OMG THIS IS ALL SO VERY FUCKING IMPORTANT I THOUGHT I LOST ALL OF THIS FUUUUUCK THANK GOD

This commit is contained in:
bigguy345 committed 2026-03-19 20:00:37 +02:00
1 parent b7137d39cb
commit bcef6ffd25
26 files changed
+8919 -9

No files matched your search

+87
View File
@@ -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, &lt;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 &mdash; for example, via
* Minecraft's scheduled-task system &mdash; 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} &mdash; 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} &mdash; only
* the scope tree is rebuilt.</li>
* <li>{@link InvalidationScope#DECLARATION DECLARATION} &mdash; full
* rebuild (symbol table + scope tree).</li>
* <li>{@link InvalidationScope#IMPORTS IMPORTS} &mdash; only the import
* index is rebuilt.</li>
* <li>{@link InvalidationScope#STRUCTURAL STRUCTURAL} &mdash; 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 &mdash; 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 &amp; 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 &lt; editStart &lt; 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();
@@ -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.