mirror of
https://github.com/KAMKEEL/CustomNPC-Plus.git
synced 2026-11-18 14:59:05 +00:00
OMG THIS IS ALL SO VERY FUCKING IMPORTANT I THOUGHT I LOST ALL OF THIS FUUUUUCK THANK GOD
This commit is contained in:
1 parent
b7137d39cb
commit
bcef6ffd25
26 files changed
+8919
-9
No files matched your search
@@ -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
|
||||
@@ -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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <h3>State machine</h3>
|
||||
* <pre>{@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)
|
||||
* }</pre>
|
||||
*
|
||||
* <h3>Feature gating</h3>
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <h3>Thread safety</h3>
|
||||
* <p>Enum constants are inherently immutable. The state <em>variable</em> holding
|
||||
* the current readiness should be protected by whatever concurrency mechanism
|
||||
* the orchestrator uses (e.g. {@code AtomicReference<ReadinessState>}).</p>
|
||||
*/
|
||||
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<ReadinessState> FROM_UNINITIALIZED =
|
||||
Collections.unmodifiableSet(EnumSet.of(SYNTAX_READY));
|
||||
|
||||
private static final Set<ReadinessState> FROM_SYNTAX_READY =
|
||||
Collections.unmodifiableSet(EnumSet.of(ANALYZING, SYNTAX_READY));
|
||||
|
||||
private static final Set<ReadinessState> FROM_ANALYZING =
|
||||
Collections.unmodifiableSet(EnumSet.of(SMART, DEGRADED, SYNTAX_READY));
|
||||
|
||||
private static final Set<ReadinessState> FROM_SMART =
|
||||
Collections.unmodifiableSet(EnumSet.of(SYNTAX_READY));
|
||||
|
||||
private static final Set<ReadinessState> 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.
|
||||
*
|
||||
* <p>When syntax is available, the following features are safe to use:</p>
|
||||
* <ul>
|
||||
* <li>Tree-sitter syntax highlighting</li>
|
||||
* <li>Bracket matching (CST-based)</li>
|
||||
* <li>Keyword-only autocomplete</li>
|
||||
* </ul>
|
||||
*
|
||||
* @return whether CST-based features are available
|
||||
*/
|
||||
public boolean isSyntaxAvailable() {
|
||||
return syntaxAvailable;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns {@code true} when full semantic analysis has completed successfully.
|
||||
*
|
||||
* <p>When semantics are available, the following features are safe to use:</p>
|
||||
* <ul>
|
||||
* <li>Error underlines and diagnostic rendering</li>
|
||||
* <li>Full (scope-aware, type-aware) autocomplete</li>
|
||||
* <li>Hover tooltips with type information</li>
|
||||
* <li>Go-to-definition navigation</li>
|
||||
* <li>Scope coloring</li>
|
||||
* </ul>
|
||||
*
|
||||
* @return whether semantic features are available
|
||||
*/
|
||||
public boolean isSemanticsAvailable() {
|
||||
return semanticsAvailable;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns {@code true} when background analysis is currently in progress.
|
||||
*
|
||||
* <p>UI code can use this to display a progress indicator without blocking.</p>
|
||||
*
|
||||
* @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<ReadinessState> 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;
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
*
|
||||
* <h3>Pipeline</h3>
|
||||
* <pre>{@code
|
||||
* onTextChanged(text)
|
||||
* → parser.parse(text) → SyntaxTree
|
||||
* → DocumentSyntax.create(tree, version)
|
||||
* → queryEngine.highlights(tree, text) → HighlightCaptures
|
||||
* → convertHighlightsToMarks(captures, text) → List<Mark>
|
||||
* → 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
|
||||
* }</pre>
|
||||
*
|
||||
* <h3>Thread model</h3>
|
||||
* <ul>
|
||||
* <li>Syntax highlighting runs on the UI thread (fast, <5ms)</li>
|
||||
* <li>Semantic analysis runs on a background daemon thread via {@link SemanticAnalyzer}</li>
|
||||
* <li>Analysis callbacks fire on the background thread, updating {@code volatile state}</li>
|
||||
* <li>State transitions are atomic via volatile {@link ReadinessState}</li>
|
||||
* </ul>
|
||||
*
|
||||
* <h3>State machine</h3>
|
||||
* <pre>{@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)
|
||||
* }</pre>
|
||||
*/
|
||||
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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*/
|
||||
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.
|
||||
*
|
||||
* <p>Any in-flight analysis from a previous edit is cancelled before
|
||||
* scheduling a new one, ensuring stale results are never applied.</p>
|
||||
*
|
||||
* @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<HighlightCapture> highlights = queryEngine.highlights(syntaxTree, text);
|
||||
|
||||
// Step 5: Convert highlights to Mark objects
|
||||
List<Mark> 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<Mark> 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<Mark> semanticMarks = SemanticMarkBuilder.build(semanticModel, syntax);
|
||||
markLayer.setSemanticMarks(semanticMarks);
|
||||
List<Mark> 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<Mark> convertHighlightsToMarks(List<HighlightCapture> highlights, String text) {
|
||||
if (highlights.isEmpty()) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
int textLength = text.length();
|
||||
List<Mark> 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.
|
||||
*
|
||||
* <p>The mapping aims to match IntelliJ-style colorization:</p>
|
||||
* <ul>
|
||||
* <li>Language keywords and control flow → {@link TokenType#KEYWORD}</li>
|
||||
* <li>Type references and declarations → {@link TokenType#TYPE_DECL} / specific decl types</li>
|
||||
* <li>Function/method names → {@link TokenType#METHOD_DECL} or {@link TokenType#METHOD_CALL}</li>
|
||||
* <li>Strings, numbers, booleans → their respective literal types</li>
|
||||
* <li>Comments → {@link TokenType#COMMENT}</li>
|
||||
* <li>Punctuation/operators → {@link TokenType#DEFAULT} (white, lowest priority)</li>
|
||||
* </ul>
|
||||
*
|
||||
* @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}.
|
||||
*
|
||||
* <p>ERROR nodes represent unparseable source regions. MISSING nodes
|
||||
* represent tokens the parser expected but did not find (e.g. a
|
||||
* missing semicolon).</p>
|
||||
*
|
||||
* @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)}.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* @param line the render line to query diagnostics for
|
||||
* @return a list of diagnostic ranges, possibly empty, never {@code null}
|
||||
*/
|
||||
public List<RenderLine.DiagnosticRange> getDiagnosticsForLine(RenderLine line) {
|
||||
if (line == null) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
List<Diagnostic> lineDiagnostics = diagnosticStore.getDiagnosticsInRange(
|
||||
line.getGlobalStart(), line.getGlobalEnd());
|
||||
if (lineDiagnostics.isEmpty()) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
List<RenderLine.DiagnosticRange> 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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*/
|
||||
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
|
||||
+ '}';
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <h3>Design</h3>
|
||||
* <p>The algorithm walks upward from each changed range's deepest node to
|
||||
* classify the edit into one of five categories:</p>
|
||||
* <ol>
|
||||
* <li>{@link InvalidationScope#NONE NONE} — edit inside string/comment</li>
|
||||
* <li>{@link InvalidationScope#LOCAL_SCOPE LOCAL_SCOPE} — edit inside method body</li>
|
||||
* <li>{@link InvalidationScope#DECLARATION DECLARATION} — signature changed</li>
|
||||
* <li>{@link InvalidationScope#IMPORTS IMPORTS} — import changed</li>
|
||||
* <li>{@link InvalidationScope#STRUCTURAL STRUCTURAL} — class/method boundary changed</li>
|
||||
* </ol>
|
||||
*
|
||||
* <h3>Performance impact</h3>
|
||||
* <pre>
|
||||
* | 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 |
|
||||
* </pre>
|
||||
*
|
||||
* <h3>Thread safety</h3>
|
||||
* <p>This class is stateless and therefore inherently thread-safe. All methods
|
||||
* are pure functions of their arguments.</p>
|
||||
*
|
||||
* @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<String> DECLARATION_NODE_TYPES = Collections.unmodifiableSet(
|
||||
new HashSet<String>(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<String> METHOD_LIKE_NODE_TYPES = Collections.unmodifiableSet(
|
||||
new HashSet<String>(Arrays.asList(
|
||||
NODE_METHOD_DECLARATION,
|
||||
NODE_CONSTRUCTOR_DECLARATION
|
||||
))
|
||||
);
|
||||
|
||||
// ── Invalidation scope enum ────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Describes the extent of semantic invalidation required after an edit.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*/
|
||||
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.
|
||||
*
|
||||
* <p>This class is stateless; a single instance can be reused across
|
||||
* all analysis cycles.</p>
|
||||
*/
|
||||
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.
|
||||
*
|
||||
* <p>Each changed range is classified independently via
|
||||
* {@link #classifySingleChange(TextSpan, DocumentSyntax)}, and the
|
||||
* worst-case (highest severity) scope across all ranges is returned.</p>
|
||||
*
|
||||
* <p>If no ranges changed, returns {@link InvalidationScope#NONE}.</p>
|
||||
*
|
||||
* @param changedRanges the byte ranges that changed (from tree-sitter's
|
||||
* {@code getChangedRanges()}); may be {@code null} or empty
|
||||
* @param syntax the <em>new</em> 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.
|
||||
*
|
||||
* <p>The algorithm proceeds in three steps:</p>
|
||||
* <ol>
|
||||
* <li><strong>Exclusion check:</strong> If the edit start falls inside a
|
||||
* string literal or comment, the edit is semantically invisible →
|
||||
* {@link InvalidationScope#NONE}.</li>
|
||||
* <li><strong>Node lookup:</strong> Find the deepest named CST node at the
|
||||
* edit's start byte offset.</li>
|
||||
* <li><strong>Ancestor walk:</strong> 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.</li>
|
||||
* </ol>
|
||||
*
|
||||
* @param changedRange the byte range that changed
|
||||
* @param syntax the <em>new</em> 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.
|
||||
*
|
||||
* <p>The walk checks in order:</p>
|
||||
* <ol>
|
||||
* <li>Is the node inside a method/constructor body? → {@code LOCAL_SCOPE}</li>
|
||||
* <li>Is the node inside an import declaration? → {@code IMPORTS}</li>
|
||||
* <li>Is the node inside a declaration node? → {@code DECLARATION}</li>
|
||||
* <li>Otherwise → {@code STRUCTURAL}</li>
|
||||
* </ol>
|
||||
*
|
||||
* @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{}";
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <h3>Lifecycle</h3>
|
||||
* <ol>
|
||||
* <li>The orchestrator calls {@link #scheduleAnalysis} or
|
||||
* {@link #scheduleIncrementalAnalysis} after each text change.</li>
|
||||
* <li>Any in-flight analysis is cancelled immediately.</li>
|
||||
* <li>An immutable snapshot of the current state is captured and submitted
|
||||
* to a single-thread {@link ExecutorService}.</li>
|
||||
* <li>On completion, results are published back to the caller via an
|
||||
* {@link AnalysisCallback}.</li>
|
||||
* <li>Stale results (where the revision has advanced since submission)
|
||||
* are silently discarded.</li>
|
||||
* </ol>
|
||||
*
|
||||
* <h3>Stale-result protocol</h3>
|
||||
* <p>The key invariant is: <strong>never blend stale semantic data with fresh
|
||||
* syntax</strong>. When a revision changes:</p>
|
||||
* <ol>
|
||||
* <li>Drop ALL semantic decorations immediately.</li>
|
||||
* <li>Show syntax-only highlighting.</li>
|
||||
* <li>When semantic analysis completes for the <em>current</em> revision,
|
||||
* apply atomically.</li>
|
||||
* <li>When semantic analysis completes for an <em>old</em> revision,
|
||||
* discard silently.</li>
|
||||
* </ol>
|
||||
*
|
||||
* <h3>Thread safety</h3>
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <h3>Callback threading</h3>
|
||||
* <p>The {@link AnalysisCallback} is invoked on the <em>background</em>
|
||||
* 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.</p>
|
||||
*
|
||||
* @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.
|
||||
*
|
||||
* <p>The orchestrator implements this to apply semantic marks and
|
||||
* transition state. <strong>Important:</strong> callbacks are invoked on
|
||||
* the background analysis thread, not the UI thread. Implementors must
|
||||
* marshal results to the appropriate thread before modifying UI state.</p>
|
||||
*
|
||||
* <p>The caller <strong>must</strong> 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.</p>
|
||||
*/
|
||||
public interface AnalysisCallback {
|
||||
|
||||
/**
|
||||
* Called when analysis completes successfully for the given revision.
|
||||
*
|
||||
* <p>The caller <strong>must</strong> 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.</p>
|
||||
*
|
||||
* @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.
|
||||
*
|
||||
* <p>The revision is provided so the caller can determine whether
|
||||
* the failure is still relevant to the current document state.</p>
|
||||
*
|
||||
* @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}.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*/
|
||||
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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <p>If the analyzer has been {@linkplain #dispose() disposed}, this
|
||||
* method is a no-op.</p>
|
||||
*
|
||||
* @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.
|
||||
*
|
||||
* <p>Only rebuilds the affected parts of the semantic model, as determined
|
||||
* by the {@link InvalidationScope}:</p>
|
||||
* <ul>
|
||||
* <li>{@link InvalidationScope#NONE NONE} — no-op; the callback
|
||||
* is still invoked with the existing model so the orchestrator can
|
||||
* apply offset-adjusted decorations.</li>
|
||||
* <li>{@link InvalidationScope#LOCAL_SCOPE LOCAL_SCOPE} — only
|
||||
* the scope tree is rebuilt.</li>
|
||||
* <li>{@link InvalidationScope#DECLARATION DECLARATION} — full
|
||||
* rebuild (symbol table + scope tree).</li>
|
||||
* <li>{@link InvalidationScope#IMPORTS IMPORTS} — only the import
|
||||
* index is rebuilt.</li>
|
||||
* <li>{@link InvalidationScope#STRUCTURAL STRUCTURAL} — full
|
||||
* rebuild of all sub-components.</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p>Any currently in-flight analysis is cancelled before scheduling.
|
||||
* If the analyzer has been {@linkplain #dispose() disposed}, this method
|
||||
* is a no-op.</p>
|
||||
*
|
||||
* @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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <p>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).</p>
|
||||
*/
|
||||
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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* @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.
|
||||
*
|
||||
* <p>The returned reference is the <em>live</em> 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:</p>
|
||||
* <ul>
|
||||
* <li>Read only when {@link #isAnalyzing()} is {@code false}, or</li>
|
||||
* <li>Use the model snapshot provided via {@link AnalysisCallback}.</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p>This method is primarily intended for incremental analysis paths that
|
||||
* need access to the previous model state before scheduling an update.</p>
|
||||
*
|
||||
* @return the semantic model (never {@code null})
|
||||
*/
|
||||
public SemanticModel getSemanticModel() {
|
||||
return semanticModel;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the incremental strategy used by this analyzer.
|
||||
*
|
||||
* <p>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}.</p>
|
||||
*
|
||||
* @return the incremental strategy (never {@code null})
|
||||
*/
|
||||
public IncrementalStrategy getStrategy() {
|
||||
return strategy;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the revision number that was most recently submitted for
|
||||
* analysis.
|
||||
*
|
||||
* <p>This can be compared against the document's current revision to
|
||||
* determine whether the latest analysis results are still relevant.</p>
|
||||
*
|
||||
* @return the most recently submitted revision number
|
||||
*/
|
||||
public long getCurrentRevision() {
|
||||
return currentRevision.get();
|
||||
}
|
||||
|
||||
/**
|
||||
* Shuts down the background executor and cancels any in-flight analysis.
|
||||
*
|
||||
* <p><strong>Must</strong> be called when the editor closes to release
|
||||
* the background thread. After disposal:</p>
|
||||
* <ul>
|
||||
* <li>All {@code schedule*} methods become no-ops.</li>
|
||||
* <li>{@link #isAnalyzing()} returns {@code false}.</li>
|
||||
* <li>Any in-flight analysis bails out without invoking the callback.</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p>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()}.
|
||||
* </p>
|
||||
*
|
||||
* <p>Safe to call multiple times; subsequent calls are no-ops.</p>
|
||||
*/
|
||||
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.
|
||||
*
|
||||
* <p>Abort conditions:</p>
|
||||
* <ul>
|
||||
* <li>The analyzer has been disposed.</li>
|
||||
* <li>The thread has been interrupted (task was cancelled).</li>
|
||||
* <li>The revision has been superseded by a newer submission.</li>
|
||||
* </ul>
|
||||
*
|
||||
* @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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*/
|
||||
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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* @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
|
||||
+ '}';
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
*
|
||||
* <p>This builder bridges semantic analysis and visual rendering. It walks the CST
|
||||
* via {@link DocumentSyntax} to locate the <em>name</em> 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.</p>
|
||||
*
|
||||
* <h3>Why walk the CST instead of using Symbol ranges?</h3>
|
||||
* <p>{@link Symbol#range()} covers the <em>entire</em> 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.</p>
|
||||
*
|
||||
* <h3>Symbol → TokenType mapping</h3>
|
||||
* <table>
|
||||
* <tr><th>Symbol type</th><th>Condition</th><th>TokenType</th></tr>
|
||||
* <tr><td>{@link TypeSymbol}</td><td>{@link SymbolKind#CLASS}</td>
|
||||
* <td>{@link TokenType#CLASS_DECL}</td></tr>
|
||||
* <tr><td>{@link TypeSymbol}</td><td>{@link SymbolKind#INTERFACE}</td>
|
||||
* <td>{@link TokenType#INTERFACE_DECL}</td></tr>
|
||||
* <tr><td>{@link TypeSymbol}</td><td>{@link SymbolKind#ENUM}</td>
|
||||
* <td>{@link TokenType#ENUM_DECL}</td></tr>
|
||||
* <tr><td>{@link TypeSymbol}</td><td>{@link SymbolKind#ANNOTATION}</td>
|
||||
* <td>{@link TokenType#JSDOC_TAG}</td></tr>
|
||||
* <tr><td>{@link MethodSymbol}</td><td>any</td>
|
||||
* <td>{@link TokenType#METHOD_DECL}</td></tr>
|
||||
* <tr><td>{@link FieldSymbol}</td><td>static & final</td>
|
||||
* <td>{@link TokenType#STATIC_FINAL_FIELD}</td></tr>
|
||||
* <tr><td>{@link FieldSymbol}</td><td>otherwise</td>
|
||||
* <td>{@link TokenType#GLOBAL_FIELD}</td></tr>
|
||||
* <tr><td>{@link ImportSymbol}</td><td>always</td>
|
||||
* <td>{@link TokenType#IMPORTED_CLASS}</td></tr>
|
||||
* </table>
|
||||
*
|
||||
* <h3>Thread safety</h3>
|
||||
* <p>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.</p>
|
||||
*
|
||||
* @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<String> TYPE_DECLARATION_TYPES;
|
||||
|
||||
static {
|
||||
Set<String> types = new HashSet<String>();
|
||||
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.
|
||||
*
|
||||
* <p>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
|
||||
* <em>name</em> node. Only the name identifier is highlighted — keywords,
|
||||
* modifiers, and body content are left to tree-sitter's syntax marks.</p>
|
||||
*
|
||||
* <p>The returned list is unsorted. Callers (typically {@code MarkLayer})
|
||||
* should sort the marks before merging them with syntax marks.</p>
|
||||
*
|
||||
* @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<Mark> 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<Mark> marks = new ArrayList<Mark>();
|
||||
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<Mark> marks) {
|
||||
List<SemanticNode> 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<Mark> 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<Mark> 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<Mark> marks) {
|
||||
// Multi-declarator fields: "int x, y, z;"
|
||||
List<SemanticNode> 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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* @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<Mark> 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.
|
||||
*
|
||||
* <p>If multiple types share the same simple name (e.g., nested classes),
|
||||
* the one whose range contains the declaration node's range wins.</p>
|
||||
*
|
||||
* @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<TypeSymbol> 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<MethodSymbol> 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<FieldSymbol> 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<ImportSymbol> 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}.
|
||||
*
|
||||
* <p>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).</p>
|
||||
*
|
||||
* @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<SemanticNode> 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();
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
*
|
||||
* <p>Severity levels and source categories follow the Language Server Protocol
|
||||
* specification to ease future LSP integration.</p>
|
||||
*/
|
||||
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() + ")";
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <p>All query methods return unmodifiable snapshots — callers never see
|
||||
* the internal mutable list.</p>
|
||||
*/
|
||||
public final class DiagnosticStore {
|
||||
|
||||
private final CopyOnWriteArrayList<Diagnostic> 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<Diagnostic> getDiagnosticsInRange(int startByte, int endByte) {
|
||||
List<Diagnostic> 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<Diagnostic> getDiagnosticsBySource(Source source) {
|
||||
List<Diagnostic> 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<Diagnostic> getDiagnosticsBySeverity(Severity severity) {
|
||||
List<Diagnostic> 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<Diagnostic> 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() + "}";
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
*
|
||||
* <p>Follows IntelliJ's {@code PsiElement} specialization pattern: a common
|
||||
* interface with concrete final implementations for each symbol category.</p>
|
||||
*/
|
||||
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<String> 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 "<init>"} 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<String> 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<String> 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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*/
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
package bigguy.texteditor.index;
|
||||
|
||||
/**
|
||||
* Classifies symbols within a source document for indexing, navigation, and
|
||||
* icon display.
|
||||
*
|
||||
* <p>Follows the LSP {@code SymbolKind} enumeration and IntelliJ IDEA's
|
||||
* {@code IElementType} hierarchy, covering the Java language constructs
|
||||
* relevant to the script editor.</p>
|
||||
*/
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
*
|
||||
* <p>Marks are produced by:
|
||||
* <ul>
|
||||
* <li>Tree-sitter highlight queries (syntax marks)</li>
|
||||
* <li>Semantic analysis (type resolution, scope coloring)</li>
|
||||
* <li>Error detection (diagnostic marks)</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p>Multiple marks can overlap. {@link MarkLayer} resolves conflicts using
|
||||
* {@link TokenType#getPriority()}.
|
||||
*
|
||||
* <p>Sorting order (used by {@link MarkLayer#merge()}):
|
||||
* <ol>
|
||||
* <li>By start position ascending</li>
|
||||
* <li>By span length descending (longest first)</li>
|
||||
* <li>By priority descending (highest first)</li>
|
||||
* </ol>
|
||||
*/
|
||||
public final class Mark implements Comparable<Mark> {
|
||||
|
||||
/** 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() : "")
|
||||
+ "}";
|
||||
}
|
||||
}
|
||||
@@ -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()}.
|
||||
*
|
||||
* <p>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.
|
||||
*
|
||||
* <p>A monotonically increasing {@link #getRevision() revision} counter lets
|
||||
* consumers detect stale merge results cheaply.
|
||||
*/
|
||||
public class MarkLayer {
|
||||
|
||||
private List<Mark> syntaxMarks = Collections.emptyList();
|
||||
private List<Mark> semanticMarks = Collections.emptyList();
|
||||
private List<Mark> 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<Mark> 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<Mark> 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<Mark> marks) {
|
||||
this.errorMarks = new ArrayList<>(marks);
|
||||
revision++;
|
||||
}
|
||||
|
||||
/** @return the current syntax marks (defensive copy) */
|
||||
public synchronized List<Mark> getSyntaxMarks() {
|
||||
return new ArrayList<>(syntaxMarks);
|
||||
}
|
||||
|
||||
/** @return the current semantic marks (defensive copy) */
|
||||
public synchronized List<Mark> 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<Mark> 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.
|
||||
*
|
||||
* <p>Algorithm:
|
||||
* <ol>
|
||||
* <li>Combine syntax + semantic marks and sort by start position</li>
|
||||
* <li>Walk left-to-right through a "sweep line" over every boundary point</li>
|
||||
* <li>At each boundary, the active mark with the highest
|
||||
* {@link TokenType#getPriority()} wins</li>
|
||||
* <li>Semantic marks override syntax marks for the same range
|
||||
* (semantic priority is typically equal or higher)</li>
|
||||
* <li>Output non-overlapping marks sorted by start position</li>
|
||||
* </ol>
|
||||
*
|
||||
* @return merged, non-overlapping mark list (safe to iterate without synchronization)
|
||||
*/
|
||||
public List<Mark> merge() {
|
||||
List<Mark> syntax;
|
||||
List<Mark> 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<Mark> semanticSet = Collections.newSetFromMap(new IdentityHashMap<>());
|
||||
semanticSet.addAll(semantic);
|
||||
|
||||
// Collect all boundary points
|
||||
List<Integer> 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<Integer> 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<Mark> combined = new ArrayList<>(syntax.size() + semantic.size());
|
||||
combined.addAll(syntax);
|
||||
combined.addAll(semantic);
|
||||
|
||||
List<Mark> 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 + "}";
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
*
|
||||
* <p>Rendering flows through two paths:
|
||||
* <ul>
|
||||
* <li>{@link #drawStringHex(int, int)} — primary hex-color renderer
|
||||
* using {@link ClientProxy.Font#drawString(String, int, int, int)}</li>
|
||||
* <li>{@link #drawString(int, int, int)} — legacy Minecraft color-code renderer</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p>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<Token> tokens = new ArrayList<>();
|
||||
private final List<Integer> 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<Token> getTokens() { return Collections.unmodifiableList(tokens); }
|
||||
|
||||
/** Unmodifiable view of indent guide column positions. */
|
||||
public List<Integer> 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<Token> 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.
|
||||
*
|
||||
* <p>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<Mark> 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.
|
||||
*
|
||||
* <p>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)}.
|
||||
*
|
||||
* <p>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<RenderSegment> 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<DiagnosticRange> 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}";
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
*
|
||||
* <p>Replaces the layout fields previously scattered across {@code ScriptDocument}:
|
||||
* {@code lineHeight}, {@code totalHeight}, {@code visibleLines}, {@code linesCount}.
|
||||
*
|
||||
* <p>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<RenderLine> 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<RenderLine> getVisibleLines(int scrollOffset, int viewportHeight) {
|
||||
List<RenderLine> 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<RenderLine> 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<RenderLine> 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<RenderLine> 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.
|
||||
*
|
||||
* <ol>
|
||||
* <li>Splits {@code sourceText} by newlines into logical lines</li>
|
||||
* <li>Creates a {@link RenderLine} for each with correct
|
||||
* globalStart/globalEnd/lineIndex</li>
|
||||
* <li>Calls {@link RenderLine#buildTokensFromMarks(List, String)}
|
||||
* with the marks that overlap each line</li>
|
||||
* <li>Computes indent guides per line</li>
|
||||
* </ol>
|
||||
*
|
||||
* @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<Mark> mergedMarks, int lineHeight) {
|
||||
this.lineHeight = lineHeight;
|
||||
|
||||
List<RenderLine> newLines = new ArrayList<>();
|
||||
|
||||
if (sourceText.isEmpty()) {
|
||||
RenderLine empty = new RenderLine("", 0, 0, 0);
|
||||
empty.buildTokensFromMarks(Collections.<Mark>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<Mark> 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.<Mark>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<Mark> collectMarksForRange(List<Mark> allMarks, int rangeStart, int rangeEnd) {
|
||||
List<Mark> 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() + "}";
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
*
|
||||
* <p>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")
|
||||
+ "}";
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <h3>Lazy derived indexes</h3>
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <h3>Version tracking</h3>
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <h3>Thread safety</h3>
|
||||
* <p>All mutation methods are {@code synchronized}. All query methods return
|
||||
* defensive copies or unmodifiable snapshots, so callers never observe
|
||||
* partially-mutated state.</p>
|
||||
*
|
||||
* @since Phase 2 — CST editor architecture
|
||||
*/
|
||||
public final class ImportIndex {
|
||||
|
||||
// ── Primary store ──────────────────────────────────────────────────
|
||||
|
||||
/** The authoritative list of all import entries (explicit + implicit). */
|
||||
private final List<ImportEntry> entries;
|
||||
|
||||
// ── Derived indexes (lazily rebuilt) ────────────────────────────────
|
||||
|
||||
/** Quick lookup by unqualified simple name (e.g. "List" → entry). */
|
||||
private Map<String, ImportEntry> bySimpleName;
|
||||
|
||||
/** Quick lookup by fully qualified path (e.g. "java.util.List" → entry). */
|
||||
private Map<String, ImportEntry> 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<ImportEntry>();
|
||||
this.bySimpleName = Collections.emptyMap();
|
||||
this.byFullPath = Collections.emptyMap();
|
||||
this.dirty = false;
|
||||
this.version = 0;
|
||||
}
|
||||
|
||||
// ── Inner class ────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* An individual import declaration (explicit or implicit).
|
||||
*
|
||||
* <p>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.</p>
|
||||
*/
|
||||
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.
|
||||
*
|
||||
* <p>Automatically derives {@code simpleName}, {@code isWildcard}, and
|
||||
* {@code packagePath} from the path.</p>
|
||||
*
|
||||
* @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.
|
||||
*
|
||||
* <p>The entry is created with {@code isImplicit=true}, {@code isStatic=false},
|
||||
* and {@code range=null}.</p>
|
||||
*
|
||||
* @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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* @param newEntries the replacement entries; the list is defensively copied
|
||||
*/
|
||||
public synchronized void replaceAll(List<ImportEntry> newEntries) {
|
||||
entries.clear();
|
||||
if (newEntries != null) {
|
||||
entries.addAll(newEntries);
|
||||
}
|
||||
markDirty();
|
||||
}
|
||||
|
||||
// ── Resolution (queries) ───────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Resolves an import by its unqualified simple name.
|
||||
*
|
||||
* <p>Resolution order:</p>
|
||||
* <ol>
|
||||
* <li>Exact match in explicit (non-wildcard) imports by simple name.</li>
|
||||
* <li>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.)</li>
|
||||
* </ol>
|
||||
*
|
||||
* @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.
|
||||
*
|
||||
* <p>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"}).</p>
|
||||
*
|
||||
* @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<String> getWildcardPackages() {
|
||||
Set<String> result = new HashSet<String>();
|
||||
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<ImportEntry> getAllImports() {
|
||||
return Collections.unmodifiableList(new ArrayList<ImportEntry>(entries));
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a snapshot of only the implicit (auto-injected) imports.
|
||||
*
|
||||
* @return an unmodifiable list; never {@code null}
|
||||
*/
|
||||
public synchronized List<ImportEntry> getImplicitImports() {
|
||||
List<ImportEntry> result = new ArrayList<ImportEntry>();
|
||||
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<ImportEntry> getExplicitImports() {
|
||||
List<ImportEntry> result = new ArrayList<ImportEntry>();
|
||||
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.
|
||||
*
|
||||
* <p>Wildcard implicit imports are never removed by this method, since
|
||||
* they cannot be matched by simple name alone.</p>
|
||||
*
|
||||
* <p>This is typically called after the token-build pass to discard
|
||||
* implicit imports that turned out to be unused.</p>
|
||||
*
|
||||
* @param usedSimpleNames the set of simple names actually referenced
|
||||
* in the source; must not be {@code null}
|
||||
*/
|
||||
public synchronized void removeUnusedImplicitImports(Set<String> usedSimpleNames) {
|
||||
if (usedSimpleNames == null) {
|
||||
throw new IllegalArgumentException("usedSimpleNames must not be null");
|
||||
}
|
||||
boolean changed = false;
|
||||
Iterator<ImportEntry> 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.
|
||||
*
|
||||
* <p>The version is bumped on every mutation. External code can snapshot
|
||||
* this value and later compare to detect whether the index has changed.</p>
|
||||
*
|
||||
* @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<String, ImportEntry> newBySimpleName = new HashMap<String, ImportEntry>();
|
||||
Map<String, ImportEntry> newByFullPath = new HashMap<String, ImportEntry>();
|
||||
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 + "}";
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
*
|
||||
* <p>Replaces three separate cache maps that previously lived in
|
||||
* {@code ScriptDocument}:</p>
|
||||
* <ul>
|
||||
* <li>{@code objectLiterals} — cached object-literal parses keyed by
|
||||
* brace-start byte offset</li>
|
||||
* <li>{@code lambdaCache} — cached lambda inferences keyed by
|
||||
* header-start byte offset</li>
|
||||
* <li>{@code scriptMethodSamContexts} — SAM conflict tracking keyed
|
||||
* by method name</li>
|
||||
* </ul>
|
||||
*
|
||||
* <h3>Type safety</h3>
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <h3>Version-aware invalidation</h3>
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <h3>Thread safety</h3>
|
||||
* <p>This class is <strong>not</strong> 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.</p>
|
||||
*
|
||||
* @since Phase 2 — CST editor architecture
|
||||
*/
|
||||
public final class InferenceCache {
|
||||
|
||||
private final Map<Integer, Object> objectLiterals;
|
||||
private final Map<Integer, Object> lambdas;
|
||||
private final Map<String, Object> samContexts;
|
||||
private int sourceVersion;
|
||||
|
||||
/**
|
||||
* Creates a new, empty {@code InferenceCache} at source version 0.
|
||||
*/
|
||||
public InferenceCache() {
|
||||
this.objectLiterals = new HashMap<Integer, Object>();
|
||||
this.lambdas = new HashMap<Integer, Object>();
|
||||
this.samContexts = new HashMap<String, Object>();
|
||||
this.sourceVersion = 0;
|
||||
}
|
||||
|
||||
// ── Source version tracking ────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Sets the source version this cache is valid for.
|
||||
*
|
||||
* <p>This does <em>not</em> automatically invalidate existing entries.
|
||||
* Call {@link #invalidateIfStale(int)} for conditional invalidation,
|
||||
* or {@link #invalidateAll()} to force a full clear.</p>
|
||||
*
|
||||
* @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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* @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)}.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* @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 <T> the expected result type
|
||||
* @return the cached analysis, or {@code null} if not present
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public <T> 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 <T> the expected result type
|
||||
* @return the cached entry, or {@code null} if not present
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public <T> 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 <T> the expected result type
|
||||
* @return the cached entry, or {@code null} if not present
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public <T> 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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* @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<Integer, Object> map,
|
||||
int startByte, int endByte) {
|
||||
if (map.isEmpty()) {
|
||||
return;
|
||||
}
|
||||
Iterator<Integer> 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<Integer, Object> map,
|
||||
int editStart, int delta) {
|
||||
if (map.isEmpty()) {
|
||||
return;
|
||||
}
|
||||
Map<Integer, Object> adjusted = new HashMap<Integer, Object>(map.size());
|
||||
for (Map.Entry<Integer, Object> 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() + "}";
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -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.
|
||||
*
|
||||
* <p>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:</p>
|
||||
*
|
||||
* <pre>
|
||||
* SemanticModel
|
||||
* ├── SymbolTable — all declared symbols + indexed views
|
||||
* ├── ScopeTree — scope hierarchy + variable resolution
|
||||
* ├── ImportIndex — import resolution
|
||||
* └── InferenceCache — lambda/object literal caches
|
||||
* </pre>
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <h3>Lifecycle</h3>
|
||||
* <ol>
|
||||
* <li>Construct an empty model via {@link #SemanticModel()}.</li>
|
||||
* <li>After parsing, call {@link #rebuild(DocumentSyntax)} for a full build.</li>
|
||||
* <li>On subsequent edits, call
|
||||
* {@link #incrementalUpdate(DocumentSyntax, InvalidationScope)} with the
|
||||
* scope computed by {@link IncrementalStrategy}.</li>
|
||||
* </ol>
|
||||
*
|
||||
* <h3>Thread safety</h3>
|
||||
* <p>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.</p>
|
||||
*
|
||||
* @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 = "<init>";
|
||||
|
||||
/**
|
||||
* Node types that represent type declarations.
|
||||
*/
|
||||
private static final Set<String> TYPE_DECLARATION_TYPES;
|
||||
|
||||
static {
|
||||
Set<String> types = new HashSet<String>();
|
||||
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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*/
|
||||
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.
|
||||
*
|
||||
* <p>Called from the background analysis thread after syntax parsing.
|
||||
* This method performs a complete rebuild of all sub-components:</p>
|
||||
* <ol>
|
||||
* <li>Clear all sub-components</li>
|
||||
* <li>Walk CST to extract imports → populate ImportIndex</li>
|
||||
* <li>Walk CST to extract declarations → populate SymbolTable</li>
|
||||
* <li>Build ScopeTree from CST</li>
|
||||
* <li>Set source version on InferenceCache</li>
|
||||
* </ol>
|
||||
*
|
||||
* @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.
|
||||
*
|
||||
* <p>Only rebuilds the sub-components that are affected by the change,
|
||||
* as determined by the {@link InvalidationScope}:</p>
|
||||
* <ul>
|
||||
* <li>{@link InvalidationScope#NONE NONE} — no-op (only offset adjustment needed)</li>
|
||||
* <li>{@link InvalidationScope#LOCAL_SCOPE LOCAL_SCOPE} — rebuild scope tree only</li>
|
||||
* <li>{@link InvalidationScope#DECLARATION DECLARATION} — full rebuild</li>
|
||||
* <li>{@link InvalidationScope#IMPORTS IMPORTS} — rebuild imports only</li>
|
||||
* <li>{@link InvalidationScope#STRUCTURAL STRUCTURAL} — full rebuild</li>
|
||||
* </ul>
|
||||
*
|
||||
* @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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* @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<FieldSymbol> 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.<FieldSymbol>empty();
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolves a type by simple name.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* @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<TypeSymbol> resolveType(String simpleName) {
|
||||
if (simpleName == null) {
|
||||
return Optional.empty();
|
||||
}
|
||||
|
||||
List<TypeSymbol> 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.
|
||||
*
|
||||
* <p>Delegates to {@link SymbolTable#getMethodsByName(String)}.</p>
|
||||
*
|
||||
* @param name the method name to look up
|
||||
* @return an unmodifiable list of matching method symbols (never {@code null})
|
||||
*/
|
||||
public List<MethodSymbol> 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).
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* @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.
|
||||
*
|
||||
* <p>This version is incremented on every rebuild or incremental update.
|
||||
* Consumers can compare versions to detect staleness without inspecting
|
||||
* individual sub-component versions.</p>
|
||||
*
|
||||
* @return the composite version number
|
||||
*/
|
||||
public int version() {
|
||||
return compositeVersion;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns whether the model has been built at least once.
|
||||
*
|
||||
* <p>Before the first {@link #rebuild(DocumentSyntax)} call, queries
|
||||
* will return empty results. Callers should check this flag before
|
||||
* relying on semantic data.</p>
|
||||
*
|
||||
* @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.
|
||||
*
|
||||
* <p>After calling this method, {@link #isBuilt()} returns {@code false}
|
||||
* and all queries return empty results until {@link #rebuild(DocumentSyntax)}
|
||||
* is called again.</p>
|
||||
*/
|
||||
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<SemanticNode> 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.
|
||||
*
|
||||
* <p>Handles both regular imports ({@code import java.util.List;}) and
|
||||
* wildcard imports ({@code import java.util.*;}) by walking the
|
||||
* scoped_identifier chain.</p>
|
||||
*/
|
||||
private String extractImportPath(SemanticNode importNode) {
|
||||
List<SemanticNode> 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<SemanticNode> 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<String> 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<String> extractParameterNames(SemanticNode methodNode) {
|
||||
SemanticNode params = methodNode.childByFieldName(FIELD_PARAMETERS);
|
||||
if (params == null) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
List<SemanticNode> paramChildren = params.namedChildren();
|
||||
if (paramChildren.isEmpty()) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
List<String> names = new ArrayList<String>(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<SemanticNode> 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<SemanticNode> 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<Symbol> allSymbols = symbolTable.getAllSymbols();
|
||||
List<Symbol> nonImports = new ArrayList<Symbol>(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")
|
||||
+ '}';
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
*
|
||||
* <p>Replaces ScriptDocument's triple-redundant type maps ({@code scriptTypes},
|
||||
* {@code scriptTypesByFullName}, {@code scriptTypesByDotName}) and scattered
|
||||
* method/field collections with a single source of truth.</p>
|
||||
*
|
||||
* <h3>Architecture</h3>
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <h3>Thread safety</h3>
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <h3>Version tracking</h3>
|
||||
* <p>An {@link AtomicInteger} version counter increments on every mutation. Consumers
|
||||
* can poll {@link #version()} to detect staleness without deep-comparing contents.</p>
|
||||
*
|
||||
* @see Symbol
|
||||
* @see SymbolKey
|
||||
* @see SymbolKind
|
||||
*/
|
||||
public final class SymbolTable {
|
||||
|
||||
// ── Primary store ──────────────────────────────────────────────────────────
|
||||
// Insertion-ordered so getAllSymbols() returns symbols in declaration order.
|
||||
|
||||
private final LinkedHashMap<SymbolKey, Symbol> 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<String, List<TypeSymbol>> typesBySimpleName;
|
||||
|
||||
/** Types keyed by fully qualified name. {@code null} means dirty. */
|
||||
private Map<String, TypeSymbol> typesByFullName;
|
||||
|
||||
/** Methods grouped by method name. {@code null} means dirty. */
|
||||
private Map<String, List<MethodSymbol>> methodsByName;
|
||||
|
||||
/** Fields/parameters/locals grouped by name. {@code null} means dirty. */
|
||||
private Map<String, List<FieldSymbol>> fieldsByName;
|
||||
|
||||
/** Import symbols keyed by their full import path. {@code null} means dirty. */
|
||||
private Map<String, ImportSymbol> 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<Symbol> 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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* @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<Symbol> 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.
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <p><strong>Note:</strong> 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.</p>
|
||||
*
|
||||
* @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<Symbol> 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<TypeSymbol> getTypesBySimpleName(String simpleName) {
|
||||
if (simpleName == null) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
ensureTypesBySimpleName();
|
||||
List<TypeSymbol> result = typesBySimpleName.get(simpleName);
|
||||
return result != null ? result : Collections.<TypeSymbol>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<MethodSymbol> getMethodsByName(String name) {
|
||||
if (name == null) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
ensureMethodsByName();
|
||||
List<MethodSymbol> result = methodsByName.get(name);
|
||||
return result != null ? result : Collections.<MethodSymbol>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<FieldSymbol> getFieldsByName(String name) {
|
||||
if (name == null) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
ensureFieldsByName();
|
||||
List<FieldSymbol> result = fieldsByName.get(name);
|
||||
return result != null ? result : Collections.<FieldSymbol>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<Symbol> getAllSymbols() {
|
||||
if (symbols.isEmpty()) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
return Collections.unmodifiableList(new ArrayList<Symbol>(symbols.values()));
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an unmodifiable snapshot of all type symbols.
|
||||
*
|
||||
* @return all types (never {@code null}, may be empty)
|
||||
*/
|
||||
public synchronized List<TypeSymbol> getAllTypes() {
|
||||
List<TypeSymbol> 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<MethodSymbol> getAllMethods() {
|
||||
List<MethodSymbol> 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<FieldSymbol> getAllFields() {
|
||||
List<FieldSymbol> 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<ImportSymbol> getAllImports() {
|
||||
List<ImportSymbol> 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<String, List<TypeSymbol>> index = new LinkedHashMap<>();
|
||||
for (Symbol sym : symbols.values()) {
|
||||
if (sym instanceof TypeSymbol) {
|
||||
TypeSymbol ts = (TypeSymbol) sym;
|
||||
String name = ts.name();
|
||||
List<TypeSymbol> 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<String, List<TypeSymbol>> 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<String, TypeSymbol> 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<String, List<MethodSymbol>> index = new LinkedHashMap<>();
|
||||
for (Symbol sym : symbols.values()) {
|
||||
if (sym instanceof MethodSymbol) {
|
||||
MethodSymbol ms = (MethodSymbol) sym;
|
||||
String name = ms.name();
|
||||
List<MethodSymbol> bucket = index.get(name);
|
||||
if (bucket == null) {
|
||||
bucket = new ArrayList<>(2);
|
||||
index.put(name, bucket);
|
||||
}
|
||||
bucket.add(ms);
|
||||
}
|
||||
}
|
||||
for (Map.Entry<String, List<MethodSymbol>> 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<String, List<FieldSymbol>> index = new LinkedHashMap<>();
|
||||
for (Symbol sym : symbols.values()) {
|
||||
if (sym instanceof FieldSymbol) {
|
||||
FieldSymbol fs = (FieldSymbol) sym;
|
||||
String name = fs.name();
|
||||
List<FieldSymbol> bucket = index.get(name);
|
||||
if (bucket == null) {
|
||||
bucket = new ArrayList<>(2);
|
||||
index.put(name, bucket);
|
||||
}
|
||||
bucket.add(fs);
|
||||
}
|
||||
}
|
||||
for (Map.Entry<String, List<FieldSymbol>> 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<String, ImportSymbol> 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;
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
*
|
||||
* <p>Wraps the low-level {@link SyntaxTree} (tree-sitter) and provides:</p>
|
||||
* <ol>
|
||||
* <li>{@link SemanticNode} factory with identity caching (avoids re-wrapping)</li>
|
||||
* <li>{@link ExcludedRangeIndex} for string/comment skipping</li>
|
||||
* <li>Source version tracking for invalidation</li>
|
||||
* <li>Node lookup by byte offset</li>
|
||||
* </ol>
|
||||
*
|
||||
* <p>Analogous to IntelliJ's {@code PsiFile} (root PSI element for a file)
|
||||
* and Zed's {@code SyntaxSnapshot} (immutable syntax view).</p>
|
||||
*
|
||||
* <h3>Thread safety</h3>
|
||||
* <p>Not thread-safe. The orchestrator must coordinate access
|
||||
* (e.g., via copy-on-parse or synchronization).</p>
|
||||
*/
|
||||
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<SyntaxNode, SemanticNode> 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.
|
||||
*
|
||||
* <p>Walks the CST to build the {@link ExcludedRangeIndex} for string
|
||||
* and comment regions, and initialises an empty node cache.</p>
|
||||
*
|
||||
* @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.
|
||||
*
|
||||
* <p>Walks from the root downward, at each level picking the child whose
|
||||
* span contains the offset, until no further narrowing is possible.</p>
|
||||
*
|
||||
* @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<Map.Entry<SyntaxNode, SemanticNode>> iterator = nodeCache.entrySet().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
Map.Entry<SyntaxNode, SemanticNode> 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<ExcludedRangeIndex.Range> ranges = new ArrayList<>();
|
||||
collectExcludedRanges(root, ranges);
|
||||
if (ranges.isEmpty()) {
|
||||
return ExcludedRangeIndex.empty();
|
||||
}
|
||||
return ExcludedRangeIndex.build(ranges);
|
||||
}
|
||||
|
||||
private static void collectExcludedRanges(SyntaxNode node, List<ExcludedRangeIndex.Range> 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")
|
||||
+ '}';
|
||||
}
|
||||
}
|
||||
@@ -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).
|
||||
*
|
||||
* <p>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.</p>
|
||||
*/
|
||||
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<Range> {
|
||||
|
||||
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<Range> 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<Range> 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();
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
*
|
||||
* <p>The {@link SyntaxNode} is the <em>structure</em> (syntax) — it knows about
|
||||
* node types, positions, text, and parent/child relationships. This class is
|
||||
* the <em>meaning</em> (semantics layered on top) — it carries lazily-resolved
|
||||
* type information, symbol bindings, and scope references.</p>
|
||||
*
|
||||
* <h3>Design (IntelliJ IDEA analogy)</h3>
|
||||
* <table>
|
||||
* <tr><th>IntelliJ</th><th>This project</th></tr>
|
||||
* <tr><td>{@code ASTNode}</td><td>{@link SyntaxNode} (raw CST)</td></tr>
|
||||
* <tr><td>{@code PsiElement}</td><td>{@code SemanticNode} (semantic view)</td></tr>
|
||||
* <tr><td>{@code PsiFile}</td><td>{@link DocumentSyntax} (root container)</td></tr>
|
||||
* </table>
|
||||
*
|
||||
* <h3>Semantic slots</h3>
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <p>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).</p>
|
||||
*
|
||||
* <h3>Thread safety</h3>
|
||||
* <p>Not thread-safe. The owning {@link DocumentSyntax} must coordinate access.</p>
|
||||
*/
|
||||
public final class SemanticNode {
|
||||
|
||||
private static final Set<String> 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<String> 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<String> 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.
|
||||
*
|
||||
* <p>Package-private: only {@link DocumentSyntax#wrap(SyntaxNode)} should
|
||||
* create instances, ensuring identity caching is respected.</p>
|
||||
*
|
||||
* @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<SemanticNode> namedChildren() {
|
||||
List<SyntaxNode> rawChildren = syntaxNode.getNamedChildren();
|
||||
if (rawChildren.isEmpty()) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
List<SemanticNode> 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<SemanticNode> findAll(String nodeType) {
|
||||
List<SyntaxNode> rawMatches = syntaxNode.findAll(nodeType);
|
||||
if (rawMatches.isEmpty()) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
List<SemanticNode> 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 <T> the expected type (typically TypeInfo)
|
||||
* @return the resolved type, or {@code null} if not yet resolved
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public <T> T getResolvedType() {
|
||||
return (T) resolvedType;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param <T> the type of the value (typically TypeInfo)
|
||||
* @param type the resolved type information to attach
|
||||
*/
|
||||
public <T> 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 <T> the expected type (typically Symbol)
|
||||
* @return the symbol, or {@code null} if not yet resolved
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public <T> T getSymbol() {
|
||||
return (T) symbol;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param <T> the type of the value (typically Symbol)
|
||||
* @param symbol the symbol binding to attach
|
||||
*/
|
||||
public <T> void setSymbol(T symbol) {
|
||||
this.symbol = symbol;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the scope attached to this node (lexical scope that this node
|
||||
* introduces or belongs to).
|
||||
*
|
||||
* @param <T> the expected type (typically Scope)
|
||||
* @return the scope, or {@code null} if not yet resolved
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public <T> T getScope() {
|
||||
return (T) scope;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param <T> the type of the value (typically Scope)
|
||||
* @param scope the scope to attach
|
||||
*/
|
||||
public <T> 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();
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
|
||||
|
||||
+22
-4
@@ -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.
|
||||
|
||||
Reference in new issue
Block a user