diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 000000000..a56b17a4f --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,87 @@ +# Agent Guidelines + +This repo keeps “fresh memory” notes under `.$state/`. These docs are the primary mental model for the script editor + interpreter stack. + +Default todo list: `.$state/TODO.md` + +## Compilation and Building + +To compile the project, run the gradlew.bat compileJava task on ONLY the root project (CustomNPC-DBC-Addon). This applies for CustomNPC-Plus as well. +And WAIT!!! Waiting is essential, as the task can usually take up to 3 minutes. As long as the compileJava task is running, DO NOT close the terminal or interrupt the process. + +## How to use state docs + +Before exploring source code or making edits, scan the user prompt for subsystem keywords and open the relevant `.$state/*.md` doc(s) first. If multiple subsystems are involved, read all relevant docs (usually 1–3). + +Recommended read order (when multiple apply): +1. `.$state/SYNTAX_HIGHLIGHTER.md` +2. `.$state/AUTOCOMPLETE.md` +3. `.$state/DTS_ECOSYSTEM.md` +4. `.$state/SCRIPT_EDITOR.md` +5. `.$state/SCRIPT_HANDLING.md` + +The goal is not to treat the docs as perfectly authoritative; it’s to refresh terminology, invariants, and the intended architecture before verifying details in source. + +## State docs (what to read when) + +- `.$state/SYNTAX_HIGHLIGHTER.md` + - Read when the prompt involves: `ScriptDocument`, parsing/marking/token building, `TokenType` priority, `FieldChainMarker`, validation errors, hover/underlines, synthetic built-ins, JSDoc, or type-resolution questions involving `TypeResolver`, `resolveType` or `resolveExpressionType`. + +- `.$state/AUTOCOMPLETE.md` + - Read when the prompt involves: autocomplete UI/behavior, prefix/receiver detection, insertion behavior, providers (`JavaAutocompleteProvider`, `JSAutocompleteProvider`), suggestion ranking, usage tracking, import insertion, or missing/wrong suggestions. + +- `.$state/DTS_ECOSYSTEM.md` + - Read when the prompt involves: `.d.ts` generation (Gradle plugin in `gradle-plugins/`), `hooks.d.ts` / `index.d.ts`, runtime parsing (`TypeScriptDefinitionParser`), registry behavior (`JSTypeRegistry`), `JSTypeInfo`/`JSMethodInfo`/`JSFieldInfo`, or TypeScript generic bound handling. + +- `.$state/SCRIPT_EDITOR.md` + - Read when the prompt involves: `GuiScriptTextArea`, editor UX (scroll/selection/search/go-to-line/rename), hover UI wiring, or the client editor model (`ScriptTextContainer`). + +- `.$state/SCRIPT_HANDLING.md` + - Read when the prompt involves: (`JaninoScript`, `janino`, `GuiScriptInterface` ), runtime script storage/execution (`ScriptContainer`), script-related NBT serialization, hook dispatch, script engine selection, or script controller/handler wiring. + +## Cross-subsystem quick picks + +- Autocomplete issues that smell like “wrong receiver type / missing members / cannot resolve symbol”: + - Read `.$state/AUTOCOMPLETE.md` + `.$state/SYNTAX_HIGHLIGHTER.md` (+ `.$state/DTS_ECOSYSTEM.md` if JS/.d.ts types involved). +- JS autocomplete issues specifically: + - Read `.$state/AUTOCOMPLETE.md` + `.$state/DTS_ECOSYSTEM.md` + the relevant `.$state/SYNTAX_HIGHLIGHTER.md` sections. +- Hover tooltip / red underline / error text mismatches: + - Read `.$state/SYNTAX_HIGHLIGHTER.md`. + +## Workflow expectation + +1. Identify subsystem keywords in the user request. +2. Read the relevant `.$state/*.md` doc(s) first (before open-ended repo exploration). +3. Use the docs to decide which source files to inspect next. +4. Verify critical details against source before making edits (the docs can drift). +5. If edits change behavior/architecture described in a state doc, ask the user whether they want the doc updated as part of the change. + + +## Planning + +When I prompt you to plan something, I want you to always follow these steps: +1. Analyze the user request carefully to understand their needs and objectives. +2. Break down the request into smaller, manageable tasks or components. +3. Prioritize the tasks based on their importance and dependencies. +4. Create a detailed plan or outline that addresses each task systematically. +5. Review the plan to ensure it aligns with the user's goals and is feasible to implement. +6. Present the plan to the user for feedback and approval before proceeding with implementation. +7. Once approved, execute the plan step by step, keeping the user informed of progress and any adjustments needed along the way. +8. After completing the tasks, review the outcomes with the user to ensure satisfaction and address any further needs. +9. Document the process and results for future reference and learning. + +This plan must always be created and stored at .sisyphus/plans as a .md file with a unique name related to the task. +That document must be your main source of truth for the plan, you must always refer to it before and after taking any action. + +## Expert-Scripter Conventions + +For CustomNPC+ scripting conventions and quality standards, see `.github/agents/AGENTS.md`. + +That file documents: +- Mandatory review gates and triggers +- API verification requirements (zero-tolerance policy) +- Storage decision tree (getNbt vs getStoredData vs getTempData) +- Subagent usage rules +- Production quality checklist +- Code-Review conventions +- Training scripts policy \ No newline at end of file diff --git a/src/main/java/bigguy/texteditor/ReadinessState.java b/src/main/java/bigguy/texteditor/ReadinessState.java new file mode 100644 index 000000000..4c024de7a --- /dev/null +++ b/src/main/java/bigguy/texteditor/ReadinessState.java @@ -0,0 +1,185 @@ +package bigguy.texteditor; + +import java.util.Collections; +import java.util.EnumSet; +import java.util.Set; + +/** + * Models the readiness lifecycle of the script editor's semantic pipeline. + * + *

Inspired by IntelliJ IDEA's {@code DumbService} dumb/smart mode pattern, + * this enum tracks how much of the analysis pipeline has completed and which + * editor features are currently safe to invoke.

+ * + *

State machine

+ *
{@code
+ *   UNINITIALIZED ──→ SYNTAX_READY   (after initial CST parse)
+ *   SYNTAX_READY  ──→ ANALYZING      (background semantic analysis started)
+ *   ANALYZING     ──→ SMART          (analysis complete — all features available)
+ *   ANALYZING     ──→ DEGRADED       (analysis failed — fall back to syntax-only)
+ *   Any state     ──→ SYNTAX_READY   (text changed — semantics invalidated)
+ * }
+ * + *

Feature gating

+ *

Each state advertises which editor capabilities are available via + * {@link #isSyntaxAvailable()} and {@link #isSemanticsAvailable()}. + * UI code should query these predicates rather than comparing states + * directly, so that new states can be added without breaking callers.

+ * + *

Thread safety

+ *

Enum constants are inherently immutable. The state variable holding + * the current readiness should be protected by whatever concurrency mechanism + * the orchestrator uses (e.g. {@code AtomicReference}).

+ */ +public enum ReadinessState { + + /** + * No parse tree exists yet. The editor is essentially a plain text area. + * No syntax highlighting, no autocomplete, no diagnostics. + */ + UNINITIALIZED("Uninitialized — no parse tree", false, false, false), + + /** + * A concrete syntax tree is available. Tree-sitter highlighting, bracket + * matching, and keyword-only autocomplete are functional. Semantic features + * (type resolution, full autocomplete, error underlines) are not yet ready. + */ + SYNTAX_READY("Syntax ready — CST available, semantics pending", true, false, false), + + /** + * Background semantic analysis is in progress. The same features as + * {@link #SYNTAX_READY} are available; callers should show a progress + * indicator but must not block on the result. + */ + ANALYZING("Analyzing — semantic pass in progress", true, false, true), + + /** + * Full analysis is complete. Every editor feature is available: error + * underlines, scope-aware autocomplete, hover tooltips, go-to-definition, + * and scope coloring. + */ + SMART("Smart — full analysis complete", true, true, false), + + /** + * Semantic analysis failed (e.g. the type registry could not load, or an + * internal error occurred). The editor falls back to syntax-only mode + * and surface-level autocomplete. This state is recoverable: the next + * text change will transition back to {@link #SYNTAX_READY}. + */ + DEGRADED("Degraded — analysis failed, syntax-only fallback", true, false, false); + + private static final Set FROM_UNINITIALIZED = + Collections.unmodifiableSet(EnumSet.of(SYNTAX_READY)); + + private static final Set FROM_SYNTAX_READY = + Collections.unmodifiableSet(EnumSet.of(ANALYZING, SYNTAX_READY)); + + private static final Set FROM_ANALYZING = + Collections.unmodifiableSet(EnumSet.of(SMART, DEGRADED, SYNTAX_READY)); + + private static final Set FROM_SMART = + Collections.unmodifiableSet(EnumSet.of(SYNTAX_READY)); + + private static final Set FROM_DEGRADED = + Collections.unmodifiableSet(EnumSet.of(SYNTAX_READY)); + + private final String description; + private final boolean syntaxAvailable; + private final boolean semanticsAvailable; + private final boolean analyzing; + + ReadinessState(String description, boolean syntaxAvailable, + boolean semanticsAvailable, boolean analyzing) { + this.description = description; + this.syntaxAvailable = syntaxAvailable; + this.semanticsAvailable = semanticsAvailable; + this.analyzing = analyzing; + } + + /** + * Returns {@code true} when a concrete syntax tree is available. + * + *

When syntax is available, the following features are safe to use:

+ *
    + *
  • Tree-sitter syntax highlighting
  • + *
  • Bracket matching (CST-based)
  • + *
  • Keyword-only autocomplete
  • + *
+ * + * @return whether CST-based features are available + */ + public boolean isSyntaxAvailable() { + return syntaxAvailable; + } + + /** + * Returns {@code true} when full semantic analysis has completed successfully. + * + *

When semantics are available, the following features are safe to use:

+ *
    + *
  • Error underlines and diagnostic rendering
  • + *
  • Full (scope-aware, type-aware) autocomplete
  • + *
  • Hover tooltips with type information
  • + *
  • Go-to-definition navigation
  • + *
  • Scope coloring
  • + *
+ * + * @return whether semantic features are available + */ + public boolean isSemanticsAvailable() { + return semanticsAvailable; + } + + /** + * Returns {@code true} when background analysis is currently in progress. + * + *

UI code can use this to display a progress indicator without blocking.

+ * + * @return whether analysis is running + */ + public boolean isAnalyzing() { + return analyzing; + } + + /** + * Checks whether a transition from this state to {@code next} is valid + * according to the state machine's transition rules. + * + * @param next the proposed target state + * @return {@code true} if the transition is allowed + * @throws NullPointerException if {@code next} is {@code null} + */ + public boolean canTransitionTo(ReadinessState next) { + if (next == null) { + throw new NullPointerException("Target state must not be null"); + } + return validTargets().contains(next); + } + + /** + * Returns the set of states that this state may transition to. + * + * @return an unmodifiable set of valid target states + */ + public Set validTargets() { + switch (this) { + case UNINITIALIZED: return FROM_UNINITIALIZED; + case SYNTAX_READY: return FROM_SYNTAX_READY; + case ANALYZING: return FROM_ANALYZING; + case SMART: return FROM_SMART; + case DEGRADED: return FROM_DEGRADED; + default: return Collections.emptySet(); + } + } + + /** + * Returns a human-readable description of this state, suitable for + * status bar display or debug logging. + * + * @return a descriptive string (never {@code null}) + */ + @Override + public String toString() { + return description; + } +} diff --git a/src/main/java/bigguy/texteditor/ScriptOrchestrator.java b/src/main/java/bigguy/texteditor/ScriptOrchestrator.java new file mode 100644 index 000000000..1ec4ae8a7 --- /dev/null +++ b/src/main/java/bigguy/texteditor/ScriptOrchestrator.java @@ -0,0 +1,590 @@ +package bigguy.texteditor; + +import bigguy.texteditor.analysis.IncrementalStrategy; +import bigguy.texteditor.analysis.SemanticAnalyzer; +import bigguy.texteditor.analysis.SemanticMarkBuilder; +import bigguy.texteditor.diagnostics.Diagnostic; +import bigguy.texteditor.diagnostics.DiagnosticStore; +import bigguy.texteditor.render.Mark; +import bigguy.texteditor.render.MarkLayer; +import bigguy.texteditor.render.RenderLine; +import bigguy.texteditor.render.RenderModel; +import bigguy.texteditor.semantics.SemanticModel; +import bigguy.texteditor.syntax.DocumentSyntax; +import bigguy.texteditor.syntax.SemanticNode; +import bigguy.texteditor.treesitter.java.HighlightCapture; +import bigguy.texteditor.treesitter.java.HighlightGroup; +import bigguy.texteditor.treesitter.java.JavaParser; +import bigguy.texteditor.treesitter.java.JavaQueryEngine; +import bigguy.texteditor.treesitter.java.SyntaxTree; +import bigguy.texteditor.treesitter.java.TextSpan; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenType; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.concurrent.atomic.AtomicLong; + +/** + * Central pipeline coordinator for the script editor. + * Replaces ScriptDocument's coordination role with a clean, + * modular pipeline following IntelliJ IDEA's architecture. + * + *

Pipeline

+ *
{@code
+ * onTextChanged(text)
+ *   → parser.parse(text) → SyntaxTree
+ *   → DocumentSyntax.create(tree, version)
+ *   → queryEngine.highlights(tree, text) → HighlightCaptures
+ *   → convertHighlightsToMarks(captures, text) → List
+ *   → markLayer.setSyntaxMarks(marks)
+ *   → markLayer.merge() → mergedMarks
+ *   → renderModel.rebuild(text, mergedMarks, lineHeight)
+ *   → state = SYNTAX_READY
+ *   → semanticAnalyzer.scheduleAnalysis(syntax, rev, callback)
+ *   → state = ANALYZING
+ *   → (background) onAnalysisComplete → state = SMART
+ *                   onAnalysisFailed  → state = DEGRADED
+ * }
+ * + *

Thread model

+ *
    + *
  • Syntax highlighting runs on the UI thread (fast, <5ms)
  • + *
  • Semantic analysis runs on a background daemon thread via {@link SemanticAnalyzer}
  • + *
  • Analysis callbacks fire on the background thread, updating {@code volatile state}
  • + *
  • State transitions are atomic via volatile {@link ReadinessState}
  • + *
+ * + *

State machine

+ *
{@code
+ * UNINITIALIZED → SYNTAX_READY  (first onTextChanged)
+ * SYNTAX_READY  → ANALYZING     (analysis scheduled)
+ * ANALYZING     → SMART         (analysis complete, revision matches)
+ * ANALYZING     → DEGRADED      (analysis failed, revision matches)
+ * ANALYZING     → SYNTAX_READY  (new text change arrives)
+ * SMART         → SYNTAX_READY  (text changed again)
+ * DEGRADED      → SYNTAX_READY  (text changed again)
+ * }
+ */ +public class ScriptOrchestrator implements SemanticAnalyzer.AnalysisCallback { + + // --- Error underline colors (ARGB) --- + private static final int ERROR_COLOR = 0xFFFF5555; + private static final int WARNING_COLOR = 0xFFFFAA00; + private static final int INFO_COLOR = 0xFF5555FF; + + // --- Core state --- + private volatile ReadinessState state = ReadinessState.UNINITIALIZED; + private final AtomicLong revision = new AtomicLong(0); + + // --- Syntax layer --- + private final JavaParser parser; + private final JavaQueryEngine queryEngine; + private volatile DocumentSyntax currentSyntax; + + // --- Render pipeline --- + private final MarkLayer markLayer; + private final RenderModel renderModel; + private final DiagnosticStore diagnosticStore; + + // --- Configuration --- + private int lineHeight = 10; + + // --- Semantic analysis --- + private final SemanticAnalyzer semanticAnalyzer; + private final IncrementalStrategy incrementalStrategy; + private TextSpan[] lastChangedRanges; + private volatile String currentSourceText = ""; + + /** + * Creates a new orchestrator with default-configured components. + * + *

Initializes the tree-sitter parser, query engine, mark layer, + * render model, diagnostic store, semantic analyzer, and incremental + * strategy. All components start empty; call + * {@link #onTextChanged(String)} to kick off the pipeline.

+ */ + public ScriptOrchestrator() { + this.parser = new JavaParser(); + this.queryEngine = new JavaQueryEngine(); + this.markLayer = new MarkLayer(); + this.renderModel = new RenderModel(); + this.diagnosticStore = new DiagnosticStore(); + this.semanticAnalyzer = new SemanticAnalyzer(); + this.incrementalStrategy = new IncrementalStrategy(); + } + + // ==================== MAIN PIPELINE ==================== + + /** + * Called when the source text changes. Runs the syntax pipeline + * synchronously on the UI thread (fast path), then schedules + * background semantic analysis. + * + *

Any in-flight analysis from a previous edit is cancelled before + * scheduling a new one, ensuring stale results are never applied.

+ * + * @param text the complete source text of the document + */ + public void onTextChanged(String text) { + long rev = revision.incrementAndGet(); + + // Cancel any in-flight analysis from the previous edit + semanticAnalyzer.cancelInFlight(); + + // Step 1: Parse CST + SyntaxTree syntaxTree = parser.parse(text); + + // Step 2: Create DocumentSyntax + currentSyntax = DocumentSyntax.create(syntaxTree, (int) rev); + + // Step 3: Collect parser errors as diagnostics + diagnosticStore.clearBySource(Diagnostic.Source.PARSER); + collectParserErrors(currentSyntax); + + // Step 4: Extract syntax highlights from tree-sitter + List highlights = queryEngine.highlights(syntaxTree, text); + + // Step 5: Convert highlights to Mark objects + List syntaxMarks = convertHighlightsToMarks(highlights, text); + + // Step 6: Set syntax marks in the mark layer + markLayer.setSyntaxMarks(syntaxMarks); + + // Step 7: Merge marks (syntax + any prior semantic marks) + List mergedMarks = markLayer.merge(); + + // Step 8: Rebuild render model from source + merged marks + currentSourceText = text; + renderModel.rebuild(text, mergedMarks, lineHeight); + + // Step 9: Syntax pipeline complete + state = ReadinessState.SYNTAX_READY; + + // Step 10: Schedule background semantic analysis + state = ReadinessState.ANALYZING; + semanticAnalyzer.scheduleAnalysis(currentSyntax, rev, this); + } + + // ==================== ANALYSIS CALLBACKS ==================== + + @Override + public void onAnalysisComplete(long revision, SemanticModel semanticModel, DocumentSyntax syntax) { + if (revision != this.revision.get()) { + return; + } + + List semanticMarks = SemanticMarkBuilder.build(semanticModel, syntax); + markLayer.setSemanticMarks(semanticMarks); + List mergedMarks = markLayer.merge(); + renderModel.rebuild(currentSourceText, mergedMarks, lineHeight); + + state = ReadinessState.SMART; + } + + @Override + public void onAnalysisFailed(long revision, Exception error) { + if (revision != this.revision.get()) { + return; + } + + state = ReadinessState.DEGRADED; + } + + // ==================== HIGHLIGHT → MARK CONVERSION ==================== + + /** + * Converts tree-sitter {@link HighlightCapture}s into {@link Mark} objects. + * Maps each {@link HighlightGroup} to a {@link TokenType} for rendering. + * + * @param highlights the highlight captures from the query engine + * @param text the complete source text (used for bounds validation) + * @return a list of syntax marks, one per highlight capture + */ + private List convertHighlightsToMarks(List highlights, String text) { + if (highlights.isEmpty()) { + return Collections.emptyList(); + } + int textLength = text.length(); + List marks = new ArrayList<>(highlights.size()); + for (HighlightCapture capture : highlights) { + TextSpan span = capture.getSpan(); + if (span == null) { + continue; + } + int startByte = span.getStartByte(); + int endByte = span.getEndByte(); + if (startByte < 0 || endByte <= startByte || startByte >= textLength) { + continue; + } + if (endByte > textLength) { + endByte = textLength; + } + TokenType tokenType = mapHighlightGroupToTokenType(capture.getGroup()); + marks.add(Mark.syntax(startByte, endByte, tokenType)); + } + return marks; + } + + /** + * Maps a tree-sitter {@link HighlightGroup} to the rendering + * {@link TokenType}. Every group is explicitly mapped — no fallthrough. + * + *

The mapping aims to match IntelliJ-style colorization:

+ *
    + *
  • Language keywords and control flow → {@link TokenType#KEYWORD}
  • + *
  • Type references and declarations → {@link TokenType#TYPE_DECL} / specific decl types
  • + *
  • Function/method names → {@link TokenType#METHOD_DECL} or {@link TokenType#METHOD_CALL}
  • + *
  • Strings, numbers, booleans → their respective literal types
  • + *
  • Comments → {@link TokenType#COMMENT}
  • + *
  • Punctuation/operators → {@link TokenType#DEFAULT} (white, lowest priority)
  • + *
+ * + * @param group the highlight group from tree-sitter + * @return the corresponding token type for rendering + */ + private static TokenType mapHighlightGroupToTokenType(HighlightGroup group) { + switch (group) { + // --- Properties and variables --- + case PROPERTY: + return TokenType.GLOBAL_FIELD; + case VARIABLE: + return TokenType.VARIABLE; + case PARAMETER: + return TokenType.PARAMETER; + + // --- Functions / methods --- + case FUNCTION: + return TokenType.METHOD_DECL; + case FUNCTION_CALL: + return TokenType.METHOD_CALL; + case SUPER: + // "super" is function.builtin in tree-sitter — render as keyword + return TokenType.KEYWORD; + case CONSTRUCTOR: + return TokenType.METHOD_DECL; + + // --- Types --- + case TYPE: + return TokenType.TYPE_DECL; + case TYPE_PARAMETER: + return TokenType.GENERIC_TYPE_PARAM; + case INTERFACE: + return TokenType.INTERFACE_DECL; + case TYPE_BUILTIN: + // Primitive types (int, boolean, void) — styled like keywords + return TokenType.KEYWORD; + case ENUM: + return TokenType.ENUM_DECL; + + // --- Constants --- + case CONSTANT: + return TokenType.STATIC_FINAL_FIELD; + case CONSTANT_BUILTIN: + // true, false, null + return TokenType.LITERAL; + + // --- Keywords (all keyword.* variants) --- + case KEYWORD: + case KEYWORD_CONTROL: + case KEYWORD_OPERATOR: + case KEYWORD_FUNCTION: + case KEYWORD_TYPE: + case KEYWORD_MODIFIER: + return TokenType.KEYWORD; + + // --- Operators --- + case OPERATOR: + return TokenType.DEFAULT; + + // --- Strings --- + case STRING: + case STRING_ESCAPE: + case STRING_SPECIAL: + return TokenType.STRING; + + // --- Numeric and boolean literals --- + case NUMBER: + return TokenType.LITERAL; + case BOOLEAN: + return TokenType.LITERAL; + + // --- Comments --- + case COMMENT: + return TokenType.COMMENT; + case COMMENT_DOC: + return TokenType.COMMENT; + + // --- Annotations --- + case ATTRIBUTE: + // Java annotations (@Override, @Test) — styled like JSDoc tags + return TokenType.JSDOC_TAG; + + // --- Labels --- + case LABEL: + return TokenType.KEYWORD; + + // --- Punctuation --- + case PUNCTUATION_BRACKET: + case PUNCTUATION_DELIMITER: + case PUNCTUATION_SPECIAL: + return TokenType.DEFAULT; + + // --- Embedded / unknown --- + case EMBEDDED: + return TokenType.DEFAULT; + case UNKNOWN: + return TokenType.DEFAULT; + + default: + return TokenType.DEFAULT; + } + } + + // ==================== PARSER ERROR COLLECTION ==================== + + /** + * Walks the CST root and collects all ERROR and MISSING nodes as + * parser diagnostics in the {@link DiagnosticStore}. + * + *

ERROR nodes represent unparseable source regions. MISSING nodes + * represent tokens the parser expected but did not find (e.g. a + * missing semicolon).

+ * + * @param syntax the document syntax to scan for errors + */ + private void collectParserErrors(DocumentSyntax syntax) { + SemanticNode root = syntax.root(); + if (root == null || !root.hasError()) { + return; + } + collectParserErrorsRecursive(root); + } + + /** + * Recursively walks the semantic node tree, creating diagnostics + * for any ERROR or MISSING nodes encountered. + * + * @param node the current node being visited + */ + private void collectParserErrorsRecursive(SemanticNode node) { + if (node.isError()) { + TextSpan span = node.span(); + if (span != null && span.getByteLength() > 0) { + String text = node.text(); + String message = "Syntax error" + (text != null && !text.isEmpty() + ? ": unexpected '" + truncate(text, 30) + "'" + : ""); + diagnosticStore.addDiagnostic(Diagnostic.of( + span, Diagnostic.Severity.ERROR, message, Diagnostic.Source.PARSER)); + } + return; + } + if (node.isMissing()) { + TextSpan span = node.span(); + if (span != null) { + String nodeType = node.nodeType(); + String message = "Missing " + (nodeType != null ? "'" + nodeType + "'" : "token"); + diagnosticStore.addDiagnostic(Diagnostic.of( + span, Diagnostic.Severity.ERROR, message, Diagnostic.Source.PARSER)); + } + return; + } + int childCount = node.childCount(); + for (int i = 0; i < childCount; i++) { + SemanticNode child = node.child(i); + if (child != null && child.hasError()) { + collectParserErrorsRecursive(child); + } + } + } + + // ==================== STATE QUERIES ==================== + + /** + * Returns the current readiness state of the pipeline. + * + * @return the current {@link ReadinessState} + */ + public ReadinessState getReadinessState() { + return state; + } + + /** + * Returns the monotonically increasing revision counter. + * Incremented on every {@link #onTextChanged(String)} call. + * + * @return the current revision number + */ + public long getRevision() { + return revision.get(); + } + + // ==================== COMPONENT ACCESS ==================== + + /** + * Returns the render model containing the line layout and viewport calculations. + * + * @return the render model, never {@code null} + */ + public RenderModel getRenderModel() { + return renderModel; + } + + /** + * Returns the mark layer used for syntax/semantic/error mark merging. + * + * @return the mark layer, never {@code null} + */ + public MarkLayer getMarkLayer() { + return markLayer; + } + + /** + * Returns the diagnostic store containing all parser and analysis errors. + * + * @return the diagnostic store, never {@code null} + */ + public DiagnosticStore getDiagnosticStore() { + return diagnosticStore; + } + + /** + * Returns the current document syntax, or {@code null} if no parse + * has been performed yet. + * + * @return the latest {@link DocumentSyntax}, or {@code null} + */ + public DocumentSyntax getCurrentSyntax() { + return currentSyntax; + } + + /** + * Returns the current semantic model from the analyzer. + * May be {@code null} or unbuilt if no analysis has completed yet. + * + * @return the latest {@link SemanticModel}, or {@code null} + */ + public SemanticModel getSemanticModel() { + return semanticAnalyzer.getSemanticModel(); + } + + // ==================== CONFIGURATION ==================== + + /** + * Sets the pixel height per line used for render model layout. + * + * @param lineHeight pixel height per line (must be positive) + */ + public void setLineHeight(int lineHeight) { + this.lineHeight = lineHeight; + } + + /** + * Returns the current pixel height per line. + * + * @return the line height in pixels + */ + public int getLineHeight() { + return lineHeight; + } + + // ==================== DIAGNOSTIC HELPERS ==================== + + /** + * Returns diagnostic ranges for a specific render line, suitable for + * passing to {@link RenderLine#drawErrorUnderlines(int, int, List)}. + * + *

Queries the {@link DiagnosticStore} for diagnostics overlapping the + * line's byte range, then converts each to a + * {@link RenderLine.DiagnosticRange} with an appropriate underline color + * based on severity.

+ * + * @param line the render line to query diagnostics for + * @return a list of diagnostic ranges, possibly empty, never {@code null} + */ + public List getDiagnosticsForLine(RenderLine line) { + if (line == null) { + return Collections.emptyList(); + } + List lineDiagnostics = diagnosticStore.getDiagnosticsInRange( + line.getGlobalStart(), line.getGlobalEnd()); + if (lineDiagnostics.isEmpty()) { + return Collections.emptyList(); + } + List ranges = new ArrayList<>(lineDiagnostics.size()); + for (Diagnostic diag : lineDiagnostics) { + TextSpan range = diag.range(); + int color = diagnosticColor(diag.severity()); + ranges.add(new RenderLine.DiagnosticRange( + range.getStartByte(), range.getEndByte(), color)); + } + return ranges; + } + + /** + * Returns the ARGB underline color for a diagnostic severity level. + * + * @param severity the diagnostic severity + * @return the ARGB color for the wavy underline + */ + private static int diagnosticColor(Diagnostic.Severity severity) { + switch (severity) { + case ERROR: + return ERROR_COLOR; + case WARNING: + return WARNING_COLOR; + case INFO: + case HINT: + return INFO_COLOR; + default: + return ERROR_COLOR; + } + } + + // ==================== LIFECYCLE ==================== + + /** + * Releases all resources held by this orchestrator. + * Called when the editor is closed. + * + *

Disposes the semantic analyzer (cancels in-flight analysis and shuts + * down its executor), closes the tree-sitter parser (releasing native + * memory), clears the mark layer, diagnostic store, and nullifies the + * current syntax reference.

+ */ + public void dispose() { + semanticAnalyzer.dispose(); + parser.close(); + markLayer.clear(); + diagnosticStore.clear(); + currentSyntax = null; + state = ReadinessState.UNINITIALIZED; + } + + // ==================== INTERNAL UTILITIES ==================== + + /** + * Truncates a string to the given maximum length, appending "..." if truncated. + * + * @param text the string to truncate + * @param maxLength the maximum length before truncation + * @return the original string if short enough, or a truncated version + */ + private static String truncate(String text, int maxLength) { + if (text.length() <= maxLength) { + return text; + } + return text.substring(0, maxLength) + "..."; + } + + @Override + public String toString() { + return "ScriptOrchestrator{state=" + state + + ", revision=" + revision.get() + + ", syntax=" + (currentSyntax != null ? currentSyntax : "null") + + ", renderModel=" + renderModel + + ", diagnostics=" + diagnosticStore + + '}'; + } +} diff --git a/src/main/java/bigguy/texteditor/analysis/IncrementalStrategy.java b/src/main/java/bigguy/texteditor/analysis/IncrementalStrategy.java new file mode 100644 index 000000000..406359a78 --- /dev/null +++ b/src/main/java/bigguy/texteditor/analysis/IncrementalStrategy.java @@ -0,0 +1,386 @@ +package bigguy.texteditor.analysis; + +import bigguy.texteditor.syntax.DocumentSyntax; +import bigguy.texteditor.syntax.SemanticNode; +import bigguy.texteditor.treesitter.java.TextSpan; + +import java.util.Arrays; +import java.util.Collections; +import java.util.HashSet; +import java.util.Set; + +/** + * Classifies text edits into invalidation scopes, determining how much of + * the semantic model needs rebuilding after an incremental reparse. + * + *

This is the intelligence behind incremental analysis — the core of the + * "every keystroke must NOT cause a full rebuild" requirement. By inspecting + * which CST nodes changed, the strategy assigns a minimal + * {@link InvalidationScope} that tells {@code SemanticModel} exactly which + * sub-components need updating.

+ * + *

Design

+ *

The algorithm walks upward from each changed range's deepest node to + * classify the edit into one of five categories:

+ *
    + *
  1. {@link InvalidationScope#NONE NONE} — edit inside string/comment
  2. + *
  3. {@link InvalidationScope#LOCAL_SCOPE LOCAL_SCOPE} — edit inside method body
  4. + *
  5. {@link InvalidationScope#DECLARATION DECLARATION} — signature changed
  6. + *
  7. {@link InvalidationScope#IMPORTS IMPORTS} — import changed
  8. + *
  9. {@link InvalidationScope#STRUCTURAL STRUCTURAL} — class/method boundary changed
  10. + *
+ * + *

Performance impact

+ *
+ * | InvalidationScope | SymbolTable | ScopeTree       | ImportIndex | Cost    |
+ * |-------------------|-------------|-----------------|-------------|---------|
+ * | NONE              | Keep        | Keep            | Keep        | ~0.01ms |
+ * | LOCAL_SCOPE       | Keep        | Rebuild 1 scope | Keep        | ~2ms    |
+ * | DECLARATION       | Rebuild     | Rebuild         | Keep        | ~10ms   |
+ * | IMPORTS           | Keep        | Keep            | Rebuild     | ~10ms   |
+ * | STRUCTURAL        | Rebuild all | Rebuild all     | Rebuild all | ~50ms   |
+ * 
+ * + *

Thread safety

+ *

This class is stateless and therefore inherently thread-safe. All methods + * are pure functions of their arguments.

+ * + * @see InvalidationScope + */ +public final class IncrementalStrategy { + + // ── CST node type constants ──────────────────────────────────────────────── + // Centralised here to avoid scattered string literals throughout the class. + + private static final String NODE_IMPORT_DECLARATION = "import_declaration"; + private static final String NODE_CLASS_DECLARATION = "class_declaration"; + private static final String NODE_INTERFACE_DECLARATION = "interface_declaration"; + private static final String NODE_ENUM_DECLARATION = "enum_declaration"; + private static final String NODE_ANNOTATION_TYPE_DECLARATION = "annotation_type_declaration"; + private static final String NODE_METHOD_DECLARATION = "method_declaration"; + private static final String NODE_CONSTRUCTOR_DECLARATION = "constructor_declaration"; + private static final String NODE_FIELD_DECLARATION = "field_declaration"; + private static final String NODE_BLOCK = "block"; + private static final String NODE_PROGRAM = "program"; + + /** + * Node types that represent type/member declarations whose modification + * requires at least a {@link InvalidationScope#DECLARATION DECLARATION} + * level rebuild. + */ + private static final Set DECLARATION_NODE_TYPES = Collections.unmodifiableSet( + new HashSet(Arrays.asList( + NODE_CLASS_DECLARATION, + NODE_INTERFACE_DECLARATION, + NODE_ENUM_DECLARATION, + NODE_ANNOTATION_TYPE_DECLARATION, + NODE_METHOD_DECLARATION, + NODE_CONSTRUCTOR_DECLARATION, + NODE_FIELD_DECLARATION + )) + ); + + /** + * Node types that represent method-like constructs (nodes whose "body" + * child introduces a local scope). + */ + private static final Set METHOD_LIKE_NODE_TYPES = Collections.unmodifiableSet( + new HashSet(Arrays.asList( + NODE_METHOD_DECLARATION, + NODE_CONSTRUCTOR_DECLARATION + )) + ); + + // ── Invalidation scope enum ──────────────────────────────────────────────── + + /** + * Describes the extent of semantic invalidation required after an edit. + * + *

Scopes are ordered from cheapest ({@link #NONE}) to most expensive + * ({@link #STRUCTURAL}). When multiple changed ranges yield different + * scopes, the highest (most expensive) scope wins.

+ */ + public enum InvalidationScope { + + /** + * No semantic change — the edit was entirely inside a string literal or + * comment. Only byte-offset adjustment is needed; all semantic data + * structures remain valid. + */ + NONE(0), + + /** + * Edit inside a method or constructor body — only the affected scope + * needs to be rebuilt in the {@code ScopeTree}. The {@code SymbolTable} + * and {@code ImportIndex} are unaffected because no declarations or + * imports changed. + */ + LOCAL_SCOPE(1), + + /** + * A type, method, or field declaration changed — the {@code SymbolTable} + * and {@code ScopeTree} need rebuilding, but the {@code ImportIndex} + * remains valid. + */ + DECLARATION(2), + + /** + * An import declaration changed — the {@code ImportIndex} needs + * rebuilding. Downstream type resolution may also need re-running. + */ + IMPORTS(3), + + /** + * A class or method boundary changed (structural edit) — all semantic + * data structures must be fully rebuilt. This is the worst case and + * corresponds to edits that alter the fundamental structure of the file + * (e.g., adding/removing a class, changing method signatures across + * multiple declarations). + */ + STRUCTURAL(4); + + private final int severity; + + InvalidationScope(int severity) { + this.severity = severity; + } + + /** + * Returns the numeric severity level for comparison. Higher values + * indicate more expensive rebuilds. + * + * @return the severity ordinal (0 = cheapest, 4 = most expensive) + */ + public int severity() { + return severity; + } + + /** + * Returns the more severe of two scopes. + * + * @param a the first scope + * @param b the second scope + * @return the scope with the higher severity + */ + public static InvalidationScope max(InvalidationScope a, InvalidationScope b) { + if (a == null) { + return b; + } + if (b == null) { + return a; + } + return a.severity >= b.severity ? a : b; + } + } + + // ── Constructor ──────────────────────────────────────────────────────────── + + /** + * Creates a new incremental strategy instance. + * + *

This class is stateless; a single instance can be reused across + * all analysis cycles.

+ */ + public IncrementalStrategy() { + // Stateless — no initialisation needed. + } + + // ── Public API ───────────────────────────────────────────────────────────── + + /** + * Classifies the combined impact of all CST changes to determine how much + * of the semantic model needs re-analysis. + * + *

Each changed range is classified independently via + * {@link #classifySingleChange(TextSpan, DocumentSyntax)}, and the + * worst-case (highest severity) scope across all ranges is returned.

+ * + *

If no ranges changed, returns {@link InvalidationScope#NONE}.

+ * + * @param changedRanges the byte ranges that changed (from tree-sitter's + * {@code getChangedRanges()}); may be {@code null} or empty + * @param syntax the new document syntax after reparse + * @return the invalidation scope indicating how much needs rebuilding + * @throws IllegalArgumentException if {@code syntax} is {@code null} + */ + public InvalidationScope classify(TextSpan[] changedRanges, DocumentSyntax syntax) { + if (syntax == null) { + throw new IllegalArgumentException("syntax must not be null"); + } + if (changedRanges == null || changedRanges.length == 0) { + return InvalidationScope.NONE; + } + + InvalidationScope worst = InvalidationScope.NONE; + + for (TextSpan range : changedRanges) { + if (range == null) { + continue; + } + InvalidationScope rangeScope = classifySingleChange(range, syntax); + worst = InvalidationScope.max(worst, rangeScope); + + // Short-circuit: STRUCTURAL is the maximum possible severity. + if (worst == InvalidationScope.STRUCTURAL) { + return worst; + } + } + + return worst; + } + + /** + * Classifies a single changed byte range to determine its invalidation scope. + * + *

The algorithm proceeds in three steps:

+ *
    + *
  1. Exclusion check: If the edit start falls inside a + * string literal or comment, the edit is semantically invisible → + * {@link InvalidationScope#NONE}.
  2. + *
  3. Node lookup: Find the deepest named CST node at the + * edit's start byte offset.
  4. + *
  5. Ancestor walk: Walk upward from the deepest node, + * checking whether the change falls inside a method body (local scope), + * an import declaration, or a type/member declaration.
  6. + *
+ * + * @param changedRange the byte range that changed + * @param syntax the new document syntax after reparse + * @return the invalidation scope for this single change + * @throws IllegalArgumentException if either argument is {@code null} + */ + public InvalidationScope classifySingleChange(TextSpan changedRange, DocumentSyntax syntax) { + if (changedRange == null) { + throw new IllegalArgumentException("changedRange must not be null"); + } + if (syntax == null) { + throw new IllegalArgumentException("syntax must not be null"); + } + + // Step 1: Check if the edit is inside an excluded region (string/comment). + // If so, no semantic data structures are affected. + if (syntax.isExcluded(changedRange.getStartByte())) { + return InvalidationScope.NONE; + } + + // Step 2: Find the deepest named node at the start of the change. + SemanticNode node = syntax.nodeAtOffset(changedRange.getStartByte()); + if (node == null) { + // Cannot determine context — assume the worst case. + return InvalidationScope.STRUCTURAL; + } + + // Step 3: Walk up the ancestry chain to classify the change. + return classifyByAncestry(node, changedRange); + } + + // ── Private classification logic ─────────────────────────────────────────── + + /** + * Walks upward from the given node to its ancestors, classifying the change + * based on which syntactic construct encloses it. + * + *

The walk checks in order:

+ *
    + *
  1. Is the node inside a method/constructor body? → {@code LOCAL_SCOPE}
  2. + *
  3. Is the node inside an import declaration? → {@code IMPORTS}
  4. + *
  5. Is the node inside a declaration node? → {@code DECLARATION}
  6. + *
  7. Otherwise → {@code STRUCTURAL}
  8. + *
+ * + * @param startNode the deepest node at the change offset + * @param changedRange the byte range that changed + * @return the classified invalidation scope + */ + private InvalidationScope classifyByAncestry(SemanticNode startNode, TextSpan changedRange) { + SemanticNode current = startNode; + + // Track whether we've seen a block node that could be a method body. + // This prevents misclassifying standalone blocks (like static initialisers) + // as method bodies. + boolean insideMethodBody = false; + + while (current != null) { + String nodeType = current.nodeType(); + if (nodeType == null) { + current = current.parent(); + continue; + } + + // Check if we're inside a method/constructor body. + // A "block" node that is the "body" field of a method/constructor + // means the edit is contained within a local scope. + if (NODE_BLOCK.equals(nodeType)) { + SemanticNode parent = current.parent(); + if (parent != null && isMethodLikeNode(parent.nodeType())) { + // Verify the change is entirely within this body block. + TextSpan bodySpan = current.span(); + if (bodySpan != null && bodySpan.contains(changedRange)) { + insideMethodBody = true; + } + } + } + + // If we've reached a method-like node and the edit was inside its body, + // we can classify as LOCAL_SCOPE. + if (isMethodLikeNode(nodeType) && insideMethodBody) { + return InvalidationScope.LOCAL_SCOPE; + } + + // Check for import declarations. + if (NODE_IMPORT_DECLARATION.equals(nodeType)) { + return InvalidationScope.IMPORTS; + } + + // Check for declaration nodes (but not if we already know we're in a method body). + // For method/constructor declarations, we reach here only if the edit was in + // the signature (not the body), which is a DECLARATION-level change. + if (isDeclarationNode(nodeType) && !insideMethodBody) { + return InvalidationScope.DECLARATION; + } + + // If we've reached the program root without finding a specific construct, + // the edit is at the top level — structural change. + if (NODE_PROGRAM.equals(nodeType)) { + // If the edit is directly inside the program node (e.g., adding a new + // class or import), and we haven't classified it yet, it's structural. + break; + } + + current = current.parent(); + } + + // Default: structural change (couldn't classify more specifically). + return InvalidationScope.STRUCTURAL; + } + + // ── Static helper methods ────────────────────────────────────────────────── + + /** + * Tests whether the given node type represents a declaration construct + * (class, interface, enum, annotation, method, constructor, or field). + * + * @param nodeType the tree-sitter node type string + * @return {@code true} if the node type is a declaration + */ + private static boolean isDeclarationNode(String nodeType) { + return nodeType != null && DECLARATION_NODE_TYPES.contains(nodeType); + } + + /** + * Tests whether the given node type represents a method-like construct + * (method or constructor declaration) that has a body introducing a + * local scope. + * + * @param nodeType the tree-sitter node type string + * @return {@code true} if the node type is method-like + */ + private static boolean isMethodLikeNode(String nodeType) { + return nodeType != null && METHOD_LIKE_NODE_TYPES.contains(nodeType); + } + + @Override + public String toString() { + return "IncrementalStrategy{}"; + } +} diff --git a/src/main/java/bigguy/texteditor/analysis/SemanticAnalyzer.java b/src/main/java/bigguy/texteditor/analysis/SemanticAnalyzer.java new file mode 100644 index 000000000..ba94b70cc --- /dev/null +++ b/src/main/java/bigguy/texteditor/analysis/SemanticAnalyzer.java @@ -0,0 +1,651 @@ +package bigguy.texteditor.analysis; + +import bigguy.texteditor.analysis.IncrementalStrategy.InvalidationScope; +import bigguy.texteditor.semantics.SemanticModel; +import bigguy.texteditor.syntax.DocumentSyntax; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.ThreadFactory; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicLong; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * Owns the background semantic analysis pipeline and schedules semantic + * analysis after syntax parsing completes. + * + *

This class is the bridge between the UI-thread syntax pipeline and the + * background semantic pipeline. It is called by the orchestrator after each + * text change and follows a strict revision-based protocol to prevent stale + * semantic data from contaminating fresh syntax state.

+ * + *

Lifecycle

+ *
    + *
  1. The orchestrator calls {@link #scheduleAnalysis} or + * {@link #scheduleIncrementalAnalysis} after each text change.
  2. + *
  3. Any in-flight analysis is cancelled immediately.
  4. + *
  5. An immutable snapshot of the current state is captured and submitted + * to a single-thread {@link ExecutorService}.
  6. + *
  7. On completion, results are published back to the caller via an + * {@link AnalysisCallback}.
  8. + *
  9. Stale results (where the revision has advanced since submission) + * are silently discarded.
  10. + *
+ * + *

Stale-result protocol

+ *

The key invariant is: never blend stale semantic data with fresh + * syntax. When a revision changes:

+ *
    + *
  1. Drop ALL semantic decorations immediately.
  2. + *
  3. Show syntax-only highlighting.
  4. + *
  5. When semantic analysis completes for the current revision, + * apply atomically.
  6. + *
  7. When semantic analysis completes for an old revision, + * discard silently.
  8. + *
+ * + *

Thread safety

+ *

All public methods are safe to call from any thread. The executor is a + * single-thread pool, so analysis tasks are serialised. The {@code disposed} + * and {@code inFlightAnalysis} fields use {@code volatile} for visibility + * across threads, and the {@code currentRevision} uses {@link AtomicLong} + * for atomic updates.

+ * + *

Callback threading

+ *

The {@link AnalysisCallback} is invoked on the background + * analysis thread, not the UI thread. Callers (typically the orchestrator) + * must handle the thread boundary themselves — for example, via + * Minecraft's scheduled-task system — before applying results to + * UI-visible state.

+ * + * @see SemanticModel + * @see IncrementalStrategy + * @see DocumentSyntax + */ +public final class SemanticAnalyzer { + + private static final Logger LOGGER = Logger.getLogger(SemanticAnalyzer.class.getName()); + + /** + * Name assigned to the daemon analysis thread. Appears in thread dumps + * and debugger views for easy identification. + */ + private static final String THREAD_NAME = "ScriptEditor-SemanticAnalysis"; + + /** + * Maximum time (in milliseconds) to wait for the executor to terminate + * during {@link #dispose()}. + */ + private static final long SHUTDOWN_TIMEOUT_MS = 2000L; + + // ── Callback interface ───────────────────────────────────────────────────── + + /** + * Callback interface for receiving analysis results. + * + *

The orchestrator implements this to apply semantic marks and + * transition state. Important: callbacks are invoked on + * the background analysis thread, not the UI thread. Implementors must + * marshal results to the appropriate thread before modifying UI state.

+ * + *

The caller must check that the revision still matches + * the current document revision before applying results. The analyzer + * performs its own revision check before invoking the callback, but there + * is an inherent race window between the check and the callback body + * executing, so a second check in the callback is recommended.

+ */ + public interface AnalysisCallback { + + /** + * Called when analysis completes successfully for the given revision. + * + *

The caller must verify that the revision still + * matches the current document revision before applying results. + * If the revision has advanced, these results are stale and must + * be discarded.

+ * + * @param revision the revision number this analysis was for + * @param semanticModel the populated semantic model + * @param syntax the {@link DocumentSyntax} that was analyzed + */ + void onAnalysisComplete(long revision, SemanticModel semanticModel, DocumentSyntax syntax); + + /** + * Called when analysis fails with an exception. + * + *

The revision is provided so the caller can determine whether + * the failure is still relevant to the current document state.

+ * + * @param revision the revision number this analysis was for + * @param error the exception that occurred during analysis + */ + void onAnalysisFailed(long revision, Exception error); + } + + // ── Fields ───────────────────────────────────────────────────────────────── + + /** + * Single-thread executor for background analysis. Uses a daemon thread + * so it does not prevent JVM (Minecraft) shutdown. + */ + private final ExecutorService executor; + + /** + * The semantic model being built and updated. Owned exclusively by this + * analyzer; only accessed from the analysis thread (except for + * {@link #getSemanticModel()} which returns a snapshot reference). + */ + private final SemanticModel semanticModel; + + /** + * Stateless strategy for classifying edits into invalidation scopes. + * Used by the incremental analysis path to determine which parts of + * the semantic model need rebuilding. + */ + private final IncrementalStrategy strategy; + + /** + * The currently in-flight analysis {@link Future}, or {@code null} if + * no analysis is running. Volatile for cross-thread visibility. + */ + private volatile Future inFlightAnalysis; + + /** + * The revision number that was most recently submitted for analysis. + * Used for stale-result detection: if the revision has advanced past + * this value by the time analysis completes, the results are discarded. + */ + private final AtomicLong currentRevision; + + /** + * Set to {@code true} when {@link #dispose()} is called. Prevents new + * analysis submissions and causes in-flight analysis to bail out early. + */ + private volatile boolean disposed; + + // ── Constructor ──────────────────────────────────────────────────────────── + + /** + * Creates a new {@code SemanticAnalyzer} with a single-thread daemon + * executor, a fresh {@link SemanticModel}, and a stateless + * {@link IncrementalStrategy}. + * + *

The executor uses a daemon thread with slightly lower than normal + * priority ({@link Thread#NORM_PRIORITY} - 1) so that analysis does not + * compete with UI rendering for CPU time.

+ */ + public SemanticAnalyzer() { + this.executor = Executors.newSingleThreadExecutor(createDaemonThreadFactory()); + this.semanticModel = new SemanticModel(); + this.strategy = new IncrementalStrategy(); + this.inFlightAnalysis = null; + this.currentRevision = new AtomicLong(0L); + this.disposed = false; + } + + // ── Public API ───────────────────────────────────────────────────────────── + + /** + * Schedules a full semantic analysis for the given syntax snapshot. + * + *

Any currently in-flight analysis is cancelled before scheduling the + * new one. The revision number is recorded so that stale results can be + * detected and discarded when the analysis completes.

+ * + *

The analysis performs a complete rebuild of the {@link SemanticModel}: + * all sub-components (SymbolTable, ScopeTree, ImportIndex, InferenceCache) + * are cleared and rebuilt from scratch by walking the CST.

+ * + *

If the analyzer has been {@linkplain #dispose() disposed}, this + * method is a no-op.

+ * + * @param syntax the document syntax to analyze (immutable snapshot from + * the parser); must not be {@code null} + * @param revision the revision number for stale-detection; callers should + * use a monotonically increasing counter + * @param callback the callback to invoke with results; must not be + * {@code null} + * @throws IllegalArgumentException if {@code syntax} or {@code callback} + * is {@code null} + */ + public void scheduleAnalysis(DocumentSyntax syntax, long revision, AnalysisCallback callback) { + validateScheduleArguments(syntax, revision, callback); + if (disposed) { + return; + } + + currentRevision.set(revision); + cancelInFlight(); + + inFlightAnalysis = executor.submit(new FullAnalysisTask(syntax, revision, callback)); + } + + /** + * Schedules an incremental analysis using the provided invalidation scope. + * + *

Only rebuilds the affected parts of the semantic model, as determined + * by the {@link InvalidationScope}:

+ *
    + *
  • {@link InvalidationScope#NONE NONE} — no-op; the callback + * is still invoked with the existing model so the orchestrator can + * apply offset-adjusted decorations.
  • + *
  • {@link InvalidationScope#LOCAL_SCOPE LOCAL_SCOPE} — only + * the scope tree is rebuilt.
  • + *
  • {@link InvalidationScope#DECLARATION DECLARATION} — full + * rebuild (symbol table + scope tree).
  • + *
  • {@link InvalidationScope#IMPORTS IMPORTS} — only the import + * index is rebuilt.
  • + *
  • {@link InvalidationScope#STRUCTURAL STRUCTURAL} — full + * rebuild of all sub-components.
  • + *
+ * + *

Any currently in-flight analysis is cancelled before scheduling. + * If the analyzer has been {@linkplain #dispose() disposed}, this method + * is a no-op.

+ * + * @param syntax the document syntax after reparse; must not be + * {@code null} + * @param revision the revision number for stale-detection + * @param scope the invalidation scope from {@link IncrementalStrategy}; + * must not be {@code null} + * @param callback the callback to invoke with results; must not be + * {@code null} + * @throws IllegalArgumentException if any argument is {@code null} + */ + public void scheduleIncrementalAnalysis(DocumentSyntax syntax, long revision, + InvalidationScope scope, + AnalysisCallback callback) { + validateScheduleArguments(syntax, revision, callback); + if (scope == null) { + throw new IllegalArgumentException("scope must not be null"); + } + if (disposed) { + return; + } + + currentRevision.set(revision); + cancelInFlight(); + + inFlightAnalysis = executor.submit( + new IncrementalAnalysisTask(syntax, revision, scope, callback) + ); + } + + /** + * Cancels any in-flight analysis. Safe to call from any thread. + * + *

If an analysis is currently running, it is interrupted via + * {@link Future#cancel(boolean) cancel(true)}. The background task checks + * for interruption at key points and will bail out gracefully.

+ * + *

After cancellation, {@link #isAnalyzing()} will return {@code false} + * once the background thread has actually stopped (which may not be + * immediate if the task is in the middle of a non-interruptible + * operation).

+ */ + public void cancelInFlight() { + Future current = inFlightAnalysis; + if (current != null && !current.isDone()) { + current.cancel(true); + } + inFlightAnalysis = null; + } + + /** + * Returns whether an analysis is currently running or queued. + * + *

A return value of {@code true} means there is a {@link Future} that + * has not yet completed. Note that due to the inherent race between + * checking and acting, this method is advisory only — the analysis + * may complete (or be cancelled) between the check and the caller's next + * action.

+ * + * @return {@code true} if an analysis task is in flight + */ + public boolean isAnalyzing() { + Future current = inFlightAnalysis; + return current != null && !current.isDone(); + } + + /** + * Returns the current semantic model. + * + *

The returned reference is the live model that the background + * thread mutates during analysis. Callers should be aware that the model's + * contents may change between calls if an analysis is in flight. For + * consistent reads, callers should either:

+ *
    + *
  • Read only when {@link #isAnalyzing()} is {@code false}, or
  • + *
  • Use the model snapshot provided via {@link AnalysisCallback}.
  • + *
+ * + *

This method is primarily intended for incremental analysis paths that + * need access to the previous model state before scheduling an update.

+ * + * @return the semantic model (never {@code null}) + */ + public SemanticModel getSemanticModel() { + return semanticModel; + } + + /** + * Returns the incremental strategy used by this analyzer. + * + *

The strategy is stateless and can be used by external callers + * (e.g., the orchestrator) to classify edits before deciding whether + * to call {@link #scheduleAnalysis} or + * {@link #scheduleIncrementalAnalysis}.

+ * + * @return the incremental strategy (never {@code null}) + */ + public IncrementalStrategy getStrategy() { + return strategy; + } + + /** + * Returns the revision number that was most recently submitted for + * analysis. + * + *

This can be compared against the document's current revision to + * determine whether the latest analysis results are still relevant.

+ * + * @return the most recently submitted revision number + */ + public long getCurrentRevision() { + return currentRevision.get(); + } + + /** + * Shuts down the background executor and cancels any in-flight analysis. + * + *

Must be called when the editor closes to release + * the background thread. After disposal:

+ *
    + *
  • All {@code schedule*} methods become no-ops.
  • + *
  • {@link #isAnalyzing()} returns {@code false}.
  • + *
  • Any in-flight analysis bails out without invoking the callback.
  • + *
+ * + *

This method blocks for up to {@value #SHUTDOWN_TIMEOUT_MS}ms waiting + * for the executor to terminate. If the executor does not terminate in + * time, it is forcefully shut down via {@link ExecutorService#shutdownNow()}. + *

+ * + *

Safe to call multiple times; subsequent calls are no-ops.

+ */ + public void dispose() { + if (disposed) { + return; + } + disposed = true; + + cancelInFlight(); + semanticModel.clear(); + + executor.shutdown(); + try { + if (!executor.awaitTermination(SHUTDOWN_TIMEOUT_MS, TimeUnit.MILLISECONDS)) { + LOGGER.log(Level.WARNING, + "Semantic analysis executor did not terminate within {0}ms; forcing shutdown", + SHUTDOWN_TIMEOUT_MS); + executor.shutdownNow(); + } + } catch (InterruptedException e) { + executor.shutdownNow(); + Thread.currentThread().interrupt(); + } + } + + /** + * Returns whether this analyzer has been disposed. + * + * @return {@code true} if {@link #dispose()} has been called + */ + public boolean isDisposed() { + return disposed; + } + + // ── Analysis tasks ───────────────────────────────────────────────────────── + + /** + * Runnable that performs a full semantic model rebuild on the background + * thread. Checks for disposal and revision staleness before and after + * the rebuild. + */ + private final class FullAnalysisTask implements Runnable { + + private final DocumentSyntax syntax; + private final long revision; + private final AnalysisCallback callback; + + FullAnalysisTask(DocumentSyntax syntax, long revision, AnalysisCallback callback) { + this.syntax = syntax; + this.revision = revision; + this.callback = callback; + } + + @Override + public void run() { + if (shouldAbort()) { + return; + } + + try { + semanticModel.rebuild(syntax); + + if (shouldAbort()) { + return; + } + + deliverSuccess(); + } catch (Exception e) { + deliverFailure(e); + } + } + + /** + * Checks whether this task should abort execution. + * + *

Abort conditions:

+ *
    + *
  • The analyzer has been disposed.
  • + *
  • The thread has been interrupted (task was cancelled).
  • + *
  • The revision has been superseded by a newer submission.
  • + *
+ * + * @return {@code true} if the task should stop immediately + */ + private boolean shouldAbort() { + return disposed + || Thread.currentThread().isInterrupted() + || currentRevision.get() != revision; + } + + /** + * Delivers the successful analysis result via the callback, after a + * final staleness check. If the revision has been superseded between + * the analysis completing and this delivery attempt, the result is + * silently discarded. + */ + private void deliverSuccess() { + if (disposed || currentRevision.get() != revision) { + return; + } + try { + callback.onAnalysisComplete(revision, semanticModel, syntax); + } catch (Exception e) { + LOGGER.log(Level.WARNING, + "Exception in AnalysisCallback.onAnalysisComplete for revision " + revision, e); + } + } + + /** + * Delivers a failure notification via the callback, unless the + * analyzer is disposed or the thread was interrupted (in which case + * the failure is expected and not reported to the caller). + */ + private void deliverFailure(Exception error) { + if (disposed || Thread.currentThread().isInterrupted()) { + return; + } + try { + callback.onAnalysisFailed(revision, error); + } catch (Exception e) { + LOGGER.log(Level.WARNING, + "Exception in AnalysisCallback.onAnalysisFailed for revision " + revision, e); + } + } + } + + /** + * Runnable that performs an incremental semantic model update on the + * background thread. Uses the {@link InvalidationScope} to determine + * which sub-components of the model need rebuilding. + * + *

For {@link InvalidationScope#NONE}, the model is left untouched but + * the callback is still invoked so the orchestrator can apply + * offset-adjusted decorations using the existing model state.

+ */ + private final class IncrementalAnalysisTask implements Runnable { + + private final DocumentSyntax syntax; + private final long revision; + private final InvalidationScope scope; + private final AnalysisCallback callback; + + IncrementalAnalysisTask(DocumentSyntax syntax, long revision, + InvalidationScope scope, AnalysisCallback callback) { + this.syntax = syntax; + this.revision = revision; + this.scope = scope; + this.callback = callback; + } + + @Override + public void run() { + if (shouldAbort()) { + return; + } + + try { + // For NONE scope, the model is already up-to-date; we still + // invoke the callback so the orchestrator can re-apply + // decorations with corrected offsets. + if (scope != InvalidationScope.NONE) { + semanticModel.incrementalUpdate(syntax, scope); + } + + if (shouldAbort()) { + return; + } + + deliverSuccess(); + } catch (Exception e) { + deliverFailure(e); + } + } + + /** + * Checks whether this task should abort execution. + * + * @return {@code true} if the task should stop immediately + * @see FullAnalysisTask#shouldAbort() + */ + private boolean shouldAbort() { + return disposed + || Thread.currentThread().isInterrupted() + || currentRevision.get() != revision; + } + + /** + * Delivers the successful analysis result via the callback, after a + * final staleness check. + */ + private void deliverSuccess() { + if (disposed || currentRevision.get() != revision) { + return; + } + try { + callback.onAnalysisComplete(revision, semanticModel, syntax); + } catch (Exception e) { + LOGGER.log(Level.WARNING, + "Exception in AnalysisCallback.onAnalysisComplete for revision " + revision, e); + } + } + + /** + * Delivers a failure notification via the callback. + */ + private void deliverFailure(Exception error) { + if (disposed || Thread.currentThread().isInterrupted()) { + return; + } + try { + callback.onAnalysisFailed(revision, error); + } catch (Exception e) { + LOGGER.log(Level.WARNING, + "Exception in AnalysisCallback.onAnalysisFailed for revision " + revision, e); + } + } + } + + // ── Argument validation ──────────────────────────────────────────────────── + + /** + * Validates common arguments for the {@code schedule*} methods. + * + * @param syntax the document syntax (must not be {@code null}) + * @param revision the revision number (informational; no constraint) + * @param callback the analysis callback (must not be {@code null}) + * @throws IllegalArgumentException if {@code syntax} or {@code callback} + * is {@code null} + */ + private static void validateScheduleArguments(DocumentSyntax syntax, long revision, + AnalysisCallback callback) { + if (syntax == null) { + throw new IllegalArgumentException("syntax must not be null"); + } + if (callback == null) { + throw new IllegalArgumentException("callback must not be null"); + } + } + + // ── Thread factory ───────────────────────────────────────────────────────── + + /** + * Creates a {@link ThreadFactory} that produces a single daemon thread + * with a descriptive name and slightly reduced priority. + * + *

The daemon flag ensures the thread does not prevent JVM shutdown + * (critical in Minecraft's modded environment where the game client may + * close while analysis is in flight). The reduced priority + * ({@link Thread#NORM_PRIORITY} - 1) ensures analysis does not starve + * the render thread.

+ * + * @return a thread factory for the analysis executor + */ + private static ThreadFactory createDaemonThreadFactory() { + return new ThreadFactory() { + @Override + public Thread newThread(Runnable r) { + Thread t = new Thread(r, THREAD_NAME); + t.setDaemon(true); + t.setPriority(Thread.NORM_PRIORITY - 1); + return t; + } + }; + } + + @Override + public String toString() { + return "SemanticAnalyzer{" + + "analyzing=" + isAnalyzing() + + ", revision=" + currentRevision.get() + + ", disposed=" + disposed + + ", model=" + semanticModel + + '}'; + } +} diff --git a/src/main/java/bigguy/texteditor/analysis/SemanticMarkBuilder.java b/src/main/java/bigguy/texteditor/analysis/SemanticMarkBuilder.java new file mode 100644 index 000000000..92b2dea4f --- /dev/null +++ b/src/main/java/bigguy/texteditor/analysis/SemanticMarkBuilder.java @@ -0,0 +1,576 @@ +package bigguy.texteditor.analysis; + +import bigguy.texteditor.index.Symbol; +import bigguy.texteditor.index.Symbol.FieldSymbol; +import bigguy.texteditor.index.Symbol.ImportSymbol; +import bigguy.texteditor.index.Symbol.MethodSymbol; +import bigguy.texteditor.index.Symbol.TypeSymbol; +import bigguy.texteditor.index.SymbolKind; +import bigguy.texteditor.render.Mark; +import bigguy.texteditor.semantics.SemanticModel; +import bigguy.texteditor.semantics.SymbolTable; +import bigguy.texteditor.syntax.DocumentSyntax; +import bigguy.texteditor.syntax.SemanticNode; +import bigguy.texteditor.treesitter.java.TextSpan; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenType; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +/** + * Translates the semantic model (symbols extracted from the CST) into {@link Mark} + * objects that the render pipeline can merge with syntax marks. + * + *

This builder bridges semantic analysis and visual rendering. It walks the CST + * via {@link DocumentSyntax} to locate the name portion of each declaration, + * then creates a {@link Mark#semantic(int, int, TokenType, Object) semantic mark} + * with the correct {@link TokenType} and the originating {@link Symbol} as metadata. + * Attaching the symbol enables downstream features like hover tooltips and + * go-to-definition.

+ * + *

Why walk the CST instead of using Symbol ranges?

+ *

{@link Symbol#range()} covers the entire declaration (e.g., the full + * {@code public class Foo { ... }} block for a {@link TypeSymbol}). Highlighting + * the full range would incorrectly color keywords, punctuation, and body content. + * By walking the CST and extracting each declaration's "name" child node, we + * highlight only the identifier — matching what users expect from a modern IDE.

+ * + *

Symbol → TokenType mapping

+ * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
Symbol typeConditionTokenType
{@link TypeSymbol}{@link SymbolKind#CLASS}{@link TokenType#CLASS_DECL}
{@link TypeSymbol}{@link SymbolKind#INTERFACE}{@link TokenType#INTERFACE_DECL}
{@link TypeSymbol}{@link SymbolKind#ENUM}{@link TokenType#ENUM_DECL}
{@link TypeSymbol}{@link SymbolKind#ANNOTATION}{@link TokenType#JSDOC_TAG}
{@link MethodSymbol}any{@link TokenType#METHOD_DECL}
{@link FieldSymbol}static & final{@link TokenType#STATIC_FINAL_FIELD}
{@link FieldSymbol}otherwise{@link TokenType#GLOBAL_FIELD}
{@link ImportSymbol}always{@link TokenType#IMPORTED_CLASS}
+ * + *

Thread safety

+ *

This class is stateless — all state lives in the method parameters. + * It is safe to call {@link #build(SemanticModel, DocumentSyntax)} from any + * thread, provided the model and syntax are not being concurrently mutated.

+ * + * @see Mark#semantic(int, int, TokenType, Object) + * @see SemanticModel + * @see SymbolTable + */ +public final class SemanticMarkBuilder { + + // ── CST node type constants (mirror SemanticModel's constants) ────────── + + private static final String NODE_IMPORT_DECLARATION = "import_declaration"; + private static final String NODE_CLASS_DECLARATION = "class_declaration"; + private static final String NODE_INTERFACE_DECLARATION = "interface_declaration"; + private static final String NODE_ENUM_DECLARATION = "enum_declaration"; + private static final String NODE_ANNOTATION_TYPE_DECLARATION = "annotation_type_declaration"; + private static final String NODE_METHOD_DECLARATION = "method_declaration"; + private static final String NODE_CONSTRUCTOR_DECLARATION = "constructor_declaration"; + private static final String NODE_FIELD_DECLARATION = "field_declaration"; + private static final String NODE_VARIABLE_DECLARATOR = "variable_declarator"; + private static final String NODE_SCOPED_IDENTIFIER = "scoped_identifier"; + private static final String NODE_IDENTIFIER = "identifier"; + + private static final String FIELD_NAME = "name"; + + /** + * All CST node types that represent type declarations. + */ + private static final Set TYPE_DECLARATION_TYPES; + + static { + Set types = new HashSet(); + types.add(NODE_CLASS_DECLARATION); + types.add(NODE_INTERFACE_DECLARATION); + types.add(NODE_ENUM_DECLARATION); + types.add(NODE_ANNOTATION_TYPE_DECLARATION); + TYPE_DECLARATION_TYPES = Collections.unmodifiableSet(types); + } + + private SemanticMarkBuilder() { + // Utility class — no instances + } + + // ═══════════════════════════════════════════════════════════════════════════ + // Public API + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * Generates semantic marks from the given model and syntax tree. + * + *

Walks all declaration nodes in the CST, looks up the corresponding + * {@link Symbol} in the {@link SymbolTable}, and creates a + * {@link Mark#semantic(int, int, TokenType, Object)} for each declaration's + * name node. Only the name identifier is highlighted — keywords, + * modifiers, and body content are left to tree-sitter's syntax marks.

+ * + *

The returned list is unsorted. Callers (typically {@code MarkLayer}) + * should sort the marks before merging them with syntax marks.

+ * + * @param model the populated semantic model (may be {@code null}) + * @param syntax the document syntax produced by the parser (may be {@code null}) + * @return a mutable list of semantic marks, never {@code null}; empty if the + * model is not built or either argument is {@code null} + */ + public static List build(SemanticModel model, DocumentSyntax syntax) { + if (model == null || syntax == null || !model.isBuilt()) { + return Collections.emptyList(); + } + + SymbolTable table = model.getSymbolTable(); + if (table.isEmpty()) { + return Collections.emptyList(); + } + + SemanticNode root = syntax.root(); + if (root == null) { + return Collections.emptyList(); + } + + List marks = new ArrayList(); + walkDeclarations(root, table, marks); + return marks; + } + + // ═══════════════════════════════════════════════════════════════════════════ + // CST walking + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * Recursively walks the CST, visiting declaration nodes and creating marks + * for each declaration's name identifier. + * + * @param node the current CST node + * @param table the symbol table to look up symbols + * @param marks the output list to append marks to + */ + private static void walkDeclarations(SemanticNode node, SymbolTable table, List marks) { + List children = node.namedChildren(); + for (SemanticNode child : children) { + String nodeType = child.nodeType(); + if (nodeType == null) { + continue; + } + + if (TYPE_DECLARATION_TYPES.contains(nodeType)) { + processTypeDeclaration(child, nodeType, table, marks); + } else if (NODE_METHOD_DECLARATION.equals(nodeType) + || NODE_CONSTRUCTOR_DECLARATION.equals(nodeType)) { + processMethodDeclaration(child, table, marks); + } else if (NODE_FIELD_DECLARATION.equals(nodeType)) { + processFieldDeclaration(child, table, marks); + } else if (NODE_IMPORT_DECLARATION.equals(nodeType)) { + processImportDeclaration(child, table, marks); + } else { + // Recurse into non-declaration nodes (e.g., class_body, block) + // to find nested declarations. + walkDeclarations(child, table, marks); + } + } + } + + // ═══════════════════════════════════════════════════════════════════════════ + // Declaration processors + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * Processes a type declaration (class, interface, enum, annotation). + * Creates a mark for the type's name identifier and recurses into the body + * for nested declarations. + * + * @param typeNode the CST node for the type declaration + * @param nodeType the node type string (e.g., "class_declaration") + * @param table the symbol table + * @param marks the output list + */ + private static void processTypeDeclaration(SemanticNode typeNode, String nodeType, + SymbolTable table, List marks) { + SemanticNode nameNode = typeNode.childByFieldName(FIELD_NAME); + if (nameNode == null) { + return; + } + + String simpleName = nameNode.text(); + if (simpleName == null || simpleName.isEmpty()) { + return; + } + + TextSpan nameSpan = nameNode.span(); + if (nameSpan == null || nameSpan.getByteLength() <= 0) { + return; + } + + // Look up the symbol by simple name to get the exact symbol instance. + TypeSymbol symbol = findTypeSymbol(table, simpleName, typeNode.span()); + TokenType tokenType = mapTypeNodeToTokenType(nodeType); + + marks.add(Mark.semantic( + nameSpan.getStartByte(), + nameSpan.getEndByte(), + tokenType, + symbol + )); + + // Recurse into the body for nested type/method/field declarations. + SemanticNode body = typeNode.childByFieldName("body"); + if (body != null) { + walkDeclarations(body, table, marks); + } + } + + /** + * Processes a method or constructor declaration. Creates a mark for the + * method's name identifier. + * + * @param methodNode the CST node for the method/constructor declaration + * @param table the symbol table + * @param marks the output list + */ + private static void processMethodDeclaration(SemanticNode methodNode, + SymbolTable table, List marks) { + SemanticNode nameNode = methodNode.childByFieldName(FIELD_NAME); + if (nameNode == null) { + return; + } + + String methodName = nameNode.text(); + if (methodName == null || methodName.isEmpty()) { + return; + } + + TextSpan nameSpan = nameNode.span(); + if (nameSpan == null || nameSpan.getByteLength() <= 0) { + return; + } + + MethodSymbol symbol = findMethodSymbol(table, methodName, methodNode.span()); + + marks.add(Mark.semantic( + nameSpan.getStartByte(), + nameSpan.getEndByte(), + TokenType.METHOD_DECL, + symbol + )); + + // Recurse into the method body for local declarations (e.g., anonymous classes). + SemanticNode body = methodNode.childByFieldName("body"); + if (body != null) { + walkDeclarations(body, table, marks); + } + } + + /** + * Processes a field declaration. Handles multi-declarator fields + * (e.g., {@code int x, y, z;}) by extracting each variable declarator's + * name and creating a separate mark for each. + * + * @param fieldNode the CST node for the field declaration + * @param table the symbol table + * @param marks the output list + */ + private static void processFieldDeclaration(SemanticNode fieldNode, + SymbolTable table, List marks) { + // Multi-declarator fields: "int x, y, z;" + List declarators = fieldNode.findAll(NODE_VARIABLE_DECLARATOR); + + if (!declarators.isEmpty()) { + for (SemanticNode declarator : declarators) { + SemanticNode nameNode = declarator.childByFieldName(FIELD_NAME); + if (nameNode == null) { + continue; + } + + String fieldName = nameNode.text(); + if (fieldName == null || fieldName.isEmpty()) { + continue; + } + + TextSpan nameSpan = nameNode.span(); + if (nameSpan == null || nameSpan.getByteLength() <= 0) { + continue; + } + + FieldSymbol symbol = findFieldSymbol(table, fieldName, fieldNode.span()); + TokenType tokenType = mapFieldSymbol(symbol); + + marks.add(Mark.semantic( + nameSpan.getStartByte(), + nameSpan.getEndByte(), + tokenType, + symbol + )); + } + } else { + // Fallback: single declarator without variable_declarator wrapper. + SemanticNode nameNode = fieldNode.childByFieldName(FIELD_NAME); + if (nameNode == null) { + return; + } + + String fieldName = nameNode.text(); + if (fieldName == null || fieldName.isEmpty()) { + return; + } + + TextSpan nameSpan = nameNode.span(); + if (nameSpan == null || nameSpan.getByteLength() <= 0) { + return; + } + + FieldSymbol symbol = findFieldSymbol(table, fieldName, fieldNode.span()); + TokenType tokenType = mapFieldSymbol(symbol); + + marks.add(Mark.semantic( + nameSpan.getStartByte(), + nameSpan.getEndByte(), + tokenType, + symbol + )); + } + } + + /** + * Processes an import declaration. Extracts the last identifier segment + * (the simple class name) from the import path and creates a mark for it. + * + *

For a scoped identifier like {@code java.util.List}, the mark covers + * the entire scoped identifier node, matching how tree-sitter structures + * the import path. For wildcard imports ({@code java.util.*}), the entire + * scoped path is marked.

+ * + * @param importNode the CST node for the import declaration + * @param table the symbol table + * @param marks the output list + */ + private static void processImportDeclaration(SemanticNode importNode, + SymbolTable table, List marks) { + // Find the scoped_identifier or identifier child — this is the import path. + SemanticNode pathNode = findImportPathNode(importNode); + if (pathNode == null) { + return; + } + + TextSpan pathSpan = pathNode.span(); + if (pathSpan == null || pathSpan.getByteLength() <= 0) { + return; + } + + // Look up the import symbol by matching the full import range. + ImportSymbol symbol = findImportSymbol(table, importNode.span()); + + marks.add(Mark.semantic( + pathSpan.getStartByte(), + pathSpan.getEndByte(), + TokenType.IMPORTED_CLASS, + symbol + )); + } + + // ═══════════════════════════════════════════════════════════════════════════ + // Symbol lookup helpers + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * Finds the {@link TypeSymbol} in the table matching the given name and + * whose declaration range overlaps the given CST node span. + * + *

If multiple types share the same simple name (e.g., nested classes), + * the one whose range contains the declaration node's range wins.

+ * + * @param table the symbol table + * @param simpleName the type's simple name + * @param declSpan the full declaration span from the CST node + * @return the matching symbol, or {@code null} if not found + */ + private static TypeSymbol findTypeSymbol(SymbolTable table, String simpleName, + TextSpan declSpan) { + List candidates = table.getTypesBySimpleName(simpleName); + if (candidates.isEmpty()) { + return null; + } + if (candidates.size() == 1) { + return candidates.get(0); + } + // Disambiguate by declaration range overlap. + if (declSpan != null) { + for (TypeSymbol ts : candidates) { + if (spansOverlap(ts.range(), declSpan)) { + return ts; + } + } + } + return candidates.get(0); + } + + /** + * Finds the {@link MethodSymbol} in the table matching the given name and + * whose declaration range overlaps the given CST node span. + * + * @param table the symbol table + * @param methodName the method name + * @param declSpan the full declaration span from the CST node + * @return the matching symbol, or {@code null} if not found + */ + private static MethodSymbol findMethodSymbol(SymbolTable table, String methodName, + TextSpan declSpan) { + List candidates = table.getMethodsByName(methodName); + if (candidates.isEmpty()) { + return null; + } + if (candidates.size() == 1) { + return candidates.get(0); + } + if (declSpan != null) { + for (MethodSymbol ms : candidates) { + if (spansOverlap(ms.range(), declSpan)) { + return ms; + } + } + } + return candidates.get(0); + } + + /** + * Finds the {@link FieldSymbol} in the table matching the given name and + * whose declaration range overlaps the given CST node span. + * + * @param table the symbol table + * @param fieldName the field name + * @param declSpan the field declaration span from the CST node + * @return the matching symbol, or {@code null} if not found + */ + private static FieldSymbol findFieldSymbol(SymbolTable table, String fieldName, + TextSpan declSpan) { + List candidates = table.getFieldsByName(fieldName); + if (candidates.isEmpty()) { + return null; + } + if (candidates.size() == 1) { + return candidates.get(0); + } + if (declSpan != null) { + for (FieldSymbol fs : candidates) { + if (spansOverlap(fs.range(), declSpan)) { + return fs; + } + } + } + return candidates.get(0); + } + + /** + * Finds the {@link ImportSymbol} in the table whose declaration range + * overlaps the given import node span. + * + * @param table the symbol table + * @param declSpan the import declaration span from the CST node + * @return the matching symbol, or {@code null} if not found + */ + private static ImportSymbol findImportSymbol(SymbolTable table, TextSpan declSpan) { + List allImports = table.getAllImports(); + if (allImports.isEmpty()) { + return null; + } + if (declSpan == null) { + return allImports.get(0); + } + for (ImportSymbol is : allImports) { + if (spansOverlap(is.range(), declSpan)) { + return is; + } + } + return null; + } + + // ═══════════════════════════════════════════════════════════════════════════ + // TokenType mapping + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * Maps a tree-sitter type declaration node type to the corresponding + * {@link TokenType} for rendering. + * + * @param nodeType the CST node type (e.g., "class_declaration") + * @return the token type for coloring + */ + private static TokenType mapTypeNodeToTokenType(String nodeType) { + if (NODE_INTERFACE_DECLARATION.equals(nodeType)) { + return TokenType.INTERFACE_DECL; + } + if (NODE_ENUM_DECLARATION.equals(nodeType)) { + return TokenType.ENUM_DECL; + } + if (NODE_ANNOTATION_TYPE_DECLARATION.equals(nodeType)) { + return TokenType.JSDOC_TAG; + } + // NODE_CLASS_DECLARATION and fallback + return TokenType.CLASS_DECL; + } + + /** + * Maps a {@link FieldSymbol}'s modifiers to the appropriate {@link TokenType}. + * + *

Static final fields get {@link TokenType#STATIC_FINAL_FIELD} (magenta, + * bold+italic), matching IntelliJ's convention for constants. All other + * fields get {@link TokenType#GLOBAL_FIELD} (aqua).

+ * + * @param symbol the field symbol (may be {@code null} if the symbol table + * lookup failed) + * @return the token type for coloring + */ + private static TokenType mapFieldSymbol(FieldSymbol symbol) { + if (symbol != null && symbol.isStatic() && symbol.isFinal()) { + return TokenType.STATIC_FINAL_FIELD; + } + return TokenType.GLOBAL_FIELD; + } + + // ═══════════════════════════════════════════════════════════════════════════ + // Utility + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * Finds the import path node (scoped_identifier or identifier) within + * an import_declaration CST node. + * + * @param importNode the import declaration node + * @return the path node, or {@code null} if not found + */ + private static SemanticNode findImportPathNode(SemanticNode importNode) { + List children = importNode.namedChildren(); + for (SemanticNode child : children) { + String type = child.nodeType(); + if (NODE_SCOPED_IDENTIFIER.equals(type) || NODE_IDENTIFIER.equals(type)) { + return child; + } + } + return null; + } + + /** + * Tests whether two {@link TextSpan}s overlap. + * + * @param a the first span (may be {@code null}) + * @param b the second span (may be {@code null}) + * @return {@code true} if both spans are non-null and overlap + */ + private static boolean spansOverlap(TextSpan a, TextSpan b) { + if (a == null || b == null) { + return false; + } + return a.getStartByte() < b.getEndByte() && b.getStartByte() < a.getEndByte(); + } +} diff --git a/src/main/java/bigguy/texteditor/diagnostics/Diagnostic.java b/src/main/java/bigguy/texteditor/diagnostics/Diagnostic.java new file mode 100644 index 000000000..961b7bbca --- /dev/null +++ b/src/main/java/bigguy/texteditor/diagnostics/Diagnostic.java @@ -0,0 +1,151 @@ +package bigguy.texteditor.diagnostics; + +import bigguy.texteditor.treesitter.java.TextSpan; + +import java.util.Objects; + +/** + * An immutable diagnostic (error, warning, info, or hint) anchored to a range + * in the source document. Replaces the legacy {@code DocumentError} class and + * the misused {@code AssignmentInfo}-as-error pattern. + * + *

Severity levels and source categories follow the Language Server Protocol + * specification to ease future LSP integration.

+ */ +public final class Diagnostic { + + /** + * Diagnostic severity, following the LSP {@code DiagnosticSeverity} enumeration. + */ + public enum Severity { + /** A problem that prevents compilation or execution. */ + ERROR(1), + /** A potential issue that does not prevent compilation. */ + WARNING(2), + /** Informational message (e.g. deprecation notice). */ + INFO(3), + /** Subtle suggestion (e.g. unused import). */ + HINT(4); + + private final int lspValue; + + Severity(int lspValue) { + this.lspValue = lspValue; + } + + /** + * Returns the numeric value matching the LSP specification. + * + * @return the LSP {@code DiagnosticSeverity} integer (1–4) + */ + public int lspValue() { + return lspValue; + } + } + + /** + * Identifies which analysis phase produced the diagnostic, enabling + * targeted invalidation when only part of the pipeline reruns. + */ + public enum Source { + /** Syntax errors from the tree-sitter parser. */ + PARSER, + /** Declaration-level issues (duplicate names, missing types). */ + DECLARATION, + /** Type-checking errors (incompatible assignment, wrong argument type). */ + TYPE_CHECK, + /** Import resolution issues (unresolved import, wildcard ambiguity). */ + IMPORT, + /** Higher-level semantic checks (unreachable code, unused variable). */ + SEMANTIC + } + + private final TextSpan range; + private final Severity severity; + private final String message; + private final Source source; + private final String code; + + /** + * @param range the source range this diagnostic applies to + * @param severity the severity level + * @param message a human-readable description of the issue + * @param source the analysis phase that produced this diagnostic + * @param code an optional machine-readable error code (may be {@code null}) + */ + public Diagnostic(TextSpan range, Severity severity, String message, Source source, String code) { + this.range = Objects.requireNonNull(range, "range"); + this.severity = Objects.requireNonNull(severity, "severity"); + this.message = Objects.requireNonNull(message, "message"); + this.source = Objects.requireNonNull(source, "source"); + this.code = code; + } + + /** + * Convenience factory for diagnostics without an error code. + * + * @param range the source range + * @param severity the severity level + * @param message a human-readable description + * @param source the originating analysis phase + * @return a new diagnostic with a {@code null} error code + */ + public static Diagnostic of(TextSpan range, Severity severity, String message, Source source) { + return new Diagnostic(range, severity, message, source, null); + } + + /** @return the source range this diagnostic applies to */ + public TextSpan range() { return range; } + + /** @return the severity level */ + public Severity severity() { return severity; } + + /** @return a human-readable description of the issue */ + public String message() { return message; } + + /** @return the analysis phase that produced this diagnostic */ + public Source source() { return source; } + + /** @return an optional machine-readable error code, or {@code null} */ + public String code() { return code; } + + /** @return {@code true} if this diagnostic represents a compilation error */ + public boolean isError() { + return severity == Severity.ERROR; + } + + /** @return {@code true} if this diagnostic represents a warning */ + public boolean isWarning() { + return severity == Severity.WARNING; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof Diagnostic)) return false; + Diagnostic that = (Diagnostic) obj; + return range.equals(that.range) + && severity == that.severity + && message.equals(that.message) + && source == that.source + && Objects.equals(code, that.code); + } + + @Override + public int hashCode() { + int result = range.hashCode(); + result = 31 * result + severity.hashCode(); + result = 31 * result + message.hashCode(); + result = 31 * result + source.hashCode(); + result = 31 * result + (code != null ? code.hashCode() : 0); + return result; + } + + @Override + public String toString() { + String loc = range.getStartRow() + ":" + range.getStartColumn(); + String codeStr = code != null ? " [" + code + "]" : ""; + return severity.name().toLowerCase() + "(" + loc + "): " + message + codeStr + + " (" + source.name().toLowerCase() + ")"; + } +} diff --git a/src/main/java/bigguy/texteditor/diagnostics/DiagnosticStore.java b/src/main/java/bigguy/texteditor/diagnostics/DiagnosticStore.java new file mode 100644 index 000000000..9dcf5acb9 --- /dev/null +++ b/src/main/java/bigguy/texteditor/diagnostics/DiagnosticStore.java @@ -0,0 +1,171 @@ +package bigguy.texteditor.diagnostics; + +import bigguy.texteditor.diagnostics.Diagnostic.Severity; +import bigguy.texteditor.diagnostics.Diagnostic.Source; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.concurrent.CopyOnWriteArrayList; +import java.util.concurrent.atomic.AtomicInteger; + +/** + * Thread-safe, centralized storage for diagnostics with query capabilities. + * + *

Diagnostics are added from background analysis threads and read from the + * UI thread. All mutation operations increment the internal {@link #version()}, + * allowing consumers to detect changes cheaply via version comparison.

+ * + *

All query methods return unmodifiable snapshots — callers never see + * the internal mutable list.

+ */ +public final class DiagnosticStore { + + private final CopyOnWriteArrayList diagnostics = new CopyOnWriteArrayList<>(); + private final AtomicInteger version = new AtomicInteger(0); + + /** + * Adds a diagnostic to the store. + * + * @param diagnostic the diagnostic to add + * @throws NullPointerException if {@code diagnostic} is null + */ + public void addDiagnostic(Diagnostic diagnostic) { + if (diagnostic == null) { + throw new NullPointerException("diagnostic must not be null"); + } + diagnostics.add(diagnostic); + version.incrementAndGet(); + } + + /** + * Returns all diagnostics whose range overlaps the given byte interval. + * Useful for rendering underlines on visible lines. + * + * @param startByte inclusive start of the query interval + * @param endByte exclusive end of the query interval + * @return an unmodifiable list of matching diagnostics + */ + public List getDiagnosticsInRange(int startByte, int endByte) { + List result = new ArrayList<>(); + for (Diagnostic d : diagnostics) { + if (d.range().getStartByte() < endByte && startByte < d.range().getEndByte()) { + result.add(d); + } + } + return Collections.unmodifiableList(result); + } + + /** + * Returns all diagnostics produced by the given analysis phase. + * + * @param source the originating analysis phase + * @return an unmodifiable list of matching diagnostics + */ + public List getDiagnosticsBySource(Source source) { + List result = new ArrayList<>(); + for (Diagnostic d : diagnostics) { + if (d.source() == source) { + result.add(d); + } + } + return Collections.unmodifiableList(result); + } + + /** + * Returns all diagnostics with the given severity level. + * + * @param severity the severity to filter by + * @return an unmodifiable list of matching diagnostics + */ + public List getDiagnosticsBySeverity(Severity severity) { + List result = new ArrayList<>(); + for (Diagnostic d : diagnostics) { + if (d.severity() == severity) { + result.add(d); + } + } + return Collections.unmodifiableList(result); + } + + /** + * Returns an unmodifiable snapshot of all diagnostics. + * + * @return all stored diagnostics + */ + public List getAll() { + return Collections.unmodifiableList(new ArrayList<>(diagnostics)); + } + + /** Removes all diagnostics from the store. */ + public void clear() { + if (!diagnostics.isEmpty()) { + diagnostics.clear(); + version.incrementAndGet(); + } + } + + /** + * Removes all diagnostics produced by the given analysis phase. + * Useful for incremental invalidation when only one phase reruns. + * + * @param source the analysis phase whose diagnostics should be removed + */ + public void clearBySource(Source source) { + boolean removed = diagnostics.removeIf(d -> d.source() == source); + if (removed) { + version.incrementAndGet(); + } + } + + /** @return the number of diagnostics with {@link Severity#ERROR} */ + public int errorCount() { + int count = 0; + for (Diagnostic d : diagnostics) { + if (d.isError()) { + count++; + } + } + return count; + } + + /** @return the number of diagnostics with {@link Severity#WARNING} */ + public int warningCount() { + int count = 0; + for (Diagnostic d : diagnostics) { + if (d.isWarning()) { + count++; + } + } + return count; + } + + /** @return the total number of stored diagnostics */ + public int size() { + return diagnostics.size(); + } + + /** @return {@code true} if no diagnostics are stored */ + public boolean isEmpty() { + return diagnostics.isEmpty(); + } + + /** + * Returns a monotonically increasing version number that increments + * on every mutation. Consumers can compare versions to detect changes + * without re-scanning the full list. + * + * @return the current version + */ + public int version() { + return version.get(); + } + + @Override + public String toString() { + return "DiagnosticStore{size=" + diagnostics.size() + + ", errors=" + errorCount() + + ", warnings=" + warningCount() + + ", version=" + version.get() + "}"; + } +} diff --git a/src/main/java/bigguy/texteditor/index/Symbol.java b/src/main/java/bigguy/texteditor/index/Symbol.java new file mode 100644 index 000000000..2ee47cc1d --- /dev/null +++ b/src/main/java/bigguy/texteditor/index/Symbol.java @@ -0,0 +1,265 @@ +package bigguy.texteditor.index; + +import bigguy.texteditor.treesitter.java.TextSpan; + +import java.util.Collections; +import java.util.List; +import java.util.Objects; + +/** + * Hierarchy representing all symbol types in the document. + * Each variant carries type-specific metadata. + * + *

Follows IntelliJ's {@code PsiElement} specialization pattern: a common + * interface with concrete final implementations for each symbol category.

+ */ +public interface Symbol { + + /** @return the unique key identifying this symbol */ + SymbolKey key(); + + /** @return the source range of the symbol's declaration */ + TextSpan range(); + + /** @return the symbol's simple name */ + String name(); + + /** @return the classification of this symbol */ + SymbolKind kind(); + + /** + * A type declaration (class, interface, enum, annotation). + */ + final class TypeSymbol implements Symbol { + + private final SymbolKey key; + private final TextSpan range; + private final String simpleName; + private final String fullName; + private final String dotName; + + /** + * @param key the unique key for this symbol + * @param range the declaration's source range + * @param simpleName the unqualified type name + * @param fullName the fully qualified name (e.g. "java.util.List") + * @param dotName the dot-path from enclosing scope (e.g. "Outer.Inner") + */ + public TypeSymbol(SymbolKey key, TextSpan range, String simpleName, + String fullName, String dotName) { + this.key = Objects.requireNonNull(key, "key"); + this.range = Objects.requireNonNull(range, "range"); + this.simpleName = Objects.requireNonNull(simpleName, "simpleName"); + this.fullName = Objects.requireNonNull(fullName, "fullName"); + this.dotName = Objects.requireNonNull(dotName, "dotName"); + } + + @Override public SymbolKey key() { return key; } + @Override public TextSpan range() { return range; } + @Override public String name() { return simpleName; } + @Override public SymbolKind kind() { return key.kind(); } + + /** @return the fully qualified name (e.g. "java.util.List") */ + public String fullName() { return fullName; } + + /** @return the dot-path from enclosing scope (e.g. "Outer.Inner") */ + public String dotName() { return dotName; } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof TypeSymbol)) return false; + TypeSymbol that = (TypeSymbol) obj; + return key.equals(that.key); + } + + @Override + public int hashCode() { return key.hashCode(); } + + @Override + public String toString() { + return kind().displayName() + " " + fullName + " at " + range; + } + } + + /** + * A method or constructor declaration. + */ + final class MethodSymbol implements Symbol { + + private final SymbolKey key; + private final TextSpan range; + private final String name; + private final TextSpan bodyRange; + private final List parameterNames; + + /** + * @param key the unique key for this symbol + * @param range the declaration's source range (including signature) + * @param name the method name (or {@code ""} for constructors) + * @param bodyRange the range of the method body (may be {@code null} for abstract methods) + * @param parameterNames the ordered list of parameter names + */ + public MethodSymbol(SymbolKey key, TextSpan range, String name, + TextSpan bodyRange, List parameterNames) { + this.key = Objects.requireNonNull(key, "key"); + this.range = Objects.requireNonNull(range, "range"); + this.name = Objects.requireNonNull(name, "name"); + this.bodyRange = bodyRange; + this.parameterNames = Collections.unmodifiableList( + new java.util.ArrayList<>(Objects.requireNonNull(parameterNames, "parameterNames"))); + } + + @Override public SymbolKey key() { return key; } + @Override public TextSpan range() { return range; } + @Override public String name() { return name; } + @Override public SymbolKind kind() { return key.kind(); } + + /** @return the range of the method body, or {@code null} for abstract methods */ + public TextSpan bodyRange() { return bodyRange; } + + /** @return an unmodifiable list of parameter names in declaration order */ + public List parameterNames() { return parameterNames; } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof MethodSymbol)) return false; + MethodSymbol that = (MethodSymbol) obj; + return key.equals(that.key); + } + + @Override + public int hashCode() { return key.hashCode(); } + + @Override + public String toString() { + return kind().displayName() + " " + name + "(" + String.join(", ", parameterNames) + ") at " + range; + } + } + + /** + * A field, parameter, local variable, or enum constant declaration. + */ + final class FieldSymbol implements Symbol { + + private final SymbolKey key; + private final TextSpan range; + private final String name; + private final String typeName; + private final boolean isStatic; + private final boolean isFinal; + + /** + * @param key the unique key for this symbol + * @param range the declaration's source range + * @param name the field name + * @param typeName the declared type name (may be {@code null} if unresolved) + * @param isStatic whether the field is static + * @param isFinal whether the field is final + */ + public FieldSymbol(SymbolKey key, TextSpan range, String name, + String typeName, boolean isStatic, boolean isFinal) { + this.key = Objects.requireNonNull(key, "key"); + this.range = Objects.requireNonNull(range, "range"); + this.name = Objects.requireNonNull(name, "name"); + this.typeName = typeName; + this.isStatic = isStatic; + this.isFinal = isFinal; + } + + @Override public SymbolKey key() { return key; } + @Override public TextSpan range() { return range; } + @Override public String name() { return name; } + @Override public SymbolKind kind() { return key.kind(); } + + /** @return the declared type name, or {@code null} if unresolved */ + public String typeName() { return typeName; } + + /** @return whether the field is static */ + public boolean isStatic() { return isStatic; } + + /** @return whether the field is final */ + public boolean isFinal() { return isFinal; } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof FieldSymbol)) return false; + FieldSymbol that = (FieldSymbol) obj; + return key.equals(that.key); + } + + @Override + public int hashCode() { return key.hashCode(); } + + @Override + public String toString() { + String modifiers = (isStatic ? "static " : "") + (isFinal ? "final " : ""); + return kind().displayName() + " " + modifiers + + (typeName != null ? typeName + " " : "") + name + " at " + range; + } + } + + /** + * An import declaration. + */ + final class ImportSymbol implements Symbol { + + private final SymbolKey key; + private final TextSpan range; + private final String name; + private final String fullPath; + private final boolean isWildcard; + private final boolean isStatic; + + /** + * @param key the unique key for this symbol + * @param range the import statement's source range + * @param name the simple name (last segment of the import path) + * @param fullPath the full import path (e.g. "java.util.List") + * @param isWildcard whether this is a wildcard import (e.g. "java.util.*") + * @param isStatic whether this is a static import + */ + public ImportSymbol(SymbolKey key, TextSpan range, String name, + String fullPath, boolean isWildcard, boolean isStatic) { + this.key = Objects.requireNonNull(key, "key"); + this.range = Objects.requireNonNull(range, "range"); + this.name = Objects.requireNonNull(name, "name"); + this.fullPath = Objects.requireNonNull(fullPath, "fullPath"); + this.isWildcard = isWildcard; + this.isStatic = isStatic; + } + + @Override public SymbolKey key() { return key; } + @Override public TextSpan range() { return range; } + @Override public String name() { return name; } + @Override public SymbolKind kind() { return key.kind(); } + + /** @return the full import path (e.g. "java.util.List") */ + public String fullPath() { return fullPath; } + + /** @return whether this is a wildcard import (e.g. "java.util.*") */ + public boolean isWildcard() { return isWildcard; } + + /** @return whether this is a static import */ + public boolean isStatic() { return isStatic; } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof ImportSymbol)) return false; + ImportSymbol that = (ImportSymbol) obj; + return key.equals(that.key); + } + + @Override + public int hashCode() { return key.hashCode(); } + + @Override + public String toString() { + String prefix = isStatic ? "static import " : "import "; + return prefix + fullPath + (isWildcard ? ".*" : "") + " at " + range; + } + } +} diff --git a/src/main/java/bigguy/texteditor/index/SymbolKey.java b/src/main/java/bigguy/texteditor/index/SymbolKey.java new file mode 100644 index 000000000..fdbc90b30 --- /dev/null +++ b/src/main/java/bigguy/texteditor/index/SymbolKey.java @@ -0,0 +1,71 @@ +package bigguy.texteditor.index; + +import bigguy.texteditor.treesitter.java.TextSpan; + +import java.util.Objects; + +/** + * Uniquely identifies a symbol within the document by name, kind, and range. + * Replaces magic integer offset keys used in the legacy ScriptDocument. + * + *

Two keys are equal if and only if they share the same name, kind, and range. + * This guarantees uniqueness even for overloaded methods or shadowed variables + * at different scopes.

+ */ +public final class SymbolKey { + + private final String name; + private final SymbolKind kind; + private final TextSpan range; + + /** + * @param name the symbol's simple name + * @param kind the classification of the symbol + * @param range the source range of the symbol's declaration + */ + public SymbolKey(String name, SymbolKind kind, TextSpan range) { + this.name = Objects.requireNonNull(name, "name"); + this.kind = Objects.requireNonNull(kind, "kind"); + this.range = Objects.requireNonNull(range, "range"); + } + + /** @return the symbol's simple name */ + public String name() { return name; } + + /** @return the classification of the symbol */ + public SymbolKind kind() { return kind; } + + /** @return the source range of the symbol's declaration */ + public TextSpan range() { return range; } + + /** + * Returns a dot-qualified name for nested type display (e.g. "Outer.Inner"). + * For non-nested symbols this returns the simple name. + * + * @return the qualified name + */ + public String qualifiedName() { + return name; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof SymbolKey)) return false; + SymbolKey that = (SymbolKey) obj; + return name.equals(that.name) && kind == that.kind && range.equals(that.range); + } + + @Override + public int hashCode() { + int result = name.hashCode(); + result = 31 * result + kind.hashCode(); + result = 31 * result + range.hashCode(); + return result; + } + + @Override + public String toString() { + return kind.displayName() + " '" + name + "' at " + range; + } +} diff --git a/src/main/java/bigguy/texteditor/index/SymbolKind.java b/src/main/java/bigguy/texteditor/index/SymbolKind.java new file mode 100644 index 000000000..8110d7b8d --- /dev/null +++ b/src/main/java/bigguy/texteditor/index/SymbolKind.java @@ -0,0 +1,84 @@ +package bigguy.texteditor.index; + +/** + * Classifies symbols within a source document for indexing, navigation, and + * icon display. + * + *

Follows the LSP {@code SymbolKind} enumeration and IntelliJ IDEA's + * {@code IElementType} hierarchy, covering the Java language constructs + * relevant to the script editor.

+ */ +public enum SymbolKind { + + CLASS("Class", true, false, false), + INTERFACE("Interface", true, false, false), + ENUM("Enum", true, false, false), + ANNOTATION("Annotation", true, false, false), + METHOD("Method", false, true, false), + CONSTRUCTOR("Constructor", false, true, false), + FIELD("Field", false, false, true), + PARAMETER("Parameter", false, false, true), + LOCAL_VARIABLE("Local Variable", false, false, true), + IMPORT("Import", false, false, false), + PACKAGE("Package", false, false, false), + TYPE_PARAMETER("Type Parameter", false, false, false), + LAMBDA("Lambda", false, true, false), + ENUM_CONSTANT("Enum Constant", false, false, true), + STATIC_INITIALIZER("Static Initializer", false, false, false); + + private final String displayName; + private final boolean type; + private final boolean callable; + private final boolean variable; + + SymbolKind(String displayName, boolean type, boolean callable, boolean variable) { + this.displayName = displayName; + this.type = type; + this.callable = callable; + this.variable = variable; + } + + /** + * Returns a human-readable name suitable for UI display (e.g. "Local Variable"). + * + * @return the display name + */ + public String displayName() { + return displayName; + } + + /** + * Returns {@code true} for type-declaring symbols: + * {@link #CLASS}, {@link #INTERFACE}, {@link #ENUM}, {@link #ANNOTATION}. + * + * @return whether this kind represents a type declaration + */ + public boolean isType() { + return type; + } + + /** + * Returns {@code true} for callable symbols: + * {@link #METHOD}, {@link #CONSTRUCTOR}, {@link #LAMBDA}. + * + * @return whether this kind represents something that can be invoked + */ + public boolean isCallable() { + return callable; + } + + /** + * Returns {@code true} for variable-like symbols: + * {@link #FIELD}, {@link #PARAMETER}, {@link #LOCAL_VARIABLE}, {@link #ENUM_CONSTANT}. + * + * @return whether this kind represents a named value holder + */ + public boolean isVariable() { + return variable; + } + + @Override + public String toString() { + return displayName; + } +} diff --git a/src/main/java/bigguy/texteditor/render/Mark.java b/src/main/java/bigguy/texteditor/render/Mark.java new file mode 100644 index 000000000..e907806be --- /dev/null +++ b/src/main/java/bigguy/texteditor/render/Mark.java @@ -0,0 +1,182 @@ +package bigguy.texteditor.render; + +import noppes.npcs.client.gui.util.script.interpreter.token.TokenType; + +/** + * A highlight region produced by the analysis pipeline. + * Marks bridge the gap between CST/semantic analysis and token rendering. + * + *

Marks are produced by: + *

    + *
  • Tree-sitter highlight queries (syntax marks)
  • + *
  • Semantic analysis (type resolution, scope coloring)
  • + *
  • Error detection (diagnostic marks)
  • + *
+ * + *

Multiple marks can overlap. {@link MarkLayer} resolves conflicts using + * {@link TokenType#getPriority()}. + * + *

Sorting order (used by {@link MarkLayer#merge()}): + *

    + *
  1. By start position ascending
  2. + *
  3. By span length descending (longest first)
  4. + *
  5. By priority descending (highest first)
  6. + *
+ */ +public final class Mark implements Comparable { + + /** Byte offset where this mark begins (inclusive). */ + public final int start; + + /** Byte offset where this mark ends (exclusive). */ + public final int end; + + /** The token type that determines color, priority, and style. */ + public final TokenType type; + + /** + * Optional metadata attached by the analysis pipeline. + * May be {@link noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo}, + * {@link noppes.npcs.client.gui.util.script.interpreter.method.MethodCallInfo}, + * {@link noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo}, + * {@link noppes.npcs.client.gui.util.script.interpreter.type.ImportData}, + * {@link noppes.npcs.client.gui.util.script.interpreter.token.TokenErrorMessage}, + * or any other analysis artifact. Null when no metadata is available. + */ + public final Object metadata; + + /** + * Create a mark with no metadata (pure syntax mark). + * + * @param start byte offset where this mark begins (inclusive) + * @param end byte offset where this mark ends (exclusive) + * @param type the token type for coloring and priority + */ + public Mark(int start, int end, TokenType type) { + this(start, end, type, null); + } + + /** + * Create a mark with metadata (semantic or diagnostic mark). + * + * @param start byte offset where this mark begins (inclusive) + * @param end byte offset where this mark ends (exclusive) + * @param type the token type for coloring and priority + * @param metadata optional analysis metadata, may be null + */ + public Mark(int start, int end, TokenType type, Object metadata) { + this.start = start; + this.end = end; + this.type = type; + this.metadata = metadata; + } + + // ==================== FACTORY METHODS ==================== + + /** + * Create a syntax-only mark (no metadata). + * + * @param start byte offset where this mark begins (inclusive) + * @param end byte offset where this mark ends (exclusive) + * @param type the token type for coloring and priority + * @return a new Mark with no metadata + */ + public static Mark syntax(int start, int end, TokenType type) { + return new Mark(start, end, type, null); + } + + /** + * Create a semantic mark with attached metadata. + * + * @param start byte offset where this mark begins (inclusive) + * @param end byte offset where this mark ends (exclusive) + * @param type the token type for coloring and priority + * @param metadata analysis metadata (TypeInfo, MethodCallInfo, etc.) + * @return a new Mark with the given metadata + */ + public static Mark semantic(int start, int end, TokenType type, Object metadata) { + return new Mark(start, end, type, metadata); + } + + // ==================== QUERIES ==================== + + /** + * Check whether this mark's range overlaps with the given range. + * + * @param otherStart start of the other range (inclusive) + * @param otherEnd end of the other range (exclusive) + * @return true if the ranges overlap + */ + public boolean overlaps(int otherStart, int otherEnd) { + return this.start < otherEnd && this.end > otherStart; + } + + /** + * Get the length of this mark in bytes. + * + * @return end - start + */ + public int length() { + return end - start; + } + + /** + * Check whether this mark carries metadata. + * + * @return true if metadata is non-null + */ + public boolean hasMetadata() { + return metadata != null; + } + + // ==================== Comparable ==================== + + /** + * Sort marks by start position ascending, then by span length descending + * (longest first), then by priority descending (highest first). + * This ordering ensures that when two marks start at the same position, + * the one covering more text (or with higher priority) is processed first. + */ + @Override + public int compareTo(Mark other) { + // Primary: start position ascending + int cmp = Integer.compare(this.start, other.start); + if (cmp != 0) return cmp; + + // Secondary: span length descending (longest first) + cmp = Integer.compare(other.length(), this.length()); + if (cmp != 0) return cmp; + + // Tertiary: priority descending (highest first) + return Integer.compare(other.type.getPriority(), this.type.getPriority()); + } + + // ==================== equals / hashCode ==================== + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof Mark)) return false; + Mark other = (Mark) obj; + return this.start == other.start + && this.end == other.end + && this.type == other.type; + } + + @Override + public int hashCode() { + int result = start; + result = 31 * result + end; + result = 31 * result + type.hashCode(); + return result; + } + + // ==================== toString ==================== + + @Override + public String toString() { + return "Mark{" + type + " [" + start + "-" + end + "]" + + (metadata != null ? " " + metadata.getClass().getSimpleName() : "") + + "}"; + } +} diff --git a/src/main/java/bigguy/texteditor/render/MarkLayer.java b/src/main/java/bigguy/texteditor/render/MarkLayer.java new file mode 100644 index 000000000..b33cdd214 --- /dev/null +++ b/src/main/java/bigguy/texteditor/render/MarkLayer.java @@ -0,0 +1,222 @@ +package bigguy.texteditor.render; + +import noppes.npcs.client.gui.util.script.interpreter.token.TokenType; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; +import java.util.IdentityHashMap; +import java.util.List; +import java.util.Set; + +/** + * Merges three independent mark sources — syntax, semantic, and error — into + * a single non-overlapping list resolved by {@link TokenType#getPriority()}. + * + *

Thread safety: syntax marks are set from the UI thread while semantic marks + * arrive from a background analysis thread. All mutators are synchronized; + * {@link #merge()} produces a snapshot safe for the caller to iterate without + * holding the lock. + * + *

A monotonically increasing {@link #getRevision() revision} counter lets + * consumers detect stale merge results cheaply. + */ +public class MarkLayer { + + private List syntaxMarks = Collections.emptyList(); + private List semanticMarks = Collections.emptyList(); + private List errorMarks = Collections.emptyList(); + private volatile int revision; + + /** + * Replace the syntax mark layer (produced by tree-sitter highlight queries). + * + * @param marks new syntax marks; must not be null + */ + public synchronized void setSyntaxMarks(List marks) { + this.syntaxMarks = new ArrayList<>(marks); + revision++; + } + + /** + * Replace the semantic mark layer (produced by type resolution / scope analysis). + * Typically called from a background thread. + * + * @param marks new semantic marks; must not be null + */ + public synchronized void setSemanticMarks(List marks) { + this.semanticMarks = new ArrayList<>(marks); + revision++; + } + + /** + * Replace the error mark layer (diagnostic underlines). + * Error marks do not participate in color conflict resolution — + * they are kept in a separate channel and drawn as underlines. + * + * @param marks new error marks; must not be null + */ + public synchronized void setErrorMarks(List marks) { + this.errorMarks = new ArrayList<>(marks); + revision++; + } + + /** @return the current syntax marks (defensive copy) */ + public synchronized List getSyntaxMarks() { + return new ArrayList<>(syntaxMarks); + } + + /** @return the current semantic marks (defensive copy) */ + public synchronized List getSemanticMarks() { + return new ArrayList<>(semanticMarks); + } + + /** + * Error marks are kept in their own channel and drawn as underlines + * rather than merged into the color layer. + * + * @return the current error marks (defensive copy) + */ + public synchronized List getErrorMarks() { + return new ArrayList<>(errorMarks); + } + + /** + * Monotonically increasing counter that increments on every mutation. + * Compare against a cached value to detect stale merge results. + * + * @return current revision + */ + public int getRevision() { + return revision; + } + + /** + * Merge syntax and semantic marks into a single non-overlapping list. + * Error marks are NOT included — they live in a separate rendering channel. + * + *

Algorithm: + *

    + *
  1. Combine syntax + semantic marks and sort by start position
  2. + *
  3. Walk left-to-right through a "sweep line" over every boundary point
  4. + *
  5. At each boundary, the active mark with the highest + * {@link TokenType#getPriority()} wins
  6. + *
  7. Semantic marks override syntax marks for the same range + * (semantic priority is typically equal or higher)
  8. + *
  9. Output non-overlapping marks sorted by start position
  10. + *
+ * + * @return merged, non-overlapping mark list (safe to iterate without synchronization) + */ + public List merge() { + List syntax; + List semantic; + synchronized (this) { + syntax = new ArrayList<>(syntaxMarks); + semantic = new ArrayList<>(semanticMarks); + } + + if (syntax.isEmpty() && semantic.isEmpty()) { + return Collections.emptyList(); + } + + // Build identity set for O(1) semantic membership checks + Set semanticSet = Collections.newSetFromMap(new IdentityHashMap<>()); + semanticSet.addAll(semantic); + + // Collect all boundary points + List boundaries = new ArrayList<>(); + for (Mark m : syntax) { + boundaries.add(m.start); + boundaries.add(m.end); + } + for (Mark m : semantic) { + boundaries.add(m.start); + boundaries.add(m.end); + } + Collections.sort(boundaries); + // Deduplicate + List uniqueBoundaries = new ArrayList<>(); + for (int i = 0; i < boundaries.size(); i++) { + if (i == 0 || !boundaries.get(i).equals(boundaries.get(i - 1))) { + uniqueBoundaries.add(boundaries.get(i)); + } + } + + List combined = new ArrayList<>(syntax.size() + semantic.size()); + combined.addAll(syntax); + combined.addAll(semantic); + + List result = new ArrayList<>(); + + // For each interval between consecutive boundaries, find the winning mark + for (int i = 0; i < uniqueBoundaries.size() - 1; i++) { + int intervalStart = uniqueBoundaries.get(i); + int intervalEnd = uniqueBoundaries.get(i + 1); + if (intervalStart >= intervalEnd) { + continue; + } + + Mark winner = null; + boolean winnerIsSemantic = false; + + for (Mark m : combined) { + // Mark must fully cover this interval to be a candidate + if (m.start > intervalStart || m.end < intervalEnd) { + continue; + } + + if (m.start <= intervalStart && m.end >= intervalEnd) { + boolean isSemantic = semanticSet.contains(m); + + if (winner == null) { + winner = m; + winnerIsSemantic = isSemantic; + } else if (isSemantic && !winnerIsSemantic) { + // Semantic always overrides syntax for same range + winner = m; + winnerIsSemantic = true; + } else if (isSemantic == winnerIsSemantic) { + // Same source layer: higher priority wins + if (m.type.getPriority() > winner.type.getPriority()) { + winner = m; + } + } + } + } + + if (winner != null) { + // Try to merge with previous result if same type and metadata and adjacent + if (!result.isEmpty()) { + Mark prev = result.get(result.size() - 1); + if (prev.end == intervalStart + && prev.type == winner.type + && prev.metadata == winner.metadata) { + result.set(result.size() - 1, + new Mark(prev.start, intervalEnd, prev.type, prev.metadata)); + continue; + } + } + result.add(new Mark(intervalStart, intervalEnd, winner.type, winner.metadata)); + } + } + + return result; + } + + /** Remove all marks from every layer and increment the revision. */ + public synchronized void clear() { + syntaxMarks = Collections.emptyList(); + semanticMarks = Collections.emptyList(); + errorMarks = Collections.emptyList(); + revision++; + } + + @Override + public String toString() { + return "MarkLayer{syntax=" + syntaxMarks.size() + + ", semantic=" + semanticMarks.size() + + ", error=" + errorMarks.size() + + ", rev=" + revision + "}"; + } +} diff --git a/src/main/java/bigguy/texteditor/render/RenderLine.java b/src/main/java/bigguy/texteditor/render/RenderLine.java new file mode 100644 index 000000000..9494eb70f --- /dev/null +++ b/src/main/java/bigguy/texteditor/render/RenderLine.java @@ -0,0 +1,486 @@ +package bigguy.texteditor.render; + +import noppes.npcs.client.ClientProxy; +import noppes.npcs.client.gui.util.script.interpreter.token.Token; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenType; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenErrorMessage; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.ImportData; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldAccessInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodCallInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.TypeParamInfo; +import noppes.npcs.client.gui.util.script.interpreter.ErrorUnderlineRenderer; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.function.Predicate; + +/** + * The main text renderer for a single line of source code. + * Replaces {@code ScriptLine} with a decoupled design: no back-reference to + * {@code ScriptDocument}, no doubly-linked list navigation. + * + *

Rendering flows through two paths: + *

    + *
  • {@link #drawStringHex(int, int)} — primary hex-color renderer + * using {@link ClientProxy.Font#drawString(String, int, int, int)}
  • + *
  • {@link #drawString(int, int, int)} — legacy Minecraft color-code renderer
  • + *
+ * + *

Tokens are immutable after {@link #buildTokensFromMarks(List, String)} completes. + * Error underlines are drawn via caller-supplied {@link DiagnosticRange} records + * rather than reaching back into a document object. + */ +public class RenderLine { + + private static final char COLOR_CHAR = '\u00A7'; + + private final String text; + private final int globalStart; + private final int globalEnd; + private final int lineIndex; + + private final List tokens = new ArrayList<>(); + private final List indentGuides = new ArrayList<>(); + + /** + * A lightweight descriptor for a single error underline region. + * Provided by the orchestrator/RenderModel so that RenderLine never + * queries a document object. + */ + public static final class DiagnosticRange { + /** Global byte offset where the error starts (inclusive). */ + public final int start; + /** Global byte offset where the error ends (exclusive). */ + public final int end; + /** ARGB color for the wavy underline. */ + public final int color; + + /** + * @param start global start offset (inclusive) + * @param end global end offset (exclusive) + * @param color ARGB underline color + */ + public DiagnosticRange(int start, int end, int color) { + this.start = start; + this.end = end; + this.color = color; + } + } + + /** + * @param text the raw text content of this line (no trailing newline) + * @param globalStart byte offset in the full document where this line begins + * @param globalEnd byte offset in the full document where this line ends (exclusive, includes newline position) + * @param lineIndex 0-based line number + */ + public RenderLine(String text, int globalStart, int globalEnd, int lineIndex) { + this.text = text; + this.globalStart = globalStart; + this.globalEnd = globalEnd; + this.lineIndex = lineIndex; + } + + // ==================== GETTERS ==================== + + /** Raw text content of this line (no trailing newline). */ + public String getText() { return text; } + + /** Byte offset in the full document where this line begins. */ + public int getGlobalStart() { return globalStart; } + + /** Byte offset in the full document where this line ends (exclusive). */ + public int getGlobalEnd() { return globalEnd; } + + /** 0-based line number. */ + public int getLineIndex() { return lineIndex; } + + /** Character count of the line text. */ + public int getLength() { return text.length(); } + + /** Unmodifiable view of the tokens on this line. */ + public List getTokens() { return Collections.unmodifiableList(tokens); } + + /** Unmodifiable view of indent guide column positions. */ + public List getIndentGuides() { return Collections.unmodifiableList(indentGuides); } + + // ==================== TOKEN QUERIES ==================== + + /** + * Find the token that contains the given global position. + * + * @param globalPosition byte offset in the full document + * @return the token at that position, or null if none + */ + public Token getTokenAt(int globalPosition) { + for (Token t : tokens) { + if (globalPosition >= t.getGlobalStart() && globalPosition <= t.getGlobalEnd()) { + return t; + } + } + return null; + } + + /** + * Find the token at a global position that also satisfies a predicate. + * + * @param globalPosition byte offset in the full document + * @param condition additional filter + * @return the matching token, or null + */ + public Token getTokenAt(int globalPosition, Predicate condition) { + for (Token t : tokens) { + if (globalPosition >= t.getGlobalStart() && globalPosition <= t.getGlobalEnd() + && condition.test(t)) { + return t; + } + } + return null; + } + + /** @return the first token on this line, or null if the line has no tokens */ + public Token getFirstToken() { + return tokens.isEmpty() ? null : tokens.get(0); + } + + /** @return the last token on this line, or null if the line has no tokens */ + public Token getLastToken() { + return tokens.isEmpty() ? null : tokens.get(tokens.size() - 1); + } + + // ==================== POSITION UTILITIES ==================== + + /** + * Check if a global position falls within this line's range. + * + * @param globalPosition byte offset in the full document + * @return true if {@code globalStart <= globalPosition < globalEnd} + */ + public boolean containsPosition(int globalPosition) { + return globalPosition >= globalStart && globalPosition < globalEnd; + } + + /** + * Convert a global position to a local column offset within this line. + * + * @param globalPosition byte offset in the full document + * @return clamped column in {@code [0, text.length()]} + */ + public int toColumn(int globalPosition) { + return Math.max(0, Math.min(globalPosition - globalStart, text.length())); + } + + /** + * Convert a local column offset to a global position. + * + * @param column local offset within this line + * @return global byte offset + */ + public int toGlobal(int column) { + return globalStart + Math.max(0, Math.min(column, text.length())); + } + + // ==================== TOKEN BUILDING ==================== + + /** + * Build tokens from a list of marks (highlight regions). + * Fills gaps between marks with {@link TokenType#DEFAULT} tokens. + * Attaches metadata from marks to the created tokens. + * + *

This is the decoupled replacement for + * {@code ScriptLine.buildTokensFromMarks(marks, fullText, document)}. + * No ScriptDocument parameter — removes the coupling. + * + * @param marks list of highlight marks that overlap this line, sorted by start position + * @param fullText the complete document text + */ + public void buildTokensFromMarks(List marks, String fullText) { + tokens.clear(); + int cursor = globalStart; + + /* + * globalEnd includes the newline character position + * (lineEnd = lineStart + text.length() + 1), but the line's text field + * does NOT include the newline. Clamp all token boundaries to the + * displayable text end so that '\n' never leaks into rendered token text. + */ + int displayEnd = Math.min(globalStart + text.length(), fullText.length()); + + for (Mark mark : marks) { + if (mark.end <= globalStart || mark.start >= displayEnd) { + continue; + } + + int tokenStart = Math.max(mark.start, globalStart); + int tokenEnd = Math.min(mark.end, displayEnd); + + tokenStart = Math.max(0, Math.min(tokenStart, fullText.length())); + tokenEnd = Math.max(0, Math.min(tokenEnd, fullText.length())); + + if (cursor < tokenStart) { + int gapEnd = Math.min(tokenStart, fullText.length()); + String gapText = fullText.substring(cursor, gapEnd); + addToken(Token.defaultToken(gapText, cursor, gapEnd)); + } + + if (tokenStart < tokenEnd) { + String tokenText = fullText.substring(tokenStart, tokenEnd); + Token token = new Token(tokenText, tokenStart, tokenEnd, mark.type); + + if (mark.metadata != null) { + applyTokenMetadata(token, mark.metadata); + } + + addToken(token); + } + + cursor = tokenEnd; + } + + if (cursor < displayEnd) { + String trailingText = fullText.substring(cursor, displayEnd); + addToken(Token.defaultToken(trailingText, cursor, displayEnd)); + } + } + + /** + * Apply analysis metadata to a token based on the metadata's runtime type. + * Handles TypeInfo, TypeParamInfo, MethodCallInfo, FieldInfo.ArgInfo, + * FieldInfo, MethodInfo, ImportData, FieldAccessInfo, and TokenErrorMessage. + * + * @param token the token to enrich + * @param metadata the analysis artifact + */ + public void applyTokenMetadata(Token token, Object metadata) { + if (metadata instanceof TypeInfo) { + token.setTypeInfo((TypeInfo) metadata); + } else if (metadata instanceof TypeParamInfo) { + TypeParamInfo typeParam = (TypeParamInfo) metadata; + token.setTypeInfo(TypeInfo.typeParameter(typeParam.getName(), typeParam)); + } else if (metadata instanceof MethodCallInfo) { + MethodCallInfo callInfo = (MethodCallInfo) metadata; + if (callInfo.isConstructor()) { + token.setTypeInfo(callInfo.getReceiverType()); + token.setMethodInfo(callInfo.getResolvedMethod()); + } + token.setMethodCallInfo(callInfo); + } else if (metadata instanceof FieldInfo.ArgInfo) { + FieldInfo.ArgInfo ctx = (FieldInfo.ArgInfo) metadata; + token.setFieldInfo(ctx.fieldInfo); + token.setMethodCallInfo(ctx.methodCallInfo); + } else if (metadata instanceof FieldInfo) { + token.setFieldInfo((FieldInfo) metadata); + } else if (metadata instanceof MethodInfo) { + token.setMethodInfo((MethodInfo) metadata); + } else if (metadata instanceof ImportData) { + token.setImportData((ImportData) metadata); + } else if (metadata instanceof FieldAccessInfo) { + FieldAccessInfo accessInfo = (FieldAccessInfo) metadata; + token.setFieldAccessInfo(accessInfo); + token.setFieldInfo(accessInfo.getResolvedField()); + } else if (metadata instanceof TokenErrorMessage) { + token.setErrorMessage((TokenErrorMessage) metadata); + } + } + + /** + * Add a token to this line and wire up intra-line navigation links. + */ + private void addToken(Token token) { + if (!tokens.isEmpty()) { + Token last = tokens.get(tokens.size() - 1); + last.setNext(token); + token.setPrev(last); + } + token.setParentLine(null); + tokens.add(token); + } + + // ==================== INDENT GUIDES ==================== + + /** Remove all indent guides from this line. */ + public void clearIndentGuides() { + indentGuides.clear(); + } + + /** + * Add an indent guide at the specified column if not already present. + * + * @param column the column position for the guide + */ + public void addIndentGuide(int column) { + if (!indentGuides.contains(column)) { + indentGuides.add(column); + } + } + + // ==================== RENDERING ==================== + + /** + * Compute the rendered pixel width of a substring of this line, accounting for + * bold/italic token styles. Characters covered by bold or italic tokens are + * measured with the appropriate font style via + * {@link ClientProxy.Font#width(String, int)}, producing the same widths as the + * actual rendered output. + * + *

Critical for cursor positioning and error underline alignment. + * + * @param localStart start index within the line text (inclusive) + * @param localEnd end index within the line text (exclusive) + * @return pixel width matching the rendered output + */ + public int getRenderedWidth(int localStart, int localEnd) { + localStart = Math.max(0, Math.min(localStart, text.length())); + localEnd = Math.max(localStart, Math.min(localEnd, text.length())); + if (localStart >= localEnd) return 0; + + int width = 0; + int cursor = localStart; + + for (Token t : tokens) { + if (cursor >= localEnd) break; + + int tokenLocalStart = t.getGlobalStart() - globalStart; + int tokenLocalEnd = tokenLocalStart + t.getText().length(); + + // Gap before this token (rendered as plain text) + if (cursor < tokenLocalStart) { + int gapEnd = Math.min(tokenLocalStart, localEnd); + if (gapEnd > cursor) { + width += ClientProxy.Font.width(text.substring(cursor, gapEnd)); + cursor = gapEnd; + } + } + + if (cursor >= localEnd) break; + + // Token overlap with [localStart, localEnd) + int overlapStart = Math.max(cursor, tokenLocalStart); + int overlapEnd = Math.min(tokenLocalEnd, localEnd); + if (overlapEnd > overlapStart) { + String substr = text.substring(overlapStart, overlapEnd); + width += ClientProxy.Font.width(substr, t.getFontStyle()); + cursor = overlapEnd; + } + } + + // Trailing text after last token (plain) + if (cursor < localEnd) { + width += ClientProxy.Font.width(text.substring(cursor, localEnd)); + } + + return width; + } + + /** + * Draw this line with hex colors. THE PRIMARY RENDERER. + * Builds {@link RenderSegment}s from the token list, then renders each one + * at the correct pixel offset via + * {@link ClientProxy.Font#drawString(String, int, int, int)}. + * + *

Does NOT draw error underlines — call + * {@link #drawErrorUnderlines(int, int, List)} separately with + * caller-supplied diagnostics. + * + * @param x left pixel coordinate + * @param y top pixel coordinate + */ + public void drawStringHex(int x, int y) { + int lastIndex = 0; + List segments = new ArrayList<>(); + + for (Token t : tokens) { + int tokenStart = t.getGlobalStart() - globalStart; + + if (tokenStart > lastIndex && tokenStart <= text.length()) { + String gap = text.substring(lastIndex, tokenStart); + segments.add(new RenderSegment(lastIndex, gap, 0xFFFFFFFF, false)); + } + + String styledText = t.getStylePrefix() + t.getText(); + segments.add(new RenderSegment(tokenStart, styledText, t.getHexColor(), true)); + + lastIndex = tokenStart + t.getText().length(); + } + + if (lastIndex < text.length()) { + String remaining = text.substring(lastIndex); + segments.add(new RenderSegment(lastIndex, remaining, 0xFFFFFFFF, false)); + } + + for (RenderSegment seg : segments) { + if (!seg.text.isEmpty()) { + int prefixWidth = getRenderedWidth(0, seg.startPosition); + ClientProxy.Font.drawString(seg.text, x + prefixWidth, y, seg.hexColor); + } + } + } + + /** + * Draw this line with legacy Minecraft color codes. + * Backup rendering path that uses §-prefixed color codes. + * Also draws error underlines via the supplied diagnostic list. + * + * @param x left pixel coordinate + * @param y top pixel coordinate + * @param defaultColor fallback color for non-token text + */ + public void drawString(int x, int y, int defaultColor) { + StringBuilder builder = new StringBuilder(); + int lastIndex = 0; + + for (Token t : tokens) { + int tokenStart = t.getGlobalStart() - globalStart; + + if (tokenStart > lastIndex && tokenStart <= text.length()) { + String gapText = text.substring(lastIndex, tokenStart); + builder.append(gapText); + } + + String stylePrefix = t.getStylePrefix(); + builder.append(COLOR_CHAR) + .append(t.getColorCode()) + .append(stylePrefix) + .append(t.getText()) + .append(COLOR_CHAR) + .append('r'); + + lastIndex = tokenStart + t.getText().length(); + } + + if (lastIndex < text.length()) { + builder.append(text.substring(lastIndex)); + } + + ClientProxy.Font.drawString(builder.toString(), x, y, defaultColor); + } + + /** + * Draw wavy error underlines for all diagnostic ranges that intersect this line. + * Replaces the old {@code ScriptLine.drawErrorUnderlines()} that reached + * into {@code ScriptDocument} — this version receives diagnostics as arguments. + * + * @param lineStartX left pixel coordinate where the line starts rendering + * @param baselineY Y coordinate for the underline (typically {@code y + fontHeight - 1}) + * @param errors diagnostic ranges to underline; may be empty but not null + */ + public void drawErrorUnderlines(int lineStartX, int baselineY, List errors) { + for (DiagnosticRange diag : errors) { + ErrorUnderlineRenderer.drawUnderlineForSpan( + diag.start, diag.end, + lineStartX, baselineY, + text, globalStart, globalEnd, + diag.color + ); + } + } + + @Override + public String toString() { + return "RenderLine{" + lineIndex + ": '" + text + "' [" + globalStart + "-" + globalEnd + + "], " + tokens.size() + " tokens}"; + } +} diff --git a/src/main/java/bigguy/texteditor/render/RenderModel.java b/src/main/java/bigguy/texteditor/render/RenderModel.java new file mode 100644 index 000000000..839a359ec --- /dev/null +++ b/src/main/java/bigguy/texteditor/render/RenderModel.java @@ -0,0 +1,269 @@ +package bigguy.texteditor.render; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +/** + * Layout manager that owns the flat list of {@link RenderLine}s and provides + * viewport calculations for scrolled rendering. + * + *

Replaces the layout fields previously scattered across {@code ScriptDocument}: + * {@code lineHeight}, {@code totalHeight}, {@code visibleLines}, {@code linesCount}. + * + *

Thread safety: the {@code lines} reference is volatile so that a background + * rebuild can publish a new list that the render thread picks up on the next frame. + * Individual reads through the accessors are safe without external synchronization. + */ +public class RenderModel { + + private volatile List lines = Collections.emptyList(); + private volatile int lineHeight = 10; + + // ==================== LINE ACCESS ==================== + + /** + * @return total number of render lines + */ + public int getLineCount() { + return lines.size(); + } + + /** + * @return total pixel height of all lines ({@code lineCount * lineHeight}) + */ + public int getTotalHeight() { + return lines.size() * lineHeight; + } + + /** + * Compute how many lines fit in the given viewport height. + * + * @param viewportHeight pixel height of the visible area + * @return number of fully visible lines + */ + public int getVisibleLineCount(int viewportHeight) { + return lineHeight > 0 ? viewportHeight / lineHeight : 0; + } + + /** + * Bounds-checked access to a single render line. + * + * @param index 0-based line index + * @return the RenderLine at the given index + * @throws IndexOutOfBoundsException if index is out of range + */ + public RenderLine getLine(int index) { + return lines.get(index); + } + + /** + * Get the sub-list of lines visible for the current scroll position. + * + * @param scrollOffset pixel offset from the top of the document + * @param viewportHeight pixel height of the visible area + * @return unmodifiable sublist of visible lines (may be empty) + */ + public List getVisibleLines(int scrollOffset, int viewportHeight) { + List snapshot = lines; + if (snapshot.isEmpty() || lineHeight <= 0) { + return Collections.emptyList(); + } + + int firstLine = Math.max(0, scrollOffset / lineHeight); + int visibleCount = (viewportHeight / lineHeight) + 2; + int lastLine = Math.min(snapshot.size(), firstLine + visibleCount); + + if (firstLine >= snapshot.size()) { + return Collections.emptyList(); + } + + return Collections.unmodifiableList(snapshot.subList(firstLine, lastLine)); + } + + /** + * Find the line that contains the given global byte offset using binary search. + * + * @param globalOffset byte offset in the full document + * @return the RenderLine containing that offset, or null if not found + */ + public RenderLine getLineAtOffset(int globalOffset) { + List snapshot = lines; + int idx = getLineIndexForOffset(globalOffset); + if (idx >= 0 && idx < snapshot.size()) { + return snapshot.get(idx); + } + return null; + } + + /** + * Binary search for the line index containing the given global byte offset. + * + * @param offset byte offset in the full document + * @return 0-based line index, or -1 if no line contains the offset + */ + public int getLineIndexForOffset(int offset) { + List snapshot = lines; + int lo = 0; + int hi = snapshot.size() - 1; + + while (lo <= hi) { + int mid = (lo + hi) >>> 1; + RenderLine line = snapshot.get(mid); + + if (offset < line.getGlobalStart()) { + hi = mid - 1; + } else if (offset >= line.getGlobalEnd()) { + lo = mid + 1; + } else { + return mid; + } + } + + return -1; + } + + /** + * @return unmodifiable view of all render lines + */ + public List getLines() { + return Collections.unmodifiableList(lines); + } + + /** + * @return current pixel height per line + */ + public int getLineHeight() { + return lineHeight; + } + + /** + * @param lineHeight new pixel height per line + */ + public void setLineHeight(int lineHeight) { + this.lineHeight = lineHeight; + } + + // ==================== REBUILD ==================== + + /** + * Rebuild the entire line model from source text and merged marks. + * + *

    + *
  1. Splits {@code sourceText} by newlines into logical lines
  2. + *
  3. Creates a {@link RenderLine} for each with correct + * globalStart/globalEnd/lineIndex
  4. + *
  5. Calls {@link RenderLine#buildTokensFromMarks(List, String)} + * with the marks that overlap each line
  6. + *
  7. Computes indent guides per line
  8. + *
+ * + * @param sourceText the complete document text + * @param mergedMarks merged marks from {@link MarkLayer#merge()}, sorted by start + * @param lineHeight pixel height per line + */ + public void rebuild(String sourceText, List mergedMarks, int lineHeight) { + this.lineHeight = lineHeight; + + List newLines = new ArrayList<>(); + + if (sourceText.isEmpty()) { + RenderLine empty = new RenderLine("", 0, 0, 0); + empty.buildTokensFromMarks(Collections.emptyList(), sourceText); + newLines.add(empty); + this.lines = newLines; + return; + } + + int lineIdx = 0; + int pos = 0; + int textLen = sourceText.length(); + + while (pos <= textLen) { + int nlPos = sourceText.indexOf('\n', pos); + int lineEnd; + int globalEnd; + + if (nlPos == -1) { + lineEnd = textLen; + globalEnd = textLen; + } else { + lineEnd = nlPos; + globalEnd = nlPos + 1; + } + + String lineText = sourceText.substring(pos, lineEnd); + RenderLine renderLine = new RenderLine(lineText, pos, globalEnd, lineIdx); + + List lineMarks = collectMarksForRange(mergedMarks, pos, globalEnd); + renderLine.buildTokensFromMarks(lineMarks, sourceText); + + computeIndentGuides(renderLine, lineText); + + newLines.add(renderLine); + lineIdx++; + + if (nlPos == -1) { + break; + } + pos = nlPos + 1; + + if (pos == textLen) { + RenderLine trailing = new RenderLine("", pos, pos, lineIdx); + trailing.buildTokensFromMarks(Collections.emptyList(), sourceText); + newLines.add(trailing); + break; + } + } + + this.lines = newLines; + } + + /** + * Collect marks that overlap the range {@code [rangeStart, rangeEnd)}. + * Assumes {@code allMarks} is sorted by start position and uses a linear scan + * with early exit. + */ + private static List collectMarksForRange(List allMarks, int rangeStart, int rangeEnd) { + List result = new ArrayList<>(); + for (Mark m : allMarks) { + if (m.start >= rangeEnd) { + break; + } + if (m.end > rangeStart) { + result.add(m); + } + } + return result; + } + + /** + * Compute indent guides for a line based on its leading whitespace. + * Adds a guide at each tab-stop column (every 4 characters) within the indentation. + */ + private static void computeIndentGuides(RenderLine line, String text) { + int indent = 0; + for (int i = 0; i < text.length(); i++) { + char c = text.charAt(i); + if (c == ' ') { + indent++; + } else if (c == '\t') { + indent = ((indent / 4) + 1) * 4; + } else { + break; + } + } + + int tabSize = 4; + for (int col = tabSize; col <= indent; col += tabSize) { + line.addIndentGuide(col); + } + } + + @Override + public String toString() { + return "RenderModel{lines=" + lines.size() + + ", lineHeight=" + lineHeight + + ", totalHeight=" + getTotalHeight() + "}"; + } +} diff --git a/src/main/java/bigguy/texteditor/render/RenderSegment.java b/src/main/java/bigguy/texteditor/render/RenderSegment.java new file mode 100644 index 000000000..32a8655e7 --- /dev/null +++ b/src/main/java/bigguy/texteditor/render/RenderSegment.java @@ -0,0 +1,46 @@ +package bigguy.texteditor.render; + +/** + * An individual renderable text chunk within a {@link RenderLine}. + * Each segment represents either a styled token or an unstyled gap between tokens. + * + *

Immutable value type consumed during {@link RenderLine#drawStringHex(int, int)} + * rendering. Segments are built on each draw call from the line's token list and + * are not cached. + */ +public final class RenderSegment { + + /** Local offset within the line text where this segment starts. */ + public final int startPosition; + + /** The displayable text content (may include style prefix codes for tokens). */ + public final String text; + + /** ARGB hex color for rendering (e.g. 0xFFFF5555 for red). */ + public final int hexColor; + + /** True if this segment was produced from a Token; false for gap/trailing text. */ + public final boolean isToken; + + /** + * @param startPosition local offset within the line text + * @param text displayable text content + * @param hexColor ARGB hex color + * @param isToken true when this segment originates from a Token + */ + public RenderSegment(int startPosition, String text, int hexColor, boolean isToken) { + this.startPosition = startPosition; + this.text = text; + this.hexColor = hexColor; + this.isToken = isToken; + } + + @Override + public String toString() { + return "RenderSegment{pos=" + startPosition + + ", text='" + text + "'" + + ", color=0x" + Integer.toHexString(hexColor) + + (isToken ? ", token" : ", gap") + + "}"; + } +} diff --git a/src/main/java/bigguy/texteditor/semantics/ImportIndex.java b/src/main/java/bigguy/texteditor/semantics/ImportIndex.java new file mode 100644 index 000000000..a963ea7c7 --- /dev/null +++ b/src/main/java/bigguy/texteditor/semantics/ImportIndex.java @@ -0,0 +1,530 @@ +package bigguy.texteditor.semantics; + +import bigguy.texteditor.treesitter.java.TextSpan; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; + +/** + * Unified import resolution index for a single script document. + * + *

Replaces the four separate import-tracking fields that previously lived in + * {@code ScriptDocument} ({@code imports}, {@code wildcardPackages}, + * {@code importsBySimpleName}, {@code implicitImports}) with a single source of + * truth backed by a list of {@link ImportEntry} objects.

+ * + *

Lazy derived indexes

+ *

Two derived lookup maps ({@code bySimpleName} and {@code byFullPath}) are + * computed lazily on first access after any mutation, and cached until the next + * mutation invalidates them. This gives O(1) lookups without paying rebuild + * cost on every add.

+ * + *

Version tracking

+ *

A monotonically increasing version counter is bumped on every mutation. + * External code can call {@link #version()} to detect whether the index has + * changed since its last snapshot.

+ * + *

Thread safety

+ *

All mutation methods are {@code synchronized}. All query methods return + * defensive copies or unmodifiable snapshots, so callers never observe + * partially-mutated state.

+ * + * @since Phase 2 — CST editor architecture + */ +public final class ImportIndex { + + // ── Primary store ────────────────────────────────────────────────── + + /** The authoritative list of all import entries (explicit + implicit). */ + private final List entries; + + // ── Derived indexes (lazily rebuilt) ──────────────────────────────── + + /** Quick lookup by unqualified simple name (e.g. "List" → entry). */ + private Map bySimpleName; + + /** Quick lookup by fully qualified path (e.g. "java.util.List" → entry). */ + private Map byFullPath; + + /** Whether the derived indexes need rebuilding. */ + private boolean dirty; + + /** Monotonically increasing version counter, bumped on every mutation. */ + private int version; + + // ── Construction ─────────────────────────────────────────────────── + + /** + * Creates a new, empty {@code ImportIndex}. + */ + public ImportIndex() { + this.entries = new ArrayList(); + this.bySimpleName = Collections.emptyMap(); + this.byFullPath = Collections.emptyMap(); + this.dirty = false; + this.version = 0; + } + + // ── Inner class ──────────────────────────────────────────────────── + + /** + * An individual import declaration (explicit or implicit). + * + *

Instances are immutable. Two entries are equal if and only if they + * share the same {@code fullPath} and {@code isImplicit} flag — the + * source range is deliberately excluded from equality so that + * re-parsing the same import at a different offset does not produce + * a spurious "changed" signal.

+ */ + public static final class ImportEntry { + + private final String fullPath; + private final String simpleName; + private final boolean isWildcard; + private final boolean isStatic; + private final boolean isImplicit; + private final TextSpan range; + private final String packagePath; + + /** + * Creates a new {@code ImportEntry}. + * + * @param fullPath the fully qualified import path, e.g. {@code "java.util.List"} + * or {@code "java.util.*"} + * @param simpleName the unqualified name, e.g. {@code "List"} or {@code "*"} + * @param isWildcard {@code true} for wildcard imports ({@code import pkg.*}) + * @param isStatic {@code true} for static imports ({@code import static ...}) + * @param isImplicit {@code true} for auto-injected imports (e.g. {@code java.lang.*}) + * @param range source location of the import statement; may be {@code null} + * for implicit imports + * @param packagePath the package portion, e.g. {@code "java.util"} + */ + public ImportEntry(String fullPath, String simpleName, boolean isWildcard, + boolean isStatic, boolean isImplicit, TextSpan range, + String packagePath) { + if (fullPath == null) { + throw new IllegalArgumentException("fullPath must not be null"); + } + if (simpleName == null) { + throw new IllegalArgumentException("simpleName must not be null"); + } + if (packagePath == null) { + throw new IllegalArgumentException("packagePath must not be null"); + } + this.fullPath = fullPath; + this.simpleName = simpleName; + this.isWildcard = isWildcard; + this.isStatic = isStatic; + this.isImplicit = isImplicit; + this.range = range; + this.packagePath = packagePath; + } + + /** + * Factory for creating an {@code ImportEntry} from a fully qualified path string. + * + *

Automatically derives {@code simpleName}, {@code isWildcard}, and + * {@code packagePath} from the path.

+ * + * @param fullPath the fully qualified import path + * @param isStatic whether this is a static import + * @param isImplicit whether this is an implicit (auto-injected) import + * @param range source location, or {@code null} for implicit imports + * @return a new {@code ImportEntry} + */ + public static ImportEntry fromFullPath(String fullPath, boolean isStatic, + boolean isImplicit, TextSpan range) { + boolean isWildcard = fullPath.endsWith(".*"); + String simpleName; + String packagePath; + int lastDot = fullPath.lastIndexOf('.'); + if (lastDot >= 0) { + simpleName = fullPath.substring(lastDot + 1); + packagePath = fullPath.substring(0, lastDot); + } else { + simpleName = fullPath; + packagePath = ""; + } + return new ImportEntry(fullPath, simpleName, isWildcard, isStatic, + isImplicit, range, packagePath); + } + + /** @return the fully qualified import path (e.g. {@code "java.util.List"}) */ + public String getFullPath() { return fullPath; } + + /** @return the unqualified name (e.g. {@code "List"} or {@code "*"}) */ + public String getSimpleName() { return simpleName; } + + /** @return {@code true} for wildcard imports ({@code import pkg.*}) */ + public boolean isWildcard() { return isWildcard; } + + /** @return {@code true} for static imports */ + public boolean isStatic() { return isStatic; } + + /** @return {@code true} for auto-injected imports */ + public boolean isImplicit() { return isImplicit; } + + /** + * @return the source location of the import statement, or {@code null} + * for implicit imports + */ + public TextSpan getRange() { return range; } + + /** @return the package portion (e.g. {@code "java.util"}) */ + public String getPackagePath() { return packagePath; } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof ImportEntry)) return false; + ImportEntry that = (ImportEntry) obj; + return this.isImplicit == that.isImplicit + && this.fullPath.equals(that.fullPath); + } + + @Override + public int hashCode() { + int result = fullPath.hashCode(); + result = 31 * result + (isImplicit ? 1 : 0); + return result; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + if (isImplicit) sb.append("[implicit] "); + if (isStatic) sb.append("static "); + sb.append("import ").append(fullPath); + if (range != null) { + sb.append(" at ").append(range); + } + return sb.toString(); + } + } + + // ── Building (mutators) ──────────────────────────────────────────── + + /** + * Removes all import entries and resets the version counter. + */ + public synchronized void clear() { + entries.clear(); + markDirty(); + } + + /** + * Adds a single import entry. + * + * @param entry the entry to add; must not be {@code null} + * @throws IllegalArgumentException if {@code entry} is {@code null} + */ + public synchronized void addImport(ImportEntry entry) { + if (entry == null) { + throw new IllegalArgumentException("entry must not be null"); + } + entries.add(entry); + markDirty(); + } + + /** + * Adds an implicit (auto-injected) import from a fully qualified path. + * + *

The entry is created with {@code isImplicit=true}, {@code isStatic=false}, + * and {@code range=null}.

+ * + * @param fullPath the fully qualified path (e.g. {@code "java.lang.*"}) + */ + public synchronized void addImplicitImport(String fullPath) { + ImportEntry entry = ImportEntry.fromFullPath(fullPath, false, true, null); + entries.add(entry); + markDirty(); + } + + /** + * Atomically replaces all entries with the given list. + * + *

The previous contents are discarded. This is the preferred method + * when rebuilding imports from a fresh parse — it avoids intermediate + * states visible to concurrent readers.

+ * + * @param newEntries the replacement entries; the list is defensively copied + */ + public synchronized void replaceAll(List newEntries) { + entries.clear(); + if (newEntries != null) { + entries.addAll(newEntries); + } + markDirty(); + } + + // ── Resolution (queries) ─────────────────────────────────────────── + + /** + * Resolves an import by its unqualified simple name. + * + *

Resolution order:

+ *
    + *
  1. Exact match in explicit (non-wildcard) imports by simple name.
  2. + *
  3. If no exact match, returns the first wildcard import entry whose + * package could contain the type. (Full resolution would require a + * {@code TypeResolver} callback — for now the wildcard entry itself + * is returned so callers can perform the lookup.)
  4. + *
+ * + * @param simpleName the unqualified name to resolve (e.g. {@code "List"}) + * @return the matching entry, or {@code null} if not found + */ + public synchronized ImportEntry resolveBySimpleName(String simpleName) { + if (simpleName == null || simpleName.isEmpty()) { + return null; + } + ensureIndexes(); + ImportEntry exact = bySimpleName.get(simpleName); + if (exact != null) { + return exact; + } + // Fall back to wildcard entries — return the first wildcard that could + // potentially provide the type (caller must verify via TypeResolver). + for (int i = 0, size = entries.size(); i < size; i++) { + ImportEntry entry = entries.get(i); + if (entry.isWildcard) { + return entry; + } + } + return null; + } + + /** + * Resolves an import by its fully qualified path. + * + * @param fullPath the fully qualified path (e.g. {@code "java.util.List"}) + * @return the matching entry, or {@code null} if not found + */ + public synchronized ImportEntry resolveByFullPath(String fullPath) { + if (fullPath == null || fullPath.isEmpty()) { + return null; + } + ensureIndexes(); + return byFullPath.get(fullPath); + } + + /** + * Quick check whether a simple name is covered by any import + * (explicit, wildcard, or implicit). + * + * @param simpleName the unqualified name to check + * @return {@code true} if any import covers this name + */ + public synchronized boolean isImported(String simpleName) { + return resolveBySimpleName(simpleName) != null; + } + + /** + * Checks whether a fully qualified name is covered by an implicit import. + * + *

This checks both exact matches (e.g. an implicit import of + * {@code "java.lang.String"}) and wildcard matches (e.g. an implicit + * import of {@code "java.lang.*"} covers {@code "java.lang.String"}).

+ * + * @param fqn the fully qualified name to check + * @return {@code true} if an implicit import covers this FQN + */ + public synchronized boolean isImplicitlyImported(String fqn) { + if (fqn == null || fqn.isEmpty()) { + return false; + } + for (int i = 0, size = entries.size(); i < size; i++) { + ImportEntry entry = entries.get(i); + if (!entry.isImplicit) { + continue; + } + if (entry.fullPath.equals(fqn)) { + return true; + } + // Check wildcard coverage: "java.lang.*" covers "java.lang.String" + if (entry.isWildcard) { + String pkg = entry.packagePath; + if (fqn.startsWith(pkg + ".") && fqn.indexOf('.', pkg.length() + 1) < 0) { + return true; + } + } + } + return false; + } + + // ── Wildcard package queries ─────────────────────────────────────── + + /** + * Returns all wildcard package paths (e.g. {@code "java.util"} from + * {@code import java.util.*}). + * + * @return an unmodifiable set of package paths; never {@code null} + */ + public synchronized Set getWildcardPackages() { + Set result = new HashSet(); + for (int i = 0, size = entries.size(); i < size; i++) { + ImportEntry entry = entries.get(i); + if (entry.isWildcard) { + result.add(entry.packagePath); + } + } + return Collections.unmodifiableSet(result); + } + + // ── Iteration ────────────────────────────────────────────────────── + + /** + * Returns a snapshot of all import entries (both explicit and implicit). + * + * @return an unmodifiable list of all entries; never {@code null} + */ + public synchronized List getAllImports() { + return Collections.unmodifiableList(new ArrayList(entries)); + } + + /** + * Returns a snapshot of only the implicit (auto-injected) imports. + * + * @return an unmodifiable list; never {@code null} + */ + public synchronized List getImplicitImports() { + List result = new ArrayList(); + for (int i = 0, size = entries.size(); i < size; i++) { + ImportEntry entry = entries.get(i); + if (entry.isImplicit) { + result.add(entry); + } + } + return Collections.unmodifiableList(result); + } + + /** + * Returns a snapshot of only the explicit (non-implicit) imports. + * + * @return an unmodifiable list; never {@code null} + */ + public synchronized List getExplicitImports() { + List result = new ArrayList(); + for (int i = 0, size = entries.size(); i < size; i++) { + ImportEntry entry = entries.get(i); + if (!entry.isImplicit) { + result.add(entry); + } + } + return Collections.unmodifiableList(result); + } + + // ── Pruning ──────────────────────────────────────────────────────── + + /** + * Removes implicit imports whose simple name is not in the given set + * of used names. + * + *

Wildcard implicit imports are never removed by this method, since + * they cannot be matched by simple name alone.

+ * + *

This is typically called after the token-build pass to discard + * implicit imports that turned out to be unused.

+ * + * @param usedSimpleNames the set of simple names actually referenced + * in the source; must not be {@code null} + */ + public synchronized void removeUnusedImplicitImports(Set usedSimpleNames) { + if (usedSimpleNames == null) { + throw new IllegalArgumentException("usedSimpleNames must not be null"); + } + boolean changed = false; + Iterator it = entries.iterator(); + while (it.hasNext()) { + ImportEntry entry = it.next(); + if (entry.isImplicit && !entry.isWildcard + && !usedSimpleNames.contains(entry.simpleName)) { + it.remove(); + changed = true; + } + } + if (changed) { + markDirty(); + } + } + + // ── Utilities ────────────────────────────────────────────────────── + + /** + * Returns the total number of import entries (explicit + implicit). + * + * @return the entry count + */ + public synchronized int size() { + return entries.size(); + } + + /** + * Returns {@code true} if there are no import entries. + * + * @return {@code true} when empty + */ + public synchronized boolean isEmpty() { + return entries.isEmpty(); + } + + /** + * Returns the current version counter. + * + *

The version is bumped on every mutation. External code can snapshot + * this value and later compare to detect whether the index has changed.

+ * + * @return the current version (starts at 0, increments monotonically) + */ + public synchronized int version() { + return version; + } + + // ── Internals ────────────────────────────────────────────────────── + + /** + * Marks the derived indexes as stale and increments the version counter. + * Must be called under the instance lock. + */ + private void markDirty() { + dirty = true; + version++; + } + + /** + * Rebuilds the derived indexes if they are stale. Must be called under + * the instance lock. + */ + private void ensureIndexes() { + if (!dirty) { + return; + } + Map newBySimpleName = new HashMap(); + Map newByFullPath = new HashMap(); + for (int i = 0, size = entries.size(); i < size; i++) { + ImportEntry entry = entries.get(i); + newByFullPath.put(entry.fullPath, entry); + // Only index non-wildcard entries by simple name; wildcard entries + // are handled by the fallback scan in resolveBySimpleName(). + if (!entry.isWildcard) { + // Later entries with the same simple name win (last-import-wins + // semantics, matching javac behavior for duplicate imports). + newBySimpleName.put(entry.simpleName, entry); + } + } + this.bySimpleName = newBySimpleName; + this.byFullPath = newByFullPath; + this.dirty = false; + } + + @Override + public String toString() { + return "ImportIndex{size=" + entries.size() + ", version=" + version + "}"; + } +} diff --git a/src/main/java/bigguy/texteditor/semantics/InferenceCache.java b/src/main/java/bigguy/texteditor/semantics/InferenceCache.java new file mode 100644 index 000000000..38d73648c --- /dev/null +++ b/src/main/java/bigguy/texteditor/semantics/InferenceCache.java @@ -0,0 +1,384 @@ +package bigguy.texteditor.semantics; + +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; + +/** + * Cache for expensive type inference results that can be reused across + * analysis passes within a single source version. + * + *

Replaces three separate cache maps that previously lived in + * {@code ScriptDocument}:

+ *
    + *
  • {@code objectLiterals} — cached object-literal parses keyed by + * brace-start byte offset
  • + *
  • {@code lambdaCache} — cached lambda inferences keyed by + * header-start byte offset
  • + *
  • {@code scriptMethodSamContexts} — SAM conflict tracking keyed + * by method name
  • + *
+ * + *

Type safety

+ *

The old code used raw {@code int} keys with no type safety. This + * class preserves the integer-keyed approach but provides strongly-typed + * accessor families ({@code putObjectLiteral}/{@code getObjectLiteral}, + * {@code putLambda}/{@code getLambda}, {@code putSamContext}/{@code getSamContext}) + * so callers cannot accidentally cross-contaminate caches.

+ * + *

Cache entries are stored as {@link Object} internally because the + * concrete analysis types ({@code ObjectLiteralAnalysis}, + * {@code LambdaCacheEntry}) live in the legacy package and this class + * must not depend on them. Generic getter methods perform unchecked casts + * that are safe as long as callers maintain type consistency per cache + * family.

+ * + *

Version-aware invalidation

+ *

Each cache instance tracks the source version it was built against. + * When the source changes, callers invoke {@link #invalidateIfStale(int)} + * to clear all entries if the version has drifted.

+ * + *

Thread safety

+ *

This class is not thread-safe. It is designed to be + * accessed exclusively from the analysis thread. If cross-thread access + * is needed in the future, external synchronization must be applied.

+ * + * @since Phase 2 — CST editor architecture + */ +public final class InferenceCache { + + private final Map objectLiterals; + private final Map lambdas; + private final Map samContexts; + private int sourceVersion; + + /** + * Creates a new, empty {@code InferenceCache} at source version 0. + */ + public InferenceCache() { + this.objectLiterals = new HashMap(); + this.lambdas = new HashMap(); + this.samContexts = new HashMap(); + this.sourceVersion = 0; + } + + // ── Source version tracking ──────────────────────────────────────── + + /** + * Sets the source version this cache is valid for. + * + *

This does not automatically invalidate existing entries. + * Call {@link #invalidateIfStale(int)} for conditional invalidation, + * or {@link #invalidateAll()} to force a full clear.

+ * + * @param version the new source version + */ + public void setSourceVersion(int version) { + this.sourceVersion = version; + } + + /** + * Returns the source version this cache was last set to. + * + * @return the current source version + */ + public int getSourceVersion() { + return sourceVersion; + } + + // ── Invalidation ─────────────────────────────────────────────────── + + /** + * Clears all three cache stores unconditionally. + */ + public void invalidateAll() { + objectLiterals.clear(); + lambdas.clear(); + samContexts.clear(); + } + + /** + * Clears all caches if the current version does not match the given + * version, then updates the stored version. + * + *

This is the standard entry point at the start of an analysis pass: + * if the source has changed since the last pass, all cached results are + * stale and must be discarded.

+ * + * @param currentVersion the version to check against + */ + public void invalidateIfStale(int currentVersion) { + if (this.sourceVersion != currentVersion) { + invalidateAll(); + this.sourceVersion = currentVersion; + } + } + + /** + * Removes all offset-keyed cache entries whose key falls within the + * half-open range {@code [startByte, endByte)}. + * + *

This supports fine-grained incremental invalidation: when a small + * edit occurs, only entries overlapping the edited range need to be + * discarded. The SAM context cache (string-keyed) is left untouched + * since method names are not offset-based.

+ * + * @param startByte inclusive start of the invalidation range + * @param endByte exclusive end of the invalidation range + */ + public void invalidateRange(int startByte, int endByte) { + removeKeysInRange(objectLiterals, startByte, endByte); + removeKeysInRange(lambdas, startByte, endByte); + } + + // ── Object literal cache ─────────────────────────────────────────── + + /** + * Stores an object-literal analysis result keyed by brace-start offset. + * + * @param braceStartOffset byte offset of the opening brace + * @param analysis the analysis result (typically an + * {@code ObjectLiteralAnalysis} from the legacy package) + */ + public void putObjectLiteral(int braceStartOffset, Object analysis) { + objectLiterals.put(braceStartOffset, analysis); + } + + /** + * Retrieves a cached object-literal analysis by brace-start offset. + * + * @param braceStartOffset byte offset of the opening brace + * @param the expected result type + * @return the cached analysis, or {@code null} if not present + */ + @SuppressWarnings("unchecked") + public T getObjectLiteral(int braceStartOffset) { + return (T) objectLiterals.get(braceStartOffset); + } + + /** + * Checks whether an object-literal analysis is cached for the given offset. + * + * @param braceStartOffset byte offset of the opening brace + * @return {@code true} if a cached entry exists + */ + public boolean hasObjectLiteral(int braceStartOffset) { + return objectLiterals.containsKey(braceStartOffset); + } + + /** + * Removes a single object-literal cache entry. + * + * @param braceStartOffset byte offset of the opening brace + */ + public void removeObjectLiteral(int braceStartOffset) { + objectLiterals.remove(braceStartOffset); + } + + // ── Lambda cache ─────────────────────────────────────────────────── + + /** + * Stores a lambda inference result keyed by header-start offset. + * + * @param headerStartOffset byte offset of the lambda header start + * @param cacheEntry the inference result (typically a + * {@code LambdaCacheEntry} from the legacy package) + */ + public void putLambda(int headerStartOffset, Object cacheEntry) { + lambdas.put(headerStartOffset, cacheEntry); + } + + /** + * Retrieves a cached lambda inference by header-start offset. + * + * @param headerStartOffset byte offset of the lambda header start + * @param the expected result type + * @return the cached entry, or {@code null} if not present + */ + @SuppressWarnings("unchecked") + public T getLambda(int headerStartOffset) { + return (T) lambdas.get(headerStartOffset); + } + + /** + * Checks whether a lambda inference is cached for the given offset. + * + * @param headerStartOffset byte offset of the lambda header start + * @return {@code true} if a cached entry exists + */ + public boolean hasLambda(int headerStartOffset) { + return lambdas.containsKey(headerStartOffset); + } + + /** + * Removes a single lambda cache entry. + * + * @param headerStartOffset byte offset of the lambda header start + */ + public void removeLambda(int headerStartOffset) { + lambdas.remove(headerStartOffset); + } + + // ── SAM context cache ────────────────────────────────────────────── + + /** + * Stores a SAM context (method info) keyed by method name. + * + * @param methodName the method name serving as cache key + * @param methodInfo the SAM context info (typically a {@code MethodInfo} + * from the legacy package) + */ + public void putSamContext(String methodName, Object methodInfo) { + samContexts.put(methodName, methodInfo); + } + + /** + * Retrieves a cached SAM context by method name. + * + * @param methodName the method name + * @param the expected result type + * @return the cached entry, or {@code null} if not present + */ + @SuppressWarnings("unchecked") + public T getSamContext(String methodName) { + return (T) samContexts.get(methodName); + } + + /** + * Checks whether a SAM context is cached for the given method name. + * + * @param methodName the method name + * @return {@code true} if a cached entry exists + */ + public boolean hasSamContext(String methodName) { + return samContexts.containsKey(methodName); + } + + /** + * Removes a single SAM context cache entry. + * + * @param methodName the method name + */ + public void removeSamContext(String methodName) { + samContexts.remove(methodName); + } + + // ── Statistics ───────────────────────────────────────────────────── + + /** + * @return the number of cached object-literal analyses + */ + public int objectLiteralCount() { + return objectLiterals.size(); + } + + /** + * @return the number of cached lambda inferences + */ + public int lambdaCount() { + return lambdas.size(); + } + + /** + * @return the number of cached SAM contexts + */ + public int samContextCount() { + return samContexts.size(); + } + + /** + * @return the total number of cached entries across all three stores + */ + public int totalSize() { + return objectLiterals.size() + lambdas.size() + samContexts.size(); + } + + /** + * @return {@code true} if all three stores are empty + */ + public boolean isEmpty() { + return objectLiterals.isEmpty() && lambdas.isEmpty() && samContexts.isEmpty(); + } + + // ── Offset adjustment ────────────────────────────────────────────── + + /** + * Adjusts all offset-keyed cache entries to account for an edit. + * + *

Any entry whose byte-offset key is strictly greater than + * {@code editStart} has its key shifted by {@code delta}. Entries at + * or before {@code editStart} are left in place. The SAM context + * cache (string-keyed) is not affected.

+ * + *

This is used for incremental updates: after a small insertion or + * deletion, existing cache entries that follow the edit point can be + * reused if their keys are shifted to match the new byte layout.

+ * + * @param editStart the byte offset where the edit occurred + * @param delta the number of bytes inserted (positive) or removed + * (negative) + */ + public void adjustOffsets(int editStart, int delta) { + if (delta == 0) { + return; + } + adjustOffsetsInMap(objectLiterals, editStart, delta); + adjustOffsetsInMap(lambdas, editStart, delta); + } + + // ── Internal helpers ─────────────────────────────────────────────── + + /** + * Removes entries from an integer-keyed map whose keys fall within + * {@code [startByte, endByte)}. + */ + private static void removeKeysInRange(Map map, + int startByte, int endByte) { + if (map.isEmpty()) { + return; + } + Iterator it = map.keySet().iterator(); + while (it.hasNext()) { + int key = it.next(); + if (key >= startByte && key < endByte) { + it.remove(); + } + } + } + + /** + * Shifts keys in an integer-keyed map: any key strictly greater than + * {@code editStart} is replaced by {@code key + delta}. The map is + * rebuilt to avoid concurrent-modification issues with in-place shifts. + */ + private static void adjustOffsetsInMap(Map map, + int editStart, int delta) { + if (map.isEmpty()) { + return; + } + Map adjusted = new HashMap(map.size()); + for (Map.Entry entry : map.entrySet()) { + int key = entry.getKey(); + if (key > editStart) { + int newKey = key + delta; + if (newKey >= 0) { + adjusted.put(newKey, entry.getValue()); + } + // Entries shifted to negative offsets are silently discarded + // (they fell into the deleted region). + } else { + adjusted.put(key, entry.getValue()); + } + } + map.clear(); + map.putAll(adjusted); + } + + @Override + public String toString() { + return "InferenceCache{version=" + sourceVersion + + ", objectLiterals=" + objectLiterals.size() + + ", lambdas=" + lambdas.size() + + ", samContexts=" + samContexts.size() + "}"; + } +} diff --git a/src/main/java/bigguy/texteditor/semantics/ScopeTree.java b/src/main/java/bigguy/texteditor/semantics/ScopeTree.java new file mode 100644 index 000000000..9e22559d6 --- /dev/null +++ b/src/main/java/bigguy/texteditor/semantics/ScopeTree.java @@ -0,0 +1,1064 @@ +package bigguy.texteditor.semantics; + +import bigguy.texteditor.index.Symbol.FieldSymbol; +import bigguy.texteditor.index.SymbolKey; +import bigguy.texteditor.index.SymbolKind; +import bigguy.texteditor.syntax.DocumentSyntax; +import bigguy.texteditor.syntax.SemanticNode; +import bigguy.texteditor.treesitter.java.TextSpan; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +/** + * Hierarchical scope tree built from CST nodes, implementing IntelliJ's + * {@code PsiScopeProcessor} pattern for variable resolution. + * + *

Replaces ScriptDocument's triple-nested {@code methodLocals} + * ({@code Map>>}), {@code topLevelLocals}, + * and {@code innerScopes} with a proper tree structure:

+ * + *
+ * FileScope (program)
+ *   ├── ClassScope (class_body)
+ *   │     ├── MethodScope (method_declaration)
+ *   │     │     ├── BlockScope (block / for / if / try)
+ *   │     │     └── LambdaScope (lambda_expression)
+ *   │     └── FieldDecl (field_declaration)
+ *   └── ImportDecl (import_declaration)
+ * 
+ * + *

Resolution algorithm (PsiScopeProcessor)

+ *
    + *
  1. Find deepest scope S containing the byte offset via binary search
  2. + *
  3. Check S.locals for the variable name
  4. + *
  5. If found AND the declaration offset < query offset → return it
  6. + *
  7. If not found → S = S.parent, goto 2
  8. + *
  9. If S is null (walked past root) → return empty
  10. + *
+ * + *

Thread safety

+ *

A {@code ScopeTree} instance is built once from a {@link DocumentSyntax} + * snapshot and is effectively immutable after construction. Multiple threads + * may query it concurrently without synchronization.

+ * + * @see Scope + * @see ScopeKind + * @see DocumentSyntax + */ +public final class ScopeTree { + + // ── Tree-sitter node type constants ──────────────────────────────────────── + // Sourced from the tree-sitter-java grammar (v0.23.x). + + private static final String NODE_PROGRAM = "program"; + private static final String NODE_CLASS_BODY = "class_body"; + private static final String NODE_METHOD_DECLARATION = "method_declaration"; + private static final String NODE_CONSTRUCTOR_DECLARATION = "constructor_declaration"; + private static final String NODE_BLOCK = "block"; + private static final String NODE_FOR_STATEMENT = "for_statement"; + private static final String NODE_ENHANCED_FOR_STATEMENT = "enhanced_for_statement"; + private static final String NODE_WHILE_STATEMENT = "while_statement"; + private static final String NODE_DO_STATEMENT = "do_statement"; + private static final String NODE_IF_STATEMENT = "if_statement"; + private static final String NODE_TRY_STATEMENT = "try_statement"; + private static final String NODE_CATCH_CLAUSE = "catch_clause"; + private static final String NODE_SWITCH_BLOCK_STATEMENT_GROUP = "switch_block_statement_group"; + private static final String NODE_LAMBDA_EXPRESSION = "lambda_expression"; + private static final String NODE_STATIC_INITIALIZER = "static_initializer"; + private static final String NODE_LOCAL_VARIABLE_DECLARATION = "local_variable_declaration"; + private static final String NODE_FORMAL_PARAMETER = "formal_parameter"; + private static final String NODE_CATCH_FORMAL_PARAMETER = "catch_formal_parameter"; + private static final String NODE_SPREAD_PARAMETER = "spread_parameter"; + private static final String NODE_LAMBDA_PARAMETERS = "formal_parameters"; + private static final String NODE_INFERRED_PARAMETERS = "inferred_parameters"; + private static final String NODE_VARIABLE_DECLARATOR = "variable_declarator"; + private static final String NODE_IDENTIFIER = "identifier"; + private static final String NODE_ENHANCED_FOR_VARIABLE = "enhanced_for_variable"; + + // Field names used by tree-sitter-java grammar. + private static final String FIELD_NAME = "name"; + private static final String FIELD_TYPE = "type"; + private static final String FIELD_BODY = "body"; + private static final String FIELD_PARAMETERS = "parameters"; + private static final String FIELD_DIMENSIONS = "dimensions"; + + private final Scope root; + private final List flatScopes; + + private ScopeTree(Scope root, List flatScopes) { + this.root = root; + this.flatScopes = Collections.unmodifiableList(flatScopes); + } + + // ═══════════════════════════════════════════════════════════════════════════ + // ScopeKind enum + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * Classifies the kind of lexical scope. + */ + public enum ScopeKind { + /** Root file scope ({@code program} node). */ + FILE, + /** Class/interface/enum body ({@code class_body} node). */ + CLASS, + /** Method or constructor declaration. */ + METHOD, + /** Block statement ({@code block}, {@code for}, {@code if}, {@code try}, etc.). */ + BLOCK, + /** Lambda expression body. */ + LAMBDA, + /** Catch clause (declares exception variable). */ + CATCH, + /** Switch block statement group. */ + SWITCH, + /** Static initializer block. */ + STATIC_INIT + } + + // ═══════════════════════════════════════════════════════════════════════════ + // Scope hierarchy (abstract base + concrete subclasses) + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * A lexical scope in the scope tree. Each scope knows its parent, children, + * local variable declarations, and the source range it covers. + * + *

Abstract base class (not an interface) because Java 8 lacks sealed + * types. Concrete subclasses are static inner classes of {@link ScopeTree}.

+ */ + public static abstract class Scope { + + private final String nodeType; + private final TextSpan range; + private final Scope parent; + private final List children; + private final Map locals; + private boolean frozen; + + /** + * @param nodeType the tree-sitter node type that introduced this scope + * @param range the byte range this scope covers in the source text + * @param parent the enclosing scope, or {@code null} for the root + */ + protected Scope(String nodeType, TextSpan range, Scope parent) { + this.nodeType = nodeType; + this.range = range; + this.parent = parent; + this.children = new ArrayList<>(); + this.locals = new LinkedHashMap<>(); + this.frozen = false; + } + + /** + * @return the classification of this scope + */ + public abstract ScopeKind kind(); + + /** + * @return the tree-sitter node type string (e.g. {@code "method_declaration"}) + */ + public String nodeType() { + return nodeType; + } + + /** + * @return the byte range this scope covers + */ + public TextSpan range() { + return range; + } + + /** + * @return the enclosing scope, or {@code null} for the root + */ + public Scope parent() { + return parent; + } + + /** + * @return an unmodifiable view of child scopes + */ + public List children() { + return frozen + ? children + : Collections.unmodifiableList(children); + } + + /** + * @return an unmodifiable view of local variable declarations in this scope, + * keyed by variable name + */ + public Map locals() { + return frozen + ? locals + : Collections.unmodifiableMap(locals); + } + + /** + * Tests whether the given byte offset falls within this scope's range. + * + * @param byteOffset the offset to test + * @return {@code true} if this scope contains the offset + */ + public boolean containsOffset(int byteOffset) { + return range != null && range.containsByte(byteOffset); + } + + /** + * @return the start byte of this scope's range + */ + public int startByte() { + return range != null ? range.getStartByte() : 0; + } + + /** + * @return the end byte (exclusive) of this scope's range + */ + public int endByte() { + return range != null ? range.getEndByte() : 0; + } + + void addChild(Scope child) { + if (frozen) { + throw new IllegalStateException("Cannot add children to a frozen scope"); + } + children.add(child); + } + + void addLocal(FieldSymbol local) { + if (frozen) { + throw new IllegalStateException("Cannot add locals to a frozen scope"); + } + locals.put(local.name(), local); + } + + /** + * Freezes this scope and all descendants, making the children and locals + * lists truly unmodifiable. Called once after the tree is fully built. + */ + void freeze() { + if (frozen) { + return; + } + frozen = true; + for (Scope child : children) { + child.freeze(); + } + } + + @Override + public String toString() { + return kind().name() + "{" + nodeType + " " + range + + ", locals=" + locals.size() + + ", children=" + children.size() + "}"; + } + } + + /** + * Root file scope, corresponding to the {@code program} node. + */ + public static final class FileScope extends Scope { + + /** + * @param range the byte range of the entire file + * @param parent always {@code null} for the root + */ + public FileScope(TextSpan range, Scope parent) { + super(NODE_PROGRAM, range, parent); + } + + @Override + public ScopeKind kind() { + return ScopeKind.FILE; + } + } + + /** + * Class, interface, or enum body scope. + */ + public static final class ClassScope extends Scope { + + private final String className; + + /** + * @param range the byte range of the class body + * @param parent the enclosing scope + * @param className the declared class name (may be {@code null} for anonymous classes) + */ + public ClassScope(TextSpan range, Scope parent, String className) { + super(NODE_CLASS_BODY, range, parent); + this.className = className; + } + + /** + * @return the class name, or {@code null} for anonymous classes + */ + public String className() { + return className; + } + + @Override + public ScopeKind kind() { + return ScopeKind.CLASS; + } + } + + /** + * Method or constructor declaration scope. + */ + public static final class MethodScope extends Scope { + + private final String methodName; + + /** + * @param nodeType the tree-sitter node type ({@code "method_declaration"} or + * {@code "constructor_declaration"}) + * @param range the byte range of the method declaration + * @param parent the enclosing scope + * @param methodName the method name ({@code ""} for constructors) + */ + public MethodScope(String nodeType, TextSpan range, Scope parent, + String methodName) { + super(nodeType, range, parent); + this.methodName = methodName; + } + + /** + * @return the method name, or {@code ""} for constructors + */ + public String methodName() { + return methodName; + } + + @Override + public ScopeKind kind() { + return ScopeKind.METHOD; + } + } + + /** + * Block scope for {@code block}, {@code for_statement}, {@code if_statement}, + * {@code while_statement}, {@code do_statement}, {@code try_statement}, + * and {@code switch_block_statement_group} nodes. + */ + public static final class BlockScope extends Scope { + + /** + * @param nodeType the tree-sitter node type + * @param range the byte range of the block + * @param parent the enclosing scope + */ + public BlockScope(String nodeType, TextSpan range, Scope parent) { + super(nodeType, range, parent); + } + + @Override + public ScopeKind kind() { + if (NODE_SWITCH_BLOCK_STATEMENT_GROUP.equals(nodeType())) { + return ScopeKind.SWITCH; + } + return ScopeKind.BLOCK; + } + } + + /** + * Lambda expression scope. + */ + public static final class LambdaScope extends Scope { + + /** + * @param range the byte range of the lambda expression + * @param parent the enclosing scope + */ + public LambdaScope(TextSpan range, Scope parent) { + super(NODE_LAMBDA_EXPRESSION, range, parent); + } + + @Override + public ScopeKind kind() { + return ScopeKind.LAMBDA; + } + } + + /** + * Catch clause scope. Declares the caught exception variable. + */ + public static final class CatchScope extends Scope { + + /** + * @param range the byte range of the catch clause + * @param parent the enclosing scope + */ + public CatchScope(TextSpan range, Scope parent) { + super(NODE_CATCH_CLAUSE, range, parent); + } + + @Override + public ScopeKind kind() { + return ScopeKind.CATCH; + } + } + + /** + * Static initializer block scope. + */ + public static final class StaticInitScope extends Scope { + + /** + * @param range the byte range of the static initializer + * @param parent the enclosing scope + */ + public StaticInitScope(TextSpan range, Scope parent) { + super(NODE_STATIC_INITIALIZER, range, parent); + } + + @Override + public ScopeKind kind() { + return ScopeKind.STATIC_INIT; + } + } + + // ═══════════════════════════════════════════════════════════════════════════ + // Building + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * Builds a scope tree from a parsed {@link DocumentSyntax}. + * + *

Walks the CST recursively, creating scope nodes for each + * scope-introducing tree-sitter node type, extracting local variable + * declarations, and attaching scope references to {@link SemanticNode}s + * via {@link SemanticNode#setScope(Object)}.

+ * + * @param syntax the document syntax to build from (must not be {@code null}) + * @return the completed scope tree + * @throws NullPointerException if {@code syntax} is {@code null} + * @throws IllegalArgumentException if the syntax tree has no root node + */ + public static ScopeTree buildFromCST(DocumentSyntax syntax) { + if (syntax == null) { + throw new NullPointerException("syntax must not be null"); + } + SemanticNode root = syntax.root(); + if (root == null) { + throw new IllegalArgumentException("syntax tree has no root node"); + } + + List flatCollector = new ArrayList<>(); + Scope rootScope = buildScope(root, null, flatCollector); + rootScope.freeze(); + + return new ScopeTree(rootScope, flatCollector); + } + + // ═══════════════════════════════════════════════════════════════════════════ + // Resolution (PsiScopeProcessor pattern) + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * Resolves a variable by name at the given byte offset using IntelliJ's + * PsiScopeProcessor walk-up pattern. + * + *

Algorithm:

+ *
    + *
  1. Find the deepest scope containing {@code byteOffset}
  2. + *
  3. Check its locals for {@code name}
  4. + *
  5. If found AND the variable's declaration starts before {@code byteOffset}, + * return it (variables are not visible before their declaration)
  6. + *
  7. If not found, walk up to the parent scope and repeat
  8. + *
  9. If the root is reached without a match, return empty
  10. + *
+ * + * @param name the variable name to resolve + * @param byteOffset the byte offset of the reference site + * @return the resolved field symbol, or {@code null} if not found + */ + public FieldSymbol resolveVariable(String name, int byteOffset) { + if (name == null || root == null) { + return null; + } + + Scope scope = scopeAt(byteOffset); + if (scope == null) { + return null; + } + + while (scope != null) { + FieldSymbol local = scope.locals().get(name); + if (local != null) { + // Variable must be declared before the reference site. + if (local.range().getStartByte() < byteOffset) { + return local; + } + // In class scope, fields are visible regardless of declaration order. + if (scope.kind() == ScopeKind.CLASS) { + return local; + } + } + scope = scope.parent(); + } + return null; + } + + /** + * Finds the deepest (most specific) scope containing the given byte offset. + * + *

Uses a top-down walk from the root, narrowing into the child whose + * range contains the offset. Among children at the same level, the tightest + * (smallest range) match wins.

+ * + * @param byteOffset the byte offset to locate + * @return the deepest scope containing the offset, or the root if offset is + * within the file, or {@code null} if offset is outside the tree + */ + public Scope scopeAt(int byteOffset) { + if (root == null) { + return null; + } + if (!root.containsOffset(byteOffset)) { + return null; + } + return findDeepestScope(root, byteOffset); + } + + /** + * @return the root scope (always a {@link FileScope}), or {@code null} if + * the tree was built from an empty/missing CST + */ + public Scope getRoot() { + return root; + } + + // ═══════════════════════════════════════════════════════════════════════════ + // Iteration + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * Returns all scopes in the tree in pre-order (depth-first) traversal order. + * + * @return an unmodifiable list of all scopes (never {@code null}) + */ + public List getAllScopes() { + return flatScopes; + } + + /** + * Returns all method scopes (method and constructor declarations). + * + * @return an unmodifiable list of method scopes (never {@code null}, may be empty) + */ + public List getAllMethodScopes() { + List result = new ArrayList<>(); + for (Scope scope : flatScopes) { + if (scope instanceof MethodScope) { + result.add((MethodScope) scope); + } + } + if (result.isEmpty()) { + return Collections.emptyList(); + } + return Collections.unmodifiableList(result); + } + + // ═══════════════════════════════════════════════════════════════════════════ + // Incremental support + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * Finds the tightest (most deeply nested) scope that fully contains the + * given text span. Useful for determining which scope an edit affects. + * + * @param range the text span to search for + * @return the tightest enclosing scope, or the root if the span covers + * the whole file, or {@code null} if the span is outside the tree + * @throws NullPointerException if {@code range} is {@code null} + */ + public Scope findScopeContaining(TextSpan range) { + if (range == null) { + throw new NullPointerException("range must not be null"); + } + if (root == null) { + return null; + } + TextSpan rootRange = root.range(); + if (rootRange == null || !rootRange.contains(range)) { + return null; + } + return findTightestContaining(root, range); + } + + @Override + public String toString() { + return "ScopeTree{scopes=" + flatScopes.size() + + ", root=" + (root != null ? root.kind() : "null") + + "}"; + } + + // ═══════════════════════════════════════════════════════════════════════════ + // Private — tree building + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * Recursively builds the scope hierarchy from a {@link SemanticNode}. + * + *

For scope-introducing nodes, creates the appropriate {@link Scope} + * subclass. For variable-declaring nodes within a scope, extracts the + * declaration and adds it to the scope's locals. Attaches the scope + * to the {@link SemanticNode} via {@code setScope}.

+ * + * @param node the current CST node + * @param parent the enclosing scope (null for root) + * @param collector accumulates all scopes in pre-order for {@link #flatScopes} + * @return the scope created for this node (or the parent if this node + * does not introduce a scope) + */ + private static Scope buildScope(SemanticNode node, Scope parent, + List collector) { + String type = node.nodeType(); + if (type == null) { + return parent; + } + + Scope scope = createScopeForNode(type, node, parent); + if (scope != null) { + collector.add(scope); + if (parent != null) { + parent.addChild(scope); + } + node.setScope(scope); + extractLocals(node, scope); + walkChildren(node, scope, collector); + return scope; + } + + // Not a scope-introducing node — check for variable declarations + // that belong to the parent scope. + if (parent != null && isVariableDeclaration(type)) { + extractVariableDeclaration(node, parent); + } + + // Recurse into children with the same parent scope. + walkChildren(node, parent, collector); + return parent; + } + + /** + * Creates the appropriate {@link Scope} subclass for a scope-introducing + * tree-sitter node type, or returns {@code null} if the node does not + * introduce a scope. + */ + private static Scope createScopeForNode(String nodeType, SemanticNode node, + Scope parent) { + TextSpan range = node.span(); + + switch (nodeType) { + case NODE_PROGRAM: + return new FileScope(range, parent); + + case NODE_CLASS_BODY: + String className = extractClassNameFromParent(node); + return new ClassScope(range, parent, className); + + case NODE_METHOD_DECLARATION: { + String methodName = extractFieldText(node, FIELD_NAME); + if (methodName == null) { + methodName = ""; + } + return new MethodScope(nodeType, range, parent, methodName); + } + + case NODE_CONSTRUCTOR_DECLARATION: { + String ctorName = extractFieldText(node, FIELD_NAME); + if (ctorName == null) { + ctorName = ""; + } + return new MethodScope(nodeType, range, parent, ctorName); + } + + case NODE_BLOCK: + // Only create a block scope if not already the body of a method/constructor + // (the method scope itself covers the body). + if (parent != null && parent.kind() == ScopeKind.METHOD) { + // Check if this block is the direct body of the method. + if (isDirectMethodBody(node, parent)) { + return null; + } + } + return new BlockScope(nodeType, range, parent); + + case NODE_FOR_STATEMENT: + case NODE_ENHANCED_FOR_STATEMENT: + case NODE_WHILE_STATEMENT: + case NODE_DO_STATEMENT: + case NODE_IF_STATEMENT: + case NODE_TRY_STATEMENT: + return new BlockScope(nodeType, range, parent); + + case NODE_SWITCH_BLOCK_STATEMENT_GROUP: + return new BlockScope(nodeType, range, parent); + + case NODE_CATCH_CLAUSE: + return new CatchScope(range, parent); + + case NODE_LAMBDA_EXPRESSION: + return new LambdaScope(range, parent); + + case NODE_STATIC_INITIALIZER: + return new StaticInitScope(range, parent); + + default: + return null; + } + } + + /** + * Walks all named children of a node, recursing into {@link #buildScope}. + */ + private static void walkChildren(SemanticNode node, Scope currentScope, + List collector) { + List children = node.namedChildren(); + for (SemanticNode child : children) { + buildScope(child, currentScope, collector); + } + } + + /** + * Extracts local variable declarations from nodes that are direct children + * of a scope-introducing node. Called after the scope is created but before + * descending into children. + * + *

Handles:

+ *
    + *
  • Method/constructor formal parameters
  • + *
  • Enhanced-for loop variables
  • + *
  • Catch clause exception parameters
  • + *
  • Lambda parameters (both typed and inferred)
  • + *
+ */ + private static void extractLocals(SemanticNode node, Scope scope) { + String type = node.nodeType(); + if (type == null) { + return; + } + + switch (type) { + case NODE_METHOD_DECLARATION: + case NODE_CONSTRUCTOR_DECLARATION: + extractFormalParameters(node, scope); + break; + + case NODE_ENHANCED_FOR_STATEMENT: + extractEnhancedForVariable(node, scope); + break; + + case NODE_CATCH_CLAUSE: + extractCatchParameter(node, scope); + break; + + case NODE_LAMBDA_EXPRESSION: + extractLambdaParameters(node, scope); + break; + + default: + break; + } + } + + /** + * Extracts formal parameters from a method or constructor declaration. + */ + private static void extractFormalParameters(SemanticNode methodNode, Scope scope) { + SemanticNode params = methodNode.childByFieldName(FIELD_PARAMETERS); + if (params == null) { + return; + } + List children = params.namedChildren(); + for (SemanticNode child : children) { + String childType = child.nodeType(); + if (NODE_FORMAL_PARAMETER.equals(childType) + || NODE_SPREAD_PARAMETER.equals(childType)) { + addParameterAsLocal(child, scope); + } + } + } + + /** + * Extracts the loop variable from an enhanced-for statement. + * Grammar: {@code enhanced_for_statement} has fields {@code type} and + * either a direct {@code name} field or an {@code enhanced_for_variable} child. + */ + private static void extractEnhancedForVariable(SemanticNode forNode, Scope scope) { + // tree-sitter-java grammar: the variable is in child by field "name" + // or in an "enhanced_for_variable" named child, depending on grammar version. + SemanticNode nameNode = forNode.childByFieldName(FIELD_NAME); + SemanticNode typeNode = forNode.childByFieldName(FIELD_TYPE); + + if (nameNode == null) { + // Try finding enhanced_for_variable child. + List children = forNode.namedChildren(); + for (SemanticNode child : children) { + if (NODE_ENHANCED_FOR_VARIABLE.equals(child.nodeType())) { + nameNode = child.childByFieldName(FIELD_NAME); + typeNode = child.childByFieldName(FIELD_TYPE); + break; + } + } + } + + if (nameNode != null) { + String varName = nameNode.text(); + String typeName = typeNode != null ? typeNode.text() : null; + if (varName != null && !varName.isEmpty()) { + TextSpan range = nameNode.span(); + SymbolKey key = new SymbolKey(varName, SymbolKind.LOCAL_VARIABLE, range); + scope.addLocal(new FieldSymbol(key, range, varName, typeName, false, true)); + } + } + } + + /** + * Extracts the exception parameter from a catch clause. + * Grammar: {@code catch_clause} contains a {@code catch_formal_parameter}. + */ + private static void extractCatchParameter(SemanticNode catchNode, Scope scope) { + List children = catchNode.namedChildren(); + for (SemanticNode child : children) { + if (NODE_CATCH_FORMAL_PARAMETER.equals(child.nodeType())) { + addParameterAsLocal(child, scope); + return; + } + } + } + + /** + * Extracts lambda parameters (both explicitly typed and inferred). + * Grammar: lambda_expression has a "parameters" field which is either + * {@code formal_parameters} (typed) or {@code inferred_parameters} + * (just identifiers), or a single {@code identifier} (single param without parens). + */ + private static void extractLambdaParameters(SemanticNode lambdaNode, Scope scope) { + SemanticNode params = lambdaNode.childByFieldName(FIELD_PARAMETERS); + if (params == null) { + // Single identifier parameter: (x) -> ... or x -> ... + // The parameter might be the first named child if it's a bare identifier. + List children = lambdaNode.namedChildren(); + if (!children.isEmpty()) { + SemanticNode first = children.get(0); + if (NODE_IDENTIFIER.equals(first.nodeType())) { + String name = first.text(); + if (name != null && !name.isEmpty()) { + TextSpan range = first.span(); + SymbolKey key = new SymbolKey(name, SymbolKind.PARAMETER, range); + scope.addLocal(new FieldSymbol(key, range, name, null, false, true)); + } + } + } + return; + } + + String paramsType = params.nodeType(); + if (NODE_INFERRED_PARAMETERS.equals(paramsType)) { + // Inferred: (a, b) -> ... — children are bare identifiers. + List children = params.namedChildren(); + for (SemanticNode child : children) { + if (NODE_IDENTIFIER.equals(child.nodeType())) { + String name = child.text(); + if (name != null && !name.isEmpty()) { + TextSpan range = child.span(); + SymbolKey key = new SymbolKey(name, SymbolKind.PARAMETER, range); + scope.addLocal(new FieldSymbol(key, range, name, null, false, true)); + } + } + } + } else if (NODE_LAMBDA_PARAMETERS.equals(paramsType)) { + // Typed: (int a, String b) -> ... + List children = params.namedChildren(); + for (SemanticNode child : children) { + if (NODE_FORMAL_PARAMETER.equals(child.nodeType()) + || NODE_SPREAD_PARAMETER.equals(child.nodeType())) { + addParameterAsLocal(child, scope); + } + } + } else if (NODE_IDENTIFIER.equals(paramsType)) { + // Single identifier directly as the "parameters" field. + String name = params.text(); + if (name != null && !name.isEmpty()) { + TextSpan range = params.span(); + SymbolKey key = new SymbolKey(name, SymbolKind.PARAMETER, range); + scope.addLocal(new FieldSymbol(key, range, name, null, false, true)); + } + } + } + + /** + * Adds a formal_parameter, spread_parameter, or catch_formal_parameter + * as a local to the given scope. + * + *

Grammar for formal_parameter: + * {@code (formal_parameter type: (_) name: (identifier))} + * Also handles {@code dimensions: "[]"} for array parameters.

+ */ + private static void addParameterAsLocal(SemanticNode paramNode, Scope scope) { + SemanticNode nameNode = paramNode.childByFieldName(FIELD_NAME); + SemanticNode typeNode = paramNode.childByFieldName(FIELD_TYPE); + + if (nameNode == null) { + return; + } + + String name = nameNode.text(); + if (name == null || name.isEmpty()) { + return; + } + + String typeName = typeNode != null ? typeNode.text() : null; + + // Check for array dimensions (int[] arr → typeName should be "int[]"). + SemanticNode dims = paramNode.childByFieldName(FIELD_DIMENSIONS); + if (dims != null && typeName != null) { + typeName = typeName + dims.text(); + } + + TextSpan range = nameNode.span(); + SymbolKey key = new SymbolKey(name, SymbolKind.PARAMETER, range); + scope.addLocal(new FieldSymbol(key, range, name, typeName, false, true)); + } + + /** + * Tests whether a node type represents a variable declaration that should + * contribute a local to the enclosing scope. + */ + private static boolean isVariableDeclaration(String nodeType) { + return NODE_LOCAL_VARIABLE_DECLARATION.equals(nodeType); + } + + /** + * Extracts variable declarators from a {@code local_variable_declaration} + * and adds them to the parent scope. + * + *

Grammar: {@code (local_variable_declaration type: (_) + * declarator: (variable_declarator name: (identifier) [value: (_)]))} + * A single declaration may have multiple declarators: {@code int a, b = 1;}

+ */ + private static void extractVariableDeclaration(SemanticNode declNode, Scope scope) { + SemanticNode typeNode = declNode.childByFieldName(FIELD_TYPE); + String typeName = typeNode != null ? typeNode.text() : null; + + // Check for modifiers — detect `final`. + boolean isFinal = false; + List children = declNode.namedChildren(); + for (SemanticNode child : children) { + if ("modifiers".equals(child.nodeType())) { + String modText = child.text(); + if (modText != null && modText.contains("final")) { + isFinal = true; + } + break; + } + } + + // Extract each variable_declarator. + for (SemanticNode child : children) { + if (NODE_VARIABLE_DECLARATOR.equals(child.nodeType())) { + SemanticNode nameNode = child.childByFieldName(FIELD_NAME); + if (nameNode != null) { + String name = nameNode.text(); + if (name != null && !name.isEmpty()) { + TextSpan range = nameNode.span(); + SymbolKey key = new SymbolKey(name, SymbolKind.LOCAL_VARIABLE, range); + scope.addLocal(new FieldSymbol(key, range, name, typeName, false, isFinal)); + } + } + } + } + } + + // ═══════════════════════════════════════════════════════════════════════════ + // Private — helpers + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * Extracts the class name from the parent of a {@code class_body} node. + * The parent is typically a {@code class_declaration}, {@code interface_declaration}, + * or {@code enum_declaration} with a {@code name} field. + */ + private static String extractClassNameFromParent(SemanticNode classBodyNode) { + SemanticNode parent = classBodyNode.parent(); + if (parent == null) { + return null; + } + return extractFieldText(parent, FIELD_NAME); + } + + /** + * Extracts the text of a field child from a node. + * + * @param node the parent node + * @param fieldName the grammar field name + * @return the text, or {@code null} if not found + */ + private static String extractFieldText(SemanticNode node, String fieldName) { + SemanticNode child = node.childByFieldName(fieldName); + if (child == null) { + return null; + } + return child.text(); + } + + /** + * Tests whether a block node is the direct body of a method scope. + * If so, we skip creating a separate BlockScope to avoid unnecessary nesting. + */ + private static boolean isDirectMethodBody(SemanticNode blockNode, Scope methodScope) { + SemanticNode parent = blockNode.parent(); + if (parent == null) { + return false; + } + String parentType = parent.nodeType(); + if (!NODE_METHOD_DECLARATION.equals(parentType) + && !NODE_CONSTRUCTOR_DECLARATION.equals(parentType)) { + return false; + } + // Check if this block is the "body" field of the method. + SemanticNode bodyField = parent.childByFieldName(FIELD_BODY); + if (bodyField == null) { + return false; + } + TextSpan blockSpan = blockNode.span(); + TextSpan bodySpan = bodyField.span(); + return blockSpan != null && bodySpan != null + && blockSpan.getStartByte() == bodySpan.getStartByte() + && blockSpan.getEndByte() == bodySpan.getEndByte(); + } + + /** + * Finds the deepest scope containing the given byte offset by walking + * down from the given scope into its children. + */ + private static Scope findDeepestScope(Scope scope, int byteOffset) { + for (Scope child : scope.children()) { + if (child.containsOffset(byteOffset)) { + return findDeepestScope(child, byteOffset); + } + } + return scope; + } + + /** + * Finds the tightest scope that fully contains the given text span. + */ + private static Scope findTightestContaining(Scope scope, TextSpan target) { + for (Scope child : scope.children()) { + TextSpan childRange = child.range(); + if (childRange != null && childRange.contains(target)) { + return findTightestContaining(child, target); + } + } + return scope; + } +} diff --git a/src/main/java/bigguy/texteditor/semantics/SemanticModel.java b/src/main/java/bigguy/texteditor/semantics/SemanticModel.java new file mode 100644 index 000000000..feb20807a --- /dev/null +++ b/src/main/java/bigguy/texteditor/semantics/SemanticModel.java @@ -0,0 +1,794 @@ +package bigguy.texteditor.semantics; + +import bigguy.texteditor.analysis.IncrementalStrategy; +import bigguy.texteditor.analysis.IncrementalStrategy.InvalidationScope; +import bigguy.texteditor.index.Symbol; +import bigguy.texteditor.index.Symbol.FieldSymbol; +import bigguy.texteditor.index.Symbol.ImportSymbol; +import bigguy.texteditor.index.Symbol.MethodSymbol; +import bigguy.texteditor.index.Symbol.TypeSymbol; +import bigguy.texteditor.index.SymbolKey; +import bigguy.texteditor.index.SymbolKind; +import bigguy.texteditor.syntax.DocumentSyntax; +import bigguy.texteditor.syntax.SemanticNode; +import bigguy.texteditor.treesitter.java.TextSpan; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Optional; +import java.util.Set; + +/** + * Composite coordinator that owns and orchestrates all semantic data structures. + * + *

This is the single entry point for semantic queries, replacing the scattered + * field access on the legacy {@code ScriptDocument}. It owns four sub-components + * and provides convenience query methods that delegate to them:

+ * + *
+ * SemanticModel
+ *   ├── SymbolTable     — all declared symbols + indexed views
+ *   ├── ScopeTree       — scope hierarchy + variable resolution
+ *   ├── ImportIndex      — import resolution
+ *   └── InferenceCache   — lambda/object literal caches
+ * 
+ * + *

The model follows IntelliJ IDEA's {@code FileViewProvider} pattern: a single + * coordinator that lazily builds and caches multiple semantic views of the same + * source file. Callers access sub-components directly for specialised queries, + * or use the convenience methods on this class for common lookups.

+ * + *

Lifecycle

+ *
    + *
  1. Construct an empty model via {@link #SemanticModel()}.
  2. + *
  3. After parsing, call {@link #rebuild(DocumentSyntax)} for a full build.
  4. + *
  5. On subsequent edits, call + * {@link #incrementalUpdate(DocumentSyntax, InvalidationScope)} with the + * scope computed by {@link IncrementalStrategy}.
  6. + *
+ * + *

Thread safety

+ *

Not thread-safe. The orchestrator (background analysis thread) must + * coordinate access. Sub-components have their own synchronization for + * query-vs-mutation safety, but the model itself does not.

+ * + * @see SymbolTable + * @see ScopeTree + * @see ImportIndex + * @see InferenceCache + */ +public final class SemanticModel { + + // ── CST node type constants ──────────────────────────────────────────────── + + private static final String NODE_IMPORT_DECLARATION = "import_declaration"; + private static final String NODE_CLASS_DECLARATION = "class_declaration"; + private static final String NODE_INTERFACE_DECLARATION = "interface_declaration"; + private static final String NODE_ENUM_DECLARATION = "enum_declaration"; + private static final String NODE_ANNOTATION_TYPE_DECLARATION = "annotation_type_declaration"; + private static final String NODE_METHOD_DECLARATION = "method_declaration"; + private static final String NODE_CONSTRUCTOR_DECLARATION = "constructor_declaration"; + private static final String NODE_FIELD_DECLARATION = "field_declaration"; + + private static final String FIELD_NAME = "name"; + private static final String FIELD_BODY = "body"; + private static final String FIELD_TYPE = "type"; + private static final String FIELD_PARAMETERS = "parameters"; + + private static final String NODE_FORMAL_PARAMETER = "formal_parameter"; + private static final String NODE_SPREAD_PARAMETER = "spread_parameter"; + private static final String NODE_VARIABLE_DECLARATOR = "variable_declarator"; + private static final String NODE_IDENTIFIER = "identifier"; + private static final String NODE_SCOPED_IDENTIFIER = "scoped_identifier"; + private static final String NODE_MODIFIERS = "modifiers"; + + private static final String MODIFIER_STATIC = "static"; + private static final String MODIFIER_FINAL = "final"; + private static final String INIT_NAME = ""; + + /** + * Node types that represent type declarations. + */ + private static final Set TYPE_DECLARATION_TYPES; + + static { + Set types = new HashSet(); + types.add(NODE_CLASS_DECLARATION); + types.add(NODE_INTERFACE_DECLARATION); + types.add(NODE_ENUM_DECLARATION); + types.add(NODE_ANNOTATION_TYPE_DECLARATION); + TYPE_DECLARATION_TYPES = Collections.unmodifiableSet(types); + } + + // ── Sub-components ───────────────────────────────────────────────────────── + + private final SymbolTable symbolTable; + private ScopeTree scopeTree; + private final ImportIndex importIndex; + private final InferenceCache inferenceCache; + + // ── State ────────────────────────────────────────────────────────────────── + + private boolean built; + private int compositeVersion; + + // ── Constructor ──────────────────────────────────────────────────────────── + + /** + * Creates an empty semantic model with fresh sub-components. + * + *

The model starts in an unbuilt state ({@link #isBuilt()} returns + * {@code false}). Call {@link #rebuild(DocumentSyntax)} after the first + * parse to populate the semantic data structures.

+ */ + public SemanticModel() { + this.symbolTable = new SymbolTable(); + this.scopeTree = null; + this.importIndex = new ImportIndex(); + this.inferenceCache = new InferenceCache(); + this.built = false; + this.compositeVersion = 0; + } + + // ── Component access ─────────────────────────────────────────────────────── + + /** + * Returns the symbol table containing all declared symbols and indexed views. + * + * @return the symbol table (never {@code null}) + */ + public SymbolTable getSymbolTable() { + return symbolTable; + } + + /** + * Returns the scope tree for variable resolution and scope walking. + * + * @return the scope tree, or {@code null} if the model has not been built yet + */ + public ScopeTree getScopeTree() { + return scopeTree; + } + + /** + * Returns the import index for import resolution. + * + * @return the import index (never {@code null}) + */ + public ImportIndex getImportIndex() { + return importIndex; + } + + /** + * Returns the inference cache for lambda and object literal type caches. + * + * @return the inference cache (never {@code null}) + */ + public InferenceCache getInferenceCache() { + return inferenceCache; + } + + // ── Lifecycle ────────────────────────────────────────────────────────────── + + /** + * Rebuilds the entire semantic model from a parsed CST. + * + *

Called from the background analysis thread after syntax parsing. + * This method performs a complete rebuild of all sub-components:

+ *
    + *
  1. Clear all sub-components
  2. + *
  3. Walk CST to extract imports → populate ImportIndex
  4. + *
  5. Walk CST to extract declarations → populate SymbolTable
  6. + *
  7. Build ScopeTree from CST
  8. + *
  9. Set source version on InferenceCache
  10. + *
+ * + * @param syntax the document syntax produced by the parser + * @throws IllegalArgumentException if {@code syntax} is {@code null} + */ + public void rebuild(DocumentSyntax syntax) { + if (syntax == null) { + throw new IllegalArgumentException("syntax must not be null"); + } + + clear(); + + inferenceCache.setSourceVersion(syntax.getSourceVersion()); + + SemanticNode root = syntax.root(); + if (root == null) { + built = true; + compositeVersion++; + return; + } + + extractImports(root); + extractDeclarations(root, "", ""); + + scopeTree = ScopeTree.buildFromCST(syntax); + + built = true; + compositeVersion++; + } + + /** + * Performs an incremental update based on the invalidation scope. + * + *

Only rebuilds the sub-components that are affected by the change, + * as determined by the {@link InvalidationScope}:

+ *
    + *
  • {@link InvalidationScope#NONE NONE} — no-op (only offset adjustment needed)
  • + *
  • {@link InvalidationScope#LOCAL_SCOPE LOCAL_SCOPE} — rebuild scope tree only
  • + *
  • {@link InvalidationScope#DECLARATION DECLARATION} — full rebuild
  • + *
  • {@link InvalidationScope#IMPORTS IMPORTS} — rebuild imports only
  • + *
  • {@link InvalidationScope#STRUCTURAL STRUCTURAL} — full rebuild
  • + *
+ * + * @param syntax the updated document syntax after reparse + * @param scope the invalidation scope from {@link IncrementalStrategy} + * @throws IllegalArgumentException if either argument is {@code null} + */ + public void incrementalUpdate(DocumentSyntax syntax, InvalidationScope scope) { + if (syntax == null) { + throw new IllegalArgumentException("syntax must not be null"); + } + if (scope == null) { + throw new IllegalArgumentException("scope must not be null"); + } + + inferenceCache.setSourceVersion(syntax.getSourceVersion()); + + switch (scope) { + case NONE: + break; + + case LOCAL_SCOPE: + scopeTree = ScopeTree.buildFromCST(syntax); + compositeVersion++; + break; + + case DECLARATION: + rebuild(syntax); + break; + + case IMPORTS: + rebuildImports(syntax); + compositeVersion++; + break; + + case STRUCTURAL: + rebuild(syntax); + break; + + default: + rebuild(syntax); + break; + } + } + + // ── Convenience queries ──────────────────────────────────────────────────── + + /** + * Resolves a variable name at the given byte offset via scope walking. + * + *

Delegates to {@link ScopeTree#resolveVariable(String, int)} to + * walk the scope chain from the innermost scope containing the offset + * outward until a matching variable declaration is found.

+ * + * @param name the variable name to resolve + * @param byteOffset the byte offset in the source where the reference occurs + * @return an {@link Optional} containing the resolved field symbol, + * or empty if no variable with that name is visible at the offset + */ + public Optional resolveVariable(String name, int byteOffset) { + if (name == null || scopeTree == null) { + return Optional.empty(); + } + FieldSymbol result = scopeTree.resolveVariable(name, byteOffset); + return result != null ? Optional.of(result) : Optional.empty(); + } + + /** + * Resolves a type by simple name. + * + *

First checks the {@link SymbolTable} for locally declared types, + * then falls back to the {@link ImportIndex} to check if the type was + * imported. If found via import, creates a synthetic {@link TypeSymbol} + * from the import information.

+ * + * @param simpleName the unqualified type name to resolve + * @return an {@link Optional} containing the resolved type symbol, + * or empty if the type is not declared or imported + */ + public Optional resolveType(String simpleName) { + if (simpleName == null) { + return Optional.empty(); + } + + List localTypes = symbolTable.getTypesBySimpleName(simpleName); + if (!localTypes.isEmpty()) { + return Optional.of(localTypes.get(0)); + } + + ImportIndex.ImportEntry importEntry = importIndex.resolveBySimpleName(simpleName); + if (importEntry != null) { + TextSpan range = importEntry.getRange(); + if (range == null) { + // Implicit imports have no source location — use a zero-length synthetic span. + range = new TextSpan(0, 0, 0, 0, 0, 0); + } + SymbolKey key = new SymbolKey(simpleName, SymbolKind.CLASS, range); + TypeSymbol synthetic = new TypeSymbol( + key, range, simpleName, + importEntry.getFullPath(), + simpleName + ); + return Optional.of(synthetic); + } + + return Optional.empty(); + } + + /** + * Returns all method symbols with the given name. + * + *

Delegates to {@link SymbolTable#getMethodsByName(String)}.

+ * + * @param name the method name to look up + * @return an unmodifiable list of matching method symbols (never {@code null}) + */ + public List resolveMethods(String name) { + if (name == null) { + return Collections.emptyList(); + } + return symbolTable.getMethodsByName(name); + } + + /** + * Checks whether a byte offset falls inside an excluded region + * (string literal or comment). + * + *

This is a convenience method. Since exclusion data lives on the + * {@link DocumentSyntax} (via its {@code ExcludedRangeIndex}), callers + * should use {@link DocumentSyntax#isExcluded(int)} directly when they + * have a syntax reference. This method exists for cases where the + * last-known syntax snapshot is not readily available.

+ * + * @param byteOffset the byte offset to test (0-based) + * @param syntax the document syntax to query for exclusion data + * @return {@code true} if the offset is inside a string or comment + */ + public boolean isExcluded(int byteOffset, DocumentSyntax syntax) { + if (syntax == null) { + return false; + } + return syntax.isExcluded(byteOffset); + } + + // ── Version tracking ─────────────────────────────────────────────────────── + + /** + * Returns the composite version number. + * + *

This version is incremented on every rebuild or incremental update. + * Consumers can compare versions to detect staleness without inspecting + * individual sub-component versions.

+ * + * @return the composite version number + */ + public int version() { + return compositeVersion; + } + + /** + * Returns whether the model has been built at least once. + * + *

Before the first {@link #rebuild(DocumentSyntax)} call, queries + * will return empty results. Callers should check this flag before + * relying on semantic data.

+ * + * @return {@code true} after at least one successful rebuild + */ + public boolean isBuilt() { + return built; + } + + // ── Reset ────────────────────────────────────────────────────────────────── + + /** + * Clears all sub-components and resets the model to an unbuilt state. + * + *

After calling this method, {@link #isBuilt()} returns {@code false} + * and all queries return empty results until {@link #rebuild(DocumentSyntax)} + * is called again.

+ */ + public void clear() { + symbolTable.clear(); + scopeTree = null; + importIndex.clear(); + inferenceCache.invalidateAll(); + built = false; + } + + // ── Private — import extraction ──────────────────────────────────────────── + + /** + * Walks the root node's direct children to find and extract all import + * declarations, populating the ImportIndex. + */ + private void extractImports(SemanticNode root) { + List children = root.namedChildren(); + for (SemanticNode child : children) { + String nodeType = child.nodeType(); + if (NODE_IMPORT_DECLARATION.equals(nodeType)) { + processImportDeclaration(child); + } + } + } + + /** + * Processes a single import_declaration CST node and adds the result + * to both the ImportIndex and SymbolTable. + */ + private void processImportDeclaration(SemanticNode importNode) { + TextSpan range = importNode.span(); + if (range == null) { + return; + } + + boolean isStatic = hasStaticModifier(importNode); + String rawPath = extractImportPath(importNode); + if (rawPath == null || rawPath.isEmpty()) { + return; + } + + ImportIndex.ImportEntry entry = ImportIndex.ImportEntry.fromFullPath( + rawPath, isStatic, false, range + ); + importIndex.addImport(entry); + + String simpleName = entry.getSimpleName(); + boolean isWildcard = entry.isWildcard(); + String fullPath = entry.getFullPath(); + + SymbolKey key = new SymbolKey(simpleName, SymbolKind.IMPORT, range); + ImportSymbol symbol = new ImportSymbol( + key, range, simpleName, fullPath, isWildcard, isStatic + ); + symbolTable.addSymbol(symbol); + } + + /** + * Extracts the full import path from an import_declaration node. + * + *

Handles both regular imports ({@code import java.util.List;}) and + * wildcard imports ({@code import java.util.*;}) by walking the + * scoped_identifier chain.

+ */ + private String extractImportPath(SemanticNode importNode) { + List children = importNode.namedChildren(); + for (SemanticNode child : children) { + String type = child.nodeType(); + if (NODE_SCOPED_IDENTIFIER.equals(type) || NODE_IDENTIFIER.equals(type)) { + String text = child.text(); + if (text != null) { + return text.trim(); + } + } + } + + String fullText = importNode.text(); + if (fullText != null) { + fullText = fullText.trim(); + if (fullText.startsWith("import ")) { + fullText = fullText.substring("import ".length()).trim(); + } + if (fullText.startsWith("static ")) { + fullText = fullText.substring("static ".length()).trim(); + } + if (fullText.endsWith(";")) { + fullText = fullText.substring(0, fullText.length() - 1).trim(); + } + return fullText; + } + + return null; + } + + /** + * Checks whether an import_declaration node has a "static" keyword. + */ + private boolean hasStaticModifier(SemanticNode importNode) { + String text = importNode.text(); + if (text == null) { + return false; + } + return text.trim().startsWith("import static "); + } + + // ── Private — declaration extraction ─────────────────────────────────────── + + /** + * Recursively walks the CST starting from the given node, extracting + * type, method, and field declarations and adding them to the SymbolTable. + * + * @param node the current CST node to inspect + * @param parentFqn the fully qualified name of the enclosing type (empty string at top level) + * @param parentDot the dot-path from enclosing scope (empty string at top level) + */ + private void extractDeclarations(SemanticNode node, String parentFqn, String parentDot) { + List children = node.namedChildren(); + for (SemanticNode child : children) { + String nodeType = child.nodeType(); + if (nodeType == null) { + continue; + } + + if (TYPE_DECLARATION_TYPES.contains(nodeType)) { + processTypeDeclaration(child, nodeType, parentFqn, parentDot); + } else if (NODE_METHOD_DECLARATION.equals(nodeType)) { + processMethodDeclaration(child, false); + } else if (NODE_CONSTRUCTOR_DECLARATION.equals(nodeType)) { + processMethodDeclaration(child, true); + } else if (NODE_FIELD_DECLARATION.equals(nodeType)) { + processFieldDeclaration(child); + } + } + } + + /** + * Processes a type declaration (class, interface, enum, annotation) and + * recurses into its body for member declarations. + */ + private void processTypeDeclaration(SemanticNode typeNode, String nodeType, + String parentFqn, String parentDot) { + SemanticNode nameNode = typeNode.childByFieldName(FIELD_NAME); + if (nameNode == null) { + return; + } + + String simpleName = nameNode.text(); + if (simpleName == null || simpleName.isEmpty()) { + return; + } + + String fullName = parentFqn.isEmpty() ? simpleName : parentFqn + "." + simpleName; + String dotName = parentDot.isEmpty() ? simpleName : parentDot + "." + simpleName; + + TextSpan range = typeNode.span(); + if (range == null) { + return; + } + + SymbolKind kind = symbolKindForTypeNode(nodeType); + SymbolKey key = new SymbolKey(simpleName, kind, range); + TypeSymbol symbol = new TypeSymbol(key, range, simpleName, fullName, dotName); + symbolTable.addSymbol(symbol); + + SemanticNode body = typeNode.childByFieldName(FIELD_BODY); + if (body != null) { + extractDeclarations(body, fullName, dotName); + } + } + + /** + * Processes a method or constructor declaration node. + */ + private void processMethodDeclaration(SemanticNode methodNode, boolean isConstructor) { + String methodName; + if (isConstructor) { + SemanticNode nameNode = methodNode.childByFieldName(FIELD_NAME); + methodName = (nameNode != null && nameNode.text() != null) + ? nameNode.text() : INIT_NAME; + } else { + SemanticNode nameNode = methodNode.childByFieldName(FIELD_NAME); + if (nameNode == null) { + return; + } + methodName = nameNode.text(); + if (methodName == null || methodName.isEmpty()) { + return; + } + } + + TextSpan range = methodNode.span(); + if (range == null) { + return; + } + + TextSpan bodyRange = null; + SemanticNode bodyNode = methodNode.childByFieldName(FIELD_BODY); + if (bodyNode != null) { + bodyRange = bodyNode.span(); + } + + List parameterNames = extractParameterNames(methodNode); + + SymbolKind kind = isConstructor ? SymbolKind.CONSTRUCTOR : SymbolKind.METHOD; + SymbolKey key = new SymbolKey(methodName, kind, range); + MethodSymbol symbol = new MethodSymbol(key, range, methodName, bodyRange, parameterNames); + symbolTable.addSymbol(symbol); + } + + /** + * Extracts parameter names from a method or constructor declaration. + */ + private List extractParameterNames(SemanticNode methodNode) { + SemanticNode params = methodNode.childByFieldName(FIELD_PARAMETERS); + if (params == null) { + return Collections.emptyList(); + } + + List paramChildren = params.namedChildren(); + if (paramChildren.isEmpty()) { + return Collections.emptyList(); + } + + List names = new ArrayList(paramChildren.size()); + for (SemanticNode param : paramChildren) { + String paramType = param.nodeType(); + if (NODE_FORMAL_PARAMETER.equals(paramType) || NODE_SPREAD_PARAMETER.equals(paramType)) { + SemanticNode nameNode = param.childByFieldName(FIELD_NAME); + if (nameNode != null && nameNode.text() != null) { + names.add(nameNode.text()); + } + } + } + return names; + } + + /** + * Processes a field declaration node. Handles multi-declarator fields + * (e.g., {@code int x, y, z;}) by extracting each declarator's name. + */ + private void processFieldDeclaration(SemanticNode fieldNode) { + TextSpan fieldRange = fieldNode.span(); + if (fieldRange == null) { + return; + } + + String typeName = extractFieldTypeName(fieldNode); + boolean isStatic = hasModifier(fieldNode, MODIFIER_STATIC); + boolean isFinal = hasModifier(fieldNode, MODIFIER_FINAL); + + List declarators = fieldNode.findAll(NODE_VARIABLE_DECLARATOR); + if (declarators.isEmpty()) { + SemanticNode nameNode = fieldNode.childByFieldName(FIELD_NAME); + if (nameNode != null && nameNode.text() != null) { + String name = nameNode.text(); + SymbolKey key = new SymbolKey(name, SymbolKind.FIELD, fieldRange); + FieldSymbol symbol = new FieldSymbol(key, fieldRange, name, typeName, isStatic, isFinal); + symbolTable.addSymbol(symbol); + } + return; + } + + for (SemanticNode declarator : declarators) { + SemanticNode nameNode = declarator.childByFieldName(FIELD_NAME); + if (nameNode == null) { + continue; + } + String name = nameNode.text(); + if (name == null || name.isEmpty()) { + continue; + } + + TextSpan declRange = declarator.span(); + if (declRange == null) { + declRange = fieldRange; + } + + SymbolKey key = new SymbolKey(name, SymbolKind.FIELD, declRange); + FieldSymbol symbol = new FieldSymbol(key, declRange, name, typeName, isStatic, isFinal); + symbolTable.addSymbol(symbol); + } + } + + /** + * Extracts the type name from a field declaration node. + */ + private String extractFieldTypeName(SemanticNode fieldNode) { + SemanticNode typeNode = fieldNode.childByFieldName(FIELD_TYPE); + if (typeNode != null) { + String text = typeNode.text(); + if (text != null) { + return text.trim(); + } + } + return null; + } + + /** + * Checks whether a declaration node has a specific modifier (e.g., "static", "final"). + */ + private boolean hasModifier(SemanticNode declarationNode, String modifier) { + SemanticNode modifiers = declarationNode.childByFieldName(NODE_MODIFIERS); + if (modifiers == null) { + List children = declarationNode.namedChildren(); + for (SemanticNode child : children) { + if (NODE_MODIFIERS.equals(child.nodeType())) { + modifiers = child; + break; + } + } + } + + if (modifiers == null) { + return false; + } + + String modText = modifiers.text(); + if (modText != null) { + return modText.contains(modifier); + } + + return false; + } + + // ── Private — import-only rebuild ────────────────────────────────────────── + + /** + * Rebuilds only the ImportIndex from the current syntax, leaving the + * SymbolTable and ScopeTree intact. Used for + * {@link InvalidationScope#IMPORTS} incremental updates. + */ + private void rebuildImports(DocumentSyntax syntax) { + importIndex.clear(); + + removeImportSymbolsFromTable(); + + SemanticNode root = syntax.root(); + if (root != null) { + extractImports(root); + } + } + + /** + * Removes all import symbols from the SymbolTable. + * Called before re-extracting imports so the table doesn't accumulate stale entries. + */ + private void removeImportSymbolsFromTable() { + List allSymbols = symbolTable.getAllSymbols(); + List nonImports = new ArrayList(allSymbols.size()); + for (Symbol sym : allSymbols) { + if (sym.kind() != SymbolKind.IMPORT) { + nonImports.add(sym); + } + } + symbolTable.replaceAll(nonImports); + } + + // ── Private — utility ────────────────────────────────────────────────────── + + /** + * Maps a tree-sitter type declaration node type to the corresponding SymbolKind. + */ + private static SymbolKind symbolKindForTypeNode(String nodeType) { + if (NODE_CLASS_DECLARATION.equals(nodeType)) { + return SymbolKind.CLASS; + } + if (NODE_INTERFACE_DECLARATION.equals(nodeType)) { + return SymbolKind.INTERFACE; + } + if (NODE_ENUM_DECLARATION.equals(nodeType)) { + return SymbolKind.ENUM; + } + if (NODE_ANNOTATION_TYPE_DECLARATION.equals(nodeType)) { + return SymbolKind.ANNOTATION; + } + return SymbolKind.CLASS; + } + + @Override + public String toString() { + return "SemanticModel{" + + "built=" + built + + ", version=" + compositeVersion + + ", symbols=" + symbolTable.size() + + ", imports=" + importIndex.size() + + ", scopeTree=" + (scopeTree != null ? "present" : "absent") + + '}'; + } +} diff --git a/src/main/java/bigguy/texteditor/semantics/SymbolTable.java b/src/main/java/bigguy/texteditor/semantics/SymbolTable.java new file mode 100644 index 000000000..76aed46ad --- /dev/null +++ b/src/main/java/bigguy/texteditor/semantics/SymbolTable.java @@ -0,0 +1,680 @@ +package bigguy.texteditor.semantics; + +import bigguy.texteditor.index.Symbol; +import bigguy.texteditor.index.Symbol.FieldSymbol; +import bigguy.texteditor.index.Symbol.ImportSymbol; +import bigguy.texteditor.index.Symbol.MethodSymbol; +import bigguy.texteditor.index.Symbol.TypeSymbol; +import bigguy.texteditor.index.SymbolKey; +import bigguy.texteditor.index.SymbolKind; +import bigguy.texteditor.treesitter.java.TextSpan; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.atomic.AtomicInteger; + +/** + * Central registry of all symbols declared in a document. + * + *

Replaces ScriptDocument's triple-redundant type maps ({@code scriptTypes}, + * {@code scriptTypesByFullName}, {@code scriptTypesByDotName}) and scattered + * method/field collections with a single source of truth.

+ * + *

Architecture

+ *

One primary {@link LinkedHashMap} stores all symbols keyed by {@link SymbolKey}. + * Derived index views (types by simple name, types by full name, methods by name, etc.) + * are rebuilt lazily on first access after any mutation. This follows IntelliJ's + * {@code StubIndex} pattern: one canonical store with derived, cached projections.

+ * + *

Thread safety

+ *

Mutation methods ({@link #addSymbol}, {@link #removeSymbol}, {@link #replaceAll}, + * {@link #clear}, {@link #adjustOffsets}) are {@code synchronized} and intended to be + * called from a background analysis thread. Query methods return unmodifiable snapshot + * copies and are safe to call from the UI thread without external synchronization.

+ * + *

Version tracking

+ *

An {@link AtomicInteger} version counter increments on every mutation. Consumers + * can poll {@link #version()} to detect staleness without deep-comparing contents.

+ * + * @see Symbol + * @see SymbolKey + * @see SymbolKind + */ +public final class SymbolTable { + + // ── Primary store ────────────────────────────────────────────────────────── + // Insertion-ordered so getAllSymbols() returns symbols in declaration order. + + private final LinkedHashMap symbols; + + // ── Version counter ──────────────────────────────────────────────────────── + + private final AtomicInteger version; + + // ── Derived indexes (lazily rebuilt) ──────────────────────────────────────── + // All index fields are guarded by `this`. They are set to null on mutation + // and rebuilt on first query access after mutation. + + /** Types grouped by simple (unqualified) name. {@code null} means dirty. */ + private Map> typesBySimpleName; + + /** Types keyed by fully qualified name. {@code null} means dirty. */ + private Map typesByFullName; + + /** Methods grouped by method name. {@code null} means dirty. */ + private Map> methodsByName; + + /** Fields/parameters/locals grouped by name. {@code null} means dirty. */ + private Map> fieldsByName; + + /** Import symbols keyed by their full import path. {@code null} means dirty. */ + private Map importsByPath; + + // ── Constructors ─────────────────────────────────────────────────────────── + + /** + * Creates an empty symbol table. + */ + public SymbolTable() { + this.symbols = new LinkedHashMap<>(); + this.version = new AtomicInteger(0); + } + + /** + * Creates a symbol table pre-populated with the given symbols. + * + * @param initial the symbols to add (must not be {@code null}) + * @throws NullPointerException if {@code initial} is {@code null} + */ + public SymbolTable(List initial) { + this(); + if (initial == null) { + throw new NullPointerException("initial must not be null"); + } + for (Symbol sym : initial) { + if (sym != null) { + symbols.put(sym.key(), sym); + } + } + // Initial population counts as version 1. + if (!symbols.isEmpty()) { + version.set(1); + } + } + + // ═══════════════════════════════════════════════════════════════════════════ + // Mutation (background analysis thread) + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * Removes all symbols from the table and invalidates all derived indexes. + */ + public synchronized void clear() { + if (symbols.isEmpty()) { + return; + } + symbols.clear(); + invalidateIndexes(); + version.incrementAndGet(); + } + + /** + * Adds a symbol to the table. If a symbol with the same key already exists, + * it is replaced. + * + * @param symbol the symbol to add (must not be {@code null}) + * @throws NullPointerException if {@code symbol} is {@code null} + */ + public synchronized void addSymbol(Symbol symbol) { + if (symbol == null) { + throw new NullPointerException("symbol must not be null"); + } + symbols.put(symbol.key(), symbol); + invalidateIndexes(); + version.incrementAndGet(); + } + + /** + * Removes the symbol identified by {@code key}. No-op if the key is not present. + * + * @param key the key of the symbol to remove (must not be {@code null}) + * @throws NullPointerException if {@code key} is {@code null} + */ + public synchronized void removeSymbol(SymbolKey key) { + if (key == null) { + throw new NullPointerException("key must not be null"); + } + Symbol removed = symbols.remove(key); + if (removed != null) { + invalidateIndexes(); + version.incrementAndGet(); + } + } + + /** + * Atomically replaces all symbols in the table with the given list. + * + *

This is the primary bulk-update method used after a full analysis pass. + * It clears the table, inserts all new symbols, and bumps the version + * counter exactly once.

+ * + * @param newSymbols the complete set of symbols to store (must not be {@code null}; + * {@code null} elements within the list are silently skipped) + * @throws NullPointerException if {@code newSymbols} is {@code null} + */ + public synchronized void replaceAll(List newSymbols) { + if (newSymbols == null) { + throw new NullPointerException("newSymbols must not be null"); + } + symbols.clear(); + for (Symbol sym : newSymbols) { + if (sym != null) { + symbols.put(sym.key(), sym); + } + } + invalidateIndexes(); + version.incrementAndGet(); + } + + /** + * Shifts byte offsets of all symbols whose declaration starts at or after + * {@code editStart} by {@code delta} bytes. Used for incremental offset + * adjustment after an edit, so that symbol ranges stay in sync with the + * modified source text without a full re-analysis. + * + *

Symbols whose range starts before {@code editStart} are left unchanged. + * Symbols overlapping the edit point (start < editStart < end) are + * removed, since their ranges are no longer valid.

+ * + *

Note: This mutates the table in-place by rebuilding + * affected entries with adjusted {@link TextSpan}s and new {@link SymbolKey}s. + * The version counter is incremented exactly once.

+ * + * @param editStart the byte offset at which the edit occurred (0-based) + * @param delta the number of bytes inserted (positive) or removed (negative) + */ + public synchronized void adjustOffsets(int editStart, int delta) { + if (delta == 0) { + return; + } + + List adjusted = new ArrayList<>(symbols.size()); + for (Symbol sym : symbols.values()) { + TextSpan range = sym.range(); + int start = range.getStartByte(); + int end = range.getEndByte(); + + if (end <= editStart) { + // Entirely before the edit — keep as-is. + adjusted.add(sym); + } else if (start >= editStart) { + // Entirely at or after the edit — shift both endpoints. + Symbol shifted = shiftSymbol(sym, delta); + if (shifted != null) { + adjusted.add(shifted); + } + } + // else: overlaps the edit point — discard (invalid range). + } + + symbols.clear(); + for (Symbol sym : adjusted) { + symbols.put(sym.key(), sym); + } + invalidateIndexes(); + version.incrementAndGet(); + } + + // ═══════════════════════════════════════════════════════════════════════════ + // Queries (UI thread — return unmodifiable snapshots) + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * Returns the symbol identified by {@code key}, or {@code null} if not found. + * + * @param key the key to look up (must not be {@code null}) + * @return the symbol, or {@code null} + * @throws NullPointerException if {@code key} is {@code null} + */ + public synchronized Symbol getSymbol(SymbolKey key) { + if (key == null) { + throw new NullPointerException("key must not be null"); + } + return symbols.get(key); + } + + /** + * Returns all type symbols that share the given simple (unqualified) name. + * + * @param simpleName the simple type name to look up + * @return an unmodifiable list of matching types (never {@code null}, may be empty) + */ + public synchronized List getTypesBySimpleName(String simpleName) { + if (simpleName == null) { + return Collections.emptyList(); + } + ensureTypesBySimpleName(); + List result = typesBySimpleName.get(simpleName); + return result != null ? result : Collections.emptyList(); + } + + /** + * Returns the type symbol with the given fully qualified name, or {@code null}. + * + * @param fullName the fully qualified type name (e.g. {@code "java.util.List"}) + * @return the matching type symbol, or {@code null} + */ + public synchronized TypeSymbol getTypeByFullName(String fullName) { + if (fullName == null) { + return null; + } + ensureTypesByFullName(); + return typesByFullName.get(fullName); + } + + /** + * Returns all method symbols with the given name. + * + * @param name the method name to look up + * @return an unmodifiable list of matching methods (never {@code null}, may be empty) + */ + public synchronized List getMethodsByName(String name) { + if (name == null) { + return Collections.emptyList(); + } + ensureMethodsByName(); + List result = methodsByName.get(name); + return result != null ? result : Collections.emptyList(); + } + + /** + * Returns all field symbols (fields, parameters, locals) with the given name. + * + * @param name the field name to look up + * @return an unmodifiable list of matching field symbols (never {@code null}, may be empty) + */ + public synchronized List getFieldsByName(String name) { + if (name == null) { + return Collections.emptyList(); + } + ensureFieldsByName(); + List result = fieldsByName.get(name); + return result != null ? result : Collections.emptyList(); + } + + /** + * Returns the import symbol for the given full import path, or {@code null}. + * + * @param fullPath the full import path (e.g. {@code "java.util.List"}) + * @return the matching import symbol, or {@code null} + */ + public synchronized ImportSymbol getImportByPath(String fullPath) { + if (fullPath == null) { + return null; + } + ensureImportsByPath(); + return importsByPath.get(fullPath); + } + + /** + * Returns an unmodifiable snapshot of all symbols in declaration order. + * + * @return all symbols (never {@code null}, may be empty) + */ + public synchronized List getAllSymbols() { + if (symbols.isEmpty()) { + return Collections.emptyList(); + } + return Collections.unmodifiableList(new ArrayList(symbols.values())); + } + + /** + * Returns an unmodifiable snapshot of all type symbols. + * + * @return all types (never {@code null}, may be empty) + */ + public synchronized List getAllTypes() { + List result = new ArrayList<>(); + for (Symbol sym : symbols.values()) { + if (sym instanceof TypeSymbol) { + result.add((TypeSymbol) sym); + } + } + if (result.isEmpty()) { + return Collections.emptyList(); + } + return Collections.unmodifiableList(result); + } + + /** + * Returns an unmodifiable snapshot of all method symbols. + * + * @return all methods (never {@code null}, may be empty) + */ + public synchronized List getAllMethods() { + List result = new ArrayList<>(); + for (Symbol sym : symbols.values()) { + if (sym instanceof MethodSymbol) { + result.add((MethodSymbol) sym); + } + } + if (result.isEmpty()) { + return Collections.emptyList(); + } + return Collections.unmodifiableList(result); + } + + /** + * Returns an unmodifiable snapshot of all field symbols + * (fields, parameters, local variables, enum constants). + * + * @return all fields (never {@code null}, may be empty) + */ + public synchronized List getAllFields() { + List result = new ArrayList<>(); + for (Symbol sym : symbols.values()) { + if (sym instanceof FieldSymbol) { + result.add((FieldSymbol) sym); + } + } + if (result.isEmpty()) { + return Collections.emptyList(); + } + return Collections.unmodifiableList(result); + } + + /** + * Returns an unmodifiable snapshot of all import symbols. + * + * @return all imports (never {@code null}, may be empty) + */ + public synchronized List getAllImports() { + List result = new ArrayList<>(); + for (Symbol sym : symbols.values()) { + if (sym instanceof ImportSymbol) { + result.add((ImportSymbol) sym); + } + } + if (result.isEmpty()) { + return Collections.emptyList(); + } + return Collections.unmodifiableList(result); + } + + // ═══════════════════════════════════════════════════════════════════════════ + // Utilities + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * @return the number of symbols in the table + */ + public synchronized int size() { + return symbols.size(); + } + + /** + * @return {@code true} if the table contains no symbols + */ + public synchronized boolean isEmpty() { + return symbols.isEmpty(); + } + + /** + * Returns the current version number. The version is incremented on every + * mutation. Consumers can cache this value and compare to detect staleness. + * + * @return the version counter (starts at 0 for an empty table) + */ + public int version() { + return version.get(); + } + + /** + * Tests whether a symbol with the given key exists in the table. + * + * @param key the key to test (must not be {@code null}) + * @return {@code true} if present + * @throws NullPointerException if {@code key} is {@code null} + */ + public synchronized boolean containsKey(SymbolKey key) { + if (key == null) { + throw new NullPointerException("key must not be null"); + } + return symbols.containsKey(key); + } + + @Override + public String toString() { + return "SymbolTable{size=" + symbols.size() + + ", version=" + version.get() + + ", types=" + countByKindCategory(true, false, false, false) + + ", methods=" + countByKindCategory(false, true, false, false) + + ", fields=" + countByKindCategory(false, false, true, false) + + ", imports=" + countByKindCategory(false, false, false, true) + + '}'; + } + + // ═══════════════════════════════════════════════════════════════════════════ + // Private — index rebuilding + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * Marks all derived indexes as dirty. Must be called under {@code synchronized}. + */ + private void invalidateIndexes() { + typesBySimpleName = null; + typesByFullName = null; + methodsByName = null; + fieldsByName = null; + importsByPath = null; + } + + /** + * Rebuilds {@link #typesBySimpleName} if dirty. + * Must be called under {@code synchronized}. + */ + private void ensureTypesBySimpleName() { + if (typesBySimpleName != null) { + return; + } + Map> index = new LinkedHashMap<>(); + for (Symbol sym : symbols.values()) { + if (sym instanceof TypeSymbol) { + TypeSymbol ts = (TypeSymbol) sym; + String name = ts.name(); + List bucket = index.get(name); + if (bucket == null) { + bucket = new ArrayList<>(2); + index.put(name, bucket); + } + bucket.add(ts); + } + } + // Freeze each bucket as an unmodifiable list. + for (Map.Entry> entry : index.entrySet()) { + entry.setValue(Collections.unmodifiableList(entry.getValue())); + } + typesBySimpleName = Collections.unmodifiableMap(index); + } + + /** + * Rebuilds {@link #typesByFullName} if dirty. + * Must be called under {@code synchronized}. + */ + private void ensureTypesByFullName() { + if (typesByFullName != null) { + return; + } + Map index = new LinkedHashMap<>(); + for (Symbol sym : symbols.values()) { + if (sym instanceof TypeSymbol) { + TypeSymbol ts = (TypeSymbol) sym; + // fullName is the canonical key; last-write-wins on collision + // (same behaviour as the legacy ScriptDocument maps). + index.put(ts.fullName(), ts); + } + } + typesByFullName = Collections.unmodifiableMap(index); + } + + /** + * Rebuilds {@link #methodsByName} if dirty. + * Must be called under {@code synchronized}. + */ + private void ensureMethodsByName() { + if (methodsByName != null) { + return; + } + Map> index = new LinkedHashMap<>(); + for (Symbol sym : symbols.values()) { + if (sym instanceof MethodSymbol) { + MethodSymbol ms = (MethodSymbol) sym; + String name = ms.name(); + List bucket = index.get(name); + if (bucket == null) { + bucket = new ArrayList<>(2); + index.put(name, bucket); + } + bucket.add(ms); + } + } + for (Map.Entry> entry : index.entrySet()) { + entry.setValue(Collections.unmodifiableList(entry.getValue())); + } + methodsByName = Collections.unmodifiableMap(index); + } + + /** + * Rebuilds {@link #fieldsByName} if dirty. + * Must be called under {@code synchronized}. + */ + private void ensureFieldsByName() { + if (fieldsByName != null) { + return; + } + Map> index = new LinkedHashMap<>(); + for (Symbol sym : symbols.values()) { + if (sym instanceof FieldSymbol) { + FieldSymbol fs = (FieldSymbol) sym; + String name = fs.name(); + List bucket = index.get(name); + if (bucket == null) { + bucket = new ArrayList<>(2); + index.put(name, bucket); + } + bucket.add(fs); + } + } + for (Map.Entry> entry : index.entrySet()) { + entry.setValue(Collections.unmodifiableList(entry.getValue())); + } + fieldsByName = Collections.unmodifiableMap(index); + } + + /** + * Rebuilds {@link #importsByPath} if dirty. + * Must be called under {@code synchronized}. + */ + private void ensureImportsByPath() { + if (importsByPath != null) { + return; + } + Map index = new LinkedHashMap<>(); + for (Symbol sym : symbols.values()) { + if (sym instanceof ImportSymbol) { + ImportSymbol is = (ImportSymbol) sym; + index.put(is.fullPath(), is); + } + } + importsByPath = Collections.unmodifiableMap(index); + } + + // ═══════════════════════════════════════════════════════════════════════════ + // Private — offset shifting helpers + // ═══════════════════════════════════════════════════════════════════════════ + + /** + * Creates a new {@link TextSpan} shifted by {@code delta} bytes. + * Row/column information is cleared (set to 0) because accurate + * line mapping requires the full source text, which we don't have here. + * The next full analysis pass will provide correct row/column data. + * + * @param original the original span + * @param delta bytes to add to both start and end + * @return the shifted span, or {@code null} if the shift would produce + * a negative start byte + */ + private static TextSpan shiftSpan(TextSpan original, int delta) { + int newStart = original.getStartByte() + delta; + int newEnd = original.getEndByte() + delta; + if (newStart < 0 || newEnd < newStart) { + return null; + } + // Row/column zeroed — will be corrected by the next full analysis pass. + return new TextSpan(0, 0, 0, 0, newStart, newEnd); + } + + /** + * Creates a shifted copy of the given symbol. Returns {@code null} if the + * shift would produce an invalid range. + * + * @param sym the symbol to shift + * @param delta bytes to add + * @return the shifted symbol, or {@code null} + */ + private static Symbol shiftSymbol(Symbol sym, int delta) { + TextSpan shifted = shiftSpan(sym.range(), delta); + if (shifted == null) { + return null; + } + SymbolKey newKey = new SymbolKey(sym.key().name(), sym.key().kind(), shifted); + + if (sym instanceof TypeSymbol) { + TypeSymbol ts = (TypeSymbol) sym; + return new TypeSymbol(newKey, shifted, ts.name(), ts.fullName(), ts.dotName()); + } + if (sym instanceof MethodSymbol) { + MethodSymbol ms = (MethodSymbol) sym; + TextSpan shiftedBody = null; + if (ms.bodyRange() != null) { + shiftedBody = shiftSpan(ms.bodyRange(), delta); + } + return new MethodSymbol(newKey, shifted, ms.name(), shiftedBody, ms.parameterNames()); + } + if (sym instanceof FieldSymbol) { + FieldSymbol fs = (FieldSymbol) sym; + return new FieldSymbol(newKey, shifted, fs.name(), fs.typeName(), fs.isStatic(), fs.isFinal()); + } + if (sym instanceof ImportSymbol) { + ImportSymbol is = (ImportSymbol) sym; + return new ImportSymbol(newKey, shifted, is.name(), is.fullPath(), is.isWildcard(), is.isStatic()); + } + // Unknown symbol subtype — should not happen with the closed hierarchy. + return null; + } + + /** + * Counts symbols whose {@link SymbolKind} matches the requested category flags. + * Used only for {@link #toString()} diagnostics. + */ + private int countByKindCategory(boolean types, boolean callables, + boolean variables, boolean imports) { + int count = 0; + for (Symbol sym : symbols.values()) { + SymbolKind k = sym.kind(); + if (types && k.isType()) { + count++; + } else if (callables && k.isCallable()) { + count++; + } else if (variables && k.isVariable()) { + count++; + } else if (imports && k == SymbolKind.IMPORT) { + count++; + } + } + return count; + } +} diff --git a/src/main/java/bigguy/texteditor/syntax/DocumentSyntax.java b/src/main/java/bigguy/texteditor/syntax/DocumentSyntax.java new file mode 100644 index 000000000..2869ba3b4 --- /dev/null +++ b/src/main/java/bigguy/texteditor/syntax/DocumentSyntax.java @@ -0,0 +1,282 @@ +package bigguy.texteditor.syntax; + +import bigguy.texteditor.treesitter.java.SyntaxNode; +import bigguy.texteditor.treesitter.java.SyntaxTree; +import bigguy.texteditor.treesitter.java.TextSpan; + +import java.util.ArrayList; +import java.util.IdentityHashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +/** + * Document-level syntax representation combining CST structure with + * semantic enrichment capabilities. + * + *

Wraps the low-level {@link SyntaxTree} (tree-sitter) and provides:

+ *
    + *
  1. {@link SemanticNode} factory with identity caching (avoids re-wrapping)
  2. + *
  3. {@link ExcludedRangeIndex} for string/comment skipping
  4. + *
  5. Source version tracking for invalidation
  6. + *
  7. Node lookup by byte offset
  8. + *
+ * + *

Analogous to IntelliJ's {@code PsiFile} (root PSI element for a file) + * and Zed's {@code SyntaxSnapshot} (immutable syntax view).

+ * + *

Thread safety

+ *

Not thread-safe. The orchestrator must coordinate access + * (e.g., via copy-on-parse or synchronization).

+ */ +public final class DocumentSyntax { + + private static final String[] EXCLUDED_NODE_TYPES = { + "string_literal", + "string_fragment", + "character_literal", + "line_comment", + "block_comment", + "template_literal" + }; + + private final SyntaxTree syntaxTree; + private final int sourceVersion; + private final ExcludedRangeIndex excluded; + private final Map nodeCache; + + private DocumentSyntax(SyntaxTree syntaxTree, int sourceVersion, ExcludedRangeIndex excluded) { + this.syntaxTree = syntaxTree; + this.sourceVersion = sourceVersion; + this.excluded = excluded; + this.nodeCache = new IdentityHashMap<>(); + } + + /** + * Creates a new {@code DocumentSyntax} from a parsed tree-sitter tree. + * + *

Walks the CST to build the {@link ExcludedRangeIndex} for string + * and comment regions, and initialises an empty node cache.

+ * + * @param tree the parsed tree-sitter syntax tree + * @param version the source version this tree was parsed from + * @return a new document syntax instance + * @throws IllegalArgumentException if {@code tree} is {@code null} + */ + public static DocumentSyntax create(SyntaxTree tree, int version) { + if (tree == null) { + throw new IllegalArgumentException("tree must not be null"); + } + ExcludedRangeIndex excludedIndex = buildExcludedRanges(tree.getRootNode()); + return new DocumentSyntax(tree, version, excludedIndex); + } + + /** + * Wraps a raw {@link SyntaxNode} into a {@link SemanticNode}, returning a + * cached instance if one already exists for this node identity. + * + * @param node the CST node to wrap (may be {@code null}) + * @return the cached or newly created {@code SemanticNode}, or {@code null} + * if {@code node} is {@code null} or a null-node + */ + public SemanticNode wrap(SyntaxNode node) { + if (node == null || node.isNull()) { + return null; + } + SemanticNode cached = nodeCache.get(node); + if (cached != null) { + return cached; + } + SemanticNode created = new SemanticNode(node, this); + nodeCache.put(node, created); + return created; + } + + /** + * @return the root node of the syntax tree, wrapped as a {@link SemanticNode} + */ + public SemanticNode root() { + return wrap(syntaxTree.getRootNode()); + } + + /** + * @return the full source text that was parsed to produce this tree + */ + public String getSourceText() { + return syntaxTree.getSourceText(); + } + + /** + * @return the source version number this tree was parsed from + */ + public int getSourceVersion() { + return sourceVersion; + } + + /** + * Tests whether the given byte offset falls inside a string literal or comment. + * + * @param offset the byte offset to test (0-based) + * @return {@code true} if the offset is inside an excluded region + */ + public boolean isExcluded(int offset) { + return excluded.contains(offset); + } + + /** + * Tests whether any part of the given span overlaps with a string literal or comment. + * + * @param span the text span to test + * @return {@code true} if the span overlaps any excluded region + */ + public boolean isExcluded(TextSpan span) { + if (span == null) { + return false; + } + return excluded.overlaps(span.getStartByte(), span.getEndByte()); + } + + /** + * @return the excluded range index for direct querying + */ + public ExcludedRangeIndex getExcludedRanges() { + return excluded; + } + + /** + * Finds the deepest named node containing the given byte offset. + * + *

Walks from the root downward, at each level picking the child whose + * span contains the offset, until no further narrowing is possible.

+ * + * @param byteOffset the byte offset to search for (0-based) + * @return the deepest named {@link SemanticNode} containing the offset, + * or {@code null} if the offset is outside the tree + */ + public SemanticNode nodeAtOffset(int byteOffset) { + SyntaxNode root = syntaxTree.getRootNode(); + if (root == null || root.isNull()) { + return null; + } + TextSpan rootSpan = root.getSpan(); + if (rootSpan == null || !rootSpan.containsByte(byteOffset)) { + return null; + } + SyntaxNode deepest = findDeepestNamedNode(root, byteOffset); + return wrap(deepest); + } + + /** + * @return the underlying {@link SyntaxTree} for direct tree-sitter operations + * (queries, changed-range computation, etc.) + */ + public SyntaxTree unwrapTree() { + return syntaxTree; + } + + /** + * @return {@code true} if the parse tree contains any syntax errors + */ + public boolean hasErrors() { + return syntaxTree.hasErrors(); + } + + /** + * Clears the entire node cache, discarding all {@link SemanticNode} wrappers + * and their attached semantic data. Used after a full reparse. + */ + public void invalidateCache() { + nodeCache.clear(); + } + + /** + * Evicts cached nodes whose spans overlap the given byte range. + * Used after an incremental reparse to discard stale semantic data + * in the edited region while preserving unaffected nodes. + * + * @param startByte inclusive start of the invalidated range + * @param endByte exclusive end of the invalidated range + */ + public void invalidateRange(int startByte, int endByte) { + Iterator> iterator = nodeCache.entrySet().iterator(); + while (iterator.hasNext()) { + Map.Entry entry = iterator.next(); + SyntaxNode node = entry.getKey(); + TextSpan span = node.getSpan(); + if (span != null && span.getStartByte() < endByte && startByte < span.getEndByte()) { + iterator.remove(); + } + } + } + + private static SyntaxNode findDeepestNamedNode(SyntaxNode node, int byteOffset) { + SyntaxNode best = node; + int childCount = node.getChildCount(); + for (int i = 0; i < childCount; i++) { + SyntaxNode child = node.getChild(i); + if (child == null) { + continue; + } + TextSpan childSpan = child.getSpan(); + if (childSpan == null || !childSpan.containsByte(byteOffset)) { + continue; + } + SyntaxNode deeper = findDeepestNamedNode(child, byteOffset); + if (deeper.isNamed()) { + best = deeper; + } + } + return best; + } + + private static ExcludedRangeIndex buildExcludedRanges(SyntaxNode root) { + if (root == null || root.isNull()) { + return ExcludedRangeIndex.empty(); + } + List ranges = new ArrayList<>(); + collectExcludedRanges(root, ranges); + if (ranges.isEmpty()) { + return ExcludedRangeIndex.empty(); + } + return ExcludedRangeIndex.build(ranges); + } + + private static void collectExcludedRanges(SyntaxNode node, List out) { + String type = node.getType(); + if (type != null && isExcludedNodeType(type)) { + TextSpan span = node.getSpan(); + if (span != null && span.getByteLength() > 0) { + out.add(new ExcludedRangeIndex.Range(span.getStartByte(), span.getEndByte())); + } + return; + } + int childCount = node.getChildCount(); + for (int i = 0; i < childCount; i++) { + SyntaxNode child = node.getChild(i); + if (child != null) { + collectExcludedRanges(child, out); + } + } + } + + private static boolean isExcludedNodeType(String type) { + for (String excluded : EXCLUDED_NODE_TYPES) { + if (excluded.equals(type)) { + return true; + } + } + return false; + } + + @Override + public String toString() { + SyntaxNode root = syntaxTree.getRootNode(); + int nodeCount = nodeCache.size(); + return "DocumentSyntax{version=" + sourceVersion + + ", errors=" + syntaxTree.hasErrors() + + ", cached=" + nodeCount + + ", excluded=" + excluded.size() + + ", root=" + (root != null ? root.getType() : "null") + + '}'; + } +} diff --git a/src/main/java/bigguy/texteditor/syntax/ExcludedRangeIndex.java b/src/main/java/bigguy/texteditor/syntax/ExcludedRangeIndex.java new file mode 100644 index 000000000..d899f7618 --- /dev/null +++ b/src/main/java/bigguy/texteditor/syntax/ExcludedRangeIndex.java @@ -0,0 +1,271 @@ +package bigguy.texteditor.syntax; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +/** + * An immutable, sorted index of non-overlapping byte ranges that should be + * excluded from semantic analysis (string literals, comments, block comments). + * + *

Built once from a tree-sitter CST walk, this index answers containment + * and overlap queries in O(log n) via binary search over a flat sorted array. + * After an edit, call {@link #shiftRanges(int, int)} to produce a new index + * with adjusted offsets rather than rebuilding from scratch.

+ */ +public final class ExcludedRangeIndex { + + /** + * A single contiguous byte range within the source text. + * Immutable value object with natural ordering by start offset. + */ + public static final class Range implements Comparable { + + private final int start; + private final int end; + + /** + * @param start inclusive start byte offset (0-based) + * @param end exclusive end byte offset (0-based) + * @throws IllegalArgumentException if start exceeds end + */ + public Range(int start, int end) { + if (start > end) { + throw new IllegalArgumentException( + "start (" + start + ") must not exceed end (" + end + ")"); + } + this.start = start; + this.end = end; + } + + /** @return inclusive start byte offset */ + public int start() { return start; } + + /** @return exclusive end byte offset */ + public int end() { return end; } + + /** + * @param offset the byte offset to test + * @return {@code true} if {@code start <= offset < end} + */ + public boolean contains(int offset) { + return offset >= start && offset < end; + } + + /** + * @param otherStart inclusive start of the query interval + * @param otherEnd exclusive end of the query interval + * @return {@code true} if the intervals share at least one byte + */ + public boolean overlaps(int otherStart, int otherEnd) { + return this.start < otherEnd && otherStart < this.end; + } + + @Override + public int compareTo(Range other) { + int cmp = Integer.compare(this.start, other.start); + return cmp != 0 ? cmp : Integer.compare(this.end, other.end); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (!(obj instanceof Range)) return false; + Range that = (Range) obj; + return start == that.start && end == that.end; + } + + @Override + public int hashCode() { + return 31 * start + end; + } + + @Override + public String toString() { + return "[" + start + ".." + end + ")"; + } + } + + private static final ExcludedRangeIndex EMPTY = new ExcludedRangeIndex(new Range[0]); + + private final Range[] ranges; + + private ExcludedRangeIndex(Range[] ranges) { + this.ranges = ranges; + } + + /** + * Returns an empty index that excludes nothing. + * + * @return a shared empty instance + */ + public static ExcludedRangeIndex empty() { + return EMPTY; + } + + /** + * Builds an index from an unsorted, potentially overlapping collection of ranges. + * The builder sorts the input, merges overlapping/adjacent ranges, and produces + * a minimal, non-overlapping representation. + * + * @param rawRanges the ranges to index (may be unsorted and overlapping) + * @return an immutable index over the merged ranges + */ + public static ExcludedRangeIndex build(List rawRanges) { + if (rawRanges.isEmpty()) { + return EMPTY; + } + + Range[] sorted = rawRanges.toArray(new Range[0]); + Arrays.sort(sorted); + + Range[] merged = new Range[sorted.length]; + int count = 0; + Range current = sorted[0]; + + for (int i = 1; i < sorted.length; i++) { + Range next = sorted[i]; + if (next.start <= current.end) { + current = new Range(current.start, Math.max(current.end, next.end)); + } else { + merged[count++] = current; + current = next; + } + } + merged[count++] = current; + + return new ExcludedRangeIndex(Arrays.copyOf(merged, count)); + } + + /** + * Tests whether the given byte offset falls inside any excluded range. + * Runs in O(log n) via binary search. + * + * @param offset the byte offset to test (0-based) + * @return {@code true} if the offset is inside a string literal, comment, etc. + */ + public boolean contains(int offset) { + int lo = 0; + int hi = ranges.length - 1; + + while (lo <= hi) { + int mid = lo + (hi - lo) / 2; + Range r = ranges[mid]; + + if (offset < r.start) { + hi = mid - 1; + } else if (offset >= r.end) { + lo = mid + 1; + } else { + return true; + } + } + return false; + } + + /** + * Tests whether any excluded range overlaps with the half-open interval + * {@code [start, end)}. Runs in O(log n). + * + * @param start inclusive start byte offset + * @param end exclusive end byte offset + * @return {@code true} if any excluded range intersects the query interval + */ + public boolean overlaps(int start, int end) { + if (start >= end || ranges.length == 0) { + return false; + } + + int lo = 0; + int hi = ranges.length - 1; + + while (lo <= hi) { + int mid = lo + (hi - lo) / 2; + Range r = ranges[mid]; + + if (r.end <= start) { + lo = mid + 1; + } else if (r.start >= end) { + hi = mid - 1; + } else { + return true; + } + } + return false; + } + + /** + * Produces a new index with all ranges shifted to account for an edit operation. + * Ranges entirely before {@code editStart} are unchanged. Ranges overlapping + * the edit point are expanded/contracted. Ranges after are shifted by {@code delta}. + * + * @param editStart the byte offset where the edit occurred + * @param delta positive for insertion, negative for deletion + * @return a new index with adjusted ranges + */ + public ExcludedRangeIndex shiftRanges(int editStart, int delta) { + if (ranges.length == 0 || delta == 0) { + return this; + } + + Range[] shifted = new Range[ranges.length]; + int count = 0; + + for (Range r : ranges) { + if (r.end <= editStart) { + shifted[count++] = r; + } else if (r.start >= editStart) { + int newStart = r.start + delta; + int newEnd = r.end + delta; + if (newEnd > 0 && newStart < newEnd) { + shifted[count++] = new Range(Math.max(0, newStart), newEnd); + } + } else { + int newEnd = r.end + delta; + if (newEnd > r.start) { + shifted[count++] = new Range(r.start, newEnd); + } + } + } + + if (count == 0) { + return EMPTY; + } + return new ExcludedRangeIndex(Arrays.copyOf(shifted, count)); + } + + /** @return the number of excluded ranges in this index */ + public int size() { + return ranges.length; + } + + /** @return {@code true} if no ranges are indexed */ + public boolean isEmpty() { + return ranges.length == 0; + } + + /** + * Returns an unmodifiable view of all ranges, sorted by start offset. + * + * @return the excluded ranges + */ + public List getRanges() { + return Collections.unmodifiableList(Arrays.asList(ranges)); + } + + @Override + public String toString() { + if (ranges.length == 0) { + return "ExcludedRangeIndex{empty}"; + } + StringBuilder sb = new StringBuilder("ExcludedRangeIndex{"); + for (int i = 0; i < ranges.length; i++) { + if (i > 0) { + sb.append(", "); + } + sb.append(ranges[i]); + } + sb.append('}'); + return sb.toString(); + } +} diff --git a/src/main/java/bigguy/texteditor/syntax/SemanticNode.java b/src/main/java/bigguy/texteditor/syntax/SemanticNode.java new file mode 100644 index 000000000..b84016bb1 --- /dev/null +++ b/src/main/java/bigguy/texteditor/syntax/SemanticNode.java @@ -0,0 +1,463 @@ +package bigguy.texteditor.syntax; + +import bigguy.texteditor.treesitter.java.SyntaxNode; +import bigguy.texteditor.treesitter.java.TextSpan; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +/** + * PSI-style wrapper around a tree-sitter CST node that provides semantic + * enrichment without modifying the underlying concrete syntax tree. + * + *

The {@link SyntaxNode} is the structure (syntax) — it knows about + * node types, positions, text, and parent/child relationships. This class is + * the meaning (semantics layered on top) — it carries lazily-resolved + * type information, symbol bindings, and scope references.

+ * + *

Design (IntelliJ IDEA analogy)

+ * + * + * + * + * + *
IntelliJThis project
{@code ASTNode}{@link SyntaxNode} (raw CST)
{@code PsiElement}{@code SemanticNode} (semantic view)
{@code PsiFile}{@link DocumentSyntax} (root container)
+ * + *

Semantic slots

+ *

The three mutable slots ({@code resolvedType}, {@code symbol}, {@code scope}) + * are typed as {@link Object} intentionally. The concrete types (TypeInfo, Symbol, + * Scope) live in downstream packages that do not yet exist. Using {@code Object} + * avoids circular package dependencies. Callers access them through generic + * getters that perform an unchecked cast — the analysis pipeline guarantees the + * stored object matches the expected type at each call site.

+ * + *

Semantic data is populated lazily during analysis and may be {@code null} + * when in "dumb mode" (i.e., only the CST has been built, no analysis pass + * has run yet).

+ * + *

Thread safety

+ *

Not thread-safe. The owning {@link DocumentSyntax} must coordinate access.

+ */ +public final class SemanticNode { + + private static final Set SCOPE_INTRODUCING_TYPES = Collections.unmodifiableSet( + new HashSet<>(Arrays.asList( + "program", + "class_body", + "method_declaration", + "constructor_declaration", + "block", + "for_statement", + "enhanced_for_statement", + "while_statement", + "do_statement", + "if_statement", + "try_statement", + "catch_clause", + "switch_block_statement_group", + "lambda_expression", + "static_initializer" + )) + ); + + private static final Set TYPE_NODE_TYPES = Collections.unmodifiableSet( + new HashSet<>(Arrays.asList( + "type_identifier", + "generic_type", + "array_type", + "scoped_type_identifier", + "wildcard", + "void_type", + "integral_type", + "floating_point_type", + "boolean_type" + )) + ); + + private static final Set LITERAL_KEYWORDS = Collections.unmodifiableSet( + new HashSet<>(Arrays.asList("true", "false", "null")) + ); + + private final SyntaxNode syntaxNode; + private final DocumentSyntax document; + + private Object resolvedType; + private Object symbol; + private Object scope; + + /** + * Creates a semantic wrapper around the given CST node. + * + *

Package-private: only {@link DocumentSyntax#wrap(SyntaxNode)} should + * create instances, ensuring identity caching is respected.

+ * + * @param syntaxNode the underlying CST node (must not be null or null-node) + * @param document the owning document (must not be null) + */ + SemanticNode(SyntaxNode syntaxNode, DocumentSyntax document) { + if (syntaxNode == null || syntaxNode.isNull()) { + throw new IllegalArgumentException("syntaxNode must not be null or a null-node"); + } + if (document == null) { + throw new IllegalArgumentException("document must not be null"); + } + this.syntaxNode = syntaxNode; + this.document = document; + } + + /** + * Returns the tree-sitter node type string (e.g., {@code "method_declaration"}, + * {@code "identifier"}). + * + * @return the node type, or {@code null} if the underlying node is null + */ + public String nodeType() { + return syntaxNode.getType(); + } + + /** + * Returns the source text span (byte offsets and row/column positions) + * covered by this node. + * + * @return the span, or {@code null} if the underlying node is null + */ + public TextSpan span() { + return syntaxNode.getSpan(); + } + + /** + * @return the source text covered by this node, or {@code null} if unavailable + */ + public String text() { + return syntaxNode.getText(); + } + + /** + * @return {@code true} if this is a named node in the grammar (not anonymous punctuation) + */ + public boolean isNamed() { + return syntaxNode.isNamed(); + } + + /** + * @return {@code true} if this node or any descendant contains a parse error + */ + public boolean hasError() { + return syntaxNode.hasError(); + } + + /** + * @return {@code true} if this node itself is an ERROR node + */ + public boolean isError() { + return syntaxNode.isError(); + } + + /** + * @return {@code true} if this node is a MISSING node (expected but absent in source) + */ + public boolean isMissing() { + return syntaxNode.isMissing(); + } + + /** + * @return total number of children (named and anonymous) + */ + public int childCount() { + return syntaxNode.getChildCount(); + } + + /** + * Returns the child at the given index, wrapped as a {@code SemanticNode}. + * + * @param index zero-based child index + * @return the wrapped child, or {@code null} if the index is out of range + */ + public SemanticNode child(int index) { + return document.wrap(syntaxNode.getChild(index)); + } + + /** + * Returns the named child at the given index, wrapped as a {@code SemanticNode}. + * + * @param index zero-based named-child index + * @return the wrapped named child, or {@code null} if the index is out of range + */ + public SemanticNode namedChild(int index) { + return document.wrap(syntaxNode.getNamedChild(index)); + } + + /** + * Returns the child with the given field name (as defined by tree-sitter grammar), + * wrapped as a {@code SemanticNode}. + * + * @param name the field name (e.g., {@code "name"}, {@code "body"}, {@code "type"}) + * @return the wrapped child, or {@code null} if no child has that field name + */ + public SemanticNode childByFieldName(String name) { + return document.wrap(syntaxNode.getChildByFieldName(name)); + } + + /** + * @return the wrapped parent, or {@code null} if this is the root + */ + public SemanticNode parent() { + return document.wrap(syntaxNode.getParent()); + } + + /** + * @return the wrapped next sibling (named or anonymous), or {@code null} + */ + public SemanticNode nextSibling() { + return document.wrap(syntaxNode.getNextSibling()); + } + + /** + * @return the wrapped next named sibling, or {@code null} + */ + public SemanticNode nextNamedSibling() { + return document.wrap(syntaxNode.getNextNamedSibling()); + } + + /** + * @return the wrapped previous sibling (named or anonymous), or {@code null} + */ + public SemanticNode prevSibling() { + return document.wrap(syntaxNode.getPrevSibling()); + } + + /** + * @return an unmodifiable list of all named children, each wrapped as {@code SemanticNode} + */ + public List namedChildren() { + List rawChildren = syntaxNode.getNamedChildren(); + if (rawChildren.isEmpty()) { + return Collections.emptyList(); + } + List result = new ArrayList<>(rawChildren.size()); + for (SyntaxNode raw : rawChildren) { + SemanticNode wrapped = document.wrap(raw); + if (wrapped != null) { + result.add(wrapped); + } + } + return Collections.unmodifiableList(result); + } + + /** + * Finds the first descendant matching the given tree-sitter node type. + * + * @param nodeType the node type to search for (e.g., {@code "identifier"}) + * @return the first matching descendant wrapped as {@code SemanticNode}, or {@code null} + */ + public SemanticNode findFirst(String nodeType) { + return document.wrap(syntaxNode.findFirst(nodeType)); + } + + /** + * Finds all descendants matching the given tree-sitter node type. + * + * @param nodeType the node type to search for + * @return an unmodifiable list of matching descendants, never {@code null} + */ + public List findAll(String nodeType) { + List rawMatches = syntaxNode.findAll(nodeType); + if (rawMatches.isEmpty()) { + return Collections.emptyList(); + } + List result = new ArrayList<>(rawMatches.size()); + for (SyntaxNode raw : rawMatches) { + SemanticNode wrapped = document.wrap(raw); + if (wrapped != null) { + result.add(wrapped); + } + } + return Collections.unmodifiableList(result); + } + + /** + * Returns the resolved type information attached to this node. + * The unchecked cast is safe — the analysis pipeline guarantees type consistency. + * + * @param the expected type (typically TypeInfo) + * @return the resolved type, or {@code null} if not yet resolved + */ + @SuppressWarnings("unchecked") + public T getResolvedType() { + return (T) resolvedType; + } + + /** + * @param the type of the value (typically TypeInfo) + * @param type the resolved type information to attach + */ + public void setResolvedType(T type) { + this.resolvedType = type; + } + + /** + * Returns the symbol binding attached to this node (a named declaration + * that this node declares or references). + * + * @param the expected type (typically Symbol) + * @return the symbol, or {@code null} if not yet resolved + */ + @SuppressWarnings("unchecked") + public T getSymbol() { + return (T) symbol; + } + + /** + * @param the type of the value (typically Symbol) + * @param symbol the symbol binding to attach + */ + public void setSymbol(T symbol) { + this.symbol = symbol; + } + + /** + * Returns the scope attached to this node (lexical scope that this node + * introduces or belongs to). + * + * @param the expected type (typically Scope) + * @return the scope, or {@code null} if not yet resolved + */ + @SuppressWarnings("unchecked") + public T getScope() { + return (T) scope; + } + + /** + * @param the type of the value (typically Scope) + * @param scope the scope to attach + */ + public void setScope(T scope) { + this.scope = scope; + } + + /** @return {@code true} if a resolved type has been attached */ + public boolean hasResolvedType() { + return resolvedType != null; + } + + /** @return {@code true} if a symbol binding has been attached */ + public boolean hasSymbol() { + return symbol != null; + } + + /** @return {@code true} if a scope has been attached */ + public boolean hasScope() { + return scope != null; + } + + /** + * @return {@code true} if the node type ends with {@code "_declaration"} + */ + public boolean isDeclaration() { + String type = syntaxNode.getType(); + return type != null && type.endsWith("_declaration"); + } + + /** + * @return {@code true} if this node represents an expression (types ending + * with {@code "_expression"}, or {@code "identifier"}, {@code "method_invocation"}, etc.) + */ + public boolean isExpression() { + String type = syntaxNode.getType(); + if (type == null) { + return false; + } + return type.endsWith("_expression") + || "identifier".equals(type) + || "method_invocation".equals(type) + || "field_access".equals(type) + || "array_access".equals(type) + || "object_creation_expression".equals(type) + || "cast_expression".equals(type); + } + + /** + * @return {@code true} if the node type ends with {@code "_statement"} + */ + public boolean isStatement() { + String type = syntaxNode.getType(); + return type != null && type.endsWith("_statement"); + } + + /** + * @return {@code true} if the node type contains {@code "literal"} or is + * {@code "true"}, {@code "false"}, or {@code "null"} + */ + public boolean isLiteral() { + String type = syntaxNode.getType(); + if (type == null) { + return false; + } + return type.contains("literal") || LITERAL_KEYWORDS.contains(type); + } + + /** + * @return {@code true} if this node is a type reference ({@code "type_identifier"}, + * {@code "generic_type"}, {@code "array_type"}, etc.) + */ + public boolean isTypeNode() { + String type = syntaxNode.getType(); + return type != null && TYPE_NODE_TYPES.contains(type); + } + + /** + * @return {@code true} if the node type is exactly {@code "identifier"} + */ + public boolean isIdentifier() { + return "identifier".equals(syntaxNode.getType()); + } + + /** + * @return {@code true} if this node introduces a new lexical scope + * (program, class_body, method_declaration, block, lambda_expression, etc.) + */ + public boolean isScopeIntroducing() { + String type = syntaxNode.getType(); + return type != null && SCOPE_INTRODUCING_TYPES.contains(type); + } + + /** + * Returns the underlying raw CST node. Prefer the delegating methods on this class; + * use this escape hatch only when the low-level tree-sitter API is needed directly. + * + * @return the underlying {@link SyntaxNode}, never {@code null} + */ + public SyntaxNode unwrap() { + return syntaxNode; + } + + /** + * @return the {@link DocumentSyntax} that owns this node + */ + public DocumentSyntax getDocument() { + return document; + } + + @Override + public String toString() { + TextSpan s = syntaxNode.getSpan(); + String type = syntaxNode.getType(); + StringBuilder sb = new StringBuilder("SemanticNode{"); + sb.append(type); + if (s != null) { + sb.append(' ').append(s); + } + if (resolvedType != null) { + sb.append(" type=").append(resolvedType); + } + if (symbol != null) { + sb.append(" sym=").append(symbol); + } + sb.append('}'); + return sb.toString(); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/GuiScriptTextArea.java b/src/main/java/noppes/npcs/client/gui/util/GuiScriptTextArea.java index 6aed0debd..a833a7bb8 100644 --- a/src/main/java/noppes/npcs/client/gui/util/GuiScriptTextArea.java +++ b/src/main/java/noppes/npcs/client/gui/util/GuiScriptTextArea.java @@ -12,7 +12,7 @@ import noppes.npcs.client.gui.util.script.*; import noppes.npcs.client.gui.util.script.JavaTextContainer.LineData; // New interpreter system imports import noppes.npcs.client.gui.util.script.autocomplete.AutocompleteMenu; -import noppes.npcs.client.gui.util.script.interpreter.ScriptLine; +import bigguy.texteditor.render.RenderLine; import noppes.npcs.client.gui.util.script.interpreter.ScriptTextContainer; import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; import noppes.npcs.client.gui.util.script.interpreter.field.FieldAccessInfo; @@ -558,7 +558,7 @@ public class GuiScriptTextArea extends GuiNpcTextField { if (container != null && container.lines != null && cursorLine < container.lines.size()) { LineData ld = container.lines.get(cursorLine); int cursorOffset = selection.getCursorPosition() - ld.start; - ScriptLine sl = container.getDocument() != null ? container.getDocument().getLine(cursorLine) : null; + RenderLine sl = container.getOrchestrator() != null ? container.getOrchestrator().getRenderModel().getLine(cursorLine) : null; if (sl != null) { cursorCol = sl.getRenderedWidth(0, Math.min(cursorOffset, ld.text.length())); } else { @@ -862,7 +862,8 @@ public class GuiScriptTextArea extends GuiNpcTextField { // Render Viewport for (int i = renderStart; i <= renderEnd; i++) { LineData data = list.get(i); - ScriptLine scriptLine = container.getDocument().getLine(i); + RenderLine scriptLine = container.getOrchestrator().getRenderModel().getLine(i); + if (scriptLine == null) continue; String line = data.text; int w = line.length(); // Use integer Y relative to scrolledLine; fractional offset applied via GL translate @@ -1154,7 +1155,7 @@ public class GuiScriptTextArea extends GuiNpcTextField { if (i >= scroll.getScrolledLine() && i <= scroll.getScrolledLine() + this.container.visibleLines +1) { double yPos = (i - scroll.getScrolledLine()) * this.container.lineHeight; if (yMouseD >= yPos && yMouseD < yPos + this.container.lineHeight) { - ScriptLine scriptLine = container.getDocument() != null ? container.getDocument().getLine(i) : null; + RenderLine scriptLine = container.getOrchestrator() != null ? container.getOrchestrator().getRenderModel().getLine(i) : null; int lineWidth = 0; char[] chars = data.text.toCharArray(); @@ -1223,7 +1224,8 @@ public class GuiScriptTextArea extends GuiNpcTextField { return null; } - ScriptLine lineData = container.getDocument().getLine(lineIdx); + RenderLine lineData = container.getOrchestrator() != null ? container.getOrchestrator().getRenderModel().getLine(lineIdx) : null; + if (lineData == null) return null; String lineText = lineData.getText(); int lineStart = lineData.getGlobalStart(); diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptTextContainer.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptTextContainer.java index 022c8c82c..859b91859 100644 --- a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptTextContainer.java +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptTextContainer.java @@ -1,5 +1,6 @@ package noppes.npcs.client.gui.util.script.interpreter; +import bigguy.texteditor.ScriptOrchestrator; import noppes.npcs.client.ClientProxy; import noppes.npcs.client.gui.util.script.JavaTextContainer; import noppes.npcs.constants.ScriptContext; @@ -30,6 +31,7 @@ public class ScriptTextContainer extends JavaTextContainer { public static boolean USE_NEW_INTERPRETER = true; private ScriptDocument document; + private ScriptOrchestrator orchestrator; /** The scripting language: "ECMAScript", "Groovy", etc. */ private String language = "ECMAScript"; @@ -44,6 +46,7 @@ public class ScriptTextContainer extends JavaTextContainer { super(text); if (USE_NEW_INTERPRETER) { document = new ScriptDocument(text); + orchestrator = new ScriptOrchestrator(); } } @@ -52,6 +55,7 @@ public class ScriptTextContainer extends JavaTextContainer { this.language = language != null ? language : "ECMAScript"; if (USE_NEW_INTERPRETER) { document = new ScriptDocument(text, this.language); + orchestrator = new ScriptOrchestrator(); } } @@ -127,9 +131,13 @@ public class ScriptTextContainer extends JavaTextContainer { lineHeight = ClientProxy.Font.height(); if (lineHeight == 0) lineHeight = 12; - // Initialize the document - document.setText(text); - document.init(width, height); + // Initialize the document (legacy — still needed for semantic analysis) + // document.setText(text); + //document.init(width, height); + + // Initialize the orchestrator (new CST-based pipeline) + orchestrator.setLineHeight(lineHeight); + orchestrator.onTextChanged(text); // Convert ScriptLines to LineData for compatibility rebuildLineData(); @@ -156,6 +164,9 @@ public class ScriptTextContainer extends JavaTextContainer { document.setScriptContext(this.scriptContext); document.setEditorGlobals(this.editorGlobals); } + if (orchestrator == null) { + orchestrator = new ScriptOrchestrator(); + } init(width, height); } @@ -203,7 +214,7 @@ public class ScriptTextContainer extends JavaTextContainer { } //ScriptProfiler.setEnabled(true); - document.formatCodeText(); + // document.formatCodeText(); ScriptProfiler.setEnabled(false); rebuildLineData(); } @@ -241,6 +252,13 @@ public class ScriptTextContainer extends JavaTextContainer { return document; } + /** + * Get the ScriptOrchestrator for the new CST-based pipeline. + */ + public ScriptOrchestrator getOrchestrator() { + return orchestrator; + } + /** * Get the interpreter Token at a specific global position in the text. * Returns null if no token is at that position or if the interpreter is disabled.