diff --git a/.gitignore b/.gitignore index 908eae39d..4d121433c 100644 --- a/.gitignore +++ b/.gitignore @@ -44,3 +44,5 @@ run src/main/resources/assets/customnpcs/api df/ tmp/ +src/test + diff --git a/1.11_Beta_Update.md b/1.11_Beta_Update.md new file mode 100644 index 000000000..815c62e5d --- /dev/null +++ b/1.11_Beta_Update.md @@ -0,0 +1,92 @@ +# CNPC+ 1.11 Beta - The Scripting Update + +🟡 **In Testing** + + + +## Features: ⚒️ + +- **Syntax Highlighting:** + +> Full color-coded script editor. Keywords, types, variables, methods, strings, and comments are all distinct. Scope-aware coloring distinguishes local fields from globals and chained method calls. + + + +- **Autocomplete:** + +> Smart suggestions as you type. Context-aware for static vs instance access, shows method parameters, resolves chained calls, and suggests auto imports for classes. Frequently used members prioritized. + + + +- **Error Detection:** + +> Catch mistakes before running. Type mismatches, wrong arguments, missing methods, unused imports, duplicate definitions, and more -- all underlined with hover messages explaining the issue. + + + +- **Hover Information:** + +> Hover any symbol to see its type, documentation, and declaration. Works on methods, fields, classes, and even generics. Click to pin tooltips in place. + + + +- **Script Editor Overhaul:** + +> - **Line Numbers** - Gutter with current line highlighting. +> - **Go To Line** - CTRL+G to jump to any line. +> - **Search & Replace** - CTRL+F / CTRL+H with real-time highlighting. +> - **Go To Definition** - CTRL+Click to jump to any symbol. +> - **Smart Undo/Redo** - Word-level instead of character-level. +> - **Line Operations** - Duplicate, delete, move up/down. +> - **Comment Toggle** - CTRL+/ for selected lines. +> - **Rename** - Rename a symbol across all occurrences. +> - **Smooth Scrolling** - Eased scroll animation. +> - **Indent Guides** - Scope-highlighted vertical indent lines. +> - **Brace Matching** - Highlighted pairs, red for unclosed. +> - **Smart Brackets** - Auto-pairing for `{}`, `()`, `[]`, `""`, `''`. +> - **Fullscreen Mode** - Expand editor to fill the game window. +> - **Shortcut Overlay** - View all keyboard shortcuts at a glance. + + + +- **Java Scripting (Janino):** + +> Write scripts in real Java compiled at runtime. Name methods after hooks for automatic wiring. Language selector per tab to switch between Java and JavaScript. External `.java` file support. + + + +- **Client-Side Scripting:** + +> Run scripts on the client for responsive experiences. Server-controlled -- off by default, must be explicitly enabled. Script files sync automatically on login and reload. + + + +- **Cloner Tab Overhaul:** + +> Folder-based organization for saved NPCs, items, and entries. Full-width directory browser for large collections. Improved tab navigation. + + + +- **Addon API Support:** + +> Addons can ship type definitions that load into the script editor automatically. Full autocomplete, hover info, and documentation for addon APIs. Addons can extend existing CNPC+ types with new methods. + + + +- **Animation Improvements:** + +> Data store for passing data across animation events and frames. New consumer-based task system for animation lifecycle. Expanded scripting API for animation control. + + + +**Extras** + +- Player Dialog Events now work like NPC Dialog Events. +- Attack speed configuration for linked items. +- Client-side balance prediction during Trader interactions. +- Right-click cycling on multi-option NPC buttons (Hair, Eyes, Fur, etc.). +- Fixed quest cooldown for MC Custom and RL Custom timer types. +- Fixed Bard music restarting when opening dialogs. +- Fixed NPC biome spawn settings not saving after editing. +- Fixed block waypoint issues. +- Fixed script config syncing between server and client. diff --git a/1.11_Update.md b/1.11_Update.md new file mode 100644 index 000000000..c6101a559 --- /dev/null +++ b/1.11_Update.md @@ -0,0 +1,118 @@ +# ✏️ CustomNPC+ 1.11 - The Scripting Update ✏️ + +--- + +The **Scripting Update** completely transforms how you write scripts in CNPC+! A brand new **Script Editor** with **syntax highlighting**, **autocomplete**, and **error detection** makes scripting feel like a real IDE. Write scripts in **Java** with the new Janino engine, enable **client-side scripting** for responsive experiences, and organize your Cloner with **folders**! + +--- + +## Script Editor 📝 + +The script editor has been rebuilt from the ground up into a **full-featured code editor** right inside Minecraft. + +### Writing Code + +- **Syntax Highlighting** - Keywords, types, variables, methods, strings, and comments are all color-coded automatically. The editor understands your code -- local variables, global fields, and chained method calls each get their own color +- **Autocomplete** - Start typing and get smart suggestions for methods, fields, and classes. Suggestions know whether you're in a static or instance context, and frequently used members appear first +- **Auto Imports** - Type a class name and the editor suggests the correct import for you +- **Error Detection** - Catch mistakes before you even run your script! Wrong argument types, missing methods, type mismatches, unused imports, and more are all underlined with detailed error messages on hover + +> Hover over any symbol to see its **full type information**, documentation, and declaration -- just like a desktop IDE. + +--- + +### Navigation + +- **Go To Line** - `CTRL+G` jumps to any line instantly +- **Search & Replace** - `CTRL+F` to search, `CTRL+H` to replace. All matches highlight in real-time +- **Go To Definition** - `CTRL+Click` any method, field, or type to jump straight to its definition +- **Fullscreen Mode** - Expand the editor to fill your entire game window for maximum workspace + +### Editing + +- **Undo/Redo** - Smart undo that works on whole words at a time, not individual characters +- **Line Operations** - Duplicate lines with `CTRL+D`, delete lines, and move lines up or down with shortcuts +- **Comment Toggle** - `CTRL+/` to comment or uncomment selected lines +- **Rename** - Rename a variable or method and every occurrence updates at once +- **Copy Whole Line** - Copy with nothing selected grabs the entire line +- **Triple Click** - Select an entire line instantly + +### Visual Polish + +- **Line Numbers** - A clean gutter with line numbers and current line highlighting +- **Smooth Scrolling** - Eased scroll animations for a polished feel +- **Indent Guides** - Vertical lines show your code's nesting depth, with the current scope highlighted in green +- **Brace Matching** - Matching `{}` braces light up, and unclosed braces turn red +- **Smart Brackets** - Typing `{` automatically creates the closing `}` with correct indentation. Same for `()`, `[]`, `""`, and `''` +- **Keyboard Shortcut Overlay** - Press a button to see all available shortcuts at a glance + +--- + +## Java Scripting ☕ + +Write scripts in **real Java** instead of JavaScript! Powered by the **Janino** compiler, your Java code is compiled and runs natively. + +- **Full Java Language** - Use classes, interfaces, enums, generics, lambdas, and everything you know from Java +- **Automatic Hook Resolution** - Just name your methods after the hook you want (e.g., `init`, `tick`, `interact`) and they're wired up automatically +- **Language Selector** - Each script tab has a dropdown to choose between JavaScript and Java. Mix and match across tabs +- **External Files** - Write `.java` scripts in an external editor and they're loaded automatically + +> Java and JavaScript scripts coexist side by side. Pick whichever language fits your workflow! + +--- + +## Client-Side Scripting 🖥️ + +Scripts can now run **on the client** for responsive, visual experiences! + +- **Server Controlled** - Server owners decide whether client scripting is allowed. Players can't enable it on their own +- **Automatic Sync** - Script files are sent from the server to all connected clients on login, and re-synced whenever scripts are reloaded +- **Safe by Default** - Client scripting is off by default and must be explicitly enabled in the server config + +> Client-side scripts open the door to custom UI effects, visual feedback, and client-only hooks -- all while the server stays in full control. + +--- + +## Cloner Tab Overhaul 📂 + +The Cloner now supports **folders** for organizing your saved NPCs, items, and entries! + +- **Folder System** - Create folders and subfolders to keep your cloner organized however you like +- **Full Screen Browser** - A new full-width directory view makes browsing large collections much easier +- **Improved Tabs** - Better tab navigation for switching between cloner categories + +--- + +## Addon API Support 📘 + +Addon developers can now ship **type definitions** alongside their mods, giving scripters full autocomplete and documentation for addon APIs! + +- **Automatic Loading** - Any mod can include API definitions and they'll appear in the script editor automatically +- **Patch Support** - Addons can extend existing CNPC+ types with new methods (e.g., a DBC addon adding `getDBCPlayer()` to the Player type) +- **Full Documentation** - Parameter names, return types, and descriptions all show up in autocomplete and hover info + +> If you're a scripter using addons, you get autocomplete for their APIs with zero setup. If you're an addon developer, just include your definitions and everything works. + +--- + +## Animation Improvements 🎬 + +- **Data Store** - Animations can now store and pass data across events and frames for more complex animation logic +- **Task System** - A new consumer-based system for reacting to animation lifecycle events, replacing the old approach +- **Expanded API** - More animation control exposed to the scripting API + +--- + +## Additional Changes 🔧 + +- **Player Dialog Events** - Now work the same way as NPC Dialog Events for consistency +- **Linked Item Attack Speed** - Added attack speed configuration to linked items +- **Trader Balance Preview** - Client-side balance prediction shows your expected balance during trades +- **Right-Click Cycling** - Multi-option NPC buttons (Hair, Eyes, Fur, etc.) can now be right-clicked to cycle backwards +- **Quest Cooldown Fix** - Fixed cooldown not working for MC Custom and RL Custom timer types +- **Bard Music Fix** - Fixed music restarting or duplicating when opening dialogs +- **Biome Spawn Fix** - Fixed NPC biome spawn settings not saving after editing +- **Block Waypoint Fix** - Fixed issues with block waypoints +- **Script Config Fix** - Fixed script configuration not syncing properly between server and client + +--- diff --git a/build.gradle b/build.gradle index 9c56b2e2e..01a710526 100644 --- a/build.gradle +++ b/build.gradle @@ -3,6 +3,7 @@ plugins { id 'com.gtnewhorizons.gtnhconvention' id 'idea' + id "dts.typescript-generator" } version = "1.11-prerelease3" @@ -56,6 +57,30 @@ sourceSets.main.java { srcDirs += apiDir } +// ============================================================================ +// TypeScript Definition Generation Task +// Generates .d.ts files from Java API sources for scripting IDE support +// ============================================================================ +// TypeScript plugin is applied above in the main plugins block + +tasks.named("generateTypeScriptDefinitions").configure { + sourceDirectories = ['src/api/java', 'src/main/java'] + outputDirectory = "src/main/resources/assets/${project.property("modId")}/api" + apiPackages = ['noppes.npcs.api', 'net.minecraft'] as Set + cleanOutputFirst = true // Clean old generated files before regenerating + patchesDirectory = "dts-patches" + implementationPackages = [ + 'noppes.npcs.scripted', + 'noppes.npcs.controllers.data', + 'noppes.npcs.entity.data', + 'noppes.npcs.quests', + 'kamkeel.npcs.controllers.data' + ] as Set +} +processResources.dependsOn generateTypeScriptDefinitions +sourcesJar.dependsOn generateTypeScriptDefinitions + + // Register @hookName as a valid Javadoc tag tasks.withType(Javadoc) { options.tags = [ diff --git a/dependencies.gradle b/dependencies.gradle index 33dc51ee2..33eb048c1 100644 --- a/dependencies.gradle +++ b/dependencies.gradle @@ -45,6 +45,8 @@ dependencies { shadowImplementation(project.files("tools/standalone-JaninoLoader-1.0.1-ALPHA.jar")) annotationProcessor(project.files("tools/standalone-JaninoLoader-1.0.1-ALPHA.jar")) + + testImplementation("junit:junit:4.13.2") if(embedMixin){ // Normal Jar will include built in Mixins diff --git a/dts-patches/ecmascript/Array.d.ts b/dts-patches/ecmascript/Array.d.ts new file mode 100644 index 000000000..6ffd25a8c --- /dev/null +++ b/dts-patches/ecmascript/Array.d.ts @@ -0,0 +1,126 @@ +/** + * ECMAScript 5.1 - Array type for working with ordered collections of elements. + * Supports static methods like Array.isArray() and instance methods like push(), map(), filter(). + * + * ## How to Use + * + * ### Creating Arrays + * ```js + * var empty = []; // Empty array + * var nums = [1, 2, 3]; // Array with values + * var mixed = ["hello", 42, true]; // Mixed types + * var nested = [[1, 2], [3, 4]]; // Nested arrays + * ``` + * + * ### Static Methods + * ```js + * Array.isArray([1, 2, 3]); // true + * Array.isArray("hello"); // false + * Array.isArray({length: 3}); // false + * ``` + * + * ### Adding & Removing Elements + * ```js + * var arr = [1, 2, 3]; + * arr.push(4); // [1, 2, 3, 4] — add to end + * arr.pop(); // [1, 2, 3] — remove from end + * arr.unshift(0); // [0, 1, 2, 3] — add to start + * arr.shift(); // [1, 2, 3] — remove from start + * arr.splice(1, 1, 99); // [1, 99, 3] — replace at index 1 + * ``` + * + * ### Searching & Iterating + * ```js + * var arr = [10, 20, 30, 20]; + * arr.indexOf(20); // 1 (first match) + * arr.lastIndexOf(20); // 3 (last match) + * arr.forEach(function(val) { log(val); }); + * var doubled = arr.map(function(v) { return v * 2; }); // [20, 40, 60, 40] + * var big = arr.filter(function(v) { return v > 15; }); // [20, 30, 20] + * ``` + * + * ### Reducing & Testing + * ```js + * var sum = [1, 2, 3].reduce(function(acc, v) { return acc + v; }, 0); // 6 + * var allPositive = [1, 2, 3].every(function(v) { return v > 0; }); // true + * var hasNeg = [1, -2, 3].some(function(v) { return v < 0; }); // true + * ``` + * + * ### ❌ Common Mistakes + * ```js + * Array.push(1); // TypeError — push is an instance method + * var a = [3,1,2]; a.sort(); // Sorts as strings! Use compareFn for numbers + * a.sort(function(a, b) { return a - b; }); // Correct numeric sort: [1, 2, 3] + * ``` + */ +export interface Array { + /** Returns true if the given object is an array, false otherwise */ + static isArray(arg: any): boolean; + + /** The number of elements in the array */ + length: number; + + /** Combines two or more arrays and returns a new array without modifying the original */ + concat(...items: T[]): T[]; + + /** Tests whether all elements in the array pass the provided test function */ + every(callback: Java.java.util.function.Function): boolean; + + /** Creates a new array with all elements that pass the test implemented by the provided function */ + filter(callback: Java.java.util.function.Function): T[]; + + /** Executes a provided function once for each array element. Returns undefined */ + forEach(callback: Java.java.util.function.Consumer): void; + + /** Returns the first index at which an element is found, or -1 if not present */ + indexOf(searchElement: T): number; + indexOf(searchElement: T, fromIndex: number): number; + + /** Joins all elements of an array into a string separated by the given separator */ + join(separator: string): string; + + /** Returns the last index at which an element is found, or -1 if not present */ + lastIndexOf(searchElement: T): number; + lastIndexOf(searchElement: T, fromIndex: number): number; + + /** Creates a new array with the results of calling a function on every element */ + map(callback: Java.java.util.function.Function): any[]; + + /** Removes and returns the last element from the array, modifying the original array */ + pop(): T; + + /** Adds one or more elements to the end of an array and returns the new length */ + push(...items: T[]): number; + + /** Applies a function against an accumulator and each element to reduce the array to a single value */ + reduce(callback: Java.java.util.function.BiFunction): any; + reduce(callback: Java.java.util.function.BiFunction, initialValue: any): any; + + /** Same as reduce() but processes the array from right to left */ + reduceRight(callback: Java.java.util.function.BiFunction): any; + reduceRight(callback: Java.java.util.function.BiFunction, initialValue: any): any; + + /** Reverses an array in place. The first element becomes the last, and vice versa */ + reverse(): T[]; + + /** Removes and returns the first element from the array, modifying the original array */ + shift(): T; + + /** Returns a shallow copy of a portion of an array as a new array object */ + slice(start: number, end: number): T[]; + + /** Tests whether at least one element in the array passes the test implemented by the provided function */ + some(callback: Java.java.util.function.Function): boolean; + + /** Sorts the elements of an array in place and returns the sorted array */ + sort(compareFn: Java.java.util.function.BiFunction): T[]; + + /** Changes the contents of an array by removing or replacing existing elements and/or adding new ones */ + splice(start: number, deleteCount: number, ...items: T[]): T[]; + + /** Returns a string representation of the array */ + toString(): string; + + /** Adds one or more elements to the beginning of an array and returns the new length */ + unshift(...items: T[]): number; +} diff --git a/dts-patches/ecmascript/Boolean.d.ts b/dts-patches/ecmascript/Boolean.d.ts new file mode 100644 index 000000000..50b68626e --- /dev/null +++ b/dts-patches/ecmascript/Boolean.d.ts @@ -0,0 +1,36 @@ +/** + * ECMAScript 5.1 - Boolean type for true/false values. + * Booleans are the result of comparison and logical operations. + * + * ## How to Use + * + * ### Creating Booleans + * ```js + * var yes = true; // Boolean literal + * var no = false; // Boolean literal + * var fromExpr = (5 > 3); // true (comparison result) + * ``` + * + * ### Boolean Methods + * ```js + * var b = true; + * b.toString(); // "true" + * b.valueOf(); // true (primitive value) + * ``` + * + * ### Truthy & Falsy Values + * ```js + * // These are FALSY (evaluate to false): + * // false, 0, "", null, undefined, NaN + * + * // These are TRUTHY (evaluate to true): + * // true, any non-zero number, any non-empty string, objects, arrays + * + */ +export interface Boolean { + /** Returns the string "true" or "false" */ + toString(): string; + + /** Returns the primitive boolean value */ + valueOf(): boolean; +} diff --git a/dts-patches/ecmascript/Date.d.ts b/dts-patches/ecmascript/Date.d.ts new file mode 100644 index 000000000..68f6f069c --- /dev/null +++ b/dts-patches/ecmascript/Date.d.ts @@ -0,0 +1,168 @@ +/** + * ECMAScript 5.1 - Date type for working with dates and times. + * Create with `new Date()` or use static methods like Date.now() to get current timestamp. + * + * ## How to Use + * + * ### Creating Dates + * ```js + * var now = new Date(); // Current date & time + * var epoch = new Date(0); // Jan 1, 1970 + * var specific = new Date(2024, 0, 15); // Jan 15, 2024 (months are 0-based!) + * var full = new Date(2024, 5, 15, 10, 30, 0); // Jun 15, 2024 10:30:00 + * var fromStr = new Date("2024-01-15"); // Parse from ISO string + * ``` + * + * ### Static Methods (no `new` needed) + * ```js + * var timestamp = Date.now(); // Current time in milliseconds + * var parsed = Date.parse("2024-01-15"); // Parse string to timestamp + * var utc = Date.UTC(2024, 0, 15); // UTC timestamp for Jan 15, 2024 + * ``` + * + * ### Common Mistakes + * ```js + * Date.now; // Returns the function, not the timestamp! + * Date.getMinutes(); // TypeError — instance method, not static + * new Date(2024, 1, 1); // Feb 1, not Jan 1 — months are 0-based! + * ``` + */ +export interface Date { + /** Returns the current time as the number of milliseconds since 1970-01-01 00:00:00 UTC */ + static now(): number; + + /** Parses a date string and returns the number of milliseconds since 1970-01-01 00:00:00 UTC */ + static parse(s: string): number; + + /** Returns the number of milliseconds since 1970-01-01 00:00:00 UTC for the given UTC date/time components */ + static UTC(year: number, month: number, date: number, hours: number, minutes: number, seconds: number, ms: number): number; + + /** Returns the day of the month (1-31) in local time */ + getDate(): number; + + /** Returns the day of the week (0=Sunday, 6=Saturday) in local time */ + getDay(): number; + + /** Returns the year in local time */ + getFullYear(): number; + + /** Returns the hour (0-23) in local time */ + getHours(): number; + + /** Returns the milliseconds (0-999) in local time */ + getMilliseconds(): number; + + /** Returns the minutes (0-59) in local time */ + getMinutes(): number; + + /** Returns the month (0=January, 11=December) in local time */ + getMonth(): number; + + /** Returns the seconds (0-59) in local time */ + getSeconds(): number; + + /** Returns the number of milliseconds since 1970-01-01 00:00:00 UTC */ + getTime(): number; + + /** Returns the time zone offset in minutes between local time and UTC */ + getTimezoneOffset(): number; + + /** Returns the day of the month (1-31) in UTC */ + getUTCDate(): number; + + /** Returns the day of the week (0=Sunday, 6=Saturday) in UTC */ + getUTCDay(): number; + + /** Returns the year in UTC */ + getUTCFullYear(): number; + + /** Returns the hour (0-23) in UTC */ + getUTCHours(): number; + + /** Returns the milliseconds (0-999) in UTC */ + getUTCMilliseconds(): number; + + /** Returns the minutes (0-59) in UTC */ + getUTCMinutes(): number; + + /** Returns the month (0=January, 11=December) in UTC */ + getUTCMonth(): number; + + /** Returns the seconds (0-59) in UTC */ + getUTCSeconds(): number; + + /** Sets the day of the month and returns the new timestamp */ + setDate(date: number): number; + + /** Sets the year, and optionally month and date, then returns the new timestamp */ + setFullYear(year: number, month: number, date: number): number; + + /** Sets the hour, minutes, seconds, and milliseconds, then returns the new timestamp */ + setHours(hour: number, min: number, sec: number, ms: number): number; + + /** Sets the milliseconds and returns the new timestamp */ + setMilliseconds(ms: number): number; + + /** Sets the minutes, seconds, and milliseconds, then returns the new timestamp */ + setMinutes(min: number, sec: number, ms: number): number; + + /** Sets the month, and optionally date, then returns the new timestamp */ + setMonth(month: number, date: number): number; + + /** Sets the seconds and milliseconds, then returns the new timestamp */ + setSeconds(sec: number, ms: number): number; + + /** Sets the timestamp (milliseconds since epoch) and returns it */ + setTime(time: number): number; + + /** Sets the day of the month (UTC) and returns the new timestamp */ + setUTCDate(date: number): number; + + /** Sets the year, month, and date (UTC), then returns the new timestamp */ + setUTCFullYear(year: number, month: number, date: number): number; + + /** Sets the hour, minutes, seconds, and milliseconds (UTC), then returns the new timestamp */ + setUTCHours(hour: number, min: number, sec: number, ms: number): number; + + /** Sets the milliseconds (UTC) and returns the new timestamp */ + setUTCMilliseconds(ms: number): number; + + /** Sets the minutes, seconds, and milliseconds (UTC), then returns the new timestamp */ + setUTCMinutes(min: number, sec: number, ms: number): number; + + /** Sets the month and date (UTC), then returns the new timestamp */ + setUTCMonth(month: number, date: number): number; + + /** Sets the seconds and milliseconds (UTC), then returns the new timestamp */ + setUTCSeconds(sec: number, ms: number): number; + + /** Returns a string representation of the date portion in local time (e.g., "Mon Jan 01 2024") */ + toDateString(): string; + + /** Returns the date as an ISO 8601 string (e.g., "2024-01-01T00:00:00.000Z") */ + toISOString(): string; + + /** Returns a JSON representation of the date (typically an ISO 8601 string) */ + toJSON(key: any): string; + + /** Returns a localized string for the date portion (format depends on locale) */ + toLocaleDateString(): string; + + /** Returns a localized string for the entire date and time (format depends on locale) */ + toLocaleString(): string; + + /** Returns a localized string for the time portion (format depends on locale) */ + toLocaleTimeString(): string; + + /** Returns a string representation of the date and time in local time */ + toString(): string; + + /** Returns a string representation of the time portion in local time (e.g., "00:00:00 GMT+0000") */ + toTimeString(): string; + + /** Returns a string representation of the date and time in UTC (e.g., "Mon, 01 Jan 2024 00:00:00 GMT") */ + toUTCString(): string; + + /** Returns the primitive value of the date object (milliseconds since 1970-01-01 00:00:00 UTC) */ + valueOf(): number; +} diff --git a/dts-patches/ecmascript/Error.d.ts b/dts-patches/ecmascript/Error.d.ts new file mode 100644 index 000000000..797a763e4 --- /dev/null +++ b/dts-patches/ecmascript/Error.d.ts @@ -0,0 +1,81 @@ +/** + * ECMAScript 5.1 - Error base type for runtime errors. + * Throw Error objects to indicate failure conditions in your code. + * + * ## How to Use + * + * ### Creating & Throwing Errors + * ```js + * throw new Error("Something went wrong"); + * throw new TypeError("Expected a string"); + * throw new RangeError("Value out of range"); + * ``` + * + * ### Catching Errors + * ```js + * try { + * var result = riskyOperation(); + * } catch (e) { + * log(e.name); // "Error", "TypeError", etc. + * log(e.message); // "Something went wrong" + * log(e.toString()); // "Error: Something went wrong" + * } + * ``` + * + * ### Custom Error Messages + * ```js + * function divide(a, b) { + * if (b === 0) { + * throw new Error("Cannot divide by zero"); + * } + * return a / b; + * } + * ``` + * + * ### ❌ Common Mistakes + * ```js + * throw "Something went wrong"; // Works but no .name or .message properties + * Error("oops"); // Creates error but doesn't throw it! + * throw Error("oops"); // ✅ Works (with or without `new`) + * ``` + */ +export interface Error { + /** The name of the error type (e.g., "Error", "TypeError", "RangeError") */ + name: string; + + /** A human-readable description of what went wrong */ + message: string; + + /** Returns a string representation of the error (typically "name: message") */ + toString(): string; +} + +/** + * EvalError - Thrown when eval() function is misused (rarely used in modern JavaScript) + */ +export interface EvalError extends Error {} + +/** + * RangeError - Thrown when a numeric value is out of the acceptable range (e.g., array length < 0) + */ +export interface RangeError extends Error {} + +/** + * ReferenceError - Thrown when trying to reference a variable that does not exist or is not in scope + */ +export interface ReferenceError extends Error {} + +/** + * SyntaxError - Thrown when parsing invalid syntax (usually caught during compile/parse, not runtime) + */ +export interface SyntaxError extends Error {} + +/** + * TypeError - Thrown when an operation is performed on a value of the wrong type (e.g., calling a non-function) + */ +export interface TypeError extends Error {} + +/** + * URIError - Thrown by URI encoding/decoding functions when given invalid characters or sequences + */ +export interface URIError extends Error {} diff --git a/dts-patches/ecmascript/GlobalFunctions.d.ts b/dts-patches/ecmascript/GlobalFunctions.d.ts new file mode 100644 index 000000000..4f1f7ad3d --- /dev/null +++ b/dts-patches/ecmascript/GlobalFunctions.d.ts @@ -0,0 +1,75 @@ +/** + * ECMAScript 5.1 - Global functions available in the global scope. + * These are not on any specific object - call them directly (e.g., parseInt("42")). + * + * ## How to Use + * + * ### Parsing Numbers + * ```js + * parseInt("42"); // 42 + * parseInt("42px"); // 42 (stops at non-digit) + * parseInt("0xFF", 16); // 255 (hexadecimal) + * parseInt("111", 2); // 7 (binary) + * parseFloat("3.14"); // 3.14 + * parseFloat("3.14abc"); // 3.14 (stops at invalid char) + * ``` + * + * ### Checking Special Values + * ```js + * isNaN(NaN); // true + * isNaN(42); // false + * isNaN("hello"); // true (cannot parse as number) + * isNaN("42"); // false (can parse as number) + * isFinite(42); // true + * isFinite(Infinity); // false + * isFinite(NaN); // false + * ``` + * + * ### URI Encoding/Decoding + * ```js + * encodeURI("hello world"); // "hello%20world" + * decodeURI("hello%20world"); // "hello world" + * encodeURIComponent("a=1&b=2"); // "a%3D1%26b%3D2" (encodes & and =) + * decodeURIComponent("a%3D1%26b%3D2"); // "a=1&b=2" + * ``` + * + * ### ❌ Common Mistakes + * ```js + * parseInt("08"); // Some engines treat as octal! Always specify radix + * parseInt("08", 10); // 8 ✅ — explicitly base-10 + * parseInt(""); // NaN — empty string returns NaN, not 0 + * parseFloat(""); // NaN + * isNaN(undefined); // true — coerces to NaN first + * ``` + */ +export interface GlobalFunctions { + /** Evaluates JavaScript code in a string (use with caution - slow and potential security issues) */ + static eval(x: any): any; + + /** Parses a string and returns an integer. Stops parsing at the first non-digit character */ + static parseInt(string: string): number; + + /** Parses a string and returns an integer using the specified radix (base). Stops parsing at the first non-digit character */ + static parseInt(string: string, radix: number): number; + + /** Parses a string and returns a floating-point number. Stops parsing at the first invalid character */ + static parseFloat(string: string): number; + + /** Determines whether a value is NaN (not-a-number). The value is first coerced to a number before testing */ + static isNaN(value: any): boolean; + + /** Determines whether a value is a finite number. The value is first coerced to a number. Returns false for Infinity, -Infinity, and NaN */ + static isFinite(value: any): boolean; + + /** Decodes a URI by replacing encoded sequences like %20 with their original characters */ + static decodeURI(encodedURI: string): string; + + /** Decodes URI component by replacing ALL encoded sequences including those for reserved URI characters */ + static decodeURIComponent(encodedURIComponent: string): string; + + /** Encodes a URI by replacing special characters with %HH sequences (but preserves reserved characters like / : ?) */ + static encodeURI(uri: string): string; + + /** Encodes URI component by replacing ALL special characters including reserved ones with %HH sequences */ + static encodeURIComponent(uriComponent: string): string; +} diff --git a/dts-patches/ecmascript/JSON.d.ts b/dts-patches/ecmascript/JSON.d.ts new file mode 100644 index 000000000..1934e532e --- /dev/null +++ b/dts-patches/ecmascript/JSON.d.ts @@ -0,0 +1,100 @@ +/** + * ECMAScript 5.1 - JSON built-in object for parsing and serializing JSON data. + * + * ## How to Use + * + * JSON is a **static object** — use its methods directly, never with `new`. + * + * ### Parsing JSON Strings to Objects + * ```js + * var obj = JSON.parse('{"name": "Steve", "level": 5}'); + * log(obj.name); // "Steve" + * log(obj.level); // 5 + * + * var arr = JSON.parse('[1, 2, 3]'); + * log(arr[0]); // 1 + * ``` + * + * ### Converting Objects to JSON Strings + * ```js + * var data = { name: "Steve", hp: 100 }; + * var json = JSON.stringify(data); // '{"name":"Steve","hp":100}' + * + * // Pretty-printed with 2-space indent: + * var pretty = JSON.stringify(data, null, 2); + * // '{ + * // "name": "Steve", + * // "hp": 100 + * // }' + * ``` + * + * ### Storing & Loading Data + * ```js + * // Save to NPC stored data: + * var inventory = { sword: 1, potion: 5 }; + * npc.getStoredData().put("inv", JSON.stringify(inventory)); + * + * // Load from NPC stored data: + * var raw = npc.getStoredData().get("inv"); + * var loaded = JSON.parse(raw); + * log(loaded.potion); // 5 + * ``` + * + * ### ❌ Common Mistakes + * ```js + * new JSON(); // TypeError — JSON is not a constructor + * JSON.parse('{name: "Steve"}'); // SyntaxError — keys must be quoted + * JSON.parse("{'name': 'Steve'}"); // SyntaxError — must use double quotes + * JSON.parse('{"name": "Steve"}'); // ✅ Correct — double-quoted keys & values + * ``` + */ +export interface JSON { + /** + * Parses a JSON string and returns the parsed value (object, array, string, number, boolean, or null). + * @param text - A valid JSON string to parse + * @returns The parsed JavaScript value + */ + static parse(text: string): any; + + /** + * Parses a JSON string with a reviver function that transforms each parsed key-value pair. + * @param text - A valid JSON string to parse + * @param reviver - Function called for each key-value pair; receives the key and parsed value, returns the transformed value + * @returns The parsed JavaScript value after applying the reviver + */ + static parse(text: string, reviver: Java.java.util.function.BiFunction): any; + + /** + * Converts a JavaScript value to a JSON string. + * @param value - The value to serialize (object, array, string, number, boolean, or null) + * @returns A JSON-formatted string representation of the value + */ + static stringify(value: any): string; + + /** + * Converts a JavaScript value to a JSON string, using a replacer function to filter or transform properties. + * @param value - The value to serialize + * @param replacer - Function called for each key-value pair; receives the key and value, returns the value to include (or undefined to omit) + * @param space - Optional indentation: a number of spaces (up to 10), or a string prefix per level + * @returns A JSON-formatted string representation of the value + */ + static stringify(value: any, replacer: Java.java.util.function.BiFunction, space?: any): string; + + /** + * Converts a JavaScript value to a JSON string, including only the specified properties. + * @param value - The value to serialize + * @param replacer - Array of property names to include in the output + * @param space - Optional indentation: a number of spaces (up to 10), or a string prefix per level + * @returns A JSON-formatted string representation of the value + */ + static stringify(value: any, replacer: string[], space?: any): string; + + /** + * Converts a JavaScript value to a JSON string with optional pretty-printing. + * @param value - The value to serialize + * @param replacer - Pass null to include all properties + * @param space - Indentation: a number of spaces (up to 10), or a string prefix per level + * @returns A JSON-formatted string representation of the value + */ + static stringify(value: any, replacer: null, space: any): string; +} diff --git a/dts-patches/ecmascript/Math.d.ts b/dts-patches/ecmascript/Math.d.ts new file mode 100644 index 000000000..30f7e2889 --- /dev/null +++ b/dts-patches/ecmascript/Math.d.ts @@ -0,0 +1,128 @@ +/** + * ECMAScript 5.1 - Math built-in object providing mathematical constants and functions. + * All methods are static and called as Math.methodName(). No constructor. + * + * ## How to Use + * + * Math is a **static object** — use its methods directly, never with `new`. + * + * ### Basic Math Operations + * ```js + * var rounded = Math.floor(3.7); // 3 + * var ceiling = Math.ceil(3.2); // 4 + * var nearest = Math.round(3.5); // 4 + * var absolute = Math.abs(-42); // 42 + * ``` + * + * ### Powers, Roots & Logarithms + * ```js + * var squared = Math.pow(2, 3); // 8 + * var root = Math.sqrt(16); // 4 + * var natural = Math.log(Math.E); // 1 + * ``` + * + * ### Random Numbers + * ```js + * var rand = Math.random(); // 0.0 to 0.999... + * // Random integer between 1 and 10: + * var dice = Math.floor(Math.random() * 10) + 1; + * ``` + * + * ### Finding Min/Max + * ```js + * var biggest = Math.max(5, 10, 3); // 10 + * var smallest = Math.min(5, 10, 3); // 3 + * ``` + * + * ### Trigonometry + * ```js + * var sine = Math.sin(Math.PI / 2); // 1 + * var cosine = Math.cos(0); // 1 + * var angle = Math.atan2(1, 1); // 0.785... (PI/4) + * ``` + * + * ### ❌ Common Mistakes + * ```js + * new Math() // TypeError — Math is not a constructor + * Math() // TypeError — Math is not a function + * ``` + */ +export interface Math { + /** Euler's number (~2.718), the base of natural logarithms */ + static readonly E: number; + + /** Natural logarithm of 2 (~0.693) */ + static readonly LN2: number; + + /** Natural logarithm of 10 (~2.303) */ + static readonly LN10: number; + + /** Base-2 logarithm of e (~1.443) */ + static readonly LOG2E: number; + + /** Base-10 logarithm of e (~0.434) */ + static readonly LOG10E: number; + + /** Ratio of a circle's circumference to its diameter (~3.14159) */ + static readonly PI: number; + + /** Square root of 0.5 (~0.707) */ + static readonly SQRT1_2: number; + + /** Square root of 2 (~1.414) */ + static readonly SQRT2: number; + + /** Returns the absolute value of a number */ + static abs(x: number): number; + + /** Returns the arccosine (in radians) of a number */ + static acos(x: number): number; + + /** Returns the arcsine (in radians) of a number */ + static asin(x: number): number; + + /** Returns the arctangent (in radians) of a number */ + static atan(x: number): number; + + /** Returns the arctangent of two numbers (y/x), with proper quadrant handling */ + static atan2(y: number, x: number): number; + + /** Returns the smallest integer greater than or equal to a number */ + static ceil(x: number): number; + + /** Returns the cosine (in radians) of a number */ + static cos(x: number): number; + + /** Returns e raised to the power of a number */ + static exp(x: number): number; + + /** Returns the largest integer less than or equal to a number */ + static floor(x: number): number; + + /** Returns the natural logarithm (base e) of a number */ + static log(x: number): number; + + /** Returns the largest of zero or more numbers */ + static max(...values: number[]): number; + + /** Returns the smallest of zero or more numbers */ + static min(...values: number[]): number; + + /** Returns base raised to the power of exponent */ + static pow(x: number, y: number): number; + + /** Returns a random number between 0 (inclusive) and 1 (exclusive) */ + static random(): number; + + /** Returns the value of a number rounded to the nearest integer */ + static round(x: number): number; + + /** Returns the sine (in radians) of a number */ + static sin(x: number): number; + + /** Returns the square root of a number */ + static sqrt(x: number): number; + + /** Returns the tangent (in radians) of a number */ + static tan(x: number): number; +} diff --git a/dts-patches/ecmascript/Number.d.ts b/dts-patches/ecmascript/Number.d.ts new file mode 100644 index 000000000..10f57f816 --- /dev/null +++ b/dts-patches/ecmascript/Number.d.ts @@ -0,0 +1,74 @@ +/** + * ECMAScript 5.1 - Number type for working with numeric values and constants. + * Access static constants like Number.MAX_VALUE or format numbers with instance methods. + * + * ## How to Use + * + * ### Number Constants + * ```js + * Number.MAX_VALUE; // ~1.79e+308 (largest representable number) + * Number.MIN_VALUE; // ~5e-324 (smallest positive number) + * Number.NaN; // NaN + * Number.POSITIVE_INFINITY; // Infinity + * Number.NEGATIVE_INFINITY; // -Infinity + * ``` + * + * ### Formatting Numbers + * ```js + * var n = 3.14159; + * n.toFixed(2); // "3.14" (fixed decimal places) + * n.toFixed(0); // "3" + * n.toPrecision(4); // "3.142" (significant digits) + * n.toExponential(2); // "3.14e+0" (scientific notation) + * ``` + * + * ### Converting to String + * ```js + * var n = 255; + * n.toString(); // "255" (base 10, default) + * n.toString(16); // "ff" (hexadecimal) + * n.toString(2); // "11111111" (binary) + * n.toString(8); // "377" (octal) + * ``` + * + * ### ❌ Common Mistakes + * ```js + * Number.toFixed(2); // TypeError — instance method, not static + * (3).toFixed(2); // "3.00" ✅ — wrap literal in parentheses + * 3.toFixed(2); // SyntaxError — parser reads 3. as float + * ``` + */ +export interface Number { + /** The largest representable number (~1.79e+308) */ + static readonly MAX_VALUE: number; + + /** The smallest representable positive number (~5e-324) */ + static readonly MIN_VALUE: number; + + /** Represents "Not a Number" (NaN) - the result of undefined or invalid arithmetic operations */ + static readonly NaN: number; + + /** Represents negative infinity, the result of overflow or division by zero */ + static readonly NEGATIVE_INFINITY: number; + + /** Represents positive infinity, the result of overflow or division by zero */ + static readonly POSITIVE_INFINITY: number; + + /** Formats the number using exponential notation with optional fractional digits */ + toExponential(fractionDigits: number): string; + + /** Formats the number as a fixed-point string with the specified number of fractional digits (0-20) */ + toFixed(fractionDigits: number): string; + + /** Returns a localized string representation of the number (format depends on locale) */ + toLocaleString(): string; + + /** Formats the number as a string with the specified number of significant digits (1-21) */ + toPrecision(precision: number): string; + + /** Converts the number to a string in the specified radix (base 2-36, default 10) */ + toString(radix: number): string; + + /** Returns the primitive numeric value of this Number object */ + valueOf(): number; +} diff --git a/dts-patches/ecmascript/Object.d.ts b/dts-patches/ecmascript/Object.d.ts new file mode 100644 index 000000000..3b103139c --- /dev/null +++ b/dts-patches/ecmascript/Object.d.ts @@ -0,0 +1,105 @@ +/** + * ECMAScript 5.1 - Object type, the base type for all JavaScript objects. + * Use static methods like Object.keys() and Object.create() to manipulate object structure. + * + * ## How to Use + * + * ### Creating Objects + * ```js + * var obj = {}; // Empty object literal + * var person = { name: "Steve", age: 20 }; // Object with properties + * var child = Object.create(person); // Create with prototype + * ``` + * + * ### Inspecting Objects + * ```js + * var obj = { a: 1, b: 2, c: 3 }; + * Object.keys(obj); // ["a", "b", "c"] + * Object.getOwnPropertyNames(obj); // ["a", "b", "c"] (includes non-enumerable) + * obj.hasOwnProperty("a"); // true + * obj.hasOwnProperty("toString"); // false (inherited, not own) + * ``` + * + * ### Freezing & Sealing + * ```js + * var config = { debug: false }; + * Object.freeze(config); // Cannot modify, add, or delete properties + * config.debug = true; // Silently fails (or throws in strict mode) + * Object.isFrozen(config); // true + * + * var settings = { volume: 50 }; + * Object.seal(settings); // Can modify values, but cannot add/delete + * settings.volume = 75; // ✅ Works + * settings.newProp = true; // Silently fails + * ``` + * + * ### Property Descriptors + * ```js + * var obj = {}; + * Object.defineProperty(obj, "id", { + * value: 42, + * writable: false, // Cannot be changed + * enumerable: true // Shows up in for-in / Object.keys + * }); + * ``` + * + * ### ❌ Common Mistakes + * ```js + * Object.keys(); // TypeError — needs an argument + * obj.keys(); // TypeError — keys is a static method + * Object.hasOwnProperty("a"); // Wrong — instance method on the object + * ``` + */ +export interface Object { + /** Creates a new object with the specified prototype and optional property descriptors */ + static create(proto: any, propertiesObject: any): any; + + /** Defines or modifies multiple properties on an object and returns the modified object */ + static defineProperties(obj: any, props: any): any; + + /** Defines a new property on an object or modifies an existing property and returns the object */ + static defineProperty(obj: any, prop: string, descriptor: any): any; + + /** Prevents all modifications to an object (cannot add, modify, or delete properties) */ + static freeze(obj: any): any; + + /** Returns a property descriptor for a named property on an object, or undefined if not found */ + static getOwnPropertyDescriptor(obj: any, prop: string): any; + + /** Returns an array of all property names (both enumerable and non-enumerable) on an object */ + static getOwnPropertyNames(obj: any): string[]; + + /** Returns the prototype object of the specified object */ + static getPrototypeOf(obj: any): any; + + /** Determines whether an object is extensible (can have new properties added to it) */ + static isExtensible(obj: any): boolean; + + /** Determines whether an object has been frozen (is immutable) */ + static isFrozen(obj: any): boolean; + + /** Determines whether an object is sealed (cannot add or delete properties) */ + static isSealed(obj: any): boolean; + + /** Returns an array of all enumerable property names on an object */ + static keys(obj: any): string[]; + + /** Prevents new properties from being added to an object but allows modification of existing ones */ + static preventExtensions(obj: any): any; + + /** Prevents all modifications to an object except for reading and writing property values */ + static seal(obj: any): any; + + /** Determines whether an object has a property with the specified name (direct property, not inherited) */ + hasOwnProperty(prop: string): boolean; + + /** Determines whether an object is in the prototype chain of another object */ + isPrototypeOf(obj: any): boolean; + + /** Determines whether an object property is enumerable (would be included in a for-in loop) */ + propertyIsEnumerable(prop: string): boolean; + + /** Returns a localized string representation of the object (format depends on locale) */ + toLocaleString(): string; + +} diff --git a/dts-patches/ecmascript/RegExp.d.ts b/dts-patches/ecmascript/RegExp.d.ts new file mode 100644 index 000000000..a048f429d --- /dev/null +++ b/dts-patches/ecmascript/RegExp.d.ts @@ -0,0 +1,94 @@ +/** + * ECMAScript 5.1 - RegExp type for pattern matching and string manipulation. + * Create with the RegExp constructor or literal syntax: /pattern/flags + * + * ## How to Use + * + * ### Creating Regular Expressions + * ```js + * // Method 1: Regex literal (preferred) + * var re = /hello/; + * var reFlags = /hello/gi; // g=global, i=ignore case, m=multiline + * + * // Method 2: Constructor (useful for dynamic patterns) + * var re2 = new RegExp("hello"); + * var re3 = new RegExp("hello", "gi"); + * var dynamic = new RegExp(playerName); // Build pattern from variable + * ``` + * + * ### Testing for Matches + * ```js + * /\d+/.test("abc123"); // true — contains digits + * /^\d+$/.test("abc123"); // false — not ALL digits + * /^\d+$/.test("12345"); // true — all digits + * /hello/i.test("Hello World"); // true — case insensitive + * ``` + * + * ### Extracting Matches + * ```js + * var match = /\d+/.exec("abc123def"); // ["123"] + * var noMatch = /\d+/.exec("no digits"); // null + * + * // With capturing groups + * var result = /(\w+)@(\w+)/.exec("user@domain"); + * // result[0] = "user@domain" (full match) + * // result[1] = "user" (first group) + * // result[2] = "domain" (second group) + * ``` + * + * ### Using with String Methods + * ```js + * "abc123".match(/\d+/); // ["123"] + * "abc123".search(/\d/); // 3 (index of first digit) + * "abc123".replace(/\d+/, "NUM"); // "abcNUMdef" + * "a,b,,c".split(/,+/); // ["a", "b", "c"] + * ``` + * + * ### RegExp Properties + * ```js + * var re = /hello/gi; + * re.source; // "hello" + * re.global; // true + * re.ignoreCase; // true + * re.multiline; // false + * re.lastIndex; // 0 (changes with global exec/test) + * ``` + * + * ### ❌ Common Mistakes + * ```js + * RegExp.test("string"); // TypeError — test is an INSTANCE method! + * new RegExp.test("string"); // TypeError — incorrect syntax + * // ✅ CORRECT: + * /pattern/.test("string"); // Use on a regex instance + * new RegExp("pattern").test("string"); // Or create instance first + * + * // Double-escape backslashes in constructor strings: + * new RegExp("\d+"); // Wrong — \d becomes just d + * new RegExp("\\d+"); // ✅ Correct — \\d becomes \d + * ``` + */ +export interface RegExp { + /** The pattern string that was used to create this regular expression */ + source: string; + + /** True if the 'g' (global) flag is set, affecting match behavior in exec() and test() */ + global: boolean; + + /** True if the 'i' (ignore case) flag is set, making pattern matching case-insensitive */ + ignoreCase: boolean; + + /** True if the 'm' (multiline) flag is set, affecting ^ and $ anchor behavior */ + multiline: boolean; + + /** The index at which to start searching in the string (used with 'g' flag in exec() loops) */ + lastIndex: number; + + /** Searches the string for a match and returns an array of matches or null if no match found */ + exec(string: string): any[]; + + /** Tests whether the pattern matches the string, returning true or false */ + test(string: string): boolean; + + /** Returns a string representation of the regular expression (e.g., "/pattern/flags") */ + toString(): string; +} diff --git a/dts-patches/ecmascript/String.d.ts b/dts-patches/ecmascript/String.d.ts new file mode 100644 index 000000000..8a48033e2 --- /dev/null +++ b/dts-patches/ecmascript/String.d.ts @@ -0,0 +1,82 @@ +/** + * ECMAScript 5.1 - String type for working with text. Strings are immutable sequences of characters. + * Use String.fromCharCode() to create a string from character codes. + * + * ## How to Use + * + * ### Creating Strings + * ```js + * var greeting = "Hello, world!"; // String literal (double quotes) + * var name = 'Steve'; // String literal (single quotes) + * var fromCode = String.fromCharCode(65); // "A" (from char code) + * ``` + * + * ### Searching & Checking + * ```js + * var str = "Hello, world!"; + * str.indexOf("world"); // 7 + * str.indexOf("missing"); // -1 (not found) + * str.lastIndexOf("l"); // 10 + * str.search(/world/); // 7 (regex search) + * str.charAt(0); // "H" + * str.charCodeAt(0); // 72 + * str.length; // 13 + * ``` + * + * ### Extracting & Transforming + * ```js + * var str = "Hello, world!"; + * str.slice(7, 12); // "world" + * str.substring(0, 5); // "Hello" + * str.toUpperCase(); // "HELLO, WORLD!" + * str.toLowerCase(); // "hello, world!" + * str.trim(); // Removes leading/trailing whitespace + * str.replace("world", "NPC"); // "Hello, NPC!" + * str.replace(/l/g, "L"); // "HeLLo, worLd!" (regex with global flag) + * ``` + * + * ### Splitting & Joining + * ```js + * "a,b,c".split(","); // ["a", "b", "c"] + * "hello".split(""); // ["h", "e", "l", "l", "o"] + * ["a", "b", "c"].join("-"); // "a-b-c" (Array.join, but related) + * "one two three".split(" ", 2); // ["one", "two"] (limit results) + * ``` + * + * ### Pattern Matching + * ```js + * "abc123".match(/\d+/); // ["123"] + * "no numbers".match(/\d+/); // null + * "hello".concat(" ", "world"); // "hello world" + * ``` + * + * ### ❌ Common Mistakes + * ```js + * str.replace("l", "L"); // Only replaces FIRST "l" — use /l/g for all + * String.charAt(0); // TypeError — instance method, not static + * "abc"[0]; // May not work in all engines — use charAt() + * ``` + */ +export interface String { + /** The number of characters in the string */ + length: number; + + /** Creates a string from one or more Unicode character codes (e.g., String.fromCharCode(65, 66, 67) returns "ABC") */ + static fromCharCode(...codes: number[]): string; + + /** Returns the Unicode code point (0–65535) of the character at the specified index. Unlike Java's charAt() + cast, this returns the numeric code directly. */ + charCodeAt(pos: number): number; + + /** Tests the string against a regular expression and returns an array of matches, or null if no match found */ + match(regexp: any): any[]; + + /** + * Replaces a pattern (string or RegExp object) with a replacement string. + * Unlike Java's replace/replaceAll which only accept String/CharSequence, + * this accepts a RegExp object as the first argument. + */ + replace(searchValue: any, replaceValue: any): string; + + /** Returns the index of the first character that matches a regular expression, or -1 if not found */ + search(regexp: any): number; +} diff --git a/settings.gradle b/settings.gradle index ec9681d97..e58786789 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,6 +1,14 @@ - pluginManagement { +// resolutionStrategy { +// eachPlugin { +// if(requested.id.toString() == "dts.typescript-generator") { +// useModule("com.github.bigguy345:dts-gradle-plugin:95b8ab4") +// } +// } +// } +// repositories { + maven { url "https://jitpack.io"} maven { // RetroFuturaGradle name "GTNH Maven" @@ -19,3 +27,6 @@ pluginManagement { plugins { id 'com.gtnewhorizons.gtnhsettingsconvention' version '1.0.27' } + +// Include the local gradle-plugins composite build so plugin is resolved locally +includeBuild 'gradle-plugins' \ No newline at end of file diff --git a/src/main/java/noppes/npcs/client/ClientProxy.java b/src/main/java/noppes/npcs/client/ClientProxy.java index 08342c93f..481e6ada8 100644 --- a/src/main/java/noppes/npcs/client/ClientProxy.java +++ b/src/main/java/noppes/npcs/client/ClientProxy.java @@ -159,6 +159,8 @@ import noppes.npcs.client.gui.roles.GuiNpcTransporter; import noppes.npcs.client.gui.script.GuiScriptGlobal; import noppes.npcs.client.gui.script.GuiScriptInterface; import noppes.npcs.client.gui.util.script.PackageFinder; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeRegistry; +import noppes.npcs.client.gui.util.script.interpreter.type.ClassIndex; import noppes.npcs.client.model.ModelNPCGolem; import noppes.npcs.client.model.ModelNpcCrystal; import noppes.npcs.client.model.ModelNpcDragon; @@ -863,6 +865,8 @@ public class ClientProxy extends CommonProxy { public void buildPackageIndex() { try { PackageFinder.init(Thread.currentThread().getContextClassLoader()); + ClassIndex.init(); + JSTypeRegistry.getInstance().initializeFromResources(); } catch (IOException e) { } } diff --git a/src/main/java/noppes/npcs/client/CustomNpcResourceListener.java b/src/main/java/noppes/npcs/client/CustomNpcResourceListener.java index 2f2bc3115..14bb52e71 100644 --- a/src/main/java/noppes/npcs/client/CustomNpcResourceListener.java +++ b/src/main/java/noppes/npcs/client/CustomNpcResourceListener.java @@ -9,6 +9,7 @@ import net.minecraft.util.ResourceLocation; import net.minecraft.util.StatCollector; import noppes.npcs.CustomNpcs; import noppes.npcs.LogWriter; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeRegistry; import javax.imageio.ImageIO; import java.awt.Graphics; @@ -30,6 +31,11 @@ public class CustomNpcResourceListener implements FolderResourcePack pack = new FolderResourcePack(CustomNpcs.Dir); simplemanager.reloadResourcePack(pack); + + // Reload scripting .d.ts files + JSTypeRegistry registry = JSTypeRegistry.getInstance(); + registry.clear(); + registry.initializeFromResources(); try { DefaultTextColor = Integer.parseInt(StatCollector.translateToLocal("customnpcs.defaultTextColor"), 16); diff --git a/src/main/java/noppes/npcs/client/gui/GuiScript.java b/src/main/java/noppes/npcs/client/gui/GuiScript.java index febb3c9b1..b8309b955 100644 --- a/src/main/java/noppes/npcs/client/gui/GuiScript.java +++ b/src/main/java/noppes/npcs/client/gui/GuiScript.java @@ -16,6 +16,8 @@ import noppes.npcs.client.gui.util.GuiNpcButton; import noppes.npcs.client.gui.util.GuiNpcLabel; import noppes.npcs.client.gui.util.GuiNpcTextArea; import noppes.npcs.client.gui.util.GuiScriptTextArea; +import noppes.npcs.client.gui.util.script.interpreter.ScriptTextContainer; +import noppes.npcs.constants.EnumScriptType; import noppes.npcs.constants.ScriptContext; import noppes.npcs.controllers.ScriptContainer; import noppes.npcs.controllers.ScriptController; @@ -88,18 +90,25 @@ public class GuiScript extends GuiScriptInterface { super.initGui(); this.guiTop += 10; - // ==================== TOP BUTTONS (hidden in fullscreen) ==================== - if (!isFullscreen) { - GuiMenuTopButton top; - addTopButton(top = new GuiMenuTopButton(13, guiLeft + 4, guiTop - 17, "script.scripts")); - addTopButton(new GuiMenuTopButton(16, guiLeft + (xSize - 102), guiTop - 17, "eventscript.eventScripts")); - addTopButton(new GuiMenuTopButton(17, guiLeft + (xSize - 22), guiTop - 17, "X")); - top.active = showScript; - addTopButton(top = new GuiMenuTopButton(14, top, "gui.settings")); - top.active = !showScript; - addTopButton(new GuiMenuTopButton(15, top, "gui.website")); + if (isFullscreen) { + FullscreenConfig.paddingTop = 30; } + // ==================== TOP BUTTONS ==================== + boolean isFullscreenView = isFullscreen && showScript; + int menuX = isFullscreenView ? FullscreenConfig.paddingLeft : guiLeft + 4; + int menuY = isFullscreenView ? FullscreenConfig.paddingTop - 20 : guiTop - 17; + int rightX = isFullscreenView ? width - FullscreenConfig.paddingRight : guiLeft + xSize; + + GuiMenuTopButton top; + addTopButton(top = new GuiMenuTopButton(13, menuX, menuY, "script.scripts")); + addTopButton(new GuiMenuTopButton(16, rightX - 102, menuY, "eventscript.eventScripts")); + addTopButton(new GuiMenuTopButton(17, rightX - 22, menuY, "X")); + top.active = showScript; + addTopButton(top = new GuiMenuTopButton(14, top, "gui.settings")); + top.active = !showScript; + addTopButton(new GuiMenuTopButton(15, top, "gui.website")); + if (showScript) { initScriptView(); } else { @@ -162,6 +171,10 @@ public class GuiScript extends GuiScriptInterface { String language = (container != null) ? container.getLanguage() : script.getLanguage(); activeArea.setLanguage(language); activeArea.setScriptContext(getScriptContext()); + + // Set editor globals based on the active NPC hook + String hookName = EnumScriptType.values()[activeTab].function; + applyEditorGlobals(activeArea, hookName); // Setup fullscreen key binding GuiScriptTextArea.KEYS.FULLSCREEN.setTask(e -> { @@ -244,6 +257,19 @@ public class GuiScript extends GuiScriptInterface { } } + // Apply editor globals for the active NPC hook. + private void applyEditorGlobals(GuiScriptTextArea activeArea, String hookName) { + if (activeArea == null) + return; + + ScriptTextContainer textContainer = activeArea.getContainer(); + if (textContainer == null) + return; + + if (script != null) + textContainer.setEditorGlobalsMap(script.getEditorGlobals(hookName)); + } + @Override protected String getConsoleText() { Map map = this.script.getOldConsoleText(); @@ -382,24 +408,4 @@ public class GuiScript extends GuiScriptInterface { initGui(); } } - - @Override - public void drawScreen(int mouseX, int mouseY, float partialTicks) { - super.drawScreen(mouseX, mouseY, partialTicks); - - // Draw fullscreen button when in script view (GuiScript uses 0-based activeTab) - if (showScript) { - fullscreenButton.draw(mouseX, mouseY); - } - } - - @Override - public void mouseClicked(int mouseX, int mouseY, int mouseButton) { - // Check fullscreen button first when in script view - if (showScript && fullscreenButton.mouseClicked(mouseX, mouseY, mouseButton)) { - return; - } - super.mouseClicked(mouseX, mouseY, mouseButton); - } } - diff --git a/src/main/java/noppes/npcs/client/gui/script/GuiScriptInterface.java b/src/main/java/noppes/npcs/client/gui/script/GuiScriptInterface.java index fa64fb9a9..9607a7b2e 100644 --- a/src/main/java/noppes/npcs/client/gui/script/GuiScriptInterface.java +++ b/src/main/java/noppes/npcs/client/gui/script/GuiScriptInterface.java @@ -25,6 +25,7 @@ import noppes.npcs.client.gui.util.IGuiData; import noppes.npcs.client.gui.util.IJTextAreaListener; import noppes.npcs.client.gui.util.ITextChangeListener; import noppes.npcs.client.gui.util.ITextfieldListener; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeRegistry; import noppes.npcs.constants.ScriptContext; import noppes.npcs.controllers.ScriptContainer; import noppes.npcs.controllers.ScriptController; @@ -32,15 +33,11 @@ import noppes.npcs.controllers.data.ForgeDataScript; import noppes.npcs.controllers.data.IScriptHandler; import noppes.npcs.controllers.data.IScriptHandlerPacket; import noppes.npcs.controllers.data.IScriptUnit; +import noppes.npcs.janino.JaninoScript; import noppes.npcs.scripted.item.ScriptCustomItem; import org.lwjgl.opengl.Display; -import java.util.ArrayList; -import java.util.Date; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; +import java.util.*; import java.util.Map.Entry; public class GuiScriptInterface extends GuiNPCInterface implements GuiYesNoCallback, IGuiData, ITextChangeListener, ICustomScrollListener, IJTextAreaListener, ITextfieldListener { @@ -105,6 +102,7 @@ public class GuiScriptInterface extends GuiNPCInterface implements GuiYesNoCallb this.drawDefaultBackground = true; this.closeOnEsc = true; this.xSize = 420; + this.isPannableGUI = true; this.setBackground("menubg.png"); } @@ -120,6 +118,12 @@ public class GuiScriptInterface extends GuiNPCInterface implements GuiYesNoCallb // Initialize hooks from handler gui.hookList = new ArrayList<>(handler.getHooks()); + JSTypeRegistry registry = JSTypeRegistry.getInstance(); + if (!registry.isInitialized()) { + registry.initializeFromResources(); + } + registry.syncHooksFromScriptHookControllerIfNeeded(); + // Request data from server if (handler instanceof IScriptHandlerPacket) ((IScriptHandlerPacket) handler).requestData(); @@ -139,6 +143,7 @@ public class GuiScriptInterface extends GuiNPCInterface implements GuiYesNoCallb public void initGui() { // ==================== BASE LAYOUT CALCULATION ==================== + isPanning = false; this.ySize = (int) ((double) this.xSize * 0.56D); if ((double) this.ySize > (double) this.height * 0.95D) { this.ySize = (int) ((double) this.height * 0.95D); @@ -278,6 +283,9 @@ public class GuiScriptInterface extends GuiNPCInterface implements GuiYesNoCallb // Set the script context for context-aware hook autocomplete activeArea.setScriptContext(getScriptContext()); + activeArea.enableCodeHighlighting(); + + updateScriptDocumentImports(activeArea, container); // Setup fullscreen key binding GuiScriptTextArea.KEYS.FULLSCREEN.setTask(e -> { @@ -328,8 +336,9 @@ public class GuiScriptInterface extends GuiNPCInterface implements GuiYesNoCallb } this.addScroll(scroll); } - } + computePanBounds(editorX, editorY, editorWidth, editorHeight); + } /** * Initialize the settings tab layout (console view). */ @@ -371,6 +380,12 @@ public class GuiScriptInterface extends GuiNPCInterface implements GuiYesNoCallb // Language button requires options to be available this.getButton(103).enabled = languageOptions.size() > 0; } + + int consoleX = this.guiLeft + 4 + yoffset; + int consoleY = this.guiTop + 6 + yoffset; + int consoleW = this.xSize - 160 - yoffset; + int consoleH = (int) ((float) this.ySize * 0.92F) - yoffset * 2; + computePanBounds(consoleX, consoleY, consoleW, consoleH); } public GuiScriptInterface setDimensions(int x, int y) { @@ -389,30 +404,34 @@ public class GuiScriptInterface extends GuiNPCInterface implements GuiYesNoCallb return handler.getContext(); } - // ==================== RENDERING ==================== - @Override - public void drawScreen(int mouseX, int mouseY, float partialTicks) { - super.drawScreen(mouseX, mouseY, partialTicks); - - // Draw fullscreen button on top of everything when on script editor tab - // Skip for useSettingsToggle GUIs (like GuiScript) - they handle this themselves - if (this.activeTab > 0 && !useSettingsToggle && !handler.isSingleContainer()) { - fullscreenButton.draw(mouseX, mouseY); + protected boolean isPannableArea(int mx, int my) { + if (activeTab > 0 && fullscreenButton.isMouseOver(mx, my)) { + return false; } + + GuiScriptTextArea activeArea = getActiveScriptArea(); + if (activeArea != null && activeArea.isPointOnAutocompleteMenu(mx, my)) { + return false; + } + + return super.isPannableArea(mx, my); } - // ==================== MOUSE HANDLING ==================== - @Override - public void mouseClicked(int mouseX, int mouseY, int mouseButton) { - // Check fullscreen button first when on script editor tab - // Skip for useSettingsToggle GUIs (like GuiScript) - they handle this themselves - if (this.activeTab > 0 && !useSettingsToggle && !handler.isSingleContainer() && fullscreenButton.mouseClicked(mouseX, mouseY, mouseButton)) { + public void mouseClicked(int i, int j, int k) { + int adjX = panAdjustedX(i); + int adjY = panAdjustedY(j); + + GuiScriptTextArea activeArea = getActiveScriptArea(); + boolean isOverAutocomplete = activeArea != null + && activeArea.isPointOnAutocompleteMenu(adjX, adjY); + if (isOverAutocomplete) { + activeArea.mouseClicked(adjX, adjY, k); return; } - super.mouseClicked(mouseX, mouseY, mouseButton); + super.mouseClicked(i, j, k); } public String previousHookClicked = ""; @@ -435,11 +454,40 @@ public class GuiScriptInterface extends GuiNPCInterface implements GuiYesNoCallb this.getTextField(2).setText(this.getTextField(2).getText() + addString); previousHookClicked = ""; + + updateScriptDocumentImports(getActiveScriptArea(), container); } else { previousHookClicked = hook; } } + public void updateScriptDocumentImports(GuiScriptTextArea activeArea, IScriptUnit container) { + // For JaninoScripts, add implicit imports (default imports + hook signature types) + // These allow the syntax highlighter to resolve types without explicit import statements + if (container instanceof JaninoScript) { + JaninoScript janinoScript = (JaninoScript) container; + ScriptContext ctx = getScriptContext(); + // Add default imports (e.g., noppes.npcs.api.*, noppes.npcs.api.entity.*, etc.) + activeArea.addImplicitImports(janinoScript.getDefaultImports()); + + // Add hook types from signatures (parameters + return types) + // e.g., INpcEvent.InitEvent, Color, String, IOverlayContext, etc. + Set hookTypes = janinoScript.getHookTypes(); + activeArea.addImplicitImports(hookTypes.toArray(new String[0])); + + // Add wildcard imports for each event class in the script context: INpcEvent.*, IProjectileEvent.* + // so nested types like INpcEvent.CollideEvent resolve without explicit import + Set wildcardImports = new HashSet<>(); + for (String fqn : ctx.getNamespaceFQNs()) + wildcardImports.add(fqn + ".*"); + activeArea.addImplicitImports(wildcardImports.toArray(new String[0])); + + + // Format to update which implicit imports are actually used + activeArea.formatCodeText(); + } + } + @Override public void unFocused(GuiNpcTextField textfield) { diff --git a/src/main/java/noppes/npcs/client/gui/util/GuiNPCInterface.java b/src/main/java/noppes/npcs/client/gui/util/GuiNPCInterface.java index ccdbe845c..08a5dff00 100644 --- a/src/main/java/noppes/npcs/client/gui/util/GuiNPCInterface.java +++ b/src/main/java/noppes/npcs/client/gui/util/GuiNPCInterface.java @@ -61,6 +61,30 @@ public abstract class GuiNPCInterface extends GuiScreen { public float bgScaleZ = 1; public int bgTextureHeight = 256; // Actual content height in texture (for bottom border stitching) + // ==================== VIEWPORT PANNING ==================== + /** + * If true, this GUI supports viewport panning via click-drag on empty areas. + * Subclasses set this to true and call computePanBounds() to enable. + */ + protected boolean isPannableGUI = false; + protected boolean isPanning = false; + protected double panStartX, panStartY; + + /** + * Cumulative pan offset in scaled GUI pixels. + * Positive values = viewport shifted right/down (content appears to move left/up). + */ + public double currentPanX, currentPanY; + + public double getPanX() { return currentPanX; } + public double getPanY() { return currentPanY; } + + protected double minPanX, maxPanX, minPanY, maxPanY; + protected int panViewportX, panViewportY, panViewportWidth, panViewportHeight; + + /** Pan-adjusted mouse coordinates, updated every frame in drawScreen for hit-testing panned components. */ + protected int panAdjMouseX, panAdjMouseY; + public GuiNPCInterface(EntityNPCInterface npc) { this.player = Minecraft.getMinecraft().thePlayer; this.npc = npc; @@ -161,28 +185,39 @@ public abstract class GuiNPCInterface extends GuiScreen { if (subgui != null) subgui.mouseClicked(i, j, k); else { - for (GuiNpcTextField tf : new ArrayList(textfields.values())) - if (tf.enabled) - tf.mouseClicked(i, j, k); + int adjX = isPannableGUI ? panAdjustedX(i) : i; + int adjY = isPannableGUI ? panAdjustedY(j) : j; + + if (isPannableGUI && k == 0 && isPannableArea(adjX, adjY)) { + isPanning = true; + panStartX = i; + panStartY = j; + return; + } + + mouseEvent(adjX, adjY, k); + vanillaMouseClicked(adjX, adjY, k); for (GuiScrollWindow guiScrollableComponent : scrollWindows.values()) { - guiScrollableComponent.mouseClicked(i, j, k); + guiScrollableComponent.mouseClicked(adjX, adjY, k); } if (k == 0) { for (GuiCustomScroll scroll : new ArrayList(scrolls.values())) { - scroll.mouseClicked(i, j, k); + scroll.mouseClicked(adjX, adjY, k); } } - // Process diagram mouse clicks for (GuiDiagram diagram : diagrams.values()) { - if (diagram.isWithin(i, j)) { - if (diagram.mouseClicked(i, j, k)) + if (diagram.isWithin(adjX, adjY)) { + if (diagram.mouseClicked(adjX, adjY, k)) return; } } - mouseEvent(i, j, k); - vanillaMouseClicked(i, j, k); + + for (GuiNpcTextField tf : new ArrayList(textfields.values())) + if (tf.enabled) + tf.mouseClicked(adjX, adjY, k); + } } @@ -223,7 +258,12 @@ public abstract class GuiNPCInterface extends GuiScreen { subgui.mouseClickMove(mouseX, mouseY, clickedMouseButton, timeSinceLastClick); return; } - super.mouseClickMove(mouseX, mouseY, clickedMouseButton, timeSinceLastClick); + if (isPannableGUI && isPanning) { + return; + } + int adjX = isPannableGUI ? panAdjustedX(mouseX) : mouseX; + int adjY = isPannableGUI ? panAdjustedY(mouseY) : mouseY; + super.mouseClickMove(adjX, adjY, clickedMouseButton, timeSinceLastClick); } @Override @@ -232,12 +272,72 @@ public abstract class GuiNPCInterface extends GuiScreen { subgui.mouseMovedOrUp(mouseX, mouseY, state); return; } - super.mouseMovedOrUp(mouseX, mouseY, state); + if (isPannableGUI && state == 0 && isPanning) { + isPanning = false; + panStartX = 0; + panStartY = 0; + return; + } + int adjX = isPannableGUI ? panAdjustedX(mouseX) : mouseX; + int adjY = isPannableGUI ? panAdjustedY(mouseY) : mouseY; + super.mouseMovedOrUp(adjX, adjY, state); } public void mouseEvent(int i, int j, int k) { } + // ==================== VIEWPORT PANNING METHODS ==================== + + protected boolean isPannableArea(int mx, int my) { + for (Object obj : this.buttonList) { + GuiButton btn = (GuiButton) obj; + if (btn.visible && mx >= btn.xPosition && mx < btn.xPosition + btn.width + && my >= btn.yPosition && my < btn.yPosition + btn.height) { + return false; + } + } + + for (GuiCustomScroll scroll : scrolls.values()) { + if (scroll.visible && scroll.isMouseOver(mx, my)) { + return false; + } + } + + for (GuiNpcTextField tf : textfields.values()) { + if (tf.enabled && mx >= tf.xPosition && mx < tf.xPosition + tf.width + && my >= tf.yPosition && my < tf.yPosition + tf.height) { + return false; + } + } + + return true; + } + + protected void computePanBounds(int vpX, int vpY, int vpW, int vpH) { + this.panViewportX = vpX; + this.panViewportY = vpY; + this.panViewportWidth = vpW; + this.panViewportHeight = vpH; + + int panRange = Math.max(this.width, this.height) / 2; + this.minPanX = -panRange; + this.maxPanX = panRange; + this.minPanY = -panRange; + this.maxPanY = panRange; + } + + protected int panAdjustedX(int rawMouseX) { + return rawMouseX + (int) currentPanX; + } + + protected int panAdjustedY(int rawMouseY) { + return rawMouseY + (int) currentPanY; + } + + public boolean hasPanOffset() { + return isPannableGUI && (currentPanX != 0 || currentPanY != 0); + } + @Override protected void actionPerformed(GuiButton guibutton) { if (subgui != null) @@ -375,9 +475,41 @@ public abstract class GuiNPCInterface extends GuiScreen { public void drawScreen(int i, int j, float f) { mouseX = i; mouseY = j; + + boolean panning = hasPanOffset(); + int drawX = panning ? panAdjustedX(i) : i; + int drawY = panning ? panAdjustedY(j) : j; + panAdjMouseX = drawX; + panAdjMouseY = drawY; + + // Smooth pan: update pan offset every frame using raw mouse delta + if (isPannableGUI && isPanning && Mouse.isButtonDown(0)) { + double deltaX = i - panStartX; + double deltaY = j - panStartY; + + currentPanX = Math.max(minPanX, Math.min(maxPanX, currentPanX - deltaX)); + currentPanY = Math.max(minPanY, Math.min(maxPanY, currentPanY - deltaY)); + + panStartX = i; + panStartY = j; + + panning = hasPanOffset(); + drawX = panning ? panAdjustedX(i) : i; + drawY = panning ? panAdjustedY(j) : j; + panAdjMouseX = drawX; + panAdjMouseY = drawY; + } else if (isPanning && !Mouse.isButtonDown(0)) { + isPanning = false; + } + if (drawDefaultBackground && subgui == null) drawDefaultBackground(); + if (panning) { + GL11.glPushMatrix(); + GL11.glTranslated(-currentPanX, -currentPanY, 0); + } + if (background != null && mc.renderEngine != null) { drawBackground(); } @@ -386,45 +518,45 @@ public abstract class GuiNPCInterface extends GuiScreen { drawCenteredString(fontRendererObj, title, width / 2, guiTop + 4, 0xffffff); for (GuiNpcLabel label : labels.values()) label.drawLabel(this, fontRendererObj); - for (GuiNpcTextField tf : textfields.values()) { - tf.drawTextBox(i, j); - } for (GuiCustomScroll scroll : scrolls.values()) { scroll.updateSubGUI(subGui); - scroll.drawScreen(i, j, f, !subGui && scroll.isMouseOver(i, j) ? Mouse.getDWheel() : 0); + scroll.drawScreen(drawX, drawY, f, !subGui && scroll.isMouseOver(drawX, drawY) ? Mouse.getDWheel() : 0); } - // Draw scrollable windows. for (GuiScrollWindow guiScrollableComponent : scrollWindows.values()) { - guiScrollableComponent.drawScreen(i, j, f, !subGui && guiScrollableComponent.isMouseOver(i, j) ? Mouse.getDWheel() : 0); + guiScrollableComponent.drawScreen(drawX, drawY, f, !subGui && guiScrollableComponent.isMouseOver(drawX, drawY) ? Mouse.getDWheel() : 0); } for (GuiDiagram diagram : diagrams.values()) { - diagram.drawDiagram(i, j, subGui); + diagram.drawDiagram(drawX, drawY, subGui); } - super.drawScreen(i, j, f); + super.drawScreen(drawX, drawY, f); for (GuiCustomScroll scroll : scrolls.values()) if (scroll.hoverableText) { - scroll.drawHover(i, j); + scroll.drawHover(drawX, drawY); } for (GuiNpcButton button : buttons.values()) { button.updateSubGUI(subGui); if (!button.hoverableText.isEmpty()) { - button.drawHover(i, j, subGui); + button.drawHover(drawX, drawY, subGui); } } - for (GuiNpcTextField textField : textfields.values()) { - if (textField.hasHoverText()) { - textField.drawHover(i, j, subGui); - } + for (GuiNpcTextField tf : textfields.values()) { + tf.drawTextBox(drawX, drawY); + if (tf.hasHoverText()) + tf.drawHover(drawX, drawY, subGui); } for(GuiScrollWindow guiScrollableComponent : scrollWindows.values()) { - if (guiScrollableComponent.isMouseOver(mouseX, mouseY)) { - guiScrollableComponent.drawHoverTexts(mouseX, mouseY); + if (guiScrollableComponent.isMouseOver(drawX, drawY)) { + guiScrollableComponent.drawHoverTexts(drawX, drawY); } } for (GuiScreen gui : extra.values()) - gui.drawScreen(i, j, f); + gui.drawScreen(drawX, drawY, f); + + if (panning) { + GL11.glPopMatrix(); + } if (subgui != null) { subgui.drawScreen(i, j, f); diff --git a/src/main/java/noppes/npcs/client/gui/util/GuiScriptTextArea.java b/src/main/java/noppes/npcs/client/gui/util/GuiScriptTextArea.java index be148c11d..e7798ff5a 100644 --- a/src/main/java/noppes/npcs/client/gui/util/GuiScriptTextArea.java +++ b/src/main/java/noppes/npcs/client/gui/util/GuiScriptTextArea.java @@ -8,17 +8,23 @@ import noppes.npcs.NoppesStringUtils; import noppes.npcs.client.ClientProxy; import noppes.npcs.client.gui.script.GuiScriptInterface; import noppes.npcs.client.gui.util.key.OverlayKeyPresetViewer; -import noppes.npcs.client.gui.util.script.BracketMatcher; -import noppes.npcs.client.gui.util.script.CommentHandler; -import noppes.npcs.client.gui.util.script.CursorNavigation; -import noppes.npcs.client.gui.util.script.GoToLineDialog; -import noppes.npcs.client.gui.util.script.IndentHelper; -import noppes.npcs.client.gui.util.script.JavaTextContainer; +import noppes.npcs.client.gui.util.script.*; import noppes.npcs.client.gui.util.script.JavaTextContainer.LineData; -import noppes.npcs.client.gui.util.script.RenameRefactorHandler; -import noppes.npcs.client.gui.util.script.ScrollState; -import noppes.npcs.client.gui.util.script.SearchReplaceBar; -import noppes.npcs.client.gui.util.script.SelectionState; +// New interpreter system imports +import noppes.npcs.client.gui.util.script.autocomplete.AutocompleteMenu; +import noppes.npcs.client.gui.util.script.interpreter.ScriptLine; +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; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodCallInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +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.hover.GutterIconRenderer; +import noppes.npcs.client.gui.util.script.interpreter.hover.HoverState; +import noppes.npcs.client.gui.util.script.interpreter.hover.TokenHoverRenderer; +import noppes.npcs.client.gui.util.script.autocomplete.AutocompleteManager; +import noppes.npcs.client.gui.util.script.interpreter.type.ScriptTypeInfo; import noppes.npcs.client.key.impl.ScriptEditorKeys; import noppes.npcs.constants.ScriptContext; import noppes.npcs.util.ValueUtil; @@ -36,7 +42,7 @@ import static net.minecraft.client.gui.GuiScreen.isCtrlKeyDown; /** * Script text editor component with syntax highlighting, bracket matching, * smooth scrolling, and IDE-like features. - *

+ * * Helper classes used: * - ScrollState: smooth scroll animation and state management * - SelectionState: cursor position and text selection management @@ -47,10 +53,12 @@ import static net.minecraft.client.gui.GuiScreen.isCtrlKeyDown; */ public class GuiScriptTextArea extends GuiNpcTextField { + private GuiScriptInterface parent; + // ==================== DIMENSIONS & POSITION ==================== public int x; public int y; - + // ==================== STATE FLAGS ==================== public boolean active = false; public boolean enabled = true; @@ -60,11 +68,11 @@ public class GuiScriptTextArea extends GuiNpcTextField { public boolean tripleClicked = false; private int clickCount = 0; private long lastClicked = 0L; - + // ==================== TEXT & CONTAINER ==================== public String text = null; public String highlightedWord; - private JavaTextContainer container = null; + private ScriptTextContainer container = null; private boolean enableCodeHighlighting = false; // Extra empty lines to allow padding at the bottom of the editor viewport private int bottomPaddingLines = 6; @@ -89,16 +97,31 @@ public class GuiScriptTextArea extends GuiNpcTextField { // ==================== HELPER CLASS INSTANCES ==================== private final ScrollState scroll = new ScrollState(); private final SelectionState selection = new SelectionState(); - + private final HoverState hoverState = new HoverState(); + /** When true, clicking a token will pin its hover tooltip until dismissed. */ + public boolean clickToPinEnabled = false; + // ==================== UI COMPONENTS ==================== private int cursorCounter; private ITextChangeListener listener; private static int LINE_NUMBER_GUTTER_WIDTH = 25; - + + // ==================== GUTTER ICONS ==================== + /** Hover state for gutter icons - tracks which icon the mouse is over */ + private MethodInfo hoveredGutterMethod = null; + // ==================== UNDO/REDO ==================== public List undoList = new ArrayList<>(); public List redoList = new ArrayList<>(); public boolean undoing = false; + + // Atomic undo: group typing into word-based undo steps + private long lastTypingTime = 0; + private int lastTypingPos = -1; + + // Clipboard tracking for line-copy paste behavior + private boolean lastCopyWasLine = false; + private String lastCopiedLineText = null; // ==================== KEYS ==================== public static final ScriptEditorKeys KEYS = new ScriptEditorKeys(); @@ -107,17 +130,26 @@ public class GuiScriptTextArea extends GuiNpcTextField { // ==================== SEARCH/REPLACE ==================== public static final SearchReplaceBar searchBar = new SearchReplaceBar(); + // ==================== PASTE SETTINGS ==================== + private static final int PASTE_TRAILING_WS_TRIM_THRESHOLD = 16; + // ==================== GO TO LINE ==================== private final GoToLineDialog goToLineDialog = new GoToLineDialog(); // ==================== RENAME REFACTOR ==================== private final RenameRefactorHandler renameHandler = new RenameRefactorHandler(); + // ==================== AUTOCOMPLETE ==================== + private final AutocompleteManager autocompleteManager = new AutocompleteManager(); + // ==================== CONSTRUCTOR ==================== public GuiScriptTextArea(GuiScreen guiScreen, int id, int x, int y, int width, int height, String text) { super(id, guiScreen, x, y, width, height, null); init(x, y, width, height, text); + + if (guiScreen instanceof GuiScriptInterface) + this.parent = (GuiScriptInterface) guiScreen; } public void init(int x, int y, int width, int height, String text) { @@ -134,12 +166,13 @@ public class GuiScriptTextArea extends GuiNpcTextField { this.searchBaseHeight = 0; this.searchAppliedOffset = 0; this.searchBaseInitialized = false; - + KEYS_OVERLAY.openOnClick = true; initGui(); initializeKeyBindings(); + // Propagate click-to-pin option into hover state + hoverState.setClickToPinEnabled(clickToPinEnabled); } - public void initGui() { int endX = x + width, endY = y + height; int xOffset = hasVerticalScrollbar() ? -8 : -2; @@ -147,11 +180,16 @@ public class GuiScriptTextArea extends GuiNpcTextField { KEYS_OVERLAY.borderCol1 = KEYS_OVERLAY.borderCol2 = 0xFF3c3c3c; int overlayWidth = 160; KEYS_OVERLAY.initGui(x + (width - overlayWidth) / 2 + 5, y + height / 10, overlayWidth, - height - height / 5 - 10); + height - height / 5 - 10); KEYS_OVERLAY.viewButton.scale = 0.45f; KEYS_OVERLAY.viewButton.initGui(endX + xOffset, endY - 26); - + + // Dismiss autocomplete on resize to avoid positioning issues + if (autocompleteManager != null) { + autocompleteManager.dismiss(); + } + // Initialize search bar (preserves state across initGui calls) searchBar.initGui(x, y, width); if (searchBar.isVisible()) { // If open @@ -160,7 +198,7 @@ public class GuiScriptTextArea extends GuiNpcTextField { if (!active) // Focus search if opening another script tab & bar is open searchBar.focus(false); } - + // Initialize Go To Line dialog goToLineDialog.initGui(x, y, width); } @@ -203,7 +241,7 @@ public class GuiScriptTextArea extends GuiNpcTextField { int visibleLines = effectiveHeight / container.lineHeight; // Calculate how many lines the search bar covers int linesHiddenBySRB = searchBarOffset > 0 ? (int) Math.ceil( - (double) searchBarOffset / container.lineHeight) : 0; + (double) searchBarOffset / container.lineHeight) : 0; for (int i = 0; i < container.lines.size(); i++) { LineData ld = container.lines.get(i); @@ -426,7 +464,7 @@ public class GuiScriptTextArea extends GuiNpcTextField { } @Override - public JavaTextContainer getContainer() { + public ScriptTextContainer getContainer() { return container; } @@ -453,48 +491,124 @@ public class GuiScriptTextArea extends GuiNpcTextField { return width - LINE_NUMBER_GUTTER_WIDTH - 8; // Account for gutter and scrollbar } }); + + // Initialize Autocomplete Manager with callback + autocompleteManager.setInsertCallback(new AutocompleteManager.InsertCallback() { + @Override + public void insertText(String text, int startPosition) { + // Replace text from startPosition to current cursor + String fullText = GuiScriptTextArea.this.text; + int cursorPos = selection.getCursorPosition(); + + // Bounds check to prevent StringIndexOutOfBoundsException + int start = Math.max(0, Math.min(startPosition, fullText.length())); + int cursor = Math.max(start, Math.min(cursorPos, fullText.length())); + + String before = fullText.substring(0, start); + String after = fullText.substring(cursor); + setText(before + text + after); + selection.reset(start + text.length()); + scrollToCursor(); + } + + @Override + public void replaceTextRange(String text, int startPosition, int endPosition) { + // Replace text from startPosition to endPosition + String fullText = GuiScriptTextArea.this.text; + + // Bounds check to prevent StringIndexOutOfBoundsException + int start = Math.max(0, Math.min(startPosition, fullText.length())); + int end = Math.max(start, Math.min(endPosition, fullText.length())); + + String before = fullText.substring(0, start); + String after = fullText.substring(end); + setText(before + text + after); + selection.reset(start + text.length()); + scrollToCursor(); + } + + @Override + public void addImport(String importPath) { + // Add import statement and sort all imports + addAndSortImport(importPath); + } + + @Override + public int getCursorPosition() { + return selection.getCursorPosition(); + } + + @Override + public void setCursorPosition(int position) { + selection.reset(Math.max(0, Math.min(position, GuiScriptTextArea.this.text.length()))); + scrollToCursor(); + } + + @Override + public String getText() { + return GuiScriptTextArea.this.text; + } + + @Override + public int[] getCursorScreenPosition() { + // Calculate screen position of cursor for menu placement + int cursorLine = getCursorLineIndex(); + int cursorCol = 0; + if (container != null && container.lines != null && cursorLine < container.lines.size()) { + LineData ld = container.lines.get(cursorLine); + String lineText = ld.text; + int cursorOffset = selection.getCursorPosition() - ld.start; + cursorCol = ClientProxy.Font.width(lineText.substring(0, Math.min(cursorOffset, lineText.length()))); + } + + int screenX = GuiScriptTextArea.this.x + LINE_NUMBER_GUTTER_WIDTH + 1 + cursorCol; + int lineY = cursorLine - scroll.getScrolledLine(); + int screenY = GuiScriptTextArea.this.y + lineY * (container != null ? container.lineHeight : 12); + + return new int[] { screenX, screenY }; + } + + @Override + public int[] getViewportDimensions() { + Minecraft mc = Minecraft.getMinecraft(); + ScaledResolution sr = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight); + return new int[] { sr.getScaledWidth(), sr.getScaledHeight() }; + } + }); } public boolean fullscreen() { return GuiScriptInterface.isFullscreen; } - - public void setLanguage(String language) { - if (this.container != null) { - // this.container.setLanguage(language); - if (this.enableCodeHighlighting) { - this.container.formatCodeText(); - } - } - } - + // ==================== RENDERING ==================== public void drawTextBox(int xMouse, int yMouse) { if (!visible) return; clampSelectionBounds(); - - // Dynamically calculate gutter width based on line count digits + + // Dynamically calculate gutter width based on line count digits + icon space if (container != null && container.linesCount > 0) { int maxLineNum = container.linesCount; String maxLineStr = "" + maxLineNum; int digitWidth = ClientProxy.Font.width(maxLineStr); - LINE_NUMBER_GUTTER_WIDTH = digitWidth + 10; // 10px total padding (5px left + 5px right) + LINE_NUMBER_GUTTER_WIDTH = digitWidth + 10 + GutterIconRenderer.ICON_GUTTER_WIDTH; // 10px padding + icon space } // Draw outer border around entire area int offset = fullscreen() ? 2 : 1; drawRect(x - offset, y - offset - searchBar.getTotalHeight(), x + width + offset, y + height + offset, - 0xffa0a0a0); + 0xffa0a0a0); int searchHeight = searchBar.getTotalHeight(); // Draw line number gutter background + int viewportX = x + LINE_NUMBER_GUTTER_WIDTH; drawRect(x, y, x + LINE_NUMBER_GUTTER_WIDTH, y + height, 0xff000000); // Draw text viewport background (starts after gutter) drawRect(x + LINE_NUMBER_GUTTER_WIDTH, y, x + width, y + height, 0xff000000); // Draw separator line between gutter and text area - drawRect(x + LINE_NUMBER_GUTTER_WIDTH - 1, y, x + LINE_NUMBER_GUTTER_WIDTH, y + height, 0xff3c3f41); + drawRect(x + LINE_NUMBER_GUTTER_WIDTH-1, y, x + LINE_NUMBER_GUTTER_WIDTH, y + height, 0xff3c3f41); // Enable scissor test to clip drawing to the TEXT viewport rectangle (excludes gutter) GL11.glEnable(GL11.GL_SCISSOR_TEST); @@ -504,27 +618,96 @@ public class GuiScriptTextArea extends GuiNpcTextField { int maxScroll = Math.max(0, getPaddedLineCount() - container.visibleLines); - // Handle mouse wheel scroll - only consume when mouse is over this text area - boolean isMouseOverTextArea = xMouse >= x && xMouse < x + width && yMouse >= y && yMouse < y + height; - int wheelDelta = 0; - if (isMouseOverTextArea) { - wheelDelta = Mouse.getDWheel(); - if (listener instanceof GuiNPCInterface) { - ((GuiNPCInterface) listener).mouseScroll = wheelDelta; + // Handle mouse wheel scroll + int wheelDelta = ((GuiNPCInterface) listener).mouseScroll = Mouse.getDWheel(); + if (listener instanceof GuiNPCInterface) { + ((GuiNPCInterface) listener).mouseScroll = wheelDelta; + + // Intercept wheel scroll for tooltip (highest priority) + if (wheelDelta != 0 && hoverState.isTooltipVisible() && hoverState.isMouseOverTooltip(xMouse, yMouse)) { + hoverState.scrollTooltip(wheelDelta); + wheelDelta = 0; } - boolean canScroll = !KEYS_OVERLAY.isVisible() || KEYS_OVERLAY.isVisible() && !KEYS_OVERLAY.aboveOverlay; - if (wheelDelta != 0 && canScroll) - scroll.applyWheelScroll(wheelDelta, maxScroll); + + // Let autocomplete menu consume scroll first if visible + if (wheelDelta != 0 && autocompleteManager.isVisible() && autocompleteManager.mouseScrolled(xMouse, yMouse, wheelDelta)) { + // Autocomplete consumed the scroll + } else { + boolean canScroll = !KEYS_OVERLAY.isVisible() || KEYS_OVERLAY.isVisible() && !KEYS_OVERLAY.aboveOverlay; + if (wheelDelta != 0 && canScroll) { + int previousScrollLine = scroll.getScrolledLine(); + scroll.applyWheelScroll(wheelDelta, maxScroll); + if (scroll.getScrolledLine() != previousScrollLine) { + hoverState.clearHover(); + } + } + } } // Handle scrollbar dragging (delegated to ScrollState) - if (scroll.isClickScrolling()) + if (scroll.isClickScrolling()) { + int prevLine = scroll.getScrolledLine(); scroll.handleClickScrolling(yMouse, x, y, height, container.visibleLines, getPaddedLineCount(), maxScroll); - + if (scroll.getScrolledLine() != prevLine) { + hoverState.clearHover(); + } + } + // Handle tooltip scrollbar drag (update each frame; release when button lifted) + if (hoverState.isDraggingScrollbar()) { + if (Mouse.isButtonDown(0)) { + hoverState.updateScrollbarDrag(yMouse); + } else { + hoverState.releaseScrollbarDrag(); + } + } + // Handle tooltip panel drag (update each frame; release when button lifted) + if (hoverState.isDraggingTooltip()) { + if (Mouse.isButtonDown(0)) { + hoverState.updateTooltipDrag(xMouse, yMouse); + } else { + hoverState.releaseTooltipDrag(); + } + } + // Handle tooltip panel resize (update each frame; release when button lifted) + if (hoverState.isResizingTooltip()) { + if (Mouse.isButtonDown(0)) { + hoverState.updateTooltipResize(xMouse, yMouse); + } else { + hoverState.releaseTooltipResize(); + } + } + // Handle autocomplete scrollbar drag + if (autocompleteManager.isDraggingScrollbarMenu()) { + if (Mouse.isButtonDown(0)) { + autocompleteManager.updateScrollbarDrag(yMouse); + } else { + autocompleteManager.releaseScrollbarDrag(); + } + } + // Handle autocomplete panel drag + if (autocompleteManager.isDraggingPanel()) { + if (Mouse.isButtonDown(0)) { + autocompleteManager.updatePanelDrag(xMouse, yMouse); + } else { + autocompleteManager.releasePanelDrag(); + } + } + // Handle autocomplete panel resize + if (autocompleteManager.isResizingPanel()) { + if (Mouse.isButtonDown(0)) { + autocompleteManager.updatePanelResize(xMouse, yMouse); + } else { + autocompleteManager.releasePanelResize(); + } + } + // Update scroll animation scroll.initializeIfNeeded(scroll.getScrolledLine()); scroll.update(maxScroll); + // Update hover state for token tooltips + updateHoverState(xMouse, yMouse); + // Handle click-dragging for selection if (clicked) { clicked = Mouse.isButtonDown(0); @@ -535,7 +718,7 @@ public class GuiScriptTextArea extends GuiNpcTextField { doubleClicked = false; tripleClicked = false; } - setCursor(i, true); + setCursor(i, true); } } else if (doubleClicked || tripleClicked) { doubleClicked = false; @@ -546,8 +729,8 @@ public class GuiScriptTextArea extends GuiNpcTextField { // Calculate braces next to cursor to highlight int startBracket = 0, endBracket = 0; if (selection.getStartSelection() >= 0 && text != null && text.length() > 0 && - (selection.getEndSelection() - selection.getStartSelection() == 1 || !selection.hasSelection())) { - int[] span = BracketMatcher.findBracketSpanAt(text, selection.getStartSelection()); + (selection.getEndSelection() - selection.getStartSelection() == 1 || !selection.hasSelection())) { + int[] span = BracketMatcher.findBracketSpanAt(text,selection.getStartSelection()); if (span != null) { startBracket = span[0]; endBracket = span[1]; @@ -555,12 +738,12 @@ public class GuiScriptTextArea extends GuiNpcTextField { } List list = new ArrayList<>(container.lines); - + // Build brace spans: {origDepth, open line, close line, adjustedDepth} List braceSpans = BracketMatcher.computeBraceSpans(text, list); // Always highlight unmatched braces (positions in text) List unmatchedBraces = BracketMatcher.findUnmatchedBracePositions(text); - + // Determine which exact brace span (openLine/closeLine) to highlight indent guides for int highlightedOpenLine = -1; int highlightedCloseLine = -1; @@ -629,25 +812,25 @@ public class GuiScriptTextArea extends GuiNpcTextField { float fracPixels = (float) (fracOffset * container.lineHeight); GL11.glPushMatrix(); GL11.glTranslatef(0.0f, -fracPixels, 0.0f); - - + + // Expand render range by one line above/below so partially-visible lines are drawn int renderStart = Math.max(0, scroll.getScrolledLine() - 1); // Compute the last line index to render, including the last partially-visible line if any. // Adds the fractional scroll offset (fracOffset * lineHeight) to ensure the bottom line is drawn // when only part of it is visible in the viewport. int renderEnd = (int) Math.min(list.size() - 1, - scroll.getScrolledLine() + container.visibleLines + fracPixels + 1); + scroll.getScrolledLine() + container.visibleLines + fracPixels + 1); // Strings start drawing vertically this much into the line. int stringYOffset = 2; - + // Render LINE GUTTER numbers for (int i = renderStart; i <= renderEnd; i++) { int posY = y + (i - scroll.getScrolledLine()) * container.lineHeight + stringYOffset; String lineNum = "" + (i + 1); int lineNumWidth = ClientProxy.Font.width(lineNum); - int lineNumX = x + LINE_NUMBER_GUTTER_WIDTH - lineNumWidth - 5; // right-align with 5px padding + int lineNumX = x + LINE_NUMBER_GUTTER_WIDTH - lineNumWidth - 5 - GutterIconRenderer.ICON_GUTTER_WIDTH; // right-align before icon space int lineNumY = posY + 1; // Highlight current line number int lineNumColor = 0xFF606366; @@ -664,10 +847,11 @@ public class GuiScriptTextArea extends GuiNpcTextField { } ClientProxy.Font.drawString(lineNum, lineNumX, lineNumY, lineNumColor); } - + // Render Viewport for (int i = renderStart; i <= renderEnd; i++) { LineData data = list.get(i); + ScriptLine scriptLine = container.getDocument().getLine(i); String line = data.text; int w = line.length(); // Use integer Y relative to scrolledLine; fractional offset applied via GL translate @@ -709,7 +893,7 @@ public class GuiScriptTextArea extends GuiNpcTextField { } } } - + // Highlight search matches if (searchBar.isVisible()) { List searchMatches = searchBar.getMatches(); @@ -758,8 +942,8 @@ public class GuiScriptTextArea extends GuiNpcTextField { if (occStart <= occEnd) { // Changed from < to <= to handle empty case int s = ClientProxy.Font.width(line.substring(0, occStart)); int e = isEmpty ? s + 2 : ClientProxy.Font.width( - line.substring(0, occEnd)) + 1; // 2px wide for empty - int occX = x + LINE_NUMBER_GUTTER_WIDTH + s; + line.substring(0, occEnd)) + 1; // 2px wide for empty + int occX = x + LINE_NUMBER_GUTTER_WIDTH + s; int occEndX = x + LINE_NUMBER_GUTTER_WIDTH + 2 + e; boolean isPrimary = renameHandler.isPrimaryOccurrence(occ[0]); @@ -772,12 +956,12 @@ public class GuiScriptTextArea extends GuiNpcTextField { int borderColor = 0xDDFFFFFF; //RED BG drawRect(occX, posY, occEndX, posY + container.lineHeight, 0x33ff0000); - + // Top border drawRect(occX, posY, occEndX, posY + 1, borderColor); - // Bottom border + // Bottom border drawRect(occX, posY + container.lineHeight - 1, occEndX, - posY + container.lineHeight, borderColor); + posY + container.lineHeight, borderColor); // Left border drawRect(occX, posY, occX + 1, posY + container.lineHeight, borderColor); // Right border @@ -789,7 +973,7 @@ public class GuiScriptTextArea extends GuiNpcTextField { String currentWord = renameHandler.getCurrentWord(); if (currentWord != null && cursorInWord >= 0 && cursorInWord <= currentWord.length()) { String beforeCursor = currentWord.substring(0, - Math.min(cursorInWord, currentWord.length())); + Math.min(cursorInWord, currentWord.length())); int cursorX = occX + ClientProxy.Font.width(beforeCursor); // drawRect(cursorX, posY + 1, cursorX + 1, posY + container.lineHeight - 1, // 0xFFFFFFFF); @@ -800,18 +984,18 @@ public class GuiScriptTextArea extends GuiNpcTextField { } } } - + // Highlight the current line (light gray) under any selection if (active && isEnabled() && (selection.getCursorPosition() >= data.start && selection.getCursorPosition() < data.end || (i == list.size() - 1 && selection.getCursorPosition() == text.length()))) { - drawRect(x, posY, x + width - 1, posY + container.lineHeight, 0x22e0e0e0); + drawRect(x , posY, x + width - 1, posY + container.lineHeight, 0x22e0e0e0); } // Highlight selection if (selection.hasSelection() && selection.getEndSelection() > data.start && selection.getStartSelection() <= data.end) { if (selection.getStartSelection() < data.end) { int s = ClientProxy.Font.width( - line.substring(0, Math.max(selection.getStartSelection() - data.start, 0))); + line.substring(0, Math.max(selection.getStartSelection() - data.start, 0))); int e = ClientProxy.Font.width( - line.substring(0, Math.min(selection.getEndSelection() - data.start, w))) + 1; + line.substring(0, Math.min(selection.getEndSelection() - data.start, w))) + 1; drawRect(x + LINE_NUMBER_GUTTER_WIDTH + 1 + s, posY, x + LINE_NUMBER_GUTTER_WIDTH + 1 + e, posY + container.lineHeight, 0x992172ff); } } @@ -848,30 +1032,43 @@ public class GuiScriptTextArea extends GuiNpcTextField { boolean highlighted = (openLine == highlightedOpenLine && closeLine == highlightedCloseLine); int guideColor = highlighted ? 0x9933cc00 : 0x33FFFFFF; - + int topY = y + (drawStart - scroll.getScrolledLine()) * container.lineHeight; int bottomY = y + (endLine - scroll.getScrolledLine() + 1) * container.lineHeight; - if (highlighted) - bottomY -= 2; + if(highlighted) + bottomY-=2; drawRect(gx, topY, gx + 1, bottomY, guideColor); } } int yPos = posY + stringYOffset; - data.drawString(x + LINE_NUMBER_GUTTER_WIDTH + 1, yPos, 0xFFe0e0e0); + + //data.drawString(x + LINE_NUMBER_GUTTER_WIDTH + 1, yPos, 0xFFe0e0e0); + + //scriptLine.drawString(x+LINE_NUMBER_GUTTER_WIDTH + 1, yPos, 0xFFe0e0e0); + scriptLine.drawStringHex(x + LINE_NUMBER_GUTTER_WIDTH + 1, yPos); // Draw cursor: pause blinking while user is active recently boolean recentInput = selection.hadRecentInput(); if (active && isEnabled() && (recentInput || (cursorCounter / 10) % 2 == 0) && (selection.getCursorPosition() >= data.start && selection.getCursorPosition() < data.end || (i == list.size() - 1 && selection.getCursorPosition() == text.length()))) { int posX = x + LINE_NUMBER_GUTTER_WIDTH + ClientProxy.Font.width( - line.substring(0, Math.min(selection.getCursorPosition() - data.start, line.length()))); - drawRect(posX + 1, posY, posX + 2, posY + container.lineHeight, 0xffffffff); + line.substring(0, Math.min(selection.getCursorPosition() - data.start, line.length()))); + drawRect(posX + 1, posY, posX + 2, posY + container.lineHeight, 0xffffffff); } } } + + // Render gutter icons for method override/implements + if (container != null && container.getDocument() != null) { + hoveredGutterMethod = GutterIconRenderer.renderIcons(container.lineHeight, + x + LINE_NUMBER_GUTTER_WIDTH - GutterIconRenderer.ICON_GUTTER_WIDTH + 1, y, renderStart, renderEnd, + scroll.getScrolledLine(), stringYOffset, container.getDocument().getAllMethods(), container.lines, + xMouse, yMouse, fracPixels); + } + GL11.glPopMatrix(); GL11.glDisable(GL11.GL_SCISSOR_TEST); - + if (hasVerticalScrollbar()) { Minecraft.getMinecraft().renderEngine.bindTexture(GuiCustomScroll.resource); int effLines = Math.max(1, getPaddedLineCount()); @@ -884,24 +1081,48 @@ public class GuiScriptTextArea extends GuiNpcTextField { drawRect(posX, posY, posX + 5, posY + sbSize + 2, 0xFFe0e0e0); } - // Draw search/replace bar (overlays viewport) + if (parent != null) + parent.fullscreenButton.draw(xMouse, yMouse); + + searchBar.ownerGui = parent; searchBar.draw(xMouse, yMouse); - + // Draw go to line dialog (overlays everything) goToLineDialog.draw(xMouse, yMouse); + KEYS_OVERLAY.draw(xMouse, yMouse, wheelDelta); + + autocompleteManager.getMenu().ownerGui = parent; + autocompleteManager.draw(xMouse, yMouse); + + // Draw hover tooltips (on top of everything) + if (hoverState.isTooltipVisible()) { + int xOffset = hasVerticalScrollbar() ? -8 : -2; + int viewportWidth = width - LINE_NUMBER_GUTTER_WIDTH; + int viewportY = y; + int viewportHeight = height; + TokenHoverRenderer.render(hoverState, viewportX, viewportWidth+xOffset, viewportY, viewportHeight,parent); + } + + // Draw gutter icon tooltip + if (hoveredGutterMethod != null) { + GutterIconRenderer.renderTooltip(hoveredGutterMethod, xMouse, yMouse, x, width, y, height); + } } private void scissorViewport() { Minecraft mc = Minecraft.getMinecraft(); ScaledResolution sr = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight); int scaleFactor = sr.getScaleFactor(); - int scissorX = (this.x) * scaleFactor; - int scissorY = (sr.getScaledHeight() - (this.y + this.height)) * scaleFactor; - int scissorW = (this.width) * scaleFactor; + double panX = parent != null ? parent.getPanX() : 0; + double panY = parent != null ? parent.getPanY() : 0; + int scissorX = (int)((this.x - panX) * scaleFactor); + int scissorY = (int)((sr.getScaledHeight() - (this.y - panY + this.height)) * scaleFactor); + int scissorW = this.width * scaleFactor; int scissorH = this.height * scaleFactor; GL11.glScissor(scissorX, scissorY, scissorW, scissorH); } + // ==================== SELECTION & CURSOR POSITION ==================== // Get cursor position from mouse coordinates @@ -913,13 +1134,13 @@ public class GuiScriptTextArea extends GuiNpcTextField { // visible lines (fractional positions) correctly hit that line. double fracPixels = scroll.getFractionalOffset() * container.lineHeight; double yMouseD = yMouse + fracPixels; - + ArrayList list = new ArrayList(this.container.lines); for (int i = 0; i < list.size(); ++i) { LineData data = (LineData) list.get(i); //+1 to account for the fractional line - if (i >= scroll.getScrolledLine() && i <= scroll.getScrolledLine() + this.container.visibleLines + 1) { + 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) { int lineWidth = 0; @@ -952,13 +1173,123 @@ public class GuiScriptTextArea extends GuiNpcTextField { private int getCursorLineIndex() { return selection.getCursorLineIndex(container.lines, text != null ? text.length() : 0); } + + /** + * Get the token at a specific screen position (mouse coordinates). + * Also returns the token's screen position and dimensions for tooltip placement. + * + * @param xMouse Screen X coordinate + * @param yMouse Screen Y coordinate + * @return Array of [Token, tokenScreenX, tokenScreenY, tokenWidth] or null if no token + */ + private Object[] getTokenAtScreenPosition(int xMouse, int yMouse) { + if (container == null || !(container instanceof ScriptTextContainer)) { + return null; + } + + ScriptTextContainer scriptContainer = (ScriptTextContainer) container; + + // Check if mouse is within the text viewport + int viewportX = x + LINE_NUMBER_GUTTER_WIDTH + 1; + if (xMouse < viewportX || xMouse > x + width || yMouse < y || yMouse > y + height) { + return null; + } + + // Adjust mouse position relative to text area + int relativeY = yMouse - y; - + // Account for fractional scrolling + double fracOffset = scroll.getFractionalOffset(); + double fracPixels = fracOffset * container.lineHeight; + double adjustedY = relativeY + fracPixels; + + // Find which line the mouse is over + int lineIdx = scroll.getScrolledLine() + (int)(adjustedY / container.lineHeight); + if (lineIdx < 0 || lineIdx >= container.lines.size()) { + return null; + } + + ScriptLine lineData = container.getDocument().getLine(lineIdx); + String lineText = lineData.getText(); + int lineStart = lineData.getGlobalStart(); + + // Get the token at this position + int globalMouseX = getSelectionPos(xMouse,yMouse); + Token token = lineData.getTokenAt(globalMouseX, (t) -> t.getType() != TokenType.DEFAULT); // Ignore default tokens i.e. whitespaces + if (token == null) + return null; + + // Calculate token's screen position + int tokenLocalStart = token.getGlobalStart() - lineStart; + int tokenLocalEnd = token.getGlobalEnd() - lineStart; + tokenLocalStart = Math.max(0, Math.min(tokenLocalStart, lineText.length())); + tokenLocalEnd = Math.max(0, Math.min(tokenLocalEnd, lineText.length())); + + int tokenScreenX = viewportX + ClientProxy.Font.width(lineText.substring(0, tokenLocalStart)); + int tokenScreenY = y + (lineIdx - scroll.getScrolledLine()) * container.lineHeight - (int)fracPixels; + int tokenWidth = ClientProxy.Font.width(lineText.substring(tokenLocalStart, tokenLocalEnd)); + + return new Object[] { token, tokenScreenX, tokenScreenY, tokenWidth }; + } + + /** + * Update hover state based on current mouse position. + * Called every frame from drawTextBox. + */ + private void updateHoverState(int xMouse, int yMouse) { + // Keep tooltip alive and skip token re-evaluation while it is being dragged + if (hoverState.isDraggingTooltip()) { + hoverState.setLastMousePosition(xMouse, yMouse); + return; + } + // Keep tooltip alive while resizing (mouse may be outside the panel bounds) + if (hoverState.isResizingTooltip()) { + hoverState.setLastMousePosition(xMouse, yMouse); + return; + } + // Tooltip has been dragged or resized — keep it pinned until an explicit outside click + if (hoverState.hasOverriddenPosition() || hoverState.hasOverriddenSize()) { + hoverState.setLastMousePosition(xMouse, yMouse); + return; + } + // If mouse is currently over the tooltip panel, keep it visible — do not clear or re-evaluate tokens + if (hoverState.isTooltipVisible() && hoverState.isMouseOverTooltip(xMouse, yMouse)) { + hoverState.setLastMousePosition(xMouse, yMouse); + return; + } + // Don't show tooltips when not active, clicking, or when overlays are visible + if (!isEnabled() || clicked || searchBar.isVisible() || + goToLineDialog.isVisible() || KEYS_OVERLAY.isVisible() || renameHandler.isActive() || autocompleteManager.isVisible()) { + hoverState.clearHover(); + return; + } + + // Get token at current mouse position + Object[] tokenInfo = getTokenAtScreenPosition(xMouse, yMouse); + + if (tokenInfo != null) { + Token token = (Token) tokenInfo[0]; + int tokenScreenX = (Integer) tokenInfo[1]; + int tokenScreenY = (Integer) tokenInfo[2]; + int tokenWidth = (Integer) tokenInfo[3]; + + hoverState.update(xMouse, yMouse, token, tokenScreenX, tokenScreenY, tokenWidth); + } else { + // If mouse is over the tooltip box, keep tooltip visible — do not clear + if (hoverState.isMouseOverTooltip(xMouse, yMouse)) { + hoverState.setLastMousePosition(xMouse, yMouse); + return; + } + hoverState.update(xMouse, yMouse, null, 0, 0, 0); + } + } + + // Scroll viewport to keep cursor visible (minimal adjustment, like IntelliJ) // Only scrolls if cursor is outside the visible area private void scrollToCursor() { if (container == null || container.lines == null || container.lines.isEmpty()) return; - + int lineIdx = getCursorLineIndex(); int visible = Math.max(1, container.visibleLines); int effectiveVisible = Math.max(1, visible - bottomPaddingLines); @@ -1038,13 +1369,35 @@ public class GuiScriptTextArea extends GuiNpcTextField { } }); - // COPY: Copy selection to clipboard + // COPY: Copy selection to clipboard (or entire line if no selection) KEYS.COPY.setTask(e -> { if (!e.isPress() || !isActive.get()) return; - if (selection.hasSelection()) + if (selection.hasSelection()) { NoppesStringUtils.setClipboardContents(selection.getSelectedText(text)); + lastCopyWasLine = false; + lastCopiedLineText = null; + } else { + // Copy entire current line (including newline) + int cursor = selection.getCursorPosition(); + LineData targetLine = null; + for (LineData line : container.lines) { + if (cursor >= line.start && cursor <= line.end) { + targetLine = line; + break; + } + } + + if (targetLine != null) { + int safeStart = Math.max(0, Math.min(targetLine.start, text.length())); + int safeEnd = Math.max(safeStart, Math.min(targetLine.end, text.length())); + String lineText = text.substring(safeStart, safeEnd); + NoppesStringUtils.setClipboardContents(lineText); + lastCopyWasLine = true; + lastCopiedLineText = lineText; + } + } }); // PASTE: Insert clipboard contents at caret @@ -1052,7 +1405,48 @@ public class GuiScriptTextArea extends GuiNpcTextField { if (!e.isPress() || !isActive.get()) return; - addText(NoppesStringUtils.getClipboardContents()); + String clipboardRaw = NoppesStringUtils.getClipboardContents(); + if (clipboardRaw == null) + clipboardRaw = ""; + + boolean isLinePaste = lastCopyWasLine && lastCopiedLineText != null && clipboardRaw.equals(lastCopiedLineText); + String clipboard = FormatHelper.sanitizeClipboard(clipboardRaw, PASTE_TRAILING_WS_TRIM_THRESHOLD); + + if (selection.hasSelection()) { + addText(clipboard); + lastCopyWasLine = false; + lastCopiedLineText = null; + scrollToCursor(); + return; + } + + if (isLinePaste && container != null && container.lines != null) { + LineData currentLine = selection.findCurrentLine(container.lines); + if (currentLine != null) { + int insertPos = Math.max(0, Math.min(currentLine.end, text.length())); + String insertText = clipboard; + + // Ensure insertion happens on the line below + if (insertPos > 0 && text.charAt(insertPos - 1) != '\n') { + insertText = "\n" + insertText; + } + + // Ensure the inserted line doesn't merge with the following line + if (insertPos < text.length() && !insertText.endsWith("\n")) { + insertText = insertText + "\n"; + } + + String newText = text.substring(0, insertPos) + insertText + text.substring(insertPos); + setText(newText); + + int newCursor = insertPos + (insertText.startsWith("\n") ? 1 : 0); + selection.reset(Math.min(newCursor, newText.length())); + scrollToCursor(); + return; + } + } + + addText(clipboard); scrollToCursor(); }); @@ -1165,6 +1559,142 @@ public class GuiScriptTextArea extends GuiNpcTextField { } }); + // DELETE_LINE: Delete the current line + KEYS.DELETE_LINE.setTask(e -> { + if (!e.isPress() || !isActive.get()) + return; + + if (text == null || text.isEmpty()) + return; + + int cursor = selection.getCursorPosition(); + + LineData targetLine = null; + int targetIndex = -1; + for (LineData line : container.lines) { + if (cursor >= line.start && cursor <= line.end) { + targetLine = line; + targetIndex = container.lines.indexOf(line); + break; + } + } + + if (targetLine == null) + return; + + int start = Math.max(0, Math.min(targetLine.start, text.length())); + int end = Math.max(start, Math.min(targetLine.end, text.length())); + + String newText = text.substring(0, start) + text.substring(end); + setText(newText); + + int newCursor = 0; + if (targetIndex > 0 && targetIndex <= container.lines.size() - 1) { + LineData previousLine = container.lines.get(targetIndex - 1); + int prevStart = Math.max(0, Math.min(previousLine.start, newText.length())); + int prevEnd = Math.max(prevStart, Math.min(previousLine.end, newText.length())); + int prevLen = Math.max(0, prevEnd - prevStart); + int offsetInLine = Math.max(0, Math.min(cursor - targetLine.start, prevLen)); + newCursor = Math.min(prevStart + offsetInLine, newText.length()); + } + + selection.reset(Math.min(newCursor, newText.length())); + scrollToCursor(); + }); + + // MOVE_LINE_UP: Move current line up + KEYS.MOVE_LINE_UP.setThrottleInterval(50).setTask(e -> { + if ((!e.isPress() && !e.isHold()) || !isActive.get()) + return; + + if (text == null || text.isEmpty()) + return; + + int tLen = text.length(); + int cursor = Math.max(0, Math.min(selection.getCursorPosition(), tLen)); + + // Work on real newline-delimited lines, not wrapped LineData. + int currStart = text.lastIndexOf('\n', Math.max(0, cursor - 1)); + currStart = currStart == -1 ? 0 : (currStart + 1); + if (currStart == 0) + return; // Can't move first line up + + int currEnd = text.indexOf('\n', cursor); + currEnd = currEnd == -1 ? tLen : (currEnd + 1); + + int prevEnd = currStart; + int prevStart = text.lastIndexOf('\n', Math.max(0, prevEnd - 2)); + prevStart = prevStart == -1 ? 0 : (prevStart + 1); + + String previousText = text.substring(prevStart, prevEnd); + String currentText = text.substring(currStart, currEnd); + + // If current line is the last line without a trailing newline, but it is being moved + // into the middle, ensure it ends with '\n' by transferring the '\n' from the previous line. + if (!currentText.endsWith("\n") && previousText.endsWith("\n") && !previousText.isEmpty()) { + currentText = currentText + "\n"; + previousText = previousText.substring(0, previousText.length() - 1); + } + + String before = text.substring(0, prevStart); + String after = text.substring(currEnd); + String newText = before + currentText + previousText + after; + setText(newText); + + int currentContentLen = currentText.endsWith("\n") ? Math.max(0, currentText.length() - 1) : currentText.length(); + int offsetInLine = Math.max(0, Math.min(cursor - currStart, currentContentLen)); + int newCursor = Math.min(prevStart + offsetInLine, newText.length()); + selection.reset(newCursor); + scrollToCursor(); + }); + + // MOVE_LINE_DOWN: Move current line down + KEYS.MOVE_LINE_DOWN.setThrottleInterval(50).setTask(e -> { + if ((!e.isPress() && !e.isHold()) || !isActive.get()) + return; + + if (text == null || text.isEmpty()) + return; + + int tLen = text.length(); + int cursor = Math.max(0, Math.min(selection.getCursorPosition(), tLen)); + + // Work on real newline-delimited lines, not wrapped LineData. + int currStart = text.lastIndexOf('\n', Math.max(0, cursor - 1)); + currStart = currStart == -1 ? 0 : (currStart + 1); + + int currEnd = text.indexOf('\n', cursor); + currEnd = currEnd == -1 ? tLen : (currEnd + 1); + if (currEnd >= tLen) + return; // Can't move last line down + + int nextStart = currEnd; + int nextEnd = text.indexOf('\n', nextStart); + nextEnd = nextEnd == -1 ? tLen : (nextEnd + 1); + + String currentText = text.substring(currStart, currEnd); + String nextText = text.substring(nextStart, nextEnd); + + // If the next line is the last line and doesn't end with '\n' (common when it contains + // only indentation spaces), swapping can merge whitespace onto the moved line. + // Fix by transferring the '\n' from currentText to nextText. + if (!nextText.endsWith("\n") && currentText.endsWith("\n") && !currentText.isEmpty()) { + currentText = currentText.substring(0, currentText.length() - 1); + nextText = nextText + "\n"; + } + + String before = text.substring(0, currStart); + String after = text.substring(nextEnd); + String newText = before + nextText + currentText + after; + setText(newText); + + int currentContentLen = currentText.endsWith("\n") ? Math.max(0, currentText.length() - 1) : currentText.length(); + int offsetInLine = Math.max(0, Math.min(cursor - currStart, currentContentLen)); + int newCursor = Math.min(currStart + nextText.length() + offsetInLine, newText.length()); + selection.reset(newCursor); + scrollToCursor(); + }); + // Check if can open just for SearchReplaceBar and GoToLine @@ -1173,27 +1703,27 @@ public class GuiScriptTextArea extends GuiNpcTextField { KEYS.SEARCH.setTask(e -> { if (!e.isPress() || !openBoxes.get()) return; - + unfocusAll(); searchBar.openSearch(); }); - + // SEARCH_REPLACE: Open search+replace bar (Ctrl+Shift+R) // Works in search bar. KEYS.SEARCH_REPLACE.setTask(e -> { if (!e.isPress() || !openBoxes.get()) return; - + unfocusAll(); searchBar.openSearchReplace(); }); - + // GO_TO_LINE: Open go to line dialog (Ctrl+G) // Works in search bar. KEYS.GO_TO_LINE.setTask(e -> { if (!e.isPress() || !openBoxes.get()) return; - + unfocusAll(); goToLineDialog.toggle(); }); @@ -1210,6 +1740,14 @@ public class GuiScriptTextArea extends GuiNpcTextField { renameHandler.startRename(); } }); + + // AUTOCOMPLETE: Trigger autocomplete (Ctrl+Space) + KEYS.AUTOCOMPLETE.setTask(e -> { + if (!e.isPress() || !isActive.get()) + return; + + autocompleteManager.triggerExplicit(); + }); } public void unfocusAll() { @@ -1217,6 +1755,8 @@ public class GuiScriptTextArea extends GuiNpcTextField { if (goToLineDialog.hasFocus()) goToLineDialog.unfocus(); if (renameHandler.isActive()) renameHandler.cancel(); + if (autocompleteManager.isVisible()) + autocompleteManager.dismiss(); } // ==================== KEYBOARD INPUT HANDLING ==================== @@ -1232,14 +1772,32 @@ public class GuiScriptTextArea extends GuiNpcTextField { // Handle rename refactor input first if active if (renameHandler.isActive() && renameHandler.keyTyped(c, i)) return true; - + // Handle Go To Line dialog input first if it has focus - if (goToLineDialog.isVisible() && goToLineDialog.keyTyped(c, i)) - return true; - + if (goToLineDialog.isVisible() &&goToLineDialog.keyTyped(c, i)) + return true; + // Handle search bar input first if it has focus - if (searchBar.isVisible() && searchBar.keyTyped(c, i)) + if (searchBar.isVisible() && searchBar.keyTyped(c, i)) return true; + + // Handle autocomplete navigation keys first when visible + if (autocompleteManager.isVisible()) { + if (autocompleteManager.keyPressed(i)) { + return true; + } + } + + // Dismiss pinned/resized tooltip on Escape + if (i == Keyboard.KEY_ESCAPE && hoverState.isTooltipVisible() + && (hoverState.hasOverriddenPosition() || hoverState.hasOverriddenSize())) { + hoverState.clearHover(); + return true; + } + // Ignore if any global keys bound to this code are currently pressed + if (KEYS.hasMatchingKeyPressed(i)) + return false; + if (!active) return false; @@ -1268,20 +1826,31 @@ public class GuiScriptTextArea extends GuiNpcTextField { if (i == Keyboard.KEY_LEFT) { int j = 1; // default: move one character if (isCtrlKeyDown()) { - // When Ctrl is down, compute distance to previous word boundary. - // We match words in the text slice before the cursor and pick - // the last match start as the new boundary. - Matcher m = container.regexWord.matcher(text.substring(0, selection.getCursorPosition())); - while (m.find()) { - if (m.start() == m.end()) - continue; // skip empty matches - // j becomes the number of chars to move left to reach word start - j = selection.getCursorPosition() - m.start(); + int pos = selection.getCursorPosition(); + int g = pos; + java.util.function.IntPredicate isWordChar = ch -> Character.isLetterOrDigit(ch) || ch == '_'; + + if (pos > 0) { + char left = text.charAt(pos - 1); + if (Character.isWhitespace(left)) { + while (g - 1 >= 0 && Character.isWhitespace(text.charAt(g - 1))) g--; + } else if (isWordChar.test(left)) { + while (g - 1 >= 0 && isWordChar.test(text.charAt(g - 1))) g--; + } else { + while (g - 1 >= 0 && !Character.isWhitespace(text.charAt(g - 1)) && !isWordChar.test(text.charAt(g - 1))) g--; + } } + j = Math.max(1, pos - g); } int newPos = Math.max(selection.getCursorPosition() - j, 0); // If Shift is held, extend selection; otherwise place caret. setCursor(newPos, GuiScreen.isShiftKeyDown()); + + // Notify autocomplete of cursor movement + if (autocompleteManager.isVisible()) { + autocompleteManager.onCursorMove(text, newPos); + } + return true; } @@ -1289,26 +1858,30 @@ public class GuiScriptTextArea extends GuiNpcTextField { if (i == Keyboard.KEY_RIGHT) { int j = 1; // default: move one character if (isCtrlKeyDown()) { - String after = text.substring(selection.getCursorPosition()); - Matcher m = container.regexWord.matcher(after); - if (m.find()) { - if (m.start() == 0) { - // If the first match starts at 0 (cursor at word start), - // try to find the next match so we advance past the current word. - if (m.find()) - j = m.start(); - else - j = Math.max(1, after.length()); + int pos = selection.getCursorPosition(); + int end = pos; + java.util.function.IntPredicate isWordChar = ch -> Character.isLetterOrDigit(ch) || ch == '_'; + + if (pos < text.length()) { + char first = text.charAt(pos); + if (Character.isWhitespace(first)) { + while (end < text.length() && Character.isWhitespace(text.charAt(end))) end++; + } else if (isWordChar.test(first)) { + while (end < text.length() && isWordChar.test(text.charAt(end))) end++; } else { - j = m.start(); + while (end < text.length() && !Character.isWhitespace(text.charAt(end)) && !isWordChar.test(text.charAt(end))) end++; } - } else { - // No word match found after cursor -> jump to end - j = Math.max(1, after.length()); } + j = Math.max(1, end - pos); } int newPos = Math.min(selection.getCursorPosition() + j, text.length()); setCursor(newPos, GuiScreen.isShiftKeyDown()); + + // Notify autocomplete of cursor movement + if (autocompleteManager.isVisible()) { + autocompleteManager.onCursorMove(text, newPos); + } + return true; } @@ -1345,29 +1918,149 @@ public class GuiScriptTextArea extends GuiNpcTextField { return true; } - // RETURN/ENTER: special handling when preceding char is an opening brace '{' + // RETURN/ENTER: special handling for /** javadoc stub and opening brace '{' if (i == Keyboard.KEY_RETURN) { int cursorPos = selection.getCursorPosition(); + + // JSDoc / comment Enter behavior summary: + // - If the caret is at (or after spaces/tabs following) "/**", Enter generates a JSDoc stub. + // - If an inline closer exists ("/** */"), expand to a multi-line block without duplicating "*/". + // - If already inside an existing JSDoc with "*" lines, insert a new " * " line (IDE-style). + // - If the caret is on a "*" line inside an unclosed JSDoc block, Enter inserts a new " * " line. + // - Multi-line selections are not special-cased (avoid surprising mass edits). + + if (selection.hasSelection() && text != null && selection.getSelectedText(text).indexOf('\n') != -1) { + addText(Character.toString('\n') + getAutoIndentForEnter()); + scrollToCursor(); + return true; + } + + // Check for /** javadoc stub auto-generation + String before = getSelectionBeforeText(); + int beforeTrimEnd = before.length(); + while (beforeTrimEnd > 0) { + char ch = before.charAt(beforeTrimEnd - 1); + if (ch == ' ' || ch == '\t') { + beforeTrimEnd--; + } else { + break; + } + } + + if (before.substring(0, beforeTrimEnd).endsWith("/**")) { + // Derive indentation from the logical source line (not soft-wrapped LineData). + String indent = getLogicalLineIndentAt(Math.max(0, Math.min(cursorPos, text != null ? text.length() : 0))); + + // Look ahead for a function declaration to generate smart JSDoc + String after = getSelectionAfterText(); + + String afterTrimmed = after; + int wsLen = 0; + while (wsLen < afterTrimmed.length() && (afterTrimmed.charAt(wsLen) == ' ' || afterTrimmed.charAt(wsLen) == '\t')) { + wsLen++; + } + if (wsLen < afterTrimmed.length() && afterTrimmed.charAt(wsLen) == '\n') { + int idx = wsLen + 1; + while (idx < afterTrimmed.length() && (afterTrimmed.charAt(idx) == ' ' || afterTrimmed.charAt(idx) == '\t')) { + idx++; + } + if (afterTrimmed.startsWith("*/", idx)) { + // Inline "/** */" -> expand to multi-line and keep the existing closer. + String restAfterCloser = afterTrimmed.substring(Math.min(idx + 2, afterTrimmed.length())); + String expanded = "\n" + indent + " * " + "\n" + indent + " */" + restAfterCloser; + setText(before + expanded, true); + int newCursorPos = before.length() + 1 + indent.length() + 3; // +1 for \n, +3 for " * " + selection.reset(newCursorPos); + scrollToCursor(); + return true; + } + if (idx < afterTrimmed.length() && afterTrimmed.charAt(idx) == '*') { + int closerPos = afterTrimmed.indexOf("*/", idx); + if (closerPos != -1) { + // Already inside a multi-line JSDoc -> insert a new " * " line. + addText("\n" + indent + " * "); + int newCursorPos = before.length() + 1 + indent.length() + 3; // +1 for \n, +3 for " * " + selection.reset(newCursorPos); + scrollToCursor(); + return true; + } + } + } + if (afterTrimmed.substring(wsLen).startsWith("*/")) { + // Inline "/** */" (same line) -> expand to multi-line and keep the existing closer. + String restAfterCloser = afterTrimmed.substring(wsLen + 2); + String expanded = "\n" + indent + " * " + "\n" + indent + " */" + restAfterCloser; + setText(before + expanded, true); + int newCursorPos = before.length() + 1 + indent.length() + 3; // +1 for \n, +3 for " * " + selection.reset(newCursorPos); + scrollToCursor(); + return true; + } + + // Look ahead for a function declaration to generate smart JSDoc + String javadocStub = generateJSDocStub(after, indent); + addText(javadocStub); + + // Position cursor after " * " on the description line + int newCursorPos = before.length() + 1 + indent.length() + 3; // +1 for \n, +3 for " * " + selection.reset(newCursorPos); + scrollToCursor(); + return true; + } + + if (text != null && !text.isEmpty()) { + int openPos = text.lastIndexOf("/**", Math.max(0, cursorPos - 1)); + if (openPos != -1) { + int closeBetween = text.indexOf("*/", openPos + 3); + if (closeBetween == -1 || closeBetween >= cursorPos) { + int lineStart = text.lastIndexOf('\n', Math.max(0, cursorPos - 1)) + 1; + int lineEnd = text.indexOf('\n', lineStart); + if (lineEnd == -1) { + lineEnd = text.length(); + } + String line = text.substring(lineStart, lineEnd); + String trimmed = line.trim(); + if (trimmed.startsWith("*") && !trimmed.startsWith("*/")) { + // Continuation line inside an unclosed JSDoc block. + int openLineStart = text.lastIndexOf('\n', Math.max(0, openPos - 1)) + 1; + int openLineEnd = text.indexOf('\n', openLineStart); + if (openLineEnd == -1) { + openLineEnd = text.length(); + } + String openLine = text.substring(openLineStart, openLineEnd); + String baseIndent = openLine.substring(0, IndentHelper.getLineIndent(openLine)); + addText("\n" + baseIndent + " * "); + int newCursorPos = cursorPos + 1 + baseIndent.length() + 3; + selection.reset(Math.min(newCursorPos, this.text.length())); + scrollToCursor(); + return true; + } + } + } + } + int prevNonWs = cursorPos - 1; while (prevNonWs >= 0 && prevNonWs < (text != null ? text.length() : 0) && Character.isWhitespace( - text.charAt(prevNonWs))) { + text.charAt(prevNonWs))) { prevNonWs--; } if (prevNonWs >= 0 && cursorPos <= (text != null ? text.length() : 0) && text.charAt(prevNonWs) == '{') { - String indent = ""; - for (LineData ld : this.container.lines) { - if (prevNonWs >= ld.start && prevNonWs < ld.end) { - indent = ld.text.substring(0, IndentHelper.getLineIndent(ld.text)); - break; - } - } - if (indent == null) - indent = ""; + String indent = getLogicalLineIndentAt(prevNonWs); String childIndent = indent + " "; - String before = getSelectionBeforeText(); String after = getSelectionAfterText(); + // If the next non-whitespace char is '}', don't insert another closer. + int nextNonWs = 0; + while (nextNonWs < after.length() && Character.isWhitespace(after.charAt(nextNonWs))) { + nextNonWs++; + } + if (nextNonWs < after.length() && after.charAt(nextNonWs) == '}') { + addText("\n" + childIndent); + scrollToCursor(); + return true; + } + int firstNewline = after.indexOf('\n'); String leadingSegment = firstNewline == -1 ? after : after.substring(0, firstNewline); if (leadingSegment.trim().length() > 0) { @@ -1425,6 +2118,116 @@ public class GuiScriptTextArea extends GuiNpcTextField { return false; } + + /** + * Generates a JSDoc stub for a function declaration. + * Looks at the text after the cursor to find function signature and generates + * appropriate @param and @return tags. + * + * @param after Text after the /** to search for function + * @param indent Current line indentation + * @return The JSDoc stub string including newlines + */ + private String generateJSDocStub(String after, String indent) { + StringBuilder stub = new StringBuilder(); + stub.append("\n").append(indent).append(" * "); // Description line + + // Try to find a function/method declaration or field declaration following the JSDoc + // Skip whitespace and newlines + String trimmed = after.replaceFirst("^[\\s\\n\\r]*", ""); + + // First, try to match function/method pattern + java.util.regex.Pattern funcPattern = java.util.regex.Pattern.compile( + // Group 1: Optional return type (Java) or 'function' keyword (JS) + "^(?:(\\w+(?:<[^>]+>)?|function)\\s+)?" + + // Group 2: Method/function name + "(\\w+)\\s*" + + // Group 3: Parameters inside parentheses + "\\(([^)]*)\\)" + ); + + java.util.regex.Matcher funcMatcher = funcPattern.matcher(trimmed); + if (funcMatcher.find()) { + // Handle function/method + String returnOrKeyword = funcMatcher.group(1); + String funcName = funcMatcher.group(2); + String paramsStr = funcMatcher.group(3) != null ? funcMatcher.group(3).trim() : ""; + + // Determine if this is JavaScript (function keyword or no return type) + boolean isJS = "function".equals(returnOrKeyword) || returnOrKeyword == null || + (container != null && container.getDocument() != null && container.getDocument().isJavaScript()); + + // Parse parameters + if (!paramsStr.isEmpty()) { + String[] params = paramsStr.split(","); + for (String param : params) { + param = param.trim(); + if (param.isEmpty()) continue; + + String paramName; + String paramType = "any"; + + // Split on whitespace to get type and name + String[] parts = param.split("\\s+"); + if (parts.length >= 2) { + // Java style: Type name + paramType = parts[parts.length - 2]; + paramName = parts[parts.length - 1]; + } else { + // JS style: just name + paramName = parts[0]; + } + + // Remove any trailing array brackets or varargs + paramName = paramName.replaceAll("[\\[\\]\\.]", ""); + + if (isJS) { + stub.append("\n").append(indent).append(" * @param {").append(paramType).append("} ").append(paramName); + } else { + stub.append("\n").append(indent).append(" * @param ").append(paramName); + } + } + } + + // Add @return/@returns tag if applicable + if (returnOrKeyword != null && !"function".equals(returnOrKeyword) && !"void".equals(returnOrKeyword)) { + if (isJS) { + stub.append("\n").append(indent).append(" * @returns {").append(returnOrKeyword).append("}"); + } else { + stub.append("\n").append(indent).append(" * @return"); + } + } else if (isJS) { + // For JS functions without explicit return type, add empty @returns + stub.append("\n").append(indent).append(" * @returns {any}"); + } + } else { + // Try to match field declaration: [modifiers] Type name or var/let/const name + java.util.regex.Pattern fieldPattern = java.util.regex.Pattern.compile( + "^(?:(?:public|private|protected|static|final|var|let|const)\\s+)*" + // Optional modifiers + "(\\w+(?:<[^>]+>)?)\\s+" + // Type (Group 1) + "(\\w+)" + // Field name (Group 2) + "(?:\\s*=|\\s*;)" // Followed by = or ; + ); + + java.util.regex.Matcher fieldMatcher = fieldPattern.matcher(trimmed); + if (fieldMatcher.find()) { + String fieldType = fieldMatcher.group(1); + + // Check if this is JavaScript + boolean isJS = container != null && container.getDocument() != null && container.getDocument().isJavaScript(); + + if (isJS && fieldType != null) { + // For JS fields, add @type annotation + stub.append("\n").append(indent).append(" * @type {").append("any").append("}"); + } + } + } + + // Close the JSDoc block + stub.append("\n").append(indent).append(" */"); + + return stub.toString(); + } /** * Handles deletion keys: Delete, Backspace, and Ctrl+Backspace. @@ -1439,7 +2242,7 @@ public class GuiScriptTextArea extends GuiNpcTextField { if (!s.isEmpty() && !selection.hasSelection()) // remove single character after caret when nothing is selected s = s.substring(1); - setText(getSelectionBeforeText() + s); + setText(getSelectionBeforeText() + s, true); // Use atomic undo // Keep caret at same start selection selection.reset(selection.getStartSelection()); return true; @@ -1447,46 +2250,33 @@ public class GuiScriptTextArea extends GuiNpcTextField { // CTRL+BACKSPACE: delete to previous word or whitespace boundary. if (isKeyComboCtrlBackspace(i)) { - String s = getSelectionBeforeText(); + String before = getSelectionBeforeText(); if (selection.getStartSelection() > 0 && !selection.hasSelection()) { - int nearestCondition = selection.getCursorPosition(); - int g; - // If the char left of caret is whitespace, find the first non-space to the left; - // otherwise find first whitespace/newline to the left (word boundary). - boolean cursorInWhitespace = Character.isWhitespace(s.charAt(selection.getCursorPosition() - 1)); - if (cursorInWhitespace) { - // Scan left until non-whitespace (start of previous word) - for (g = selection.getCursorPosition() - 1; g >= 0; g--) { - char currentChar = s.charAt(g); - if (!Character.isWhitespace(currentChar)) { - nearestCondition = g; - break; - } - if (g == 0) { - nearestCondition = 0; - } - } + int pos = selection.getCursorPosition(); + int g = pos; + + // Helper: treat letters, digits and underscore as word characters + java.util.function.IntPredicate isWordChar = ch -> Character.isLetterOrDigit(ch) || ch == '_'; + + // If caret is after whitespace, delete contiguous whitespace first + char left = before.charAt(pos - 1); + if (Character.isWhitespace(left)) { + while (g - 1 >= 0 && Character.isWhitespace(before.charAt(g - 1))) + g--; + } else if (isWordChar.test(left)) { + // Delete contiguous word characters (letters/digits/_) + while (g - 1 >= 0 && isWordChar.test(before.charAt(g - 1))) + g--; } else { - // Scan left until whitespace/newline is found (word boundary) - for (g = selection.getCursorPosition() - 1; g >= 0; g--) { - char currentChar = s.charAt(g); - if (Character.isWhitespace(currentChar) || currentChar == '\n') { - nearestCondition = g; - break; - } - if (g == 0) { - nearestCondition = 0; - } - } + // Delete contiguous non-word, non-whitespace characters (punctuation) + while (g - 1 >= 0 && !Character.isWhitespace(before.charAt(g - 1)) && !isWordChar.test(before.charAt(g - 1))) + g--; } - // Trim the prefix up to the discovered boundary - s = s.substring(0, nearestCondition); - // Adjust selection start to match removed characters - selection.setStartSelection( - selection.getStartSelection() - (selection.getCursorPosition() - nearestCondition)); + before = before.substring(0, g); + selection.setStartSelection(selection.getStartSelection() - (pos - g)); } - setText(s + getSelectionAfterText()); + setText(before + getSelectionAfterText(), true); // Use atomic undo selection.reset(selection.getStartSelection()); return true; } @@ -1501,7 +2291,7 @@ public class GuiScriptTextArea extends GuiNpcTextField { // 1) selection deletion if (selection.hasSelection()) { String s = getSelectionBeforeText(); - setText(s + getSelectionAfterText()); + setText(s + getSelectionAfterText(), true); // Use atomic undo selection.reset(selection.getStartSelection()); scrollToCursor(); return true; @@ -1517,15 +2307,9 @@ public class GuiScriptTextArea extends GuiNpcTextField { // intuitive on blank/indented lines outside any recognized scope. LineData currCheck = selection.findCurrentLine(container.lines); if (currCheck != null && currCheck.text.trim().length() == 0) { - int removeEnd = text.indexOf('\n', currCheck.start - 1); - if (removeEnd == -1) { - removeEnd = text.length(); - } else { - removeEnd = removeEnd + 1; // include the newline - } String before = text.substring(0, ValueUtil.clamp(currCheck.start - 1, 0, text.length())); - String after = removeEnd <= text.length() ? text.substring(removeEnd) : ""; - setText(before + after); + String after = text.substring(Math.min(currCheck.end, text.length())); + setText(before + after, true); // Use atomic undo int newCursor = Math.max(0, currCheck.start - 1); selection.reset(newCursor); scrollToCursor(); @@ -1554,7 +2338,7 @@ public class GuiScriptTextArea extends GuiNpcTextField { } String before = text.substring(0, curr.start); String after = removeEnd <= text.length() ? text.substring(removeEnd) : ""; - setText(before + after); + setText(before + after, true); // Use atomic undo // Place caret at end of previous line int newCursor = Math.max(0, curr.start - 1); selection.reset(newCursor); @@ -1572,16 +2356,16 @@ public class GuiScriptTextArea extends GuiNpcTextField { char lastChar = before.charAt(before.length() - 1); char firstChar = content.charAt(0); // Avoid adding space when punctuation/brackets are adjacent - if (!Character.isWhitespace(lastChar) && + if (!Character.isWhitespace(lastChar) && lastChar != '{' && lastChar != '(' && lastChar != '[' && - firstChar != '}' && firstChar != ')' && firstChar != ']' && + firstChar != '}' && firstChar != ')' && firstChar != ']' && firstChar != ';' && firstChar != ',' && firstChar != '.' && firstChar != '\n') { spacer = " "; } } - setText(before + spacer + content); + setText(before + spacer + content, true); // Use atomic undo int newCursor = before.length() + spacer.length(); selection.reset(newCursor); scrollToCursor(); @@ -1595,15 +2379,15 @@ public class GuiScriptTextArea extends GuiNpcTextField { if (selection.getStartSelection() > 0 && selection.getStartSelection() < text.length()) { char prev = text.charAt(selection.getStartSelection() - 1); char nextc = text.charAt(selection.getStartSelection()); - if ((prev == '(' && nextc == ')') || - (prev == '[' && nextc == ']') || - (prev == '{' && nextc == '}') || - (prev == '\'' && nextc == '\'') || + if ((prev == '(' && nextc == ')') || + (prev == '[' && nextc == ']') || + (prev == '{' && nextc == '}') || + (prev == '\'' && nextc == '\'') || (prev == '"' && nextc == '"')) { String before = text.substring(0, selection.getStartSelection() - 1); String after = selection.getStartSelection() + 1 < text.length() ? text.substring( - selection.getStartSelection() + 1) : ""; - setText(before + after); + selection.getStartSelection() + 1) : ""; + setText(before + after, true); // Use atomic undo selection.setStartSelection(selection.getStartSelection() - 1); selection.reset(selection.getStartSelection()); scrollToCursor(); @@ -1615,9 +2399,11 @@ public class GuiScriptTextArea extends GuiNpcTextField { String s = getSelectionBeforeText(); s = s.substring(0, s.length() - 1); selection.setStartSelection(selection.getStartSelection() - 1); - setText(s + getSelectionAfterText()); + setText(s + getSelectionAfterText(), true); // Use atomic undo selection.reset(selection.getStartSelection()); scrollToCursor(); + // Notify autocomplete of deletion + autocompleteManager.onDeleteKey(text, selection.getCursorPosition()); return true; } @@ -1763,63 +2549,176 @@ public class GuiScriptTextArea extends GuiNpcTextField { if (ChatAllowedCharacters.isAllowedCharacter(c)) { String before = getSelectionBeforeText(); String after = getSelectionAfterText(); + int cursorPos = selection.getCursorPosition(); - // If the user types a closing character and that same closer is - // already immediately after the caret, move caret past it instead - // of inserting another closer. This prevents duplicate closers - // when the editor auto-inserts pairs. - if ((c == ')' || c == ']' || c == '"' || c == '\'') && after.length() > 0 && after.charAt(0) == c) { - // Move caret forward by one (skip over existing closer) + if ((c == ')' || c == ']' || c == '}') && after.length() > 0 && after.charAt(0) == c) { selection.reset(before.length() + 1); scrollToCursor(); + autocompleteManager.onCharTyped(c, text, cursorPos); + return true; + } + + if (c == '"' || c == '\'') { + if (after.length() > 0 && after.charAt(0) == c) { + // Move caret forward by one (skip over existing closer) + selection.reset(before.length() + 1); + scrollToCursor(); + // Notify autocomplete of the character + autocompleteManager.onCharTyped(c, text, cursorPos); + return true; + } + + // Auto-pair only when it looks like we're starting a new string. If the current + // logical line already has an unclosed quote of this type, treat the typed quote + // as a closer to avoid producing triple quotes. + boolean allowAutoPair = !container.getDocument().isExcludedInclusive(cursorPos) + && !isLikelyClosingQuote(before, c); + + if (allowAutoPair) { + if (c == '"') { + setText(before + "\"\"" + after, true); + } else { + setText(before + "''" + after, true); + } + selection.reset(before.length() + 1); + scrollToCursor(); + autocompleteManager.onCharTyped(c, text, cursorPos); + return true; + } + + addText(Character.toString(c)); + scrollToCursor(); + autocompleteManager.onCharTyped(c, text, cursorPos); return true; } // Auto-pair insertion: when opening a quote/brace/bracket is typed, // insert a matching closer and place caret between the pair. - if (c == '"') { - setText(before + "\"\"" + after); - selection.reset(before.length() + 1); - scrollToCursor(); - return true; + // But only if the current position is not excluded (e.g., inside a comment or string) + if (!container.getDocument().isExcludedInclusive(cursorPos)) { + if (c == '[') { + if (hasUnmatchedCloserAhead(after, '[', ']')) { + setText(before + c + after, true); + selection.reset(before.length() + 1); + scrollToCursor(); + autocompleteManager.onCharTyped(c, text, cursorPos); + return true; + } + setText(before + "[]" + after, true); + selection.reset(before.length() + 1); + scrollToCursor(); + // Notify autocomplete of the character + autocompleteManager.onCharTyped(c, text, cursorPos); + return true; + } + if (c == '(') { + if (hasUnmatchedCloserAhead(after, '(', ')')) { + setText(before + c + after, true); + selection.reset(before.length() + 1); + scrollToCursor(); + autocompleteManager.onCharTyped(c, text, cursorPos); + return true; + } + setText(before + "()" + after, true); + selection.reset(before.length() + 1); + scrollToCursor(); + // Notify autocomplete of the character + autocompleteManager.onCharTyped(c, text, cursorPos); + return true; + } + if (c == '{') { + if (hasUnmatchedCloserAhead(after, '{', '}')) { + setText(before + c + after, true); + selection.reset(before.length() + 1); + scrollToCursor(); + autocompleteManager.onCharTyped(c, text, cursorPos); + return true; + } + } } - if (c == '\'') { - setText(before + "''" + after); - selection.reset(before.length() + 1); - scrollToCursor(); - return true; - } - if (c == '[') { - setText(before + "[]" + after); - selection.reset(before.length() + 1); - scrollToCursor(); - return true; - } - if (c == '(') { - setText(before + "()" + after); - selection.reset(before.length() + 1); - scrollToCursor(); - return true; - } - // Default insertion for printable characters: insert at caret (replacing selection) addText(Character.toString(c)); scrollToCursor(); + // Notify autocomplete of the character + autocompleteManager.onCharTyped(c, text, cursorPos); return true; } return false; } + private boolean isLikelyClosingQuote(String before, char quote) { + if (before == null || before.isEmpty()) { + return false; + } + int lineStart = before.lastIndexOf('\n'); + int start = lineStart == -1 ? 0 : lineStart + 1; + int count = 0; + for (int i = start; i < before.length(); i++) { + if (before.charAt(i) == quote && !isEscaped(before, i)) { + count++; + } + } + return (count % 2) == 1; + } + + private boolean isEscaped(String s, int index) { + int backslashes = 0; + for (int i = index - 1; i >= 0 && s.charAt(i) == '\\'; i--) { + backslashes++; + } + return (backslashes % 2) == 1; + } + + private boolean hasUnmatchedCloserAhead(String after, char opener, char closer) { + int balance = 0; + int len = after.length(); + for (int idx = 0; idx < len; idx++) { + char ch = after.charAt(idx); + if (ch == '\n') break; + // Bail out at string / comment boundaries to avoid false matches + if (ch == '"' || ch == '\'') return false; + if (ch == '/' && idx + 1 < len) { + char next = after.charAt(idx + 1); + if (next == '/' || next == '*') return false; + } + if (ch == opener) { + balance++; + } else if (ch == closer) { + if (balance == 0) return true; + balance--; + } + } + return false; + } + + private String getLogicalLineIndentAt(int pos) { + if (text == null || text.isEmpty()) { + return ""; + } + int safePos = Math.max(0, Math.min(pos, text.length())); + int lineStart = text.lastIndexOf('\n', Math.max(0, safePos - 1)) + 1; + int p = lineStart; + while (p < text.length()) { + char ch = text.charAt(p); + if (ch == ' ' || ch == '\t') { + p++; + } else { + break; + } + } + return text.substring(lineStart, p); + } + private boolean isShiftKeyDown() { return Keyboard.isKeyDown(42) || Keyboard.isKeyDown(54); } // ==================== COMMENT TOGGLING ==================== // Uses CommentHandler helper for comment operations - + private void toggleCommentSelection() { CommentHandler.SelectionToggleResult result = CommentHandler.toggleCommentSelection( - text, container.lines, selection.getStartSelection(), selection.getEndSelection()); + text, container.lines, selection.getStartSelection(), selection.getEndSelection()); setText(result.newText); selection.setStartSelection(result.newStartSelection); selection.setEndSelection(result.newEndSelection); @@ -1827,15 +2726,17 @@ public class GuiScriptTextArea extends GuiNpcTextField { private void toggleCommentLineAtCursor() { CommentHandler.SingleLineToggleResult result = CommentHandler.toggleCommentAtCursor( - text, container.lines, selection.getCursorPosition()); + text, container.lines, selection.getCursorPosition()); setText(result.newText); setCursor(result.newCursorPosition, false); } - - public boolean closeOnEsc() { - return !KEYS_OVERLAY.isVisible() && !searchBar.isVisible() && !goToLineDialog.isVisible() && !renameHandler.isActive(); + + public boolean closeOnEsc(){ + return !KEYS_OVERLAY.isVisible() && !searchBar.isVisible() && !goToLineDialog.isVisible() + && !renameHandler.isActive() && !autocompleteManager.isVisible() + && !(hoverState.isTooltipVisible() && (hoverState.hasOverriddenPosition() || hoverState.hasOverriddenSize())); } - + // ==================== KEYBOARD MODIFIERS ==================== private boolean isAltKeyDown() { @@ -1883,7 +2784,7 @@ public class GuiScriptTextArea extends GuiNpcTextField { return IndentHelper.getAutoIndentForEnter(currentLine.text, selection.getCursorPosition() - currentLine.start); } // ==================== TEXT FORMATTING ==================== - + private int getTabSize() { return IndentHelper.TAB_SIZE; } @@ -1899,7 +2800,7 @@ public class GuiScriptTextArea extends GuiNpcTextField { setText(result.text); selection.reset(Math.max(0, Math.min(result.cursorPosition, this.text.length()))); } - + // ==================== TAB HANDLING ==================== private void handleTab() { @@ -1997,7 +2898,7 @@ public class GuiScriptTextArea extends GuiNpcTextField { } } } - + // ==================== CURSOR MANAGEMENT ==================== private void setCursor(int i, boolean select) { @@ -2006,7 +2907,7 @@ public class GuiScriptTextArea extends GuiNpcTextField { private void addText(String s) { int insertPos = selection.getStartSelection(); - this.setText(this.getSelectionBeforeText() + s + this.getSelectionAfterText()); + this.setText(this.getSelectionBeforeText() + s + this.getSelectionAfterText(), true); // Use atomic undo for typing selection.afterTextInsert(insertPos + s.length()); } @@ -2025,32 +2926,121 @@ public class GuiScriptTextArea extends GuiNpcTextField { public String getSelectionAfterText() { return selection.getTextAfter(text); } - + // ==================== MOUSE HANDLING ==================== public void mouseClicked(int xMouse, int yMouse, int mouseButton) { + // HIGHEST PRIORITY: tooltip panel absorbs all clicks — no click-through to panels beneath it + if (hoverState.isTooltipVisible() && hoverState.isMouseOverTooltipPanel(xMouse, yMouse)) { + if (mouseButton == 0) { + if (hoverState.isMouseOverResizeHandle(xMouse, yMouse)) { + hoverState.startTooltipResize(xMouse, yMouse); + } else if (hoverState.isMouseOverScrollbarThumb(xMouse, yMouse)) { + hoverState.startScrollbarDrag(yMouse); + } else { + hoverState.startTooltipDrag(xMouse, yMouse); + } + } + return; // consume — nothing below receives this click + } + // M1 outside a dragged/resized tooltip — dismiss it and fall through to editor + if (mouseButton == 0 && (hoverState.hasOverriddenPosition() || hoverState.hasOverriddenSize()) + && !hoverState.isMouseOverTooltipPanel(xMouse, yMouse)) { + hoverState.clearHover(); + } + // Check autocomplete menu clicks first + if (autocompleteManager.isVisible() && autocompleteManager.mouseClicked(xMouse, yMouse, mouseButton)) { + return; + } + + // Dismiss autocomplete if clicking elsewhere + if (autocompleteManager.isVisible()) { + autocompleteManager.dismiss(); + } + + if (parent != null && parent.fullscreenButton.mouseClicked(xMouse, yMouse, mouseButton)) + return; + + // Check go to line dialog clicks first if (goToLineDialog.isVisible() && goToLineDialog.mouseClicked(xMouse, yMouse, mouseButton)) { return; } - + // Check search bar clicks first if (searchBar.isVisible() && searchBar.mouseClicked(xMouse, yMouse, mouseButton)) { return; } - + // If search bar is visible but click was outside it, unfocus the search bar if (searchBar.isVisible()) { searchBar.unfocus(); } - + // Let the overlay consume clicks (it returns true when it handled the event) if (KEYS_OVERLAY.mouseClicked(xMouse, yMouse, mouseButton)) return; - + // Determine whether click occurred inside the text area bounds this.active = xMouse >= this.x && xMouse < this.x + this.width && yMouse >= this.y && yMouse < this.y + this.height; if (this.active) { + // Ctrl+Click: Go to definition + if (mouseButton == 0 && isCtrlKeyDown()) { + Object[] tokenInfo = getTokenAtScreenPosition(xMouse, yMouse); + if (tokenInfo != null) { + Token token = (Token) tokenInfo[0]; + int targetOffset = -1; + + // Check if token has method info with declaration + if (token.getMethodInfo() != null) { + MethodInfo methodInfo = token.getMethodInfo(); + if (methodInfo.getNameOffset() >= 0) { + targetOffset = methodInfo.getNameOffset(); + } + } + // Check if token has method call info with resolved declaration + else if (token.getMethodCallInfo() != null) { + MethodCallInfo callInfo = token.getMethodCallInfo(); + MethodInfo resolvedMethod = callInfo.getResolvedMethod(); + if (resolvedMethod != null && resolvedMethod.getNameOffset() >= 0) { + targetOffset = resolvedMethod.getNameOffset(); + } + } + // Check if token has field info with declaration + else if (token.getFieldInfo() != null) { + FieldInfo fieldInfo = token.getFieldInfo(); + if (fieldInfo.getDeclarationOffset() >= 0) { + targetOffset = fieldInfo.getDeclarationOffset(); + } + } + // Check if token has field access info with resolved declaration + else if (token.getFieldAccessInfo() != null) { + FieldAccessInfo accessInfo = token.getFieldAccessInfo(); + FieldInfo resolvedField = accessInfo.getResolvedField(); + if (resolvedField != null && resolvedField.getDeclarationOffset() >= 0) { + targetOffset = resolvedField.getDeclarationOffset(); + } + } + // Check if token is a script-defined type + else if (token.getTypeInfo() != null && token.getTypeInfo() instanceof ScriptTypeInfo) { + ScriptTypeInfo scriptType = + (ScriptTypeInfo) token.getTypeInfo(); + if (scriptType.getDeclarationOffset() >= 0) { + targetOffset = scriptType.getDeclarationOffset(); + } + } + + // Jump to definition if found + if (targetOffset >= 0) { + selection.reset(targetOffset); + scrollToCursor(); + this.clicked = false; + activeTextfield = this; + return; // Consume the event + } + } + } + // Compute logical click position in text int clickPos = this.getSelectionPos(xMouse, yMouse); @@ -2078,7 +3068,7 @@ public class GuiScriptTextArea extends GuiNpcTextField { if (this.clicked && getPaddedLineCount() * this.container.lineHeight > this.height && xMouse > this.x + this.width - 8) { // We consumed the mouse-down as a scrollbar drag start this.clicked = false; - scroll.startScrollbarDrag(yMouse, this.y, this.height, getPaddedLineCount()); + scroll.startScrollbarDrag(yMouse,this.y,this.height, getPaddedLineCount()); } else { // Handle double/triple click selection counting if (time - this.lastClicked < 300L) { @@ -2108,6 +3098,29 @@ public class GuiScriptTextArea extends GuiNpcTextField { this.lastClicked = time; activeTextfield = this; + + // Click-to-pin handling: if enabled, clicking a token will pin/unpin its tooltip + if (mouseButton == 0 && hoverState.isClickToPinEnabled()) { + Object[] tokenInfo = getTokenAtScreenPosition(xMouse, yMouse); + if (tokenInfo != null) { + Token clickedToken = (Token) tokenInfo[0]; + int tokenScreenX = (Integer) tokenInfo[1]; + int tokenScreenY = (Integer) tokenInfo[2]; + int tokenWidth = (Integer) tokenInfo[3]; + + // If already pinned on same token, unpin; otherwise pin this token + if (hoverState.isPinned() && hoverState.getHoveredToken() == clickedToken) { + hoverState.unpin(); + } else { + hoverState.pinToken(clickedToken, tokenScreenX, tokenScreenY, tokenWidth); + } + } else { + // Clicked outside any token -> unpin any pinned tooltip + if (hoverState.isPinned()) { + hoverState.unpin(); + } + } + } } } @@ -2122,10 +3135,20 @@ public class GuiScriptTextArea extends GuiNpcTextField { renameHandler.updateCursor(); ++this.cursorCounter; } - + // ==================== TEXT MANAGEMENT ==================== public void setText(String text) { + setText(text, false); + } + + /** + * Set text with optional atomic undo support. + * + * @param text The new text content + * @param allowAtomic If true, allows grouping consecutive typing into single undo steps + */ + private void setText(String text, boolean allowAtomic) { if (text == null) { return; } @@ -2139,19 +3162,53 @@ public class GuiScriptTextArea extends GuiNpcTextField { this.listener.textUpdate(text); } - if (!this.undoing) { + // Atomic undo logic: group consecutive typing into word-based undo steps + if (!this.undoing && allowAtomic && !undoList.isEmpty()) { + long now = System.currentTimeMillis(); + int cursorPos = selection.getCursorPosition(); + + // Check if we should merge with the previous undo entry + boolean shouldMerge = + (now - lastTypingTime < 2000) && // Within 2 seconds + Math.abs(cursorPos - lastTypingPos) <= 1; // Contiguous edit + + // If typing a space or newline, break the undo group + if (shouldMerge && text.length() > 0 && cursorPos > 0 && cursorPos <= text.length()) { + char lastChar = text.charAt(cursorPos - 1); + if (Character.isWhitespace(lastChar)) { + shouldMerge = false; + } + } + + if (shouldMerge) { + // Don't add a new undo entry - just update the text + // The existing undo entry will remain unchanged + } else { + // Add new undo entry + this.undoList.add(new GuiScriptTextArea.UndoData(this.text, selection.getCursorPosition())); + this.redoList.clear(); + } + + lastTypingTime = now; + lastTypingPos = cursorPos; + } else if (!this.undoing) { + // Normal undo entry (non-atomic) this.undoList.add(new GuiScriptTextArea.UndoData(this.text, selection.getCursorPosition())); this.redoList.clear(); + + // Reset atomic undo tracking + lastTypingTime = System.currentTimeMillis(); + lastTypingPos = selection.getCursorPosition(); } this.text = text; //this.container = new TextContainer(text); if (this.container == null) - this.container = new JavaTextContainer(text); + this.container = new ScriptTextContainer(text); this.container.init(text, this.width, this.height); - if (this.enableCodeHighlighting) + if (this.enableCodeHighlighting) this.container.formatCodeText(); // Ensure scroll state stays in bounds after text change @@ -2163,6 +3220,9 @@ public class GuiScriptTextArea extends GuiNpcTextField { // Consider text changes user activity to pause caret blinking briefly selection.markActivity(); searchBar.updateMatches(); + + // Update autocomplete manager with current container + autocompleteManager.setContainer(this.container); } } @@ -2183,6 +3243,26 @@ public class GuiScriptTextArea extends GuiNpcTextField { this.enableCodeHighlighting = true; this.container.formatCodeText(); } + + /** + * Set the scripting language for syntax highlighting and type inference. + * @param language The language name (e.g., "ECMAScript", "Groovy") + */ + public void setLanguage(String language) { + if (this.container != null) { + this.container.setLanguage(language); + if (this.enableCodeHighlighting) { + this.container.formatCodeText(); + } + } + } + + /** + * Get the current scripting language. + */ + public String getLanguage() { + return this.container != null ? this.container.getLanguage() : "ECMAScript"; + } /** * Set the script context (NPC, PLAYER, BLOCK, ITEM, etc.). @@ -2192,7 +3272,7 @@ public class GuiScriptTextArea extends GuiNpcTextField { */ public void setScriptContext(ScriptContext context) { if (this.container != null) { - // this.container.setScriptContext(context); + this.container.setScriptContext(context); } } @@ -2202,8 +3282,23 @@ public class GuiScriptTextArea extends GuiNpcTextField { * @return The script context (NPC, PLAYER, BLOCK, ITEM, etc.) */ public ScriptContext getScriptContext() { - // return this.container != null ? this.container.getScriptContext() : ScriptContext.GLOBAL; - return ScriptContext.GLOBAL; + return this.container != null ? this.container.getScriptContext() : ScriptContext.GLOBAL; + } + + public ScriptTextContainer getContainer() { + return this.container; + } + + /** + * Add implicit imports that should be resolved without explicit import statements. + * Used for JaninoScript default imports and hook parameter types. + * + * @param patterns Array of import patterns to add (wildcard packages like "noppes.npcs.api.*" or FQ class names) + */ + public void addImplicitImports(String... patterns) { + if (this.container != null) { + this.container.addImplicitImports(patterns); + } } public void setListener(ITextChangeListener listener) { @@ -2213,7 +3308,164 @@ public class GuiScriptTextArea extends GuiNpcTextField { private void clampSelectionBounds() { selection.clamp(text != null ? text.length() : 0); } + + // ==================== AUTOCOMPLETE VISIBILITY ==================== + + /** + * Check if a click position is within the bounds of the autocomplete menu. + * Returns false if autocomplete is not visible. + */ + public boolean isPointOnAutocompleteMenu(int mouseX, int mouseY) { + if (autocompleteManager == null || !autocompleteManager.isVisible()) { + return false; + } + + + AutocompleteMenu menu = autocompleteManager.getMenu(); + if (menu == null) { + return false; + } + + int menuX = menu.getX(); + int menuY = menu.getY(); + int menuWidth = menu.getWidth(); + int menuHeight = menu.getHeight(); + + return mouseX >= menuX && mouseX <= menuX + menuWidth && + mouseY >= menuY && mouseY <= menuY + menuHeight; + } + + // ==================== AUTO-IMPORT ==================== + + /** + * Add an import statement and sort all imports. + */ + private void addAndSortImport(String importPath) { + String currentText = this.text; + int savedCursorPos = selection.getCursorPosition(); + + // Find all existing imports + java.util.regex.Pattern importPattern = java.util.regex.Pattern.compile( + "(?m)^\\s*import\\s+(?:static\\s+)?([A-Za-z_][A-Za-z0-9_]*(?:\\s*\\.\\s*[A-Za-z_*][A-Za-z0-9_]*)*)\\s*;\\s*$" + ); + java.util.regex.Matcher matcher = importPattern.matcher(currentText); + + java.util.List imports = new java.util.ArrayList<>(); + int firstImportStart = -1; + int lastImportEnd = -1; + + while (matcher.find()) { + String importStatement = matcher.group(0); + String importPathFound = matcher.group(1).replaceAll("\\s+", ""); + + if (firstImportStart == -1) { + firstImportStart = matcher.start(); + } + lastImportEnd = matcher.end(); + + // Skip if this is the import we're trying to add + if (!importPathFound.equals(importPath)) { + imports.add(new ImportEntry(importPathFound, importStatement.trim())); + } + } + + // Add the new import + imports.add(new ImportEntry(importPath, "import " + importPath + ";")); + + // Sort imports + java.util.Collections.sort(imports, new java.util.Comparator() { + @Override + public int compare(ImportEntry a, ImportEntry b) { + // Sort order: java.*, javax.*, then others alphabetically + boolean aIsJava = a.path.startsWith("java."); + boolean aIsJavax = a.path.startsWith("javax."); + boolean bIsJava = b.path.startsWith("java."); + boolean bIsJavax = b.path.startsWith("javax."); + + if (aIsJava && !bIsJava) return -1; + if (!aIsJava && bIsJava) return 1; + if (aIsJavax && !bIsJavax && !bIsJava) return -1; + if (!aIsJavax && bIsJavax && !aIsJava) return 1; + + return a.path.compareTo(b.path); + } + }); + + // Build the new import block + StringBuilder importBlock = new StringBuilder(); + String prevPackage = ""; + for (ImportEntry entry : imports) { + // Add blank line between different top-level packages + String topPackage = entry.path.contains(".") ? + entry.path.substring(0, entry.path.indexOf('.')) : entry.path; + if (!prevPackage.isEmpty() && !topPackage.equals(prevPackage)) { + importBlock.append("\n"); + } + importBlock.append(entry.statement).append("\n"); + prevPackage = topPackage; + } + + // Determine where to insert/replace imports + String newText; + int cursorAdjustment = 0; + + if (firstImportStart != -1) { + // Replace existing import block + String before = currentText.substring(0, firstImportStart); + String after = currentText.substring(lastImportEnd); + newText = before + importBlock.toString() + after; + + // Adjust cursor if it's after the import block + int newImportEnd = firstImportStart + importBlock.length(); + if (savedCursorPos >= lastImportEnd) { + cursorAdjustment = newImportEnd - lastImportEnd; + } + } else { + // No existing imports - add at top after package statement (if any) + java.util.regex.Pattern packagePattern = java.util.regex.Pattern.compile( + "(?m)^\\s*package\\s+[A-Za-z_][A-Za-z0-9_.]*\\s*;\\s*$" + ); + java.util.regex.Matcher pkgMatcher = packagePattern.matcher(currentText); + + int insertPos = 0; + if (pkgMatcher.find()) { + insertPos = pkgMatcher.end(); + // Add blank line after package + newText = currentText.substring(0, insertPos) + "\n" + + importBlock.toString() + "\n" + currentText.substring(insertPos); + cursorAdjustment = importBlock.length() + 2; // +2 for the newlines + } else { + // Insert at very beginning + newText = importBlock.toString() + "\n" + currentText; + cursorAdjustment = importBlock.length() + 1; + } + } + + // Apply the changes + setText(newText); + selection.reset(savedCursorPos + cursorAdjustment); + scrollToCursor(); + } + public void formatCodeText() { + if (this.enableCodeHighlighting && this.container != null) { + this.container.formatCodeText(); + } + } + + /** + * Helper class for tracking imports during sorting. + */ + private static class ImportEntry { + String path; + String statement; + + ImportEntry(String path, String statement) { + this.path = path; + this.statement = statement; + } + } + // ==================== INNER CLASSES ==================== public static class UndoData { diff --git a/src/main/java/noppes/npcs/client/gui/util/GuiScriptTextArea1.java b/src/main/java/noppes/npcs/client/gui/util/GuiScriptTextArea1.java new file mode 100644 index 000000000..60e5a38a0 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/GuiScriptTextArea1.java @@ -0,0 +1,2186 @@ +package noppes.npcs.client.gui.util; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.GuiScreen; +import net.minecraft.client.gui.ScaledResolution; +import net.minecraft.util.ChatAllowedCharacters; +import noppes.npcs.NoppesStringUtils; +import noppes.npcs.client.ClientProxy; +import noppes.npcs.client.gui.script.GuiScriptInterface; +import noppes.npcs.client.gui.util.key.OverlayKeyPresetViewer; +import noppes.npcs.client.gui.util.script.*; +import noppes.npcs.client.gui.util.script.JavaTextContainer.LineData; +import noppes.npcs.client.gui.util.script.interpreter.ScriptLine; +import noppes.npcs.client.gui.util.script.interpreter.ScriptTextContainer; +import noppes.npcs.client.key.impl.ScriptEditorKeys; +import noppes.npcs.util.ValueUtil; +import org.lwjgl.input.Keyboard; +import org.lwjgl.input.Mouse; +import org.lwjgl.opengl.GL11; + +import java.util.ArrayList; +import java.util.List; +import java.util.function.Supplier; +import java.util.regex.Matcher; + +import static net.minecraft.client.gui.GuiScreen.isCtrlKeyDown; + +/** + * Script text editor component with syntax highlighting, bracket matching, + * smooth scrolling, and IDE-like features. + * + * Helper classes used: + * - ScrollState: smooth scroll animation and state management + * - SelectionState: cursor position and text selection management + * - BracketMatcher: bracket matching and brace span computation + * - IndentHelper: indentation utilities and text formatting + * - CommentHandler: line comment toggling + * - CursorNavigation: cursor movement logic + */ +public class GuiScriptTextArea1 extends GuiNpcTextField { + + // ==================== DIMENSIONS & POSITION ==================== + public int x; + public int y; + + // ==================== STATE FLAGS ==================== + public boolean active = false; + public boolean enabled = true; + public boolean visible = true; + public boolean clicked = false; + public boolean doubleClicked = false; + public boolean tripleClicked = false; + private int clickCount = 0; + private long lastClicked = 0L; + + // ==================== TEXT & CONTAINER ==================== + public String text = null; + public String highlightedWord; + private ScriptTextContainer container = null; + private boolean enableCodeHighlighting = false; + // Extra empty lines to allow padding at the bottom of the editor viewport + private int bottomPaddingLines = 6; + + // Search bar layout tracking to allow idempotent/resilient resizing + private int searchBaseY = 0; + private int searchBaseHeight = 0; + private int searchAppliedOffset = 0; + private boolean searchBaseInitialized = false; + + private int getPaddedLineCount() { + if (container == null) return 0; + // Only add bottom padding when the content is already scrollable. This avoids + // introducing a scrollbar when there's nothing to scroll for. + if (container.linesCount > container.visibleLines - bottomPaddingLines) { + return Math.max(0, container.linesCount + bottomPaddingLines); + } else { + return container.linesCount; + } + } + + // ==================== HELPER CLASS INSTANCES ==================== + private final ScrollState scroll = new ScrollState(); + private final SelectionState selection = new SelectionState(); + + // ==================== UI COMPONENTS ==================== + private int cursorCounter; + private ITextChangeListener listener; + private static int LINE_NUMBER_GUTTER_WIDTH = 25; + + // ==================== UNDO/REDO ==================== + public List undoList = new ArrayList<>(); + public List redoList = new ArrayList<>(); + public boolean undoing = false; + + // ==================== KEYS ==================== + public static final ScriptEditorKeys KEYS = new ScriptEditorKeys(); + public OverlayKeyPresetViewer KEYS_OVERLAY = new OverlayKeyPresetViewer(KEYS); + + // ==================== SEARCH/REPLACE ==================== + public static final SearchReplaceBar searchBar = new SearchReplaceBar(); + + // ==================== GO TO LINE ==================== + private final GoToLineDialog goToLineDialog = new GoToLineDialog(); + + // ==================== RENAME REFACTOR ==================== + private final RenameRefactorHandler renameHandler = new RenameRefactorHandler(); + + // ==================== CONSTRUCTOR ==================== + + public GuiScriptTextArea1(GuiScreen guiScreen, int id, int x, int y, int width, int height, String text) { + super(id, guiScreen, x, y, width, height, null); + init(x, y, width, height, text); + } + + public void init(int x, int y, int width, int height, String text) { + this.x = xPosition = x; + this.y = yPosition = y; + this.width = width; + this.height = height; + this.undoing = true; + this.setText(text); + this.undoing = false; + setCallbacks(); + // Reset search-base tracking whenever the editor is (re)initialized + this.searchBaseY = 0; + this.searchBaseHeight = 0; + this.searchAppliedOffset = 0; + this.searchBaseInitialized = false; + + KEYS_OVERLAY.openOnClick = true; + initGui(); + initializeKeyBindings(); + } + public void initGui() { + int endX = x + width, endY = y + height; + int xOffset = hasVerticalScrollbar() ? -8 : -2; + KEYS_OVERLAY.scale = 0.75f; + KEYS_OVERLAY.borderCol1 = KEYS_OVERLAY.borderCol2 = 0xFF3c3c3c; + int overlayWidth = 160; + KEYS_OVERLAY.initGui(x + (width - overlayWidth) / 2 + 5, y + height / 10, overlayWidth, + height - height / 5 - 10); + + KEYS_OVERLAY.viewButton.scale = 0.45f; + KEYS_OVERLAY.viewButton.initGui(endX + xOffset, endY - 26); + + // Initialize search bar (preserves state across initGui calls) + searchBar.initGui(x, y, width); + if (searchBar.isVisible()) { // If open + // Shift viewport down again using the bar's current height + searchBar.callback.resizeEditor(true, searchBar.getTotalHeight()); + if (!active) // Focus search if opening another script tab & bar is open + searchBar.focus(false); + } + + // Initialize Go To Line dialog + goToLineDialog.initGui(x, y, width); + } + + public void setCallbacks() { + searchBar.setCallback(new SearchReplaceBar.SearchCallback() { + @Override + public String getText() { + return GuiScriptTextArea1.this.text; + } + + public String getHighlightedWord() { + return GuiScriptTextArea1.this.highlightedWord; + } + + @Override + public int getSelectionStart() { + return GuiScriptTextArea1.this.selection.getStartSelection(); + } + + @Override + public int getSelectionEnd() { + return GuiScriptTextArea1.this.selection.getEndSelection(); + } + + @Override + public void setText(String newText) { + GuiScriptTextArea1.this.setText(newText); + } + + @Override + public void scrollToPosition(int position) { + // Find line containing position and scroll to it + if (container == null || container.lines == null) + return; + + // Calculate offset to account for search bar height + int searchBarOffset = searchBar.getTotalHeight(); + int effectiveHeight = GuiScriptTextArea1.this.height - searchBarOffset; + int visibleLines = effectiveHeight / container.lineHeight; + // Calculate how many lines the search bar covers + int linesHiddenBySRB = searchBarOffset > 0 ? (int) Math.ceil( + (double) searchBarOffset / container.lineHeight) : 0; + + for (int i = 0; i < container.lines.size(); i++) { + LineData ld = container.lines.get(i); + if (position >= ld.start && position < ld.end) { + int visible = Math.max(1, visibleLines); + int effectiveVisible = Math.max(1, visible - bottomPaddingLines); + int maxScroll = Math.max(0, getPaddedLineCount() - visible); + int targetLine = i; + + // If search bar is visible and would hide this line, scroll down so it's visible + // The target line should appear below the search bar, not under it + int currentScroll = scroll.getScrolledLine(); + int firstVisibleLine = currentScroll + linesHiddenBySRB; + + if (searchBarOffset > 0 && targetLine < firstVisibleLine) { + // Force scroll so target line appears just below the search bar + scroll.setTargetScroll(Math.max(0, targetLine - linesHiddenBySRB), maxScroll); + } else { + scroll.scrollToLine(targetLine, effectiveVisible, maxScroll); + } + break; + } + } + } + + @Override + public void setSelection(int start, int end) { + selection.setSelection(start, end); + selection.setCursorPositionDirect(end); + } + + @Override + public int getGutterWidth() { + return LINE_NUMBER_GUTTER_WIDTH; + } + + @Override + public void unfocusMainEditor() { + // Save position but unfocus + active = false; + } + + @Override + public void focusMainEditor() { + active = true; + searchBar.resetSelection(); + } + + @Override + public void onMatchesUpdated() { + // Called when matches change - could be used for UI updates + } + + // Robust resize: use base editor bounds and apply the requested offset + public void resizeEditor(boolean open, int barHeight) { + int desiredOffset = Math.max(0, barHeight); + // Initialize base values if not set + if (!searchBaseInitialized) { + searchBaseY = GuiScriptTextArea1.this.y; + searchBaseHeight = GuiScriptTextArea1.this.height; + searchAppliedOffset = 0; + searchBaseInitialized = true; + } + + int targetOffset = open ? desiredOffset : 0; + if (targetOffset == searchAppliedOffset) + return; // already in desired state + + // Compute new bounds from base values (idempotent) + int newY = searchBaseY + targetOffset; + int newHeight = Math.max(12, searchBaseHeight - targetOffset); + + GuiScriptTextArea1.this.y = newY; + GuiScriptTextArea1.this.height = newHeight; + searchAppliedOffset = targetOffset; + + if (container != null) + container.visibleLines = Math.max(GuiScriptTextArea1.this.height / container.lineHeight - 1, 1); + } + }); + // Initialize Go To Line dialog with callback + goToLineDialog.setCallback(new GoToLineDialog.GoToLineCallback() { + @Override + public int getLineCount() { + return container != null ? container.linesCount : 0; + } + + @Override + public int getColumnCount(int lineIndex) { + if (container == null || container.lines == null || lineIndex < 0 || lineIndex >= container.lines.size()) { + return 0; + } + LineData ld = container.lines.get(lineIndex); + return ld.end - ld.start; + } + + @Override + public void goToLineColumn(int line, int column) { + if (container == null || container.lines == null) + return; + + // Convert 1-indexed line to 0-indexed + int lineIdx = line - 1; + if (lineIdx < 0 || lineIdx >= container.lines.size()) + return; + + LineData ld = container.lines.get(lineIdx); + int lineLength = ld.end - ld.start; + + // Convert 1-indexed column to 0-indexed, clamp to line length + // lineLength - 1 because the line's end is the start of the next line + int col = Math.max(0, Math.min(column - 1, lineLength - 1)); + int position = ld.start + col; + + // Set cursor position + selection.reset(position); + + // Scroll to make the line visible + int visible = GuiScriptTextArea1.this.height / (container != null ? container.lineHeight : 12); + int effectiveVisible = Math.max(1, visible - bottomPaddingLines); + int maxScroll = Math.max(0, getPaddedLineCount() - visible); + scroll.scrollToLine(lineIdx, effectiveVisible, maxScroll); + } + + @Override + public void unfocusMainEditor() { + // Save position but unfocus + active = false; + } + + @Override + public void focusMainEditor() { + active = true; + selection.markActivity(); + } + + @Override + public void onDialogClose() { + active = true; + selection.markActivity(); + } + }); + + // Initialize Rename Refactor handler with callback + renameHandler.setCallback(new RenameRefactorHandler.RenameCallback() { + @Override + public String getText() { + return GuiScriptTextArea1.this.text; + } + + @Override + public void setText(String newText) { + GuiScriptTextArea1.this.setText(newText); + } + + @Override + public List getLines() { + return container != null ? container.lines : new ArrayList<>(); + } + + @Override + public int getCursorPosition() { + return selection.getCursorPosition(); + } + + public SelectionState getSelectionState() { + return selection; + } + + @Override + public void setCursorPosition(int pos) { + selection.reset(pos); + } + + @Override + public void unfocusMainEditor() { + active = false; + } + + @Override + public void focusMainEditor() { + active = true; + selection.markActivity(); + } + + @Override + public int getGutterWidth() { + return LINE_NUMBER_GUTTER_WIDTH; + } + + @Override + public int getLineHeight() { + return container != null ? container.lineHeight : 12; + } + + @Override + public int getScrolledLine() { + return scroll.getScrolledLine(); + } + + @Override + public double getFractionalOffset() { + return scroll.getFractionalOffset(); + } + + @Override + public void scrollToPosition(int pos) { + if (container == null || container.lines == null) + return; + for (int i = 0; i < container.lines.size(); i++) { + LineData ld = container.lines.get(i); + if (pos >= ld.start && pos < ld.end) { + int visible = Math.max(1, container.visibleLines); + int effectiveVisible = Math.max(1, visible - bottomPaddingLines); + int maxScroll = Math.max(0, getPaddedLineCount() - visible); + scroll.scrollToLine(i, effectiveVisible, maxScroll); + break; + } + } + } + + @Override + public ScriptTextContainer getContainer() { + return container; + } + + @Override + public void setTextWithoutUndo(String newText) { + // Set text without creating an undo entry (for live rename preview) + boolean wasUndoing = undoing; + undoing = true; + setText(newText); + undoing = wasUndoing; + } + + @Override + public void pushUndoState(String textState, int cursor) { + // Push a specific text state to the undo list + if (!undoing) { + undoList.add(new UndoData(textState, cursor)); + redoList.clear(); + } + } + + @Override + public int getViewportWidth() { + return width - LINE_NUMBER_GUTTER_WIDTH - 8; // Account for gutter and scrollbar + } + }); + } + + public boolean fullscreen() { + return GuiScriptInterface.isFullscreen; + } + // ==================== RENDERING ==================== + public void drawTextBox(int xMouse, int yMouse) { + if (!visible) + return; + clampSelectionBounds(); + + // Dynamically calculate gutter width based on line count digits + if (container != null && container.linesCount > 0) { + int maxLineNum = container.linesCount; + String maxLineStr = String.valueOf(maxLineNum); + int digitWidth = ClientProxy.Font.width(maxLineStr); + LINE_NUMBER_GUTTER_WIDTH = digitWidth + 10; // 10px total padding (5px left + 5px right) + } + // Draw outer border around entire area + int offset = fullscreen() ? 2 : 1; + drawRect(x - offset, y - offset - searchBar.getTotalHeight(), x + width + offset, y + height + offset, + 0xffa0a0a0); + + int searchHeight = searchBar.getTotalHeight(); + + + // Draw line number gutter background + drawRect(x, y, x + LINE_NUMBER_GUTTER_WIDTH, y + height, 0xff000000); + // Draw text viewport background (starts after gutter) + drawRect(x + LINE_NUMBER_GUTTER_WIDTH, y, x + width, y + height, 0xff000000); + // Draw separator line between gutter and text area + drawRect(x + LINE_NUMBER_GUTTER_WIDTH-1, y, x + LINE_NUMBER_GUTTER_WIDTH, y + height, 0xff3c3f41); + + // Enable scissor test to clip drawing to the TEXT viewport rectangle (excludes gutter) + GL11.glEnable(GL11.GL_SCISSOR_TEST); + scissorViewport(); + + container.visibleLines = (height / container.lineHeight); + + int maxScroll = Math.max(0, getPaddedLineCount() - container.visibleLines); + + // Handle mouse wheel scroll + int wheelDelta = ((GuiNPCInterface) listener).mouseScroll = Mouse.getDWheel(); + if (listener instanceof GuiNPCInterface) { + ((GuiNPCInterface) listener).mouseScroll = wheelDelta; + boolean canScroll = !KEYS_OVERLAY.isVisible() || KEYS_OVERLAY.isVisible() && !KEYS_OVERLAY.aboveOverlay; + if (wheelDelta != 0 && canScroll) + scroll.applyWheelScroll(wheelDelta, maxScroll); + } + + // Handle scrollbar dragging (delegated to ScrollState) + if (scroll.isClickScrolling()) + scroll.handleClickScrolling(yMouse, x, y, height, container.visibleLines, getPaddedLineCount(), maxScroll); + + // Update scroll animation + scroll.initializeIfNeeded(scroll.getScrolledLine()); + scroll.update(maxScroll); + + // Handle click-dragging for selection + if (clicked) { + clicked = Mouse.isButtonDown(0); + int i = getSelectionPos(xMouse, yMouse); + if (i != selection.getCursorPosition()) { + if (doubleClicked || tripleClicked) { + selection.reset(selection.getCursorPosition()); + doubleClicked = false; + tripleClicked = false; + } + setCursor(i, true); + } + } else if (doubleClicked || tripleClicked) { + doubleClicked = false; + tripleClicked = false; + } + // y += searchHeight; + // height -= searchHeight; + // Calculate braces next to cursor to highlight + int startBracket = 0, endBracket = 0; + if (selection.getStartSelection() >= 0 && text != null && text.length() > 0 && + (selection.getEndSelection() - selection.getStartSelection() == 1 || !selection.hasSelection())) { + int[] span = BracketMatcher.findBracketSpanAt(text,selection.getStartSelection()); + if (span != null) { + startBracket = span[0]; + endBracket = span[1]; + } + } + + List list = new ArrayList<>(container.lines); + + // Build brace spans: {origDepth, open line, close line, adjustedDepth} + List braceSpans = BracketMatcher.computeBraceSpans(text, list); + // Always highlight unmatched braces (positions in text) + List unmatchedBraces = BracketMatcher.findUnmatchedBracePositions(text); + + // Determine which exact brace span (openLine/closeLine) to highlight indent guides for + int highlightedOpenLine = -1; + int highlightedCloseLine = -1; + if (startBracket != endBracket && startBracket >= 0) { + int bracketLineIdx = -1; + // Only consider curly braces for highlighting the indent guides + boolean isCurlyBracket = false; + char bc = text.charAt(startBracket); + if (text != null && startBracket >= 0 && startBracket < text.length()) { + if (bc == '{' || bc == '}') isCurlyBracket = true; + } + for (int li = 0; li < list.size(); li++) { + LineData ld = list.get(li); + if (startBracket >= ld.start && startBracket < ld.end) { + bracketLineIdx = li; + break; + } + } + if (bracketLineIdx >= 0 && isCurlyBracket) { + // Prefer a span that directly matches the bracket character's line: + // - if the bracket is an opening '{', prefer spans where openLine == bracketLineIdx + // - if the bracket is a closing '}', prefer spans where closeLine == bracketLineIdx + // If no exact match is found, fall back to the smallest enclosing span (innermost). + int bestSize = Integer.MAX_VALUE; + boolean foundExact = false; + char bracketChar = bc; // from earlier + for (int[] span : braceSpans) { + int openLine = span[1]; + int closeLine = span[2]; + if (bracketLineIdx >= openLine && bracketLineIdx <= closeLine) { + int size = closeLine - openLine; + boolean exactMatch = (bracketChar == '{' && openLine == bracketLineIdx) || (bracketChar == '}' && closeLine == bracketLineIdx); + if (exactMatch) { + // Prefer exact matches immediately (still choose smallest exact span) + if (!foundExact || size < bestSize) { + foundExact = true; + bestSize = size; + highlightedOpenLine = openLine; + highlightedCloseLine = closeLine; + } + } else if (!foundExact) { + // keep the smallest enclosing span as a fallback + if (size < bestSize) { + bestSize = size; + highlightedOpenLine = openLine; + highlightedCloseLine = closeLine; + } + } + } + } + } + } + + highlightedWord = null; + if (selection.hasSelection()) { + Matcher m = container.regexWord.matcher(text); + while (m.find()) { + if (m.start() == selection.getStartSelection() && m.end() == selection.getEndSelection()) { + highlightedWord = text.substring(selection.getStartSelection(), selection.getEndSelection()); + } + } + } + + // Apply fractional GL translate for sub-pixel smooth scrolling + double fracOffset = scroll.getFractionalOffset(); + float fracPixels = (float) (fracOffset * container.lineHeight); + GL11.glPushMatrix(); + GL11.glTranslatef(0.0f, -fracPixels, 0.0f); + + + // Expand render range by one line above/below so partially-visible lines are drawn + int renderStart = Math.max(0, scroll.getScrolledLine() - 1); + // Compute the last line index to render, including the last partially-visible line if any. + // Adds the fractional scroll offset (fracOffset * lineHeight) to ensure the bottom line is drawn + // when only part of it is visible in the viewport. + int renderEnd = (int) Math.min(list.size() - 1, + scroll.getScrolledLine() + container.visibleLines + fracPixels + 1); + + // Strings start drawing vertically this much into the line. + int stringYOffset = 2; + + // Render LINE GUTTER numbers + for (int i = renderStart; i <= renderEnd; i++) { + int posY = y + (i - scroll.getScrolledLine()) * container.lineHeight + stringYOffset; + String lineNum = String.valueOf(i + 1); + int lineNumWidth = ClientProxy.Font.width(lineNum); + int lineNumX = x + LINE_NUMBER_GUTTER_WIDTH - lineNumWidth - 5; // right-align with 5px padding + int lineNumY = posY + 1; + // Highlight current line number + int lineNumColor = 0xFF606366; + if (active && isEnabled()) { + for (int li = 0; li < list.size(); li++) { + LineData ld = list.get(li); + if (selection.getCursorPosition() >= ld.start && selection.getCursorPosition() < ld.end || (li == list.size() - 1 && selection.getCursorPosition() == text.length())) { + if (li == i) { + lineNumColor = 0xFFb9c7d6; + break; + } + } + } + } + ClientProxy.Font.drawString(lineNum, lineNumX, lineNumY, lineNumColor); + } + + // Render Viewport + for (int i = renderStart; i <= renderEnd; i++) { + LineData data = list.get(i); + ScriptLine scriptLine = container.getDocument().getLineAt(i); + String line = data.text; + int w = line.length(); + // Use integer Y relative to scrolledLine; fractional offset applied via GL translate + int posY = y + (i - scroll.getScrolledLine()) * container.lineHeight; + if (i >= renderStart && i <= renderEnd) { + //Highlight braces the cursor position is on + if (startBracket != endBracket) { + if (startBracket >= data.start && startBracket < data.end) { + int s = ClientProxy.Font.width(line.substring(0, startBracket - data.start)); + int e = ClientProxy.Font.width(line.substring(0, startBracket - data.start + 1)) + 1; + drawRect(x + LINE_NUMBER_GUTTER_WIDTH + 1 + s, posY, x + LINE_NUMBER_GUTTER_WIDTH + 1 + e, posY + container.lineHeight + 0, 0x9900cc00); + } + if (endBracket >= data.start && endBracket < data.end) { + int s = ClientProxy.Font.width(line.substring(0, endBracket - data.start)); + int e = ClientProxy.Font.width(line.substring(0, endBracket - data.start + 1)) + 1; + drawRect(x + LINE_NUMBER_GUTTER_WIDTH + 1 + s, posY, x + LINE_NUMBER_GUTTER_WIDTH + 1 + e, posY + container.lineHeight + 0, 0x9900cc00); + } + } + + // Highlight unmatched braces in this line (always red) + if (unmatchedBraces != null && !unmatchedBraces.isEmpty()) { + for (int ubPos : unmatchedBraces) { + if (ubPos >= data.start && ubPos < data.end) { + int rel = ubPos - data.start; + int s = ClientProxy.Font.width(line.substring(0, rel)); + int e = ClientProxy.Font.width(line.substring(0, rel + 1)) + 1; + drawRect(x + LINE_NUMBER_GUTTER_WIDTH + 1 + s, posY, x + LINE_NUMBER_GUTTER_WIDTH + 1 + e, posY + container.lineHeight, 0xffcc0000); + } + } + } + //Highlight words + if (highlightedWord != null) { + Matcher m = container.regexWord.matcher(line); + while (m.find()) { + if (line.substring(m.start(), m.end()).equals(highlightedWord)) { + int s = ClientProxy.Font.width(line.substring(0, m.start())); + int e = ClientProxy.Font.width(line.substring(0, m.end())) + 1; + drawRect(x + LINE_NUMBER_GUTTER_WIDTH + 1 + s, posY, x + LINE_NUMBER_GUTTER_WIDTH + 1 + e, posY + container.lineHeight, 0x99004c00); + } + } + } + + // Highlight search matches + if (searchBar.isVisible()) { + List searchMatches = searchBar.getMatches(); + int currentMatchIdx = searchBar.getCurrentMatchIndex(); + for (int mi = 0; mi < searchMatches.size(); mi++) { + int[] match = searchMatches.get(mi); + // Check if match overlaps with this line + if (match[1] > data.start && match[0] < data.end) { + int matchStart = Math.max(match[0] - data.start, 0); + int matchEnd = Math.min(match[1] - data.start, line.length()); + if (matchStart < matchEnd) { + int s = ClientProxy.Font.width(line.substring(0, matchStart)); + int e = ClientProxy.Font.width(line.substring(0, matchEnd)) + 1; + boolean isExcluded = searchBar.isMatchExcluded(mi); + // Current match gets brighter highlight, others get dimmer + int highlightColor = (mi == currentMatchIdx) ? 0xBB4488ff : 0x662266aa; + if (isExcluded) { + highlightColor = 0x33666666; // Dimmer for excluded matches + } + int highlightX = x + LINE_NUMBER_GUTTER_WIDTH + 1 + s; + int highlightEndX = x + LINE_NUMBER_GUTTER_WIDTH + 1 + e; + drawRect(highlightX, posY, highlightEndX, posY + container.lineHeight, highlightColor); + + // Draw strikethrough line for excluded matches + if (isExcluded) { + int strikeY = posY + container.lineHeight / 2; + drawRect(highlightX, strikeY, highlightEndX, strikeY + 1, 0xFFaa4444); + } + } + } + } + } + + // Highlight rename refactor occurrences + if (renameHandler.isActive()) { + List renameOccurrences = renameHandler.getOccurrences(); + for (int[] occ : renameOccurrences) { + // Check if occurrence overlaps with this line + if (occ[1] >= data.start && occ[0] <= data.end) { + int occStart = Math.max(occ[0] - data.start, 0); + int occEnd = Math.min(occ[1] - data.start, line.length()); + + // Handle empty word case - draw 1 pixel wide box + boolean isEmpty = (occ[0] == occ[1]); + + if (occStart <= occEnd) { // Changed from < to <= to handle empty case + int s = ClientProxy.Font.width(line.substring(0, occStart)); + int e = isEmpty ? s + 2 : ClientProxy.Font.width( + line.substring(0, occEnd)) + 1; // 2px wide for empty + int occX = x + LINE_NUMBER_GUTTER_WIDTH + s; + int occEndX = x + LINE_NUMBER_GUTTER_WIDTH + 2 + e; + boolean isPrimary = renameHandler.isPrimaryOccurrence(occ[0]); + + // Draw background highlight + int bgColor = isPrimary ? 0x55335577 : 0x33224466; + drawRect(occX, posY, occEndX, posY + container.lineHeight, bgColor); + + // Draw white border for primary occurrence (IntelliJ-like) + if (isPrimary) { + int borderColor = 0xDDFFFFFF; + //RED BG + drawRect(occX, posY, occEndX, posY + container.lineHeight, 0x33ff0000); + + // Top border + drawRect(occX, posY, occEndX, posY + 1, borderColor); + // Bottom border + drawRect(occX, posY + container.lineHeight - 1, occEndX, + posY + container.lineHeight, borderColor); + // Left border + drawRect(occX, posY, occX + 1, posY + container.lineHeight, borderColor); + // Right border + drawRect(occEndX - 1, posY, occEndX, posY + container.lineHeight, borderColor); + + // Draw cursor inside the primary occurrence + if (renameHandler.shouldShowCursor()) { + int cursorInWord = renameHandler.getCursorInWord(); + String currentWord = renameHandler.getCurrentWord(); + if (currentWord != null && cursorInWord >= 0 && cursorInWord <= currentWord.length()) { + String beforeCursor = currentWord.substring(0, + Math.min(cursorInWord, currentWord.length())); + int cursorX = occX + ClientProxy.Font.width(beforeCursor); + // drawRect(cursorX, posY + 1, cursorX + 1, posY + container.lineHeight - 1, + // 0xFFFFFFFF); + } + } + } + } + } + } + } + + // Highlight the current line (light gray) under any selection + if (active && isEnabled() && (selection.getCursorPosition() >= data.start && selection.getCursorPosition() < data.end || (i == list.size() - 1 && selection.getCursorPosition() == text.length()))) { + drawRect(x , posY, x + width - 1, posY + container.lineHeight, 0x22e0e0e0); + } + // Highlight selection + if (selection.hasSelection() && selection.getEndSelection() > data.start && selection.getStartSelection() <= data.end) { + if (selection.getStartSelection() < data.end) { + int s = ClientProxy.Font.width( + line.substring(0, Math.max(selection.getStartSelection() - data.start, 0))); + int e = ClientProxy.Font.width( + line.substring(0, Math.min(selection.getEndSelection() - data.start, w))) + 1; + drawRect(x + LINE_NUMBER_GUTTER_WIDTH + 1 + s, posY, x + LINE_NUMBER_GUTTER_WIDTH + 1 + e, posY + container.lineHeight, 0x992172ff); + } + } + + // Draw indent guides once per visible block based on brace spans + if (i == Math.max(0, scroll.getScrolledLine()) && !braceSpans.isEmpty()) { + int visStart = Math.max(0, scroll.getScrolledLine()); + int visEnd = Math.min(list.size() - 1, visStart + container.visibleLines - 0); + for (int[] span : braceSpans) { + int originalDepth = span[0]; + int openLine = span[1]; + int closeLine = span[2]; + int depth = span.length > 3 ? span[3] : originalDepth; + // Skip top-level (depth 1) using the original depth to avoid hiding nested guides when adjusted + if (originalDepth <= 1) + continue; + int startLine = openLine + 1; // start under the opening brace + int endLine = closeLine - 1; // stop before the closing brace + if (startLine > endLine) + continue; + if (endLine < visStart || startLine > visEnd) + continue; + + int drawStart = Math.max(startLine, visStart); + int drawEnd = Math.min(endLine, visEnd); + // Compute horizontal position: 4 spaces per indent level, minus a tiny left offset + int safeDepth = Math.max(1, depth); + int spaces = (safeDepth - 1) * 4; + StringBuilder sb = new StringBuilder(); + for (int k = 0; k < spaces; k++) + sb.append(' '); + int px = ClientProxy.Font.width(sb.toString()); + int gx = x + LINE_NUMBER_GUTTER_WIDTH + 4 + px - 2; // shift left ~2px for the IntelliJ feel + + boolean highlighted = (openLine == highlightedOpenLine && closeLine == highlightedCloseLine); + int guideColor = highlighted ? 0x9933cc00 : 0x33FFFFFF; + + int topY = y + (drawStart - scroll.getScrolledLine()) * container.lineHeight; + int bottomY = y + (endLine - scroll.getScrolledLine() + 1) * container.lineHeight; + if(highlighted) + bottomY-=2; + drawRect(gx, topY, gx + 1, bottomY, guideColor); + } + } + int yPos = posY + stringYOffset; + + // data.drawString(x + LINE_NUMBER_GUTTER_WIDTH + 1, yPos, 0xFFe0e0e0); + scriptLine.drawString(x+LINE_NUMBER_GUTTER_WIDTH + 1, yPos, 0xFFe0e0e0); + + // Draw cursor: pause blinking while user is active recently + boolean recentInput = selection.hadRecentInput(); + if (active && isEnabled() && (recentInput || (cursorCounter / 10) % 2 == 0) && (selection.getCursorPosition() >= data.start && selection.getCursorPosition() < data.end || (i == list.size() - 1 && selection.getCursorPosition() == text.length()))) { + int posX = x + LINE_NUMBER_GUTTER_WIDTH + ClientProxy.Font.width( + line.substring(0, Math.min(selection.getCursorPosition() - data.start, line.length()))); + drawRect(posX + 1, posY, posX + 2, posY + container.lineHeight, 0xffffffff); + } + } + } + GL11.glPopMatrix(); + GL11.glDisable(GL11.GL_SCISSOR_TEST); + + + if (hasVerticalScrollbar()) { + Minecraft.getMinecraft().renderEngine.bindTexture(GuiCustomScroll.resource); + int effLines = Math.max(1, getPaddedLineCount()); + int sbSize = Math.max((int) (1f * (container.visibleLines) / effLines * height), 2); + + int posX = x + width - 6; + double linesCount = (double) effLines; + int posY = (int) (y + 1f * scroll.getScrollPos() / linesCount * (height - 4)) + 1; + + drawRect(posX, posY, posX + 5, posY + sbSize + 2, 0xFFe0e0e0); + } + + // Draw search/replace bar (overlays viewport) + searchBar.draw(xMouse, yMouse); + + // Draw go to line dialog (overlays everything) + goToLineDialog.draw(xMouse, yMouse); + KEYS_OVERLAY.draw(xMouse, yMouse, wheelDelta); + } + + private void scissorViewport() { + Minecraft mc = Minecraft.getMinecraft(); + ScaledResolution sr = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight); + int scaleFactor = sr.getScaleFactor(); + int scissorX = (this.x) * scaleFactor; + int scissorY = (sr.getScaledHeight() - (this.y + this.height)) * scaleFactor; + int scissorW = (this.width) * scaleFactor; + int scissorH = this.height * scaleFactor; + GL11.glScissor(scissorX, scissorY, scissorW, scissorH); + } + // ==================== SELECTION & CURSOR POSITION ==================== + + // Get cursor position from mouse coordinates + private int getSelectionPos(int xMouse, int yMouse) { + xMouse -= (this.x + LINE_NUMBER_GUTTER_WIDTH + 1); + yMouse -= this.y + 1; + // Adjust yMouse to account for fractional GL translation (negative offset applied in rendering). + // Use a double here (no integer rounding) so clicks that land on partially + // visible lines (fractional positions) correctly hit that line. + double fracPixels = scroll.getFractionalOffset() * container.lineHeight; + double yMouseD = yMouse + fracPixels; + + ArrayList list = new ArrayList(this.container.lines); + + for (int i = 0; i < list.size(); ++i) { + LineData data = (LineData) list.get(i); + //+1 to account for the fractional line + 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) { + int lineWidth = 0; + char[] chars = data.text.toCharArray(); + + for (int j = 1; j <= chars.length; ++j) { + int w = ClientProxy.Font.width(data.text.substring(0, j)); + if (xMouse < lineWidth + (w - lineWidth) / 2) { + return data.start + j - 1; + } + + lineWidth = w; + } + + // Place cursor after the last visible character of the line. + // `data.end - 1` previously pointed at the newline for non-last lines + // which made clicks land on the newline rather than after the text. + // Use data.start + chars.length to return the position directly + // after the line's characters, clamped to the total text length. + int posAfterChars = data.start + chars.length; + return Math.min(posAfterChars, text.length()); + } + } + } + + return this.container.text.length(); + } + + // Find which line the cursor is on (0-indexed) + private int getCursorLineIndex() { + return selection.getCursorLineIndex(container.lines, text != null ? text.length() : 0); + } + + + // Scroll viewport to keep cursor visible (minimal adjustment, like IntelliJ) + // Only scrolls if cursor is outside the visible area + private void scrollToCursor() { + if (container == null || container.lines == null || container.lines.isEmpty()) return; + + int lineIdx = getCursorLineIndex(); + int visible = Math.max(1, container.visibleLines); + int effectiveVisible = Math.max(1, visible - bottomPaddingLines); + int maxScroll = Math.max(0, getPaddedLineCount() - visible); + + scroll.scrollToLine(lineIdx, effectiveVisible, maxScroll); + } + + // ==================== KEY BINDINGS INITIALIZATION ==================== + + /** + * Initialize key bindings for editor shortcuts using ScriptEditorKeys. + * Centralized active/enabled checking ensures shortcuts only fire when appropriate. + */ + private void initializeKeyBindings() { + // Helper: execute action only if text area is active and enabled + Supplier isActive = () -> active && isEnabled() && !KEYS_OVERLAY.isVisible(); + Supplier openBoxes = () -> !KEYS_OVERLAY.isVisible(); + + // CUT: Copy selection to clipboard and delete it. If no selection, cut the current sentence. + KEYS.CUT.setTask(e -> { + if (!e.isPress() || !isActive.get()) + return; + + if (selection.hasSelection()) { + NoppesStringUtils.setClipboardContents(selection.getSelectedText(text)); + String s = getSelectionBeforeText(); + setText(s + getSelectionAfterText()); + selection.reset(s.length()); + scrollToCursor(); + return; + } + + // No selection: cut the current sentence (heuristic based on .!? or newline) + if (text == null || text.isEmpty()) + return; + int cursor = selection.getCursorPosition(); + int start = cursor; + int pos = cursor - 1; + while (pos >= 0) { + char ch = text.charAt(pos); + if (ch == '.' || ch == '!' || ch == '?' || ch == '\n') { + start = pos + 1; + break; + } + pos--; + } + while (start < cursor && Character.isWhitespace(text.charAt(start))) start++; + + int end = cursor; + pos = cursor; + while (pos < text.length()) { + char ch = text.charAt(pos); + if (ch == '.' || ch == '!' || ch == '?' || ch == '\n') { + end = pos + 1; + break; + } + pos++; + } + if (end == cursor) end = text.length(); + while (end > start && Character.isWhitespace(text.charAt(end - 1))) end--; + + if (start >= end) { + // fallback: cut whole current line + int ls = text.lastIndexOf('\n', Math.max(0, cursor - 1)); + start = ls == -1 ? 0 : ls + 1; + int le = text.indexOf('\n', cursor); + end = le == -1 ? text.length() : le; + } + + if (start < end) { + String cut = text.substring(start, end); + NoppesStringUtils.setClipboardContents(cut); + setText(text.substring(0, start) + text.substring(end)); + selection.reset(start); + scrollToCursor(); + } + }); + + // COPY: Copy selection to clipboard + KEYS.COPY.setTask(e -> { + if (!e.isPress() || !isActive.get()) + return; + + if (selection.hasSelection()) + NoppesStringUtils.setClipboardContents(selection.getSelectedText(text)); + }); + + // PASTE: Insert clipboard contents at caret + KEYS.PASTE.setTask(e -> { + if (!e.isPress() || !isActive.get()) + return; + + addText(NoppesStringUtils.getClipboardContents()); + scrollToCursor(); + }); + + // UNDO: Restore last edit from undo list + // Works in search bar. + KEYS.UNDO.setTask(e -> { + if ((!e.isPress() && !e.isHold()) || !openBoxes.get()) + return; + + if (searchBar.hasFocus()) { + searchBar.undo(); + } else { + if (undoList.isEmpty()) + return; + undoing = true; + redoList.add(new UndoData(this.text, selection.getCursorPosition())); + UndoData data = undoList.remove(undoList.size() - 1); + setText(data.text); + selection.reset(data.cursorPosition); + undoing = false; + scrollToCursor(); + searchBar.updateMatches(); + if (!active) + active = true; + } + }); + + // REDO: Restore last undone edit from redo list + // Works in search bar. + KEYS.REDO.setTask(e -> { + if ((!e.isPress() && !e.isHold()) || !openBoxes.get()) + return; + + if (searchBar.hasFocus()) { + searchBar.redo(); + } else { + if (redoList.isEmpty()) + return; + undoing = true; + undoList.add(new UndoData(this.text, selection.getCursorPosition())); + UndoData data = redoList.remove(redoList.size() - 1); + setText(data.text); + selection.reset(data.cursorPosition); + undoing = false; + scrollToCursor(); + searchBar.updateMatches(); + if (!active) + active = true; + } + }); + + // FORMAT: Format/indent code + KEYS.FORMAT.setTask(e -> { + if (!e.isPress() || !isActive.get()) + return; + formatText(); + }); + + // TOGGLE_COMMENT: Toggle comment for selection or current line + KEYS.TOGGLE_COMMENT.setTask(e -> { + if (!e.isPress() || !isActive.get()) + return; + + if (selection.hasSelection()) + toggleCommentSelection(); + else + toggleCommentLineAtCursor(); + }); + + // DUPLICATE: Duplicate selection or current line + KEYS.DUPLICATE.setTask(e -> { + if (!e.isPress() || !isActive.get()) + return; + + if (selection.hasSelection()) { + // Multi-line selection duplication + LineData firstLine = null, lastLine = null; + for (LineData line : container.lines) { + if (line.end > selection.getStartSelection() && line.start < selection.getEndSelection()) { + if (firstLine == null) + firstLine = line; + lastLine = line; + } + } + if (firstLine != null && lastLine != null) { + String selectedText = text.substring(firstLine.start, lastLine.end); + int savedStart = selection.getStartSelection(); + int savedEnd = selection.getEndSelection(); + int insertAt = lastLine.end; + setText(text.substring(0, insertAt) + selectedText + text.substring(insertAt)); + selection.setStartSelection(savedStart); + selection.setEndSelection(savedEnd); + selection.setCursorPositionDirect(savedEnd); + } + } else { + // Duplicate current line + for (LineData line : container.lines) { + if (selection.getCursorPosition() >= line.start && selection.getCursorPosition() <= line.end) { + int safeStart = Math.max(0, Math.min(line.start, text.length())); + int safeEnd = Math.max(safeStart, Math.min(line.end, text.length())); + String lineText = text.substring(safeStart, safeEnd); + String insertText = lineText.endsWith("\n") ? lineText : "\n" + lineText; + int insertionPoint = Math.min(line.end, text.length()); + setText(text.substring(0, insertionPoint) + insertText + text.substring(insertionPoint)); + int newCursor = insertionPoint + insertText.length() - (insertText.endsWith("\n") ? 1 : 0); + selection.reset(Math.max(0, Math.min(newCursor, this.text.length()))); + break; + } + } + } + }); + + + // Check if can open just for SearchReplaceBar and GoToLine + + // SEARCH: Open search bar (Ctrl+R) + // Works in search bar. + KEYS.SEARCH.setTask(e -> { + if (!e.isPress() || !openBoxes.get()) + return; + + unfocusAll(); + searchBar.openSearch(); + }); + + // SEARCH_REPLACE: Open search+replace bar (Ctrl+Shift+R) + // Works in search bar. + KEYS.SEARCH_REPLACE.setTask(e -> { + if (!e.isPress() || !openBoxes.get()) + return; + + unfocusAll(); + searchBar.openSearchReplace(); + }); + + // GO_TO_LINE: Open go to line dialog (Ctrl+G) + // Works in search bar. + KEYS.GO_TO_LINE.setTask(e -> { + if (!e.isPress() || !openBoxes.get()) + return; + + unfocusAll(); + goToLineDialog.toggle(); + }); + + // RENAME: Start rename refactoring (Shift+F6) + KEYS.RENAME.setTask(e -> { + if (!e.isPress() || !openBoxes.get()) + return; + + + if (!renameHandler.isActive()) { + unfocusAll(); + active = true; + renameHandler.startRename(); + } + }); + } + + public void unfocusAll() { + if (searchBar.hasFocus()) searchBar.unfocus(); + if (goToLineDialog.hasFocus()) goToLineDialog.unfocus(); + if (renameHandler.isActive()) + renameHandler.cancel(); + } + // ==================== KEYBOARD INPUT HANDLING ==================== + + /** + * Handles keyboard input for the text area, delegating to specialized handlers + * for different types of input: navigation, deletion, shortcuts, and character input. + */ + @Override + public boolean textboxKeyTyped(char c, int i) { + if (KEYS_OVERLAY.keyTyped(c, i)) + return true; + + // Handle rename refactor input first if active + if (renameHandler.isActive() && renameHandler.keyTyped(c, i)) + return true; + + // Handle Go To Line dialog input first if it has focus + if (goToLineDialog.isVisible() &&goToLineDialog.keyTyped(c, i)) + return true; + + // Handle search bar input first if it has focus + if (searchBar.isVisible() && searchBar.keyTyped(c, i)) + return true; + + if (!active) + return false; + + if (this.isKeyComboCtrlA(i)) { + selection.selectAll(text.length()); + return true; + } + + if (!isEnabled()) return false; + + if (handleNavigationKeys(i)) return true; + if (handleInsertionKeys(i)) return true; + if (handleDeletionKeys(i)) return true; + if (handleCharacterInput(c)) return true; + + return true; + } + + /** + * Handles cursor navigation keys (arrows) with support for word-jumping (Ctrl) + * and selection (Shift). Updates cursor position and scrolls viewport if needed. + */ + private boolean handleNavigationKeys(int i) { + // LEFT ARROW: move cursor left; with Ctrl -> jump by word + if (i == Keyboard.KEY_LEFT) { + int j = 1; // default: move one character + if (isCtrlKeyDown()) { + // When Ctrl is down, compute distance to previous word boundary. + // We match words in the text slice before the cursor and pick + // the last match start as the new boundary. + Matcher m = container.regexWord.matcher(text.substring(0, selection.getCursorPosition())); + while (m.find()) { + if (m.start() == m.end()) + continue; // skip empty matches + // j becomes the number of chars to move left to reach word start + j = selection.getCursorPosition() - m.start(); + } + } + int newPos = Math.max(selection.getCursorPosition() - j, 0); + // If Shift is held, extend selection; otherwise place caret. + setCursor(newPos, GuiScreen.isShiftKeyDown()); + return true; + } + + // RIGHT ARROW: move cursor right; with Ctrl -> jump to next word start + if (i == Keyboard.KEY_RIGHT) { + int j = 1; // default: move one character + if (isCtrlKeyDown()) { + String after = text.substring(selection.getCursorPosition()); + Matcher m = container.regexWord.matcher(after); + if (m.find()) { + if (m.start() == 0) { + // If the first match starts at 0 (cursor at word start), + // try to find the next match so we advance past the current word. + if (m.find()) + j = m.start(); + else + j = Math.max(1, after.length()); + } else { + j = m.start(); + } + } else { + // No word match found after cursor -> jump to end + j = Math.max(1, after.length()); + } + } + int newPos = Math.min(selection.getCursorPosition() + j, text.length()); + setCursor(newPos, GuiScreen.isShiftKeyDown()); + return true; + } + + // UP/DOWN: logical cursor movement across lines while preserving + // column where possible. After moving, ensure the caret remains visible + // by adjusting the scroll if necessary. + if (i == Keyboard.KEY_UP) { + setCursor(cursorUp(), GuiScreen.isShiftKeyDown()); + scrollToCursor(); + return true; + } + if (i == Keyboard.KEY_DOWN) { + setCursor(cursorDown(), GuiScreen.isShiftKeyDown()); + scrollToCursor(); + return true; + } + + return false; // not a navigation key + } + + /** + * Handles insertion-related keys such as Tab indentation and Enter behavior. + */ + private boolean handleInsertionKeys(int i) { + // TAB: indent or unindent depending on Shift + if (i == Keyboard.KEY_TAB) { + boolean shift = isShiftKeyDown(); + if (shift) { + handleShiftTab(); + } else { + handleTab(); + } + scrollToCursor(); + return true; + } + + // RETURN/ENTER: special handling when preceding char is an opening brace '{' + if (i == Keyboard.KEY_RETURN) { + int cursorPos = selection.getCursorPosition(); + int prevNonWs = cursorPos - 1; + while (prevNonWs >= 0 && prevNonWs < (text != null ? text.length() : 0) && Character.isWhitespace( + text.charAt(prevNonWs))) { + prevNonWs--; + } + + if (prevNonWs >= 0 && cursorPos <= (text != null ? text.length() : 0) && text.charAt(prevNonWs) == '{') { + String indent = ""; + for (LineData ld : this.container.lines) { + if (prevNonWs >= ld.start && prevNonWs < ld.end) { + indent = ld.text.substring(0, IndentHelper.getLineIndent(ld.text)); + break; + } + } + if (indent == null) + indent = ""; + String childIndent = indent + " "; + String before = getSelectionBeforeText(); + String after = getSelectionAfterText(); + + int firstNewline = after.indexOf('\n'); + String leadingSegment = firstNewline == -1 ? after : after.substring(0, firstNewline); + if (leadingSegment.trim().length() > 0) { + addText("\n" + childIndent); + scrollToCursor(); + return true; + } + + boolean hasMatchingCloseSameIndent = false; + try { + int openLineIdx = -1; + int bracePos = prevNonWs; + for (int li = 0; li < this.container.lines.size(); li++) { + LineData ld = this.container.lines.get(li); + if (bracePos >= ld.start && bracePos < ld.end) { + openLineIdx = li; + break; + } + } + + if (openLineIdx >= 0) { + List spans = BracketMatcher.computeBraceSpans(text, this.container.lines); + for (int[] span : spans) { + int spanOpen = span[1]; + int spanClose = span[2]; + if (spanOpen == openLineIdx) { + int closeIndent = IndentHelper.getLineIndent(this.container.lines.get(spanClose).text); + if (closeIndent == indent.length()) { + hasMatchingCloseSameIndent = true; + } + break; + } + } + } + } catch (Exception ex) { + hasMatchingCloseSameIndent = false; + } + + if (hasMatchingCloseSameIndent) { + addText("\n" + childIndent); + scrollToCursor(); + } else { + String insert = "\n" + childIndent + "\n" + indent + "}"; + setText(before + insert + after); + int newCursor = before.length() + 1 + childIndent.length(); + selection.reset(newCursor); + scrollToCursor(); + } + } else { + addText(Character.toString('\n') + getAutoIndentForEnter()); + scrollToCursor(); + } + return true; + } + + return false; + } + + /** + * Handles deletion keys: Delete, Backspace, and Ctrl+Backspace. + * Includes smart backspace behavior for indentation-aware line merging, + * auto-pair deletion for brackets/quotes, and word-level deletion. + */ + private boolean handleDeletionKeys(int i) { + // DELETE key: remove the character under the cursor if no selection, + // otherwise remove the selected region's tail. + if (i == Keyboard.KEY_DELETE) { + String s = getSelectionAfterText(); + if (!s.isEmpty() && !selection.hasSelection()) + // remove single character after caret when nothing is selected + s = s.substring(1); + setText(getSelectionBeforeText() + s); + // Keep caret at same start selection + selection.reset(selection.getStartSelection()); + return true; + } + + // CTRL+BACKSPACE: delete to previous word or whitespace boundary. + if (isKeyComboCtrlBackspace(i)) { + String s = getSelectionBeforeText(); + if (selection.getStartSelection() > 0 && !selection.hasSelection()) { + int nearestCondition = selection.getCursorPosition(); + int g; + // If the char left of caret is whitespace, find the first non-space to the left; + // otherwise find first whitespace/newline to the left (word boundary). + boolean cursorInWhitespace = Character.isWhitespace(s.charAt(selection.getCursorPosition() - 1)); + if (cursorInWhitespace) { + // Scan left until non-whitespace (start of previous word) + for (g = selection.getCursorPosition() - 1; g >= 0; g--) { + char currentChar = s.charAt(g); + if (!Character.isWhitespace(currentChar)) { + nearestCondition = g; + break; + } + if (g == 0) { + nearestCondition = 0; + } + } + } else { + // Scan left until whitespace/newline is found (word boundary) + for (g = selection.getCursorPosition() - 1; g >= 0; g--) { + char currentChar = s.charAt(g); + if (Character.isWhitespace(currentChar) || currentChar == '\n') { + nearestCondition = g; + break; + } + if (g == 0) { + nearestCondition = 0; + } + } + } + + // Trim the prefix up to the discovered boundary + s = s.substring(0, nearestCondition); + // Adjust selection start to match removed characters + selection.setStartSelection( + selection.getStartSelection() - (selection.getCursorPosition() - nearestCondition)); + } + setText(s + getSelectionAfterText()); + selection.reset(selection.getStartSelection()); + return true; + } + + // BACKSPACE: complex handling with a few cases: + // 1) If a selection exists, delete it + // 2) If at start, nothing to do + // 3) Smart indent-aware merge with previous line when caret is at/near expected indent + // 4) Auto-pair deletion (remove both opening and closing chars when deleting an opener) + // 5) Fallback: delete a single char to the left + if (i == Keyboard.KEY_BACK) { + // 1) selection deletion + if (selection.hasSelection()) { + String s = getSelectionBeforeText(); + setText(s + getSelectionAfterText()); + selection.reset(selection.getStartSelection()); + scrollToCursor(); + return true; + } + + // 2) nothing to delete + if (selection.getStartSelection() <= 0) { + return true; + } + + // If the current line is whitespace-only, delete the whole line + // (including the trailing newline if present). This makes Backspace + // intuitive on blank/indented lines outside any recognized scope. + LineData currCheck = selection.findCurrentLine(container.lines); + if (currCheck != null && currCheck.text.trim().length() == 0) { + int removeEnd = text.indexOf('\n', currCheck.start - 1); + if (removeEnd == -1) { + removeEnd = text.length(); + } else { + removeEnd = removeEnd + 1; // include the newline + } + String before = text.substring(0, ValueUtil.clamp(currCheck.start - 1, 0, text.length())); + String after = removeEnd <= text.length() ? text.substring(removeEnd) : ""; + setText(before + after); + int newCursor = Math.max(0, currCheck.start - 1); + selection.reset(newCursor); + scrollToCursor(); + return true; + } + + // 3) indent-aware merge: find current line and compute expected indent + LineData curr = selection.findCurrentLine(container.lines); + if (curr != null && curr.start > 0) { + int col = selection.getCursorPosition() - curr.start; + int actualIndent = IndentHelper.getLineIndent(curr.text); + int expectedIndent = IndentHelper.getExpectedIndent(curr, container.lines); + + // Trigger smart merge only when caret is at or before the expected indent. + if (col <= expectedIndent) { + boolean lineHasContent = curr.text.trim().length() > 0; + int newlinePos = curr.start - 1; // index of newline before this line + + if (!lineHasContent) { + // Empty or whitespace-only line: remove it including its trailing newline + int removeEnd = text.indexOf('\n', curr.start); + if (removeEnd == -1) { + removeEnd = text.length(); + } else { + removeEnd = removeEnd + 1; // include the newline in removal + } + String before = text.substring(0, curr.start); + String after = removeEnd <= text.length() ? text.substring(removeEnd) : ""; + setText(before + after); + // Place caret at end of previous line + int newCursor = Math.max(0, curr.start - 1); + selection.reset(newCursor); + scrollToCursor(); + return true; + } else { + // Merge current line content with the previous line preserving spacing + int contentStart = curr.start + actualIndent; + String before = newlinePos >= 0 ? text.substring(0, newlinePos) : ""; + String content = contentStart <= text.length() ? text.substring(contentStart) : ""; + + // Decide whether a space is needed between concatenated fragments. + String spacer = ""; + if (before.length() > 0 && content.length() > 0) { + char lastChar = before.charAt(before.length() - 1); + char firstChar = content.charAt(0); + // Avoid adding space when punctuation/brackets are adjacent + if (!Character.isWhitespace(lastChar) && + lastChar != '{' && lastChar != '(' && lastChar != '[' && + firstChar != '}' && firstChar != ')' && firstChar != ']' && + firstChar != ';' && firstChar != ',' && firstChar != '.' && + firstChar != '\n') { + spacer = " "; + } + } + + setText(before + spacer + content); + int newCursor = before.length() + spacer.length(); + selection.reset(newCursor); + scrollToCursor(); + return true; + } + } + } + + // 4) Auto-pair deletion: when deleting an opener and a matching closer follows, + // remove both so the pair is cleaned up in one backspace. + if (selection.getStartSelection() > 0 && selection.getStartSelection() < text.length()) { + char prev = text.charAt(selection.getStartSelection() - 1); + char nextc = text.charAt(selection.getStartSelection()); + if ((prev == '(' && nextc == ')') || + (prev == '[' && nextc == ']') || + (prev == '{' && nextc == '}') || + (prev == '\'' && nextc == '\'') || + (prev == '"' && nextc == '"')) { + String before = text.substring(0, selection.getStartSelection() - 1); + String after = selection.getStartSelection() + 1 < text.length() ? text.substring( + selection.getStartSelection() + 1) : ""; + setText(before + after); + selection.setStartSelection(selection.getStartSelection() - 1); + selection.reset(selection.getStartSelection()); + scrollToCursor(); + return true; + } + } + + // 5) Normal single-character backspace + String s = getSelectionBeforeText(); + s = s.substring(0, s.length() - 1); + selection.setStartSelection(selection.getStartSelection() - 1); + setText(s + getSelectionAfterText()); + selection.reset(selection.getStartSelection()); + scrollToCursor(); + return true; + } + + return false; + } + + /** + * Handles keyboard shortcuts: clipboard operations (cut/copy/paste), + * undo/redo, tab indentation, code formatting, enter with brace handling, + * comment toggling, and line duplication. + */ + private boolean handleShortcutKeys(int i) { + // CTRL+X: Cut + if (this.isKeyComboCtrlX(i)) { + if (selection.hasSelection()) { + // Copy selected text into clipboard, then remove the selection + NoppesStringUtils.setClipboardContents(selection.getSelectedText(text)); + String s = getSelectionBeforeText(); + setText(s + getSelectionAfterText()); + selection.reset(s.length()); + scrollToCursor(); + } + return true; + } + + // CTRL+C: Copy + if (this.isKeyComboCtrlC(i)) { + if (selection.hasSelection()) { + NoppesStringUtils.setClipboardContents(selection.getSelectedText(text)); + } + return true; + } + + // CTRL+V: Paste (insert clipboard contents at caret) + if (this.isKeyComboCtrlV(i)) { + addText(NoppesStringUtils.getClipboardContents()); + scrollToCursor(); + return true; + } + + // UNDO (Ctrl+Z): restore last entry from undoList and push current state to redoList + if (i == Keyboard.KEY_Z && isCtrlKeyDown()) { + if (undoList.isEmpty()) + return false; // nothing to undo + undoing = true; + redoList.add(new UndoData(this.text, selection.getCursorPosition())); + UndoData data = undoList.remove(undoList.size() - 1); + setText(data.text); + selection.reset(data.cursorPosition); + undoing = false; + scrollToCursor(); + return true; + } + + // REDO (Ctrl+Y): opposite of undo + if (i == Keyboard.KEY_Y && isCtrlKeyDown()) { + if (redoList.isEmpty()) + return false; + undoing = true; + undoList.add(new UndoData(this.text, selection.getCursorPosition())); + UndoData data = redoList.remove(redoList.size() - 1); + setText(data.text); + selection.reset(data.cursorPosition); + undoing = false; + scrollToCursor(); + return true; + } + + // CTRL+F: format the text according to IndentHelper rules + if (i == Keyboard.KEY_F && isCtrlKeyDown()) { + formatText(); + return true; + } + + // CTRL+/ : toggle comment for selection or current line + if (i == Keyboard.KEY_SLASH && isCtrlKeyDown()) { + if (selection.hasSelection()) { + toggleCommentSelection(); + } else { + toggleCommentLineAtCursor(); + } + return true; + } + + // CTRL+D : duplicate selection or current line + if (i == Keyboard.KEY_D && isCtrlKeyDown()) { + if (selection.hasSelection()) { + // Multi-line selection duplication: find first and last covered lines, + // then insert the whole block after the last line without adding extra newline. + LineData firstLine = null, lastLine = null; + for (LineData line : container.lines) { + if (line.end > selection.getStartSelection() && line.start < selection.getEndSelection()) { + if (firstLine == null) firstLine = line; + lastLine = line; + } + } + if (firstLine != null && lastLine != null) { + String selectedText = text.substring(firstLine.start, lastLine.end); + String insertText = selectedText; + int savedStart = selection.getStartSelection(); + int savedEnd = selection.getEndSelection(); + int insertAt = lastLine.end; + setText(text.substring(0, insertAt) + insertText + text.substring(insertAt)); + // Restore prior selection / cursor positions + selection.setStartSelection(savedStart); + selection.setEndSelection(savedEnd); + selection.setCursorPositionDirect(savedEnd); + return true; + } + } else { + // Duplicate current line when nothing is selected + for (LineData line : container.lines) { + if (selection.getCursorPosition() >= line.start && selection.getCursorPosition() <= line.end) { + int lineStart = line.start, lineEnd = line.end; + String lineText = text.substring(lineStart, lineEnd); + // If the line already ends with a newline, reuse it; otherwise + // prefix a newline so duplicate appears after current line. + String insertText; + if (lineText.endsWith("\n")) { + insertText = lineText; + } else { + insertText = "\n" + lineText; + } + int insertionPoint = lineEnd; + setText(text.substring(0, insertionPoint) + insertText + text.substring(insertionPoint)); + int newCursor = insertionPoint + insertText.length() - (insertText.endsWith("\n") ? 1 : 0); + selection.reset(Math.max(0, Math.min(newCursor, this.text.length()))); + return true; + } + } + } + return true; + } + + return false; + } + + /** + * Handles printable character input with auto-pairing for quotes and brackets, + * and smart skipping over existing closing characters. + */ + private boolean handleCharacterInput(char c) { + if (ChatAllowedCharacters.isAllowedCharacter(c)) { + String before = getSelectionBeforeText(); + String after = getSelectionAfterText(); + + // If the user types a closing character and that same closer is + // already immediately after the caret, move caret past it instead + // of inserting another closer. This prevents duplicate closers + // when the editor auto-inserts pairs. + if ((c == ')' || c == ']' || c == '"' || c == '\'' ) && after.length() > 0 && after.charAt(0) == c) { + // Move caret forward by one (skip over existing closer) + selection.reset(before.length() + 1); + scrollToCursor(); + return true; + } + + // Auto-pair insertion: when opening a quote/brace/bracket is typed, + // insert a matching closer and place caret between the pair. + if (c == '"') { + setText(before + "\"\"" + after); + selection.reset(before.length() + 1); + scrollToCursor(); + return true; + } + if (c == '\'') { + setText(before + "''" + after); + selection.reset(before.length() + 1); + scrollToCursor(); + return true; + } + if (c == '[') { + setText(before + "[]" + after); + selection.reset(before.length() + 1); + scrollToCursor(); + return true; + } + if (c == '(') { + setText(before + "()" + after); + selection.reset(before.length() + 1); + scrollToCursor(); + return true; + } + + // Default insertion for printable characters: insert at caret (replacing selection) + addText(Character.toString(c)); + scrollToCursor(); + return true; + } + return false; + } + + private boolean isShiftKeyDown() { + return Keyboard.isKeyDown(42) || Keyboard.isKeyDown(54); + } + + // ==================== COMMENT TOGGLING ==================== + // Uses CommentHandler helper for comment operations + + private void toggleCommentSelection() { + CommentHandler.SelectionToggleResult result = CommentHandler.toggleCommentSelection( + text, container.lines, selection.getStartSelection(), selection.getEndSelection()); + setText(result.newText); + selection.setStartSelection(result.newStartSelection); + selection.setEndSelection(result.newEndSelection); + } + + private void toggleCommentLineAtCursor() { + CommentHandler.SingleLineToggleResult result = CommentHandler.toggleCommentAtCursor( + text, container.lines, selection.getCursorPosition()); + setText(result.newText); + setCursor(result.newCursorPosition, false); + } + + public boolean closeOnEsc(){ + return !KEYS_OVERLAY.isVisible() && !searchBar.isVisible() && !goToLineDialog.isVisible() && !renameHandler.isActive(); + } + + // ==================== KEYBOARD MODIFIERS ==================== + + private boolean isAltKeyDown() { + return Keyboard.isKeyDown(56) || Keyboard.isKeyDown(184); + } + + private boolean isKeyComboCtrlX(int keyID) { + return keyID == 45 && isCtrlKeyDown() && !isShiftKeyDown() && !isAltKeyDown(); + } + + private boolean isKeyComboCtrlBackspace(int keyID) { + return keyID == Keyboard.KEY_BACK && isCtrlKeyDown() && !isShiftKeyDown() && !isAltKeyDown(); + } + + private boolean isKeyComboCtrlV(int keyID) { + return keyID == 47 && isCtrlKeyDown() && !isShiftKeyDown() && !isAltKeyDown(); + } + + private boolean isKeyComboCtrlC(int keyID) { + return keyID == 46 && isCtrlKeyDown() && !isShiftKeyDown() && !isAltKeyDown(); + } + + private boolean isKeyComboCtrlA(int keyID) { + return keyID == 30 && isCtrlKeyDown() && !isShiftKeyDown() && !isAltKeyDown(); + } + + private String getIndentCurrentLine() { + for (LineData data : this.container.lines) { + if (selection.getCursorPosition() > data.start && selection.getCursorPosition() <= data.end) { + int i; + for (i = 0; i < data.text.length() && data.text.charAt(i) == ' '; ++i) { + } + return data.text.substring(0, i); + } + } + return ""; + } + + private String getAutoIndentForEnter() { + LineData currentLine = selection.findCurrentLine(container.lines); + + if (currentLine == null) { + return ""; + } + return IndentHelper.getAutoIndentForEnter(currentLine.text, selection.getCursorPosition() - currentLine.start); + } + // ==================== TEXT FORMATTING ==================== + + private int getTabSize() { + return IndentHelper.TAB_SIZE; + } + + private String repeatSpace(int count) { + return IndentHelper.spaces(count); + } + + private void formatText() { + // Calculate viewport width for line wrapping (account for gutter and scrollbar) + int viewportWidth = this.width - LINE_NUMBER_GUTTER_WIDTH - 10; + IndentHelper.FormatResult result = IndentHelper.formatText(text, selection.getCursorPosition(), viewportWidth); + setText(result.text); + selection.reset(Math.max(0, Math.min(result.cursorPosition, this.text.length()))); + } + + // ==================== TAB HANDLING ==================== + + private void handleTab() { + LineData currentLine = selection.findCurrentLine(container.lines); + if (currentLine == null) { + addText(" "); + return; + } + int tab = getTabSize(); + int indentLen = IndentHelper.getLineIndent(currentLine.text); + int textStartPos = currentLine.start + indentLen; + + if (selection.getCursorPosition() <= textStartPos) { + // Cursor before any text: if cursor is exactly at text start, move forward to next tab stop. + // If cursor is inside leading whitespace (before text start), choose nearest tab stop (tie -> forward). + int targetIndent; + if (selection.getCursorPosition() == textStartPos) { + targetIndent = ((indentLen / tab) + 1) * tab; + } else { + int remainder = indentLen % tab; + if (remainder == 0) { + targetIndent = indentLen + tab; // already aligned -> next level + } else { + int down = indentLen - remainder; + int up = indentLen + (tab - remainder); + int distDown = remainder; + int distUp = tab - remainder; + if (distUp < distDown) targetIndent = up; + else if (distUp > distDown) targetIndent = down; + else targetIndent = up; // tie -> forward + } + } + if (targetIndent < 0) targetIndent = 0; + String newIndent = repeatSpace(targetIndent); + String rest = currentLine.text.substring(indentLen); + String before = text.substring(0, currentLine.start); + int contentEnd = Math.min(currentLine.start + currentLine.text.length(), text.length()); + int sepEnd = Math.min(currentLine.end, text.length()); + String sep = contentEnd < sepEnd ? text.substring(contentEnd, sepEnd) : ""; + String after = text.substring(sepEnd); + setText(before + newIndent + rest + sep + after); + int newCursor = currentLine.start + targetIndent; + selection.reset(Math.min(newCursor, this.text.length())); + } else { + // Cursor is after start of text: insert spaces at cursor to move following text to next tab stop + int column = selection.getCursorPosition() - currentLine.start; + int targetColumn = ((column / tab) + 1) * tab; + int toInsert = Math.max(0, targetColumn - column); + if (toInsert > 0) { + String spaces = repeatSpace(toInsert); + addText(spaces); + } + } + } + + private void handleShiftTab() { + LineData currentLine = selection.findCurrentLine(container.lines); + if (currentLine == null) + return; + int tab = getTabSize(); + int indentLen = IndentHelper.getLineIndent(currentLine.text); + int textStartPos = currentLine.start + indentLen; + + if (selection.getCursorPosition() <= textStartPos) { + // Cursor before any text: reduce leading indent to previous tab stop + int targetIndent = Math.max(0, ((indentLen - 1) / tab) * tab); + String newIndent = repeatSpace(targetIndent); + String rest = currentLine.text.substring(indentLen); + String before = text.substring(0, currentLine.start); + int contentEnd = Math.min(currentLine.start + currentLine.text.length(), text.length()); + int sepEnd = Math.min(currentLine.end, text.length()); + String sep = contentEnd < sepEnd ? text.substring(contentEnd, sepEnd) : ""; + String after = text.substring(sepEnd); + setText(before + newIndent + rest + sep + after); + int newCursor = currentLine.start + targetIndent; + selection.reset(Math.min(newCursor, this.text.length())); + } else { + // Cursor after start of text: remove up to previous tab stop worth of spaces immediately before cursor + int column = selection.getCursorPosition() - currentLine.start; + int mod = column % tab; + int toRemove = mod == 0 ? tab : mod; + int removed = 0; + int pos = selection.getCursorPosition() - 1; + while (pos >= currentLine.start && removed < toRemove && text.charAt(pos) == ' ') { + pos--; + removed++; + } + if (removed > 0) { + int removeStart = pos + 1; + String before = text.substring(0, removeStart); + String after = text.substring(selection.getCursorPosition()); + setText(before + after); + int newCursor = removeStart; + selection.reset(Math.min(newCursor, this.text.length())); + } + } + } + + // ==================== CURSOR MANAGEMENT ==================== + + private void setCursor(int i, boolean select) { + selection.setCursor(i, text != null ? text.length() : 0, select); + } + + private void addText(String s) { + int insertPos = selection.getStartSelection(); + this.setText(this.getSelectionBeforeText() + s + this.getSelectionAfterText()); + selection.afterTextInsert(insertPos + s.length()); + } + + private int cursorUp() { + return CursorNavigation.cursorUp(selection.getCursorPosition(), container.lines, text); + } + + private int cursorDown() { + return CursorNavigation.cursorDown(selection.getCursorPosition(), container.lines, text); + } + + public String getSelectionBeforeText() { + return selection.getTextBefore(text); + } + + public String getSelectionAfterText() { + return selection.getTextAfter(text); + } + + // ==================== MOUSE HANDLING ==================== + + public void mouseClicked(int xMouse, int yMouse, int mouseButton) { + // Check go to line dialog clicks first + if (goToLineDialog.isVisible() && goToLineDialog.mouseClicked(xMouse, yMouse, mouseButton)) { + return; + } + + // Check search bar clicks first + if (searchBar.isVisible() && searchBar.mouseClicked(xMouse, yMouse, mouseButton)) { + return; + } + + // If search bar is visible but click was outside it, unfocus the search bar + if (searchBar.isVisible()) { + searchBar.unfocus(); + } + + // Let the overlay consume clicks (it returns true when it handled the event) + if (KEYS_OVERLAY.mouseClicked(xMouse, yMouse, mouseButton)) + return; + + // Determine whether click occurred inside the text area bounds + this.active = xMouse >= this.x && xMouse < this.x + this.width && yMouse >= this.y && yMouse < this.y + this.height; + if (this.active) { + // Compute logical click position in text + int clickPos = this.getSelectionPos(xMouse, yMouse); + + // Check if rename refactoring is active and click is in the rename box + if (renameHandler.isActive() && renameHandler.handleClick(clickPos)) { + // Click was handled by rename handler - don't reset selection or do other click handling + this.clicked = false; + activeTextfield = this; + return; + } + + // Normal click handling - reset selection/caret + selection.reset(clickPos); + selection.markActivity(); + + // Prepare click state (left button starts most interactions) + this.clicked = mouseButton == 0; + this.doubleClicked = false; + this.tripleClicked = false; + long time = System.currentTimeMillis(); + + // Prefer delegating scrollbar-start logic to ScrollState. If the click + // is on the scrollbar area and the scrollbar can be dragged, we start + // click-scrolling mode and cancel the normal text click-drag behavior. + if (this.clicked && getPaddedLineCount() * this.container.lineHeight > this.height && xMouse > this.x + this.width - 8) { + // We consumed the mouse-down as a scrollbar drag start + this.clicked = false; + scroll.startScrollbarDrag(yMouse,this.y,this.height, getPaddedLineCount()); + } else { + // Handle double/triple click selection counting + if (time - this.lastClicked < 300L) { + this.clickCount++; + } else { + this.clickCount = 1; + } + + if (this.clickCount == 2) { + // Double-click: select the word under the caret using the container's word regex + this.doubleClicked = true; + selection.selectWordAtCursor(this.text, this.container.regexWord); + // Prevent subsequent mouse-drag handling in the render loop from + // treating this double-click as a normal click-drag which would + // immediately reset and extend the selection. Clearing `clicked` + // keeps the double-click selection stable. + this.clicked = false; + } else if (this.clickCount >= 3) { + // Triple-click: select the entire logical line that contains the caret + this.tripleClicked = true; + selection.selectLineAtCursor(container.lines); + // Same as double-click: clear `clicked` to avoid accidental drag-extension + this.clicked = false; + this.clickCount = 0; + } + } + + this.lastClicked = time; + activeTextfield = this; + } + } + + // Called from GuiScreen.updateScreen() + public void updateCursorCounter() { + // Only process KeyPresets if search bar and go-to-line dialog don't have focus + // This prevents COPY, PASTE, UNDO, etc. from firing when typing in dialogs + KEYS.tick(); + + searchBar.updateCursor(); + goToLineDialog.updateCursor(); + renameHandler.updateCursor(); + ++this.cursorCounter; + } + + // ==================== TEXT MANAGEMENT ==================== + + public void setText(String text) { + if (text == null) { + return; + } + + text = text.replace("\r", ""); + text = text.replace("\t", " "); + // preserve trailing newlines here — JavaTextContainer.init will + // ignore an extra empty final split when rendering lines. + if (this.text == null || !this.text.equals(text)) { + if (this.listener != null) { + this.listener.textUpdate(text); + } + + if (!this.undoing) { + this.undoList.add(new GuiScriptTextArea1.UndoData(this.text, selection.getCursorPosition())); + this.redoList.clear(); + } + + this.text = text; + //this.container = new TextContainer(text); + if (this.container == null) + this.container = new ScriptTextContainer(text); + + this.container.init(text, this.width, this.height); + + if (this.enableCodeHighlighting) + this.container.formatCodeText(); + + // Ensure scroll state stays in bounds after text change + int maxScroll = Math.max(0, getPaddedLineCount() - this.container.visibleLines); + scroll.clampToBounds(maxScroll); + + selection.clamp(this.text.length()); + + // Consider text changes user activity to pause caret blinking briefly + selection.markActivity(); + searchBar.updateMatches(); + + } + } + + public String getText() { + return this.text; + } + + public boolean isEnabled() { + return this.enabled && this.visible; + } + + public boolean hasVerticalScrollbar() { + return this.container != null && this.container.visibleLines < getPaddedLineCount(); + } + + public void enableCodeHighlighting() { + this.enableCodeHighlighting = true; + this.container.formatCodeText(); + } + + public void setListener(ITextChangeListener listener) { + this.listener = listener; + } + + private void clampSelectionBounds() { + selection.clamp(text != null ? text.length() : 0); + } + + // ==================== INNER CLASSES ==================== + + public static class UndoData { + public String text; + public int cursorPosition; + + public UndoData(String text, int cursorPosition) { + this.text = text; + this.cursorPosition = cursorPosition; + } + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/GuiUtil.java b/src/main/java/noppes/npcs/client/gui/util/GuiUtil.java index 7350668b8..10f0efc53 100644 --- a/src/main/java/noppes/npcs/client/gui/util/GuiUtil.java +++ b/src/main/java/noppes/npcs/client/gui/util/GuiUtil.java @@ -10,11 +10,19 @@ import org.lwjgl.opengl.GL11; public class GuiUtil { public static void setScissorClip(int x, int y, int width, int height) { + setScissorClip(x, y, width, height, null); + } + + public static void setScissorClip(int x, int y, int width, int height, GuiNPCInterface gui) { Minecraft mc = Minecraft.getMinecraft(); ScaledResolution res = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight); int scale = res.getScaleFactor(); - + if (gui != null) { + x -= (int) gui.getPanX(); + y -= (int) gui.getPanY(); + } + // Adjust position to Top-Left origin (OpenGL window/screen space uses bottom-left origin) y = mc.displayHeight - y * scale; height *= scale; @@ -159,6 +167,32 @@ public class GuiUtil { tessellator.draw(); } + /** + * Draw a scaled textured rectangle (for rendering icons). + */ + public static void drawScaledTexturedRect(int x, int y, int u, int v, int srcWidth, int srcHeight, + int destWidth, int destHeight, int textureWidth, int textureHeight) { + float uScale = 1.0f / textureWidth; + float vScale = 1.0f / textureHeight; + + GL11.glEnable(GL11.GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + + GL11.glBegin(GL11.GL_QUADS); + GL11.glTexCoord2f(u * uScale, v * vScale); + GL11.glVertex2f(x, y); + GL11.glTexCoord2f(u * uScale, (v + srcHeight) * vScale); + GL11.glVertex2f(x, y + destHeight); + GL11.glTexCoord2f((u + srcWidth) * uScale, (v + srcHeight) * vScale); + GL11.glVertex2f(x + destWidth, y + destHeight); + GL11.glTexCoord2f((u + srcWidth) * uScale, v * vScale); + GL11.glVertex2f(x + destWidth, y); + GL11.glEnd(); + + GL11.glDisable(GL11.GL_BLEND); + } + + public static void setMouse(int guiX, int guiY) { Minecraft mc = Minecraft.getMinecraft(); ScaledResolution scaledResolution = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight); diff --git a/src/main/java/noppes/npcs/client/gui/util/script/ClassPathFinder.java b/src/main/java/noppes/npcs/client/gui/util/script/ClassPathFinder.java index 844da165b..9b6567b1e 100644 --- a/src/main/java/noppes/npcs/client/gui/util/script/ClassPathFinder.java +++ b/src/main/java/noppes/npcs/client/gui/util/script/ClassPathFinder.java @@ -375,7 +375,8 @@ public class ClassPathFinder { if (p == null || p.isEmpty()) continue; String[] segs = p.split("\\."); String last = segs[segs.length - 1]; - boolean lastIsClass = last.length() > 0 && Character.isUpperCase(last.charAt(0)); + // Check if last segment is actually a class (try to resolve it) + boolean lastIsClass = last.length() > 0 && tryResolveClass(p) != null; // Try package wildcard: pkg.SimpleName if (!lastIsClass) { @@ -539,6 +540,8 @@ public class ClassPathFinder { private int findFirstUppercaseSegment(String[] segments) { for (int i = 0; i < segments.length; i++) { if (segments[i].length() > 0 && Character.isUpperCase(segments[i].charAt(0))) { + // Keep uppercase check here as it's a heuristic for package splitting + // This is about Java naming conventions, not actual type resolution return i; } } @@ -653,10 +656,10 @@ public class ClassPathFinder { } String typeName = content.substring(start, i); - // Only process if it looks like a type name (starts with uppercase) - if (Character.isUpperCase(typeName.charAt(0))) { - // Resolve the type - ClassInfo info = resolveSimpleName(typeName, importedClasses, importedPackages); + // Try to resolve as an actual type + ClassInfo info = resolveSimpleName(typeName, importedClasses, importedPackages); + if (info != null) { + // Only process if it actually resolves to a type ClassType classType = (info != null) ? info.type : ClassType.CLASS; results.add(new TypeOccurrence(baseOffset + start, baseOffset + i, typeName, classType)); diff --git a/src/main/java/noppes/npcs/client/gui/util/script/FormatHelper.java b/src/main/java/noppes/npcs/client/gui/util/script/FormatHelper.java index a1eedce0b..a52bf2576 100644 --- a/src/main/java/noppes/npcs/client/gui/util/script/FormatHelper.java +++ b/src/main/java/noppes/npcs/client/gui/util/script/FormatHelper.java @@ -2,24 +2,156 @@ package noppes.npcs.client.gui.util.script; import java.util.ArrayList; import java.util.List; -import java.util.regex.Pattern; /** * Configurable code formatter with IntelliJ-like settings. *

+ * Architecture: Token-based pipeline (tokenize → format → reconstruct). + *

+ * The formatter processes code in three phases: + *

    + *
  1. Tokenize — Splits code segments into typed tokens + * (operators, keywords, identifiers, literals, punctuation, whitespace). + * Multi-character operators are matched longest-first to avoid sub-token clobbering.
  2. + *
  3. Format — Applies spacing rules to each token pair based on their types + * and the current {@link FormatSettings}. Context-aware: distinguishes unary from + * binary operators, generic brackets from comparison operators, etc.
  4. + *
  5. Reconstruct — Joins formatted tokens back into a code string.
  6. + *
+ *

+ * String literals and comments are identified before tokenization and passed through + * unchanged (the "preserve regions" approach). Line-by-line processing preserves + * original structure and indentation. + *

* Features: - * - Operator spacing (a+b → a + b) - * - Whitespace normalization (a b → a b) - * - Long line wrapping - * - Bracket spacing configuration - * - Preserves string content and comments + *

    + *
  • Operator spacing (a+b → a + b)
  • + *
  • Whitespace normalization (a b → a b)
  • + *
  • Long line wrapping
  • + *
  • Bracket spacing configuration
  • + *
  • Preserves string content and comments
  • + *
*/ public class FormatHelper { + // ==================== TOKEN TYPES ==================== + + /** + * Token type classification for the formatter tokenizer. + */ + enum TokenType { + /** String literal: "..." or '...' (with escape handling) */ + STRING_LITERAL, + /** Block comment: /* ... */ */ + BLOCK_COMMENT, + /** Line comment: // ... */ + LINE_COMMENT, + /** Multi-char or single-char operator: ==, !=, >=, +, -, etc. */ + OPERATOR, + /** Control-flow keyword: if, while, for, switch, catch, else, return, etc. */ + KEYWORD, + /** ( */ + PAREN_OPEN, + /** ) */ + PAREN_CLOSE, + /** [ */ + BRACKET_OPEN, + /** ] */ + BRACKET_CLOSE, + /** { */ + BRACE_OPEN, + /** } */ + BRACE_CLOSE, + /** , */ + COMMA, + /** ; */ + SEMICOLON, + /** : */ + COLON, + /** . */ + DOT, + /** Variable name, method name, type name, etc. */ + IDENTIFIER, + /** Numeric literal */ + NUMBER, + /** Spaces, tabs (not newlines — those are line delimiters) */ + WHITESPACE + } + + // ==================== TOKEN CLASS ==================== + + /** + * A single token produced by the tokenizer. + */ + static class Token { + final TokenType type; + final String value; + final int position; // position in original code segment + + Token(TokenType type, String value, int position) { + this.type = type; + this.value = value; + this.position = position; + } + + @Override + public String toString() { + return type + "(" + value + ")@" + position; + } + } + + // ==================== OPERATOR CLASSIFICATION ==================== + + /** + * Multi-character operators ordered longest-first for greedy matching. + */ + private static final String[] MULTI_CHAR_OPERATORS = { + ">>>=", // unsigned right shift assign + "===", "!==", // JS strict equality + "<<=", ">>=", // shift assign + ">>>", // unsigned right shift + "+=", "-=", "*=", "/=", "%=", // compound assign + "&=", "|=", "^=", // bitwise compound assign + "&&", "||", // logical + "==", "!=", // equality + "<=", ">=", // comparison + "<<", ">>", // shift + "++", "--", // increment/decrement + "->", "=>", // arrow operators (Java lambda, JS arrow) + }; + + /** + * Single-character operators. Note: < and > are handled specially + * (could be generics). + */ + private static final String SINGLE_CHAR_OPERATORS = "=+-*/%&|^!~<>?"; + + /** + * Keywords that get special spacing before parentheses. + */ + private static final String[] CONTROL_KEYWORDS = { + "if", "while", "for", "switch", "catch", + "else", "return", "new", "throw", "typeof", "instanceof", + "in", "of", "var", "let", "const", "function", "class", + "try", "finally", "do", "case", "default", "break", "continue", + "void", "delete", "yield", "await", "async", "extends", "implements", + "import", "export", "package", "interface", "enum", "abstract", + "static", "final", "synchronized", "volatile", "transient", "native", + "this", "super", "null", "true", "false", "undefined", + "public", "private", "protected" + }; + + /** + * Keywords that require a space before '(' when setting is enabled. + */ + private static final String[] PAREN_KEYWORDS = { + "if", "while", "for", "switch", "catch" + }; + // ==================== SETTINGS ==================== /** - * Formatting configuration - similar to IntelliJ Code Style settings + * Formatting configuration — similar to IntelliJ Code Style settings. */ public static class FormatSettings { // Spaces around operators @@ -117,7 +249,7 @@ public class FormatHelper { // ==================== MAIN FORMAT METHOD ==================== /** - * Format the entire text with all configured options + * Format the entire text with all configured options. */ public String format(String text) { if (text == null || text.isEmpty()) return text; @@ -127,7 +259,7 @@ public class FormatHelper { StringBuilder result = new StringBuilder(); for (int i = 0; i < lines.length; i++) { - String line = formatLine(lines[i], text, getLineStartOffset(lines, i)); + String line = formatLine(lines[i]); if (settings.trimTrailingWhitespace) { line = trimTrailing(line); @@ -206,7 +338,7 @@ public class FormatHelper { } /** - * Split content by semicolons, preserving those in strings and for-loops + * Split content by semicolons, preserving those in strings and for-loops. */ private List splitBySemicolons(String content) { List statements = new ArrayList<>(); @@ -215,11 +347,10 @@ public class FormatHelper { boolean inString = false; boolean inChar = false; boolean escaped = false; - int forLoopDepth = 0; // Track for(...) depth to preserve semicolons + int forLoopDepth = 0; for (int i = 0; i < content.length(); i++) { char c = content.charAt(i); - char prev = i > 0 ? content.charAt(i - 1) : ' '; // Track strings if (c == '\"' && !escaped && !inChar) { @@ -267,18 +398,10 @@ public class FormatHelper { return statements; } - private int getLineStartOffset(String[] lines, int lineIndex) { - int offset = 0; - for (int i = 0; i < lineIndex; i++) { - offset += lines[i].length() + 1; // +1 for \n - } - return offset; - } - /** - * Format a single line of code + * Format a single line of code. */ - private String formatLine(String line, String fullText, int lineOffset) { + private String formatLine(String line) { if (line.trim().isEmpty()) return line; // Preserve leading indentation @@ -304,14 +427,14 @@ public class FormatHelper { } // Format the content - String formatted = formatContent(content, fullText, lineOffset + indent); + String formatted = formatContent(content); return indentation + formatted; } /** * Check if a line appears to be a continuation of a previous line - * (i.e., starts with an operator, dot, or other continuation character) + * (i.e., starts with an operator, dot, or other continuation character). */ private boolean isContinuationLine(String trimmedContent) { if (trimmedContent.isEmpty()) return false; @@ -331,43 +454,71 @@ public class FormatHelper { } /** - * Format line content, preserving strings and comments + * Format line content, preserving strings and comments. + * Splits content into code segments and preserved regions (strings/comments), + * then tokenizes and formats each code segment. */ - private String formatContent(String content, String fullText, int offset) { - // Find string/comment regions to preserve + private String formatContent(String content) { List preserveRegions = findPreserveRegions(content); if (preserveRegions.isEmpty()) { - // No strings/comments, format everything return formatCodeSegment(content); } - // Build result by formatting non-preserved regions StringBuilder result = new StringBuilder(); int lastEnd = 0; for (int[] region : preserveRegions) { - // Format code before this preserved region if (region[0] > lastEnd) { String codeSegment = content.substring(lastEnd, region[0]); - result.append(formatCodeSegment(codeSegment)); + String formatted = formatCodeSegment(codeSegment); + result.append(formatted); + + // Ensure space between code ending with operator and following preserved region + if (!formatted.isEmpty() && !formatted.endsWith(" ")) { + char lastChar = formatted.charAt(formatted.length() - 1); + boolean operatorEnd = SINGLE_CHAR_OPERATORS.indexOf(lastChar) >= 0; + boolean identifierEnd = Character.isJavaIdentifierPart(lastChar); + if (operatorEnd || identifierEnd) { + result.append(' '); + } + } } - // Append preserved region unchanged - result.append(content.substring(region[0], region[1])); + // Ensure space before line comments (// ...) + String preserved = content.substring(region[0], region[1]); + if (preserved.startsWith("//") && result.length() > 0 && result.charAt(result.length() - 1) != ' ') { + result.append(' '); + } + + // Normalize line comment: ensure space after // prefix + if (preserved.startsWith("//") && preserved.length() > 2 && preserved.charAt(2) != ' ') { + preserved = "// " + preserved.substring(2); + } + + result.append(preserved); lastEnd = region[1]; } - // Format remaining code after last preserved region if (lastEnd < content.length()) { - result.append(formatCodeSegment(content.substring(lastEnd))); + String codeSegment = content.substring(lastEnd); + String formatted = formatCodeSegment(codeSegment); + // Ensure space after block comment end (*/) before code tokens + if (result.length() > 1 && !formatted.isEmpty()) { + String tail = result.substring(result.length() - 2); + char nextChar = formatted.charAt(0); + if (tail.equals("*/") && nextChar != ';' && nextChar != ',' && nextChar != ')') { + result.append(' '); + } + } + result.append(formatted); } return result.toString(); } /** - * Find string literals and comments that should not be formatted + * Find string literals and comments that should not be formatted. */ private List findPreserveRegions(String content) { List regions = new ArrayList<>(); @@ -418,7 +569,7 @@ public class FormatHelper { } /** - * Find end of string/char literal + * Find end of string/char literal. */ private int findStringEnd(String content, int start, char quote) { int i = start + 1; @@ -436,434 +587,838 @@ public class FormatHelper { return content.length(); } - // ==================== CODE SEGMENT FORMATTING ==================== + // ==================== TOKEN-BASED CODE SEGMENT FORMATTING ==================== /** - * Format a code segment (no strings/comments) + * Format a code segment (no strings/comments) using the token pipeline: + * tokenize → format → reconstruct. */ private String formatCodeSegment(String code) { if (code.isEmpty()) return code; - String result = code; + // Phase 1: Tokenize + List tokens = tokenize(code); - // Normalize whitespace first + // Phase 1.5: Merge split operators (e.g. = = → ==, > = → >=) if (settings.normalizeWhitespace) { - result = normalizeWhitespace(result); + tokens = mergeSplitOperators(tokens); } - // Apply operator spacing - result = formatOperators(result); + // Phase 1.75: Split >> and >>> into individual > tokens when in generic context. + // Must run AFTER merge so that merged >> tokens get split back when generic. + tokens = splitGenericShiftOperators(tokens); - // Apply bracket spacing - result = formatBrackets(result); + // Phase 2: Format (apply spacing rules) + List formatted = formatTokens(tokens); - // Apply keyword spacing - result = formatKeywords(result); + // Phase 3: Reconstruct + return reconstruct(formatted); + } - // Apply punctuation spacing - result = formatPunctuation(result); + // ==================== PHASE 1: TOKENIZER ==================== + + /** + * Tokenize a code segment into a list of typed tokens. + * Multi-character operators are matched longest-first. + * Whitespace is collapsed into single-space tokens when normalizeWhitespace is enabled. + */ + private List tokenize(String code) { + List tokens = new ArrayList<>(); + int i = 0; + int len = code.length(); + + while (i < len) { + char c = code.charAt(i); + + // Whitespace + if (c == ' ' || c == '\t') { + int start = i; + while (i < len && (code.charAt(i) == ' ' || code.charAt(i) == '\t')) { + i++; + } + String ws = settings.normalizeWhitespace ? " " : code.substring(start, i); + tokens.add(new Token(TokenType.WHITESPACE, ws, start)); + continue; + } + + // Try multi-char operators (longest first) + String multiOp = matchMultiCharOperator(code, i); + if (multiOp != null) { + tokens.add(new Token(TokenType.OPERATOR, multiOp, i)); + i += multiOp.length(); + continue; + } + + // Punctuation (single-char tokens with specific types) + if (c == '(') { tokens.add(new Token(TokenType.PAREN_OPEN, "(", i)); i++; continue; } + if (c == ')') { tokens.add(new Token(TokenType.PAREN_CLOSE, ")", i)); i++; continue; } + if (c == '[') { tokens.add(new Token(TokenType.BRACKET_OPEN, "[", i)); i++; continue; } + if (c == ']') { tokens.add(new Token(TokenType.BRACKET_CLOSE, "]", i)); i++; continue; } + if (c == '{') { tokens.add(new Token(TokenType.BRACE_OPEN, "{", i)); i++; continue; } + if (c == '}') { tokens.add(new Token(TokenType.BRACE_CLOSE, "}", i)); i++; continue; } + if (c == ',') { tokens.add(new Token(TokenType.COMMA, ",", i)); i++; continue; } + if (c == ';') { tokens.add(new Token(TokenType.SEMICOLON, ";", i)); i++; continue; } + if (c == ':' && i + 1 < len && code.charAt(i + 1) == ':') { + tokens.add(new Token(TokenType.OPERATOR, "::", i)); + i += 2; + continue; + } + if (c == ':') { tokens.add(new Token(TokenType.COLON, ":", i)); i++; continue; } + if (c == '.') { tokens.add(new Token(TokenType.DOT, ".", i)); i++; continue; } + + // Single-char operators (=, +, -, *, /, %, &, |, ^, !, ~, <, >, ?) + if (SINGLE_CHAR_OPERATORS.indexOf(c) >= 0) { + tokens.add(new Token(TokenType.OPERATOR, String.valueOf(c), i)); + i++; + continue; + } + + // Number + if (Character.isDigit(c) || (c == '.' && i + 1 < len && Character.isDigit(code.charAt(i + 1)))) { + int start = i; + // Handle hex (0x...), binary (0b...), octal (0o...) + if (c == '0' && i + 1 < len) { + char next = code.charAt(i + 1); + if (next == 'x' || next == 'X' || next == 'b' || next == 'B' || next == 'o' || next == 'O') { + i += 2; + while (i < len && isHexDigit(code.charAt(i))) i++; + tokens.add(new Token(TokenType.NUMBER, code.substring(start, i), start)); + continue; + } + } + while (i < len && (Character.isDigit(code.charAt(i)) || code.charAt(i) == '.')) i++; + // Handle suffixes like L, f, d + if (i < len && "LlFfDd".indexOf(code.charAt(i)) >= 0) i++; + tokens.add(new Token(TokenType.NUMBER, code.substring(start, i), start)); + continue; + } + + // Annotation: @ followed by identifier → single token (@Override, @Deprecated) + if (c == '@') { + int start = i; + i++; + // Skip whitespace between @ and annotation name + while (i < len && (code.charAt(i) == ' ' || code.charAt(i) == '\t')) i++; + if (i < len && Character.isJavaIdentifierStart(code.charAt(i))) { + while (i < len && Character.isJavaIdentifierPart(code.charAt(i))) i++; + String annotation = "@" + code.substring(start + 1, i).trim(); + tokens.add(new Token(TokenType.IDENTIFIER, annotation, start)); + } else { + tokens.add(new Token(TokenType.IDENTIFIER, "@", start)); + } + continue; + } + + // Identifier or keyword + if (Character.isJavaIdentifierStart(c)) { + int start = i; + while (i < len && Character.isJavaIdentifierPart(code.charAt(i))) i++; + String word = code.substring(start, i); + if (isKeyword(word)) { + tokens.add(new Token(TokenType.KEYWORD, word, start)); + } else { + tokens.add(new Token(TokenType.IDENTIFIER, word, start)); + } + continue; + } + + // Anything else — emit as identifier (safety fallback) + tokens.add(new Token(TokenType.IDENTIFIER, String.valueOf(c), i)); + i++; + } + + return tokens; + } + + /** + * Try to match a multi-character operator at the given position. + * Checks longest operators first for correct greedy matching. + */ + private String matchMultiCharOperator(String code, int pos) { + for (String op : MULTI_CHAR_OPERATORS) { + if (pos + op.length() <= code.length() && + code.substring(pos, pos + op.length()).equals(op)) { + return op; + } + } + return null; + } + + private boolean isHexDigit(char c) { + return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') || c == '_'; + } + + private boolean isKeyword(String word) { + for (String kw : CONTROL_KEYWORDS) { + if (kw.equals(word)) return true; + } + return false; + } + + // ==================== PHASE 1.25: SPLIT GENERIC SHIFT OPERATORS ==================== + + /** + * Split {@code >>} and {@code >>>} operator tokens into individual {@code >} + * tokens when they appear inside a generic type context (e.g., {@code List>}). + *

+ * Without this, the greedy tokenizer matches {@code >>} as the right-shift operator, + * causing the formatter to add spaces around it as an arithmetic/bitwise operator. + */ + private List splitGenericShiftOperators(List tokens) { + int genericDepth = 0; + List result = new ArrayList<>(); + + for (int i = 0; i < tokens.size(); i++) { + Token t = tokens.get(i); + + if (t.type == TokenType.OPERATOR && t.value.equals("<")) { + Token before = findPrevNonWhitespaceInList(result); + if (before != null && before.type == TokenType.IDENTIFIER && !before.value.isEmpty() + && Character.isUpperCase(before.value.charAt(0))) { + genericDepth++; + } + } + + if (genericDepth > 0 && t.type == TokenType.OPERATOR + && (t.value.equals(">>") || t.value.equals(">>>"))) { + for (int c = 0; c < t.value.length(); c++) { + result.add(new Token(TokenType.OPERATOR, ">", t.position + c)); + genericDepth--; + if (genericDepth < 0) genericDepth = 0; + } + continue; + } + + if (t.type == TokenType.OPERATOR && t.value.equals(">")) { + if (genericDepth > 0) { + genericDepth--; + } + } + + result.add(t); + } return result; } - /** - * Normalize whitespace (multiple spaces → single space) - */ - private String normalizeWhitespace(String code) { - // Replace multiple spaces with single space, but preserve indentation - return code.replaceAll(" +", " "); + private Token findPrevNonWhitespaceInList(List tokens) { + for (int i = tokens.size() - 1; i >= 0; i--) { + if (tokens.get(i).type != TokenType.WHITESPACE) { + return tokens.get(i); + } + } + return null; } + // ==================== PHASE 1.5: MERGE SPLIT OPERATORS ==================== + /** - * Format operator spacing + * Merge operator tokens that were split by whitespace in the original code. + * Example: tokens [=] [ws] [=] → single token [==]. + * This handles the case where users type "x = = y" and the formatter + * should recognize it as "x == y" (the == operator was split). + * + * Merge candidates (longest first): + * > > > = → >>>= = = = → === ! = = → !== + * > > = → >>= < < = → <<= > > > → >>> + * > > → >> < < → << = = → == + * ! = → != > = → >= < = → <= + * + = → += - = → -= * = → *= + * / = → /= % = → %= & = → &= + * | = → |= ^ = → ^= & & → && + * | | → || */ - private String formatOperators(String code) { - String result = code; + private List mergeSplitOperators(List tokens) { + // Extract only operator values (ignoring whitespace between them) + // and try to merge consecutive operators into known multi-char operators + List result = new ArrayList<>(); + int i = 0; - // Assignment operators - if (settings.spaceAroundAssignment) { - // Compound assignments first (longer patterns first) - result = formatBinaryOp(result, "+=", " += "); - result = formatBinaryOp(result, "-=", " -= "); - result = formatBinaryOp(result, "*=", " *= "); - result = formatBinaryOp(result, "/=", " /= "); - result = formatBinaryOp(result, "%=", " %= "); - result = formatBinaryOp(result, "&=", " &= "); - result = formatBinaryOp(result, "|=", " |= "); - result = formatBinaryOp(result, "^=", " ^= "); - result = formatBinaryOp(result, "<<=", " <<= "); - result = formatBinaryOp(result, ">>=", " >>= "); - result = formatBinaryOp(result, ">>>=", " >>>= "); + while (i < tokens.size()) { + Token t = tokens.get(i); - // Simple assignment (but not ==, !=, <=, >=) - result = formatSimpleAssignment(result); - } + if (t.type == TokenType.OPERATOR) { + // Try to merge with following operator tokens (skipping whitespace) + String merged = tryMergeOperators(tokens, i); + if (merged != null && merged.length() > t.value.length()) { + result.add(new Token(TokenType.OPERATOR, merged, t.position)); + // Skip past all the tokens we consumed + i = skipMergedTokens(tokens, i, merged); + continue; + } + } - // Comparison operators - if (settings.spaceAroundComparison) { - result = formatBinaryOp(result, "==", " == "); - result = formatBinaryOp(result, "!=", " != "); - result = formatBinaryOp(result, "<=", " <= "); - result = formatBinaryOp(result, ">=", " >= "); - // Simple < > (but not generics) - result = formatComparisonOperators(result); - } + // Merge split :: (method reference) — two COLON tokens with optional whitespace + if (t.type == TokenType.COLON) { + int next = i + 1; + while (next < tokens.size() && tokens.get(next).type == TokenType.WHITESPACE) next++; + if (next < tokens.size() && tokens.get(next).type == TokenType.COLON) { + result.add(new Token(TokenType.OPERATOR, "::", t.position)); + i = next + 1; + continue; + } + } - // Logical operators - if (settings.spaceAroundLogical) { - result = formatBinaryOp(result, "&&", " && "); - result = formatBinaryOp(result, "||", " || "); - } - - // Arithmetic operators - if (settings.spaceAroundArithmetic) { - // Handle ++ and -- first to avoid conflicts - result = formatArithmeticOperators(result); - } - - // Bitwise operators (but not in generics) - if (settings.spaceAroundBitwise) { - result = formatBitwiseOperators(result); + result.add(t); + i++; } return result; } /** - * Format a binary operator with proper spacing + * Try to merge operator tokens starting at index, skipping whitespace between them. + * Returns the merged operator string if a known multi-char operator is formed, + * or null if no merge is possible. */ - private String formatBinaryOp(String code, String op, String replacement) { - // First normalize: remove extra spaces around the operator - String pattern = "\\s*" + Pattern.quote(op) + "\\s*"; - return code.replaceAll(pattern, replacement); + private String tryMergeOperators(List tokens, int startIdx) { + StringBuilder ops = new StringBuilder(); + List opIndices = new ArrayList<>(); + boolean hasWhitespaceBetween = false; + + for (int i = startIdx; i < tokens.size(); i++) { + Token t = tokens.get(i); + if (t.type == TokenType.OPERATOR) { + ops.append(t.value); + opIndices.add(i); + } else if (t.type == TokenType.WHITESPACE) { + if (!opIndices.isEmpty()) { + hasWhitespaceBetween = true; + } + continue; + } else { + break; + } + } + + String allOps = ops.toString(); + + for (String multiOp : MULTI_CHAR_OPERATORS) { + if (allOps.startsWith(multiOp) && multiOp.length() > 1) { + // Don't merge ++ or -- when whitespace separated the operators. + // Whitespace-separated +/+ or -/- means binary op + unary op (e.g. a - -b), + // not increment/decrement. Real ++ and -- are tokenized as single tokens. + if (hasWhitespaceBetween && (multiOp.equals("++") || multiOp.equals("--"))) { + continue; + } + return multiOp; + } + } + + return null; } /** - * Format simple assignment = (not ==, !=, <=, >=, etc.) + * Skip past the tokens that were consumed by the merge. + * Returns the index of the first token AFTER the merged sequence. */ - private String formatSimpleAssignment(String code) { - StringBuilder result = new StringBuilder(); - int i = 0; - while (i < code.length()) { - char c = code.charAt(i); - if (c == '=') { - // Check it's not part of ==, !=, <=, >=, +=, etc. - char prev = i > 0 ? code.charAt(i - 1) : ' '; - char next = i + 1 < code.length() ? code.charAt(i + 1) : ' '; + private int skipMergedTokens(List tokens, int startIdx, String merged) { + int charsConsumed = 0; + int i = startIdx; - boolean isCompound = prev == '!' || prev == '<' || prev == '>' || - prev == '+' || prev == '-' || prev == '*' || - prev == '/' || prev == '%' || prev == '&' || - prev == '|' || prev == '^'; - boolean isEquality = next == '='; - - if (!isCompound && !isEquality) { - // Ensure space before = - if (result.length() > 0 && result.charAt(result.length() - 1) != ' ') { - result.append(' '); - } - result.append('='); - // Ensure space after = - if (next != ' ') { - result.append(' '); - } - } else { - result.append(c); - } - } else { - result.append(c); + while (i < tokens.size() && charsConsumed < merged.length()) { + Token t = tokens.get(i); + if (t.type == TokenType.OPERATOR) { + charsConsumed += t.value.length(); } + // Skip whitespace tokens between operators i++; } - return result.toString(); + + return i; } + // ==================== PHASE 2: TOKEN FORMATTER ==================== + /** - * Format < and > comparison operators (avoiding generics) + * Apply formatting rules to a token list, producing a new list with + * whitespace tokens inserted/removed/adjusted according to settings. + *

+ * The formatter works by iterating through tokens and deciding what + * whitespace should appear between each pair of non-whitespace tokens. */ - private String formatComparisonOperators(String code) { - StringBuilder result = new StringBuilder(); - int i = 0; - while (i < code.length()) { - char c = code.charAt(i); - - if ((c == '<' || c == '>') && !isLikelyGeneric(code, i, c)) { - char prev = i > 0 ? code.charAt(i - 1) : ' '; - char next = i + 1 < code.length() ? code.charAt(i + 1) : ' '; - - // Skip if part of <<, >>, <=, >= - if ((c == '<' && next == '<') || (c == '>' && next == '>') || - next == '=' || prev == '<' || prev == '>') { - result.append(c); - } else { - // Add spacing - if (result.length() > 0 && result.charAt(result.length() - 1) != ' ') { - result.append(' '); - } - result.append(c); - if (next != ' ' && next != '=') { - result.append(' '); - } - } - } else { - result.append(c); + private List formatTokens(List tokens) { + // First, strip existing whitespace tokens to normalize + List stripped = new ArrayList<>(); + for (Token t : tokens) { + if (t.type != TokenType.WHITESPACE) { + stripped.add(t); } - i++; } - return result.toString(); + + if (stripped.isEmpty()) return tokens; + + // Now rebuild with correct spacing + List result = new ArrayList<>(); + result.add(stripped.get(0)); + + for (int i = 1; i < stripped.size(); i++) { + Token prev = stripped.get(i - 1); + Token curr = stripped.get(i); + + // Determine the previous non-whitespace before prev (for context) + Token prevPrev = i >= 2 ? stripped.get(i - 2) : null; + + String spacing = determineSpacing(prevPrev, prev, curr, stripped, i); + + if (!spacing.isEmpty()) { + result.add(new Token(TokenType.WHITESPACE, spacing, -1)); + } + result.add(curr); + } + + return result; } /** - * Check if < or > is likely part of a generic type declaration + * Determine the spacing string that should appear between prev and curr tokens. + * Returns "" for no space, " " for single space. + * + * @param prevPrev token before prev (may be null) + * @param prev the token before the gap + * @param curr the token after the gap + * @param allTokens all stripped tokens + * @param currIdx index of curr in allTokens */ - private boolean isLikelyGeneric(String code, int pos, char bracket) { - if (bracket == '<') { - // Check for pattern like List<, Map<, etc. - if (pos > 0) { - int start = pos - 1; - while (start > 0 && Character.isLetterOrDigit(code.charAt(start - 1))) { - start--; + private String determineSpacing(Token prevPrev, Token prev, Token curr, + List allTokens, int currIdx) { + + // ---- DOT: never space around dots (method chains, property access) ---- + if (prev.type == TokenType.DOT || curr.type == TokenType.DOT) { + return ""; + } + + // ---- OPERATOR SPACING ---- + if (prev.type == TokenType.OPERATOR || curr.type == TokenType.OPERATOR) { + return determineOperatorSpacing(prevPrev, prev, curr, allTokens, currIdx); + } + + // ---- KEYWORD before PAREN_OPEN: if (...), while (...), etc. ---- + if (prev.type == TokenType.KEYWORD && curr.type == TokenType.PAREN_OPEN) { + return determineKeywordParenSpacing(prev); + } + + // ---- IDENTIFIER before PAREN_OPEN: method call foo(...) ---- + if (prev.type == TokenType.IDENTIFIER && curr.type == TokenType.PAREN_OPEN) { + return settings.spaceBeforeMethodParens ? " " : ""; + } + + // ---- PAREN_CLOSE before BRACE_OPEN: ) { ---- + if (prev.type == TokenType.PAREN_CLOSE && curr.type == TokenType.BRACE_OPEN) { + return settings.spaceBeforeOpenBrace ? " " : ""; + } + + // ---- KEYWORD before BRACE_OPEN: else {, try {, finally { ---- + if (prev.type == TokenType.KEYWORD && curr.type == TokenType.BRACE_OPEN) { + return settings.spaceBeforeOpenBrace ? " " : ""; + } + + // ---- IDENTIFIER/NUMBER/OPERATOR(>) before BRACE_OPEN: class Foo {, enum Bar { ---- + if ((prev.type == TokenType.IDENTIFIER || prev.type == TokenType.NUMBER || + (prev.type == TokenType.OPERATOR && prev.value.equals(">"))) + && curr.type == TokenType.BRACE_OPEN) { + return settings.spaceBeforeOpenBrace ? " " : ""; + } + + // ---- PAREN_OPEN / PAREN_CLOSE: inner spacing ---- + if (prev.type == TokenType.PAREN_OPEN) { + if (curr.type == TokenType.PAREN_CLOSE) return ""; // empty () + return settings.spaceWithinParens ? " " : ""; + } + if (curr.type == TokenType.PAREN_CLOSE) { + return settings.spaceWithinParens ? " " : ""; + } + + // ---- BRACKET_OPEN / BRACKET_CLOSE: inner spacing ---- + if (prev.type == TokenType.BRACKET_OPEN) { + if (curr.type == TokenType.BRACKET_CLOSE) return ""; // empty [] + return settings.spaceWithinBrackets ? " " : ""; + } + if (curr.type == TokenType.BRACKET_CLOSE) { + return settings.spaceWithinBrackets ? " " : ""; + } + + // ---- COMMA spacing ---- + if (prev.type == TokenType.COMMA) { + return settings.spaceAfterComma ? " " : ""; + } + if (curr.type == TokenType.COMMA) { + return settings.spaceBeforeComma ? " " : ""; + } + + // ---- SEMICOLON spacing ---- + if (prev.type == TokenType.SEMICOLON) { + return settings.spaceAfterSemicolon ? " " : ""; + } + if (curr.type == TokenType.SEMICOLON) { + return settings.spaceBeforeSemicolon ? " " : ""; + } + + // ---- COLON spacing (ternary : always gets space, label : uses settings) ---- + if (prev.type == TokenType.COLON) { + if (isTernaryColon(allTokens, currIdx - 1)) return " "; + return settings.spaceAfterColon ? " " : ""; + } + if (curr.type == TokenType.COLON) { + if (isTernaryColon(allTokens, currIdx)) return " "; + return settings.spaceBeforeColon ? " " : ""; + } + + // ---- IDENTIFIER/NUMBER next to BRACKET_OPEN: arr[0] no space ---- + if ((prev.type == TokenType.IDENTIFIER || prev.type == TokenType.NUMBER || + prev.type == TokenType.PAREN_CLOSE) && curr.type == TokenType.BRACKET_OPEN) { + return ""; + } + + // ---- BRACKET_CLOSE before IDENTIFIER/KEYWORD: int[] name, String[] args ---- + if (prev.type == TokenType.BRACKET_CLOSE && + (curr.type == TokenType.IDENTIFIER || curr.type == TokenType.KEYWORD || + curr.type == TokenType.NUMBER)) { + return " "; + } + + // ---- KEYWORD next to KEYWORD, IDENTIFIER, etc: must have space ---- + if (prev.type == TokenType.KEYWORD && + (curr.type == TokenType.KEYWORD || curr.type == TokenType.IDENTIFIER || + curr.type == TokenType.NUMBER)) { + return " "; + } + if (curr.type == TokenType.KEYWORD && + (prev.type == TokenType.KEYWORD || prev.type == TokenType.IDENTIFIER || + prev.type == TokenType.NUMBER || prev.type == TokenType.PAREN_CLOSE || + prev.type == TokenType.BRACE_CLOSE)) { + return " "; + } + + // ---- IDENTIFIER/NUMBER adjacency: need space ---- + if ((prev.type == TokenType.IDENTIFIER || prev.type == TokenType.NUMBER) && + (curr.type == TokenType.IDENTIFIER || curr.type == TokenType.NUMBER)) { + return " "; + } + + // ---- PAREN_CLOSE before IDENTIFIER/KEYWORD: ) instanceof, (int) x ---- + if (prev.type == TokenType.PAREN_CLOSE && + (curr.type == TokenType.IDENTIFIER || curr.type == TokenType.NUMBER)) { + return " "; + } + + // ---- BRACE_OPEN: space after { when followed by code ---- + if (prev.type == TokenType.BRACE_OPEN) { + if (curr.type == TokenType.BRACE_CLOSE) return ""; // empty {} + return settings.spaceWithinBraces ? " " : ""; + } + // ---- BRACE_CLOSE: space before } when preceded by code ---- + if (curr.type == TokenType.BRACE_CLOSE) { + return settings.spaceWithinBraces ? " " : ""; + } + + // Default: no space + return ""; + } + + /** + * Determine spacing around an operator token, considering whether it's + * unary, binary, assignment, comparison, logical, arithmetic, or bitwise. + */ + private String determineOperatorSpacing(Token prevPrev, Token prev, Token curr, + List allTokens, int currIdx) { + // When prev is the operator + if (prev.type == TokenType.OPERATOR) { + String op = prev.value; + + // ++ and -- : never add spaces around them (they bind tightly) + if (op.equals("++") || op.equals("--")) { + return settings.spaceAroundUnaryIncDec ? " " : ""; + } + + // :: method reference: no spaces + if (op.equals("::")) { + return ""; + } + + // Arrow operators -> and => always get spaces + if (op.equals("->") || op.equals("=>")) { + return " "; + } + + // Determine operator category and apply setting + if (isAssignmentOperator(op)) { + return settings.spaceAroundAssignment ? " " : ""; + } + if (isComparisonOperator(op)) { + if ((op.equals("<") || op.equals(">")) && isGenericContext(allTokens, currIdx - 1)) { + if (op.equals(">") && (curr.type == TokenType.IDENTIFIER || curr.type == TokenType.KEYWORD)) { + return " "; + } + return ""; } - String before = code.substring(start, pos); - // Common generic types or capital letter start (type name) - if (!before.isEmpty() && Character.isUpperCase(before.charAt(0))) { + return settings.spaceAroundComparison ? " " : ""; + } + if (isLogicalOperator(op)) { + return settings.spaceAroundLogical ? " " : ""; + } + // Unary ! and ~ — check before bitwise since ~ is in both categories + if (op.equals("!") || op.equals("~")) { + return settings.spaceAroundUnaryNot ? " " : ""; + } + if (isBitwiseOperator(op)) { + return settings.spaceAroundBitwise ? " " : ""; + } + if (isArithmeticOperator(op)) { + // Check unary context: was this operator unary? + // prevPrev is the token before this operator + if (isUnaryOperatorToken(op, null, prevPrev)) { + return ""; // No space after unary operator + } + return settings.spaceAroundArithmetic ? " " : ""; + } + // Ternary ? + if (op.equals("?")) { + return " "; + } + + // Default for unknown operators + return " "; + } + + // When curr is the operator + if (curr.type == TokenType.OPERATOR) { + String op = curr.value; + + // ++ and -- : never add spaces around them + if (op.equals("++") || op.equals("--")) { + return settings.spaceAroundUnaryIncDec ? " " : ""; + } + + // :: method reference: no spaces + if (op.equals("::")) { + return ""; + } + + if (op.equals("->") || op.equals("=>")) { + return " "; + } + + if (isAssignmentOperator(op)) { + return settings.spaceAroundAssignment ? " " : ""; + } + if (isComparisonOperator(op)) { + if ((op.equals("<") || op.equals(">")) && isGenericContext(allTokens, currIdx)) { + // Space before < when preceded by a keyword (e.g. public ) + if (op.equals("<") && prev.type == TokenType.KEYWORD) { + return " "; + } + return ""; + } + return settings.spaceAroundComparison ? " " : ""; + } + if (isLogicalOperator(op)) { + return settings.spaceAroundLogical ? " " : ""; + } + // Unary ! and ~ — check before bitwise since ~ is in both categories + if (op.equals("!") || op.equals("~")) { + return settings.spaceAroundUnaryNot ? " " : ""; + } + if (isBitwiseOperator(op)) { + return settings.spaceAroundBitwise ? " " : ""; + } + if (isArithmeticOperator(op)) { + // Check if unary + if (isUnaryOperatorToken(op, prevPrev, prev)) { + return ""; // No space before unary operator + } + return settings.spaceAroundArithmetic ? " " : ""; + } + // Ternary ? + if (op.equals("?")) { + return " "; + } + + return " "; + } + + return " "; + } + + /** + * Determine spacing between a keyword and a following open-paren. + * Applies settings for if/while/for/switch/catch keywords. + */ + private String determineKeywordParenSpacing(Token keyword) { + String kw = keyword.value; + if (kw.equals("if")) return settings.spaceBeforeIfParens ? " " : ""; + if (kw.equals("while")) return settings.spaceBeforeWhileParens ? " " : ""; + if (kw.equals("for")) return settings.spaceBeforeForParens ? " " : ""; + if (kw.equals("switch")) return settings.spaceBeforeSwitchParens ? " " : ""; + if (kw.equals("catch")) return settings.spaceBeforeCatchParens ? " " : ""; + // For other keywords followed by paren (e.g. return(...) — unusual but allowed) + return " "; + } + + // ---- Operator classification helpers ---- + + /** + * Check if a colon at the given index is part of a ternary expression (? :) + * by scanning backwards for a matching ? operator. + */ + private boolean isTernaryColon(List tokens, int colonIdx) { + for (int i = colonIdx - 1; i >= 0; i--) { + Token t = tokens.get(i); + if (t.type == TokenType.OPERATOR && t.value.equals("?")) return true; + if (t.type == TokenType.SEMICOLON || t.type == TokenType.BRACE_OPEN || + t.type == TokenType.BRACE_CLOSE) return false; + } + return false; + } + + private boolean isAssignmentOperator(String op) { + switch (op) { + case "=": case "+=": case "-=": case "*=": case "/=": case "%=": + case "&=": case "|=": case "^=": case "<<=": case ">>=": case ">>>=": + return true; + default: + return false; + } + } + + private boolean isComparisonOperator(String op) { + switch (op) { + case "==": case "!=": case "===": case "!==": + case "<": case ">": case "<=": case ">=": + return true; + default: + return false; + } + } + + private boolean isLogicalOperator(String op) { + return op.equals("&&") || op.equals("||"); + } + + private boolean isBitwiseOperator(String op) { + switch (op) { + case "&": case "|": case "^": case "~": + case "<<": case ">>": case ">>>": + return true; + default: + return false; + } + } + + private boolean isArithmeticOperator(String op) { + return op.equals("+") || op.equals("-") || op.equals("*") || + op.equals("/") || op.equals("%"); + } + + /** + * Determine if an operator is in unary context based on the previous token. + * Unary context: after operator, open paren/bracket/brace, comma, semicolon, + * colon, keyword, or at start of expression. + */ + private boolean isUnaryOperatorToken(String op, Token prevPrev, Token prevToken) { + // Only +, - can be unary in arithmetic context + if (!op.equals("+") && !op.equals("-")) return false; + + // If prevToken is null (start of expression) → unary + if (prevToken == null) return true; + + // After these token types → unary + switch (prevToken.type) { + case OPERATOR: + case PAREN_OPEN: + case BRACKET_OPEN: + case BRACE_OPEN: + case COMMA: + case SEMICOLON: + case COLON: + case KEYWORD: + return true; + default: + return false; + } + } + + /** + * Check if a < or > operator at the given token index is likely part of a + * generic type declaration (e.g., List). + * Uses surrounding token context rather than regex. + */ + private boolean isGenericContext(List tokens, int opIdx) { + if (opIdx < 0 || opIdx >= tokens.size()) return false; + + Token opToken = tokens.get(opIdx); + String op = opToken.value; + + if (op.equals("<")) { + // Check if preceded by an identifier that looks like a type (starts with uppercase) + // or by known generic-compatible keywords (var, let, const) + Token before = findPrevNonWhitespace(tokens, opIdx); + if (before != null) { + if (before.type == TokenType.IDENTIFIER && !before.value.isEmpty() && + Character.isUpperCase(before.value.charAt(0))) { + return true; + } + if (before.type == TokenType.KEYWORD && + (before.value.equals("var") || before.value.equals("let") || + before.value.equals("const"))) { return true; } } - // Check if there's a matching > + // Check if there's a matching > ahead int depth = 1; - for (int i = pos + 1; i < code.length() && depth > 0; i++) { - char c = code.charAt(i); - if (c == '<') depth++; - else if (c == '>') depth--; - else if (c == ';' || c == '{' || c == '}') break; // Not a generic + for (int i = opIdx + 1; i < tokens.size() && depth > 0; i++) { + Token t = tokens.get(i); + if (t.type == TokenType.WHITESPACE) continue; + if (t.type == TokenType.OPERATOR && t.value.equals("<")) depth++; + else if (t.type == TokenType.OPERATOR && t.value.equals(">")) depth--; + else if (t.type == TokenType.SEMICOLON || t.type == TokenType.BRACE_OPEN || + t.type == TokenType.BRACE_CLOSE) break; // Not a generic } return depth == 0; - } else { // '>' + } else if (op.equals(">")) { // Check if there's a matching < before int depth = 1; - for (int i = pos - 1; i >= 0 && depth > 0; i--) { - char c = code.charAt(i); - if (c == '>') depth++; - else if (c == '<') depth--; - else if (c == ';' || c == '{' || c == '}') break; + for (int i = opIdx - 1; i >= 0 && depth > 0; i--) { + Token t = tokens.get(i); + if (t.type == TokenType.WHITESPACE) continue; + if (t.type == TokenType.OPERATOR && t.value.equals(">")) depth++; + else if (t.type == TokenType.OPERATOR && t.value.equals("<")) depth--; + else if (t.type == TokenType.SEMICOLON || t.type == TokenType.BRACE_OPEN || + t.type == TokenType.BRACE_CLOSE) break; } return depth == 0; } + + return false; } /** - * Format arithmetic operators (+, -, *, /, %) + * Find the previous non-whitespace token before the given index. */ - private String formatArithmeticOperators(String code) { - StringBuilder result = new StringBuilder(); - int i = 0; - while (i < code.length()) { - char c = code.charAt(i); - char next = i + 1 < code.length() ? code.charAt(i + 1) : ' '; - char prev = i > 0 ? code.charAt(i - 1) : ' '; - - boolean isArithOp = c == '+' || c == '-' || c == '*' || c == '/' || c == '%'; - - if (isArithOp) { - // Skip ++, --, +=, -=, *=, /=, %=, and unary +/- - if ((c == '+' && next == '+') || (c == '-' && next == '-') || - (c == '+' && prev == '+') || (c == '-' && prev == '-') || - next == '=') { - result.append(c); - } else if (isUnaryContext(code, i)) { - // Unary + or - (after operator, open paren, comma, etc.) - result.append(c); - } else { - // Binary operator - add spacing - if (result.length() > 0 && result.charAt(result.length() - 1) != ' ') { - result.append(' '); - } - result.append(c); - if (next != ' ' && next != '=' && !((c == '+' && next == '+') || (c == '-' && next == '-'))) { - result.append(' '); - } - } - } else { - result.append(c); + private Token findPrevNonWhitespace(List tokens, int idx) { + for (int i = idx - 1; i >= 0; i--) { + if (tokens.get(i).type != TokenType.WHITESPACE) { + return tokens.get(i); } - i++; } - return result.toString(); + return null; } - /** - * Check if position is in a unary context (operator is unary, not binary) - */ - private boolean isUnaryContext(String code, int pos) { - if (pos == 0) return true; - - // Look back for context - int i = pos - 1; - while (i >= 0 && code.charAt(i) == ' ') { - i--; - } - - if (i < 0) return true; - - char prev = code.charAt(i); - // Unary context after: ( [ { , ; = + - * / % < > & | ^ ? : - return prev == '(' || prev == '[' || prev == '{' || prev == ',' || - prev == ';' || prev == '=' || prev == '+' || prev == '-' || - prev == '*' || prev == '/' || prev == '%' || prev == '<' || - prev == '>' || prev == '&' || prev == '|' || prev == '^' || - prev == '?' || prev == ':' || prev == '!'; - } + // ==================== PHASE 3: RECONSTRUCTOR ==================== /** - * Format bitwise operators + * Reconstruct formatted code from a list of tokens. */ - private String formatBitwiseOperators(String code) { - String result = code; - - // Shift operators first - result = formatBinaryOp(result, ">>>", " >>> "); - result = formatBinaryOp(result, "<<", " << "); - result = formatBinaryOp(result, ">>", " >> "); - - // Single & | ^ (not && ||) + private String reconstruct(List tokens) { StringBuilder sb = new StringBuilder(); - int i = 0; - while (i < result.length()) { - char c = result.charAt(i); - char next = i + 1 < result.length() ? result.charAt(i + 1) : ' '; - char prev = i > 0 ? result.charAt(i - 1) : ' '; - - if ((c == '&' && next != '&' && prev != '&' && next != '=') || - (c == '|' && next != '|' && prev != '|' && next != '=') || - (c == '^' && next != '=')) { - if (sb.length() > 0 && sb.charAt(sb.length() - 1) != ' ') { - sb.append(' '); - } - sb.append(c); - if (next != ' ') { - sb.append(' '); - } - } else { - sb.append(c); - } - i++; + for (Token t : tokens) { + sb.append(t.value); } - return sb.toString(); } - // ==================== BRACKET FORMATTING ==================== - /** - * Format bracket spacing - */ - private String formatBrackets(String code) { - String result = code; - - // Parentheses - if (settings.spaceWithinParens) { - result = result.replaceAll("\\(\\s*", "( "); - result = result.replaceAll("\\s*\\)", " )"); - } else { - result = result.replaceAll("\\(\\s+", "("); - result = result.replaceAll("\\s+\\)", ")"); - } - - // Square brackets - if (settings.spaceWithinBrackets) { - result = result.replaceAll("\\[\\s*", "[ "); - result = result.replaceAll("\\s*\\]", " ]"); - } else { - result = result.replaceAll("\\[\\s+", "["); - result = result.replaceAll("\\s+\\]", "]"); - } - - // Curly braces (for array initializers inline) - // Note: standalone braces for blocks are handled by indentation logic - - return result; - } - - // ==================== KEYWORD FORMATTING ==================== - - /** - * Format keyword spacing (if, while, for, etc.) - */ - private String formatKeywords(String code) { - String result = code; - - if (settings.spaceBeforeIfParens) { - result = result.replaceAll("\\bif\\s*\\(", "if ("); - } else { - result = result.replaceAll("\\bif\\s+\\(", "if("); - } - - if (settings.spaceBeforeWhileParens) { - result = result.replaceAll("\\bwhile\\s*\\(", "while ("); - } else { - result = result.replaceAll("\\bwhile\\s+\\(", "while("); - } - - if (settings.spaceBeforeForParens) { - result = result.replaceAll("\\bfor\\s*\\(", "for ("); - } else { - result = result.replaceAll("\\bfor\\s+\\(", "for("); - } - - if (settings.spaceBeforeSwitchParens) { - result = result.replaceAll("\\bswitch\\s*\\(", "switch ("); - } else { - result = result.replaceAll("\\bswitch\\s+\\(", "switch("); - } - - if (settings.spaceBeforeCatchParens) { - result = result.replaceAll("\\bcatch\\s*\\(", "catch ("); - } else { - result = result.replaceAll("\\bcatch\\s+\\(", "catch("); - } - - // Space before opening brace - if (settings.spaceBeforeOpenBrace) { - result = result.replaceAll("\\)\\s*\\{", ") {"); - } else { - result = result.replaceAll("\\)\\s+\\{", "){"); - } - - return result; - } - - // ==================== PUNCTUATION FORMATTING ==================== - - /** - * Format punctuation spacing (commas, semicolons, colons) - */ - private String formatPunctuation(String code) { - String result = code; - - // Commas - if (settings.spaceAfterComma && !settings.spaceBeforeComma) { - result = result.replaceAll("\\s*,\\s*", ", "); - } else if (settings.spaceAfterComma && settings.spaceBeforeComma) { - result = result.replaceAll("\\s*,\\s*", " , "); - } else if (!settings.spaceAfterComma && settings.spaceBeforeComma) { - result = result.replaceAll("\\s*,\\s*", " ,"); - } else { - result = result.replaceAll("\\s*,\\s*", ","); - } - - // Semicolons (but not in for loops - handle more carefully) - // This is tricky because for(;;) should be handled differently - // For now, just handle trailing semicolons - if (settings.trimTrailingWhitespace) { - result = result.replaceAll("\\s+;", ";"); - } - - return result; - } - - /** - * Trim trailing whitespace from a line + * Trim trailing whitespace from a line. */ private String trimTrailing(String line) { int end = line.length(); @@ -876,19 +1431,76 @@ public class FormatHelper { // ==================== STATIC UTILITIES ==================== /** - * Format code with default settings + * Format code with default settings. */ public static String formatCode(String code) { return new FormatHelper().format(code); } /** - * Format code with custom settings + * Format code with custom settings. */ public static String formatCode(String code, FormatSettings settings) { return new FormatHelper(settings).format(code); } + /** + * Sanitize clipboard text for paste into the script editor. + *

+ * This is a paste-only cleanup intended to prevent large trailing + * whitespace runs from causing misleading soft-wrap splits in the editor. + *

+ * Processing: + *

    + *
  • Normalizes line separators ({@code \r\n} and bare {@code \r}) to {@code \n}.
  • + *
  • For each line, strips trailing spaces/tabs only when the trailing + * whitespace run length is ≥ {@code trimThreshold}.
  • + *
  • Preserves all leading whitespace, interior spacing, and newline structure + * (trailing empty lines are kept).
  • + *
+ * The threshold avoids clobbering intentional minor trailing spaces while still + * removing the large padding blocks that confuse soft-wrap layout. + * + * @param clipboard the raw clipboard text (may be {@code null} or empty) + * @param trimThreshold minimum trailing whitespace run length to trigger trimming; + * runs shorter than this are left intact + * @return sanitized text, or the original reference if {@code null}/empty + */ + public static String sanitizeClipboard(String clipboard, int trimThreshold) { + if (clipboard == null || clipboard.isEmpty()) { + return clipboard; + } + + // Normalize line separators: \r\n -> \n, then bare \r -> \n + String normalized = clipboard.replace("\r\n", "\n").replace("\r", "\n"); + + String[] lines = normalized.split("\n", -1); + StringBuilder result = new StringBuilder(normalized.length()); + + for (int i = 0; i < lines.length; i++) { + String line = lines[i]; + + // Measure trailing whitespace run length + int end = line.length(); + while (end > 0 && (line.charAt(end - 1) == ' ' || line.charAt(end - 1) == '\t')) { + end--; + } + int trailingLen = line.length() - end; + + if (trailingLen >= trimThreshold) { + result.append(line, 0, end); + } else { + result.append(line); + } + + if (i < lines.length - 1) { + result.append('\n'); + } + } + + return result.toString(); + } + // ==================== LINE WRAPPING ==================== /** @@ -932,7 +1544,7 @@ public class FormatHelper { } /** - * Get visual length of a line (tabs count as 4 spaces) + * Get visual length of a line (tabs count as 4 spaces). */ private int getVisualLength(String line) { int len = 0; @@ -947,7 +1559,7 @@ public class FormatHelper { } /** - * Extract leading indentation from a line + * Extract leading indentation from a line. */ private String extractIndent(String line) { int i = 0; @@ -958,7 +1570,7 @@ public class FormatHelper { } /** - * Wrap a single-line comment (// style) + * Wrap a single-line comment (// style). */ private String wrapCommentLine(String line, int maxWidth) { if (!settings.wrapComments) return line; @@ -1005,7 +1617,7 @@ public class FormatHelper { } /** - * Wrap a block comment line (* style) + * Wrap a block comment line (* style). */ private String wrapBlockCommentLine(String line, int maxWidth) { if (!settings.wrapComments) return line; @@ -1081,21 +1693,184 @@ public class FormatHelper { } /** - * Wrap a code line at appropriate break points + * Find the start position of an inline line comment ({@code //}) in a code line, + * correctly skipping {@code //} inside string literals and block comments. + * + * @return index of the {@code //} in content, or -1 if no inline comment exists + */ + private int findInlineCommentStart(String content) { + boolean inString = false; + char stringChar = 0; + + for (int i = 0; i < content.length(); i++) { + char c = content.charAt(i); + char prev = i > 0 ? content.charAt(i - 1) : 0; + + if ((c == '"' || c == '\'') && prev != '\\') { + if (!inString) { + inString = true; + stringChar = c; + } else if (c == stringChar) { + inString = false; + } + } + + if (inString) continue; + + // Skip block comments + if (c == '/' && i + 1 < content.length() && content.charAt(i + 1) == '*') { + int endBlock = content.indexOf("*/", i + 2); + if (endBlock >= 0) { + i = endBlock + 1; + continue; + } + } + + if (c == '/' && i + 1 < content.length() && content.charAt(i + 1) == '/') { + return i; + } + } + + return -1; + } + + /** + * Word-wrap a comment string across multiple {@code //} continuation lines. + * Each continuation line uses the given prefix (indent + "// "). + * + * @param commentText the text after {@code //} (already trimmed) + * @param prefix indent + "// " for each continuation line + * @param maxWidth maximum line width + * @param firstLineCapacity chars available on the first output line (-1 to start fresh) + * @return the wrapped comment lines joined with newlines + */ + private String wordWrapComment(String commentText, String prefix, int maxWidth, + int firstLineCapacity) { + if (commentText.isEmpty()) return "//"; + + String[] words = commentText.split("\\s+"); + int prefixLen = getVisualLength(prefix); + int contentWidth = maxWidth - prefixLen; + if (contentWidth <= 10) { + return "// " + commentText; + } + + StringBuilder result = new StringBuilder(); + boolean onFirstLine = (firstLineCapacity > 0); + int capacity = onFirstLine ? firstLineCapacity : contentWidth; + int lineLen = 0; + + if (!onFirstLine) { + result.append(prefix); + } else { + result.append("// "); + lineLen = 3; + } + + for (int i = 0; i < words.length; i++) { + String word = words[i]; + int wordLen = word.length(); + + if (lineLen + (lineLen > (onFirstLine ? 3 : 0) ? 1 : 0) + wordLen > capacity && lineLen > 0) { + result.append("\n").append(prefix); + lineLen = 0; + capacity = contentWidth; + onFirstLine = false; + } + + if (lineLen > 0) { + result.append(" "); + lineLen++; + } + + result.append(word); + lineLen += wordLen; + } + + return result.toString(); + } + + /** + * Wrap a code line at appropriate break points, with intelligent inline comment handling. + *

+ * If the line has a trailing {@code // comment}, the comment is extracted first. + * The code portion is wrapped normally, then the comment is reattached: + *

    + *
  • If code + comment fit within maxWidth → keep inline
  • + *
  • If only the code fits → comment moves to its own indented line
  • + *
  • If the comment is very long → it gets word-wrapped across multiple lines
  • + *
*/ private String wrapCodeLine(String line, int maxWidth) { String indent = extractIndent(line); String content = line.substring(indent.length()); - // Additional indent for wrapped lines - String wrapIndent = indent + spaces(settings.wrapIndentSpaces); + // --- Phase 1: Detect and extract inline comment --- + int commentStart = findInlineCommentStart(content); + String codePart = content; + String commentPart = null; + + if (commentStart >= 0) { + codePart = content.substring(0, commentStart); + commentPart = content.substring(commentStart); + // Trim trailing space from code part + while (!codePart.isEmpty() && codePart.charAt(codePart.length() - 1) == ' ') { + codePart = codePart.substring(0, codePart.length() - 1); + } + } + + // --- Phase 2: Wrap the code part (without the comment) --- + String wrappedCode = wrapCodeContent(codePart, indent, maxWidth); + + // --- Phase 3: Reattach the comment intelligently --- + if (commentPart == null) { + return wrappedCode; + } + + // Find the last line of the wrapped code to measure available space + int lastNewline = wrappedCode.lastIndexOf('\n'); + String lastLine = (lastNewline >= 0) ? wrappedCode.substring(lastNewline + 1) : wrappedCode; + int lastLineLen = getVisualLength(lastLine); + + // Measure the comment: " // comment text" + int commentLen = 1 + getVisualLength(commentPart); // +1 for the space separator + + // Strategy A: Comment fits inline on the last line + if (lastLineLen + commentLen <= maxWidth) { + return wrappedCode + " " + commentPart; + } + + // Strategy B: Comment on its own line(s), indented to match original code level + String commentIndent = indent; + String commentText = commentPart.startsWith("//") ? + commentPart.substring(2).trim() : commentPart; + String commentPrefix = commentIndent + "// "; + int availableWidth = maxWidth - getVisualLength(commentPrefix); + + if (availableWidth > 10 && getVisualLength(commentText) > availableWidth) { + // Word-wrap the long comment + String wrappedComment = wordWrapComment(commentText, commentPrefix, maxWidth, -1); + return wrappedCode + "\n" + wrappedComment; + } else { + return wrappedCode + "\n" + commentPrefix + commentText; + } + } + + /** + * Core code wrapping logic (extracted from old wrapCodeLine, operates on code without comments). + */ + private String wrapCodeContent(String content, String indent, int maxWidth) { + String wrapIndent = indent + spaces(settings.wrapIndentSpaces); + String fullLine = indent + content; + + if (getVisualLength(fullLine) <= maxWidth) { + return fullLine; + } - // Find break points - positions where we can break the line List breakPoints = findBreakPoints(content); if (breakPoints.isEmpty()) { - // No good break points, just return as-is - return line; + return fullLine; } StringBuilder result = new StringBuilder(); @@ -1110,17 +1885,13 @@ public class FormatHelper { String segment = content.substring(lastBreak, segmentEnd); int segmentLen = getVisualLength(segment); - // Check if adding this segment would exceed max width if (currentLen + segmentLen > maxWidth && !isFirstLine) { - // Break here result.append("\n").append(wrapIndent); currentLen = getVisualLength(wrapIndent); isFirstLine = false; - // Trim leading space from continuation if any segment = trimLeading(segment); } else if (currentLen + segmentLen > maxWidth && isFirstLine && lastBreak > 0) { - // Even first segment is too long after indent, break before it result.append("\n").append(wrapIndent); currentLen = getVisualLength(wrapIndent); isFirstLine = false; @@ -1132,7 +1903,6 @@ public class FormatHelper { isFirstLine = false; } - // Append remaining content if (lastBreak < content.length()) { String remaining = content.substring(lastBreak); int remLen = getVisualLength(remaining); @@ -1149,7 +1919,7 @@ public class FormatHelper { } /** - * Trim leading whitespace (Java 8 compatible) + * Trim leading whitespace (Java 8 compatible). */ private String trimLeading(String s) { int start = 0; @@ -1160,7 +1930,7 @@ public class FormatHelper { } /** - * A potential line break point + * A potential line break point. */ private static class BreakPoint { int position; // Position in string (after this char) @@ -1174,7 +1944,7 @@ public class FormatHelper { } /** - * Find good positions to break a line + * Find good positions to break a line. */ private List findBreakPoints(String content) { List points = new ArrayList<>(); @@ -1253,7 +2023,7 @@ public class FormatHelper { } /** - * Create a string of n spaces + * Create a string of n spaces. */ private String spaces(int n) { StringBuilder sb = new StringBuilder(); @@ -1264,7 +2034,7 @@ public class FormatHelper { } /** - * Format and wrap code in one step + * Format and wrap code in one step. */ public String formatAndWrap(String text, int maxWidth) { String formatted = format(text); diff --git a/src/main/java/noppes/npcs/client/gui/util/script/JavaTextContainer.java b/src/main/java/noppes/npcs/client/gui/util/script/JavaTextContainer.java index fe09cb81a..b54b1cf1d 100644 --- a/src/main/java/noppes/npcs/client/gui/util/script/JavaTextContainer.java +++ b/src/main/java/noppes/npcs/client/gui/util/script/JavaTextContainer.java @@ -8,6 +8,7 @@ import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern; +@Deprecated public class JavaTextContainer extends TextContainer { public static final Pattern MODIFIER = Pattern.compile( diff --git a/src/main/java/noppes/npcs/client/gui/util/script/RenameRefactorHandler.java b/src/main/java/noppes/npcs/client/gui/util/script/RenameRefactorHandler.java index 81c346f8f..15a71a900 100644 --- a/src/main/java/noppes/npcs/client/gui/util/script/RenameRefactorHandler.java +++ b/src/main/java/noppes/npcs/client/gui/util/script/RenameRefactorHandler.java @@ -2,6 +2,12 @@ package noppes.npcs.client.gui.util.script; import net.minecraft.client.gui.GuiScreen; import noppes.npcs.client.gui.util.script.JavaTextContainer.LineData; +import noppes.npcs.client.gui.util.script.interpreter.ScriptDocument; +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.jsdoc.JSDocInfo; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocParamTag; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; import org.lwjgl.input.Keyboard; import java.util.ArrayList; @@ -11,7 +17,7 @@ import java.util.regex.Pattern; /** * Handles IntelliJ-like rename refactoring with scope-aware renaming. - *

+ * * Features: * - Scope detection: local variables rename only within their block, global fields rename everywhere * - Visual feedback: primary occurrence has white border, others just highlighted @@ -32,7 +38,11 @@ public class RenameRefactorHandler { private int primaryOccurrenceEnd = -1; private List allOccurrences = new ArrayList<>(); private ScopeInfo scope = null; - + + // For parameter renaming: track containing method to find JSDoc + private boolean isParameterRename = false; + private MethodInfo containingMethod = null; + // For global scope, track positions that have local shadowing (to exclude them) private List localShadowedPositions = new ArrayList<>(); @@ -82,32 +92,11 @@ public class RenameRefactorHandler { void scrollToPosition(int pos); - JavaTextContainer getContainer(); + ScriptTextContainer getContainer(); int getViewportWidth(); // For determining if clicks are in rename box } - /** - * Scope information for a variable - */ - public static class ScopeInfo { - public final int startOffset; - public final int endOffset; - public final boolean isGlobal; - public final String scopeType; // "global", "method", "block" - - public ScopeInfo(int start, int end, boolean isGlobal, String type) { - this.startOffset = start; - this.endOffset = end; - this.isGlobal = isGlobal; - this.scopeType = type; - } - - public boolean containsPosition(int pos) { - return pos >= startOffset && pos < endOffset; - } - } - public void setCallback(RenameCallback callback) { this.callback = callback; } @@ -140,29 +129,62 @@ public class RenameRefactorHandler { initialWord = text.substring(wordBounds[0], wordBounds[1]); // Remember for undo originalWord = initialWord; currentWord = initialWord; - + // Determine scope for this identifier - MUST check if local shadows global scope = determineScope(text, wordBounds[0], originalWord, callback.getContainer()); - + + // Track if this is a parameter rename by checking if position is in any method's parameter declaration + isParameterRename = false; + containingMethod = null; + + ScriptTextContainer container = callback.getContainer(); + if (container != null && container.getDocument() != null) { + ScriptDocument document = container.getDocument(); + List methods = document.getAllMethods(); + + // Check if the word at cursor position is a parameter of any method + // A rename is a parameter rename if: + // 1. The word matches a parameter name + // 2. The cursor is within that method's declaration or body + for (MethodInfo method : methods) { + // Check if cursor is within this method's range + int methodStart = method.getFullDeclarationOffset(); + int methodEnd = method.getBodyEnd(); + if (methodStart < 0 || methodEnd < 0) continue; // External method + + if (wordBounds[0] >= methodStart && wordBounds[0] <= methodEnd) { + // Check if the word matches any parameter of this method + for (FieldInfo param : method.getParameters()) { + if (param.getName().equals(originalWord)) { + isParameterRename = true; + containingMethod = method; + break; + } + } + if (isParameterRename) break; + } + } + } + // If global scope, find all positions where local variables shadow this name localShadowedPositions.clear(); if (scope != null && scope.isGlobal) { findLocalShadowedPositions(text, originalWord); } - // Find all occurrences within scope + // Find all occurrences within scope (including JSDoc if it's a parameter) findOccurrences(text, originalWord); if (allOccurrences.isEmpty()) return false; active = true; - + // Set selection to full word (uses GuiScriptTextArea's selection) primaryOccurrenceStart = wordBounds[0]; primaryOccurrenceEnd = wordBounds[1]; callback.getSelectionState().setSelection(wordBounds[0], wordBounds[1]); - // callback.setCursorPosition(wordBounds[1]); + // callback.setCursorPosition(wordBounds[1]); callback.getSelectionState().markActivity(); return true; @@ -206,7 +228,7 @@ public class RenameRefactorHandler { // During live editing we used setTextWithoutUndo to avoid creating intermediate // undo entries; pushing the original snapshot here gives a single predictable // undo step back to the pre-rename state. - if (originalText != null && !originalText.isEmpty()) + if (originalText != null && !originalText.isEmpty()) callback.pushUndoState(originalText, originalCursorPos); // Calculate cursor position relative to primary occurrence @@ -230,13 +252,14 @@ public class RenameRefactorHandler { allOccurrences.clear(); localShadowedPositions.clear(); scope = null; + isParameterRename = false; + containingMethod = null; originalText = ""; originalCursorPos = 0; } /** * Handle keyboard input during rename - * * @return true if input was consumed */ public boolean keyTyped(char c, int keyCode) { @@ -264,7 +287,7 @@ public class RenameRefactorHandler { // Get selection state SelectionState sel = callback.getSelectionState(); boolean hasSelection = sel.hasSelection(); - + // Calculate cursor position within the word int cursorInWord = callback.getCursorPosition() - primaryOccurrenceStart; cursorInWord = Math.max(0, Math.min(cursorInWord, currentWord.length())); @@ -315,7 +338,7 @@ public class RenameRefactorHandler { sel.setSelection(primaryOccurrenceStart, primaryOccurrenceStart); callback.setCursorPosition(primaryOccurrenceStart); } - + // Left arrow if (keyCode == Keyboard.KEY_LEFT) { if (cursorInWord > 0) { @@ -354,7 +377,7 @@ public class RenameRefactorHandler { // Ctrl+A - select all (select the whole word) if (keyCode == Keyboard.KEY_A && - Keyboard.isKeyDown(Keyboard.KEY_LCONTROL)) { + Keyboard.isKeyDown(Keyboard.KEY_LCONTROL)) { sel.setSelection(primaryOccurrenceStart, primaryOccurrenceStart + currentWord.length()); callback.setCursorPosition(primaryOccurrenceStart + currentWord.length()); sel.markActivity(); @@ -536,23 +559,86 @@ public class RenameRefactorHandler { allOccurrences.add(new int[]{start, end}); } } + + // If this is a parameter rename, also look for JSDoc @param occurrences + if (isParameterRename && containingMethod != null) { + findJSDocParamOccurrences(text, word); + } } - + + /** + * Find JSDoc @param occurrences for a parameter name. + * Uses the JSDocInfo stored in the MethodInfo to locate the JSDoc comment, + * then searches for the parameter name pattern in the current text. + */ + private void findJSDocParamOccurrences(String text, String paramName) { + if (containingMethod == null) return; + + // Get the JSDocInfo from the method to verify it has a @param for our parameter + JSDocInfo jsDocInfo = containingMethod.getJSDocInfo(); + if (jsDocInfo == null) return; + + // Check that this parameter has a JSDoc @param tag (using initial word to find the tag definition) + JSDocParamTag paramTag = jsDocInfo.getParamTag(initialWord); + if (paramTag == null) return; + + // Get the approximate JSDoc location from the original document + int originalJsDocStart = jsDocInfo.getStartOffset(); + int originalJsDocEnd = jsDocInfo.getEndOffset(); + if (originalJsDocStart < 0 || originalJsDocEnd < 0) return; + + // Calculate how much positions have shifted due to renames before the JSDoc + // Count occurrences that are currently in the text before the original JSDoc start + int shiftBeforeJsDoc = 0; + int lengthDiff = paramName.length() - initialWord.length(); + + // The occurrences we've already found (code occurrences) - count how many are before the JSDoc + for (int[] occ : allOccurrences) { + // Map current position back to approximate original position + int approxOriginalPos = occ[0] - shiftBeforeJsDoc; + if (approxOriginalPos < originalJsDocStart) { + shiftBeforeJsDoc += lengthDiff; + } + } + + // Now search for the @param pattern in the current text around where the JSDoc should be + int adjustedJsDocStart = originalJsDocStart + shiftBeforeJsDoc; + int adjustedJsDocEnd = originalJsDocEnd + shiftBeforeJsDoc; + + // Clamp to text bounds + adjustedJsDocStart = Math.max(0, adjustedJsDocStart); + adjustedJsDocEnd = Math.min(text.length(), adjustedJsDocEnd + 50); // Add some buffer for expanded text + + if (adjustedJsDocStart >= adjustedJsDocEnd) return; + + String jsDocRegion = text.substring(adjustedJsDocStart, adjustedJsDocEnd); + + // Search for @param {Type} paramName or @param paramName pattern + Pattern pattern = Pattern.compile("@param\\s+(?:\\{[^}]*\\}\\s+)?(" + Pattern.quote(paramName) + ")(?:\\s|$|-)"); + Matcher m = pattern.matcher(jsDocRegion); + + while (m.find()) { + int paramNameStart = adjustedJsDocStart + m.start(1); + int paramNameEnd = adjustedJsDocStart + m.end(1); + allOccurrences.add(new int[]{paramNameStart, paramNameEnd}); + } + } + /** * Find all positions where local variables with the same name shadow the global variable. * This populates localShadowedPositions with ranges where local declarations exist. */ private void findLocalShadowedPositions(String text, String varName) { localShadowedPositions.clear(); - + List methods = MethodBlock.collectMethodBlocks(text); List excluded = MethodBlock.getExcludedRanges(text); - + for (MethodBlock method : methods) { // Check if this method has a local variable or parameter with the same name boolean hasLocalDecl = method.localVariables.contains(varName); boolean hasParamDecl = isParameterInMethod(text, varName, method); - + if (hasLocalDecl || hasParamDecl) { // Find where the local/param scope starts int scopeStart; @@ -564,18 +650,18 @@ public class RenameRefactorHandler { scopeStart = findLocalDeclarationPosition(text, varName, method); if (scopeStart < 0) scopeStart = method.startOffset; } - + // Find all occurrences of varName within this method's shadowed range Pattern pattern = Pattern.compile("\\b" + Pattern.quote(varName) + "\\b"); Matcher m = pattern.matcher(text); - + while (m.find()) { int pos = m.start(); - + // Skip if in string or comment if (isInExcludedRange(pos, excluded)) continue; - + // Check if within the shadowed scope of this method if (pos >= scopeStart && pos < method.endOffset) { localShadowedPositions.add(new int[]{m.start(), m.end()}); @@ -584,7 +670,7 @@ public class RenameRefactorHandler { } } } - + /** * Check if a position is within a locally shadowed range */ @@ -595,13 +681,13 @@ public class RenameRefactorHandler { } return false; } - + /** * Check if varName is a parameter in the method */ private boolean isParameterInMethod(String text, String varName, MethodBlock method) { String methodHeader = text.substring(method.startOffset, - Math.min(method.startOffset + 500, method.endOffset)); + Math.min(method.startOffset + 500, method.endOffset)); int parenStart = methodHeader.indexOf('('); int parenEnd = methodHeader.indexOf(')'); if (parenStart >= 0 && parenEnd > parenStart) { @@ -687,7 +773,7 @@ public class RenameRefactorHandler { // Cursor is inside a method // Check if it's a method parameter first String methodHeader = text.substring(containingMethod.startOffset, - Math.min(containingMethod.startOffset + 500, containingMethod.endOffset)); + Math.min(containingMethod.startOffset + 500, containingMethod.endOffset)); int parenStart = methodHeader.indexOf('('); int parenEnd = methodHeader.indexOf(')'); if (parenStart >= 0 && parenEnd > parenStart) { @@ -861,9 +947,9 @@ public class RenameRefactorHandler { public boolean isWordFullySelected() { if (callback == null) return false; SelectionState selection = callback.getSelectionState(); - return selection.hasSelection() && - selection.getStartSelection() == primaryOccurrenceStart && - selection.getEndSelection() == primaryOccurrenceEnd; + return selection.hasSelection() && + selection.getStartSelection() == primaryOccurrenceStart && + selection.getEndSelection() == primaryOccurrenceEnd; } /** @@ -884,7 +970,7 @@ public class RenameRefactorHandler { public boolean handleClick(int clickPosInText) { if (!active || callback == null) return false; - + return false; } diff --git a/src/main/java/noppes/npcs/client/gui/util/script/ScopeInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/ScopeInfo.java new file mode 100644 index 000000000..f06454597 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/ScopeInfo.java @@ -0,0 +1,26 @@ +package noppes.npcs.client.gui.util.script; + +/** + * Scope information for a variable + */ +public class ScopeInfo { + public final int startOffset; + public final int endOffset; + public final boolean isGlobal; + public final String scopeType; // "global", "method", "block" + + public ScopeInfo(int start, int end, boolean isGlobal, String type) { + this.startOffset = start; + this.endOffset = end; + this.isGlobal = isGlobal; + this.scopeType = type; + } + + public boolean containsPosition(int pos) { + return pos >= startOffset && pos < endOffset; + } + + public boolean isWithin(ScopeInfo other) { + return this.startOffset >= other.startOffset && this.endOffset <= other.endOffset; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/ScrollState.java b/src/main/java/noppes/npcs/client/gui/util/script/ScrollState.java index 4d71a6b62..f8c92d64a 100644 --- a/src/main/java/noppes/npcs/client/gui/util/script/ScrollState.java +++ b/src/main/java/noppes/npcs/client/gui/util/script/ScrollState.java @@ -21,12 +21,12 @@ public class ScrollState { private int scrollbarDragOffset = 0; // Whether currently dragging the scrollbar private boolean clickScrolling = false; - + // Animation parameters - private static final double TAU = 0.1; // Time constant (~55ms feels snappy) - private static final double SNAP_THRESHOLD = 0.01; // Snap to target when this close - private static final double MAX_DT = 0.05; // Max delta time for stability - + private static final double TAU = 0.15; // Time constant (~55ms feels snappy) + private static final double SNAP_THRESHOLD = 0.1; // Snap to target when this close (increased to avoid microstutters) + private static final double MAX_DT = 0.1; // Max delta time for stability + /** * Reset scroll state to initial values */ @@ -37,7 +37,7 @@ public class ScrollState { scrolledLine = 0; lastScrollTime = System.currentTimeMillis(); } - + /** * Initialize scroll position if not already initialized */ @@ -47,19 +47,18 @@ public class ScrollState { lastScrollTime = System.currentTimeMillis(); } } - + /** * Update scroll animation. Call once per frame. - * * @param maxScroll Maximum valid scroll position */ public void update(int maxScroll) { long nowMs = System.currentTimeMillis(); double dt = Math.min(MAX_DT, (nowMs - lastScrollTime) / 1000.0); lastScrollTime = nowMs; - + double dist = targetScroll - scrollPos; - + // Snap to target if close enough if (Math.abs(dist) < SNAP_THRESHOLD) { scrollPos = targetScroll; @@ -70,21 +69,21 @@ public class ScrollState { double prev = scrollPos; scrollPos += dist * alpha; scrollVelocity = (scrollPos - prev) / (dt > 0 ? dt : 1e-6); - + // Clamp overshoot if ((dist > 0 && scrollPos > targetScroll) || (dist < 0 && scrollPos < targetScroll)) { scrollPos = targetScroll; scrollVelocity = 0.0; } } - + // Keep in bounds clampToBounds(maxScroll); - + // Update integer line for rendering scrolledLine = Math.max(0, Math.min((int) Math.floor(scrollPos), maxScroll)); } - + /** * Clamp scroll position to valid bounds */ @@ -95,37 +94,35 @@ public class ScrollState { if (targetScroll > maxScroll) targetScroll = maxScroll; scrolledLine = Math.max(0, Math.min(scrolledLine, maxScroll)); } - + /** * Apply mouse wheel scroll - * * @param wheelDelta Positive = scroll up, negative = scroll down - * @param maxScroll Maximum valid scroll position + * @param maxScroll Maximum valid scroll position */ public void applyWheelScroll(int wheelDelta, int maxScroll) { double sign = Math.copySign(1, wheelDelta); targetScroll -= sign * 2.0; // 2 lines per wheel tick clampToBounds(maxScroll); } - + /** * Set target scroll directly (for scrollbar dragging) */ public void setTargetScroll(double target, int maxScroll) { targetScroll = Math.max(0, Math.min(target, maxScroll)); } - + /** * Scroll to make a specific line visible - * - * @param lineIdx Line index to make visible + * @param lineIdx Line index to make visible * @param visibleLines Number of visible lines in viewport - * @param maxScroll Maximum scroll position + * @param maxScroll Maximum scroll position */ public void scrollToLine(int lineIdx, int visibleLines, int maxScroll) { int firstVisible = scrolledLine; int lastFullyVisible = scrolledLine + visibleLines; - + if (lineIdx < firstVisible) { // Line is above viewport - scroll up targetScroll = lineIdx; @@ -135,66 +132,41 @@ public class ScrollState { } // If line is visible, don't change scroll } - + // Getters - public double getScrollPos() { - return scrollPos; - } + public double getScrollPos() { return scrollPos; } + public double getTargetScroll() { return targetScroll; } - public double getTargetScroll() { - return targetScroll; - } - - /** - * @return First visible line - **/ + /** @return First visible line **/ public int getScrolledLine() { return scrolledLine; } - - public double getScrollVelocity() { - return scrollVelocity; - } - - public boolean isClickScrolling() { - return clickScrolling; - } - - public int getScrollbarDragOffset() { - return scrollbarDragOffset; - } - + public double getScrollVelocity() { return scrollVelocity; } + public boolean isClickScrolling() { return clickScrolling; } + public int getScrollbarDragOffset() { return scrollbarDragOffset; } + /** * Get fractional offset for sub-pixel rendering */ public double getFractionalOffset() { return scrollPos - scrolledLine; } - + // Setters for scrollbar interaction - public void setClickScrolling(boolean scrolling) { - this.clickScrolling = scrolling; - } - - public void setScrollbarDragOffset(int offset) { - this.scrollbarDragOffset = offset; - } - - public void setScrolledLine(int line) { - this.scrolledLine = line; - } + public void setClickScrolling(boolean scrolling) { this.clickScrolling = scrolling; } + public void setScrollbarDragOffset(int offset) { this.scrollbarDragOffset = offset; } + public void setScrolledLine(int line) { this.scrolledLine = line; } /** * Handle scrollbar dragging interaction. This encapsulates the logic that was * previously in the GUI class for handling thumb clicks/drags. - * - * @param yMouse current mouse Y coordinate - * @param areaX GUI area X (unused but kept for parity) - * @param areaY GUI area Y (top of text area) - * @param areaHeight height of the scroll track area + * @param yMouse current mouse Y coordinate + * @param areaX GUI area X (unused but kept for parity) + * @param areaY GUI area Y (top of text area) + * @param areaHeight height of the scroll track area * @param visibleLines number of visible lines in viewport - * @param linesCount total number of lines - * @param maxScroll maximum allowed scroll value + * @param linesCount total number of lines + * @param maxScroll maximum allowed scroll value */ public void handleClickScrolling(int yMouse, int areaX, int areaY, int areaHeight, int visibleLines, int linesCount, int maxScroll) { // Keep dragging while mouse button is down @@ -238,4 +210,4 @@ public class ScrollState { int thumbTop = (int) (areaY + 1f * getScrollPos() / linesCountD * (areaHeight - 4)) + 1; setScrollbarDragOffset(yMouse - thumbTop); } -} +} \ No newline at end of file diff --git a/src/main/java/noppes/npcs/client/gui/util/script/SearchReplaceBar.java b/src/main/java/noppes/npcs/client/gui/util/script/SearchReplaceBar.java index 32e835aaf..5e783d227 100644 --- a/src/main/java/noppes/npcs/client/gui/util/script/SearchReplaceBar.java +++ b/src/main/java/noppes/npcs/client/gui/util/script/SearchReplaceBar.java @@ -5,6 +5,7 @@ import net.minecraft.client.gui.FontRenderer; import net.minecraft.client.gui.Gui; import net.minecraft.util.ChatAllowedCharacters; import net.minecraft.util.ResourceLocation; +import noppes.npcs.client.gui.util.GuiNPCInterface; import noppes.npcs.client.gui.util.GuiScriptTextArea.UndoData; import noppes.npcs.client.gui.util.GuiUtil; import noppes.npcs.client.gui.util.key.OverlayKeyPresetViewer; @@ -35,6 +36,7 @@ public class SearchReplaceBar { // ==================== DIMENSIONS ==================== private int x, y, width; + public GuiNPCInterface ownerGui; private int barHeight = 24; private int replaceBarHeight = 22; private int textFieldWidth = 150; @@ -538,7 +540,7 @@ public class SearchReplaceBar { } GL11.glEnable(GL11.GL_SCISSOR_TEST); - GuiUtil.setScissorClip(fieldX + 2, fieldY, fieldWidth - 4, fieldHeight); + GuiUtil.setScissorClip(fieldX + 2, fieldY, fieldWidth - 4, fieldHeight, ownerGui); // Draw selection highlight @@ -604,7 +606,7 @@ public class SearchReplaceBar { } GL11.glEnable(GL11.GL_SCISSOR_TEST); - GuiUtil.setScissorClip(fieldX + 2, fieldY, fieldWidth - 4, fieldHeight); + GuiUtil.setScissorClip(fieldX + 2, fieldY, fieldWidth - 4, fieldHeight, ownerGui); { // Draw selection highlight diff --git a/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/AutocompleteItem.java b/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/AutocompleteItem.java new file mode 100644 index 000000000..413c72667 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/AutocompleteItem.java @@ -0,0 +1,830 @@ +package noppes.npcs.client.gui.util.script.autocomplete; + +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSFieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSMethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.synthetic.SyntheticField; +import noppes.npcs.client.gui.util.script.interpreter.type.synthetic.SyntheticMethod; +import noppes.npcs.client.gui.util.script.interpreter.type.synthetic.SyntheticParameter; + +/** + * Represents a single autocomplete suggestion. + * Unified representation for both Java and JavaScript completions. + */ +public class AutocompleteItem implements Comparable { + + /** + * The kind of completion item. + */ + public enum Kind { + ENUM_CONSTANT(-1), // Enum constant value (highest priority for enums) + METHOD(0), // Method or function + FIELD(1), // Field or property + VARIABLE(2), // Local variable or parameter + CLASS(3), // Class or interface type + ENUM(4), // Enum type + KEYWORD(6), // Language keyword + SNIPPET(7); // Code snippet + + private final int priority; + + Kind(int priority) { + this.priority = priority; + } + + public int getPriority() { + return priority; + } + } + + private final String name; // Display name (e.g., "getPlayer" or "getPlayer(UUID id)" for methods) + private final String searchName; // Name to search against (just the identifier, e.g., "getPlayer") + private final String insertText; // Text to insert (e.g., "getPlayer()") + private final Kind kind; // Type of completion + private final String typeLabel; // Type label (e.g., "IPlayer", "void") + private final TypeInfo typeInfo; // TypeInfo for the typeLabel + private final String signature; // Full signature for methods + private final String documentation; // Documentation/description + private final Object sourceData; // Original source (MethodInfo, FieldInfo, etc.) + private final boolean deprecated; // Whether this item is deprecated + + // Import tracking + private final boolean requiresImport; // Whether selecting this item requires adding an import + private final String importPath; // Full path for import (e.g., "net.minecraft.client.Minecraft") + + // Inheritance tracking (for JS types) + private final int inheritanceDepth; // Depth in inheritance tree (0 = child, 1 = parent, 2 = grandparent, etc.) + + // Match scoring + private int matchScore = 0; // How well this matches the query + private int[] matchIndices; // Indices of matched characters for highlighting + + private AutocompleteItem(String name, String searchName, String insertText, Kind kind, String typeLabel, + TypeInfo typeLabelTypeInfo, String signature, String documentation, Object sourceData, + boolean deprecated, boolean requiresImport, String importPath, int inheritanceDepth) { + this.name = name; + this.searchName = searchName != null ? searchName : name; // Default to name if not provided + this.insertText = insertText; + this.kind = kind; + this.typeLabel = typeLabel; + this.typeInfo = typeLabelTypeInfo; + this.signature = signature; + this.documentation = documentation; + this.sourceData = sourceData; + this.deprecated = deprecated; + this.requiresImport = requiresImport; + this.importPath = importPath; + this.inheritanceDepth = inheritanceDepth; + } + + // ==================== FACTORY METHODS ==================== + + /** + * Create from a Java MethodInfo. + */ + public static AutocompleteItem fromMethod(MethodInfo method) { + return fromMethod(method, false); + } + + /** + * Create from a Java MethodInfo, optionally for method reference context. + * @param method The method info + * @param forMethodReference If true, insert text will NOT include parentheses + */ + public static AutocompleteItem fromMethod(MethodInfo method, boolean forMethodReference) { + String name = method.getName(); + StringBuilder insertText = new StringBuilder(name); + + // For method references, don't add () since it's ::methodName not ::methodName() + if (!forMethodReference) { + insertText.append("("); + // Add placeholders for parameters if any + if (method.getParameterCount() > 0) { + // Just add () - user will fill in params + } + insertText.append(")"); + } + + String returnType = method.getReturnType() != null ? + getName(method.getReturnType()) : "void"; + + String signature = buildMethodSignature(method); + + // Build display name with parameters like "read(byte[] b)" + StringBuilder displayName = new StringBuilder(name); + displayName.append("("); + for (int i = 0; i < method.getParameterCount(); i++) { + if (i > 0) displayName.append(", "); + FieldInfo param = method.getParameters().get(i); + String paramType = param.getTypeInfo() != null ? + getName(param.getTypeInfo()) : "?"; + displayName.append(paramType); + if (param.isVarArg()) displayName.append("..."); + if (param.getName() != null && !param.getName().isEmpty()) { + displayName.append(" ").append(param.getName()); + } + } + displayName.append(")"); + + return new AutocompleteItem( + displayName.toString(), + name, // Search against just the method name, not the params + insertText.toString(), + Kind.METHOD, + returnType, + method.getReturnType(), // TypeInfo for return type + signature, + method.getDocumentation(), + method, + false, // TODO: Check for @Deprecated annotation + false, // Methods don't require imports + null, + -1 // Java methods don't use inheritance depth sorting + ); + } + + /** + * Create from a Java FieldInfo. + */ + public static AutocompleteItem fromField(FieldInfo field) { + String typeLabel = field.getTypeInfo() != null ? + getName(field.getTypeInfo()) : "?"; + + Kind kind; + switch (field.getScope()) { + case PARAMETER: + kind = Kind.VARIABLE; + break; + case LOCAL: + kind = Kind.VARIABLE; + break; + case ENUM_CONSTANT: + kind = Kind.ENUM_CONSTANT; + break; + default: + kind = Kind.FIELD; + } + + return new AutocompleteItem( + field.getName(), + field.getName(), // searchName same as display name for fields + field.getName(), + kind, + typeLabel, + field.getTypeInfo(), // TypeInfo for field type + typeLabel + " " + field.getName(), + null, + field, + false, + false, // Fields don't require imports + null, + -1// Java fields don't use inheritance depth sorting + ); + } + + /** + * Create from a Java TypeInfo. + */ + public static AutocompleteItem fromType(TypeInfo type) { + Kind kind; + switch (type.getKind()) { + case INTERFACE: + kind = Kind.CLASS; + break; + case ENUM: + kind = Kind.ENUM; + break; + default: + kind = Kind.CLASS; + } + String name = getName(type); + return new AutocompleteItem( + name, + name, // searchName same as display name for types + name, + kind, + type.getPackageName(), + type, // TypeInfo for package name + type.getFullName(), + null, + type, + false, + false, // Will be overridden for unimported types + null, + -1 // Java types don't use inheritance depth sorting + ); + } + + /** + * Create from a JavaScript JSMethodInfo. + */ + public static AutocompleteItem fromJSMethod(JSMethodInfo method) { + return fromJSMethod(method, null, 0, false); + } + + /** + * Create from a JavaScript JSMethodInfo with inheritance depth. + * @param method The method info + * @param inheritanceDepth Depth in inheritance tree (0 = child, 1 = parent, etc.) + */ + public static AutocompleteItem fromJSMethod(JSMethodInfo method, int inheritanceDepth) { + return fromJSMethod(method, null, inheritanceDepth, false); + } + + /** + * Create from a JavaScript JSMethodInfo with type parameter resolution for display. + * @param method The method info + * @param contextType The TypeInfo context for resolving type parameters (e.g., IPlayer to resolve T → EntityPlayerMP) + * @param inheritanceDepth Depth in inheritance tree (0 = child, 1 = parent, etc.) + */ + public static AutocompleteItem fromJSMethod(JSMethodInfo method, TypeInfo contextType, int inheritanceDepth) { + return fromJSMethod(method, contextType, inheritanceDepth, false); + } + + /** + * Create from a JavaScript JSMethodInfo with type parameter resolution for display. + * @param method The method info + * @param contextType The TypeInfo context for resolving type parameters (e.g., IPlayer to resolve T → EntityPlayerMP) + * @param inheritanceDepth Depth in inheritance tree (0 = child, 1 = parent, etc.) + * @param forMethodReference If true, insert text will NOT include parentheses + */ + public static AutocompleteItem fromJSMethod(JSMethodInfo method, TypeInfo contextType, int inheritanceDepth, boolean forMethodReference) { + String name = method.getName(); + StringBuilder insertText = new StringBuilder(name); + + // For method references, don't add () since it's ::methodName not ::methodName() + if (!forMethodReference) { + insertText.append("("); + insertText.append(")"); + } + + // Build display name with resolved parameter types + StringBuilder displayName = new StringBuilder(name); + displayName.append("("); + for (int i = 0; i < method.getParameters().size(); i++) { + if (i > 0) displayName.append(", "); + JSMethodInfo.JSParameterInfo param = method.getParameters().get(i); + + // Use resolved type with full generic display + TypeInfo paramType = param.getResolvedType(contextType); + String paramTypeName = paramType.isResolved() ? paramType.getDisplayName() : param.getType(); + if (param.isVarArg()) paramTypeName = paramTypeName + "..."; + displayName.append(paramTypeName).append(" ").append(param.getName()); + } + displayName.append(")"); + + // Get return type using the new method with full generic display + TypeInfo returnTypeInfo = method.getResolvedReturnType(contextType); + String returnType = returnTypeInfo.isResolved() ? returnTypeInfo.getDisplayName() : method.getReturnType(); + + return new AutocompleteItem( + displayName.toString(), + name, // Search against just the method name + insertText.toString(), + Kind.METHOD, + returnType, + returnTypeInfo, // TypeInfo for return type + method.getSignature(), + method.getDocumentation(), + method, + false, + false, + null, + inheritanceDepth + ); + } + + /** + * Create from a JavaScript JSFieldInfo. + */ + public static AutocompleteItem fromJSField(JSFieldInfo field) { + return fromJSField(field, null, 0); + } + + /** + * Create from a JavaScript JSFieldInfo with inheritance depth. + * @param field The field info + * @param inheritanceDepth Depth in inheritance tree (0 = child, 1 = parent, etc.) + */ + public static AutocompleteItem fromJSField(JSFieldInfo field, int inheritanceDepth) { + return fromJSField(field, null, inheritanceDepth); + } + + /** + * Create from a JavaScript JSFieldInfo with type parameter resolution for display. + * @param field The field info + * @param contextType The TypeInfo context for resolving type parameters + * @param inheritanceDepth Depth in inheritance tree (0 = child, 1 = parent, etc.) + */ + public static AutocompleteItem fromJSField(JSFieldInfo field, TypeInfo contextType, int inheritanceDepth) { + // Get field type using the new method with full generic display + TypeInfo fieldTypeInfo = field.getResolvedType(contextType); + String fieldType = fieldTypeInfo.isResolved() ? fieldTypeInfo.getDisplayName() : field.getType(); + + return new AutocompleteItem( + field.getName(), + field.getName(), // searchName same as display name + field.getName(), + Kind.FIELD, + fieldType, + fieldTypeInfo, // TypeInfo for field type + field.toString(), + field.getDocumentation(), + field, + false, + false, + null, + inheritanceDepth + ); + } + + /** + * Create a keyword item. + */ + public static AutocompleteItem keyword(String keyword) { + return new AutocompleteItem( + keyword, + keyword, // searchName same as display name + keyword, + Kind.KEYWORD, + "keyword", + null, // TypeInfo for keyword + null, + null, + null, + false, + false, + null, + -1 // Keywords don't use inheritance depth sorting + ); + } + + /** + * Create from a synthetic method (e.g., Nashorn built-in like Java.type). + */ + public static AutocompleteItem fromSyntheticMethod( + SyntheticMethod method, + TypeInfo containingType) { + return fromSyntheticMethod(method, containingType, false); + } + + /** + * Create from a synthetic method (e.g., Nashorn built-in like Java.type). + * @param method The synthetic method + * @param containingType The containing type info + * @param forMethodReference If true, insert text will NOT include parentheses + */ + public static AutocompleteItem fromSyntheticMethod( + SyntheticMethod method, + TypeInfo containingType, + boolean forMethodReference) { + String name = method.name; + StringBuilder insertText = new StringBuilder(name); + + // For method references, don't add () since it's ::methodName not ::methodName() + if (!forMethodReference) { + insertText.append("("); + insertText.append(")"); + } + + // Build display name with parameters - use simple names for types + StringBuilder displayName = new StringBuilder(name); + displayName.append("("); + for (int i = 0; i < method.parameters.size(); i++) { + if (i > 0) displayName.append(", "); + SyntheticParameter param = + method.parameters.get(i); + // Use simple name for display (e.g., "Class" instead of "java.lang.Class") + String simpleTypeName = getSimpleTypeName(param.typeName); + displayName.append(simpleTypeName).append(" ").append(param.name); + } + displayName.append(")"); + + // Use simple name for return type display too + String simpleReturnType = getSimpleTypeName(method.returnType); + + return new AutocompleteItem( + displayName.toString(), + name, // Search against just the method name + insertText.toString(), + Kind.METHOD, + simpleReturnType, + method.getReturnTypeInfo(), // TypeInfo for return type - would need to resolve from TypeResolver + method.getSignature(), + method.documentation, + method, + false, + false, + null, + 0 // Synthetic types are at depth 0 + ); + } + + /** + * Get simple name from a fully-qualified type name. + */ + private static String getSimpleTypeName(String typeName) { + if (typeName == null) return "void"; + int lastDot = typeName.lastIndexOf('.'); + return lastDot >= 0 ? typeName.substring(lastDot + 1) : typeName; + } + + /** + * Create from a synthetic field (e.g., Nashorn built-in). + */ + public static AutocompleteItem fromSyntheticField( + SyntheticField field) { + return new AutocompleteItem( + field.name, + field.name, // searchName same as display name + field.name, + Kind.FIELD, + field.typeName, + field.getTypeInfo(), // TypeInfo for field type - would need to resolve from TypeResolver + field.typeName + " " + field.name, + field.documentation, + field, + false, + false, + null, + 0 // Synthetic types are at depth 0 + ); + } + + // ==================== HELPER METHODS ==================== + + private static String buildMethodSignature(MethodInfo method) { + StringBuilder sb = new StringBuilder(); + String returnType = method.getReturnType() != null ? + getName(method.getReturnType()) : "void"; + sb.append(returnType).append(" ").append(method.getName()).append("("); + + for (int i = 0; i < method.getParameterCount(); i++) { + if (i > 0) sb.append(", "); + FieldInfo param = method.getParameters().get(i); + String paramType = param.getTypeInfo() != null ? + getName(param.getTypeInfo()) : "?"; + sb.append(paramType); + if (param.isVarArg()) sb.append("..."); + sb.append(" ").append(param.getName()); + } + + sb.append(")"); + return sb.toString(); + } + + // ==================== MATCHING ==================== + + /** + * Calculate fuzzy match score against a query string. + * Returns -1 if no match, or a positive score (higher = better match). + * + * @param query The search query + * @param requirePrefix If true, only match items that start with the query (no fuzzy/contains matching) + */ + public int calculateMatchScore(String query, boolean requirePrefix) { + if (query == null || query.isEmpty()) { + matchScore = 100; // Everything matches empty query + matchIndices = new int[0]; + return matchScore; + } + + String lowerName = searchName.toLowerCase(); + String lowerQuery = query.toLowerCase(); + + // Exact prefix match is best + if (lowerName.startsWith(lowerQuery)) { + matchScore = 1000 - query.length(); // Shorter prefixes score higher + matchIndices = new int[query.length()]; + for (int i = 0; i < query.length(); i++) { + matchIndices[i] = i; + } + return matchScore; + } + + // If requirePrefix is true, stop here - no fuzzy/substring matching + if (requirePrefix) { + matchScore = -1; + matchIndices = new int[0]; + return matchScore; + } + + // Exact substring match + int subIndex = lowerName.indexOf(lowerQuery); + if (subIndex >= 0) { + matchScore = 500 - subIndex; // Earlier substrings score higher + matchIndices = new int[query.length()]; + for (int i = 0; i < query.length(); i++) { + matchIndices[i] = subIndex + i; + } + return matchScore; + } + + // Fuzzy match - characters must appear in order + int[] indices = new int[query.length()]; + int nameIdx = 0; + int queryIdx = 0; + int gaps = 0; + int consecutiveBonus = 0; + int lastMatchIdx = -2; + + while (queryIdx < query.length() && nameIdx < searchName.length()) { + if (Character.toLowerCase(searchName.charAt(nameIdx)) == lowerQuery.charAt(queryIdx)) { + indices[queryIdx] = nameIdx; + + // Bonus for consecutive matches + if (nameIdx == lastMatchIdx + 1) { + consecutiveBonus += 10; + } + + // Bonus for matching at word boundaries (camelCase) + if (nameIdx == 0 || !Character.isLetterOrDigit(searchName.charAt(nameIdx - 1)) || + (Character.isUpperCase(searchName.charAt(nameIdx)) && nameIdx > 0 && + Character.isLowerCase(searchName.charAt(nameIdx - 1)))) { + consecutiveBonus += 20; + } + + lastMatchIdx = nameIdx; + queryIdx++; + } else { + gaps++; + } + nameIdx++; + } + + if (queryIdx < query.length()) { + // Didn't match all characters + matchScore = -1; + matchIndices = null; + return -1; + } + + matchScore = 100 + consecutiveBonus - gaps; + matchIndices = indices; + return matchScore; + } + + /** + * Backward compatibility overload - defaults to fuzzy matching (no prefix requirement). + */ + public int calculateMatchScore(String query) { + return calculateMatchScore(query, false); + } + + /** + * Add a boost to the match score (e.g., from usage tracking). + */ + public void addScoreBoost(int boost) { + this.matchScore += boost; + } + + // ==================== GETTERS ==================== + + public String getName() { return name; } + public String getSearchName() { return searchName; } + public String getInsertText() { return insertText; } + public Kind getKind() { return kind; } + public String getTypeLabel() { return typeLabel; } + public TypeInfo getTypeInfo() { return typeInfo; } + public String getSignature() { return signature; } + public String getDocumentation() { return documentation; } + public Object getSourceData() { return sourceData; } + public boolean isDeprecated() { return deprecated; } + public boolean requiresImport() { return requiresImport; } + public String getImportPath() { return importPath; } + public int getMatchScore() { return matchScore; } + public int[] getMatchIndices() { return matchIndices; } + + /** + * Get the display name for a type, including generic arguments. + * Uses the unified getDisplayName() method which handles: + * - Simple types: "String" + * - Parameterized types: "List", "Map" + * - Nested generics: "List>" + * - JS types with namespace: "IPlayerEvent.InteractEvent" + */ + public static String getName(TypeInfo type) { + return type.getDisplayName(); + } + + public int getParameterCount() { + if (sourceData instanceof MethodInfo) { + return ((MethodInfo) sourceData).getParameterCount(); + } else if (sourceData instanceof JSMethodInfo) { + return ((JSMethodInfo) sourceData).getParameterCount(); + } else if (sourceData instanceof SyntheticMethod) { + return ((SyntheticMethod) sourceData).parameters.size(); + } + return 0; + } + + /** + * Check if this item represents a static member. + */ + public boolean isStatic() { + if (sourceData instanceof MethodInfo) { + return ((MethodInfo) sourceData).isStatic(); + } else if (sourceData instanceof FieldInfo) { + return ((FieldInfo) sourceData).isStatic(); + } else if (sourceData instanceof JSMethodInfo) { + return ((JSMethodInfo) sourceData).isStatic(); + } else if (sourceData instanceof JSFieldInfo) { + return ((JSFieldInfo) sourceData).isStatic(); + } + return false; + } + + /** + * Check if this item represents a final member. + */ + public boolean isFinal() { + if (sourceData instanceof MethodInfo) { + return ((MethodInfo) sourceData).isFinal(); + } else if (sourceData instanceof FieldInfo) { + return ((FieldInfo) sourceData).isFinal(); + }else if (sourceData instanceof JSFieldInfo) { + return ((JSFieldInfo) sourceData).isReadonly(); + } + return false; + } + + /** + * Check if this method is inherited from Object class and NOT overridden. + * These methods should be deprioritized in autocomplete. + */ + public boolean isInheritedObjectMethod() { + if (kind != Kind.METHOD) return false; + + if (sourceData instanceof MethodInfo) { + MethodInfo methodInfo = (MethodInfo) sourceData; + java.lang.reflect.Method javaMethod = methodInfo.getJavaMethod(); + if (javaMethod != null) { + return Object.class.equals(javaMethod.getDeclaringClass()); + } + TypeInfo containingType = methodInfo.getContainingType(); + return containingType != null + && containingType.getFullName().equals("java.lang.Object") + && !methodInfo.isStatic() + && !methodInfo.isOverride(); + } + + if (sourceData instanceof JSMethodInfo) { + JSMethodInfo jsMethod = (JSMethodInfo) sourceData; + JSTypeInfo definingType = jsMethod.getContainingType(); + return definingType != null + && "Object".equals(definingType.getSimpleName()) + && !jsMethod.isStatic() + && inheritanceDepth > 0; + } + + return false; + } + + /** + * Get icon identifier based on kind. + */ + public String getIconId() { + switch (kind) { + case METHOD: return "m"; + case FIELD: return "f"; + case VARIABLE: return "v"; + case CLASS: return "C"; + case ENUM: return "E"; + case ENUM_CONSTANT: return "e"; + case KEYWORD: return "k"; + case SNIPPET: return "s"; + default: return "?"; + } + } + + /** + * Get color for the kind icon. + */ + public int getIconColor() { + switch (kind) { + case METHOD: return 0xFFB877DB; // Purple for methods + case FIELD: return 0xFF79C0FF; // Blue for fields + case VARIABLE: return 0xFF7EE787; // Green for variables + case CLASS: return 0xFFFFA657; // Orange for classes + case ENUM: return 0xFFFFD866; // Yellow for enums + case ENUM_CONSTANT: return 0xFFFFD866; + case KEYWORD: return 0xFFFF7B72; // Red for keywords + case SNIPPET: return 0xFFCCCCCC; // Gray for snippets + default: return 0xFFCCCCCC; + } + } + + @Override + public int compareTo(AutocompleteItem other) { + // First by match score (descending) - this includes all penalties and boosts + if (this.matchScore != other.matchScore) { + return other.matchScore - this.matchScore; + } + + // Then by kind priority + if (this.kind.getPriority() != other.kind.getPriority()) { + return this.kind.getPriority() - other.kind.getPriority(); + } + + // For JS types, prioritize by inheritance depth (child class members first) + // Only apply if both items have valid inheritance depth (>= 0) + if (this.inheritanceDepth >= 0 && other.inheritanceDepth >= 0) { + if (this.inheritanceDepth != other.inheritanceDepth) { + return this.inheritanceDepth - other.inheritanceDepth; // Lower depth = closer to child = higher priority + } + } + + // Finally alphabetically + return this.name.compareToIgnoreCase(other.name); + } + + @Override + public String toString() { + return name + " (" + kind + ")"; + } + + // ==================== BUILDER ==================== + + /** + * Builder for creating AutocompleteItem instances without source data. + */ + public static class Builder { + private String name; + private String searchName; + private String insertText; + private Kind kind = Kind.FIELD; + private String typeLabel = ""; + private String signature; + private String documentation; + private Object sourceData; + private boolean deprecated = false; + private boolean requiresImport = false; + private String importPath = null; + + public Builder name(String name) { + this.name = name; + return this; + } + + public Builder searchName(String searchName) { + this.searchName = searchName; + return this; + } + + public Builder insertText(String insertText) { + this.insertText = insertText; + return this; + } + + public Builder kind(Kind kind) { + this.kind = kind; + return this; + } + + public Builder typeLabel(String typeLabel) { + this.typeLabel = typeLabel; + return this; + } + + public Builder signature(String signature) { + this.signature = signature; + return this; + } + + public Builder documentation(String documentation) { + this.documentation = documentation; + return this; + } + + public Builder sourceData(Object sourceData) { + this.sourceData = sourceData; + return this; + } + + public Builder deprecated(boolean deprecated) { + this.deprecated = deprecated; + return this; + } + + public Builder requiresImport(boolean requiresImport) { + this.requiresImport = requiresImport; + return this; + } + + public Builder importPath(String importPath) { + this.importPath = importPath; + return this; + } + + public AutocompleteItem build() { + if (insertText == null) { + insertText = name; + } + return new AutocompleteItem(name, searchName, insertText, kind, typeLabel, + null, signature, documentation, sourceData, deprecated, requiresImport, importPath, -1); + } + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/AutocompleteManager.java b/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/AutocompleteManager.java new file mode 100644 index 000000000..1ef9d3034 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/AutocompleteManager.java @@ -0,0 +1,1117 @@ +package noppes.npcs.client.gui.util.script.autocomplete; + +import noppes.npcs.api.handler.data.IAction; +import noppes.npcs.client.gui.util.script.interpreter.ScriptDocument; +import noppes.npcs.client.gui.util.script.interpreter.ScriptTextContainer; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import org.lwjgl.input.Mouse; + +import java.util.List; +import java.util.function.Consumer; +import java.util.regex.Pattern; + +/** + * Manages autocomplete state and coordinates between providers and UI. + * This is the main entry point for autocomplete functionality. + */ +public class AutocompleteManager { + + // ==================== CONSTANTS ==================== + + /** Characters that trigger autocomplete */ + private static final String TRIGGER_CHARS = "."; + + /** Characters that should close autocomplete */ + private static final String CLOSE_CHARS = ";{}()[]<>,\"'`"; + + /** Minimum characters before showing suggestions (for non-dot triggers) */ + private static final int MIN_PREFIX_LENGTH = 1; + + /** Maximum number of suggestions to show (performance/UX) */ + private static final int MAX_SUGGESTIONS = 150; + + /** Pattern for identifier characters */ + private static final Pattern IDENTIFIER_PATTERN = Pattern.compile("[a-zA-Z_$][a-zA-Z0-9_$]*"); + + // ==================== STATE ==================== + + private final AutocompleteMenu menu; + private final JavaAutocompleteProvider javaProvider; + private final JSAutocompleteProvider jsProvider; + + private ScriptTextContainer container; + private ScriptDocument document; + + /** Whether autocomplete is currently active */ + private boolean active = false; + + /** The prefix being typed */ + private String currentPrefix = ""; + + /** Start position of the current prefix */ + private int prefixStartPosition = -1; + + /** Whether this was an explicit trigger (Ctrl+Space) */ + private boolean explicitTrigger = false; + + /** The full class name of the current receiver type (for member access tracking) */ + private String currentReceiverFullName = null; + + /** Whether current context is member access */ + private boolean currentIsMemberAccess = false; + + /** Callback for text insertion */ + private InsertCallback insertCallback; + + /** + * Callback interface for inserting autocomplete results. + */ + public interface InsertCallback { + /** + * Insert text, replacing from start to current cursor position. + * @param text Text to insert + * @param startPosition Position to start replacing from + */ + void insertText(String text, int startPosition); + + /** + * Replace text in a specific range. + * @param text Text to insert + * @param startPosition Position to start replacing from + * @param endPosition Position to end replacing at + */ + void replaceTextRange(String text, int startPosition, int endPosition); + + /** + * Add an import statement and sort all imports. + * @param importPath Full path of the class to import (e.g., "net.minecraft.client.Minecraft") + */ + void addImport(String importPath); + + /** + * Get current cursor position. + */ + int getCursorPosition(); + + /** + * Set cursor position. + * @param position New cursor position + */ + void setCursorPosition(int position); + + /** + * Get current document text. + */ + String getText(); + + /** + * Get cursor screen coordinates for menu positioning. + */ + int[] getCursorScreenPosition(); + + /** + * Get viewport dimensions. + */ + int[] getViewportDimensions(); + } + + // ==================== CONSTRUCTOR ==================== + + public AutocompleteManager() { + this.menu = new AutocompleteMenu(); + this.javaProvider = new JavaAutocompleteProvider(); + this.jsProvider = new JSAutocompleteProvider(); + + // Set up menu callback + menu.setCallback(new AutocompleteMenu.AutocompleteCallback() { + @Override + public void onItemSelected(AutocompleteItem item) { + handleItemSelected(item); + } + + @Override + public void onDismiss() { + active = false; + } + }); + } + + // ==================== CONFIGURATION ==================== + + /** + * Set the script container for type resolution. + */ + public void setContainer(ScriptTextContainer container) { + this.container = container; + if (container != null) { + this.document = container.getDocument(); + javaProvider.setDocument(document); + jsProvider.setDocument(document); + } + } + + /** + * Set the callback for text insertion. + */ + public void setInsertCallback(InsertCallback callback) { + this.insertCallback = callback; + } + + // ==================== TRIGGER LOGIC ==================== + + /** + * Called when a character is typed. + * Determines whether to show, update, or hide autocomplete. + */ + public void onCharTyped(char c, String text, int cursorPosition) { + // Check if we should close autocomplete + if (CLOSE_CHARS.indexOf(c) >= 0) { + dismiss(); + return; + } + + // Check if this is a trigger character + if (TRIGGER_CHARS.indexOf(c) >= 0) { + // Trigger after dot + triggerAfterDot(text, cursorPosition); + return; + } + + // Check if this completes a :: (method reference) + if (c == ':') { + // Normalize cursor position - some callers pass pre-insert position + int effectiveCursor = cursorPosition; + if (effectiveCursor >= 0 && effectiveCursor < text.length() && text.charAt(effectiveCursor) == c) { + effectiveCursor = effectiveCursor + 1; + } + + effectiveCursor = Math.max(0, Math.min(effectiveCursor, text.length())); + + // Check if the previous character is also : + if (effectiveCursor >= 2 && text.charAt(effectiveCursor - 2) == ':') { + triggerAfterMethodReference(text, effectiveCursor); + return; + } + } + + // Check if we're typing an identifier + if (Character.isJavaIdentifierPart(c)) { + // GuiScriptTextArea passes a cursor position captured BEFORE insertion while `text` + // is already the post-insert text. When this happens, cursorPosition points at the + // newly inserted character, not the caret-after-insert. Normalize to a caret position + // for prefix extraction/update. + int effectiveCursor = cursorPosition; + if (effectiveCursor >= 0 && effectiveCursor < text.length() && text.charAt(effectiveCursor) == c) { + effectiveCursor = effectiveCursor + 1; + } + + effectiveCursor = Math.max(0, Math.min(effectiveCursor, text.length())); + + if (active) { + // Update existing autocomplete + updatePrefix(text, effectiveCursor); + } else if (Character.isJavaIdentifierStart(c)) { + // Check if we're after a dot with whitespace (e.g., "obj. |" where | is cursor) + int dotPos = findDotBeforeWhitespace(text, effectiveCursor - 1); + if (dotPos >= 0) { + // We're typing after a dot (with possible whitespace), trigger member access + triggerAfterDot(text, effectiveCursor); + } else { + // Potentially start new autocomplete + maybeStartAutocomplete(text, effectiveCursor, false); + } + } + return; + } + + // Any other character closes autocomplete + if (active && !Character.isWhitespace(c)) { + dismiss(); + } + } + + /** + * Called when backspace/delete is pressed. + */ + public void onDeleteKey(String text, int cursorPosition) { + if (active) { + updatePrefix(text, cursorPosition); + + // Close if prefix is now empty and not after dot + if (currentPrefix.isEmpty() && !isAfterDot(text, cursorPosition)) { + dismiss(); + } + } + } + + /** + * Called when cursor position changes (e.g., arrow keys). + * Updates the autocomplete prefix based on the new cursor position. + */ + public void onCursorMove(String text, int cursorPosition) { + if (!active) + return; + + // Check if we're still in a valid identifier position + if (cursorPosition < 0 || cursorPosition > text.length()) { + dismiss(); + return; + } + + // Find the word boundaries at the current position + int wordStart = cursorPosition; + while (wordStart > 0 && Character.isJavaIdentifierPart(text.charAt(wordStart - 1))) { + wordStart--; + } + + int wordEnd = cursorPosition; + while (wordEnd < text.length() && Character.isJavaIdentifierPart(text.charAt(wordEnd))) { + wordEnd++; + } + + // Check if we moved out of the current word + if (cursorPosition < prefixStartPosition || cursorPosition > prefixStartPosition + currentPrefix.length()) { + // Check if we're in a different word that we can autocomplete + boolean isMemberAccess = wordStart > 0 && text.charAt(wordStart - 1) == '.'; + + if (isMemberAccess || wordStart < cursorPosition) { + // Update to the new word + prefixStartPosition = wordStart; + updatePrefix(text, cursorPosition); + } else { + // Moved to empty space or invalid position + dismiss(); + } + } else { + // Still in same word, just update the prefix + updatePrefix(text, cursorPosition); + } + } + + /** + * Explicitly trigger autocomplete (Ctrl+Space). + */ + public void triggerExplicit() { + if (insertCallback == null) return; + + String text = insertCallback.getText(); + int cursorPosition = insertCallback.getCursorPosition(); + + explicitTrigger = true; + + // Check if after dot + if (isAfterDot(text, cursorPosition)) { + triggerAfterDot(text, cursorPosition); + } else { + maybeStartAutocomplete(text, cursorPosition, true); + } + } + + /** + * Trigger autocomplete after a dot is typed. + */ + private void triggerAfterDot(String text, int cursorPosition) { + // Normalize cursor semantics. + // Some callers pass a pre-insert cursor index (points at '.') even though the caret + // is visually after the inserted '.' in the current text. + int caretPos = Math.max(0, Math.min(cursorPosition, text.length())); + + int dotPos = -1; + if (caretPos > 0 && caretPos <= text.length() && text.charAt(caretPos - 1) == '.') { + // Caret-after-dot case + dotPos = caretPos - 1; + } else if (caretPos >= 0 && caretPos < text.length() && text.charAt(caretPos) == '.') { + // Pre-insert cursor case: cursorPosition points at the dot itself + dotPos = caretPos; + caretPos = Math.min(caretPos + 1, text.length()); + } else { + // Look backwards skipping whitespace/identifier to find dot + dotPos = findDotBeforeWhitespace(text, caretPos - 1); + } + + if (dotPos < 0) return; + + String receiverExpr = findReceiverExpression(text, dotPos); + String prefix = findCurrentWord(text, caretPos); + + // Find where the prefix actually starts (after dot + any whitespace) + int prefixStart = dotPos + 1; + while (prefixStart < caretPos && Character.isWhitespace(text.charAt(prefixStart))) { + prefixStart++; + } + + prefixStartPosition = prefixStart; + currentPrefix = prefix; + + showSuggestions(text, caretPos, prefix, prefixStartPosition, true, receiverExpr, false); + } + + /** + * Trigger autocomplete after :: is typed (method reference). + * Shows only method suggestions filtered for method references. + */ + private void triggerAfterMethodReference(String text, int cursorPosition) { + int doubleColonPos = cursorPosition - 2; + + // Find the receiver expression before :: + String receiverExpr = findMethodRefReceiverExpression(text, doubleColonPos); + if (receiverExpr == null || receiverExpr.isEmpty()) return; + + // Skip whitespace after :: when establishing prefix start position + int prefixStart = cursorPosition; + while (prefixStart < text.length() && Character.isWhitespace(text.charAt(prefixStart))) { + prefixStart++; + } + + String prefix = ""; + + prefixStartPosition = prefixStart; + currentPrefix = prefix; + + // Show suggestions filtered for methods only + showSuggestions(text, cursorPosition, prefix, prefixStart, true, receiverExpr, true); + } + + /** + * Find the receiver expression before :: for method references. + * Similar to findReceiverExpression but stops at :: + */ + private String findMethodRefReceiverExpression(String text, int doubleColonPos) { + if (text == null || doubleColonPos <= 0) return ""; + + int pos = doubleColonPos - 1; + + // Skip whitespace immediately left of :: + while (pos >= 0 && Character.isWhitespace(text.charAt(pos))) pos--; + if (pos < 0) return ""; + + int end = pos + 1; + + // Walk left across a dotted receiver chain + while (pos >= 0) { + char c = text.charAt(pos); + + if (Character.isWhitespace(c)) { + pos--; + continue; + } + + if (c == ')') { + int open = findMatchingBackward(text, pos, '(', ')'); + if (open < 0) break; + pos = open - 1; + continue; + } + + if (c == ']') { + int open = findMatchingBackward(text, pos, '[', ']'); + if (open < 0) break; + pos = open - 1; + continue; + } + + if (Character.isJavaIdentifierPart(c)) { + // Consume identifier + while (pos >= 0 && Character.isJavaIdentifierPart(text.charAt(pos))) pos--; + + // If preceded by a dot, keep going + int checkPos = pos; + while (checkPos >= 0 && Character.isWhitespace(text.charAt(checkPos))) { + checkPos--; + } + if (checkPos >= 0 && text.charAt(checkPos) == '.') { + pos = checkPos - 1; + continue; + } + break; + } + + // Anything else terminates the receiver + break; + } + + int start = pos + 1; + if (start < 0) start = 0; + if (end > text.length()) end = text.length(); + if (start >= end) return ""; + + String expr = text.substring(start, end).replaceAll("\\s+", " ").trim(); + return expr; + } + + /** + * Maybe start autocomplete based on current context. + */ + private void maybeStartAutocomplete(String text, int cursorPosition, boolean force) { + String prefix = findCurrentWord(text, cursorPosition); + int prefixStart = cursorPosition - prefix.length(); + + // Check minimum prefix length (unless forced) + if (!force && prefix.length() < MIN_PREFIX_LENGTH) { + return; + } + + // Don't auto-trigger if we're in the middle of a word + if (!force && prefixStart > 0 && Character.isJavaIdentifierPart(text.charAt(prefixStart - 1))) { + return; + } + + prefixStartPosition = prefixStart; + currentPrefix = prefix; + + showSuggestions(text, cursorPosition, prefix, prefixStart, false, null, false); + } + + /** + * Update the prefix and refresh suggestions. + */ + private void updatePrefix(String text, int cursorPosition) { + if (text == null || cursorPosition < 0 || cursorPosition > text.length()) { + dismiss(); + return; + } + + // Re-calculate prefix from the original start position + if (prefixStartPosition < 0 || prefixStartPosition > cursorPosition) { + dismiss(); + return; + } + + String newPrefix = text.substring(prefixStartPosition, cursorPosition); + + // Validate prefix (should be valid identifier or empty) + if (!newPrefix.isEmpty() && !isValidPrefix(newPrefix)) { + dismiss(); + return; + } + + currentPrefix = newPrefix; + + // Check if this is a method reference context (after ::) + boolean isMethodReference = isAfterMethodReference(text, prefixStartPosition); + + // Check if after dot (skipping whitespace) + int dotPos = findDotBeforeWhitespace(text, prefixStartPosition - 1); + boolean isMemberAccess = dotPos >= 0 || isMethodReference; + + String receiverExpr = null; + if (isMethodReference) { + // Find :: position + int doubleColonPos = findDoubleColonBefore(text, prefixStartPosition); + if (doubleColonPos >= 0) { + receiverExpr = findMethodRefReceiverExpression(text, doubleColonPos); + } + } else if (isMemberAccess) { + receiverExpr = findReceiverExpression(text, dotPos); + } + + showSuggestions(text, cursorPosition, currentPrefix, prefixStartPosition, + isMemberAccess, receiverExpr, isMethodReference); + } + + /** + * Check if position is after :: (method reference). + */ + private boolean isAfterMethodReference(String text, int pos) { + int checkPos = pos - 1; + // Skip whitespace + while (checkPos >= 0 && Character.isWhitespace(text.charAt(checkPos))) { + checkPos--; + } + // Check for :: + if (checkPos >= 1 && text.charAt(checkPos) == ':' && text.charAt(checkPos - 1) == ':') { + return true; + } + return false; + } + + /** + * Find the position of :: before the given position. + */ + private int findDoubleColonBefore(String text, int pos) { + int checkPos = pos - 1; + // Skip whitespace + while (checkPos >= 0 && Character.isWhitespace(text.charAt(checkPos))) { + checkPos--; + } + // Check for :: + if (checkPos >= 1 && text.charAt(checkPos) == ':' && text.charAt(checkPos - 1) == ':') { + return checkPos - 1; + } + return -1; + } + + // ==================== SUGGESTION LOGIC ==================== + + /** + * Show autocomplete suggestions. + */ + private void showSuggestions(String text, int cursorPosition, String prefix, + int prefixStart, boolean isMemberAccess, String receiverExpr, + boolean methodsOnly) { + if (insertCallback == null || document == null) return; + + // Track context for usage recording when item is selected + currentIsMemberAccess = isMemberAccess; + currentReceiverFullName = null; + + // Resolve receiver type if member access + if (isMemberAccess && receiverExpr != null) { + // Use a position inside the receiver/scope for resolution. + // `prefixStart` can land on end-exclusive boundaries (e.g., right at bodyEnd), + // causing findInnermostScopeAt(prefixStart) to return null. + int dotPos = findDotBeforeWhitespace(text, prefixStart - 1); + int resolvePos = dotPos >= 0 ? dotPos : prefixStart; + TypeInfo receiverType = document.resolveExpressionType(receiverExpr, resolvePos); + if (receiverType != null && receiverType.isResolved()) { + currentReceiverFullName = receiverType.getFullName(); + } + } + + // Build context + int lineNumber = getLineNumber(text, cursorPosition); + String currentLine = getCurrentLine(text, cursorPosition); + int columnPosition = getColumnPosition(text, cursorPosition); + + AutocompleteProvider.Context context = new AutocompleteProvider.Context( + text, cursorPosition, lineNumber, columnPosition, currentLine, + prefix, prefixStart, isMemberAccess, receiverExpr, explicitTrigger, methodsOnly + ); + + // Get suggestions from appropriate provider + AutocompleteProvider provider = document.isJavaScript() ? jsProvider : javaProvider; + + // No need to update variable types - JSAutocompleteProvider now gets them directly from ScriptDocument + + List suggestions = provider.getSuggestions(context); + + // Limit suggestions to prevent overwhelming the UI and improve performance + // Items are already sorted by relevance in the provider + if (suggestions.size() > MAX_SUGGESTIONS) { + // Disabled for now to show all suggestions + // suggestions = suggestions.subList(0, MAX_SUGGESTIONS); + } + + // Show menu + if (suggestions.isEmpty()) { + if (explicitTrigger) { + // Show "No suggestions" message + suggestions.add(new AutocompleteItem.Builder() + .name("No suggestions") + .kind(AutocompleteItem.Kind.SNIPPET) + .typeLabel("") + .build()); + } else { + dismiss(); + return; + } + } + + // Get screen position for menu + int[] screenPos = insertCallback.getCursorScreenPosition(); + int[] viewport = insertCallback.getViewportDimensions(); + + menu.show(screenPos[0], screenPos[1] + 15, suggestions, viewport[0], viewport[1]); + active = true; + explicitTrigger = false; + } + + // ==================== KEY HANDLING ==================== + + /** + * Handle key press. + * @return true if the key was consumed + */ + public boolean keyPressed(int keyCode) { + if (!active || !menu.isVisible()) return false; + + switch (keyCode) { + case 200: // UP + menu.selectPrevious(); + return true; + + case 208: // DOWN + menu.selectNext(); + return true; + + case 28: // ENTER + case 15: // TAB + if (menu.hasItems()) { + menu.confirmSelection(); + return true; + } + return false; + + case 1: // ESCAPE + dismiss(); + return true; + + default: + return false; + } + } + + /** + * Handle mouse click. + * @return true if the click was consumed + */ + public boolean mouseClicked(int mouseX, int mouseY, int button) { + if (!active) return false; + return menu.mouseClicked(mouseX, mouseY, button); + } + + /** + * Handle mouse scroll. + * @return true if the scroll was consumed + */ + public boolean mouseScrolled(int mouseX, int mouseY, int delta) { + if (!active) return false; + return menu.mouseScrolled(mouseX, mouseY, delta); + } + + /** + * Handle mouse release. + * @return true if the release was consumed + */ + public boolean mouseReleased(int mouseX, int mouseY, int button) { + if (!active) + return false; + return menu.mouseReleased(mouseX, mouseY, button); + } + + /** + * Handle mouse drag. + * @return true if the drag was consumed + */ + public boolean mouseDragged(int mouseX, int mouseY) { + if (!active) + return false; + return menu.mouseDragged(mouseX, mouseY); + } + + public boolean isDraggingPanel() { return active && menu.isDraggingPanel(); } + public boolean isDraggingScrollbarMenu() { return active && menu.isDraggingScrollbarMenu(); } + public boolean isResizingPanel() { return active && menu.isResizingPanel(); } + public boolean isMouseOverResizeHandle(int mx, int my) { return active && menu.isMouseOverResizeHandle(mx, my); } + public void updatePanelDrag(int x, int y) { if (active) menu.updatePanelDrag(x, y); } + public void releasePanelDrag() { if (active) menu.releasePanelDrag(); } + public void updateScrollbarDrag(int y) { if (active) menu.updateScrollbarDragDraw(y); } + public void releaseScrollbarDrag() { if (active) menu.releaseScrollbarDrag(); } + public void updatePanelResize(int x, int y) { if (active) menu.updatePanelResize(x, y); } + public void releasePanelResize() { if (active) menu.releasePanelResize(); } + + // ==================== ITEM SELECTION ==================== + + /** + * Handle when an item is selected from the menu. + */ + private void handleItemSelected(AutocompleteItem item) { + if (insertCallback == null || item == null) return; + + // Don't insert "No suggestions" placeholder + if (item.getName().equals("No suggestions")) { + return; + } + + // Record usage for learning + recordUsage(item); + + String insertText = item.getInsertText(); + + // Smart tab completion: replace till next separator + // Find the end position (current word till next separator) + String text = insertCallback.getText(); + int cursorPos = insertCallback.getCursorPosition(); + int endPos = cursorPos; + + // Extend to consume rest of current word + while (endPos < text.length() && Character.isJavaIdentifierPart(text.charAt(endPos))) { + endPos++; + } + + // Also consume following parentheses and their content if present + if (endPos < text.length() && text.charAt(endPos) == '(') { + int parenDepth = 1; + endPos++; // Skip opening paren + while (endPos < text.length() && parenDepth > 0) { + char c = text.charAt(endPos); + if (c == '(') parenDepth++; + else if (c == ')') parenDepth--; + endPos++; + } + } + + // IMPORTANT: Do the text replacement FIRST, then add import + // This prevents position corruption since import adds text at the TOP + insertCallback.replaceTextRange(insertText, prefixStartPosition, endPos); + + // If the inserted text ends with (), move cursor inside only when parameters exist + if (insertText.endsWith("()") && item.getParameterCount() > 0) { + int currentCursor = insertCallback.getCursorPosition(); + insertCallback.setCursorPosition(currentCursor - 1); + } + + // If this item requires an import, add it AFTER the text replacement + if (item.requiresImport() && item.getImportPath() != null) { + insertCallback.addImport(item.getImportPath()); + } + + active = false; + } + + /** + * Record that the user selected an autocomplete item for usage tracking. + */ + private void recordUsage(AutocompleteItem item) { + if (document == null) return; + + UsageTracker tracker = document.isJavaScript() ? + UsageTracker.getJSInstance() : UsageTracker.getJavaInstance(); + + // For member access, use the resolved receiver type + // For standalone items (types, keywords, variables), owner is null + String owner = currentIsMemberAccess ? currentReceiverFullName : null; + + tracker.recordUsage(item, owner); + } + + // ==================== DISMISS ==================== + + /** + * Dismiss autocomplete. + */ + public void dismiss() { + if (active) { + menu.hide(); + active = false; + currentPrefix = ""; + prefixStartPosition = -1; + explicitTrigger = false; + } + } + + // ==================== DRAWING ==================== + + /** + * Draw the autocomplete menu. + */ + public void draw(int mouseX, int mouseY) { + if (active) { + menu.draw(mouseX, mouseY); + + if (Mouse.isButtonDown(0)) + mouseDragged(mouseX, mouseY); + else + mouseReleased(mouseX, mouseY, 0); + } + } + + // ==================== STATE QUERIES ==================== + + public boolean isActive() { + return active; + } + + public boolean isVisible() { + return active && menu.isVisible(); + } + + public AutocompleteMenu getMenu() { + return menu; + } + + // ==================== HELPER METHODS ==================== + + /** + * Find the word being typed at the cursor position. + */ + private String findCurrentWord(String text, int cursorPos) { + if (text == null || text.isEmpty()) return ""; + + int safeCursorPos = Math.max(0, Math.min(cursorPos, text.length())); + if (safeCursorPos <= 0) return ""; + + int start = safeCursorPos; + while (start > 0 && Character.isJavaIdentifierPart(text.charAt(start - 1))) { + start--; + } + + return text.substring(start, safeCursorPos); + } + + /** + * Find the receiver expression before a dot. + * Handles multiline chains and whitespace intelligently. + * + * Stops at statement boundaries: + * - Semicolons (Java) + * - Blank lines or newlines not part of chain continuation + * + * Continues through: + * - Dots at start/end of lines (chain continuation pattern) + * - Whitespace within expressions + */ + private String findReceiverExpression(String text, int dotPos) { + if (text == null || dotPos <= 0) return ""; + if (dotPos >= text.length()) return ""; + + int end = dotPos; + int pos = dotPos - 1; + + // Skip whitespace immediately left of dot + while (pos >= 0 && Character.isWhitespace(text.charAt(pos))) pos--; + if (pos < 0) return ""; + + // Walk left across a dotted receiver chain. + while (pos >= 0) { + // Skip excluded regions (comments/strings) if the document knows them + if (document != null && document.isExcluded(pos)) { + int jumped = jumpBeforeExcluded(pos); + if (jumped == pos) { + pos--; // Safety fallback + } else { + pos = jumped; + } + continue; + } + + char c = text.charAt(pos); + if (Character.isWhitespace(c)) { + pos--; + continue; + } + + if (c == ')') { + int open = findMatchingBackward(text, pos, '(', ')'); + if (open < 0) break; + pos = open - 1; + continue; + } + + if (c == ']') { + int open = findMatchingBackward(text, pos, '[', ']'); + if (open < 0) break; + pos = open - 1; + continue; + } + + if (Character.isJavaIdentifierPart(c)) { + // Consume identifier + while (pos >= 0 && Character.isJavaIdentifierPart(text.charAt(pos))) pos--; + + // If preceded by a dot (allowing whitespace/newlines between), keep going. + int checkPos = pos; + while (checkPos >= 0) { + char ch = text.charAt(checkPos); + if (Character.isWhitespace(ch)) { + checkPos--; + continue; + } + // Critical for cases like: "). // comment\n setData(...)" + // The last non-whitespace char before the newline is inside an excluded range, + // so we need to skip excluded ranges when searching for the dot. + if (document != null && document.isExcluded(checkPos)) { + int jumped = jumpBeforeExcluded(checkPos); + if (jumped == checkPos) { + checkPos--; // Safety fallback + } else { + checkPos = jumped; + } + continue; + } + break; + } + if (checkPos >= 0 && text.charAt(checkPos) == '.') { + pos = checkPos - 1; + continue; + } + break; + } + + // Anything else terminates the receiver + break; + } + + int start = pos + 1; + if (start < 0) start = 0; + if (end > text.length()) end = text.length(); + if (start >= end) return ""; + + String expr = text.substring(start, end); + + // Mask comment ranges so comment words don't get parsed as identifiers/segments. + // Keep string literal ranges intact so argument type resolution still works. + if (document != null) { + char[] chars = expr.toCharArray(); + for (int[] range : document.getExcludedRanges()) { + if (range == null || range.length < 2) continue; + if (!isCommentRange(text, range[0])) continue; + + int a = Math.max(range[0], start) - start; + int b = Math.min(range[1], end) - start; + if (b <= 0 || a >= chars.length) continue; + if (a < 0) a = 0; + if (b > chars.length) b = chars.length; + + for (int i = a; i < b; i++) { + char ch = chars[i]; + if (ch != '\n' && ch != '\r') { + chars[i] = ' '; + } + } + } + expr = new String(chars); + } + expr = expr.replaceAll("\\s+", " ").trim(); + return expr; + } + + private boolean isCommentRange(String text, int start) { + if (start < 0 || start + 1 >= text.length()) return false; + if (text.charAt(start) != '/') return false; + char next = text.charAt(start + 1); + return next == '/' || next == '*'; + } + + /** + * Jump to just before the excluded range that contains position, or return position if unknown. + */ + private int jumpBeforeExcluded(int position) { + if (document == null) return position; + for (int[] range : document.getExcludedRanges()) { + if (position >= range[0] && position < range[1]) { + return range[0] - 1; + } + } + return position; + } + + /** + * Find the matching opening delimiter scanning backward from closePos. + * Skips excluded ranges and ignores delimiters inside string literals. + */ + private int findMatchingBackward(String text, int closePos, char openChar, char closeChar) { + int depth = 0; + boolean inString = false; + char stringChar = 0; + + for (int i = closePos; i >= 0; i--) { + char c = text.charAt(i); + + // Handle strings (backward), respecting escapes + if (!inString && (c == '"' || c == '\'')) { + int backslashCount = 0; + for (int j = i - 1; j >= 0 && text.charAt(j) == '\\'; j--) backslashCount++; + if (backslashCount % 2 == 0) { + inString = true; + stringChar = c; + } + } else if (inString && c == stringChar) { + int backslashCount = 0; + for (int j = i - 1; j >= 0 && text.charAt(j) == '\\'; j--) backslashCount++; + if (backslashCount % 2 == 0) { + inString = false; + } + } + + if (inString) continue; + + if (document != null && document.isExcluded(i)) continue; + + if (c == closeChar) depth++; + else if (c == openChar) { + depth--; + if (depth == 0) return i; + } + } + return -1; + } + + /** + * Find dot position before cursor, skipping whitespace. + * Returns -1 if no dot found. + */ + private int findDotBeforeWhitespace(String text, int fromPos) { + if (text == null || text.isEmpty()) return -1; + + int pos = Math.min(fromPos, text.length() - 1); + if (pos < 0) return -1; + // Skip backwards over whitespace + + while (pos >= 0 && Character.isWhitespace(text.charAt(pos))) { + pos--; + } + + // Check if we found a dot + if (pos >= 0 && text.charAt(pos) == '.') { + return pos; + } else { + while (pos >= 0 && Character.isJavaIdentifierPart(text.charAt(pos))) + pos--; + + if (pos >= 0 && text.charAt(pos) == '.') + return pos; + } + return -1; + } + + /** + * Check if cursor is after a dot. + */ + private boolean isAfterDot(String text, int cursorPos) { + if (text == null || text.isEmpty()) return false; + + // Look backwards, skipping any identifier characters + int pos = Math.min(cursorPos - 1, text.length() - 1); + if (pos < 0) return false; + while (pos >= 0 && Character.isJavaIdentifierPart(text.charAt(pos))) { + pos--; + } + // Also skip whitespace to check for dot + while (pos >= 0 && Character.isWhitespace(text.charAt(pos))) { + pos--; + } + return pos >= 0 && text.charAt(pos) == '.'; + } + + /** + * Check if a prefix is valid (identifier characters only). + */ + private boolean isValidPrefix(String prefix) { + if (prefix.isEmpty()) return true; + if (!Character.isJavaIdentifierStart(prefix.charAt(0))) return false; + for (int i = 1; i < prefix.length(); i++) { + if (!Character.isJavaIdentifierPart(prefix.charAt(i))) return false; + } + return true; + } + + /** + * Get line number (0-indexed) for a position. + */ + private int getLineNumber(String text, int position) { + int line = 0; + for (int i = 0; i < position && i < text.length(); i++) { + if (text.charAt(i) == '\n') line++; + } + return line; + } + + /** + * Get the current line text. + */ + private String getCurrentLine(String text, int position) { + int lineStart = text.lastIndexOf('\n', position - 1) + 1; + int lineEnd = text.indexOf('\n', position); + if (lineEnd < 0) lineEnd = text.length(); + return text.substring(lineStart, lineEnd); + } + + /** + * Get column position within the current line. + */ + private int getColumnPosition(String text, int position) { + int lineStart = text.lastIndexOf('\n', position - 1) + 1; + return position - lineStart; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/AutocompleteMenu.java b/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/AutocompleteMenu.java new file mode 100644 index 000000000..58263494e --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/AutocompleteMenu.java @@ -0,0 +1,1000 @@ +package noppes.npcs.client.gui.util.script.autocomplete; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.FontRenderer; +import net.minecraft.client.gui.Gui; +import net.minecraft.client.gui.ScaledResolution; +import noppes.npcs.client.gui.util.GuiNPCInterface; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenType; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import org.lwjgl.opengl.GL11; + +import java.util.ArrayList; +import java.util.List; + +/** + * UI component for displaying autocomplete suggestions. + * Styled similar to SearchReplaceBar with IntelliJ-like appearance. + */ +public class AutocompleteMenu extends Gui { + + // ==================== CONSTANTS ==================== + private static final int MAX_VISIBLE_ITEMS = 10; + private static final int ITEM_HEIGHT = 16; + private static final int PADDING = 4; + private static final int ICON_WIDTH = 16; + private static final int MIN_WIDTH = 200; + private static final int MAX_WIDTH = 400; + private static final int HINT_HEIGHT = 18; + + // ==================== COLORS ==================== + private static final int BG_COLOR = 0xFF2d2d30; + private static final int BORDER_COLOR = 0xFF3c3c3c; + private static final int SELECTED_BG = 0xFF094771; + private static final int HOVER_BG = 0xFF37373d; + private static final int TEXT_COLOR = 0xFFe0e0e0; + private static final int DIM_TEXT_COLOR = 0xFF808080; + private static final int HIGHLIGHT_COLOR = 0xFFFFD866; + private static final int HINT_BG_COLOR = 0xFF252526; + private static final int SCROLLBAR_BG = 0xFF3c3c3c; + private static final int SCROLLBAR_FG = 0xFF606060; + + // ==================== STATE ==================== + private boolean visible = false; + private List items = new ArrayList<>(); + private int selectedIndex = 0; + private int scrollOffset = 0; + private int hoveredIndex = -1; + + // Scrollbar drag state + private boolean isDraggingScrollbar = false; + private int dragStartY = 0; + private int dragStartScroll = 0; + + // Panel pan/drag state + private boolean isDraggingPanel; + private int panelDragOffsetX, panelDragOffsetY; + private boolean panelPositionOverridden; + private int overriddenX, overriddenY; + private boolean hasPendingPanelDrag; + private int pendingDragStartX, pendingDragStartY; + private boolean pendingItemConfirm; + + // Panel resize state + private boolean isResizingPanel; + private int resizeInitMouseX, resizeInitMouseY; + private int resizeInitW, resizeInitH; + private boolean panelSizeOverridden; + private int overriddenW, overriddenH; + private static final int MIN_RESIZE_W = 140; + private static final int MIN_RESIZE_H = 60; + private static final int DRAG_THRESHOLD = 4; + + // ==================== POSITION ==================== + private int x, y; + public GuiNPCInterface ownerGui; + private int width, height; + private int menuWidth; + private int visibleItemsCount; // Actual number of items that fit in the menu + + // ==================== FONT ==================== + private final FontRenderer font; + + // ==================== CALLBACK ==================== + private AutocompleteCallback callback; + + /** + * Callback interface for autocomplete events. + */ + public interface AutocompleteCallback { + void onItemSelected(AutocompleteItem item); + void onDismiss(); + } + + public AutocompleteMenu() { + this.font = Minecraft.getMinecraft().fontRenderer; + this.visibleItemsCount = MAX_VISIBLE_ITEMS; + } + + private int getVisibleItemCapacity() { + if (items == null || items.isEmpty()) + return 0; + int cap = visibleItemsCount > 0 ? visibleItemsCount : MAX_VISIBLE_ITEMS; + if (!panelSizeOverridden) cap = Math.min(cap, MAX_VISIBLE_ITEMS); + return Math.max(1, Math.min(cap, items.size())); + } + + private int getMaxScrollOffset() { + int cap = getVisibleItemCapacity(); + if (cap <= 0) + return 0; + return Math.max(0, items.size() - cap); + } + + public void setCallback(AutocompleteCallback callback) { + this.callback = callback; + } + + // ==================== VISIBILITY ==================== + + /** + * Show the menu at the specified position with the given items. + */ + public void show(int x, int y, List items, int viewportWidth, int viewportHeight) { + this.items = items != null ? new ArrayList<>(items) : new ArrayList<>(); + this.selectedIndex = 0; + this.scrollOffset = 0; + this.hoveredIndex = -1; + + // Calculate menu dimensions + calculateDimensions(x, y, viewportWidth, viewportHeight); + + this.visible = !this.items.isEmpty(); + } + + /** + * Update the items while keeping the menu open. + */ + public void updateItems(List newItems) { + this.items = newItems != null ? new ArrayList<>(newItems) : new ArrayList<>(); + + // Clamp selection + if (selectedIndex >= items.size()) { + selectedIndex = Math.max(0, items.size() - 1); + } + + // Clamp scroll + int maxScroll = getMaxScrollOffset(); + if (scrollOffset > maxScroll) { + scrollOffset = maxScroll; + } + + visible = !items.isEmpty(); + } + + /** + * Hide the menu. + */ + public void hide() { + visible = false; + isDraggingPanel = false; + isResizingPanel = false; + panelPositionOverridden = false; + panelSizeOverridden = false; + hasPendingPanelDrag = false; + pendingItemConfirm = false; + if (callback != null) { + callback.onDismiss(); + } + } + + public boolean isVisible() { + return visible; + } + + public boolean hasItems() { + return !items.isEmpty(); + } + + // ==================== DIMENSIONS ==================== + + private void calculateDimensions(int cursorX, int cursorY, int viewportWidth, int viewportHeight) { + // Calculate width based on item content + int maxItemWidth = MIN_WIDTH; + for (AutocompleteItem item : items) { + int itemWidth = ICON_WIDTH + PADDING + font.getStringWidth(item.getName()) + PADDING; + if (item.getTypeLabel() != null) { + itemWidth += font.getStringWidth(item.getTypeLabel()) + PADDING * 2; + } + maxItemWidth = Math.max(maxItemWidth, itemWidth); + } + menuWidth = Math.min(maxItemWidth + 20, MAX_WIDTH); // +20 for scrollbar + + // Calculate initial height + int visibleItems = Math.min(items.size(), MAX_VISIBLE_ITEMS); + int menuHeight = visibleItems * ITEM_HEIGHT + HINT_HEIGHT + PADDING * 2; + + // Line height estimation (cursor position is typically at baseline) + int lineHeight = 20; + + // Calculate available space + int spaceBelow = viewportHeight - cursorY - 10; // Space below cursor + int spaceAbove = cursorY - lineHeight - 10; // Space above current line + + // Determine if we should use horizontal positioning + // Use horizontal if both vertical positions would be cramped or block the cursor line + boolean useHorizontalPosition = false; + if (spaceBelow < menuHeight && spaceAbove < menuHeight) { + // Check if horizontal positioning would work better + int spaceRight = viewportWidth - (cursorX + 50) - 10; // 50 = offset from cursor + if (spaceRight >= menuWidth && viewportHeight > menuHeight + 20) { + useHorizontalPosition = true; + } else { + // Reduce height to fit in the best available vertical space + int availableVerticalSpace = Math.max(spaceBelow, spaceAbove); + if (availableVerticalSpace < menuHeight) { + // Calculate how many items we can show in available space + int maxItemsForSpace = (availableVerticalSpace - HINT_HEIGHT - PADDING * 2) / ITEM_HEIGHT; + maxItemsForSpace = Math.max(3, Math.min(maxItemsForSpace, items.size())); // At least 3 items + visibleItems = maxItemsForSpace; + menuHeight = visibleItems * ITEM_HEIGHT + HINT_HEIGHT + PADDING * 2; + } + } + } + + // Store the calculated visible items count + this.visibleItemsCount = visibleItems; + + // Position the menu + if (useHorizontalPosition) { + // Position to the right of the cursor + this.x = cursorX + 50; + this.y = cursorY - lineHeight; // Align with current line + + // Ensure doesn't go off bottom + if (y + menuHeight > viewportHeight - 10) { + y = viewportHeight - menuHeight - 10; + } + } else { + // Standard vertical positioning + this.x = cursorX; + + // Try below first + if (spaceBelow >= menuHeight) { + this.y = cursorY ; + } else if (spaceAbove >= menuHeight) { + // Show above cursor line + this.y = cursorY - menuHeight - lineHeight; + } else { + // Use the larger space + if (spaceBelow >= spaceAbove) { + this.y = cursorY; + } else { + this.y = cursorY - menuHeight - lineHeight; + } + } + + // Check if menu would go off-screen to the right + if (x + menuWidth > viewportWidth - 10) { + x = viewportWidth - menuWidth - 10; + } + } + + // Ensure not off-screen to the left or top + x = Math.max(5, x); + y = Math.max(5, y); + + this.width = menuWidth; + this.height = menuHeight; + // Apply position override if user has dragged the panel + if (panelPositionOverridden) { this.x = overriddenX; this.y = overriddenY; } + // Apply size override if user has resized the panel + if (panelSizeOverridden) { + this.menuWidth = overriddenW; + this.width = overriddenW; + this.height = overriddenH; + this.visibleItemsCount = Math.max(1, (overriddenH - HINT_HEIGHT - PADDING * 2) / ITEM_HEIGHT); + } + } + + // ==================== SELECTION ==================== + + /** + * Move selection up. + */ + public void selectPrevious() { + if (items.isEmpty()) return; + + selectedIndex--; + if (selectedIndex < 0) { + selectedIndex = items.size() - 1; + scrollOffset = getMaxScrollOffset(); + } else if (selectedIndex < scrollOffset) { + scrollOffset = selectedIndex; + } + } + + /** + * Move selection down. + */ + public void selectNext() { + if (items.isEmpty()) return; + + selectedIndex++; + if (selectedIndex >= items.size()) { + selectedIndex = 0; + scrollOffset = 0; + } else { + int cap = getVisibleItemCapacity(); + if (cap > 0 && selectedIndex >= scrollOffset + cap) { + scrollOffset = selectedIndex - cap + 1; + } + } + } + + /** + * Confirm the current selection. + */ + public void confirmSelection() { + if (items.isEmpty() || selectedIndex < 0 || selectedIndex >= items.size()) { + hide(); + return; + } + + AutocompleteItem selected = items.get(selectedIndex); + if (callback != null) { + callback.onItemSelected(selected); + } + hide(); + } + + /** + * Get the currently selected item. + */ + public AutocompleteItem getSelectedItem() { + if (items.isEmpty() || selectedIndex < 0 || selectedIndex >= items.size()) { + return null; + } + return items.get(selectedIndex); + } + + // ==================== DRAWING ==================== + + /** + * Draw the autocomplete menu. + */ + public void draw(int mouseX, int mouseY) { + if (!visible || items.isEmpty()) return; + + // Update hover state + updateHoverState(mouseX, mouseY); + + // Enable scissoring to clip content + GL11.glEnable(GL11.GL_SCISSOR_TEST); + setScissor(x - 2, y - 2, width + 4, height + 4); + + // Draw background + drawRect(x, y, x + width, y + height, BG_COLOR); + + // Draw border + drawRect(x, y, x + width, y + 1, BORDER_COLOR); + drawRect(x, y + height - 1, x + width, y + height, BORDER_COLOR); + drawRect(x, y, x + 1, y + height, BORDER_COLOR); + drawRect(x + width - 1, y, x + width, y + height, BORDER_COLOR); + + // Draw items — tighter scissor so partial last item is clipped at the items-area boundary + int itemAreaH = height - HINT_HEIGHT - PADDING * 2; + setScissor(x + 1, y + PADDING , width - 2, itemAreaH); + int itemY = y + PADDING; + + int visibleCount = getVisibleItemCapacity(); + int renderCount = Math.min(visibleCount + 1, items.size() - scrollOffset); + for (int i = 0; i < renderCount; i++) { + int itemIndex = scrollOffset + i; + if (itemIndex >= items.size()) break; + + AutocompleteItem item = items.get(itemIndex); + boolean isSelected = (itemIndex == selectedIndex); + boolean isHovered = (itemIndex == hoveredIndex); + + drawItem(item, x + PADDING, itemY, width - PADDING * 2 - 8, isSelected, isHovered); + itemY += ITEM_HEIGHT; + } + + // Restore full-panel scissor for scrollbar and hint bar + setScissor(x - 2, y - 2, width + 4, height + 4); + + // Draw scrollbar if needed + if (items.size() > visibleCount) { + drawScrollbar(mouseX, mouseY); + } + + // Draw hint bar at bottom + drawHintBar(); + + GL11.glDisable(GL11.GL_SCISSOR_TEST); + // Draw resize handle outside scissor + drawResizeHandle(mouseX, mouseY); + } + + /** + * Draw a single autocomplete item. + */ + private void drawItem(AutocompleteItem item, int itemX, int itemY, int itemWidth, + boolean selected, boolean hovered) { + // Background + if (selected) { + drawRect(itemX - 2, itemY, itemX + itemWidth + 2, itemY + ITEM_HEIGHT, SELECTED_BG); + } else if (hovered) { + drawRect(itemX - 2, itemY, itemX + itemWidth + 2, itemY + ITEM_HEIGHT, HOVER_BG); + } + + int textX = itemX; + int textY = itemY + (ITEM_HEIGHT - font.FONT_HEIGHT) / 2; + + // Draw modifier text (static/final) if present + boolean isStatic = item.isStatic(); + boolean isFinal = item.isFinal(); + if (isStatic || isFinal) { + GL11.glPushMatrix(); + float scale = 0.5f; + GL11.glScalef(scale, scale, scale); + int col = TokenType.MODIFIER.getHexColor(); + + if (isStatic) + font.drawString("s", (int) (textX / scale), (int) (textY / scale), col); + if (isFinal) + font.drawString("f", (int) (textX / scale), (int) (textY / scale) + 10, col); + GL11.glPopMatrix(); + } + + // Draw icon + String icon = item.getIconId(); + int iconColor = item.getIconColor(); + font.drawString(icon, textX + (ICON_WIDTH - font.getStringWidth(icon)) / 2, textY, iconColor); + textX += ICON_WIDTH; + + // Calculate available width for text (leave space for type label) + int availableWidth = itemWidth - (textX - itemX); + if (item.getTypeLabel() != null && !item.getTypeLabel().isEmpty()) { + int typeLabelWidth = font.getStringWidth(item.getTypeLabel()); + availableWidth -= typeLabelWidth + PADDING * 2; + } + + // Determine text color - gray for inherited Object methods + int textColor = getColor(item); + if (item.getKind() == AutocompleteItem.Kind.METHOD) { + drawMethodNameTruncated(item.getName(), item.getMatchIndices(), textX, textY, + textColor, availableWidth); + } else { + drawHighlightedTextTruncated(item.getName(), item.getMatchIndices(), textX, textY, + textColor, availableWidth); + } + + // Draw type label on the right + if (item.getTypeLabel() != null && !item.getTypeLabel().isEmpty()) { + String typeLabel = item.getTypeLabel(); + int typeLabelWidth = font.getStringWidth(typeLabel); + int typeLabelX = itemX + itemWidth - typeLabelWidth - PADDING; + + TypeInfo type = item.getTypeInfo(); + int col = type != null ? type.getTokenType().getHexColor() : DIM_TEXT_COLOR; + drawTypeLabel(typeLabel, typeLabelX, textY, col, type); + } + } + + public int getColor(AutocompleteItem item) { + if (item.isInheritedObjectMethod() || item.isDeprecated()) + return DIM_TEXT_COLOR; + + switch (item.getKind()) { + case METHOD: + return TokenType.METHOD_CALL.getHexColor(); + case FIELD: + return TokenType.GLOBAL_FIELD.getHexColor(); + case ENUM_CONSTANT: + return TokenType.ENUM_CONSTANT.getHexColor(); + case CLASS: + return TokenType.getColor(item.getTypeInfo()); + case VARIABLE: + return TokenType.LOCAL_FIELD.getHexColor(); + case KEYWORD: + return TokenType.KEYWORD.getHexColor(); + default: + return TEXT_COLOR; + } + } + + /** + * Draw method name with parameters colored gray. + */ + private void drawMethodName(String text, int[] matchIndices, int x, int y, int baseColor) { + // Find the opening parenthesis + int parenIndex = text.indexOf('('); + if (parenIndex == -1) { + // No parameters, just draw normally + drawHighlightedText(text, matchIndices, x, y, baseColor); + return; + } + + // Draw method name part with highlighting + String methodName = text.substring(0, parenIndex); + drawHighlightedText(methodName, matchIndices, x, y, baseColor); + + // Draw parameters part in gray (no highlighting) + String params = text.substring(parenIndex); + int paramX = x + font.getStringWidth(methodName); + font.drawString(params, paramX, y, DIM_TEXT_COLOR); + } + + /** + * Draw method name with parameters colored gray, truncated if too long. + */ + private void drawMethodNameTruncated(String text, int[] matchIndices, int x, int y, int baseColor, int maxWidth) { + // Find the opening parenthesis + int parenIndex = text.indexOf('('); + if (parenIndex == -1) { + // No parameters, just draw normally + drawHighlightedTextTruncated(text, matchIndices, x, y, baseColor, maxWidth); + return; + } + + String methodName = text.substring(0, parenIndex); + String params = text.substring(parenIndex); + + int methodNameWidth = font.getStringWidth(methodName); + int paramsWidth = font.getStringWidth(params); + int totalWidth = methodNameWidth + paramsWidth; + + if (totalWidth <= maxWidth) { + // Fits, draw normally + drawHighlightedText(methodName, matchIndices, x, y, baseColor); + int paramX = x + methodNameWidth; + font.drawString(params, paramX, y, DIM_TEXT_COLOR); + } else { + // Need to truncate + String ellipsis = "..."; + int ellipsisWidth = font.getStringWidth(ellipsis); + + // Always show method name, truncate params if needed + if (methodNameWidth + ellipsisWidth < maxWidth) { + drawHighlightedText(methodName, matchIndices, x, y, baseColor); + int paramX = x + methodNameWidth; + + // Truncate parameters + int availableForParams = maxWidth - methodNameWidth - ellipsisWidth; + String truncatedParams = truncateString(params, availableForParams); + font.drawString(truncatedParams + ellipsis, paramX, y, DIM_TEXT_COLOR); + } else { + // Even method name doesn't fit, truncate it too + int availableForMethod = maxWidth - ellipsisWidth; + String truncatedMethod = truncateString(methodName, availableForMethod); + drawHighlightedText(truncatedMethod, matchIndices, x, y, baseColor); + font.drawString(ellipsis, x + font.getStringWidth(truncatedMethod), y, baseColor); + } + } + } + + /** + * Draw text with specific characters highlighted. + */ + private void drawHighlightedText(String text, int[] matchIndices, int x, int y, int baseColor) { + if (matchIndices == null || matchIndices.length == 0) { + font.drawString(text, x, y, baseColor); + return; + } + + // Create a set of highlighted indices for quick lookup + java.util.Set highlightSet = new java.util.HashSet<>(); + for (int idx : matchIndices) { + highlightSet.add(idx); + } + + // Draw character by character + int currentX = x; + for (int i = 0; i < text.length(); i++) { + String ch = String.valueOf(text.charAt(i)); + int color = highlightSet.contains(i) ? HIGHLIGHT_COLOR : baseColor; + font.drawString(ch, currentX, y, color); + currentX += font.getStringWidth(ch); + } + } + + /** + * Draw text with highlighting, truncated if too long. + */ + private void drawHighlightedTextTruncated(String text, int[] matchIndices, int x, int y, int baseColor, int maxWidth) { + int textWidth = font.getStringWidth(text); + + if (textWidth <= maxWidth) { + // Fits, draw normally + drawHighlightedText(text, matchIndices, x, y, baseColor); + } else { + // Truncate with ellipsis + String ellipsis = "..."; + int ellipsisWidth = font.getStringWidth(ellipsis); + String truncated = truncateString(text, maxWidth - ellipsisWidth); + + // Adjust match indices for truncated text + int[] adjustedIndices = null; + if (matchIndices != null) { + java.util.List validIndices = new java.util.ArrayList<>(); + for (int idx : matchIndices) { + if (idx < truncated.length()) { + validIndices.add(idx); + } + } + adjustedIndices = new int[validIndices.size()]; + for (int i = 0; i < validIndices.size(); i++) { + adjustedIndices[i] = validIndices.get(i); + } + } + + drawHighlightedText(truncated, adjustedIndices, x, y, baseColor); + font.drawString(ellipsis, x + font.getStringWidth(truncated), y, baseColor); + } + } + + /** + * Truncate a string to fit within the given width. + */ + private String truncateString(String text, int maxWidth) { + if (text.isEmpty()) return text; + + int width = 0; + for (int i = 0; i < text.length(); i++) { + width += font.getStringWidth(String.valueOf(text.charAt(i))); + if (width > maxWidth) { + return text.substring(0, Math.max(0, i)); + } + } + return text; + } + + private void drawTypeLabel(String typeLabel, int x, int y, int typeColor, TypeInfo typeInfo) { + if (typeInfo == null) { + drawSimpleTypeWithArraySuffix(typeLabel, x, y, typeColor); + return; + } + drawTypeLabel(x, y, typeInfo, 0); + } + + private int drawTypeLabel(int x, int y, TypeInfo typeInfo, int depth) { + if (depth > 25) { + String name = typeInfo.getDisplayName(); + font.drawString(name, x, y, TokenType.getColor(typeInfo)); + return x + font.getStringWidth(name); + } + int defaultColor = TokenType.DEFAULT.getHexColor(); + if (typeInfo.isParameterized()) { + TypeInfo raw = typeInfo.getRawType(); + x = drawSimpleTypeWithArraySuffix(raw.getDisplayName(), x, y, TokenType.getColor(raw)); + font.drawString("<", x, y, defaultColor); + x += font.getStringWidth("<"); + java.util.List args = typeInfo.getAppliedTypeArgs(); + for (int i = 0; i < args.size(); i++) { + if (i > 0) { + font.drawString(", ", x, y, defaultColor); + x += font.getStringWidth(", "); + } + x = drawTypeLabel(x, y, args.get(i), depth + 1); + } + font.drawString(">", x, y, defaultColor); + return x + font.getStringWidth(">"); + } + return drawSimpleTypeWithArraySuffix(typeInfo.getDisplayName(), x, y, TokenType.getColor(typeInfo)); + } + + /** @return x position after last drawn character */ + private int drawSimpleTypeWithArraySuffix(String typeLabel, int x, int y, int typeColor) { + if (!typeLabel.endsWith("[]")) { + font.drawString(typeLabel, x, y, typeColor); + return x + font.getStringWidth(typeLabel); + } + int suffixStart = typeLabel.length() - 2; + while (suffixStart >= 2 && typeLabel.charAt(suffixStart - 2) == '[' && typeLabel.charAt(suffixStart - 1) == ']') { + suffixStart -= 2; + } + String core = typeLabel.substring(0, suffixStart); + String suffix = typeLabel.substring(suffixStart); + font.drawString(core, x, y, typeColor); + int coreWidth = font.getStringWidth(core); + font.drawString(suffix, x + coreWidth, y, TokenType.DEFAULT.getHexColor()); + return x + coreWidth + font.getStringWidth(suffix); + } + + private void drawScrollbar(int mouseX, int mouseY) { + int scrollbarX = x + width - 8; + int scrollbarY = y + PADDING; + int visibleCount = getVisibleItemCapacity(); + if (visibleCount <= 0) + return; + int scrollbarHeight = visibleCount * ITEM_HEIGHT - 8; // leave room for resize handle + + // Background + drawRect(scrollbarX, scrollbarY, scrollbarX + 6, scrollbarY + scrollbarHeight, SCROLLBAR_BG); + + // Thumb + float thumbRatio = (float) visibleCount / items.size(); + int thumbHeight = Math.max(20, (int) (scrollbarHeight * thumbRatio)); + float thumbPosRatio = Math.min(1f, (float) scrollOffset / Math.max(1, items.size() - visibleCount)); + int thumbY = scrollbarY + (int) ((scrollbarHeight - thumbHeight) * thumbPosRatio); + thumbY = Math.max(scrollbarY, Math.min(scrollbarY + scrollbarHeight - thumbHeight, thumbY)); + + // Check if mouse is above the scrollbar thumb + boolean isAboveScrollbar = mouseX >= scrollbarX && mouseX <= scrollbarX + 6 && + mouseY >= thumbY && mouseY < thumbY + thumbHeight; + + int col = isDraggingScrollbar || isAboveScrollbar? 0xFF808080 : SCROLLBAR_FG; + + drawRect(scrollbarX + 1, thumbY, scrollbarX + 5, thumbY + thumbHeight, col); + } + + /** + * Draw the hint bar at the bottom (shows Tab/Enter to confirm). + */ + private void drawHintBar() { + int hintY = y + height - HINT_HEIGHT; + + // Darker background for hint area + drawRect(x + 1, hintY, x + width - 1, y + height - 1, HINT_BG_COLOR); + + // Draw hints + int hintTextY = hintY + (HINT_HEIGHT - font.FONT_HEIGHT) / 2; + int hintX = x + PADDING; + + // Tab hint + drawKeyHint("Tab", hintX, hintTextY); + hintX += font.getStringWidth("Tab") + 8; + font.drawString("or", hintX, hintTextY, DIM_TEXT_COLOR); + hintX += font.getStringWidth("or") + 4; + + // Enter hint + drawKeyHint("Enter", hintX, hintTextY); + hintX += font.getStringWidth("Enter") + 8; + font.drawString("to insert", hintX, hintTextY, DIM_TEXT_COLOR); + } + + /** + * Draw a key hint with a darker background box. + */ + private void drawKeyHint(String key, int x, int y) { + int keyWidth = font.getStringWidth(key); + int boxPadding = 2; + + // Draw box + drawRect(x - boxPadding, y - boxPadding, + x + keyWidth + boxPadding, y + font.FONT_HEIGHT + boxPadding, + 0xFF404040); + + // Draw key text + font.drawString(key, x, y, TEXT_COLOR); + } + + // ==================== MOUSE HANDLING ==================== + + /** + * Update hover state based on mouse position. + */ + private void updateHoverState(int mouseX, int mouseY) { + hoveredIndex = -1; + + if (!isMouseInBounds(mouseX, mouseY)) return; + + int itemY = y + PADDING; + + int visibleItems = getVisibleItemCapacity(); + + for (int i = 0; i <= visibleItems; i++) { + int idx = scrollOffset + i; + if (idx >= items.size()) break; + if (mouseY >= itemY && mouseY < itemY + ITEM_HEIGHT) { + hoveredIndex = idx; + break; + } + itemY += ITEM_HEIGHT; + } + } + + /** + * Handle mouse click. + * @return true if click was consumed + */ + public boolean mouseClicked(int mouseX, int mouseY, int button) { + if (!visible) return false; + + // Check if click is outside menu + if (!isMouseInBounds(mouseX, mouseY)) { + hide(); + return false; + } + + // Resize handle has top priority + if (button == 0 && isMouseOverResizeHandle(mouseX, mouseY)) { + isResizingPanel = true; + resizeInitMouseX = mouseX; resizeInitMouseY = mouseY; + resizeInitW = width; resizeInitH = height; + return true; + } + + // Scrollbar + if (button == 0 && items.size() > getVisibleItemCapacity()) { + int scrollbarX = x + width - 8; + if (mouseX >= scrollbarX && mouseX <= scrollbarX + 6) { + isDraggingScrollbar = true; + dragStartY = mouseY; + dragStartScroll = scrollOffset; + return true; + } + } + + // Anywhere inside panel body — start pending drag, defer item confirm to release + if (button == 0) { + hasPendingPanelDrag = true; + pendingDragStartX = mouseX; + pendingDragStartY = mouseY; + panelDragOffsetX = mouseX - x; + panelDragOffsetY = mouseY - y; + if (hoveredIndex >= 0 && hoveredIndex < items.size()) { + selectedIndex = hoveredIndex; + pendingItemConfirm = true; + } + return true; + } + + return true; // Consume click if inside menu + } + + /** + * Handle mouse release. + * @return true if release was consumed + */ + public boolean mouseReleased(int mouseX, int mouseY, int button) { + if (button == 0) { + if (isDraggingScrollbar) { isDraggingScrollbar = false; return true; } + if (isDraggingPanel) { isDraggingPanel = false; return true; } + if (isResizingPanel) { isResizingPanel = false; return true; } + hasPendingPanelDrag = false; + if (pendingItemConfirm) { + pendingItemConfirm = false; + confirmSelection(); + return true; + } + } + return false; + } + + /** + * Handle mouse drag. + * @return true if drag was consumed + */ + public boolean mouseDragged(int mouseX, int mouseY) { + if (!visible) return false; + if (isDraggingPanel) { updatePanelDrag(mouseX, mouseY); return true; } + if (isResizingPanel) { updatePanelResize(mouseX, mouseY); return true; } + + // Activate panel drag once movement exceeds threshold + if (hasPendingPanelDrag) { + int dx = Math.abs(mouseX - pendingDragStartX); + int dy = Math.abs(mouseY - pendingDragStartY); + if (dx > DRAG_THRESHOLD || dy > DRAG_THRESHOLD) { + isDraggingPanel = true; + hasPendingPanelDrag = false; + pendingItemConfirm = false; // cancel any pending selection + updatePanelDrag(mouseX, mouseY); + return true; + } + return true; + } + + if (!isDraggingScrollbar) return false; + // Scrollbar drag (kept for backward compat — also handled via draw loop) + int visibleCount = getVisibleItemCapacity(); + if (visibleCount <= 0) return false; + int scrollbarHeight = visibleCount * ITEM_HEIGHT - 8; + int thumbHeight = Math.max(20, (int) (scrollbarHeight * (float) visibleCount / Math.max(1, items.size()))); + int scrollTrackHeight = Math.max(1, scrollbarHeight - thumbHeight); + int maxScroll = items.size() - visibleCount; + int deltaY = mouseY - dragStartY; + int scrollDelta = (deltaY * maxScroll) / scrollTrackHeight; + scrollOffset = Math.max(0, Math.min(maxScroll, dragStartScroll + scrollDelta)); + return true; + } + + /** + * Handle mouse scroll. + * @return true if scroll was consumed + */ + public boolean mouseScrolled(int mouseX, int mouseY, int delta) { + if (!visible || !isMouseInBounds(mouseX, mouseY)) return false; + + int visibleCount = getVisibleItemCapacity(); + if (items.size() > visibleCount) { + if (delta > 0) { + scrollOffset = Math.max(0, scrollOffset - 1); + } else { + scrollOffset = Math.min(items.size() - visibleCount, scrollOffset + 1); + } + return true; + } + + return false; + } + + private boolean isMouseInBounds(int mouseX, int mouseY) { + return mouseX >= x && mouseX <= x + width && mouseY >= y && mouseY <= y + height; + } + + // ==================== UTILITY ==================== + + private void setScissor(int x, int y, int width, int height) { + Minecraft mc = Minecraft.getMinecraft(); + ScaledResolution sr = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight); + int scaleFactor = sr.getScaleFactor(); + + if (ownerGui != null) { + x -= (int) ownerGui.getPanX(); + y -= (int) ownerGui.getPanY(); + } + + int scissorX = x * scaleFactor; + int scissorY = mc.displayHeight - (y + height) * scaleFactor; + int scissorW = width * scaleFactor; + int scissorH = height * scaleFactor; + + GL11.glScissor(scissorX, scissorY, scissorW, scissorH); + } + + // ==================== GETTERS ==================== + + public int getX() { return x; } + public int getY() { return y; } + public int getWidth() { return width; } + public int getHeight() { return height; } + public List getItems() { return items; } + // ==================== PANEL DRAG / RESIZE ==================== + + public boolean isMouseOverResizeHandle(int mx, int my) { + if (!visible) return false; + return mx >= x + width - 8 && mx <= x + width && my >= y + height - 8 && my <= y + height; + } + + public void updatePanelDrag(int mouseX, int mouseY) { + if (!isDraggingPanel) return; + x = mouseX - panelDragOffsetX; + y = mouseY - panelDragOffsetY; + overriddenX = x; + overriddenY = y; + panelPositionOverridden = true; + } + + public void releasePanelDrag() { isDraggingPanel = false; hasPendingPanelDrag = false; } + + public void updatePanelResize(int mouseX, int mouseY) { + if (!isResizingPanel) return; + overriddenW = Math.max(MIN_RESIZE_W, resizeInitW + (mouseX - resizeInitMouseX)); + overriddenH = Math.max(MIN_RESIZE_H, resizeInitH + (mouseY - resizeInitMouseY)); + panelSizeOverridden = true; + menuWidth = overriddenW; + width = overriddenW; + height = overriddenH; + visibleItemsCount = Math.max(1, (overriddenH - HINT_HEIGHT - PADDING * 2) / ITEM_HEIGHT); + } + + public void releasePanelResize() { isResizingPanel = false; } + + /** Used by draw-loop scrollbar update in GuiScriptTextArea */ + public void updateScrollbarDragDraw(int mouseY) { + if (!isDraggingScrollbar || items.isEmpty()) return; + int visibleCount = getVisibleItemCapacity(); + if (visibleCount <= 0) return; + int scrollbarHeight = visibleCount * ITEM_HEIGHT - 8; + int thumbHeight = Math.max(20, (int) (scrollbarHeight * (float) visibleCount / items.size())); + int scrollTrackHeight = Math.max(1, scrollbarHeight - thumbHeight); + int maxScroll = items.size() - visibleCount; + int deltaY = mouseY - dragStartY; + int scrollDelta = (deltaY * maxScroll) / scrollTrackHeight; + scrollOffset = Math.max(0, Math.min(maxScroll, dragStartScroll + scrollDelta)); + } + + public void releaseScrollbarDrag() { isDraggingScrollbar = false; } + + public boolean isDraggingPanel() { return isDraggingPanel; } + public boolean isDraggingScrollbarMenu() { return isDraggingScrollbar; } + public boolean isResizingPanel() { return isResizingPanel; } + + private void drawResizeHandle(int mouseX, int mouseY) { + boolean resizeActive = isResizingPanel || isMouseOverResizeHandle(mouseX, mouseY); + int dotColor = resizeActive ? 0xFFCCCCCC : 0x80888888; + int rhX = x + width - 2; + int rhY = y + height - 2; + // Three-dot diagonal pattern (◢) + drawRect(rhX - 1, rhY - 1, rhX, rhY, dotColor); + drawRect(rhX - 3, rhY - 1, rhX - 2, rhY, dotColor); + drawRect(rhX - 1, rhY - 3, rhX, rhY - 2, dotColor); + drawRect(rhX - 5, rhY - 1, rhX - 4, rhY, dotColor); + drawRect(rhX - 3, rhY - 3, rhX - 2, rhY - 2, dotColor); + drawRect(rhX - 1, rhY - 5, rhX, rhY - 4, dotColor); + } + +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/AutocompleteProvider.java b/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/AutocompleteProvider.java new file mode 100644 index 000000000..a11282d24 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/AutocompleteProvider.java @@ -0,0 +1,74 @@ +package noppes.npcs.client.gui.util.script.autocomplete; + +import java.util.List; + +/** + * Abstract provider for autocomplete suggestions. + * Implementations handle different contexts (after dot, in identifier, etc.) + */ +public interface AutocompleteProvider { + + /** + * Context information for autocomplete requests. + */ + class Context { + /** Full text of the document */ + public final String text; + /** Current cursor position in the document */ + public final int cursorPosition; + /** The current line number (0-indexed) */ + public final int lineNumber; + /** Position of cursor within the current line */ + public final int columnPosition; + /** The current line text */ + public final String currentLine; + /** The word being typed (prefix before cursor, after last separator) */ + public final String prefix; + /** Start position of the prefix in the document */ + public final int prefixStart; + /** Whether this is after a dot (member access) */ + public final boolean isMemberAccess; + /** Expression before the dot (for member access) */ + public final String receiverExpression; + /** Whether autocomplete was explicitly triggered (CTRL+Space) */ + public final boolean explicitTrigger; + /** Whether to show only methods (for method reference context ::) */ + public final boolean methodsOnly; + + public Context(String text, int cursorPosition, int lineNumber, int columnPosition, + String currentLine, String prefix, int prefixStart, + boolean isMemberAccess, String receiverExpression, boolean explicitTrigger) { + this(text, cursorPosition, lineNumber, columnPosition, currentLine, prefix, prefixStart, + isMemberAccess, receiverExpression, explicitTrigger, false); + } + + public Context(String text, int cursorPosition, int lineNumber, int columnPosition, + String currentLine, String prefix, int prefixStart, + boolean isMemberAccess, String receiverExpression, boolean explicitTrigger, + boolean methodsOnly) { + this.text = text; + this.cursorPosition = cursorPosition; + this.lineNumber = lineNumber; + this.columnPosition = columnPosition; + this.currentLine = currentLine; + this.prefix = prefix; + this.prefixStart = prefixStart; + this.isMemberAccess = isMemberAccess; + this.receiverExpression = receiverExpression; + this.explicitTrigger = explicitTrigger; + this.methodsOnly = methodsOnly; + } + } + + /** + * Get autocomplete suggestions for the given context. + * @param context The context containing cursor position, text, etc. + * @return List of autocomplete items, sorted by relevance + */ + List getSuggestions(Context context); + + /** + * Check if this provider can handle the given context. + */ + boolean canProvide(Context context); +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/JSAutocompleteProvider.java b/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/JSAutocompleteProvider.java new file mode 100644 index 000000000..b342a5384 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/JSAutocompleteProvider.java @@ -0,0 +1,354 @@ +package noppes.npcs.client.gui.util.script.autocomplete; + +import noppes.npcs.client.gui.util.script.interpreter.js_parser.*; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.synthetic.*; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeChecker; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import noppes.npcs.config.ConfigScript; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.*; + +/** + * Autocomplete provider for JavaScript/ECMAScript scripts. + * Uses ScriptDocument's unified TypeInfo/TypeResolver system for type resolution. + */ +public class JSAutocompleteProvider extends JavaAutocompleteProvider { + + private final JSTypeRegistry registry; + + public JSAutocompleteProvider() { + this.registry = JSTypeRegistry.getInstance(); + if (!registry.isInitialized()) { + registry.initializeFromResources(); + } + } + + @Override + public boolean canProvide(Context context) { + return document != null && document.isJavaScript(); + } + + + /** + * Add suggestions for member access (after dot). + * Uses ScriptDocument's unified type resolution system. + */ + protected void addMemberSuggestions(Context context, List items) { + String receiverExpr = context.receiverExpression; + if (receiverExpr == null || receiverExpr.isEmpty()) { + return; + } + + // Use ScriptDocument's resolveExpressionType - handles both Java and JS + TypeInfo receiverType = document.resolveExpressionType(receiverExpr, getMemberAccessResolvePosition(context)); + if (receiverType == null || !receiverType.isResolved()) { + return; + } + + // Check for synthetic types first (e.g., Nashorn Java object, custom types) + SyntheticType syntheticType = + document.getTypeResolver().getSyntheticType(receiverType.getSimpleName()); + if (syntheticType != null) { + addSyntheticTypeSuggestions(syntheticType, items, context.methodsOnly); + return; + } + + boolean isStaticContext = isStaticAccess(receiverExpr, getMemberAccessResolvePosition(context)); + + Class javaClass = receiverType.getJavaClass(); + if (javaClass != null) { + Set addedMethods = new HashSet<>(); + for (Method method : javaClass.getMethods()) { + if (!Modifier.isPublic(method.getModifiers())) continue; + if (isStaticContext && !Modifier.isStatic(method.getModifiers())) continue; + String sig = method.getName() + "(" + method.getParameterCount() + ")"; + if (addedMethods.add(sig)) { + items.add(AutocompleteItem.fromMethod(MethodInfo.fromReflection(method, receiverType), context.methodsOnly)); + } + } + List effectiveSyntheticMethods = receiverType.getSyntheticMethods(); + if (!effectiveSyntheticMethods.isEmpty()) { + for (MethodInfo method : effectiveSyntheticMethods) { + if (isStaticContext && !method.isStatic()) continue; + items.add(AutocompleteItem.fromMethod(method, context.methodsOnly)); + } + } else { + JSTypeInfo jsType = getMergeRegistryType(javaClass); + if (jsType != null) { + addMethodsFromType(jsType, receiverType, items, new HashSet<>(), context.methodsOnly, isStaticContext); + } + } + if (!context.methodsOnly) { + for (Field field : javaClass.getFields()) { + if (!Modifier.isPublic(field.getModifiers())) continue; + if (isStaticContext && !Modifier.isStatic(field.getModifiers())) continue; + items.add(AutocompleteItem.fromField(FieldInfo.fromReflection(field, receiverType))); + } + if (!receiverType.getSyntheticFields().isEmpty()) { + for (FieldInfo field : receiverType.getSyntheticFields()) { + if (isStaticContext && !field.isStatic()) continue; + items.add(AutocompleteItem.fromField(field)); + } + } else { + JSTypeInfo jsType = getMergeRegistryType(javaClass); + if (jsType != null) { + addFieldsFromType(jsType, receiverType, items, new HashSet<>(), isStaticContext); + } + } + } + if (!isStaticContext && javaClass != Object.class) { + JSTypeInfo objJSType = registry.getType("Object"); + if (objJSType != null) { + for (JSMethodInfo m : objJSType.getMethods().values()) { + if (!m.isStatic()) { + items.add(AutocompleteItem.fromJSMethod(m, receiverType, 1, context.methodsOnly)); + } + } + } + } + return; + } + + Set syntheticMethodNames = new HashSet<>(); + for (MethodInfo method : receiverType.getSyntheticMethods()) { + syntheticMethodNames.add(method.getName()); + if (isStaticContext && !method.isStatic()) continue; + items.add(AutocompleteItem.fromMethod(method, context.methodsOnly)); + } + for (FieldInfo field : receiverType.getSyntheticFields()) { + if (!context.methodsOnly) { + if (isStaticContext && !field.isStatic()) continue; + if (syntheticMethodNames.contains(field.getName())) continue; + items.add(AutocompleteItem.fromField(field)); + } + } + + JSTypeInfo jsTypeInfo = receiverType.getJSTypeInfo(); + if (jsTypeInfo != null) { + addMethodsFromType(jsTypeInfo, receiverType, items, new HashSet<>(), context.methodsOnly, isStaticContext); + if (!context.methodsOnly && ConfigScript.ShowImplementationFieldsInAutocomplete) { + addFieldsFromType(jsTypeInfo, receiverType, items, new HashSet<>(), isStaticContext); + } + } + + if (!isStaticContext) { + Set addedObjMethods = new HashSet<>(); + for (Method m : Object.class.getMethods()) { + if (!Modifier.isPublic(m.getModifiers()) || Modifier.isStatic(m.getModifiers())) continue; + String sig = m.getName() + "(" + m.getParameterCount() + ")"; + if (addedObjMethods.add(sig)) { + items.add(AutocompleteItem.fromMethod(MethodInfo.fromReflection(m, receiverType), context.methodsOnly)); + } + } + JSTypeInfo objJSType = registry.getType("Object"); + if (objJSType != null) { + for (JSMethodInfo m : objJSType.getMethods().values()) { + if (!m.isStatic()) { + items.add(AutocompleteItem.fromJSMethod(m, receiverType, 1, context.methodsOnly)); + } + } + } + } + } + + private JSTypeInfo getMergeRegistryType(Class javaClass) { + return document.getTypeResolver().findJSTypeForJavaClass(javaClass); + } + + /** + * Add autocomplete suggestions for a synthetic type's methods and fields. + * @param syntheticType The synthetic type + * @param items The list to add items to + * @param forMethodReference If true, only add methods with no parentheses in insert text + */ + private void addSyntheticTypeSuggestions(SyntheticType syntheticType, List items, boolean forMethodReference) { + // Add methods + for (SyntheticMethod method : syntheticType.getMethods()) { + AutocompleteItem item = AutocompleteItem.fromSyntheticMethod(method, syntheticType.getTypeInfo(), forMethodReference); + items.add(item); + } + + // Add fields (skip if forMethodReference is true) + if (!forMethodReference) { + for (SyntheticField field : syntheticType.getFields()) { + AutocompleteItem item = AutocompleteItem.fromSyntheticField(field); + items.add(item); + } + } + } + + /** + * Recursively add methods from a type and its parents. + * @param type The current JS type to get methods from (changes as we walk up inheritance) + * @param contextType The original TypeInfo context for resolving type parameters (stays constant) + */ + protected void addMethodsFromType(JSTypeInfo type, TypeInfo contextType, List items, Set added) { + addMethodsFromType(type, contextType, items, added, 0, false, false); + } + + /** + * Recursively add methods from a type and its parents. + * @param type The current JS type to get methods from (changes as we walk up inheritance) + * @param contextType The original TypeInfo context for resolving type parameters (stays constant) + * @param forMethodReference If true, insert text will NOT include parentheses + */ + protected void addMethodsFromType(JSTypeInfo type, TypeInfo contextType, List items, Set added, boolean forMethodReference) { + addMethodsFromType(type, contextType, items, added, 0, forMethodReference, false); + } + + /** + * Recursively add methods from a type and its parents. + * @param type The current JS type to get methods from (changes as we walk up inheritance) + * @param contextType The original TypeInfo context for resolving type parameters (stays constant) + * @param forMethodReference If true, insert text will NOT include parentheses + * @param isStaticContext If true, only add static methods + */ + protected void addMethodsFromType(JSTypeInfo type, TypeInfo contextType, List items, Set added, boolean forMethodReference, boolean isStaticContext) { + addMethodsFromType(type, contextType, items, added, 0, forMethodReference, isStaticContext); + } + + /** + * Recursively add methods from a type and its parents with inheritance depth tracking. + * Shows all overloads - one autocomplete item per overload. + * @param type The current JS type in inheritance chain + * @param contextType The original TypeInfo context for resolving type parameters (e.g., IPlayer with T → EntityPlayerMP) + */ + private void addMethodsFromType(JSTypeInfo type, TypeInfo contextType, List items, Set added, int depth) { + addMethodsFromType(type, contextType, items, added, depth, false, false); + } + + /** + * Recursively add methods from a type and its parents with inheritance depth tracking. + * Shows all overloads - one autocomplete item per overload. + * @param type The current JS type in inheritance chain + * @param contextType The original TypeInfo context for resolving type parameters (e.g., IPlayer with T → EntityPlayerMP) + * @param forMethodReference If true, insert text will NOT include parentheses + */ + private void addMethodsFromType(JSTypeInfo type, TypeInfo contextType, List items, Set added, int depth, boolean forMethodReference) { + addMethodsFromType(type, contextType, items, added, depth, forMethodReference, false); + } + + private void addMethodsFromType(JSTypeInfo type, TypeInfo contextType, List items, Set added, int depth, boolean forMethodReference, boolean isStaticContext) { + // Collect base method names (without $N suffix) that we haven't processed yet + Set baseNames = new HashSet<>(); + for (String key : type.getMethods().keySet()) { + String baseName = key.contains("$") ? key.substring(0, key.indexOf('$')) : key; + if (!added.contains(baseName)) { + baseNames.add(baseName); + } + } + + // For each base method name, add all overloads + for (String baseName : baseNames) { + added.add(baseName); + // Use getMethodOverloads to get all overloads for this method (excluding inherited) + List overloads = new ArrayList<>(); + if (type.getMethods().containsKey(baseName)) { + overloads.add(type.getMethods().get(baseName)); + } + int index = 1; + while (type.getMethods().containsKey(baseName + "$" + index)) { + overloads.add(type.getMethods().get(baseName + "$" + index)); + index++; + } + // Add one autocomplete item per overload + for (JSMethodInfo method : overloads) { + if (isStaticContext && !method.isStatic()) continue; + items.add(AutocompleteItem.fromJSMethod(method, contextType, depth, forMethodReference)); + } + } + + // Add from parent type with incremented depth - keep same contextType + if (type.getResolvedParent() != null) { + addMethodsFromType(type.getResolvedParent(), contextType, items, added, depth + 1, forMethodReference, isStaticContext); + } + } + + /** + * Recursively add fields from a type and its parents. + * @param type The current JS type to get fields from (changes as we walk up inheritance) + * @param contextType The original TypeInfo context for resolving type parameters (stays constant) + */ + protected void addFieldsFromType(JSTypeInfo type, TypeInfo contextType, List items, Set added) { + addFieldsFromType(type, contextType, items, added, 0, false); + } + + protected void addFieldsFromType(JSTypeInfo type, TypeInfo contextType, List items, Set added, boolean isStaticContext) { + addFieldsFromType(type, contextType, items, added, 0, isStaticContext); + } + + /** + * Recursively add fields from a type and its parents with inheritance depth tracking. + * @param type The current JS type in inheritance chain + * @param contextType The original TypeInfo context for resolving type parameters + */ + private void addFieldsFromType(JSTypeInfo type, TypeInfo contextType, List items, Set added, int depth) { + addFieldsFromType(type, contextType, items, added, depth, false); + } + + private void addFieldsFromType(JSTypeInfo type, TypeInfo contextType, List items, Set added, int depth, boolean isStaticContext) { + for (JSFieldInfo field : type.getFields().values()) { + if (!added.contains(field.getName())) { + if (isStaticContext && !field.isStatic()) continue; + added.add(field.getName()); + // Pass contextType (original receiver) for type parameter resolution, not current type + items.add(AutocompleteItem.fromJSField(field, contextType, depth)); + } + } + + // Add from parent type with incremented depth - keep same contextType + if (type.getResolvedParent() != null) { + addFieldsFromType(type.getResolvedParent(), contextType, items, added, depth + 1, isStaticContext); + } + } + + protected void addUnimportedClassSuggestions(String prefix, List items) { + // For JavaScript, we typically don't suggest unimported classes + // as imports are handled differently. This can be customized + // if needed to suggest global JS types. + } + + @Override + protected void addLanguageUniqueSuggestions(Context context, List items) { + super.addLanguageUniqueSuggestions(context, items); + + // Add global variables from both global engine objects and document editor/DataScript globals + List globalNames = new ArrayList<>(); + globalNames.addAll(registry.getGlobalEngineObjects().keySet()); + globalNames.addAll(document.getEditorGlobals().keySet()); + + for (String name : globalNames) { + FieldInfo fieldInfo = document.resolveVariable(name, context.cursorPosition); + if (fieldInfo == null || !fieldInfo.isResolved()) + continue; + + items.add(AutocompleteItem.fromField(fieldInfo)); + } + + // Add global imports in JSTypeRegistry.globalEngineImports + for (String importName : registry.getGlobalEngineImports().keySet()) { + JSTypeInfo jsTypeInfo = registry.getGlobalImportType(importName); + if (jsTypeInfo != null) { + items.add(AutocompleteItem.fromType(TypeInfo.fromJSTypeInfo(jsTypeInfo))); + } + } + + // Add global engine functions (parseInt, parseFloat, isNaN, isFinite, etc.) + for (JSMethodInfo fn : registry.getGlobalEngineFunctions().values()) { + items.add(AutocompleteItem.fromJSMethod(fn, 0)); + } + } + + protected UsageTracker getUsageTracker() { + return UsageTracker.getJSInstance(); + } + + public String[] getKeywords() { + return TypeChecker.getJavaScriptKeywords(); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/JavaAutocompleteProvider.java b/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/JavaAutocompleteProvider.java new file mode 100644 index 000000000..067bccaca --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/JavaAutocompleteProvider.java @@ -0,0 +1,605 @@ +package noppes.npcs.client.gui.util.script.autocomplete; + +import noppes.npcs.client.gui.util.script.interpreter.ScriptDocument; +import noppes.npcs.client.gui.util.script.interpreter.field.EnumConstantInfo; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.ScriptTypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeChecker; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeResolver; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.*; + +/** + * Autocomplete provider for Java/Groovy scripts. + * Uses ScriptDocument for type resolution and scope analysis. + */ +public class JavaAutocompleteProvider implements AutocompleteProvider { + + protected ScriptDocument document; + + public void setDocument(ScriptDocument document) { + this.document = document; + } + + @Override + public boolean canProvide(Context context) { + return document != null && !document.isJavaScript(); + } + + @Override + public List getSuggestions(Context context) { + List items = new ArrayList<>(); + + if (document == null) { + return items; + } + + // Resolve owner type for usage tracking and static context detection + String ownerFullName = null; + boolean isStaticContext = false; + if (context.isMemberAccess && context.receiverExpression != null) { + int resolvePos = getMemberAccessResolvePosition(context); + TypeInfo receiverType = document.resolveExpressionType( + context.receiverExpression, resolvePos); + if (receiverType != null && receiverType.isResolved()) { + ownerFullName = receiverType.getFullName(); + } + // Check if accessing through a class (static context) vs instance + isStaticContext = isStaticAccess(context.receiverExpression, resolvePos); + } + + if (context.isMemberAccess) { + // Member access: resolve type of receiver and get its members + addMemberSuggestions(context, items); + } else { + // Identifier context: show variables, methods, types in scope + addScopeSuggestions(context, items); + } + + // For method reference context, filter to show only methods (and constructor "new") + if (context.methodsOnly) { + items.removeIf(item -> item.getKind() != AutocompleteItem.Kind.METHOD); + + // Add "new" constructor reference option if the receiver is a class + if (context.receiverExpression != null) { + int resolvePos = getMemberAccessResolvePosition(context); + TypeInfo receiverType = document.resolveExpressionType( + context.receiverExpression, resolvePos); + if (receiverType != null && receiverType.isResolved() && isStaticContext) { + items.add(new AutocompleteItem.Builder() + .name("new") + .insertText("new") + .kind(AutocompleteItem.Kind.KEYWORD) + .typeLabel("constructor") + .signature(receiverType.getSimpleName() + "::new") + .build()); + } + } + } + + // Filter and score by prefix, then apply usage boosts and static penalties + filterAndScore(items, context.prefix, context.isMemberAccess, isStaticContext, ownerFullName); + + // Sort by score + Collections.sort(items); + + return items; + } + + /** + * Add suggestions for member access (after dot). + */ + protected void addMemberSuggestions(Context context, List items) { + String receiverExpr = context.receiverExpression; + if (receiverExpr == null || receiverExpr.isEmpty()) { + return; + } + + // Resolve the type of the receiver expression + TypeInfo receiverType = document.resolveExpressionType(receiverExpr, getMemberAccessResolvePosition(context)); + + if (receiverType == null || !receiverType.isResolved()) { + return; + } + + // Determine if this is a static context (accessing a class type) + boolean isStaticContext = isStaticAccess(receiverExpr, getMemberAccessResolvePosition(context)); + + Class clazz = receiverType.getJavaClass(); + if (clazz == null) { + // Try ScriptTypeInfo + if (receiverType instanceof ScriptTypeInfo) { + addScriptTypeMembers((ScriptTypeInfo) receiverType, items, isStaticContext, context.methodsOnly); + } + return; + } + + // Add methods + Set addedMethods = new HashSet<>(); + for (Method method : clazz.getMethods()) { + if (Modifier.isPublic(method.getModifiers())) { + // Filter by static context + if (isStaticContext && !Modifier.isStatic(method.getModifiers())) { + continue; + } + + String sig = method.getName() + "(" + method.getParameterCount() + ")"; + if (!addedMethods.contains(sig)) { + addedMethods.add(sig); + MethodInfo methodInfo = MethodInfo.fromReflection(method, receiverType); + items.add(AutocompleteItem.fromMethod(methodInfo, context.methodsOnly)); + } + } + } + + for (MethodInfo method : receiverType.getSyntheticMethods()) { + if (isStaticContext && !Modifier.isStatic(method.getModifiers())) + continue; + + items.add(AutocompleteItem.fromMethod(method, context.methodsOnly)); + } + + // Add fields (skip if methodsOnly is true - but the filtering will be done in getSuggestions) + if (!context.methodsOnly) { + for (Field field : clazz.getFields()) { + if (Modifier.isPublic(field.getModifiers())) { + // Filter by static context + if (isStaticContext && !Modifier.isStatic(field.getModifiers())) { + continue; + } + + FieldInfo fieldInfo = FieldInfo.fromReflection(field, receiverType); + items.add(AutocompleteItem.fromField(fieldInfo)); + } + } + + for (FieldInfo field : receiverType.getSyntheticFields()) { + if (isStaticContext && !Modifier.isStatic(field.getModifiers())) + continue; + + items.add(AutocompleteItem.fromField(field)); + } + } + + // Add nested types (inner classes/interfaces) in static context + if (isStaticContext && !context.methodsOnly) { + try { + for (Class nested : clazz.getDeclaredClasses()) { + if (!Modifier.isPublic(nested.getModifiers())) { + continue; + } + // Convert $ notation to dot notation for resolution + String nestedFullName = nested.getName().replace('$', '.'); + TypeInfo nestedType = TypeResolver.getInstance().resolveFullName(nestedFullName); + if (nestedType != null && nestedType.isResolved()) { + items.add(AutocompleteItem.fromType(nestedType)); + } + } + } catch (SecurityException ignored) { + // Some runtimes may restrict getDeclaredClasses() + } + } + + } + + /** + * Pick a stable position for resolving member-access receiver types. + * + * Using `prefixStart` can land on end-exclusive scope boundaries (position == bodyEnd) + * depending on caller cursor semantics and surrounding syntax, causing scope lookups + * to fail. For member access we prefer the dot position (or nearest non-whitespace) + * immediately before prefixStart. + */ + protected int getMemberAccessResolvePosition(Context context) { + if (context == null || context.text == null || context.text.isEmpty()) { + return 0; + } + + int pos = Math.max(0, Math.min(context.prefixStart, context.text.length())); + int i = Math.min(pos - 1, context.text.length() - 1); + + // Skip whitespace backwards + while (i >= 0 && Character.isWhitespace(context.text.charAt(i))) { + i--; + } + + // Prefer the dot index if present + if (i >= 0 && context.text.charAt(i) == '.') { + return i; + } + + // Fallback: use the provided prefixStart (caret context) + return Math.max(0, Math.min(context.prefixStart, context.text.length())); + } + + /** + * Add members from a script-defined type. + */ + protected void addScriptTypeMembers(ScriptTypeInfo scriptType, List items, boolean isStaticContext) { + addScriptTypeMembers(scriptType, items, isStaticContext, false); + } + + /** + * Add members from a script-defined type. + * @param scriptType The script type to get members from + * @param items The list to add items to + * @param isStaticContext Whether we're in a static context + * @param forMethodReference If true, only add methods with no parentheses in insert text + */ + protected void addScriptTypeMembers(ScriptTypeInfo scriptType, List items, boolean isStaticContext, boolean forMethodReference) { + // Add methods (getMethods returns Map>) + for (List overloads : scriptType.getMethods().values()) { + for (MethodInfo method : overloads) { + // Filter by static context + if (isStaticContext && !method.isStatic()) { + continue; + } + items.add(AutocompleteItem.fromMethod(method, forMethodReference)); + } + } + + // Add fields (skip if methodsOnly/forMethodReference is true) + if (!forMethodReference) { + // Add fields (getFields returns Map) + for (FieldInfo field : scriptType.getFields().values()) { + // Filter by static context + if (isStaticContext && !field.isStatic()) { + continue; + } + items.add(AutocompleteItem.fromField(field)); + } + + // Add enum constants (getEnumConstants returns Map) + for (EnumConstantInfo enumConstant : scriptType.getEnumConstants().values()) { + items.add(AutocompleteItem.fromField(enumConstant.getFieldInfo())); + } + + // Add nested types (inner classes/interfaces) in static context + if (isStaticContext) { + for (ScriptTypeInfo inner : scriptType.getInnerClasses()) { + items.add(AutocompleteItem.fromType(inner)); + } + } + } + + // Add parent class members + if (scriptType.hasSuperClass()) { + TypeInfo superType = scriptType.getSuperClass(); + if (superType != null && superType.getJavaClass() != null) { + Class superClazz = superType.getJavaClass(); + Set addedMethods = new HashSet<>(); + for (Method method : superClazz.getMethods()) { + if (Modifier.isPublic(method.getModifiers())) { + String sig = method.getName() + "(" + method.getParameterCount() + ")"; + if (!addedMethods.contains(sig)) { + addedMethods.add(sig); + MethodInfo methodInfo = MethodInfo.fromReflection(method, superType); + items.add(AutocompleteItem.fromMethod(methodInfo, forMethodReference)); + } + } + } + } + } + } + + /** + * Add suggestions based on current scope (not after a dot). + */ + protected void addScopeSuggestions(Context context, List items) { + int pos = context.cursorPosition; + + // Find containing method + MethodInfo containingMethod = document.findContainingMethod(pos); + + // Add local variables + if (containingMethod != null) { + List available = document.getAvailableVariablesAt(pos); + Set seenNames = new HashSet<>(); + for (FieldInfo field : available) { + if (!(field.isLocal() || field.isParameter())) { + continue; + } + if (seenNames.add(field.getName())) { + items.add(AutocompleteItem.fromField(field)); + } + } + } + + // Add global fields + for (FieldInfo globalField : document.getGlobalFields().values()) { + if (globalField.isVisibleAt(pos)) { + items.add(AutocompleteItem.fromField(globalField)); + } + } + + // Add enclosing type fields (find via script types map) + ScriptTypeInfo enclosingType = findEnclosingType(pos); + if (enclosingType != null) { + for (FieldInfo field : enclosingType.getFields().values()) { + if (field.isVisibleAt(pos)) { + items.add(AutocompleteItem.fromField(field)); + } + } + + // Add methods from enclosing type + for (List overloads : enclosingType.getMethods().values()) { + for (MethodInfo method : overloads) { + items.add(AutocompleteItem.fromMethod(method, context.methodsOnly)); + } + } + + // Add inner classes of the enclosing type as type suggestions + for (ScriptTypeInfo inner : enclosingType.getInnerClasses()) { + items.add(AutocompleteItem.fromType(inner)); + } + + // Walk up the outerClass chain to include outer class members and sibling types. + // Inside a nested class, users can access outer class fields/methods/sibling types. + ScriptTypeInfo outer = enclosingType.getOuterClass(); + while (outer != null) { + for (ScriptTypeInfo sibling : outer.getInnerClasses()) { + if (sibling != enclosingType) { + items.add(AutocompleteItem.fromType(sibling)); + } + } + for (FieldInfo field : outer.getFields().values()) { + items.add(AutocompleteItem.fromField(field)); + } + for (List overloads : outer.getMethods().values()) { + for (MethodInfo method : overloads) { + items.add(AutocompleteItem.fromMethod(method, context.methodsOnly)); + } + } + outer = outer.getOuterClass(); + } + } + + // Add script-defined methods + for (MethodInfo method : document.getAllMethods()) { + items.add(AutocompleteItem.fromMethod(method, context.methodsOnly)); + } + + addLanguageUniqueSuggestions(context, items); + + // Add keywords + addKeywords(items); + } + + protected void addLanguageUniqueSuggestions(Context context, List items) { + // Add imported types + for (TypeInfo type : document.getImportedTypes()) { + items.add(AutocompleteItem.fromType(type)); + } + + // Add script-defined types + for (ScriptTypeInfo scriptType : document.getScriptTypesMap().values()) { + items.add(AutocompleteItem.fromType(scriptType)); + } + + // Add unimported classes that match the prefix (for auto-import) + if (context.prefix != null && context.prefix.length() >= 2 && Character.isUpperCase(context.prefix.charAt(0))) { + addUnimportedClassSuggestions(context.prefix, items); + } + } + + + /** + * Add suggestions for unimported classes that match the prefix. + * These will trigger auto-import when selected. + */ + protected void addUnimportedClassSuggestions(String prefix, List items) { + // Get the type resolver + TypeResolver resolver = TypeResolver.getInstance(); + // Find classes matching this prefix (not just exact matches) + List matchingClasses = resolver.findClassesByPrefix(prefix, -1); + + // Track what's already imported to avoid duplicates + Set importedFullNames = new HashSet<>(); + for (TypeInfo imported : document.getImportedTypes()) { + importedFullNames.add(imported.getFullName()); + } + + // Also track simple names already in the list to avoid showing both + // imported and unimported versions of the same class + Set existingSimpleNames = new HashSet<>(); + for (AutocompleteItem item : items) { + if (item.getKind() == AutocompleteItem.Kind.CLASS || + item.getKind() == AutocompleteItem.Kind.ENUM) { + existingSimpleNames.add(item.getName()); + } + } + + for (String fullName : matchingClasses) { + // Skip if already imported + if (importedFullNames.contains(fullName)) { + continue; + } + + TypeInfo type = resolver.resolveFullName(fullName); + if (type != null && type.isResolved()) { + // Skip if a class with this simple name is already in the list + if (existingSimpleNames.contains(type.getSimpleName())) { + continue; + } + + // Create an item that requires import + AutocompleteItem item = new AutocompleteItem.Builder() + .name(type.getSimpleName()) + .insertText(type.getSimpleName()) + .kind(type.getKind() == TypeInfo.Kind.ENUM ? + AutocompleteItem.Kind.ENUM : AutocompleteItem.Kind.CLASS) + .typeLabel(type.getPackageName()) + .signature(type.getFullName()) + .sourceData(type) + .requiresImport(true) + .importPath(fullName) + .build(); + items.add(item); + existingSimpleNames.add(type.getSimpleName()); + } + } + } + + /** + * Add Java keywords. + */ + protected void addKeywords(List items) { + for (String keyword : getKeywords()) { + items.add(AutocompleteItem.keyword(keyword)); + } + } + + public String[] getKeywords() { + return TypeChecker.getJavaKeywords(); + } + + /** + * Find the enclosing script type at a position. + * Delegates to ScriptDocument's recursive descent implementation + * which correctly returns the innermost enclosing type for nested classes. + */ + protected ScriptTypeInfo findEnclosingType(int position) { + return document.findEnclosingScriptType(position); + } + + /** + * Check if the receiver expression represents static access (class type). + * Returns true if the expression is a TYPE NAME (not a variable). + */ + protected boolean isStaticAccess(String receiverExpr, int position) { + // Use unified static access checker + return TypeResolver.isStaticAccessExpression(receiverExpr, position, document); + } + + protected UsageTracker getUsageTracker() { + return UsageTracker.getJavaInstance(); + } + + /** + * Filter items by prefix, calculate match scores, apply usage boosts, and penalize static members in instance contexts. + */ + protected void filterAndScore(List items, String prefix, + boolean isMemberAccess, boolean isStaticContext, String ownerFullName) { + UsageTracker tracker = getUsageTracker(); + + if (prefix == null || prefix.isEmpty()) { + // No filtering needed, all items get a base score + usage boost + for (AutocompleteItem item : items) { + item.calculateMatchScore("", false); + applyUsageBoost(item, tracker, ownerFullName); + applyStaticPenalty(item, isMemberAccess, isStaticContext); + applyObjectMethodPenalty(item); + applyKeywordPenalty(item, prefix); + } + return; + } + + // For non-member access (first word), require strict prefix matching + // For member access (after dot), allow fuzzy/contains matching + boolean requirePrefix = !isMemberAccess; + + // Filter, score, apply usage boosts, and apply penalties + Iterator iter = items.iterator(); + while (iter.hasNext()) { + AutocompleteItem item = iter.next(); + int score = item.calculateMatchScore(prefix, requirePrefix); + if (score < 0) { + iter.remove(); + } else { + applyUsageBoost(item, tracker, ownerFullName); + applyStaticPenalty(item, isMemberAccess, isStaticContext); + applyObjectMethodPenalty(item); + applyKeywordPenalty(item, prefix); + } + } + } + + /** + * Apply usage-based score boost to an item. + */ + protected void applyUsageBoost(AutocompleteItem item, UsageTracker tracker, String ownerFullName) { + int usageCount = tracker.getUsageCount(item, ownerFullName); + int boost = UsageTracker.calculateUsageBoost(usageCount); + item.addScoreBoost(boost); + } + + /** + * Apply penalty to static members when accessed in a non-static (instance) context. + * This matches IntelliJ's behavior where static members are deprioritized when + * accessing through an instance (e.g., Minecraft.getMinecraft().getMinecraft()). + * However, if the item is a very strong match (exact prefix), don't penalize as much. + */ + protected void applyStaticPenalty(AutocompleteItem item, boolean isMemberAccess, boolean isStaticContext) { + // Only apply penalty in member access contexts (after dot) + if (!isMemberAccess) { + return; + } + + // Only penalize when we're in an instance context (not static) + if (isStaticContext) { + return; + } + + boolean isStatic = item.isStatic(); + + // Apply penalty to static members in instance context + if (isStatic) { + int matchScore = item.getMatchScore(); + // Strong prefix matches (score >= 800) get a lighter penalty + // Weaker matches get pushed down more aggressively + if (matchScore >= 800) { + // Light penalty for exact prefix matches - just deprioritize slightly + item.addScoreBoost(-200); + } else { + // Heavy penalty for fuzzy/substring matches - push to bottom + item.addScoreBoost(-matchScore); + } + } + } + + /** + * Apply penalty to inherited Object methods to push them to bottom. + * Strong matches get lighter penalty, weak matches get pushed all the way down. + */ + protected void applyObjectMethodPenalty(AutocompleteItem item) { + if (!item.isInheritedObjectMethod()) { + return; + } + + int matchScore = item.getMatchScore(); + // Strong prefix matches (score >= 900) get a moderate penalty + // Everything else gets pushed to the very bottom + if (matchScore >= 900) { + // Strong match - moderate penalty to keep it visible but below normal methods + item.addScoreBoost(-500); + } else { + // Weak match - heavy penalty to push to bottom + item.addScoreBoost(-10000); + } + } + + /** + * Push keywords below non-keywords unless user typed a longer prefix. + */ + protected void applyKeywordPenalty(AutocompleteItem item, String prefix) { + if (item.getKind() != AutocompleteItem.Kind.KEYWORD) { + return; + } + + if (prefix == null || prefix.length() < 2) { + item.addScoreBoost(-10000); + } + } + + /** + * Builder class for AutocompleteItem to handle cases without source data. + */ + private static class AutocompleteItemBuilder { + // This would be needed if AutocompleteItem had a builder pattern + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/UsageTracker.java b/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/UsageTracker.java new file mode 100644 index 000000000..6d23e0c2f --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/autocomplete/UsageTracker.java @@ -0,0 +1,284 @@ +package noppes.npcs.client.gui.util.script.autocomplete; + +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.google.gson.reflect.TypeToken; +import noppes.npcs.CustomNpcs; + +import java.io.*; +import java.lang.reflect.Type; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicBoolean; + +/** + * Tracks user autocomplete selections to improve suggestion ranking. + * Usage counts are persisted to JSON and used to boost frequently selected items. + * + * Key format: "ownerFullName|memberName|KIND" + * - ownerFullName: Full class name for members, empty for standalone items + * - memberName: The item name (method, field, type, etc.) + * - KIND: The item kind (METHOD, FIELD, CLASS, ENUM, etc.) + * + * Examples: + * - "net.minecraft.client.Minecraft|getMinecraft|METHOD" + * - "net.minecraft.entity.player.EntityPlayer|inventory|FIELD" + * - "|EntityPlayer|CLASS" (standalone type suggestion) + * - "|if|KEYWORD" + */ +public class UsageTracker { + + private static final String JAVA_FILE = "java_usages.json"; + private static final String JS_FILE = "js_usages.json"; + private static final long SAVE_INTERVAL_MS = 60_000; // Auto-save every 60 seconds + private static final int USAGE_SCORE_MULTIPLIER = 50; // Score boost per usage + private static final int MAX_USAGE_BOOST = 5000; // Cap the boost to prevent runaway scores + + private static UsageTracker javaInstance; + private static UsageTracker jsInstance; + private static boolean initialized = false; + + private final Map usageCounts = new ConcurrentHashMap<>(); + private final File file; + private final AtomicBoolean dirty = new AtomicBoolean(false); + private final AtomicBoolean loaded = new AtomicBoolean(false); + + private static ScheduledExecutorService scheduler; + private static final Gson GSON = new GsonBuilder().setPrettyPrinting().create(); + + // ==================== SINGLETON ACCESS ==================== + + public static synchronized UsageTracker getJavaInstance() { + ensureInitialized(); + if (javaInstance == null) { + javaInstance = new UsageTracker(JAVA_FILE); + javaInstance.load(); + } + return javaInstance; + } + + public static synchronized UsageTracker getJSInstance() { + ensureInitialized(); + if (jsInstance == null) { + jsInstance = new UsageTracker(JS_FILE); + jsInstance.load(); + } + return jsInstance; + } + + /** + * Ensure the tracker system is initialized with auto-save and shutdown hook. + */ + private static void ensureInitialized() { + if (!initialized) { + initialized = true; + initialize(); + + // Add shutdown hook to save on JVM exit + Runtime.getRuntime().addShutdownHook(new Thread(() -> { + shutdown(); + }, "UsageTracker-Shutdown")); + } + } + + /** + * Initialize the auto-save scheduler. Call once on client startup. + */ + public static void initialize() { + if (scheduler == null || scheduler.isShutdown()) { + scheduler = Executors.newSingleThreadScheduledExecutor(r -> { + Thread t = new Thread(r, "UsageTracker-AutoSave"); + t.setDaemon(true); + return t; + }); + + scheduler.scheduleAtFixedRate(() -> { + saveAllIfDirty(); + }, SAVE_INTERVAL_MS, SAVE_INTERVAL_MS, TimeUnit.MILLISECONDS); + } + } + + /** + * Shutdown and save all data. Call on client shutdown. + */ + public static void shutdown() { + saveAllIfDirty(); + if (scheduler != null && !scheduler.isShutdown()) { + scheduler.shutdown(); + } + } + + private static void saveAllIfDirty() { + if (javaInstance != null) { + javaInstance.saveIfDirty(); + } + if (jsInstance != null) { + jsInstance.saveIfDirty(); + } + } + + // ==================== INSTANCE METHODS ==================== + + private UsageTracker(String filename) { + File dir = getDir(); + this.file = new File(dir, filename); + } + + private File getDir() { + File dir = new File(CustomNpcs.Dir, "tracked_usages"); + if (!dir.exists()) { + dir.mkdir(); + } + return dir; + } + + /** + * Record that the user selected an autocomplete item. + * + * @param owner The owner context (full class name for members, null/empty for standalone) + * @param name The item name + * @param kind The item kind + */ + public void recordUsage(String owner, String name, AutocompleteItem.Kind kind) { + String key = buildKey(owner, name, kind); + usageCounts.merge(key, 1, Integer::sum); + dirty.set(true); + } + + /** + * Record usage directly from an AutocompleteItem. + * + * @param item The selected autocomplete item + * @param ownerFullName The full class name of the owner (for member access), or null + */ + public void recordUsage(AutocompleteItem item, String ownerFullName) { + String name = item.getSearchName() != null ? item.getSearchName() : item.getName(); + + // For methods, include parameter count to distinguish overloads + if (item.getKind() == AutocompleteItem.Kind.METHOD) { + int paramCount = item.getParameterCount(); + name = name + "(" + paramCount + ")"; + } + + recordUsage(ownerFullName, name, item.getKind()); + } + + /** + * Get the usage count for an item. + * + * @param owner The owner context + * @param name The item name + * @param kind The item kind + * @return The number of times this item was selected + */ + public int getUsageCount(String owner, String name, AutocompleteItem.Kind kind) { + String key = buildKey(owner, name, kind); + return usageCounts.getOrDefault(key, 0); + } + + /** + * Get usage count directly from an AutocompleteItem. + */ + public int getUsageCount(AutocompleteItem item, String ownerFullName) { + String name = item.getSearchName() != null ? item.getSearchName() : item.getName(); + + // For methods, include parameter count to distinguish overloads + if (item.getKind() == AutocompleteItem.Kind.METHOD) { + int paramCount = item.getParameterCount(); + name = name + "(" + paramCount + ")"; + } + + return getUsageCount(ownerFullName, name, item.getKind()); + } + + /** + * Calculate the score boost based on usage count. + * Uses a logarithmic scale to prevent very frequent items from dominating completely. + * + * @param usageCount The number of times the item was selected + * @return The score boost to add + */ + public static int calculateUsageBoost(int usageCount) { + if (usageCount <= 0) return 0; + + // Logarithmic scaling: log2(count + 1) * multiplier + // This gives diminishing returns for very high counts + int boost = (int) (Math.log(usageCount + 1) / Math.log(2) * USAGE_SCORE_MULTIPLIER); + return Math.min(boost, MAX_USAGE_BOOST); + } + + /** + * Build a unique key for an item. + */ + public static String buildKey(String owner, String name, AutocompleteItem.Kind kind) { + String ownerPart = owner != null ? owner : ""; + String kindPart = kind != null ? kind.name() : "UNKNOWN"; + return ownerPart + "|" + name + "|" + kindPart; + } + + // ==================== PERSISTENCE ==================== + + /** + * Load usage data from file. + */ + public void load() { + if (loaded.get()) return; + + if (!file.exists()) { + loaded.set(true); + return; + } + + try (BufferedReader reader = new BufferedReader(new FileReader(file))) { + Type type = new TypeToken>(){}.getType(); + Map data = GSON.fromJson(reader, type); + if (data != null) { + usageCounts.putAll(data); + } + loaded.set(true); + } catch (Exception e) { + System.err.println("[UsageTracker] Failed to load " + file.getName() + ": " + e.getMessage()); + loaded.set(true); // Mark as loaded even on failure to prevent retry loops + } + } + + /** + * Save usage data to file if there are pending changes. + */ + public void saveIfDirty() { + if (!dirty.compareAndSet(true, false)) { + return; // Not dirty, nothing to save + } + save(); + } + + /** + * Force save usage data to file. + */ + public void save() { + try (BufferedWriter writer = new BufferedWriter(new FileWriter(file))) { + GSON.toJson(usageCounts, writer); + } catch (Exception e) { + System.err.println("[UsageTracker] Failed to save " + file.getName() + ": " + e.getMessage()); + dirty.set(true); // Mark dirty again so we retry later + } + } + + /** + * Clear all usage data (for testing/reset purposes). + */ + public void clear() { + usageCounts.clear(); + dirty.set(true); + } + + /** + * Get the number of tracked items. + */ + public int size() { + return usageCounts.size(); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/CodeParser.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/CodeParser.java new file mode 100644 index 000000000..435c8f42e --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/CodeParser.java @@ -0,0 +1,323 @@ +package noppes.npcs.client.gui.util.script.interpreter; + +/** + * Utility class for parsing and analyzing code text. + * Provides methods for finding matching braces/parentheses, removing comments/strings, + * and locating keywords in code. + */ +public final class CodeParser { + + private CodeParser() {} // Utility class + + // ==================== Matching Delimiters ==================== + + /** + * Find the closing brace that matches the opening brace at the given position. + * @param text The text to search + * @param openBrace Position of the opening '{' + * @return Position of matching '}' or -1 if not found + */ + public static int findMatchingBrace(String text, int openBrace) { + if (openBrace < 0 || openBrace >= text.length() || text.charAt(openBrace) != '{') { + return -1; + } + int depth = 1; + for (int i = openBrace + 1; i < text.length(); i++) { + char c = text.charAt(i); + if (c == '{') depth++; + else if (c == '}') { + depth--; + if (depth == 0) return i; + } + } + return -1; + } + + /** + * Find the closing parenthesis that matches the opening parenthesis at the given position. + * @param text The text to search + * @param openParen Position of the opening '(' + * @return Position of matching ')' or -1 if not found + */ + public static int findMatchingParen(String text, int openParen) { + if (openParen < 0 || openParen >= text.length() || text.charAt(openParen) != '(') { + return -1; + } + int depth = 1; + for (int i = openParen + 1; i < text.length(); i++) { + char c = text.charAt(i); + if (c == '(') depth++; + else if (c == ')') { + depth--; + if (depth == 0) return i; + } + } + return -1; + } + + // ==================== Comment/String Removal ==================== + + /** + * Remove string literals and comments from code for structural analysis. + * This is used when analyzing control flow to avoid false positives from + * keywords inside strings or comments. + * @param code The source code + * @return Code with strings and comments removed + */ + public static String removeStringsAndComments(String code) { + StringBuilder result = new StringBuilder(); + boolean inString = false; + boolean inChar = false; + boolean inLineComment = false; + boolean inBlockComment = false; + + for (int i = 0; i < code.length(); i++) { + char c = code.charAt(i); + char next = (i + 1 < code.length()) ? code.charAt(i + 1) : 0; + + if (inLineComment) { + if (c == '\n') { + inLineComment = false; + result.append(c); + } + continue; + } + + if (inBlockComment) { + if (c == '*' && next == '/') { + inBlockComment = false; + i++; // skip '/' + } + continue; + } + + if (inString || inChar) { + if (c == '\\' && i + 1 < code.length()) { + i++; // skip escaped character + continue; + } + if ((inString && c == '"') || (inChar && c == '\'')) { + inString = false; + inChar = false; + } + continue; + } + + // Check for start of comments or strings + if (c == '/' && next == '/') { + inLineComment = true; + i++; + continue; + } + if (c == '/' && next == '*') { + inBlockComment = true; + i++; + continue; + } + if (c == '"') { + inString = true; + continue; + } + if (c == '\'') { + inChar = true; + continue; + } + + result.append(c); + } + + return result.toString(); + } + + /** + * Remove only comments from code, keeping strings intact and preserving positions. + * Comments are replaced with spaces to maintain character positions. + * @param code The source code + * @return Code with comments replaced by spaces + */ + public static String removeComments(String code) { + StringBuilder result = new StringBuilder(); + boolean inString = false; + boolean inChar = false; + boolean inLineComment = false; + boolean inBlockComment = false; + + for (int i = 0; i < code.length(); i++) { + char c = code.charAt(i); + char next = (i + 1 < code.length()) ? code.charAt(i + 1) : 0; + + if (inLineComment) { + if (c == '\n') { + inLineComment = false; + result.append(c); + } else { + result.append(' '); // Preserve position with spaces + } + continue; + } + + if (inBlockComment) { + if (c == '*' && next == '/') { + inBlockComment = false; + result.append(" "); // Preserve position + i++; + } else { + result.append(c == '\n' ? '\n' : ' '); // Preserve newlines + } + continue; + } + + if (inString) { + result.append(c); + if (c == '\\' && i + 1 < code.length()) { + result.append(code.charAt(++i)); + continue; + } + if (c == '"') inString = false; + continue; + } + + if (inChar) { + result.append(c); + if (c == '\\' && i + 1 < code.length()) { + result.append(code.charAt(++i)); + continue; + } + if (c == '\'') inChar = false; + continue; + } + + // Check for start of comments + if (c == '/' && next == '/') { + inLineComment = true; + result.append(" "); // Preserve position + i++; + continue; + } + if (c == '/' && next == '*') { + inBlockComment = true; + result.append(" "); // Preserve position + i++; + continue; + } + if (c == '"') { inString = true; } + if (c == '\'') { inChar = true; } + + result.append(c); + } + + return result.toString(); + } + + // ==================== Keyword Detection ==================== + + /** + * Check if a keyword exists at the given position in text. + * Verifies the keyword is not part of a larger identifier. + * @param text The text to check + * @param pos Position to check + * @param keyword The keyword to look for + * @return true if the keyword is at this position as a standalone word + */ + public static boolean isKeywordAt(String text, int pos, String keyword) { + if (pos + keyword.length() > text.length()) return false; + if (!text.substring(pos).startsWith(keyword)) return false; + + boolean validBefore = pos == 0 || !Character.isLetterOrDigit(text.charAt(pos - 1)); + boolean validAfter = pos + keyword.length() >= text.length() + || !Character.isLetterOrDigit(text.charAt(pos + keyword.length())); + + return validBefore && validAfter; + } + + /** + * Find the next "return" keyword that is not inside a string literal. + * @param text The text to search + * @param start Position to start searching from + * @return Position of "return" or -1 if not found + */ + public static int findReturnKeyword(String text, int start) { + boolean inString = false; + boolean inChar = false; + + for (int i = start; i < text.length() - 5; i++) { + char c = text.charAt(i); + + if (inString) { + if (c == '\\' && i + 1 < text.length()) { i++; continue; } + if (c == '"') inString = false; + continue; + } + if (inChar) { + if (c == '\\' && i + 1 < text.length()) { i++; continue; } + if (c == '\'') inChar = false; + continue; + } + + if (c == '"') { inString = true; continue; } + if (c == '\'') { inChar = true; continue; } + + // Check for "return" keyword + if (isKeywordAt(text, i, "return")) { + return i; + } + } + return -1; + } + + /** + * Find the semicolon that ends a return statement, handling nested structures. + * @param text The text to search + * @param start Position to start searching (after "return" keyword) + * @return Position of ';' or -1 if not found + */ + public static int findReturnSemicolon(String text, int start) { + int parenDepth = 0; + int braceDepth = 0; + boolean inString = false; + boolean inChar = false; + + for (int i = start; i < text.length(); i++) { + char c = text.charAt(i); + + if (inString) { + if (c == '\\' && i + 1 < text.length()) { i++; continue; } + if (c == '"') inString = false; + continue; + } + if (inChar) { + if (c == '\\' && i + 1 < text.length()) { i++; continue; } + if (c == '\'') inChar = false; + continue; + } + + if (c == '"') { inString = true; continue; } + if (c == '\'') { inChar = true; continue; } + if (c == '(') { parenDepth++; continue; } + if (c == ')') { parenDepth--; continue; } + if (c == '{') { braceDepth++; continue; } + if (c == '}') { braceDepth--; continue; } + + if (c == ';' && parenDepth == 0 && braceDepth == 0) { + return i; + } + } + return -1; + } + + // ==================== Whitespace Utilities ==================== + + /** + * Skip whitespace characters starting from the given position. + * @param text The text + * @param pos Starting position + * @return Position of first non-whitespace character + */ + public static int skipWhitespace(String text, int pos) { + while (pos < text.length() && Character.isWhitespace(text.charAt(pos))) { + pos++; + } + return pos; + } +} + diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ControlFlowAnalyzer.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ControlFlowAnalyzer.java new file mode 100644 index 000000000..6416805ba --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ControlFlowAnalyzer.java @@ -0,0 +1,215 @@ +package noppes.npcs.client.gui.util.script.interpreter; + +/** + * Analyzes control flow in method bodies to determine if all paths return a value. + * Used for detecting "missing return statement" errors. + */ +public final class ControlFlowAnalyzer { + + private ControlFlowAnalyzer() {} // Utility class + + /** + * Check if the method body has a guaranteed return on all code paths. + */ + public static boolean hasGuaranteedReturn(String body) { + String cleanBody = CodeParser.removeStringsAndComments(body); + + return hasTopLevelReturn(cleanBody) + || hasCompleteIfElseReturn(cleanBody) + || hasTryFinallyReturn(cleanBody) + || hasCompleteSwitchReturn(cleanBody); + } + + /** + * Check for a bare return statement at the method's top level (brace depth 0). + */ + private static boolean hasTopLevelReturn(String body) { + int braceDepth = 0; + int parenDepth = 0; + + for (int i = 0; i < body.length(); i++) { + char c = body.charAt(i); + + if (c == '{') braceDepth++; + else if (c == '}') braceDepth--; + else if (c == '(') parenDepth++; + else if (c == ')') parenDepth--; + + if (braceDepth == 0 && parenDepth == 0 && isKeywordAt(body, i, "return")) { + return true; + } + } + return false; + } + + /** + * Check for complete if-else chains where all branches return. + */ + private static boolean hasCompleteIfElseReturn(String body) { + int braceDepth = 0; + + for (int i = 0; i < body.length(); i++) { + char c = body.charAt(i); + if (c == '{') { braceDepth++; continue; } + if (c == '}') { braceDepth--; continue; } + + if (braceDepth == 0 && isKeywordAt(body, i, "if")) { + if (checkIfElseChainReturns(body, i)) { + return true; + } + } + } + return false; + } + + /** + * Check if an if-else chain starting at the given position guarantees a return. + * Handles: if(true) { return; } - always returns (else unreachable) + * if(false) { } else { return; } - else always executes + */ + private static boolean checkIfElseChainReturns(String body, int ifStart) { + int pos = ifStart; + + while (pos < body.length()) { + if (!body.substring(pos).startsWith("if")) return false; + pos += 2; + + pos = skipWhitespace(body, pos); + if (pos >= body.length() || body.charAt(pos) != '(') return false; + + int condStart = pos; + int condEnd = CodeParser.findMatchingParen(body, pos); + if (condEnd < 0) return false; + + // Check for literal true/false conditions + String condition = body.substring(condStart + 1, condEnd).trim(); + boolean isAlwaysTrue = condition.equals("true"); + boolean isAlwaysFalse = condition.equals("false"); + + pos = skipWhitespace(body, condEnd + 1); + if (pos >= body.length() || body.charAt(pos) != '{') return false; + + int blockEnd = CodeParser.findMatchingBrace(body, pos); + if (blockEnd < 0) return false; + + String ifBlock = body.substring(pos + 1, blockEnd); + boolean ifBlockReturns = hasGuaranteedReturn(ifBlock); + + // if(true) with return means we always return (else is unreachable) + if (isAlwaysTrue && ifBlockReturns) { + return true; + } + + pos = skipWhitespace(body, blockEnd + 1); + + // Must have else clause for guaranteed return + if (!body.substring(pos).startsWith("else")) { + return false; + } + pos += 4; + pos = skipWhitespace(body, pos); + + // else if - continue the chain + if (isKeywordAt(body, pos, "if")) { + continue; + } + + // Plain else block - final branch + if (pos >= body.length() || body.charAt(pos) != '{') return false; + int elseBlockEnd = CodeParser.findMatchingBrace(body, pos); + if (elseBlockEnd < 0) return false; + + String elseBlock = body.substring(pos + 1, elseBlockEnd); + boolean elseBlockReturns = hasGuaranteedReturn(elseBlock); + + // For if-else to guarantee return: both branches must return + // Special case: if(false) means if-block never executes, so only else matters + if (isAlwaysFalse) { + return elseBlockReturns; + } + + // Normal case: both if and else must return + return ifBlockReturns && elseBlockReturns; + } + return false; + } + + /** + * Check for try-finally where finally block returns. + */ + private static boolean hasTryFinallyReturn(String body) { + for (int i = 0; i < body.length(); i++) { + if (!isKeywordAt(body, i, "try")) continue; + + int tryBlockStart = body.indexOf('{', i); + if (tryBlockStart < 0) continue; + + int tryBlockEnd = CodeParser.findMatchingBrace(body, tryBlockStart); + if (tryBlockEnd < 0) continue; + + // Skip catch blocks + int searchPos = skipCatchBlocks(body, tryBlockEnd + 1); + searchPos = skipWhitespace(body, searchPos); + + // Check for finally + if (body.substring(searchPos).startsWith("finally")) { + int finallyBlockStart = body.indexOf('{', searchPos); + if (finallyBlockStart >= 0) { + int finallyBlockEnd = CodeParser.findMatchingBrace(body, finallyBlockStart); + if (finallyBlockEnd >= 0) { + String finallyBlock = body.substring(finallyBlockStart + 1, finallyBlockEnd); + if (hasGuaranteedReturn(finallyBlock)) { + return true; + } + } + } + } + } + return false; + } + + private static int skipCatchBlocks(String body, int start) { + int pos = start; + while (true) { + pos = skipWhitespace(body, pos); + if (pos >= body.length() || !body.substring(pos).startsWith("catch")) break; + + int catchBlockStart = body.indexOf('{', pos); + if (catchBlockStart < 0) break; + + int catchBlockEnd = CodeParser.findMatchingBrace(body, catchBlockStart); + if (catchBlockEnd < 0) break; + + pos = catchBlockEnd + 1; + } + return pos; + } + + /** + * Check for switch with default where all cases return. + * Returns false for now - full implementation is complex. + */ + private static boolean hasCompleteSwitchReturn(String body) { + return false; + } + + // ==================== Utility Methods ==================== + + private static boolean isKeywordAt(String text, int pos, String keyword) { + if (pos + keyword.length() > text.length()) return false; + if (!text.substring(pos).startsWith(keyword)) return false; + + boolean validBefore = pos == 0 || !Character.isLetterOrDigit(text.charAt(pos - 1)); + boolean validAfter = pos + keyword.length() >= text.length() + || !Character.isLetterOrDigit(text.charAt(pos + keyword.length())); + + return validBefore && validAfter; + } + + private static int skipWhitespace(String text, int pos) { + while (pos < text.length() && Character.isWhitespace(text.charAt(pos))) { + pos++; + } + return pos; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ErrorUnderlineRenderer.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ErrorUnderlineRenderer.java new file mode 100644 index 000000000..1e3bae054 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ErrorUnderlineRenderer.java @@ -0,0 +1,292 @@ +package noppes.npcs.client.gui.util.script.interpreter; + +import noppes.npcs.client.ClientProxy; +import noppes.npcs.client.gui.util.script.interpreter.field.AssignmentInfo; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodCallInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.ScriptTypeInfo; +import org.lwjgl.opengl.GL11; + +/** + * Helper class for rendering error underlines in script editor lines. + * Handles the repetitive calculation of underline positions and drawing of curly underlines. + */ +public class ErrorUnderlineRenderer { + private static final int ERROR_COLOR = 0xFF5555; + + // Holds the calculation result for an underline + private static class UnderlinePosition { + final int x; + final int width; + + UnderlinePosition(int x, int width) { + this.x = x; + this.width = width; + } + + boolean isValid() { + return width > 0; + } + } + + /** + * Draw error underlines for all validation errors in the document that intersect the given line. + * + * @param doc The script document containing all errors + * @param lineStartX X coordinate where the line starts rendering + * @param baselineY Y coordinate for the underline baseline + * @param lineText The text content of the line + * @param lineStart Global offset where this line starts + * @param lineEnd Global offset where this line ends + */ + public static void drawErrorUnderlines( + ScriptDocument doc, + int lineStartX, int baselineY, + String lineText, int lineStart, int lineEnd) { + + if (doc == null) + return; + + + // Check all method calls in the document + for (MethodCallInfo call : doc.getMethodCalls()) { + // Skip method declarations that were erroneously recorded as calls + boolean isDeclaration = false; + int methodStart = call.getMethodNameStart(); + for (MethodInfo mi : doc.getAllMethods()) { + //!call.isConstructor for enum declarations + if (!call.isConstructor() && mi.getDeclarationOffset() <= methodStart && mi.getBodyStart() >= methodStart) { + isDeclaration = true; + break; + } + } + if (isDeclaration) + continue; + + // Skip if this call doesn't intersect this line + if (call.getCloseParenOffset() < lineStart || call.getOpenParenOffset() > lineEnd) + continue; + + // Handle arg count errors (underline the method name) + if (call.hasArgCountError()) { + int methodEnd = methodStart + call.getMethodName().length(); + drawUnderlineForSpan(methodStart, methodEnd, lineStartX, baselineY, + lineText, lineStart, lineEnd, ERROR_COLOR); + } else if (call.hasArgTypeError()) { + // Handle return type mismatch (underline the method name) - currently commented out + // if (call.hasReturnTypeMismatch()) { ... } + + // Handle arg type errors (underline specific arguments) + + for (MethodCallInfo.ArgumentTypeError error : call.getArgumentTypeErrors()) { + MethodCallInfo.Argument arg = error.getArg(); + drawUnderlineForSpan(arg.getStartOffset(), arg.getEndOffset(), + lineStartX, baselineY, lineText, lineStart, lineEnd, ERROR_COLOR); + } + } else if(call.hasError()){ + // Handle other call errors (underline the whole call) + drawUnderlineForSpan(call.getMethodNameStart(), call.getCloseParenOffset() + 1, + lineStartX, baselineY, lineText, lineStart, lineEnd, ERROR_COLOR); + } + } + + // Check all field accesses in the document (currently commented out) + // for (FieldAccessInfo access : doc.getFieldAccesses()) { ... } + + // Check all errored assignments in the document + for (AssignmentInfo assign : doc.getAllErroredAssignments()) { + int underlineStart, underlineEnd; + + if (assign.isLhsError()) { + underlineStart = assign.getLhsStart(); + underlineEnd = assign.getLhsEnd(); + } else if (assign.isRhsError()) { + underlineStart = assign.getRhsStart(); + underlineEnd = assign.getRhsEnd(); + } else if (assign.isFullLineError()) { + underlineStart = assign.getStatementStart(); + underlineEnd = assign.getRhsEnd(); + } else { + continue; + } + + drawUnderlineForSpan(underlineStart, underlineEnd, lineStartX, baselineY, + lineText, lineStart, lineEnd, ERROR_COLOR); + } + + // Check all method declarations for errors + for (MethodInfo method : doc.getAllMethods()) { + if (!method.isDeclaration() || !method.hasError()) + continue; + + // Handle return statement type errors + if (method.hasReturnStatementErrors()) { + for (MethodInfo.ReturnStatementError returnError : method.getReturnStatementErrors()) { + drawUnderlineForSpan(returnError.getStartOffset(), returnError.getEndOffset(), + lineStartX, baselineY, lineText, lineStart, lineEnd, ERROR_COLOR); + } + } + + // Handle missing return error (underline the method name) + else if (method.hasMissingReturnError()) { + int methodNameStart = method.getNameOffset(); + int methodNameEnd = methodNameStart + method.getName().length(); + drawUnderlineForSpan(methodNameStart, methodNameEnd, lineStartX, baselineY, + lineText, lineStart, lineEnd, ERROR_COLOR); + } + // Handle parameter errors + else if (method.hasParameterErrors()) { + for (MethodInfo.ParameterError paramError : method.getParameterErrors()) { + FieldInfo param = paramError.getParameter(); + if (param == null || param.getDeclarationOffset() < 0) + continue; + + int paramStart = param.getDeclarationOffset(); + int paramEnd = paramStart + param.getName().length(); + drawUnderlineForSpan(paramStart, paramEnd, lineStartX, baselineY, + lineText, lineStart, lineEnd, ERROR_COLOR); + } + } + + // Handle all other errors + else if (method.hasError()) { + drawUnderlineForSpan(method.getFullDeclarationOffset(), method.getDeclarationEnd(), lineStartX, + baselineY, lineText, lineStart, lineEnd, ERROR_COLOR); + } + + } + + + for(ScriptTypeInfo types : doc.getScriptTypes()){ + if(!types.hasError()) + continue; + + int typeStart = types.getDeclarationOffset(); + int typeEnd = types.getBodyStart(); + drawUnderlineForSpan(typeStart, typeEnd, lineStartX, baselineY, + lineText, lineStart, lineEnd, ERROR_COLOR); + } + } + + /** + * Calculate underline position for a span of text within a line. + * Handles clipping to line boundaries and pixel width calculation. + * + * @param spanStart Global offset where the span starts + * @param spanEnd Global offset where the span ends + * @param lineStartX X coordinate where the line starts rendering + * @param lineText The text content of the line + * @param lineStart Global offset where this line starts + * @param lineEnd Global offset where this line ends + * @return UnderlinePosition with x and width, or null if span doesn't intersect line + */ + private static UnderlinePosition calculateUnderlinePosition( + int spanStart, int spanEnd, + int lineStartX, String lineText, int lineStart, int lineEnd) { + + // Skip if span doesn't intersect this line + if (spanEnd < lineStart || spanStart > lineEnd) + return null; + + // Clip to line boundaries + int clipStart = Math.max(spanStart, lineStart); + int clipEnd = Math.min(spanEnd, lineEnd); + + if (clipStart >= clipEnd) + return null; + + // Convert to line-local coordinates + int lineLocalStart = clipStart - lineStart; + int lineLocalEnd = clipEnd - lineStart; + + // Bounds check + if (lineLocalStart < 0 || lineLocalStart >= lineText.length()) + return null; + + // Compute pixel position + String beforeSpan = lineText.substring(0, lineLocalStart); + int beforeWidth = ClientProxy.Font.width(beforeSpan); + + int spanWidth; + if (lineLocalEnd > lineText.length()) { + // Span extends past line end + spanWidth = ClientProxy.Font.width(lineText.substring(lineLocalStart)); + } else { + // Span is fully on this line (or clipped) + String spanTextOnLine = lineText.substring(lineLocalStart, lineLocalEnd); + spanWidth = ClientProxy.Font.width(spanTextOnLine); + } + + return new UnderlinePosition(lineStartX + beforeWidth, spanWidth); + } + + /** + * Draw an underline for a simple span if it intersects the line. + * + * @param spanStart Global offset where the span starts + * @param spanEnd Global offset where the span ends + * @param lineStartX X coordinate where the line starts rendering + * @param baselineY Y coordinate for the underline baseline + * @param lineText The text content of the line + * @param lineStart Global offset where this line starts + * @param lineEnd Global offset where this line ends + * @param color Underline color + */ + public static void drawUnderlineForSpan( + int spanStart, int spanEnd, + int lineStartX, int baselineY, + String lineText, int lineStart, int lineEnd, + int color) { + + UnderlinePosition pos = calculateUnderlinePosition( + spanStart, spanEnd, lineStartX, lineText, lineStart, lineEnd); + + if (pos != null && pos.isValid()) { + drawCurlyUnderline(pos.x, baselineY, pos.width, color); + } + } + + /** + * Draw a curly/wavy underline (like IDE error highlighting). + * @param x Start X position + * @param y Y position (bottom of text) + * @param width Width of the underline + * @param color Color in ARGB format (e.g., 0xFFFF5555 for red) + */ + public static void drawCurlyUnderline(int x, int y, int width, int color) { + if (width <= 0) + return; + + float a = ((color >> 24) & 0xFF) / 255f; + float r = ((color >> 16) & 0xFF) / 255f; + float g = ((color >> 8) & 0xFF) / 255f; + float b = (color & 0xFF) / 255f; + + // If alpha is 0, assume full opacity + if (a == 0) + a = 1.0f; + + GL11.glPushMatrix(); + GL11.glDisable(GL11.GL_TEXTURE_2D); + GL11.glEnable(GL11.GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + GL11.glColor4f(r, g, b, a); + GL11.glLineWidth(1.0f); + + GL11.glBegin(GL11.GL_LINE_STRIP); + // Wave parameters: 2 pixels amplitude, 4 pixels wavelength + int waveHeight = 1; + float waveLength = 4f; + for (float i = -0.5f; i <= width - 1; i += 0.125f) { + // Create a sine-like wave pattern + double phase = (double) i / waveLength * Math.PI * 2; + float yOffset = (float) (Math.sin(phase) * waveHeight) - 0.25f; + GL11.glVertex2f(x + i + 2f, y + yOffset); + } + GL11.glEnd(); + + GL11.glEnable(GL11.GL_TEXTURE_2D); + GL11.glPopMatrix(); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/FieldChainMarker.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/FieldChainMarker.java new file mode 100644 index 000000000..edd06f0a3 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/FieldChainMarker.java @@ -0,0 +1,517 @@ +package noppes.npcs.client.gui.util.script.interpreter; + +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeResolver; +import noppes.npcs.client.gui.util.script.interpreter.type.ScriptTypeInfo; +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.token.TokenType; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenErrorMessage; + +import java.util.ArrayList; +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** + * Helper class for marking chained field accesses in script documents. + * Handles patterns like: identifier.field, this.field, super.field, method().field + */ +public class FieldChainMarker { + private final ScriptDocument document; + private final String text; + + public FieldChainMarker(ScriptDocument document, String text) { + this.document = document; + this.text = text; + } + + /** + * Mark all chained field accesses in the document. + * Uses two passes: one for standard chains, one for method/array result chains. + */ + public void markChainedFieldAccesses(List marks) { + // ==================== PASS 1: Standard identifier chains ==================== + // Pattern: identifier.identifier, this.identifier, super.identifier + Pattern chainPattern = Pattern.compile( + "\\b(this|super|[a-zA-Z_][a-zA-Z0-9_]*)\\s*\\.\\s*([a-zA-Z_][a-zA-Z0-9_]*)"); + Matcher m = chainPattern.matcher(text); + + while (m.find()) { + int chainStart = m.start(1); + + // Skip excluded ranges and imports + if (document.isExcluded(chainStart) || document.isInImportOrPackage(chainStart)) continue; + + // Skip if second segment is a method call - markMethodCalls handles it + if (document.isFollowedByParen(m.end(2))) continue; + + // Build the full chain + ChainData chain = buildChain(m); + if (chain == null) continue; + + // Resolve the starting type + ChainContext ctx = resolveChainStart(chain, chainStart); + + // Mark each segment + for (int i = ctx.startIndex; i < chain.segments.size(); i++) { + ctx.currentIndex = i; + int[] pos = chain.positions.get(i); + + if (document.isExcluded(pos[0])) continue; + + // Determine what type of marking this segment needs + MarkResult result = resolveSegmentMark(ctx, chainStart); + + // Apply the mark + if (result.mark != null) { + marks.add(result.mark); + } + + // Update context for next segment + ctx.currentType = result.nextType; + } + } + + // ==================== PASS 2: Method/array result chains ==================== + // Handle: getMinecraft().thePlayer, array[0].length + Pattern dotIdent = Pattern.compile("\\.\\s*([a-zA-Z_][a-zA-Z0-9_]*)"); + Matcher md = dotIdent.matcher(text); + + while (md.find()) { + int identStart = md.start(1); + int identEnd = md.end(1); + int dotPos = md.start(); + + // Skip excluded ranges and imports + if (document.isExcluded(identStart) || document.isInImportOrPackage(identStart)) continue; + + // Only handle when preceded by ')' or ']' (method call or array access result) + Character precedingChar = getNonWhitespaceBefore(dotPos); + if (precedingChar == null || (precedingChar != ')' && precedingChar != ']')) continue; + + // Get receiver type from the expression before the dot + int[] bounds = document.findReceiverBoundsBefore(dotPos); + if (bounds == null) continue; + + if (document.isExcluded(bounds[0]) || document.isInImportOrPackage(bounds[0])) continue; + + String receiverExpr = text.substring(bounds[0], bounds[1]).trim(); + if (receiverExpr.isEmpty()) continue; + + TypeInfo receiverType = document.resolveExpressionType(receiverExpr, bounds[0]); + + // Mark the first field and continue the chain + markReceiverChainSegments(marks, md.group(1), identStart, identEnd, receiverType); + } + } + + // ==================== CHAIN BUILDING HELPERS ==================== + + /** Data class for a parsed chain */ + private static class ChainData { + final List segments = new ArrayList<>(); + final List positions = new ArrayList<>(); + } + + /** Context for chain resolution */ + private static class ChainContext { + ChainData chain; + int currentIndex; + TypeInfo currentType; + ScriptTypeInfo enclosingType; // The enclosing script type for 'this' resolution + int startIndex; + boolean firstIsThis; + boolean firstIsSuper; + boolean firstIsPrecededByDot; + } + + /** Result of resolving a segment's mark */ + private static class MarkResult { + final ScriptLine.Mark mark; + final TypeInfo nextType; + + MarkResult(ScriptLine.Mark mark, TypeInfo nextType) { + this.mark = mark; + this.nextType = nextType; + } + } + + /** Build a complete chain from a regex match, continuing to read more segments */ + private ChainData buildChain(Matcher m) { + ChainData chain = new ChainData(); + + // Add first two segments from the match + chain.segments.add(m.group(1)); + chain.positions.add(new int[]{m.start(1), m.end(1)}); + chain.segments.add(m.group(2)); + chain.positions.add(new int[]{m.start(2), m.end(2)}); + + // Continue reading subsequent .identifier segments + int pos = m.end(2); + while (pos < text.length()) { + pos = document.skipWhitespace(pos); + if (pos >= text.length() || text.charAt(pos) != '.') break; + pos++; // Skip dot + + pos = document.skipWhitespace(pos); + if (pos >= text.length() || !Character.isJavaIdentifierStart(text.charAt(pos))) break; + + // Read identifier + int identStart = pos; + while (pos < text.length() && Character.isJavaIdentifierPart(text.charAt(pos))) pos++; + int identEnd = pos; + + // Stop if this is a method call + if (document.isFollowedByParen(identEnd)) break; + + chain.segments.add(text.substring(identStart, identEnd)); + chain.positions.add(new int[]{identStart, identEnd}); + } + + return chain; + } + + /** Resolve the starting context for a chain */ + private ChainContext resolveChainStart(ChainData chain, int chainStart) { + ChainContext ctx = new ChainContext(); + ctx.chain = chain; + ctx.currentIndex = 0; + String first = chain.segments.get(0); + + ctx.firstIsThis = first.equals("this"); + ctx.firstIsSuper = first.equals("super"); + ctx.firstIsPrecededByDot = document.isPrecededByDot(chainStart); + ctx.startIndex = ctx.firstIsPrecededByDot ? 0 : 1; + ctx.currentType = null; + ctx.enclosingType = document.findEnclosingScriptType(chainStart); + + if (ctx.firstIsThis) { + // 'this' - resolve to enclosing class/global fields + ctx.currentType = document.resolveThisType(chainStart); + if (ctx.currentType == null) { + ctx.currentType = ctx.enclosingType; + } + } else if (ctx.firstIsSuper) { + // 'super' - resolve to parent class + if (ctx.enclosingType != null && ctx.enclosingType.hasSuperClass()) { + ctx.currentType = ctx.enclosingType.getSuperClass(); + } + } else if (ctx.firstIsPrecededByDot) { + // Field access on a receiver (e.g., getMinecraft().thePlayer) + TypeInfo receiverType = document.resolveReceiverChain(chainStart); + if (receiverType != null && receiverType.hasField(first)) { + FieldInfo varInfo = receiverType.getFieldInfo(first); + ctx.currentType = (varInfo != null) ? varInfo.getTypeInfo() : null; + } + } else { + // Try as type first (static access), then as variable + TypeInfo typeCheck = document.resolveType(first); + if (typeCheck != null && typeCheck.isResolved()) { + ctx.currentType = typeCheck; + } else { + FieldInfo varInfo = document.resolveVariable(first, chainStart); + ctx.currentType = (varInfo != null) ? varInfo.getTypeInfo() : null; + } + } + + return ctx; + } + + /** Resolve what mark a segment should get */ + private MarkResult resolveSegmentMark(ChainContext ctx, int chainStart) { + int index = ctx.currentIndex; + String segment = ctx.chain.segments.get(index); + int[] pos = ctx.chain.positions.get(index); + + // Case 1: First segment preceded by dot (field on receiver) + if (index == 0 && ctx.firstIsPrecededByDot) { + return resolveReceiverFieldMark(ctx, chainStart); + } + + // Case 2: this.field + if (index == 1 && ctx.firstIsThis) { + return resolveThisFieldMark(ctx); + } + + // Case 3: super.field + if (index == 1 && ctx.firstIsSuper) { + return resolveSuperFieldMark(ctx); + } + + // Case 4: Resolved type with field + if (ctx.currentType != null && ctx.currentType.isResolved()) { + return resolveTypedFieldMark(ctx); + } + + // Case 5: Unresolved - mark as undefined + return new MarkResult( + new ScriptLine.Mark(pos[0], pos[1], TokenType.UNDEFINED_VAR), + null + ); + } + + // ==================== SEGMENT RESOLUTION HELPERS ==================== + + /** Resolve mark for field access on a receiver (preceded by dot) */ + private MarkResult resolveReceiverFieldMark(ChainContext ctx, int chainStart) { + int index = ctx.currentIndex; + String segment = ctx.chain.segments.get(index); + int[] pos = ctx.chain.positions.get(index); + boolean isLast = (index == ctx.chain.segments.size() - 1); + boolean isStatic = isStaticContext(ctx); + + TypeInfo receiverType = document.resolveReceiverChain(chainStart); + + if (receiverType != null && receiverType.hasField(segment)) { + FieldInfo fieldInfo = receiverType.getFieldInfo(segment); + FieldAccessInfo accessInfo = document.createFieldAccessInfo(segment, pos[0], pos[1], + receiverType, fieldInfo, isLast, isStatic); + + return new MarkResult(new ScriptLine.Mark(pos[0], pos[1], getFieldTokenType(fieldInfo), accessInfo), + (fieldInfo != null) ? fieldInfo.getTypeInfo() : null + ); + } + + return new MarkResult( + new ScriptLine.Mark(pos[0], pos[1], TokenType.UNDEFINED_VAR), + null + ); + } + + /** Resolve mark for this.field access */ + private MarkResult resolveThisFieldMark(ChainContext ctx) { + int index = ctx.currentIndex; + String segment = ctx.chain.segments.get(index); + int[] pos = ctx.chain.positions.get(index); + boolean isLast = (index == ctx.chain.segments.size() - 1); + + boolean found = false; + FieldInfo fieldInfo = null; + + TypeInfo thisType = ctx.currentType != null ? ctx.currentType : ctx.enclosingType; + + if (thisType != null && thisType.hasField(segment)) { + found = true; + fieldInfo = thisType.getFieldInfo(segment); + } else if (document.getGlobalFields().containsKey(segment)) { + found = true; + fieldInfo = document.getGlobalFields().get(segment); + } + + if (found) { + FieldAccessInfo accessInfo = document.createFieldAccessInfo(segment, pos[0], pos[1], thisType, + fieldInfo, isLast, false); + + return new MarkResult(new ScriptLine.Mark(pos[0], pos[1], getFieldTokenType(fieldInfo), accessInfo), + (fieldInfo != null) ? fieldInfo.getTypeInfo() : null + ); + } + + return new MarkResult(new ScriptLine.Mark(pos[0], pos[1], TokenType.UNDEFINED_VAR), null + ); + } + + /** Resolve mark for super.field access */ + private MarkResult resolveSuperFieldMark(ChainContext ctx) { + int index = ctx.currentIndex; + String segment = ctx.chain.segments.get(index); + int[] pos = ctx.chain.positions.get(index); + boolean isLast = (index == ctx.chain.segments.size() - 1); + TypeInfo superType = ctx.currentType; + + if (superType == null) { + return new MarkResult( + new ScriptLine.Mark(pos[0], pos[1], TokenType.UNDEFINED_VAR, + TokenErrorMessage.from("Cannot resolve field '" + segment + "'").clearOtherErrors()), + null + ); + } + + // Search through inheritance hierarchy + boolean found = false; + FieldInfo fieldInfo = null; + + if (superType instanceof ScriptTypeInfo) { + ScriptTypeInfo scriptSuper = (ScriptTypeInfo) superType; + found = scriptSuper.hasFieldInHierarchy(segment); + if (found) fieldInfo = scriptSuper.getFieldInfoInHierarchy(segment); + } else { + found = superType.hasField(segment); + if (found) fieldInfo = superType.getFieldInfo(segment); + } + + if (found) { + FieldAccessInfo accessInfo = document.createFieldAccessInfo(segment, pos[0], pos[1], + superType, fieldInfo, isLast, false); + return new MarkResult(new ScriptLine.Mark(pos[0], pos[1], getFieldTokenType(fieldInfo), accessInfo), + (fieldInfo != null) ? fieldInfo.getTypeInfo() : null + ); + } + + String errorMsg = "Field '" + segment + "' not found in parent class hierarchy starting from '" + + superType.getSimpleName() + "'"; + return new MarkResult( + new ScriptLine.Mark(pos[0], pos[1], TokenType.UNDEFINED_VAR, + TokenErrorMessage.from(errorMsg).clearOtherErrors()), + null + ); + } + + /** Resolve mark for typed field access */ + private MarkResult resolveTypedFieldMark(ChainContext ctx) { + int index = ctx.currentIndex; + String segment = ctx.chain.segments.get(index); + int[] pos = ctx.chain.positions.get(index); + boolean isLast = (index == ctx.chain.segments.size() - 1); + boolean isStatic = isStaticContext(ctx); + TypeInfo currentType = ctx.currentType; + + if (!currentType.hasField(segment)) { + // Field not found — check if the segment names an inner class. + // This handles chains like Outer.Inner where Inner is a nested type, not a field. + if (currentType instanceof ScriptTypeInfo) { + ScriptTypeInfo innerClass = ((ScriptTypeInfo) currentType).getInnerClass(segment); + if (innerClass != null) { + return new MarkResult( + new ScriptLine.Mark(pos[0], pos[1], innerClass.getTokenType(), innerClass), + innerClass + ); + } + } + // Also check Java inner classes via reflection (e.g., Map.Entry) + if (currentType.getJavaClass() != null) { + try { + for (Class nested : currentType.getJavaClass().getDeclaredClasses()) { + if (java.lang.reflect.Modifier.isPublic(nested.getModifiers()) + && nested.getSimpleName().equals(segment)) { + TypeInfo nestedType = TypeInfo.fromClass(nested); + return new MarkResult( + new ScriptLine.Mark(pos[0], pos[1], nestedType.getTokenType(), nestedType), + nestedType + ); + } + } + } catch (SecurityException ignored) { } + } + + return new MarkResult( + new ScriptLine.Mark(pos[0], pos[1], TokenType.UNDEFINED_VAR), + null + ); + } + + FieldInfo fieldInfo = currentType.getFieldInfo(segment); + + // Check for static access error + if (isStatic && fieldInfo != null && !fieldInfo.isStatic()) { + TokenErrorMessage errorMsg = TokenErrorMessage + .from("Cannot access non-static field '" + segment + "' from static context '" + + currentType.getSimpleName() + "'") + .clearOtherErrors(); + return new MarkResult( + new ScriptLine.Mark(pos[0], pos[1], TokenType.UNDEFINED_VAR, errorMsg), + null + ); + } + + // Valid field access + FieldAccessInfo accessInfo = document.createFieldAccessInfo(segment, pos[0], pos[1], + currentType, fieldInfo, isLast, isStatic); + + return new MarkResult(new ScriptLine.Mark(pos[0], pos[1], getFieldTokenType(fieldInfo), accessInfo), + (fieldInfo != null) ? fieldInfo.getTypeInfo() : null + ); + } + + /** Mark segments following a method call or array access result */ + private void markReceiverChainSegments(List marks, String firstField, + int identStart, int identEnd, TypeInfo receiverType) { + // Mark the first field + FieldInfo fInfo = null; + TypeInfo currentType = null; + + if (receiverType != null && receiverType.hasField(firstField)) { + fInfo = receiverType.getFieldInfo(firstField); + boolean hasMore = document.isFollowedByDot(identEnd); + // For method/array result chains, the receiver is always an instance, not a type + boolean isStatic = false; + + FieldAccessInfo accessInfo = document.createFieldAccessInfo(firstField, identStart, identEnd, + receiverType, fInfo, !hasMore, isStatic); + + marks.add(new ScriptLine.Mark(identStart, identEnd, getFieldTokenType(fInfo), accessInfo)); + currentType = (fInfo != null) ? fInfo.getTypeInfo() : null; + } else { + marks.add(new ScriptLine.Mark(identStart, identEnd, TokenType.UNDEFINED_VAR)); + return; + } + + // Continue the chain + int pos = identEnd; + while (pos < text.length()) { + pos = document.skipWhitespace(pos); + if (pos >= text.length() || text.charAt(pos) != '.') break; + pos++; // Skip dot + + pos = document.skipWhitespace(pos); + if (pos >= text.length() || !Character.isJavaIdentifierStart(text.charAt(pos))) break; + + // Read identifier + int nStart = pos; + while (pos < text.length() && Character.isJavaIdentifierPart(text.charAt(pos))) pos++; + int nEnd = pos; + String seg = text.substring(nStart, nEnd); + + // Stop if method call + if (document.isFollowedByParen(nEnd)) break; + if (document.isExcluded(nStart)) break; + + boolean isLast = !document.isFollowedByDot(nEnd); + + if (currentType != null && currentType.isResolved() && currentType.hasField(seg)) { + FieldInfo segInfo = currentType.getFieldInfo(seg); + // In method/array result chains, segments are always instance access + boolean isStatic = false; + + FieldAccessInfo accessInfo = document.createFieldAccessInfo(seg, nStart, nEnd, + currentType, segInfo, isLast, isStatic); + + marks.add(new ScriptLine.Mark(nStart, nEnd, getFieldTokenType(segInfo), accessInfo)); + currentType = (segInfo != null) ? segInfo.getTypeInfo() : null; + } else { + marks.add(new ScriptLine.Mark(nStart, nEnd, TokenType.UNDEFINED_VAR)); + break; + } + } + } + + // ==================== UTILITY HELPERS ==================== + + private TokenType getFieldTokenType(FieldInfo fieldInfo) { + if (fieldInfo != null && fieldInfo.isEnumConstant()) + return TokenType.ENUM_CONSTANT; + + return TokenType.GLOBAL_FIELD; + } + + /** Get the non-whitespace character before a position */ + private Character getNonWhitespaceBefore(int pos) { + int before = pos - 1; + while (before >= 0 && Character.isWhitespace(text.charAt(before))) before--; + return (before >= 0) ? text.charAt(before) : null; + } + + /** Check if the receiver type is a class/type (static context) */ + private boolean isStaticContext(ChainContext ctx) { + // Static context if the previous segment name resolves to a type/class + if (ctx.currentIndex <= 0) + return false; + + String previousSegment = ctx.chain.segments.get(ctx.currentIndex - 1); + int prevPos = ctx.chain.positions.get(ctx.currentIndex - 1)[0]; + + // Use unified static access checker + return TypeResolver.isStaticAccessExpression(previousSegment, prevPos, document); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/InnerCallableScope.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/InnerCallableScope.java new file mode 100644 index 000000000..e0fed4951 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/InnerCallableScope.java @@ -0,0 +1,104 @@ +package noppes.npcs.client.gui.util.script.interpreter; + +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import java.util.List; +import java.util.ArrayList; +import java.util.Map; +import java.util.HashMap; + +/** + * Represents an inner callable scope (lambda or JS function expression). + * These are NOT added to the methods list - they're resolution-only scopes. + */ +public class InnerCallableScope { + + public enum Kind { + JAVA_LAMBDA, + JS_FUNCTION_EXPR, + JS_ARROW_FUNC, + JS_SHORTHAND_METHOD + } + + private final Kind kind; + private final int headerStart; // Start of "(params) ->" or "function(params)" + private final int headerEnd; // End of header (position of "->" for lambda, ")" for JS func) + private final int bodyStart; // Start of body (expression start or '{') + private final int bodyEnd; // End of body (expression end or '}') + private final List parameters = new ArrayList<>(); + private final Map locals = new HashMap<>(); + private InnerCallableScope parentScope; // Enclosing inner scope (for nested lambdas) + private TypeInfo expectedType; // The expected functional interface type (set during resolution) + private TypeInfo containingObjectType; // For object-literal methods, the synthetic object-literal type + + public InnerCallableScope(Kind kind, int headerStart, int headerEnd, int bodyStart, int bodyEnd) { + this.kind = kind; + this.headerStart = headerStart; + this.headerEnd = headerEnd; + this.bodyStart = bodyStart; + this.bodyEnd = bodyEnd; + } + + // Getters + public Kind getKind() { return kind; } + public int getHeaderStart() { return headerStart; } + public int getHeaderEnd() { return headerEnd; } + public int getBodyStart() { return bodyStart; } + public int getBodyEnd() { return bodyEnd; } + public List getParameters() { return parameters; } + public Map getLocals() { return locals; } + public InnerCallableScope getParentScope() { return parentScope; } + public TypeInfo getExpectedType() { return expectedType; } + public TypeInfo getContainingObjectType() { return containingObjectType; } + + // Setters + public void setParentScope(InnerCallableScope parent) { this.parentScope = parent; } + public void setExpectedType(TypeInfo type) { this.expectedType = type; } + public void setContainingObjectType(TypeInfo type) { this.containingObjectType = type; } + + public void addParameter(FieldInfo param) { + parameters.add(param); + } + + public void addLocal(String name, FieldInfo local) { + locals.put(name, local); + } + + public FieldInfo getParameter(String name) { + for (FieldInfo param : parameters) { + if (param.getName().equals(name)) { + return param; + } + } + return null; + } + + public boolean hasParameter(String name) { + return getParameter(name) != null; + } + + /** + * Check if a position is inside this scope's body. + */ + public boolean containsPosition(int position) { + return position >= bodyStart && position < bodyEnd; + } + + /** + * Check if a position is inside this scope's header (parameter list). + */ + public boolean containsHeaderPosition(int position) { + return position >= headerStart && position < headerEnd; + } + + /** + * Get the full range (header + body). + */ + public int getFullStart() { + return headerStart; + } + + public int getFullEnd() { + return bodyEnd; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/LoopVariableParser.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/LoopVariableParser.java new file mode 100644 index 000000000..b71a8438a --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/LoopVariableParser.java @@ -0,0 +1,224 @@ +package noppes.npcs.client.gui.util.script.interpreter; + +import noppes.npcs.client.gui.util.script.ScopeInfo; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +import java.util.*; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +class LoopVariableParser { + + private static final Pattern ENHANCED_FOR = Pattern.compile( + "\\bfor\\s*\\(\\s*([A-Za-z_][\\w.<>\\[\\] \\t]*?(?:\\[\\s*\\])*)\\s+(\\w+)\\s*:\\s*([^)]+)\\)"); + private static final Pattern CLASSIC_FOR = Pattern.compile( + "\\bfor\\s*\\(\\s*([A-Za-z_][\\w.<>\\[\\] \\t]*?(?:\\[\\s*\\])*)\\s+(\\w+)\\s*="); + private static final Pattern FOR_IN = Pattern.compile( + "\\bfor\\s*\\(\\s*(?:var|let|const)\\s+(\\w+)\\s+in\\s+([^)]+)\\)"); + private static final Pattern FOR_OF = Pattern.compile( + "\\bfor\\s*\\(\\s*(?:var|let|const)\\s+(\\w+)\\s+of\\s+([^)]+)\\)"); + static final Pattern FOR_IN_OF_LOOKAHEAD = Pattern.compile("^\\s+(?:in|of)\\s"); + + private static final Set SKIP_TYPES = new HashSet<>(Arrays.asList( + "return", "if", "while", "for", "switch", "catch", "new", "throw")); + + private final ScriptDocument doc; + private final String text; + + LoopVariableParser(ScriptDocument doc, String text) { + this.doc = doc; + this.text = text; + } + + boolean isForInOrOf(String textAfterVarName) { + return FOR_IN_OF_LOOKAHEAD.matcher(textAfterVarName).find(); + } + + boolean isInsideForHeader(int bodyStart, int absPos) { + int enclosingParen = doc.findEnclosingParenStart(bodyStart, absPos); + return enclosingParen >= 0 && "for".equals(doc.readKeywordBefore(enclosingParen)); + } + + void parse(Map>> methodLocals) { + boolean js = doc.isJavaScript(); + + for (MethodInfo method : doc.getAllMethods()) { + int bodyStart = method.getBodyStart(); + int bodyEnd = method.getBodyEnd(); + if (bodyStart < 0 || bodyEnd <= bodyStart) continue; + String bodyText = text.substring(bodyStart, Math.min(bodyEnd, text.length())); + Map> locals = methodLocals.computeIfAbsent(method.getDeclarationOffset(), k -> new HashMap<>()); + scanRange(bodyText, bodyStart, bodyEnd, method, locals, js); + } + + for (InnerCallableScope scope : doc.getInnerScopes()) { + int bodyStart = scope.getBodyStart(); + int bodyEnd = scope.getBodyEnd(); + if (bodyStart < 0 || bodyEnd <= bodyStart) continue; + String bodyText = text.substring(bodyStart, Math.min(bodyEnd, text.length())); + MethodInfo ownerMethod = doc.findMethodAtPosition(bodyStart); + if (ownerMethod == null) continue; + Map> locals = methodLocals.computeIfAbsent(ownerMethod.getDeclarationOffset(), k -> new HashMap<>()); + scanRange(bodyText, bodyStart, bodyEnd, ownerMethod, locals, js); + } + + scanTopLevelLoops(); + } + + private void scanTopLevelLoops() { + boolean js = doc.isJavaScript(); + + if (!js) { + for (Matcher m = ENHANCED_FOR.matcher(text); m.find(); ) { + int absForPos = m.start(); + if (doc.isExcluded(absForPos) || isInsideAnyScope(absForPos)) continue; + String typeName = m.group(1).trim(); + String varName = m.group(2); + TypeInfo typeInfo = doc.resolveType(typeName); + ScopeInfo scope = computeForBodyScope(absForPos, 0, text.length()); + FieldInfo fi = FieldInfo.localField(varName, typeInfo, m.start(2), null, -1, -1, 0); + fi.setScopeInfo(scope); + doc.addTopLevelLocal(fi); + } + + for (Matcher m = CLASSIC_FOR.matcher(text); m.find(); ) { + int absForPos = m.start(); + if (doc.isExcluded(absForPos) || isInsideAnyScope(absForPos)) continue; + String typeName = m.group(1).trim(); + String varName = m.group(2); + if (SKIP_TYPES.contains(typeName)) continue; + TypeInfo typeInfo = doc.resolveType(typeName); + ScopeInfo scope = computeForBodyScope(absForPos, 0, text.length()); + FieldInfo fi = FieldInfo.localField(varName, typeInfo, m.start(2), null, -1, -1, 0); + fi.setScopeInfo(scope); + doc.addTopLevelLocal(fi); + } + } else { + for (Matcher m = FOR_IN.matcher(text); m.find(); ) { + int absForPos = m.start(); + if (doc.isExcluded(absForPos) || isInsideAnyScope(absForPos)) continue; + String varName = m.group(1); + ScopeInfo scope = computeForBodyScope(absForPos, 0, text.length()); + FieldInfo fi = FieldInfo.localField(varName, TypeInfo.fromPrimitive("int"), m.start(1), null, -1, -1, 0); + fi.setScopeInfo(scope); + doc.addTopLevelLocal(fi); + } + + for (Matcher m = FOR_OF.matcher(text); m.find(); ) { + int absForPos = m.start(); + if (doc.isExcluded(absForPos) || isInsideAnyScope(absForPos)) continue; + String varName = m.group(1); + String iterableExpr = m.group(2).trim(); + TypeInfo iterableType = doc.resolveExpressionType(iterableExpr, absForPos); + TypeInfo elementType = (iterableType != null) ? iterableType.getElementType() : null; + if (elementType == null) elementType = TypeInfo.ANY; + ScopeInfo scope = computeForBodyScope(absForPos, 0, text.length()); + FieldInfo fi = FieldInfo.localField(varName, elementType, m.start(1), null, -1, -1, 0); + fi.setScopeInfo(scope); + doc.addTopLevelLocal(fi); + } + } + } + + private boolean isInsideAnyScope(int pos) { + for (MethodInfo method : doc.getAllMethods()) { + if (method.containsPosition(pos)) return true; + } + for (InnerCallableScope scope : doc.getInnerScopes()) { + if (scope.containsPosition(pos)) return true; + } + return false; + } + + private void scanRange(String bodyText, int bodyStart, int bodyEnd, + MethodInfo method, Map> locals, boolean js) { + if (!js) { + Matcher m = ENHANCED_FOR.matcher(bodyText); + while (m.find()) { + int absForPos = bodyStart + m.start(); + if (doc.isExcluded(absForPos)) continue; + String typeName = m.group(1).trim(); + String varName = m.group(2); + int absVarPos = bodyStart + m.start(2); + TypeInfo typeInfo = doc.resolveType(typeName); + ScopeInfo scope = computeForBodyScope(absForPos, bodyStart, bodyEnd); + FieldInfo fi = FieldInfo.localField(varName, typeInfo, absVarPos, method, -1, -1, 0); + fi.setScopeInfo(scope); + locals.computeIfAbsent(varName, k -> new ArrayList<>()).add(fi); + } + + m = CLASSIC_FOR.matcher(bodyText); + while (m.find()) { + int absForPos = bodyStart + m.start(); + if (doc.isExcluded(absForPos)) continue; + String typeName = m.group(1).trim(); + String varName = m.group(2); + if (SKIP_TYPES.contains(typeName)) continue; + int absVarPos = bodyStart + m.start(2); + TypeInfo typeInfo = doc.resolveType(typeName); + ScopeInfo scope = computeForBodyScope(absForPos, bodyStart, bodyEnd); + FieldInfo fi = FieldInfo.localField(varName, typeInfo, absVarPos, method, -1, -1, 0); + fi.setScopeInfo(scope); + locals.computeIfAbsent(varName, k -> new ArrayList<>()).add(fi); + } + } else { + Matcher m = FOR_IN.matcher(bodyText); + while (m.find()) { + int absForPos = bodyStart + m.start(); + if (doc.isExcluded(absForPos)) continue; + String varName = m.group(1); + int absVarPos = bodyStart + m.start(1); + ScopeInfo scope = computeForBodyScope(absForPos, bodyStart, bodyEnd); + FieldInfo fi = FieldInfo.localField(varName, TypeInfo.fromPrimitive("int"), absVarPos, method, -1, -1, 0); + fi.setScopeInfo(scope); + locals.computeIfAbsent(varName, k -> new ArrayList<>()).add(fi); + } + + m = FOR_OF.matcher(bodyText); + while (m.find()) { + int absForPos = bodyStart + m.start(); + if (doc.isExcluded(absForPos)) continue; + String varName = m.group(1); + String iterableExpr = m.group(2).trim(); + int absVarPos = bodyStart + m.start(1); + TypeInfo iterableType = doc.resolveExpressionType(iterableExpr, absForPos); + TypeInfo elementType = (iterableType != null) ? iterableType.getElementType() : null; + if (elementType == null) elementType = TypeInfo.ANY; + ScopeInfo scope = computeForBodyScope(absForPos, bodyStart, bodyEnd); + FieldInfo fi = FieldInfo.localField(varName, elementType, absVarPos, method, -1, -1, 0); + fi.setScopeInfo(scope); + locals.computeIfAbsent(varName, k -> new ArrayList<>()).add(fi); + } + } + } + + private ScopeInfo computeForBodyScope(int forKeywordPos, int bodyStart, int bodyEnd) { + int max = Math.min(bodyEnd, text.length()); + int openParen = -1; + for (int i = forKeywordPos; i < max; i++) { + if (doc.isExcluded(i)) continue; + char c = text.charAt(i); + if (c == '(') { openParen = i; break; } + if (!Character.isWhitespace(c) && c != 'f' && c != 'o' && c != 'r') break; + } + if (openParen < 0) return new ScopeInfo(forKeywordPos, bodyEnd, false, "block"); + + int closeParen = doc.findMatchingParen(openParen, max); + if (closeParen < 0) return new ScopeInfo(forKeywordPos, bodyEnd, false, "block"); + + int after = doc.skipWhitespaceAndExcluded(closeParen + 1, max); + if (after < 0 || after >= max) return new ScopeInfo(forKeywordPos, bodyEnd, false, "block"); + + if (text.charAt(after) == '{') { + int closeBrace = doc.findMatchingBrace(after); + if (closeBrace > 0) return new ScopeInfo(forKeywordPos, closeBrace + 1, false, "block"); + return new ScopeInfo(forKeywordPos, bodyEnd, false, "block"); + } + + int stmtEnd = doc.findStatementEnd(after, max); + if (stmtEnd > after) return new ScopeInfo(forKeywordPos, stmtEnd, false, "block"); + return new ScopeInfo(forKeywordPos, bodyEnd, false, "block"); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/MultiDeclaratorParser.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/MultiDeclaratorParser.java new file mode 100644 index 000000000..7c5806a03 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/MultiDeclaratorParser.java @@ -0,0 +1,405 @@ +package noppes.npcs.client.gui.util.script.interpreter; + +// ==================== MULTI-DECLARATOR HELPERS ==================== +// +// JavaScript and Java both allow declaring multiple variables in a single +// statement, separated by commas: +// +// JS: var a = 1, b = "x", c = player; +// Java: int x = 1, y, z = 3; +// +// The existing regex patterns only match the FIRST declarator because: +// - The JS pattern `(var|let|const)\s+(\w+)` requires a keyword prefix. +// - The Java FIELD_DECL_PATTERN requires a type name prefix. +// +// Continuation declarators after the first comma have no keyword/type prefix, +// so they must be scanned manually. The two helpers below handle this by +// scanning forward from the end of the first declarator for commas at +// nesting depth 0, then extracting the `name [= initializer]` pattern +// for each continuation declarator. + +/** + * Static helpers for parsing comma-separated multi-variable declarations. + * + *

Extracted from {@link ScriptDocument} to keep the main document class + * focused on orchestration while this class owns the scanning algorithms.

+ */ +public final class MultiDeclaratorParser { + + private MultiDeclaratorParser() {} + + // ======================== CALLBACKS ======================== + + /** Callback for {@link #scanJSContinuationDeclarators}. */ + @FunctionalInterface + public interface JSContinuationCallback { + void accept(String varName, int absNamePos, String initializer, int absInitStart, int absInitEnd); + } + + /** Callback for {@link #scanJavaContinuationDeclarators}. */ + @FunctionalInterface + public interface JavaContinuationCallback { + void accept(String varName, int absNamePos, int absInitStart, int absInitEnd); + } + + // ======================== JS SCANNING ======================== + + /** + * Scan forward from {@code scanStart} in {@code source} for comma-separated + * continuation declarators in a JS {@code var/let/const} statement. + * + *

Each continuation declarator follows the pattern: {@code name [= initializer]}. + * The initializer (if present) is terminated using comma-aware scanning via + * {@link ScriptDocument#findJsInitializerEnd(String, int, boolean)}, which stops at + * top-level commas so that each declarator's RHS is correctly bounded.

+ * + *

The callback receives (varName, absNamePos, initializer, absInitStart, absInitEnd) + * for each continuation declarator found.

+ * + * @param doc the owning ScriptDocument (provides {@code findJsInitializerEnd} + * and {@code skipSegmentWhitespace}) + * @param source the source text to scan within (e.g. method body or global text) + * @param scanStart the position in {@code source} to begin scanning (typically + * right after the first declarator's initializer end or name end) + * @param absBase the absolute offset of {@code source[0]} in the full document text + * (used to compute absolute positions for the callback) + * @param callback receives each continuation declarator + */ + public static void scanJSContinuationDeclarators( + ScriptDocument doc, String source, int scanStart, int absBase, + JSContinuationCallback callback) { + + int pos = scanStart; + while (pos < source.length()) { + // Skip whitespace + while (pos < source.length() && Character.isWhitespace(source.charAt(pos))) pos++; + if (pos >= source.length()) break; + + // Expect a comma separating the next declarator + if (source.charAt(pos) != ',') break; + pos++; // skip the comma + + // Skip whitespace after comma + while (pos < source.length() && Character.isWhitespace(source.charAt(pos))) pos++; + if (pos >= source.length()) break; + + // Read the variable name (must be an identifier) + int nameStart = pos; + while (pos < source.length() && Character.isJavaIdentifierPart(source.charAt(pos))) pos++; + if (pos == nameStart) break; // no identifier found; malformed + String varName = source.substring(nameStart, pos); + + // Skip whitespace after name + while (pos < source.length() && Character.isWhitespace(source.charAt(pos))) pos++; + + String initializer = null; + int initStart = -1; + int initEnd = -1; + + // Check for optional '=' initializer + if (pos < source.length() && source.charAt(pos) == '=') { + // Make sure it's not == + if (pos + 1 < source.length() && source.charAt(pos + 1) == '=') break; + pos++; // skip '=' + int rhsStart = doc.skipSegmentWhitespace(source, pos); + // Use comma-aware initializer termination so that the RHS stops at + // the next top-level comma (which starts the next declarator). + int rhsEnd = doc.findJsInitializerEnd(source, rhsStart, true); + if (rhsEnd > rhsStart) { + initializer = source.substring(rhsStart, rhsEnd).trim(); + if (initializer.isEmpty()) initializer = null; + } + initStart = rhsStart; + initEnd = rhsEnd; + pos = rhsEnd; + } + + int absNamePos = absBase + nameStart; + int absInitStart = initStart >= 0 ? absBase + initStart : -1; + int absInitEnd = initEnd >= 0 ? absBase + initEnd : -1; + + callback.accept(varName, absNamePos, initializer, absInitStart, absInitEnd); + } + } + + // ======================== JAVA SCANNING ======================== + + /** + * Scan forward from {@code scanStart} in {@code source} for comma-separated + * continuation declarators in a Java multi-variable declaration. + * + *

Java allows {@code int x = 1, y, z = 3;} where all declarators share + * the same declared type. The {@code FIELD_DECL_PATTERN} regex only matches + * the first declarator ({@code int x =}); subsequent names like {@code y} + * and {@code z} lack a type prefix. This method manually scans the remainder + * of the statement for those continuation names.

+ * + *

Each continuation declarator follows the pattern: {@code name [= initializer]}. + * The initializer is terminated at {@code ;} or {@code ,} at depth 0.

+ * + * @param source the source text to scan within + * @param scanStart the position in {@code source} to begin scanning (typically + * right after the semicolon/delimiter of the first declarator + * match, or right after the first declarator's initializer) + * @param absBase the absolute offset of {@code source[0]} in the full document text + * @param callback receives each continuation declarator + */ + public static void scanJavaContinuationDeclarators( + String source, int scanStart, int absBase, + JavaContinuationCallback callback) { + + int pos = scanStart; + while (pos < source.length()) { + // Skip whitespace + while (pos < source.length() && Character.isWhitespace(source.charAt(pos))) pos++; + if (pos >= source.length()) break; + + // Expect a comma separating the next declarator + if (source.charAt(pos) != ',') break; + pos++; // skip the comma + + // Skip whitespace after comma + while (pos < source.length() && Character.isWhitespace(source.charAt(pos))) pos++; + if (pos >= source.length()) break; + + // Read the variable name (must be an identifier) + int nameStart = pos; + while (pos < source.length() && Character.isJavaIdentifierPart(source.charAt(pos))) pos++; + if (pos == nameStart) break; // no identifier found; malformed + String varName = source.substring(nameStart, pos); + + // Skip whitespace after name + while (pos < source.length() && Character.isWhitespace(source.charAt(pos))) pos++; + + int initStart = -1; + int initEnd = -1; + + // Check for optional '=' initializer + if (pos < source.length() && source.charAt(pos) == '=') { + // Make sure it's not == + if (pos + 1 < source.length() && source.charAt(pos + 1) == '=') break; + + initStart = pos; // position of '=' + pos++; // skip '=' + int rhsStart = pos; + // Skip whitespace after '=' + while (rhsStart < source.length() && Character.isWhitespace(source.charAt(rhsStart))) rhsStart++; + + // Scan forward for ';' or ',' at depth 0 to terminate this declarator's initializer + int depth = 0; + int angleDepth = 0; + int scanPos = rhsStart; + while (scanPos < source.length()) { + char c = source.charAt(scanPos); + if (c == '(' || c == '[' || c == '{') depth++; + else if (c == ')' || c == ']' || c == '}') depth--; + else if (c == '<') angleDepth++; + else if (c == '>') angleDepth--; + else if ((c == ';' || c == ',') && depth == 0 && angleDepth == 0) { + initEnd = scanPos; + break; + } + scanPos++; + } + pos = (initEnd >= 0) ? initEnd : scanPos; + } else if (pos < source.length() && (source.charAt(pos) == ';' || source.charAt(pos) == ',')) { + // No initializer — name only (e.g., the `y` in `int x, y, z;`) + // Don't advance past ';' here; let the outer loop handle it. + // If it's a comma, we'll pick it up on the next iteration. + } else { + // Unexpected character; stop scanning + break; + } + + int absNamePos = absBase + nameStart; + int absInitStartAbs = initStart >= 0 ? absBase + initStart : -1; + int absInitEndAbs = initEnd >= 0 ? absBase + initEnd : -1; + + callback.accept(varName, absNamePos, absInitStartAbs, absInitEndAbs); + } + } + + // ======================== SCAN-START POSITION HELPERS ======================== + + /** + * Determine the scan position for continuation declarators after a JS + * declarator match. If the first declarator has an initializer, we scan + * from the initializer end; otherwise we scan from after the variable name. + * + * @param bodyText the body text being parsed + * @param matchEnd the end position of the regex match (end of var name or '=') + * @param hasEquals whether the first declarator has '=' + * @param initEnd the initializer end position (in bodyText coords), or -1 + * @return the position in bodyText to start scanning for continuation commas + */ + public static int jsDeclaratorScanStart(String bodyText, int matchEnd, boolean hasEquals, int initEnd) { + if (hasEquals && initEnd >= 0) { + return initEnd; + } + // No initializer: scan from after the variable name + return matchEnd; + } + + /** + * Determine the scan position for continuation declarators after a Java + * FIELD_DECL_PATTERN match. The pattern's group(3) matches either '=', ';', + * or ','. If it matched '=', the scan starts after the initializer expression; + * if ';', there are no continuations (semicolon ends the statement). + * + *

Note: when the regex greedily consumed commas into the type name + * (e.g. {@code "int x, y,"} as the type group), the caller must detect this + * via {@link #findFirstDepthZeroComma(String)} on the matched type string + * and use the returned comma position directly as the scan start, bypassing + * this method. See the call sites in {@link ScriptDocument} for details.

+ * + * @param source the source text + * @param delimiter the delimiter matched by group(3): "=", ";", or "," + * @param delimEnd the end position of the delimiter in source coords + * @param initEnd the initializer end position, or -1 if no initializer + * @return the position in source to start scanning for continuation commas, + * or -1 if the statement ended at a semicolon + */ + public static int javaDeclaratorScanStart(String source, String delimiter, int delimEnd, int initEnd) { + if (";".equals(delimiter)) { + return -1; // semicolon terminates the statement; no continuations possible + } + // delimiter is '=' or ',' — scan from after the initializer (which stops at ',' or ';') + if (initEnd >= 0) { + return initEnd; + } + // When delimiter is ',' with no initializer (e.g. the 'x' in "int x,y,z;"), + // m.end(3) lands AFTER the comma. The scanner expects to START at the comma + // so it can consume it as the continuation separator — so back up by one. + if (",".equals(delimiter)) { + return delimEnd - 1; + } + return delimEnd; + } + + // ======================== GREEDY-REGEX COMMA HELPERS ======================== + + /** + * Find the first comma at bracket-depth 0 in the given string. + * + *

The Java {@code FIELD_DECL_PATTERN} regex allows commas inside the + * type-name character class (to support generics like {@code Map}). + * This causes the regex to greedily consume multi-declarator commas into + * group(1). For example, {@code "int x, y, z;"} matches with + * group(1)={@code "int x, y,"} and group(2)={@code "z"}.

+ * + *

This helper scans for the first comma that is NOT inside angle brackets + * ({@code <>}), parentheses, square brackets, or braces, i.e. at depth 0. + * A depth-0 comma indicates a multi-declarator separator that was consumed + * by the greedy regex.

+ * + * @param s the string to search (typically the matched type group) + * @return the index of the first depth-0 comma, or -1 if none found + */ + public static int findFirstDepthZeroComma(String s) { + int depth = 0; + int angleDepth = 0; + for (int i = 0; i < s.length(); i++) { + char c = s.charAt(i); + if (c == '(' || c == '[' || c == '{') depth++; + else if (c == ')' || c == ']' || c == '}') depth--; + else if (c == '<') angleDepth++; + else if (c == '>') angleDepth--; + else if (c == ',' && depth == 0 && angleDepth == 0) return i; + } + return -1; + } + + /** + * Extract the real type name from a regex group(1) that greedily consumed + * extra variable names and commas. + * + *

When the regex matches {@code "int x, y, z;"} as group(1)={@code "int x, y,"}, + * the real type name is {@code "int"} — everything before the first identifier + * that precedes the first depth-0 comma.

+ * + *

For {@code "final int x, y,"}, returns {@code "final int"}. + * For {@code "Map x, y,"}, returns {@code "Map"}.

+ * + * @param typeGroup the full group(1) string from the regex match + * @param commaIndex the index of the first depth-0 comma in {@code typeGroup} + * (as returned by {@link #findFirstDepthZeroComma(String)}) + * @return the real type name (may include modifiers like "final") + */ + public static String extractRealTypeFromGreedyMatch(String typeGroup, int commaIndex) { + // The part before the first depth-0 comma contains "Type firstVar" + // (possibly with modifiers). We need to split off the last identifier + // token before the comma, as that's the first variable name, not the type. + String beforeComma = typeGroup.substring(0, commaIndex).trim(); + int lastSpace = beforeComma.lastIndexOf(' '); + int lastTab = beforeComma.lastIndexOf('\t'); + int lastWS = Math.max(lastSpace, lastTab); + if (lastWS < 0) { + // No whitespace found — the "type" is actually just a variable name + // This shouldn't happen for valid declarations but handle gracefully + return beforeComma; + } + return beforeComma.substring(0, lastWS).trim(); + } + + /** + * Extract the first variable name from a regex group(1) that greedily consumed + * extra variable names and commas. + * + *

When the regex matches {@code "int x, y, z;"} as group(1)={@code "int x, y,"}, + * the first variable name is {@code "x"} — the last identifier token before + * the first depth-0 comma.

+ * + * @param typeGroup the full group(1) string from the regex match + * @param commaIndex the index of the first depth-0 comma in {@code typeGroup} + * (as returned by {@link #findFirstDepthZeroComma(String)}) + * @return the first variable name + */ + public static String extractFirstVarFromGreedyMatch(String typeGroup, int commaIndex) { + String beforeComma = typeGroup.substring(0, commaIndex).trim(); + int lastSpace = beforeComma.lastIndexOf(' '); + int lastTab = beforeComma.lastIndexOf('\t'); + int lastWS = Math.max(lastSpace, lastTab); + if (lastWS < 0) { + return beforeComma; + } + return beforeComma.substring(lastWS + 1).trim(); + } + + /** + * Find the absolute position of the first variable name within a greedily-consumed + * type group. Searches for the first variable name (the last token before the + * first depth-0 comma) within the source text starting from the type group start. + * + * @param source the full source text + * @param typeGroupStart the absolute start of group(1) in the source + * @param typeGroup the group(1) string + * @param commaIndex the index of the first depth-0 comma in typeGroup + * @return the absolute position of the first variable name in source + */ + public static int findFirstVarPosition(String source, int typeGroupStart, String typeGroup, int commaIndex) { + String firstVar = extractFirstVarFromGreedyMatch(typeGroup, commaIndex); + // The first variable appears in typeGroup just before the comma. + // Search backwards from commaIndex to find it. + String beforeComma = typeGroup.substring(0, commaIndex).trim(); + int varStartInGroup = beforeComma.lastIndexOf(firstVar); + return typeGroupStart + varStartInGroup; + } + + // ======================== MISC HELPERS ======================== + + /** + * Check whether the statement starting at {@code stmtStart} begins with + * a JS declaration keyword ({@code var}, {@code let}, or {@code const}). + * Used by {@link ScriptDocument}'s {@code parseAssignments()} to decide + * whether the RHS of an {@code =} should stop at a top-level comma + * (multi-declarator context). + */ + public static boolean startsWithJSKeyword(String source, int stmtStart, int equalsPos) { + int i = stmtStart; + while (i < equalsPos && Character.isWhitespace(source.charAt(i))) i++; + String prefix = source.substring(i, Math.min(i + 6, equalsPos)).trim(); + return prefix.startsWith("var ") || prefix.startsWith("var\t") + || prefix.startsWith("let ") || prefix.startsWith("let\t") + || prefix.startsWith("const ") || prefix.startsWith("const\t"); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ObjectLiteralParser.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ObjectLiteralParser.java new file mode 100644 index 000000000..9ddec2a92 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ObjectLiteralParser.java @@ -0,0 +1,1494 @@ +package noppes.npcs.client.gui.util.script.interpreter; + +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +import java.util.ArrayList; +import java.util.List; + +/** + * Helper class for JavaScript object literal (AKA dicts) analysis, parsing, type-shape inference, + * and dynamic property access handling. + * + *

Purpose

+ * Encapsulates the logic for: + *
    + *
  • Parsing object literal syntax ({@code { key: value, ... }}) into structured property lists.
  • + *
  • Inferring synthetic {@link TypeInfo} shapes from object literal contents for hover/autocomplete.
  • + *
  • Parsing dynamic property accesses ({@code obj.prop}, {@code obj["prop"]}) on the assignment LHS.
  • + *
  • Extending synthetic object shapes when new properties are assigned after initial declaration.
  • + *
  • Detecting synthetic object literal display names for UI rendering.
  • + *
+ * + *

V1 Scope

+ *
    + *
  • Only simple identifier keys and quoted-string keys are supported. Computed keys ({@code [expr]: val}) + * and spread ({@code ...obj}) are recognized but gracefully skipped.
  • + *
  • Nested object literals inside values degrade to {@link TypeInfo#ANY} rather than recursive inference.
  • + *
  • Value type inference delegates to the caller-supplied {@link ExpressionTypeResolverFn}; this class + * does not resolve types itself.
  • + *
+ * + *

Degradation Behavior

+ * When the parser encounters unsupported syntax (computed keys, spread, deeply nested literals), + * it sets {@link ObjectLiteralAnalysis#supportsInference} to {@code false} and returns partial + * property data. Callers (e.g. mark building) can still use the parsed properties for key highlighting + * even when full type inference is unavailable. + * + *

Architecture Note

+ * Methods that need access to ScriptDocument's type resolution ({@code resolveExpressionType}, + * {@code resolveVariable}) accept functional interfaces ({@link ExpressionTypeResolverFn}, + * {@link VariableResolverFn}) so that this class remains decoupled from ScriptDocument's internals. + * ScriptDocument retains ownership of {@code markObjectLiteralKeys} and + * {@code findMatchingBraceEndInDocument} which need direct access to document state (excluded ranges, text). + */ +public final class ObjectLiteralParser { + + private ObjectLiteralParser() { + // Static utility class — not instantiable + } + + // ────────────────────────────────────────────────────────────────────────── + // Functional interfaces for ScriptDocument callbacks + // ────────────────────────────────────────────────────────────────────────── + + /** + * Callback to resolve an expression's type given the expression text and its absolute position + * within the document. Delegates to {@code ScriptDocument.resolveExpressionType(expr, position)}. + */ + @FunctionalInterface + public interface ExpressionTypeResolverFn { + TypeInfo resolve(String expr, int position); + } + + /** Resolves a script-declared method by name. Used to copy parameter/return info into callable properties. */ + @FunctionalInterface + public interface MethodReferenceResolverFn { + MethodInfo resolve(String methodName, TypeInfo[] argTypes); + } + + /** + * Callback to resolve a variable by name at a given document position. + * Delegates to {@code ScriptDocument.resolveVariable(name, position)}. + */ + @FunctionalInterface + public interface VariableResolverFn { + FieldInfo resolve(String name, int position); + } + + // ────────────────────────────────────────────────────────────────────────── + // Data classes + // ────────────────────────────────────────────────────────────────────────── + + /** + * Result of analyzing an object literal expression. + * + *

Contains the parsed properties, whether full type inference is feasible, + * and (when inference succeeded) the synthetic {@link TypeInfo} representing the object's shape.

+ */ + public static final class ObjectLiteralAnalysis { + /** Parsed properties (key name, offsets, optional inferred value type). */ + public final List properties; + /** + * {@code true} when every property was fully parseable and the closing brace was found, + * meaning a synthetic type shape can be constructed. {@code false} when unsupported syntax + * was encountered or the literal is incomplete. + */ + public final boolean supportsInference; + /** + * The synthetic {@link TypeInfo} representing this object literal's shape, or {@code null} + * when inference was not requested or not supported. + */ + public final TypeInfo inferredType; + + ObjectLiteralAnalysis(List properties, boolean supportsInference, TypeInfo inferredType) { + this.properties = properties; + this.supportsInference = supportsInference; + this.inferredType = inferredType; + } + } + + /** + * A single property inside an object literal. + * + *

Tracks the key name, whether the key was written as a bare identifier or a quoted string, + * the absolute document offsets for both key and value spans, the inferred value type + * (when type inference was requested), and optional callable metadata when the value is a + * function expression, arrow function, or shorthand method.

+ */ + public static final class ObjectLiteralProperty { + /** The property key name (without quotes if originally quoted). */ + public final String keyName; + /** {@code true} if the key was a bare identifier; {@code false} if it was a quoted string. */ + public final boolean isIdentifierKey; + /** Absolute start offset of the key in the document. */ + public final int keyStartAbs; + /** Absolute end offset of the key in the document. */ + public final int keyEndAbs; + /** Absolute start offset of the value expression in the document. */ + public final int valueStartAbs; + /** Absolute end offset of the value expression in the document. */ + public final int valueEndAbs; + /** The inferred type of the value expression, or {@code null} if inference was not requested. */ + public final TypeInfo valueType; + /** Callable metadata if this property's value is a function expression, arrow, or shorthand method. */ + public final CallableInfo callableInfo; + + ObjectLiteralProperty(String keyName, boolean isIdentifierKey, int keyStartAbs, int keyEndAbs, + int valueStartAbs, int valueEndAbs, TypeInfo valueType, CallableInfo callableInfo) { + this.keyName = keyName; + this.isIdentifierKey = isIdentifierKey; + this.keyStartAbs = keyStartAbs; + this.keyEndAbs = keyEndAbs; + this.valueStartAbs = valueStartAbs; + this.valueEndAbs = valueEndAbs; + this.valueType = valueType; + this.callableInfo = callableInfo; + } + + public boolean isCallable() { + return callableInfo != null; + } + } + + /** + * Represents a dynamic property access on the LHS of an assignment. + * + *

Two forms are supported:

+ *
    + *
  • Dot access: {@code obj.prop} → {@code receiverExpr="obj", propertyName="prop", bracketAccess=false}
  • + *
  • Bracket access: {@code obj["prop"]} → {@code receiverExpr="obj", propertyName="prop", bracketAccess=true}
  • + *
+ */ + public static final class DynamicPropertyAccess { + /** The expression for the receiver object (everything before the dot or bracket). */ + public final String receiverExpr; + /** The property name being accessed. */ + public final String propertyName; + /** Absolute document offset where the receiver expression starts. */ + public final int receiverStart; + /** {@code true} if this is bracket notation ({@code obj["prop"]}); {@code false} for dot notation. */ + public final boolean bracketAccess; + + DynamicPropertyAccess(String receiverExpr, String propertyName, int receiverStart, boolean bracketAccess) { + this.receiverExpr = receiverExpr; + this.propertyName = propertyName; + this.receiverStart = receiverStart; + this.bracketAccess = bracketAccess; + } + } + + // ────────────────────────────────────────────────────────────────────────── + // Object literal analysis + // ────────────────────────────────────────────────────────────────────────── + + /** + * Analyze an object literal string and extract its properties. + * + *

The input is expected to start with {@code '{'} (after optional leading whitespace) and + * may or may not be a complete literal. Properties are parsed into {@link ObjectLiteralProperty} + * records. When {@code inferTypes} is {@code true} and inference is feasible, a synthetic + * {@link TypeInfo} shape is constructed with fields matching the parsed properties.

+ * + * @param objectLiteral the source text of the object literal (starting at or near '{') + * @param baseOffset the absolute document offset corresponding to the start of {@code objectLiteral} + * @param inferTypes if {@code true}, attempt to resolve value types and build a synthetic shape + * @param assumeComplete if {@code true}, treat the entire string as a complete literal (no brace matching needed) + * @param typeResolver callback for resolving value expression types (may be {@code null} if {@code inferTypes} is false) + * @param methodChecker callback for checking if an identifier is a known script method (for callable detection) + * @return the analysis result, or {@code null} if the input is not a valid object literal start + */ + public static ObjectLiteralAnalysis parse(String objectLiteral, int baseOffset, + boolean inferTypes, boolean assumeComplete, + ExpressionTypeResolverFn typeResolver, + MethodReferenceResolverFn methodResolver) { + if (objectLiteral == null) { + return null; + } + + // Trim leading and trailing whitespace. + int leading = 0; + while (leading < objectLiteral.length() && Character.isWhitespace(objectLiteral.charAt(leading))) { + leading++; + } + int trailing = objectLiteral.length(); + while (trailing > leading && Character.isWhitespace(objectLiteral.charAt(trailing - 1))) { + trailing--; + } + + String src = objectLiteral.substring(leading, trailing); + int absBase = baseOffset + leading; + + // Verify this starts with '{'. + if (src.isEmpty() || src.charAt(0) != '{') { + return null; + } + + // Find the matching '}' or use the entire string if assumeComplete is true. + int endExclusive; + if (assumeComplete) { + endExclusive = src.length(); + } else { + endExclusive = findMatchingObjectLiteralEnd(src); + if (endExclusive <= 0) { + return null; + } + } + + // Only attempt type inference if the literal is complete (closing brace found). + boolean supportsInference = (endExclusive == src.length()); + int bodyStart = 1; + int bodyEnd = endExclusive - 1; + + List props = new ArrayList<>(); + boolean sawUnsupported = false; + + // Parse each property in the object literal body. + int i = bodyStart; + while (i < bodyEnd) { + i = skipSeparatorsAndComments(src, i, bodyEnd); + if (i >= bodyEnd) { + break; + } + + int keyStart = i; + String keyName = null; + boolean isIdentifierKey = false; + + char kc = src.charAt(i); + // Parse key: quoted string or bare identifier or async method shorthand + if (kc == '"' || kc == '\'') { + // Quoted key — extract and validate + int keyEnd = scanStringLiteralEnd(src, i); + if (keyEnd < 0 || keyEnd > bodyEnd) { + sawUnsupported = true; + break; + } + keyName = src.substring(i + 1, keyEnd - 1); + isIdentifierKey = false; + if (!isSimpleIdentifier(keyName)) { + sawUnsupported = true; + i = scanToNextTopLevelComma(src, keyEnd, bodyEnd); + continue; + } + i = keyEnd; + } else if (Character.isJavaIdentifierStart(kc)) { + // Bare identifier key + i++; + while (i < bodyEnd && Character.isJavaIdentifierPart(src.charAt(i))) { + i++; + } + keyName = src.substring(keyStart, i); + isIdentifierKey = true; + + // Handle 'async methodName()' shorthand syntax + if ("async".equals(keyName)) { + int afterAsync = i; + while (afterAsync < bodyEnd && Character.isWhitespace(src.charAt(afterAsync))) { + afterAsync++; + } + if (afterAsync < bodyEnd && Character.isJavaIdentifierStart(src.charAt(afterAsync))) { + int realKeyStart = afterAsync; + afterAsync++; + while (afterAsync < bodyEnd && Character.isJavaIdentifierPart(src.charAt(afterAsync))) { + afterAsync++; + } + keyStart = realKeyStart; + keyName = src.substring(realKeyStart, afterAsync); + i = afterAsync; + } + } + } else if (kc == '[') { + // Computed key — unsupported for inference, skip to next property + sawUnsupported = true; + i = scanToNextTopLevelComma(src, i, bodyEnd); + continue; + } else if (kc == '.' && i + 2 < bodyEnd && src.charAt(i + 1) == '.' && src.charAt(i + 2) == '.') { + // Spread syntax — unsupported, skip + sawUnsupported = true; + i = scanToNextTopLevelComma(src, i, bodyEnd); + continue; + } else { + sawUnsupported = true; + i = scanToNextTopLevelComma(src, i, bodyEnd); + continue; + } + + int keyEnd = i; + while (i < bodyEnd && Character.isWhitespace(src.charAt(i))) { + i++; + } + + // Check for shorthand method syntax: key() { ... } + if (i < bodyEnd && src.charAt(i) == '(' && isIdentifierKey) { + int parenOpen = i; + int parenClose = findMatchingParen(src, parenOpen); + if (parenClose < 0 || parenClose >= bodyEnd) { + sawUnsupported = true; + i = scanToNextTopLevelComma(src, i, bodyEnd); + continue; + } + + // Extract parameter names and infer return type from the method body. + List params = extractParameterNames(src.substring(parenOpen + 1, parenClose)); + int afterParen = parenClose + 1; + while (afterParen < bodyEnd && Character.isWhitespace(src.charAt(afterParen))) { + afterParen++; + } + // Expect a '{' after the parameter list + if (afterParen >= bodyEnd || src.charAt(afterParen) != '{') { + sawUnsupported = true; + i = scanToNextTopLevelComma(src, afterParen, bodyEnd); + continue; + } + + int braceEnd = findMatchingObjectLiteralEnd(src.substring(afterParen)); + if (braceEnd <= 0) { + sawUnsupported = true; + break; + } + int methodBodyEnd = afterParen + braceEnd; + String bodyText = src.substring(afterParen, methodBodyEnd); + TypeInfo returnType = inferReturnTypeFromBlockBody(bodyText, absBase + afterParen, typeResolver); + + CallableInfo callableInfo = new CallableInfo(params, returnType, + absBase + afterParen, absBase + methodBodyEnd, true); + int keyStartAbs = absBase + keyStart; + int keyEndAbs = absBase + keyEnd; + int valueStartAbs = absBase + parenOpen; + int valueEndAbs = absBase + methodBodyEnd; + + props.add(new ObjectLiteralProperty(keyName, true, keyStartAbs, keyEndAbs, + valueStartAbs, valueEndAbs, returnType, callableInfo)); + i = methodBodyEnd; + while (i < bodyEnd && Character.isWhitespace(src.charAt(i))) { + i++; + } + if (i < bodyEnd && src.charAt(i) == ',') { + i++; + } + continue; + } + + // Regular property: key: value + if (i >= bodyEnd || src.charAt(i) != ':') { + sawUnsupported = true; + i = scanToNextTopLevelComma(src, i, bodyEnd); + continue; + } + i++; + + while (i < bodyEnd && Character.isWhitespace(src.charAt(i))) { + i++; + } + int valueStart = i; + int valueEnd = scanTopLevelValueEnd(src, valueStart, bodyEnd); + if (valueEnd < valueStart) { + sawUnsupported = true; + break; + } + + // Try to detect callable or infer value type + TypeInfo valueType = null; + CallableInfo callableInfo = null; + if (inferTypes && typeResolver != null) { + String valueExpr = src.substring(valueStart, valueEnd).trim(); + callableInfo = detectCallableExpression(valueExpr, absBase + valueStart, methodResolver, typeResolver); + if (callableInfo != null) { + valueType = callableInfo.returnType; + } else { + valueType = inferValueType(valueExpr, absBase + valueStart, typeResolver); + } + } + + int keyStartAbs = absBase + keyStart; + int keyEndAbs = absBase + keyEnd; + int valueStartAbs = absBase + valueStart; + int valueEndAbs = absBase + valueEnd; + + if (keyName != null) { + props.add(new ObjectLiteralProperty(keyName, isIdentifierKey, keyStartAbs, keyEndAbs, + valueStartAbs, valueEndAbs, valueType, callableInfo)); + } + + i = valueEnd; + i = skipSeparatorsAndComments(src, i, bodyEnd); + } + + if (sawUnsupported) { + supportsInference = false; + } + + TypeInfo inferredType = null; + if (inferTypes && supportsInference) { + inferredType = TypeInfo.objectLiteral(props); + } + + return new ObjectLiteralAnalysis(props, supportsInference, inferredType); + } + + // ────────────────────────────────────────────────────────────────────────── + // Synthetic object literal display name detection + // ────────────────────────────────────────────────────────────────────────── + + /** + * Determine whether a {@link JSTypeInfo} represents a synthetic object literal type, + * and if so return its display name ({@code "Object"}). + * + *

Synthetic object literal types are created by {@link #parse} with + * names of the form {@code __ObjectLiteral$} under the {@code __synthetic__} namespace. + * This method recognizes that naming convention and maps it to a human-readable display name.

+ * + * @param jsType the JS type info to inspect (may be {@code null}) + * @return {@code "Object"} if this is a synthetic object literal type, {@code null} otherwise + */ + public static String getSyntheticObjectLiteralDisplayName(JSTypeInfo jsType) { + if (jsType == null) { + return null; + } + String namespace = jsType.getNamespace(); + String simple = jsType.getSimpleName(); + if ("__synthetic__".equals(namespace) && simple != null && simple.startsWith("__ObjectLiteral$")) { + return "Object"; + } + return null; + } + + // ────────────────────────────────────────────────────────────────────────── + // Dynamic property access parsing + // ────────────────────────────────────────────────────────────────────────── + + /** + * Parse a left-hand-side expression to detect dynamic property access patterns. + * + *

Recognizes two forms:

+ *
    + *
  • Dot access: {@code obj.prop} — the last dot-separated segment is treated as the property name.
  • + *
  • Bracket access: {@code obj["prop"]} or {@code obj['prop']} — the quoted string inside brackets + * is treated as the property name.
  • + *
+ * + *

Only simple identifier property names are accepted. Complex expressions (e.g., {@code obj[expr]} + * where {@code expr} is not a string literal) return {@code null}.

+ * + * @param lhs the left-hand-side expression text + * @param lhsStart the absolute document offset of the LHS start + * @return a {@link DynamicPropertyAccess} if a valid pattern was detected, {@code null} otherwise + */ + public static DynamicPropertyAccess parseDynamicPropertyAccess(String lhs, int lhsStart) { + if (lhs == null || lhs.isEmpty()) { + return null; + } + + int dotIndex = lhs.lastIndexOf('.'); + int bracketIndex = lhs.lastIndexOf('['); + + if (dotIndex >= 0 && dotIndex > bracketIndex) { + String receiverExpr = lhs.substring(0, dotIndex).trim(); + String propertyName = lhs.substring(dotIndex + 1).trim(); + if (!receiverExpr.isEmpty() && isSimpleIdentifier(propertyName)) { + return new DynamicPropertyAccess(receiverExpr, propertyName, lhsStart, false); + } + return null; + } + + if (bracketIndex >= 0 && lhs.endsWith("]")) { + String receiverExpr = lhs.substring(0, bracketIndex).trim(); + String keyExpr = lhs.substring(bracketIndex + 1, lhs.length() - 1).trim(); + String propertyName = extractQuotedPropertyName(keyExpr); + if (!receiverExpr.isEmpty() && propertyName != null && isSimpleIdentifier(propertyName)) { + return new DynamicPropertyAccess(receiverExpr, propertyName, lhsStart, true); + } + } + + return null; + } + + /** + * Resolve the receiver type for a dynamic property access by first trying expression type resolution + * and then falling back to variable resolution. + * + * @param access the dynamic property access to resolve + * @param typeResolver callback for expression type resolution + * @param variableResolver callback for variable resolution + * @return the resolved receiver {@link TypeInfo}, or {@code null} if resolution failed + */ + public static TypeInfo resolveDynamicPropertyReceiverType(DynamicPropertyAccess access, + ExpressionTypeResolverFn typeResolver, + VariableResolverFn variableResolver) { + if (access == null) { + return null; + } + + TypeInfo receiverType = typeResolver.resolve(access.receiverExpr, access.receiverStart); + if (receiverType != null && receiverType.isResolved()) { + return receiverType; + } + + FieldInfo receiverField = variableResolver.resolve(access.receiverExpr, access.receiverStart); + if (receiverField != null) { + return receiverField.getTypeInfo(); + } + + return null; + } + + /** + * Extract a property name from a quoted string expression. + * + *

Handles both single and double quotes, plus basic backslash escapes. + * Returns {@code null} if the expression is not a properly quoted string.

+ * + * @param expr the expression to extract from (e.g., {@code "prop"} or {@code 'prop'}) + * @return the unquoted, unescaped property name, or {@code null} if extraction failed + */ + public static String extractQuotedPropertyName(String expr) { + if (expr == null || expr.length() < 2) { + return null; + } + char quote = expr.charAt(0); + if ((quote != '"' && quote != '\'') || expr.charAt(expr.length() - 1) != quote) { + return null; + } + + StringBuilder sb = new StringBuilder(); + for (int i = 1; i < expr.length() - 1; i++) { + char c = expr.charAt(i); + if (c == '\\') { + if (i + 1 >= expr.length() - 1) { + return null; + } + char escaped = expr.charAt(++i); + sb.append(escaped); + continue; + } + sb.append(c); + } + return sb.toString(); + } + + /** + * Extend a synthetic object literal shape with a new property (or update an existing one). + * + *

This is called when an assignment like {@code obj.newProp = value} is encountered and + * {@code obj} was previously inferred as a synthetic object literal type. The new property + * is added to the underlying {@link JSTypeInfo} so subsequent hover/autocomplete sees it.

+ * + *

Only operates on types that are recognized as synthetic object literals + * (see {@link #getSyntheticObjectLiteralDisplayName}). Returns {@code false} and does nothing + * if the receiver type is not a synthetic object literal.

+ * + * @param receiverType the type of the receiver object + * @param propertyName the name of the property to add/update + * @param propertyType the inferred type of the property value (defaults to {@link TypeInfo#ANY} if null/unresolved) + * @return {@code true} if the shape was extended/updated, {@code false} if the receiver is not a synthetic object literal + */ + public static boolean extendSyntheticObjectShape(TypeInfo receiverType, String propertyName, TypeInfo propertyType) { + if (receiverType == null || propertyName == null || propertyName.isEmpty()) { + return false; + } + if (!receiverType.isSyntheticObjectLiteralType()) { + return false; + } + TypeInfo safeType = (propertyType != null && propertyType.isResolved()) ? propertyType : TypeInfo.ANY; + receiverType.removeSyntheticField(propertyName); + receiverType.addSyntheticField(propertyName, safeType); + return true; + } + + /** Holds the resolved receiver type, property name, and field for a dynamic property access result. */ + public static final class DynamicFieldResult { + public final TypeInfo receiverType; + public final String propertyName; + public final FieldInfo field; + + DynamicFieldResult(TypeInfo receiverType, String propertyName, FieldInfo field) { + this.receiverType = receiverType; + this.propertyName = propertyName; + this.field = field; + } + } + + /** Resolve an existing field on a dynamic property access receiver without modifying the type shape. */ + public static DynamicFieldResult resolveExistingField(DynamicPropertyAccess access, + ExpressionTypeResolverFn typeResolver, VariableResolverFn varResolver) { + TypeInfo receiver = resolveDynamicPropertyReceiverType(access, typeResolver, varResolver); + FieldInfo field = (receiver != null && receiver.isResolved()) ? receiver.getFieldInfo(access.propertyName) : null; + return new DynamicFieldResult(receiver, access.propertyName, field); + } + + /** Extend a synthetic object's shape with a new property, then return the resolved field. Overload without RHS text. */ + public static DynamicFieldResult extendAndGetField(DynamicPropertyAccess access, + TypeInfo existingReceiver, TypeInfo sourceType, + ExpressionTypeResolverFn typeResolver, VariableResolverFn varResolver) { + return extendAndGetField(access, existingReceiver, sourceType, null, typeResolver, varResolver); + } + + /** + * Extend a synthetic object's shape with a new property, then return the resolved field. + * When {@code rhsText} is a function expression, a synthetic method is registered instead of a plain field. + */ + public static DynamicFieldResult extendAndGetField(DynamicPropertyAccess access, + TypeInfo existingReceiver, TypeInfo sourceType, String rhsText, + ExpressionTypeResolverFn typeResolver, VariableResolverFn varResolver) { + // Prefer the already-resolved receiver to avoid a redundant re-resolution. + TypeInfo receiver = (existingReceiver != null && existingReceiver.isResolved()) + ? existingReceiver + : resolveDynamicPropertyReceiverType(access, typeResolver, varResolver); + if (receiver == null || !receiver.isSyntheticObjectLiteralType()) return null; + + // If the RHS looks like a callable (function/arrow/ref), register it as a method; otherwise as a field. + CallableInfo callable = (rhsText != null) ? detectCallableExpression(rhsText.trim(), -1, null, typeResolver) : null; + if (callable != null) { + extendSyntheticObjectWithMethod(receiver, access.propertyName, callable); + } else { + if (!extendSyntheticObjectShape(receiver, access.propertyName, sourceType)) return null; + } + return new DynamicFieldResult(receiver, access.propertyName, receiver.getFieldInfo(access.propertyName)); + } + + /** + * Metadata for a callable property value (function expression, arrow function, or shorthand method). + * + *

Captures the parameter names and the inferred return type so that the property can be + * registered as a synthetic method on the object literal's type.

+ */ + public static final class CallableInfo { + private static final TypeInfo THIS_RETURN_SENTINEL = TypeInfo.unresolved("", ""); + public final List parameterNames; + public final TypeInfo returnType; + public final int bodyStartAbs; + public final int bodyEndAbs; + public final boolean blockBody; + + CallableInfo(List parameterNames, TypeInfo returnType, int bodyStartAbs, int bodyEndAbs, boolean blockBody) { + this.parameterNames = parameterNames != null ? parameterNames : new ArrayList<>(); + this.returnType = returnType; + this.bodyStartAbs = bodyStartAbs; + this.bodyEndAbs = bodyEndAbs; + this.blockBody = blockBody; + } + + public boolean returnsThis() { + return returnType == THIS_RETURN_SENTINEL; + } + + static TypeInfo thisReturnSentinel() { + return THIS_RETURN_SENTINEL; + } + } + + // ────────────────────────────────────────────────────────────────────────── + // Callable expression detection + // ────────────────────────────────────────────────────────────────────────── + + /** + * Detect whether a value expression is callable (function expression, arrow function, or bare script method reference). + * Returns a {@link CallableInfo} with parameter names and inferred return type, or {@code null} if not callable. + */ + static CallableInfo detectCallableExpression(String expr, int exprStartAbs, + MethodReferenceResolverFn methodResolver, + ExpressionTypeResolverFn typeResolver) { + if (expr == null || expr.isEmpty()) return null; + + // Inline function expression: function(...) { ... } + if (expr.startsWith("function")) { + return parseFunctionExpressionCallable(expr, exprStartAbs, typeResolver); + } + + // Arrow function: (...) => ... or x => ... + if (expr.contains("=>")) { + return parseArrowFunctionCallable(expr, exprStartAbs, typeResolver); + } + + // Bare identifier that resolves to a known script method (e.g. onTick: handleTick) + if (isSimpleIdentifier(expr.trim()) && methodResolver != null) { + MethodInfo method = methodResolver.resolve(expr.trim(), new TypeInfo[0]); + if (method != null) { + TypeInfo returnType = method.getReturnType() != null ? method.getReturnType() : TypeInfo.ANY; + List paramNames = new ArrayList<>(); + for (FieldInfo param : method.getParameters()) paramNames.add(param.getName()); + return new CallableInfo(paramNames, returnType, exprStartAbs, exprStartAbs + expr.trim().length(), false); + } + } + + return null; + } + + /** Parse a {@code function(...) { ... }} expression into a CallableInfo, extracting params and inferring return type. */ + private static CallableInfo parseFunctionExpressionCallable(String expr, int exprStartAbs, + ExpressionTypeResolverFn typeResolver) { + int parenOpen = expr.indexOf('('); + if (parenOpen < 0) return null; + int parenClose = findMatchingParen(expr, parenOpen); + if (parenClose < 0) return null; + + List params = extractParameterNames(expr.substring(parenOpen + 1, parenClose)); + TypeInfo returnType = inferReturnTypeFromBody(expr, parenClose + 1, exprStartAbs, typeResolver); + String rest = expr.substring(parenClose + 1).trim(); + int bodyOffset = expr.indexOf(rest, parenClose + 1); + return new CallableInfo(params, returnType, + exprStartAbs >= 0 ? exprStartAbs + Math.max(bodyOffset, 0) : -1, + exprStartAbs >= 0 ? exprStartAbs + expr.length() : -1, + rest.startsWith("{")); + } + + /** + * Parse an arrow function — handles both parenthesized params {@code (a, b) => ...} + * and single bare param {@code x => ...}. + */ + private static CallableInfo parseArrowFunctionCallable(String expr, int exprStartAbs, + ExpressionTypeResolverFn typeResolver) { + int arrowIdx = findArrowOperator(expr); + if (arrowIdx < 0) return null; + + String paramPart = expr.substring(0, arrowIdx).trim(); + List params; + if (paramPart.startsWith("(") && paramPart.endsWith(")")) { + // Parenthesized parameter list + params = extractParameterNames(paramPart.substring(1, paramPart.length() - 1)); + } else { + // Single bare parameter (no parens) + params = new ArrayList<>(); + if (isSimpleIdentifier(paramPart)) { + params.add(paramPart); + } + } + + String bodyPart = expr.substring(arrowIdx + 2).trim(); + int bodyOffset = expr.indexOf(bodyPart, arrowIdx + 2); + int bodyStartAbs = exprStartAbs >= 0 ? exprStartAbs + Math.max(bodyOffset, 0) : -1; + // Route both block and expression bodies through the shared inference path + TypeInfo returnType = inferReturnTypeFromBody(bodyPart, 0, bodyStartAbs, typeResolver); + return new CallableInfo(params, returnType, + bodyStartAbs, + bodyStartAbs >= 0 ? bodyStartAbs + bodyPart.length() : -1, + bodyPart.startsWith("{")); + } + + /** + * Find the {@code =>} operator in an arrow function expression, skipping strings and nested parentheses + * to avoid false positives from comparison operators inside nested expressions. + */ + private static int findArrowOperator(String expr) { + boolean inString = false; + char stringChar = 0; + int parenDepth = 0; + + for (int i = 0; i < expr.length() - 1; i++) { + char c = expr.charAt(i); + if (inString) { + if (c == '\\') { i++; continue; } + if (c == stringChar) inString = false; + continue; + } + if (c == '"' || c == '\'') { inString = true; stringChar = c; continue; } + if (c == '(') parenDepth++; + else if (c == ')') parenDepth = Math.max(0, parenDepth - 1); + + if (c == '=' && expr.charAt(i + 1) == '>' && parenDepth == 0) { + return i; + } + } + return -1; + } + + /** Split a comma-separated parameter list into individual names, stripping any leading type annotation. */ + private static List extractParameterNames(String paramList) { + List params = new ArrayList<>(); + if (paramList == null || paramList.trim().isEmpty()) return params; + + for (String part : paramList.split(",")) { + String name = part.trim(); + int spaceIdx = name.indexOf(' '); + if (spaceIdx > 0) name = name.substring(0, spaceIdx); + if (isSimpleIdentifier(name)) { + params.add(name); + } + } + return params; + } + + /** Find the closing {@code )} matching the opening {@code (} at {@code openPos}, respecting strings and nesting. */ + private static int findMatchingParen(String src, int openPos) { + int depth = 0; + boolean inString = false; + char stringChar = 0; + for (int i = openPos; i < src.length(); i++) { + char c = src.charAt(i); + if (inString) { + if (c == '\\') { i++; continue; } + if (c == stringChar) inString = false; + continue; + } + if (c == '"' || c == '\'') { inString = true; stringChar = c; continue; } + if (c == '(') depth++; + else if (c == ')') { depth--; if (depth == 0) return i; } + } + return -1; + } + + /** Infer the return type from the portion of a function expression after the parameter list. */ + private static TypeInfo inferReturnTypeFromBody(String expr, int afterParams, + int exprStartAbs, ExpressionTypeResolverFn typeResolver) { + String rest = expr.substring(afterParams).trim(); + int restOffset = expr.indexOf(rest, afterParams); + int restStartAbs = exprStartAbs >= 0 ? exprStartAbs + restOffset : -1; + if (rest.startsWith("{")) { + return inferReturnTypeFromBlockBody(rest, restStartAbs, typeResolver); + } + return inferReturnTypeFromExpressionBody(rest, restStartAbs, typeResolver); + } + + /** + * Infer a return type from a block body {@code { ... }} by scanning {@code return} statements + * and resolving each expression via the type resolver. Falls back to {@code ANY} if nothing resolves. + */ + private static TypeInfo inferReturnTypeFromBlockBody(String body, int bodyStartAbs, + ExpressionTypeResolverFn typeResolver) { + if (body == null || !body.startsWith("{")) return TypeInfo.ANY; + + int endBrace = findMatchingObjectLiteralEnd(body); + if (endBrace <= 0) return TypeInfo.ANY; + + String inner = body.substring(1, endBrace - 1); + int innerStartAbs = bodyStartAbs >= 0 ? bodyStartAbs + 1 : -1; + + // Scan for 'return ' statements and resolve each one. + int i = 0; + while (i < inner.length()) { + int returnIdx = inner.indexOf("return", i); + if (returnIdx < 0) break; + + // Ensure 'return' is a keyword boundary, not part of a longer identifier. + if (returnIdx > 0 && Character.isJavaIdentifierPart(inner.charAt(returnIdx - 1))) { + i = returnIdx + 6; + continue; + } + int afterReturn = returnIdx + 6; + if (afterReturn >= inner.length()) break; + char afterChar = inner.charAt(afterReturn); + if (!Character.isWhitespace(afterChar) && afterChar != ';') { + i = afterReturn; + continue; + } + + while (afterReturn < inner.length() && Character.isWhitespace(inner.charAt(afterReturn))) { + afterReturn++; + } + + // Scan to end of the return expression (stop at ';' or newline at depth 0). + int exprEnd = afterReturn; + int depth = 0; + while (exprEnd < inner.length()) { + char c = inner.charAt(exprEnd); + if (c == '{' || c == '(' || c == '[') depth++; + else if (c == '}' || c == ')' || c == ']') { if (depth == 0) break; depth--; } + else if ((c == ';' || c == '\n' || c == '\r') && depth == 0) break; + exprEnd++; + } + + String returnExpr = inner.substring(afterReturn, exprEnd).trim(); + if (returnExpr.isEmpty()) { i = exprEnd + 1; continue; } + + if ("this".equals(returnExpr)) return CallableInfo.thisReturnSentinel(); + + // Try full type resolution, then fall back to literal matching. + if (typeResolver != null && innerStartAbs >= 0) { + TypeInfo resolved = typeResolver.resolve(returnExpr, innerStartAbs + afterReturn); + if (resolved != null && resolved.isResolved()) return resolved; + } + TypeInfo literal = resolveLiteralType(returnExpr); + if (literal != TypeInfo.ANY) return literal; + + i = exprEnd + 1; + } + + return TypeInfo.ANY; + } + + /** + * Infer a return type from a concise arrow-function body (expression, not block). + * Delegates to the type resolver first, then falls back to literal pattern matching. + */ + private static TypeInfo inferReturnTypeFromExpressionBody(String bodyExpr, int bodyStartAbs, + ExpressionTypeResolverFn typeResolver) { + if (bodyExpr == null || bodyExpr.isEmpty()) return TypeInfo.ANY; + bodyExpr = bodyExpr.trim(); + + if ("this".equals(bodyExpr)) return CallableInfo.thisReturnSentinel(); + + // Full resolution via ScriptDocument — covers variables, method calls, chains, etc. + if (typeResolver != null && bodyStartAbs >= 0) { + TypeInfo resolved = typeResolver.resolve(bodyExpr, bodyStartAbs); + if (resolved != null && resolved.isResolved()) return resolved; + } + + return resolveLiteralType(bodyExpr); + } + + /** Match simple literal expressions to their TypeInfo without needing a resolver. */ + private static TypeInfo resolveLiteralType(String expr) { + if (expr.startsWith("{") && expr.endsWith("}")) return TypeInfo.ANY; + if (expr.startsWith("\"") && expr.endsWith("\"")) return TypeInfo.string(); + if (expr.startsWith("'") && expr.endsWith("'")) return TypeInfo.fromPrimitive("char"); + if (expr.equals("true") || expr.equals("false")) return TypeInfo.fromPrimitive("boolean"); + if (expr.matches("[-+]?\\d*\\.?\\d+[fFdD]?")) return TypeInfo.NUMBER; + if (expr.contains("+") || expr.contains("-") || expr.contains("*") || expr.contains("/") || expr.contains("%")) return TypeInfo.NUMBER; + return TypeInfo.ANY; + } + + /** + * Register a callable property as both a synthetic field (for field-access resolution) + * and a synthetic method (for call-site resolution) on the receiver's type shape. + */ + private static void extendSyntheticObjectWithMethod(TypeInfo receiver, String name, CallableInfo callable) { + // Build typed parameter list — all params default to ANY since we only have names, not types. + List params = new ArrayList<>(); + for (String paramName : callable.parameterNames) { + params.add(FieldInfo.external(paramName, TypeInfo.ANY, null, java.lang.reflect.Modifier.PUBLIC)); + } + // Use 'receiver' as the return type sentinel when the method returns 'this'. + TypeInfo returnType = callable.returnsThis() ? receiver : (callable.returnType != null ? callable.returnType : TypeInfo.ANY); + receiver.removeSyntheticField(name); + receiver.addSyntheticField(name, TypeInfo.ANY); + receiver.removeSyntheticMethod(name); + receiver.addSyntheticMethod(name, returnType, params); + } + + /** + * Walk backward from the start of an inner callable scope to find the enclosing object literal and + * attach its inferred {@link TypeInfo} as the scope's containing object type (enabling {@code this.} resolution). + * Handles three cases: {@code key: function(...)} (colon), {@code obj = { ... }} (equals), and shorthand methods. + */ + static void attachObjectLiteralContext(InnerCallableScope scope, ScriptDocument doc) { + // Only applicable for JS; skip if already has a containing object type. + if (!doc.isJavaScript() || scope == null || scope.getContainingObjectType() != null) { + return; + } + String text = doc.getText(); + int headerStart = scope.getHeaderStart(); + if (headerStart < 0 || headerStart >= text.length()) { + return; + } + + // Walk backward from the scope header to find a ':' or '=' that indicates object literal context. + int searchPos = headerStart - 1; + while (searchPos >= 0 && Character.isWhitespace(text.charAt(searchPos))) { + searchPos--; + } + if (searchPos < 0) { + return; + } + + // Find the opening '{' of the enclosing object literal by walking backward, respecting nesting and strings. + int braceStart = -1; + if (text.charAt(searchPos) == ':') { + // Case 1: key: function(...) — find the containing {...} + searchPos--; + int depth = 0; + boolean inString = false; + char stringChar = 0; + for (int i = searchPos; i >= 0; i--) { + char c = text.charAt(i); + if (doc.isExcluded(i)) { + continue; + } + if (inString) { + if (c == stringChar && (i == 0 || text.charAt(i - 1) != '\\')) { + inString = false; + } + continue; + } + if (c == '"' || c == '\'') { + inString = true; + stringChar = c; + continue; + } + if (c == '}') { + depth++; + } else if (c == '{') { + if (depth == 0) { + braceStart = i; + break; + } + depth--; + } + } + } else if (text.charAt(searchPos) == '=') { + // Case 2: variable = {...} — find the containing {...} + searchPos--; + while (searchPos >= 0 && Character.isWhitespace(text.charAt(searchPos))) { + searchPos--; + } + int depth = 0; + boolean inString = false; + char stringChar = 0; + for (int i = searchPos; i >= 0; i--) { + char c = text.charAt(i); + if (doc.isExcluded(i)) { + continue; + } + if (inString) { + if (c == stringChar && (i == 0 || text.charAt(i - 1) != '\\')) { + inString = false; + } + continue; + } + if (c == '"' || c == '\'') { + inString = true; + stringChar = c; + continue; + } + if (c == '}') { + depth++; + } else if (c == '{') { + if (depth == 0) { + braceStart = i; + break; + } + depth--; + } + } + } else if (scope.getKind() == InnerCallableScope.Kind.JS_SHORTHAND_METHOD) { + // Case 3: Shorthand method inside {...} — find the containing {...} + int depth = 0; + boolean inString = false; + char stringChar = 0; + for (int i = searchPos; i >= 0; i--) { + char c = text.charAt(i); + if (doc.isExcluded(i)) { + continue; + } + if (inString) { + if (c == stringChar && (i == 0 || text.charAt(i - 1) != '\\')) { + inString = false; + } + continue; + } + if (c == '"' || c == '\'') { + inString = true; + stringChar = c; + continue; + } + if (c == '}') { + depth++; + } else if (c == '{') { + if (depth == 0) { + braceStart = i; + break; + } + depth--; + } + } + } + + if (braceStart < 0) { + return; + } + + ObjectLiteralAnalysis analysis = doc.getObjectLiteral(braceStart); + if (analysis != null && analysis.inferredType != null) { + scope.setContainingObjectType(analysis.inferredType); + } + } + + + /** + * Infer the TypeInfo for a single value expression inside an object literal. + * Nested object literals are recursively parsed; arrays and other complex expressions fall back to {@code ANY}. + */ + private static TypeInfo inferValueType(String valueExpr, int valueStartAbs, ExpressionTypeResolverFn typeResolver) { + if (valueExpr == null || valueExpr.isEmpty()) { + return TypeInfo.ANY; + } + + char first = valueExpr.charAt(0); + if (first == '{') { + ObjectLiteralAnalysis nested = parse(valueExpr, valueStartAbs, true, false, typeResolver,null); + if (nested != null && nested.supportsInference && nested.inferredType != null) { + return nested.inferredType; + } + return TypeInfo.ANY; + } + + TypeInfo inferred = typeResolver.resolve(valueExpr, valueStartAbs); + return (inferred != null) ? inferred : TypeInfo.ANY; + } + + // ────────────────────────────────────────────────────────────────────────── + // Scanning / parsing utilities (package-private static, used by analyzer) + // ────────────────────────────────────────────────────────────────────────── + + /** + * Scan to the end of a string literal starting at {@code start}. + * + *

Handles backslash escapes. The returned index points one past the closing quote character.

+ * + * @param src the source text + * @param start index of the opening quote character + * @return index one past the closing quote, or {@code -1} if the string is unterminated + */ + static int scanStringLiteralEnd(String src, int start) { + if (start < 0 || start >= src.length()) { + return -1; + } + char quote = src.charAt(start); + int i = start + 1; + while (i < src.length()) { + char c = src.charAt(i); + if (c == '\\') { + i += (i + 1 < src.length()) ? 2 : 1; + continue; + } + if (c == quote) { + return i + 1; + } + i++; + } + return -1; + } + + /** + * Check whether a string is a valid simple identifier (Java identifier rules). + * + * @param s the string to check + * @return {@code true} if {@code s} is non-empty and consists of valid Java identifier characters + */ + static boolean isSimpleIdentifier(String s) { + if (s == null || s.isEmpty()) { + return false; + } + if (!Character.isJavaIdentifierStart(s.charAt(0))) { + return false; + } + for (int i = 1; i < s.length(); i++) { + if (!Character.isJavaIdentifierPart(s.charAt(i))) { + return false; + } + } + return true; + } + + /** + * Scan forward to find the end of a top-level value expression within an object literal. + * + *

Respects nested braces, brackets, parentheses, string literals, and comments. + * Stops at a top-level comma or the {@code endLimit}.

+ * + * @param src the source text + * @param start where to start scanning + * @param endLimit the exclusive boundary (typically the position of the closing brace) + * @return the index where the value expression ends (at a comma or {@code endLimit}) + */ + static int scanTopLevelValueEnd(String src, int start, int endLimit) { + int parenDepth = 0; + int bracketDepth = 0; + int braceDepth = 0; + + boolean inString = false; + char stringChar = 0; + boolean inLineComment = false; + boolean inBlockComment = false; + + int i = start; + while (i < endLimit) { + char c = src.charAt(i); + char next = (i + 1 < endLimit) ? src.charAt(i + 1) : 0; + + if (inLineComment) { + if (c == '\n' || c == '\r') { + inLineComment = false; + } + i++; + continue; + } + + if (inBlockComment) { + if (c == '*' && next == '/') { + inBlockComment = false; + i += 2; + continue; + } + i++; + continue; + } + + if (inString) { + if (c == '\\') { + i += (i + 1 < endLimit) ? 2 : 1; + continue; + } + if (c == stringChar) { + inString = false; + } + i++; + continue; + } + + if (c == '/' && next == '/') { + inLineComment = true; + i += 2; + continue; + } + if (c == '/' && next == '*') { + inBlockComment = true; + i += 2; + continue; + } + + if (c == '"' || c == '\'') { + inString = true; + stringChar = c; + i++; + continue; + } + + if (c == '(') parenDepth++; + else if (c == ')') parenDepth = Math.max(0, parenDepth - 1); + else if (c == '[') bracketDepth++; + else if (c == ']') bracketDepth = Math.max(0, bracketDepth - 1); + else if (c == '{') braceDepth++; + else if (c == '}') braceDepth = Math.max(0, braceDepth - 1); + + if (c == ',' && parenDepth == 0 && bracketDepth == 0 && braceDepth == 0) { + return i; + } + + i++; + } + + return endLimit; + } + + /** Advance past whitespace, commas, and line/block comments between object literal properties. */ + private static int skipSeparatorsAndComments(String src, int start, int endLimit) { + int i = start; + while (i < endLimit) { + char c = src.charAt(i); + char next = (i + 1 < endLimit) ? src.charAt(i + 1) : 0; + if (Character.isWhitespace(c) || c == ',') { + i++; + continue; + } + if (c == '/' && next == '/') { + i += 2; + while (i < endLimit) { + char line = src.charAt(i); + if (line == '\n' || line == '\r') { + break; + } + i++; + } + continue; + } + if (c == '/' && next == '*') { + i += 2; + while (i + 1 < endLimit) { + if (src.charAt(i) == '*' && src.charAt(i + 1) == '/') { + i += 2; + break; + } + i++; + } + continue; + } + break; + } + return i; + } + + /** + * Determine whether the document position is inside an object literal by counting unmatched braces + * and verifying that the nearest enclosing {@code {} is preceded by {@code =}, {@code :}, {@code (}, etc. + */ + static boolean isInsideObjectLiteral(int position, ScriptDocument doc) { + // First pass: count unmatched braces forward to position to check if we're in a brace context. + int braceDepth = 0; + boolean inString = false; + char stringChar = 0; + String text = doc.getText(); + for (int i = 0; i < position && i < text.length(); i++) { + if (doc.isExcluded(i)) { + continue; + } + char c = text.charAt(i); + if (inString) { + if (c == '\\') { i++; continue; } + if (c == stringChar) inString = false; + continue; + } + if (c == '"' || c == '\'') { inString = true; stringChar = c; continue; } + if (c == '{') braceDepth++; + else if (c == '}') braceDepth = Math.max(0, braceDepth - 1); + } + // Not inside any braces at all. + if (braceDepth <= 0) return false; + + // Second pass: walk backward to find the matching '{' for our position. + int braceStart = -1; + int depth = 0; + inString = false; + stringChar = 0; + for (int i = position - 1; i >= 0; i--) { + char c = text.charAt(i); + if (doc.isExcluded(i)) { + continue; + } + if (inString) { + if (c == stringChar && (i == 0 || text.charAt(i - 1) != '\\')) { + inString = false; + } + continue; + } + if (c == '"' || c == '\'') { + inString = true; + stringChar = c; + continue; + } + if (c == '}') { + depth++; + } else if (c == '{') { + if (depth == 0) { + braceStart = i; + break; + } + depth--; + } + } + if (braceStart < 0) { + return false; + } + + // Third pass: check if the '{' is preceded by a literal indicator (=, :, (, [, comma, or nested {). + for (int i = braceStart - 1; i >= 0; i--) { + char c = text.charAt(i); + if (doc.isExcluded(i) || Character.isWhitespace(c)) { + continue; + } + return c == '=' || c == ':' || c == '(' || c == '[' || c == ',' || c == '{'; + } + return true; + } + + /** + * Scan forward to find the next top-level comma (skipping nested structures and strings). + * + *

Used to skip over unsupported property entries (computed keys, spread, etc.) + * and advance to the next property in the object literal.

+ * + * @param src the source text + * @param start where to start scanning + * @param endLimit the exclusive boundary + * @return the index just past the comma, or {@code endLimit} if no comma is found + */ + static int scanToNextTopLevelComma(String src, int start, int endLimit) { + int i = start; + int depth = 0; + boolean inString = false; + char stringChar = 0; + while (i < endLimit) { + char c = src.charAt(i); + if (inString) { + if (c == '\\') { + i += (i + 1 < endLimit) ? 2 : 1; + continue; + } + if (c == stringChar) { + inString = false; + } + i++; + continue; + } + if (c == '"' || c == '\'') { + inString = true; + stringChar = c; + i++; + continue; + } + if (c == '{' || c == '[' || c == '(') depth++; + else if (c == '}' || c == ']' || c == ')') depth = Math.max(0, depth - 1); + if (c == ',' && depth == 0) { + return i + 1; + } + i++; + } + return endLimit; + } + + /** + * Find the matching closing brace for an object literal within a standalone string. + * + *

Unlike {@code ScriptDocument.findMatchingBraceEndInDocument} which operates on the full + * document text with excluded-range awareness, this method works on an isolated string snippet + * and handles comments/strings inline.

+ * + * @param src the source text starting with '{' (or containing it) + * @return the index one past the matching '}', or {@code -1} if not found + */ + static int findMatchingObjectLiteralEnd(String src) { + int depth = 0; + boolean inString = false; + char stringChar = 0; + boolean inLineComment = false; + boolean inBlockComment = false; + + for (int i = 0; i < src.length(); i++) { + char c = src.charAt(i); + char next = (i + 1 < src.length()) ? src.charAt(i + 1) : 0; + + if (inLineComment) { + if (c == '\n' || c == '\r') { + inLineComment = false; + } + continue; + } + if (inBlockComment) { + if (c == '*' && next == '/') { + inBlockComment = false; + i++; + } + continue; + } + if (inString) { + if (c == '\\') { + i += (i + 1 < src.length()) ? 1 : 0; + continue; + } + if (c == stringChar) { + inString = false; + } + continue; + } + + if (c == '/' && next == '/') { + inLineComment = true; + i++; + continue; + } + if (c == '/' && next == '*') { + inBlockComment = true; + i++; + continue; + } + if (c == '"' || c == '\'') { + inString = true; + stringChar = c; + continue; + } + + if (c == '{') { + depth++; + } else if (c == '}') { + depth--; + if (depth == 0) { + return i + 1; + } + } + } + + return -1; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptDocument.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptDocument.java new file mode 100644 index 000000000..de3e56d5e --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptDocument.java @@ -0,0 +1,9650 @@ +package noppes.npcs.client.gui.util.script.interpreter; + +import noppes.npcs.client.ClientProxy; +import noppes.npcs.client.gui.util.script.interpreter.expression.CastExpressionResolver; +import noppes.npcs.client.gui.util.script.interpreter.expression.ExpressionNode; +import noppes.npcs.client.gui.util.script.interpreter.expression.ExpressionTypeResolver; +import noppes.npcs.client.gui.util.script.interpreter.field.AssignmentInfo; +import noppes.npcs.client.gui.util.script.interpreter.field.EnumConstantInfo; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldAccessInfo; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSScriptAnalyzer; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSMethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeRegistry; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocInfo; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocParamTag; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocParser; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodCallInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodSignature; +import noppes.npcs.client.gui.util.script.interpreter.token.Token; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenErrorMessage; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenType; +import noppes.npcs.client.gui.util.script.interpreter.type.*; +import noppes.npcs.client.gui.util.script.interpreter.type.synthetic.SyntheticField; +import noppes.npcs.client.gui.util.script.interpreter.type.synthetic.SyntheticMethod; +import noppes.npcs.client.gui.util.script.interpreter.type.synthetic.SyntheticType; +import noppes.npcs.client.gui.util.script.ScopeInfo; +import noppes.npcs.constants.ScriptContext; +import noppes.npcs.controllers.data.DataScript; +import noppes.npcs.controllers.ScriptHookController; + +import java.util.*; +import java.util.function.Function; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.stream.Collectors; + +/** + * The main document container that manages script text, lines, and tokens. + * This is the clean reimplementation of JavaTextContainer. + * + * Architecture: + * - ScriptDocument holds the complete source text and global state + * - ScriptLine holds individual lines with their tokens + * - Token holds individual syntax elements with type-specific metadata + * - TypeResolver handles all class/type resolution + * + * Single-pass tokenization: + * 1. Parse excluded regions (comments, strings) + * 2. Parse imports and resolve types + * 3. Parse structure (methods, classes, fields) + * 4. Tokenize with all context available + */ +public class ScriptDocument { + + public static ScriptDocument INSTANCE = null; // For easy access in expressions + // ==================== PATTERNS ==================== + + private static final Pattern WORD_PATTERN = Pattern.compile("[\\p{L}\\p{N}_-]+|\\n|$"); + + // Literals + private static final Pattern STRING_PATTERN = Pattern.compile("([\"'])(?:(?=(\\\\?))\\2.)*?\\1"); + private static final Pattern COMMENT_PATTERN = Pattern.compile("/\\*[\\s\\S]*?(?:\\*/|$)|//.*|#.*"); + private static final Pattern NUMBER_PATTERN = Pattern.compile( + "\\b-?(?:0[xX][\\dA-Fa-f]+|0[bB][01]+|0[oO][0-7]+|\\d*\\.?\\d+(?:[Ee][+-]?\\d+)?(?:[fFbBdDlLsS])?|NaN|null|Infinity|true|false)\\b"); + + // Keywords + private static final Pattern MODIFIER_PATTERN = Pattern.compile( + "\\b(public|protected|private|static|final|abstract|synchronized|native|default)\\b"); + private static final Pattern KEYWORD_PATTERN = Pattern.compile( + "\\b(null|boolean|int|float|double|long|char|byte|short|void|if|else|switch|case|for|while|do|try|catch|finally|return|throw|var|let|const|function|continue|break|this|super|new|typeof|instanceof|import)\\b"); + + private static final Pattern KEYWORD_JS_PATTERN = Pattern.compile( + "\\b(function|var|let|const|if|else|for|while|do|switch|case|break|continue|return|" + + "try|catch|finally|throw|delete|new|typeof|instanceof|in|of|this|null|undefined|true|false|" + + "class|extends|import|export|default|async|await|yield)\\b"); + + // Declarations - Updated to capture method parameters + private static final Pattern IMPORT_PATTERN = Pattern.compile( + "(?m)\\bimport\\s+(?:static\\s+)?([A-Za-z_][A-Za-z0-9_]*(?:\\s*\\.\\s*[A-Za-z_][A-Za-z0-9_]*)*)(?:\\s*\\.\\s*\\*?)?\\s*(?:;|$)"); + private static final Pattern CLASS_DECL_PATTERN = Pattern.compile( + "\\b(class|interface|enum)\\s+([A-Za-z_][a-zA-Z0-9_]*)"); + private static final Pattern METHOD_DECL_PATTERN = Pattern.compile( + "\\b([A-Za-z_][a-zA-Z0-9_<>\\[\\]]*)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\("); + private static final Pattern METHOD_CALL_PATTERN = Pattern.compile( + "([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\("); + // Also matches ',' as a delimiter so that "int x, y, z;" is recognized + // (the first declarator "int x," is captured; continuations are scanned manually). + private static final Pattern FIELD_DECL_PATTERN = Pattern.compile( + "\\b([A-Za-z_][a-zA-Z0-9_.<>,[ \\t]\\[\\]]*)[ \\t]+([a-zA-Z_][a-zA-Z0-9_]*)[ \\t]*(=|;|,)"); + private static final Pattern NEW_TYPE_PATTERN = Pattern.compile("\\bnew\\s+([A-Za-z_][a-zA-Z0-9_]*)"); + + // Cast expression pattern: captures type name inside cast parentheses + // Matches: (Type), (Type[]), (pkg.Type), (Type) + private static final Pattern CAST_TYPE_PATTERN = Pattern.compile( + "\\(\\s*([A-Za-z_][a-zA-Z0-9_]*(?:\\s*\\.\\s*[A-Za-z_][a-zA-Z0-9_]*)*)\\s*(?:<[^>]*>)?\\s*(\\[\\s*\\])*\\s*\\)\\s*(?=[a-zA-Z_\"'(\\d!~+-])"); + + // Function parameters (for JS-style scripts) + private static final Pattern FUNC_PARAMS_PATTERN = Pattern.compile( + "\\bfunction\\s+[a-zA-Z_][a-zA-Z0-9_]*\\s*\\(([^)]*)\\)"); + + // ==================== STATE ==================== + + private String text = ""; + private final List lines = new ArrayList<>(); + + private final List imports = new ArrayList<>(); + private final Set wildcardPackages = new HashSet<>(); + private Map importsBySimpleName = new HashMap<>(); + + // Script-defined types (classes, interfaces, enums defined in the script) + // PRIMARY: simple name → ScriptTypeInfo (backward-compatible, top-level only) + private final Map scriptTypes = new HashMap<>(); + // SECONDARY: dollar-separated full name → ScriptTypeInfo (all types including nested) + // Enables O(1) lookup by qualified name for any nesting depth (e.g., "Outer$Middle$Inner") + private final Map scriptTypesByFullName = new HashMap<>(); + // TERTIARY: dot-separated display name → ScriptTypeInfo (for resolveType("Outer.Inner")) + // Populated alongside scriptTypesByFullName during parsing; matches user-written syntax + private final Map scriptTypesByDotName = new HashMap<>(); + + private final List methods = new ArrayList<>(); + private final Map globalFields = new HashMap<>(); + // Local variables per method (methodStartOffset -> {varName -> FieldInfo}) + private final Map>> methodLocals = new HashMap<>(); + // Top-level variables (outside methods) - for JavaScript, these can be treated as globals, but we keep them separate for clarity + // Mainly top level loops like for (var x : collection) { } where x is a local variable but not inside a method + private final Map> topLevelLocals = new HashMap<>(); + + // Inner callable scopes (lambdas, JS function expressions) - NOT in methods list + private final List innerScopes = new ArrayList<>(); + + // Method calls - stores all parsed method call information + private final List methodCalls = new ArrayList<>(); + // Field accesses - stores all parsed field access information + private final List fieldAccesses = new ArrayList<>(); + // Assignments to external fields (fields from reflection, not script-defined) + private final List externalFieldAssignments = new ArrayList<>(); + + // Declaration errors (duplicate declarations, etc.) + private final List declarationErrors = new ArrayList<>(); + + // Excluded regions (strings/comments) - positions where other patterns shouldn't match + private final List excludedRanges = new ArrayList<>(); + + // SAM context tracking for named function references + // Maps method name -> first SAM signature applied (for conflict detection) + private final Map scriptMethodSamContexts = new HashMap<>(); + + // Cached object literal analyses, keyed by brace-start offset in text. + // Populated once in parseObjectLiterals() and consumed by markObjectLiteralKeys, + // resolveExpressionType, and attachObjectLiteralContext. + private final Map objectLiterals = new HashMap<>(); + + // Thread-local to communicate SAM conflict errors from resolveIdentifier back to parseMethodArguments + // Set when injectSamParameterTypes detects a conflict, cleared after argument is created + private static final ThreadLocal CURRENT_SAM_CONFLICT_ERROR = new ThreadLocal<>(); + + // Type resolver + private final TypeResolver typeResolver; + + // JSDoc parser for extracting type information from JSDoc comments + private final JSDocParser jsDocParser = new JSDocParser(this); + + // Script language: "ECMAScript", "Groovy", etc. + private String language = "ECMAScript"; + + // Script context: NPC, PLAYER, BLOCK, ITEM, etc. + // Determines which hooks and event types are available + private ScriptContext scriptContext = ScriptContext.GLOBAL; + + // Editor-injected globals (name -> type name) provided by the handler + private Map editorGlobals = Collections.emptyMap(); + + // Implicit imports from JaninoScript default imports and hook parameter types + // These are types that should be resolved even without explicit import statements + private final Set implicitImports = new HashSet<>(); + + // Layout properties + public int lineHeight = 13; + public int totalHeight; + public int visibleLines = 1; + public int linesCount; + + // ==================== CONSTRUCTOR ==================== + + public ScriptDocument(String text) { + this.typeResolver = TypeResolver.getInstance(); + setText(text); + } + + public ScriptDocument(String text, TypeResolver resolver) { + this.typeResolver = resolver != null ? resolver : TypeResolver.getInstance(); + setText(text); + } + + public ScriptDocument(String text, String language) { + this.typeResolver = TypeResolver.getInstance(); + this.language = language != null ? language : "ECMAScript"; + setText(text); + } + + /** + * Set the scripting language. + */ + public void setLanguage(String language) { + this.language = language != null ? language : "ECMAScript"; + } + + /** + * Get the scripting language. + */ + public String getLanguage() { + return language; + } + + /** + * Check if this is a JavaScript/ECMAScript document. + */ + public boolean isJavaScript() { + return "ECMAScript".equalsIgnoreCase(language); + } + + /** + * Set the script context (NPC, PLAYER, BLOCK, ITEM, etc.). + * This determines which hooks and event types are available for autocomplete. + * + * @param context The script context + */ + public void setScriptContext(ScriptContext context) { + this.scriptContext = context != null ? context : ScriptContext.GLOBAL; + } + + /** + * Get the current script context. + * + * @return The script context (NPC, PLAYER, BLOCK, ITEM, etc.) + */ + public ScriptContext getScriptContext() { + return scriptContext; + } + + /** + * Set editor-injected globals (name -> type name). + * i.e. DataScript global definitions {@link DataScript#getEditorGlobals(String)} + * This is provided by the script handler at editor init time. + */ + public void setEditorGlobals(Map globals) { + if (globals == null || globals.isEmpty()) { + this.editorGlobals = Collections.emptyMap(); + return; + } + this.editorGlobals = new LinkedHashMap<>(globals); + } + + /** + * Get editor-injected globals (name -> type name). + */ + public Map getEditorGlobals() { + return Collections.unmodifiableMap(editorGlobals); + } + + /** + * Add implicit imports that should be resolved without explicit import statements. + * Used for JaninoScript default imports and hook parameter types. + * + * Patterns can be: + * - Wildcard: "noppes.npcs.api.*" (imports all classes from package) + * - Specific class: "noppes.npcs.api.event.INpcEvent$InitEvent" (nested class) + * - Regular class: "noppes.npcs.api.entity.IEntity" + * + * @param patterns Array of import patterns to add (packages with .* or fully qualified class names) + */ + public void addImplicitImports(String... patterns) { + if (patterns != null) { + for (String pattern : patterns) { + if (pattern != null && !pattern.isEmpty()) { + this.implicitImports.add(pattern); + } + } + } + } + + // ==================== TEXT MANAGEMENT ==================== + + public void setText(String text) { + this.text = text != null ? text.replaceAll("\\r?\\n|\\r", "\n") : ""; + } + + public String getText() { + return text; + } + + // ==================== INITIALIZATION ==================== + + /** + * Initialize the document with layout constraints. + * Builds lines based on width wrapping. + */ + public void init(int width, int height) { + lines.clear(); + lineHeight = ClientProxy.Font.height(); + if (lineHeight == 0) + lineHeight = 12; + + String[] sourceLines = text.split("\n", -1); + int totalChars = 0; + int lineIndex = 0; + + for (String sourceLine : sourceLines) { + StringBuilder currentLine = new StringBuilder(); + Matcher m = WORD_PATTERN.matcher(sourceLine); + int i = 0; + + while (m.find()) { + String word = sourceLine.substring(i, m.start()); + if (ClientProxy.Font.width(currentLine + word) > width - 10) { + // Wrap line + int lineStart = totalChars; + int lineEnd = totalChars + currentLine.length(); + lines.add(new ScriptLine(currentLine.toString(), lineStart, lineEnd, lineIndex++)); + totalChars = lineEnd; + currentLine = new StringBuilder(); + } + currentLine.append(word); + i = m.start(); + } + + // Add final line segment (including newline character in range) + int lineStart = totalChars; + int lineEnd = totalChars + currentLine.length() + 1; + lines.add(new ScriptLine(currentLine.toString(), lineStart, lineEnd, lineIndex++)); + totalChars = lineEnd; + } + + // Set up line navigation + for (int li = 0; li < lines.size(); li++) { + ScriptLine line = lines.get(li); + line.setParent(this); + if (li > 0) { + line.setPrev(lines.get(li - 1)); + lines.get(li - 1).setNext(line); + } + } + + linesCount = lines.size(); + totalHeight = linesCount * lineHeight; + visibleLines = Math.max(height / lineHeight - 1, 1); + INSTANCE = this; + } + + // ==================== TOKENIZATION ==================== + + /** + * Main tokenization entry point. + * Performs complete analysis and builds tokens for all lines. + * Uses the SAME unified pipeline for both Java and JavaScript. + * + * All data structures (methods, globalFields, methodLocals, methodCalls, + * fieldAccesses, etc.) are shared between languages. + */ + public void formatCodeText() { + // Clear previous state (same for both languages) + imports.clear(); + methods.clear(); + globalFields.clear(); + wildcardPackages.clear(); + excludedRanges.clear(); + methodLocals.clear(); + topLevelLocals.clear(); + scriptTypes.clear(); + scriptTypesByFullName.clear(); + scriptTypesByDotName.clear(); + innerScopes.clear(); + methodCalls.clear(); + externalFieldAssignments.clear(); + declarationErrors.clear(); + scriptMethodSamContexts.clear(); + objectLiterals.clear(); + + // Unified pipeline for both languages + List marks = formatUnified(); + + // Phase 5: Resolve conflicts and sort + marks = resolveConflicts(marks); + + // Phase 6: Build tokens for each line + for (ScriptLine line : lines) { + line.buildTokensFromMarks(marks, text, this); + } + + // Phase 6.5: Now that tokens are built, remove implicit imports that aren't actually used + removeUnusedImplicitImports(); + + // Phase 7: Compute indent guides + computeIndentGuides(marks); + } + + // Store the last JS analyzer for autocomplete (deprecated - use methods/globalFields/methodLocals instead) + @Deprecated + private JSScriptAnalyzer currentJSAnalyzer; + + /** + * @deprecated Use the unified pipeline. Access methods/globalFields/methodLocals directly. + */ + @Deprecated + public JSScriptAnalyzer getJSAnalyzer() { + return currentJSAnalyzer; + } + + /** + * Unified format method - single pipeline for both Java and JavaScript. + * ALL methods called here handle BOTH languages using the SAME data structures. + */ + private List formatUnified() { + TypeChecker.enterTypeCheckingContext(isJavaScript()); + + // Phase 1: Find excluded regions (strings/comments) - same for both + findExcludedRanges(); + + // Phase 2: Parse imports (Java only, JS skips this) + parseImports(); + + // Phase 3: Parse structure (methods, fields, locals) - language aware + parseStructure(); + + // Phase 4: Build marks - language aware + return buildMarks(); + } + + /** + * @deprecated Use formatUnified() instead. Kept for compatibility. + */ + @Deprecated + private List formatJavaScript() { + // Delegate to unified pipeline + currentJSAnalyzer = new JSScriptAnalyzer(this); + return currentJSAnalyzer.analyze(); + } + + /** + * @deprecated Use formatUnified() instead. Kept for compatibility. + */ + @Deprecated + private List formatJava() { + return formatUnified(); + } + + // ==================== PHASE 1: EXCLUDED RANGES ==================== + + private void findExcludedRanges() { + // Find strings + Matcher m = STRING_PATTERN.matcher(text); + while (m.find()) { + excludedRanges.add(new int[]{m.start(), m.end()}); + } + + // Find comments + m = COMMENT_PATTERN.matcher(text); + while (m.find()) { + excludedRanges.add(new int[]{m.start(), m.end()}); + } + + // Sort and merge overlapping ranges + excludedRanges.sort(Comparator.comparingInt(a -> a[0])); + mergeOverlappingRanges(); + } + + private void mergeOverlappingRanges() { + if (excludedRanges.size() < 2) + return; + + List merged = new ArrayList<>(); + int[] current = excludedRanges.get(0); + + for (int i = 1; i < excludedRanges.size(); i++) { + int[] next = excludedRanges.get(i); + if (next[0] <= current[1]) { + current[1] = Math.max(current[1], next[1]); + } else { + merged.add(current); + current = next; + } + } + merged.add(current); + + excludedRanges.clear(); + excludedRanges.addAll(merged); + } + + + public boolean isExcluded(int position) { + for (int[] range : excludedRanges) { + if (position >= range[0] && position < range[1]) { + return true; + } + } + return false; + } + + /** + * Like isExcluded but uses inclusive end bound (position <= range end). + * Used by auto-pair logic where the cursor sits right at a string boundary. + */ + public boolean isExcludedInclusive(int position) { + for (int[] range : excludedRanges) { + if (position >= range[0] && position <= range[1]) { + return true; + } + } + return false; + } + + /** + * Check if a position falls inside one of the type's inner class bodies. + * Used to prevent field/constructor declarations inside inner classes + * from being misattributed to the outer class during member parsing. + */ + private boolean isInsideNestedType(int position, ScriptTypeInfo type) { + for (ScriptTypeInfo inner : type.getInnerClasses()) { + if (inner.containsPosition(position)) { + return true; + } + } + return false; + } + + /** + * Get the list of excluded ranges (comments, strings, etc.). + * Used by AutocompleteManager to skip over excluded regions. + * @return List of [start, end) ranges to exclude + */ + public List getExcludedRanges() { + return excludedRanges; + } + + /** + * Check if a position is within a comment range (not string). + * Used to skip comment text when scanning for identifiers. + */ + private boolean isInCommentRange(int position) { + // Check if position is in a comment by checking against COMMENT_PATTERN + Matcher m = COMMENT_PATTERN.matcher(text); + while (m.find()) { + if (position >= m.start() && position < m.end()) { + return true; + } + } + return false; + } + + // ==================== PHASE 2: IMPORTS ==================== + + private void parseImports() { + // JavaScript doesn't use Java-style imports + if (isJavaScript()) { + return; + } + + Matcher m = IMPORT_PATTERN.matcher(text); + while (m.find()) { + if (isExcluded(m.start())) + continue; + + String fullPath = m.group(1).replaceAll("\\s+", "").trim(); + String matchText = m.group(0); + boolean isWildcard = matchText.contains("*"); + boolean isStatic = matchText.contains("static"); + + // Skip if path ends with dot (incomplete import) + if (fullPath.endsWith(".")) { + // continue; + } + + int lastDot = fullPath.lastIndexOf('.'); + String simpleName = isWildcard ? null : (lastDot >= 0 ? fullPath.substring(lastDot + 1) : fullPath); + + ImportData importData = new ImportData( + fullPath, simpleName, isWildcard, isStatic, + m.start(), m.end(), m.start(1), m.end(1) + ); + imports.add(importData); + + if (isWildcard) { + wildcardPackages.add(fullPath); + } + } + + // Add ALL implicit imports initially so tokens can be built with proper type resolution + addAllImplicitImportsToList(); + + // Resolve all imports (including all implicit ones) + importsBySimpleName = typeResolver.resolveImports(imports); + } + + /** + * Add ALL implicit imports to the imports list initially. + * This allows tokens to be built with proper type resolution. + * After tokenization, we'll remove the unused ones. + */ + private void addAllImplicitImportsToList() { + for (String pattern : implicitImports) { + if (pattern == null || pattern.isEmpty()) continue; + + boolean isWildcard = pattern.endsWith(".*"); + String fullPath; + String simpleName; + + if (isWildcard) { + fullPath = pattern.substring(0, pattern.length() - 2); // Remove ".*" + simpleName = null; + wildcardPackages.add(fullPath); + } else { + fullPath = pattern.replace('$', '.'); + int lastDot = fullPath.lastIndexOf('.'); + simpleName = lastDot >= 0 ? fullPath.substring(lastDot + 1) : fullPath; + } + + ImportData importData = new ImportData( + fullPath, simpleName, isWildcard, false, + -1, -1, -1, -1 + ); + + if (!imports.contains(importData)) { + imports.add(importData); + } + } + } + + /** + * Remove implicit imports that aren't actually used in the text. + * This keeps autocomplete clean by not showing types from hooks that aren't present. + * Called after tokenization is complete. + */ + private void removeUnusedImplicitImports() { + // Collect imports to remove (can't remove during iteration) + List toRemove = new ArrayList<>(); + + for (ImportData imp : imports) { + // Only check implicit imports (those with offset -1) + if (imp.getStartOffset() != -1) continue; + + // Skip wildcard imports - keep them all + if (imp.isWildcard()) continue; + + // Check if this specific class import is actually used + String simpleName = imp.getSimpleName(); + String fullPath = imp.getFullPath(); + + if (!isTypeReferenced(simpleName, fullPath)) { + toRemove.add(imp); + } + } + + // Remove unused implicit imports + imports.removeAll(toRemove); + + // Re-resolve imports after removing unused ones + importsBySimpleName = typeResolver.resolveImports(imports); + } + + /** + * Check if a type is referenced anywhere in the script tokens. + * Looks for the simple name or any part of the fully qualified name. + */ + private boolean isTypeReferenced(String simpleName, String fullPath) { + if (simpleName == null || simpleName.isEmpty()) return false; + + // Check all lines and their tokens + for (ScriptLine line : lines) { + for (Token token : line.getTokens()) { + String tokenText = token.getText(); + + // Check if token matches the simple name + if (tokenText.equals(simpleName)) { + return true; + } + + // Check if token contains nested class reference (e.g., "InitEvent" in "INpcEvent.InitEvent") + if (fullPath.contains("$") && tokenText.equals(simpleName)) { + return true; + } + + // Check for partial matches in qualified references + if (fullPath.contains(".") && tokenText.contains(".")) { + // e.g., "INpcEvent.InitEvent" matches "noppes.npcs.api.event.INpcEvent$InitEvent" + String[] pathParts = fullPath.replace('$', '.').split("\\."); + String[] tokenParts = tokenText.split("\\."); + + // Check if the last parts match (e.g., "InitEvent") + if (pathParts.length > 0 && tokenParts.length > 0) { + String lastPathPart = pathParts[pathParts.length - 1]; + String lastTokenPart = tokenParts[tokenParts.length - 1]; + if (lastTokenPart.equals(lastPathPart)) { + return true; + } + } + } + } + } + + return false; + } + + + // ==================== PHASE 3: STRUCTURE ==================== + + /** + * Parse the script structure - methods, fields, variables. + * Uses the SAME logic and data structures for both Java and JavaScript. + */ + private void parseStructure() { + // Clear import references before re-parsing + for (ImportData imp : imports) { + imp.clearReferences(); + } + + // Parse script-defined types (classes, interfaces, enums) - Java only + if (!isJavaScript()) { + parseScriptTypes(); + } + + // Parse methods/functions - UNIFIED for both languages + parseMethodDeclarations(); + + // Parse inner callable scopes (lambdas, JS function expressions) + parseInnerCallableScopes(); + + // Parse local variables inside methods/functions - UNIFIED for both languages + parseLocalVariables(); + + // Parse global fields (outside methods) - UNIFIED for both languages + parseGlobalFields(); + + // Parse and validate assignments (reassignments) - UNIFIED for both languages + parseAssignments(); + + // Cache object literals after globals/locals are available for accurate value-type inference + parseObjectLiterals(); + + // Detect method overrides and interface implementations for script types - Java only + if (!isJavaScript()) { + detectMethodInheritance(); + } + } + + /** + * Intermediate record for type declarations discovered in Pass 1 of parseScriptTypes(). + * Holds raw data before hierarchy relationships are established in Pass 2. + */ + private static class RawTypeDeclaration { + final String name; + final TypeInfo.Kind kind; + final int declOffset; + final int bodyStart; + final int bodyEnd; + final int modifiers; + final String extendsClause; + final String implementsClause; + final JSDocInfo jsDoc; + + RawTypeDeclaration(String name, TypeInfo.Kind kind, int declOffset, int bodyStart, int bodyEnd, + int modifiers, String extendsClause, String implementsClause, JSDocInfo jsDoc) { + this.name = name; + this.kind = kind; + this.declOffset = declOffset; + this.bodyStart = bodyStart; + this.bodyEnd = bodyEnd; + this.modifiers = modifiers; + this.extendsClause = extendsClause; + this.implementsClause = implementsClause; + this.jsDoc = jsDoc; + } + } + + /** + * Parse class, interface, and enum declarations using a two-pass strategy. + * + * Pass 1: Regex scan discovers all type declarations with their body spans. + * Pass 2: Sort by bodyStart, then use a stack to determine parent-child nesting. + * The stack invariant is: top = innermost enclosing type for the current position. + * This correctly handles arbitrary nesting depth in O(n) time. + */ + private void parseScriptTypes() { + // ========== PASS 1: Discover all type declarations (flat list) ========== + Pattern typeDecl = Pattern.compile( + "(?:(?:public|private|protected|static|final|abstract)\\s+)*(class|interface|enum)\\s+([A-Za-z_][a-zA-Z0-9_]*)\\s*(?:\\(\\))?\\s*(?:extends\\s+([A-Za-z_][a-zA-Z0-9_.]*))?\\s*(?:implements\\s+([A-Za-z_][a-zA-Z0-9_.,\\s]*))?\\s*\\{"); + + List rawDeclarations = new ArrayList<>(); + Matcher m = typeDecl.matcher(text); + while (m.find()) { + if (isExcluded(m.start())) + continue; + + String kindStr = m.group(1); + String typeName = m.group(2); + String extendsClause = m.group(3); + String implementsClause = m.group(4); + + int bodyStart = text.indexOf('{', m.start()); + int bodyEnd = findMatchingBrace(bodyStart); + if (bodyEnd < 0) { + bodyEnd = text.length(); + } + + TypeInfo.Kind kind; + switch (kindStr) { + case "interface": kind = TypeInfo.Kind.INTERFACE; break; + case "enum": kind = TypeInfo.Kind.ENUM; break; + default: kind = TypeInfo.Kind.CLASS; break; + } + + String fullMatch = text.substring(m.start(), m.end()); + int modifiers = parseModifiers(fullMatch); + JSDocInfo jsDoc = jsDocParser.extractJSDocBefore(text, m.start()); + + rawDeclarations.add(new RawTypeDeclaration( + typeName, kind, m.start(), bodyStart, bodyEnd, + modifiers, extendsClause, implementsClause, jsDoc)); + } + + // ========== PASS 2: Build hierarchy using stack-based containment ========== + // Sort by bodyStart ascending so outer types are processed before inner types + rawDeclarations.sort(Comparator.comparingInt(r -> r.bodyStart)); + + // Stack tracks the nesting chain: top = current innermost enclosing type + Deque parentStack = new ArrayDeque<>(); + + for (RawTypeDeclaration raw : rawDeclarations) { + // Pop any parent whose body has ended before this declaration starts. + // This handles sibling types at the same level: when we reach InnerB, + // InnerA (whose bodyEnd <= InnerB.bodyStart) gets popped, leaving Outer on top. + while (!parentStack.isEmpty() && parentStack.peek().getBodyEnd() <= raw.bodyStart) { + parentStack.pop(); + } + + ScriptTypeInfo scriptType; + if (parentStack.isEmpty()) { + // Top-level type: no enclosing parent + scriptType = ScriptTypeInfo.create( + raw.name, raw.kind, raw.declOffset, raw.bodyStart, raw.bodyEnd, raw.modifiers); + scriptTypes.put(raw.name, scriptType); + } else { + // Inner type: parent is top of stack. createInner sets outerClass link + // and adds this type to the parent's innerClasses list. + ScriptTypeInfo parent = parentStack.peek(); + scriptType = ScriptTypeInfo.createInner( + raw.name, raw.kind, parent, raw.declOffset, raw.bodyStart, raw.bodyEnd, raw.modifiers); + } + + if (raw.jsDoc != null) { + scriptType.setJSDocInfo(raw.jsDoc); + } + + // Register in all lookup maps for O(1) access by any naming convention + scriptTypesByFullName.put(scriptType.getFullName(), scriptType); + scriptTypesByDotName.put(scriptType.getDotSeparatedName(), scriptType); + + // Push onto stack — this type can contain further nested types + parentStack.push(scriptType); + + // Resolve extends clause (parent class inheritance) + if (raw.extendsClause != null && !raw.extendsClause.trim().isEmpty()) { + String parentName = raw.extendsClause.trim(); + TypeInfo parentType = resolveType(parentName, raw.declOffset); + if (parentType == null) { + parentType = TypeInfo.unresolved(parentName, parentName); + } + scriptType.setSuperClass(parentType, parentName); + } + + // Resolve implements clause (interfaces) + if (raw.implementsClause != null && !raw.implementsClause.trim().isEmpty()) { + String[] interfaceNames = raw.implementsClause.split(","); + for (String ifaceName : interfaceNames) { + String trimmedName = ifaceName.trim(); + if (trimmedName.isEmpty()) + continue; + TypeInfo ifaceType = resolveType(trimmedName, raw.declOffset); + if (ifaceType == null) { + ifaceType = TypeInfo.unresolved(trimmedName, trimmedName); + } + scriptType.addImplementedInterface(ifaceType, trimmedName); + } + } + + // Parse fields and methods inside this type + parseScriptTypeMembers(scriptType); + } + } + + /** + * Parse fields and methods inside a script-defined type. + */ + private void parseScriptTypeMembers(ScriptTypeInfo scriptType) { + int bodyStart = scriptType.getBodyStart(); + int bodyEnd = scriptType.getBodyEnd(); + + if (bodyStart < 0 || bodyEnd <= bodyStart) return; + + String bodyText = text.substring(bodyStart + 1, Math.min(bodyEnd, text.length())); + + // Parse constructors (ClassName(params) { ... }) + // Constructor pattern: ClassName matches the script type name, no return type + String typeName = scriptType.getSimpleName(); + Pattern constructorPattern = Pattern.compile( + "\\b" + Pattern.quote(typeName) + "\\s*\\(([^)]*)\\)\\s*\\{"); + Matcher cm = constructorPattern.matcher(bodyText); + while (cm.find()) { + int absPos = bodyStart + 1 + cm.start(); + if (isExcluded(absPos)) continue; + // Skip constructors found inside a nested type's body — they belong to the inner class + if (isInsideNestedType(absPos, scriptType)) continue; + + String paramList = cm.group(1); + + int constructorBodyStart = bodyStart + 1 + cm.end() - 1; + int constructorBodyEnd = findMatchingBrace(constructorBodyStart); + if (constructorBodyEnd < 0) constructorBodyEnd = bodyEnd; + + // Extract documentation before this constructor + String documentation = extractDocumentationBefore(absPos); + + // Extract modifiers by scanning backwards + int modifiers = extractModifiersBackwards(cm.start() - 1, bodyText); + + // Parse parameters with their actual positions + List params = parseParametersWithPositions(paramList, bodyStart + 1 + cm.start(1)); + + // Calculate the three offsets for constructor + // For constructors, type offset and name offset are the same (start of constructor name) + int nameOffset = bodyStart + 1 + cm.start(); + int typeOffset = nameOffset; // No separate type for constructors + int fullDeclOffset = findFullDeclarationStart(cm.start(), bodyText); + if (fullDeclOffset >= 0) { + fullDeclOffset += bodyStart + 1; + } else { + fullDeclOffset = nameOffset; + } + + // Constructors don't have a return type, but we'll use the containing type as a marker + MethodInfo constructorInfo = MethodInfo.declaration( + typeName, + scriptType, + // Return type is the type itself + scriptType, + params, + fullDeclOffset, + typeOffset, + nameOffset, + constructorBodyStart, + constructorBodyEnd, + modifiers, + documentation); + scriptType.addConstructor(constructorInfo); + } + + // Parse enum constants (for enum types only) + if (scriptType.getKind() == TypeInfo.Kind.ENUM) { + List constants = EnumConstantInfo.parseEnumConstants( + scriptType, + bodyText, + bodyStart + 1, + KEYWORD_PATTERN + ); + + for (EnumConstantInfo constant : constants) { + scriptType.addEnumConstant(constant); + if (constant.getConstructorCall() != null) { + + } + // methodCalls.add(constant.getConstructorCall()); + + } + } + } + + /** + * Check if a position is inside a nested method body within a class. + * This prevents field declarations inside methods from being treated as class fields. + */ + private boolean isInsideNestedMethod(int position, int classBodyStart, int classBodyEnd) { + String bodyText = text.substring(classBodyStart + 1, Math.min(classBodyEnd, text.length())); + int relativePos = position - classBodyStart - 1; + + Pattern methodPattern = Pattern.compile( + "\\b[A-Za-z_][a-zA-Z0-9_<>\\[\\]]*\\s+[a-zA-Z_][a-zA-Z0-9_]*\\s*\\([^)]*\\)\\s*\\{"); + Matcher m = methodPattern.matcher(bodyText); + + while (m.find()) { + int methodBodyStart = m.end() - 1; + int absMethodBodyStart = classBodyStart + 1 + methodBodyStart; + int absMethodBodyEnd = findMatchingBrace(absMethodBodyStart); + + if (absMethodBodyEnd > 0 && position > absMethodBodyStart && position < absMethodBodyEnd) { + return true; + } + } + return false; + } + + /** + * Parse method/function declarations - UNIFIED for both Java and JavaScript. + * Stores results in the shared 'methods' list. + * + * For Java: Parses "ReturnType methodName(params) { ... }" + * For JavaScript: Parses "function funcName(params) { ... }" with hook type inference + */ + private void parseMethodDeclarations() { + if (isJavaScript()) { + // JavaScript: function funcName(params) { ... } + Pattern funcPattern = Pattern.compile("function\\s+(\\w+)\\s*\\(([^)]*)\\)\\s*\\{"); + Matcher m = funcPattern.matcher(text); + + while (m.find()) { + if (isExcluded(m.start())) continue; + + String funcName = m.group(1); + String paramList = m.group(2); + + int nameStart = m.start(1); + int bodyStart = text.indexOf('{', m.end() - 1); + int bodyEnd = findMatchingBrace(bodyStart); + if (bodyEnd < 0) bodyEnd = text.length(); + + // Extract documentation before this method + String documentation = extractDocumentationBefore(m.start()); + + // Check for JSDoc before the function declaration + JSDocInfo jsDoc = jsDocParser.extractJSDocBefore(text, m.start()); + + // For JS hooks, infer parameter types from registry + // Use the script context's namespaces (e.g., ["IPlayerEvent", "IAnimationEvent"]) for lookup + List params = new ArrayList<>(); + TypeInfo returnType = TypeInfo.fromPrimitive("void"); + List namespaces = scriptContext != null ? scriptContext.getNamespaces() : Collections.singletonList("Global"); + + boolean runtimeHook = false; + if (ScriptHookController.Instance != null && scriptContext != null) { + String hookContext = scriptContext.hookContext; + if (hookContext != null && !hookContext.isEmpty()) { + runtimeHook = ScriptHookController.Instance.hasHook(hookContext, funcName); + } + } + + if (runtimeHook) { + if (typeResolver.isJSHook(namespaces, funcName)) { + List sigs = typeResolver.getJSHookSignatures(namespaces, funcName); + if (!sigs.isEmpty()) { + JSTypeRegistry.HookSignature sig = sigs.get(0); + documentation = sig.doc; + + if (paramList != null && !paramList.trim().isEmpty()) { + String[] paramNames = paramList.split(","); + if (paramNames.length > 0) { + String paramName = paramNames[0].trim(); + TypeInfo paramType = typeResolver.resolveJSType(sig.paramType); + int paramStart = m.start(2) + paramList.indexOf(paramName); + params.add(FieldInfo.parameter(paramName, paramType, paramStart, null)); + } + } + } + } else { + if (paramList != null && !paramList.trim().isEmpty()) { + String[] paramNames = paramList.split(","); + if (paramNames.length > 0) { + String paramName = paramNames[0].trim(); + int paramStart = m.start(2) + paramList.indexOf(paramName); + params.add(FieldInfo.parameter(paramName, TypeInfo.ANY, paramStart, null)); + } + } + } + } else { + // Non-hook function - use JSDoc param types if available, else 'any' type + if (paramList != null && !paramList.trim().isEmpty()) { + int paramOffset = m.start(2); + for (String p : paramList.split(",")) { + String pn = p.trim(); + if (!pn.isEmpty()) { + int paramStart = paramOffset + paramList.indexOf(pn); + + // Check if JSDoc has a @param tag for this parameter + TypeInfo paramType = TypeInfo.ANY; + if (jsDoc != null) { + JSDocParamTag paramTag = jsDoc.getParamTag(pn); + if (paramTag != null && paramTag.getTypeInfo() != null) { + paramType = paramTag.getTypeInfo(); + } + } + + params.add(FieldInfo.parameter(pn, paramType, paramStart, null)); + } + } + } + + // Use JSDoc @return type if available + if (jsDoc != null && jsDoc.hasReturnTag() && jsDoc.getReturnType() != null) { + returnType = jsDoc.getReturnType(); + } + } + + // Create MethodInfo and add to shared methods list + MethodInfo methodInfo = MethodInfo.declaration( + funcName, null, returnType, params, + m.start(), nameStart, nameStart, + bodyStart, bodyEnd, 0, documentation + ); + + if(jsDoc!=null) + methodInfo.setJSDocInfo(jsDoc); + + methods.add(methodInfo); + } + } else { + // Java: ReturnType methodName(params) { ... } or { ; } + Pattern methodWithBody = Pattern.compile( + "\\b([a-zA-Z_][a-zA-Z0-9_<>\\[\\]]*)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\(([^)]*)\\)\\s*(\\{|;)"); + + Matcher m = methodWithBody.matcher(text); + while (m.find()) { + String methodName = m.group(2); + + if (isExcluded(m.start()) || isKeyword(methodName)) + continue; + + String returnType = m.group(1); + + if (returnType.equals("class") || returnType.equals("interface") || returnType.equals("enum") || returnType.equals("new") + || TypeResolver.isModifier(returnType)) { + continue; + } + + String paramList = m.group(3); + String delimiter = m.group(4); + boolean hasBody = delimiter.equals("{"); + + int bodyStart = !hasBody ? m.end() : text.indexOf('{', m.end() - 1); + int bodyEnd = !hasBody ? m.end() : findMatchingBrace(bodyStart); + if (bodyEnd < 0) + bodyEnd = text.length(); + + // Extract documentation before this method + String documentation = extractDocumentationBefore(m.start()); + + // Extract modifiers by scanning backwards from match start + int modifiers = extractModifiersBackwards(m.start() - 1, text); + + // Calculate offset positions + int typeOffset = m.start(1); + int nameOffset = m.start(2); + int fullDeclOffset = findFullDeclarationStart(m.start(1), text); + + // Use findEnclosingScriptType (recursive descent) so methods declared + // inside inner classes are attributed to the innermost containing type. + ScriptTypeInfo scriptType = findEnclosingScriptType(bodyStart); + + // Parse parameters with their actual positions + List params = parseParametersWithPositions(paramList, m.start(3)); + + MethodInfo methodInfo = MethodInfo.declaration( + methodName, + scriptType, + resolveType(returnType, m.start(1)), + params, + fullDeclOffset, + typeOffset, + nameOffset, + bodyStart, + bodyEnd, + modifiers, + documentation + ); + + if (scriptType != null) { + scriptType.addMethod(methodInfo); + } else + methods.add(methodInfo); + + // Validate the method (return statements, parameters) with type resolution + String methodBodyText = bodyEnd > bodyStart + 1 ? text.substring(bodyStart + 1, bodyEnd) : ""; + methodInfo.validate(methodBodyText, hasBody, (expr, pos) -> resolveExpressionType(expr, pos)); + } + + + } + // Check for duplicate method declarations + checkDuplicateMethods(); + } + + /** + * Find the start of a full method declaration, including any modifiers before the type. + */ + private int findFullDeclarationStart(int typeStart, String sourceText) { + int pos = typeStart - 1; + + // Skip whitespace before type + while (pos >= 0 && Character.isWhitespace(sourceText.charAt(pos))) { + pos--; + } + + // Check for modifiers + int earliestPos = typeStart; + while (pos >= 0) { + // Skip whitespace + while (pos >= 0 && Character.isWhitespace(sourceText.charAt(pos))) { + pos--; + } + if (pos < 0) break; + + // Read word backwards + int wordEnd = pos + 1; + while (pos >= 0 && Character.isJavaIdentifierPart(sourceText.charAt(pos))) { + pos--; + } + int wordStart = pos + 1; + + if (wordStart < wordEnd) { + String word = sourceText.substring(wordStart, wordEnd); + if (TypeResolver.isModifier(word)) { + earliestPos = wordStart; + } else { + break; + } + } else { + break; + } + } + + return earliestPos; + } + + /** + * Check for duplicate method declarations with same signature in same scope. + */ + private void checkDuplicateMethods() { + // Group methods by their containing type (script class/interface or document root) + // Methods are only duplicates if they're in the SAME containing type + Map> methodsByType = new HashMap<>(); + + for (MethodInfo method : getAllMethods()) { + TypeInfo containingType = method.getContainingType(); + methodsByType.computeIfAbsent(containingType, k -> new ArrayList<>()).add(method); + } + + // Check each type for duplicate method signatures + for (List typeMethods : methodsByType.values()) { + Map> signatureMap = new HashMap<>(); + + for (MethodInfo method : typeMethods) { + MethodSignature signature = method.getSignature(); + signatureMap.computeIfAbsent(signature, k -> new ArrayList<>()).add(method); + } + + // Mark all methods with duplicate signatures within the same type + for (Map.Entry> entry : signatureMap.entrySet()) { + List duplicates = entry.getValue(); + if (duplicates.size() > 1) { + for (MethodInfo duplicate : duplicates) { + duplicate.setError( + MethodInfo.ErrorType.DUPLICATE_METHOD, + duplicate.getSignature() + " is already defined in this scope" + ); + } + } + } + } + } + + /** + * Calculate the scope depth of a position (0 = top level, 1 = in class, etc.). + */ + private int calculateScopeDepth(int position) { + int depth = 0; + int braceDepth = 0; + boolean inString = false; + boolean inComment = false; + boolean inLineComment = false; + + for (int i = 0; i < position && i < text.length(); i++) { + char c = text.charAt(i); + char next = (i + 1 < text.length()) ? text.charAt(i + 1) : 0; + + // Handle strings + if (c == '"' && !inComment && !inLineComment) { + inString = !inString; + continue; + } + if (inString) continue; + + // Handle comments + if (!inComment && !inLineComment && c == '/' && next == '/') { + inLineComment = true; + i++; + continue; + } + if (!inComment && !inLineComment && c == '/' && next == '*') { + inComment = true; + i++; + continue; + } + if (inComment && c == '*' && next == '/') { + inComment = false; + i++; + continue; + } + if (inLineComment && c == '\n') { + inLineComment = false; + continue; + } + if (inComment || inLineComment) continue; + + // Track braces + if (c == '{') { + braceDepth++; + depth = Math.max(depth, braceDepth); + } else if (c == '}') { + braceDepth--; + } + } + + return depth; + } + + private List parseParametersWithPositions(String paramList, int paramListStart) { + List params = new ArrayList<>(); + if (paramList == null || paramList.trim().isEmpty()) { + return params; + } + + // Pattern: Type varName (with optional spaces) + Pattern paramPattern = Pattern.compile( + "([a-zA-Z_][a-zA-Z0-9_<>\\[\\]]*(?:\\.{3})?)\\s+([a-zA-Z_][a-zA-Z0-9_]*)"); + Matcher m = paramPattern.matcher(paramList); + while (m.find()) { + String typeName = m.group(1); + String paramName = m.group(2); + boolean isVarArg = typeName.endsWith("..."); + if (isVarArg) typeName = typeName.substring(0, typeName.length() - 3); + TypeInfo typeInfo = resolveType(typeName, paramListStart); + // Store the absolute position of the parameter name + int paramNameStart = paramListStart + m.start(2); + FieldInfo fieldInfo = FieldInfo.parameter(paramName, typeInfo, paramNameStart, null); + fieldInfo.setVarArg(isVarArg); + params.add(fieldInfo); + } + return params; + } + + private ScopeInfo computeBlockScope(int bodyStart, int bodyEnd, int declarationOffset) { + int end = Math.min(bodyEnd, text.length()); + int pos = Math.min(Math.max(declarationOffset, bodyStart), end); + + Deque stack = new ArrayDeque<>(); + for (int i = bodyStart; i < pos && i < text.length(); i++) { + if (isExcluded(i)) { + continue; + } + char c = text.charAt(i); + if (c == '{') { + stack.push(i); + } else if (c == '}') { + if (!stack.isEmpty()) { + stack.pop(); + } + } + } + + if (stack.isEmpty()) { + ScopeInfo parenScope = computeParenStatementScope(bodyStart, bodyEnd, pos); + if (parenScope != null) { + return parenScope; + } + return new ScopeInfo(bodyStart, bodyEnd, false, "method"); + } + + int openBrace = stack.peek(); + int closeBrace = findMatchingBrace(openBrace); + if (closeBrace < 0 || closeBrace > bodyEnd) { + return new ScopeInfo(bodyStart, bodyEnd, false, "method"); + } + return new ScopeInfo(openBrace + 1, closeBrace, false, "block"); + } + + private ScopeInfo computeParenStatementScope(int bodyStart, int bodyEnd, int position) { + int openParen = findEnclosingParenStart(bodyStart, position); + if (openParen < 0) { + return null; + } + + int closeParen = findMatchingParen(openParen, bodyEnd); + if (closeParen < 0 || position > closeParen) { + return null; + } + + String keyword = readKeywordBefore(openParen); + if (!"for".equals(keyword) && !"catch".equals(keyword)) { + return null; + } + + int after = skipWhitespaceAndExcluded(closeParen + 1, bodyEnd); + if (after < 0 || after >= bodyEnd) { + return null; + } + + if (text.charAt(after) == '{') { + int closeBrace = findMatchingBrace(after); + if (closeBrace > 0) { + return new ScopeInfo(openParen, closeBrace, false, "block"); + } + return null; + } + + int stmtEnd = findStatementEnd(after, bodyEnd); + if (stmtEnd > after) { + return new ScopeInfo(openParen, stmtEnd, false, "block"); + } + return null; + } + + int skipWhitespaceAndExcluded(int pos, int limit) { + int i = Math.max(pos, 0); + int max = Math.min(limit, text.length()); + while (i < max) { + if (isExcluded(i)) { + i++; + continue; + } + if (!Character.isWhitespace(text.charAt(i))) { + return i; + } + i++; + } + return -1; + } + + int findStatementEnd(int start, int limit) { + int max = Math.min(limit, text.length()); + int parenDepth = 0; + int bracketDepth = 0; + for (int i = start; i < max; i++) { + if (isExcluded(i)) { + continue; + } + char c = text.charAt(i); + if (c == '(') parenDepth++; + else if (c == ')') parenDepth = Math.max(0, parenDepth - 1); + else if (c == '[') bracketDepth++; + else if (c == ']') bracketDepth = Math.max(0, bracketDepth - 1); + else if (c == '{') { + int closeBrace = findMatchingBrace(i); + return closeBrace > 0 ? closeBrace : -1; + } else if (c == ';' && parenDepth == 0 && bracketDepth == 0) { + return i + 1; + } + } + return -1; + } + + int findEnclosingParenStart(int min, int position) { + int depth = 0; + for (int i = Math.min(position - 1, text.length() - 1); i >= min; i--) { + if (isExcluded(i)) { + continue; + } + char c = text.charAt(i); + if (c == ')') { + depth++; + } else if (c == '(') { + if (depth == 0) { + return i; + } + depth--; + } + } + return -1; + } + + int findMatchingParen(int openParenIndex, int limit) { + if (openParenIndex < 0 || openParenIndex >= text.length()) { + return -1; + } + int max = Math.min(limit, text.length()); + int depth = 0; + for (int i = openParenIndex; i < max; i++) { + if (isExcluded(i)) { + continue; + } + char c = text.charAt(i); + if (c == '(') depth++; + else if (c == ')') { + depth--; + if (depth == 0) { + return i; + } + } + } + return -1; + } + + String readKeywordBefore(int position) { + int i = position - 1; + while (i >= 0) { + if (isExcluded(i)) { + i--; + continue; + } + if (!Character.isWhitespace(text.charAt(i))) { + break; + } + i--; + } + if (i < 0) { + return ""; + } + int end = i + 1; + while (i >= 0 && Character.isJavaIdentifierPart(text.charAt(i))) { + i--; + } + int start = i + 1; + if (start >= end) { + return ""; + } + return text.substring(start, end); + } + + private FieldInfo pickVisibleLocal(List candidates, int position) { + if (candidates == null || candidates.isEmpty()) { + return null; + } + FieldInfo best = null; + for (FieldInfo f : candidates) { + if (f == null) { + continue; + } + if (!f.isVisibleAt(position)) { + continue; + } + if (best == null || f.getDeclarationOffset() > best.getDeclarationOffset()) { + best = f; + } + } + return best; + } + + private FieldInfo pickVisibleTopLevelLocal(String name, int position) { + return pickVisibleLocal(topLevelLocals.get(name), position); + } + + void addTopLevelLocal(FieldInfo fieldInfo) { + if (fieldInfo == null) { + return; + } + topLevelLocals.computeIfAbsent(fieldInfo.getName(), k -> new ArrayList<>()).add(fieldInfo); + } + + private Collection getVisibleTopLevelLocals(int position) { + List visible = new ArrayList<>(); + for (List candidates : topLevelLocals.values()) { + FieldInfo best = pickVisibleLocal(candidates, position); + if (best != null) { + visible.add(best); + } + } + return visible; + } + + Collection getTopLevelLocalCandidates() { + List all = new ArrayList<>(); + for (List fields : topLevelLocals.values()) { + all.addAll(fields); + } + return all; + } + + /** + * Parse local variables inside methods/functions - UNIFIED for both Java and JavaScript. + * Stores results in the shared 'methodLocals' map (methodOffset -> varName -> FieldInfo). + * + * For Java: Parses "Type varName = expr;" or "Type varName;" + * For JavaScript: Parses "var/let/const varName = expr;" with type inference + */ + private void parseLocalVariables() { + for (MethodInfo method : getAllMethods()) { + Map> locals = new HashMap<>(); + methodLocals.put(method.getDeclarationOffset(), locals); + + int bodyStart = method.getBodyStart(); + int bodyEnd = method.getBodyEnd(); + if (bodyStart < 0 || bodyEnd <= bodyStart) continue; + + String bodyText = text.substring(bodyStart, Math.min(bodyEnd, text.length())); + + if (isJavaScript()) { + // JavaScript: var/let/const varName = expr; + Pattern varPattern = Pattern.compile("(var|let|const)\\s+(\\w+)(?:\\s*(=))?"); + Matcher m = varPattern.matcher(bodyText); + + while (m.find()) { + int absPos = bodyStart + m.start(2); + if (isExcluded(absPos)) continue; + + int afterVar = m.end(2); + if (afterVar < bodyText.length()) { + String rest = bodyText.substring(afterVar); + if (rest.length() > 0 && java.util.regex.Pattern.compile("^\\s+(?:in|of)\\s").matcher(rest).find()) continue; + } + + boolean insideInner = false; + for (InnerCallableScope scope : innerScopes) { + if (scope.containsPosition(absPos)) { + insideInner = true; + break; + } + } + if (insideInner) continue; + + String kind = m.group(1); + String varName = m.group(2); + String initializer = null; + int initializerStart = -1; + int initializerEnd = -1; + if (m.group(3) != null) { + initializerStart = skipSegmentWhitespace(bodyText, m.end(3)); + initializerEnd = findJsInitializerEnd(bodyText, initializerStart, true); + if (initializerEnd > initializerStart) { + initializer = bodyText.substring(initializerStart, initializerEnd).trim(); + if (initializer.isEmpty()) { + initializer = null; + } + } + } + + // Check for JSDoc type annotation before the declaration + int absStart = bodyStart + m.start(); + JSDocInfo jsDoc = jsDocParser.extractJSDocBefore(text, absStart); + + TypeInfo typeInfo = null; + + // Priority 1: JSDoc @type takes precedence + if (jsDoc != null && jsDoc.hasTypeTag()) { + typeInfo = jsDoc.getDeclaredType(); + } + + // Priority 2: Infer type from initializer if no JSDoc type + if (typeInfo == null && initializer != null && !initializer.isEmpty()) { + TypeInfo inferred = resolveExpressionType(initializer, bodyStart + initializerStart); + if (!TypeInfo.NULL.equals(inferred)) { + typeInfo = inferred; + } + } + + // Priority 3: Use "any" type for uninitialized variables + if (typeInfo == null) { + typeInfo = TypeInfo.ANY; + } + + int initStart = -1, initEnd = -1; + if (m.group(3) != null) { + initStart = bodyStart + m.start(3); + initEnd = (initializerEnd >= 0) ? bodyStart + initializerEnd : bodyStart + m.end(3); + } + + FieldInfo fieldInfo = FieldInfo.localField(varName, typeInfo, absPos, method, initStart, initEnd, 0); + ScopeInfo scopeInfo; + if ("var".equals(kind)) { + scopeInfo = new ScopeInfo(bodyStart, bodyEnd, false, "method"); + } else { + scopeInfo = computeBlockScope(bodyStart, bodyEnd, absPos); + } + fieldInfo.setScopeInfo(scopeInfo); + + if(jsDoc != null) + fieldInfo.setJSDocInfo(jsDoc); + // Check for duplicate + List existing = locals.get(varName); + if (existing != null && !existing.isEmpty()) { + boolean dup = false; + if ("let".equals(kind) || "const".equals(kind)) { + for (FieldInfo prev : existing) { + ScopeInfo prevScope = prev.getScopeInfo(); + if (prevScope != null && prevScope.startOffset == scopeInfo.startOffset && prevScope.endOffset == scopeInfo.endOffset) { + dup = true; + break; + } + } + } + if (dup || globalFields.containsKey(varName)) { + AssignmentInfo dupError = AssignmentInfo.duplicateDeclaration( + varName, absPos, absPos + varName.length(), + "Variable '" + varName + "' is already defined in the scope"); + dupError.setScopeInfo(scopeInfo); + declarationErrors.add(dupError); + continue; + } + if ("var".equals(kind)) { + continue; + } + } else if (globalFields.containsKey(varName)) { + AssignmentInfo dupError = AssignmentInfo.duplicateDeclaration( + varName, absPos, absPos + varName.length(), + "Variable '" + varName + "' is already defined in the scope"); + dupError.setScopeInfo(scopeInfo); + declarationErrors.add(dupError); + continue; + } + + locals.computeIfAbsent(varName, k -> new ArrayList<>()).add(fieldInfo); + + // --- Multi-declarator continuation for JS --- + // For "var a=1, b='x', c=player;" the regex only matched 'a'. + // Scan forward from the end of this declarator for comma-separated + // continuation names (b, c, ...) that share the same var/let/const keyword. + final String fKind = kind; + final MethodInfo fMethod = method; + final int fBodyStart = bodyStart; + final int fBodyEnd = bodyEnd; + final Map> fLocals = locals; + int contScanStart = MultiDeclaratorParser.jsDeclaratorScanStart(bodyText, m.end(2), m.group(3) != null, initializerEnd); + MultiDeclaratorParser.scanJSContinuationDeclarators(this, bodyText, contScanStart, bodyStart, + (cVarName, cAbsNamePos, cInit, cAbsInitStart, cAbsInitEnd) -> { + if (isExcluded(cAbsNamePos)) return; + boolean cInsideInner = false; + for (InnerCallableScope sc : innerScopes) { + if (sc.containsPosition(cAbsNamePos)) { cInsideInner = true; break; } + } + if (cInsideInner) return; + + TypeInfo cType = null; + if (cInit != null && !cInit.isEmpty()) { + TypeInfo inferred = resolveExpressionType(cInit, cAbsInitStart); + if (!TypeInfo.NULL.equals(inferred)) cType = inferred; + } + if (cType == null) cType = TypeInfo.ANY; + + FieldInfo cField = FieldInfo.localField(cVarName, cType, cAbsNamePos, fMethod, + cAbsInitStart, cAbsInitEnd, 0); + ScopeInfo cScope; + if ("var".equals(fKind)) { + cScope = new ScopeInfo(fBodyStart, fBodyEnd, false, "method"); + } else { + cScope = computeBlockScope(fBodyStart, fBodyEnd, cAbsNamePos); + } + cField.setScopeInfo(cScope); + + if (fLocals.containsKey(cVarName) || globalFields.containsKey(cVarName)) { + AssignmentInfo dupErr = AssignmentInfo.duplicateDeclaration( + cVarName, cAbsNamePos, cAbsNamePos + cVarName.length(), + "Variable '" + cVarName + "' is already defined in the scope"); + dupErr.setScopeInfo(cScope); + declarationErrors.add(dupErr); + return; + } + fLocals.computeIfAbsent(cVarName, k -> new ArrayList<>()).add(cField); + }); + } + } else { + // Java: Type varName = expr; or Type varName; + Matcher m = FIELD_DECL_PATTERN.matcher(bodyText); + while (m.find()) { + String typeName = m.group(1); + String varName = m.group(2); + String delimiter = m.group(3); + + int absPos = bodyStart + m.start(2); + if (isExcluded(absPos)) continue; + + // --- FIX: Detect greedy regex consuming commas into the type name --- + // FIELD_DECL_PATTERN allows commas in its type character class (for generics). + // This causes "int x, y, z = 10;" to match as type="int x, y," name="z" delim="=". + // When a depth-0 comma exists in typeName, the regex swallowed extra declarators. + // We extract the real type and first variable, then let the continuation scanner + // handle ALL variables (including the regex-matched one). + int commaInType = MultiDeclaratorParser.findFirstDepthZeroComma(typeName); + if (commaInType >= 0) { + String realTypeName = MultiDeclaratorParser.extractRealTypeFromGreedyMatch(typeName, commaInType); + String firstVar = MultiDeclaratorParser.extractFirstVarFromGreedyMatch(typeName, commaInType); + int firstVarAbsPos = MultiDeclaratorParser.findFirstVarPosition( + bodyText, m.start(1), typeName, commaInType) + bodyStart; + + // Skip control flow keywords on the real type + if (realTypeName.equals("return") || realTypeName.equals("if") || realTypeName.equals("while") || + realTypeName.equals("for") || realTypeName.equals("switch") || realTypeName.equals("catch") || + realTypeName.equals("new") || realTypeName.equals("throw")) { + continue; + } + + int enclosingParen1 = findEnclosingParenStart(bodyStart, firstVarAbsPos); + if (enclosingParen1 >= 0) continue; + + int greedyModifiers = parseModifiers(realTypeName); + TypeInfo greedyTypeInfo = resolveType(realTypeName, firstVarAbsPos); + + // Register the first variable (extracted from the greedy type group) + FieldInfo firstField = FieldInfo.localField(firstVar, greedyTypeInfo, firstVarAbsPos, + method, -1, -1, greedyModifiers); + ScopeInfo firstScope = computeBlockScope(bodyStart, bodyEnd, firstVarAbsPos); + firstField.setScopeInfo(firstScope); + + List existingFirst = locals.get(firstVar); + if (existingFirst != null) { + boolean dup = false; + for (FieldInfo prev : existingFirst) { + ScopeInfo prevScope = prev.getScopeInfo(); + if (prevScope != null && prevScope.containsPosition(firstVarAbsPos)) { + dup = true; + break; + } + } + if (dup || globalFields.containsKey(firstVar)) { + AssignmentInfo dupErr = AssignmentInfo.duplicateDeclaration( + firstVar, firstVarAbsPos, firstVarAbsPos + firstVar.length(), + "Variable '" + firstVar + "' is already defined in the scope"); + dupErr.setScopeInfo(firstScope); + declarationErrors.add(dupErr); + } else { + locals.computeIfAbsent(firstVar, k -> new ArrayList<>()).add(firstField); + } + } else if (globalFields.containsKey(firstVar)) { + AssignmentInfo dupErr = AssignmentInfo.duplicateDeclaration( + firstVar, firstVarAbsPos, firstVarAbsPos + firstVar.length(), + "Variable '" + firstVar + "' is already defined in the scope"); + dupErr.setScopeInfo(firstScope); + declarationErrors.add(dupErr); + } else { + locals.computeIfAbsent(firstVar, k -> new ArrayList<>()).add(firstField); + } + + // Scan continuations from the first depth-0 comma in the type group. + // This will pick up all remaining variables (y, z, etc.) including the + // regex-matched varName which was the last one consumed by the greedy match. + final TypeInfo greedySharedType = greedyTypeInfo; + final int greedySharedMod = greedyModifiers; + final MethodInfo fMethod3 = method; + final Map> fLocals3 = locals; + int greedyScanStart = m.start(1) + commaInType; + MultiDeclaratorParser.scanJavaContinuationDeclarators(bodyText, greedyScanStart, bodyStart, + (cVarName, cAbsNamePos, cAbsInitStart, cAbsInitEnd) -> { + if (isExcluded(cAbsNamePos)) return; + if (findEnclosingParenStart(bodyStart, cAbsNamePos) >= 0) return; + FieldInfo cField = FieldInfo.localField(cVarName, greedySharedType, cAbsNamePos, + fMethod3, cAbsInitStart, cAbsInitEnd, greedySharedMod); + ScopeInfo cScope = computeBlockScope(bodyStart, bodyEnd, cAbsNamePos); + cField.setScopeInfo(cScope); + + if (fLocals3.containsKey(cVarName) || globalFields.containsKey(cVarName)) { + AssignmentInfo dupErr = AssignmentInfo.duplicateDeclaration( + cVarName, cAbsNamePos, cAbsNamePos + cVarName.length(), + "Variable '" + cVarName + "' is already defined in the scope"); + dupErr.setScopeInfo(cScope); + declarationErrors.add(dupErr); + return; + } + fLocals3.computeIfAbsent(cVarName, k -> new ArrayList<>()).add(cField); + }); + continue; + } + + // Skip control flow keywords + if (typeName.equals("return") || typeName.equals("if") || typeName.equals("while") || + typeName.equals("for") || typeName.equals("switch") || typeName.equals("catch") || + typeName.equals("new") || typeName.equals("throw")) { + continue; + } + + int enclosingParen = findEnclosingParenStart(bodyStart, absPos); + if (enclosingParen >= 0 && "for".equals(readKeywordBefore(enclosingParen))) continue; + + int modifiers = parseModifiers(typeName); + + TypeInfo typeInfo; + if ((typeName.equals("var") || typeName.equals("let") || typeName.equals("const")) + && delimiter.equals("=")) { + int rhsStart = bodyStart + m.end(); + typeInfo = inferTypeFromExpression(rhsStart); + } else { + // Use position-aware resolution so inner class type names resolve in scope + typeInfo = resolveType(typeName, bodyStart + m.start(2)); + } + + int initStart = -1, initEnd = -1; + if ("=".equals(delimiter)) { + initStart = bodyStart + m.start(3); + int searchPos = bodyStart + m.end(3); + int depth = 0; + int angleDepth = 0; + while (searchPos < text.length()) { + char c = text.charAt(searchPos); + if (c == '(' || c == '[' || c == '{') depth++; + else if (c == ')' || c == ']' || c == '}') depth--; + else if (c == '<') angleDepth++; + else if (c == '>') angleDepth--; + else if ((c == ';' || c == ',') && depth == 0 && angleDepth == 0) { + initEnd = searchPos; + break; + } + searchPos++; + } + } + + int declPos = bodyStart + m.start(2); + FieldInfo fieldInfo = FieldInfo.localField(varName, typeInfo, declPos, method, initStart, initEnd, modifiers); + ScopeInfo scopeInfo = computeBlockScope(bodyStart, bodyEnd, declPos); + fieldInfo.setScopeInfo(scopeInfo); + + List existing = locals.get(varName); + if (existing != null) { + boolean dup = false; + for (FieldInfo prev : existing) { + ScopeInfo prevScope = prev.getScopeInfo(); + if (prevScope != null && prevScope.containsPosition(declPos)) { + dup = true; + break; + } + } + if (dup || globalFields.containsKey(varName)) { + AssignmentInfo dupError = AssignmentInfo.duplicateDeclaration( + varName, declPos, declPos + varName.length(), + "Variable '" + varName + "' is already defined in the scope"); + dupError.setScopeInfo(scopeInfo); + declarationErrors.add(dupError); + continue; + } + } else if (globalFields.containsKey(varName)) { + AssignmentInfo dupError = AssignmentInfo.duplicateDeclaration( + varName, declPos, declPos + varName.length(), + "Variable '" + varName + "' is already defined in the scope"); + dupError.setScopeInfo(scopeInfo); + declarationErrors.add(dupError); + continue; + } + + locals.computeIfAbsent(varName, k -> new ArrayList<>()).add(fieldInfo); + + // --- Multi-declarator continuation for Java --- + // For "int x = 1, y, z = 3;" FIELD_DECL_PATTERN matched "int x =" (or "int x,"). + // Scan forward for comma-separated continuation declarators (y, z) + // that share the same declared type from the first match. + final TypeInfo sharedType = typeInfo; + final int sharedModifiers = modifiers; + final MethodInfo fMethod2 = method; + final Map> fLocals2 = locals; + int javaScanStart = MultiDeclaratorParser.javaDeclaratorScanStart(bodyText, delimiter, m.end(3), + initEnd >= 0 ? initEnd - bodyStart : -1); + if (javaScanStart >= 0) { + MultiDeclaratorParser.scanJavaContinuationDeclarators(bodyText, javaScanStart, bodyStart, + (cVarName, cAbsNamePos, cAbsInitStart, cAbsInitEnd) -> { + if (isExcluded(cAbsNamePos)) return; + FieldInfo cField = FieldInfo.localField(cVarName, sharedType, cAbsNamePos, + fMethod2, cAbsInitStart, cAbsInitEnd, sharedModifiers); + ScopeInfo cScope = computeBlockScope(bodyStart, bodyEnd, cAbsNamePos); + cField.setScopeInfo(cScope); + + if (fLocals2.containsKey(cVarName) || globalFields.containsKey(cVarName)) { + AssignmentInfo dupErr = AssignmentInfo.duplicateDeclaration( + cVarName, cAbsNamePos, cAbsNamePos + cVarName.length(), + "Variable '" + cVarName + "' is already defined in the scope"); + dupErr.setScopeInfo(cScope); + declarationErrors.add(dupErr); + return; + } + fLocals2.computeIfAbsent(cVarName, k -> new ArrayList<>()).add(cField); + }); + } + } + } + } + + // Also parse locals inside inner callable scopes + for (InnerCallableScope scope : innerScopes) { + parseLocalVariablesInScope(scope); + } + + new LoopVariableParser(this, text).parse(methodLocals); + } + + private void parseLocalVariablesInScope(InnerCallableScope scope) { + int start = scope.getBodyStart(); + int end = scope.getBodyEnd(); + + if (start < 0 || end <= start) return; + + if (isJavaScript()) { + parseJSLocalsInRange(start, end, scope); + } else { + parseJavaLocalsInRange(start, end, scope); + } + } + + /** + * Parse Java local variable declarations in the range [start, end). + * Pattern: Type varName = ... or var varName = ... + */ + private void parseJavaLocalsInRange(int start, int end, InnerCallableScope scope) { + String rangeText = text.substring(start, Math.min(end, text.length())); + + Matcher m = FIELD_DECL_PATTERN.matcher(rangeText); + while (m.find()) { + int declPos = start + m.start(); + if (declPos < start || declPos >= end) continue; + if (isExcluded(declPos)) continue; + + String typeNameRaw = m.group(1); + String varName = m.group(2); + String delimiter = m.group(3); + + // --- FIX: Detect greedy regex consuming commas into the type name --- + // Same issue as the other call sites: FIELD_DECL_PATTERN greedily consumes + // multi-declarator commas into group(1). Handle by extracting the real type + // and first variable, then scanning continuations from the first comma. + int commaInType = MultiDeclaratorParser.findFirstDepthZeroComma(typeNameRaw); + if (commaInType >= 0) { + String realTypeNameRaw = MultiDeclaratorParser.extractRealTypeFromGreedyMatch(typeNameRaw, commaInType); + String firstVar = MultiDeclaratorParser.extractFirstVarFromGreedyMatch(typeNameRaw, commaInType); + int firstVarAbsPos = MultiDeclaratorParser.findFirstVarPosition( + rangeText, m.start(1), typeNameRaw, commaInType) + start; + + // Skip control flow keywords on the real type + if (realTypeNameRaw.equals("return") || realTypeNameRaw.equals("if") || realTypeNameRaw.equals("while") || + realTypeNameRaw.equals("for") || realTypeNameRaw.equals("switch") || realTypeNameRaw.equals("catch") || + realTypeNameRaw.equals("new") || realTypeNameRaw.equals("throw")) { + continue; + } + + String greedyTypeName = stripModifiers(realTypeNameRaw); + int greedyModifiers = parseModifiers(realTypeNameRaw); + TypeInfo greedyVarType = resolveType(greedyTypeName, firstVarAbsPos); + + // Register the first variable + FieldInfo firstField = FieldInfo.localField(firstVar, greedyVarType, firstVarAbsPos, + null, -1, -1, greedyModifiers); + scope.addLocal(firstVar, firstField); + + // Scan continuations from the first depth-0 comma + final TypeInfo greedySharedType = greedyVarType; + final int greedySharedMod = greedyModifiers; + final InnerCallableScope fScope3 = scope; + int greedyScanStart = m.start(1) + commaInType; + MultiDeclaratorParser.scanJavaContinuationDeclarators(rangeText, greedyScanStart, start, + (cVarName, cAbsNamePos, cAbsInitStart, cAbsInitEnd) -> { + if (isExcluded(cAbsNamePos)) return; + FieldInfo cField = FieldInfo.localField(cVarName, greedySharedType, cAbsNamePos, + null, cAbsInitStart, cAbsInitEnd, greedySharedMod); + fScope3.addLocal(cVarName, cField); + }); + continue; + } + + // Skip control flow keywords + if (typeNameRaw.equals("return") || typeNameRaw.equals("if") || typeNameRaw.equals("while") || + typeNameRaw.equals("for") || typeNameRaw.equals("switch") || typeNameRaw.equals("catch") || + typeNameRaw.equals("new") || typeNameRaw.equals("throw")) { + continue; + } + + String typeName = stripModifiers(typeNameRaw); + int modifiers = parseModifiers(typeNameRaw); + + TypeInfo varType = null; + if (!typeName.equals("var") && !typeName.equals("let") && !typeName.equals("const")) { + varType = resolveType(typeName); + } else if (delimiter.equals("=")) { + // Infer type from initializer + int rhsStart = start + m.end(); + varType = inferTypeFromExpression(rhsStart); + } + + int initStart = -1, initEnd = -1; + if ("=".equals(delimiter)) { + initStart = start + m.start(3); + int searchPos = start + m.end(3); + int depth = 0; + int angleDepth = 0; + while (searchPos < end) { + char c = text.charAt(searchPos); + if (c == '(' || c == '[' || c == '{') depth++; + else if (c == ')' || c == ']' || c == '}') depth--; + else if (c == '<') angleDepth++; + else if (c == '>') angleDepth--; + else if ((c == ';' || c == ',') && depth == 0 && angleDepth == 0) { + initEnd = searchPos; + break; + } + searchPos++; + } + } + + int absPos = start + m.start(2); + FieldInfo localVar = FieldInfo.localField(varName, varType, absPos, null, initStart, initEnd, modifiers); + scope.addLocal(varName, localVar); + + // Multi-declarator continuation for Java: "int x, y = 2, z;" + final TypeInfo sharedType = varType; + final int sharedModifiers = modifiers; + final InnerCallableScope fScope2 = scope; + int javaScanStart = MultiDeclaratorParser.javaDeclaratorScanStart(rangeText, delimiter, m.end(3), + initEnd >= 0 ? initEnd - start : -1); + if (javaScanStart >= 0) { + MultiDeclaratorParser.scanJavaContinuationDeclarators(rangeText, javaScanStart, start, + (cVarName, cAbsNamePos, cAbsInitStart, cAbsInitEnd) -> { + if (isExcluded(cAbsNamePos)) return; + FieldInfo cField = FieldInfo.localField(cVarName, sharedType, cAbsNamePos, + null, cAbsInitStart, cAbsInitEnd, sharedModifiers); + fScope2.addLocal(cVarName, cField); + }); + } + } + } + + /** + * Parse JS local variable declarations in the range [start, end). + * Pattern: var/let/const varName = ... + */ + private void parseJSLocalsInRange(int start, int end, InnerCallableScope scope) { + String rangeText = text.substring(start, Math.min(end, text.length())); + + Pattern varPattern = Pattern.compile("(?:var|let|const)\\s+(\\w+)(?:\\s*(=))?"); + Matcher m = varPattern.matcher(rangeText); + + while (m.find()) { + int declPos = start + m.start(); + if (declPos < start || declPos >= end) continue; + if (isExcluded(declPos)) continue; + + int afterVar = m.end(1); + if (afterVar < rangeText.length()) { + String rest = rangeText.substring(afterVar); + if (rest.length() > 0 && java.util.regex.Pattern.compile("^\\s+(?:in|of)\\s").matcher(rest).find()) continue; + } + + String varName = m.group(1); + String initializer = null; + int initializerStart = -1; + int initializerEnd = -1; + if (m.group(2) != null) { + initializerStart = skipSegmentWhitespace(rangeText, m.end(2)); + // Use comma-aware termination so multi-declarator RHS is bounded correctly + initializerEnd = findJsInitializerEnd(rangeText, initializerStart, true); + if (initializerEnd > initializerStart) { + initializer = rangeText.substring(initializerStart, initializerEnd).trim(); + if (initializer.isEmpty()) { + initializer = null; + } + } + } + + // Check for JSDoc type annotation + JSDocInfo jsDoc = jsDocParser.extractJSDocBefore(text, declPos); + + TypeInfo varType = null; + + // Priority 1: JSDoc @type + if (jsDoc != null && jsDoc.hasTypeTag()) { + varType = jsDoc.getDeclaredType(); + } + + // Priority 2: Infer from initializer + if (varType == null && initializer != null && !initializer.isEmpty()) { + TypeInfo inferred = resolveExpressionType(initializer, start + initializerStart); + if (!TypeInfo.NULL.equals(inferred)) { + varType = inferred; + } + } + + // Priority 3: Use "any" type + if (varType == null) { + varType = TypeInfo.ANY; + } + + int initStart = -1, initEnd = -1; + if (m.group(2) != null) { + initStart = start + m.start(2); + initEnd = (initializerEnd >= 0) ? start + initializerEnd : start + m.end(2); + } + + int absPos = start + m.start(1); + FieldInfo localVar = FieldInfo.localField(varName, varType, absPos, null, initStart, initEnd, 0); + + if (jsDoc != null) { + localVar.setJSDocInfo(jsDoc); + } + + scope.addLocal(varName, localVar); + + // Multi-declarator continuation: scan for "var a=1, b, c=3" + final InnerCallableScope fScope = scope; + int contScanStart = MultiDeclaratorParser.jsDeclaratorScanStart(rangeText, m.end(1), m.group(2) != null, initializerEnd); + MultiDeclaratorParser.scanJSContinuationDeclarators(this, rangeText, contScanStart, start, + (cVarName, cAbsNamePos, cInit, cAbsInitStart, cAbsInitEnd) -> { + if (isExcluded(cAbsNamePos)) return; + TypeInfo cType = null; + if (cInit != null && !cInit.isEmpty()) { + TypeInfo inferred = resolveExpressionType(cInit, cAbsInitStart); + if (!TypeInfo.NULL.equals(inferred)) cType = inferred; + } + if (cType == null) cType = TypeInfo.ANY; + FieldInfo cField = FieldInfo.localField(cVarName, cType, cAbsNamePos, null, + cAbsInitStart, cAbsInitEnd, 0); + fScope.addLocal(cVarName, cField); + }); + } + } + + int skipSegmentWhitespace(String source, int pos) { + while (pos < source.length() && Character.isWhitespace(source.charAt(pos))) { + pos++; + } + return pos; + } + + /** + * Scans forward from {@code rhsStart} to find where a JavaScript initializer expression ends. + * + * Unlike Java, JS has no mandatory semicolons, so this method implements a conservative + * ASI (Automatic Semicolon Insertion) heuristic: + *
    + *
  • A {@code ;} at depth 0 always terminates the expression.
  • + *
  • A newline while inside open parens, brackets, or braces does NOT terminate — + * the expression continues on the next line (e.g. multi-line object literals, + * chained calls).
  • + *
  • A newline at depth 0 terminates only if {@link #shouldContinueJsInitializer} + * says the line break is NOT a continuation. Continuation is inferred from + * the current line ending with an operator/open-bracket, or the next line + * starting with {@code .}, {@code ?.}, or {@code [}.
  • + *
+ * + * String literals (single/double-quoted) and both comment forms ({@code //} and + * {@code /* ... *\/}) are skipped so their contents never affect depth tracking. + * + * @param source the full source text to scan + * @param rhsStart the index to begin scanning (typically the character after {@code =}) + * @return the index of the terminating character (a {@code ;} or newline), or + * {@code source.length()} if the source ends before a terminator is found. + * Returns {@code rhsStart} unchanged if {@code rhsStart} is out of bounds. + */ + int findJsInitializerEnd(String source, int rhsStart) { + return findJsInitializerEnd(source, rhsStart, false); + } + + int findJsInitializerEnd(String source, int rhsStart, boolean stopAtTopLevelComma) { + if (rhsStart < 0 || rhsStart >= source.length()) { + return rhsStart; + } + + int pos = rhsStart; + int lineExprStart = rhsStart; + + int parenDepth = 0; + int bracketDepth = 0; + int braceDepth = 0; + + boolean inString = false; + char stringChar = 0; + boolean inLineComment = false; + boolean inBlockComment = false; + + while (pos < source.length()) { + char c = source.charAt(pos); + char next = (pos + 1 < source.length()) ? source.charAt(pos + 1) : 0; + + if (inLineComment) { + if (c == '\n' || c == '\r') { + inLineComment = false; + } else { + pos++; + continue; + } + } + + if (inBlockComment) { + if (c == '*' && next == '/') { + inBlockComment = false; + pos += 2; + continue; + } + pos++; + continue; + } + + if (inString) { + if (c == '\\') { + pos += (pos + 1 < source.length()) ? 2 : 1; + continue; + } + if (c == stringChar) { + inString = false; + } + pos++; + continue; + } + + if (c == '/' && next == '/') { + inLineComment = true; + pos += 2; + continue; + } + if (c == '/' && next == '*') { + inBlockComment = true; + pos += 2; + continue; + } + + if (c == '"' || c == '\'') { + inString = true; + stringChar = c; + pos++; + continue; + } + + if (c == '(') { + parenDepth++; + } else if (c == ')') { + parenDepth = Math.max(0, parenDepth - 1); + } else if (c == '[') { + bracketDepth++; + } else if (c == ']') { + bracketDepth = Math.max(0, bracketDepth - 1); + } else if (c == '{') { + braceDepth++; + } else if (c == '}') { + braceDepth = Math.max(0, braceDepth - 1); + } + + if (c == ';' && parenDepth == 0 && bracketDepth == 0 && braceDepth == 0) { + return pos; + } + + if (stopAtTopLevelComma && c == ',' && parenDepth == 0 && bracketDepth == 0 && braceDepth == 0) { + return pos; + } + + if (c == '\n' || c == '\r') { + int lineBreakPos = pos; + int nextPos = pos + 1; + if (c == '\r' && nextPos < source.length() && source.charAt(nextPos) == '\n') { + nextPos++; + } + + if (parenDepth != 0 || bracketDepth != 0 || braceDepth != 0) { + pos = nextPos; + lineExprStart = nextPos; + continue; + } + + int currentLineEnd = lineBreakPos; + while (currentLineEnd > lineExprStart && Character.isWhitespace(source.charAt(currentLineEnd - 1))) { + currentLineEnd--; + } + String currentLineExpr = source.substring(lineExprStart, currentLineEnd); + + int nextExprStart = nextPos; + while (nextExprStart < source.length()) { + char n = source.charAt(nextExprStart); + if (n == ' ' || n == '\t') { + nextExprStart++; + continue; + } + if (n == ';') { + return nextExprStart; + } + if (n == '\n' || n == '\r') { + nextExprStart++; + if (n == '\r' && nextExprStart < source.length() && source.charAt(nextExprStart) == '\n') { + nextExprStart++; + } + continue; + } + break; + } + + if (nextExprStart >= source.length()) { + return source.length(); + } + + int nextLineEnd = nextExprStart; + while (nextLineEnd < source.length()) { + char n = source.charAt(nextLineEnd); + if (n == '\n' || n == '\r' || n == ';') { + break; + } + nextLineEnd++; + } + String nextLineExpr = source.substring(nextExprStart, nextLineEnd).trim(); + + if (!shouldContinueJsInitializer(currentLineExpr, nextLineExpr)) { + return lineBreakPos; + } + + pos = nextExprStart; + lineExprStart = nextExprStart; + continue; + } + pos++; + } + return source.length(); + } + + private boolean shouldContinueJsInitializer(String currentLineExpr, String nextLineExpr) { + if (nextLineExpr.isEmpty()) { + return false; + } + + if (nextLineExpr.startsWith(".") || nextLineExpr.startsWith("?.") || nextLineExpr.startsWith("[")) { + return true; + } + + String current = currentLineExpr.trim(); + if (current.isEmpty()) { + return false; + } + + char tail = current.charAt(current.length() - 1); + return tail == '+' || tail == '-' || tail == '*' || tail == '/' || tail == '%' || + tail == '&' || tail == '|' || tail == '^' || tail == '!' || tail == '=' || + tail == '<' || tail == '>' || tail == '?' || tail == ':' || tail == ',' || + tail == '.' || tail == '(' || tail == '[' || tail == '{'; + } + + /** + * Infer the type of an expression starting at the given position. + * Handles patterns like: + * - "new TypeName()" - returns TypeName + * - "receiver.fieldOrMethod" - resolves chain and returns result type + * - "variable" - looks up variable type + * - Literals like numbers, strings, booleans + */ + private TypeInfo inferTypeFromExpression(int position) { + // Skip whitespace + while (position < text.length() && Character.isWhitespace(text.charAt(position))) + position++; + + if (position >= text.length()) + return null; + + // Check for 'new' keyword + if (text.startsWith("new ", position)) { + position += 4; + while (position < text.length() && Character.isWhitespace(text.charAt(position))) + position++; + + // Read the type name + int typeStart = position; + while (position < text.length() && Character.isJavaIdentifierPart(text.charAt(position))) + position++; + + if (position > typeStart) { + String typeName = text.substring(typeStart, position); + return resolveType(typeName, typeStart); + } + return null; + } + + // Check for string literal + if (position < text.length() && (text.charAt(position) == '"' || text.charAt(position) == '\'')) { + return resolveType("String"); + } + + // Check for numeric literal + if (position < text.length() && Character.isDigit(text.charAt(position))) { + // Check for float/double (has decimal point or f/d suffix) + int numEnd = position; + boolean hasDecimal = false; + while (numEnd < text.length() && (Character.isDigit(text.charAt(numEnd)) || + text.charAt(numEnd) == '.' || text.charAt(numEnd) == 'f' || + text.charAt(numEnd) == 'd' || text.charAt(numEnd) == 'F' || + text.charAt(numEnd) == 'D' || text.charAt(numEnd) == 'L' || + text.charAt(numEnd) == 'l')) { + if (text.charAt(numEnd) == '.') hasDecimal = true; + numEnd++; + } + String num = text.substring(position, numEnd).toLowerCase(); + if (num.endsWith("f")) return resolveType("float"); + if (num.endsWith("d") || hasDecimal) return resolveType("double"); + if (num.endsWith("l")) return resolveType("long"); + return resolveType("int"); + } + + // Check for boolean literals + if (text.startsWith("true", position) || text.startsWith("false", position)) { + return resolveType("boolean"); + } + + // Check for null + if (text.startsWith("null", position)) { + return null; // Can't infer type from null + } + + // Must be an identifier or chain - read the first identifier + if (Character.isJavaIdentifierStart(text.charAt(position))) { + int identStart = position; + while (position < text.length() && Character.isJavaIdentifierPart(text.charAt(position))) + position++; + String ident = text.substring(identStart, position); + + // Skip whitespace + while (position < text.length() && Character.isWhitespace(text.charAt(position))) + position++; + + // Check if this is the start of a chain (followed by .) + if (position < text.length() && text.charAt(position) == '.') { + // This is a chain like "event.player" or "Minecraft.getMinecraft()" + // We need to resolve the entire chain to get the final type + return inferChainType(ident, identStart, position); + } + + // Check if this is a method call (followed by ()) + if (position < text.length() && text.charAt(position) == '(') { + // Method call - check if it's a script method + if (isScriptMethod(ident)) { + MethodInfo methodInfo = getScriptMethodInfo(ident); + return (methodInfo != null) ? methodInfo.getReturnType() : null; + } + return null; + } + + // Just a variable - resolve its type + FieldInfo varInfo = resolveVariable(ident, identStart); + return (varInfo != null) ? varInfo.getTypeInfo() : null; + } + + return null; + } + + /** + * Infer the type from a chain expression starting with the given identifier. + */ + private TypeInfo inferChainType(String firstIdent, int identStart, int dotPosition) { + TypeInfo currentType = null; + + // Resolve the first segment + if ("this".equals(firstIdent)) { + currentType = resolveThisType(identStart); + } + + TypeInfo typeCheck = resolveType(firstIdent, identStart); + if (currentType == null && typeCheck != null && typeCheck.isResolved()) { + // Static access like Event.player or scriptType.field + currentType = typeCheck; + } else if (currentType == null) { + // Variable access + FieldInfo varInfo = resolveVariable(firstIdent, identStart); + currentType = (varInfo != null) ? varInfo.getTypeInfo() : null; + } + + if (currentType == null || !currentType.isResolved()) + return null; + + // Now resolve the rest of the chain + int pos = dotPosition; + while (pos < text.length() && text.charAt(pos) == '.') { + pos++; // Skip the dot + + // Skip whitespace + while (pos < text.length() && Character.isWhitespace(text.charAt(pos))) + pos++; + + if (pos >= text.length() || !Character.isJavaIdentifierStart(text.charAt(pos))) + break; + + // Read the next identifier + int segStart = pos; + while (pos < text.length() && Character.isJavaIdentifierPart(text.charAt(pos))) + pos++; + String segment = text.substring(segStart, pos); + + // Skip whitespace + while (pos < text.length() && Character.isWhitespace(text.charAt(pos))) + pos++; + + // Check if this is a method call + if (pos < text.length() && text.charAt(pos) == '(') { + // Method call + if (currentType.hasMethod(segment)) { + // Parse argument types + int closeParen = findMatchingParen(pos); + if (closeParen < 0) return null; + String argsText = text.substring(pos + 1, closeParen).trim(); + TypeInfo[] argTypes = parseArgumentTypes(argsText, pos + 1); + + // Check if this is a synthetic type with dynamic return type resolver (like Java.type()) + SyntheticType syntheticType = null; + if (isJavaScript() && typeResolver.isSyntheticType(firstIdent)) { + syntheticType = typeResolver.getSyntheticType(firstIdent); + } + + if (syntheticType != null && syntheticType.hasMethod(segment)) { + SyntheticMethod synMethod = syntheticType.getMethod(segment); + if (synMethod != null) { + // Try dynamic resolution first + String[] strArgs = TypeResolver.parseStringArguments(argsText); + TypeInfo dynamicType = synMethod.resolveReturnType(strArgs); + if (dynamicType != null) { + currentType = dynamicType; + } else { + // Fall back to static return type + currentType = synMethod.getReturnTypeInfo(); + } + } + } else { + MethodInfo methodInfo = currentType.getBestMethodOverload(segment, argTypes); + currentType = (methodInfo != null) ? methodInfo.getReturnType() : null; + } + + // Skip to after the closing paren + pos = closeParen + 1; + } else { + return null; + } + } else { + // Field access + if (currentType.hasField(segment)) { + FieldInfo fieldInfo = currentType.getFieldInfo(segment); + currentType = (fieldInfo != null) ? fieldInfo.getTypeInfo() : null; + } else { + return null; + } + } + + if (currentType == null || !currentType.isResolved()) + return null; + + // Skip whitespace for next iteration + while (pos < text.length() && Character.isWhitespace(text.charAt(pos))) + pos++; + } + + return currentType; + } + + /** + * Parse inner callable scopes (lambdas and JS function expressions). + * These are NOT added to the methods list - they're resolution-only scopes. + */ + private void parseInnerCallableScopes() { + // For Java: detect (params) -> expr and (params) -> { ... } and param -> expr + // For JS: detect function(params) { ... } that are expressions (not declarations) + + if (isJavaScript()) { + parseJSFunctionExpressions(); + parseJSArrowFunctions(); + parseJSShorthandMethods(); + } else { + parseJavaLambdas(); + } + + // Sort by header start and set up parent relationships + innerScopes.sort((a, b) -> Integer.compare(a.getHeaderStart(), b.getHeaderStart())); + setupScopeParents(); + } + + private void parseJavaLambdas() { + // Pattern: (params) -> or identifier -> + // Look for -> that's not inside strings/comments + String arrowPattern = "->"; + int pos = 0; + while ((pos = text.indexOf(arrowPattern, pos)) >= 0) { + if (isExcluded(pos)) { + pos += 2; + continue; + } + + // Found a potential lambda arrow + int arrowPos = pos; + + // Look backwards to find the parameter list + int headerStart = findLambdaHeaderStart(arrowPos); + if (headerStart < 0) { + pos += 2; + continue; + } + + // Look forward to find the body end + int bodyStart = arrowPos + 2; + // Skip whitespace after -> + while (bodyStart < text.length() && Character.isWhitespace(text.charAt(bodyStart))) { + bodyStart++; + } + + if (bodyStart >= text.length()) { + pos += 2; + continue; + } + + int bodyEnd; + if (text.charAt(bodyStart) == '{') { + // Block lambda + bodyEnd = findMatchingBrace(bodyStart); + if (bodyEnd < 0) bodyEnd = text.length(); + else bodyEnd++; // Include the closing brace + } else { + // Expression lambda - find end of expression + bodyEnd = findLambdaExpressionEnd(bodyStart); + } + + InnerCallableScope scope = new InnerCallableScope( + InnerCallableScope.Kind.JAVA_LAMBDA, + headerStart, + arrowPos + 2, + bodyStart, + bodyEnd + ); + + // Parse parameters (will be typed later during resolution) + parseLambdaParameters(scope, headerStart, arrowPos); + + innerScopes.add(scope); + pos = bodyEnd; + } + } + + private int findLambdaHeaderStart(int arrowPos) { + // Work backwards from arrow to find start of parameter list + int pos = arrowPos - 1; + + // Skip whitespace + while (pos >= 0 && Character.isWhitespace(text.charAt(pos))) { + pos--; + } + + if (pos < 0) return -1; + + if (text.charAt(pos) == ')') { + // Parenthesized params: find matching ( + int depth = 1; + pos--; + while (pos >= 0 && depth > 0) { + if (isExcluded(pos)) { + pos--; + continue; + } + char c = text.charAt(pos); + if (c == ')') depth++; + else if (c == '(') depth--; + pos--; + } + return pos + 1; // Position of '(' + } else if (Character.isJavaIdentifierPart(text.charAt(pos))) { + // Single identifier param (no parens): identifier -> + while (pos >= 0 && Character.isJavaIdentifierPart(text.charAt(pos))) { + pos--; + } + return pos + 1; + } + + return -1; + } + + private int findLambdaExpressionEnd(int start) { + // Find end of expression lambda body + // Ends at: ; , ) ] } (at depth 0) or end of text + int depth = 0; + int angleDepth = 0; + int pos = start; + boolean inString = false; + char stringChar = 0; + + while (pos < text.length()) { + char c = text.charAt(pos); + + // Handle strings + if (!inString && (c == '"' || c == '\'')) { + inString = true; + stringChar = c; + pos++; + continue; + } + if (inString) { + if (c == stringChar && (pos == 0 || text.charAt(pos - 1) != '\\')) { + inString = false; + } + pos++; + continue; + } + + // Track nesting + if (c == '(' || c == '[' || c == '{') depth++; + else if (c == ')' || c == ']' || c == '}') { + if (depth == 0) return pos; + depth--; + } + else if (c == '<') angleDepth++; + else if (c == '>') angleDepth = Math.max(0, angleDepth - 1); + else if ((c == ';' || c == ',') && depth == 0 && angleDepth == 0) { + return pos; + } + + pos++; + } + + return pos; + } + + private void parseLambdaParameters(InnerCallableScope scope, int headerStart, int arrowPos) { + String headerText = text.substring(headerStart, arrowPos).trim(); + + if (headerText.startsWith("(") && headerText.endsWith(")")) { + // Parenthesized: (a, b) or (Type a, Type b) + String paramsText = headerText.substring(1, headerText.length() - 1).trim(); + if (!paramsText.isEmpty()) { + String[] params = paramsText.split(","); + int offset = headerStart + 1; // After '(' + for (String param : params) { + param = param.trim(); + if (param.isEmpty()) continue; + + // Find position in original text + int paramOffset = text.indexOf(param, offset); + if (paramOffset < 0) paramOffset = offset; + + String[] parts = param.split("\\s+"); + String paramName; + TypeInfo paramType = null; + + if (parts.length >= 2) { + // Typed: Type name + paramName = parts[parts.length - 1]; + String typeName = parts[parts.length - 2]; + boolean isVarArg = typeName.endsWith("..."); + if (isVarArg) typeName = typeName.substring(0, typeName.length() - 3); + paramType = resolveType(typeName); + int nameOffset = text.indexOf(paramName, paramOffset); + if (nameOffset < 0) nameOffset = paramOffset; + FieldInfo paramInfo = FieldInfo.parameter(paramName, paramType, nameOffset, null); + paramInfo.setVarArg(isVarArg); + scope.addParameter(paramInfo); + } else { + // Untyped: just name (type will be inferred from expected FI) + paramName = parts[0]; + int nameOffset = text.indexOf(paramName, paramOffset); + if (nameOffset < 0) nameOffset = paramOffset; + FieldInfo paramInfo = FieldInfo.parameter(paramName, paramType, nameOffset, null); + scope.addParameter(paramInfo); + } + + offset = paramOffset + param.length(); + } + } + } else { + // Single identifier: x -> + String paramName = headerText; + int nameOffset = text.indexOf(paramName, headerStart); + if (nameOffset < 0) nameOffset = headerStart; + + FieldInfo paramInfo = FieldInfo.parameter(paramName, null, nameOffset, null); + scope.addParameter(paramInfo); + } + } + + private void parseJSFunctionExpressions() { + // Pattern: function(params) { ... } or function name(params) { ... } + // But NOT function declarations at top level (those are already in methods) + Pattern funcExprPattern = Pattern.compile("function\\s*(?:\\w+)?\\s*\\(([^)]*)\\)\\s*\\{"); + Matcher m = funcExprPattern.matcher(text); + + while (m.find()) { + int start = m.start(); + if (isExcluded(start)) continue; + + // Check if this is a function expression (not a declaration) + // A function declaration is at statement level; expression is inside parens, after =, etc. + if (isFunctionDeclaration(start)) continue; + + int headerStart = start; + int headerEnd = m.end() - 1; // Position of '{' + int bodyStart = m.end() - 1; + int bodyEnd = findMatchingBrace(bodyStart); + if (bodyEnd < 0) bodyEnd = text.length(); + else bodyEnd++; // Include closing brace + + InnerCallableScope scope = new InnerCallableScope( + InnerCallableScope.Kind.JS_FUNCTION_EXPR, + headerStart, + headerEnd, + bodyStart, + bodyEnd + ); + + // Parse parameters + String paramsText = m.group(1).trim(); + if (!paramsText.isEmpty()) { + String[] params = paramsText.split(","); + int offset = m.start(1); + for (String param : params) { + param = param.trim(); + if (param.isEmpty()) continue; + + int nameOffset = text.indexOf(param, offset); + if (nameOffset < 0) nameOffset = offset; + + // JS params don't have types by default; will infer from expected FI + FieldInfo paramInfo = FieldInfo.parameter(param, TypeInfo.ANY, nameOffset, null); + scope.addParameter(paramInfo); + + offset = nameOffset + param.length(); + } + } + + innerScopes.add(scope); + } + } + + private void parseJSArrowFunctions() { + String arrowToken = "=>"; + int pos = 0; + while ((pos = text.indexOf(arrowToken, pos)) >= 0) { + if (isExcluded(pos)) { + pos += 2; + continue; + } + + int arrowPos = pos; + int headerStart = findArrowFunctionHeaderStart(arrowPos); + if (headerStart < 0) { + pos += 2; + continue; + } + + int bodyStart = arrowPos + 2; + while (bodyStart < text.length() && Character.isWhitespace(text.charAt(bodyStart))) { + bodyStart++; + } + + if (bodyStart >= text.length()) { + pos += 2; + continue; + } + + int bodyEnd; + if (text.charAt(bodyStart) == '{') { + bodyEnd = findMatchingBrace(bodyStart); + if (bodyEnd < 0) bodyEnd = text.length(); + else bodyEnd++; + } else { + bodyEnd = findLambdaExpressionEnd(bodyStart); + } + + InnerCallableScope scope = new InnerCallableScope( + InnerCallableScope.Kind.JS_ARROW_FUNC, + headerStart, + arrowPos + 2, + bodyStart, + bodyEnd + ); + + parseArrowFunctionParameters(scope, headerStart, arrowPos); + innerScopes.add(scope); + pos = bodyEnd; + } + } + + private int findArrowFunctionHeaderStart(int arrowPos) { + int pos = arrowPos - 1; + while (pos >= 0 && Character.isWhitespace(text.charAt(pos))) { + pos--; + } + if (pos < 0) return -1; + + if (text.charAt(pos) == ')') { + int depth = 1; + pos--; + while (pos >= 0 && depth > 0) { + if (isExcluded(pos)) { pos--; continue; } + char c = text.charAt(pos); + if (c == ')') depth++; + else if (c == '(') depth--; + pos--; + } + return pos + 1; + } else if (Character.isJavaIdentifierPart(text.charAt(pos))) { + while (pos >= 0 && Character.isJavaIdentifierPart(text.charAt(pos))) { + pos--; + } + return pos + 1; + } + return -1; + } + + private void parseArrowFunctionParameters(InnerCallableScope scope, int headerStart, int arrowPos) { + String headerText = text.substring(headerStart, arrowPos).trim(); + + if (headerText.startsWith("(") && headerText.endsWith(")")) { + String paramsText = headerText.substring(1, headerText.length() - 1).trim(); + if (!paramsText.isEmpty()) { + String[] params = paramsText.split(","); + int offset = headerStart + 1; + for (String param : params) { + param = param.trim(); + if (param.isEmpty()) continue; + + int nameOffset = text.indexOf(param, offset); + if (nameOffset < 0) nameOffset = offset; + + FieldInfo paramInfo = FieldInfo.parameter(param, TypeInfo.ANY, nameOffset, null); + scope.addParameter(paramInfo); + offset = nameOffset + param.length(); + } + } + } else { + if (ObjectLiteralParser.isSimpleIdentifier(headerText)) { + int nameOffset = text.indexOf(headerText, headerStart); + if (nameOffset < 0) nameOffset = headerStart; + FieldInfo paramInfo = FieldInfo.parameter(headerText, TypeInfo.ANY, nameOffset, null); + scope.addParameter(paramInfo); + } + } + } + + private void parseJSShorthandMethods() { + Pattern shorthandPattern = Pattern.compile("(\\w+)\\s*\\(([^)]*)\\)\\s*\\{"); + Matcher m = shorthandPattern.matcher(text); + + while (m.find()) { + int start = m.start(); + if (isExcluded(start)) continue; + + if (!ObjectLiteralParser.isInsideObjectLiteral(start,this)) continue; + + String methodName = m.group(1); + if (TypeChecker.isJavaScriptKeyword(methodName)) continue; + + int headerStart = m.start(1); + int bodyStart = m.end() - 1; + int bodyEnd = findMatchingBrace(bodyStart); + if (bodyEnd < 0) bodyEnd = text.length(); + else bodyEnd++; + + InnerCallableScope scope = new InnerCallableScope( + InnerCallableScope.Kind.JS_SHORTHAND_METHOD, + headerStart, + bodyStart, + bodyStart, + bodyEnd + ); + + String paramsText = m.group(2).trim(); + if (!paramsText.isEmpty()) { + String[] params = paramsText.split(","); + int offset = m.start(2); + for (String param : params) { + param = param.trim(); + if (param.isEmpty()) continue; + + int nameOffset = text.indexOf(param, offset); + if (nameOffset < 0) nameOffset = offset; + + FieldInfo paramInfo = FieldInfo.parameter(param, TypeInfo.ANY, nameOffset, null); + scope.addParameter(paramInfo); + offset = nameOffset + param.length(); + } + } + + innerScopes.add(scope); + } + } + + private boolean isFunctionDeclaration(int funcStart) { + // A function declaration is a statement, check context: + // - If preceded by = or ( or , or : or [ it's an expression + // - If at line start (possibly with whitespace) or after { or ; it's a declaration + + int pos = funcStart - 1; + while (pos >= 0 && Character.isWhitespace(text.charAt(pos)) && text.charAt(pos) != '\n') { + pos--; + } + + if (pos < 0) return true; // Start of file = declaration + + char prev = text.charAt(pos); + // These characters indicate it's an expression, not a declaration + if (prev == '=' || prev == '(' || prev == ',' || prev == ':' || prev == '[' || prev == '?') { + return false; + } + // After newline + whitespace could be declaration + if (prev == '\n' || prev == '{' || prev == ';' || prev == '}') { + return true; + } + + return true; // Default to declaration to avoid false positives in inner scopes + } + + private void setupScopeParents() { + // For each scope, find its immediate parent (smallest enclosing scope) + for (int i = 0; i < innerScopes.size(); i++) { + InnerCallableScope scope = innerScopes.get(i); + InnerCallableScope parent = null; + + for (int j = 0; j < innerScopes.size(); j++) { + if (i == j) continue; + InnerCallableScope candidate = innerScopes.get(j); + + // Check if candidate contains scope + if (candidate.getBodyStart() < scope.getHeaderStart() && + candidate.getBodyEnd() > scope.getFullEnd()) { + // candidate contains scope + if (parent == null || + (candidate.getBodyStart() > parent.getBodyStart())) { + // candidate is smaller (more immediate) than current parent + parent = candidate; + } + } + } + + scope.setParentScope(parent); + } + } + + /** + * Parse global fields/variables (outside methods) - UNIFIED for both Java and JavaScript. + * Stores results in the shared 'globalFields' map. + * + * For Java: Parses "[modifiers] Type fieldName [= expr];" + * For JavaScript: Parses "var/let/const varName [= expr];" outside of functions + */ + private void parseGlobalFields() { + if (isJavaScript()) { + // JavaScript: var/let/const varName = expr; (outside functions) + Pattern varPattern = Pattern.compile("(?:var|let|const)\\s+(\\w+)(?:\\s*(=))?"); + Matcher m = varPattern.matcher(text); + + while (m.find()) { + int position = m.start(1); + if (isExcluded(position)) continue; + + // Check if inside a function - if so, skip (handled by parseLocalVariables) + boolean insideMethod = false; + for (MethodInfo method : getAllMethods()) { + if (method.containsPosition(position)) { + insideMethod = true; + break; + } + } + if (insideMethod) continue; + + boolean insideInner = false; + for (InnerCallableScope scope : innerScopes) { + if (scope.containsPosition(position)) { + insideInner = true; + break; + } + } + if (insideInner) continue; + + int afterVar = m.end(1); + if (afterVar < text.length() && LoopVariableParser.FOR_IN_OF_LOOKAHEAD.matcher(text.substring(afterVar)).find()) continue; + + String varName = m.group(1); + String initializer = null; + int initializerStart = -1; + int initializerEnd = -1; + if (m.group(2) != null) { + initializerStart = skipSegmentWhitespace(text, m.end(2)); + // Use comma-aware termination for multi-declarator support + initializerEnd = findJsInitializerEnd(text, initializerStart, true); + if (initializerEnd > initializerStart) { + initializer = text.substring(initializerStart, initializerEnd).trim(); + if (initializer.isEmpty()) { + initializer = null; + } + } + } + + // First, check for JSDoc type annotation + String documentation = extractDocumentationBefore(m.start()); + JSDocInfo jsDoc = jsDocParser.extractJSDocBefore(text, m.start()); + + TypeInfo typeInfo = null; + + // Priority 1: JSDoc @type takes precedence + if (jsDoc != null && jsDoc.hasTypeTag()) { + typeInfo = jsDoc.getDeclaredType(); + } + + // Priority 2: Infer from initializer if no JSDoc type + if (typeInfo == null && initializer != null && !initializer.isEmpty()) { + TypeInfo inferred = resolveExpressionType(initializer, initializerStart); + if (!TypeInfo.NULL.equals(inferred)) { + typeInfo = inferred; + } + } + + // Priority 3: Use "any" type for uninitialized variables + if (typeInfo == null) { + typeInfo = TypeInfo.ANY; + } + + int initStart = -1, initEnd = -1; + if (m.group(2) != null) { + initStart = m.start(2); + initEnd = (initializerEnd >= 0) ? initializerEnd : m.end(2); + } + + FieldInfo fieldInfo = FieldInfo.globalField(varName, typeInfo, position, documentation, initStart, initEnd, 0); + + if(jsDoc != null) + fieldInfo.setJSDocInfo(jsDoc); + + if (globalFields.containsKey(varName)) { + AssignmentInfo dupError = AssignmentInfo.duplicateDeclaration( + varName, position, position + varName.length(), + "Variable '" + varName + "' is already defined in the scope"); + declarationErrors.add(dupError); + } else { + globalFields.put(varName, fieldInfo); + } + + // Multi-declarator continuation for global JS: "var a=1, b='x', c;" + int contScanStart = MultiDeclaratorParser.jsDeclaratorScanStart(text, m.end(1), m.group(2) != null, initializerEnd); + MultiDeclaratorParser.scanJSContinuationDeclarators(this, text, contScanStart, 0, + (cVarName, cAbsNamePos, cInit, cAbsInitStart, cAbsInitEnd) -> { + if (isExcluded(cAbsNamePos)) return; + boolean cInsideMethod = false; + for (MethodInfo method : getAllMethods()) { + if (method.containsPosition(cAbsNamePos)) { cInsideMethod = true; break; } + } + if (cInsideMethod) return; + boolean cInsideInner = false; + for (InnerCallableScope sc : innerScopes) { + if (sc.containsPosition(cAbsNamePos)) { cInsideInner = true; break; } + } + if (cInsideInner) return; + + TypeInfo cType = null; + if (cInit != null && !cInit.isEmpty()) { + TypeInfo inferred = resolveExpressionType(cInit, cAbsInitStart); + if (!TypeInfo.NULL.equals(inferred)) cType = inferred; + } + if (cType == null) cType = TypeInfo.ANY; + + FieldInfo cField = FieldInfo.globalField(cVarName, cType, cAbsNamePos, null, + cAbsInitStart, cAbsInitEnd, 0); + if (globalFields.containsKey(cVarName)) { + AssignmentInfo dupErr = AssignmentInfo.duplicateDeclaration( + cVarName, cAbsNamePos, cAbsNamePos + cVarName.length(), + "Variable '" + cVarName + "' is already defined in the scope"); + declarationErrors.add(dupErr); + } else { + globalFields.put(cVarName, cField); + } + }); + } + } else { + // Java: [modifiers] Type fieldName [= expr]; + Matcher m = FIELD_DECL_PATTERN.matcher(text); + while (m.find()) { + String typeNameRaw = m.group(1); + String fieldName = m.group(2); + String delimiter = m.group(3); + int position = m.start(2); + + if (isExcluded(position)) + continue; + + // --- FIX: Detect greedy regex consuming commas into the type name --- + // Same issue as parseLocalVariables: FIELD_DECL_PATTERN greedily consumes + // multi-declarator commas into group(1). When a depth-0 comma exists in + // typeNameRaw, extract the real type and first variable, then let the + // continuation scanner handle ALL variables. + int commaInType = MultiDeclaratorParser.findFirstDepthZeroComma(typeNameRaw); + if (commaInType >= 0) { + String realTypeNameRaw = MultiDeclaratorParser.extractRealTypeFromGreedyMatch(typeNameRaw, commaInType); + String firstVar = MultiDeclaratorParser.extractFirstVarFromGreedyMatch(typeNameRaw, commaInType); + int firstVarAbsPos = MultiDeclaratorParser.findFirstVarPosition( + text, m.start(1), typeNameRaw, commaInType); + + if (isExcluded(firstVarAbsPos)) continue; + + int enclosingParen1 = findEnclosingParenStart(0, firstVarAbsPos); + if (enclosingParen1 >= 0 && "for".equals(readKeywordBefore(enclosingParen1))) continue; + + int greedyModifiers = parseModifiers(realTypeNameRaw); + String greedyTypeName = stripModifiers(realTypeNameRaw); + + // Use findEnclosingScriptType (recursive descent) so inner class fields + // are attributed to the innermost containing type, not just the first + // HashMap match (which could be the outer class). + ScriptTypeInfo greedyContainingType = findEnclosingScriptType(firstVarAbsPos); + + boolean greedyInsideMethod = false; + if (greedyContainingType != null && isInsideNestedMethod(firstVarAbsPos, + greedyContainingType.getBodyStart(), greedyContainingType.getBodyEnd())) + greedyInsideMethod = true; + else { + for (MethodInfo method : getAllMethods()) { + if (method.containsPosition(firstVarAbsPos)) { greedyInsideMethod = true; break; } + } + } + if (greedyInsideMethod) continue; + + String greedyDocumentation = extractDocumentationBefore(m.start()); + TypeInfo greedyTypeInfo = resolveType(greedyTypeName, firstVarAbsPos); + + // Register the first variable (no initializer since the regex consumed it into the type group) + FieldInfo firstField = FieldInfo.globalField(firstVar, greedyTypeInfo, firstVarAbsPos, + greedyDocumentation, -1, -1, greedyModifiers); + if (greedyContainingType != null) { + greedyContainingType.addField(firstField); + } else if (globalFields.containsKey(firstVar)) { + AssignmentInfo dupErr = AssignmentInfo.duplicateDeclaration( + firstVar, firstVarAbsPos, firstVarAbsPos + firstVar.length(), + "Variable '" + firstVar + "' is already defined in the scope"); + declarationErrors.add(dupErr); + } else { + globalFields.put(firstVar, firstField); + } + + // Scan continuations from the first depth-0 comma in the type group + final TypeInfo greedySharedType = greedyTypeInfo; + final int greedySharedMod = greedyModifiers; + final ScriptTypeInfo fGreedyContType = greedyContainingType; + int greedyScanStart = m.start(1) + commaInType; + MultiDeclaratorParser.scanJavaContinuationDeclarators(text, greedyScanStart, 0, + (cVarName, cAbsNamePos, cAbsInitStart, cAbsInitEnd) -> { + if (isExcluded(cAbsNamePos)) return; + boolean cInsideMethod = false; + if (fGreedyContType != null && isInsideNestedMethod(cAbsNamePos, + fGreedyContType.getBodyStart(), fGreedyContType.getBodyEnd())) + cInsideMethod = true; + else { + for (MethodInfo method : getAllMethods()) { + if (method.containsPosition(cAbsNamePos)) { cInsideMethod = true; break; } + } + } + if (cInsideMethod) return; + + FieldInfo cField = FieldInfo.globalField(cVarName, greedySharedType, cAbsNamePos, + null, cAbsInitStart, cAbsInitEnd, greedySharedMod); + if (fGreedyContType != null) { + fGreedyContType.addField(cField); + } else if (globalFields.containsKey(cVarName)) { + AssignmentInfo dupErr = AssignmentInfo.duplicateDeclaration( + cVarName, cAbsNamePos, cAbsNamePos + cVarName.length(), + "Variable '" + cVarName + "' is already defined in the scope"); + declarationErrors.add(dupErr); + } else { + globalFields.put(cVarName, cField); + } + }); + continue; + } + + int enclosingParen = findEnclosingParenStart(0, position); + if (enclosingParen >= 0 && "for".equals(readKeywordBefore(enclosingParen))) + continue; + + int modifiers = parseModifiers(typeNameRaw); + String typeName = stripModifiers(typeNameRaw); + + // Use findEnclosingScriptType (recursive descent) so inner class fields + // are attributed to the innermost containing type, not just the first + // HashMap match (which could be the outer class). + ScriptTypeInfo containingScriptType = findEnclosingScriptType(position); + + // Check if inside a method - if so, it's a local, not global + boolean insideMethod = false; + if (containingScriptType != null && isInsideNestedMethod(position, containingScriptType.getBodyStart(), + containingScriptType.getBodyEnd())) + insideMethod = true; + else { + for (MethodInfo method : getAllMethods()) { + if (method.containsPosition(position)) { + insideMethod = true; + break; + } + } + } + + if (insideMethod) + continue; + + String documentation = extractDocumentationBefore(m.start()); + + int initStart = -1; + int initEnd = -1; + if ("=".equals(delimiter)) { + initStart = m.start(3); + int searchPos = m.end(3); + int depth = 0; + // Stop at ',' or ';' at depth 0 so that multi-declarator + // statements like "int x = 1, y, z = 3;" correctly bound + // the initializer of x to just "1" (not "1, y, z = 3"). + while (searchPos < text.length()) { + char c = text.charAt(searchPos); + if (c == '(' || c == '[' || c == '{') depth++; + else if (c == ')' || c == ']' || c == '}') depth--; + else if ((c == ';' || c == ',') && depth == 0) { + initEnd = searchPos; + break; + } + searchPos++; + } + } + + // Use position-aware resolution so inner class type names resolve correctly + TypeInfo typeInfo = resolveType(typeName, position); + FieldInfo fieldInfo = FieldInfo.globalField(fieldName, typeInfo, position, documentation, initStart, initEnd, modifiers); + + if (containingScriptType != null) { + containingScriptType.addField(fieldInfo); + } else if (globalFields.containsKey(fieldName)) { + AssignmentInfo dupError = AssignmentInfo.duplicateDeclaration( + fieldName, position, position + fieldName.length(), + "Variable '" + fieldName + "' is already defined in the scope"); + declarationErrors.add(dupError); + } else { + globalFields.put(fieldName, fieldInfo); + } + + // --- Multi-declarator continuation for global Java fields --- + // For "int x = 1, y, z = 3;" FIELD_DECL_PATTERN matched "int x =" + // (or "int x,"). Scan forward for comma-separated continuation + // declarators (y, z) that share the same declared type. + final TypeInfo sharedType = typeInfo; + final int sharedModifiers = modifiers; + final ScriptTypeInfo fContainingType = containingScriptType; + int javaScanStart = MultiDeclaratorParser.javaDeclaratorScanStart(text, delimiter, m.end(3), + initEnd >= 0 ? initEnd : -1); + if (javaScanStart >= 0) { + MultiDeclaratorParser.scanJavaContinuationDeclarators(text, javaScanStart, 0, + (cVarName, cAbsNamePos, cAbsInitStart, cAbsInitEnd) -> { + if (isExcluded(cAbsNamePos)) return; + // Check if inside a method — if so, skip (it's a local, not global) + boolean cInsideMethod = false; + if (fContainingType != null && isInsideNestedMethod(cAbsNamePos, + fContainingType.getBodyStart(), fContainingType.getBodyEnd())) + cInsideMethod = true; + else { + for (MethodInfo method : getAllMethods()) { + if (method.containsPosition(cAbsNamePos)) { cInsideMethod = true; break; } + } + } + if (cInsideMethod) return; + + FieldInfo cField = FieldInfo.globalField(cVarName, sharedType, cAbsNamePos, + null, cAbsInitStart, cAbsInitEnd, sharedModifiers); + if (fContainingType != null) { + fContainingType.addField(cField); + } else if (globalFields.containsKey(cVarName)) { + AssignmentInfo dupErr = AssignmentInfo.duplicateDeclaration( + cVarName, cAbsNamePos, cAbsNamePos + cVarName.length(), + "Variable '" + cVarName + "' is already defined in the scope"); + declarationErrors.add(dupErr); + } else { + globalFields.put(cVarName, cField); + } + }); + } + } + } + } + + /** + * Strip Java modifiers from a type name string. + * e.g., "public static String" -> "String" + */ + private String stripModifiers(String typeName) { + if (typeName == null) return null; + + String[] parts = typeName.trim().split("\\s+"); + // Filter out known modifiers + StringBuilder result = new StringBuilder(); + for (String part : parts) { + if (!TypeResolver.isModifier(part)) { + if (result.length() > 0) result.append(" "); + result.append(part); + } + } + return result.toString(); + } + + /** + * Parse modifiers from a declaration string and return the corresponding Modifier flags. + * e.g., "public static final" -> Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL + */ + private int parseModifiers(String declaration) { + if (declaration == null) return 0; + + int modifiers = 0; + String[] parts = declaration.trim().split("\\s+"); + for (String part : parts) { + if (part.equals("public")) modifiers |= java.lang.reflect.Modifier.PUBLIC; + else if (part.equals("private")) modifiers |= java.lang.reflect.Modifier.PRIVATE; + else if (part.equals("protected")) modifiers |= java.lang.reflect.Modifier.PROTECTED; + else if (part.equals("static")) modifiers |= java.lang.reflect.Modifier.STATIC; + else if (part.equals("final")) modifiers |= java.lang.reflect.Modifier.FINAL; + else if (part.equals("abstract")) modifiers |= java.lang.reflect.Modifier.ABSTRACT; + else if (part.equals("synchronized")) modifiers |= java.lang.reflect.Modifier.SYNCHRONIZED; + else if (part.equals("volatile")) modifiers |= java.lang.reflect.Modifier.VOLATILE; + else if (part.equals("transient")) modifiers |= java.lang.reflect.Modifier.TRANSIENT; + else if (part.equals("native")) modifiers |= java.lang.reflect.Modifier.NATIVE; + else if (part.equals("strictfp")) modifiers |= java.lang.reflect.Modifier.STRICT; + } + return modifiers; + } + + /** + * Scan backwards from scanStart position in the given text to extract modifier keywords. + * Returns the parsed modifier flags. + * + * @param scanStart The position to start scanning backwards from (exclusive) + * @param sourceText The text to scan in + * @return The combined modifier flags + */ + private int extractModifiersBackwards(int scanStart, String sourceText) { + // Skip whitespace + while (scanStart >= 0 && Character.isWhitespace(sourceText.charAt(scanStart))) { + scanStart--; + } + + // Scan backwards collecting modifier words + StringBuilder modifiersText = new StringBuilder(); + while (scanStart >= 0) { + // Skip whitespace + while (scanStart >= 0 && Character.isWhitespace(sourceText.charAt(scanStart))) { + scanStart--; + } + if (scanStart < 0) break; + + // Read a word backwards + int wordEnd = scanStart + 1; + while (scanStart >= 0 && Character.isJavaIdentifierPart(sourceText.charAt(scanStart))) { + scanStart--; + } + int wordStart = scanStart + 1; + if (wordStart < wordEnd) { + String word = sourceText.substring(wordStart, wordEnd); + // Check if it's a modifier + if (TypeResolver.isModifier(word)) { + if (modifiersText.length() > 0) { + modifiersText.insert(0, " "); + } + modifiersText.insert(0, word); + } else { + // Hit a non-modifier word, stop scanning + break; + } + } else { + break; + } + } + + // Parse the collected modifiers + return parseModifiers(modifiersText.toString()); + } + + /** + * Extract documentation comment immediately preceding a position. + * Supports both single-line (//) and multi-line (/* *\/) comment styles. + * Returns null if no documentation is found. + * + * @param position The position of the declaration (e.g., start of method/field) + * @return The documentation text, or null if none found + */ + private String extractDocumentationBefore(int position) { + if (position <= 0) return null; + + // First, skip backwards to get off the current declaration line + // (declarations might have modifiers like 'public' before the matched position) + int searchStart = position - 1; + + // Skip backwards to the previous newline + while (searchStart >= 0 && text.charAt(searchStart) != '\n') { + searchStart--; + } + + if (searchStart < 0) return null; + + // Now we're at a newline before the declaration line + // Skip backwards through any additional whitespace + searchStart--; + while (searchStart >= 0 && Character.isWhitespace(text.charAt(searchStart))) { + searchStart--; + } + + if (searchStart < 0) return null; + + // Now searchStart should be at the last non-whitespace character before the declaration line + + // Check if we're at the end of a comment + // Case 1: Multi-line comment ending with */ + if (searchStart > 0 && text.charAt(searchStart) == '/' && text.charAt(searchStart - 1) == '*') { + // Find the start of this comment + int commentEnd = searchStart + 1; + int commentStart = text.lastIndexOf("/*", searchStart - 1); + if (commentStart >= 0) { + String comment = text.substring(commentStart, commentEnd); + return cleanDocumentation(comment); + } + } + + // Case 2: Single-line comments (may be multiple consecutive lines) + StringBuilder doc = new StringBuilder(); + int currentPos = searchStart; + + // Walk backward through consecutive comment lines + while (currentPos >= 0) { + // Find start of current line + int lineStart = currentPos; + while (lineStart > 0 && text.charAt(lineStart - 1) != '\n') { + lineStart--; + } + + // Find end of current line + int lineEnd = currentPos; + while (lineEnd < text.length() && text.charAt(lineEnd) != '\n') { + lineEnd++; + } + + // Extract the line and trim + String line = text.substring(lineStart, lineEnd).trim(); + + // Check if this line is a comment + if (line.startsWith("//") || line.startsWith("#")) { + // Prepend to doc (we're going backwards) + String commentText = line.substring(2).trim(); + if (doc.length() > 0) { + doc.insert(0, "\n"); + } + doc.insert(0, commentText); + + // Move to previous line + if (lineStart > 0) { + currentPos = lineStart - 1; + // Skip to previous line (skip the newline) + while (currentPos >= 0 && text.charAt(currentPos) == '\n') { + currentPos--; + } + } else { + break; + } + } else { + // Not a comment line, stop + break; + } + } + + if (doc.length() > 0) { + return doc.toString(); + } + + return null; + } + + /** + * Clean up documentation comment text by removing comment markers and extra formatting. + */ + private String cleanDocumentation(String comment) { + if (comment == null || comment.isEmpty()) return null; + + // Remove /* and */ markers + comment = comment.replaceAll("^/\\*+\\s*", "").replaceAll("\\s*\\*+/$", ""); + + // Split into lines and clean each one + String[] lines = comment.split("\n"); + StringBuilder cleaned = new StringBuilder(); + + for (String line : lines) { + // Remove leading asterisks and whitespace + line = line.trim().replaceAll("^\\*+\\s*", ""); + if (cleaned.length() > 0 && !line.isEmpty()) { + cleaned.append("\n"); + } + if (!line.isEmpty()) { + cleaned.append(line); + } + } + + String result = cleaned.toString().trim(); + return result.isEmpty() ? null : result; + } + + public TypeInfo resolveType(String typeName) { + /** + * Resolve a JS type name to unified TypeInfo. + * Handles JS primitives, .d.ts defined types, and falls back to Java types. + */ + if (isJavaScript()) + return typeResolver.resolveJSType(typeName); + + return resolveTypeAndTrackUsage(typeName); + } + + /** + * Position-aware type resolution overload. + * Resolves a type name with positional context so that an unqualified inner class name + * (e.g., just "Inner") resolves correctly when the cursor/position is inside the body + * of an enclosing type that declares that inner class. + * + * Resolution order: + * 1. Standard resolveType(typeName) — handles simple names, dot-names, imports, primitives + * 2. If unresolved and the name is a simple identifier (no dots), check the enclosing + * type at 'position' for an inner class with that name. + * This walks the nesting hierarchy upward so "Inner" resolves even from deeply nested code. + * + * @param typeName The type name to resolve (simple or dot-separated) + * @param position The absolute offset in the script text for scope context + * @return The resolved TypeInfo, or an unresolved TypeInfo if not found + */ + public TypeInfo resolveType(String typeName, int position) { + // First: delegate to the standard (positionless) resolver + TypeInfo resolved = resolveType(typeName); + + // If already resolved, no need for positional fallback + if (resolved != null && resolved.isResolved()) { + return resolved; + } + + // Positional fallback: only applies to simple names (no dots) that could be + // inner classes visible from the current scope. Dot-separated names like + // "Outer.Inner" are already handled by scriptTypesByDotName in resolveType(). + if (typeName != null && !typeName.contains(".")) { + // Walk the enclosing type hierarchy upward from the innermost type at this position. + // At each level, check if there's an inner class matching the name. + // This mirrors Java's scoping rules where inner classes shadow outer-scope types. + ScriptTypeInfo enclosing = findEnclosingScriptType(position); + while (enclosing != null) { + ScriptTypeInfo inner = enclosing.getInnerClass(typeName); + if (inner != null) { + return inner; + } + // Move up to the parent type — inner classes of outer types are also in scope + enclosing = enclosing.getOuterClass(); + } + } + + // Return whatever resolveType() returned (possibly unresolved) + return resolved; + } + + /** + * Resolve a type and track the import usage for unused import detection. + * Checks script-defined types first, then falls back to imported types. + * Used for Java/Groovy scripts. + */ + private TypeInfo resolveTypeAndTrackUsage(String typeName) { + if (typeName == null || typeName.isEmpty()) + return TypeInfo.unresolved(typeName, typeName); + + final String normalized = typeName.trim(); + final String normalizedFinal = stripLeadingModifiers(normalized); + + // Split array suffixes first + TypeStringNormalizer.ArraySplit arraySplit = TypeStringNormalizer.splitArraySuffixes(normalizedFinal); + String baseExpr = arraySplit.base; + int arrayDims = arraySplit.dimensions; + + // Base type resolver with import tracking + Function resolveBase = baseName -> { + TypeInfo resolved; + + // Primitives + if (TypeResolver.isPrimitiveType(baseName)) { + resolved = TypeInfo.fromPrimitive(baseName); + } + // Common java.lang.String + else if ("String".equals(baseName)) { + resolved = typeResolver.resolveFullName("java.lang.String"); + } + // Script-defined types (simple names only) + else if (!baseName.contains(".") && scriptTypes.containsKey(baseName)) { + resolved = scriptTypes.get(baseName); + } + // Script-defined inner types (dot-separated, e.g., "Outer.Inner") + // Checked before Java full-name resolution so script types shadow Java types + else if (baseName.contains(".") && scriptTypesByDotName.containsKey(baseName)) { + resolved = scriptTypesByDotName.get(baseName); + } + // Fully-qualified Java types + else if (baseName.contains(".")) { + resolved = typeResolver.resolveFullName(baseName); + } + // Imported/simple + else { + resolved = typeResolver.resolveSimpleName(baseName, importsBySimpleName, wildcardPackages); + + // Track import usage + if (resolved != null && resolved.isResolved()) { + ImportData usedImport = importsBySimpleName.get(baseName); + if (usedImport != null) { + usedImport.incrementUsage(); + } else if (wildcardPackages != null) { + String resultPkg = resolved.getPackageName(); + for (ImportData imp : imports) { + if (imp.isWildcard() && resultPkg != null && resultPkg.equals(imp.getFullPath())) { + imp.incrementUsage(); + break; + } + } + } + } + } + + return resolved != null ? resolved : TypeInfo.unresolved(baseName, normalizedFinal); + }; + + TypeInfo resolved; + + // Fast path: no generics - skip expensive parsing + if (!baseExpr.contains("<")) { + resolved = resolveBase.apply(baseExpr); + } else { + // Slow path: parse and resolve generics + GenericTypeParser.ParsedType parsed = GenericTypeParser.parse(baseExpr); + if (parsed != null) { + // Normalize whitespace around dots in base name + String baseName = parsed.baseName.replaceAll("\\s*\\.\\s*", ".").trim(); + resolved = resolveBase.apply(baseName); + + // Apply generic arguments + if (parsed.hasTypeArgs() && resolved != null && resolved.isResolved()) { + List resolvedArgs = new ArrayList<>(); + for (GenericTypeParser.ParsedType argParsed : parsed.typeArgs) { + if (argParsed == null) { + resolvedArgs.add(TypeInfo.fromClass(Object.class)); + } else { + TypeInfo argType = resolveTypeAndTrackUsage(argParsed.rawString); + resolvedArgs.add(argType != null ? argType : TypeInfo.unresolved(argParsed.baseName, + argParsed.baseName)); + } + } + if (!resolvedArgs.isEmpty()) { + resolved = resolved.parameterize(resolvedArgs); + } + } + } else + // Fallback: treat as simple type + resolved = resolveBase.apply(baseExpr); + } + + // Apply array dimensions + for (int i = 0; i < arrayDims; i++) { + resolved = TypeInfo.arrayOf(resolved); + } + + return resolved; + } + + /** + * Strip only LEADING Java modifiers from a type expression. + * This avoids breaking generic argument lists which may contain whitespace. + */ + private String stripLeadingModifiers(String typeExpr) { + if (typeExpr == null) { + return null; + } + int i = 0; + int len = typeExpr.length(); + while (i < len) { + while (i < len && Character.isWhitespace(typeExpr.charAt(i))) i++; + int start = i; + while (i < len && Character.isJavaIdentifierPart(typeExpr.charAt(i))) i++; + if (start == i) { + break; + } + String word = typeExpr.substring(start, i); + if (TypeResolver.isModifier(word)) { + // Continue stripping modifiers + continue; + } + // Not a modifier; rewind to the start of this token + return typeExpr.substring(start).trim(); + } + return typeExpr.trim(); + } + + // ==================== PHASE 4: BUILD MARKS ==================== + + /** + * Build syntax highlighting marks - UNIFIED for both Java and JavaScript. + * Uses the SAME mark methods for both languages since they share data structures. + */ + private List buildMarks() { + List marks = new ArrayList<>(); + + // Strings first to protect their content + addPatternMarks(marks, STRING_PATTERN, TokenType.STRING); + + // JSDoc comments with fragmented marking (avoids conflicts with @tags and {Type}) + markJSDocElements(marks); + + // Regular comments (non-JSDoc) + markNonJSDocComments(marks); + + // Keywords - same for both languages (KEYWORD_PATTERN includes JS keywords like function, var, let, const) + addPatternMarks(marks, KEYWORD_PATTERN, TokenType.KEYWORD); + if(isJavaScript()) + addPatternMarks(marks, KEYWORD_JS_PATTERN, TokenType.KEYWORD); + + // Numbers - same for both languages + addPatternMarks(marks, NUMBER_PATTERN, TokenType.LITERAL); + + if (isJavaScript()) { + markObjectLiteralKeys(marks); + } + + // Import statements - Java only + if (!isJavaScript()) { + markImports(marks); + } + + // Class/interface/enum declarations - Java only + if (!isJavaScript()) { + markClassDeclarations(marks); + markEnumConstants(marks); + } + + // Modifiers - Java only + if (!isJavaScript()) { + addPatternMarks(marks, MODIFIER_PATTERN, TokenType.MODIFIER); + } + + // Type declarations and usages - Java only (JS doesn't have explicit types) + if (!isJavaScript()) { + markTypeDeclarations(marks); + } + + // Methods/functions - UNIFIED (uses shared 'methods' list) + markMethodDeclarations(marks); + + // Method calls - UNIFIED (stores in shared 'methodCalls' list) + markMethodCalls(marks); + + // Variables and fields - UNIFIED (uses shared globalFields, methodLocals) + markVariables(marks); + + // Chained field accesses - UNIFIED (uses resolveVariable which handles both) + markChainedFieldAccesses(marks); + markImportedClassUsages(marks); + + // Java-specific final passes + if (!isJavaScript()) { + markCastTypes(marks); + markUnusedImports(marks); + // Mark method reference expressions (target::methodName) + markMethodReferences(marks); + } + + // Mark lambda and method reference operators (-> and ::) + markLambdaOperators(marks); + + // Mark lambda/function parameters with type info + markInnerScopeParameters(marks); + + // Validate lambda return types + validateLambdaReturnTypes(marks); + + // Final pass: Mark any remaining unmarked identifiers as undefined + markUndefinedIdentifiers(marks); + + return marks; + } + + private void markObjectLiteralKeys(List marks) { + for (ObjectLiteralParser.ObjectLiteralAnalysis analysis : objectLiterals.values()) { + for (ObjectLiteralParser.ObjectLiteralProperty p : analysis.properties) { + if (p.isIdentifierKey) { + marks.add(new ScriptLine.Mark(p.keyStartAbs, p.keyEndAbs, TokenType.LOCAL_FIELD)); + } + } + } + } + + private void parseObjectLiterals() { + if (!isJavaScript()) return; + int i = 0; + while (i < text.length()) { + int brace = text.indexOf('{', i); + if (brace < 0) break; + if (isExcluded(brace) || !isLikelyObjectLiteralStart(brace)) { + i = brace + 1; + continue; + } + int end = findMatchingBraceEndInDocument(brace); + if (end <= brace) { + i = brace + 1; + continue; + } + String objectLiteral = text.substring(brace, end); + ObjectLiteralParser.ObjectLiteralAnalysis analysis = + ObjectLiteralParser.parse(objectLiteral, brace, true, true, this::resolveExpressionType, this::getScriptMethodInfo); + if (analysis != null) + objectLiterals.put(brace, analysis); + + i = brace + 1; + } + // Wire each object-literal inner scope to its containing object type (needs the cache) + for (InnerCallableScope scope : innerScopes) + ObjectLiteralParser.attachObjectLiteralContext(scope, this); + + } + + private boolean isLikelyObjectLiteralStart(int bracePos) { + int prev = bracePos - 1; + while (prev >= 0 && Character.isWhitespace(text.charAt(prev))) { + prev--; + } + if (prev < 0) { + return false; + } + + char pc = text.charAt(prev); + if (pc == '=' || pc == '(' || pc == '[' || pc == ',' || pc == ':' || pc == '?' || pc == '!' || + pc == '+' || pc == '-' || pc == '*' || pc == '/' || pc == '%' || pc == '&' || pc == '|' || + pc == '^') { + return true; + } + + if (Character.isJavaIdentifierPart(pc)) { + int end = prev + 1; + int start = prev; + while (start >= 0 && Character.isJavaIdentifierPart(text.charAt(start))) { + start--; + } + start++; + String word = text.substring(start, end); + return "return".equals(word); + } + + return false; + } + + private int findMatchingBraceEndInDocument(int braceStart) { + int depth = 0; + for (int pos = braceStart; pos < text.length(); pos++) { + if (isExcluded(pos)) { + continue; + } + char c = text.charAt(pos); + if (c == '{') { + depth++; + } else if (c == '}') { + depth--; + if (depth == 0) { + return pos + 1; + } + } + } + return -1; + } + + + + + + + /** + * Mark lambda arrow (->) and method reference (::) operators. + */ + private void markLambdaOperators(List marks) { + // Mark -> operators (lambda arrows) + for (int i = 0; i < text.length() - 1; i++) { + if (text.charAt(i) == '-' && text.charAt(i + 1) == '>') { + if (!isExcluded(i)) { + marks.add(new ScriptLine.Mark(i, i + 2, TokenType.KEYWORD)); + } + } + } + + // Mark :: operators (method references) + for (int i = 0; i < text.length() - 1; i++) { + if (text.charAt(i) == ':' && text.charAt(i + 1) == ':') { + if (!isExcluded(i)) { + marks.add(new ScriptLine.Mark(i, i + 2, TokenType.DEFAULT)); + } + } + } + } + + /** + * Pattern for method reference: target::methodName + * target can be: identifier, qualified name (a.b.c), or 'this'/'super' + */ + private static final java.util.regex.Pattern METHOD_REF_PATTERN = + java.util.regex.Pattern.compile("([a-zA-Z_$][a-zA-Z0-9_$]*(?:\\.[a-zA-Z_$][a-zA-Z0-9_$]*)*)\\s*::\\s*([a-zA-Z_$][a-zA-Z0-9_$]*|new)"); + + /** + * Mark method reference expressions with appropriate token types. + * Target gets its resolved type's token, method name gets METHOD_CALL if valid. + * Validates that the method exists on the target type. + */ + private void markMethodReferences(List marks) { + java.util.regex.Matcher m = METHOD_REF_PATTERN.matcher(text); + while (m.find()) { + int targetStart = m.start(1); + int targetEnd = m.end(1); + int methodStart = m.start(2); + int methodEnd = m.end(2); + + // Skip if in excluded region (string/comment) + if (isExcluded(targetStart) || isExcluded(methodStart)) { + continue; + } + + String target = m.group(1); + String methodName = m.group(2); + + // Check if there are parentheses after the method name (invalid for method references) + if (methodEnd < text.length() && text.charAt(methodEnd) == '(') { + // Mark the :: as error + int doubleColonPos = targetEnd; + while (doubleColonPos < methodStart && text.charAt(doubleColonPos) != ':') { + doubleColonPos++; + } + if (doubleColonPos < methodStart) { + marks.add(new ScriptLine.Mark(doubleColonPos, doubleColonPos + 2, TokenType.UNDEFINED_VAR, + TokenErrorMessage.from("Method references cannot have parentheses. Use '" + target + "::" + methodName + "' instead of '" + target + "::" + methodName + "()'"))); + } + // Also mark the method name as error + marks.add(new ScriptLine.Mark(methodStart, methodEnd, TokenType.UNDEFINED_VAR, + TokenErrorMessage.from("Method references cannot have parentheses"))); + // Mark opening paren as error too + marks.add(new ScriptLine.Mark(methodEnd, methodEnd + 1, TokenType.UNDEFINED_VAR, + TokenErrorMessage.from("Remove parentheses from method reference"))); + continue; // Skip normal processing for this invalid reference + } + + // Mark the target based on what it resolves to + markMethodRefTarget(marks, target, targetStart, targetEnd); + + // Resolve the target type to validate method existence + TypeInfo targetType = resolveMethodRefTargetType(target, targetStart); + + if (targetType != null && targetType.isResolved()) { + // Handle constructor references (::new) + if ("new".equals(methodName)) { + if (targetType.hasConstructors()) { + MethodInfo ctorInfo = targetType.findConstructor(0); + if (ctorInfo == null) { + List ctors = targetType.getConstructors(); + if (!ctors.isEmpty()) { + ctorInfo = ctors.get(0); + } + } + marks.add(new ScriptLine.Mark(methodStart, methodEnd, TokenType.METHOD_CALL, ctorInfo)); + } else { + // No constructors found + marks.add(new ScriptLine.Mark(methodStart, methodEnd, TokenType.UNDEFINED_VAR, + TokenErrorMessage.from("No constructor found for '" + targetType.getSimpleName() + "'"))); + } + } else if (targetType.hasMethod(methodName)) { + // Method exists - get the MethodInfo for metadata + MethodInfo methodInfo = targetType.getMethodInfo(methodName); + if (methodInfo == null) { + // Try getting from overloads if single getMethodInfo fails + List overloads = targetType.getAllMethodOverloads(methodName); + if (!overloads.isEmpty()) { + methodInfo = overloads.get(0); + } + } + marks.add(new ScriptLine.Mark(methodStart, methodEnd, TokenType.METHOD_CALL, methodInfo)); + } else { + // Method does not exist on target type + marks.add(new ScriptLine.Mark(methodStart, methodEnd, TokenType.UNDEFINED_VAR, + TokenErrorMessage.from("Method '" + methodName + "' not found in '" + targetType.getSimpleName() + "'"))); + } + } else { + // Could not resolve target type - mark method as potentially valid (no error) + // This allows for cases where the target type cannot be resolved but might be valid at runtime + marks.add(new ScriptLine.Mark(methodStart, methodEnd, TokenType.UNDEFINED_VAR)); + } + } + } + + /** + * Resolve the target type for a method reference expression. + * @param target The target expression (e.g., "this", "String", "java.util.Arrays") + * @param position The position in the text for scope resolution + * @return The resolved TypeInfo, or null if it cannot be resolved + */ + private TypeInfo resolveMethodRefTargetType(String target, int position) { + // Handle keywords + if ("this".equals(target)) { + // Resolve 'this' to the enclosing type + ScriptTypeInfo enclosingType = findEnclosingScriptType(position); + if (enclosingType != null) { + return enclosingType; + } + // For hook methods, resolve to the implied 'this' type + MethodInfo containingMethod = findContainingMethod(position); + if (containingMethod != null && containingMethod.getContainingType() != null) { + return containingMethod.getContainingType(); + } + return null; + } + + if ("super".equals(target)) { + // Resolve 'super' to the parent type of the enclosing class + ScriptTypeInfo enclosingType = findEnclosingScriptType(position); + if (enclosingType != null && enclosingType.hasSuperClass()) { + return enclosingType.getSuperClass(); + } + return null; + } + + // Handle qualified names (a.b.ClassName) + if (target.contains(".")) { + TypeInfo typeInfo = resolveType(target, position); + if (typeInfo != null && typeInfo.isResolved()) { + return typeInfo; + } + // Could not resolve as type - leave unresolved + return null; + } + + // Simple identifier - try as variable first (instance reference like myList::add) + FieldInfo varInfo = resolveVariable(target, position); + if (varInfo != null && varInfo.getTypeInfo() != null) { + return varInfo.getTypeInfo(); + } + + // Try as type name (class reference like String::valueOf) + TypeInfo typeInfo = resolveType(target, position); + if (typeInfo != null && typeInfo.isResolved()) { + return typeInfo; + } + + return null; + } + + /** + * Mark the target of a method reference with the appropriate token type. + */ + private void markMethodRefTarget(List marks, String target, int start, int end) { + // Handle keywords + if ("this".equals(target)) { + marks.add(new ScriptLine.Mark(start, end, TokenType.KEYWORD)); + return; + } + if ("super".equals(target)) { + marks.add(new ScriptLine.Mark(start, end, TokenType.KEYWORD)); + return; + } + + // Handle qualified names (a.b.ClassName) - mark the whole thing + if (target.contains(".")) { + // Try to resolve as a type + TypeInfo typeInfo = resolveType(target); + if (typeInfo != null && typeInfo.isResolved()) { + addTypeMark(marks, start, end, TokenType.IMPORTED_CLASS, typeInfo); + return; + } + // Otherwise mark the parts separately + markQualifiedTargetParts(marks, target, start); + return; + } + + // Simple identifier - determine its token type + // Check for local variable + FieldInfo varInfo = resolveVariable(target, start); + if (varInfo != null) { + TokenType tokenType = varInfo.isParameter() ? TokenType.PARAMETER + : varInfo.isGlobal() ? TokenType.GLOBAL_FIELD + : TokenType.LOCAL_FIELD; + marks.add(new ScriptLine.Mark(start, end, tokenType, varInfo)); + return; + } + + // Check for type name (imported class) + TypeInfo typeInfo = resolveType(target); + if (typeInfo != null && typeInfo.isResolved()) { + addTypeMark(marks, start, end, TokenType.IMPORTED_CLASS, typeInfo); + return; + } + + // Unknown - leave as default + } + + /** + * Mark parts of a qualified name like java.util.Arrays::asList + */ + private void markQualifiedTargetParts(List marks, String qualifiedName, int baseStart) { + String[] parts = qualifiedName.split("\\."); + int offset = baseStart; + for (int i = 0; i < parts.length; i++) { + String part = parts[i]; + int partEnd = offset + part.length(); + + if (i == parts.length - 1) { + // Last part is typically the class name + marks.add(new ScriptLine.Mark(offset, partEnd, TokenType.IMPORTED_CLASS)); + } else { + // Package parts + marks.add(new ScriptLine.Mark(offset, partEnd, TokenType.TYPE_DECL)); + } + + offset = partEnd + 1; // +1 for the dot + } + } + + /** + * Mark parameters in all inner callable scopes (lambdas and JS function expressions). + */ + private void markInnerScopeParameters(List marks) { + for (InnerCallableScope scope : innerScopes) { + for (FieldInfo param : scope.getParameters()) { + int start = param.getDeclarationOffset(); + int end = start + param.getName().length(); + + // Use FieldInfo as metadata - hover system will extract tooltip + marks.add(new ScriptLine.Mark(start, end, TokenType.PARAMETER, param)); + } + } + } + + /** + * Validate lambda return types against expected SAM return type. + */ + private void validateLambdaReturnTypes(List marks) { + for (InnerCallableScope scope : innerScopes) { + if (scope.getKind() == InnerCallableScope.Kind.JAVA_LAMBDA || + scope.getKind() == InnerCallableScope.Kind.JS_FUNCTION_EXPR || + scope.getKind() == InnerCallableScope.Kind.JS_ARROW_FUNC || + scope.getKind() == InnerCallableScope.Kind.JS_SHORTHAND_METHOD) { + validateLambdaReturnType(scope, marks); + } + } + } + + /** + * Validate that a lambda's body return type matches the expected SAM return type. + */ + private void validateLambdaReturnType(InnerCallableScope lambda, List marks) { + TypeInfo expectedType = lambda.getExpectedType(); + if (expectedType == null || !expectedType.isFunctionalInterface()) { + return; // No expected type to validate against + } + + MethodInfo sam = expectedType.getSingleAbstractMethod(); + if (sam == null) { + return; + } + + TypeInfo expectedReturnType = sam.getReturnType(); + + int bodyStart = lambda.getBodyStart(); + int bodyEnd = lambda.getBodyEnd(); + if (bodyStart < 0 || bodyEnd <= bodyStart || bodyEnd > text.length()) { + return; + } + + String bodyText = text.substring(bodyStart, bodyEnd).trim(); + + if (bodyText.startsWith("{")) { + // Block lambda - validate return statements + validateBlockLambdaReturns(lambda, bodyStart, bodyEnd, expectedReturnType, marks); + } else { + // Expression lambda - validate expression type + try { + TypeInfo bodyType = resolveExpressionType(bodyText, bodyStart); + + if (bodyType != null && expectedReturnType != null) { + // Check compatibility + if (!isCompatibleType(bodyType, expectedReturnType)) { + // Mark error at body start + String error = "Incompatible return type: expected " + + expectedReturnType.getSimpleName() + + " but was " + bodyType.getSimpleName(); + marks.add(new ScriptLine.Mark(bodyStart, bodyEnd, TokenType.UNDEFINED_VAR, TokenErrorMessage.from(error))); + } + } + } catch (Exception e) { + // Fail soft - don't crash on malformed expressions + } + } + } + + /** + * Validate return statements in a block lambda (one with { }). + * Checks that all return statements return compatible types with the expected SAM return type. + */ + private void validateBlockLambdaReturns(InnerCallableScope lambda, int blockStart, int blockEnd, + TypeInfo expectedReturnType, List marks) { + // Find all return statements in the block + String blockText = text.substring(blockStart, blockEnd); + Pattern returnPattern = Pattern.compile("\\breturn\\b(\\s*;|\\s+[^;]+;)"); + Matcher m = returnPattern.matcher(blockText); + + while (m.find()) { + int returnStart = blockStart + m.start(); + int returnEnd = blockStart + m.end(); + + if (isExcluded(returnStart)) { + continue; + } + + // Get the return expression (if any) + String returnStmt = m.group(1).trim(); + + if (returnStmt.equals(";")) { + // return; - void return + if (expectedReturnType != null && !expectedReturnType.getSimpleName().equals("void")) { + String error = "Cannot return void from lambda expecting " + expectedReturnType.getSimpleName(); + marks.add(new ScriptLine.Mark(returnStart, returnEnd, TokenType.UNDEFINED_VAR, TokenErrorMessage.from(error))); + } + } else { + // return ; - typed return + String expr = returnStmt.substring(0, returnStmt.length() - 1).trim(); + + if (expectedReturnType != null && expectedReturnType.getSimpleName().equals("void")) { + String error = "Cannot return a value from void lambda"; + marks.add(new ScriptLine.Mark(returnStart, returnEnd, TokenType.UNDEFINED_VAR, TokenErrorMessage.from(error))); + } else { + try { + // Validate return expression type + int exprStart = returnStart + m.group(0).indexOf(expr); + TypeInfo returnType = resolveExpressionType(expr, exprStart); + + if (returnType != null && expectedReturnType != null) { + if (!isCompatibleType(returnType, expectedReturnType)) { + String error = "Incompatible return type: expected " + + expectedReturnType.getSimpleName() + + " but returned " + returnType.getSimpleName(); + int exprEnd = exprStart + expr.length(); + marks.add(new ScriptLine.Mark(exprStart, exprEnd, TokenType.UNDEFINED_VAR, TokenErrorMessage.from(error))); + } + } + } catch (Exception e) { + // Fail soft on malformed expressions + } + } + } + } + + // Check for missing returns in non-void lambdas + // This is a warning rather than an error - Java allows it if the lambda throws or has infinite loop + // We skip this validation to avoid false positives + } + + /** + * Check if an actual type is compatible with an expected type. + * Includes boxing, subtype checking, and special cases like void. + */ + private boolean isCompatibleType(TypeInfo actual, TypeInfo expected) { + if (actual == null || expected == null) return false; + if (actual.equals(expected)) return true; + if (actual.getSimpleName().equals(expected.getSimpleName())) return true; + + // void is compatible with anything (statement lambda) + if (expected.getSimpleName().equals("void")) return true; + + // Object is compatible with anything + if (expected.getSimpleName().equals("Object") || expected.getFullName().equals("java.lang.Object")) return true; + + // Check primitive boxing + if (isBoxingCompatible(actual.getSimpleName(), expected.getSimpleName())) return true; + + // Use TypeChecker for more complex compatibility + return TypeChecker.isTypeCompatible(expected, actual); + } + + /** + * Check if types are compatible via boxing/unboxing. + */ + private boolean isBoxingCompatible(String actualName, String expectedName) { + if (actualName.equals("int") && expectedName.equals("Integer")) return true; + if (actualName.equals("Integer") && expectedName.equals("int")) return true; + if (actualName.equals("boolean") && expectedName.equals("Boolean")) return true; + if (actualName.equals("Boolean") && expectedName.equals("boolean")) return true; + if (actualName.equals("long") && expectedName.equals("Long")) return true; + if (actualName.equals("Long") && expectedName.equals("long")) return true; + if (actualName.equals("double") && expectedName.equals("Double")) return true; + if (actualName.equals("Double") && expectedName.equals("double")) return true; + if (actualName.equals("float") && expectedName.equals("Float")) return true; + if (actualName.equals("Float") && expectedName.equals("float")) return true; + if (actualName.equals("byte") && expectedName.equals("Byte")) return true; + if (actualName.equals("Byte") && expectedName.equals("byte")) return true; + if (actualName.equals("short") && expectedName.equals("Short")) return true; + if (actualName.equals("Short") && expectedName.equals("short")) return true; + if (actualName.equals("char") && expectedName.equals("Character")) return true; + if (actualName.equals("Character") && expectedName.equals("char")) return true; + return false; + } + + /** + * Find and mark unused imports as UNUSED_IMPORT type. + * This must be called after all other mark building is complete. + */ + private void markUnusedImports(List marks) { + for (ImportData imp : imports) { + if (!imp.isUsed() && imp.isResolved() && !imp.isWildcard()) { + // This import is not used - find and update its marks + // Mark the entire import line as unused (gray color) + marks.add(new ScriptLine.Mark(imp.getStartOffset(), imp.getEndOffset(), + TokenType.UNUSED_IMPORT, imp)); + } + } + } + + /** + * Final pass: Mark any remaining unmarked identifiers as UNDEFINED_VAR. + * This should be called last, after all other marking passes are complete. + * Only marks identifiers that haven't been marked by any other pass. + */ + private void markUndefinedIdentifiers(List marks) { + // Build a set of all marked positions for fast lookup + // Use a boolean array for O(1) lookup + boolean[] markedPositions = new boolean[text.length()]; + for (ScriptLine.Mark mark : marks) { + for (int i = mark.start; i < mark.end && i < markedPositions.length; i++) { + markedPositions[i] = true; + } + } + + // Keywords that should not be marked as undefined + Set knownKeywords = new HashSet<>(Arrays.asList( + "boolean", "int", "float", "double", "long", "char", "byte", "short", "void", + "null", "true", "false", "if", "else", "switch", "case", "for", "while", "do", + "try", "catch", "finally", "return", "throw", "var", "let", "const", "function", + "continue", "break", "this", "new", "typeof", "instanceof", "class", "interface", + "extends", "implements", "import", "package", "public", "private", "protected", + "static", "final", "abstract", "synchronized", "native", "default", "enum", + "throws", "super", "assert", "volatile", "transient" + )); + + if (isJavaScript()) { + knownKeywords.add("delete"); + knownKeywords.add("undefined"); + } + + // Find all identifiers + Pattern identifier = Pattern.compile("\\b([a-zA-Z_][a-zA-Z0-9_]*)\\b"); + Matcher m = identifier.matcher(text); + + while (m.find()) { + int start = m.start(1); + int end = m.end(1); + String name = m.group(1); + + // Skip if already marked + if (start < markedPositions.length && markedPositions[start]) { + continue; + } + + // Skip if in excluded region (string/comment) + if (isExcluded(start)) { + continue; + } + + // Skip keywords + if (knownKeywords.contains(name)) { + continue; + } + + // Mark as undefined + marks.add(new ScriptLine.Mark(start, end, TokenType.UNDEFINED_VAR, null)); + } + } + + private void addPatternMarks(List marks, Pattern pattern, TokenType type) { + addPatternMarks(marks, pattern, type, 0); + } + + private void addPatternMarks(List marks, Pattern pattern, TokenType type, int group) { + Matcher m = pattern.matcher(text); + while (m.find()) { + marks.add(new ScriptLine.Mark(m.start(group), m.end(group), type)); + } + } + + private void markImports(List marks) { + for (ImportData imp : imports) { + // Skip implicit imports (from JaninoScript defaults, not in source text) + // These have offset -1 and don't need to be visually marked + if (imp.getStartOffset() < 0) + continue; + + // Mark 'import' keyword + marks.add(new ScriptLine.Mark(imp.getStartOffset(), imp.getStartOffset() + 6, TokenType.IMPORT_KEYWORD, imp)); + + // Parse path tokens + int pathStart = imp.getPathStartOffset(); + int pathEnd = imp.getPathEndOffset(); + String pathText = text.substring(pathStart, Math.min(pathEnd, text.length())); + + // Skip if path ends with dot (incomplete) + if (pathText.trim().endsWith(".")) { + continue; + } + + // Tokenize the path + List tokens = new ArrayList<>(); + List tokenStarts = new ArrayList<>(); + List tokenEnds = new ArrayList<>(); + Pattern idPattern = Pattern.compile("[A-Za-z_][A-Za-z0-9_]*"); + Matcher idm = idPattern.matcher(pathText); + while (idm.find()) { + tokens.add(idm.group()); + tokenStarts.add(pathStart + idm.start()); + tokenEnds.add(pathStart + idm.end()); + } + + if (tokens.isEmpty()) continue; + + if (imp.isWildcard()) { + // Wildcard import: mark all tokens as package (blue) if valid + boolean pkgValid = typeResolver.isValidPackage(imp.getFullPath()); + + // Also check if it might be a class wildcard (OuterClass.*) + TypeInfo outerType = typeResolver.resolveFullName(imp.getFullPath()); + + if (pkgValid || outerType != null) { + // Mark package portion in blue + int pkgTokenCount = outerType != null ? tokens.size() - 1 : tokens.size(); + for (int i = 0; i < Math.min(pkgTokenCount, tokens.size()); i++) { + marks.add(new ScriptLine.Mark(tokenStarts.get(i), tokenEnds.get(i), TokenType.TYPE_DECL, imp)); + } + // If it's a class wildcard, mark the class with its type + if (outerType != null && tokens.size() > 0) { + int lastIdx = tokens.size() - 1; + marks.add(new ScriptLine.Mark(tokenStarts.get(lastIdx), tokenEnds.get(lastIdx), + outerType.getTokenType(), imp)); + } + } else { + // Unknown package/class - mark as undefined + marks.add(new ScriptLine.Mark(pathStart, pathEnd, TokenType.UNDEFINED_VAR, imp)); + } + } else { + // Non-wildcard import: package is blue, class name(s) get type colors + TypeInfo resolvedType = imp.getResolvedType(); + + if (resolvedType != null && resolvedType.isResolved()) { + // Count package segments + String fullPath = imp.getFullPath(); + String resolvedName = resolvedType.getFullName(); + String pkgName = resolvedType.getPackageName(); + + int pkgSegments = pkgName != null && !pkgName.isEmpty() + ? pkgName.split("\\.").length : 0; + + // Mark package tokens in blue + for (int i = 0; i < Math.min(pkgSegments, tokens.size()); i++) { + marks.add(new ScriptLine.Mark(tokenStarts.get(i), tokenEnds.get(i), TokenType.TYPE_DECL, imp)); + } + + // Mark class tokens with appropriate type colors + // For inner classes, each segment might have a different type + for (int i = pkgSegments; i < tokens.size(); i++) { + String segmentName = tokens.get(i); + // Try to resolve this specific class/inner class + StringBuilder classPath = new StringBuilder(); + if (pkgName != null && !pkgName.isEmpty()) { + classPath.append(pkgName).append("."); + } + for (int j = pkgSegments; j <= i; j++) { + if (j > pkgSegments) classPath.append("$"); + classPath.append(tokens.get(j)); + } + + TypeInfo segmentType = typeResolver.resolveFullName(classPath.toString()); + TokenType tokenType = segmentType != null + ? segmentType.getTokenType() + : resolvedType.getTokenType(); + + marks.add(new ScriptLine.Mark(tokenStarts.get(i), tokenEnds.get(i), tokenType, imp)); + } + } else { + // Try to figure out which parts are valid vs invalid + // First, try to find valid package segments + int lastValidPkg = -1; + StringBuilder pkgBuilder = new StringBuilder(); + + for (int i = 0; i < tokens.size(); i++) { + if (i > 0) pkgBuilder.append("."); + pkgBuilder.append(tokens.get(i)); + + // Check if this is a valid package + if (typeResolver.isValidPackage(pkgBuilder.toString())) { + lastValidPkg = i; + } + } + + // Now try to resolve outer classes that might exist after the package + // For import like kamkeel.api.IOverlay.idk where IOverlay exists but idk doesn't + int lastValidClass = -1; + TypeInfo lastValidType = null; + StringBuilder classPath = new StringBuilder(); + + if (lastValidPkg >= 0) { + classPath.append(pkgBuilder.substring(0, + pkgBuilder.toString().indexOf(tokens.get(lastValidPkg)) + tokens.get(lastValidPkg) + .length())); + } + + for (int i = lastValidPkg + 1; i < tokens.size(); i++) { + if (classPath.length() > 0) + classPath.append(i == lastValidPkg + 1 ? "." : "$"); + classPath.append(tokens.get(i)); + + TypeInfo segmentType = typeResolver.resolveFullName(classPath.toString()); + if (segmentType != null && segmentType.isResolved()) { + lastValidClass = i; + lastValidType = segmentType; + } else { + break; // Stop at first unresolved segment + } + } + + // Mark valid package portion in blue + for (int i = 0; i <= lastValidPkg; i++) { + marks.add(new ScriptLine.Mark(tokenStarts.get(i), tokenEnds.get(i), TokenType.TYPE_DECL, imp)); + } + + // Mark valid class segments with their type colors + StringBuilder resolvedPath = new StringBuilder(); + if (lastValidPkg >= 0) { + for (int i = 0; i <= lastValidPkg; i++) { + if (i > 0) + resolvedPath.append("."); + resolvedPath.append(tokens.get(i)); + } + } + + for (int i = lastValidPkg + 1; i <= lastValidClass; i++) { + if (resolvedPath.length() > 0) + resolvedPath.append(i == lastValidPkg + 1 ? "." : "$"); + resolvedPath.append(tokens.get(i)); + + TypeInfo segmentType = typeResolver.resolveFullName(resolvedPath.toString()); + TokenType tokenType = (segmentType != null) ? segmentType.getTokenType() : TokenType.IMPORTED_CLASS; + marks.add(new ScriptLine.Mark(tokenStarts.get(i), tokenEnds.get(i), tokenType, imp)); + } + + // Mark remaining unresolved segments as undefined (red) + int firstUnresolved = Math.max(lastValidPkg + 1, lastValidClass + 1); + for (int i = firstUnresolved; i < tokens.size(); i++) { + marks.add(new ScriptLine.Mark(tokenStarts.get(i), tokenEnds.get(i), TokenType.UNDEFINED_VAR, + imp)); + } + + // If nothing was valid at all, mark everything as undefined + if (lastValidPkg < 0 && lastValidClass < 0) { + marks.add(new ScriptLine.Mark(pathStart, pathEnd, TokenType.UNDEFINED_VAR, imp)); + } + } + } + } + } + + private void markClassDeclarations(List marks) { + // Extended pattern to capture extends and implements clauses + // Groups: 1=class|interface|enum, 2=TypeName, 3=extends clause, 4=implements clause + Pattern classWithInheritance = Pattern.compile( + "\\b(class|interface|enum)\\s+([A-Za-z_][a-zA-Z0-9_]*)\\s*(?:\\(\\))?\\s*" + + "(?:(extends)\\s+([A-Za-z_][a-zA-Z0-9_.]*))?\\s*" + + "(?:(implements)\\s+([A-Za-z_][a-zA-Z0-9_.,\\s]*))?\\s*(?=\\{)"); + + Matcher m = classWithInheritance.matcher(text); + while (m.find()) { + if (isExcluded(m.start())) + continue; + + // Mark the keyword (class/interface/enum) + marks.add(new ScriptLine.Mark(m.start(1), m.end(1), TokenType.CLASS_KEYWORD)); + + // Mark the class name + String kind = m.group(1); + TokenType nameType; + if ("interface".equals(kind)) { + nameType = TokenType.INTERFACE_DECL; + } else if ("enum".equals(kind)) { + nameType = TokenType.ENUM_DECL; + } else { + nameType = TokenType.CLASS_DECL; + } + String typeName = m.group(2); + // Look up the ScriptTypeInfo: try top-level first, then search all types + // by simple name + declaration range (declarationOffset..bodyEnd) to handle inner classes. + // Cannot use containsPosition() here because the class NAME sits before the opening '{', + // i.e., in [declarationOffset, bodyStart) — outside the body range checked by containsPosition. + ScriptTypeInfo typeInfo = scriptTypes.get(typeName); + if (typeInfo == null) { + for (ScriptTypeInfo candidate : scriptTypesByFullName.values()) { + if (candidate.getSimpleName().equals(typeName) + && m.start(2) >= candidate.getDeclarationOffset() + && m.start(2) < candidate.getBodyEnd()) { + typeInfo = candidate; + break; + } + } + } + marks.add(new ScriptLine.Mark(m.start(2), m.end(2), nameType, typeInfo)); + + // Mark extends clause + if (m.group(3) != null) { + //Extends key word + marks.add(new ScriptLine.Mark(m.start(3), m.end(3), TokenType.IMPORT_KEYWORD)); + markExtendsClause(marks, m.start(4), m.group(4)); + } + + // Mark implements clause + if (m.group(5) != null) { + //Implements key word + marks.add(new ScriptLine.Mark(m.start(5),m.end(5), TokenType.IMPORT_KEYWORD)); + markImplementsClause(marks, m.start(6), m.group(6)); + } + } + } + + /** + * Mark enum constants with ENUM_CONSTANT token type. + * Adds marks for all enum constants in script-defined enums. + */ + private void markEnumConstants(List marks) { + // Iterate all types (including inner) so enum constants in nested enums are marked + for (ScriptTypeInfo scriptType : scriptTypesByFullName.values()) { + if (!scriptType.isEnum()) + continue; + + // Mark each enum constant + for (EnumConstantInfo constant : scriptType.getEnumConstants().values()) { + FieldInfo fieldInfo = constant.getFieldInfo(); + int start = fieldInfo.getDeclarationOffset(); + int end = start + fieldInfo.getName().length(); + + // Always use ENUM_CONSTANT token type (blue + bold + italic) + // Errors are shown via underline, not by changing the token type + marks.add(new ScriptLine.Mark(start, end, TokenType.ENUM_CONSTANT, fieldInfo)); + } + } + } + + /** + * Mark the extends clause with proper coloring. + * The parent class is colored based on its resolved type. + */ + private void markExtendsClause(List marks, int clauseStart, String parentName) { + String trimmedName = parentName.trim(); + if (trimmedName.isEmpty()) + return; + + + // Resolve the parent type with position context for inner class names + TypeInfo parentType = resolveType(trimmedName, clauseStart); + TokenType tokenType; + + if (parentType != null && parentType.isResolved()) { + // Use the type's specific token type (CLASS, INTERFACE, ENUM) + tokenType = parentType.getTokenType(); + } else { + // Unresolved - mark as undefined + tokenType = TokenType.UNDEFINED_VAR; + if (parentType == null) { + parentType = TypeInfo.unresolved(trimmedName, trimmedName); + } + } + + // Find actual position in text (might have leading whitespace in the group) + int actualStart = clauseStart; + String fullClause = parentName; + while (actualStart < clauseStart + fullClause.length() && + Character.isWhitespace(text.charAt(actualStart))) { + actualStart++; + } + + marks.add(new ScriptLine.Mark(actualStart, actualStart + trimmedName.length(), tokenType, parentType)); + } + + /** + * Mark the implements clause with proper coloring. + * Each interface is colored based on its resolved type. + */ + private void markImplementsClause(List marks, int clauseStart, String implementsList) { + String[] interfaces = implementsList.split(","); + int currentPos = clauseStart; + + for (String ifaceName : interfaces) { + String trimmedName = ifaceName.trim(); + if (trimmedName.isEmpty()) { + currentPos += ifaceName.length() + 1; // +1 for comma + continue; + } + + // Find the actual start position of this interface name in the text + int leadingSpaces = 0; + while (leadingSpaces < ifaceName.length() && Character.isWhitespace(ifaceName.charAt(leadingSpaces))) { + leadingSpaces++; + } + int actualStart = currentPos + leadingSpaces; + + // Resolve the interface type with position context for inner class names + TypeInfo ifaceType = resolveType(trimmedName, actualStart); + TokenType tokenType; + + if (ifaceType != null && ifaceType.isResolved()) { + tokenType = ifaceType.getTokenType(); + } else { + tokenType = TokenType.UNDEFINED_VAR; + if (ifaceType == null) { + ifaceType = TypeInfo.unresolved(trimmedName, trimmedName); + } + } + + marks.add(new ScriptLine.Mark(actualStart, actualStart + trimmedName.length(), tokenType, ifaceType)); + + // Move past this interface name and the comma + currentPos += ifaceName.length() + 1; + } + } + + private void markTypeDeclarations(List marks) { + // First, mark variables that hold Java.type() results + if (isJavaScript()) { + markJavaTypeVariables(marks); + } + + // Pattern for type optionally followed by generics - we'll manually parse generics + Pattern typeStart = Pattern.compile( + "(?:(?:public|private|protected|static|final|transient|volatile)\\s+)*" + + "([a-zA-Z][a-zA-Z0-9_]*)\\s*"); + + Matcher m = typeStart.matcher(text); + int searchFrom = 0; + + while (m.find(searchFrom)) { + int typeNameStart = m.start(1); + int typeNameEnd = m.end(1); + + if (isExcluded(typeNameStart) || isInImportOrPackage(typeNameStart)) { + searchFrom = m.end(); + continue; + } + + String typeName = m.group(1); + int posAfterType = m.end(1); + + // Skip whitespace after type name + while (posAfterType < text.length() && Character.isWhitespace(text.charAt(posAfterType))) { + posAfterType++; + } + + // Check for generic parameters + String genericContent = null; + int genericStart = -1; + int genericEnd = -1; + + if (posAfterType < text.length() && text.charAt(posAfterType) == '<') { + genericStart = posAfterType; + int depth = 1; + int i = posAfterType + 1; + while (i < text.length() && depth > 0) { + char c = text.charAt(i); + if (c == '<') + depth++; + else if (c == '>') + depth--; + i++; + } + if (depth == 0) { + genericEnd = i; + genericContent = text.substring(genericStart + 1, genericEnd - 1); + posAfterType = genericEnd; + } + } + + // Skip whitespace after generics + while (posAfterType < text.length() && Character.isWhitespace(text.charAt(posAfterType))) { + posAfterType++; + } + + int varScanPos = posAfterType; + while (text.startsWith("[]", varScanPos)) { + marks.add(new ScriptLine.Mark(varScanPos, varScanPos + 2, TokenType.DEFAULT, null)); + varScanPos += 2; + while (varScanPos < text.length() && Character.isWhitespace(text.charAt(varScanPos))) varScanPos++; + } + + // Check if this looks like a type declaration: + boolean hasGeneric = genericContent != null && !genericContent.isEmpty(); + boolean followedByVarName = false; + boolean atEndOfLine = varScanPos >= text.length() || text.charAt(varScanPos) == '\n'; + + if (!atEndOfLine && varScanPos < text.length()) { + char nextChar = text.charAt(varScanPos); + followedByVarName = Character.isLetter(nextChar) || nextChar == '_'; + } + + // Accept as type if: has generics OR followed by variable name + if (hasGeneric || followedByVarName) { + // Resolve the main type + TypeInfo info = resolveType(typeName); + TokenType tokenType = (info != null && info.isResolved()) ? info.getTokenType() : TokenType.UNDEFINED_VAR; + marks.add(new ScriptLine.Mark(typeNameStart, typeNameEnd, tokenType, info)); + + // Handle generic content recursively + if (hasGeneric && genericStart >= 0) { + int contentStart = genericStart + 1; + markGenericTypesRecursive(genericContent, contentStart, marks); + } + } + + searchFrom = m.end(); + } + } + + + + /** + * Mark variables that hold Java.type() class references. + * Example: var File = Java.type("java.io.File"); + */ + private void markJavaTypeVariables(List marks) { + // Pattern: var/let/const varName = Java.type("className") + Pattern javaTypePattern = Pattern.compile( + "\\b(var|let|const)\\s+(\\w+)\\s*=\\s*Java\\.type\\s*\\(\\s*[\"']([^\"']+)[\"']\\s*\\)"); + + Matcher m = javaTypePattern.matcher(text); + + while (m.find()) { + if (isExcluded(m.start())) continue; + + String varName = m.group(2); + String className = m.group(3); + int varStart = m.start(2); + int varEnd = m.end(2); + + // Resolve the class name + TypeInfo classType = typeResolver.resolveFullName(className); + if (classType != null && classType.isResolved()) { + // Create ClassTypeInfo to represent that this variable holds a Class reference + ClassTypeInfo classRef = new ClassTypeInfo(classType); + + // Mark the variable with the ClassTypeInfo for hover info + marks.add(new ScriptLine.Mark(varStart, varEnd, TokenType.LOCAL_FIELD, classRef)); + } + } + } + + /** + * Recursively parse and mark generic type parameters. + * Handles arbitrarily nested generics like Map>>. + */ + private void markGenericTypesRecursive(String content, int baseOffset, List marks) { + if (content == null || content.isEmpty()) + return; + + int i = 0; + while (i < content.length()) { + char c = content.charAt(i); + + // Skip whitespace and punctuation + if (!Character.isJavaIdentifierStart(c)) { + i++; + continue; + } + + // Found start of identifier + int start = i; + while (i < content.length() && Character.isJavaIdentifierPart(content.charAt(i))) { + i++; + } + String typeName = content.substring(start, i); + + // Only process if it's an actual type (check via resolveType) + TypeInfo typeCheck = resolveType(typeName); + if (typeCheck != null && typeCheck.isResolved()) { + int absStart = baseOffset + start; + int absEnd = baseOffset + i; + + if (!isExcluded(absStart)) { + TypeInfo info = resolveType(typeName); + TokenType tokenType = (info != null && info.isResolved()) ? info.getTokenType() : TokenType.UNDEFINED_VAR; + marks.add(new ScriptLine.Mark(absStart, absEnd, tokenType, info)); + } + } + + // Skip whitespace + while (i < content.length() && Character.isWhitespace(content.charAt(i))) { + i++; + } + + // Check for nested generic + if (i < content.length() && content.charAt(i) == '<') { + int nestedStart = i + 1; + int depth = 1; + i++; + + // Find matching > + while (i < content.length() && depth > 0) { + if (content.charAt(i) == '<') + depth++; + else if (content.charAt(i) == '>') + depth--; + i++; + } + + // Recursively parse nested content + if (nestedStart < i - 1) { + String nestedContent = content.substring(nestedStart, i - 1); + markGenericTypesRecursive(nestedContent, baseOffset + nestedStart, marks); + } + } + } + } + + /** + * Mark JSDoc elements within comments for syntax highlighting. + * Adds marks for @tags (like @param, @return, @type) and {Type} references. + */ + private void markJSDocElements(List marks) { + // Find all JSDoc comments (/** ... */) + Pattern jsDocPattern = Pattern.compile("/\\*\\*([\\s\\S]*?)\\*/"); + Matcher jsDocMatcher = jsDocPattern.matcher(text); + + while (jsDocMatcher.find()) { + int commentStart = jsDocMatcher.start(); + int commentEnd = jsDocMatcher.end(); + + // Skip if this JSDoc is inside a string + boolean insideString = false; + for (ScriptLine.Mark mark : marks) { + if (mark.type == TokenType.STRING && + commentStart >= mark.start && commentEnd <= mark.end) { + insideString = true; + break; + } + } + if (insideString) { + continue; + } + + String commentContent = jsDocMatcher.group(0); + + // Find the method that this JSDoc belongs to, for parameter validation + MethodInfo associatedMethod = findMethodAfterPosition(commentEnd); + Set methodParamNames = new HashSet<>(); + if (associatedMethod != null) { + for (FieldInfo param : associatedMethod.getParameters()) { + methodParamNames.add(param.getName()); + } + } + + // Collect all special element positions (@tags and {Type}s) that should NOT be gray + java.util.List specialRanges = new java.util.ArrayList<>(); + + // Find @tags and process @param and @type specially + Pattern tagPattern = Pattern.compile("@(\\w+)"); + Matcher tagMatcher = tagPattern.matcher(commentContent); + while (tagMatcher.find()) { + int tagStart = commentStart + tagMatcher.start(); + int tagEnd = commentStart + tagMatcher.end(); + specialRanges.add(new int[]{tagStart, tagEnd}); + + String tagName = tagMatcher.group(1); + + // For @type tag, resolve the type and attach it for hover + TypeInfo tagTypeInfo = null; + if ("type".equals(tagName)) { + // Look for {Type} after @type + int afterTag = tagMatcher.end(); + String afterTagText = commentContent.substring(afterTag); + Pattern typeRefPattern = Pattern.compile("^\\s*\\{([^}]+)\\}"); + Matcher typeRefMatcher = typeRefPattern.matcher(afterTagText); + if (typeRefMatcher.find()) { + String typeName = typeRefMatcher.group(1).trim(); + tagTypeInfo = resolveType(typeName); + } + } + + // Mark the @tag itself (with TypeInfo for @type) + marks.add(new ScriptLine.Mark(tagStart, tagEnd, TokenType.JSDOC_TAG, tagTypeInfo)); + + // If this is @param, look for parameter name after the type + if ("param".equals(tagName)) { + // Look for: @param {Type} paramName or @param paramName + int afterTag = tagMatcher.end(); + String afterTagText = commentContent.substring(afterTag); + + // Pattern to match optional {Type} followed by parameter name + Pattern paramNamePattern = Pattern.compile("^\\s*(?:\\{[^}]*\\}\\s*)?([a-zA-Z_][a-zA-Z0-9_]*)"); + Matcher paramNameMatcher = paramNamePattern.matcher(afterTagText); + if (paramNameMatcher.find()) { + String paramName = paramNameMatcher.group(1); + int paramNameStart = commentStart + afterTag + paramNameMatcher.start(1); + int paramNameEnd = commentStart + afterTag + paramNameMatcher.end(1); + + // Check if this parameter exists in the method + boolean paramExists = methodParamNames.contains(paramName); + TokenType paramTokenType = paramExists ? TokenType.PARAMETER : TokenType.UNDEFINED_VAR; + + // Add to special ranges to exclude from comment marking + specialRanges.add(new int[]{paramNameStart, paramNameEnd}); + // Mark the parameter name + marks.add(new ScriptLine.Mark(paramNameStart, paramNameEnd, paramTokenType, null)); + } + } + } + + // Find {Type} references + Pattern typePattern = Pattern.compile("\\{([^}]+)\\}"); + Matcher typeMatcher = typePattern.matcher(commentContent); + while (typeMatcher.find()) { + int braceStart = commentStart + typeMatcher.start(); + int braceEnd = commentStart + typeMatcher.end(); + specialRanges.add(new int[]{braceStart, braceEnd}); + + // Mark braces + marks.add(new ScriptLine.Mark(braceStart, braceStart + 1, TokenType.JSDOC_TYPE, null)); // { + marks.add(new ScriptLine.Mark(braceEnd - 1, braceEnd, TokenType.JSDOC_TYPE, null)); // } + + // Mark the type name inside braces + String typeName = typeMatcher.group(1).trim(); + int typeStart = commentStart + typeMatcher.start(1); + int typeEnd = commentStart + typeMatcher.end(1); + + // Try to resolve the type for hover info + TypeInfo resolvedType = resolveType(typeName); + addTypeMark(marks, typeStart, typeEnd, + resolvedType != null ? resolvedType.getTokenType() : TokenType.UNDEFINED_VAR, + resolvedType); + } + + // Sort special ranges by start position + specialRanges.sort((a, b) -> Integer.compare(a[0], b[0])); + + // Mark the comment in FRAGMENTS between special elements + int lastPos = commentStart; + for (int[] range : specialRanges) { + // Mark from lastPos to start of special element + if (lastPos < range[0]) { + marks.add(new ScriptLine.Mark(lastPos, range[0], TokenType.COMMENT, null)); + } + lastPos = range[1]; // Move past the special element + } + // Mark from last special element to end of comment + if (lastPos < commentEnd) { + marks.add(new ScriptLine.Mark(lastPos, commentEnd, TokenType.COMMENT, null)); + } + } + } + + /** + * Find the method declaration that immediately follows the given position. + * Used to associate JSDoc comments with their methods for parameter validation. + */ + private MethodInfo findMethodAfterPosition(int position) { + // Skip whitespace after position + int searchStart = position; + while (searchStart < text.length() && Character.isWhitespace(text.charAt(searchStart))) { + searchStart++; + } + + // Find the method with the smallest offset that is >= searchStart + MethodInfo closestMethod = null; + int closestDistance = Integer.MAX_VALUE; + + for (MethodInfo method : methods) { + if (!method.isDeclaration()) + continue; + int methodStart = method.getFullDeclarationOffset(); + if (methodStart < 0) + methodStart = method.getNameOffset(); + if (methodStart < 0) + continue; + + // Check if this method starts at or after our search position + // but within a reasonable distance (e.g., 200 chars to account for modifiers) + if (methodStart >= position && methodStart < position + 200) { + int distance = methodStart - position; + if (distance < closestDistance) { + closestDistance = distance; + closestMethod = method; + } + } + } + + // Also check methods inside script types (including inner classes) + for (ScriptTypeInfo scriptType : scriptTypesByFullName.values()) { + for (MethodInfo method : scriptType.getAllMethodsFlat()) { + if (!method.isDeclaration()) + continue; + int methodStart = method.getFullDeclarationOffset(); + if (methodStart < 0) + methodStart = method.getNameOffset(); + if (methodStart < 0) + continue; + + if (methodStart >= position && methodStart < position + 200) { + int distance = methodStart - position; + if (distance < closestDistance) { + closestDistance = distance; + closestMethod = method; + } + } + } + } + + return closestMethod; + } + + /** + * Mark all comments EXCEPT JSDoc comments (slash-star-star style). + * JSDoc comments are handled separately in markJSDocElements. + */ + private void markNonJSDocComments(List marks) { + // Match: /* ... */ (but not /**), // ..., # ... + Matcher m = COMMENT_PATTERN.matcher(text); + while (m.find()) { + int start = m.start(); + int end = m.end(); + String comment = m.group(); + + // Skip JSDoc comments (/** style) - they're handled separately + if (comment.startsWith("/**")) { + continue; + } + + marks.add(new ScriptLine.Mark(start, end, TokenType.COMMENT, null)); + } + } + + private void addTypeMark(List marks, int start, int end, TokenType type, Object metadata) { + int bracketStart = text.indexOf('[', start); + int coreEnd = (bracketStart >= start && bracketStart < end) ? bracketStart : end; + if (coreEnd < end) marks.add(new ScriptLine.Mark(coreEnd, end, TokenType.DEFAULT, null)); + marks.add(new ScriptLine.Mark(start, coreEnd, type, metadata)); + } + + private void markMethodDeclarations(List marks) { + Matcher m = METHOD_DECL_PATTERN.matcher(text); + while (m.find()) { + if (isExcluded(m.start())) + continue; + + // Skip class/interface/enum declarations - these look like method declarations + // but "class Foo(" is not a method, it's a class declaration3 + String returnType = m.group(1); + if (returnType.equals("class") || returnType.equals("interface") || returnType.equals("enum") ||returnType.equals("new")) { + continue; + } + + // Find the corresponding MethodInfo created in parseMethodDeclarations + int methodDeclStart = m.start(); + int methodNameStart = m.start(2); + MethodInfo methodInfo = null; + for (MethodInfo method : getAllMethods()) { + boolean matchesDeclStart = method.getTypeOffset() == methodDeclStart + || method.getFullDeclarationOffset() == methodDeclStart; + boolean matchesNameStart = method.getNameOffset() == methodNameStart; + + if (matchesDeclStart || matchesNameStart) { + methodInfo = method; + break; + } + } + + // Return type + TokenType returnToken = TokenType.UNDEFINED_VAR; + if (methodInfo != null) + returnToken = methodInfo.getReturnType().getTokenType(); + + int returnStart = m.start(1); + int returnEnd = m.end(1); + addTypeMark(marks, returnStart, returnEnd, + returnToken, methodInfo != null ? methodInfo.getReturnType() : null); + // Method name with MethodInfo metadata + marks.add(new ScriptLine.Mark(m.start(2), m.end(2), TokenType.METHOD_DECL, methodInfo)); + } + } + + private void markMethodCalls(List marks) { + Matcher m = METHOD_CALL_PATTERN.matcher(text); + while (m.find()) { + int nameStart = m.start(1); + int nameEnd = m.end(1); + String methodName = m.group(1); + + if (isExcluded(nameStart) || isKeyword(methodName)) + continue; + + // Skip if in import/package statement + if (isInImportOrPackage(nameStart)) + continue; + + boolean skip = false; + for (MethodInfo decl : methods) + if (decl.getNameOffset() == nameStart) + // This is a method declaration, not a call + skip = true; + + if (skip) + continue; + + // Find the opening parenthesis by scanning forward from the method name end + // The regex includes \( but we scan manually to be safe + int openParen = nameEnd; + while (openParen < text.length() && Character.isWhitespace(text.charAt(openParen))) { + openParen++; + } + + if (openParen >= text.length() || text.charAt(openParen) != '(') { + // Not actually a method call + continue; + } + + // Find the matching closing parenthesis + int closeParen = findMatchingParen(openParen); + if (closeParen < 0) { + // Malformed - no closing paren + continue; + } + + // Handle super() constructor calls + if (methodName.equals("super")) { + handleSuperConstructorCall(marks, nameStart, nameEnd, openParen, closeParen); + continue; + } + + // Parse the arguments (first pass - without expected types for overload resolution) + List arguments = parseMethodArguments(openParen + 1, closeParen, null); + + // Check if this is a static access (Class.method() style) + boolean isStaticAccess = isStaticAccessCall(nameStart); + + // Resolve receiver using existing chain-based resolver and detect static access + TypeInfo receiverType = resolveReceiverChain(nameStart); + MethodInfo resolvedMethod = null; + + if (receiverType != null) { + // Check for synthetic types first (JavaScript only) + SyntheticType syntheticType = null; + if (isJavaScript()) { + syntheticType = typeResolver.getSyntheticType(receiverType.getSimpleName()); + } + + if (syntheticType != null && syntheticType.hasMethod(methodName)) { + // Synthetic type method call (e.g., Java.type()) + resolvedMethod = syntheticType.getMethodInfo(methodName); + + // Check for dynamic return type resolution (like Java.type("className")) + SyntheticMethod synMethod = syntheticType.getMethod(methodName); + TypeInfo dynamicReturnType = null; + if (synMethod != null) { + String argsText = text.substring(openParen + 1, closeParen); + String[] strArgs = TypeResolver.parseStringArguments(argsText); + dynamicReturnType = synMethod.resolveReturnType(strArgs); + } + + MethodCallInfo callInfo = new MethodCallInfo(methodName, nameStart, nameEnd, openParen, + closeParen, arguments, receiverType, resolvedMethod, false); + + // Set the actual resolved return type for downstream type resolution + if (dynamicReturnType != null) { + callInfo.setResolvedReturnType(dynamicReturnType); + } + + callInfo.validate(); + methodCalls.add(callInfo); + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.METHOD_CALL, callInfo)); + continue; + } + // Regular type - check for method existence using hierarchy search if it's a ScriptTypeInfo + boolean hasMethod = false; + if (receiverType instanceof ScriptTypeInfo) { + hasMethod = ((ScriptTypeInfo) receiverType).hasMethodInHierarchy(methodName); + } else { + hasMethod = receiverType.hasMethod(methodName); + } + + if (hasMethod) { + + TypeInfo[] argTypes = arguments.stream().map(MethodCallInfo.Argument::getResolvedType).toArray(TypeInfo[]::new); + + // Get best method overload based on argument types + resolvedMethod = receiverType.getBestMethodOverload(methodName, argTypes); + + if (isStaticAccess && resolvedMethod != null && !resolvedMethod.isStatic()) { + TokenErrorMessage errorMsg = TokenErrorMessage + .from("Cannot call non-static method '" + methodName + "' from static context '" + receiverType.getSimpleName() + "'") + .clearOtherErrors(); + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.UNDEFINED_VAR, errorMsg)); + } else { + // Second pass: Re-resolve arguments with expected parameter types if method was found + if (resolvedMethod != null && resolvedMethod.getParameters().size() == arguments.size()) + arguments = parseMethodArguments(openParen + 1, closeParen, resolvedMethod); + + + MethodCallInfo callInfo = new MethodCallInfo(methodName, nameStart, nameEnd, openParen, + closeParen, arguments, receiverType, resolvedMethod, isStaticAccess); + // Set expected type for validation if this is the final expression + if (!isFollowedByDot(closeParen)) { + TypeInfo expectedType = findExpectedTypeAtPosition(nameStart); + if (expectedType != null) { + callInfo.setExpectedType(expectedType); + } + } + + callInfo.validate(); + methodCalls.add(callInfo); + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.METHOD_CALL, callInfo)); + } + } else { + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.UNDEFINED_VAR)); + } + } else { + boolean hasDot = isPrecededByDot(nameStart); + if (hasDot) { + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.UNDEFINED_VAR)); + } else { + if (isScriptMethod(methodName)) { + // Extract argument types from parsed arguments + + TypeInfo[] argTypes = arguments.stream().map(MethodCallInfo.Argument::getResolvedType).toArray(TypeInfo[]::new); + resolvedMethod = getScriptMethodInfo(methodName, argTypes); + + // Second pass: Re-resolve arguments with expected parameter types if method was found + if (resolvedMethod != null && resolvedMethod.getParameters().size() == arguments.size()) { + arguments = parseMethodArguments(openParen + 1, closeParen, resolvedMethod); + } + + // Check if this is a method from a script type + // Instance methods from script types cannot be called without a receiver + if (resolvedMethod != null && isMethodFromScriptType(resolvedMethod) && !resolvedMethod.isStatic()) { + // Instance method called without receiver - mark as undefined + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.UNDEFINED_VAR)); + } else { + MethodCallInfo callInfo = new MethodCallInfo( + methodName, nameStart, nameEnd, openParen, closeParen, + arguments, null, resolvedMethod + ); + + // Only set expected type if this is the final expression (not followed by .field or .method) + if (!isFollowedByDot(closeParen)) { + TypeInfo expectedType = findExpectedTypeAtPosition(nameStart); + if (expectedType != null) { + callInfo.setExpectedType(expectedType); + } + } + + callInfo.validate(); + methodCalls.add(callInfo); + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.METHOD_CALL, callInfo)); + } + } else if (isGlobalEngineFunction(methodName)) { + JSMethodInfo jsGlobalMethod = JSTypeRegistry.getInstance().getGlobalEngineFunction(methodName); + MethodInfo resolvedGlobal = MethodInfo.fromJSMethod(jsGlobalMethod, null); + + List globalArguments = arguments; + if (resolvedGlobal.getParameters().size() == arguments.size()) { + globalArguments = parseMethodArguments(openParen + 1, closeParen, resolvedGlobal); + } + + MethodCallInfo callInfo = new MethodCallInfo( + methodName, nameStart, nameEnd, openParen, closeParen, + globalArguments, null, resolvedGlobal + ); + if (!isFollowedByDot(closeParen)) { + TypeInfo expectedType = findExpectedTypeAtPosition(nameStart); + if (expectedType != null) callInfo.setExpectedType(expectedType); + } + callInfo.validate(); + methodCalls.add(callInfo); + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.METHOD_CALL, callInfo)); + } else { + // Not a top-level script method or engine function — check if the call site is inside + // a ScriptTypeInfo whose method table contains this name (implicit 'this' call). + // e.g. getYaw() called without 'this.' or 'abilityLine.' inside AbilityLine resolves via AbilityLine's method hierarchy. + ScriptTypeInfo callerType = findEnclosingScriptType(nameStart); + + if (callerType != null && callerType.hasMethodInHierarchy(methodName)) { + TypeInfo[] argTypes = arguments.stream().map(MethodCallInfo.Argument::getResolvedType).toArray(TypeInfo[]::new); + MethodInfo implicitMethod = callerType.getBestMethodOverload(methodName, argTypes); + if (implicitMethod != null && implicitMethod.getParameters().size() == arguments.size()) { + arguments = parseMethodArguments(openParen + 1, closeParen, implicitMethod); + } + MethodCallInfo callInfo = new MethodCallInfo( + methodName, nameStart, nameEnd, openParen, closeParen, + arguments, callerType, implicitMethod + ); + if (!isFollowedByDot(closeParen)) { + TypeInfo expectedType = findExpectedTypeAtPosition(nameStart); + if (expectedType != null) callInfo.setExpectedType(expectedType); + } + callInfo.validate(); + methodCalls.add(callInfo); + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.METHOD_CALL, callInfo)); + } else { + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.UNDEFINED_VAR)); + } + } + } + } + } + } + + public boolean isKeyword(String word){ + Set keywords = new HashSet<>(Arrays.asList(TypeChecker.getJavaKeywords())); + if (isJavaScript()) + keywords.addAll(Arrays.asList(TypeChecker.getJavaScriptKeywords())); + return keywords.contains(word); + } + /** + * Check if a method call is a static access (Class.method() style). + * Returns true if the immediate receiver before the dot is a class name (uppercase). + */ + /** + * Check if a method call at the given position is static access. + * Walks backward from the method name to analyze the receiver. + */ + private boolean isStaticAccessCall(int methodNameStart) { + // Walk backward to find the dot + int pos = methodNameStart - 1; + while (pos >= 0 && Character.isWhitespace(text.charAt(pos))) + pos--; + + if (pos < 0 || text.charAt(pos) != '.') + return false; + + // Skip the dot and any whitespace + pos--; + while (pos >= 0 && Character.isWhitespace(text.charAt(pos))) + pos--; + + if (pos < 0) + return false; + + // Check what's before the dot - could be: + // 1. An identifier ending (field or class name) + // 2. A closing paren (method call result) + // 3. A closing bracket (array access) + + char c = text.charAt(pos); + if (c == ')' || c == ']') { + // Method call or array - would need complex expression resolution + // For now, conservatively treat as instance access + return false; + } + + if (!Character.isJavaIdentifierPart(c)) + return false; + + // Read the identifier backward + int identEnd = pos + 1; + while (pos >= 0 && Character.isJavaIdentifierPart(text.charAt(pos))) + pos--; + int identStart = pos + 1; + + String ident = text.substring(identStart, identEnd); + + // Skip whitespace before the identifier + while (pos >= 0 && Character.isWhitespace(text.charAt(pos))) + pos--; + + // If preceded by a dot, this is part of a chain - treat as instance for now + if (pos >= 0 && text.charAt(pos) == '.') { + return false; + } + + // Direct identifier - check if it resolves to a type (static) or variable (instance) + if (ident.isEmpty()) return false; + + // Use unified static access checker + return TypeResolver.isStaticAccessExpression(ident, identStart, this); + } + + /** + * Find the MethodCallInfo that contains the given position as an argument. + * Returns null if the position is not inside any method call's argument list. + */ + private MethodCallInfo findMethodCallContainingPosition(int position) { + for (MethodCallInfo call : methodCalls) { + // Check if position is within the argument list (between open and close parens) + if (position >= call.getOpenParenOffset() && position <= call.getCloseParenOffset()) { + // Check if it's within any of the arguments + for (MethodCallInfo.Argument arg : call.getArguments()) { + if (position >= arg.getStartOffset() && position <= arg.getEndOffset()) { + return call; + } + } + } + } + return null; + } + + /** + * Find the matching closing parenthesis for an opening parenthesis. + * Handles nested parentheses, strings, and comments. + */ + private int findMatchingParen(int openPos) { + if (openPos < 0 || openPos >= text.length() || text.charAt(openPos) != '(') { + return -1; + } + + int depth = 1; + boolean inString = false; + boolean inChar = false; + char stringChar = 0; + + for (int i = openPos + 1; i < text.length(); i++) { + char c = text.charAt(i); + char prev = (i > 0) ? text.charAt(i - 1) : 0; + + // Handle string literals + if (!inChar && (c == '"' || c == '\'') && prev != '\\') { + if (!inString) { + inString = true; + stringChar = c; + } else if (c == stringChar) { + inString = false; + } + continue; + } + + if (inString) continue; + + // Skip excluded regions (comments) + if (isExcluded(i)) continue; + + if (c == '(') { + depth++; + } else if (c == ')') { + depth--; + if (depth == 0) { + return i; + } + } + } + + return -1; // No matching paren found + } + + /** + * Parse method arguments from the text between opening and closing parentheses. + * Handles nested expressions, strings, and complex argument types. + */ + /** + * Parse method call arguments. + * + * @param start Start position of arguments (after opening paren) + * @param end End position of arguments (at closing paren) + * @param methodInfo Optional MethodInfo to provide expected parameter types for validation + * @return List of parsed arguments with resolved types + */ + public List parseMethodArguments(int start, int end, MethodInfo methodInfo) { + List args = new ArrayList<>(); + + if (start >= end) + return args; // No arguments + + end = Math.min(end, text.length()); + + + int depth = 0; + int argStart = start; + boolean inString = false; + char stringChar = 0; + + for (int i = start; i <= end; i++) { + if (i == end || (depth == 0 && !inString && text.charAt(i) == ',')) { + // End of an argument + String argText = text.substring(argStart, i).trim(); + if (!argText.isEmpty()) { + // Find the actual start/end positions (excluding leading/trailing whitespace) + int actualStart = argStart; + while (actualStart < i && Character.isWhitespace(text.charAt(actualStart))) { + actualStart++; + } + int actualEnd = i; + while (actualEnd > actualStart && Character.isWhitespace(text.charAt(actualEnd - 1))) { + actualEnd--; + } + + // Try to resolve the argument type + // First check if this looks like a parameter declaration (Type varName) + // Get expected parameter type if available + TypeInfo expectedParamType = null; + if (methodInfo != null && args.size() < methodInfo.getParameters().size()) { + FieldInfo parameter = methodInfo.getParameters().get(args.size()); + expectedParamType = parameter.getTypeInfo(); + } + + TypeInfo argType = resolveArgumentType(argText, actualStart, expectedParamType); + + String samConflictError = CURRENT_SAM_CONFLICT_ERROR.get(); + if (samConflictError != null) { + CURRENT_SAM_CONFLICT_ERROR.remove(); + args.add(new MethodCallInfo.Argument( + argText, actualStart, actualEnd, argType, false, samConflictError + )); + } else { + args.add(new MethodCallInfo.Argument( + argText, actualStart, actualEnd, argType, true, null + )); + } + } + argStart = i + 1; + continue; + } + + char c = text.charAt(i); + char prev = (i > start) ? text.charAt(i - 1) : 0; + + // Handle string literals + if (!inString && (c == '"' || c == '\'') && prev != '\\') { + inString = true; + stringChar = c; + } else if (inString && c == stringChar && prev != '\\') { + inString = false; + } + + if (!inString) { + if (c == '(' || c == '[' || c == '{' || c == '<') { + depth++; + } else if (c == ')' || c == ']' || c == '}' || c == '>') { + depth--; + } + } + } + + return args; + } + + /** + * Resolve the type of a method call argument. + * Handles both parameter declarations (Type varName) and expressions (variable.field()). + * + * @param argText The argument text + * @param position The position in the document + * @param expectedType Optional expected parameter type for validation + * @return The resolved type of the argument + */ + private TypeInfo resolveArgumentType(String argText, int position, TypeInfo expectedType) { + argText = argText.trim(); + + // Check if this looks like a parameter declaration: "Type varName" + // Pattern: identifier followed by whitespace and another identifier + if (argText.matches("^[A-Za-z_][a-zA-Z0-9_<>\\[\\],\\s]*\\s+[a-zA-Z_][a-zA-Z0-9_]*$")) { + // Split into tokens + String[] parts = argText.split("\\s+"); + if (parts.length >= 2) { + // Last part is the variable name, everything before is the type + // Join all but last as the type name + StringBuilder typeBuilder = new StringBuilder(); + for (int i = 0; i < parts.length - 1; i++) { + if (i > 0) typeBuilder.append(" "); + typeBuilder.append(parts[i]); + } + String typeName = typeBuilder.toString(); + return resolveType(typeName); + } + } + + // Otherwise, treat it as an expression with expected type context + if (expectedType != null) { + ExpressionTypeResolver.CURRENT_EXPECTED_TYPE = expectedType; + try { + return resolveExpressionType(argText, position); + } finally { + ExpressionTypeResolver.CURRENT_EXPECTED_TYPE = null; + } + } + + // No expected type - resolve normally + return resolveExpressionType(argText, position); + } + + /** + * Check if a numeric literal has excessive precision for its type. + * Counts significant digits (excluding leading zeros, decimal point, and suffix). + * + * @param numLiteral The numeric literal string (e.g., "1.23456789f", "0.00123456789") + * @param maxDigits Maximum significant digits allowed (7 for float, 15 for double) + * @return true if the literal has more significant digits than allowed + */ + private boolean hasExcessivePrecision(String numLiteral, int maxDigits) { + String cleaned = numLiteral.trim(); + + // Remove leading sign + if (cleaned.startsWith("-") || cleaned.startsWith("+")) { + cleaned = cleaned.substring(1); + } + + // Remove suffix (f, F, d, D, l, L) + if (cleaned.endsWith("f") || cleaned.endsWith("F") || + cleaned.endsWith("d") || cleaned.endsWith("D") || + cleaned.endsWith("l") || cleaned.endsWith("L")) { + cleaned = cleaned.substring(0, cleaned.length() - 1); + } + + // Remove decimal point for counting + cleaned = cleaned.replace(".", ""); + + // Remove leading zeros (they're not significant in the mantissa) + while (cleaned.startsWith("0") && cleaned.length() > 1) { + cleaned = cleaned.substring(1); + } + + // If it's just "0", that's fine + if (cleaned.equals("0") || cleaned.isEmpty()) { + return false; + } + + // Count significant digits + int significantDigits = cleaned.length(); + + return significantDigits > maxDigits; + } + + private TypeInfo narrowIntLiteral(String literalText) { + if (isJavaScript()) + return TypeInfo.NUMBER; + + TypeInfo expectedType = ExpressionTypeResolver.CURRENT_EXPECTED_TYPE; + if (expectedType != null) { + TypeInfo narrowed = TypeChecker.narrowLiteralToExpectedType(literalText, expectedType); + if (narrowed != null) { + return narrowed; + } + } + return TypeInfo.fromPrimitive("int"); + } + + /** + * Comprehensive expression type resolver that handles: + * - Literals (strings, numbers, booleans, null) + * - Variables (local, parameter, global) + * - Simple identifiers + * - Chained field accesses (a.b.c) + * - Chained method calls (a().b().c()) + * - Mixed chains (a.b().c.d()) + * - Static access (Class.field, Class.method()) + * - New expressions (new Type()) + * - All Java operators (arithmetic, logical, bitwise, etc.) + * + * This is THE method that should be used for all type resolution needs. + */ + public TypeInfo resolveExpressionType(String expr, int position) { + expr = expr.trim(); + expr = stripLineComments(expr); + + if (expr.endsWith(".")) + expr = expr.substring(0, expr.length() - 1).trim(); + + if (expr.isEmpty()) + return null; + + if (isJavaScript() && expr.charAt(0) == '{') { + ObjectLiteralParser.ObjectLiteralAnalysis analysis = objectLiterals.get(position); + if (analysis == null) + analysis = ObjectLiteralParser.parse(expr, position, true, false, this::resolveExpressionType, this::getScriptMethodInfo); + + if (analysis == null) { + return TypeInfo.ANY; + } + if (!analysis.supportsInference || analysis.inferredType == null) { + return TypeInfo.ANY; + } + return analysis.inferredType; + } + + // Check if expression contains operators - if so, use the full expression resolver + // Handle cast expressions: (Type)expr, ((Type)expr).method(), etc + // Also route JS function expressions and arrow lambdas through the parser + if (containsOperators(expr) || expr.contains("::") || expr.contains("->") || expr.contains("=>") || expr.startsWith("(") || looksLikeFunctionOrLambda(expr)) { + return resolveExpressionWithParserAPI(expr, position); + } + + // JS array literals: [], [a, b], ["hi", "bye"] + if (isJavaScript() && expr.startsWith("[") && expr.endsWith("]")) { + String inner = expr.substring(1, expr.length() - 1).trim(); + return TypeInfo.arrayOf(unifyJsArrayElementType(inner, position + 1)); + } + + // Invalid expressions starting with brackets + if (expr.startsWith("[") || expr.startsWith("]")) { + return null; // Invalid syntax + } + + // String literals + if (expr.startsWith("\"") && expr.endsWith("\"")) { + return TypeInfo.string(); + } + + // Character literals + if (expr.startsWith("'") && expr.endsWith("'")) { + return TypeInfo.fromPrimitive("char"); + } + + // Boolean literals + if (expr.equals("true") || expr.equals("false")) { + return TypeInfo.fromPrimitive("boolean"); + } + + // Null literal + if (expr.equals("null")) { + return TypeInfo.NULL; // null is compatible with any reference type + } + + // Numeric literals with precision checking + // Float: can be 10f, 10.5f, 10.f, .5f + if (expr.matches("-?\\d*\\.?\\d+[fF]")) { + if (isJavaScript()) + return TypeInfo.NUMBER; + + // Check if it has too many decimal places for float (>7 significant digits) + // If so, treat it as double (causing type mismatch) + if (hasExcessivePrecision(expr, 7)) { + return TypeInfo.fromPrimitive("double"); + } + return TypeInfo.fromPrimitive("float"); + } + // Double: can be 10d, 10.5d, 10.5, .5, 10., but NOT plain integers + if (expr.matches("-?\\d*\\.\\d+[dD]?") || expr.matches("-?\\d+\\.[dD]?") || expr.matches("-?\\d+[dD]")) { + if (isJavaScript()) + return TypeInfo.NUMBER; + + // Check if it has too many decimal places for double (>15 significant digits) + // Return null to indicate the literal is invalid/unrepresentable + if (hasExcessivePrecision(expr, 15)) { + return null; // Exceeds double precision + } + return TypeInfo.fromPrimitive("double"); + } + // Long: 10L or 10l + if (expr.matches("-?\\d+[lL]")) { + if (isJavaScript()) + return TypeInfo.NUMBER; + + return TypeInfo.fromPrimitive("long"); + } + // Hex integer literals: 0x7F, -0x80, 0X1A + if (expr.matches("[-+]?0[xX][0-9a-fA-F][0-9a-fA-F_]*")) { + return narrowIntLiteral(expr); + } + // Binary integer literals: 0b1010, -0b1100, 0B1111 + if (expr.matches("[-+]?0[bB][01][01_]*")) { + return narrowIntLiteral(expr); + } + // Int: plain integers without suffix + if (expr.matches("[-+]?\\d[\\d_]*")) { + return narrowIntLiteral(expr); + } + + // "this" keyword + if (expr.equals("this")) { + return resolveThisType(position); + } + + if (expr.startsWith("new ")) { + Matcher newMatcher = NEW_TYPE_PATTERN.matcher(expr); + if (newMatcher.find()) { + String typeName = newMatcher.group(1); + FieldInfo varInfo = resolveVariable(typeName, position); + if (varInfo != null && varInfo.getTypeInfo() instanceof ClassTypeInfo) { + return ((ClassTypeInfo) varInfo.getTypeInfo()).getInstanceType(); + } + if (isJavaScript() && typeName.equals("Array")) { + String rest = expr.substring(newMatcher.end()).trim(); + String argsText = (rest.startsWith("(") && rest.endsWith(")")) + ? rest.substring(1, rest.length() - 1).trim() + : ""; + return TypeInfo.arrayOf(unifyJsArrayElementType(argsText, position)); + } + TypeInfo baseType = resolveType(typeName, position); + if (baseType == null) return null; + String rest = expr.substring(newMatcher.end()); + int dims = 0; + for (int i = 0; i < rest.length() && rest.charAt(i) != '('; i++) { + if (rest.charAt(i) == '[') { dims++; i = rest.indexOf(']', i); } + } + for (int i = 0; i < dims; i++) baseType = TypeInfo.arrayOf(baseType); + return baseType; + } + } + + // Now handle the complex case: chains of fields and method calls + // Parse the expression into segments + List segments = parseExpressionChain(expr); + + if (segments.isEmpty()) { + return null; + } + + // Resolve the first segment + ChainSegment first = segments.get(0); + TypeInfo currentType = null; + + if (first.name.equals("this")) { + currentType = resolveThisType(position); + // Handle this.field where we don't have a script type + if (currentType == null && segments.size() > 1 && !segments.get(1).isMethodCall) { + String fieldName = segments.get(1).name; + if (globalFields.containsKey(fieldName)) { + currentType = globalFields.get(fieldName).getTypeInfo(); + currentType = applyBracketAccess(currentType, segments.get(1)); + // Continue from segment 2 + for (int i = 2; i < segments.size(); i++) { + currentType = resolveChainSegment(currentType, segments.get(i)); + currentType = applyBracketAccess(currentType, segments.get(i)); + if (currentType == null) return null; + } + return currentType; + } + } + } else if (first.name.equals("super")) { + // Resolve super to parent class + ScriptTypeInfo enclosingType = findEnclosingScriptType(position); + if (enclosingType != null && enclosingType.hasSuperClass()) { + currentType = enclosingType.getSuperClass(); + } else { + return null; // No parent class + } + } else { + // Check if first segment is a type name for static access + TypeInfo typeCheck = resolveType(first.name, position); + if (typeCheck != null && typeCheck.isResolved()) { + currentType = typeCheck; + } + } + + if (currentType == null && !first.isMethodCall) { + // Regular variable + FieldInfo varInfo = resolveVariable(first.name, position); + if (varInfo != null) { + currentType = varInfo.getTypeInfo(); + } else if (isScriptMethod(first.name)) { + // Script method reference used as an expression. + // In JS, this is commonly used as a SAM callback (e.g., schedule("id", actionFunction)). + TypeInfo expectedType = ExpressionTypeResolver.CURRENT_EXPECTED_TYPE; + TypeInfo samType = resolveScriptMethodAsSam(first.name, expectedType); + if (samType != null) { + currentType = samType; + } else if (isJavaScript()) { + // Provide a non-null placeholder type so overload selection can prefer functional-interface params. + currentType = TypeInfo.unresolved("", "__script_method_ref__"); + } + } + } else { + // First segment is a method call - check script methods + if (isScriptMethod(first.name)) { + MethodInfo scriptMethod = getScriptMethodInfo(first.name); + if (scriptMethod != null) { + currentType = scriptMethod.getReturnType(); + } + } + if (currentType == null && isGlobalEngineFunction(first.name)) { + currentType = getGlobalEngineFunctionReturnType(first.name); + } + if (currentType == null) { + // Implicit 'this' call: bare method name inside a ScriptTypeInfo body (e.g. getYaw() inside AbilityLine.foo()) + ScriptTypeInfo enclosingType = findEnclosingScriptType(position); + if (enclosingType != null && enclosingType.hasMethodInHierarchy(first.name)) { + MethodInfo implicitMethod = enclosingType.getMethodInfoInHierarchy(first.name); + if (implicitMethod != null) { + currentType = implicitMethod.getReturnType(); + } + } + } + } + + currentType = applyBracketAccess(currentType, first); + + // Resolve the rest of the chain + for (int i = 1; i < segments.size(); i++) { + currentType = resolveChainSegment(currentType, segments.get(i)); + currentType = applyBracketAccess(currentType, segments.get(i)); + if (currentType == null) { + return null; + } + } + + return currentType; + } + + /** + * Resolve a cast or parenthesized expression. + * Delegates to CastExpressionResolver helper class. + * Handles: + * - Simple casts: (Type) expr + * - Nested casts: ((Type) expr) + * - Cast chains: ((Type) expr).method() + * - Parenthesized expressions: (expr) + * + * @param expr The expression starting with '(' + * @param position The position in the source text + * @return The resolved type + */ + private TypeInfo resolveCastOrParenthesizedExpression(String expr, int position) { + return CastExpressionResolver.resolveCastOrParenthesizedExpression( + expr, + position, + this::resolveType, + this::resolveExpressionType, + this::parseExpressionChain, + this::resolveChainSegment + ); + } + + + /** + * Parse an expression string into chain segments. + * Handles dots, method calls, and nested expressions. + * Examples: + * - "a.b.c" -> [a, b, c] (all fields) + * - "a().b()" -> [a(), b()] (all methods) + * - "a.b().c" -> [a, b(), c] (mixed) + */ + private List parseExpressionChain(String expr) { + List segments = new ArrayList<>(); + int i = 0; + + while (i < expr.length()) { + // Skip whitespace + while (i < expr.length() && Character.isWhitespace(expr.charAt(i))) { + i++; + } + + if (i >= expr.length()) break; + + // Read identifier + int start = i; + while (i < expr.length() && Character.isJavaIdentifierPart(expr.charAt(i))) { + i++; + } + + if (i == start) { + // Not an identifier, skip this character + i++; + continue; + } + + String name = expr.substring(start, i); + + // Skip whitespace + while (i < expr.length() && Character.isWhitespace(expr.charAt(i))) { + i++; + } + + // Check if followed by parentheses (method call) + boolean isMethodCall = false; + String arguments = null; + if (i < expr.length() && expr.charAt(i) == '(') { + isMethodCall = true; + int argsStart = i + 1; + // Skip to the matching closing paren + int depth = 1; + i++; + while (i < expr.length() && depth > 0) { + char c = expr.charAt(i); + if (c == '(') depth++; + else if (c == ')') depth--; + i++; + } + // Extract argument text (between parentheses) + int argsEnd = i - 1; // Position of closing paren + if (argsEnd > argsStart) { + arguments = expr.substring(argsStart, argsEnd); + } else { + arguments = ""; // Empty arguments + } + } + + boolean hasArrayAccess = false; + String bracketKey = null; + while (i < expr.length() && Character.isWhitespace(expr.charAt(i))) { + i++; + } + if (i < expr.length() && expr.charAt(i) == '[') { + hasArrayAccess = true; + int bracketStart = i + 1; + int depth = 1; + i++; + while (i < expr.length() && depth > 0) { + char c = expr.charAt(i); + if (c == '[') depth++; + else if (c == ']') depth--; + i++; + } + String bracketContent = expr.substring(bracketStart, i - 1).trim(); + if (bracketContent.length() >= 2) { + char q = bracketContent.charAt(0); + if ((q == '"' || q == '\'') && bracketContent.charAt(bracketContent.length() - 1) == q) { + bracketKey = bracketContent.substring(1, bracketContent.length() - 1); + } + } + } + + segments.add(new ChainSegment(name, start, i, isMethodCall, arguments, hasArrayAccess, bracketKey)); + + // Skip whitespace + while (i < expr.length() && Character.isWhitespace(expr.charAt(i))) { + i++; + } + + // Check for dot (continuing chain) + if (i < expr.length() && expr.charAt(i) == '.') { + i++; // Skip the dot + } + } + + return segments; + } + + /** + * Resolve the full receiver chain before a method call position. + * For example, for "mc.thePlayer.worldObj.weatherEffects.get()", + * this would resolve mc -> Minecraft -> thePlayer -> EntityPlayer -> worldObj -> World -> weatherEffects -> List + * and return the final TypeInfo (List). + * + * Also handles method calls in chains like "Minecraft.getMinecraft().thePlayer" by resolving + * the return type of getMinecraft() and continuing resolution. + * + * @param methodNameStart The start position of the method name + * @return The TypeInfo of the final receiver, or null if no receiver or couldn't resolve + */ + TypeInfo resolveReceiverChain(int methodNameStart) { + // First check if preceded by a dot + int scanPos = methodNameStart - 1; + while (scanPos >= 0 && Character.isWhitespace(text.charAt(scanPos))) + scanPos--; + + if (scanPos < 0 || text.charAt(scanPos) != '.') { + return null; // No receiver + } + + // Use the shared helper to locate the receiver expression before the dot, + // then delegate resolution to the comprehensive resolver. + int[] bounds = findReceiverBoundsBefore(scanPos); + if (bounds == null) return null; + int start = bounds[0]; + int end = bounds[1]; + String receiverExpr = text.substring(start, end).trim(); + if (receiverExpr.isEmpty()) return null; + return resolveExpressionType(receiverExpr, start); + } + + /** + * Parse argument types from a method call's argument list. + * @param argsText The text between parentheses (e.g., "20, 20" or "x, y.toString()") + * @param position The position in the source text + * @return Array of TypeInfo for each argument, or empty array if no arguments + */ + private TypeInfo[] parseArgumentTypes(String argsText, int position) { + if (argsText == null || argsText.trim().isEmpty()) { + return new TypeInfo[0]; + } + + // Split arguments by comma, respecting nested parentheses and strings + java.util.List args = new java.util.ArrayList<>(); + int depth = 0; + int start = 0; + boolean inString = false; + char stringChar = 0; + + for (int i = 0; i < argsText.length(); i++) { + char c = argsText.charAt(i); + + // Handle strings + if ((c == '"' || c == '\'') && (i == 0 || argsText.charAt(i-1) != '\\')) { + if (!inString) { + inString = true; + stringChar = c; + } else if (c == stringChar) { + inString = false; + } + continue; + } + + if (inString) continue; + + // Track parentheses depth + if (c == '(' || c == '[' || c == '{') { + depth++; + } else if (c == ')' || c == ']' || c == '}') { + depth--; + } else if (c == ',' && depth == 0) { + // Found argument separator at top level + args.add(argsText.substring(start, i).trim()); + start = i + 1; + } + } + + // Add the last argument + if (start < argsText.length()) { + args.add(argsText.substring(start).trim()); + } + + // Resolve each argument's type + TypeInfo[] argTypes = new TypeInfo[args.size()]; + for (int i = 0; i < args.size(); i++) { + argTypes[i] = resolveExpressionType(args.get(i), position); + } + + return argTypes; + } + + /** + * For JavaScript array literals, unify the element types to determine the array's element type. + */ + private TypeInfo unifyJsArrayElementType(String argsText, int position) { + if (argsText.isEmpty()) return TypeInfo.ANY; + TypeInfo[] elementTypes = parseArgumentTypes(argsText, position); + if (elementTypes.length == 1 && TypeInfo.NUMBER.equals(elementTypes[0])) return TypeInfo.ANY; + TypeInfo common = null; + boolean allSame = true; + for (TypeInfo t : elementTypes) { + boolean isUnresolvable = t == null || TypeInfo.NULL.equals(t); + if (isUnresolvable) continue; + if (common == null) { + common = t; + } else if (!common.equals(t)) { + allSame = false; + break; + } + } + return allSame && common != null ? common : TypeInfo.ANY; + } + + /** + * Helper class for chain segments (can be field access or method call). + */ + private static class ChainSegment { + final String name; + final int start; + final int end; + final boolean isMethodCall; + final String arguments; + final boolean hasArrayAccess; + final String bracketKey; + + ChainSegment(String name, int start, int end, boolean isMethodCall, String arguments, boolean hasArrayAccess, String bracketKey) { + this.name = name; + this.start = start; + this.end = end; + this.isMethodCall = isMethodCall; + this.arguments = arguments; + this.hasArrayAccess = hasArrayAccess; + this.bracketKey = bracketKey; + } + } + + /** + * + */ + private String stripLineComments(String expr) { + if (!expr.contains("//")) + return expr; + + String[] lines = expr.split("\n", -1); + StringBuilder result = new StringBuilder(); + for (String line : lines) { + int ci = line.indexOf("//"); + String part = (ci >= 0 ? line.substring(0, ci) : line).trim(); + if (!part.isEmpty()) { + if (result.length() > 0) result.append(' '); + result.append(part); + } + } + return result.toString().trim(); + } + + /** + * Handle ObjectLiteral bracket access (e.g., obj["field"] or obj[fieldName]) and array access (e.g., items[0]). + * @param type + * @param seg + * @return + */ + private TypeInfo applyBracketAccess(TypeInfo type, ChainSegment seg) { + if (type == null || !seg.hasArrayAccess) return type; + if (seg.bracketKey != null) { + FieldInfo f = type.getFieldInfo(seg.bracketKey); + return f != null ? f.getTypeInfo() : TypeInfo.ANY; + } + if (type.isSyntheticObjectLiteralType()) return TypeInfo.ANY; + return unwrapArrayElement(type); + } + /** + * Extract the element type from an array type, using multiple fallback strategies. + * + * Used when a chain segment has array subscript notation (e.g., items[1]). + * Given an array type like IItemStack[], returns IItemStack so that subsequent + * chain resolution (e.g., .getName()) operates on the element type, not the array type. + * + * Strategy (in priority order): + * 1. If TypeInfo stores elementType (preferred, from arrayOf factory), use it directly + * 2. If fullName has [] suffix (legacy or JS types), strip it and re-resolve + * 3. If underlying javaClass is an array, use Class.getComponentType() + * 4. Fallback to ANY type to prevent null propagation + * + * @param arrayType The array type to unwrap + * @return The element type, or TypeInfo.ANY if unwrapping fails + */ + private TypeInfo unwrapArrayElement(TypeInfo arrayType) { + if (arrayType == null) return null; + TypeInfo el = arrayType.getElementType(); + if (el != null) return el; + String name = arrayType.getFullName(); + if (name != null && name.endsWith("[]")) { + return resolveType(name.substring(0, name.length() - 2)); + } + if (arrayType.getJavaClass() != null && arrayType.getJavaClass().isArray()) { + return TypeInfo.fromClass(arrayType.getJavaClass().getComponentType()); + } + return TypeInfo.ANY; + } + + /** + * Resolve a single segment of a chain given the current type context. + */ + private TypeInfo resolveChainSegment(TypeInfo currentType, ChainSegment segment) { + if (currentType == null || !currentType.isResolved()) { + return null; + } + + // Check if current type is a synthetic type + if (isJavaScript()) { + SyntheticType syntheticType = typeResolver.getSyntheticType(currentType.getSimpleName()); + if (syntheticType != null) { + return resolveSyntheticChainSegment(syntheticType, segment); + } + } + + if (segment.isMethodCall) { + // Method call - get return type with argument-based overload resolution + // Check for method existence using hierarchy search if it's a ScriptTypeInfo + boolean hasMethod = false; + if (currentType instanceof ScriptTypeInfo) { + hasMethod = ((ScriptTypeInfo) currentType).hasMethodInHierarchy(segment.name); + } else { + hasMethod = currentType.hasMethod(segment.name); + } + + if (hasMethod) { + // Parse argument types from the method call + TypeInfo[] argTypes = parseArgumentTypes(segment.arguments, segment.start); + + // Get the best matching overload based on argument types + // getBestMethodOverload is now overridden in ScriptTypeInfo to search hierarchy + MethodInfo methodInfo = currentType.getBestMethodOverload(segment.name, argTypes); + return (methodInfo != null) ? methodInfo.getReturnType() : null; + } + return null; + } else { + // Field access - use hierarchy search for ScriptTypeInfo + boolean hasField = false; + FieldInfo fieldInfo = null; + + if (currentType instanceof ScriptTypeInfo) { + hasField = ((ScriptTypeInfo) currentType).hasFieldInHierarchy(segment.name); + if (hasField) { + fieldInfo = ((ScriptTypeInfo) currentType).getFieldInfoInHierarchy(segment.name); + } + } else { + hasField = currentType.hasField(segment.name); + if (hasField) { + fieldInfo = currentType.getFieldInfo(segment.name); + } + } + + if (hasField) { + return (fieldInfo != null) ? fieldInfo.getTypeInfo() : null; + } + + // Field not found — check if the segment names an inner class. + // This handles chains like Outer.Inner where Inner is a nested type, not a field. + if (currentType instanceof ScriptTypeInfo) { + ScriptTypeInfo innerClass = ((ScriptTypeInfo) currentType).getInnerClass(segment.name); + if (innerClass != null) { + return innerClass; + } + } + // Also check Java inner classes via reflection (e.g., Map.Entry) + if (currentType.getJavaClass() != null) { + try { + for (Class nested : currentType.getJavaClass().getDeclaredClasses()) { + if (java.lang.reflect.Modifier.isPublic(nested.getModifiers()) + && nested.getSimpleName().equals(segment.name)) { + return TypeInfo.fromClass(nested); + } + } + } catch (SecurityException ignored) { } + } + + return null; + } + } + + /** + * Resolve a chain segment on a synthetic type (like Nashorn's Java object). + */ + /** + * Resolve a chain segment for a synthetic type (method call or field access). + * Handles dynamic return type resolution for methods like Java.type(). + */ + private TypeInfo resolveSyntheticChainSegment(SyntheticType syntheticType, ChainSegment segment) { + if (segment.isMethodCall) { + SyntheticMethod method = syntheticType.getMethod(segment.name); + if (method != null) { + // For methods with dynamic return type resolvers (like Java.type), + // extract string arguments and resolve + if (segment.arguments != null) { + String[] args = TypeResolver.parseStringArguments(segment.arguments); + TypeInfo resolved = method.resolveReturnType(args); + if (resolved != null) { + return resolved; + } + } + // Fall back to static return type + TypeInfo returnType = typeResolver.resolve(method.returnType); + return returnType != null ? returnType : TypeInfo.unresolved(method.returnType, method.returnType); + } + } else { + SyntheticField field = syntheticType.getField(segment.name); + if (field != null) { + TypeInfo fieldType = typeResolver.resolve(field.typeName); + return fieldType != null ? fieldType : TypeInfo.unresolved(field.typeName, field.typeName); + } + } + return null; + } + + /** + * Resolve the type of "this" at a given position by finding the innermost scope and checking for containing object types. + * For both Java and JavaScript, this will correctly resolve to the appropriate type based on the current context (e.g., enclosing class, script type, or synthetic type). + * @param position + * @return + */ + TypeInfo resolveThisType(int position) { + Object innermostScope = findInnermostScopeAt(position); + if (innermostScope instanceof InnerCallableScope) { + TypeInfo objectType = ((InnerCallableScope) innermostScope).getContainingObjectType(); + if (objectType != null && objectType.isResolved()) { + return objectType; + } + } + return findEnclosingScriptType(position); + } + + // ==================== OPERATOR EXPRESSION RESOLUTION ==================== + + /** + * Check if an expression contains operators that need advanced resolution. + * This is a quick heuristic check - it may have false positives for operators + * inside strings, but those are handled by the full parser. + */ + public boolean containsOperators(String expr) { + if (expr == null) return false; + + boolean inString = false; + boolean inChar = false; + + for (int i = 0; i < expr.length(); i++) { + char c = expr.charAt(i); + char next = (i + 1 < expr.length()) ? expr.charAt(i + 1) : 0; + + // Track string literals + if (c == '"' && !inChar) { + if (!inString) { + inString = true; + } else if (i > 0 && expr.charAt(i - 1) != '\\') { + inString = false; + } + continue; + } + + // Track char literals + if (c == '\'' && !inString) { + if (!inChar) { + inChar = true; + } else if (i > 0 && expr.charAt(i - 1) != '\\') { + inChar = false; + } + continue; + } + + // Skip content inside strings/chars + if (inString || inChar) continue; + + // Check for operators (excluding . which is used for member access) + switch (c) { + case '+': + // + is arithmetic unless it's unary at start or after operator + if (next == '+') return true; // ++ + if (next == '=') return true; // += + // Check if this is binary + by looking at previous non-whitespace + int prevIdx = i - 1; + while (prevIdx >= 0 && Character.isWhitespace(expr.charAt(prevIdx))) prevIdx--; + if (prevIdx >= 0) { + char prev = expr.charAt(prevIdx); + // If previous char is identifier char or ), this is binary + if (Character.isJavaIdentifierPart(prev) || prev == ')' || prev == ']' || prev == '"' || prev == '\'' || Character.isDigit(prev)) { + return true; + } + } + break; + + case '-': + // - is arithmetic unless it's unary minus before a number + if (next == '-') return true; // -- + if (next == '=') return true; // -= + // Check if this is binary - by looking at previous non-whitespace + prevIdx = i - 1; + while (prevIdx >= 0 && Character.isWhitespace(expr.charAt(prevIdx))) prevIdx--; + if (prevIdx >= 0) { + char prev = expr.charAt(prevIdx); + // If previous char is identifier char or ), this is binary + if (Character.isJavaIdentifierPart(prev) || prev == ')' || prev == ']' || Character.isDigit(prev)) { + return true; + } + } + break; + + case '*': case '/': case '%': + return true; + + case '&': + if (next == '&' || next == '=') return true; + // Single & is bitwise AND + return true; + + case '|': + if (next == '|' || next == '=') return true; + // Single | is bitwise OR + return true; + + case '^': case '~': + return true; + + case '<': + // <<, <= are always operators + if (next == '<' || next == '=') return true; + // If preceded by digit/)/] it's definitely a relational operator (not a generic) + prevIdx = i - 1; + while (prevIdx >= 0 && Character.isWhitespace(expr.charAt(prevIdx))) prevIdx--; + if (prevIdx >= 0) { + char prevC = expr.charAt(prevIdx); + if (Character.isDigit(prevC) || prevC == ')' || prevC == ']') return true; + } + // Generics follow an uppercase type name; anything else is relational + int nextNonSpace = i + 1; + while (nextNonSpace < expr.length() && Character.isWhitespace(expr.charAt(nextNonSpace))) nextNonSpace++; + if (nextNonSpace < expr.length() && !Character.isUpperCase(expr.charAt(nextNonSpace))) { + return true; + } + break; + + case '>': + // >>, >= are always operators + if (next == '>' || next == '=') return true; + // If preceded by digit/)/] it's definitely a relational operator (not closing generic) + prevIdx = i - 1; + while (prevIdx >= 0 && Character.isWhitespace(expr.charAt(prevIdx))) prevIdx--; + if (prevIdx >= 0) { + char prevC = expr.charAt(prevIdx); + if (Character.isDigit(prevC) || prevC == ')' || prevC == ']') return true; + } + break; + + case '!': + if (next == '=') return true; // != + // Standalone ! is logical NOT + return true; + + case '=': + if (next == '=') return true; // == + // Single = is assignment + return true; + + case '?': + // Ternary operator - but be careful of generics with ? + // If followed by :, it's definitely ternary + for (int j = i + 1; j < expr.length(); j++) { + if (expr.charAt(j) == ':') return true; + } + break; + } + } + + // Check for instanceof keyword + if (expr.contains(" instanceof ")) { + return true; + } + + return false; + } + + /** + * Check if an expression looks like a JS function or arrow lambda. + * This is a fast heuristic to detect: + * - JS function expressions: function(...) {} + * - Arrow lambdas: (...) => ... + * These need to be routed through the parser for proper SAM typing. + */ + private boolean looksLikeFunctionOrLambda(String expr) { + if (expr == null || expr.isEmpty()) return false; + String trimmed = expr.trim(); + if (trimmed.startsWith("function")) return true; + if (trimmed.contains("=>")) return true; + if (trimmed.contains("->")) return true; + return false; + } + + /** + * Resolve an expression that contains operators or casts using the full expression parser. + * This handles all Java operators with proper precedence and type promotion rules. + */ + private TypeInfo resolveExpressionWithParserAPI(String expr, int position) { + // Create a context that bridges to ScriptDocument's existing resolution methods + ExpressionNode.TypeResolverContext context = createExpressionResolverContext(position); + + // Use the expression resolver to parse and resolve the type + // Pass the position as basePosition so lambda position calculations work correctly + ExpressionTypeResolver resolver = new ExpressionTypeResolver(context, this, position); + TypeInfo result = resolver.resolve(expr); + + // Special case: null literal type is "unresolved" but valid + if (result != null && "".equals(result.getFullName())) { + return result; + } + + // If the expression resolver couldn't resolve it, fall back to simple resolution + if (result == null || !result.isResolved()) { + // Try the simple path in case the operator detection was a false positive + return resolveSimpleExpression(expr, position); + } + + return result; + } + + /** + * Create a type resolver context that connects the expression resolver + * to ScriptDocument's existing type resolution infrastructure. + */ + private ExpressionNode.TypeResolverContext createExpressionResolverContext(int position) { + return new ExpressionNode.TypeResolverContext() { + @Override + public TypeInfo resolveIdentifier(String name) { + if ("this".equals(name)) { + return resolveThisType(position); + } + if ("super".equals(name)) { + // Resolve super to parent class type + ScriptTypeInfo enclosingType = findEnclosingScriptType(position); + if (enclosingType != null && enclosingType.hasSuperClass()) { + return enclosingType.getSuperClass(); + } + return null; + } + if ("true".equals(name) || "false".equals(name)) { + return TypeInfo.fromPrimitive("boolean"); + } + if ("null".equals(name)) { + return TypeInfo.unresolved("null", ""); + } + + // Variable shadowing: variables take precedence over script methods + FieldInfo varInfo = resolveVariable(name, position); + if (varInfo != null) { + return varInfo.getTypeInfo(); + } + + if (name.length() > 0) { + TypeInfo typeCheck = resolveType(name, position); + if (typeCheck != null && typeCheck.isResolved()) { + return typeCheck; + } + } + + // Named script function as SAM callback: schedule("id", actionFunction) + TypeInfo expectedType = ExpressionTypeResolver.CURRENT_EXPECTED_TYPE; + TypeInfo samType = resolveScriptMethodAsSam(name, expectedType); + if (samType != null) { + return samType; + } + + return null; + } + + @Override + public TypeInfo resolveMemberAccess(TypeInfo targetType, String memberName) { + if (targetType == null || !targetType.isResolved()) { + return null; + } + + if (targetType.hasField(memberName)) { + FieldInfo fieldInfo = targetType.getFieldInfo(memberName); + return (fieldInfo != null) ? fieldInfo.getTypeInfo() : null; + } + + return null; + } + + @Override + public TypeInfo resolveMethodCall(TypeInfo targetType, String methodName, TypeInfo[] argTypes) { + if (targetType == null || !targetType.isResolved()) { + // Try as a script-defined method + if (isScriptMethod(methodName)) { + MethodInfo scriptMethod = getScriptMethodInfo(methodName); + if (scriptMethod != null) { + return scriptMethod.getReturnType(); + } + } + if (isGlobalEngineFunction(methodName)) { + return getGlobalEngineFunctionReturnType(methodName); + } + return null; + } + + if (targetType.hasMethod(methodName)) { + MethodInfo methodInfo = targetType.getBestMethodOverload(methodName, argTypes); + return (methodInfo != null) ? methodInfo.getReturnType() : null; + } + + return null; + } + + @Override + public TypeInfo resolveArrayAccess(TypeInfo arrayType) { + if (arrayType == null || !arrayType.isResolved()) { + return null; + } + + String typeName = arrayType.getFullName(); + if (typeName.endsWith("[]")) { + String elementTypeName = typeName.substring(0, typeName.length() - 2); + // Try to resolve the element type properly + return resolveType(elementTypeName); + } + + // For List or similar, try to extract the element type + // This is a simplified version - could be enhanced for full generic support + return null; + } + + @Override + public TypeInfo resolveTypeName(String typeName) { + return resolveType(typeName); + } + }; + } + + /** + * Resolve a simple expression without operators. + * This is the fallback path when operator detection was a false positive. + */ + private TypeInfo resolveSimpleExpression(String expr, int position) { + // String literals + if (expr.startsWith("\"") && expr.endsWith("\"")) { + return TypeInfo.string(); + } + + // Character literals + if (expr.startsWith("'") && expr.endsWith("'")) { + return TypeInfo.fromPrimitive("char"); + } + + // Boolean literals + if (expr.equals("true") || expr.equals("false")) { + return TypeInfo.fromPrimitive("boolean"); + } + + // Null literal + if (expr.equals("null")) { + return null; + } + + // Numeric literals + if (expr.matches("-?\\d*\\.?\\d+[fF]")) { + if (hasExcessivePrecision(expr, 7)) { + return TypeInfo.fromPrimitive("double"); + } + return TypeInfo.fromPrimitive("float"); + } + if (expr.matches("-?\\d*\\.\\d+[dD]?") || expr.matches("-?\\d+\\.[dD]?") || expr.matches("-?\\d+[dD]")) { + if (hasExcessivePrecision(expr, 15)) { + return null; + } + return TypeInfo.fromPrimitive("double"); + } + if (expr.matches("-?\\d+[lL]")) { + return TypeInfo.fromPrimitive("long"); + } + // Hex integer literals: 0x7F, -0x80, 0X1A + if (expr.matches("[-+]?0[xX][0-9a-fA-F][0-9a-fA-F_]*")) { + return narrowIntLiteral(expr); + } + // Binary integer literals: 0b1010, -0b1100, 0B1111 + if (expr.matches("[-+]?0[bB][01][01_]*")) { + return narrowIntLiteral(expr); + } + if (expr.matches("[-+]?\\d[\\d_]*")) { + return narrowIntLiteral(expr); + } + + // "this" keyword + if (expr.equals("this")) { + return resolveThisType(position); + } + + // "new Type()" expressions + if (expr.startsWith("new ")) { + Matcher newMatcher = NEW_TYPE_PATTERN.matcher(expr); + if (newMatcher.find()) { + String typeName = newMatcher.group(1); + + // First check if it's a variable holding a ClassTypeInfo (like var File = Java.type("java.io.File")) + FieldInfo varInfo = resolveVariable(typeName, position); + if (varInfo != null && varInfo.getTypeInfo() instanceof ClassTypeInfo) { + // It's a variable holding a class reference, return the wrapped class + ClassTypeInfo classRef = (ClassTypeInfo) varInfo.getTypeInfo(); + return classRef.getInstanceType(); + } + + // Otherwise treat it as a type name + return resolveType(typeName); + } + } + + // Try as variable or field chain + List segments = parseExpressionChain(expr); + if (segments.isEmpty()) { + return null; + } + + ChainSegment first = segments.get(0); + TypeInfo currentType = null; + + if (first.name.equals("this")) { + currentType = resolveThisType(position); + } else { + // Check if first segment is a type name + TypeInfo typeCheck = resolveType(first.name, position); + if (typeCheck != null && typeCheck.isResolved()) { + currentType = typeCheck; + } + } + + if (currentType == null && !first.isMethodCall) { + FieldInfo varInfo = resolveVariable(first.name, position); + if (varInfo != null) { + currentType = varInfo.getTypeInfo(); + } + } else { + if (isScriptMethod(first.name)) { + MethodInfo scriptMethod = getScriptMethodInfo(first.name); + if (scriptMethod != null) { + currentType = scriptMethod.getReturnType(); + } + } + if (currentType == null && isGlobalEngineFunction(first.name)) { + currentType = getGlobalEngineFunctionReturnType(first.name); + } + } + + currentType = applyBracketAccess(currentType, first); + + for (int i = 1; i < segments.size(); i++) { + currentType = resolveChainSegment(currentType, segments.get(i)); + currentType = applyBracketAccess(currentType, segments.get(i)); + if (currentType == null) { + return null; + } + } + + return currentType; + } + + /** + * Find the matching opening parenthesis when given a closing paren position. + */ + private int findMatchingParenBackward(int closeParenPos) { + if (closeParenPos < 0 || closeParenPos >= text.length() || text.charAt(closeParenPos) != ')') { + return -1; + } + + int depth = 1; + boolean inString = false; + char stringChar = 0; + + for (int i = closeParenPos - 1; i >= 0; i--) { + char c = text.charAt(i); + char next = (i < text.length() - 1) ? text.charAt(i + 1) : 0; + + // Handle string literals (going backward, check for escapes) + if (!inString && (c == '"' || c == '\'')) { + // Check if this quote is escaped (look back for backslash) + int backslashCount = 0; + for (int j = i - 1; j >= 0 && text.charAt(j) == '\\'; j--) { + backslashCount++; + } + if (backslashCount % 2 == 0) { + inString = true; + stringChar = c; + } + } else if (inString && c == stringChar) { + int backslashCount = 0; + for (int j = i - 1; j >= 0 && text.charAt(j) == '\\'; j--) { + backslashCount++; + } + if (backslashCount % 2 == 0) { + inString = false; + } + } + + if (inString) continue; + + // Skip excluded regions (comments) + if (isExcluded(i)) continue; + + if (c == ')') { + depth++; + } else if (c == '(') { + depth--; + if (depth == 0) { + return i; + } + } + } + + return -1; // No matching paren found + } + + /** + * Find the matching opening bracket of a given closing bracket position. + * Supports any pair of open/close chars (e.g., '[' and ']'). + */ + private int findMatchingBracketBackward(int closePos, char openChar, char closeChar) { + if (closePos < 0 || closePos >= text.length() || text.charAt(closePos) != closeChar) { + return -1; + } + + int depth = 1; + boolean inString = false; + char stringChar = 0; + + for (int i = closePos - 1; i >= 0; i--) { + char c = text.charAt(i); + + // Handle string literals (backward) + if (!inString && (c == '"' || c == '\'')) { + int backslashCount = 0; + for (int j = i - 1; j >= 0 && text.charAt(j) == '\\'; j--) backslashCount++; + if (backslashCount % 2 == 0) { + inString = true; + stringChar = c; + } + } else if (inString && c == stringChar) { + int backslashCount = 0; + for (int j = i - 1; j >= 0 && text.charAt(j) == '\\'; j--) backslashCount++; + if (backslashCount % 2 == 0) { + inString = false; + } + } + + if (inString) continue; + + if (isExcluded(i)) continue; + + if (c == closeChar) depth++; + else if (c == openChar) { + depth--; + if (depth == 0) return i; + } + } + return -1; + } + + /** + * Given the position of a dot ('.') in `text`, find the bounds [start, end) + * of the receiver expression immediately to the left of the dot. The end + * returned will be the dot index (exclusive). Returns null if not found or malformed. + */ + int[] findReceiverBoundsBefore(int dotIndex) { + if (dotIndex < 0 || dotIndex >= text.length() || text.charAt(dotIndex) != '.') { + return null; + } + + int pos = dotIndex - 1; + // Skip whitespace + while (pos >= 0 && Character.isWhitespace(text.charAt(pos))) pos--; + if (pos < 0) return null; + + while (pos >= 0) { + // Check if we're in an excluded range (comment, string, etc.) + // Skip excluded regions to avoid picking up types from comment text + if (isExcluded(pos)) { + // Find the excluded range and skip to before it + for (int[] range : excludedRanges) { + if (pos >= range[0] && pos < range[1]) { + pos = range[0] - 1; // Jump to before the excluded range + break; + } + } + continue; // Continue scanning from before the excluded range + } + + char c = text.charAt(pos); + if (Character.isWhitespace(c)) { pos--; continue; } + + if (c == ')') { + int open = findMatchingParenBackward(pos); + if (open < 0) return null; + pos = open - 1; + continue; + } + + if (c == ']') { + int open = findMatchingBracketBackward(pos, '[', ']'); + if (open < 0) return null; + pos = open - 1; + continue; + } + + if (Character.isJavaIdentifierPart(c)) { + while (pos >= 0 && Character.isJavaIdentifierPart(text.charAt(pos))) pos--; + // Skip whitespace to check for chained identifier (preceded by a dot) + int checkPos = pos; + while (checkPos >= 0 && Character.isWhitespace(text.charAt(checkPos))) checkPos--; + // If it's part of a chained identifier (preceded by a dot), continue + if (checkPos >= 0 && text.charAt(checkPos) == '.') { pos = checkPos - 1; continue; } + break; + } + + // Unexpected char - stop and treat as start after this + break; + } + + int start = pos + 1; + int end = dotIndex; // exclusive + if (start >= end) return null; + return new int[]{start, end}; + } + + /** + * Find the innermost script-defined type that contains the given position. + * Uses recursive descent: starts from top-level types in scriptTypes, then drills + * into inner classes. This is O(depth) rather than O(total_types). + */ + public ScriptTypeInfo findEnclosingScriptType(int position) { +for (ScriptTypeInfo type:scriptTypes.values()) { + if (type.containsPosition(position)) { + return findInnermostType(type,position); + } + } + return null; + } + + /** + * Recursively descend into inner classes to find the innermost type containing the position. + * At each level, if an inner class contains the position, recurse into it. + * If no inner class matches, the current parent is the innermost enclosing type. + */ + private ScriptTypeInfo findInnermostType(ScriptTypeInfo parent, int position) { + for (ScriptTypeInfo inner : parent.getInnerClasses()) { + if (inner.containsPosition(position)) { + return findInnermostType(inner, position); + } + } + return parent; + } + + /** + * Find the constructor that contains the given position. + * Used for validating super() calls. + */ + private MethodInfo findEnclosingConstructor(int position) { + ScriptTypeInfo enclosingType = findEnclosingScriptType(position); + if (enclosingType == null) + return null; + + for (MethodInfo constructor : enclosingType.getConstructors()) { + int bodyStart = constructor.getBodyStart(); + int bodyEnd = constructor.getBodyEnd(); + if (bodyStart >= 0 && bodyEnd > bodyStart && position >= bodyStart && position < bodyEnd) { + return constructor; + } + } + return null; + } + + /** + * Handle super() constructor calls with validation and argument matching. + */ + private void handleSuperConstructorCall(List marks, int nameStart, int nameEnd, int openParen, + int closeParen) { + // Validate that we're in a constructor + TokenErrorMessage errorMsg = null; + + //Parent class + ScriptTypeInfo enclosingType = findEnclosingScriptType(nameStart); + MethodInfo enclosingConstructor = findEnclosingConstructor(nameStart); + TypeInfo superClass = enclosingType != null ? enclosingType.getSuperClass() : null; + + // Parse arguments and find matching parent constructor + List arguments = parseMethodArguments(openParen + 1, closeParen, null); + TypeInfo[] argTypes = arguments.stream().map(MethodCallInfo.Argument::getResolvedType).toArray(TypeInfo[]::new); + + // Find matching constructor in parent class + MethodInfo parentConstructor = superClass != null ? superClass.findConstructor(argTypes) : null; + + if (enclosingType == null || !enclosingType.hasSuperClass()) { + // No parent class - error + errorMsg = TokenErrorMessage + .from(enclosingType == null ? "'super()' can only be used within a class" : "Class '" + enclosingType.getSimpleName() + "' does not have a parent class") + .clearOtherErrors(); + } else if (enclosingConstructor == null) { + // Not in a constructor - error + errorMsg = TokenErrorMessage.from("Call to 'super()' only allowed in constructor body").clearOtherErrors(); + } else if (superClass == null || !superClass.isResolved()) { + // Parent class not resolved - error + errorMsg = TokenErrorMessage.from( + "Cannot resolve parent class '" + enclosingType.getSuperClassName() + "'"); + } else if (parentConstructor == null) { + // No matching constructor found + String argTypeStr = java.util.Arrays.stream(argTypes) + .map(t -> t != null ? t.getSimpleName() : "unknown") + .collect(java.util.stream.Collectors.joining(", ")); + errorMsg = TokenErrorMessage + .from("No constructor found in '" + superClass.getSimpleName() + "' matching super(" + argTypeStr + ")") + .clearOtherErrors(); + } + + // Successfully resolved - mark as a valid method call (constructor call) + MethodCallInfo callInfo = new MethodCallInfo("super", nameStart, nameEnd, openParen, closeParen, arguments, + superClass, parentConstructor, false).setConstructor(true); + callInfo.validate(); + methodCalls.add(callInfo); + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.IMPORT_KEYWORD, + errorMsg != null ? errorMsg : callInfo)); + } + + /** + * Check if a method name is defined in this script. + */ + private boolean isScriptMethod(String methodName) { + for (MethodInfo method : methods) { + if (method.getName().equals(methodName)) { + return true; + } + } + return false; + } + + private TypeInfo resolveScriptMethodAsSam(String methodName, TypeInfo expectedType) { + if (methodName == null || expectedType == null || !expectedType.isFunctionalInterface() || !isScriptMethod(methodName)) { + return null; + } + + // Java mode: bare method names are invalid as SAM callbacks + if (!isJavaScript()) { + CURRENT_SAM_CONFLICT_ERROR.set( + "Bare method name '" + methodName + "' cannot be used as callback in Java. Use this::" + methodName + ); + return expectedType; + } + + MethodInfo sam = expectedType.getSingleAbstractMethod(); + if (sam == null) { + return null; + } + + int samArity = sam.getParameters().size(); + MethodInfo bestMatch = getScriptMethodBySamArity(methodName, samArity); + if (bestMatch == null) { + return null; + } + + injectSamParameterTypes(bestMatch, sam); + return expectedType; + } + + /** + * Get the MethodInfo for a script-defined method by name. + */ + private MethodInfo getScriptMethodInfo(String methodName) { + for (MethodInfo method : methods) { + if (method.getName().equals(methodName)) { + return method; + } + } + return null; + } + + /** + * Get the best matching script method overload based on argument types. + */ + MethodInfo getScriptMethodInfo(String methodName, TypeInfo[] argTypes) { + List candidates = new ArrayList<>(); + + // Collect all methods with matching name + for (MethodInfo method : methods) { + if (method.getName().equals(methodName)) { + candidates.add(method); + } + } + + if (candidates.isEmpty()) { + return null; + } + + if (candidates.size() == 1) { + return candidates.get(0); + } + + // Use same 3-phase matching as TypeInfo.getBestMethodOverload + + // Phase 1: Look for exact match + for (MethodInfo method : candidates) { + List params = method.getParameters(); + if (params.size() != argTypes.length) { + continue; + } + + boolean exactMatch = true; + for (int i = 0; i < argTypes.length; i++) { + TypeInfo paramType = params.get(i).getDeclaredType(); + TypeInfo argType = argTypes[i]; + + if (argType == null || paramType == null || !argType.equals(paramType)) { + exactMatch = false; + break; + } + } + + if (exactMatch) { + return method; + } + } + + // Phase 2: Look for compatible match (widening/autoboxing) + for (MethodInfo method : candidates) { + List params = method.getParameters(); + if (params.size() != argTypes.length) { + continue; + } + + boolean compatible = true; + for (int i = 0; i < argTypes.length; i++) { + TypeInfo paramType = params.get(i).getDeclaredType(); + TypeInfo argType = argTypes[i]; + + if (argType != null && paramType != null && !TypeChecker.isTypeCompatible(paramType, argType)) { + compatible = false; + break; + } + } + + if (compatible) { + return method; + } + } + + // Phase 3: Fallback to first overload + return candidates.get(0); + } + + /** + * Get the best matching script method for use as a SAM callback by arity. + * Returns null if no match found, or if multiple overloads match by arity (ambiguous). + * + * @param methodName Name of the script method + * @param samArity Number of parameters in the SAM interface method + * @return The matching MethodInfo, or null if no unambiguous match + */ + private MethodInfo getScriptMethodBySamArity(String methodName, int samArity) { + List matchingByArity = new ArrayList<>(); + + for (MethodInfo method : methods) { + if (method.getName().equals(methodName)) { + if (method.getParameters().size() == samArity) { + matchingByArity.add(method); + } + } + } + + if (matchingByArity.size() == 1) { + return matchingByArity.get(0); + } + + if (matchingByArity.isEmpty()) { + return getScriptMethodInfo(methodName); + } + + CURRENT_SAM_CONFLICT_ERROR.set( + "Ambiguous overload for '" + methodName + "' with " + samArity + " parameter(s): " + + matchingByArity.size() + " overloads match" + ); + return null; + } + + /** + * True if in JS mode and name is a registered global engine function (parseInt, parseFloat, etc.). + */ + private boolean isGlobalEngineFunction(String name) { + return isJavaScript() && JSTypeRegistry.getInstance().isGlobalEngineFunction(name); + } + + /** + * Return the resolved return type of a global engine function call, or null if unknown. + */ + private TypeInfo getGlobalEngineFunctionReturnType(String name) { + JSMethodInfo m = JSTypeRegistry.getInstance().getGlobalEngineFunction(name); + return m != null ? m.getResolvedReturnType(null) : null; + } + + private void injectSamParameterTypes(MethodInfo scriptMethod, MethodInfo sam) { + String methodName = scriptMethod.getName(); + + MethodInfo previousSam = scriptMethodSamContexts.get(methodName); + if (previousSam != null) { + if (!areSamSignaturesCompatible(previousSam, sam)) { + String existingSig = formatSamSignature(previousSam); + String newSig = formatSamSignature(sam); + CURRENT_SAM_CONFLICT_ERROR.set( + "Function '" + methodName + "' used in incompatible SAM contexts: " + + existingSig + " vs " + newSig + ); + return; + } + } else { + scriptMethodSamContexts.put(methodName, sam); + } + + List scriptParams = scriptMethod.getParameters(); + List samParams = sam.getParameters(); + + if (scriptParams.size() != samParams.size()) { + return; + } + + for (int i = 0; i < scriptParams.size(); i++) { + FieldInfo scriptParam = scriptParams.get(i); + TypeInfo samParamType = samParams.get(i).getTypeInfo(); + + if (samParamType == null) { + continue; + } + + TypeInfo declaredType = scriptParam.getDeclaredType(); + + boolean hasExplicitType = declaredType != null + && declaredType.isResolved() + && !"any".equals(declaredType.getFullName()); + + if (hasExplicitType) { + if (!TypeChecker.isTypeCompatible(declaredType, samParamType)) { + scriptMethod.addSamTypeError(i, samParamType, declaredType); + } + } else { + scriptParam.setInferredType(samParamType); + } + } + } + + private boolean areSamSignaturesCompatible(MethodInfo sam1, MethodInfo sam2) { + List params1 = sam1.getParameters(); + List params2 = sam2.getParameters(); + + if (params1.size() != params2.size()) { + return false; + } + + for (int i = 0; i < params1.size(); i++) { + TypeInfo type1 = params1.get(i).getTypeInfo(); + TypeInfo type2 = params2.get(i).getTypeInfo(); + + if (type1 == null || type2 == null) { + continue; + } + + if (!TypeChecker.isTypeCompatible(type1, type2) && !TypeChecker.isTypeCompatible(type2, type1)) { + return false; + } + } + + TypeInfo return1 = sam1.getReturnType(); + TypeInfo return2 = sam2.getReturnType(); + + if (return1 != null && return2 != null) { + if (!TypeChecker.isTypeCompatible(return1, return2) && !TypeChecker.isTypeCompatible(return2, return1)) { + return false; + } + } + + return true; + } + + private String formatSamSignature(MethodInfo sam) { + StringBuilder sb = new StringBuilder(); + sb.append("("); + List params = sam.getParameters(); + for (int i = 0; i < params.size(); i++) { + if (i > 0) sb.append(", "); + TypeInfo type = params.get(i).getTypeInfo(); + sb.append(type != null ? type.getSimpleName() : "?"); + } + sb.append(") -> "); + TypeInfo returnType = sam.getReturnType(); + sb.append(returnType != null ? returnType.getSimpleName() : "void"); + return sb.toString(); + } + + /** + * Check if a method belongs to a script-defined type (class/interface/enum). + * Returns true if the method is defined inside a script type. + */ + private boolean isMethodFromScriptType(MethodInfo method) { + if (method == null || !method.isDeclaration()) { + return false; + } + + int declPos = method.getDeclarationOffset(); + if (declPos < 0) { + return false; + } + + // Check if the method's declaration position is inside any script type's body + for (ScriptTypeInfo scriptType : scriptTypesByFullName.values()) { + if (scriptType.containsPosition(declPos)) { + return true; + } + } + + return false; + } + + private void markVariables(List marks) { + Set knownKeywords = new HashSet<>(Arrays.asList( + "boolean", "int", "float", "double", "long", "char", "byte", "short", "void", + "null", "true", "false", "if", "else", "switch", "case", "for", "while", "do", + "try", "catch", "finally", "return", "throw", "var", "let", "const", "function", + "continue", "break", "this", "new", "typeof", "instanceof", "class", "interface", + "extends", "implements", "import", "package", "public", "private", "protected", + "static", "final", "abstract", "synchronized", "native", "default", "enum", + "throws", "super", "assert", "volatile", "transient" + )); + + if (isJavaScript()) { + knownKeywords.add("delete"); + knownKeywords.add("undefined"); + } + + // First pass: mark method parameters in their declaration positions + List allMethods = getAllMethods(); + allMethods.addAll(getAllConstructors()); + + for (MethodInfo method : allMethods) { + for (FieldInfo param : method.getParameters()) { + int pos = param.getDeclarationOffset(); + String name = param.getName(); + marks.add(new ScriptLine.Mark(pos, pos + name.length(), TokenType.PARAMETER, param)); + } + } + + Pattern identifier = Pattern.compile("\\b([a-zA-Z_][a-zA-Z0-9_]*)\\b"); + Matcher m = identifier.matcher(text); + + identifierLoop: + while (m.find()) { + String name = m.group(1); + int position = m.start(1); + + if (isExcluded(position)) + continue; + if (knownKeywords.contains(name)) + continue; + + // Skip if preceded by dot (field access - handled separately) + if (isPrecededByDot(position)) + continue; + + // Skip import/package statements + if (isInImportOrPackage(position)) + continue; + + // Skip method calls (followed by paren) + if (isFollowedByParen(m.end(1))) + continue; + + // Find containing method + MethodInfo containingMethod = findMethodAtPosition(position); + // Check if this variable is an argument to a method call + MethodCallInfo callInfo = findMethodCallContainingPosition(position); + + // For uppercase identifiers, only process if it's a known field + // Otherwise, let type handling (markImportedClassUsages) handle it + boolean isUppercase = Character.isUpperCase(name.charAt(0)); + + // Scope resolution order: + // 1. Inner callable scope parameters (lambda/function expressions) + // 2. Inner callable scope locals + // 3. Method parameters (if inside method) + // 4. Method local variables (if inside method) + // 5. Enclosing type fields (if inside method) + // 6. Global fields + // 7. Script type fields + + boolean breakOuterLoop = false; + // Mark the parameter name at its declaration site in the parameter list. + // Example: marks the first 'item' in func = (item) => item + 1 + // Needed because the header region is outside the scope body, so findInnermostScopeAt won't find it. + for (InnerCallableScope scope : innerScopes) { + for (FieldInfo param : scope.getParameters()) { + int declStart = param.getDeclarationOffset(); + if (declStart == m.start(1) && name.equals(param.getName())) { + marks.add(new ScriptLine.Mark(m.start(1), m.end(1), TokenType.PARAMETER, param)); + breakOuterLoop = true; + break; + } + } + if (breakOuterLoop) + break; + + } + if (breakOuterLoop) + continue; + + + // Resolve parameter/local usage sites inside the scope body via the innermost enclosing scope. + // Example: marks the second 'item' in func = (item) => item + 1 + Object innermostScope = findInnermostScopeAt(m.start(1)); + if (innermostScope instanceof InnerCallableScope) { + InnerCallableScope innerScope = (InnerCallableScope) innermostScope; + FieldInfo innerParam = innerScope.getParameter(name); + if (innerParam != null) { + marks.add(new ScriptLine.Mark(m.start(1), m.end(1), TokenType.PARAMETER, innerParam)); + continue; + } + // Also check locals + FieldInfo innerLocal = innerScope.getLocals().get(name); + if (innerLocal != null) { + marks.add(new ScriptLine.Mark(m.start(1), m.end(1), TokenType.LOCAL_FIELD, innerLocal)); + continue; + } + } + + // Check parameters (method scope) - fallback if not in inner scope + if (containingMethod != null && containingMethod.hasParameter(name)) { + FieldInfo paramInfo = containingMethod.getParameter(name); + marks.add(new ScriptLine.Mark(m.start(1), m.end(1), TokenType.PARAMETER, paramInfo)); + continue; + } + + FieldInfo localInfo = null; + if (containingMethod != null) { + Map> locals = methodLocals.get(containingMethod.getDeclarationOffset()); + if (locals != null) { + localInfo = pickVisibleLocal(locals.get(name), position); + } + } else { + localInfo = pickVisibleTopLevelLocal(name, position); + } + if (localInfo != null) { + Object metadata = callInfo != null ? new FieldInfo.ArgInfo(localInfo, callInfo) : localInfo; + marks.add(new ScriptLine.Mark(m.start(1), m.end(1), TokenType.LOCAL_FIELD, metadata)); + continue; + } + + // Check enclosing type fields (when inside method) + if (containingMethod != null) { + ScriptTypeInfo enclosingType = findEnclosingScriptType(position); + if (enclosingType != null && enclosingType.hasField(name)) { + FieldInfo fieldInfo = enclosingType.getFieldInfo(name); + if (fieldInfo.isVisibleAt(position)) { + Object metadata = callInfo != null ? new FieldInfo.ArgInfo(fieldInfo, callInfo) : fieldInfo; + marks.add(new ScriptLine.Mark(m.start(1), m.end(1), TokenType.GLOBAL_FIELD, metadata)); + continue; + } + } + } + + // Check other script type fields (only if position is within that type's boundaries). + // Use continue identifierLoop to exit the outer while when a match is found — + // a plain 'continue' would only skip to the next scriptType, causing fall-through + // to the UNDEFINED_VAR mark even after a GLOBAL_FIELD mark was already added. + for (ScriptTypeInfo scriptType : scriptTypesByFullName.values()) { + if (scriptType.hasField(name)) { + // Only check if position is within this script type's class body + if (position >= scriptType.getBodyStart() && position <= scriptType.getBodyEnd()) { + FieldInfo fieldInfo = scriptType.getFieldInfo(name); + if(fieldInfo.isEnumConstant()) + continue; + + if (fieldInfo.isVisibleAt(position)) { + Object metadata = callInfo != null ? new FieldInfo.ArgInfo(fieldInfo, callInfo) : fieldInfo; + marks.add(new ScriptLine.Mark(m.start(1), m.end(1), TokenType.GLOBAL_FIELD, metadata)); + continue identifierLoop; + } + } + } + } + + // Check global fields + if (globalFields.containsKey(name)) { + FieldInfo fieldInfo = globalFields.get(name); + if (fieldInfo.isVisibleAt(position)) { + Object metadata = callInfo != null ? new FieldInfo.ArgInfo(fieldInfo, callInfo) : fieldInfo; + marks.add(new ScriptLine.Mark(m.start(1), m.end(1), TokenType.GLOBAL_FIELD, metadata)); + continue; + } + } + + if (isJavaScript()) { + // check if a variable in global objects + JSTypeRegistry registry = JSTypeRegistry.getInstance(); + String globalObjectType = registry.getGlobalObjectType(name); + if (globalObjectType != null) { + // Resolve the type and create a FieldInfo for it + FieldInfo fieldInfo = resolveVariable(name, position); + if (fieldInfo != null && fieldInfo.isResolved()) { + Object metadata = callInfo != null ? new FieldInfo.ArgInfo(fieldInfo, callInfo) : fieldInfo; + marks.add(new ScriptLine.Mark(m.start(1), m.end(1), TokenType.GLOBAL_FIELD, metadata)); + continue; + } + } + + // Mark DataScript global variable definitions + if (!editorGlobals.isEmpty() && editorGlobals.containsKey(name)) { + FieldInfo fieldInfo = resolveVariable(name, position); + if (fieldInfo != null) { + Object metadata = callInfo != null ? new FieldInfo.ArgInfo(fieldInfo, callInfo) : fieldInfo; + marks.add(new ScriptLine.Mark(m.start(1), m.end(1), TokenType.GLOBAL_FIELD, metadata)); + continue; + } + } + } + + // Skip uppercase if not a known field - type handling will deal with it + if (isUppercase) + continue; + + // Check if it's a script method used as a value (e.g., in schedule("action", methodName)) + if (isScriptMethod(name)) { + MethodInfo scriptMethod = getScriptMethodInfo(name); + if (scriptMethod != null) { + marks.add(new ScriptLine.Mark(m.start(1), m.end(1), TokenType.METHOD_CALL, scriptMethod)); + continue; + } + } + + // Unknown variable - mark as undefined + if (containingMethod != null) { + marks.add(new ScriptLine.Mark(m.start(1), m.end(1), TokenType.UNDEFINED_VAR, callInfo)); + } + } + } + + /** + * Mark chained field accesses like: mc.player.world, array.length, this.field, etc. + * This handles dot-separated access chains and colors each segment appropriately. + * Does NOT mark method calls (identifiers followed by parentheses) - those are handled by {@link #markMethodCalls}. + */ + private void markChainedFieldAccesses(List marks) { + FieldChainMarker marker = new FieldChainMarker(this, text); + marker.markChainedFieldAccesses(marks); + } + + + /** + * Parse assignment statements (reassignments, not declarations) and validate type compatibility. + * This detects patterns like: varName = expr; or obj.field = expr; + * Assignments are stored in the corresponding FieldInfo, not as marks. + */ + private void parseAssignments() { + // First clear any existing assignments in all FieldInfo objects + for (FieldInfo field : globalFields.values()) { + field.clearAssignments(); + } + for (Map> locals : methodLocals.values()) { + for (List fields : locals.values()) { + for (FieldInfo field : fields) { + field.clearAssignments(); + } + } + } + for (List fields : topLevelLocals.values()) { + for (FieldInfo field : fields) { + field.clearAssignments(); + } + } + // Also clear assignments in script type fields (including inner classes) + for (ScriptTypeInfo scriptType : scriptTypesByFullName.values()) { + for (FieldInfo field : scriptType.getFields().values()) { + field.clearAssignments(); + } + } + externalFieldAssignments.clear(); + + // Pattern to find assignments: identifier = expression; + // But NOT declarations (Type varName = expr) or compound assignments (+=, -=, etc.) + // We need to find '=' that is: + // 1. Not preceded by another operator (!, <, >, =) + // 2. Not followed by '=' + // 3. The LHS must be a valid l-value (variable or field access) + + int pos = 0; + while (pos < text.length()) { + // Find the next '=' character + int equalsPos = text.indexOf('=', pos); + if (equalsPos < 0) break; + + // Skip if in excluded region (string/comment) + if (isExcluded(equalsPos)) { + pos = equalsPos + 1; + continue; + } + + // Check it's not part of ==, !=, <=, >=, +=, -=, *=, /=, %=, &=, |=, ^= + if (equalsPos > 0 && "!<>=+-*/%&|^".indexOf(text.charAt(equalsPos - 1)) >= 0) { + pos = equalsPos + 1; + continue; + } + if (equalsPos < text.length() - 1 && text.charAt(equalsPos + 1) == '=') { + pos = equalsPos + 2; + continue; + } + + // Find the start of this statement: walk backward to ';', '{', '}', or a + // depth-0 ',' (multi-declarator separator like "int x=1, y=2"). + // Track '()'/`[]` depth so commas inside argument lists are not treated + // as declarator separators. + int stmtStart = equalsPos - 1; + { + int backDepth = 0; + while (stmtStart >= 0) { + char c = text.charAt(stmtStart); + if (c == ')' || c == ']') { + backDepth++; + } else if (c == '(' || c == '[') { + if (backDepth == 0) { stmtStart++; break; } + backDepth--; + } else if (c == ';' || c == '{' || c == '}') { + stmtStart++; + break; + } else if (c == ',' && backDepth == 0) { + stmtStart++; + break; + } + stmtStart--; + } + } + if (stmtStart < 0) stmtStart = 0; + + // Skip leading whitespace to get to the actual first character of the statement + while (stmtStart < equalsPos && Character.isWhitespace(text.charAt(stmtStart))) { + stmtStart++; + } + + int stmtEnd; + if (isJavaScript()) { + int rhsBoundaryStart = equalsPos + 1; + while (rhsBoundaryStart < text.length() && Character.isWhitespace(text.charAt(rhsBoundaryStart))) { + rhsBoundaryStart++; + } + // For multi-declarator JS statements (var a=1, b=2), the RHS of + // each declarator must stop at the top-level comma. We detect this + // by checking if the statement begins with var/let/const. + boolean isMultiDecl = MultiDeclaratorParser.startsWithJSKeyword(text, stmtStart, equalsPos); + stmtEnd = findJsInitializerEnd(text, rhsBoundaryStart, isMultiDecl); + if (stmtEnd < equalsPos + 1) { + stmtEnd = equalsPos + 1; + } + } else { + // For Java, stop at depth-0 ',' or ';' so that each declarator in + // "int x='str', y=20, z='str'" is bounded independently. + // findJsInitializerEnd handles string literals and bracket depth correctly. + stmtEnd = findJsInitializerEnd(text, equalsPos + 1, true); + if (stmtEnd < equalsPos + 1) stmtEnd = equalsPos + 1; + } + + // Extract LHS (before =) and RHS (after =) + String lhsRaw = text.substring(stmtStart, equalsPos).trim(); + String rhsRaw = text.substring(equalsPos + 1, stmtEnd).trim(); + + // Skip empty assignments + if (lhsRaw.isEmpty() || rhsRaw.isEmpty()) { + pos = equalsPos + 1; + continue; + } + + // Check if this is a declaration (has type before variable name) + // Declarations have: Type varName = expr + // Reassignments have: varName = expr or obj.field = expr + boolean isDeclaration = isVariableDeclaration(lhsRaw); + + if (isDeclaration) { + // This is a declaration with initializer - validate the initial value + createAndAttachDeclarationAssignment(lhsRaw, rhsRaw, stmtStart, equalsPos, stmtEnd); + } else { + // This is a reassignment - create AssignmentInfo and attach to FieldInfo + createAndAttachAssignment(lhsRaw, rhsRaw, stmtStart, equalsPos, stmtEnd); + } + + pos = stmtEnd + 1; + } + } + + /** + * Check if the LHS represents a variable declaration (has a type before the variable name). + */ + private boolean isVariableDeclaration(String lhs) { + // Split by whitespace + String[] parts = lhs.trim().split("\\s+"); + + // Single word = reassignment (e.g., "x") + if (parts.length == 1) { + // Could also be a.b = expr (field access) + return false; + } + + // Check if it matches pattern: [modifiers] Type varName + // Last part is the variable name, second-to-last should be a type + String potentialType = parts[parts.length - 2]; + String potentialVar = parts[parts.length - 1]; + + // Type patterns: primitives, or capitalized class names, or generic types + if (TypeResolver.isPrimitiveType(potentialType) || + (Character.isUpperCase(potentialType.charAt(0)) && potentialType.matches("[A-Za-z_][A-Za-z0-9_<>\\[\\],\\s]*")) || + potentialType.equals("var") || potentialType.equals("let") || potentialType.equals("const")) { + + // Make sure the variable name is a valid identifier (not a field access chain) + if (potentialVar.matches("[a-zA-Z_][a-zA-Z0-9_]*") && !potentialVar.contains(".")) { + return true; + } + } + + return false; + } + + /** + * Create an AssignmentInfo for a reassignment statement and attach it to the appropriate FieldInfo. + */ + private void createAndAttachAssignment(String lhs, String rhs, int stmtStart, int equalsPos, int stmtEnd) { + lhs = lhs.trim(); + rhs = rhs.trim(); + + ObjectLiteralParser.DynamicPropertyAccess dynamicPropertyAccess = isJavaScript() ? ObjectLiteralParser.parseDynamicPropertyAccess(lhs, stmtStart) : null; + + // Parse the target (LHS) + // Could be: varName or obj.field or this.field or array[index] + String targetName = lhs; + FieldInfo targetField = null; + TypeInfo targetType = null; + TypeInfo receiverType = null; + java.lang.reflect.Field reflectionField = null; + + // Find the position where the LHS starts in the actual text (skip leading whitespace) + int lhsStart = stmtStart; + while (lhsStart < equalsPos && Character.isWhitespace(text.charAt(lhsStart))) { + lhsStart++; + } + + // Calculate the actual LHS end (before '=' minus trailing whitespace) + int lhsEnd = equalsPos; + while (lhsEnd > lhsStart && Character.isWhitespace(text.charAt(lhsEnd - 1))) { + lhsEnd--; + } + + // Calculate RHS start (first non-whitespace after '=') + int rhsStart = equalsPos + 1; + while (rhsStart < stmtEnd && Character.isWhitespace(text.charAt(rhsStart))) { + rhsStart++; + } + + // RHS end is at the semicolon position (inclusive for error underline) + int rhsEnd = stmtEnd; + + // Handle chained field access (obj.field) + if (lhs.contains(".")) { + // Split into segments + String[] segments = lhs.split("\\."); + targetName = segments[segments.length - 1].trim(); + + // Check if the last segment has array subscript (e.g., obj.items[0]) + boolean lastSegmentHasArrayAccess = targetName.contains("["); + if (lastSegmentHasArrayAccess) { + targetName = targetName.substring(0, targetName.indexOf('[')).trim(); + } + + // Resolve the chain to get the target type + String receiverExpr = lhs.substring(0, lhs.lastIndexOf('.')).trim(); + receiverType = resolveExpressionType(receiverExpr, lhsStart); + + if (receiverType != null && receiverType.isResolved()) { + // Get the field from the receiver type + if (receiverType.hasField(targetName)) { + targetField = receiverType.getFieldInfo(targetName); + targetType = targetField.getTypeInfo(); + if (lastSegmentHasArrayAccess) { + targetType = unwrapArrayElement(targetType); + } + reflectionField = targetField.getReflectionField(); + } + } + // Minecraft.getMinecraft().thePlayer.PERSISTED_NBT_TAG = null; + + } else if (lhs.contains("[")) { + // Array subscript access (e.g., items[0]) + // Extract the variable name before the bracket + String varName = lhs.substring(0, lhs.indexOf('[')).trim(); + targetName = varName; + if (dynamicPropertyAccess != null) { + ObjectLiteralParser.DynamicFieldResult res = ObjectLiteralParser.resolveExistingField( + dynamicPropertyAccess, this::resolveExpressionType, this::resolveVariable); + receiverType = res.receiverType; + targetName = res.propertyName; + targetField = res.field; + if (targetField != null) { + targetType = targetField.getTypeInfo(); + reflectionField = targetField.getReflectionField(); + } + } + + if (targetField == null) { + targetField = resolveVariable(varName, lhsStart); + } + + if (targetField != null && targetType == null) { + // The variable type is the array type (e.g., ItemStack[]) + // Unwrap to get the element type (e.g., ItemStack) + targetType = unwrapArrayElement(targetField.getTypeInfo()); + reflectionField = targetField.getReflectionField(); + } + } else { + // Simple variable + targetField = resolveVariable(targetName, lhsStart); + if (targetField != null) { + targetType = targetField.getTypeInfo(); + reflectionField = targetField.getReflectionField(); + } + } + + // Resolve the source type (RHS) with expected type context + TypeInfo sourceType; + ExpressionTypeResolver.CURRENT_EXPECTED_TYPE = targetType; + try { + sourceType = resolveExpressionType(rhs, equalsPos + 1); + } finally { + ExpressionTypeResolver.CURRENT_EXPECTED_TYPE = null; + } + + if (dynamicPropertyAccess != null) { + ObjectLiteralParser.DynamicFieldResult res = ObjectLiteralParser.extendAndGetField( + dynamicPropertyAccess, receiverType, sourceType, rhs, + this::resolveExpressionType, this::resolveVariable); + if (res != null) { + receiverType = res.receiverType; + targetName = res.propertyName; + targetField = res.field; + if (targetField != null) { + targetType = targetField.getTypeInfo(); + reflectionField = targetField.getReflectionField(); + } + } + } + + // Type inference: If the target field has "any" type and no inferred type yet, + // set the inferred type from the resolved source type (first assignment wins) + if (targetField != null && targetField.canInferType() && targetField.getInferredType() == null + && sourceType != null && sourceType.isResolved()) { + // Don't infer "any" type - that doesn't refine anything + if (!"any".equals(sourceType.getFullName())) { + targetField.setInferredType(sourceType); + } + } + + // Determine if this is a script-defined field or external field + FieldInfo finalTargetField = targetField; + boolean isScriptField = targetField != null && + (globalFields.containsValue(targetField) || + methodLocals.values().stream().anyMatch(m -> m.values().stream().anyMatch(list -> list.contains(finalTargetField))) || + topLevelLocals.values().stream().anyMatch(list -> list.contains(finalTargetField))); + + // Determine if the target field is final + // For script fields, use the modifiers; for external fields, use reflection + // Array element assignment (items[0] = ...) is always allowed even if the array itself is final + boolean isFinal = false; + if (targetField != null && !lhs.contains("[")) { + isFinal = targetField.isFinal(); + } + + // Create the assignment info using the new constructor + AssignmentInfo info = new AssignmentInfo( + targetName, + stmtStart, + lhsStart, + lhsEnd, + targetType, + rhsStart, + rhsEnd, + sourceType, + rhs, + receiverType, + reflectionField, + isFinal + ); + + if (targetField != null) { + info.setScopeInfo(targetField.getScopeInfo()); + } + + // Validate the assignment + info.validate(); + + // Attach to the appropriate location + if (isScriptField && targetField != null) { + // Script-defined field - attach to FieldInfo + targetField.addAssignment(info); + } else { + // External field or unresolved - store separately + externalFieldAssignments.add(info); + } + } + + /** + * Create an AssignmentInfo for a declaration with initializer and attach it to the appropriate FieldInfo. + * Example: String str = 20; or final int x = "test"; + */ + private void createAndAttachDeclarationAssignment(String lhs, String rhs, int stmtStart, int equalsPos, int stmtEnd) { + lhs = lhs.trim(); + rhs = rhs.trim(); + + // Parse the declaration: [modifiers] Type varName + String[] parts = lhs.split("\\s+"); + if (parts.length < 2) { + return; // Invalid declaration format + } + + // Last part is the variable name + String varName = parts[parts.length - 1].trim(); + + // Find the actual position of the variable name in the text + int varNameStart = stmtStart; + int searchStart = stmtStart; + while (searchStart < equalsPos) { + int found = text.indexOf(varName, searchStart); + if (found >= 0 && found < equalsPos) { + // Verify it's the actual variable name (not part of type name) + // Check that it's either at start or preceded by whitespace + if (found == stmtStart || Character.isWhitespace(text.charAt(found - 1))) { + // Check that it's followed by whitespace or '=' + int afterVar = found + varName.length(); + if (afterVar >= text.length() || Character.isWhitespace(text.charAt(afterVar)) || text.charAt(afterVar) == '=') { + varNameStart = found; + break; + } + } + searchStart = found + 1; + } else { + break; + } + } + + int varNameEnd = varNameStart + varName.length(); + + // Calculate RHS positions + int rhsStart = equalsPos + 1; + while (rhsStart < stmtEnd && Character.isWhitespace(text.charAt(rhsStart))) { + rhsStart++; + } + int rhsEnd = stmtEnd; + + // Resolve the target field (should already exist from parseGlobalFields or parseLocalVariables) + FieldInfo targetField = resolveVariable(varName, varNameStart); + if (targetField == null || targetField.getDeclarationAssignment() != null) { + return; // Field doesn't exist, can't attach assignment + } + + TypeInfo targetType = targetField.getTypeInfo(); + + // Resolve the source type with expected type context + TypeInfo sourceType; + ExpressionTypeResolver.CURRENT_EXPECTED_TYPE = targetType; + try { + sourceType = resolveExpressionType(rhs, rhsStart); + } finally { + ExpressionTypeResolver.CURRENT_EXPECTED_TYPE = null; + } + + // Type inference: If the target field has "any" type and no inferred type yet, + // set the inferred type from the resolved source type + if (targetField.canInferType() && targetField.getInferredType() == null && sourceType != null && sourceType.isResolved()) { + // Don't infer "any" type - that doesn't refine anything + if (!"any".equals(sourceType.getFullName())) { + targetField.setInferredType(sourceType); + } + } + + // Create the assignment info + // Declaration assignments should NOT check final status - this is the one place where final fields can be assigned + AssignmentInfo info = new AssignmentInfo( + varName, + stmtStart, + varNameStart, + varNameEnd, + targetType, + rhsStart, + rhsEnd, + sourceType, + rhs, + null, // No receiver for simple declarations + targetField.getReflectionField(), + false // Don't flag as final for declaration assignments - initial assignment is always allowed + ); + + info.setScopeInfo(targetField.getScopeInfo()); + + // Validate the assignment + info.validate(); + + // Attach as the declaration assignment + targetField.setDeclarationAssignment(info); + } + + // ==================== METHOD INHERITANCE DETECTION ==================== + + /** + * Detect method overrides and interface implementations for all script-defined types. + * This analyzes each method in each ScriptTypeInfo to determine if it: + * - Overrides a method from a parent class (extends) + * - Implements a method from an interface (implements) + * + * The detection uses signature matching (method name + parameter types). + * Also validates that all interface methods are implemented and constructors match. + */ + private void detectMethodInheritance() { + for (ScriptTypeInfo scriptType : scriptTypesByFullName.values()) { + scriptType.clearErrors(); // Clear previous errors + detectMethodInheritanceForType(scriptType); + scriptType.validate(); // Validate after detecting inheritance + } + } + + /** + * Detect method inheritance for a single script type. + */ + private void detectMethodInheritanceForType(ScriptTypeInfo scriptType) { + // Check each method in this type + for (List overloads : scriptType.getMethods().values()) { + for (MethodInfo method : overloads) { + // Check if method overrides a parent class method + if (scriptType.hasSuperClass()) { + TypeInfo superClass = scriptType.getSuperClass(); + if (superClass != null && superClass.isResolved()) { + TypeInfo overrideSource = findMethodInHierarchy(superClass, method, false); + if (overrideSource != null) { + method.setOverridesFrom(overrideSource); + } + } + } + + // Check if method implements an interface method (only if not already marked as override) + if (!method.isOverride() && scriptType.hasImplementedInterfaces()) { + for (TypeInfo iface : scriptType.getImplementedInterfaces()) { + if (iface != null && iface.isResolved()) { + TypeInfo implementsSource = findMethodInInterface(iface, method); + if (implementsSource != null) { + method.setImplementsFrom(implementsSource); + break; // Only mark first matching interface + } + } + } + } + } + } + } + + /** + * Search for a matching method in a type hierarchy (class inheritance). + * @param type The type to search in (and its superclasses) + * @param method The method to find a match for + * @param includeInterfaces Whether to also search interfaces + * @return The TypeInfo containing the matching method, or null if not found + */ + private TypeInfo findMethodInHierarchy(TypeInfo type, MethodInfo method, boolean includeInterfaces) { + if (type == null || !type.isResolved()) + return null; + + // Check if this type has the method + if (hasMatchingMethod(type, method)) { + return type; + } + + // If it's a ScriptTypeInfo, check its super class + if (type instanceof ScriptTypeInfo) { + ScriptTypeInfo scriptType = (ScriptTypeInfo) type; + if (scriptType.hasSuperClass()) { + TypeInfo result = findMethodInHierarchy(scriptType.getSuperClass(), method, includeInterfaces); + if (result != null) + return result; + } + } + + // If it's a Java class, check its superclass + Class javaClass = type.getJavaClass(); + if (javaClass != null) { + Class superClass = javaClass.getSuperclass(); + if (superClass != null && superClass != Object.class) { + TypeInfo superType = TypeInfo.fromClass(superClass); + TypeInfo result = findMethodInHierarchy(superType, method, includeInterfaces); + if (result != null) + return result; + } + } + + return null; + } + + /** + * Search for a matching method in an interface and its super-interfaces. + * @param iface The interface to search in + * @param method The method to find a match for + * @return The TypeInfo containing the matching method, or null if not found + */ + private TypeInfo findMethodInInterface(TypeInfo iface, MethodInfo method) { + if (iface == null || !iface.isResolved()) + return null; + + // Check if this interface has the method + if (hasMatchingMethod(iface, method)) { + return iface; + } + + // Check super-interfaces + Class javaClass = iface.getJavaClass(); + if (javaClass != null && javaClass.isInterface()) { + for (Class superIface : javaClass.getInterfaces()) { + TypeInfo superType = TypeInfo.fromClass(superIface); + TypeInfo result = findMethodInInterface(superType, method); + if (result != null) + return result; + } + } + + return null; + } + + /** + * Check if a type has a method matching the given signature. + * Uses method name and parameter types for matching. + */ + private boolean hasMatchingMethod(TypeInfo type, MethodInfo method) { + String methodName = method.getName(); + int paramCount = method.getParameterCount(); + + // For ScriptTypeInfo, check its methods map + if (type instanceof ScriptTypeInfo) { + ScriptTypeInfo scriptType = (ScriptTypeInfo) type; + List overloads = scriptType.getAllMethodOverloads(methodName); + for (MethodInfo candidate : overloads) { + if (signaturesMatch(method, candidate)) { + return true; + } + } + return false; + } + + // For Java classes, use reflection + Class javaClass = type.getJavaClass(); + if (javaClass == null) + return false; + + try { + for (java.lang.reflect.Method javaMethod : javaClass.getMethods()) { + if (javaMethod.getName().equals(methodName) && + javaMethod.getParameterCount() == paramCount) { + // Check parameter types match + if (parameterTypesMatch(method, javaMethod)) { + return true; + } + } + } + } catch (Exception e) { + // Security or linkage error + } + + return false; + } + + /** + * Check if two MethodInfo signatures match (same name and parameter types). + */ + private boolean signaturesMatch(MethodInfo m1, MethodInfo m2) { + if (!m1.getName().equals(m2.getName())) + return false; + if (m1.getParameterCount() != m2.getParameterCount()) + return false; + + List params1 = m1.getParameters(); + List params2 = m2.getParameters(); + + for (int i = 0; i < params1.size(); i++) { + TypeInfo type1 = params1.get(i).getDeclaredType(); + TypeInfo type2 = params2.get(i).getDeclaredType(); + + // Both null = match + if (type1 == null && type2 == null) + continue; + + // One null, one not = no match + if (type1 == null || type2 == null) + return false; + + // Compare full names + if (!type1.getFullName().equals(type2.getFullName())) { + return false; + } + } + + return true; + } + + /** + * Check if a MethodInfo's parameter types match a Java reflection Method's parameter types. + */ + private boolean parameterTypesMatch(MethodInfo methodInfo, java.lang.reflect.Method javaMethod) { + List params = methodInfo.getParameters(); + Class[] javaParams = javaMethod.getParameterTypes(); + + if (params.size() != javaParams.length) + return false; + + for (int i = 0; i < params.size(); i++) { + TypeInfo paramType = params.get(i).getDeclaredType(); + if (paramType == null) + continue; // Unresolved param, skip check + + Class javaParamClass = javaParams[i]; + String javaParamName = javaParamClass.getName(); + + // Compare type names + if (!paramType.getFullName().equals(javaParamName) && + !paramType.getSimpleName().equals(javaParamClass.getSimpleName())) { + return false; + } + } + + return true; + } + + /** + * Mark types in cast expressions with their appropriate type color. + * Handles: (Type), (Type[]), (pkg.Type), etc. + */ + private void markCastTypes(List marks) { + Matcher m = CAST_TYPE_PATTERN.matcher(text); + + while (m.find()) { + String typeName = m.group(1); + int typeStart = m.start(1); + int typeEnd = m.end(1); + + // Skip if inside string or comment + if (isExcluded(typeStart)) continue; + + // Skip in import/package statements + if (isInImportOrPackage(typeStart)) continue; + + // Resolve the type with position context for inner class names + TypeInfo info = resolveType(typeName, typeStart); + if (info != null && info.isResolved()) { + // Mark the type with its appropriate color + marks.add(new ScriptLine.Mark(typeStart, typeEnd, info.getTokenType(), info)); + } else { + // Unknown type - check if it's a primitive + if (isPrimitiveType(typeName)) { + marks.add(new ScriptLine.Mark(typeStart, typeEnd, TokenType.KEYWORD)); + } else { + // Mark as undefined type + marks.add(new ScriptLine.Mark(typeStart, typeEnd, TokenType.UNDEFINED_VAR)); + } + } + } + } + + /** + * Check if a type name is a primitive type. + */ + private boolean isPrimitiveType(String typeName) { + switch (typeName) { + case "byte": case "short": case "int": case "long": + case "float": case "double": case "char": case "boolean": + case "void": + return true; + default: + return false; + } + } + + private void markImportedClassUsages(List marks) { + // Find uppercase identifiers followed by dot (static method calls, field access) + Pattern classUsage = Pattern.compile("\\b([A-Za-z][a-zA-Z0-9_]*)\\s*\\."); + Matcher m = classUsage.matcher(text); + + while (m.find()) { + String className = m.group(1); + int start = m.start(1); + int end = m.end(1); + + if (isExcluded(start)) + continue; + + // Skip in import/package statements + if (isInImportOrPackage(start)) + continue; + + // For JavaScript, first check synthetic types (Nashorn built-ins like Java, print, etc.) + if (isJavaScript()) { + if (typeResolver.isSyntheticType(className)) { + SyntheticType syntheticType = typeResolver.getSyntheticType(className); + // Mark as IMPORTED_CLASS since it's a type reference + // Pass the TypeInfo (which the hover system can display) + marks.add(new ScriptLine.Mark(m.start(1), m.end(1), TokenType.IMPORTED_CLASS, + syntheticType.getTypeInfo())); + continue; + } + JSTypeRegistry jsRegistry = JSTypeRegistry.getInstance(); + if (jsRegistry.isGlobalImport(className)) { + // Mark as IMPORTED_CLASS since it's a type reference + TypeInfo globalType = TypeInfo.fromJSTypeInfo(jsRegistry.getGlobalImportType(className)); + marks.add(new ScriptLine.Mark(m.start(1), m.end(1), TokenType.INTERFACE_DECL, globalType)); + continue; + } + } + + // Use position-aware resolution so inner class names (e.g., OrbBuilder inside Outer) + // resolve via the positional fallback that walks enclosing.getInnerClass(name). + TypeInfo info = resolveType(className, start); + if (info != null && info.isResolved()) { + marks.add(new ScriptLine.Mark(start, end, info.getTokenType(), info)); + } else { + // Unknown type - mark as undefined + marks.add(new ScriptLine.Mark(start, end, TokenType.UNDEFINED_VAR)); + } + } + + // Also mark uppercase identifiers in type positions (new X(), X variable, etc.) + Pattern typeUsage = Pattern.compile("\\b(new\\s+)?([A-Za-z][a-zA-Z0-9_]*)(?:\\s*<[^>]*>)?\\s*(?:\\(|\\[|\\b[a-z])"); + Matcher tm = typeUsage.matcher(text); + + while (tm.find()) { + String className = tm.group(2); + String newKeyword = tm.group(1); + int start = tm.start(2); + int end = tm.end(2); + + if (isExcluded(start)) + continue; + + // Skip in import/package statements + if (isInImportOrPackage(start)) + continue; + + // When the class name is preceded by a dot (e.g., OrbBuilder in AbilityLine.OrbBuilder), + // walk backwards to reconstruct the full qualified name and resolve via scriptTypesByDotName. + // resolveType(simpleNameOnly) fails outside the enclosing class body; the qualified name always works. + // We also track outerQualStart so we can detect 'new' before the full qualified name. + String resolveKey = className; + int outerQualStart = start; + if (isPrecededByDot(start)) { + int pos = start - 1; + while (pos >= 0 && Character.isWhitespace(text.charAt(pos))) pos--; + while (pos >= 0 && text.charAt(pos) == '.') { + pos--; + while (pos >= 0 && Character.isWhitespace(text.charAt(pos))) pos--; + int identEnd = pos + 1; + while (pos > 0 && (Character.isLetterOrDigit(text.charAt(pos - 1)) || text.charAt(pos - 1) == '_')) pos--; + resolveKey = text.substring(pos, identEnd) + "." + resolveKey; + outerQualStart = pos; + pos--; + while (pos >= 0 && Character.isWhitespace(text.charAt(pos))) pos--; + } + } + TypeInfo info = resolveType(resolveKey, start); + if (info == null || !info.isResolved()) { + info = resolveType(className, start); + } + boolean isClassTypeInfo = false; + ClassTypeInfo classRef = null; + FieldInfo varInfo = null; + // If not a class name, check if it's a variable holding a ClassTypeInfo + if ((info == null || !info.isResolved()) && isJavaScript()) { + varInfo = resolveVariable(className, start); + if (varInfo != null && varInfo.getTypeInfo() instanceof ClassTypeInfo) { + // Variable holds a class reference (like var File = Java.type("java.io.File")) + classRef = (ClassTypeInfo) varInfo.getTypeInfo(); + info = classRef.getInstanceType(); + isClassTypeInfo = true; + } + } + + if (info != null && info.isResolved()) { + boolean isNewCreation = newKeyword != null && newKeyword.trim().equals("new"); + // For dot-qualified types like 'new AbilityLine.OrbBuilder(...)', the regex never + // captures 'new' in group 1 because 'new' precedes 'AbilityLine', not 'OrbBuilder'. + // Detect it by checking whether outerQualStart is preceded by the 'new' keyword. + if (!isNewCreation && outerQualStart < start) { + int checkPos = outerQualStart - 1; + while (checkPos >= 0 && Character.isWhitespace(text.charAt(checkPos))) checkPos--; + if (checkPos >= 2 && "new".equals(text.substring(checkPos - 2, checkPos + 1))) { + char beforeNew = checkPos >= 3 ? text.charAt(checkPos - 3) : ' '; + if (!Character.isLetterOrDigit(beforeNew) && beforeNew != '_') { + isNewCreation = true; + } + } + } + boolean isConstructorDecl = info instanceof ScriptTypeInfo && className.equals(info.getSimpleName()); + + // Check if this is a "new" expression or constructor declaration + if (isNewCreation || isConstructorDecl) { + // Find opening paren after the class name + int searchPos = end; + while (searchPos < text.length() && Character.isWhitespace(text.charAt(searchPos))) + searchPos++; + + if (searchPos < text.length() && text.charAt(searchPos) == '(') { + int openParen = searchPos; + int closeParen = findMatchingParen(openParen); + + if (closeParen >= 0) { + // For constructor declarations, verify it's followed by opening brace + if (isConstructorDecl && !isNewCreation) { + int braceSearch = closeParen + 1; + while (braceSearch < text.length() && Character.isWhitespace(text.charAt(braceSearch))) + braceSearch++; + + if (braceSearch >= text.length() || text.charAt(braceSearch) != '{') { + // Not a constructor declaration, treat as normal type usage + marks.add(new ScriptLine.Mark(start, end, info.getTokenType(), info)); + continue; + } + } + + // Parse arguments to find matching constructor + List arguments = parseMethodArguments(openParen + 1, closeParen, + null); + int argCount = arguments.size(); + TypeInfo[] argTypes = arguments.stream().map(MethodCallInfo.Argument::getResolvedType) + .toArray(TypeInfo[]::new); + + + // Try to find matching constructor (may be null if not found). + // First try exact type-match; if that fails but constructors exist, fall back to + // arg-count match so validate() can fire a WRONG_ARG_TYPE error instead of + // incorrectly treating the call as "no constructor matches N arguments". + MethodInfo constructor = null; + if (info.hasConstructors()) { + constructor = info.findConstructor(argTypes); + if (constructor == null) { + constructor = info.findConstructor(argCount); + } + } + + // Create MethodCallInfo for constructor + // Use the actual variable name (className) for variables, not the class's simple name + MethodCallInfo ctorCall; + if (isClassTypeInfo) { + // Use constructor directly with variable name + ctorCall = new MethodCallInfo( + className, // Use variable name, not class name + start, end, + openParen, closeParen, + arguments, + classRef, // The actual class type + constructor, + false + ).setConstructor(true); + ctorCall.isClassTypeAccess = true; + } else { + // Use factory method for regular types + ctorCall = MethodCallInfo.constructor( + info, constructor, start, end, openParen, closeParen, arguments + ); + } + + ctorCall.validate(); + methodCalls.add(ctorCall); // Add to methodCalls list for error tracking + + + TokenType type = isClassTypeInfo ? varInfo.isGlobal() ? TokenType.GLOBAL_FIELD + : TokenType.LOCAL_FIELD : info.getTokenType(); + marks.add(new ScriptLine.Mark(start, end, type, isClassTypeInfo ? varInfo : ctorCall)); + continue; + } + } + } + + marks.add(new ScriptLine.Mark(start, end, info.getTokenType(), info)); + } else { + // Unknown type - mark as undefined + marks.add(new ScriptLine.Mark(start, end, TokenType.UNDEFINED_VAR)); + } + } + } + + // ==================== PHASE 5: CONFLICT RESOLUTION ==================== + + private List resolveConflicts(List marks) { + // Sort by start position, then by descending priority + marks.sort((a, b) -> { + if (a.start != b.start) + return Integer.compare(a.start, b.start); + return Integer.compare(b.type.getPriority(), a.type.getPriority()); + }); + + List result = new ArrayList<>(); + for (ScriptLine.Mark m : marks) { + boolean skip = false; + + // Remove lower-priority overlapping marks + for (int i = result.size() - 1; i >= 0; i--) { + ScriptLine.Mark r = result.get(i); + if (m.start < r.end && m.end > r.start) { + if (r.type.getPriority() < m.type.getPriority()) { + result.remove(i); + } else { + skip = true; + break; + } + } + } + + if (!skip) { + result.add(m); + } + } + + result.sort(Comparator.comparingInt(m -> m.start)); + return result; + } + + // ==================== PHASE 7: INDENT GUIDES ==================== + + private void computeIndentGuides(List marks) { + for (ScriptLine line : lines) { + line.clearIndentGuides(); + } + + // Build ignored ranges from STRING and COMMENT marks + Set ignored = new HashSet<>(); + for (ScriptLine.Mark m : marks) { + if (m.type == TokenType.STRING || m.type == TokenType.COMMENT) { + ignored.add(new int[]{m.start, m.end}); + } + } + + class OpenBrace { + int lineIdx, col; + + OpenBrace(int l, int c) { + lineIdx = l; + col = c; + } + } + Deque stack = new ArrayDeque<>(); + final int tabSize = 4; + + for (int li = 0; li < lines.size(); li++) { + ScriptLine line = lines.get(li); + String s = line.getText(); + + for (int i = 0; i < s.length(); i++) { + int absPos = line.getGlobalStart() + i; + + // Check if in ignored range + boolean isIgnored = false; + for (int[] range : ignored) { + if (absPos >= range[0] && absPos < range[1]) { + isIgnored = true; + break; + } + } + if (isIgnored) + continue; + + char c = s.charAt(i); + if (c == '{') { + int leading = 0; + for (int k = 0; k < i; k++) { + char ch = s.charAt(k); + leading += (ch == '\t') ? tabSize : 1; + } + stack.push(new OpenBrace(li, leading)); + } else if (c == '}') { + if (!stack.isEmpty()) { + OpenBrace open = stack.pop(); + if (open.lineIdx == li) + continue; + + int from = Math.max(0, open.lineIdx + 1); + int to = Math.min(lines.size() - 1, li); + for (int l = from; l <= to; l++) { + lines.get(l).addIndentGuide(open.col); + } + } + } + } + } + } + + // ==================== UTILITY METHODS ==================== + + /** + * Helper to create and validate a FieldAccessInfo. Does NOT add marks or register the info — + * callers should add to `fieldAccesses` and `marks` as appropriate so marking logic remains in-place. + */ + FieldAccessInfo createFieldAccessInfo(String name, int start, int end, + TypeInfo receiverType, FieldInfo fieldInfo, + boolean isLastSegment, boolean isStaticAccess) { + FieldAccessInfo accessInfo = new FieldAccessInfo(name, start, end, receiverType, fieldInfo, isStaticAccess); + if (isLastSegment) { + TypeInfo expectedType = findExpectedTypeAtPosition(start); + if (expectedType != null) { + accessInfo.setExpectedType(expectedType); + } + } + accessInfo.validate(); + fieldAccesses.add(accessInfo); + return accessInfo; + } + + /** + * Resolve a variable by name at a given position. + * Works for BOTH Java and JavaScript using unified data structures. + * Checks innermost scope first (lambda or method), then walks up parent chain. + */ + public FieldInfo resolveVariable(String name, int position) { + // 1. Check innermost scope (lambda or method) + Object innermostScope = findInnermostScopeAt(position); + + if (innermostScope instanceof InnerCallableScope) { + InnerCallableScope scope = (InnerCallableScope) innermostScope; + + // Check lambda parameters and locals, walking up parent chain + InnerCallableScope currentScope = scope; + while (currentScope != null) { + // Check parameters + FieldInfo param = currentScope.getParameter(name); + if (param != null) { + return param; + } + + // Check locals + FieldInfo local = currentScope.getLocals().get(name); + if (local != null) { + return local; + } + + currentScope = currentScope.getParentScope(); + } + + // Not found in lambda scopes - fall back to enclosing method + // Find which method this lambda is inside + innermostScope = findMethodAtPosition(position); + } + + // 2. Check method scope (params + locals) + if (innermostScope instanceof MethodInfo) { + MethodInfo method = (MethodInfo) innermostScope; + + // Check method parameters + if (method.hasParameter(name)) { + return method.getParameter(name); + } + + // Check method locals + Map> locals = methodLocals.get(method.getDeclarationOffset()); + if (locals != null) { + FieldInfo localInfo = pickVisibleLocal(locals.get(name), position); + if (localInfo != null) { + return localInfo; + } + } + } + + FieldInfo topLocal = pickVisibleTopLevelLocal(name, position); + if (topLocal != null) return topLocal; + + // 4. For Java only: Check if we're inside a script type and look for fields there + if (!isJavaScript()) { + ScriptTypeInfo enclosingType = findEnclosingScriptType(position); + if (enclosingType != null && enclosingType.hasField(name)) { + return enclosingType.getFieldInfo(name); + } + } + + // 4. Check global fields (stores both Java global fields and JS global var/let/const) + if (globalFields.containsKey(name)) { + return globalFields.get(name); + } + + // 5. Check JS global objects from JSTypeRegistry (like API, DBCAPI) + if (isJavaScript()) { + JSTypeRegistry registry = JSTypeRegistry.getInstance(); + String globalObjectType = registry.getGlobalObjectType(name); + if (globalObjectType != null) { + // Resolve the type and create a FieldInfo for it + TypeInfo typeInfo = resolveType(globalObjectType); + if (typeInfo != null && typeInfo.isResolved()) { + // Create a global field for this object with GLOBAL scope + return FieldInfo.globalField(name, typeInfo, -1); + } + } + + // Check if is DataScript global variable definition + String editorGlobalType = editorGlobals.get(name); + if (editorGlobalType != null) { + TypeInfo typeInfo = resolveType(editorGlobalType); + if (typeInfo == null || !typeInfo.isResolved()) { + typeInfo = TypeInfo.ANY; + } + return FieldInfo.globalField(name, typeInfo, -1); + } + } + + return null; + } + + boolean isPrecededByDot(int position) { + if (position <= 0) + return false; + int i = position - 1; + while (i >= 0 && Character.isWhitespace(text.charAt(i))) + i--; + return i >= 0 && text.charAt(i) == '.'; + } + + boolean isInImportOrPackage(int position) { + if (position < 0 || position >= text.length()) + return false; + + int lineStart = text.lastIndexOf('\n', position); + lineStart = lineStart < 0 ? 0 : lineStart + 1; + + int i = lineStart; + while (i < text.length() && Character.isWhitespace(text.charAt(i))) + i++; + + if (text.startsWith("import", i) || text.startsWith("package", i)) { + return true; + } + return false; + } + + /** Check if position is followed by '(' (method call) */ + boolean isFollowedByParen(int pos) { + int check = skipWhitespace(pos); + return check < text.length() && text.charAt(check) == '('; + } + + /** Check if position is followed by '.' */ + boolean isFollowedByDot(int pos) { + int check = skipWhitespace(pos); + return check < text.length() && text.charAt(check) == '.'; + } + + /** Skip whitespace and return new position */ + int skipWhitespace(int pos) { + while (pos < text.length() && Character.isWhitespace(text.charAt(pos))) + pos++; + return pos; + } + + MethodInfo findMethodAtPosition(int position) { + for (MethodInfo method : getAllMethods()) { + if (method.containsPosition(position)) { + return method; + } + } + return null; + } + + /** + * Find the innermost scope (method or inner callable) at a position. + * Returns null if not inside any scope. + */ + public Object findInnermostScopeAt(int position) { + // First check inner callable scopes (most specific) + InnerCallableScope innermost = null; + for (InnerCallableScope scope : innerScopes) { + if (scope.containsPosition(position) || scope.containsHeaderPosition(position)) { + if (innermost == null || scope.getBodyStart() > innermost.getBodyStart()) { + innermost = scope; + } + } + } + + if (innermost != null) { + return innermost; + } + + // Fall back to method scope + return findMethodAtPosition(position); + } + + int findMatchingBrace(int openBraceIndex) { + if (openBraceIndex < 0 || openBraceIndex >= text.length()) + return -1; + + int depth = 0; + for (int i = openBraceIndex; i < text.length(); i++) { + if (isExcluded(i)) + continue; + + char c = text.charAt(i); + if (c == '{') + depth++; + else if (c == '}') { + depth--; + if (depth == 0) + return i; + } + } + return -1; + } + + // ==================== ACCESSORS ==================== + + public List getLines() { + return Collections.unmodifiableList(lines); + } + + public List getImports() { + return Collections.unmodifiableList(imports); + } + + public List getMethods() { + return Collections.unmodifiableList(methods); + } + + public List getInnerScopes() { + return Collections.unmodifiableList(innerScopes); + } + + public ObjectLiteralParser.ObjectLiteralAnalysis getObjectLiteral(int braceOffset) { + return objectLiterals.get(braceOffset); + } + + public List getScriptTypes() { + // Return all types including inner classes — needed by error underline rendering, + // validation loops, and mark building so inner classes get full treatment + return new ArrayList<>(scriptTypesByFullName.values()); + } + + public List getAllMethods() { + List allMethods = new ArrayList<>(methods); + // Iterate all types (including inner) so nested class methods are included + for (ScriptTypeInfo scriptType : scriptTypesByFullName.values()) { + allMethods.addAll(scriptType.getAllMethodsFlat()); + } + + return allMethods; + } + + public List getAllConstructors() { + List allConstructors = new ArrayList<>(); + // Iterate all types (including inner) so nested class constructors are included + for (ScriptTypeInfo scriptType : scriptTypesByFullName.values()) { + allConstructors.addAll(scriptType.getConstructors()); + } + return allConstructors; + } + + public List getMethodCalls() { + List allCalls = new ArrayList<>(methodCalls); + + for (EnumConstantInfo constant : getAllEnumConstants()) { + if (constant.getConstructorCall() != null) + allCalls.add(constant.getConstructorCall()); + } + + + return allCalls; + } + + public List getFieldAccesses() { + return Collections.unmodifiableList(fieldAccesses); + } + + public List getAllEnumConstants() { + List enums = new ArrayList<>(); + for (ScriptTypeInfo scriptType : scriptTypesByFullName.values()) { + if (!scriptType.hasEnumConstants()) + continue; + + enums.addAll(scriptType.getEnumConstants().values()); + } + return enums; + } + /** + * Find an assignment at the given position, prioritizing LHS over RHS. + * Searches across all script fields and external field assignments. + * Used by TokenHoverInfo for finding assignment errors. + */ + public AssignmentInfo findAssignmentAtPosition(int position) { + // Check script fields (FieldInfo.findAssignmentAtPosition already handles LHS/RHS priority) + for (FieldInfo field : globalFields.values()) { + AssignmentInfo assign = field.findAssignmentAtPosition(position); + if (assign != null) { + return assign; + } + } + + for (Map> locals : methodLocals.values()) { + for (List fields : locals.values()) { + for (FieldInfo field : fields) { + AssignmentInfo assign = field.findAssignmentAtPosition(position); + if (assign != null) { + return assign; + } + } + } + } + for (List fields : topLevelLocals.values()) { + for (FieldInfo field : fields) { + AssignmentInfo assign = field.findAssignmentAtPosition(position); + if (assign != null) { + return assign; + } + } + } + + for (AssignmentInfo assign : declarationErrors) { + if (assign.containsLhsPosition(position)) { + return assign; + } + } + + // Check external field assignments with same LHS-first priority + for (AssignmentInfo assign : externalFieldAssignments) { + if (assign.containsLhsPosition(position)) { + return assign; + } + } + + for (AssignmentInfo assign : externalFieldAssignments) { + if (assign.containsRhsPosition(position)) { + return assign; + } + } + + for (ScriptTypeInfo scriptType : scriptTypesByFullName.values()) { + for (FieldInfo field : scriptType.getFields().values()) { + AssignmentInfo assign = field.findAssignmentAtPosition(position); + if (assign != null) + return assign; + } + } + + return null; + } + + public Map getGlobalFields() { + return Collections.unmodifiableMap(globalFields); + } + + /** + * Get all variables available at a specific position. + * Used by autocomplete to show scope-aware suggestions. + * Returns variables from innermost scope first (parameters, then locals), + * walking up through parent scopes, then method scope, then globals. + * + * @param position The cursor position + * @return List of FieldInfo for all available variables, ordered by priority + */ + public List getAvailableVariablesAt(int position) { + List variables = new ArrayList<>(); + + // Check innermost scope (lambda or method) + Object innermostScope = findInnermostScopeAt(position); + + if (innermostScope instanceof InnerCallableScope) { + InnerCallableScope scope = (InnerCallableScope) innermostScope; + + // Add lambda parameters and locals, walking up parent chain + InnerCallableScope currentScope = scope; + while (currentScope != null) { + // Add parameters from this scope + variables.addAll(currentScope.getParameters()); + + // Add locals from this scope (only those visible at position) + for (FieldInfo local : currentScope.getLocals().values()) { + if (local.isVisibleAt(position)) { + variables.add(local); + } + } + + currentScope = currentScope.getParentScope(); + } + + // Fall back to enclosing method + innermostScope = findMethodAtPosition(position); + } + + // Add method scope variables + if (innermostScope instanceof MethodInfo) { + MethodInfo method = (MethodInfo) innermostScope; + + // Add method parameters + variables.addAll(method.getParameters()); + + // Add method locals (only those visible at position) + Map> locals = methodLocals.get(method.getDeclarationOffset()); + if (locals != null) { + for (List candidates : locals.values()) { + FieldInfo best = pickVisibleLocal(candidates, position); + if (best != null) { + variables.add(best); + } + } + } + } + + variables.addAll(getVisibleTopLevelLocals(position)); + + // Add global fields (only those visible at position) + for (FieldInfo globalField : globalFields.values()) { + if (globalField.isVisibleAt(position)) { + variables.add(globalField); + } + } + + // For Java: add fields from enclosing type + if (!isJavaScript()) { + ScriptTypeInfo enclosingType = findEnclosingScriptType(position); + if (enclosingType != null) { + for (FieldInfo field : enclosingType.getFields().values()) { + if (field.isVisibleAt(position)) { + variables.add(field); + } + } + } + } + + // For JS: add global engine objects and editor globals + if (isJavaScript()) { + JSTypeRegistry registry = JSTypeRegistry.getInstance(); + + // Add global engine objects (like API, DBCAPI) + for (String globalName : registry.getGlobalEngineObjects().keySet()) { + FieldInfo field = resolveVariable(globalName, position); + if (field != null && field.isResolved()) { + variables.add(field); + } + } + + // Add editor/DataScript global variables + for (String globalName : editorGlobals.keySet()) { + FieldInfo field = resolveVariable(globalName, position); + if (field != null && field.isResolved()) { + variables.add(field); + } + } + } + + return variables; + } + + /** + * Get all errored assignments across all fields (global, local, and external). + * Used by ScriptLine to draw error underlines. + */ + public List getAllErroredAssignments() { + List errored = new ArrayList<>(); + + // Check global fields + for (FieldInfo field : globalFields.values()) { + errored.addAll(field.getErroredAssignments()); + } + + // Check method locals + for (Map> locals : methodLocals.values()) { + for (List fields : locals.values()) { + for (FieldInfo field : fields) { + errored.addAll(field.getErroredAssignments()); + } + } + } + for (List fields : topLevelLocals.values()) { + for (FieldInfo field : fields) { + errored.addAll(field.getErroredAssignments()); + } + } + + // Check external field assignments + for (AssignmentInfo assign : externalFieldAssignments) { + if (assign.hasError()) { + errored.add(assign); + } + } + + + for (ScriptTypeInfo scriptType : scriptTypesByFullName.values()) { + for (FieldInfo field : scriptType.getFields().values()) { + errored.addAll(field.getErroredAssignments()); + } + } + + + // Include declaration errors (duplicates, etc.) + errored.addAll(declarationErrors); + + return errored; + } + + public TypeResolver getTypeResolver() { + return typeResolver; + } + + public ScriptLine getLine(int index) { + for (ScriptLine line : lines) { + if (line.getLineIndex() == index) { + return line; + } + } + return null; + } + + public ScriptLine getLineAt(int globalPosition) { + for (ScriptLine line : lines) { + if (line.containsPosition(globalPosition)) { + return line; + } + } + return null; + } + + public int getLineIndexAt(int globalPosition) { + for (int i = 0; i < lines.size(); i++) { + if (lines.get(i).containsPosition(globalPosition)) { + return i; + } + } + return -1; + } + + /** + * Get all tokens that fall within a given range [start, end). + * Returns tokens in order. Tokens that span across the range boundaries + * are included if any part of them is within the range. + */ + public List getTokensInRange(int start, int end) { + List result = new ArrayList<>(); + if (start < 0 || end <= start) return result; + + for (ScriptLine line : lines) { + // Skip lines entirely before the range + if (line.getGlobalEnd() <= start) continue; + // Stop if line is entirely after the range + if (line.getGlobalStart() >= end) break; + + for (Token token : line.getTokens()) { + // Check if token overlaps with range + if (token.getGlobalEnd() > start && token.getGlobalStart() < end) { + result.add(token); + } + } + } + return result; + } + + /** + * Find the expected type for an expression at the given position by looking for assignment context. + * Returns the type of the variable being assigned to, or null if not in an assignment. + * + * Examples: + * - "Type varName = expr;" -> returns Type + * - "varName = expr;" -> returns type of varName + */ + public TypeInfo findExpectedTypeAtPosition(int position) { + // Walk backward from position to find '=' + int pos = position - 1; + while (pos >= 0 && Character.isWhitespace(text.charAt(pos))) { + pos--; + } + + // Look for '=' that precedes this position + int equalsPos = -1; + int depth = 0; // Track parentheses/brackets depth + for (int i = pos; i >= 0; i--) { + if (isExcluded(i)) continue; + + char c = text.charAt(i); + if (c == ')' || c == ']') depth++; + else if (c == '(' || c == '[') depth--; + else if (c == '=' && depth == 0) { + // Make sure it's not ==, !=, <=, >= + if (i > 0 && "!<>=".indexOf(text.charAt(i - 1)) >= 0) continue; + if (i < text.length() - 1 && text.charAt(i + 1) == '=') continue; + equalsPos = i; + break; + } + else if (c == ';' || c == '{' || c == '}') { + // Reached statement boundary without finding assignment + break; + } + } + + if (equalsPos < 0) { + return null; // Not in an assignment + } + + // Now parse the left-hand side of the assignment + // Could be: "Type varName = expr" or "varName = expr" + pos = equalsPos - 1; + while (pos >= 0 && Character.isWhitespace(text.charAt(pos))) { + pos--; + } + + if (pos < 0) return null; + + // Find the variable name (work backward to find identifier) + int varNameEnd = pos + 1; + int varNameStart = pos; + while (varNameStart >= 0 && (Character.isJavaIdentifierPart(text.charAt(varNameStart)))) { + varNameStart--; + } + varNameStart++; // Move to first char of identifier + + if (varNameStart >= varNameEnd) return null; + + String varName = text.substring(varNameStart, varNameEnd); + + // Now check if there's a type declaration before the variable name + pos = varNameStart - 1; + while (pos >= 0 && Character.isWhitespace(text.charAt(pos))) { + pos--; + } + + if (pos < 0) { + // Just "varName = expr" - look up varName in scope + return lookupVariableType(varName, position); + } + + // Check if this could be a type declaration (look for identifier before varName) + int typeEnd = pos + 1; + int typeStart = pos; + while (typeStart >= 0 && (Character.isJavaIdentifierPart(text.charAt(typeStart)) || + text.charAt(typeStart) == '<' || text.charAt(typeStart) == '>' || + text.charAt(typeStart) == '[' || text.charAt(typeStart) == ']' || + text.charAt(typeStart) == ',')) { + typeStart--; + } + typeStart++; + + if (typeStart >= typeEnd) { + // Just "varName = expr" - look up varName + return lookupVariableType(varName, position); + } + + String typeStr = text.substring(typeStart, typeEnd).trim(); + + // Check if this is a var/let/const keyword (type inference) + if (typeStr.equals("var") || typeStr.equals("let") || typeStr.equals("const")) { + // Can't determine expected type from var/let/const + return null; + } + + // Resolve the type + return resolveType(typeStr); + } + + /** + * Look up the type of a variable by name at the given position. + */ + private TypeInfo lookupVariableType(String varName, int position) { + // Check method locals + MethodInfo containingMethod = findMethodAtPosition(position); + if (containingMethod != null) { + Map> locals = methodLocals.get(containingMethod.getDeclarationOffset()); + if (locals != null) { + FieldInfo field = pickVisibleLocal(locals.get(varName), position); + if (field != null) { + return field.getTypeInfo(); + } + } + } + + FieldInfo topLevelLocal = pickVisibleTopLevelLocal(varName, position); + if (topLevelLocal != null) { + return topLevelLocal.getTypeInfo(); + } + + // Check global fields + if (globalFields.containsKey(varName)) { + return globalFields.get(varName).getTypeInfo(); + } + + return null; + } + + // ==================== AUTOCOMPLETE SUPPORT ==================== + + /** + * Find the method that contains the given position. + * Public accessor for autocomplete. + */ + public MethodInfo findContainingMethod(int position) { + return findMethodAtPosition(position); + } + + /** + * Get local variables for a specific method. + * Used by autocomplete to show variables in scope. + */ + public Map getLocalsForMethod(MethodInfo method) { + if (method == null) return null; + Map> locals = methodLocals.get(method.getDeclarationOffset()); + if (locals == null) { + return null; + } + Map flattened = new HashMap<>(); + for (Map.Entry> e : locals.entrySet()) { + List fields = e.getValue(); + if (fields != null && !fields.isEmpty()) { + flattened.put(e.getKey(), fields.get(0)); + } + } + return flattened; + } + + /** + * Get all imported types that have been resolved. + * Used by autocomplete to show available types. + */ + public Set getImportedTypes() { + Set types = new HashSet<>(); + for (ImportData imp : imports) { + if (!imp.isWildcard() && imp.isResolved()) { + TypeInfo type = typeResolver.resolveSimpleName(imp.getSimpleName(), importsBySimpleName, wildcardPackages); + if (type != null && type.isResolved()) { + types.add(type); + } + } + } + // For class-level wildcard imports (e.g. INpcEvent.*), add the outer class itself. + // Package-level wildcards (e.g. noppes.npcs.api.event.*) are skipped — those are + // already covered by addUnimportedClassSuggestions via ClassIndex. + for (String pkg : wildcardPackages) { + TypeInfo outerType = typeResolver.resolveFullName(pkg); + if (outerType != null && outerType.isResolved()) { + // resolveFullName succeeded → pkg is a class, not a package + types.add(outerType); + } + } + return types; + } + + /** + * Get script types as a Map (needed by autocomplete). + * Returns only top-level types keyed by simple name for backward compatibility. + */ + public Map getScriptTypesMap() { + return Collections.unmodifiableMap(scriptTypes); + } + + /** + * Get all script types including inner classes, keyed by full ($-separated) name. + * Use this when you need to iterate or look up inner classes. + */ + public Map getAllScriptTypes() { + return Collections.unmodifiableMap(scriptTypesByFullName); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptLine.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptLine.java new file mode 100644 index 000000000..f3deb5ecf --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptLine.java @@ -0,0 +1,431 @@ +package noppes.npcs.client.gui.util.script.interpreter; + +import noppes.npcs.client.ClientProxy; +import noppes.npcs.client.gui.util.script.interpreter.field.EnumConstantInfo; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldAccessInfo; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodCallInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.token.Token; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenErrorMessage; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenType; +import noppes.npcs.client.gui.util.script.interpreter.type.ImportData; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.function.Predicate; + +/** + * Represents a single line of source code with its tokens. + * Handles token management, navigation, and rendering. + * + * A ScriptLine is responsible for: + * - Storing tokens that fall within this line's character range + * - Managing token navigation (prev/next within line) + * - Rendering the line with proper syntax highlighting + * - Computing indent guides for this line + */ +public class ScriptLine { + + private static final char COLOR_CHAR = '\u00A7'; + + private final String text; // The actual text of this line + public final int globalStart; // Start offset in the full document + public final int globalEnd; // End offset in the full document (exclusive) + public final int lineIndex; // 0-based line number + + private final List tokens = new ArrayList<>(); + private final List indentGuides = new ArrayList<>(); // Column positions for indent guides + + // Navigation + private ScriptLine prev; + private ScriptLine next; + private ScriptDocument parent; + + public ScriptLine(String text, int globalStart, int globalEnd, int lineIndex) { + this.text = text; + this.globalStart = globalStart; + this.globalEnd = globalEnd; + this.lineIndex = lineIndex; + } + + // ==================== GETTERS ==================== + + public String getText() { return text; } + public int getGlobalStart() { return globalStart; } + public int getGlobalEnd() { return globalEnd; } + public int getLineIndex() { return lineIndex; } + public int getLength() { return text.length(); } + public List getTokens() { return Collections.unmodifiableList(tokens); } + public List getIndentGuides() { return Collections.unmodifiableList(indentGuides); } + public ScriptDocument getParent() { return parent; } + + void setParent(ScriptDocument parent) { this.parent = parent; } + void setPrev(ScriptLine prev) { this.prev = prev; } + void setNext(ScriptLine next) { this.next = next; } + + // ==================== NAVIGATION ==================== + + public ScriptLine prev() { return prev; } + public ScriptLine next() { return next; } + + public Token getFirstToken() { + return tokens.isEmpty() ? null : tokens.get(0); + } + + public Token getLastToken() { + return tokens.isEmpty() ? null : tokens.get(tokens.size() - 1); + } + + public Token getTokenAt(int globalPosition) { + for (Token t : tokens) + if (globalPosition >= t.getGlobalStart() && globalPosition <= t.getGlobalEnd()) + return t; + + return null; + } + + public Token getTokenAt(int globalPosition, Predicate condition) { + for (Token t : tokens) + if (globalPosition >= t.getGlobalStart() && globalPosition <= t.getGlobalEnd() && condition.test(t)) + return t; + + return null; + + } + + // ==================== TOKEN MANAGEMENT ==================== + + /** + * Clear all tokens from this line. + */ + public void clearTokens() { + tokens.clear(); + } + + /** + * Add a token to this line and set up navigation links. + */ + public void addToken(Token token) { + if (!tokens.isEmpty()) { + Token last = tokens.get(tokens.size() - 1); + last.setNext(token); + token.setPrev(last); + } + token.setParentLine(this); + tokens.add(token); + } + + /** + * Build tokens from a list of marks (highlight regions). + * Fills gaps between marks with DEFAULT tokens. + * Attaches metadata from marks to the created tokens. + * + * @param marks List of highlight marks that overlap this line + * @param fullText The complete document text + * @param document The parent ScriptDocument (for context lookups) + */ + public void buildTokensFromMarks(List marks, String fullText, ScriptDocument document) { + clearTokens(); + int cursor = globalStart; + + for (Mark mark : marks) { + // Skip marks that don't overlap this line + if (mark.end <= globalStart || mark.start >= globalEnd) { + continue; + } + + // Clamp mark to line boundaries + int tokenStart = Math.max(mark.start, globalStart); + int tokenEnd = Math.min(mark.end, globalEnd); + + // Validate bounds + tokenStart = Math.max(0, Math.min(tokenStart, fullText.length())); + tokenEnd = Math.max(0, Math.min(tokenEnd, fullText.length())); + + // Add default token for any gap before this mark + if (cursor < tokenStart) { + int gapEnd = Math.min(tokenStart, fullText.length()); + String gapText = fullText.substring(cursor, gapEnd); + addToken(Token.defaultToken(gapText, cursor, gapEnd)); + } + + // Add the marked token with metadata + if (tokenStart < tokenEnd) { + String tokenText = fullText.substring(tokenStart, tokenEnd); + Token token = new Token(tokenText, tokenStart, tokenEnd, mark.type); + + // Attach metadata based on type + if (mark.metadata != null) + applyTokenMetadata(token, mark.metadata); + + addToken(token); + } + + cursor = tokenEnd; + } + + // Add trailing default token if needed + if (cursor < globalEnd) { + int end = Math.min(globalEnd, fullText.length()); + if (cursor < end) { + String trailingText = fullText.substring(cursor, end); + addToken(Token.defaultToken(trailingText, cursor, end)); + } + } + } + + public void applyTokenMetadata(Token token, Object metadata) { + if (metadata instanceof TypeInfo) { + token.setTypeInfo((TypeInfo) metadata); + } 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); + } + } + // ==================== INDENT GUIDES ==================== + + /** + * Clear indent guides for this line. + */ + public void clearIndentGuides() { + indentGuides.clear(); + } + + /** + * Add an indent guide at the specified column. + */ + public void addIndentGuide(int column) { + if (!indentGuides.contains(column)) { + indentGuides.add(column); + } + } + + // ==================== RENDERING ==================== + + /** + * Draw this line with syntax highlighting using Minecraft color codes. + * Compatible with the existing rendering system. + * Also draws curly underlines for tokens with errors (method call validation failures). + * Supports bold (§l) and italic (§o) formatting for certain token types. + */ + public void drawString(int x, int y, int defaultColor) { + StringBuilder builder = new StringBuilder(); + int lastIndex = 0; + + // Track positions for underlines + int currentX = x; + + for (Token t : tokens) { + int tokenStart = t.getGlobalStart() - globalStart; // relative position in line + int tokenWidth = ClientProxy.Font.width(t.getText()); + + // Calculate gap width before this token + if (tokenStart > lastIndex && tokenStart <= text.length()) { + String gapText = text.substring(lastIndex, tokenStart); + builder.append(gapText); + currentX += ClientProxy.Font.width(gapText); + } + + + // Append style codes (bold/italic) if applicable + String stylePrefix = t.getStylePrefix(); + + // Append the colored token with style + builder.append(COLOR_CHAR) + .append(t.getColorCode()) + .append(stylePrefix) + .append(t.getText()) + .append(COLOR_CHAR) + .append('r'); // Reset all formatting (color + bold/italic) + + currentX += tokenWidth; + lastIndex = tokenStart + t.getText().length(); + } + + // Append any remaining text after the last token + if (lastIndex < text.length()) { + builder.append(text.substring(lastIndex)); + } + + // Draw the text + ClientProxy.Font.drawString(builder.toString(), x, y, defaultColor); +// Minecraft.getMinecraft().fontRenderer.drawString(builder.toString(), x, y, defaultColor); + + + // Draw underlines for validation errors (method calls and field accesses) + drawErrorUnderlines(x, y + ClientProxy.Font.height() - 1); + } + /** + * Draw this line with hex colors instead of Minecraft color codes. + * More flexible but requires custom font rendering. + * Also draws wavy underlines for tokens with errors. + */ + public void drawStringHex(int x, int y) { + // Build the complete text with all tokens and gaps, draw it as ONE string + // to match the spacing behavior of drawString which draws everything at once + StringBuilder fullText = new StringBuilder(); + int lastIndex = 0; + + // Build segments with token position info + java.util.List segments = new java.util.ArrayList<>(); + + for (Token t : tokens) { + int tokenStart = t.getGlobalStart() - globalStart; + + // Add any gap before this token + if (tokenStart > lastIndex && tokenStart <= text.length()) { + String gap = text.substring(lastIndex, tokenStart); + segments.add(new TextSegment(fullText.length(), gap, 0xFFFFFFFF, false)); + fullText.append(gap); + } + + // Add the colored token + String styledText = t.getStylePrefix() + t.getText(); + segments.add(new TextSegment(fullText.length(), styledText, t.getHexColor(), true)); + fullText.append(styledText); + + lastIndex = tokenStart + styledText.length(); + } + + // Add any remaining text after the last token + if (lastIndex < text.length()) { + String remaining = text.substring(lastIndex); + segments.add(new TextSegment(fullText.length(), remaining, 0xFFFFFFFF, false)); + fullText.append(remaining); + } + + // Draw each segment at the correct position + // Calculate positions based on the full string to match drawString's spacing + for (TextSegment seg : segments) { + if (!seg.text.isEmpty()) { + // Get the width of everything before this segment + String prefix = fullText.substring(0, seg.startPos); + int prefixWidth = ClientProxy.Font.width(prefix); + int color = (seg.color & 0xFF000000) == 0 ? (0xFF000000 | seg.color) : seg.color; + + // Draw this segment at the correct position + ClientProxy.Font.drawString(seg.text, x + prefixWidth, y, color); + // Minecraft.getMinecraft().fontRenderer.drawString(seg.text, x + prefixWidth, y, color); + } + } + + drawErrorUnderlines(x, y + ClientProxy.Font.height() - 1); + } + + /** + * Draw underlines for all validation errors (method calls and field accesses) that intersect this line. + * Delegates to ErrorUnderlineRenderer for the actual rendering logic. + */ + private void drawErrorUnderlines(int lineStartX, int baselineY) { + if (parent == null) + return; + + ErrorUnderlineRenderer.drawErrorUnderlines( + parent, + lineStartX, + baselineY, + getText(), + getGlobalStart(), + getGlobalEnd() + ); + } + + + // Helper class to track text segments + private static class TextSegment { + final int startPos; + final String text; + final int color; + final boolean isToken; + + TextSegment(int startPos, String text, int color, boolean isToken) { + this.startPos = startPos; + this.text = text; + this.color = color; + this.isToken = isToken; + } + } + // ==================== UTILITIES ==================== + + /** + * Check if a global position falls within this line. + */ + public boolean containsPosition(int globalPosition) { + return globalPosition >= globalStart && globalPosition < globalEnd; + } + + /** + * Convert a global position to a column (local offset) within this line. + */ + public int toColumn(int globalPosition) { + return Math.max(0, Math.min(globalPosition - globalStart, text.length())); + } + + /** + * Convert a column (local offset) to a global position. + */ + public int toGlobal(int column) { + return globalStart + Math.max(0, Math.min(column, text.length())); + } + + @Override + public String toString() { + return "ScriptLine{" + lineIndex + ": '" + text + "' [" + globalStart + "-" + globalEnd + "], " + tokens.size() + " tokens}"; + } + + // ==================== MARK CLASS (for token building) ==================== + + /** + * A simple mark representing a highlighted region. + * Used during token building phase. + * Can optionally carry metadata (TypeInfo, FieldInfo, MethodInfo, ImportData). + */ + public static class Mark { + public final int start; + public final int end; + public final TokenType type; + public final Object metadata; + + public Mark(int start, int end, TokenType type) { + this.start = start; + this.end = end; + this.type = type; + this.metadata = null; + } + + public Mark(int start, int end, TokenType type, Object metadata) { + this.start = start; + this.end = end; + this.type = type; + this.metadata = metadata; + } + + @Override + public String toString() { + return "Mark{" + type + " [" + start + "-" + end + "]" + (metadata != null ? " " + metadata.getClass().getSimpleName() : "") + "}"; + } + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptTextContainer.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptTextContainer.java new file mode 100644 index 000000000..05da45227 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/ScriptTextContainer.java @@ -0,0 +1,261 @@ +package noppes.npcs.client.gui.util.script.interpreter; + +import noppes.npcs.client.ClientProxy; +import noppes.npcs.client.gui.util.script.JavaTextContainer; +import noppes.npcs.constants.ScriptContext; + +import java.util.Collections; +import java.util.Map; + +/** + * New interpreter-based text container that replaces JavaTextContainer. + * + * This class provides the same interface as JavaTextContainer but uses the + * new modular interpreter system internally. It produces compatible LineData + * objects for seamless integration with GuiScriptTextArea. + * + * Key differences from JavaTextContainer: + * - Clean single-pass tokenization with 7 distinct phases + * - Proper token navigation via prev()/next() methods + * - Type-specific metadata on tokens (TypeInfo, FieldInfo, MethodInfo) + * - Better separation of concerns (TypeResolver, ScriptDocument, ScriptLine) + * - Hex color support in addition to Minecraft color codes + */ +public class ScriptTextContainer extends JavaTextContainer { + + /** + * Feature flag to enable/disable the new interpreter system. + * When false, falls back to original JavaTextContainer behavior. + */ + public static boolean USE_NEW_INTERPRETER = true; + + private ScriptDocument document; + + /** The scripting language: "ECMAScript", "Groovy", etc. */ + private String language = "ECMAScript"; + + /** The script context: NPC, PLAYER, BLOCK, ITEM, etc. */ + private ScriptContext scriptContext = ScriptContext.GLOBAL; + + /** Editor-injected globals (name -> type name) */ + private Map editorGlobals = Collections.emptyMap(); + + public ScriptTextContainer(String text) { + super(text); + if (USE_NEW_INTERPRETER) { + document = new ScriptDocument(text); + } + } + + public ScriptTextContainer(String text, String language) { + super(text); + this.language = language != null ? language : "ECMAScript"; + if (USE_NEW_INTERPRETER) { + document = new ScriptDocument(text, this.language); + } + } + + /** + * Set the scripting language. This affects syntax highlighting and type inference. + * @param language The language name (e.g., "ECMAScript", "Groovy") + */ + public void setLanguage(String language) { + this.language = language != null ? language : "ECMAScript"; + if (document != null) { + document.setLanguage(this.language); + } + } + + /** + * Get the current scripting language. + */ + public String getLanguage() { + return language; + } + + /** + * Set the script context (NPC, PLAYER, BLOCK, ITEM, etc.). + * This determines which hooks and event types are available for autocomplete. + * + * @param context The script context + */ + public void setScriptContext(ScriptContext context) { + this.scriptContext = context != null ? context : ScriptContext.GLOBAL; + if (document != null) { + document.setScriptContext(this.scriptContext); + } + } + + /** + * Get the current script context. + * + * @return The script context (NPC, PLAYER, BLOCK, ITEM, etc.) + */ + public ScriptContext getScriptContext() { + return scriptContext; + } + + /** + * Set editor-injected globals (name -> type name). + */ + public void setEditorGlobalsMap(java.util.Map globals) { + this.editorGlobals = globals != null ? globals : java.util.Collections.emptyMap(); + if (document != null) { + document.setEditorGlobals(this.editorGlobals); + } + } + + /** + * Add implicit imports that should be resolved without explicit import statements. + * Used for JaninoScript default imports and hook parameter types. + * + * @param patterns Array of import patterns to add (wildcard packages like "noppes.npcs.api.*" or FQ class names) + */ + public void addImplicitImports(String... patterns) { + if (document != null) { + document.addImplicitImports(patterns); + } + } + + @Override + public void init(int width, int height) { + if (!USE_NEW_INTERPRETER) { + super.init(width, height); + return; + } + + lineHeight = ClientProxy.Font.height(); + if (lineHeight == 0) lineHeight = 12; + + // Initialize the document + document.setText(text); + document.init(width, height); + + // Convert ScriptLines to LineData for compatibility + rebuildLineData(); + + linesCount = lines.size(); + totalHeight = linesCount * lineHeight; + visibleLines = Math.max(height / lineHeight - 1, 1); + } + + /** + * Initialize with explicit text (called when text changes). + */ + @Override + public void init(String text, int width, int height) { + this.text = text == null ? "" : text.replaceAll("\\r?\\n|\\r", "\n"); + + if (!USE_NEW_INTERPRETER) { + super.init(text, width, height); + return; + } + + if (document == null) { + document = new ScriptDocument(this.text, this.language); + document.setScriptContext(this.scriptContext); + document.setEditorGlobals(this.editorGlobals); + } + + init(width, height); + } + + /** + * Convert ScriptDocument lines to the legacy LineData format. + */ + private void rebuildLineData() { + lines.clear(); + for (ScriptLine scriptLine : document.getLines()) { + LineData ld = new LineData( + scriptLine.getText(), + scriptLine.getGlobalStart(), + scriptLine.getGlobalEnd() + ); + + // Copy indent guides + ld.indentCols.addAll(scriptLine.getIndentGuides()); + + // Convert tokens - use fully qualified name to avoid conflict with inherited Token + for (noppes.npcs.client.gui.util.script.interpreter.token.Token interpreterToken : scriptLine.getTokens()) { + ld.tokens.add(new JavaTextContainer.Token( + interpreterToken.getText(), + toLegacyTokenType(interpreterToken.getType()), + interpreterToken.getGlobalStart(), + interpreterToken.getGlobalEnd() + )); + } + + lines.add(ld); + } + } + + /** + * Main formatting entry point - matches JavaTextContainer signature. + */ + @Override + public void formatCodeText() { + if (!USE_NEW_INTERPRETER) { + super.formatCodeText(); + return; + } + + document.formatCodeText(); + rebuildLineData(); + } + + /** + * Convert new interpreter TokenType to legacy JavaTextContainer.TokenType format. + */ + private JavaTextContainer.TokenType toLegacyTokenType( + noppes.npcs.client.gui.util.script.interpreter.token.TokenType type) { + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.COMMENT) return JavaTextContainer.TokenType.COMMENT; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.STRING) return JavaTextContainer.TokenType.STRING; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.CLASS_KEYWORD) return JavaTextContainer.TokenType.CLASS_KEYWORD; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.IMPORT_KEYWORD) return JavaTextContainer.TokenType.IMPORT_KEYWORD; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.KEYWORD) return JavaTextContainer.TokenType.KEYWORD; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.MODIFIER) return JavaTextContainer.TokenType.MODIFIER; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.INTERFACE_DECL) return JavaTextContainer.TokenType.INTERFACE_DECL; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.ENUM_DECL) return JavaTextContainer.TokenType.ENUM_DECL; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.CLASS_DECL) return JavaTextContainer.TokenType.CLASS_DECL; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.IMPORTED_CLASS) return JavaTextContainer.TokenType.IMPORTED_CLASS; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.TYPE_DECL) return JavaTextContainer.TokenType.TYPE_DECL; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.METHOD_DECL) return JavaTextContainer.TokenType.METHOD_DECARE; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.METHOD_CALL) return JavaTextContainer.TokenType.METHOD_CALL; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.LITERAL) return JavaTextContainer.TokenType.NUMBER; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.GLOBAL_FIELD) return JavaTextContainer.TokenType.GLOBAL_FIELD; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.LOCAL_FIELD) return JavaTextContainer.TokenType.LOCAL_FIELD; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.PARAMETER) return JavaTextContainer.TokenType.PARAMETER; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.UNDEFINED_VAR) return JavaTextContainer.TokenType.UNDEFINED_VAR; + if (type == noppes.npcs.client.gui.util.script.interpreter.token.TokenType.VARIABLE) return JavaTextContainer.TokenType.VARIABLE; + return JavaTextContainer.TokenType.DEFAULT; + } + + // ==================== ACCESSORS ==================== + + /** + * Get the underlying ScriptDocument for advanced operations. + */ + public ScriptDocument getDocument() { + return document; + } + + /** + * 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. + * + * @param globalPosition Position in the document text + * @return The Token at that position, or null + */ + public noppes.npcs.client.gui.util.script.interpreter.token.Token getInterpreterTokenAt(int globalPosition) { + if (!USE_NEW_INTERPRETER || document == null) { + return null; + } + + ScriptLine line = document.getLineAt(globalPosition); + if (line == null) { + return null; + } + + return line.getTokenAt(globalPosition); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/bridge/DtsJavaBridge.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/bridge/DtsJavaBridge.java new file mode 100644 index 000000000..c18f138b1 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/bridge/DtsJavaBridge.java @@ -0,0 +1,307 @@ +package noppes.npcs.client.gui.util.script.interpreter.bridge; + +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSFieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSMethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeRegistry; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeResolver; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; + +public final class DtsJavaBridge { + + /** Cache of reflection Method -> matching JS method info (for docs/param names). */ + private static final Map METHOD_CACHE = new ConcurrentHashMap<>(); + /** Cache of reflection Field -> matching JS field info (for docs/typing). */ + private static final Map FIELD_CACHE = new ConcurrentHashMap<>(); + /** Cache of reflection Method -> resolved Java TypeInfo override from .d.ts. */ + private static final Map RETURN_OVERRIDE_CACHE = new ConcurrentHashMap<>(); + /** Negative cache for methods with no usable override. */ + private static final Set RETURN_OVERRIDE_MISSES = ConcurrentHashMap.newKeySet(); + + private DtsJavaBridge() {} + + public static void clearCache() { + METHOD_CACHE.clear(); + FIELD_CACHE.clear(); + RETURN_OVERRIDE_CACHE.clear(); + RETURN_OVERRIDE_MISSES.clear(); + } + + /** + * Resolve a Java return type override for a reflected method using its .d.ts twin. + * + * The override is used only for editor typing (e.g., Janino hover/autocomplete) and + * never changes runtime reflection. This returns a Java-resolved TypeInfo when the + * .d.ts return type can be mapped to a concrete Java class. + */ + public static TypeInfo resolveReturnTypeOverride(Method method, TypeInfo containingType, JSMethodInfo jsMethod) { + if (method == null || jsMethod == null) return null; + + TypeInfo cached = RETURN_OVERRIDE_CACHE.get(method); + if (cached != null) return cached; + if (RETURN_OVERRIDE_MISSES.contains(method)) return null; + + String jsReturnType = jsMethod.getReturnType(); + if (jsReturnType == null || jsReturnType.isEmpty()) { + RETURN_OVERRIDE_MISSES.add(method); + return null; + } + + String normalizedJsReturn = jsReturnType; + if (normalizedJsReturn.contains("|")) { + normalizedJsReturn = normalizedJsReturn.split("\\|")[0].trim(); + } + normalizedJsReturn = normalizedJsReturn.replace("?", "").trim(); + + // Fast-path: skip resolver if the .d.ts return matches reflection (common case). + Class reflectedReturn = method.getReturnType(); + if (reflectedReturn != null) { + if (normalizedJsReturn.equals(reflectedReturn.getName()) + || normalizedJsReturn.equals(reflectedReturn.getSimpleName()) + || normalizedJsReturn.equals("Java." + reflectedReturn.getName())) { + RETURN_OVERRIDE_MISSES.add(method); + return null; + } + + String lower = normalizedJsReturn.toLowerCase(); + if (("void".equals(lower) && (reflectedReturn == void.class || reflectedReturn == Void.class)) + || ("boolean".equals(lower) && (reflectedReturn == boolean.class || reflectedReturn == Boolean.class)) + || ("string".equals(lower) && reflectedReturn == String.class) + || ("number".equals(lower) && (reflectedReturn == double.class || reflectedReturn == Double.class))) { + RETURN_OVERRIDE_MISSES.add(method); + return null; + } + } + + TypeResolver resolver = TypeResolver.getInstance(); + TypeInfo resolved = resolver.resolveJSType(normalizedJsReturn); + TypeInfo javaResolved = null; + + if (resolved != null) { + if (resolved.getJavaClass() != null) { + javaResolved = resolved; + } else if (resolved.isJSType() && resolved.getJSTypeInfo() != null) { + String javaFqn = resolved.getJSTypeInfo().getJavaFqn(); + if (javaFqn != null && !javaFqn.isEmpty()) { + javaResolved = resolver.resolveFullName(javaFqn); + } + } + } + + if (javaResolved == null || javaResolved.getJavaClass() == null) { + RETURN_OVERRIDE_MISSES.add(method); + return null; + } + + RETURN_OVERRIDE_CACHE.put(method, javaResolved); + return javaResolved; + } + + public static JSMethodInfo findMatchingMethod(Method method, TypeInfo containingType) { + JSMethodInfo cached = METHOD_CACHE.get(method); + if (cached != null) return cached; + + JSTypeInfo jsType = findJSTypeInfo(method, containingType); + if (jsType == null) return null; + + List overloads = jsType.getMethodOverloads(method.getName()); + if (overloads.isEmpty()) return null; + + Class[] paramTypes = method.getParameterTypes(); + JSMethodInfo best = null; + int bestScore = -1; + + for (JSMethodInfo candidate : overloads) { + if (candidate.getParameterCount() != paramTypes.length) continue; + int score = scoreOverload(candidate, paramTypes, containingType, method.isVarArgs()); + if (score > bestScore) { + bestScore = score; + best = candidate; + } + } + + if (bestScore >= 0 && best != null) { + METHOD_CACHE.put(method, best); + return best; + } + return null; + } + + public static JSFieldInfo findMatchingField(Field field, TypeInfo containingType) { + JSFieldInfo cached = FIELD_CACHE.get(field); + if (cached != null) return cached; + + JSTypeInfo jsType = findJSTypeInfo(field, containingType); + if (jsType == null) return null; + JSFieldInfo match = jsType.getField(field.getName()); + if (match != null) { + FIELD_CACHE.put(field, match); + } + return match; + } + + private static int scoreOverload(JSMethodInfo method, Class[] paramTypes, TypeInfo containingType, boolean isVarArgs) { + int score = 0; + List jsParams = method.getParameters(); + for (int i = 0; i < paramTypes.length; i++) { + int paramScore = scoreParam(paramTypes[i], jsParams.get(i), containingType, isVarArgs, i == paramTypes.length - 1); + if (paramScore < 0) return -1; + score += paramScore; + } + return score; + } + + private static int scoreParam(Class javaParam, JSMethodInfo.JSParameterInfo jsParam, TypeInfo containingType, boolean isVarArgs, boolean isLastParam) { + if (javaParam == null || jsParam == null) return -1; + + TypeInfo resolved = jsParam.getResolvedType(containingType); + if (resolved != null && resolved.getJavaClass() != null) { + Class jsClass = resolved.getJavaClass(); + if (javaParam.equals(jsClass)) return 4; + if (jsClass.isAssignableFrom(javaParam)) return 3; + if (javaParam.isAssignableFrom(jsClass)) return 2; + } + + String jsTypeName = jsParam.getType(); + if (jsTypeName == null || jsTypeName.isEmpty()) return -1; + + if (isVarArgs && isLastParam && javaParam.isArray()) { + if (matchesArrayElement(javaParam.getComponentType(), jsTypeName, containingType)) { + return 2; + } + } + + if (matchesPrimitive(jsTypeName, javaParam)) { + return 3; + } + + if (javaParam.isArray() && jsTypeName.endsWith("[]")) { + String elementType = jsTypeName.substring(0, jsTypeName.length() - 2); + return matchesArrayElement(javaParam.getComponentType(), elementType, containingType) ? 2 : -1; + } + + JSTypeInfo jsType = resolveJSTypeInfo(jsTypeName); + if (jsType != null && jsType.getJavaFqn() != null) { + String javaFqn = normalizeJavaFqn(jsType.getJavaFqn()); + String paramFqn = normalizeJavaFqn(javaParam.getName()); + if (javaFqn.equals(paramFqn)) return 3; + } + + if (jsTypeName.equals(javaParam.getSimpleName())) return 1; + if (jsTypeName.equals(javaParam.getName())) return 1; + if ("any".equals(jsTypeName)) return 1; + return -1; + } + + private static boolean matchesArrayElement(Class elementClass, String jsElementType, TypeInfo containingType) { + if (elementClass == null) return false; + if (matchesPrimitive(jsElementType, elementClass)) return true; + + JSTypeInfo jsType = resolveJSTypeInfo(jsElementType); + if (jsType != null && jsType.getJavaFqn() != null) { + String javaFqn = normalizeJavaFqn(jsType.getJavaFqn()); + String elementFqn = normalizeJavaFqn(elementClass.getName()); + return javaFqn.equals(elementFqn); + } + + return jsElementType.equals(elementClass.getSimpleName()) || jsElementType.equals(elementClass.getName()); + } + + private static boolean matchesPrimitive(String jsTypeName, Class javaParam) { + switch (jsTypeName.toLowerCase()) { + case "string": + case "char": + return javaParam == String.class || javaParam == char.class || javaParam == Character.class; + case "boolean": + case "bool": + return javaParam == boolean.class || javaParam == Boolean.class; + case "number": + case "byte": + case "short": + case "int": + case "integer": + case "long": + case "float": + case "double": + return isNumberType(javaParam); + case "void": + return javaParam == void.class || javaParam == Void.class; + default: + return false; + } + } + + private static boolean isNumberType(Class type) { + if (type == null) return false; + return type == byte.class || type == short.class || type == int.class || type == long.class + || type == float.class || type == double.class + || Number.class.isAssignableFrom(type); + } + + private static JSTypeInfo findJSTypeInfo(Method method, TypeInfo containingType) { + if (containingType != null && containingType.isJSType()) { + return containingType.getJSTypeInfo(); + } + + Class javaClass = containingType != null ? containingType.getJavaClass() : method.getDeclaringClass(); + return resolveJSTypeInfo(javaClass); + } + + private static JSTypeInfo findJSTypeInfo(Field field, TypeInfo containingType) { + if (containingType != null && containingType.isJSType()) { + return containingType.getJSTypeInfo(); + } + + Class javaClass = containingType != null ? containingType.getJavaClass() : field.getDeclaringClass(); + return resolveJSTypeInfo(javaClass); + } + + private static JSTypeInfo resolveJSTypeInfo(Class javaClass) { + if (javaClass == null) return null; + + JSTypeInfo direct = resolveJSTypeInfo(javaClass.getName()); + if (direct != null) return direct; + + for (Class iface : javaClass.getInterfaces()) { + JSTypeInfo ifaceType = resolveJSTypeInfo(iface.getName()); + if (ifaceType != null) return ifaceType; + } + + Class superClass = javaClass.getSuperclass(); + if (superClass != null && superClass != Object.class) { + return resolveJSTypeInfo(superClass); + } + + return null; + } + + private static JSTypeInfo resolveJSTypeInfo(String javaFqnOrType) { + if (javaFqnOrType == null || javaFqnOrType.isEmpty()) return null; + if (javaFqnOrType.startsWith("Java.")) { + javaFqnOrType = javaFqnOrType.substring(5); + } + JSTypeRegistry registry = TypeResolver.getInstance().getJSTypeRegistry(); + JSTypeInfo direct = registry.getTypeByJavaFqn(javaFqnOrType); + if (direct != null) return direct; + + String normalized = normalizeJavaFqn(javaFqnOrType); + if (!normalized.equals(javaFqnOrType)) { + JSTypeInfo normalizedType = registry.getTypeByJavaFqn(normalized); + if (normalizedType != null) return normalizedType; + } + + return registry.getType(javaFqnOrType); + } + + private static String normalizeJavaFqn(String javaFqn) { + if (javaFqn == null) return null; + return javaFqn.replace('$', '.'); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/CastExpressionResolver.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/CastExpressionResolver.java new file mode 100644 index 000000000..d2b37c64a --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/CastExpressionResolver.java @@ -0,0 +1,223 @@ +package noppes.npcs.client.gui.util.script.interpreter.expression; + +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import java.util.List; +import java.util.function.Function; + +/** + * Helper class for resolving cast expressions and distinguishing them from parenthesized expressions. + * Handles: + * - Simple casts: (Type) expr + * - Nested casts: ((Type) expr) + * - Cast chains: ((Type) expr).method() + * - Parenthesized expressions: (expr) + * + * @Deprecated ExpressionTypeResolver API has all this built in. + */ +@Deprecated +public class CastExpressionResolver { + + /** + * Resolve a cast or parenthesized expression. + * + * @param expr The expression starting with '(' + * @param position The position in the source text + * @param resolveType Function to resolve type names to TypeInfo + * @param resolveExpression Function to resolve arbitrary expressions + * @param parseChain Function to parse expression chain + * @param resolveChainSegment Function to resolve chain segments + * @return The resolved type + */ + public static TypeInfo resolveCastOrParenthesizedExpression( + String expr, + int position, + Function resolveType, + TypeResolver resolveExpression, + ChainParser parseChain, + ChainSegmentResolver resolveChainSegment) { + + if (!expr.startsWith("(")) return null; + + // Find the matching closing parenthesis for the first open paren + int depth = 0; + int closeParen = -1; + boolean inString = false; + char stringChar = 0; + + for (int i = 0; i < expr.length(); i++) { + char c = expr.charAt(i); + + // Handle string literals + if ((c == '"' || c == '\'') && (i == 0 || expr.charAt(i - 1) != '\\')) { + if (!inString) { + inString = true; + stringChar = c; + } else if (c == stringChar) { + inString = false; + } + continue; + } + if (inString) continue; + + if (c == '(') { + depth++; + } else if (c == ')') { + depth--; + if (depth == 0) { + closeParen = i; + break; + } + } + } + + if (closeParen < 0) return null; + + // Extract content inside parens + String insideParens = expr.substring(1, closeParen).trim(); + String afterParens = expr.substring(closeParen + 1).trim(); + + // Check if this is a cast expression + // A cast has a type name inside the parens (starts with uppercase or is primitive) + // and is followed by an expression (not an operator or nothing) + if (looksLikeCastType(insideParens) && looksLikeExpressionStart(afterParens)) { + // This is a cast: (Type) rest + TypeInfo castType = resolveType.apply(insideParens); + if (castType != null && castType.isResolved()) { + // If there's more after the cast target, resolve the chain + // E.g., ((EntityPlayer) entity).worldObj + if (!afterParens.isEmpty()) { + // Check if afterParens starts with '.' for a method/field chain + if (afterParens.startsWith(".")) { + // Continue resolving the chain from the cast type + String chainExpr = afterParens.substring(1).trim(); + List segments = parseChain.parse(chainExpr); + TypeInfo currentType = castType; + for (T segment : segments) { + currentType = resolveChainSegment.resolve(currentType, segment); + if (currentType == null) return null; + } + return currentType; + } + } + return castType; + } + } + + // Not a cast - treat as parenthesized expression + // Could be ((expr).method()) or just (expr) + + // First, resolve what's inside the parens + TypeInfo innerType = resolveExpression.resolve(insideParens, position); + + // If there's a chain after the parens, continue resolving + if (innerType != null && !afterParens.isEmpty() && afterParens.startsWith(".")) { + String chainExpr = afterParens.substring(1).trim(); + List segments = parseChain.parse(chainExpr); + TypeInfo currentType = innerType; + for (T segment : segments) { + currentType = resolveChainSegment.resolve(currentType, segment); + if (currentType == null) return null; + } + return currentType; + } + + return innerType; + } + + /** + * Check if a string looks like a valid type name for a cast. + * Valid: EntityPlayer, int, String, java.lang.String, int[] + */ + public static boolean looksLikeCastType(String s) { + if (s == null || s.isEmpty()) return false; + s = s.trim(); + + // Handle array types: Type[] or Type[][] + while (s.endsWith("[]")) { + s = s.substring(0, s.length() - 2).trim(); + } + + if (s.isEmpty()) return false; + + // Primitive types + switch (s) { + case "byte": case "short": case "int": case "long": + case "float": case "double": case "char": case "boolean": + return true; + } + + // Class type: starts with uppercase or is fully qualified + if (Character.isUpperCase(s.charAt(0))) return true; + + // Fully qualified name: contains dots and ends with uppercase segment + if (s.contains(".")) { + String[] parts = s.split("\\."); + String lastPart = parts[parts.length - 1]; + return !lastPart.isEmpty() && Character.isUpperCase(lastPart.charAt(0)); + } + + return false; + } + + /** + * Check if a string looks like the start of an expression (what follows a cast). + * Valid: identifier, (, new, literals, this, etc. + * Invalid: empty, operators like +, -, etc. + */ + public static boolean looksLikeExpressionStart(String s) { + if (s == null || s.isEmpty()) return false; + s = s.trim(); + if (s.isEmpty()) return false; + + char first = s.charAt(0); + + // Parenthesis (nested cast or parenthesized expr) + if (first == '(') return true; + + // Identifier or keyword + if (Character.isJavaIdentifierStart(first)) return true; + + // String or char literal + if (first == '"' || first == '\'') return true; + + // Number literal (could start with digit or dot for .5) + if (Character.isDigit(first)) return true; + if (first == '.' && s.length() > 1 && Character.isDigit(s.charAt(1))) return true; + + // Unary operators followed by expression + if (first == '!' || first == '~') return true; + if ((first == '+' || first == '-') && s.length() > 1) { + // Could be unary +/- or ++/-- + char second = s.charAt(1); + if (second == first || Character.isDigit(second) || Character.isJavaIdentifierStart(second) || second == '(') { + return true; + } + } + + return false; + } + + /** + * Functional interface for resolving type expressions. + */ + @FunctionalInterface + public interface TypeResolver { + TypeInfo resolve(String expr, int position); + } + + /** + * Functional interface for parsing expression chains. + */ + @FunctionalInterface + public interface ChainParser { + List parse(String expr); + } + + /** + * Functional interface for resolving chain segments. + */ + @FunctionalInterface + public interface ChainSegmentResolver { + TypeInfo resolve(TypeInfo currentType, T segment); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/ExpressionNode.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/ExpressionNode.java new file mode 100644 index 000000000..93e85156f --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/ExpressionNode.java @@ -0,0 +1,403 @@ +package noppes.npcs.client.gui.util.script.interpreter.expression; + +import noppes.npcs.client.gui.util.script.interpreter.InnerCallableScope; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public abstract class ExpressionNode { + protected final int start; + protected final int end; + + protected ExpressionNode(int start, int end) { + this.start = start; + this.end = end; + } + + public int getStart() { return start; } + public int getEnd() { return end; } + public abstract TypeInfo resolveType(TypeResolverContext resolver); + + public static class IntLiteralNode extends ExpressionNode { + private final String value; + public IntLiteralNode(String value, int start, int end) { super(start, end); this.value = value; } + public String getValue() { return value; } + public TypeInfo resolveType(TypeResolverContext resolver) { return TypeInfo.fromPrimitive("int"); } + } + + public static class LongLiteralNode extends ExpressionNode { + public LongLiteralNode(String value, int start, int end) { super(start, end); } + public TypeInfo resolveType(TypeResolverContext resolver) { return TypeInfo.fromPrimitive("long"); } + } + + public static class FloatLiteralNode extends ExpressionNode { + public FloatLiteralNode(String value, int start, int end) { super(start, end); } + public TypeInfo resolveType(TypeResolverContext resolver) { return TypeInfo.fromPrimitive("float"); } + } + + public static class DoubleLiteralNode extends ExpressionNode { + public DoubleLiteralNode(String value, int start, int end) { super(start, end); } + public TypeInfo resolveType(TypeResolverContext resolver) { return TypeInfo.fromPrimitive("double"); } + } + + public static class BooleanLiteralNode extends ExpressionNode { + public BooleanLiteralNode(boolean value, int start, int end) { super(start, end); } + public TypeInfo resolveType(TypeResolverContext resolver) { return TypeInfo.fromPrimitive("boolean"); } + } + + public static class CharLiteralNode extends ExpressionNode { + public CharLiteralNode(String value, int start, int end) { super(start, end); } + public TypeInfo resolveType(TypeResolverContext resolver) { return TypeInfo.fromPrimitive("char"); } + } + + public static class StringLiteralNode extends ExpressionNode { + private final String value; + public StringLiteralNode(String value, int start, int end) { super(start, end); this.value = value; } + public String getValue() { return value; } + public TypeInfo resolveType(TypeResolverContext resolver) { return TypeInfo.string(); } + } + + public static class NullLiteralNode extends ExpressionNode { + public NullLiteralNode(int start, int end) { super(start, end); } + public TypeInfo resolveType(TypeResolverContext resolver) { + return TypeInfo.unresolved("null", ""); + } + } + + public static class IdentifierNode extends ExpressionNode { + private final String name; + public IdentifierNode(String name, int start, int end) { super(start, end); this.name = name; } + public String getName() { return name; } + public TypeInfo resolveType(TypeResolverContext resolver) { return resolver.resolveIdentifier(name); } + } + + public static class MemberAccessNode extends ExpressionNode { + private final ExpressionNode target; + private final String memberName; + public MemberAccessNode(ExpressionNode target, String memberName, int start, int end) { + super(start, end); this.target = target; this.memberName = memberName; + } + public ExpressionNode getTarget() { return target; } + public String getMemberName() { return memberName; } + public TypeInfo resolveType(TypeResolverContext resolver) { + TypeInfo targetType = target.resolveType(resolver); + if (targetType == null || !targetType.isResolved()) return null; + return resolver.resolveMemberAccess(targetType, memberName); + } + } + + public static class MethodCallNode extends ExpressionNode { + private final ExpressionNode target; + private final String methodName; + private final List arguments; + public MethodCallNode(ExpressionNode target, String methodName, List arguments, int start, int end) { + super(start, end); this.target = target; this.methodName = methodName; + this.arguments = arguments != null ? new ArrayList<>(arguments) : new ArrayList<>(); + } + public ExpressionNode getTarget() { return target; } + public String getMethodName() { return methodName; } + public List getArguments() { return Collections.unmodifiableList(arguments); } + public TypeInfo resolveType(TypeResolverContext resolver) { + TypeInfo targetType = target != null ? target.resolveType(resolver) : null; + TypeInfo[] argTypes = new TypeInfo[arguments.size()]; + for (int i = 0; i < arguments.size(); i++) argTypes[i] = arguments.get(i).resolveType(resolver); + return resolver.resolveMethodCall(targetType, methodName, argTypes); + } + } + + public static class ArrayAccessNode extends ExpressionNode { + private final ExpressionNode array; + private final ExpressionNode index; + public ArrayAccessNode(ExpressionNode array, ExpressionNode index, int start, int end) { + super(start, end); this.array = array; this.index = index; + } + public ExpressionNode getArray() { return array; } + public ExpressionNode getIndex() { return index; } + public TypeInfo resolveType(TypeResolverContext resolver) { + TypeInfo arrayType = array.resolveType(resolver); + if (arrayType == null || !arrayType.isResolved()) return null; + return resolver.resolveArrayAccess(arrayType); + } + } + + public static class NewNode extends ExpressionNode { + private final String typeName; + private final List arguments; + public NewNode(String typeName, List arguments, int start, int end) { + super(start, end); this.typeName = typeName; + this.arguments = arguments != null ? new ArrayList<>(arguments) : new ArrayList<>(); + } + public String getTypeName() { return typeName; } + public List getArguments() { return Collections.unmodifiableList(arguments); } + public TypeInfo resolveType(TypeResolverContext resolver) { return resolver.resolveTypeName(typeName); } + } + + public static class BinaryOpNode extends ExpressionNode { + private final ExpressionNode left; + private final OperatorType operator; + private final ExpressionNode right; + public BinaryOpNode(ExpressionNode left, OperatorType operator, ExpressionNode right, int start, int end) { + super(start, end); this.left = left; this.operator = operator; this.right = right; + } + public ExpressionNode getLeft() { return left; } + public OperatorType getOperator() { return operator; } + public ExpressionNode getRight() { return right; } + public TypeInfo resolveType(TypeResolverContext resolver) { + TypeInfo leftType = left.resolveType(resolver); + TypeInfo rightType = right.resolveType(resolver); + return TypeRules.resolveBinaryOperatorType(operator, leftType, rightType); + } + } + + public static class UnaryOpNode extends ExpressionNode { + private final OperatorType operator; + private final ExpressionNode operand; + private final boolean prefix; + public UnaryOpNode(OperatorType operator, ExpressionNode operand, boolean prefix, int start, int end) { + super(start, end); this.operator = operator; this.operand = operand; this.prefix = prefix; + } + public OperatorType getOperator() { return operator; } + public ExpressionNode getOperand() { return operand; } + public boolean isPrefix() { return prefix; } + public TypeInfo resolveType(TypeResolverContext resolver) { + TypeInfo operandType = operand.resolveType(resolver); + return TypeRules.resolveUnaryOperatorType(operator, operandType); + } + } + + public static class TernaryNode extends ExpressionNode { + private final ExpressionNode condition; + private final ExpressionNode thenExpr; + private final ExpressionNode elseExpr; + public TernaryNode(ExpressionNode condition, ExpressionNode thenExpr, ExpressionNode elseExpr, int start, int end) { + super(start, end); this.condition = condition; this.thenExpr = thenExpr; this.elseExpr = elseExpr; + } + public ExpressionNode getCondition() { return condition; } + public ExpressionNode getThenExpr() { return thenExpr; } + public ExpressionNode getElseExpr() { return elseExpr; } + public TypeInfo resolveType(TypeResolverContext resolver) { + TypeInfo thenType = thenExpr.resolveType(resolver); + TypeInfo elseType = elseExpr.resolveType(resolver); + return TypeRules.resolveTernaryType(thenType, elseType); + } + } + + public static class InstanceofNode extends ExpressionNode { + private final ExpressionNode expression; + private final String typeName; + public InstanceofNode(ExpressionNode expression, String typeName, int start, int end) { + super(start, end); this.expression = expression; this.typeName = typeName; + } + public ExpressionNode getExpression() { return expression; } + public String getTypeName() { return typeName; } + public TypeInfo resolveType(TypeResolverContext resolver) { return TypeInfo.fromPrimitive("boolean"); } + } + + public static class CastNode extends ExpressionNode { + private final String typeName; + private final ExpressionNode expression; + public CastNode(String typeName, ExpressionNode expression, int start, int end) { + super(start, end); this.typeName = typeName; this.expression = expression; + } + public String getTypeName() { return typeName; } + public ExpressionNode getExpression() { return expression; } + public TypeInfo resolveType(TypeResolverContext resolver) { return resolver.resolveTypeName(typeName); } + } + + public static class AssignmentNode extends ExpressionNode { + private final ExpressionNode target; + private final OperatorType operator; + private final ExpressionNode value; + public AssignmentNode(ExpressionNode target, OperatorType operator, ExpressionNode value, int start, int end) { + super(start, end); this.target = target; this.operator = operator; this.value = value; + } + public ExpressionNode getTarget() { return target; } + public OperatorType getOperator() { return operator; } + public ExpressionNode getValue() { return value; } + public TypeInfo resolveType(TypeResolverContext resolver) { return target.resolveType(resolver); } + } + + public static class ParenthesizedNode extends ExpressionNode { + private final ExpressionNode inner; + public ParenthesizedNode(ExpressionNode inner, int start, int end) { super(start, end); this.inner = inner; } + public ExpressionNode getInner() { return inner; } + public TypeInfo resolveType(TypeResolverContext resolver) { return inner.resolveType(resolver); } + } + + public static class LambdaNode extends ExpressionNode { + private final List parameterNames; + private final ExpressionNode body; + private final boolean isBlock; + private noppes.npcs.client.gui.util.script.interpreter.InnerCallableScope scopeRef; + + public LambdaNode(List parameterNames, ExpressionNode body, boolean isBlock, int start, int end) { + super(start, end); + this.parameterNames = parameterNames != null ? new ArrayList<>(parameterNames) : new ArrayList<>(); + this.body = body; + this.isBlock = isBlock; + this.scopeRef = null; + } + + public List getParameterNames() { return Collections.unmodifiableList(parameterNames); } + public ExpressionNode getBody() { return body; } + public boolean isBlock() { return isBlock; } + public noppes.npcs.client.gui.util.script.interpreter.InnerCallableScope getScopeRef() { return scopeRef; } + public void setScopeRef(noppes.npcs.client.gui.util.script.interpreter.InnerCallableScope scope) { + this.scopeRef = scope; + } + + @Override + public TypeInfo resolveType(TypeResolverContext resolver) { + // Lambda type is determined by the expected functional interface type + // See ExpressionTypeResolver.resolveLambdaType() + return TypeInfo.fromClass(Object.class); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + if (parameterNames.size() == 1 && !isBlock) { + sb.append(parameterNames.get(0)); + } else { + sb.append("("); + sb.append(String.join(", ", parameterNames)); + sb.append(")"); + } + sb.append(" -> "); + if (isBlock) { + sb.append("{ ... }"); + } else { + sb.append(body); + } + return sb.toString(); + } + } + + public static class JSFunctionNode extends ExpressionNode { + private final String name; // Optional name for named function expressions + private final List parameterNames; + private final String bodyText; // Raw body text (for block functions) + private noppes.npcs.client.gui.util.script.interpreter.InnerCallableScope scopeRef; + + public JSFunctionNode(String name, List parameterNames, String bodyText, int start, int end) { + super(start, end); + this.name = name; + this.parameterNames = parameterNames != null ? new ArrayList<>(parameterNames) : new ArrayList<>(); + this.bodyText = bodyText; + this.scopeRef = null; + } + + public String getName() { return name; } + public List getParameterNames() { return Collections.unmodifiableList(parameterNames); } + public String getBodyText() { return bodyText; } + public noppes.npcs.client.gui.util.script.interpreter.InnerCallableScope getScopeRef() { return scopeRef; } + public void setScopeRef(noppes.npcs.client.gui.util.script.interpreter.InnerCallableScope scope) { + this.scopeRef = scope; + } + + @Override + public TypeInfo resolveType(TypeResolverContext resolver) { + // JS function type is determined by the expected functional interface type + // See ExpressionTypeResolver.resolveJSFunctionType() + return TypeInfo.fromClass(Object.class); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("function"); + if (name != null && !name.isEmpty()) { + sb.append(" ").append(name); + } + sb.append("("); + sb.append(String.join(", ", parameterNames)); + sb.append(") { "); + if (bodyText.length() > 30) { + sb.append(bodyText.substring(0, 30)).append("..."); + } else { + sb.append(bodyText); + } + sb.append(" }"); + return sb.toString(); + } + } + + public static class JSArrowNode extends ExpressionNode { + private final List parameterNames; + private final ExpressionNode body; + private final boolean isBlock; + private InnerCallableScope scopeRef; + + public JSArrowNode(List parameterNames, ExpressionNode body, boolean isBlock, int start, int end) { + super(start, end); + this.parameterNames = parameterNames != null ? new ArrayList<>(parameterNames) : new ArrayList<>(); + this.body = body; + this.isBlock = isBlock; + } + + public List getParameterNames() { return Collections.unmodifiableList(parameterNames); } + public ExpressionNode getBody() { return body; } + public boolean isBlock() { return isBlock; } + public InnerCallableScope getScopeRef() { return scopeRef; } + public void setScopeRef(InnerCallableScope scope) { + this.scopeRef = scope; + } + + @Override + public TypeInfo resolveType(TypeResolverContext resolver) { + return TypeInfo.fromClass(Object.class); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("("); + sb.append(String.join(", ", parameterNames)); + sb.append(") => "); + if (isBlock) { + sb.append("{ ... }"); + } else if (body != null) { + sb.append(body); + } + return sb.toString(); + } + } + + public static class MethodReferenceNode extends ExpressionNode { + private final ExpressionNode target; // Object or class name + private final String methodName; + private final boolean isStatic; // Whether it's Class::method vs obj::method + + public MethodReferenceNode(ExpressionNode target, String methodName, boolean isStatic, int start, int end) { + super(start, end); + this.target = target; + this.methodName = methodName; + this.isStatic = isStatic; + } + + public ExpressionNode getTarget() { return target; } + public String getMethodName() { return methodName; } + public boolean isStatic() { return isStatic; } + + @Override + public TypeInfo resolveType(TypeResolverContext resolver) { + // Method reference type is determined by the expected functional interface type + // See ExpressionTypeResolver.resolveMethodReferenceType() + return TypeInfo.fromClass(Object.class); + } + + @Override + public String toString() { + return target + "::" + methodName; + } + } + + public interface TypeResolverContext { + TypeInfo resolveIdentifier(String name); + TypeInfo resolveMemberAccess(TypeInfo targetType, String memberName); + TypeInfo resolveMethodCall(TypeInfo targetType, String methodName, TypeInfo[] argTypes); + TypeInfo resolveArrayAccess(TypeInfo arrayType); + TypeInfo resolveTypeName(String typeName); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/ExpressionParser.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/ExpressionParser.java new file mode 100644 index 000000000..204fe80c2 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/ExpressionParser.java @@ -0,0 +1,559 @@ +package noppes.npcs.client.gui.util.script.interpreter.expression; + +import java.util.ArrayList; +import java.util.List; + +public class ExpressionParser { + private final List tokens; + private int pos; + + public ExpressionParser(List tokens) { + this.tokens = tokens; + this.pos = 0; + } + + public ExpressionNode parse() { + if (tokens.isEmpty()) return null; + return parseLambdaOrExpression(); + } + + private ExpressionNode parseLambdaOrExpression() { + // Check if this is a lambda: (params) -> or param -> + // Look ahead to see if there's a -> after the next identifier/parens + + int checkpoint = pos; + List paramNames = null; + int lambdaStart = current().getStart(); + boolean isJSArrow = false; + + // Try to parse parameter list + if (check(ExpressionToken.TokenKind.IDENTIFIER)) { + // Single param without parens + String paramName = current().getText(); + advance(); + if (check(ExpressionToken.TokenKind.LAMBDA_ARROW)) { + paramNames = new ArrayList<>(); + paramNames.add(paramName); + } else if (check(ExpressionToken.TokenKind.JS_ARROW)) { + paramNames = new ArrayList<>(); + paramNames.add(paramName); + isJSArrow = true; + } else { + // Not a lambda, rewind + pos = checkpoint; + } + } else if (check(ExpressionToken.TokenKind.LEFT_PAREN)) { + // Parenthesized params: (a, b) or () + advance(); // consume '(' + paramNames = new ArrayList<>(); + + if (!check(ExpressionToken.TokenKind.RIGHT_PAREN)) { + // Parse param list + while (true) { + if (!check(ExpressionToken.TokenKind.IDENTIFIER)) { + // Not a valid lambda param list, rewind + pos = checkpoint; + paramNames = null; + break; + } + paramNames.add(current().getText()); + advance(); + + if (check(ExpressionToken.TokenKind.COMMA)) { + advance(); + } else if (check(ExpressionToken.TokenKind.RIGHT_PAREN)) { + break; + } else { + // Invalid syntax, rewind + pos = checkpoint; + paramNames = null; + break; + } + } + } + + if (paramNames != null) { + if (check(ExpressionToken.TokenKind.RIGHT_PAREN)) { + advance(); // consume ')' + if (check(ExpressionToken.TokenKind.LAMBDA_ARROW)) { + // Valid lambda! + } else if (check(ExpressionToken.TokenKind.JS_ARROW)) { + isJSArrow = true; + } else { + // Not a lambda, rewind + pos = checkpoint; + paramNames = null; + } + } else { + // No closing paren, rewind + pos = checkpoint; + paramNames = null; + } + } + } + + if (paramNames != null) { + // This is a lambda! Parse it + advance(); // consume '->' or '=>' + + // Parse body + ExpressionNode body; + boolean isBlock = false; + int bodyEnd; + + if (check(ExpressionToken.TokenKind.LEFT_BRACE)) { + // Block lambda: { ... } + isBlock = true; + int braceStart = current().getStart(); + advance(); // consume '{' + // Skip to matching '}' + int depth = 1; + while (depth > 0 && pos < tokens.size() && !check(ExpressionToken.TokenKind.EOF)) { + if (check(ExpressionToken.TokenKind.LEFT_BRACE)) depth++; + else if (check(ExpressionToken.TokenKind.RIGHT_BRACE)) depth--; + if (depth > 0) advance(); + } + bodyEnd = current().getEnd(); + if (check(ExpressionToken.TokenKind.RIGHT_BRACE)) { + advance(); // consume '}' + } + body = new ExpressionNode.StringLiteralNode("", braceStart, bodyEnd); // Placeholder + } else { + // Expression lambda + body = parseExpressionInternal(0); + if (body == null) { + // Failed to parse body, return error recovery + return null; + } + bodyEnd = body.getEnd(); + } + + // Create lambda node (scopeRef will be set during type resolution) + if (isJSArrow) + return new ExpressionNode.JSArrowNode(paramNames, body, isBlock, lambdaStart, bodyEnd); + return new ExpressionNode.LambdaNode(paramNames, body, isBlock, lambdaStart, bodyEnd); + } + + // Not a lambda, parse as regular expression + return parseExpressionInternal(0); + } + + private ExpressionToken current() { + if (pos >= tokens.size()) return tokens.get(tokens.size() - 1); + return tokens.get(pos); + } + + private ExpressionToken advance() { + ExpressionToken tok = current(); + if (pos < tokens.size()) pos++; + return tok; + } + + private boolean check(ExpressionToken.TokenKind kind) { return current().getKind() == kind; } + + private boolean match(ExpressionToken.TokenKind kind) { + if (check(kind)) { advance(); return true; } + return false; + } + + private ExpressionNode parseExpression(int minPrecedence) { + // For top-level expressions (minPrecedence = 0), check for lambda first + if (minPrecedence == 0) { + return parseLambdaOrExpression(); + } + + return parseExpressionInternal(minPrecedence); + } + + private ExpressionNode parseExpressionInternal(int minPrecedence) { + ExpressionNode left = parsePrefixExpression(); + if (left == null) return null; + + while (true) { + if (check(ExpressionToken.TokenKind.QUESTION) && minPrecedence <= 2) { + left = parseTernary(left); + continue; + } + + OperatorType op = getCurrentBinaryOperator(); + if (op == null) break; + + int precedence = op.getPrecedence(); + if (precedence < minPrecedence) break; + + advance(); + + int nextMinPrecedence = (op.getAssociativity() == OperatorType.Associativity.LEFT) + ? precedence + 1 : precedence; + + ExpressionNode right = parseExpression(nextMinPrecedence); + if (right == null) break; + + if (op == OperatorType.INSTANCEOF) { + String typeName = extractTypeName(right); + left = new ExpressionNode.InstanceofNode(left, typeName, left.getStart(), right.getEnd()); + } else if (op.isAssignment()) { + left = new ExpressionNode.AssignmentNode(left, op, right, left.getStart(), right.getEnd()); + } else { + left = new ExpressionNode.BinaryOpNode(left, op, right, left.getStart(), right.getEnd()); + } + } + + return parsePostfixExpression(left); + } + + private String extractTypeName(ExpressionNode node) { + if (node instanceof ExpressionNode.IdentifierNode) { + return ((ExpressionNode.IdentifierNode) node).getName(); + } + if (node instanceof ExpressionNode.MemberAccessNode) { + ExpressionNode.MemberAccessNode ma = (ExpressionNode.MemberAccessNode) node; + return extractTypeName(ma.getTarget()) + "." + ma.getMemberName(); + } + return "Object"; + } + + private ExpressionNode parseTernary(ExpressionNode condition) { + int start = condition.getStart(); + advance(); + ExpressionNode thenExpr = parseExpression(0); + if (thenExpr == null) return condition; + if (!match(ExpressionToken.TokenKind.COLON)) return condition; + ExpressionNode elseExpr = parseExpression(2); + if (elseExpr == null) return condition; + return new ExpressionNode.TernaryNode(condition, thenExpr, elseExpr, start, elseExpr.getEnd()); + } + + private OperatorType getCurrentBinaryOperator() { + ExpressionToken tok = current(); + if (tok.getKind() == ExpressionToken.TokenKind.OPERATOR) { + OperatorType op = tok.getOperatorType(); + if (op != null && (op.isBinary() || op.isAssignment())) return op; + } + if (tok.getKind() == ExpressionToken.TokenKind.INSTANCEOF) return OperatorType.INSTANCEOF; + return null; + } + + private ExpressionNode parsePrefixExpression() { + ExpressionToken tok = current(); + int start = tok.getStart(); + + // Check for function expression (JS only) + if (tok.getKind() == ExpressionToken.TokenKind.FUNCTION) { + return parseFunctionExpression(); + } + + if (tok.getKind() == ExpressionToken.TokenKind.OPERATOR) { + OperatorType op = tok.getOperatorType(); + if (op != null && isUnaryOperator(op)) { + advance(); + ExpressionNode operand = parsePrefixExpression(); + if (operand == null) return null; + OperatorType unaryOp = toUnaryOperator(op); + return new ExpressionNode.UnaryOpNode(unaryOp, operand, true, start, operand.getEnd()); + } + } + + if (tok.getKind() == ExpressionToken.TokenKind.LEFT_PAREN) { + return parseCastOrParenthesized(); + } + + return parsePrimaryExpression(); + } + + private ExpressionNode parseFunctionExpression() { + int start = current().getStart(); + advance(); // consume 'function' + + // Optional function name + String functionName = null; + if (check(ExpressionToken.TokenKind.IDENTIFIER)) { + functionName = current().getText(); + advance(); + } + + // Expect '(' + if (!check(ExpressionToken.TokenKind.LEFT_PAREN)) { + return null; // Invalid syntax + } + advance(); // consume '(' + + // Parse parameters + List params = new ArrayList<>(); + while (!check(ExpressionToken.TokenKind.RIGHT_PAREN) && !check(ExpressionToken.TokenKind.EOF)) { + if (!check(ExpressionToken.TokenKind.IDENTIFIER)) { + return null; // Invalid parameter + } + params.add(current().getText()); + advance(); + + if (check(ExpressionToken.TokenKind.COMMA)) { + advance(); + } else if (!check(ExpressionToken.TokenKind.RIGHT_PAREN)) { + return null; // Expected comma or closing paren + } + } + + if (!check(ExpressionToken.TokenKind.RIGHT_PAREN)) { + return null; // Expected closing paren + } + advance(); // consume ')' + + // Expect '{' + if (!check(ExpressionToken.TokenKind.LEFT_BRACE)) { + return null; // Invalid syntax + } + advance(); // consume '{' + + // Collect body tokens until matching '}' + StringBuilder bodyBuilder = new StringBuilder(); + int depth = 1; + while (depth > 0 && !check(ExpressionToken.TokenKind.EOF)) { + ExpressionToken bodyToken = current(); + if (bodyToken.getKind() == ExpressionToken.TokenKind.LEFT_BRACE) { + depth++; + } else if (bodyToken.getKind() == ExpressionToken.TokenKind.RIGHT_BRACE) { + depth--; + if (depth == 0) { + break; + } + } + bodyBuilder.append(bodyToken.getText()).append(" "); + advance(); + } + + String bodyText = bodyBuilder.toString().trim(); + int end = current().getEnd(); + + if (!check(ExpressionToken.TokenKind.RIGHT_BRACE)) { + return null; // Expected closing brace + } + advance(); // consume final '}' + + // Find the corresponding InnerCallableScope from ScriptDocument + // This will be set during type resolution when we have access to ScriptDocument + return new ExpressionNode.JSFunctionNode(functionName, params, bodyText, start, end); + } + + private boolean isUnaryOperator(OperatorType op) { + switch (op) { + case ADD: case SUBTRACT: case LOGICAL_NOT: case BITWISE_NOT: + case PRE_INCREMENT: case PRE_DECREMENT: return true; + default: return false; + } + } + + private OperatorType toUnaryOperator(OperatorType op) { + switch (op) { + case ADD: return OperatorType.UNARY_PLUS; + case SUBTRACT: return OperatorType.UNARY_MINUS; + default: return op; + } + } + + private ExpressionNode parseCastOrParenthesized() { + int start = current().getStart(); + advance(); + + if (check(ExpressionToken.TokenKind.IDENTIFIER)) { + String possibleType = current().getText(); + int savedPos = pos; + advance(); + + while (check(ExpressionToken.TokenKind.DOT)) { + advance(); + if (check(ExpressionToken.TokenKind.IDENTIFIER)) { + possibleType += "." + current().getText(); + advance(); + } + } + + while (check(ExpressionToken.TokenKind.LEFT_BRACKET)) { + advance(); + if (!match(ExpressionToken.TokenKind.RIGHT_BRACKET)) { pos = savedPos; break; } + possibleType += "[]"; + } + + if (check(ExpressionToken.TokenKind.RIGHT_PAREN)) { + advance(); + if (canStartExpression()) { + ExpressionNode expr = parsePrefixExpression(); + if (expr != null) { + return new ExpressionNode.CastNode(possibleType, expr, start, expr.getEnd()); + } + } + } + pos = savedPos; + } + + ExpressionNode inner = parseExpression(0); + if (inner != null && match(ExpressionToken.TokenKind.RIGHT_PAREN)) { + ExpressionNode paren = new ExpressionNode.ParenthesizedNode(inner, start, current().getStart()); + return parseAccessChain(paren); + } + return inner; + } + + private boolean canStartExpression() { + ExpressionToken.TokenKind kind = current().getKind(); + switch (kind) { + case IDENTIFIER: case INT_LITERAL: case LONG_LITERAL: case FLOAT_LITERAL: + case DOUBLE_LITERAL: case BOOLEAN_LITERAL: case CHAR_LITERAL: case STRING_LITERAL: + case NULL_LITERAL: case NEW: case LEFT_PAREN: case OPERATOR: return true; + default: return false; + } + } + + private ExpressionNode parsePrimaryExpression() { + ExpressionToken tok = current(); + int start = tok.getStart(); + + switch (tok.getKind()) { + case INT_LITERAL: advance(); return new ExpressionNode.IntLiteralNode(tok.getText(), start, tok.getEnd()); + case LONG_LITERAL: advance(); return new ExpressionNode.LongLiteralNode(tok.getText(), start, tok.getEnd()); + case FLOAT_LITERAL: advance(); return new ExpressionNode.FloatLiteralNode(tok.getText(), start, tok.getEnd()); + case DOUBLE_LITERAL: advance(); return new ExpressionNode.DoubleLiteralNode(tok.getText(), start, tok.getEnd()); + case BOOLEAN_LITERAL: advance(); return new ExpressionNode.BooleanLiteralNode("true".equals(tok.getText()), start, tok.getEnd()); + case CHAR_LITERAL: advance(); return new ExpressionNode.CharLiteralNode(tok.getText(), start, tok.getEnd()); + case STRING_LITERAL: advance(); return new ExpressionNode.StringLiteralNode(tok.getText(), start, tok.getEnd()); + case NULL_LITERAL: advance(); return new ExpressionNode.NullLiteralNode(start, tok.getEnd()); + case NEW: return parseNewExpression(); + case IDENTIFIER: return parseIdentifierOrMethodCall(); + case LEFT_PAREN: return parseCastOrParenthesized(); + default: return null; + } + } + + private ExpressionNode parseNewExpression() { + int start = current().getStart(); + advance(); + if (!check(ExpressionToken.TokenKind.IDENTIFIER)) return null; + + StringBuilder typeName = new StringBuilder(current().getText()); + advance(); + + while (check(ExpressionToken.TokenKind.DOT)) { + advance(); + if (check(ExpressionToken.TokenKind.IDENTIFIER)) { + typeName.append(".").append(current().getText()); + advance(); + } + } + + List args = new ArrayList<>(); + if (match(ExpressionToken.TokenKind.LEFT_PAREN)) { + args = parseArgumentList(); + match(ExpressionToken.TokenKind.RIGHT_PAREN); + } + + return new ExpressionNode.NewNode(typeName.toString(), args, start, current().getStart()); + } + + private ExpressionNode parseIdentifierOrMethodCall() { + int start = current().getStart(); + String name = current().getText(); + advance(); + + ExpressionNode result = new ExpressionNode.IdentifierNode(name, start, current().getStart()); + return parseAccessChain(result); + } + + private ExpressionNode parseAccessChain(ExpressionNode base) { + while (true) { + if (check(ExpressionToken.TokenKind.METHOD_REFERENCE)) { + advance(); // consume '::' + + if (!check(ExpressionToken.TokenKind.IDENTIFIER)) { + // Invalid syntax, return what we have + break; + } + + String methodName = current().getText(); + int end = current().getEnd(); + advance(); + + // isStatic is determined during type resolution, not parsing + // We pass false as a placeholder - ExpressionTypeResolver will compute + // the real value based on whether target resolves to a ClassTypeInfo + base = new ExpressionNode.MethodReferenceNode(base, methodName, false, base.getStart(), end); + // Method references don't chain further (can't do obj::method.something) + break; + } else if (check(ExpressionToken.TokenKind.LEFT_PAREN)) { + advance(); + List args = parseArgumentList(); + int end = current().getStart(); + match(ExpressionToken.TokenKind.RIGHT_PAREN); + + String methodName; + ExpressionNode target; + + if (base instanceof ExpressionNode.IdentifierNode) { + methodName = ((ExpressionNode.IdentifierNode) base).getName(); + target = null; + } else if (base instanceof ExpressionNode.MemberAccessNode) { + ExpressionNode.MemberAccessNode ma = (ExpressionNode.MemberAccessNode) base; + methodName = ma.getMemberName(); + target = ma.getTarget(); + } else { + methodName = "apply"; + target = base; + } + + base = new ExpressionNode.MethodCallNode(target, methodName, args, base.getStart(), end); + } else if (check(ExpressionToken.TokenKind.DOT)) { + advance(); + if (!check(ExpressionToken.TokenKind.IDENTIFIER)) break; + String memberName = current().getText(); + int end = current().getEnd(); + advance(); + base = new ExpressionNode.MemberAccessNode(base, memberName, base.getStart(), end); + } else if (check(ExpressionToken.TokenKind.LEFT_BRACKET)) { + advance(); + ExpressionNode index = parseExpression(0); + int end = current().getStart(); + match(ExpressionToken.TokenKind.RIGHT_BRACKET); + if (index != null) { + base = new ExpressionNode.ArrayAccessNode(base, index, base.getStart(), end); + } + } else { + break; + } + } + return base; + } + + private List parseArgumentList() { + List args = new ArrayList<>(); + if (check(ExpressionToken.TokenKind.RIGHT_PAREN)) return args; + + ExpressionNode first = parseExpression(0); + if (first != null) args.add(first); + + while (match(ExpressionToken.TokenKind.COMMA)) { + ExpressionNode arg = parseExpression(0); + if (arg != null) args.add(arg); + } + return args; + } + + private ExpressionNode parsePostfixExpression(ExpressionNode expr) { + if (expr == null) return null; + + while (true) { + ExpressionToken tok = current(); + if (tok.getKind() != ExpressionToken.TokenKind.OPERATOR) break; + + OperatorType op = tok.getOperatorType(); + if (op == OperatorType.PRE_INCREMENT) { + advance(); + expr = new ExpressionNode.UnaryOpNode(OperatorType.POST_INCREMENT, expr, false, expr.getStart(), tok.getEnd()); + } else if (op == OperatorType.PRE_DECREMENT) { + advance(); + expr = new ExpressionNode.UnaryOpNode(OperatorType.POST_DECREMENT, expr, false, expr.getStart(), tok.getEnd()); + } else { + break; + } + } + return expr; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/ExpressionToken.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/ExpressionToken.java new file mode 100644 index 000000000..2d482ed2a --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/ExpressionToken.java @@ -0,0 +1,65 @@ +package noppes.npcs.client.gui.util.script.interpreter.expression; + +public class ExpressionToken { + + public enum TokenKind { + INT_LITERAL, LONG_LITERAL, FLOAT_LITERAL, DOUBLE_LITERAL, + BOOLEAN_LITERAL, CHAR_LITERAL, STRING_LITERAL, NULL_LITERAL, + IDENTIFIER, NEW, INSTANCEOF, FUNCTION, + OPERATOR, + LEFT_PAREN, RIGHT_PAREN, LEFT_BRACKET, RIGHT_BRACKET, + LEFT_BRACE, RIGHT_BRACE, + DOT, COMMA, QUESTION, COLON, SEMICOLON, + LAMBDA_ARROW, JS_ARROW, METHOD_REFERENCE, + EOF + } + + private final TokenKind kind; + private final String text; + private final int start; + private final int end; + private final OperatorType operatorType; + + public ExpressionToken(TokenKind kind, String text, int start, int end) { + this(kind, text, start, end, null); + } + + public ExpressionToken(TokenKind kind, String text, int start, int end, OperatorType operatorType) { + this.kind = kind; + this.text = text; + this.start = start; + this.end = end; + this.operatorType = operatorType; + } + + public TokenKind getKind() { return kind; } + public String getText() { return text; } + public int getStart() { return start; } + public int getEnd() { return end; } + public OperatorType getOperatorType() { return operatorType; } + + public static ExpressionToken operator(String symbol, int start, int end) { + OperatorType op = OperatorType.fromBinarySymbol(symbol); + if (op == null) op = OperatorType.fromSymbol(symbol); + return new ExpressionToken(TokenKind.OPERATOR, symbol, start, end, op); + } + + public static ExpressionToken identifier(String name, int start, int end) { + if ("true".equals(name) || "false".equals(name)) { + return new ExpressionToken(TokenKind.BOOLEAN_LITERAL, name, start, end); + } + if ("null".equals(name)) { + return new ExpressionToken(TokenKind.NULL_LITERAL, name, start, end); + } + if ("new".equals(name)) { + return new ExpressionToken(TokenKind.NEW, name, start, end); + } + if ("instanceof".equals(name)) { + return new ExpressionToken(TokenKind.INSTANCEOF, name, start, end); + } + if ("function".equals(name)) { + return new ExpressionToken(TokenKind.FUNCTION, name, start, end); + } + return new ExpressionToken(TokenKind.IDENTIFIER, name, start, end); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/ExpressionTokenizer.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/ExpressionTokenizer.java new file mode 100644 index 000000000..5c0aa8d62 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/ExpressionTokenizer.java @@ -0,0 +1,176 @@ +package noppes.npcs.client.gui.util.script.interpreter.expression; + +import java.util.ArrayList; +import java.util.List; + +public class ExpressionTokenizer { + + public static List tokenize(String expr) { + List tokens = new ArrayList<>(); + int pos = 0; + int len = expr.length(); + + while (pos < len) { + char c = expr.charAt(pos); + + if (Character.isWhitespace(c)) { pos++; continue; } + + if (c == '"') { + int start = pos++; + while (pos < len && expr.charAt(pos) != '"') { + if (expr.charAt(pos) == '\\' && pos + 1 < len) pos++; + pos++; + } + if (pos < len) pos++; + tokens.add(new ExpressionToken(ExpressionToken.TokenKind.STRING_LITERAL, expr.substring(start, pos), start, pos)); + continue; + } + + if (c == '\'') { + int start = pos++; + while (pos < len && expr.charAt(pos) != '\'') { + if (expr.charAt(pos) == '\\' && pos + 1 < len) pos++; + pos++; + } + if (pos < len) pos++; + tokens.add(new ExpressionToken(ExpressionToken.TokenKind.CHAR_LITERAL, expr.substring(start, pos), start, pos)); + continue; + } + + if (Character.isDigit(c) || (c == '.' && pos + 1 < len && Character.isDigit(expr.charAt(pos + 1)))) { + int start = pos; + if (c == '0' && pos + 1 < len) { + char next = expr.charAt(pos + 1); + if (next == 'x' || next == 'X') { + pos += 2; + while (pos < len && isHexDigit(expr.charAt(pos))) pos++; + if (pos < len && (expr.charAt(pos) == 'L' || expr.charAt(pos) == 'l')) { + pos++; + tokens.add(new ExpressionToken(ExpressionToken.TokenKind.LONG_LITERAL, expr.substring(start, pos), start, pos)); + } else { + tokens.add(new ExpressionToken(ExpressionToken.TokenKind.INT_LITERAL, expr.substring(start, pos), start, pos)); + } + continue; + } + if (next == 'b' || next == 'B') { + pos += 2; + while (pos < len && (expr.charAt(pos) == '0' || expr.charAt(pos) == '1')) pos++; + tokens.add(new ExpressionToken(ExpressionToken.TokenKind.INT_LITERAL, expr.substring(start, pos), start, pos)); + continue; + } + } + + while (pos < len && Character.isDigit(expr.charAt(pos))) pos++; + boolean hasDecimal = false; + if (pos < len && expr.charAt(pos) == '.') { + if (pos + 1 < len && Character.isDigit(expr.charAt(pos + 1))) { + hasDecimal = true; + pos++; + while (pos < len && Character.isDigit(expr.charAt(pos))) pos++; + } + } + if (pos < len && (expr.charAt(pos) == 'e' || expr.charAt(pos) == 'E')) { + pos++; + if (pos < len && (expr.charAt(pos) == '+' || expr.charAt(pos) == '-')) pos++; + while (pos < len && Character.isDigit(expr.charAt(pos))) pos++; + hasDecimal = true; + } + + ExpressionToken.TokenKind kind = ExpressionToken.TokenKind.INT_LITERAL; + if (pos < len) { + char suffix = expr.charAt(pos); + if (suffix == 'f' || suffix == 'F') { kind = ExpressionToken.TokenKind.FLOAT_LITERAL; pos++; } + else if (suffix == 'd' || suffix == 'D') { kind = ExpressionToken.TokenKind.DOUBLE_LITERAL; pos++; } + else if (suffix == 'L' || suffix == 'l') { kind = ExpressionToken.TokenKind.LONG_LITERAL; pos++; } + else if (hasDecimal) kind = ExpressionToken.TokenKind.DOUBLE_LITERAL; + } else if (hasDecimal) kind = ExpressionToken.TokenKind.DOUBLE_LITERAL; + + tokens.add(new ExpressionToken(kind, expr.substring(start, pos), start, pos)); + continue; + } + + if (Character.isJavaIdentifierStart(c)) { + int start = pos; + while (pos < len && Character.isJavaIdentifierPart(expr.charAt(pos))) pos++; + tokens.add(ExpressionToken.identifier(expr.substring(start, pos), start, pos)); + continue; + } + + int start = pos; + String op = null; + + // Check for method reference :: (before lambda arrow and single colon) + if (pos + 1 < len && c == ':' && expr.charAt(pos + 1) == ':') { + tokens.add(new ExpressionToken(ExpressionToken.TokenKind.METHOD_REFERENCE, "::", pos, pos + 2)); + pos += 2; + continue; + } + + // Check for lambda arrow (Java ->) + if (pos + 1 < len && c == '-' && expr.charAt(pos + 1) == '>') { + tokens.add(new ExpressionToken(ExpressionToken.TokenKind.LAMBDA_ARROW, "->", pos, pos + 2)); + pos += 2; + continue; + } + + // Check for JS arrow (=>) + if (pos + 1 < len && c == '=' && expr.charAt(pos + 1) == '>') { + tokens.add(new ExpressionToken(ExpressionToken.TokenKind.JS_ARROW, "=>", pos, pos + 2)); + pos += 2; + continue; + } + + if (pos + 3 <= len) { + String s3 = expr.substring(pos, pos + 3); + if (">>>".equals(s3) || "<<=".equals(s3) || ">>=".equals(s3)) op = s3; + } + if (op == null && pos + 4 <= len) { + String s4 = expr.substring(pos, pos + 4); + if (">>>=".equals(s4)) op = s4; + } + if (op == null && pos + 2 <= len) { + String s2 = expr.substring(pos, pos + 2); + if ("++".equals(s2) || "--".equals(s2) || "+=".equals(s2) || "-=".equals(s2) || + "*=".equals(s2) || "/=".equals(s2) || "%=".equals(s2) || "&=".equals(s2) || + "|=".equals(s2) || "^=".equals(s2) || "==".equals(s2) || "!=".equals(s2) || + "<=".equals(s2) || ">=".equals(s2) || "&&".equals(s2) || "||".equals(s2) || + "<<".equals(s2) || ">>".equals(s2)) op = s2; + } + if (op == null) { + switch (c) { + case '+': case '-': case '*': case '/': case '%': case '&': case '|': + case '^': case '~': case '!': case '<': case '>': case '=': + op = String.valueOf(c); break; + } + } + + if (op != null) { + pos += op.length(); + tokens.add(ExpressionToken.operator(op, start, pos)); + continue; + } + + switch (c) { + case '(': tokens.add(new ExpressionToken(ExpressionToken.TokenKind.LEFT_PAREN, "(", pos, pos + 1)); break; + case ')': tokens.add(new ExpressionToken(ExpressionToken.TokenKind.RIGHT_PAREN, ")", pos, pos + 1)); break; + case '[': tokens.add(new ExpressionToken(ExpressionToken.TokenKind.LEFT_BRACKET, "[", pos, pos + 1)); break; + case ']': tokens.add(new ExpressionToken(ExpressionToken.TokenKind.RIGHT_BRACKET, "]", pos, pos + 1)); break; + case '{': tokens.add(new ExpressionToken(ExpressionToken.TokenKind.LEFT_BRACE, "{", pos, pos + 1)); break; + case '}': tokens.add(new ExpressionToken(ExpressionToken.TokenKind.RIGHT_BRACE, "}", pos, pos + 1)); break; + case '.': tokens.add(new ExpressionToken(ExpressionToken.TokenKind.DOT, ".", pos, pos + 1)); break; + case ',': tokens.add(new ExpressionToken(ExpressionToken.TokenKind.COMMA, ",", pos, pos + 1)); break; + case '?': tokens.add(new ExpressionToken(ExpressionToken.TokenKind.QUESTION, "?", pos, pos + 1)); break; + case ':': tokens.add(new ExpressionToken(ExpressionToken.TokenKind.COLON, ":", pos, pos + 1)); break; + case ';': tokens.add(new ExpressionToken(ExpressionToken.TokenKind.SEMICOLON, ";", pos, pos + 1)); break; + } + pos++; + } + + tokens.add(new ExpressionToken(ExpressionToken.TokenKind.EOF, "", len, len)); + return tokens; + } + + private static boolean isHexDigit(char c) { + return Character.isDigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/ExpressionTypeResolver.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/ExpressionTypeResolver.java new file mode 100644 index 000000000..f773d6e84 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/ExpressionTypeResolver.java @@ -0,0 +1,949 @@ +package noppes.npcs.client.gui.util.script.interpreter.expression; + +import noppes.npcs.client.gui.util.script.interpreter.ScriptDocument; +import noppes.npcs.client.gui.util.script.interpreter.InnerCallableScope; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.ClassTypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.OverloadSelector; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeChecker; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +import java.util.ArrayList; +import java.util.List; + +public class ExpressionTypeResolver { + private final ExpressionNode.TypeResolverContext context; + private final ScriptDocument document; // Access to document for inner scope lookups + private final int basePosition; // Document offset for this expression + + /** + * Static field to track the expected/desired type for the current expression being resolved. + * This allows TypeRules to validate type compatibility in context (e.g., ternary operator branches + * must be compatible with the assignment target type). + * Should be set before calling resolve() and cleared after. + */ + public static TypeInfo CURRENT_EXPECTED_TYPE = null; + + public ExpressionTypeResolver(ExpressionNode.TypeResolverContext context) { + this.context = context; + this.document = null; + this.basePosition = 0; + } + + public ExpressionTypeResolver(ExpressionNode.TypeResolverContext context, ScriptDocument document) { + this(context, document, 0); + } + + public ExpressionTypeResolver(ExpressionNode.TypeResolverContext context, ScriptDocument document, int basePosition) { + this.context = context; + this.document = document; + this.basePosition = basePosition; + } + + public TypeInfo resolve(String expression) { + if (expression == null || expression.trim().isEmpty()) return null; + + try { + List tokens = ExpressionTokenizer.tokenize(expression); + if (tokens.isEmpty()) return null; + + ExpressionParser parser = new ExpressionParser(tokens); + ExpressionNode ast = parser.parse(); + if (ast == null) return null; + + return resolveNodeType(ast); + } catch (Exception e) { + return null; + } + } + + public static boolean containsOperators(String expression) { + if (expression == null) return false; + for (int i = 0; i < expression.length(); i++) { + char c = expression.charAt(i); + switch (c) { + case '+': case '-': case '*': case '/': case '%': + case '&': case '|': case '^': case '~': + case '<': case '>': case '=': case '!': + case '?': case ':': return true; + } + } + return false; + } + + private TypeInfo resolveNodeType(ExpressionNode node) { + if (node == null) return null; + + if (node instanceof ExpressionNode.IntLiteralNode) { + if (CURRENT_EXPECTED_TYPE != null) { + TypeInfo narrowed = TypeChecker.narrowLiteralToExpectedType( + ((ExpressionNode.IntLiteralNode) node).getValue(), CURRENT_EXPECTED_TYPE); + if (narrowed != null) return narrowed; + } + return TypeInfo.fromPrimitive("int"); + } + if (node instanceof ExpressionNode.LongLiteralNode) return TypeInfo.fromPrimitive("long"); + if (node instanceof ExpressionNode.FloatLiteralNode) return TypeInfo.fromPrimitive("float"); + if (node instanceof ExpressionNode.DoubleLiteralNode) return TypeInfo.fromPrimitive("double"); + if (node instanceof ExpressionNode.BooleanLiteralNode) return TypeInfo.fromPrimitive("boolean"); + if (node instanceof ExpressionNode.CharLiteralNode) return TypeInfo.fromPrimitive("char"); + if (node instanceof ExpressionNode.StringLiteralNode) return TypeInfo.string(); + if (node instanceof ExpressionNode.NullLiteralNode) return TypeInfo.unresolved("null", ""); + + if (node instanceof ExpressionNode.IdentifierNode) { + return context.resolveIdentifier(((ExpressionNode.IdentifierNode) node).getName()); + } + + if (node instanceof ExpressionNode.MemberAccessNode) { + ExpressionNode.MemberAccessNode ma = (ExpressionNode.MemberAccessNode) node; + TypeInfo targetType = resolveNodeType(ma.getTarget()); + if (targetType == null || !targetType.isResolved()) return null; + if (targetType == TypeInfo.ANY || "any".equals(targetType.getFullName())) return TypeInfo.ANY; + return context.resolveMemberAccess(targetType, ma.getMemberName()); + } + + if (node instanceof ExpressionNode.MethodCallNode) { + ExpressionNode.MethodCallNode mc = (ExpressionNode.MethodCallNode) node; + TypeInfo targetType = mc.getTarget() == null ? context.resolveIdentifier("this") : resolveNodeType(mc.getTarget()); + if (targetType == null || !targetType.isResolved()) return null; + if (targetType == TypeInfo.ANY || "any".equals(targetType.getFullName())) return TypeInfo.ANY; + TypeInfo[] argTypes = new TypeInfo[mc.getArguments().size()]; + for (int i = 0; i < argTypes.length; i++) argTypes[i] = resolveNodeType(mc.getArguments().get(i)); + return context.resolveMethodCall(targetType, mc.getMethodName(), argTypes); + } + + if (node instanceof ExpressionNode.ArrayAccessNode) { + ExpressionNode.ArrayAccessNode aa = (ExpressionNode.ArrayAccessNode) node; + TypeInfo arrayType = resolveNodeType(aa.getArray()); + if (arrayType == null || !arrayType.isResolved()) return null; + if (arrayType == TypeInfo.ANY || "any".equals(arrayType.getFullName())) return TypeInfo.ANY; + String typeName = arrayType.getFullName(); + if (typeName.endsWith("[]")) { + String elementTypeName = typeName.substring(0, typeName.length() - 2); + return context.resolveTypeName(elementTypeName); + } + return context.resolveArrayAccess(arrayType); + } + + if (node instanceof ExpressionNode.NewNode) { + return context.resolveTypeName(((ExpressionNode.NewNode) node).getTypeName()); + } + + if (node instanceof ExpressionNode.BinaryOpNode) { + ExpressionNode.BinaryOpNode bin = (ExpressionNode.BinaryOpNode) node; + TypeInfo leftType = resolveNodeType(bin.getLeft()); + TypeInfo rightType = resolveNodeType(bin.getRight()); + return TypeRules.resolveBinaryOperatorType(bin.getOperator(), leftType, rightType); + } + + if (node instanceof ExpressionNode.UnaryOpNode) { + ExpressionNode.UnaryOpNode un = (ExpressionNode.UnaryOpNode) node; + // Special case: negation of an IntLiteralNode can narrow to byte/short + if (un.getOperator() == OperatorType.UNARY_MINUS + && un.getOperand() instanceof ExpressionNode.IntLiteralNode + && CURRENT_EXPECTED_TYPE != null) { + String negatedText = "-" + ((ExpressionNode.IntLiteralNode) un.getOperand()).getValue(); + TypeInfo narrowed = TypeChecker.narrowLiteralToExpectedType(negatedText, CURRENT_EXPECTED_TYPE); + if (narrowed != null) return narrowed; + } + TypeInfo operandType = resolveNodeType(un.getOperand()); + return TypeRules.resolveUnaryOperatorType(un.getOperator(), operandType); + } + + if (node instanceof ExpressionNode.TernaryNode) { + ExpressionNode.TernaryNode tern = (ExpressionNode.TernaryNode) node; + TypeInfo thenType = resolveNodeType(tern.getThenExpr()); + TypeInfo elseType = resolveNodeType(tern.getElseExpr()); + return TypeRules.resolveTernaryType(thenType, elseType); + } + + if (node instanceof ExpressionNode.CastNode) { + return context.resolveTypeName(((ExpressionNode.CastNode) node).getTypeName()); + } + + if (node instanceof ExpressionNode.InstanceofNode) { + return TypeInfo.fromPrimitive("boolean"); + } + + if (node instanceof ExpressionNode.AssignmentNode) { + return resolveNodeType(((ExpressionNode.AssignmentNode) node).getTarget()); + } + + if (node instanceof ExpressionNode.ParenthesizedNode) { + return resolveNodeType(((ExpressionNode.ParenthesizedNode) node).getInner()); + } + + if (node instanceof ExpressionNode.LambdaNode) { + return resolveLambdaType((ExpressionNode.LambdaNode) node); + } + + if (node instanceof ExpressionNode.JSFunctionNode) { + return resolveJSFunctionType((ExpressionNode.JSFunctionNode) node); + } + + if (node instanceof ExpressionNode.JSArrowNode) { + return resolveJSArrowType((ExpressionNode.JSArrowNode) node); + } + + if (node instanceof ExpressionNode.MethodReferenceNode) { + return resolveMethodReferenceType((ExpressionNode.MethodReferenceNode) node); + } + + return null; + } + + private TypeInfo resolveLambdaType(ExpressionNode.LambdaNode lambda) { + // Lambda type is determined by the expected functional interface + TypeInfo expectedType = CURRENT_EXPECTED_TYPE; + + if (expectedType == null) { + // No expected type context + // Return a generic Object type + return TypeInfo.fromClass(Object.class); + } + + // Get SAM method from the expected functional interface + MethodInfo sam = expectedType.getSingleAbstractMethod(); + if (sam != null && document != null) { + // Find the InnerCallableScope for this lambda by matching position and parameters + InnerCallableScope scope = findLambdaScopeByPosition(lambda.getStart(), lambda.getParameterNames()); + + if (scope != null) { + scope.setExpectedType(expectedType); + + // Extract and apply parameter types from SAM to lambda parameters + List samParams = sam.getParameters(); + List lambdaParams = scope.getParameters(); + + if (samParams.size() == lambdaParams.size()) { + for (int i = 0; i < lambdaParams.size(); i++) { + FieldInfo lambdaParam = lambdaParams.get(i); + TypeInfo inferredType = samParams.get(i).getTypeInfo(); + + // Set inferred type on the parameter + if (inferredType != null) { + lambdaParam.setInferredType(inferredType); + } + } + } + } + + // Type check lambda body (if expression lambda) + if (!lambda.isBlock() && lambda.getBody() != null) { + // Resolve body type for validation + TypeInfo bodyType = resolveNodeType(lambda.getBody()); + // The actual compatibility check will be done during marking phase + } + + return expectedType; + } + + // Fallback: check if it's a recognized functional interface by name + String typeName = expectedType.getFullName(); + if (typeName != null && (typeName.contains("Function") || typeName.contains("Consumer") || + typeName.contains("Predicate") || typeName.contains("Supplier") || + typeName.equals("java.lang.Runnable"))) { + // Update the scope reference if available + if (lambda.getScopeRef() != null) { + lambda.getScopeRef().setExpectedType(expectedType); + } + + return expectedType; + } + + // Not a recognized functional interface, return Object + return TypeInfo.fromClass(Object.class); + } + + /** + * Find the InnerCallableScope for a lambda by matching position and parameter names. + * + * @param expressionRelativePos The start position of the lambda (relative to expression string) + * @param paramNames The parameter names of the lambda + * @return The matching InnerCallableScope, or null if not found + */ + private InnerCallableScope findLambdaScopeByPosition(int expressionRelativePos, List paramNames) { + if (document == null) { + return null; + } + + // Convert expression-relative position to absolute document position + int absolutePos = basePosition + expressionRelativePos; + + for (InnerCallableScope scope : document.getInnerScopes()) { + if (scope.getKind() == InnerCallableScope.Kind.JAVA_LAMBDA) { + // Check if absolute position is in range + if (absolutePos >= scope.getHeaderStart() && absolutePos < scope.getFullEnd()) { + // Verify parameter names match + if (scope.getParameters().size() == paramNames.size()) { + boolean match = true; + for (int i = 0; i < paramNames.size(); i++) { + if (!scope.getParameters().get(i).getName().equals(paramNames.get(i))) { + match = false; + break; + } + } + if (match) { + return scope; + } + } + } + } + } + return null; + } + + private TypeInfo resolveJSFunctionType(ExpressionNode.JSFunctionNode functionNode) { + // JS function type is determined by the expected functional interface (if any) + TypeInfo expectedType = CURRENT_EXPECTED_TYPE; + + if (expectedType == null) { + // No expected type - return generic Function type or Object + // Try to resolve "Function" as a type from the context + TypeInfo functionType = context.resolveTypeName("Function"); + if (functionType != null && functionType.isResolved()) { + return functionType; + } + return TypeInfo.fromClass(Object.class); // Fallback + } + + // Get SAM method from the expected functional interface + MethodInfo sam = expectedType.getSingleAbstractMethod(); + if (sam != null && document != null) { + // Find the InnerCallableScope for this JS function by matching position and parameters + InnerCallableScope scope = findJSFunctionScopeByPosition(functionNode.getStart(), functionNode.getParameterNames()); + + if (scope != null) { + scope.setExpectedType(expectedType); + + // Extract and apply parameter types from SAM to function parameters + List samParams = sam.getParameters(); + List functionParams = scope.getParameters(); + + if (samParams.size() == functionParams.size()) { + for (int i = 0; i < functionParams.size(); i++) { + FieldInfo functionParam = functionParams.get(i); + TypeInfo inferredType = samParams.get(i).getTypeInfo(); + + // Set inferred type on the parameter + if (inferredType != null) { + functionParam.setInferredType(inferredType); + } + } + } + } + + return expectedType; + } + + // Fallback: check if expected type is compatible with a function + String typeName = expectedType.getFullName(); + if (typeName != null && (typeName.contains("Function") || typeName.contains("Consumer") || + typeName.contains("Predicate") || typeName.contains("Supplier") || + typeName.equals("java.lang.Runnable"))) { + // This is likely a functional interface + + // Update the InnerCallableScope with the expected type + if (functionNode.getScopeRef() != null) { + functionNode.getScopeRef().setExpectedType(expectedType); + } + + return expectedType; + } + + // Expected type is not a recognized functional interface + // Check if it's a generic JS "Function" type expectation + if (typeName != null && typeName.equals("Function")) { + return expectedType; + } + + return TypeInfo.fromClass(Object.class); // Fallback + } + + /** + * Find the InnerCallableScope for a JS function by matching position and parameter names. + * + * @param expressionRelativePos The start position of the function (relative to expression string) + * @param paramNames The parameter names of the function + * @return The matching InnerCallableScope, or null if not found + */ + private InnerCallableScope findJSFunctionScopeByPosition(int expressionRelativePos, List paramNames) { + if (document == null) { + return null; + } + + // Convert expression-relative position to absolute document position + int absolutePos = basePosition + expressionRelativePos; + + for (InnerCallableScope scope : document.getInnerScopes()) { + if (scope.getKind() == InnerCallableScope.Kind.JS_FUNCTION_EXPR) { + // Check if absolute position is in range + if (absolutePos >= scope.getHeaderStart() && absolutePos < scope.getFullEnd()) { + // Verify parameter names match + if (scope.getParameters().size() == paramNames.size()) { + boolean match = true; + for (int i = 0; i < paramNames.size(); i++) { + if (!scope.getParameters().get(i).getName().equals(paramNames.get(i))) { + match = false; + break; + } + } + if (match) { + return scope; + } + } + } + } + } + return null; + } + + private TypeInfo resolveJSArrowType(ExpressionNode.JSArrowNode arrowNode) { + TypeInfo expectedType = CURRENT_EXPECTED_TYPE; + + if (expectedType == null) { + TypeInfo functionType = context.resolveTypeName("Function"); + if (functionType != null && functionType.isResolved()) { + return functionType; + } + return TypeInfo.fromClass(Object.class); + } + + MethodInfo sam = expectedType.getSingleAbstractMethod(); + if (sam != null && document != null) { + InnerCallableScope scope = findJSArrowScopeByPosition(arrowNode.getStart(), arrowNode.getParameterNames()); + + if (scope != null) { + scope.setExpectedType(expectedType); + + List samParams = sam.getParameters(); + List arrowParams = scope.getParameters(); + + if (samParams.size() == arrowParams.size()) { + for (int i = 0; i < arrowParams.size(); i++) { + TypeInfo inferredType = samParams.get(i).getTypeInfo(); + if (inferredType != null) { + arrowParams.get(i).setInferredType(inferredType); + } + } + } + } + + return expectedType; + } + + String typeName = expectedType.getFullName(); + if (typeName != null && (typeName.contains("Function") || typeName.contains("Consumer") || + typeName.contains("Predicate") || typeName.contains("Supplier") || + typeName.equals("java.lang.Runnable"))) { + if (arrowNode.getScopeRef() != null) { + arrowNode.getScopeRef().setExpectedType(expectedType); + } + return expectedType; + } + + if (typeName != null && typeName.equals("Function")) { + return expectedType; + } + + return TypeInfo.fromClass(Object.class); + } + + private InnerCallableScope findJSArrowScopeByPosition(int expressionRelativePos, List paramNames) { + if (document == null) { + return null; + } + + int absolutePos = basePosition + expressionRelativePos; + + for (InnerCallableScope scope : document.getInnerScopes()) { + if (scope.getKind() == InnerCallableScope.Kind.JS_ARROW_FUNC) { + if (absolutePos >= scope.getHeaderStart() && absolutePos < scope.getFullEnd()) { + if (scope.getParameters().size() == paramNames.size()) { + boolean match = true; + for (int i = 0; i < paramNames.size(); i++) { + if (!scope.getParameters().get(i).getName().equals(paramNames.get(i))) { + match = false; + break; + } + } + if (match) { + return scope; + } + } + } + } + } + return null; + } + + // ==================== Method Reference Resolution ==================== + + /** + * Resolve the type of a method reference expression (target::methodName). + * + * Supports all Java method reference forms: + * - this::method - Instance method on current object + * - super::method - Instance method on superclass + * - variable::method - Instance method on a variable's value + * - ClassName::method - Static method OR unbound instance method + * - pkg.ClassName::method - Fully qualified class reference + * - ClassName::new - Constructor reference + * - Type[]::new - Array constructor reference + * + * @param methodRef The method reference AST node + * @return The resolved type (functional interface type if valid, Object if invalid) + */ + private TypeInfo resolveMethodReferenceType(ExpressionNode.MethodReferenceNode methodRef) { + TypeInfo expectedType = CURRENT_EXPECTED_TYPE; + + // Must have expected functional interface context + if (expectedType == null || !expectedType.isFunctionalInterface()) { + return TypeInfo.fromClass(Object.class); + } + + MethodInfo sam = expectedType.getSingleAbstractMethod(); + if (sam == null) { + return TypeInfo.fromClass(Object.class); + } + + // Resolve target and determine if it's a class reference (static context) + MethodReferenceTarget resolvedTarget = resolveMethodReferenceTarget(methodRef); + if (resolvedTarget == null || resolvedTarget.type == null) { + // Unresolved target - return expected type to allow forward references + return expectedType; + } + + String methodName = methodRef.getMethodName(); + + // Handle constructor references (ClassName::new or Type[]::new) + if ("new".equals(methodName)) { + return resolveConstructorReference(resolvedTarget, sam, expectedType); + } + + // Handle method references + return resolveMethodReference(resolvedTarget, methodName, sam, expectedType); + } + + /** + * Encapsulates the resolved target of a method reference. + */ + private static class MethodReferenceTarget { + final TypeInfo type; // The resolved type + final boolean isClassRef; // True if target is a class reference (for static access) + + MethodReferenceTarget(TypeInfo type, boolean isClassRef) { + this.type = type; + this.isClassRef = isClassRef; + } + } + + /** + * Resolve the target (left side of ::) for a method reference. + * Returns both the type and whether it's a class reference. + */ + private MethodReferenceTarget resolveMethodReferenceTarget(ExpressionNode.MethodReferenceNode methodRef) { + ExpressionNode target = methodRef.getTarget(); + if (target == null) { + return null; + } + + // Handle simple identifiers: this, super, variable, ClassName + if (target instanceof ExpressionNode.IdentifierNode) { + String name = ((ExpressionNode.IdentifierNode) target).getName(); + return resolveSimpleTarget(name); + } + + // Handle qualified names: pkg.ClassName or outer.Inner + if (target instanceof ExpressionNode.MemberAccessNode) { + return resolveQualifiedTarget((ExpressionNode.MemberAccessNode) target); + } + + // Handle array type targets: Type[] + if (target instanceof ExpressionNode.ArrayAccessNode) { + TypeInfo arrayType = resolveNodeType(target); + if (arrayType != null && arrayType.isResolved()) { + // Array type is always a class reference (for Type[]::new) + return new MethodReferenceTarget(arrayType, true); + } + } + + // Fallback: resolve as expression (e.g., (expr)::method) + TypeInfo exprType = resolveNodeType(target); + if (exprType != null && exprType.isResolved()) { + // Expression results are always instance references + return new MethodReferenceTarget(exprType, false); + } + + return null; + } + + /** + * Resolve a simple identifier as method reference target. + */ + private MethodReferenceTarget resolveSimpleTarget(String name) { + // this::method - instance method on current object + if ("this".equals(name)) { + TypeInfo thisType = context.resolveIdentifier("this"); + return thisType != null ? new MethodReferenceTarget(thisType, false) : null; + } + + // super::method - instance method on superclass + if ("super".equals(name)) { + TypeInfo superType = context.resolveIdentifier("super"); + return superType != null ? new MethodReferenceTarget(superType, false) : null; + } + + // Try as type name first (ClassName::method) + TypeInfo typeInfo = context.resolveTypeName(name); + if (typeInfo != null && typeInfo.isResolved()) { + // Wrap as ClassTypeInfo to indicate class reference + TypeInfo classRef = new ClassTypeInfo(typeInfo); + return new MethodReferenceTarget(classRef, true); + } + + // Try as variable (instance::method) + TypeInfo varType = context.resolveIdentifier(name); + if (varType != null && varType.isResolved()) { + // Check if variable holds a Class reference (e.g., var File = Java.type("java.io.File")) + boolean isClassRef = varType.isClassReference(); + return new MethodReferenceTarget(varType, isClassRef); + } + + return null; + } + + /** + * Resolve a qualified name (a.b.c) as method reference target. + * Handles both package-qualified class names and nested class access. + */ + private MethodReferenceTarget resolveQualifiedTarget(ExpressionNode.MemberAccessNode memberAccess) { + // Try to build qualified name and resolve as type + String qualifiedName = buildQualifiedName(memberAccess); + if (qualifiedName != null) { + TypeInfo typeInfo = context.resolveTypeName(qualifiedName); + if (typeInfo != null && typeInfo.isResolved()) { + TypeInfo classRef = new ClassTypeInfo(typeInfo); + return new MethodReferenceTarget(classRef, true); + } + } + + // Try resolving as expression chain (object.field::method) + TypeInfo exprType = resolveNodeType(memberAccess); + if (exprType != null && exprType.isResolved()) { + boolean isClassRef = exprType.isClassReference(); + return new MethodReferenceTarget(exprType, isClassRef); + } + + return null; + } + + /** + * Build a qualified name string from a MemberAccessNode chain. + * Example: a.b.c.ClassName -> "a.b.c.ClassName" + */ + private String buildQualifiedName(ExpressionNode node) { + if (node instanceof ExpressionNode.IdentifierNode) { + return ((ExpressionNode.IdentifierNode) node).getName(); + } + + if (node instanceof ExpressionNode.MemberAccessNode) { + ExpressionNode.MemberAccessNode ma = (ExpressionNode.MemberAccessNode) node; + String baseName = buildQualifiedName(ma.getTarget()); + if (baseName != null) { + return baseName + "." + ma.getMemberName(); + } + } + + return null; + } + + /** + * Resolve a method reference (target::methodName). + */ + private TypeInfo resolveMethodReference(MethodReferenceTarget target, String methodName, + MethodInfo sam, TypeInfo expectedType) { + TypeInfo targetType = target.isClassRef && target.type instanceof ClassTypeInfo + ? ((ClassTypeInfo) target.type).getInstanceType() + : target.type; + + if (targetType == null || !targetType.hasMethod(methodName)) { + return TypeInfo.fromClass(Object.class); + } + + // Find best matching method using OverloadSelector + MethodInfo method = findBestMethodForReference(targetType, methodName, sam, target.isClassRef); + if (method == null) { + return TypeInfo.fromClass(Object.class); + } + + // Validate signature compatibility + String error = validateMethodSignature(method, sam, target.isClassRef, targetType); + if (error != null) { + return TypeInfo.fromClass(Object.class); + } + + return expectedType; + } + + /** + * Find the best matching method for a method reference using OverloadSelector logic. + */ + private MethodInfo findBestMethodForReference(TypeInfo targetType, String methodName, + MethodInfo sam, boolean isClassRef) { + List allOverloads = targetType.getAllMethodOverloads(methodName); + if (allOverloads.isEmpty()) { + return null; + } + + // Extract SAM parameter types for overload matching + TypeInfo[] samParamTypes = extractSamParamTypes(sam, isClassRef, targetType); + + // Filter candidates by arity first, then use OverloadSelector + List candidates = new ArrayList<>(); + int expectedArity = samParamTypes.length; + + for (MethodInfo method : allOverloads) { + int methodArity = method.getParameters().size(); + + // Direct match: instance::method or ClassName::staticMethod + if (methodArity == expectedArity) { + candidates.add(method); + } + // Unbound instance method: ClassName::instanceMethod (first SAM param is receiver) + else if (isClassRef && methodArity == sam.getParameters().size() - 1 && !isStaticMethod(method)) { + candidates.add(method); + } + } + + if (candidates.isEmpty()) { + return null; + } + + if (candidates.size() == 1) { + return candidates.get(0); + } + + // Use OverloadSelector for multi-candidate selection + return OverloadSelector.selectBestOverload(candidates, samParamTypes); + } + + /** + * Extract the effective parameter types from SAM for method matching. + * For unbound instance methods, excludes the first receiver parameter. + */ + private TypeInfo[] extractSamParamTypes(MethodInfo sam, boolean isClassRef, TypeInfo targetType) { + List samParams = sam.getParameters(); + + // For class references, we might be matching an unbound instance method + // where the first SAM param is the receiver - handled in findBestMethodForReference + TypeInfo[] types = new TypeInfo[samParams.size()]; + for (int i = 0; i < samParams.size(); i++) { + types[i] = samParams.get(i).getTypeInfo(); + } + return types; + } + + /** + * Check if a method is static (Java reflection). + */ + private boolean isStaticMethod(MethodInfo method) { + java.lang.reflect.Method javaMethod = method.getJavaMethod(); + if (javaMethod != null) { + return java.lang.reflect.Modifier.isStatic(javaMethod.getModifiers()); + } + // For script-defined methods, assume non-static unless marked + return method.isStatic(); + } + + /** + * Validate method signature compatibility with SAM. + */ + private String validateMethodSignature(MethodInfo method, MethodInfo sam, + boolean isClassRef, TypeInfo targetType) { + List methodParams = method.getParameters(); + List samParams = sam.getParameters(); + + int methodArity = methodParams.size(); + int samArity = samParams.size(); + + // Check for unbound instance method reference (ClassName::instanceMethod) + boolean isUnbound = isClassRef && methodArity == samArity - 1 && !isStaticMethod(method); + + // Validate parameter count + if (methodArity != samArity && !isUnbound) { + return "Parameter count mismatch"; + } + + // Validate parameter types + int offset = isUnbound ? 1 : 0; + for (int i = 0; i < methodArity; i++) { + TypeInfo methodParamType = methodParams.get(i).getTypeInfo(); + TypeInfo samParamType = samParams.get(i + offset).getTypeInfo(); + + if (methodParamType != null && samParamType != null) { + if (!TypeChecker.isTypeCompatible(methodParamType, samParamType)) { + return "Parameter type mismatch at position " + (i + 1); + } + } + } + + // For unbound reference, validate receiver compatibility + if (isUnbound && samArity > 0) { + TypeInfo firstSamParam = samParams.get(0).getTypeInfo(); + if (firstSamParam != null && !TypeChecker.isTypeCompatible(targetType, firstSamParam)) { + return "Receiver type mismatch"; + } + } + + // Validate return type (covariant) + TypeInfo methodReturn = method.getReturnType(); + TypeInfo samReturn = sam.getReturnType(); + + if (samReturn != null && methodReturn != null) { + boolean samIsVoid = "void".equals(samReturn.getFullName()) || samReturn.getJavaClass() == void.class; + if (!samIsVoid && !TypeChecker.isTypeCompatible(samReturn, methodReturn)) { + return "Return type mismatch"; + } + } + + return null; + } + + /** + * Resolve a constructor reference (ClassName::new or Type[]::new). + */ + private TypeInfo resolveConstructorReference(MethodReferenceTarget target, MethodInfo sam, + TypeInfo expectedType) { + TypeInfo targetType = target.type; + + // Handle array constructor reference: Type[]::new + if (isArrayType(targetType)) { + return resolveArrayConstructorReference(targetType, sam, expectedType); + } + + // Get the actual class type for constructor lookup + TypeInfo classType = target.type instanceof ClassTypeInfo + ? ((ClassTypeInfo) target.type).getInstanceType() + : target.type; + + if (classType == null) { + return TypeInfo.fromClass(Object.class); + } + + // Cannot construct interfaces or abstract classes + if (classType.getKind() == TypeInfo.Kind.INTERFACE) { + return TypeInfo.fromClass(Object.class); + } + + // Extract SAM parameter types for constructor matching + List samParams = sam.getParameters(); + TypeInfo[] paramTypes = new TypeInfo[samParams.size()]; + for (int i = 0; i < samParams.size(); i++) { + paramTypes[i] = samParams.get(i).getTypeInfo(); + } + + // Find matching constructor + MethodInfo constructor = classType.findConstructor(paramTypes); + if (constructor == null && samParams.size() > 0) { + // Try by arity if exact type match fails + constructor = classType.findConstructor(samParams.size()); + } + + if (constructor == null) { + return TypeInfo.fromClass(Object.class); + } + + // Validate return type compatibility + TypeInfo samReturn = sam.getReturnType(); + if (samReturn != null && !TypeChecker.isTypeCompatible(samReturn, classType)) { + return TypeInfo.fromClass(Object.class); + } + + return expectedType; + } + + /** + * Resolve an array constructor reference: Type[]::new + * Must match IntFunction or similar single-int-param functional interface. + */ + private TypeInfo resolveArrayConstructorReference(TypeInfo arrayType, MethodInfo sam, + TypeInfo expectedType) { + List samParams = sam.getParameters(); + + // Array constructor takes exactly one int parameter (the size) + if (samParams.size() != 1) { + return TypeInfo.fromClass(Object.class); + } + + TypeInfo sizeParam = samParams.get(0).getTypeInfo(); + if (sizeParam == null || !isIntLike(sizeParam)) { + return TypeInfo.fromClass(Object.class); + } + + // Return type must be compatible with array type + TypeInfo samReturn = sam.getReturnType(); + if (samReturn != null && !TypeChecker.isTypeCompatible(samReturn, arrayType)) { + return TypeInfo.fromClass(Object.class); + } + + return expectedType; + } + + /** + * Check if a type is an array type. + */ + private boolean isArrayType(TypeInfo type) { + if (type == null) return false; + String name = type.getFullName(); + return name != null && name.endsWith("[]"); + } + + /** + * Check if a type is int-like (int, Integer, or numeric that can represent array size). + */ + private boolean isIntLike(TypeInfo type) { + if (type == null) return false; + String name = type.getFullName(); + return "int".equals(name) || "java.lang.Integer".equals(name) + || "long".equals(name) || "java.lang.Long".equals(name); + } + + public static ExpressionNode.TypeResolverContext createBasicContext() { + return new ExpressionNode.TypeResolverContext() { + public TypeInfo resolveIdentifier(String name) { + if ("true".equals(name) || "false".equals(name)) return TypeInfo.fromPrimitive("boolean"); + if ("null".equals(name)) return TypeInfo.unresolved("null", ""); + return null; + } + public TypeInfo resolveMemberAccess(TypeInfo targetType, String memberName) { return null; } + public TypeInfo resolveMethodCall(TypeInfo targetType, String methodName, TypeInfo[] argTypes) { return null; } + public TypeInfo resolveArrayAccess(TypeInfo arrayType) { + String typeName = arrayType.getFullName(); + if (typeName.endsWith("[]")) { + // For primitive arrays, we need to map back to primitive TypeInfo + String elementType = typeName.substring(0, typeName.length() - 2); + switch (elementType) { + case "int": case "long": case "float": case "double": + case "byte": case "short": case "char": case "boolean": + return TypeInfo.fromPrimitive(elementType); + default: + return TypeInfo.unresolved(elementType, elementType); + } + } + return null; + } + public TypeInfo resolveTypeName(String typeName) { + // Handle primitives + switch (typeName) { + case "int": case "long": case "float": case "double": + case "byte": case "short": case "char": case "boolean": case "void": + return TypeInfo.fromPrimitive(typeName); + default: + return TypeInfo.unresolved(typeName, typeName); + } + } + }; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/OperatorType.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/OperatorType.java new file mode 100644 index 000000000..2d4bf32dc --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/OperatorType.java @@ -0,0 +1,147 @@ +package noppes.npcs.client.gui.util.script.interpreter.expression; + +public enum OperatorType { + + ADD("+", 11, Associativity.LEFT, Category.ARITHMETIC), + SUBTRACT("-", 11, Associativity.LEFT, Category.ARITHMETIC), + MULTIPLY("*", 12, Associativity.LEFT, Category.ARITHMETIC), + DIVIDE("/", 12, Associativity.LEFT, Category.ARITHMETIC), + MODULO("%", 12, Associativity.LEFT, Category.ARITHMETIC), + + + ASSIGN("=", 1, Associativity.RIGHT, Category.ASSIGNMENT), + ADD_ASSIGN("+=", 1, Associativity.RIGHT, Category.ASSIGNMENT), + SUBTRACT_ASSIGN("-=", 1, Associativity.RIGHT, Category.ASSIGNMENT), + MULTIPLY_ASSIGN("*=", 1, Associativity.RIGHT, Category.ASSIGNMENT), + DIVIDE_ASSIGN("/=", 1, Associativity.RIGHT, Category.ASSIGNMENT), + MODULO_ASSIGN("%=", 1, Associativity.RIGHT, Category.ASSIGNMENT), + AND_ASSIGN("&=", 1, Associativity.RIGHT, Category.ASSIGNMENT), + OR_ASSIGN("|=", 1, Associativity.RIGHT, Category.ASSIGNMENT), + XOR_ASSIGN("^=", 1, Associativity.RIGHT, Category.ASSIGNMENT), + LEFT_SHIFT_ASSIGN("<<=", 1, Associativity.RIGHT, Category.ASSIGNMENT), + RIGHT_SHIFT_ASSIGN(">>=", 1, Associativity.RIGHT, Category.ASSIGNMENT), + UNSIGNED_RIGHT_SHIFT_ASSIGN(">>>=", 1, Associativity.RIGHT, Category.ASSIGNMENT), + + TERNARY_QUESTION("?", 2, Associativity.RIGHT, Category.TERNARY), + TERNARY_COLON(":", 2, Associativity.RIGHT, Category.TERNARY), + + LOGICAL_OR("||", 3, Associativity.LEFT, Category.LOGICAL), + LOGICAL_AND("&&", 4, Associativity.LEFT, Category.LOGICAL), + + BITWISE_OR("|", 5, Associativity.LEFT, Category.BITWISE), + BITWISE_XOR("^", 6, Associativity.LEFT, Category.BITWISE), + BITWISE_AND("&", 7, Associativity.LEFT, Category.BITWISE), + + EQUALS("==", 8, Associativity.LEFT, Category.RELATIONAL), + NOT_EQUALS("!=", 8, Associativity.LEFT, Category.RELATIONAL), + LESS_THAN("<", 9, Associativity.LEFT, Category.RELATIONAL), + GREATER_THAN(">", 9, Associativity.LEFT, Category.RELATIONAL), + LESS_THAN_OR_EQUAL("<=", 9, Associativity.LEFT, Category.RELATIONAL), + GREATER_THAN_OR_EQUAL(">=", 9, Associativity.LEFT, Category.RELATIONAL), + + LEFT_SHIFT("<<", 10, Associativity.LEFT, Category.BITWISE), + RIGHT_SHIFT(">>", 10, Associativity.LEFT, Category.BITWISE), + UNSIGNED_RIGHT_SHIFT(">>>", 10, Associativity.LEFT, Category.BITWISE), + + UNARY_PLUS("+", 14, Associativity.RIGHT, Category.UNARY), + UNARY_MINUS("-", 14, Associativity.RIGHT, Category.UNARY), + LOGICAL_NOT("!", 14, Associativity.RIGHT, Category.UNARY), + BITWISE_NOT("~", 14, Associativity.RIGHT, Category.UNARY), + PRE_INCREMENT("++", 14, Associativity.RIGHT, Category.UNARY), + PRE_DECREMENT("--", 14, Associativity.RIGHT, Category.UNARY), + POST_INCREMENT("++", 15, Associativity.LEFT, Category.UNARY_POSTFIX), + POST_DECREMENT("--", 15, Associativity.LEFT, Category.UNARY_POSTFIX), + + MEMBER_ACCESS(".", 16, Associativity.LEFT, Category.ACCESS), + ARRAY_ACCESS("[]", 16, Associativity.LEFT, Category.ACCESS), + METHOD_CALL("()", 16, Associativity.LEFT, Category.ACCESS), + + CAST("(type)", 14, Associativity.RIGHT, Category.CAST), + INSTANCEOF("instanceof", 9, Associativity.LEFT, Category.INSTANCEOF); + + + private final String symbol; + private final int precedence; + private final Associativity associativity; + private final Category category; + + OperatorType(String symbol, int precedence, Associativity associativity, Category category) { + this.symbol = symbol; + this.precedence = precedence; + this.associativity = associativity; + this.category = category; + } + + public String getSymbol() { return symbol; } + public int getPrecedence() { return precedence; } + public Associativity getAssociativity() { return associativity; } + public Category getCategory() { return category; } + + public boolean isBinary() { + return category == Category.ARITHMETIC || category == Category.RELATIONAL || + category == Category.LOGICAL || category == Category.BITWISE; + } + + public boolean isUnary() { + return category == Category.UNARY || category == Category.UNARY_POSTFIX; + } + + public boolean isAssignment() { + return category == Category.ASSIGNMENT; + } + + public boolean isComparison() { + return category == Category.RELATIONAL; + } + + public enum Associativity { LEFT, RIGHT } + + public enum Category { + ARITHMETIC, UNARY, UNARY_POSTFIX, RELATIONAL, LOGICAL, BITWISE, + TERNARY, INSTANCEOF, ASSIGNMENT, CAST, ACCESS + } + + public static OperatorType fromSymbol(String symbol) { + for (OperatorType op : values()) { + if (op.symbol.equals(symbol)) return op; + } + return null; + } + + public static OperatorType fromBinarySymbol(String symbol) { + switch (symbol) { + case "+": return ADD; + case "-": return SUBTRACT; + case "*": return MULTIPLY; + case "/": return DIVIDE; + case "%": return MODULO; + case "==": return EQUALS; + case "!=": return NOT_EQUALS; + case "<": return LESS_THAN; + case ">": return GREATER_THAN; + case "<=": return LESS_THAN_OR_EQUAL; + case ">=": return GREATER_THAN_OR_EQUAL; + case "&&": return LOGICAL_AND; + case "||": return LOGICAL_OR; + case "&": return BITWISE_AND; + case "|": return BITWISE_OR; + case "^": return BITWISE_XOR; + case "<<": return LEFT_SHIFT; + case ">>": return RIGHT_SHIFT; + case ">>>": return UNSIGNED_RIGHT_SHIFT; + case "=": return ASSIGN; + case "+=": return ADD_ASSIGN; + case "-=": return SUBTRACT_ASSIGN; + case "*=": return MULTIPLY_ASSIGN; + case "/=": return DIVIDE_ASSIGN; + case "%=": return MODULO_ASSIGN; + case "&=": return AND_ASSIGN; + case "|=": return OR_ASSIGN; + case "^=": return XOR_ASSIGN; + case "<<=": return LEFT_SHIFT_ASSIGN; + case ">>=": return RIGHT_SHIFT_ASSIGN; + case ">>>=": return UNSIGNED_RIGHT_SHIFT_ASSIGN; + default: return null; + } + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/TypeRules.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/TypeRules.java new file mode 100644 index 000000000..d20f8709a --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/expression/TypeRules.java @@ -0,0 +1,349 @@ +package noppes.npcs.client.gui.util.script.interpreter.expression; + +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +public class TypeRules { + + private static boolean isJsNumber(TypeInfo type) { + if (type == null || !type.isResolved()) return false; + String name = type.getSimpleName(); + String full = type.getFullName(); + return "number".equals(name) || "number".equals(full); + } + + private static boolean isNumericPrimitiveOrWrapper(TypeInfo type) { + if (type == null || type.getJavaClass() == null) return false; + Class cls = type.getJavaClass(); + return cls == byte.class || cls == Byte.class || + cls == short.class || cls == Short.class || + cls == int.class || cls == Integer.class || + cls == long.class || cls == Long.class || + cls == float.class || cls == Float.class || + cls == double.class || cls == Double.class || + cls == char.class || cls == Character.class; + } + + private static boolean isAny(TypeInfo type) { + if (type == null) return false; + if (type == TypeInfo.ANY) return true; + String full = type.getFullName(); + return "any".equals(full); + } + + public static boolean isNumeric(TypeInfo type) { + if (type == null || !type.isResolved()) return false; + if (isJsNumber(type)) return true; + String name = type.getSimpleName(); + return "int".equals(name) || "long".equals(name) || "float".equals(name) || + "double".equals(name) || "byte".equals(name) || "short".equals(name) || "char".equals(name); + } + + public static boolean isIntegral(TypeInfo type) { + if (type == null || !type.isResolved()) return false; + String name = type.getSimpleName(); + return "int".equals(name) || "long".equals(name) || "byte".equals(name) || + "short".equals(name) || "char".equals(name); + } + + public static boolean isFloatingPoint(TypeInfo type) { + if (type == null || !type.isResolved()) return false; + if (isJsNumber(type)) return true; + String name = type.getSimpleName(); + return "float".equals(name) || "double".equals(name); + } + + public static boolean isBoolean(TypeInfo type) { + if (type == null || !type.isResolved()) return false; + return "boolean".equals(type.getSimpleName()); + } + + public static boolean isString(TypeInfo type) { + if (type == null || !type.isResolved()) return false; + String name = type.getSimpleName(); + String fullName = type.getFullName(); + return "String".equals(name) || "java.lang.String".equals(fullName); + } + + public static TypeInfo binaryNumericPromotion(TypeInfo left, TypeInfo right) { + if (isJsNumber(left) || isJsNumber(right)) return TypeInfo.NUMBER; + if (left == null || right == null || !left.isResolved() || !right.isResolved()) { + return null; + } + String l = left.getSimpleName(); + String r = right.getSimpleName(); + if ("double".equals(l) || "double".equals(r)) return TypeInfo.fromPrimitive("double"); + if ("float".equals(l) || "float".equals(r)) return TypeInfo.fromPrimitive("float"); + if ("long".equals(l) || "long".equals(r)) return TypeInfo.fromPrimitive("long"); + return TypeInfo.fromPrimitive("int"); + } + + public static TypeInfo unaryNumericPromotion(TypeInfo type) { + if (type == null || !type.isResolved()) return null; + if (isJsNumber(type)) return TypeInfo.NUMBER; + String name = type.getSimpleName(); + if ("double".equals(name) || "float".equals(name) || "long".equals(name)) return type; + if ("byte".equals(name) || "short".equals(name) || "char".equals(name) || "int".equals(name)) { + return TypeInfo.fromPrimitive("int"); + } + return null; + } + + public static TypeInfo resolveBinaryOperatorType(OperatorType op, TypeInfo left, TypeInfo right) { + if (op == null) return null; + + switch (op.getCategory()) { + case ARITHMETIC: + if (op == OperatorType.ADD && (isString(left) || isString(right))) { + return validateAgainstExpectedType(TypeInfo.string()); + } + if (isAny(left) || isAny(right)) { + return validateAgainstExpectedType(TypeInfo.ANY); + } + if (isNumeric(left) && isNumeric(right)) { + TypeInfo promoted = binaryNumericPromotion(left, right); + return validateAgainstExpectedType(promoted); + } + return null; + + case RELATIONAL: + if (op == OperatorType.EQUALS || op == OperatorType.NOT_EQUALS) { + return TypeInfo.fromPrimitive("boolean"); + } + if (isAny(left) || isAny(right)) { + return TypeInfo.fromPrimitive("boolean"); + } + if (isNumeric(left) && isNumeric(right)) { + return TypeInfo.fromPrimitive("boolean"); + } + return null; + + case LOGICAL: + if (isAny(left) || isAny(right)) { + return TypeInfo.ANY; + } + if (isBoolean(left) && isBoolean(right)) { + return TypeInfo.fromPrimitive("boolean"); + } + return null; + + case BITWISE: + if (isAny(left) || isAny(right)) { + return validateAgainstExpectedType(TypeInfo.ANY); + } + if (op == OperatorType.LEFT_SHIFT || op == OperatorType.RIGHT_SHIFT || + op == OperatorType.UNSIGNED_RIGHT_SHIFT) { + if (isIntegral(left)) { + TypeInfo promoted = unaryNumericPromotion(left); + return validateAgainstExpectedType(promoted); + } + } + if (isIntegral(left) && isIntegral(right)) { + TypeInfo promoted = binaryNumericPromotion(left, right); + return validateAgainstExpectedType(promoted); + } + if (isBoolean(left) && isBoolean(right)) { + return TypeInfo.fromPrimitive("boolean"); + } + return null; + + case ASSIGNMENT: + return left; + + default: + return null; + } + } + + public static TypeInfo resolveUnaryOperatorType(OperatorType op, TypeInfo operand) { + if (op == null || operand == null || !operand.isResolved()) { + return null; + } + + if (isAny(operand)) { + if (op == OperatorType.LOGICAL_NOT) { + return TypeInfo.fromPrimitive("boolean"); + } + return TypeInfo.ANY; + } + + switch (op) { + case UNARY_PLUS: + case UNARY_MINUS: + if (isNumeric(operand)) { + TypeInfo promoted = unaryNumericPromotion(operand); + return validateAgainstExpectedType(promoted); + } + return null; + + case BITWISE_NOT: + if (isIntegral(operand)) { + TypeInfo promoted = unaryNumericPromotion(operand); + return validateAgainstExpectedType(promoted); + } + return null; + + case LOGICAL_NOT: + if (isBoolean(operand)) return TypeInfo.fromPrimitive("boolean"); + return null; + + case PRE_INCREMENT: + case PRE_DECREMENT: + case POST_INCREMENT: + case POST_DECREMENT: + if (isNumeric(operand)) return operand; + return null; + + default: + return null; + } + } + + /** + * Check if sourceType can be assigned to targetType. + * Handles primitives, numeric conversions, null compatibility, and reference types. + */ + public static boolean isAssignmentCompatible(TypeInfo sourceType, TypeInfo targetType) { + if (sourceType == null || targetType == null) + return false; + if (!targetType.isResolved()) + return true; // Can't validate against unresolved type + + if (isAny(sourceType) || isAny(targetType)) { + return true; + } + + // Null literal can be assigned to any reference type + if ("".equals(sourceType.getFullName())) { + return !isPrimitive(targetType); + } + + if (!sourceType.isResolved()) + return false; + + if ((isJsNumber(sourceType) && isNumericPrimitiveOrWrapper(targetType)) || + (isJsNumber(targetType) && isNumericPrimitiveOrWrapper(sourceType))) { + return true; + } + + // Exact match + if (sourceType.equals(targetType)) + return true; + if (sourceType.getFullName().equals(targetType.getFullName())) + return true; + + // Numeric conversions (widening primitive conversions) + String source = sourceType.getSimpleName(); + String target = targetType.getSimpleName(); + + // byte -> short, int, long, float, double + if ("byte".equals(source)) { + return "short".equals(target) || "int".equals(target) || "long".equals(target) || + "float".equals(target) || "double".equals(target); + } + // short -> int, long, float, double + if ("short".equals(source)) { + return "int".equals(target) || "long".equals(target) || + "float".equals(target) || "double".equals(target); + } + // char -> int, long, float, double + if ("char".equals(source)) { + return "int".equals(target) || "long".equals(target) || + "float".equals(target) || "double".equals(target); + } + // int -> long, float, double + if ("int".equals(source)) { + return "long".equals(target) || "float".equals(target) || "double".equals(target); + } + // long -> float, double + if ("long".equals(source)) { + return "float".equals(target) || "double".equals(target); + } + // float -> double + if ("float".equals(source)) { + return "double".equals(target); + } + + // For reference types, we'd need inheritance/interface checking + // For now, return false for incompatible types + return false; + } + + /** + * Check if a type is a primitive type. + */ + public static boolean isPrimitive(TypeInfo type) { + if (type == null || !type.isResolved()) + return false; + String name = type.getSimpleName(); + return "int".equals(name) || "long".equals(name) || "float".equals(name) || + "double".equals(name) || "byte".equals(name) || "short".equals(name) || + "char".equals(name) || "boolean".equals(name) || "void".equals(name); + } + + /** + * Validate a computed type against the current expected type context. + * If there's an expected type and the computed type is compatible, returns the expected type. + * If incompatible, returns the computed type so the error can be properly reported. + * If no expected type context, returns the computed type unchanged. + * + * @param computedType The type computed by normal type rules + * @return The type to use (either expectedType if compatible, or computedType) + */ + public static TypeInfo validateAgainstExpectedType(TypeInfo computedType) { + if (computedType == null) return null; + + TypeInfo expectedType = ExpressionTypeResolver.CURRENT_EXPECTED_TYPE; + if (expectedType != null && expectedType.isResolved() && computedType.isResolved()) { + if (isAssignmentCompatible(computedType, expectedType)) { + return expectedType; + } + // Return computed type so error can be detected (incompatible with expected) + return computedType; + } + + return computedType; + } + + public static TypeInfo resolveTernaryType(TypeInfo thenType, TypeInfo elseType) { + if (thenType == null && elseType == null) return null; + if (thenType == null) return elseType; + if (elseType == null) return thenType; + + // Handle null literal type + boolean thenIsNull = "".equals(thenType.getFullName()); + boolean elseIsNull = "".equals(elseType.getFullName()); + + if (thenIsNull && elseIsNull) return thenType; // both null -> null + if (thenIsNull) return elseType; // null : T -> T + if (elseIsNull) return thenType; // T : null -> T + + if (!thenType.isResolved()) return elseType.isResolved() ? elseType : null; + if (!elseType.isResolved()) return thenType; + + // If there's an expected type context, validate both branches against it + TypeInfo expectedType = ExpressionTypeResolver.CURRENT_EXPECTED_TYPE; + if (expectedType != null && expectedType.isResolved()) { + boolean thenCompatible = isAssignmentCompatible(thenType, expectedType); + boolean elseCompatible = isAssignmentCompatible(elseType, expectedType); + + // If both branches are compatible with expected type, return expected type + if (thenCompatible && elseCompatible) { + return expectedType; + } else if (!elseCompatible) { + // Return the incompatible type so error can be detected + return elseType; + } else { + // thenType is incompatible + return thenType; + } + } + + // Normal ternary type resolution without expected type context + if (thenType.equals(elseType)) return thenType; + if (isNumeric(thenType) && isNumeric(elseType)) { + return binaryNumericPromotion(thenType, elseType); + } + + return thenType; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/field/AssignmentInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/field/AssignmentInfo.java new file mode 100644 index 000000000..565dd9717 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/field/AssignmentInfo.java @@ -0,0 +1,249 @@ +package noppes.npcs.client.gui.util.script.interpreter.field; + +import noppes.npcs.client.gui.util.script.ScopeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeChecker; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; + +/** + * Metadata for assignment validation. + * Tracks assignment statements like "varName = expr" or "obj.field = expr" + * and validates type compatibility, access modifiers, and final status. + * + * Each AssignmentInfo represents a single assignment to a field. + * The positions are: + * - lhsStart/lhsEnd: The target variable/field position (left-hand side) + * - rhsStart/rhsEnd: From first token of RHS to the semicolon (inclusive) + */ +public class AssignmentInfo { + + /** + * Error type for assignment validation. + */ + public enum ErrorType { + NONE, + TYPE_MISMATCH, // Assigned value type doesn't match target type + FINAL_REASSIGNMENT, // Attempting to reassign a final field + PRIVATE_ACCESS, // Attempting to access private field + PROTECTED_ACCESS, // Attempting to access protected field from invalid context + UNRESOLVED_TARGET, // Target variable/field doesn't exist + STATIC_CONTEXT_ERROR, // Accessing instance field from static context + DUPLICATE_DECLARATION // Variable is already defined in the scope + } + + // Statement position + private final int statementStart; // Absolute start of statement (includes modifiers/type for declarations) + + // Target/LHS info + private final String targetName; + private final int lhsStart; // Position of first char of target variable/field + private final int lhsEnd; // Position after last char of target + private final TypeInfo targetType; // Declared type of target + + // Source/RHS info (from first token of RHS expression to semicolon) + private final int rhsStart; // Position of first non-whitespace char after '=' + private final int rhsEnd; // Position of ';' (inclusive in the range for underlining) + private final TypeInfo sourceType; // Resolved type of RHS expression + private final String sourceExpr; // The RHS expression text (for display) + + // For chained field access (e.g., obj.field = value) + private final TypeInfo receiverType; // Type of receiver (null for simple variables) + private final Field reflectionField; // Java reflection field (for modifier checks) + + // Flag for script-defined final variables + private final boolean isFinal; + + // Validation + private ErrorType errorType = ErrorType.NONE; + private String errorMessage; + private String requiredType; + private String providedType; + + private ScopeInfo scopeInfo; + + public AssignmentInfo(String targetName, int statementStart, int lhsStart, int lhsEnd, + TypeInfo targetType, int rhsStart, int rhsEnd, + TypeInfo sourceType, String sourceExpr, + TypeInfo receiverType, java.lang.reflect.Field reflectionField, + boolean isFinal) { + this.targetName = targetName; + this.statementStart = statementStart; + this.lhsStart = lhsStart; + this.lhsEnd = lhsEnd; + this.targetType = targetType; + this.rhsStart = rhsStart; + this.rhsEnd = rhsEnd; + this.sourceType = sourceType; + this.sourceExpr = sourceExpr; + this.receiverType = receiverType; + this.reflectionField = reflectionField; + this.isFinal = isFinal; + } + + /** + * Factory method to create an AssignmentInfo representing a duplicate declaration error. + * Only the LHS (variable name) position is relevant for underlining. + */ + public static AssignmentInfo duplicateDeclaration(String varName, int nameStart, int nameEnd, String errorMessage) { + AssignmentInfo info = new AssignmentInfo( + varName, + nameStart, // statementStart = nameStart for underline positioning + nameStart, // lhsStart + nameEnd, // lhsEnd + null, // targetType + -1, // rhsStart (not applicable) + -1, // rhsEnd (not applicable) + null, // sourceType + null, // sourceExpr + null, // receiverType + null, // reflectionField + false // isFinal + ); + info.setError(ErrorType.DUPLICATE_DECLARATION, errorMessage); + return info; + } + + // ==================== VALIDATION ==================== + + /** + * Validate this assignment. + * Checks type compatibility, final status, and access modifiers. + */ + public void validate() { + // Check for final field reassignment from reflection + if (reflectionField != null && Modifier.isFinal(reflectionField.getModifiers())) { + setError(ErrorType.FINAL_REASSIGNMENT, + "Cannot assign a value to final variable '" + targetName + "'"); + return; + } + + // Check for final field reassignment from FieldInfo (script-defined finals) + if (isFinal) { + setError(ErrorType.FINAL_REASSIGNMENT, + "Cannot assign a value to final variable '" + targetName + "'"); + return; + } + + // Check access modifiers for chained field access + if (reflectionField != null && receiverType != null) { + int mods = reflectionField.getModifiers(); + if (Modifier.isPrivate(mods)) { + setError(ErrorType.PRIVATE_ACCESS, + "'" + targetName + "' has private access in '" + receiverType.getFullName() + "'"); + return; + } + } + + // Check type compatibility + if (targetType != null && sourceType != null) { + if (!TypeChecker.isTypeCompatible(targetType, sourceType)) { + this.requiredType = targetType.getSimpleName(); + this.providedType = sourceType.getSimpleName(); + setError(ErrorType.TYPE_MISMATCH, buildTypeMismatchMessage()); + } + } + } + + /** + * Build a formatted type mismatch error message (IntelliJ style). + */ + private String buildTypeMismatchMessage() { + return "Provided type: " + providedType + "\nRequired: " + requiredType; + } + + private void setError(ErrorType type, String message) { + this.errorType = type; + this.errorMessage = message; + } + + // ==================== POSITION CHECKS ==================== + + /** + * Check if the given global position falls within the LHS (target) of this assignment. + */ + public boolean containsLhsPosition(int position) { + return position >= statementStart && position < lhsEnd; + } + + /** + * Check if the given global position falls within the RHS (source) of this assignment. + */ + public boolean containsRhsPosition(int position) { + return position >= rhsStart && position <= rhsEnd; + } + + /** + * Check if the given global position falls anywhere in this assignment (LHS or RHS). + */ + public boolean containsPosition(int position) { + return position >= statementStart && position <= rhsEnd; + } + + // ==================== ERROR TYPE CHECKS ==================== + + /** + * Check if this is an LHS error (final reassignment, access errors, duplicate declarations). + * These errors should underline the LHS. + */ + public boolean isLhsError() { + return errorType == ErrorType.FINAL_REASSIGNMENT || + errorType == ErrorType.PRIVATE_ACCESS || + errorType == ErrorType.PROTECTED_ACCESS || + errorType == ErrorType.STATIC_CONTEXT_ERROR || + errorType == ErrorType.DUPLICATE_DECLARATION; + } + + /** + * Check if this is an RHS error (type mismatch). + * These errors should underline the RHS. + */ + public boolean isRhsError() { + return false; + } + + public boolean isFullLineError() { + return errorType == ErrorType.TYPE_MISMATCH; + } + + // ==================== GETTERS ==================== + + public String getTargetName() { return targetName; } + public int getStatementStart() { return statementStart; } + public int getLhsStart() { return lhsStart; } + public int getLhsEnd() { return lhsEnd; } + public TypeInfo getTargetType() { return targetType; } + public int getRhsStart() { return rhsStart; } + public int getRhsEnd() { return rhsEnd; } + public TypeInfo getSourceType() { return sourceType; } + public String getSourceExpr() { return sourceExpr; } + public TypeInfo getReceiverType() { return receiverType; } + public java.lang.reflect.Field getReflectionField() { return reflectionField; } + + public ErrorType getErrorType() { return errorType; } + public String getErrorMessage() { return errorMessage; } + public String getRequiredType() { return requiredType; } + public String getProvidedType() { return providedType; } + + public boolean hasError() { return errorType != ErrorType.NONE; } + public boolean hasTypeMismatch() { return errorType == ErrorType.TYPE_MISMATCH; } + public boolean hasFinalReassignment() { return errorType == ErrorType.FINAL_REASSIGNMENT; } + public boolean hasAccessError() { return errorType == ErrorType.PRIVATE_ACCESS || errorType == ErrorType.PROTECTED_ACCESS; } + + public ScopeInfo getScopeInfo() { return scopeInfo; } + public void setScopeInfo(ScopeInfo scopeInfo) { this.scopeInfo = scopeInfo; } + + @Override + public String toString() { + return "AssignmentInfo{" + + "target='" + targetName + "', " + + "stmt=" + statementStart + ", " + + "lhs=[" + lhsStart + "-" + lhsEnd + "], " + + "rhs=[" + rhsStart + "-" + rhsEnd + "], " + + "targetType=" + targetType + ", " + + "sourceType=" + sourceType + ", " + + "error=" + errorType + + '}'; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/field/EnumConstantInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/field/EnumConstantInfo.java new file mode 100644 index 000000000..f86b3e146 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/field/EnumConstantInfo.java @@ -0,0 +1,317 @@ +package noppes.npcs.client.gui.util.script.interpreter.field; + +import noppes.npcs.client.gui.util.script.interpreter.ScriptDocument; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodCallInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.ScriptTypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** + * Represents an enum constant declaration with its constructor call. + * Combines a FieldInfo (the constant itself) with a MethodCallInfo (the constructor call validation). + * This allows us to reuse existing method call validation logic for enum constructor matching. + */ +public class EnumConstantInfo { + + private final FieldInfo fieldInfo; + private final MethodCallInfo constructorCall; // Can be null if no args provided + private final TypeInfo enumType; + + public EnumConstantInfo(FieldInfo fieldInfo, MethodCallInfo constructorCall, TypeInfo enumType) { + this.fieldInfo = fieldInfo; + this.constructorCall = constructorCall; + this.enumType = enumType; + } + + /** + * Parse enum constants from an enum body. + * Returns a list of EnumConstantInfo objects, each representing one constant. + * + * @param enumType The enum type being parsed + * @param bodyText The text content of the enum body + * @param bodyOffset The absolute offset where the enum body starts + * @param keywordPattern Pattern to detect Java keywords (to skip them) + * @return List of parsed enum constants + */ + public static List parseEnumConstants( + ScriptTypeInfo enumType, + String bodyText, + int bodyOffset, + Pattern keywordPattern) { + + List constants = new ArrayList<>(); + + // Find where enum constants end (first semicolon not in parens, or first method/field declaration) + int constantsEnd = findEnumConstantsEnd(bodyText); + if (constantsEnd <= 0) { + // No semicolon found - entire body might be constants + constantsEnd = bodyText.length(); + } + + // Pattern to match enum constants: NAME or NAME() or NAME(args) + Pattern constantPattern = Pattern.compile( + "([A-Za-z_][a-zA-Z0-9_]*)\\s*(\\(([^)]*)\\))?"); + + Matcher m = constantPattern.matcher(bodyText); + int lastEnd = 0; + + while (m.find()) { + // Skip if we're past the constants section + if (m.start() >= constantsEnd) { + break; + } + + int absPos = bodyOffset + m.start(); + if (ScriptDocument.INSTANCE.isExcluded(absPos)) { + lastEnd = m.end(); + continue; + } + + // Check if this is at a valid position (after comma or at start) + String beforeMatch = bodyText.substring(lastEnd, m.start()).trim(); + if (!beforeMatch.isEmpty() && !beforeMatch.equals(",")) { + // Not a valid enum constant position - might be inside parens + continue; + } + + String constantName = m.group(1); + String argsClause = m.group(2); // includes parens if present + String args = m.group(3); // just the args without parens + + // Skip keywords + if (keywordPattern.matcher(constantName).matches()) { + lastEnd = m.end(); + continue; + } + + // Determine init range (the constructor arguments) + int initStart = -1; + int initEnd = -1; + + // Create MethodCallInfo for constructor validation if args present + MethodCallInfo constructorCall = null; + if (argsClause != null && !argsClause.isEmpty()) { + initStart = bodyOffset + m.start(2); // Position of '(' + initEnd = bodyOffset + m.end(2) - 1; // Position after ')' + + constructorCall = createConstructorCall( + enumType, + constantName, + absPos, + initStart, + initEnd + ); + } else if (enumType.hasConstructors()) { + // No args provided, but enum has constructors - validate against no-arg constructor + initStart = absPos + constantName.length(); + initEnd = initStart; + + constructorCall = createConstructorCall( + enumType, + constantName, + absPos, + initStart, + initEnd + ); + } + + + // Create FieldInfo for the enum constant + FieldInfo fieldInfo = FieldInfo.enumConstant( + constantName, + enumType, + absPos, + initStart, + initEnd, + null + ); + + EnumConstantInfo constantInfo = new EnumConstantInfo(fieldInfo, constructorCall, enumType); + fieldInfo.setEnumConstantInfo(constantInfo); + constants.add(constantInfo); + + lastEnd = m.end(); + } + + return constants; + } + + /** + * Create a MethodCallInfo for an enum constant's constructor call. + * Validates the arguments against available constructors. + */ + private static MethodCallInfo createConstructorCall( + ScriptTypeInfo enumType, + String constantName, + int constantStart, + int openParenPos, + int closeParenPos) { + + List constructors = enumType.getConstructors(); + + // Parse arguments - pass absolute positions (bodyOffset accounts for the offset into the document) + List arguments = ScriptDocument.INSTANCE.parseMethodArguments( + openParenPos + 1, + closeParenPos, + null + ); + + // Find matching constructor + MethodInfo matchedConstructor = null; + List candidates = new ArrayList<>(); + + for (MethodInfo constructor : constructors) { + candidates.add(constructor); + if (constructor.getParameterCount() == arguments.size()) { + matchedConstructor = constructor; + break; + } + } + + // Create MethodCallInfo + MethodCallInfo callInfo = new MethodCallInfo( + constantName, // Use constant name as "method" name + constantStart, + openParenPos, + openParenPos, + closeParenPos, + arguments, + enumType, // Receiver is the enum type + matchedConstructor + ); + + + callInfo.setConstructor(true); + callInfo.validate(); + return callInfo; + } + + /** + * Create EnumConstantInfo from a reflection-based enum constant. + * Used for enum constants from external libraries (via reflection). + * + * @param constantName The name of the enum constant + * @param enumType The enum type this constant belongs to + * @return EnumConstantInfo representing this constant, or null if not found + */ + public static EnumConstantInfo fromReflection(String constantName, TypeInfo enumType, Field javaField) { + if (enumType == null || enumType.getJavaClass() == null || !enumType.getJavaClass().isEnum()) { + return null; + } + + try { + FieldInfo fieldInfo = FieldInfo.enumConstant( + constantName, + enumType, + -1, // No declaration offset for reflection-based constants + -1, + -1, + javaField + ); + + EnumConstantInfo enumInfo = new EnumConstantInfo(fieldInfo, null, enumType); + fieldInfo.setEnumConstantInfo(enumInfo); + return enumInfo; + } catch (SecurityException e) { + // Constant not found or access denied + return null; + } + } + + /** + * Find where enum constants section ends. + * Returns the position of the first semicolon that's not inside parentheses, + * or the position of the first method/field declaration. + */ + private static int findEnumConstantsEnd(String bodyText) { + int parenDepth = 0; + boolean foundConstant = false; + + for (int i = 0; i < bodyText.length(); i++) { + char c = bodyText.charAt(i); + + if (c == '(') { + parenDepth++; + } else if (c == ')') { + parenDepth--; + } else if (c == ';' && parenDepth == 0) { + return i; + } else if (c == '{' && parenDepth == 0) { + // Start of method body - constants end before this + return findStatementStart(bodyText, i); + } + + // Track if we've found at least one identifier (potential constant) + if (Character.isJavaIdentifierStart(c)) { + foundConstant = true; + } + } + + // If we found constants but no semicolon, return the full length + return foundConstant ? bodyText.length() : -1; + } + + /** + * Find the start of a statement by going backwards from a position. + */ + private static int findStatementStart(String text, int fromPos) { + int pos = fromPos - 1; + int parenDepth = 0; + + while (pos >= 0) { + char c = text.charAt(pos); + if (c == ')') + parenDepth++; + else if (c == '(') + parenDepth--; + else if ((c == ',' || c == ';' || c == '{' || c == '}') && parenDepth == 0) { + return pos + 1; + } + pos--; + } + return 0; + } + + // ==================== GETTERS ==================== + + public FieldInfo getFieldInfo() { + return fieldInfo; + } + + public MethodCallInfo getConstructorCall() { + return constructorCall; + } + + public TypeInfo getEnumType() { + return enumType; + } + + public String getName() { + return fieldInfo.getName(); + } + + public int getDeclarationOffset() { + return fieldInfo.getDeclarationOffset(); + } + + /** + * Check if this enum constant has any errors (constructor mismatch, etc). + */ + public boolean hasError() { + return (constructorCall != null && constructorCall.hasError()); + } + + /** + * Get the error message if any. + */ + public String getErrorMessage() { + return null; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/field/FieldAccessInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/field/FieldAccessInfo.java new file mode 100644 index 000000000..fc87898f7 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/field/FieldAccessInfo.java @@ -0,0 +1,152 @@ +package noppes.npcs.client.gui.util.script.interpreter.field; + +import noppes.npcs.client.gui.util.script.interpreter.type.TypeChecker; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +/** + * Metadata for field access validation. + * Parallel to MethodCallInfo but for field accesses like `obj.field` or `Class.staticField`. + */ +public class FieldAccessInfo { + + /** + * Validation error type for field accesses. + */ + public enum ErrorType { + NONE, + TYPE_MISMATCH, // Field type doesn't match expected type (e.g., assignment LHS) + UNRESOLVED_FIELD, // Field doesn't exist on the receiver type + STATIC_ACCESS_ERROR // Trying to access instance field statically or vice versa + } + + private final String fieldName; + private final int fieldNameStart; + private final int fieldNameEnd; + private final TypeInfo receiverType; // The type on which this field is accessed + private final FieldInfo resolvedField; // The resolved field (null if unresolved) + private final boolean isStaticAccess; // True if this is Class.field style access + private TypeInfo expectedType; // Expected field type (from assignment LHS, etc.) + + private ErrorType errorType = ErrorType.NONE; + private String errorMessage; + + public FieldAccessInfo(String fieldName, int fieldNameStart, int fieldNameEnd, + TypeInfo receiverType, FieldInfo resolvedField, boolean isStaticAccess) { + this.fieldName = fieldName; + this.fieldNameStart = fieldNameStart; + this.fieldNameEnd = fieldNameEnd; + this.receiverType = receiverType; + this.resolvedField = resolvedField; + this.isStaticAccess = isStaticAccess; + } + + // Getters + public String getFieldName() { + return fieldName; + } + + public int getFieldNameStart() { + return fieldNameStart; + } + + public int getFieldNameEnd() { + return fieldNameEnd; + } + + public TypeInfo getReceiverType() { + return receiverType; + } + + public FieldInfo getResolvedField() { + return resolvedField; + } + + public boolean isStaticAccess() { + return isStaticAccess; + } + + public boolean isEnumConstantAccess() { + return resolvedField != null && resolvedField.isEnumConstant(); + } + + public TypeInfo getExpectedType() { + return expectedType; + } + + public void setExpectedType(TypeInfo expectedType) { + this.expectedType = expectedType; + } + + public ErrorType getErrorType() { + return errorType; + } + + public String getErrorMessage() { + return errorMessage; + } + + /** + * Validate this field access. + * Checks type compatibility with expected type. + */ + public void validate() { + // Check if field was resolved + if (resolvedField == null) { + setError(ErrorType.UNRESOLVED_FIELD, "Cannot resolve field '" + fieldName + "'"); + return; + } + + // Check return type compatibility with expected type (e.g., assignment LHS) + if (expectedType != null && resolvedField != null) { + TypeInfo fieldType = resolvedField.getTypeInfo(); + if (fieldType != null && !TypeChecker.isTypeCompatible(expectedType, fieldType)) { + //extra space is necessary for alignment + //setError(ErrorType.TYPE_MISMATCH, "Provided type: " + fieldType.getSimpleName()+ + //"\nRequired: " + expectedType.getSimpleName()); + } + } + } + + private void setError(ErrorType type, String message) { + this.errorType = type; + this.errorMessage = message; + } + + /** + * Check if this field access has any validation error. + */ + public boolean hasError() { + return errorType != ErrorType.NONE; + } + + /** + * Check if this is a type mismatch error. + */ + public boolean hasTypeMismatch() { + return errorType == ErrorType.TYPE_MISMATCH; + } + + /** + * Check if this is an unresolved field error. + */ + public boolean hasUnresolvedField() { + return errorType == ErrorType.UNRESOLVED_FIELD; + } + + /** + * Check if this is a static access error. + */ + public boolean hasStaticAccessError() { + return errorType == ErrorType.STATIC_ACCESS_ERROR; + } + + @Override + public String toString() { + return "FieldAccessInfo{" + + "fieldName='" + fieldName + "', " + + "receiverType=" + receiverType + ", " + + "resolvedField=" + resolvedField + ", " + + "errorType=" + errorType + + '}'; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/field/FieldInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/field/FieldInfo.java new file mode 100644 index 000000000..466f1d8c4 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/field/FieldInfo.java @@ -0,0 +1,616 @@ +package noppes.npcs.client.gui.util.script.interpreter.field; + +import noppes.npcs.client.gui.util.script.ScopeInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSFieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeRegistry; +import noppes.npcs.client.gui.util.script.interpreter.bridge.DtsJavaBridge; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocInfo; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenType; +import noppes.npcs.client.gui.util.script.interpreter.type.GenericContext; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeSubstitutor; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodCallInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; + +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +/** + * Metadata for a field (variable) declaration or reference. + * Tracks the field name, type, scope, and declaration location. + * Also tracks all assignments made to this field throughout the script. + */ +public final class FieldInfo { + + public enum Scope { + GLOBAL, // Class-level field + LOCAL, // Local variable inside a method + PARAMETER, // Method parameter + ENUM_CONSTANT // Enum constant value + } + + private final String name; + private final Scope scope; + private final TypeInfo declaredType; // The declared type (e.g., String, List) + private final int declarationOffset; // Where this field was declared in the source + private final boolean resolved; + private final String documentation; // Javadoc/comment documentation for this field + private JSDocInfo jsDocInfo; // Parsed JSDoc info for this method (may be null) + + // Initialization value range (for displaying "= value" in hover info) + private final int initStart; // Position of '=' or -1 if no initializer + private final int initEnd; // Position after initializer (before ';') or -1 + + // For local/parameter fields, track the containing method + private final MethodInfo containingMethod; + + // Modifiers for script-defined fields + private final int modifiers; // Java Modifier flags (e.g., Modifier.FINAL) + + // Reflection field for external types + private final Field reflectionField; + + private ScopeInfo scopeInfo; + + // Assignments to this field (populated after parsing) + private final List assignments = new ArrayList<>(); + + // Declaration assignment (for initial value validation) + private AssignmentInfo declarationAssignment; + + // Enum constant specific info + private EnumConstantInfo enumConstantInfo; + + private boolean isVarArg = false; + + // Type inference support (for JavaScript "any" typed variables) + // When a variable is declared without type (var x;), it starts as "any" but can be + // refined through assignments or JSDoc comments + private TypeInfo inferredType; + + private FieldInfo(String name, Scope scope, TypeInfo declaredType, + int declarationOffset, boolean resolved, MethodInfo containingMethod, + String documentation, int initStart, int initEnd, int modifiers, + Field reflectionField) { + this.name = name; + this.scope = scope; + this.declaredType = declaredType; + this.declarationOffset = declarationOffset; + this.resolved = resolved; + this.containingMethod = containingMethod; + this.documentation = documentation; + this.initStart = initStart; + this.initEnd = initEnd; + this.modifiers = modifiers; + this.reflectionField = reflectionField; + } + + // Factory methods + public static FieldInfo globalField(String name, TypeInfo type, int declOffset) { + return new FieldInfo(name, Scope.GLOBAL, type, declOffset, type != null && type.isResolved(), null, null, -1, + -1, 0, null); + } + + public static FieldInfo globalField(String name, TypeInfo type, int declOffset, String documentation) { + return new FieldInfo(name, Scope.GLOBAL, type, declOffset, type != null && type.isResolved(), null, + documentation, -1, -1, 0, null); + } + + public static FieldInfo globalField(String name, TypeInfo type, int declOffset, String documentation, int initStart, int initEnd) { + return new FieldInfo(name, Scope.GLOBAL, type, declOffset, type != null && type.isResolved(), null, + documentation, initStart, initEnd, 0, null); + } + + public static FieldInfo globalField(String name, TypeInfo type, int declOffset, String documentation, int initStart, + int initEnd, int modifiers) { + return new FieldInfo(name, Scope.GLOBAL, type, declOffset, type != null && type.isResolved(), null, + documentation, initStart, initEnd, modifiers, null); + } + + public static FieldInfo localField(String name, TypeInfo type, int declOffset, MethodInfo method) { + return new FieldInfo(name, Scope.LOCAL, type, declOffset, type != null && type.isResolved(), method, null, -1, + -1, 0, null); + } + + public static FieldInfo localField(String name, TypeInfo type, int declOffset, MethodInfo method, int initStart, int initEnd) { + return new FieldInfo(name, Scope.LOCAL, type, declOffset, type != null && type.isResolved(), method, null, + initStart, initEnd, 0, null); + } + + public static FieldInfo localField(String name, TypeInfo type, int declOffset, MethodInfo method, int initStart, + int initEnd, int modifiers) { + return new FieldInfo(name, Scope.LOCAL, type, declOffset, type != null && type.isResolved(), method, null, + initStart, initEnd, modifiers, null); + } + + public static FieldInfo parameter(String name, TypeInfo type, int declOffset, MethodInfo method) { + return new FieldInfo(name, Scope.PARAMETER, type, declOffset, type != null && type.isResolved(), method, null, + -1, -1, 0, null); + } + + public static FieldInfo unresolved(String name, Scope scope) { + return new FieldInfo(name, scope, null, -1, false, null, null, -1, -1, 0, null); + } + + /** + * Create a FieldInfo from reflection data for method parameters. + */ + public static FieldInfo reflectionParam(String name, TypeInfo type) { + return new FieldInfo(name, Scope.PARAMETER, type, -1, true, null, null, -1, -1, 0, null); + } + + /** + * Create a FieldInfo for a synthetic/external field. + * Used for built-in types like Nashorn's Java object. + */ + public static FieldInfo external(String name, TypeInfo type, String documentation, int modifiers) { + return new FieldInfo(name, Scope.GLOBAL, type, -1, true, null, documentation, -1, -1, modifiers, null); + } + + /** + * Create a FieldInfo from reflection data for a class field. + * Preserves generic type information like List. + */ + public static FieldInfo fromReflection(Field field, TypeInfo containingType) { + String name = field.getName(); + // Use getGenericType() to preserve generic information + TypeInfo type = TypeInfo.fromGenericType(field.getGenericType()); + if (type == null) { + type = TypeInfo.fromClass(field.getType()); + } + + // If the receiver is parameterized, substitute class type variables in the field type + if (GenericContext.hasGenerics(containingType)) { + Map receiverBindings = TypeSubstitutor.createBindingsFromReceiver(containingType); + if (!receiverBindings.isEmpty()) { + type = TypeSubstitutor.substitute(type, receiverBindings); + } + } + + // Check if this is an enum constant + if (field.isEnumConstant()) { + // Create enum constant FieldInfo + EnumConstantInfo constantInfo = EnumConstantInfo.fromReflection(name, containingType,field); + if (constantInfo != null) + return constantInfo.getFieldInfo(); + } + + // Try to find matching JSFieldInfo to bridge over documentation + JSFieldInfo jsField = DtsJavaBridge.findMatchingField(field, containingType); + String documentation = null; + JSDocInfo jsDocInfo = null; + if (jsField != null) { + jsDocInfo = jsField.getJsDocInfo(); + String jsDocDesc = jsDocInfo != null ? jsDocInfo.getDescription() : null; + documentation = jsDocDesc != null ? jsDocDesc : jsField.getDocumentation(); + } + + FieldInfo fieldInfo = new FieldInfo(name, Scope.GLOBAL, type, -1, true, null, documentation, -1, -1, field.getModifiers(), field); + if (jsDocInfo != null) { + fieldInfo.setJSDocInfo(jsDocInfo); + } + return fieldInfo; + } + + /** + * Create a FieldInfo from a JSFieldInfo (parsed from .d.ts files). + * Used when resolving field access on JavaScript types. + * + * @param jsField The JavaScript field info from the type registry + * @param containingType The TypeInfo that owns this field + * @return A FieldInfo representing the JavaScript field + */ + public static FieldInfo fromJSField(JSFieldInfo jsField, TypeInfo containingType) { + String name = jsField.getName(); + + TypeInfo type = jsField.getResolvedType(containingType); + if (type == null || !type.isResolved()) { + type = resolveJSType(jsField.getType()); + } + + // JS fields are public by default, readonly maps to final + int modifiers = Modifier.PUBLIC; + if (jsField.isReadonly()) { + modifiers |= Modifier.FINAL; + } + if (jsField.isStatic()) { + modifiers |= Modifier.STATIC; + } + + // Use documentation if available + JSDocInfo jsDocInfo = jsField.getJsDocInfo(); + String jsDocDesc = jsDocInfo != null ? jsDocInfo.getDescription() : null; + String documentation = jsDocDesc != null ? jsDocDesc : jsField.getDocumentation(); + + FieldInfo fieldInfo = new FieldInfo(name, Scope.GLOBAL, type, -1, true, null, documentation, -1, -1, modifiers, null); + fieldInfo.setJSDocInfo(jsDocInfo); + return fieldInfo; + } + + /** + * Resolves a JavaScript type name to a TypeInfo. + * Handles primitives, mapped types, and custom types from the registry. + */ + private static TypeInfo resolveJSType(String jsTypeName) { + if (jsTypeName == null || jsTypeName.isEmpty() || "void".equals(jsTypeName)) { + return TypeInfo.fromPrimitive("void"); + } + + // Handle JS primitives + switch (jsTypeName) { + case "string": + return TypeInfo.fromClass(String.class); + case "number": + return TypeInfo.fromClass(double.class); + case "boolean": + return TypeInfo.fromClass(boolean.class); + case "any": + return TypeInfo.fromClass(Object.class); + case "void": + return TypeInfo.fromPrimitive("void"); + } + + // Handle array types + if (jsTypeName.endsWith("[]")) { + String elementType = jsTypeName.substring(0, jsTypeName.length() - 2); + TypeInfo elementTypeInfo = resolveJSType(elementType); + return TypeInfo.arrayOf(elementTypeInfo); + } + + // Try to resolve from the JS type registry + JSTypeRegistry registry = JSTypeRegistry.getInstance(); + if (registry != null) { + JSTypeInfo jsTypeInfo = registry.getType(jsTypeName); + if (jsTypeInfo != null) { + return TypeInfo.fromJSTypeInfo(jsTypeInfo); + } + } + + // Fallback: unresolved type + return TypeInfo.unresolved(jsTypeName, jsTypeName); + } + + /** + * Create a FieldInfo for an enum constant. + * @param name The constant name (e.g., "NORTH") + * @param type The enum type itself + * @param declOffset The declaration position + * @param initStart The position of '(' if args present, else -1 + * @param initEnd The position after ')' if args present, else -1 + */ + public static FieldInfo enumConstant(String name, TypeInfo type, int declOffset, int initStart, int initEnd,Field javaField) { + // Enum constants are implicitly public static final + int modifiers = Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL; + return new FieldInfo(name, Scope.ENUM_CONSTANT, type, declOffset, true, null, null, initStart, initEnd, + modifiers, javaField); + } + + // ==================== ENUM HANDLING ==================== + + public void setEnumConstantInfo(EnumConstantInfo enumConstantInfo) { + this.enumConstantInfo = enumConstantInfo; + } + + public EnumConstantInfo getEnumInfo() { + return enumConstantInfo; + } + /** + * Check if this is an enum constant. + */ + public boolean isEnumConstant() { + return scope == Scope.ENUM_CONSTANT; + } + + + // ==================== ASSIGNMENT MANAGEMENT ==================== + + /** + * Add an assignment to this field. + */ + public void addAssignment(AssignmentInfo assignment) { + assignments.add(assignment); + } + + /** + * Get all assignments to this field (unmodifiable). + */ + public List getAssignments() { + return Collections.unmodifiableList(assignments); + } + + /** + * Set the declaration assignment (initial value assignment). + */ + public void setDeclarationAssignment(AssignmentInfo assignment) { + this.declarationAssignment = assignment; + } + + /** + * Get the declaration assignment (initial value assignment). + * Returns null if there was no initializer or it hasn't been validated yet. + */ + public AssignmentInfo getDeclarationAssignment() { + return declarationAssignment; + } + + /** + * Find an assignment that contains the given position. + * Returns null if no assignment contains this position. + * Prioritizes LHS matches over RHS matches. + */ + public AssignmentInfo findAssignmentAtPosition(int position) { + // Check declaration assignment first + if (declarationAssignment != null && declarationAssignment.containsPosition(position)) { + // Prioritize LHS match + if (declarationAssignment.containsLhsPosition(position)) { + return declarationAssignment; + } + } + + // Check other assignments for LHS matches first (more specific) + for (AssignmentInfo assign : assignments) { + if (assign.containsLhsPosition(position)) { + return assign; + } + } + + // Then check RHS matches (less specific - might just be a reference in the value) + if (declarationAssignment != null && declarationAssignment.containsRhsPosition(position)) { + return declarationAssignment; + } + + for (AssignmentInfo assign : assignments) { + if (assign.containsRhsPosition(position)) { + return assign; + } + } + + return null; + } + + /** + * Get all errored assignments for this field. + */ + public List getErroredAssignments() { + List errored = new ArrayList<>(); + + // Include declaration assignment if it has an error + if (declarationAssignment != null && declarationAssignment.hasError()) { + errored.add(declarationAssignment); + } + + // Include all other assignments with errors + for (AssignmentInfo assign : assignments) { + if (assign.hasError()) { + errored.add(assign); + } + } + return errored; + } + + /** + * Clear all assignments (for re-parsing). + */ + public void clearAssignments() { + assignments.clear(); + declarationAssignment = null; + } + + // ==================== MODIFIER CHECKS ==================== + + /** + * Check if this field is declared as final. + * Works for both script-defined fields (via modifiers) and reflection fields. + */ + public boolean isFinal() { + if (reflectionField != null) + return Modifier.isFinal(reflectionField.getModifiers()); + + return Modifier.isFinal(modifiers); + } + + /** + * Check if this field is declared as static. + */ + public boolean isStatic() { + if (reflectionField != null) + return Modifier.isStatic(reflectionField.getModifiers()); + + return Modifier.isStatic(modifiers); + } + + /** + * Check if this field is declared as private. + */ + public boolean isPrivate() { + if (reflectionField != null) + return Modifier.isPrivate(reflectionField.getModifiers()); + + return Modifier.isPrivate(modifiers); + } + + /** + * Check if this field is declared as protected. + */ + public boolean isProtected() { + if (reflectionField != null) + return Modifier.isProtected(reflectionField.getModifiers()); + + return Modifier.isProtected(modifiers); + } + + /** + * Check if this field is declared as public. + */ + public boolean isPublic() { + if (reflectionField != null) + return Modifier.isPublic(reflectionField.getModifiers()); + + return Modifier.isPublic(modifiers); + } + + /** + * Get the raw modifiers value. + */ + public int getModifiers() { + if (reflectionField != null) + return reflectionField.getModifiers(); + + return modifiers; + } + + /** + * Get the reflection field, if available. + */ + public java.lang.reflect.Field getReflectionField() { + return reflectionField; + } + + // ==================== TYPE INFERENCE ==================== + + /** + * Get the inferred type for this field. + * This is set when a variable declared as "any" has its type refined through + * assignment analysis or JSDoc comments. + */ + public TypeInfo getInferredType() { + return inferredType; + } + + /** + * Set the inferred type for this field. + * Used when type inference determines a more specific type than the declared type. + * @param inferredType The refined type based on assignments or JSDoc + */ + public void setVarArg(boolean isVarArg) { this.isVarArg = isVarArg; } + public boolean isVarArg() { return isVarArg; } + + public void setInferredType(TypeInfo inferredType) { + this.inferredType = inferredType; + } + + /** + * Check if this field has a type that can be refined (currently "any" type). + */ + public boolean canInferType() { + return declaredType != null && "any".equals(declaredType.getFullName()); + } + + /** + * Get the effective type for this field, considering inference. + * Returns inferredType if available, otherwise declaredType. + */ + public TypeInfo getEffectiveType() { + if (inferredType != null) { + return inferredType; + } + return declaredType; + } + + // ==================== BASIC GETTERS ==================== + + public String getName() { return name; } + public Scope getScope() { return scope; } + public TypeInfo getDeclaredType() { return declaredType; } + public TypeInfo getTypeInfo() { + // Return the effective type (inferred if available, otherwise declared) + return getEffectiveType(); + } + public int getDeclarationOffset() { return declarationOffset; } + public boolean isResolved() { + // Check if we have any resolved type (declared or inferred) + TypeInfo effectiveType = getEffectiveType(); + return effectiveType != null && effectiveType.isResolved(); + } + public MethodInfo getContainingMethod() { return containingMethod; } + public String getDocumentation() { return documentation; } + public JSDocInfo getJSDocInfo() { return jsDocInfo; } + public void setJSDocInfo(JSDocInfo jsDocInfo) { this.jsDocInfo = jsDocInfo; } + public int getInitStart() { return initStart; } + public int getInitEnd() { return initEnd; } + public boolean hasInitializer() { return initStart >= 0 && initEnd > initStart; } + + public boolean isGlobal() { return scope == Scope.GLOBAL; } + public boolean isLocal() { return scope == Scope.LOCAL; } + public boolean isParameter() { return scope == Scope.PARAMETER; } + + /** + * Check if a reference at the given position can see this field. + * For local variables, they're only visible after their declaration. + */ + public boolean isVisibleAt(int position) { + if (scopeInfo != null && !scopeInfo.containsPosition(position)) { + return false; + } + if (scope == Scope.GLOBAL || scope == Scope.PARAMETER) { + return true; // Always visible in their scope + } + // Local variables are only visible after declaration + return position >= declarationOffset; + } + + public ScopeInfo getScopeInfo() { return scopeInfo; } + public void setScopeInfo(ScopeInfo scopeInfo) { this.scopeInfo = scopeInfo; } + + /** + * Get the appropriate TokenType for highlighting this field. + */ + public TokenType getTokenType() { + if (!resolved) { + return TokenType.UNDEFINED_VAR; + } + switch (scope) { + case GLOBAL: + // Static final fields get special highlighting + if (isStatic() && isFinal()) { + return TokenType.STATIC_FINAL_FIELD; + } + return TokenType.GLOBAL_FIELD; + case LOCAL: + return TokenType.LOCAL_FIELD; + case PARAMETER: + return TokenType.PARAMETER; + case ENUM_CONSTANT: + return TokenType.ENUM_CONSTANT; + default: + return TokenType.VARIABLE; + } + } + + @Override + public String toString() { + return "FieldInfo{" + name + ", " + scope + ", type=" + declaredType + ", final=" + isFinal() + "}"; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + FieldInfo fieldInfo = (FieldInfo) o; + return name.equals(fieldInfo.name) && scope == fieldInfo.scope; + } + + @Override + public int hashCode() { + return name.hashCode() * 31 + scope.ordinal(); + } + + /** + * Wrapper class that holds both FieldInfo and MethodCallInfo for a variable usage. + * This is used when a variable is used as an argument to a method call. + */ + public static class ArgInfo { + public final FieldInfo fieldInfo; + public final MethodCallInfo methodCallInfo; + + public ArgInfo(FieldInfo fieldInfo, MethodCallInfo methodCallInfo) { + this.fieldInfo = fieldInfo; + this.methodCallInfo = methodCallInfo; + } + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/hover/GutterIconRenderer.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/hover/GutterIconRenderer.java new file mode 100644 index 000000000..3c5087533 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/hover/GutterIconRenderer.java @@ -0,0 +1,304 @@ +package noppes.npcs.client.gui.util.script.interpreter.hover; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.Gui; +import net.minecraft.util.ResourceLocation; +import noppes.npcs.client.ClientProxy; +import noppes.npcs.client.gui.util.GuiUtil; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenType; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import org.lwjgl.opengl.GL11; + +import java.util.ArrayList; +import java.util.List; + +/** + * Renders gutter icons for method inheritance (override/implements) in the script editor. + * + * Renders IntelliJ-style tooltips when hovering over gutter icons: + * - Background + border matching TokenHoverRenderer style + * - Colored declaration showing which class/interface the method overrides/implements + * - Uses the same token highlighting system for type names + */ +public class GutterIconRenderer { + + // ==================== CONSTANTS ==================== + + /** Texture resource for script icons (64x32: first 32x32 = override, second 32x32 = implements) */ + private static final ResourceLocation SCRIPT_ICONS = new ResourceLocation("customnpcs", + "textures/gui/script/icons.png"); + + /** Icon size when rendered in the gutter (scaled from 32x32) */ + private static final int GUTTER_ICON_SIZE = 10; + + /** Extra gutter width to accommodate inheritance icons */ + public static final int ICON_GUTTER_WIDTH = 12; + + /** Padding inside the tooltip box */ + private static final int PADDING = 6; + + /** Line spacing between rows */ + private static final int LINE_SPACING = 2; + + /** Vertical offset from mouse */ + private static final int VERTICAL_OFFSET = 10; + + // ==================== COLORS ==================== + + /** Background color (dark gray like IntelliJ) */ + private static final int BG_COLOR = 0xF0313335; + + /** Border color */ + private static final int BORDER_COLOR = 0xFF3C3F41; + + /** Info text color */ + private static final int INFO_COLOR = 0xFFA9B7C6; + + // ==================== RENDERING ==================== + + /** + * Render gutter icons for a range of lines. + * + * @param lineHeight Height of each line + * @param gutterX X position for the icon in the gutter + * @param gutterY Base Y position of the gutter + * @param renderStart First line index to render + * @param renderEnd Last line index to render + * @param scrolledLine Current scroll position + * @param stringYOffset Y offset for text positioning + * @param methods All methods in the document + * @param lines Line data for position calculation + * @param xMouse Mouse X position + * @param yMouse Mouse Y position + * @param fracPixels Fractional scroll offset + * @return The hovered method, or null if no icon is hovered + */ + public static MethodInfo renderIcons( + int lineHeight, + int gutterX, + int gutterY, + int renderStart, + int renderEnd, + int scrolledLine, + int stringYOffset, + List methods, + List lines, + int xMouse, + int yMouse, + float fracPixels) { + + if (methods == null || methods.isEmpty()) + return null; + + MethodInfo hoveredMethod = null; + float adjustedMouseY = yMouse + fracPixels; + + for (int lineIndex = renderStart; lineIndex <= renderEnd; lineIndex++) { + MethodInfo method = getMethodAtLine(lineIndex, methods, lines); + if (method == null || !method.hasInheritanceMarker()) + continue; + + int posY = gutterY + (lineIndex - scrolledLine) * lineHeight + stringYOffset; + int iconY = posY + (lineHeight - GUTTER_ICON_SIZE) / 2 - 1; + + // Draw the icon + renderIcon(gutterX, iconY, method.isOverride()); + + // Check for hover + int iconScaleOffsetX = -4; + int screenPosY = gutterY + (lineIndex - scrolledLine) * lineHeight; + if (xMouse >= gutterX + iconScaleOffsetX && xMouse < gutterX + GUTTER_ICON_SIZE + iconScaleOffsetX && + adjustedMouseY >= screenPosY && adjustedMouseY < screenPosY + lineHeight) { + hoveredMethod = method; + } + } + + return hoveredMethod; + } + + /** + * Render a single gutter icon. + */ + private static void renderIcon(int x, int y, boolean isOverride) { + int iconU = isOverride ? 0 : 32; + + Minecraft.getMinecraft().renderEngine.bindTexture(SCRIPT_ICONS); + GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f); + + GL11.glPushMatrix(); + float scale = 2.0f, scaleOffsetX = -4, scaleOffsetY = -3.25f; + GL11.glScalef(scale, scale, scale); + GL11.glTranslatef(scaleOffsetX, scaleOffsetY, 0); + GuiUtil.drawScaledTexturedRect( + (int) (x / scale), (int) (y / scale), + iconU, 0, 32, 32, + GUTTER_ICON_SIZE, GUTTER_ICON_SIZE, + 64, 32 + ); + GL11.glPopMatrix(); + } + + /** + * Render the tooltip for a hovered gutter icon. + */ + public static void renderTooltip(MethodInfo method, int mouseX, int mouseY, int viewportX, int viewportWidth, + int viewportY, int viewportHeight) { + if (method == null) + return; + + // Build tooltip content + List segments = buildTooltipContent(method); + if (segments.isEmpty()) + return; + + int lineHeight = ClientProxy.Font.height(); + + // Calculate dimensions + int contentWidth = calculateContentWidth(segments); + int contentHeight = lineHeight; + int boxWidth = contentWidth + PADDING * 2; + int boxHeight = contentHeight + PADDING * 2; + + // Position tooltip + int tooltipX = mouseX + VERTICAL_OFFSET; + int tooltipY = mouseY - 5; + + // Clamp to viewport + int rightBound = viewportX + viewportWidth; + int bottomBound = viewportY + viewportHeight; + + if (tooltipX + boxWidth > rightBound) { + tooltipX = mouseX - boxWidth - 5; + } + if (tooltipX < viewportX) { + tooltipX = viewportX; + } + + if (tooltipY + boxHeight > bottomBound) { + tooltipY = bottomBound - boxHeight; + } + if (tooltipY < viewportY) { + tooltipY = viewportY; + } + + // Render tooltip box + renderTooltipBox(tooltipX, tooltipY, boxWidth, boxHeight, segments); + } + + // ==================== PRIVATE HELPERS ==================== + + /** + * Get the method that starts on the given line. + */ + private static MethodInfo getMethodAtLine(int lineIndex, List methods, List lines) { + if (lineIndex < 0 || lineIndex >= lines.size()) + return null; + + Object lineObj = lines.get(lineIndex); + int lineStart, lineEnd; + + try { + java.lang.reflect.Field startField = lineObj.getClass().getField("start"); + java.lang.reflect.Field endField = lineObj.getClass().getField("end"); + lineStart = startField.getInt(lineObj); + lineEnd = endField.getInt(lineObj); + } catch (Exception e) { + return null; + } + + for (MethodInfo method : methods) { + if (!method.hasInheritanceMarker()) + continue; + int nameOffset = method.getNameOffset(); + if (nameOffset >= lineStart && nameOffset < lineEnd) { + return method; + } + } + + return null; + } + + /** + * Build the tooltip content as colored text segments. + */ + private static List buildTooltipContent(MethodInfo method) { + List segments = new ArrayList<>(); + + if (method.isOverride()) { + TypeInfo overridesFrom = method.getOverridesFrom(); + segments.add(new TextSegment("Overrides method in ", INFO_COLOR)); + + if (overridesFrom != null) { + int color = TokenType.getColor(overridesFrom); + segments.add(new TextSegment(overridesFrom.getSimpleName(), color)); + } else { + segments.add(new TextSegment("parent class", INFO_COLOR)); + } + } else if (method.isImplements()) { + TypeInfo implementsFrom = method.getImplementsFrom(); + segments.add(new TextSegment("Implements method from ", INFO_COLOR)); + + if (implementsFrom != null) { + int color = TokenType.getColor(implementsFrom); + segments.add(new TextSegment(implementsFrom.getSimpleName(), color)); + } else { + segments.add(new TextSegment("interface", INFO_COLOR)); + } + } + + return segments; + } + + /** + * Calculate the width needed for the segments. + */ + private static int calculateContentWidth(List segments) { + int totalWidth = 0; + for (TextSegment segment : segments) { + totalWidth += ClientProxy.Font.width(segment.text); + } + return totalWidth; + } + + /** + * Render the tooltip box with background, border, and content. + */ + private static void renderTooltipBox(int x, int y, int width, int height, List segments) { + GL11.glDisable(GL11.GL_SCISSOR_TEST); + + // Draw background + int paddedHeight = y + height - 4; + Gui.drawRect(x, y, x + width, paddedHeight, BG_COLOR); + + // Draw border + Gui.drawRect(x, y, x + width, y + 1, BORDER_COLOR); // Top + Gui.drawRect(x, paddedHeight - 1, x + width, paddedHeight, BORDER_COLOR); // Bottom + Gui.drawRect(x, y, x + 1, paddedHeight, BORDER_COLOR); // Left + Gui.drawRect(x + width - 1, y, x + width, paddedHeight, BORDER_COLOR); // Right + + // Draw text segments + int currentX = x + PADDING; + int currentY = y + PADDING; + + for (TextSegment segment : segments) { + ClientProxy.Font.drawString(segment.text, currentX, currentY, 0xFF000000 | segment.color); + currentX += ClientProxy.Font.width(segment.text); + } + } + + // ==================== DATA CLASSES ==================== + + /** + * A colored text segment. + */ + private static class TextSegment { + final String text; + final int color; + + TextSegment(String text, int color) { + this.text = text; + this.color = color; + } + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/hover/HoverState.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/hover/HoverState.java new file mode 100644 index 000000000..7618561c5 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/hover/HoverState.java @@ -0,0 +1,558 @@ +package noppes.npcs.client.gui.util.script.interpreter.hover; + +import noppes.npcs.client.gui.util.script.interpreter.ScriptDocument; +import noppes.npcs.client.gui.util.script.interpreter.ScriptLine; +import noppes.npcs.client.gui.util.script.interpreter.token.Token; + +/** + * Manages the hover state for token tooltips in the script editor. + * + * Tracks: + * - Current mouse position + * - Hovered token (if any) + * - Hover duration for delayed tooltip display + * - Whether tooltip should be visible + * + * Implements a 500ms delay before showing tooltips, resetting when + * the mouse moves to a different token. + */ +public class HoverState { + + /** Minimum hover time (ms) before showing tooltip */ + private static final long HOVER_DELAY_MS = 100; + + // ==================== STATE ==================== + + /** Currently hovered token (null if none) */ + private Token hoveredToken; + + /** Time when hover on current token started */ + private long hoverStartTime; + + /** Whether the tooltip should currently be displayed */ + private boolean tooltipVisible; + + /** Cached hover info for the current token */ + private TokenHoverInfo hoverInfo; + + /** Last known mouse position */ + private int lastMouseX; + private int lastMouseY; + + /** Position of the hovered token (for tooltip positioning) */ + private int tokenScreenX; + private int tokenScreenY; + private int tokenWidth; + + /** Tooltip bounding box (set after each render frame, used for mouse-over detection) */ + private int tooltipBoxX, tooltipBoxY, tooltipBoxWidth, tooltipBoxHeight; + + /** Also store the actual tooltip panel rect (not including the token-gap extension) */ + private int tooltipPanelX, tooltipPanelY, tooltipPanelW, tooltipPanelH; + + /** Scrollbar thumb rect (set each render frame, used for drag/hover detection) */ + private int scrollbarThumbX, scrollbarThumbY, scrollbarThumbH; + private int scrollbarX; + private int scrollbarTrackTop; + private int scrollbarTrackHeight; + private boolean isDraggingScrollbar; + private int dragStartMouseY; + private int dragStartScrollOffset; + + /** Tooltip panel drag state */ + private boolean isDraggingTooltip; + private int tooltipDragOffsetX, tooltipDragOffsetY; + private boolean tooltipPositionOverridden; + private int overriddenTooltipX, overriddenTooltipY; + + /** Tooltip panel resize state */ + private boolean isResizingTooltip; + private int resizeInitMouseX, resizeInitMouseY; + private int resizeInitW, resizeInitH; + private boolean tooltipSizeOverridden; + private int overriddenTooltipW, overriddenTooltipH; + /** Minimum tooltip dimensions when user-resized */ + private static final int MIN_TOOLTIP_W = 80; + private static final int MIN_TOOLTIP_H = 30; + + /** Smooth scroll: target offset (pixels), current is animated toward it each frame */ + private float targetScrollOffset; + /** Vertical scroll offset for tooltip content (pixels) */ + private float tooltipScrollOffsetF; + + /** Maximum scroll offset = totalContentHeight - visibleContentHeight (pixels) */ + private int tooltipMaxScroll; + /** Pinned token (set when user clicks a token to keep tooltip open) */ + private Token pinnedToken; + private TokenHoverInfo pinnedHoverInfo; + + /** Whether click-to-pin behaviour is enabled for this hover state. */ + private boolean clickToPinEnabled = true; + + // ==================== UPDATE ==================== + + /** + * Update the hover state based on current mouse position. + * Should be called every frame from drawTextBox. + * + * @param mouseX Current mouse X position + * @param mouseY Current mouse Y position + * @param document The script document + * @param viewportX X position of the text viewport (after gutter) + * @param viewportY Y position of the text viewport + * @param viewportWidth Width of the text viewport + * @param viewportHeight Height of the text viewport + * @param scrollOffset Current vertical scroll offset (in lines) + * @param lineHeight Height of each line in pixels + * @param gutterWidth Width of the line number gutter + */ + public void update(int mouseX, int mouseY, ScriptDocument document, + int viewportX, int viewportY, int viewportWidth, int viewportHeight, + float scrollOffset, int lineHeight, int gutterWidth) { + + lastMouseX = mouseX; + lastMouseY = mouseY; + + // Check if mouse is within the text viewport + if (mouseX < viewportX || mouseX > viewportX + viewportWidth || + mouseY < viewportY || mouseY > viewportY + viewportHeight) { + clearHover(); + return; + } + + if (document == null) { + clearHover(); + return; + } + + // Calculate which line the mouse is over + int relativeY = mouseY - viewportY; + int lineIndex = (int) (scrollOffset + (relativeY / (float) lineHeight)); + + // Get the line + ScriptLine line = null; + for (ScriptLine l : document.getLines()) { + if (l.getLineIndex() == lineIndex) { + line = l; + break; + } + } + + if (line == null) { + clearHover(); + return; + } + + // Calculate character position within the line + int relativeX = mouseX - viewportX; + int globalPos = line.getGlobalStart() + getCharacterIndexAtX(line, relativeX); + + // Find the token at this position + Token token = line.getTokenAt(globalPos); + + if (token == null) { + clearHover(); + return; + } + + // Check if this is a new token + if (token != hoveredToken) { + // New token - reset timer + hoveredToken = token; + hoverStartTime = System.currentTimeMillis(); + tooltipVisible = false; + hoverInfo = null; + + resetTooltipScroll(); + // Calculate token screen position for tooltip + calculateTokenPosition(line, token, viewportX, viewportY, scrollOffset, lineHeight); + } else { + // Same token - check if delay has elapsed + long elapsed = System.currentTimeMillis() - hoverStartTime; + if (elapsed >= HOVER_DELAY_MS && !tooltipVisible) { + tooltipVisible = true; + hoverInfo = TokenHoverInfo.fromToken(token); + } + } + } + + /** + * Update the hover state with a specific token. + * Simplified version for when the token has already been found. + * + * @param mouseX Current mouse X position + * @param mouseY Current mouse Y position + * @param token The token at the mouse position (or null if none) + * @param tokenX Screen X position of the token + * @param tokenY Screen Y position of the token + * @param tokenW Width of the token in pixels + */ + public void update(int mouseX, int mouseY, Token token, int tokenX, int tokenY, int tokenW) { + lastMouseX = mouseX; + lastMouseY = mouseY; + clickToPinEnabled=false; + // If a token has been pinned by click, ignore mouse movement updates + if (pinnedToken != null) { + // keep pinned tooltip visible + tooltipVisible = true; + hoverInfo = pinnedHoverInfo; + return; + } + + if (token == null) { + clearHover(); + return; + } + + // Check if this is a new token + if (token != hoveredToken) { + // New token - reset timer + hoveredToken = token; + hoverStartTime = System.currentTimeMillis(); + tooltipVisible = false; + hoverInfo = null; + + resetTooltipScroll(); + // Store token position + tokenScreenX = tokenX; + tokenScreenY = tokenY; + tokenWidth = tokenW; + } else { + // Same token - check if delay has elapsed + long elapsed = System.currentTimeMillis() - hoverStartTime; + if (elapsed >= HOVER_DELAY_MS && !tooltipVisible) { + tooltipVisible = true; + hoverInfo = TokenHoverInfo.fromToken(token); + } + } + } + + /** + * Clear the current hover state. + */ + public void clearHover() { + if (hoveredToken != null) { + hoveredToken = null; + hoverStartTime = 0; + // Do not clear tooltipInfo here if pinned; if not pinned, hide tooltip. + if (pinnedToken == null) { + tooltipVisible = false; + hoverInfo = null; + tooltipBoxX = tooltipBoxY = tooltipBoxWidth = tooltipBoxHeight = 0; + tooltipPanelX = tooltipPanelY = tooltipPanelW = tooltipPanelH = 0; + isDraggingScrollbar = false; + isDraggingTooltip = false; + tooltipPositionOverridden = false; + isResizingTooltip = false; + tooltipSizeOverridden = false; + tooltipScrollOffsetF = 0; + targetScrollOffset = 0; + tooltipMaxScroll = 0; + isDraggingScrollbar = false; + } + } + } + + /** + * Force the tooltip to hide (e.g., when clicking). + */ + public void hideTooltip() { + tooltipVisible = false; + } + + /** + * Enable or disable click-to-pin behaviour. + */ + public void setClickToPinEnabled(boolean enabled) { + this.clickToPinEnabled = enabled; + } + + public boolean isClickToPinEnabled() { + return clickToPinEnabled; + } + + /** + * Pin a token so its tooltip stays visible until explicitly unpinned. + */ + public void pinToken(Token token, int tokenX, int tokenY, int tokenW) { + if (token == null) return; + this.pinnedToken = token; + this.pinnedHoverInfo = TokenHoverInfo.fromToken(token); + this.tooltipVisible = pinnedHoverInfo != null && pinnedHoverInfo.hasContent(); + this.tokenScreenX = tokenX; + this.tokenScreenY = tokenY; + this.tokenWidth = tokenW; + // ensure hoveredToken reflects pinned token + this.hoveredToken = token; + } + + /** + * Unpin any pinned token and hide tooltip. + */ + public void unpin() { + this.pinnedToken = null; + this.pinnedHoverInfo = null; + this.tooltipVisible = false; + this.hoverInfo = null; + } + + public boolean isPinned() { return pinnedToken != null; } + + // ==================== POSITION CALCULATION ==================== + + /** + * Get the character index within a line at the given X pixel position. + */ + private int getCharacterIndexAtX(ScriptLine line, int x) { + String text = line.getText(); + if (text == null || text.isEmpty()) return 0; + + int accumWidth = 0; + for (int i = 0; i < text.length(); i++) { + int charWidth = noppes.npcs.client.ClientProxy.Font.width(String.valueOf(text.charAt(i))); + if (accumWidth + charWidth / 2 > x) { + return i; + } + accumWidth += charWidth; + } + return text.length(); + } + + /** + * Calculate the screen position of a token for tooltip positioning. + */ + private void calculateTokenPosition(ScriptLine line, Token token, + int viewportX, int viewportY, + float scrollOffset, int lineHeight) { + // X position: calculate width of text before the token + String lineText = line.getText(); + int tokenLocalStart = token.getGlobalStart() - line.getGlobalStart(); + tokenLocalStart = Math.max(0, Math.min(tokenLocalStart, lineText.length())); + + String textBefore = lineText.substring(0, tokenLocalStart); + tokenScreenX = viewportX + noppes.npcs.client.ClientProxy.Font.width(textBefore); + + // Y position: line position minus scroll + int lineY = line.getLineIndex(); + tokenScreenY = viewportY + (int) ((lineY - scrollOffset) * lineHeight); + + // Token width + tokenWidth = noppes.npcs.client.ClientProxy.Font.width(token.getText()); + } + + public void setTooltipBounds(int x, int y, int width, int height) { + tooltipBoxX = x; + tooltipBoxY = y; + tooltipBoxWidth = width; + tooltipBoxHeight = height; + } + + public void setTooltipMaxScroll(int maxScroll) { + this.tooltipMaxScroll = Math.max(0, maxScroll); + } + + public boolean isMouseOverTooltip(int mouseX, int mouseY) { + if (!tooltipVisible || tooltipBoxWidth <= 0) return false; + return mouseX >= tooltipBoxX && mouseX <= tooltipBoxX + tooltipBoxWidth + && mouseY >= tooltipBoxY && mouseY <= tooltipBoxY + tooltipBoxHeight; + } + + public void scrollTooltip(int wheelDelta) { + // LWJGL wheelDelta: positive = scrolled up (content should move up = offset increases) + // Divide by 2 for sensitivity; negate to match expected direction + targetScrollOffset = Math.max(0, Math.min(tooltipMaxScroll, targetScrollOffset - wheelDelta / 5.0f)); + } + + public int getTooltipScrollOffset() { + return (int) tooltipScrollOffsetF; + } + + public void resetTooltipScroll() { + tooltipScrollOffsetF = 0; + targetScrollOffset = 0; + } + + /** Lerp current offset toward target. Call every frame while tooltip is visible. */ + public void updateSmoothScroll() { + float diff = targetScrollOffset - tooltipScrollOffsetF; + if (Math.abs(diff) < 0.5f) { + tooltipScrollOffsetF = targetScrollOffset; + } else { + tooltipScrollOffsetF += diff * 0.04f; + } + } + + /** Called by renderer each frame to store thumb bounds for drag/hover detection. */ + public void setScrollbarThumb(int barX, int thumbY, int thumbH, int trackTop, int trackHeight) { + scrollbarX = barX; + scrollbarThumbX = barX; + scrollbarThumbY = thumbY; + scrollbarThumbH = thumbH; + scrollbarTrackTop = trackTop; + scrollbarTrackHeight = trackHeight; + } + + public boolean isMouseOverScrollbarThumb(int mx, int my) { + if (!tooltipVisible || scrollbarThumbH <= 0) return false; + return mx >= scrollbarX && mx <= scrollbarX + 3 + && my >= scrollbarThumbY && my <= scrollbarThumbY + scrollbarThumbH; + } + + public void startScrollbarDrag(int mouseY) { + isDraggingScrollbar = true; + dragStartMouseY = mouseY; + dragStartScrollOffset = (int) tooltipScrollOffsetF; + } + + public void updateScrollbarDrag(int mouseY) { + if (!isDraggingScrollbar || scrollbarTrackHeight <= 0 || tooltipMaxScroll <= 0) return; + float scrollRatio = (float) (scrollbarTrackHeight) / Math.max(1, scrollbarTrackHeight + tooltipMaxScroll); + int thumbH = Math.max(6, (int)(scrollbarTrackHeight * scrollRatio)); + int effectiveTrack = scrollbarTrackHeight - thumbH; + if (effectiveTrack <= 0) return; + int deltaY = mouseY - dragStartMouseY; + float scrollDelta = (float) deltaY / effectiveTrack * tooltipMaxScroll; + targetScrollOffset = Math.max(0, Math.min(tooltipMaxScroll, dragStartScrollOffset + scrollDelta)); + tooltipScrollOffsetF = targetScrollOffset; // snap during drag + } + + public void releaseScrollbarDrag() { + isDraggingScrollbar = false; + } + + // ==================== TOOLTIP PANEL DRAG ==================== + + /** Record the actual rendered tooltip panel rect (used for drag hit-testing). */ + public void setTooltipPanel(int x, int y, int w, int h) { + tooltipPanelX = x; + tooltipPanelY = y; + tooltipPanelW = w; + tooltipPanelH = h; + } + + public boolean isMouseOverTooltipPanel(int mx, int my) { + if (!tooltipVisible || tooltipPanelW <= 0) return false; + return mx >= tooltipPanelX && mx <= tooltipPanelX + tooltipPanelW + && my >= tooltipPanelY && my <= tooltipPanelY + tooltipPanelH; + } + + public int getTooltipPanelX() { return tooltipPanelX; } + public int getTooltipPanelY() { return tooltipPanelY; } + + /** Begin dragging the tooltip; offsets are from mouse to tooltip top-left. */ + public void startTooltipDrag(int mouseX, int mouseY) { + isDraggingTooltip = true; + tooltipDragOffsetX = mouseX - tooltipPanelX; + tooltipDragOffsetY = mouseY - tooltipPanelY; + } + + /** Called every frame while M1 is held to move the tooltip. */ + public void updateTooltipDrag(int mouseX, int mouseY) { + if (!isDraggingTooltip) return; + overriddenTooltipX = mouseX - tooltipDragOffsetX; + overriddenTooltipY = mouseY - tooltipDragOffsetY; + tooltipPositionOverridden = true; + } + + public void releaseTooltipDrag() { + isDraggingTooltip = false; + } + + public boolean isDraggingTooltip() { return isDraggingTooltip; } + public boolean hasOverriddenPosition() { return tooltipPositionOverridden; } + public int getOverriddenTooltipX() { return overriddenTooltipX; } + public int getOverriddenTooltipY() { return overriddenTooltipY; } + + // ==================== TOOLTIP PANEL RESIZE ==================== + + /** Returns true when the mouse is over the resize handle (bottom-right corner). */ + public boolean isMouseOverResizeHandle(int mx, int my) { + if (!tooltipVisible || tooltipPanelW <= 0) return false; + int rx = tooltipPanelX + tooltipPanelW - 8; + int ry = tooltipPanelY + tooltipPanelH - 8; + return mx >= rx && mx <= tooltipPanelX + tooltipPanelW + && my >= ry && my <= tooltipPanelY + tooltipPanelH; + } + + /** Begin resizing; captures current panel dimensions as the baseline. */ + public void startTooltipResize(int mouseX, int mouseY) { + isResizingTooltip = true; + resizeInitMouseX = mouseX; + resizeInitMouseY = mouseY; + resizeInitW = tooltipSizeOverridden ? overriddenTooltipW : tooltipPanelW; + resizeInitH = tooltipSizeOverridden ? overriddenTooltipH : tooltipPanelH; + } + + /** Called every frame while M1 is held to resize the tooltip panel. */ + public void updateTooltipResize(int mouseX, int mouseY) { + if (!isResizingTooltip) return; + overriddenTooltipW = Math.max(MIN_TOOLTIP_W, resizeInitW + (mouseX - resizeInitMouseX)); + overriddenTooltipH = Math.max(MIN_TOOLTIP_H, resizeInitH + (mouseY - resizeInitMouseY)); + tooltipSizeOverridden = true; + } + + public void releaseTooltipResize() { + isResizingTooltip = false; + } + + public boolean isResizingTooltip() { return isResizingTooltip; } + public boolean hasOverriddenSize() { return tooltipSizeOverridden; } + public int getOverriddenTooltipW() { return overriddenTooltipW; } + public int getOverriddenTooltipH() { return overriddenTooltipH; } + + public boolean isDraggingScrollbar() { + return isDraggingScrollbar; + } + + public int getScrollbarThumbY() { return scrollbarThumbY; } + public int getScrollbarThumbH() { return scrollbarThumbH; } + public int getScrollbarX() { return scrollbarX; } + + // ==================== GETTERS ==================== + + public boolean isTooltipVisible() { + return tooltipVisible && hoverInfo != null && hoverInfo.hasContent(); + } + + public TokenHoverInfo getHoverInfo() { + return hoverInfo; + } + + public Token getHoveredToken() { + return hoveredToken; + } + + public int getTokenScreenX() { + return tokenScreenX; + } + + public int getTokenScreenY() { + return tokenScreenY; + } + + public int getTokenWidth() { + return tokenWidth; + } + + public int getLastMouseX() { + return lastMouseX; + } + + public int getLastMouseY() { + return lastMouseY; + } + public void setLastMousePosition(int x, int y) { + lastMouseX = x; + lastMouseY = y; + } + + /** + * Get the progress (0.0 to 1.0) of the hover delay. + * Can be used for fade-in animation. + */ + public float getHoverProgress() { + if (hoveredToken == null) return 0f; + long elapsed = System.currentTimeMillis() - hoverStartTime; + return Math.min(1.0f, elapsed / (float) HOVER_DELAY_MS); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/hover/TokenHoverInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/hover/TokenHoverInfo.java new file mode 100644 index 000000000..3e2912bf6 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/hover/TokenHoverInfo.java @@ -0,0 +1,1787 @@ +package noppes.npcs.client.gui.util.script.interpreter.hover; + +import noppes.npcs.client.gui.util.script.interpreter.*; +import noppes.npcs.client.gui.util.script.interpreter.field.AssignmentInfo; +import noppes.npcs.client.gui.util.script.interpreter.field.EnumConstantInfo; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldAccessInfo; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocInfo; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocParamTag; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocReturnTag; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocSeeTag; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocTag; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocTypeTag; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodCallInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.token.Token; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenErrorMessage; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenType; +import noppes.npcs.client.gui.util.script.interpreter.type.ScriptTypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeResolver; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.ArrayList; +import java.util.List; + +/** + * Data class containing all displayable information for a token hover tooltip. + * Extracts and formats information from Token metadata for rendering. + * + * Supports display for: + * - Classes/Interfaces/Enums: Package, declaration with modifiers/extends/implements + * - Methods: Return type, signature, parameters, Javadoc + * - Fields: Type, containing class, declaration + * - Variables: Type, scope (local/parameter/global) + * - Errors: Validation errors, type mismatches + */ +public class TokenHoverInfo { + + // ==================== DISPLAY SECTIONS ==================== + + /** Package name (e.g., "net.minecraft.client") - shown in gray */ + private String packageName; + + /** Icon indicator (e.g., "C" for class, "I" for interface, "m" for method) */ + private String iconIndicator; + + /** Primary declaration line with syntax coloring */ + private List declaration = new ArrayList<>(); + + /** Javadoc/documentation comment lines */ + private List documentation = new ArrayList<>(); + + /** JSDoc-formatted documentation with colored segments (sections like Params, Returns) */ + private List jsDocLines = new ArrayList<>(); + + /** Error messages (shown in red) */ + private List errors = new ArrayList<>(); + + /** Additional info lines (e.g., "Variable 'x' is never used") */ + private List additionalInfo = new ArrayList<>(); + + /** The token this info was built from */ + private final Token token; + + // ==================== DOCUMENTATION LINE ==================== + + /** + * A line of documentation that may contain colored segments. + * Used for JSDoc-style rendering with "Params:", parameter names, etc. + */ + public static class DocumentationLine { + public final List segments; + + /** True for every line (including empty ones) inside a ``` code fence */ + public boolean isCodeLine = false; + /** True only for the FIRST line of each code block (triggers background draw) */ + public boolean isCodeBlockFirst = false; + /** Number of stripped leading spaces — used to apply explicit pixel indentation */ + public int codeLeadingSpaces = 0; + + public DocumentationLine() { + this.segments = new ArrayList<>(); + } + + public void addSegment(String text, int color) { + segments.add(new TextSegment(text, color)); + } + + public void addText(String text) { + segments.add(new TextSegment(text, TextSegment.COLOR_DEFAULT)); + } + + public boolean isEmpty() { + return segments.isEmpty() || segments.stream().allMatch(s -> s.text == null || s.text.isEmpty()); + } + } + + // ==================== TEXT SEGMENT ==================== + + /** + * A colored segment of text within the declaration line. + */ + public static class TextSegment { + public final String text; + public final int color; + + public TextSegment(String text, int color) { + this.text = text; + this.color = color; + } + + // Predefined colors matching IntelliJ dark theme + public static final int COLOR_KEYWORD = 0xCC7832; // Orange for keywords/modifiers + public static final int COLOR_TYPE = 0x6897BB; // Blue for types + public static final int COLOR_CLASS = 0xA9B7C6; // Light gray for class names + public static final int COLOR_METHOD = 0xFFC66D; // Yellow for method names + public static final int COLOR_FIELD = 0x9876AA; // Purple for fields + public static final int COLOR_PARAM = 0xA9B7C6; // Light gray for parameters + public static final int COLOR_PACKAGE = 0x808080; // Gray for package + public static final int COLOR_DEFAULT = 0xA9B7C6; // Default text + public static final int COLOR_ERROR = 0xFF6B68; // Red for errors + public static final int COLOR_STRING = 0x6A8759; // Green for strings + public static final int COLOR_ANNOTATION = 0xBBB529; // Yellow-green for annotations + } + + // ==================== CONSTRUCTOR ==================== + + private TokenHoverInfo(Token token) { + this.token = token; + } + + // ==================== FACTORY METHOD ==================== + + /** + * Build hover info from a token based on its type and metadata. + */ + public static TokenHoverInfo fromToken(Token token) { + if (token == null) return null; + + TokenHoverInfo info = new TokenHoverInfo(token); + + // First, check for errors + info.extractErrors(token); + + // Then, extract type-specific information + switch (token.getType()) { + case IMPORTED_CLASS: + case CLASS_DECL: + case INTERFACE_DECL: + case ENUM_DECL: + case TYPE_DECL: + info.extractClassInfo(token); + break; + + case METHOD_CALL: + info.extractMethodCallInfo(token); + break; + + case METHOD_DECL: + info.extractMethodDeclInfo(token); + break; + + case ENUM_CONSTANT: + info.extractEnumConstantInfo(token); + break; + case GLOBAL_FIELD: + info.extractGlobalFieldInfo(token); + break; + + case LOCAL_FIELD: + info.extractLocalFieldInfo(token); + break; + + case PARAMETER: + info.extractParameterInfo(token); + break; + + case UNDEFINED_VAR: + info.extractUndefinedInfo(token); + break; + case LITERAL: + case KEYWORD: + case MODIFIER: + case STRING: + case COMMENT: + if (info.hasErrors()) + return info; + return null; + default: + // For other types, try to extract any available metadata + if (token.getTypeInfo() != null) { + info.extractClassInfo(token); + } else if (token.getMethodInfo() != null) { + info.extractMethodDeclInfo(token); + } else if (token.getFieldInfo() != null) { + info.extractFieldInfoGeneric(token); + } else if (info.hasErrors()) + return info; + else { + return null; // Nothing to show + } + break; + } + + return info; + } + + // ==================== EXTRACTION METHODS ==================== + + private void extractErrors(Token token) { + // Check if this token is part of a method call argument (positional lookup) + MethodCallInfo containingCall = findMethodCallContainingPosition(token); + if (containingCall != null) { + MethodCallInfo.Argument containingArg = findArgumentContainingPosition(containingCall, token.getGlobalStart()); + if (containingArg != null) { + // Show only this argument's specific error + MethodCallInfo.ArgumentTypeError argError = findArgumentError(containingCall, containingArg); + if (argError != null) { + errors.add(argError.getMessage()); + return; // Only show argument error, not method-level errors + } + } + } + + // Show method-level errors if this is the method name itself + MethodCallInfo callInfo = token.isEnumConstant()? containingCall : token.getMethodCallInfo(); + if (callInfo != null) { + if (callInfo.hasArgCountError()) { + errors.add(callInfo.getErrorMessage()); + } + if (callInfo.hasArgTypeError()) { + for (MethodCallInfo.ArgumentTypeError error : callInfo.getArgumentTypeErrors()) { + errors.add(error.getMessage()); + } + } + if (callInfo.hasReturnTypeMismatch()) { + errors.add(callInfo.getErrorMessage()); + } + if (callInfo.hasStaticAccessError()) { + errors.add(callInfo.getErrorMessage()); + } + if (callInfo.getErrorType() == MethodCallInfo.ErrorType.UNRESOLVED_METHOD) { + errors.add(callInfo.getErrorMessage()); + } + } + + // Show field access errors + FieldAccessInfo fieldAccessInfo = token.getFieldAccessInfo(); + if (fieldAccessInfo != null && fieldAccessInfo.hasError()) { + errors.add(fieldAccessInfo.getErrorMessage()); + } + + // Show assignment errors (type mismatch, final reassignment, etc.) + // Search through FieldInfo's assignments by position + AssignmentInfo assignmentInfo = findAssignmentContainingPosition(token); + if (assignmentInfo != null && assignmentInfo.hasError()) { + errors.add(assignmentInfo.getErrorMessage()); + } + + // Show unresolved field errors + FieldInfo fieldInfo = token.getFieldInfo(); + if (fieldInfo != null && !fieldInfo.isResolved()) { + errors.add("Cannot resolve symbol '" + token.getText() + "'"); + } + + // Show method declaration errors (missing return, parameter errors, return type errors) + MethodInfo methodDecl = findMethodDeclarationContainingPosition(token); + if (methodDecl != null && methodDecl.hasError()) { + int tokenStart = token.getGlobalStart(); + int tokenEnd = token.getGlobalEnd(); + + // If hovering over the method name, show missing return error + if (methodDecl.hasMissingReturnError()) { + int methodNameStart = methodDecl.getNameOffset(); + int methodNameEnd = methodNameStart + methodDecl.getName().length(); + + if (tokenStart >= methodNameStart && tokenEnd <= methodNameEnd) { + errors.add(methodDecl.getErrorMessage()); + } + } + + // If hovering over a parameter with an error, show that error + else if (methodDecl.hasParameterErrors()) { + for (MethodInfo.ParameterError paramError : methodDecl.getParameterErrors()) { + FieldInfo param = paramError.getParameter(); + if (param != null && param.getDeclarationOffset() >= 0) { + int paramStart = param.getDeclarationOffset(); + int paramEnd = paramStart + param.getName().length(); + + if (tokenStart >= paramStart && tokenEnd <= paramEnd) { + errors.add(paramError.getMessage()); + } + } + } + } + + // If hovering over a return statement with a type error, show that error + else if (methodDecl.hasReturnStatementErrors()) { + for (MethodInfo.ReturnStatementError returnError : methodDecl.getReturnStatementErrors()) { + int returnStart = returnError.getStartOffset(); + int returnEnd = returnError.getEndOffset(); + + if (tokenStart >= returnStart && tokenEnd <= returnEnd) { + errors.add(returnError.getMessage()); + } + } + } + + + // All other errors + else if (methodDecl.hasError()) { + int declStart = methodDecl.getFullDeclarationOffset(); + int declEnd = methodDecl.getDeclarationEnd(); + + if (tokenStart >= declStart && tokenEnd <= declEnd) { + errors.add(methodDecl.getErrorMessage()); + } + } + } + + ScriptTypeInfo scriptType = findScriptTypeContainingPosition(token); + if (scriptType != null && scriptType.hasError()) { + // Missing interface method errors + for (ScriptTypeInfo.MissingMethodError err : scriptType.getMissingMethodErrors()) { + errors.add(err.getMessage()); + } + // Constructor mismatch errors + for (ScriptTypeInfo.ConstructorMismatchError err : scriptType.getConstructorMismatchErrors()) { + errors.add(err.getMessage()); + } + // General error message + if (scriptType.getErrorMessage() != null) { + errors.add(scriptType.getErrorMessage()); + } + } + + EnumConstantInfo enumConst = findEnumConstantContainingPosition(token); + if (enumConst != null && enumConst.hasError()) { + errors.add(enumConst.getErrorMessage()); + } + + if(token.getType() == TokenType.UNDEFINED_VAR) + errors.add("Cannot resolve symbol '" + token.getText() + "'"); + + TokenErrorMessage msg = token.getErrorMessage(); + if (msg != null && !msg.getMessage().isEmpty()) { + if(msg.clearOtherErrors) + errors.clear(); + + errors.add(msg.getMessage()); + } + } + + /** + * Find an assignment that contains this token's position. + * Searches through all assignments (script fields and external fields). + */ + private AssignmentInfo findAssignmentContainingPosition(Token token) { + ScriptLine line = token.getParentLine(); + if (line == null || line.getParent() == null) { + return null; + } + + ScriptDocument doc = line.getParent(); + int tokenStart = token.getGlobalStart(); + + // Use ScriptDocument's method which handles all prioritization + return doc.findAssignmentAtPosition(tokenStart); + } + + /** + * Find the method call that contains this token's position within its argument list. + */ + private MethodCallInfo findMethodCallContainingPosition(Token token) { + ScriptLine line = token.getParentLine(); + if (line == null || line.getParent() == null) { + return null; + } + + ScriptDocument doc = line.getParent(); + int tokenStart = token.getGlobalStart(); + + for (MethodCallInfo call : doc.getMethodCalls()) { + boolean isWithinName = tokenStart >= call.getMethodNameStart() && tokenStart <= call.getMethodNameEnd(); + + // If this is an enum constant, return methodCall on name itself + if (token.isEnumConstant() && isWithinName) + return call; + + // Check if token is within the argument list + if (tokenStart >= call.getOpenParenOffset() && tokenStart <= call.getCloseParenOffset()) { + // Make sure it's not the method name itself + if (isWithinName) { + continue; + } + return call; + } + } + return null; + } + + /** + * Find the method declaration that contains this token's position. + * Returns null if the token is not within a method declaration (header or body). + */ + private MethodInfo findMethodDeclarationContainingPosition(Token token) { + ScriptLine line = token.getParentLine(); + if (line == null || line.getParent() == null) { + return null; + } + + ScriptDocument doc = line.getParent(); + int tokenStart = token.getGlobalStart(); + + for (MethodInfo method : doc.getAllMethods()) { + if (!method.isDeclaration()) + continue; + + // Check if token is within the method declaration header OR body + int methodStart = method.getFullDeclarationOffset(); + if (methodStart < 0) methodStart = method.getTypeOffset(); + int bodyEnd = method.getBodyEnd(); + + // Token is within the method (header + body) + if (tokenStart >= methodStart && tokenStart <= bodyEnd) { + return method; + } + } + return null; + } + + private ScriptTypeInfo findScriptTypeContainingPosition(Token token) { + ScriptLine line = token.getParentLine(); + if (line == null || line.getParent() == null) { + return null; + } + + ScriptDocument doc = line.getParent(); + int tokenStart = token.getGlobalStart(); + + for (ScriptTypeInfo scriptType : doc.getScriptTypes()) { + int typeStart = scriptType.getDeclarationOffset(); + int typeEnd = scriptType.getBodyStart(); + + // Token is within the type declaration + if (tokenStart >= typeStart && tokenStart <= typeEnd) { + return scriptType; + } + } + return null; + } + + private EnumConstantInfo findEnumConstantContainingPosition(Token token) { + ScriptLine line = token.getParentLine(); + if (line == null || line.getParent() == null) { + return null; + } + + ScriptDocument doc = line.getParent(); + int tokenStart = token.getGlobalStart(); + + for (EnumConstantInfo enumConst : doc.getAllEnumConstants()) { + int constStart = enumConst.getDeclarationOffset(); + int constEnd = constStart + enumConst.getName().length(); + + // Token is within the enum constant declaration + if (tokenStart >= constStart && tokenStart <= constEnd) { + return enumConst; + } + } + return null; + } + + /** + * Find the argument that contains the given position. + */ + private MethodCallInfo.Argument findArgumentContainingPosition(MethodCallInfo callInfo, int position) { + for (MethodCallInfo.Argument arg : callInfo.getArguments()) { + if (position >= arg.getStartOffset() && position <= arg.getEndOffset()) { + return arg; + } + } + return null; + } + + /** + * Find the type error for a specific argument. + */ + private MethodCallInfo.ArgumentTypeError findArgumentError(MethodCallInfo callInfo, MethodCallInfo.Argument argument) { + if (!callInfo.hasArgTypeError()) { + return null; + } + + int argIndex = callInfo.getArguments().indexOf(argument); + if (argIndex < 0) { + return null; + } + + for (MethodCallInfo.ArgumentTypeError error : callInfo.getArgumentTypeErrors()) { + if (error.getArgIndex() == argIndex) { + return error; + } + } + return null; + } + + private int getExpectedArgCount(MethodCallInfo callInfo) { + MethodInfo method = callInfo.getResolvedMethod(); + if (method != null) { + return method.getParameterCount(); + } + return 0; + } + + private void extractClassInfo(Token token) { + TypeInfo typeInfo = token.getTypeInfo(); + if (typeInfo == null) return; + + packageName = getPackageName(typeInfo); + + Class clazz = typeInfo.getJavaClass(); + if (clazz != null) { + boolean isEnum = clazz.isEnum(); + // Icon + if (clazz.isInterface()) { + iconIndicator = "I"; + } else if (isEnum) { + iconIndicator = "E"; + } else { + iconIndicator = "C"; + } + + // Build declaration + int mods = clazz.getModifiers(); + + // Modifiers + if (Modifier.isPublic(mods)) addSegment("public ", TokenType.MODIFIER.getHexColor()); + if (Modifier.isAbstract(mods) && !clazz.isInterface()) addSegment("abstract ", TokenType.MODIFIER.getHexColor()); + if (Modifier.isFinal(mods) && !isEnum) addSegment("final ", TokenType.MODIFIER.getHexColor()); + + // Class type keyword + if (clazz.isInterface()) { + addSegment("interface ", TokenType.MODIFIER.getHexColor()); + } else if (isEnum) { + addSegment("enum ", TokenType.MODIFIER.getHexColor()); + } else { + addSegment("class ", TokenType.MODIFIER.getHexColor()); + } + + // Class name - use proper color based on type + int classColor = clazz.isInterface() ? TokenType.INTERFACE_DECL.getHexColor() + : clazz.isEnum() ? TokenType.ENUM_DECL.getHexColor() + : TokenType.IMPORTED_CLASS.getHexColor(); + // Render generics with correct segment colors if present + addTypeSegments(typeInfo); + + // Extends + Class superclass = clazz.getSuperclass(); + if (superclass != null && superclass != Object.class && !isEnum) { + addSegment(" extends ", TokenType.MODIFIER.getHexColor()); + addSegment(superclass.getSimpleName(), getColorForClass(superclass)); + } + + List declaration = null; + + // Implements + Class[] interfaces = clazz.getInterfaces(); + if (interfaces.length > 0) { + addSegment(clazz.isInterface() ? " extends " : " implements ", TokenType.MODIFIER.getHexColor()); + for (int i = 0; i < Math.min(interfaces.length, 3); i++) { + if (i > 0) addSegment(", ", TokenType.DEFAULT.getHexColor()); + addSegment(interfaces[i].getSimpleName(), TokenType.INTERFACE_DECL.getHexColor()); + } + if (interfaces.length > 3) { + addSegment(", ...", TokenType.DEFAULT.getHexColor()); + } + } + } else if (typeInfo instanceof ScriptTypeInfo) { + // Script-defined type + ScriptTypeInfo scriptType = (ScriptTypeInfo) typeInfo; + + // Icon + if (scriptType.getKind() == TypeInfo.Kind.INTERFACE) { + iconIndicator = "I"; + } else if (scriptType.getKind() == TypeInfo.Kind.ENUM) { + iconIndicator = "E"; + } else { + iconIndicator = "C"; + } + + // Build declaration with modifiers + int mods = scriptType.getModifiers(); + + // Modifiers + if (Modifier.isPublic(mods)) addSegment("public ", TokenType.MODIFIER.getHexColor()); + if (Modifier.isAbstract(mods) && scriptType.getKind() != TypeInfo.Kind.INTERFACE) + addSegment("abstract ", TokenType.MODIFIER.getHexColor()); + if (Modifier.isFinal(mods)) addSegment("final ", TokenType.MODIFIER.getHexColor()); + if (Modifier.isStatic(mods)) addSegment("static ", TokenType.MODIFIER.getHexColor()); + + // Class type keyword + if (scriptType.getKind() == TypeInfo.Kind.INTERFACE) { + addSegment("interface ", TokenType.MODIFIER.getHexColor()); + } else if (scriptType.getKind() == TypeInfo.Kind.ENUM) { + addSegment("enum ", TokenType.MODIFIER.getHexColor()); + } else { + addSegment("class ", TokenType.MODIFIER.getHexColor()); + } + + // Class name + int classColor = scriptType.getKind() == TypeInfo.Kind.INTERFACE ? TokenType.INTERFACE_DECL.getHexColor() + : scriptType.getKind() == TypeInfo.Kind.ENUM ? TokenType.ENUM_DECL.getHexColor() + : TokenType.IMPORTED_CLASS.getHexColor(); + addTypeSegments(typeInfo); + + // Extends clause for ScriptTypeInfo + if (scriptType.hasSuperClass()) { + addSegment(" extends ", TokenType.MODIFIER.getHexColor()); + TypeInfo superClass = scriptType.getSuperClass(); + if (superClass != null && superClass.isResolved()) { + // Color based on resolved type + addTypeSegments(superClass); + } else { + // Unresolved - show the raw name in undefined color + String superName = scriptType.getSuperClassName(); + if (superName != null) { + addSegment(superName, TokenType.UNDEFINED_VAR.getHexColor()); + } + } + } + + // Implements clause for ScriptTypeInfo + List implementedInterfaces = scriptType.getImplementedInterfaces(); + if (!implementedInterfaces.isEmpty()) { + // For interfaces, they "extend" other interfaces; for classes, they "implement" + String keyword = scriptType.getKind() == TypeInfo.Kind.INTERFACE ? " extends " : " implements "; + if (scriptType.hasSuperClass() && scriptType.getKind() == TypeInfo.Kind.INTERFACE) { + // Already showed extends, so use comma + addSegment(", ", TokenType.DEFAULT.getHexColor()); + } else { + addSegment(keyword, TokenType.MODIFIER.getHexColor()); + } + + List interfaceNames = scriptType.getImplementedInterfaceNames(); + for (int i = 0; i < implementedInterfaces.size(); i++) { + if (i > 0) addSegment(", ", TokenType.DEFAULT.getHexColor()); + + TypeInfo ifaceType = implementedInterfaces.get(i); + String ifaceName = (i < interfaceNames.size()) ? interfaceNames.get(i) : getName(ifaceType); + + if (ifaceType != null && ifaceType.isResolved()) { + // Prefer rendering from the resolved TypeInfo so generics color correctly + addTypeSegments(ifaceType); + } else { + addSegment(ifaceName, TokenType.UNDEFINED_VAR.getHexColor()); + } + } + } + + // Add ScriptTypeInfo errors + if (false) { //|| scriptType.hasError() + // Missing interface method errors + for (ScriptTypeInfo.MissingMethodError err : scriptType.getMissingMethodErrors()) { + errors.add(err.getMessage()); + } + // Constructor mismatch errors + for (ScriptTypeInfo.ConstructorMismatchError err : scriptType.getConstructorMismatchErrors()) { + errors.add(err.getMessage()); + } + // General error message + if (scriptType.getErrorMessage() != null) { + errors.add(scriptType.getErrorMessage()); + } + } + + JSDocInfo jsDocInfo = scriptType.getJSDocInfo(); + if (jsDocInfo != null) { + formatJSDocumentation(jsDocInfo, null); + } + + } else if (typeInfo.isJSType()) { + JSTypeInfo jsType = typeInfo.getJSTypeInfo(); + + iconIndicator = "I"; + addSegment("interface ", TokenType.MODIFIER.getHexColor()); + addTypeSegments(typeInfo); + + if (jsType.getExtendsType() != null) { + addSegment(" extends ", TokenType.MODIFIER.getHexColor()); + addSegment(jsType.getExtendsType(), TokenType.INTERFACE_DECL.getHexColor()); + } + + JSDocInfo jsDocInfo = typeInfo.getJSDocInfo(); + if (jsDocInfo != null) { + formatJSDocumentation(jsDocInfo, null); + } + + } else { + // Unresolved type + iconIndicator = "?"; + String typeName = getName(typeInfo); + splitAndAddTypeName(typeName, token.getType().getHexColor()); + if (!typeInfo.isResolved()) { + errors.add("Cannot resolve class '" + typeName + "'"); + } + } + + // If this is a NEW_TYPE token with constructor info, show the constructor signature + if (token.getMethodInfo() != null) { + MethodInfo constructor = token.getMethodInfo(); + declaration.add(new TextSegment("\n", TokenType.DEFAULT.getHexColor())); + additionalInfo.add("Constructor"); + buildConstructorDeclaration(constructor, typeInfo); + } + } + + private void extractMethodCallInfo(Token token) { + MethodCallInfo callInfo = token.getMethodCallInfo(); + MethodInfo methodInfo = callInfo != null ? callInfo.getResolvedMethod() : token.getMethodInfo(); + + if (methodInfo == null && callInfo == null) return; + + iconIndicator = "m"; + + TypeInfo containingType = null; + if (callInfo != null) { + containingType = callInfo.getReceiverType(); + + //Checks true containing type from resolved method (handles inheritance cases) + if (callInfo.getResolvedMethod() != null) { + TypeInfo trueContainingType = callInfo.getResolvedMethod().getContainingType(); + if (trueContainingType != null) + containingType = trueContainingType; + } + } + if (containingType == null && methodInfo != null) { + containingType = methodInfo.getContainingType(); + } + + if (containingType != null) { + // Show full qualified class name (like IntelliJ) + String pkg = getPackageName(containingType); + if (pkg != null && !pkg.isEmpty()) + packageName = pkg; + } + + // Try to get actual Java method for more details + if (methodInfo != null && shouldPreferMethodInfo(methodInfo)) { + buildBasicMethodDeclaration(methodInfo, containingType); + return; + } + if (methodInfo != null && methodInfo.getJavaMethod() != null) { + // When receiver is parameterized, MethodInfo has adapted generic params + // (e.g., Map.get(String) instead of get(Object)). + // Use buildBasicMethodDeclaration to show adapted types correctly. + if (containingType != null && containingType.isParameterized()) { + buildBasicMethodDeclaration(methodInfo, containingType); + return; + } + TypeInfo methodReturnType = methodInfo.getReturnType(); + Class reflectedReturnType = methodInfo.getJavaMethod().getReturnType(); + if (methodReturnType != null && methodReturnType.getJavaClass() != null + && methodReturnType.getJavaClass() != reflectedReturnType) { + // Use MethodInfo when its return type differs from reflection (e.g., .d.ts override like IDBCPlayer -> IDBCAddon in npcdbc). + buildBasicMethodDeclaration(methodInfo, containingType); + return; + } + buildMethodDeclaration(methodInfo.getJavaMethod(), containingType); + extractJavadoc(methodInfo.getJavaMethod()); + return; + } + + // Fallback to basic method info + if (methodInfo != null) { + buildBasicMethodDeclaration(methodInfo, containingType); + } + } + + private void extractMethodDeclInfo(Token token) { + MethodInfo methodInfo = token.getMethodInfo(); + if (methodInfo == null) return; + + iconIndicator = "m"; + + // For script-defined methods, show basic declaration + buildBasicMethodDeclaration(methodInfo, null); + } + + private void extractGlobalFieldInfo(Token token) { + FieldInfo fieldInfo = token.getFieldInfo(); + FieldAccessInfo accessInfo = token.getFieldAccessInfo(); + if (fieldInfo == null && accessInfo != null) + fieldInfo = accessInfo.getResolvedField(); + + if (fieldInfo == null) + return; + + iconIndicator = "f"; + + // Add documentation if available + JSDocInfo jsDoc = fieldInfo.getJSDocInfo(); + if (jsDoc != null) { + formatJSDocumentation(jsDoc, null); + } else if (fieldInfo.getDocumentation() != null && !fieldInfo.getDocumentation().isEmpty()) { + String[] docLines = fieldInfo.getDocumentation().split("\n"); + for (String line : docLines) { + documentation.add(line); + } + } + + TypeInfo declaredType = fieldInfo.getTypeInfo(); + + // Try to get modifiers from Java reflection if this is a chained field + boolean foundModifiers = false; + if (accessInfo != null && accessInfo.getReceiverType() != null) { + TypeInfo receiverType = accessInfo.getReceiverType(); + if (receiverType.getJavaClass() != null) { + try { + Field javaField = receiverType.getJavaClass().getField(fieldInfo.getName()); + if (javaField != null) + addFieldModifiers(javaField.getModifiers()); + foundModifiers = true; + } catch (Exception e) { + } + } + } + + int modifiers = fieldInfo.getModifiers(); + if(modifiers !=0 && !foundModifiers) { + addFieldModifiers(modifiers); + } + +// if (!foundModifiers && fieldInfo.getDeclarationOffset() >= 0) { +// // Show modifiers from source if we have a declaration position +// String modifiers = extractModifiersAtPosition(fieldInfo.getDeclarationOffset()); +// if (modifiers != null && !modifiers.isEmpty()) { +// addSegment(modifiers + " ", TokenType.MODIFIER.getHexColor()); +// } +// } + + if (declaredType != null) { + // accessInfo For Minecraft.getMinecraft.thePlayer + // Return net.minecraft.client.Minecraft, and not net.minecraft.entity.EntityPlayer + String pkg = getPackageName(accessInfo != null ? accessInfo.getReceiverType() : declaredType); + + if (pkg != null && !pkg.isEmpty()) + packageName = pkg; + + // Type - check for actual type color + addTypeSegments(declaredType); + addSegment(" ", TokenType.DEFAULT.getHexColor()); + } + + // Field name + addSegment(fieldInfo.getName(), TokenType.GLOBAL_FIELD.getHexColor()); + + // Add initialization value if available + addInitializationTokens(token, fieldInfo); + } + + private void extractEnumConstantInfo(Token token) { + FieldInfo fieldInfo = token.getFieldInfo(); + if (fieldInfo == null) + return; + + EnumConstantInfo enumInfo = fieldInfo.getEnumInfo(); + if (enumInfo == null) + return; + + iconIndicator = "e"; + + // Add documentation if available + if (fieldInfo.getDocumentation() != null && !fieldInfo.getDocumentation().isEmpty()) { + String[] docLines = fieldInfo.getDocumentation().split("\n"); + for (String line : docLines) { + documentation.add(line); + } + } + + TypeInfo enumType = enumInfo.getEnumType(); + + if (enumType != null) { + // Show enum's package + String pkg = getPackageName(enumType); + if (pkg != null && !pkg.isEmpty()) + packageName = pkg; + + + // Type (enum type name) + addTypeSegments(enumType); + addSegment(" ", TokenType.DEFAULT.getHexColor()); + } + + // Enum constant name + addSegment(token.getStylePrefix() + fieldInfo.getName(), TokenType.ENUM_CONSTANT.getHexColor()); + + // Add constructor arguments if available + addInitializationTokens(token, fieldInfo); + } + + private void extractLocalFieldInfo(Token token) { + FieldInfo fieldInfo = token.getFieldInfo(); + if (fieldInfo == null) return; + + iconIndicator = "v"; + + // Add documentation if available (though local vars rarely have docs) + if (fieldInfo.getDocumentation() != null && !fieldInfo.getDocumentation().isEmpty()) { + String[] docLines = fieldInfo.getDocumentation().split("\n"); + for (String line : docLines) { + documentation.add(line); + } + } + + TypeInfo declaredType = fieldInfo.getTypeInfo(); + if (declaredType != null) { + addTypeSegments(declaredType); + addSegment(" ", TokenType.DEFAULT.getHexColor()); + } + + addSegment(fieldInfo.getName(), TokenType.LOCAL_FIELD.getHexColor()); + + // Add initialization value if available + addInitializationTokens(token, fieldInfo); + + // Show it's a local variable + additionalInfo.add("Local variable"); + } + + public String getPackageName(TypeInfo type) { + if (type == null) + return null; + + TypeInfo base = type.isArray() ? type.getElementType() : type; + if (base == null) base = type; + + String fullName = base.getFullName(); + if (fullName != null && !fullName.isEmpty()) { + return fullName; + } else { + String pkg = base.getPackageName(); + String className = getName(base); + if (pkg != null && !pkg.isEmpty()) { + return pkg + "." + className; + } else { + return className; + } + } + } + + private void extractParameterInfo(Token token) { + FieldInfo fieldInfo = token.getFieldInfo(); + if (fieldInfo == null) return; + + iconIndicator = "p"; + + // Add documentation if available (args/parameters might have docs from method javadoc) + if (fieldInfo.getDocumentation() != null && !fieldInfo.getDocumentation().isEmpty()) { + String[] docLines = fieldInfo.getDocumentation().split("\n"); + for (String line : docLines) { + documentation.add(line); + } + } + + TypeInfo declaredType = fieldInfo.getTypeInfo(); + if (declaredType != null) { + addTypeSegments(declaredType); + addSegment(" ", TokenType.DEFAULT.getHexColor()); + } + + addSegment(fieldInfo.getName(), TokenType.PARAMETER.getHexColor()); + + additionalInfo.add("Parameter"); + } + + private void extractUndefinedInfo(Token token) { + iconIndicator = "?"; + //addSegment(token.getText(), TokenType.UNDEFINED_VAR.getHexColor()); + } + + /** + * Get the display name for a type, including generic arguments. + * Uses the unified getDisplayName() method which handles: + * - Simple types: "String" + * - Parameterized types: "List", "Map" + * - Nested generics: "List>" + * - JS types with namespace: "IPlayerEvent.InteractEvent" + */ + public String getName(TypeInfo type){ + if (type instanceof ScriptTypeInfo) { + return ((ScriptTypeInfo) type).getDotSeparatedName(); + } + return type.getDisplayName(); + } + + /** + * Add a type name as multiple colored segments so generics render like the editor marks. + * Example: List -> "List" (interface), "<" (default), "String" (class), ">" (default) + */ + private void addTypeSegments(TypeInfo typeInfo) { + addTypeSegments(typeInfo, 0); + } + + private void addTypeSegments(TypeInfo typeInfo, int depth) { + if (typeInfo == null) { + addSegment("any", TokenType.DEFAULT.getHexColor()); + return; + } + if (depth > 25) { + addSegment(getName(typeInfo), getColorForTypeInfo(typeInfo)); + return; + } + + if (typeInfo.isParameterized()) { + TypeInfo raw = typeInfo.getRawType(); + String rawName = getName(raw); + splitAndAddTypeName(rawName, getColorForTypeInfo(raw)); + addSegment("<", TokenType.DEFAULT.getHexColor()); + + java.util.List args = typeInfo.getAppliedTypeArgs(); + for (int i = 0; i < args.size(); i++) { + if (i > 0) { + addSegment(", ", TokenType.DEFAULT.getHexColor()); + } + addTypeSegments(args.get(i), depth + 1); + } + + addSegment(">", TokenType.DEFAULT.getHexColor()); + return; + } + + String typeName = getName(typeInfo); + splitAndAddTypeName(typeName, getColorForTypeInfo(typeInfo)); + } + + private void splitAndAddTypeName(String typeName, int typeColor) { + if (typeName == null || !typeName.endsWith("[]")) { + addSegment(typeName, typeColor); + return; + } + int idx = typeName.length() - 2; + while (idx >= 1 && typeName.charAt(idx - 1) == '[' && typeName.charAt(idx) == ']') { + idx -= 2; + } + if (idx > 0) { + addSegment(typeName.substring(0, idx), typeColor); + } + addSegment(typeName.substring(idx), TokenType.DEFAULT.getHexColor()); + } + + private void extractFieldInfoGeneric(Token token) { + FieldInfo fieldInfo = token.getFieldInfo(); + if (fieldInfo == null) return; + + switch (fieldInfo.getScope()) { + case GLOBAL: + extractGlobalFieldInfo(token); + break; + case LOCAL: + extractLocalFieldInfo(token); + break; + case PARAMETER: + extractParameterInfo(token); + break; + } + } + + private void buildConstructorDeclaration(MethodInfo constructor, TypeInfo containingType) { + // Modifiers (public, private, etc.) + declaration.clear(); + int mods = constructor.getModifiers(); + if (Modifier.isPublic(mods)) addSegment("public ", TokenType.MODIFIER.getHexColor()); + else if (Modifier.isProtected(mods)) addSegment("protected ", TokenType.MODIFIER.getHexColor()); + else if (Modifier.isPrivate(mods)) addSegment("private ", TokenType.MODIFIER.getHexColor()); + + // Constructor name (same as class name) + addSegment(constructor.getName(), containingType.getTokenType().getHexColor()); + + // Parameters + addSegment("(", TokenType.DEFAULT.getHexColor()); + List params = constructor.getParameters(); + for (int i = 0; i < params.size(); i++) { + if (i > 0) addSegment(", ", TokenType.DEFAULT.getHexColor()); + FieldInfo param = params.get(i); + TypeInfo paramType = param.getTypeInfo(); + if (paramType != null) { + addTypeSegments(paramType); + if (param.isVarArg()) { + addSegment("...", TokenType.DEFAULT.getHexColor()); + } + addSegment(" ", TokenType.DEFAULT.getHexColor()); + } + addSegment(param.getName(), TokenType.PARAMETER.getHexColor()); + } + addSegment(")", TokenType.DEFAULT.getHexColor()); + + // Add documentation if available + if (constructor.getDocumentation() != null && !constructor.getDocumentation().isEmpty()) { + String[] docLines = constructor.getDocumentation().split("\n"); + for (String line : docLines) { + documentation.add(line); + } + } + } + + private void addSegment(String text, int color) { + declaration.add(new TextSegment(text, color)); + } + + private void buildMethodDeclaration(Method method, TypeInfo containingType) { + int mods = method.getModifiers(); + + // Annotations (show @Contract if present, etc.) + // Skip for now - could add later + + // Modifiers + if (Modifier.isPublic(mods)) addSegment("public ", TokenType.MODIFIER.getHexColor()); + else if (Modifier.isProtected(mods)) addSegment("protected ", TokenType.MODIFIER.getHexColor()); + else if (Modifier.isPrivate(mods)) addSegment("private ", TokenType.MODIFIER.getHexColor()); + + if (Modifier.isStatic(mods)) addSegment("static ", TokenType.MODIFIER.getHexColor()); + if (Modifier.isFinal(mods)) addSegment("final ", TokenType.MODIFIER.getHexColor()); + if (Modifier.isAbstract(mods)) addSegment("abstract ", TokenType.MODIFIER.getHexColor()); + if (Modifier.isSynchronized(mods)) addSegment("synchronized ", TokenType.MODIFIER.getHexColor()); + + // Return type - check for actual type color (handle array suffix coloring) + Class returnType = method.getReturnType(); + String returnTypeName = returnType.getSimpleName(); + splitAndAddTypeName(returnTypeName, getColorForTypeInfo(containingType)); + addSegment(" ", TokenType.DEFAULT.getHexColor()); + + // Method name + addSegment(method.getName(), TokenType.METHOD_DECL.getHexColor()); + + // Parameters + addSegment("(", TokenType.DEFAULT.getHexColor()); + Class[] paramTypes = method.getParameterTypes(); + java.lang.reflect.Parameter[] params = method.getParameters(); + for (int i = 0; i < paramTypes.length; i++) { + if (i > 0) addSegment(", ", TokenType.DEFAULT.getHexColor()); + int paramTypeColor = getColorForClass(paramTypes[i]); + String paramTypeName = paramTypes[i].getSimpleName(); + splitAndAddTypeName(paramTypeName, paramTypeColor); + if (method.isVarArgs() && i == paramTypes.length - 1) { + addSegment("...", TokenType.DEFAULT.getHexColor()); + } + addSegment(" ", TokenType.DEFAULT.getHexColor()); + // Try to get parameter name if available + String paramName = params.length > i ? params[i].getName() : "arg" + i; + addSegment(paramName, TokenType.PARAMETER.getHexColor()); + } + addSegment(")", TokenType.DEFAULT.getHexColor()); + } + + private void buildBasicMethodDeclaration(MethodInfo methodInfo, TypeInfo containingType) { + // Try to extract modifiers from source if this is a declaration + if (methodInfo.isDeclaration() && methodInfo.getDeclarationOffset() >= 0) { + String modifiers = extractModifiersAtPosition(methodInfo.getDeclarationOffset()); + if (modifiers != null && !modifiers.isEmpty()) { + addSegment(modifiers + " ", TokenType.MODIFIER.getHexColor()); + } + } else { + // Fallback: show static if we know it + if (methodInfo.isStatic()) { + addSegment("static ", TokenType.MODIFIER.getHexColor()); + } + } + + // Return type + TypeInfo returnType = methodInfo.getReturnType(); + if (ScriptDocument.INSTANCE.isJavaScript() && methodInfo.isDeclaration()) + addSegment("function ", TokenType.KEYWORD.getHexColor()); + else if (returnType != null) { + addTypeSegments(returnType); + addSegment(" ", TokenType.DEFAULT.getHexColor()); + } else { + addSegment("void ", TokenType.KEYWORD.getHexColor()); + } + + // Method name + addSegment(methodInfo.getName(), TokenType.METHOD_DECL.getHexColor()); + + // Parameters + addSegment("(", TokenType.DEFAULT.getHexColor()); + List params = methodInfo.getParameters(); + for (int i = 0; i < params.size(); i++) { + if (i > 0) addSegment(", ", TokenType.DEFAULT.getHexColor()); + FieldInfo param = params.get(i); + TypeInfo paramType = param.getTypeInfo(); + if (paramType != null) { + addTypeSegments(paramType); + if (param.isVarArg()) { + addSegment("...", TokenType.DEFAULT.getHexColor()); + } + addSegment(" ", TokenType.DEFAULT.getHexColor()); + } + addSegment(param.getName(), TokenType.PARAMETER.getHexColor()); + } + addSegment(")", TokenType.DEFAULT.getHexColor()); + + // Add documentation if available - use JSDoc formatting if we have JSDocInfo + JSDocInfo jsDoc = methodInfo.getJSDocInfo(); + if (jsDoc != null) { + formatJSDocumentation(jsDoc, methodInfo.getParameters()); + } else if (methodInfo.getDocumentation() != null && !methodInfo.getDocumentation().isEmpty()) { + // Fallback to raw documentation + String[] docLines = methodInfo.getDocumentation().split("\n"); + for (String line : docLines) { + documentation.add(line); + } + } + + } + + private boolean shouldPreferMethodInfo(MethodInfo methodInfo) { + if (methodInfo.getJSDocInfo() != null) return true; + String doc = methodInfo.getDocumentation(); + if (doc != null && !doc.isEmpty()) return true; + + for (FieldInfo param : methodInfo.getParameters()) { + String name = param.getName(); + if (name != null && !name.matches("arg\\d+")) { + return true; + } + } + return false; + } + + /** + * Parses a JSDoc description string and routes each logical line into jsDocLines[] + * with markdown-aware coloring: + * - ## / ### headings → COLOR_METHOD (yellow) + * - ``` code fences → markers suppressed; code lines → COLOR_STRING (green) + * - blank lines → empty DocumentationLine (spacer) + * - normal text → default color + */ + /** + * Simple JavaScript syntax tokenizer. + * Breaks a single code line into colored TextSegments. + * Handles: // comments, "strings", 'strings', keywords, numbers, identifiers. + */ + private static List tokenizeCodeLine(String line) { + List tokens = new ArrayList<>(); + if (line == null || line.isEmpty()) return tokens; + + // JS keywords + java.util.Set keywords = new java.util.HashSet<>(java.util.Arrays.asList( + "var","let","const","function","return","if","else","while","for","do", + "break","continue","new","this","null","undefined","true","false", + "typeof","instanceof","void","delete","in","of","class","extends", + "import","export","from","try","catch","finally","throw","switch","case", + "default","with","debugger","yield","async","await" + )); + + int i = 0; + int len = line.length(); + + while (i < len) { + char c = line.charAt(i); + + // Line comment + if (c == '/' && i + 1 < len && line.charAt(i + 1) == '/') { + tokens.add(new TextSegment(line.substring(i), 0x6A9955)); // muted green-gray + break; + } + + // String literal + if (c == '"' || c == '\'') { + char quote = c; + int start = i++; + while (i < len && line.charAt(i) != quote) { + if (line.charAt(i) == '\\') i++; // skip escape + i++; + } + if (i < len) i++; // consume closing quote + tokens.add(new TextSegment(line.substring(start, i), TextSegment.COLOR_STRING)); + continue; + } + + // Number + if (Character.isDigit(c)) { + int start = i++; + while (i < len && (Character.isDigit(line.charAt(i)) || line.charAt(i) == '.' || line.charAt(i) == 'x' || line.charAt(i) == 'X' || (line.charAt(i) >= 'a' && line.charAt(i) <= 'f') || (line.charAt(i) >= 'A' && line.charAt(i) <= 'F'))) i++; + tokens.add(new TextSegment(line.substring(start, i), 0x6897BB)); + continue; + } + + // Identifier or keyword + if (Character.isLetter(c) || c == '_' || c == '$') { + int start = i++; + while (i < len && (Character.isLetterOrDigit(line.charAt(i)) || line.charAt(i) == '_' || line.charAt(i) == '$')) i++; + String word = line.substring(start, i); + int color = keywords.contains(word) ? TextSegment.COLOR_KEYWORD : TextSegment.COLOR_DEFAULT; + tokens.add(new TextSegment(word, color)); + continue; + } + + // Anything else (operators, punctuation, spaces) — group consecutive non-identifier chars + int start = i++; + while (i < len) { + char nc = line.charAt(i); + if (Character.isLetterOrDigit(nc) || nc == '_' || nc == '$' || nc == '"' || nc == '\'' || nc == '/' ) break; + i++; + } + tokens.add(new TextSegment(line.substring(start, i), TextSegment.COLOR_DEFAULT)); + } + + return tokens; + } + + private static boolean isCodeOperatorChar(char c) { + return "=<>!+-*/%&|^~,;:([{".indexOf(c) >= 0; + } + + private void addDescriptionAsMarkdown(String description) { + if (description == null || description.isEmpty()) return; + String[] lines = description.split("\n", -1); + boolean inCodeFence = false; + boolean nextIsFirst = false; + for (String line : lines) { + DocumentationLine docLine = new DocumentationLine(); + if (line.trim().startsWith("```")) { + // Toggle code fence — suppress the fence marker, emit empty spacer + inCodeFence = !inCodeFence; + if (inCodeFence) { + nextIsFirst = true; + } + jsDocLines.add(new DocumentationLine()); + } else if (inCodeFence) { + if (line.trim().isEmpty()) { + // Empty line inside code fence — keep as code line + DocumentationLine emptyCode = new DocumentationLine(); + emptyCode.isCodeLine = true; + if (nextIsFirst) { + emptyCode.isCodeBlockFirst = true; + nextIsFirst = false; + } + jsDocLines.add(emptyCode); + } else { + // Code content — strip leading spaces for explicit indentation, then syntax-highlight + int leadingSpaces = 0; + while (leadingSpaces < line.length() && line.charAt(leadingSpaces) == ' ') { + leadingSpaces++; + } + String codeLine = leadingSpaces > 0 ? line.substring(leadingSpaces) : line; + List codeTokens = tokenizeCodeLine(codeLine); + if (codeTokens.isEmpty()) { + docLine.addSegment(codeLine, TextSegment.COLOR_STRING); + } else { + for (TextSegment tok : codeTokens) { + docLine.segments.add(tok); + } + } + docLine.isCodeLine = true; + docLine.codeLeadingSpaces = leadingSpaces; + if (nextIsFirst) { + docLine.isCodeBlockFirst = true; + nextIsFirst = false; + } + jsDocLines.add(docLine); + } + } else if (line.trim().startsWith("###")) { + // H3 heading — yellow (strip ### prefix, keep emoji if present) + String text = line.trim().substring(3).trim(); + docLine.addSegment(text, TextSegment.COLOR_METHOD); + jsDocLines.add(docLine); + } else if (line.trim().startsWith("##")) { + // H2 heading — yellow (strip ## prefix, keep emoji if present) + String text = line.trim().substring(2).trim(); + docLine.addSegment(text, TextSegment.COLOR_METHOD); + jsDocLines.add(docLine); + } else if (line.trim().isEmpty()) { + // Blank line — empty spacer + jsDocLines.add(new DocumentationLine()); + } else { + // Normal text + docLine.addText(line.trim()); + jsDocLines.add(docLine); + } + } + // Strip trailing blank lines left by description ending with \n + while (!jsDocLines.isEmpty() && jsDocLines.get(jsDocLines.size() - 1).isEmpty() && !jsDocLines.get(jsDocLines.size() - 1).isCodeLine) { + jsDocLines.remove(jsDocLines.size() - 1); + } + } + + /** + * Format JSDoc information in IntelliJ-style with "Params:" and "Returns:" sections. + * Creates colored documentation lines with parameter names highlighted. + */ + private void formatJSDocumentation(JSDocInfo jsDoc, List methodParams) { + // Add description if available (without @tags) + String description = jsDoc.getDescription(); + if (description != null && !description.isEmpty()) { + addDescriptionAsMarkdown(description); + } + + // Add Returns section if there's a @return tag + JSDocTypeTag typeTag = jsDoc.getTypeTag(); + if (typeTag != null) { + // "Type:" header + DocumentationLine typeLine = new DocumentationLine(); + typeLine.addSegment("Type:", TokenType.JSDOC_TAG.getHexColor()); + + // Type if available + if (typeTag.hasType()) { + typeLine.addText(" "); + typeLine.addSegment("{", TokenType.JSDOC_TYPE.getHexColor()); + typeLine.addSegment(typeTag.getTypeName(), TokenType.getColor(typeTag.getTypeInfo())); + typeLine.addSegment("}", TokenType.JSDOC_TYPE.getHexColor()); + } + + // Description if available + String typeDesc = typeTag.getDescription(); + if (typeDesc != null && !typeDesc.isEmpty()) { + typeLine.addText(" - "); + typeLine.addText(typeDesc.trim()); + } + + jsDocLines.add(typeLine); + } + + // Add Params section if there are @param tags + List paramTags = jsDoc.getParamTags(); + if (paramTags != null && !paramTags.isEmpty()) { + // "Params:" header + DocumentationLine paramsHeader = new DocumentationLine(); + paramsHeader.addSegment("Params:", TokenType.JSDOC_TAG.getHexColor()); + jsDocLines.add(paramsHeader); + + // Add each parameter + for (JSDocParamTag paramTag : paramTags) { + DocumentationLine paramLine = new DocumentationLine(); + + // Indent and parameter name + String paramName = paramTag.getParamName(); + if (paramName == null || paramName.isEmpty()) { + paramLine.addSegment("param", TokenType.JSDOC_TAG.getHexColor()); + } else { + boolean paramExists = methodParams != null && methodParams.stream() + .anyMatch(p -> p.getName().equals(paramName)); + paramLine.addSegment(paramName, + paramExists ? TokenType.PARAMETER.getHexColor() : TokenType.UNDEFINED_VAR.getHexColor()); + } + + // Type if available + if (paramTag.hasType()) { + paramLine.addSegment(" {", TokenType.JSDOC_TYPE.getHexColor()); + paramLine.addSegment(paramTag.getTypeName(), TokenType.getColor(paramTag.getTypeInfo())); + paramLine.addSegment("}", TokenType.JSDOC_TYPE.getHexColor()); + } + + // Description if available + String paramDesc = paramTag.getDescription(); + if (paramDesc != null && !paramDesc.isEmpty()) { + String[] paramDescLines = paramDesc.split("\n", -1); + paramLine.addText(" - "); + paramLine.addText(paramDescLines[0].trim()); + jsDocLines.add(paramLine); + for (int i = 1; i < paramDescLines.length; i++) { + if (!paramDescLines[i].trim().isEmpty()) { + DocumentationLine contLine = new DocumentationLine(); + contLine.addText(" " + paramDescLines[i].trim()); + jsDocLines.add(contLine); + } + } + } else { + jsDocLines.add(paramLine); + } + } + } + + // Add Returns section if there's a @return tag + JSDocReturnTag returnTag = jsDoc.getReturnTag(); + if (returnTag != null) { + DocumentationLine returnLine = new DocumentationLine(); + + //"Returns:" header + returnLine.addSegment("Returns:", TokenType.JSDOC_TAG.getHexColor()); + + // Type if available + if (returnTag.hasType()) { + returnLine.addText(" "); + returnLine.addSegment("{", TokenType.JSDOC_TYPE.getHexColor()); + returnLine.addSegment(returnTag.getTypeName(), TokenType.getColor(returnTag.getTypeInfo())); + returnLine.addSegment("}", TokenType.JSDOC_TYPE.getHexColor()); + } + + // Description if available + String returnDesc = returnTag.getDescription(); + if (returnDesc != null && !returnDesc.isEmpty()) { + String[] returnDescLines = returnDesc.split("\n", -1); + returnLine.addText(" - "); + returnLine.addText(returnDescLines[0].trim()); + jsDocLines.add(returnLine); + for (int i = 1; i < returnDescLines.length; i++) { + if (!returnDescLines[i].trim().isEmpty()) { + DocumentationLine contLine = new DocumentationLine(); + contLine.addText(" " + returnDescLines[i].trim()); + jsDocLines.add(contLine); + } + } + } else { + jsDocLines.add(returnLine); + } + } + + List seeTags = jsDoc.getSeeTags(); + if (seeTags != null && !seeTags.isEmpty()) { + for (JSDocSeeTag seeTag : seeTags) { + DocumentationLine seeLine = new DocumentationLine(); + seeLine.addSegment("See:", TokenType.JSDOC_TAG.getHexColor()); + + String reference = seeTag.getReference(); + if (seeTag.hasLinkText()) { + seeLine.addText(" "); + seeLine.addSegment(seeTag.getLinkText(), TokenType.INTERFACE_DECL.getHexColor()); + } else if (reference != null) { + seeLine.addText(" " + reference); + } + + jsDocLines.add(seeLine); + } + } + + List allTags = jsDoc.getAllTags(); + if (allTags != null && !allTags.isEmpty()) { + for (JSDocTag tag : allTags) { + String tagName = tag.getTagName(); + if (tagName == null) { + continue; + } + + String normalized = tagName.toLowerCase(); + if ("type".equals(normalized) + || "param".equals(normalized) + || "return".equals(normalized) + || "returns".equals(normalized) + || "see".equals(normalized)) { + continue; + } + + DocumentationLine tagLine = new DocumentationLine(); + //capitalise first letter in tag name + String capTagName = tagName.substring(0, 1).toUpperCase() + tagName.substring(1); + tagLine.addSegment(capTagName + ":", TokenType.JSDOC_TAG.getHexColor()); + + if (tag.hasType()) { + tagLine.addSegment(" {", TokenType.JSDOC_TYPE.getHexColor()); + tagLine.addSegment(tag.getTypeName(), TokenType.getColor(tag.getTypeInfo())); + tagLine.addSegment("}", TokenType.JSDOC_TYPE.getHexColor()); + } + + String tagDesc = tag.getDescription(); + if (tagDesc != null && !tagDesc.isEmpty()) { + tagLine.addText(" - "); + tagLine.addText(tagDesc.trim()); + } + + jsDocLines.add(tagLine); + } + } + } + + private void extractJavadoc(Method method) { + // Java reflection doesn't provide Javadoc at runtime + // We could potentially load it from source files or external documentation + // For now, we'll leave this as a placeholder for future enhancement + + // Check for @Deprecated annotation + if (method.isAnnotationPresent(Deprecated.class)) { + additionalInfo.add("@Deprecated"); + } + } + + /** + * Extract modifiers (public, private, static, final, etc.) before a declaration position. + * Looks backward from the position to find modifiers. + */ + private String extractModifiersAtPosition(int position) { + if (token.getParentLine().getParent() == null) + return null; + + String text = token.getParentLine().getParent().getText(); + if (position < 0 || position >= text.length()) + return null; + + // Look backward from position to find start of line or previous semicolon/brace + int searchStart = position - 1; + while (searchStart >= 0) { + char c = text.charAt(searchStart); + if (c == ';' || c == '{' || c == '}' || c == '\n') { + searchStart++; + break; + } + searchStart--; + } + if (searchStart < 0) + searchStart = 0; + + // Extract text before the declaration + String beforeDecl = text.substring(searchStart, position).trim(); + + // Match modifier keywords + StringBuilder modifiers = new StringBuilder(); + String[] words = beforeDecl.split("\\s+"); + for (String word : words) { + if (TypeResolver.isModifier(word)) { + if (modifiers.length() > 0) + modifiers.append(" "); + modifiers.append(word); + } + } + + return modifiers.toString(); + } + + /** + * Add field modifiers from Java reflection modifiers. + */ + private void addFieldModifiers(int mods) { + if (Modifier.isPublic(mods)) + addSegment("public ", TokenType.MODIFIER.getHexColor()); + else if (Modifier.isProtected(mods)) + addSegment("protected ", TokenType.MODIFIER.getHexColor()); + else if (Modifier.isPrivate(mods)) + addSegment("private ", TokenType.MODIFIER.getHexColor()); + + if (Modifier.isStatic(mods)) + addSegment("static ", TokenType.MODIFIER.getHexColor()); + if (Modifier.isFinal(mods)) + addSegment("final ", TokenType.MODIFIER.getHexColor()); + if (Modifier.isVolatile(mods)) + addSegment("volatile ", TokenType.MODIFIER.getHexColor()); + if (Modifier.isTransient(mods)) + addSegment("transient ", TokenType.MODIFIER.getHexColor()); + } + + /** + * Get the appropriate color for a Class based on its type. + */ + private int getColorForClass(Class clazz) { + if(clazz.isPrimitive()) return TokenType.KEYWORD.getHexColor(); + if (clazz.isInterface()) return TokenType.INTERFACE_DECL.getHexColor(); + if (clazz.isEnum()) return TokenType.ENUM_DECL.getHexColor(); + return TokenType.IMPORTED_CLASS.getHexColor(); + } + + /** + * Get the appropriate color for a TypeInfo based on its type kind. + * Works for both Java-backed TypeInfo and ScriptTypeInfo. + */ + private int getColorForTypeInfo(TypeInfo typeInfo) { + // Use the TypeInfo's own token type, which handles ScriptTypeInfo correctly + return TokenType.getColor(typeInfo); + } + + /** + * Add initialization tokens from the field's initializer to the declaration. + * Fetches the tokens in the initialization range and adds them with their proper coloring. + */ + private void addInitializationTokens(Token token, FieldInfo fieldInfo) { + if (!fieldInfo.hasInitializer()) return; + + ScriptLine line = token.getParentLine(); + if (line == null || line.getParent() == null) return; + + ScriptDocument doc = line.getParent(); + // Include the semicolon by extending range by 1 + List initTokens = doc.getTokensInRange(fieldInfo.getInitStart(), fieldInfo.getInitEnd() + 1); + + if (initTokens.isEmpty()) return; + + // Add space before '=' for readability + addSegment(" ", TokenType.DEFAULT.getHexColor()); + + // Add each token with its proper color, ensuring normalized spacing between tokens + String lastText = null; + for (Token initToken : initTokens) { + String text = initToken.getText(); + + // Normalize whitespace - replace all newlines and multiple spaces with single space + text = text.replaceAll("\\s+", " ").trim(); + + // Skip if token became empty after whitespace removal + if (text.isEmpty()) { + continue; + } + + // Determine if we need a space between last token and current token + if (lastText != null && shouldAddSpace(lastText, text)) { + addSegment(" ", TokenType.DEFAULT.getHexColor()); + } + + addSegment(text, initToken.getType().getHexColor()); + lastText = text; + } + } + + /** + * Determine if a space should be added between two tokens. + */ + private boolean shouldAddSpace(String lastToken, String currentToken) { + if (lastToken.isEmpty() || currentToken.isEmpty()) + return false; + + char lastChar = lastToken.charAt(lastToken.length() - 1); + char firstChar = currentToken.charAt(0); + + // Never add space before these closing/trailing characters + if (firstChar == '(' || firstChar == '[' || firstChar == '{' || + firstChar == '.' || firstChar == ',' || firstChar == ';' || + firstChar == '>' || // No space before closing angle bracket + (firstChar == ':' && lastToken.equals("?"))) { + return false; + } + + // Never add space after these opening/leading characters + if (lastChar == '(' || lastChar == '[' || lastChar == '{' || + lastChar == '.' || lastChar == '<') { // No space after opening angle bracket + return false; + } + + // Add space around operators (check last/first characters) + if (isOperatorChar(lastChar) || isOperatorChar(firstChar)) { + return true; + } + + // Add space after closing brackets/parens before other tokens + if (lastChar == ')' || lastChar == ']' || lastChar == '}') { + return true; + } + + // Add space after colons and commas (except after ?: ternary) + if ((lastChar == ':' && !lastToken.equals("?:")) || lastChar == ',') { + return true; + } + + // Add space between identifiers/keywords and numbers + boolean lastIsIdentifier = Character.isLetterOrDigit(lastChar) || lastChar == '_'; + boolean firstIsIdentifier = Character.isLetterOrDigit(firstChar) || firstChar == '_'; + if (lastIsIdentifier && firstIsIdentifier) { + return true; + } + + return false; + } + + /** + * Check if a character is an operator that needs spacing. + */ + private boolean isOperatorChar(char c) { + return "+-*/%<>=!&|^?:".indexOf(c) >= 0; + } + // ==================== GETTERS ==================== + + public String getPackageName() { return packageName; } + public String getIconIndicator() { return iconIndicator; } + + public List getDeclaration() { + return declaration; + } + public List getDocumentation() { return documentation; } + + public List getJSDocLines() { + return jsDocLines; + } + public List getErrors() { return errors; } + public List getAdditionalInfo() { return additionalInfo; } + public Token getToken() { return token; } + + public boolean hasContent() { + return !declaration.isEmpty() || !errors.isEmpty() || !documentation.isEmpty() || !jsDocLines.isEmpty(); + } + + public boolean hasJSDocContent() { + return !jsDocLines.isEmpty(); + } + + public boolean hasErrors() { + return !errors.isEmpty(); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/hover/TokenHoverRenderer.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/hover/TokenHoverRenderer.java new file mode 100644 index 000000000..f3215b1a9 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/hover/TokenHoverRenderer.java @@ -0,0 +1,744 @@ +package noppes.npcs.client.gui.util.script.interpreter.hover; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.Gui; +import net.minecraft.client.gui.ScaledResolution; +import noppes.npcs.client.ClientProxy; +import noppes.npcs.client.gui.util.GuiNPCInterface; +import org.lwjgl.opengl.GL11; + +import java.util.ArrayList; +import java.util.List; + +/** + * Renders hover tooltips for tokens in the script editor. + * + * Renders IntelliJ-style tooltips with: + * - Package name in gray + * - Icon indicator (C/I/E/m/f/v/p) + * - Colored declaration line + * - Documentation/Javadoc + * - Error messages in red + * + * Uses a unified approach for width/height calculation based on max available width. + */ +public class TokenHoverRenderer { + + // ==================== CONSTANTS ==================== + + /** Padding inside the tooltip box */ + private static final int PADDING = 6; + + /** Line spacing between rows */ + private static final int LINE_SPACING = 2; + + /** Separator line height */ + private static final int SEPARATOR_HEIGHT = 1; + + /** Spacing above and below separator */ + private static final int SEPARATOR_SPACING = 5; + + /** Vertical offset from token */ + private static final int VERTICAL_OFFSET = 4; + + /** Maximum tooltip width as percentage of viewport */ + private static final float MAX_WIDTH_RATIO = 0.9f; + + /** Minimum tooltip width */ + private static final int MIN_WIDTH = 50; + + // ==================== COLORS ==================== + + /** Background color (dark gray like IntelliJ) */ + private static final int BG_COLOR = 0xF0313335; + + /** Border color */ + private static final int BORDER_COLOR = 0xFF3C3F41; + + /** Package text color */ + private static int PACKAGE_COLOR = 0xFF6490e2; + + /** Error text color */ + private static final int ERROR_COLOR = 0xFFFF6B68; + + /** Info text color */ + private static final int INFO_COLOR = 0xFF808080; + + /** Documentation text color */ + private static final int DOC_COLOR = 0xFFA9B7C6; + + /** Background fill for ``` code blocks */ + private static final int CODE_BG_COLOR = 0xFF1E1F22; + /** Left accent bar color for code blocks */ + private static final int CODE_ACCENT_COLOR = 0xFF4FC1FF; + /** Horizontal padding inside code block */ + private static final int CODE_INDENT = 10; + /** Vertical padding above/below code block content */ + private static final int CODE_VPAD = 6; + /** Fixed visual gap between last content line and the panel bottom (always visible, regardless of scroll) */ + private static final int BOTTOM_GAP = 4; + + // ==================== RENDERING ==================== + + /** + * Render the hover tooltip. + */ + public static void render(HoverState hoverState, int viewportX, int viewportWidth, int viewportY, int viewportHeight, GuiNPCInterface gui) { + if (!hoverState.isTooltipVisible()) return; + hoverState.updateSmoothScroll(); + + TokenHoverInfo info = hoverState.getHoverInfo(); + if (info == null || !info.hasContent()) return; + + int lineHeight = ClientProxy.Font.height(); + int tokenX = hoverState.getTokenScreenX(); + int tokenY = hoverState.getTokenScreenY(); + + // Screen dimensions for clamping when the panel has been dragged outside the editor viewport + Minecraft mc2 = Minecraft.getMinecraft(); + ScaledResolution sr2 = new ScaledResolution(mc2, mc2.displayWidth, mc2.displayHeight); + int screenW = sr2.getScaledWidth(); + int screenH = sr2.getScaledHeight(); + boolean positionOverridden = hoverState.hasOverriddenPosition(); + // Use screen bounds whenever the panel has been dragged OR resized — both escape the editor viewport + boolean useScreenBounds = positionOverridden || hoverState.hasOverriddenSize(); + + // Calculate max available width for content + int maxContentWidth = getMaxContentWidth(viewportX, viewportWidth, tokenX); + + // Calculate actual content width needed (clamped to max) + int contentWidth = calculateContentWidth(info, maxContentWidth); + + // Cap visible height at 60% of viewport + int totalContentHeight = calculateContentHeight(info, contentWidth); + int maxVisibleContentHeight = (int)((useScreenBounds ? screenH : viewportHeight) * 0.60f); + if (totalContentHeight > maxVisibleContentHeight) { + // Scrollbar will appear, reducing effective wrap width by 6px — re-measure for accurate height + totalContentHeight = calculateContentHeight(info, contentWidth - 6); + } + int visibleContentHeight = Math.min(totalContentHeight, maxVisibleContentHeight); + + // Box dimensions — use visibleContentHeight so positioning matches rendering + int boxWidth = contentWidth + PADDING * 2; + int boxHeight = visibleContentHeight + PADDING * 2; + + // Apply user size override when the panel has been resized + if (hoverState.hasOverriddenSize()) { + int overW = Math.max(MIN_WIDTH + PADDING * 2, hoverState.getOverriddenTooltipW()); + int overH = Math.max(lineHeight + PADDING * 2, hoverState.getOverriddenTooltipH()); + boxWidth = overW; + visibleContentHeight = overH - PADDING * 2; + boxHeight = overH; + // Re-measure with new wrap width so scrollbar detection is accurate + int newContentW = boxWidth - PADDING * 2; + totalContentHeight = calculateContentHeight(info, newContentW); + if (totalContentHeight > visibleContentHeight) { + totalContentHeight = calculateContentHeight(info, newContentW - 6); + } + } + + // Position the tooltip — use dragged position if user has panned the panel + int tooltipX = positionOverridden ? hoverState.getOverriddenTooltipX() : tokenX; + int tooltipY = positionOverridden ? hoverState.getOverriddenTooltipY() : tokenY + lineHeight + VERTICAL_OFFSET; + + // Clamp position — use screen bounds when user has dragged the panel outside the editor viewport + int leftBound = useScreenBounds ? 0 : viewportX; + int rightBound = useScreenBounds ? screenW : viewportX + viewportWidth; + int topBound = useScreenBounds ? 0 : viewportY; + int bottomBound = useScreenBounds ? screenH : viewportY + viewportHeight; + + if (tooltipX + boxWidth > rightBound) { + tooltipX = rightBound - boxWidth; + } + if (tooltipX < leftBound) { + tooltipX = leftBound; + } + + // If box still doesn't fit horizontally, shrink it + int availableWidth = rightBound - tooltipX; + if (boxWidth > availableWidth) { + boxWidth = availableWidth; + } + + if (tooltipY + boxHeight > bottomBound) { + if (useScreenBounds) { + tooltipY = bottomBound - boxHeight; + } else { + tooltipY = tokenY - boxHeight - VERTICAL_OFFSET; // try above token + } + } + if (tooltipY < topBound) { + tooltipY = topBound; + } + + // Record actual panel rect for drag hit-testing + hoverState.setTooltipPanel(tooltipX, tooltipY, boxWidth, boxHeight); + + // Mouse-over detection bounds: + // When dragged, use panel rect only — no gap extension (token is unrelated to panel position) + // When default, union the token bottom and the tooltip rect so both directions are covered + if (hoverState.hasOverriddenPosition()) { + hoverState.setTooltipBounds(tooltipX, tooltipY, boxWidth, boxHeight); + } else { + int boundsTopY = Math.min(tokenY + lineHeight, tooltipY); + int boundsBottomY = Math.max(tooltipY + boxHeight, tokenY + lineHeight); + hoverState.setTooltipBounds(tooltipX, boundsTopY, boxWidth, boundsBottomY - boundsTopY); + } + + // Render the tooltip + renderTooltipBox(tooltipX, tooltipY, boxWidth, maxContentWidth, info, hoverState, + totalContentHeight, visibleContentHeight, gui); + } + + /** + * Calculate the maximum content width based on viewport and token position. + */ + private static int getMaxContentWidth(int viewportX, int viewportWidth, int tokenX) { + // Max width is based on viewport size (80% by default) + // This scales naturally with viewport size - no artificial hard cap + int maxWidth = (int)(viewportWidth * MAX_WIDTH_RATIO); + + // The tooltip can expand across the entire viewport width + // (positioning logic will shift it left if needed) + return Math.max(MIN_WIDTH, maxWidth); + } + + /** + * Render the tooltip box with all content. + */ + private static void renderTooltipBox(int x, int y, int boxWidth, int wrapWidth, TokenHoverInfo info, + HoverState hoverState, int totalContentHeight, int visibleContentHeight, GuiNPCInterface gui) { + + boolean hasScrollbar = totalContentHeight > visibleContentHeight; + // Wrap at the actual box content area width, not the max allowed width. + // Using maxContentWidth here caused lines to never wrap at wide viewports (fullscreen). + int contentWrapWidth = boxWidth - PADDING * 2; + int effectiveWrapWidth = hasScrollbar ? contentWrapWidth - 6 : contentWrapWidth; + + int boxHeight = visibleContentHeight + PADDING * 2; + + // Store scroll metadata into HoverState + hoverState.setTooltipMaxScroll(Math.max(0, totalContentHeight - visibleContentHeight + BOTTOM_GAP)); + + // Draw background + Gui.drawRect(x, y, x + boxWidth, y + boxHeight, BG_COLOR); + + // Draw border + Gui.drawRect(x, y, x + boxWidth, y + 1, BORDER_COLOR); + Gui.drawRect(x, y + boxHeight - 1, x + boxWidth, y + boxHeight, BORDER_COLOR); + Gui.drawRect(x, y, x + 1, y + boxHeight, BORDER_COLOR); + Gui.drawRect(x + boxWidth - 1, y, x + boxWidth, y + boxHeight, BORDER_COLOR); + + Minecraft mc = Minecraft.getMinecraft(); + ScaledResolution sr = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight); + int sf = sr.getScaleFactor(); + double panX = gui != null ? gui.getPanX() : 0; + double panY = gui != null ? gui.getPanY() : 0; + int clipX = (int)((x + 1 - panX) * sf); + int clipY = (int)((sr.getScaledHeight() - (y - panY + boxHeight - 1 - BOTTOM_GAP)) * sf); + int clipW = (hasScrollbar ? boxWidth - PADDING - 1 : boxWidth - 2) * sf; + int clipH = (boxHeight - 2 - BOTTOM_GAP) * sf; + GL11.glEnable(GL11.GL_SCISSOR_TEST); + GL11.glScissor(clipX, clipY, clipW, clipH); + + int textX = x + PADDING; + int currentY = y + PADDING - hoverState.getTooltipScrollOffset(); + int lineHeight = ClientProxy.Font.height(); + + String packageName = info.getPackageName(); + List declaration = info.getDeclaration(); + List docs = info.getDocumentation(); + List additionalInfo = info.getAdditionalInfo(); + + // Draw errors first + List errors = info.getErrors(); + if (!errors.isEmpty()) { + for (String error : errors) { + List wrappedLines = wrapText(error, effectiveWrapWidth); + for (String line : wrappedLines) { + drawText(textX, currentY, line, ERROR_COLOR); + currentY += lineHeight + LINE_SPACING; + } + } + boolean onlyErrors = errors != null && !errors.isEmpty() && (packageName == null || packageName.isEmpty()) && (declaration == null || + declaration.isEmpty()) && (docs == null || docs.isEmpty()) && (additionalInfo == null || additionalInfo.isEmpty()); + + if (!onlyErrors) { //Add error separator line + currentY += SEPARATOR_HEIGHT + SEPARATOR_SPACING - 5; + Gui.drawRect(textX, currentY, x + boxWidth - PADDING, currentY + SEPARATOR_HEIGHT, BORDER_COLOR); + currentY += SEPARATOR_HEIGHT + SEPARATOR_SPACING; + } + currentY += LINE_SPACING; + } + + // Draw package name + if (packageName != null && !packageName.isEmpty()) { + String packageText = "\u25CB " + packageName; + List wrappedLines = wrapText(packageText, effectiveWrapWidth); + for (String line : wrappedLines) { + drawText(textX, currentY, line, PACKAGE_COLOR); + currentY += lineHeight + LINE_SPACING; + } + } + + // Draw declaration (colored segments with wrapping) + if (!declaration.isEmpty()) { + currentY = drawWrappedSegments(textX, currentY, effectiveWrapWidth, declaration); + currentY += LINE_SPACING; + } + + // Draw documentation (plain text) + if (!docs.isEmpty()) { + // Draw separator line before documentation + Gui.drawRect(textX, currentY, x + boxWidth - PADDING, currentY + SEPARATOR_HEIGHT, BORDER_COLOR); + currentY += SEPARATOR_HEIGHT + SEPARATOR_SPACING; + for (String doc : docs) { + List wrappedLines = wrapText(doc, effectiveWrapWidth); + for (String line : wrappedLines) { + drawText(textX, currentY, line, DOC_COLOR); + currentY += lineHeight + LINE_SPACING; + } + } + } + + // Draw JSDoc-formatted documentation with colored segments + List jsDocLines = info.getJSDocLines(); + if (!jsDocLines.isEmpty()) { + // Draw separator line if there was plain documentation or declaration + if (docs.isEmpty() && !declaration.isEmpty()) { + Gui.drawRect(textX, currentY, x + boxWidth - PADDING, currentY + SEPARATOR_HEIGHT, BORDER_COLOR); + currentY += SEPARATOR_HEIGHT + SEPARATOR_SPACING; + } + + boolean previousVisibleJSDocWasCode = false; + for (int di = 0; di < jsDocLines.size(); di++) { + TokenHoverInfo.DocumentationLine docLine = jsDocLines.get(di); + + if (docLine.isCodeBlockFirst) { + // Lookahead: measure full block height + int blockH = CODE_VPAD; + for (int k = di; k < jsDocLines.size() && jsDocLines.get(k).isCodeLine; k++) { + TokenHoverInfo.DocumentationLine cl = jsDocLines.get(k); + if (!cl.isEmpty()) { + int clIndent = cl.codeLeadingSpaces * ClientProxy.Font.width(" "); + int clWrapW = Math.max(10, effectiveWrapWidth - CODE_INDENT - clIndent); + blockH += calculateSegmentsHeight(clWrapW, cl.segments) + LINE_SPACING; + } else { + blockH += lineHeight / 2; + } + } + blockH -= LINE_SPACING * 2; // subtract trailing LINE_SPACING (present inside bg) + one more to visually balance top/bottom + blockH += CODE_VPAD; + // Draw background + Gui.drawRect(textX , currentY - CODE_VPAD, + textX + effectiveWrapWidth + 4, currentY - CODE_VPAD + blockH, + CODE_BG_COLOR); + // Left accent bar + Gui.drawRect(textX, currentY - CODE_VPAD, + textX+2, currentY - CODE_VPAD + blockH, + CODE_ACCENT_COLOR); + } + + if (docLine.isCodeLine) { + if (!docLine.isEmpty()) { + int explicitIndent = docLine.codeLeadingSpaces * ClientProxy.Font.width(" "); + int codeX = textX + CODE_INDENT + explicitIndent; + int codeWrapW = Math.max(10, effectiveWrapWidth - CODE_INDENT - explicitIndent); + currentY = drawWrappedSegments(codeX, currentY, codeWrapW, docLine.segments); + currentY += LINE_SPACING; + previousVisibleJSDocWasCode = true; + } else { + currentY += lineHeight / 2; + } + } else if (!docLine.isEmpty()) { + if (previousVisibleJSDocWasCode) { + currentY += LINE_SPACING; + } + currentY = drawWrappedSegments(textX, currentY, effectiveWrapWidth, docLine.segments); + currentY += LINE_SPACING; + previousVisibleJSDocWasCode = false; + } else { + currentY += (di > 0 && jsDocLines.get(di - 1).isCodeLine) ? LINE_SPACING : lineHeight / 2; + } + } + } + + // Draw additional info + if (!additionalInfo.isEmpty()) { + currentY += LINE_SPACING; + for (String infoLine : additionalInfo) { + List wrappedLines = wrapText(infoLine, effectiveWrapWidth); + for (String line : wrappedLines) { + drawText(textX, currentY, line, INFO_COLOR); + currentY += lineHeight + LINE_SPACING; + } + } + } + + // Restore scissor state before drawing scrollbar (scrollbar must not be clipped) + GL11.glDisable(GL11.GL_SCISSOR_TEST); + + // Draw scrollbar outside scissor rect so it is never clipped + if (hasScrollbar) { + int scrollbarX = x + boxWidth - PADDING; + int scrollbarTrackTop = y + PADDING; + int scrollbarTrackHeight = visibleContentHeight - 4; // leave room for resize handle + // Track + Gui.drawRect(scrollbarX, scrollbarTrackTop, scrollbarX + 3, + scrollbarTrackTop + scrollbarTrackHeight, 0x40888888); + // Thumb + float scrollRatio = (float) visibleContentHeight / (totalContentHeight + BOTTOM_GAP); + int thumbHeight = Math.max(6, (int)(scrollbarTrackHeight * scrollRatio)); + int effectiveMaxScroll = totalContentHeight - visibleContentHeight + BOTTOM_GAP; + // Clamp scrollProgress to [0,1] — guards against stale offset after resize shrinks content + float scrollProgress = effectiveMaxScroll > 0 + ? Math.min(1f, (float) hoverState.getTooltipScrollOffset() / effectiveMaxScroll) : 0f; + int thumbY = scrollbarTrackTop + (int)((scrollbarTrackHeight - thumbHeight) * scrollProgress); + // Clamp thumb within track bounds defensively + thumbY = Math.max(scrollbarTrackTop, Math.min(scrollbarTrackTop + scrollbarTrackHeight - thumbHeight, thumbY)); + // Store thumb bounds in HoverState for drag/hover detection + hoverState.setScrollbarThumb(scrollbarX, thumbY, thumbHeight, scrollbarTrackTop, scrollbarTrackHeight); + // Highlight thumb when hovered or dragging (darker = active, like AutocompleteMenu) + int mouseX = hoverState.getLastMouseX(); + int mouseY = hoverState.getLastMouseY(); + boolean thumbActive = hoverState.isDraggingScrollbar() + || hoverState.isMouseOverScrollbarThumb(mouseX, mouseY); + int thumbColor = thumbActive ? 0xFFCCCCCC : 0xFF808080; + Gui.drawRect(scrollbarX, thumbY, scrollbarX + 3, thumbY + thumbHeight, thumbColor); + } + + // Draw resize handle at bottom-right corner (outside scissor, same as scrollbar) + { + int mouseX = hoverState.getLastMouseX(); + int mouseY = hoverState.getLastMouseY(); + boolean resizeActive = hoverState.isResizingTooltip() + || hoverState.isMouseOverResizeHandle(mouseX, mouseY); + int dotColor = resizeActive ? 0xFFCCCCCC : 0x80888888; + int rhX = x + boxWidth - 2; + int rhY = y + boxHeight - 2; + // Three-dot diagonal pattern (◢) + Gui.drawRect(rhX - 1, rhY - 1, rhX, rhY, dotColor); + Gui.drawRect(rhX - 3, rhY - 1, rhX - 2, rhY, dotColor); + Gui.drawRect(rhX - 1, rhY - 3, rhX, rhY - 2, dotColor); + Gui.drawRect(rhX - 5, rhY - 1, rhX - 4, rhY, dotColor); + Gui.drawRect(rhX - 3, rhY - 3, rhX - 2, rhY - 2, dotColor); + Gui.drawRect(rhX - 1, rhY - 5, rhX, rhY - 4, dotColor); + } + } + + /** + * Draw colored text segments with word wrapping. + * Returns the Y position after drawing. + */ + private static int drawWrappedSegments(int startX, int startY, int maxWidth, List segments) { + int lineHeight = ClientProxy.Font.height(); + int currentX = startX; + int currentY = startY; + + for (TokenHoverInfo.TextSegment segment : segments) { + String text = segment.text; + int color = 0xFF000000 | segment.color; + + // Split segment into words for wrapping + String[] words = text.split("(?<=\\s)|(?=\\s)"); // Keep whitespace as separate tokens + + for (String word : words) { + int wordWidth = ClientProxy.Font.width(word); + + // Check if word fits on current line + if (currentX + wordWidth > startX + maxWidth && currentX > startX) { + // Wrap to next line + currentY += lineHeight + LINE_SPACING; + currentX = startX; + + // Skip leading whitespace on new line + if (word.trim().isEmpty()) { + continue; + } + } + + drawText(currentX, currentY, word, color); + currentX += wordWidth; + } + } + + return currentY + lineHeight; + } + + /** + * Wrap text to fit within maxWidth. + * Returns list of lines. + */ + private static List wrapText(String text, int maxWidth) { + List lines = new ArrayList<>(); + + if (text == null || text.isEmpty()) { + return lines; + } + + // First split by explicit newlines + String[] paragraphs = text.split("\n", -1); // -1 to preserve trailing empty lines + + for (String paragraph : paragraphs) { + if (paragraph.isEmpty()) { + lines.add(""); + continue; + } + + // Then apply word wrapping to each paragraph + String[] words = paragraph.split(" "); + StringBuilder currentLine = new StringBuilder(); + + for (String word : words) { + String testLine = currentLine.length() == 0 ? word : currentLine + " " + word; + int testWidth = ClientProxy.Font.width(testLine); + + if (testWidth > maxWidth && currentLine.length() > 0) { + lines.add(currentLine.toString()); + currentLine = new StringBuilder(word); + } else { + if (currentLine.length() > 0) { + currentLine.append(" "); + } + currentLine.append(word); + } + } + + if (currentLine.length() > 0) { + lines.add(currentLine.toString()); + } + } + + if (lines.isEmpty()) { + lines.add(text); + } + return lines; + } + + /** + * Draw text using the font renderer. + */ + private static void drawText(int x, int y, String text, int color) { + ClientProxy.Font.drawString(text, x, y, color); + } + + // ==================== DIMENSION CALCULATION ==================== + + /** + * Calculate the width needed for the content, clamped to maxWidth. + * Returns the width of the longest wrapped line. + */ + private static int calculateContentWidth(TokenHoverInfo info, int maxWidth) { + int longestLineWidth = 0; + + // Package name + String packageName = info.getPackageName(); + if (packageName != null && !packageName.isEmpty()) { + String packageText = "\u25CB " + packageName; + List wrappedLines = wrapText(packageText, maxWidth); + for (String line : wrappedLines) { + longestLineWidth = Math.max(longestLineWidth, ClientProxy.Font.width(line)); + } + } + + // Declaration - wrap segments and find longest line + if (!info.getDeclaration().isEmpty()) { + int declarationLongestLine = calculateSegmentsLongestLine(maxWidth, info.getDeclaration()); + longestLineWidth = Math.max(longestLineWidth, declarationLongestLine); + } + + // Errors + for (String error : info.getErrors()) { + List wrappedLines = wrapText(error, maxWidth); + for (String line : wrappedLines) { + longestLineWidth = Math.max(longestLineWidth, ClientProxy.Font.width(line)); + } + } + + // Documentation + for (String doc : info.getDocumentation()) { + List wrappedLines = wrapText(doc, maxWidth); + for (String line : wrappedLines) { + longestLineWidth = Math.max(longestLineWidth, ClientProxy.Font.width(line)); + } + } + + // JSDoc-formatted documentation lines + List jsDocLines = info.getJSDocLines(); + if (jsDocLines != null) { + for (TokenHoverInfo.DocumentationLine docLine : jsDocLines) { + if (!docLine.isEmpty()) { + int explicitIndent = docLine.isCodeLine + ? CODE_INDENT + docLine.codeLeadingSpaces * ClientProxy.Font.width(" ") + : 0; + int lineLongest = calculateSegmentsLongestLine(maxWidth - explicitIndent, docLine.segments) + explicitIndent; + longestLineWidth = Math.max(longestLineWidth, lineLongest); + } + } + } + + // Additional info + for (String line : info.getAdditionalInfo()) { + List wrappedLines = wrapText(line, maxWidth); + for (String wrappedLine : wrappedLines) { + longestLineWidth = Math.max(longestLineWidth, ClientProxy.Font.width(wrappedLine)); + } + } + + // Ensure minimum width + return Math.max(50, longestLineWidth); + } + + /** + * Calculate the height needed for the content given the available width. + * Uses the same wrapping logic as rendering. + */ + private static int calculateContentHeight(TokenHoverInfo info, int contentWidth) { + int lineHeight = ClientProxy.Font.height(); + int totalHeight = 0; + + String packageName = info.getPackageName(); + List declaration = info.getDeclaration(); + List docs = info.getDocumentation(); + List jsDocLines = info.getJSDocLines(); + List additionalInfo = info.getAdditionalInfo(); + + // Errors + List errors = info.getErrors(); + if (!errors.isEmpty()) { + for (String error : errors) { + List wrappedLines = wrapText(error, contentWidth); + totalHeight += wrappedLines.size() * (lineHeight + LINE_SPACING); + } + + boolean onlyErrors = errors != null && !errors.isEmpty() && (packageName == null || packageName.isEmpty()) && (declaration == null || + declaration.isEmpty()) && (docs == null || docs.isEmpty()) && (jsDocLines == null || jsDocLines.isEmpty()) && (additionalInfo == null || additionalInfo.isEmpty()); + + if (!onlyErrors) //Add error separator height + totalHeight += (SEPARATOR_SPACING + SEPARATOR_HEIGHT) * 2 - 5; + + totalHeight += LINE_SPACING; // Extra space after errors + } + + // Package name + if (packageName != null && !packageName.isEmpty()) { + String packageText = "\u25CB " + packageName; + List wrappedLines = wrapText(packageText, contentWidth); + totalHeight += wrappedLines.size() * (lineHeight + LINE_SPACING); + } + + // Declaration (colored segments with wrapping) + if (!declaration.isEmpty()) { + totalHeight += calculateSegmentsHeight(contentWidth, declaration); + totalHeight += LINE_SPACING; + } + + // Documentation (plain text) + if (!docs.isEmpty()) { + // Add space for separator line and spacing + totalHeight += SEPARATOR_SPACING + SEPARATOR_HEIGHT; + for (String doc : docs) { + List wrappedLines = wrapText(doc, contentWidth); + totalHeight += wrappedLines.size() * (lineHeight + LINE_SPACING); + } + } + + // JSDoc-formatted documentation lines + if (jsDocLines != null && !jsDocLines.isEmpty()) { + if (docs.isEmpty() && !declaration.isEmpty()) { + totalHeight += SEPARATOR_HEIGHT + SEPARATOR_SPACING; + } + + boolean previousVisibleJSDocWasCode = false; + for (int i = 0; i < jsDocLines.size(); i++) { + TokenHoverInfo.DocumentationLine docLine = jsDocLines.get(i); + if (!docLine.isEmpty()) { + int explicitIndent = docLine.isCodeLine + ? docLine.codeLeadingSpaces * ClientProxy.Font.width(" ") + : 0; + int wrapW = Math.max(10, contentWidth - (docLine.isCodeLine ? CODE_INDENT : 0) - explicitIndent); + if (!docLine.isCodeLine && previousVisibleJSDocWasCode) { + totalHeight += LINE_SPACING; + } + totalHeight += calculateSegmentsHeight(wrapW, docLine.segments); + totalHeight += LINE_SPACING; + previousVisibleJSDocWasCode = docLine.isCodeLine; + } else { + totalHeight += (i > 0 && jsDocLines.get(i - 1).isCodeLine) ? LINE_SPACING : lineHeight / 2; + } + } + } + + // Additional info + if (!additionalInfo.isEmpty()) { + totalHeight += LINE_SPACING; + for (String infoLine : additionalInfo) { + List wrappedLines = wrapText(infoLine, contentWidth); + totalHeight += wrappedLines.size() * (lineHeight + LINE_SPACING); + } + } + return Math.max(lineHeight, Math.max(0, totalHeight - LINE_SPACING))-2; + } + + /** + * Calculate height needed for wrapped segments. + */ + private static int calculateSegmentsHeight(int maxWidth, List segments) { + int lineHeight = ClientProxy.Font.height(); + int currentLineWidth = 0; + int lineCount = 1; + + for (TokenHoverInfo.TextSegment segment : segments) { + String text = segment.text; + String[] words = text.split("(?<=\\s)|(?=\\s)"); + + for (String word : words) { + int wordWidth = ClientProxy.Font.width(word); + + if (currentLineWidth + wordWidth > maxWidth && currentLineWidth > 0) { + lineCount++; + currentLineWidth = word.trim().isEmpty() ? 0 : wordWidth; + } else { + currentLineWidth += wordWidth; + } + } + } + + if (lineCount <= 0) { + return 0; + } + + // Total height = (lines * lineHeight) + (spacing between lines) + return (lineCount * lineHeight) + ((lineCount - 1) * LINE_SPACING); + } + + /** + * Calculate the width of the longest line when segments are wrapped. + */ + private static int calculateSegmentsLongestLine(int maxWidth, List segments) { + int currentLineWidth = 0; + int longestLineWidth = 0; + + for (TokenHoverInfo.TextSegment segment : segments) { + String text = segment.text; + String[] words = text.split("(?<=\\s)|(?=\\s)"); + + for (String word : words) { + int wordWidth = ClientProxy.Font.width(word); + + if (currentLineWidth + wordWidth > maxWidth && currentLineWidth > 0) { + // Line break - record current line width and start new line + longestLineWidth = Math.max(longestLineWidth, currentLineWidth); + currentLineWidth = word.trim().isEmpty() ? 0 : wordWidth; + } else { + currentLineWidth += wordWidth; + } + } + } + + // Don't forget the last line + longestLineWidth = Math.max(longestLineWidth, currentLineWidth); + + return longestLineWidth; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/DTSJSDocParser.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/DTSJSDocParser.java new file mode 100644 index 000000000..74b3cb280 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/DTSJSDocParser.java @@ -0,0 +1,236 @@ +package noppes.npcs.client.gui.util.script.interpreter.js_parser; + +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.*; + +import java.util.ArrayList; +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public class DTSJSDocParser { + + private static final Pattern JSDOC_BLOCK_PATTERN = Pattern.compile( + "/\\*\\*\\s*(.*?)\\*/", Pattern.DOTALL); + + private static final Pattern TAG_PATTERN = Pattern.compile( + "@(\\w+)(?:\\s+\\{([^}]+)\\})?(?:\\s+(.*))?"); + + private static final Pattern PARAM_PATTERN = Pattern.compile( + "@param(?:\\s+\\{([^}]+)\\})?(?:\\s+(\\w+))?(?:\\s+(.*))?"); + + private static final Pattern RETURN_PATTERN = Pattern.compile( + "@returns?\\s+(?:\\{([^}]+)\\}\\s*)?(.*)"); + + private static final Pattern TYPE_PATTERN = Pattern.compile( + "@type(?:\\s+\\{([^}]+)\\})?(?:\\s+(.*))?"); + + public static JSDocInfo parseJSDocBlock(String jsDocContent) { + if (jsDocContent == null || jsDocContent.isEmpty()) { + return null; + } + + JSDocInfo info = new JSDocInfo(jsDocContent, -1, -1); + + String[] lines = jsDocContent.split("\\r?\\n"); + StringBuilder descriptionBuilder = new StringBuilder(); + boolean foundFirstTag = false; + JSDocTag lastTag = null; + + for (String line : lines) { + line = cleanLine(line); + if (line.startsWith("@")) { + foundFirstTag = true; + lastTag = parseTag(line, info); + } else if (!foundFirstTag) { + if (line.isEmpty()) { + // Preserve blank lines as paragraph gaps (only if description has started) + if (descriptionBuilder.length() > 0) { + descriptionBuilder.append("\n"); + } + } else { + if (descriptionBuilder.length() > 0) { + descriptionBuilder.append("\n"); + } + descriptionBuilder.append(line); + } + } else if (lastTag != null) { + if (!line.isEmpty()) { + String existing = lastTag.getDescription(); + if (existing == null || existing.isEmpty()) { + lastTag.setDescription(line); + } else { + lastTag.setDescription(existing + "\n" + line); + } + } + } + } + + if (descriptionBuilder.length() > 0) { + info.setDescription(descriptionBuilder.toString().trim()); + } + + return info; + } + + private static String cleanLine(String line) { + // Strip outer leading whitespace (before the * marker) and all trailing whitespace + line = line.trim(); + if (line.startsWith("/**")) { + line = line.substring(3).trim(); + } + if (line.endsWith("*/")) { + line = line.substring(0, line.length() - 2); + // Strip trailing whitespace between content and */ but preserve leading spaces + int end = line.length(); + while (end > 0 && Character.isWhitespace(line.charAt(end - 1))) end--; + line = line.substring(0, end); + } + if (line.startsWith("*")) { + line = line.substring(1); // strip the leading * + // Consume exactly ONE space after * (the JSDoc conventional separator). + // Remaining leading spaces are intentional indentation (e.g. inside code fences). + if (!line.isEmpty() && line.charAt(0) == ' ') { + line = line.substring(1); + } + // Strip trailing whitespace + int end = line.length(); + while (end > 0 && Character.isWhitespace(line.charAt(end - 1))) end--; + line = line.substring(0, end); + } + return line; + } + + private static JSDocTag parseTag(String line, JSDocInfo info) { + Matcher paramMatcher = PARAM_PATTERN.matcher(line); + if (paramMatcher.find()) { + String type = paramMatcher.group(1); + String name = paramMatcher.group(2); + String desc = paramMatcher.group(3); + if (desc == null && type == null && name != null) { + desc = name; + name = null; + } + if (desc != null) { + desc = desc.trim(); + if (desc.isEmpty()) { + desc = null; + } + } + JSDocParamTag tag = JSDocParamTag.create(-1, -1, -1, + type, null, -1, -1, name, -1, -1, desc); + info.addParamTag(tag); + return tag; + } + + Matcher returnMatcher = RETURN_PATTERN.matcher(line); + if (returnMatcher.find()) { + String type = returnMatcher.group(1); + String desc = returnMatcher.group(2); + if (desc != null) { + desc = desc.trim(); + if (desc.isEmpty()) { + desc = null; + } + } + JSDocReturnTag tag = JSDocReturnTag.create("return", -1, -1, -1, + type, null, -1, -1, desc); + info.setReturnTag(tag); + return tag; + } + + Matcher typeMatcher = TYPE_PATTERN.matcher(line); + if (typeMatcher.find()) { + String type = typeMatcher.group(1); + String desc = typeMatcher.group(2); + if (desc != null) { + desc = desc.trim(); + if (desc.isEmpty()) { + desc = null; + } + } + JSDocTypeTag tag = JSDocTypeTag.create(-1, -1, -1, + type, null, -1, -1, desc); + info.setTypeTag(tag); + return tag; + } + + Matcher tagMatcher = TAG_PATTERN.matcher(line); + if (tagMatcher.find()) { + String tagName = tagMatcher.group(1); + String typeName = tagMatcher.group(2); + String rest = tagMatcher.group(3); + + switch (tagName) { + case "see": + JSDocSeeTag seeTag = JSDocSeeTag.createSimple(rest != null ? rest.trim() : ""); + info.addSeeTag(seeTag); + return seeTag; + default: + JSDocTag genericTag = new JSDocTag(tagName, -1, -1, -1); + if (typeName != null) { + typeName = typeName.trim(); + genericTag.setType(typeName, null, -1, -1); + } + genericTag.setDescription(rest != null ? rest.trim() : ""); + info.addTag(genericTag); + return genericTag; + } + } + return null; + } + + public static String extractJSDocBefore(String content, int elementStart) { + if (elementStart <= 0) return null; + + String searchArea = content.substring(0, elementStart); + + int lastJSDocEnd = searchArea.lastIndexOf("*/"); + if (lastJSDocEnd < 0) return null; + + int jsDocStart = searchArea.lastIndexOf("/**", lastJSDocEnd); + if (jsDocStart < 0) return null; + + String between = searchArea.substring(lastJSDocEnd + 2).trim(); + if (between.isEmpty() || isOnlyWhitespaceOrModifiers(between)) { + return searchArea.substring(jsDocStart, lastJSDocEnd + 2); + } + + return null; + } + + private static boolean isOnlyWhitespaceOrModifiers(String text) { + String cleaned = text.replaceAll("\\s+", " ").trim(); + return cleaned.isEmpty() + || cleaned.matches("^(export\\s*)?(readonly\\s*)?(interface|class|type|function)?\\s*$"); + } + + public static List extractAllJSDocBlocks(String content) { + List blocks = new ArrayList<>(); + Matcher matcher = JSDOC_BLOCK_PATTERN.matcher(content); + + while (matcher.find()) { + int start = matcher.start(); + int end = matcher.end(); + String docContent = matcher.group(0); + blocks.add(new JSDocBlock(start, end, docContent)); + } + + return blocks; + } + + public static class JSDocBlock { + public final int start; + public final int end; + public final String content; + + public JSDocBlock(int start, int end, String content) { + this.start = start; + this.end = end; + this.content = content; + } + + public JSDocInfo parse() { + return parseJSDocBlock(content); + } + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/DtsModScanner.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/DtsModScanner.java new file mode 100644 index 000000000..d30503e8b --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/DtsModScanner.java @@ -0,0 +1,201 @@ +package noppes.npcs.client.gui.util.script.interpreter.js_parser; + +import cpw.mods.fml.common.Loader; +import cpw.mods.fml.common.ModContainer; + +import java.io.*; +import java.util.*; +import java.util.jar.JarEntry; +import java.util.jar.JarFile; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +final class DtsModScanner { + + private static final Pattern MOD_DTS_PATH_PATTERN = Pattern.compile("^assets/([^/]+)/api/(.+\\.d\\.ts)$"); + + private static final List DOMAIN_PRIORITY = Arrays.asList("customnpcs", "npcdbc"); + + private DtsModScanner() {} + + static List collectDtsFilesFromMods() { + List dtsFiles = new ArrayList<>(); + try { + for (ModContainer mod : Loader.instance().getModList()) { + File source = mod.getSource(); + if (source == null || !source.exists()) { + continue; + } + if (source.isDirectory()) { + scanDirectoryForModDts(source, mod.getModId(), dtsFiles); + } else if (source.getName().endsWith(".jar") || source.getName().endsWith(".zip")) { + scanJarForModDts(source, mod.getModId(), dtsFiles); + } + } + } catch (Throwable ignored) { + // Headless/non-FML environment: fall back to resource scanning. + } + return dtsFiles; + } + + static void sortDtsFiles(List dtsFiles) { + Collections.sort(dtsFiles, new DtsFileRefComparator()); + } + + static void logSummary(List dtsFiles) { + Map domainCounts = new LinkedHashMap<>(); + for (DtsFileRef ref : dtsFiles) { + domainCounts.put(ref.getDomain(), domainCounts.getOrDefault(ref.getDomain(), 0) + 1); + } + System.out.println("[JSTypeRegistry] Found " + dtsFiles.size() + " .d.ts files across " + domainCounts.size() + " domains"); + for (Map.Entry entry : domainCounts.entrySet()) { + System.out.println("[JSTypeRegistry] Domain " + entry.getKey() + ": " + entry.getValue() + " files"); + } + } + + private static void scanDirectoryForModDts(File baseDir, String modId, List dtsFiles) { + scanDirectoryForModDts(baseDir, baseDir, modId, dtsFiles); + } + + private static void scanDirectoryForModDts(File baseDir, File directory, String modId, List dtsFiles) { + File[] files = directory.listFiles(); + if (files == null) { + return; + } + for (File file : files) { + if (file.isDirectory()) { + scanDirectoryForModDts(baseDir, file, modId, dtsFiles); + continue; + } + if (!file.getName().endsWith(".d.ts")) { + continue; + } + String relativePath = baseDir.toURI().relativize(file.toURI()).getPath(); + if (relativePath == null) { + continue; + } + String normalized = relativePath.replace('\\', '/'); + Matcher matcher = MOD_DTS_PATH_PATTERN.matcher(normalized); + if (matcher.matches()) { + String domain = matcher.group(1); + String apiPath = matcher.group(2); + dtsFiles.add(DtsFileRef.forFile(modId, domain, apiPath, file)); + } + } + } + + private static void scanJarForModDts(File jarFile, String modId, List dtsFiles) { + try { + JarFile jar = new JarFile(jarFile); + Enumeration entries = jar.entries(); + while (entries.hasMoreElements()) { + JarEntry entry = entries.nextElement(); + String entryName = entry.getName(); + Matcher matcher = MOD_DTS_PATH_PATTERN.matcher(entryName); + if (matcher.matches()) { + String domain = matcher.group(1); + String apiPath = matcher.group(2); + dtsFiles.add(DtsFileRef.forJar(modId, domain, apiPath, jarFile, entryName)); + } + } + jar.close(); + } catch (Exception e) { + System.err.println("[JSTypeRegistry] Error scanning mod jar for .d.ts files: " + e.getMessage()); + } + } + + static final class DtsFileRef { + private final String modId; + private final String domain; + private final String relativePath; + private final File file; + private final File jarFile; + private final String jarEntryName; + + private DtsFileRef(String modId, String domain, String relativePath, File file, File jarFile, String jarEntryName) { + this.modId = modId; + this.domain = domain; + this.relativePath = relativePath; + this.file = file; + this.jarFile = jarFile; + this.jarEntryName = jarEntryName; + } + + static DtsFileRef forFile(String modId, String domain, String relativePath, File file) { + return new DtsFileRef(modId, domain, relativePath, file, null, null); + } + + static DtsFileRef forJar(String modId, String domain, String relativePath, File jarFile, String jarEntryName) { + return new DtsFileRef(modId, domain, relativePath, null, jarFile, jarEntryName); + } + + InputStream openStream() throws IOException { + if (file != null) { + return new FileInputStream(file); + } + if (jarFile != null && jarEntryName != null) { + final JarFile jar = new JarFile(jarFile); + JarEntry entry = jar.getJarEntry(jarEntryName); + if (entry == null) { + jar.close(); + return null; + } + InputStream is = jar.getInputStream(entry); + return new FilterInputStream(is) { + @Override + public void close() throws IOException { + super.close(); + jar.close(); + } + }; + } + return null; + } + + String getDomain() { + return domain; + } + + String getRelativePath() { + return relativePath; + } + + String getOrigin() { + return modId + ":" + domain + ":" + relativePath; + } + } + + private static class DtsFileRefComparator implements Comparator { + @Override + public int compare(DtsFileRef a, DtsFileRef b) { + int domainCompare = Integer.compare(getDomainRank(a.getDomain()), getDomainRank(b.getDomain())); + if (domainCompare != 0) { + return domainCompare; + } + int domainNameCompare = a.getDomain().compareTo(b.getDomain()); + if (domainNameCompare != 0) { + return domainNameCompare; + } + int filePriorityCompare = Integer.compare(getFilePriority(a.getRelativePath()), getFilePriority(b.getRelativePath())); + if (filePriorityCompare != 0) { + return filePriorityCompare; + } + return a.getRelativePath().compareTo(b.getRelativePath()); + } + + private int getDomainRank(String domain) { + int idx = DOMAIN_PRIORITY.indexOf(domain); + return idx >= 0 ? idx : DOMAIN_PRIORITY.size(); + } + + private int getFilePriority(String relativePath) { + if (relativePath.endsWith("hooks.d.ts")) { + return 0; + } + if (relativePath.endsWith("index.d.ts")) { + return 1; + } + return 2; + } + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSFieldInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSFieldInfo.java new file mode 100644 index 000000000..27e8c589c --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSFieldInfo.java @@ -0,0 +1,120 @@ +package noppes.npcs.client.gui.util.script.interpreter.js_parser; + +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.GenericContext; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeResolver; +/** + * Represents a field/property in a TypeScript interface. + */ +public class JSFieldInfo { + + private final String name; + private final String type; // Raw type string for display + private TypeInfo typeInfo; // Resolved TypeInfo + private final boolean readonly; + private boolean isStatic; + private JSDocInfo jsDocInfo; + private JSTypeInfo containingType; // The type that contains this field + + public JSFieldInfo(String name, String type, boolean readonly) { + this.name = name; + this.type = type; + this.readonly = readonly; + } + + public JSFieldInfo setJsDocInfo(JSDocInfo jsDocInfo) { + this.jsDocInfo = jsDocInfo; + return this; + } + + public boolean isStatic() { return isStatic; } + + public JSFieldInfo setStatic(boolean isStatic) { + this.isStatic = isStatic; + return this; + } + + + /** + * Set the containing type (the JSTypeInfo that owns this field). + */ + public void setContainingType(JSTypeInfo containingType) { + this.containingType = containingType; + } + + public void setTypeInfo(TypeInfo typeInfo) { + this.typeInfo = typeInfo; + } + + /** + * Get the resolved type, with fallback resolution using type parameters. + * @param contextType The TypeInfo context for resolving type parameters + * @return The resolved TypeInfo for the field type + */ + public TypeInfo getResolvedType(TypeInfo contextType) { + TypeResolver resolver = TypeResolver.getInstance(); + + // Cache only the raw resolved type; substitutions depend on the receiver context. + TypeInfo resolved = typeInfo != null ? typeInfo : resolver.resolveJSType(type); + if (typeInfo == null) { + typeInfo = resolved; + } + + if (contextType != null) { + GenericContext ctx = GenericContext.forReceiver(contextType); + return ctx.substituteType(resolved, type, resolver); + } + + return resolved; + } + + // Getters + public String getName() { return name; } + public String getType() { return type; } + public TypeInfo getTypeInfo() { return typeInfo; } + public boolean isReadonly() { return readonly; } + public JSDocInfo getJsDocInfo() { return jsDocInfo; } + public JSTypeInfo getContainingType() { return containingType; } + + /** + * Get documentation string (backward compatibility). + * Extracts description from JSDocInfo if available. + */ + public String getDocumentation() { + return jsDocInfo != null ? jsDocInfo.getDescription() : null; + } + + /** + * Get display name - uses resolved TypeInfo display name if available, + * including generic type arguments like List. + */ + public String getDisplayType() { + if (typeInfo != null && typeInfo.isResolved()) { + return typeInfo.getDisplayName(); + } + return type; + } + + /** + * Build hover info HTML for this field. + */ + public String buildHoverInfo() { + StringBuilder sb = new StringBuilder(); + if (readonly) { + sb.append("readonly "); + } + sb.append("").append(name).append(": ").append(type).append(""); + + if (jsDocInfo != null && jsDocInfo.getDescription() != null && !jsDocInfo.getDescription().isEmpty()) { + sb.append("

").append(jsDocInfo.getDescription()); + } + + return sb.toString(); + } + + @Override + public String toString() { + return (readonly ? "readonly " : "") + name + ": " + type; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSMethodInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSMethodInfo.java new file mode 100644 index 000000000..4bca83dec --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSMethodInfo.java @@ -0,0 +1,205 @@ +package noppes.npcs.client.gui.util.script.interpreter.js_parser; + +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.GenericContext; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeResolver; + +import java.util.*; + +/** + * Represents a method signature parsed from .d.ts files. + */ +public class JSMethodInfo { + + private final String name; + private final String returnType; // Raw type string for display, e.g., "number", "IEntity", "void" + private TypeInfo returnTypeInfo; // Resolved TypeInfo (set during Phase 2) + private final List parameters; + private boolean isStatic; + private JSDocInfo jsDocInfo; + private JSTypeInfo containingType; // The type that contains this method + + public JSMethodInfo(String name, String returnType, List parameters) { + this.name = name; + this.returnType = returnType; + this.parameters = parameters != null ? new ArrayList<>(parameters) : new ArrayList<>(); + } + + public JSMethodInfo setJsDocInfo(JSDocInfo jsDocInfo) { + this.jsDocInfo = jsDocInfo; + return this; + } + + public boolean isStatic() { return isStatic; } + + public JSMethodInfo setStatic(boolean isStatic) { + this.isStatic = isStatic; + return this; + } + + /** + * Set the resolved return type info (called during Phase 2 type resolution). + */ + public void setReturnTypeInfo(TypeInfo typeInfo) { + this.returnTypeInfo = typeInfo; + } + + /** + * Set the containing type (the JSTypeInfo that owns this method). + */ + public void setContainingType(JSTypeInfo containingType) { + this.containingType = containingType; + // Also set for all parameters + for (JSParameterInfo param : parameters) + param.setContainingMethod(this); + } + + /** + * Get the resolved return type, with type parameter substitution based on receiver context. + * + * For parameterized receivers like List, this will substitute type variables: + * - If return type is "T" and receiver is List, returns TypeInfo(String) + * - Handles nested generics like List> with proper substitution + * + * @param contextType The TypeInfo context for resolving type parameters (e.g., List to resolve E → String) + * @return The resolved TypeInfo for the return type, with type variables substituted + */ + public TypeInfo getResolvedReturnType(TypeInfo contextType) { + TypeResolver resolver = TypeResolver.getInstance(); + TypeInfo resolved = resolver.resolveJSType(returnType); + + if (contextType != null) { + GenericContext ctx = GenericContext.forReceiver(contextType); + resolved = ctx.substituteType(resolved, returnType, resolver); + } + + return resolved; + } + + // Getters + public String getName() { return name; } + public String getReturnType() { return returnType; } + public TypeInfo getReturnTypeInfo() { return returnTypeInfo; } + public List getParameters() { return parameters; } + public JSDocInfo getJsDocInfo() { return jsDocInfo; } + public int getParameterCount() { return parameters.size(); } + public JSTypeInfo getContainingType() { return containingType; } + + /** + * Get documentation string (backward compatibility). + * Extracts description from JSDocInfo if available. + */ + public String getDocumentation() { + return jsDocInfo != null ? jsDocInfo.getDescription() : null; + } + + /** + * Get a formatted signature string for display. + */ + public String getSignature() { + StringBuilder sb = new StringBuilder(); + sb.append(name).append("("); + for (int i = 0; i < parameters.size(); i++) { + if (i > 0) sb.append(", "); + JSParameterInfo param = parameters.get(i); + sb.append(param.getName()).append(": ").append(param.getType()); + } + sb.append("): ").append(returnType); + return sb.toString(); + } + + /** + * Build hover info HTML for this method. + */ + public String buildHoverInfo() { + StringBuilder sb = new StringBuilder(); + sb.append("").append(name).append("("); + for (int i = 0; i < parameters.size(); i++) { + if (i > 0) sb.append(", "); + JSParameterInfo param = parameters.get(i); + sb.append(param.getName()).append(": ").append(param.getType()).append(""); + } + sb.append("): ").append(returnType).append(""); + + if (jsDocInfo != null && jsDocInfo.getDescription() != null && !jsDocInfo.getDescription().isEmpty()) { + sb.append("

").append(jsDocInfo.getDescription()); + } + + return sb.toString(); + } + + @Override + public String toString() { + return getSignature(); + } + + /** + * Represents a parameter in a method signature. + */ + public static class JSParameterInfo { + private final String name; + private final String type; + private TypeInfo typeInfo; // Resolved TypeInfo (set during Phase 2) + private JSMethodInfo containingMethod; // The type that contains the method with this parameter + private boolean isVarArg = false; + + public JSParameterInfo(String name, String type) { + this.name = name; + this.type = type; + } + + public void setVarArg(boolean isVarArg) { this.isVarArg = isVarArg; } + public boolean isVarArg() { return isVarArg; } + + public void setContainingMethod(JSMethodInfo containingMethod) { + this.containingMethod = containingMethod; + } + + public void setTypeInfo(TypeInfo typeInfo) { + this.typeInfo = typeInfo; + } + + /** + * Get the resolved type, with type parameter substitution based on receiver context. + * + * For parameterized receivers like Consumer, this will substitute type variables: + * - If param type is "T" and receiver is Consumer, returns TypeInfo(IAction) + * + * @param contextType The TypeInfo context for resolving type parameters + * @return The resolved TypeInfo for the parameter type + */ + public TypeInfo getResolvedType(TypeInfo contextType) { + TypeResolver resolver = TypeResolver.getInstance(); + TypeInfo resolved = resolver.resolveJSType(type); + + if (contextType != null) { + GenericContext ctx = GenericContext.forReceiver(contextType); + resolved = ctx.substituteType(resolved, type, resolver); + } + + return resolved; + } + + public String getName() { return name; } + public String getType() { return type; } + public TypeInfo getTypeInfo() {return typeInfo;} + public JSMethodInfo getContainingMethod() {return containingMethod;} + + /** + * Get display name - uses resolved TypeInfo display name if available, + * including generic type arguments like List. + */ + public String getDisplayType() { + if (typeInfo != null && typeInfo.isResolved()) { + return typeInfo.getDisplayName(); + } + return type; + } + + @Override + public String toString() { + return name + ": " + type; + } + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSScriptAnalyzer.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSScriptAnalyzer.java new file mode 100644 index 000000000..0ebcce69f --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSScriptAnalyzer.java @@ -0,0 +1,554 @@ +package noppes.npcs.client.gui.util.script.interpreter.js_parser; + +import noppes.npcs.client.gui.util.script.interpreter.ScriptDocument; +import noppes.npcs.client.gui.util.script.interpreter.ScriptLine; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenType; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import scala.annotation.meta.field; + +import java.util.*; +import java.util.regex.*; + +/** + * Analyzes JavaScript scripts to produce syntax highlighting marks and type information. + * Uses the JSTypeRegistry to resolve types and validate member access. + * + * @deprecated This class is deprecated. All JavaScript analysis is now handled by the + * unified pipeline in {@link ScriptDocument}. JavaScript and Java scripts now use the + * same methods and data structures: + *
    + *
  • {@link ScriptDocument#parseMethodDeclarations()} - for both Java methods and JS functions
  • + *
  • {@link ScriptDocument#parseLocalVariables()} - for both Java and JS local variables
  • + *
  • {@link ScriptDocument#parseGlobalFields()} - for both Java and JS global variables
  • + *
  • {@link ScriptDocument#buildMarks(List)} - for mark building (both languages)
  • + *
+ * Type information is available via the unified data structures: {@code getMethods()}, + * {@code getMethodLocals()}, and {@code getGlobalFields()}. + */ +@Deprecated +public class JSScriptAnalyzer { + + private final ScriptDocument document; + private final String text; + private final JSTypeRegistry registry; + + // Variable tracking: varName -> inferred type name + private final Map variableTypes = new HashMap<>(); + + // Function parameter types: funcName -> paramName -> typeName + private final Map> functionParams = new HashMap<>(); + + // Excluded ranges (strings, comments) + private final List excludedRanges = new ArrayList<>(); + + // Patterns + private static final Pattern STRING_PATTERN = Pattern.compile("\"(?:[^\"\\\\]|\\\\.)*\"|'(?:[^'\\\\]|\\\\.)*'"); + private static final Pattern COMMENT_PATTERN = Pattern.compile("//.*?$|/\\*.*?\\*/", Pattern.MULTILINE | Pattern.DOTALL); + private static final Pattern FUNCTION_PATTERN = Pattern.compile("function\\s+(\\w+)\\s*\\(([^)]*)\\)"); + private static final Pattern VAR_DECL_PATTERN = Pattern.compile("(?:var|let|const)\\s+(\\w+)(?:\\s*=\\s*([^;]+))?"); + private static final Pattern ASSIGNMENT_PATTERN = Pattern.compile("(\\w+)\\s*=\\s*([^;]+)"); + private static final Pattern METHOD_CALL_PATTERN = Pattern.compile("(\\w+(?:\\.\\w+)*)\\s*\\("); + private static final Pattern MEMBER_ACCESS_PATTERN = Pattern.compile("(\\w+)(?:\\.(\\w+))+"); + private static final Pattern IDENTIFIER_PATTERN = Pattern.compile("\\b([a-zA-Z_][a-zA-Z0-9_]*)\\b"); + + private static final Pattern JS_KEYWORD_PATTERN = Pattern.compile( + "\\b(function|var|let|const|if|else|for|while|do|switch|case|break|continue|return|" + + "try|catch|finally|throw|new|typeof|instanceof|in|of|this|null|undefined|true|false|" + + "class|extends|import|export|default|async|await|yield)\\b"); + + private static final Pattern NUMBER_PATTERN = Pattern.compile("\\b\\d+\\.?\\d*\\b"); + + public JSScriptAnalyzer(ScriptDocument document) { + this.document = document; + this.text = document.getText(); + this.registry = JSTypeRegistry.getInstance(); + // Ensure registry is initialized + if (!registry.isInitialized()) { + registry.initializeFromResources(); + } + } + + /** + * Analyze the script and produce marks. + */ + public List analyze() { + List marks = new ArrayList<>(); + + // First pass: find excluded regions + findExcludedRanges(); + + // Mark comments and strings + addPatternMarks(marks, COMMENT_PATTERN, TokenType.COMMENT); + addPatternMarks(marks, STRING_PATTERN, TokenType.STRING); + + // Mark keywords + addPatternMarks(marks, JS_KEYWORD_PATTERN, TokenType.KEYWORD); + + // Mark numbers + addPatternMarks(marks, NUMBER_PATTERN, TokenType.LITERAL); + + // Parse functions and infer parameter types from hooks + parseFunctions(marks); + + // Parse variable declarations + parseVariables(marks); + + // Mark member accesses with type validation + markMemberAccesses(marks); + + // Mark method calls + markMethodCalls(marks); + + // Mark standalone identifiers (parameters and variables in function bodies) + markIdentifiers(marks); + + return marks; + } + + /** + * Find strings and comments to exclude from analysis. + */ + private void findExcludedRanges() { + Matcher m = STRING_PATTERN.matcher(text); + while (m.find()) { + excludedRanges.add(new int[]{m.start(), m.end()}); + } + + m = COMMENT_PATTERN.matcher(text); + while (m.find()) { + excludedRanges.add(new int[]{m.start(), m.end()}); + } + } + + private boolean isExcluded(int pos) { + for (int[] range : excludedRanges) { + if (pos >= range[0] && pos < range[1]) return true; + } + return false; + } + + /** + * Parse function declarations and infer parameter types from hook signatures. + */ + private void parseFunctions(List marks) { + Matcher m = FUNCTION_PATTERN.matcher(text); + while (m.find()) { + if (isExcluded(m.start())) continue; + + String funcName = m.group(1); + String params = m.group(2); + + // Mark function name + int nameStart = m.start(1); + int nameEnd = m.end(1); + + // Check if this is a known hook + if (registry.isHook(funcName)) { + // Create a unified MethodInfo for the hook + List sigs = registry.getHookSignatures(funcName); + if (!sigs.isEmpty()) { + JSTypeRegistry.HookSignature sig = sigs.get(0); + + // Create unified MethodInfo for hover info + TypeInfo paramTypeInfo = resolveJSType(sig.paramType); + List methodParams = new ArrayList<>(); + methodParams.add(FieldInfo.reflectionParam(sig.paramName, paramTypeInfo)); + + MethodInfo hookMethod = MethodInfo.declaration( + funcName, null, TypeInfo.fromPrimitive("void"), methodParams, + nameStart, nameStart, nameStart, -1, -1, 0, sig.doc + ); + + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.METHOD_DECL, hookMethod)); + + // Infer parameter types from hook + if (!params.isEmpty()) { + // Parse parameter names from function + String[] paramNames = params.split(","); + if (paramNames.length > 0) { + String paramName = paramNames[0].trim(); + String paramType = sig.paramType; + + // Store in function params and variable types + Map funcParamMap = new HashMap<>(); + funcParamMap.put(paramName, paramType); + functionParams.put(funcName, funcParamMap); + variableTypes.put(paramName, paramType); + + // Mark the parameter with unified FieldInfo + int paramStart = m.start(2) + params.indexOf(paramName); + int paramEnd = paramStart + paramName.length(); + FieldInfo paramFieldInfo = FieldInfo.parameter( + paramName, paramTypeInfo, paramStart, hookMethod + ); + marks.add(new ScriptLine.Mark(paramStart, paramEnd, TokenType.PARAMETER, paramFieldInfo)); + } + } + } else { + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.METHOD_DECL, funcName)); + } + } else { + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.METHOD_DECL, funcName)); + } + } + } + + /** + * Parse variable declarations and infer types. + */ + private void parseVariables(List marks) { + Matcher m = VAR_DECL_PATTERN.matcher(text); + while (m.find()) { + if (isExcluded(m.start())) continue; + + String varName = m.group(1); + String initializer = m.group(2); + + // Infer type from initializer + String inferredType = null; + if (initializer != null) { + inferredType = inferTypeFromExpression(initializer.trim()); + } + + if (inferredType != null) { + variableTypes.put(varName, inferredType); + } + + // Mark variable declaration with unified FieldInfo + int varStart = m.start(1); + int varEnd = m.end(1); + TypeInfo typeInfo = resolveJSType(inferredType != null ? inferredType : "any"); + FieldInfo varFieldInfo = FieldInfo.localField(varName, typeInfo, varStart, null); + marks.add(new ScriptLine.Mark(varStart, varEnd, TokenType.LOCAL_FIELD, varFieldInfo)); + } + } + + /** + * Infer type from an expression. + */ + private String inferTypeFromExpression(String expr) { + if (expr == null || expr.isEmpty()) return null; + + // String literal + if (expr.startsWith("\"") || expr.startsWith("'")) { + return "string"; + } + + // Number literal + if (expr.matches("\\d+\\.?\\d*")) { + return "number"; + } + + // Boolean literal + if (expr.equals("true") || expr.equals("false")) { + return "boolean"; + } + + // null/undefined + if (expr.equals("null")) return "null"; + if (expr.equals("undefined")) return "undefined"; + + // Array literal + if (expr.startsWith("[")) { + return "any[]"; + } + + // Object literal + if (expr.startsWith("{")) { + return "object"; + } + + // Method call: something.method() - infer from method return type + if (expr.contains(".") && expr.contains("(")) { + return inferTypeFromMethodCall(expr); + } + + // Variable reference + if (variableTypes.containsKey(expr)) { + return variableTypes.get(expr); + } + + return null; + } + + /** + * Infer type from a method call chain. + */ + private String inferTypeFromMethodCall(String expr) { + // Remove trailing parentheses and args for analysis + int parenIndex = expr.indexOf('('); + if (parenIndex > 0) { + expr = expr.substring(0, parenIndex); + } + + String[] parts = expr.split("\\."); + if (parts.length < 2) return null; + + // Start with the receiver type + String currentType = variableTypes.get(parts[0]); + if (currentType == null) return null; + + // Walk the chain + for (int i = 1; i < parts.length; i++) { + JSTypeInfo typeInfo = registry.getType(currentType); + if (typeInfo == null) return null; + + String member = parts[i]; + + // Check if it's a method + JSMethodInfo method = typeInfo.getMethod(member); + if (method != null) { + currentType = method.getReturnType(); + continue; + } + + // Check if it's a field + JSFieldInfo f = typeInfo.getField(member); + if (f != null) { + currentType = f.getType(); + continue; + } + + return null; // Unknown member + } + + return currentType; + } + + /** + * Mark member accesses (x.y.z) with type validation. + */ + private void markMemberAccesses(List marks) { + Matcher m = MEMBER_ACCESS_PATTERN.matcher(text); + while (m.find()) { + if (isExcluded(m.start())) continue; + + String fullAccess = m.group(0); + String[] parts = fullAccess.split("\\."); + + if (parts.length < 2) continue; + + // Get receiver type + String receiverName = parts[0]; + String currentType = variableTypes.get(receiverName); + + int pos = m.start(); + + // Mark receiver with unified FieldInfo + if (currentType != null) { + TypeInfo unifiedType = resolveJSType(currentType); + FieldInfo receiverField = FieldInfo.localField(receiverName, unifiedType, pos, null); + marks.add(new ScriptLine.Mark(pos, pos + receiverName.length(), TokenType.LOCAL_FIELD, receiverField)); + } + + pos += receiverName.length() + 1; // +1 for the dot + + // Walk the chain and mark each member + for (int i = 1; i < parts.length; i++) { + String member = parts[i]; + int memberStart = pos; + int memberEnd = pos + member.length(); + + if (currentType != null) { + JSTypeInfo jsTypeInfo = registry.getType(currentType); + if (jsTypeInfo != null) { + TypeInfo unifiedContainingType = TypeInfo.fromJSTypeInfo(jsTypeInfo); + + // Check method first + JSMethodInfo jsMethod = jsTypeInfo.getMethod(member); + if (jsMethod != null) { + // Convert to unified MethodInfo + MethodInfo unifiedMethod = MethodInfo.fromJSMethod(jsMethod, unifiedContainingType); + marks.add(new ScriptLine.Mark(memberStart, memberEnd, TokenType.METHOD_CALL, unifiedMethod)); + currentType = jsMethod.getReturnType(); + } else { + // Check field + JSFieldInfo jsField = jsTypeInfo.getField(member); + if (jsField != null) { + // Convert to unified FieldInfo + FieldInfo unifiedField = FieldInfo.fromJSField(jsField, unifiedContainingType); + marks.add(new ScriptLine.Mark(memberStart, memberEnd, TokenType.GLOBAL_FIELD, unifiedField)); + currentType = jsField.getType(); + } else { + // Unknown member - mark as undefined + marks.add(new ScriptLine.Mark(memberStart, memberEnd, TokenType.UNDEFINED_VAR, + "Unknown member '" + member + "' on type " + jsTypeInfo.getFullName())); + currentType = null; + } + } + } else { + currentType = null; + } + } + + pos = memberEnd + 1; // +1 for the next dot + } + } + } + + /** + * Mark method calls. + */ + private void markMethodCalls(List marks) { + Matcher m = METHOD_CALL_PATTERN.matcher(text); + while (m.find()) { + if (isExcluded(m.start())) continue; + + String callExpr = m.group(1); + if (!callExpr.contains(".")) { + // Simple function call + int nameStart = m.start(1); + int nameEnd = m.end(1); + + if (registry.isHook(callExpr)) { + // It's a known hook being called - create unified MethodInfo + List sigs = registry.getHookSignatures(callExpr); + if (!sigs.isEmpty()) { + JSTypeRegistry.HookSignature sig = sigs.get(0); + TypeInfo paramTypeInfo = resolveJSType(sig.paramType); + List methodParams = new ArrayList<>(); + methodParams.add(FieldInfo.reflectionParam(sig.paramName, paramTypeInfo)); + + MethodInfo hookMethod = MethodInfo.declaration( + callExpr, null, TypeInfo.fromPrimitive("void"), methodParams, + nameStart, nameStart, nameStart, -1, -1, 0, sig.doc + ); + marks.add(new ScriptLine.Mark(nameStart, nameEnd, TokenType.METHOD_CALL, hookMethod)); + } + } + } + // Chained calls are handled in markMemberAccesses + } + } + + /** + * Add pattern-based marks. + */ + private void addPatternMarks(List marks, Pattern pattern, TokenType type) { + Matcher m = pattern.matcher(text); + while (m.find()) { + marks.add(new ScriptLine.Mark(m.start(), m.end(), type)); + } + } + + /** + * Get the inferred type of a variable at a position. + */ + public String getVariableType(String varName) { + return variableTypes.get(varName); + } + + /** + * Get all inferred variable types. + */ + public Map getVariableTypes() { + return new HashMap<>(variableTypes); + } + + /** + * Resolves a JavaScript type name to a unified TypeInfo. + * Handles primitives, mapped types, and custom types from the registry. + */ + private TypeInfo resolveJSType(String jsTypeName) { + if (jsTypeName == null || jsTypeName.isEmpty() || "void".equals(jsTypeName)) { + return TypeInfo.fromPrimitive("void"); + } + + // Handle JS primitives + switch (jsTypeName) { + case "string": + return TypeInfo.fromClass(String.class); + case "number": + return TypeInfo.fromClass(double.class); + case "boolean": + return TypeInfo.fromClass(boolean.class); + case "any": + return TypeInfo.fromClass(Object.class); + case "void": + return TypeInfo.fromPrimitive("void"); + } + + // Handle array types + if (jsTypeName.endsWith("[]")) { + String elementType = jsTypeName.substring(0, jsTypeName.length() - 2); + TypeInfo elementTypeInfo = resolveJSType(elementType); + return TypeInfo.arrayOf(elementTypeInfo); + } + + // Try to resolve from the JS type registry + if (registry != null) { + JSTypeInfo jsTypeInfo = registry.getType(jsTypeName); + if (jsTypeInfo != null) { + return TypeInfo.fromJSTypeInfo(jsTypeInfo); + } + } + + // Fallback: unresolved type + return TypeInfo.unresolved(jsTypeName, jsTypeName); + } + + /** + * Mark all identifiers in the script - variables and parameters. + * This ensures consistent coloring for parameters throughout function bodies. + */ + private void markIdentifiers(List marks) { + // Build set of positions already marked + Set markedPositions = new HashSet<>(); + for (ScriptLine.Mark mark : marks) { + for (int i = mark.start; i < mark.end; i++) { + markedPositions.add(i); + } + } + + // Find all identifiers + Matcher matcher = IDENTIFIER_PATTERN.matcher(text); + while (matcher.find()) { + if (isExcluded(matcher.start())) { + continue; + } + + int start = matcher.start(); + int end = matcher.end(); + + // Skip if already marked + boolean alreadyMarked = false; + for (int i = start; i < end; i++) { + if (markedPositions.contains(i)) { + alreadyMarked = true; + break; + } + } + if (alreadyMarked) { + continue; + } + + String identifier = matcher.group(); + + // Check if it's a parameter + boolean isParameter = false; + for (Map params : functionParams.values()) { + if (params.containsKey(identifier)) { + isParameter = true; + break; + } + } + + if (isParameter) { + marks.add(new ScriptLine.Mark(start, end, TokenType.PARAMETER)); + // Mark this position as used + for (int i = start; i < end; i++) { + markedPositions.add(i); + } + } else if (variableTypes.containsKey(identifier)) { + // It's a local variable + marks.add(new ScriptLine.Mark(start, end, TokenType.LOCAL_FIELD)); + // Mark this position as used + for (int i = start; i < end; i++) { + markedPositions.add(i); + } + } + } + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSTypeInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSTypeInfo.java new file mode 100644 index 000000000..0926ceafe --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSTypeInfo.java @@ -0,0 +1,311 @@ +package noppes.npcs.client.gui.util.script.interpreter.js_parser; + +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocInfo; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocParamTag; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocReturnTag; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocTypeTag; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeResolver; + +import java.util.*; + +/** + * Represents a TypeScript interface/type parsed from .d.ts files. + * This is the JS equivalent of TypeInfo for Java types. + */ +public class JSTypeInfo { + + private final String simpleName; // e.g., "InteractEvent" + private final String fullName; // e.g., "IPlayerEvent.InteractEvent" + private final String namespace; // e.g., "IPlayerEvent" (parent namespace, null for top-level) + + // Java fully-qualified name (e.g., "noppes.npcs.api.entity.IPlayer") + private String javaFqn; + + // Type parameters (generics) + private final List typeParams = new ArrayList<>(); + + // Members + private final Map methods = new LinkedHashMap<>(); + private final Map fields = new LinkedHashMap<>(); + + // Inheritance + private String extendsType; // The type this interface extends + private JSTypeInfo resolvedParent; // Resolved parent type (after registry is built) + + // Inner types (for namespaces) + private final Map innerTypes = new LinkedHashMap<>(); + private JSTypeInfo parentType; // The containing type (for inner types) + + // Documentation + private JSDocInfo jsDocInfo; + + public JSTypeInfo(String simpleName, String namespace) { + this.simpleName = simpleName; + this.namespace = namespace; + this.fullName = namespace != null ? namespace + "." + simpleName : simpleName; + } + + // Builder methods + public JSTypeInfo setExtends(String extendsType) { + this.extendsType = extendsType; + return this; + } + + public JSTypeInfo setJsDocInfo(JSDocInfo jsDocInfo) { + this.jsDocInfo = jsDocInfo; + return this; + } + + public JSTypeInfo setJavaFqn(String javaFqn) { + this.javaFqn = javaFqn; + return this; + } + + public void addMethod(JSMethodInfo method) { + method.setContainingType(this); + // Handle overloads - store with index if name already exists + String key = method.getName(); + if (methods.containsKey(key)) { + // Find next available key for overload + int index = 1; + while (methods.containsKey(key + "$" + index)) { + index++; + } + methods.put(key + "$" + index, method); + } else { + methods.put(key, method); + } + } + + public void addField(JSFieldInfo field) { + field.setContainingType(this); + fields.put(field.getName(), field); + } + + public void addInnerType(JSTypeInfo inner) { + inner.parentType = this; + innerTypes.put(inner.getSimpleName(), inner); + } + + public void setResolvedParent(JSTypeInfo parent) { + this.resolvedParent = parent; + } + + // Getters + public String getSimpleName() { return simpleName; } + public String getFullName() { return fullName; } + public String getNamespace() { return namespace; } + public String getJavaFqn() { return javaFqn; } + public String getExtendsType() { return extendsType; } + public JSTypeInfo getResolvedParent() { return resolvedParent; } + public JSDocInfo getJsDocInfo() { return jsDocInfo; } + public JSTypeInfo getParentType() { return parentType; } + public List getTypeParams() { return typeParams; } + + public Map getMethods() { return methods; } + public Map getFields() { return fields; } + public Map getInnerTypes() { return innerTypes; } + + /** + * Get the type parameter info for a given parameter name (e.g., "T"). + * @return TypeParamInfo or null if not found + */ + public TypeParamInfo getTypeParam(String name) { + for (TypeParamInfo param : typeParams) { + if (param.getName().equals(name)) { + return param; + } + } + return null; + } + + public void addTypeParam(TypeParamInfo param) { + typeParams.add(param); + } + + /** + * Resolve all type parameters for this type. + * Called during Phase 2 after all types are loaded into the registry. + */ + public void resolveTypeParameters() { + for (TypeParamInfo param : typeParams) { + param.resolveBoundType(); + } + } + + /** + * Resolve all member types (return types, field types, parameter types). + * Called during Phase 2 after all types are loaded into the registry. + * This resolves types like "Java.java.io.File" to proper TypeInfo objects. + */ + public void resolveMemberTypes() { + TypeResolver resolver = TypeResolver.getInstance(); + + // Resolve method return types and parameter types + for (JSMethodInfo method : methods.values()) { + TypeInfo returnTypeInfo = resolver.resolveJSType(method.getReturnType()); + method.setReturnTypeInfo(returnTypeInfo); + + // Resolve parameter types + for (JSMethodInfo.JSParameterInfo param : method.getParameters()) { + TypeInfo paramTypeInfo = resolver.resolveJSType(param.getType()); + param.setTypeInfo(paramTypeInfo); + } + } + + // Resolve field types + for (JSFieldInfo field : fields.values()) { + TypeInfo fieldTypeInfo = resolver.resolveJSType(field.getType()); + field.setTypeInfo(fieldTypeInfo); + } + } + + public void resolveJSDocTypes() { + TypeResolver resolver = TypeResolver.getInstance(); + + if (jsDocInfo != null) { + resolveJSDocInfoTypes(jsDocInfo, resolver); + } + + for (JSMethodInfo method : methods.values()) { + JSDocInfo methodDoc = method.getJsDocInfo(); + if (methodDoc != null) { + resolveJSDocInfoTypes(methodDoc, resolver); + } + } + + for (JSFieldInfo field : fields.values()) { + JSDocInfo fieldDoc = field.getJsDocInfo(); + if (fieldDoc != null) { + resolveJSDocInfoTypes(fieldDoc, resolver); + } + } + } + + private void resolveJSDocInfoTypes(JSDocInfo jsDoc, TypeResolver resolver) { + JSDocTypeTag typeTag = jsDoc.getTypeTag(); + if (typeTag != null && typeTag.hasType() && typeTag.getTypeInfo() == null) { + TypeInfo resolved = resolver.resolveJSType(typeTag.getTypeName()); + typeTag.setType(typeTag.getTypeName(), resolved, typeTag.getTypeStart(), typeTag.getTypeEnd()); + } + + for (JSDocParamTag paramTag : jsDoc.getParamTags()) { + if (paramTag.hasType() && paramTag.getTypeInfo() == null) { + TypeInfo resolved = resolver.resolveJSType(paramTag.getTypeName()); + paramTag.setType(paramTag.getTypeName(), resolved, paramTag.getTypeStart(), paramTag.getTypeEnd()); + } + } + + JSDocReturnTag returnTag = jsDoc.getReturnTag(); + if (returnTag != null && returnTag.hasType() && returnTag.getTypeInfo() == null) { + TypeInfo resolved = resolver.resolveJSType(returnTag.getTypeName()); + returnTag.setType(returnTag.getTypeName(), resolved, returnTag.getTypeStart(), returnTag.getTypeEnd()); + } + } + + /** + * Resolves a type parameter to its bound TypeInfo. + * For example, if this type has "T extends EntityPlayerMP", resolveTypeParam("T") returns the TypeInfo for EntityPlayerMP. + * If no type parameter is found with that name, returns null. + */ + public TypeInfo resolveTypeParamToTypeInfo(String typeName) { + TypeParamInfo param = getTypeParam(typeName); + if (param != null) { + return param.getBoundTypeInfo(); + } + return null; + } + + /** + * Resolves a type parameter to its bound type name (for backward compatibility). + * @deprecated Use resolveTypeParamToTypeInfo instead + */ + @Deprecated + public String resolveTypeParam(String typeName) { + TypeParamInfo param = getTypeParam(typeName); + if (param != null && param.getBoundTypeInfo() != null) { + return param.getBoundTypeInfo().getSimpleName(); + } + return typeName; + } + + /** + * Get a method by name, including inherited methods. + */ + public JSMethodInfo getMethod(String name) { + JSMethodInfo method = methods.get(name); + if (method != null) return method; + + // Check parent + if (resolvedParent != null) { + return resolvedParent.getMethod(name); + } + return null; + } + + /** + * Get all methods with a given name (for overloads). + */ + public List getMethodOverloads(String name) { + List overloads = new ArrayList<>(); + + // Get from this type + if (methods.containsKey(name)) { + overloads.add(methods.get(name)); + } + // Get numbered overloads + int index = 1; + while (methods.containsKey(name + "$" + index)) { + overloads.add(methods.get(name + "$" + index)); + index++; + } + + // Get from parent + if (resolvedParent != null) { + overloads.addAll(resolvedParent.getMethodOverloads(name)); + } + + return overloads; + } + + /** + * Check if this type has a method (including inherited). + */ + public boolean hasMethod(String name) { + return getMethod(name) != null; + } + + /** + * Get a field by name, including inherited fields. + */ + public JSFieldInfo getField(String name) { + JSFieldInfo field = fields.get(name); + if (field != null) return field; + + // Check parent + if (resolvedParent != null) { + return resolvedParent.getField(name); + } + return null; + } + + /** + * Check if this type has a field (including inherited). + */ + public boolean hasField(String name) { + return getField(name) != null; + } + + /** + * Get an inner type by name. + */ + public JSTypeInfo getInnerType(String name) { + return innerTypes.get(name); + } + + @Override + public String toString() { + return "JSTypeInfo{" + fullName + "}"; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSTypeRegistry.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSTypeRegistry.java new file mode 100644 index 000000000..83e11d317 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/JSTypeRegistry.java @@ -0,0 +1,1199 @@ +package noppes.npcs.client.gui.util.script.interpreter.js_parser; + +import net.minecraft.client.Minecraft; +import net.minecraft.util.ResourceLocation; +import noppes.npcs.scripted.NpcAPI; +import noppes.npcs.client.gui.util.script.interpreter.bridge.DtsJavaBridge; +import noppes.npcs.api.handler.IHookDefinition; +import noppes.npcs.controllers.ScriptHookController; + +import java.io.*; +import java.net.URL; +import java.nio.charset.StandardCharsets; +import java.util.*; +import java.util.jar.JarEntry; +import java.util.jar.JarFile; + +/** + * Central registry for all TypeScript types parsed from .d.ts files. + * Also manages hook function signatures and type aliases. + */ +public class JSTypeRegistry { + + private static JSTypeRegistry INSTANCE; + + // All registered types by full name (e.g., "IPlayerEvent.InteractEvent") + private final Map types = new LinkedHashMap<>(); + + // Registered types by Java fully-qualified name (e.g., "noppes.npcs.api.entity.IPlayer") + private final Map typesByJavaFqn = new LinkedHashMap<>(); + + // Type aliases (simple name -> full type name) + private final Map typeAliases = new HashMap<>(); + + // Type full name -> origin string (modId:domain:relativePath) + private final Map typeOrigins = new HashMap<>(); + + // Alias name -> origin string (modId:domain:relativePath) + private final Map aliasOrigins = new HashMap<>(); + + // Context-aware hook function signatures: namespace -> functionName -> list of signatures + // The namespace is the event interface name (e.g., "INpcEvent", "IPlayerEvent") + // This allows any mod to register hooks without modifying an enum + private final Map>> contextHooks = new LinkedHashMap<>(); + + // Legacy hook storage: functionName -> list of (paramName, paramType) pairs + // Kept for backward compatibility with code that doesn't use contexts + private final Map> hooks = new LinkedHashMap<>(); + + // Fallback namespace for hooks that don't match a specific context + private static final String GLOBAL_NAMESPACE = "Global"; + + // Global object instances: name -> type (e.g., "API" -> "AbstractNpcAPI") + // These are treated as instance objects, not static classes + private final Map globalEngineObjects = new LinkedHashMap<>(); + // Math / Number / Json / etc. built-in globals from ECMAScript 5.1 + private final Map globalEngineImports = new LinkedHashMap<>(); + // Top-level global functions from GlobalFunctions.d.ts (parseInt, parseFloat, isNaN, etc.) + private final Map globalEngineFunctions = new LinkedHashMap<>(); + + // Primitive types + private static final Set PRIMITIVES = new HashSet<>(Arrays.asList( + "number", "string", "boolean", "void", "any", "null", "undefined", "never", "object", + "byte", "short", "int", "integer", "long", "float", "double", "char", "bool" + )); + + private boolean initialized = false; + private boolean initializationAttempted = false; + private int lastSyncedHookRevision = -1; + + private String currentSource = null; + + public static JSTypeRegistry getInstance() { + if (INSTANCE == null) { + INSTANCE = new JSTypeRegistry(); + } + return INSTANCE; + } + + private JSTypeRegistry() {} + + /** + * Initialize the registry from the embedded resources. + * Recursively loads all .d.ts files from assets/customnpcs/api/ + */ + public void initializeFromResources() { + if (initialized || initializationAttempted) return; + initializationAttempted = true; + + try { + TypeScriptDefinitionParser parser = new TypeScriptDefinitionParser(this); + + List dtsFiles = DtsModScanner.collectDtsFilesFromMods(); + if (dtsFiles.isEmpty()) { + Set fallbackFiles = findAllDtsFilesInResources("assets/customnpcs/api"); + + System.out.println("[JSTypeRegistry] Found " + fallbackFiles.size() + " .d.ts files in resources"); + + if (fallbackFiles.contains("hooks.d.ts")) { + loadResourceFile(parser, "hooks.d.ts"); + } + if (fallbackFiles.contains("index.d.ts")) { + loadResourceFile(parser, "index.d.ts"); + } + + for (String filePath : fallbackFiles) { + if (!filePath.equals("hooks.d.ts") && !filePath.equals("index.d.ts")) { + loadResourceFile(parser, filePath); + } + } + } else { + DtsModScanner.logSummary(dtsFiles); + loadDtsFiles(parser, dtsFiles); + } + + // Phase 2: Resolve all type parameters now that all types are loaded + resolveAllTypeParameters(); + + // Phase 2b: Resolve member types (return types, field types, param types) + resolveAllMemberTypes(); + + // Phase 2c: Resolve JSDoc types (@param, @return, @type type references) + resolveAllJSDocTypes(); + + resolveInheritance(); + registerEngineGlobalObjects(); + registerES5Builtins(); + + initialized = true; + System.out.println("[JSTypeRegistry] Loaded " + types.size() + " types, " + hooks.size() + " hooks from resources"); + } catch (Exception e) { + System.err.println("[JSTypeRegistry] Failed to load type definitions from resources: " + e.getMessage()); + e.printStackTrace(); + } + } + + private void loadDtsFiles(TypeScriptDefinitionParser parser, List dtsFiles) { + DtsModScanner.sortDtsFiles(dtsFiles); + for (DtsModScanner.DtsFileRef ref : dtsFiles) { + try (InputStream is = ref.openStream()) { + if (is == null) { + continue; + } + String content = readFully(new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8))); + setCurrentSource(ref.getOrigin()); + parser.parseDefinitionFile(content, ref.getRelativePath()); + } catch (Exception e) { + System.err.println("[JSTypeRegistry] Failed to load " + ref.getOrigin() + ": " + e.getMessage()); + } finally { + setCurrentSource(null); + } + } + } + + private String readFully(BufferedReader reader) throws IOException { + StringBuilder sb = new StringBuilder(); + String line; + while ((line = reader.readLine()) != null) { + sb.append(line).append("\n"); + } + return sb.toString(); + } + + /** + * Recursively find all .d.ts files in the resources directory. + * Similar to ClassIndex.addPackage, scans both file system and JAR resources. + * + * @param resourcePath The full resource path (e.g., "assets/customnpcs/api") + */ + private Set findAllDtsFilesInResources(String resourcePath) { + Set dtsFiles = new HashSet<>(); + + try { + ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); + Enumeration resources = classLoader.getResources(resourcePath); + + while (resources.hasMoreElements()) { + URL resource = resources.nextElement(); + + if (resource.getProtocol().equals("file")) { + // Scan file system directory + File directory = new File(resource.getFile()); + scanDirectoryForDts(directory, "", dtsFiles); + } else if (resource.getProtocol().equals("jar")) { + // Scan JAR file + String jarPath = resource.getPath(); + if (jarPath.startsWith("file:")) { + jarPath = jarPath.substring(5); + } + int separatorIndex = jarPath.indexOf("!"); + if (separatorIndex != -1) { + jarPath = jarPath.substring(0, separatorIndex); + } + scanJarForDts(jarPath, resourcePath, dtsFiles); + } + } + } catch (Exception e) { + System.err.println("[JSTypeRegistry] Error scanning for .d.ts files: " + e.getMessage()); + } + + return dtsFiles; + } + + /** + * Recursively scan a file system directory for .d.ts files. + * + * @param directory The directory to scan + * @param currentPath The relative path from the base (used for building file paths) + * @param dtsFiles The set to collect .d.ts file paths + */ + private void scanDirectoryForDts(File directory, String currentPath, Set dtsFiles) { + if (!directory.exists() || !directory.isDirectory()) { + return; + } + + File[] files = directory.listFiles(); + if (files == null) { + return; + } + + for (File file : files) { + String fileName = file.getName(); + String filePath = currentPath.isEmpty() ? fileName : currentPath + "/" + fileName; + + if (file.isDirectory()) { + // Recursively scan subdirectory + scanDirectoryForDts(file, filePath, dtsFiles); + } else if (fileName.endsWith(".d.ts")) { + // Add .d.ts file path + dtsFiles.add(filePath); + } + } + } + + /** + * Scan a JAR file for .d.ts files in the specified resource path. + */ + private void scanJarForDts(String jarPath, String resourcePath, Set dtsFiles) { + try { + JarFile jarFile = new JarFile(jarPath); + Enumeration entries = jarFile.entries(); + + while (entries.hasMoreElements()) { + JarEntry entry = entries.nextElement(); + String entryName = entry.getName(); + + // Check if entry is under our resource path and is a .d.ts file + if (entryName.startsWith(resourcePath + "/") && entryName.endsWith(".d.ts")) { + // Convert to relative path from resourcePath + String relativePath = entryName.substring(resourcePath.length() + 1); + dtsFiles.add(relativePath); + } + } + + jarFile.close(); + } catch (Exception e) { + System.err.println("[JSTypeRegistry] Error scanning JAR for .d.ts files: " + e.getMessage()); + } + } + + /** + * Load a specific .d.ts file from resources. + */ + private void loadResourceFile(TypeScriptDefinitionParser parser, String fileName) { + try { + ResourceLocation loc = new ResourceLocation("customnpcs", "api/" + fileName); + InputStream is = Minecraft.getMinecraft().getResourceManager().getResource(loc).getInputStream(); + if (is != null) { + try (BufferedReader reader = new BufferedReader(new InputStreamReader(is))) { + StringBuilder sb = new StringBuilder(); + String line; + while ((line = reader.readLine()) != null) { + sb.append(line).append("\n"); + } + parser.parseDefinitionFile(sb.toString(), fileName); + } + } + } catch (Exception e) { + // File might not exist, that's ok + System.out.println("[JSTypeRegistry] Could not load " + fileName + ": " + e.getMessage()); + } + } + + /** + * Initialize the registry from a directory containing .d.ts files. + */ + public void initializeFromDirectory(File directory) { + if (initialized) return; + + try { + TypeScriptDefinitionParser parser = new TypeScriptDefinitionParser(this); + parser.parseDirectory(directory); + resolveAllTypeParameters(); + resolveAllMemberTypes(); + resolveAllJSDocTypes(); + resolveInheritance(); + initialized = true; + System.out.println("[JSTypeRegistry] Loaded " + types.size() + " types, " + hooks.size() + " hooks"); + } catch (IOException e) { + System.err.println("[JSTypeRegistry] Failed to load type definitions: " + e.getMessage()); + e.printStackTrace(); + } + } + + /** + * Initialize the registry from a VSIX file. + */ + public void initializeFromVsix(File vsixFile) { + if (initialized) return; + + try { + TypeScriptDefinitionParser parser = new TypeScriptDefinitionParser(this); + parser.parseVsixArchive(vsixFile); + resolveAllTypeParameters(); + resolveAllMemberTypes(); + resolveAllJSDocTypes(); + resolveInheritance(); + initialized = true; + System.out.println("[JSTypeRegistry] Loaded " + types.size() + " types, " + hooks.size() + " hooks from VSIX"); + } catch (IOException e) { + System.err.println("[JSTypeRegistry] Failed to load VSIX: " + e.getMessage()); + e.printStackTrace(); + } + } + + /** + * Register a type. + * If a type with matching javaFqn or fullName already exists, merges instead of discarding. + */ + public void registerType(JSTypeInfo type) { + String fullName = type.getFullName(); + String javaFqn = type.getJavaFqn(); + + JSTypeInfo existingType = null; + + if (javaFqn != null && !javaFqn.isEmpty()) { + existingType = typesByJavaFqn.get(javaFqn); + } + + if (existingType == null && types.containsKey(fullName)) { + existingType = types.get(fullName); + } + + if (existingType != null) { + mergeType(existingType, type, getCurrentSource()); + + // Preserve an addressable key for the incoming declared name. + // Some .d.ts parsing paths can encounter the same Java type via multiple textual names + // (e.g., due to nested namespaces). Even if we merge by @javaFqn, callers still expect + // lookups like "INpcEvent.DamagedEvent" to work. + if (!types.containsKey(fullName)) { + types.put(fullName, existingType); + typeOrigins.put(fullName, getCurrentSource()); + } + return; + } + + types.put(fullName, type); + typeOrigins.put(fullName, getCurrentSource()); + if (javaFqn != null && !javaFqn.isEmpty()) { + if (!typesByJavaFqn.containsKey(javaFqn)) { + typesByJavaFqn.put(javaFqn, type); + } else { + System.out.println("[JSTypeRegistry] Duplicate javaFqn " + javaFqn + " from " + getCurrentSource()); + } + } + } + + /** + * Get a type by Java fully-qualified name. + */ + public JSTypeInfo getTypeByJavaFqn(String javaFqn) { + if (javaFqn == null || javaFqn.isEmpty()) return null; + return typesByJavaFqn.get(javaFqn); + } + + /** + * Register a type alias. + */ + public void registerTypeAlias(String alias, String fullType) { + if (typeAliases.containsKey(alias)) { + String existing = typeAliases.get(alias); + if (!Objects.equals(existing, fullType)) { + logAliasCollision(alias, existing, fullType, getCurrentSource()); + } + return; + } + typeAliases.put(alias, fullType); + aliasOrigins.put(alias, getCurrentSource()); + } + + /** + * Register a hook function signature with a namespace. + * + * @param namespace The event interface namespace (e.g., "INpcEvent", "IPlayerEvent") + * @param functionName The hook function name (e.g., "interact", "damaged") + * @param paramName The parameter name (e.g., "event") + * @param paramType The parameter type (e.g., "INpcEvent.InteractEvent") + */ + public void registerHook(String namespace, String functionName, String paramName, String paramType) { + HookSignature sig = new HookSignature(paramName, paramType, null, namespace); + + // Add to context-specific map + contextHooks.computeIfAbsent(namespace, k -> new LinkedHashMap<>()) + .computeIfAbsent(functionName, k -> new ArrayList<>()) + .add(sig); + + // Also add to legacy hooks map for backward compatibility + hooks.computeIfAbsent(functionName, k -> new ArrayList<>()).add(sig); + } + + /** + * Get a type by name (handles aliases and primitives). + */ + public JSTypeInfo getType(String name) { + return getType(name, new HashSet<>()); + } + + /** + * Internal method with cycle detection for type aliases. + */ + private JSTypeInfo getType(String name, Set visited) { + if (name == null || name.isEmpty()) return null; + + // Strip array brackets for lookup + String baseName = name.replace("[]", "").trim(); + + // Check if primitive + if (PRIMITIVES.contains(baseName)) { + return null; // Primitives don't have JSTypeInfo + } + + // Detect circular alias references + if (visited.contains(baseName)) { + // Circular alias detected - try direct type lookup as fallback + if (types.containsKey(baseName)) { + return types.get(baseName); + } + return null; + } + visited.add(baseName); + + // Direct lookup in types first (higher priority than aliases) + if (types.containsKey(baseName)) { + return types.get(baseName); + } + + // Check type aliases + if (typeAliases.containsKey(baseName)) { + String resolved = typeAliases.get(baseName); + // Don't follow alias if it resolves to itself + if (resolved.equals(baseName)) { + return null; + } + return getType(resolved, visited); + } + + // Check global engine imports (e.g., ES5.1 Math, JSON) before giving up + if (globalEngineImports.containsKey(baseName)){ + return globalEngineImports.get(baseName); + } + + // Try simple name lookup (for types like "IEntity" without namespace) + for (JSTypeInfo type : types.values()) { + if (type.getSimpleName().equals(baseName)) { + return type; + } + } + return null; + } + + /** + * Check if a type name is a known primitive. + */ + public boolean isPrimitive(String typeName) { + return PRIMITIVES.contains(typeName); + } + + /** + * Get hook signatures for a function name. + */ + public List getHookSignatures(String functionName) { + return hooks.getOrDefault(functionName, Collections.emptyList()); + } + + /** + * Check if a function name is a known hook. + */ + public boolean isHook(String functionName) { + return hooks.containsKey(functionName); + } + + /** + * Get the parameter type for a hook function. + * If multiple overloads exist, returns the first one. + */ + public String getHookParameterType(String functionName) { + List sigs = hooks.get(functionName); + if (sigs != null && !sigs.isEmpty()) { + return sigs.get(0).paramType; + } + return null; + } + + // ==================== Context-Aware Hook Methods ==================== + + /** + * Get hook signatures for a specific script context. + * Falls back to GLOBAL context if not found in the specified context. + * + * @param namespace The event interface namespace (e.g., "INpcEvent", "IPlayerEvent") + * @param functionName The hook function name + * @return List of hook signatures, or empty list if not found + */ + public List getHookSignatures(String namespace, String functionName) { + // First try the specific namespace + Map> namespaceMap = contextHooks.get(namespace); + if (namespaceMap != null) { + List sigs = namespaceMap.get(functionName); + if (sigs != null && !sigs.isEmpty()) { + return sigs; + } + } + + // Fall back to GLOBAL namespace + if (!GLOBAL_NAMESPACE.equals(namespace)) { + Map> globalMap = contextHooks.get(GLOBAL_NAMESPACE); + if (globalMap != null) { + List sigs = globalMap.get(functionName); + if (sigs != null && !sigs.isEmpty()) { + return sigs; + } + } + } + + return Collections.emptyList(); + } + + /** + * Check if a function name is a known hook in a specific namespace. + * + * @param namespace The event interface namespace + * @param functionName The hook function name + * @return true if the hook exists in this namespace or GLOBAL + */ + public boolean isHook(String namespace, String functionName) { + return !getHookSignatures(namespace, functionName).isEmpty(); + } + + /** + * Get the parameter type for a hook function in a specific namespace. + * Falls back to GLOBAL namespace if not found. + * + * @param namespace The event interface namespace + * @param functionName The hook function name + * @return The parameter type, or null if not found + */ + public String getHookParameterType(String namespace, String functionName) { + List sigs = getHookSignatures(namespace, functionName); + if (!sigs.isEmpty()) { + return sigs.get(0).paramType; + } + return null; + } + + /** + * Get all hook names for a specific namespace. + * + * @param namespace The event interface namespace + * @return Set of hook function names available in this namespace + */ + public Set getHookNames(String namespace) { + Set names = new HashSet<>(); + + // Add hooks from the specific namespace + Map> namespaceMap = contextHooks.get(namespace); + if (namespaceMap != null) { + names.addAll(namespaceMap.keySet()); + } + + // Also add GLOBAL hooks + if (!GLOBAL_NAMESPACE.equals(namespace)) { + Map> globalMap = contextHooks.get(GLOBAL_NAMESPACE); + if (globalMap != null) { + names.addAll(globalMap.keySet()); + } + } + + return names; + } + + /** + * Get all hooks organized by namespace. + * + * @return Map of namespace -> hookName -> signatures + */ + public Map>> getAllContextHooks() { + return Collections.unmodifiableMap(contextHooks); + } + + // ==================== MULTI-NAMESPACE LOOKUP (for ScriptContext) ==================== + + /** + * Get hook signatures by searching through multiple namespaces. + * This is used when a ScriptContext has multiple event types (e.g., Player has + * IPlayerEvent, IAnimationEvent, IPartyEvent, etc.) + * + * @param namespaces List of namespaces to search (in priority order) + * @param functionName The hook function name + * @return List of hook signatures from the first matching namespace, or empty list + */ + public List getHookSignatures(List namespaces, String functionName) { + // Search through all namespaces in order + for (String namespace : namespaces) { + Map> namespaceMap = contextHooks.get(namespace); + if (namespaceMap != null) { + List sigs = namespaceMap.get(functionName); + if (sigs != null && !sigs.isEmpty()) { + return sigs; + } + } + } + + // Fall back to GLOBAL namespace + Map> globalMap = contextHooks.get(GLOBAL_NAMESPACE); + if (globalMap != null) { + List sigs = globalMap.get(functionName); + if (sigs != null && !sigs.isEmpty()) { + return sigs; + } + } + + return Collections.emptyList(); + } + + /** + * Check if a function name is a known hook in any of the given namespaces. + * + * @param namespaces List of namespaces to search + * @param functionName The hook function name + * @return true if the hook exists in any namespace or GLOBAL + */ + public boolean isHook(List namespaces, String functionName) { + return !getHookSignatures(namespaces, functionName).isEmpty(); + } + + /** + * Get the parameter type for a hook function, searching through multiple namespaces. + * + * @param namespaces List of namespaces to search + * @param functionName The hook function name + * @return The parameter type, or null if not found + */ + public String getHookParameterType(List namespaces, String functionName) { + List sigs = getHookSignatures(namespaces, functionName); + if (!sigs.isEmpty()) { + return sigs.get(0).paramType; + } + return null; + } + + /** + * Get all hook names available in any of the given namespaces. + * + * @param namespaces List of namespaces to search + * @return Set of hook function names available in these namespaces + */ + public Set getHookNames(List namespaces) { + Set names = new HashSet<>(); + + // Add hooks from all specified namespaces + for (String namespace : namespaces) { + Map> namespaceMap = contextHooks.get(namespace); + if (namespaceMap != null) { + names.addAll(namespaceMap.keySet()); + } + } + + // Also add GLOBAL hooks + Map> globalMap = contextHooks.get(GLOBAL_NAMESPACE); + if (globalMap != null) { + names.addAll(globalMap.keySet()); + } + + return names; + } + + /** + * Resolve all type parameters for all types. + * Called after all .d.ts files are loaded (Phase 2). + * This ensures that type parameters can reference any type in the registry. + */ + public void resolveAllTypeParameters() { + for (JSTypeInfo type : types.values()) { + type.resolveTypeParameters(); + } + } + + /** + * Resolve all member types (return types, field types, parameter types) for all types. + * Called after resolveAllTypeParameters (Phase 2b). + * This resolves types like "Java.java.io.File" to proper TypeInfo objects. + */ + public void resolveAllMemberTypes() { + for (JSTypeInfo type : types.values()) + type.resolveMemberTypes(); + } + + public void resolveAllJSDocTypes() { + for (JSTypeInfo type : types.values()) + type.resolveJSDocTypes(); + } + + /** + * Resolve inheritance relationships between types. + * For each type, walks up the parent chain and resolves all ancestors. + * Efficient O(n) approach - each type's chain is walked once. + */ + public void resolveInheritance() { + for (JSTypeInfo type : types.values()) { + JSTypeInfo child = type; + while (child != null && child.getExtendsType() != null && child.getResolvedParent() == null) { + JSTypeInfo parent = getType(child.getExtendsType()); + if (parent != null) { + child.setResolvedParent(parent); + } + child = parent; + } + } + } + + /** + * Get all registered types. + */ + public Collection getAllTypes() { + return types.values(); + } + + /** + * Get all type names. + */ + public Set getTypeNames() { + return types.keySet(); + } + + /** + * Get all hook function names. + */ + public Set getHookNames() { + return hooks.keySet(); + } + + /** + * Get all registered hooks. + */ + public Map> getAllHooks() { + return hooks; + } + + /** + * Register a global object instance (like API, DBCAPI from NpcAPI.engineObjects). + * These are treated as instance objects, not static classes. + * @param name The global variable name (e.g., "API") + * @param typeName The type name (e.g., "AbstractNpcAPI") + */ + public void registerGlobalObject(String name, String typeName) { + globalEngineObjects.put(name, typeName); + } + + /** + * Get the type name for a global object. + * @param name The global variable name + * @return The type name, or null if not a registered global object + */ + public String getGlobalObjectType(String name) { + return globalEngineObjects.get(name); + } + + /** + * Check if a name is a registered global object instance. + */ + public boolean isGlobalObject(String name) { + return globalEngineObjects.containsKey(name); + } + + /** + * Get all registered global objects. + */ + public Map getGlobalEngineObjects() { + return Collections.unmodifiableMap(globalEngineObjects); + } + + /** + * Registers global objects from NpcAPI.engineObjects into JSTypeRegistry. + * This allows the IDE to recognize API, DBCAPI, etc. as instance objects with autocomplete. + */ + private void registerEngineGlobalObjects() { + Map engineObjects = new HashMap<>(NpcAPI.engineObjects); + engineObjects.put("API", NpcAPI.Instance()); //default API object + + if (engineObjects != null) { + for (Map.Entry entry : engineObjects.entrySet()) { + String name = entry.getKey(); // e.g., "API", "DBCAPI" + Object obj = entry.getValue(); // e.g., AbstractNpcAPI instance + + if (obj != null) { + // Get the actual class name + String concreteClassName = obj.getClass().getSimpleName(); + + // Map concrete implementation classes to their abstract interface names + // (because .d.ts files define the abstract interfaces, not the implementations) + String typeName = mapConcreteToAbstractClassName(concreteClassName); + + // Register as global object (instance, not static) + registerGlobalObject(name, typeName); + } + } + } + } + + /** + * Maps concrete implementation class names to their abstract interface names. + * For example: "NpcAPI" -> "AbstractNpcAPI", "DBCAPI" -> "AbstractDBCAPI" + */ + private String mapConcreteToAbstractClassName(String concreteClassName) { + // Check if the type exists in the registry as-is + if (types.containsKey(concreteClassName)) + return concreteClassName; + + // Try prepending "Abstract" if it doesn't exist + String abstractName = "Abstract" + concreteClassName; + if (types.containsKey(abstractName)) + return abstractName; + + // Default: return the original name + return concreteClassName; + } + + /** + * Register ECMAScript 5.1 global built-in objects so that expressions like + * `Math.floor(Math.random())`, `new Date()`, `Array.isArray(...)`, etc. + * resolve properly with type checking and autocomplete. + * + * These globals are parsed from .d.ts patch files under `patches/ecmascript/` + * and provide both static methods (e.g., Math.floor, Array.isArray, Object.keys) + * and instance members (e.g., date.getTime(), array.length, string.charAt). + */ + private void registerES5Builtins() { + // Singleton/namespace globals (accessed directly, not constructed) + registerGlobalIfTypeExists("Math", "Math"); + registerGlobalIfTypeExists("JSON", "JSON"); + + // Constructor globals (can be called with `new` or used for static methods) + registerGlobalIfTypeExists("Date", "Date"); + registerGlobalIfTypeExists("Array", "Array"); + registerGlobalIfTypeExists("Object", "Object"); + registerGlobalIfTypeExists("String", "String"); + registerGlobalIfTypeExists("Number", "Number"); + registerGlobalIfTypeExists("Boolean", "Boolean"); + registerGlobalIfTypeExists("RegExp", "RegExp"); + registerGlobalIfTypeExists("Error", "Error"); + + extractGlobalFunctions(); + } + + /** + * Registers a global object only if the target type is present in the registry. + * Silently skips if the .d.ts patch hasn't been loaded yet (e.g. in unit tests). + */ + private void registerGlobalIfTypeExists(String globalName, String typeName) { + // Remove the type since it's now accessed via the global import + if (types.containsKey(typeName)) { + globalEngineImports.put(globalName, types.remove(typeName)); + } + } + + /** + * Extract top-level global functions from the GlobalFunctions JSTypeInfo. + * Moves all methods into globalEngineFunctions and removes the GlobalFunctions + * type from the registry (it is not a constructable type). + */ + private void extractGlobalFunctions() { + JSTypeInfo globalFns = types.get("GlobalFunctions"); + if (globalFns == null) return; + + for (Map.Entry entry : globalFns.getMethods().entrySet()) { + String key = entry.getKey(); + // Strip overload suffix ($1, $2, …) to get base name + String baseName = key.contains("$") ? key.substring(0, key.indexOf('$')) : key; + // Keep the first overload per base name + globalEngineFunctions.putIfAbsent(baseName, entry.getValue()); + } + + // Remove GlobalFunctions from the main type registry — it is not a usable type name + types.remove("GlobalFunctions"); + } + + /** + * Get the type name for a global object. + * @param name The global variable name + * @return The type name, or null if not a registered global object + */ + public JSTypeInfo getGlobalImportType(String name) { + return globalEngineImports.get(name); + } + + /** + * Check if a name is a registered global object instance. + */ + public boolean isGlobalImport(String name) { + return globalEngineImports.containsKey(name); + } + + /** + * Get all registered global objects. + */ + public Map getGlobalEngineImports() { + return Collections.unmodifiableMap(globalEngineImports); + } + + /** + * Get JSMethodInfo for a global engine function by name (e.g., "parseInt"). + */ + public JSMethodInfo getGlobalEngineFunction(String name) { + return globalEngineFunctions.get(name); + } + + /** + * Check if a name is a registered global engine function. + */ + public boolean isGlobalEngineFunction(String name) { + return globalEngineFunctions.containsKey(name); + } + + /** + * Get all registered global engine functions (parseInt, parseFloat, isNaN, etc.). + */ + public Map getGlobalEngineFunctions() { + return Collections.unmodifiableMap(globalEngineFunctions); + } + /** + * Check if initialized. + */ + public boolean isInitialized() { + return initialized; + } + + /** + * Clear the registry (for reloading). + */ + public void clear() { + types.clear(); + typesByJavaFqn.clear(); + typeAliases.clear(); + typeOrigins.clear(); + aliasOrigins.clear(); + hooks.clear(); + contextHooks.clear(); + globalEngineObjects.clear(); + globalEngineImports.clear(); + globalEngineFunctions.clear(); + DtsJavaBridge.clearCache(); + initialized = false; + initializationAttempted = false; + currentSource = null; + lastSyncedHookRevision = -1; + } + + /** + * Sync hook signatures from ScriptHookController into this registry. + * Uses revision-gating so repeated calls are no-ops when nothing changed. + */ + public void syncHooksFromScriptHookControllerIfNeeded() { + try { + if (ScriptHookController.Instance == null) { + return; + } + + int currentRevision = ScriptHookController.Instance.getHookRevision(); + if (currentRevision == lastSyncedHookRevision) { + return; + } + + hooks.clear(); + contextHooks.clear(); + + Set seen = new HashSet<>(); + + String[] contexts = ScriptHookController.Instance.getContexts(); + if (contexts != null) { + for (String context : contexts) { + if (context == null || context.isEmpty()) { + continue; + } + List defs = ScriptHookController.Instance.getAllHookDefinitions(context); + if (defs == null || defs.isEmpty()) { + continue; + } + + for (IHookDefinition def : defs) { + if (def == null) { + continue; + } + String hookName = def.hookName(); + if (hookName == null || hookName.isEmpty()) { + continue; + } + + String usableTypeName = def.getUsableTypeName(); + String namespace; + String paramType; + + if (usableTypeName != null && usableTypeName.contains(".")) { + namespace = usableTypeName.substring(0, usableTypeName.indexOf('.')); + } else { + namespace = GLOBAL_NAMESPACE; + } + + paramType = usableTypeName != null ? usableTypeName : "any"; + + String[] paramNames = def.paramNames(); + String paramName = (paramNames != null && paramNames.length > 0 && paramNames[0] != null && !paramNames[0].isEmpty()) + ? paramNames[0] + : "event"; + + String dedupKey = namespace + "|" + hookName + "|" + paramType + "|" + paramName; + if (!seen.add(dedupKey)) { + continue; + } + registerHook(namespace, hookName, paramName, paramType); + } + } + } + + lastSyncedHookRevision = currentRevision; + } catch (Throwable t) { + System.err.println("[JSTypeRegistry] Failed to sync runtime hooks: " + t.getMessage()); + t.printStackTrace(); + } + } + + private void setCurrentSource(String source) { + currentSource = source; + } + + private String getCurrentSource() { + return currentSource == null ? "unknown" : currentSource; + } + + private void logTypeCollision(String fullName, String incomingSource) { + String existingSource = typeOrigins.getOrDefault(fullName, "unknown"); + System.out.println("[JSTypeRegistry] Duplicate type " + fullName + " from " + incomingSource + " (kept " + existingSource + ")"); + } + + private void logAliasCollision(String alias, String existingType, String incomingType, String incomingSource) { + String existingSource = aliasOrigins.getOrDefault(alias, "unknown"); + System.out.println("[JSTypeRegistry] Duplicate alias " + alias + " from " + incomingSource + " (kept " + existingSource + ")"); + System.out.println("[JSTypeRegistry] Alias " + alias + " existing=" + existingType + " incoming=" + incomingType); + } + + /** + * Find the method key in a type's methods map that matches the given method name and parameter count. + * This handles overload keys (methodName, methodName$1, methodName$2, etc.) + * + * @param type The type to search in + * @param candidate The method name to search for + * @return The method key if found, or null if no match + */ + private String findOwnMethodKeyBySignature(JSTypeInfo type, JSMethodInfo candidate) { + Map methods = type.getMethods(); + String methodName = candidate.getName(); + + // Check direct key first + JSMethodInfo direct = methods.get(methodName); + if (direct != null && hasSameParameterSignature(direct, candidate)) { + return methodName; + } + + // Check overload keys: methodName$1, methodName$2, etc. + int index = 1; + String overloadKey = methodName + "$" + index; + while (methods.containsKey(overloadKey)) { + JSMethodInfo overload = methods.get(overloadKey); + if (hasSameParameterSignature(overload, candidate)) { + return overloadKey; + } + index++; + overloadKey = methodName + "$" + index; + } + + return null; // No match found + } + + private boolean hasSameParameterSignature(JSMethodInfo left, JSMethodInfo right) { + if (left == null || right == null) { + return false; + } + + if (left.getParameterCount() != right.getParameterCount()) { + return false; + } + + List leftParams = left.getParameters(); + List rightParams = right.getParameters(); + for (int i = 0; i < leftParams.size(); i++) { + String leftType = leftParams.get(i).getType(); + String rightType = rightParams.get(i).getType(); + if (!Objects.equals(leftType, rightType)) { + return false; + } + } + + return true; + } + + /** + * Merge an incoming type into an existing type. + * This allows addon mods to patch base mod types via .d.ts files. + * + * @param existing The existing type to merge into + * @param incoming The incoming type to merge from + * @param incomingSource The source of the incoming type (for logging) + */ + private void mergeType(JSTypeInfo existing, JSTypeInfo incoming, String incomingSource) { + int methodsMerged = 0; + int fieldsMerged = 0; + + // Merge methods (replace matching overloads by param count) + for (Map.Entry entry : incoming.getMethods().entrySet()) { + JSMethodInfo incomingMethod = entry.getValue(); + String methodName = incomingMethod.getName(); + String existingKey = findOwnMethodKeyBySignature(existing, incomingMethod); + if (existingKey != null) { + // Replace existing overload + existing.getMethods().put(existingKey, incomingMethod); + incomingMethod.setContainingType(existing); + methodsMerged++; + } else { + // Add as new overload + existing.addMethod(incomingMethod); + methodsMerged++; + } + } + + // Merge fields (replace by name) + for (Map.Entry entry : incoming.getFields().entrySet()) { + String fieldName = entry.getKey(); + JSFieldInfo incomingField = entry.getValue(); + existing.getFields().put(fieldName, incomingField); + incomingField.setContainingType(existing); + fieldsMerged++; + } + + // Merge metadata (fill gaps only - preserve existing non-null values) + if (existing.getJavaFqn() == null && incoming.getJavaFqn() != null) { + existing.setJavaFqn(incoming.getJavaFqn()); + } + if (existing.getJsDocInfo() == null && incoming.getJsDocInfo() != null) { + existing.setJsDocInfo(incoming.getJsDocInfo()); + } + if (existing.getExtendsType() == null && incoming.getExtendsType() != null) { + existing.setExtends(incoming.getExtendsType()); + } + + // Log merge details + System.out.println("[JSTypeRegistry] Merged type " + existing.getFullName() + + " with " + methodsMerged + " methods, " + fieldsMerged + + " fields from " + incomingSource); + } + + /** + * Represents a hook function signature with its namespace. + */ + public static class HookSignature { + public final String paramName; + public final String paramType; + public final String doc; + public final String namespace; // The event interface namespace (e.g., "INpcEvent") + + public HookSignature(String paramName, String paramType) { + this(paramName, paramType, null, GLOBAL_NAMESPACE); + } + + public HookSignature(String paramName, String paramType, String doc) { + this(paramName, paramType, doc, GLOBAL_NAMESPACE); + } + + public HookSignature(String paramName, String paramType, String doc, String namespace) { + this.paramName = paramName; + this.paramType = paramType; + this.doc = doc; + this.namespace = namespace != null ? namespace : GLOBAL_NAMESPACE; + } + + @Override + public String toString() { + return paramName + ": " + paramType + " [" + namespace + "]"; + } + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/TypeParamInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/TypeParamInfo.java new file mode 100644 index 000000000..846a23f47 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/TypeParamInfo.java @@ -0,0 +1,68 @@ +package noppes.npcs.client.gui.util.script.interpreter.js_parser; + +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeResolver; + +/** + * Represents a generic type parameter like "T extends Entity". + * Stores the parameter name and both the string representation (for deferred resolution) + * and the resolved TypeInfo for the bound. + */ +public class TypeParamInfo { + private final String name; // e.g., "T" + private final String boundType; // Simple name like "EntityPlayerMP" (may be null) + private final String fullBoundType; // Full name like "net.minecraft.entity.player.EntityPlayerMP" (may be null) + private TypeInfo boundTypeInfo; // Resolved TypeInfo for the bound (resolved in Phase 2) + + /** + * Constructor for parse-time (Phase 1) - stores string names only. + */ + public TypeParamInfo(String name, String boundType, String fullBoundType) { + this.name = name; + this.boundType = boundType; + this.fullBoundType = fullBoundType; + this.boundTypeInfo = null; // Will be resolved later + } + + public String getName() { return name; } + + public TypeInfo getBoundTypeInfo() { + return boundTypeInfo; + } + + /** + * Resolve the bound type using TypeResolver. + * Called during Phase 2 after all types are loaded. + */ + public void resolveBoundType() { + if (boundTypeInfo != null) + return; // Already resolved + + if (fullBoundType != null && !fullBoundType.isEmpty()) { + // Try to load the Java class using the full name + boundTypeInfo = TypeResolver.getInstance().resolveFullName(fullBoundType); + } else if (boundType != null && !boundType.isEmpty()) { + // Try to resolve using the simple name + boundTypeInfo = TypeResolver.getInstance().resolveJSType(boundType); + } + } + + /** + * Get display name for the bound type, including generic arguments. + */ + public String getBoundTypeName() { + if (boundTypeInfo == null) + return null; + return boundTypeInfo.getDisplayName(); + } + + @Override + public String toString() { + if (boundTypeInfo != null) { + return name + " extends " + boundTypeInfo.getDisplayName(); + } else if (boundType != null || fullBoundType != null) { + return name + " extends " + (boundType != null ? boundType : fullBoundType); + } + return name; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/TypeScriptDefinitionParser.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/TypeScriptDefinitionParser.java new file mode 100644 index 000000000..9c82e63c4 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/js_parser/TypeScriptDefinitionParser.java @@ -0,0 +1,728 @@ +package noppes.npcs.client.gui.util.script.interpreter.js_parser; + +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocInfo; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocTag; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeStringNormalizer; + +import java.io.*; +import java.util.*; +import java.util.regex.*; +import java.util.zip.*; + +/** + * Parses TypeScript definition files (.d.ts) to extract type information. + * Can read from individual files, directories, or .vsix archives. + */ +public class TypeScriptDefinitionParser { + + // Patterns for parsing .d.ts content + // Updated to capture generic type parameters like: export interface IEntity + private static final Pattern INTERFACE_PATTERN = Pattern.compile( + "export\\s+interface\\s+(\\w+)(?:<([^>]*)>)?(?:\\s+extends\\s+([^{]+?))?\\s*\\{"); + + // Pattern for nested interfaces without export keyword + private static final Pattern NESTED_INTERFACE_PATTERN = Pattern.compile( + "(?]*)>)?(?:\\s+extends\\s+([^{]+?))?\\s*\\{"); + + // Similar pattern for classes + private static final Pattern CLASS_PATTERN = Pattern.compile( + "export\\s+class\\s+(\\w+)(?:<([^>]*)>)?(?:\\s+extends\\s+([^{]+?))?\\s*\\{"); + + // Pattern to parse individual type parameters like: T extends EntityPlayerMP /* net.minecraft.entity.player.EntityPlayerMP */ + private static final Pattern TYPE_PARAM_PATTERN = Pattern.compile( + "(\\w+)(?:\\s+extends\\s+(\\w+)(?:\\s*/\\*\\s*([\\w.]+)\\s*\\*/)?)?"); + + // Match both "export namespace" and plain "namespace" (for declare global blocks) + private static final Pattern NAMESPACE_PATTERN = Pattern.compile( + "(?:export\\s+)?namespace\\s+(\\w+)\\s*\\{"); + + // Make semicolon optional for type aliases (TypeScript doesn't require them) + private static final Pattern TYPE_ALIAS_PATTERN = Pattern.compile( + "export\\s+type\\s+(\\w+)\\s*=\\s*([^;\\n]+);?"); + + private static final Pattern METHOD_PATTERN = Pattern.compile( + "(?m)^\\s*(static\\s+)?(\\w+)\\??\\s*\\((.*)\\)\\s*:\\s*([^;]+);", Pattern.MULTILINE); + + private static final Pattern FIELD_PATTERN = Pattern.compile( + "^\\s*(static\\s+)?(readonly\\s+)?(\\w+)\\??\\s*:\\s*([^;]+);", Pattern.MULTILINE); + + private static final Pattern GLOBAL_FUNCTION_PATTERN = Pattern.compile( + "function\\s+(\\w+)\\s*\\((.*)\\)\\s*:\\s*([^;]+);"); + + private static final Pattern GLOBAL_TYPE_ALIAS_PATTERN = Pattern.compile( + "type\\s+(\\w+)\\s*=\\s*import\\(['\"]([^'\"]+)['\"]\\)\\.([\\w.]+);"); + + // Pattern for context-namespaced hooks like: declare namespace INpcEvent { ... } + // Matches any "declare namespace {" where Name starts with I and contains Event, + // or any other namespace pattern used for hooks + private static final Pattern HOOKS_NAMESPACE_PATTERN = Pattern.compile( + "declare\\s+namespace\\s+(I\\w*Event|\\w+)\\s*\\{", Pattern.MULTILINE); + + private final JSTypeRegistry registry; + + public TypeScriptDefinitionParser(JSTypeRegistry registry) { + this.registry = registry; + } + + /** + * Parse all .d.ts files from a VSIX archive. + */ + public void parseVsixArchive(File vsixFile) throws IOException { + try (ZipFile zip = new ZipFile(vsixFile)) { + Enumeration entries = zip.entries(); + while (entries.hasMoreElements()) { + ZipEntry entry = entries.nextElement(); + if (entry.getName().endsWith(".d.ts")) { + try (InputStream is = zip.getInputStream(entry); + BufferedReader reader = new BufferedReader(new InputStreamReader(is))) { + String content = readFully(reader); + String fileName = entry.getName(); + parseDefinitionFile(content, fileName); + } + } + } + } + } + + /** + * Parse all .d.ts files from a directory recursively. + */ + public void parseDirectory(File directory) throws IOException { + if (!directory.isDirectory()) { + throw new IllegalArgumentException("Not a directory: " + directory); + } + parseDirectoryRecursive(directory); + } + + private void parseDirectoryRecursive(File dir) throws IOException { + File[] files = dir.listFiles(); + if (files == null) return; + + for (File file : files) { + if (file.isDirectory()) { + parseDirectoryRecursive(file); + } else if (file.getName().endsWith(".d.ts")) { + parseFile(file); + } + } + } + + /** + * Parse a single .d.ts file. + */ + public void parseFile(File file) throws IOException { + try (BufferedReader reader = new BufferedReader(new FileReader(file))) { + String content = readFully(reader); + parseDefinitionFile(content, file.getName()); + } + } + + /** + * Parse a .d.ts file content. + */ + public void parseDefinitionFile(String content, String fileName) { + // Special handling for hooks.d.ts - extract function signatures + if (fileName.contains("hooks.d.ts")) { + // Commented out as hooks are now parsed through ScriptHookController which is the universal source of truth for registered hooks. + // parseHooksFile(content); + return; + } + + // Special handling for index.d.ts - extract global type aliases + if (fileName.contains("index.d.ts")) { + parseIndexFile(content); + return; + } + + // Parse regular interface files + String packageName = derivePackageName(fileName); + parseInterfaceFile(content, null, packageName); + } + + /** + * Parse hooks.d.ts to extract function signatures for JS hooks. + * + * Hooks are organized by their parent event interface, with the interface name + * used directly as the namespace. Any mod can register its own event interfaces + * and they will be automatically parsed: + * + * declare namespace INpcEvent { + * function interact(event: INpcEvent.InteractEvent): void; + * function init(event: INpcEvent.InitEvent): void; + * } + * + * declare namespace IPlayerEvent { + * function interact(event: IPlayerEvent.InteractEvent): void; + * } + * + * declare namespace IDBCEvent { + * function customHook(event: IDBCEvent.CustomEvent): void; + * } + * + * The namespace name is stored as a string, allowing dynamic registration + * without requiring enum modifications. + */ + private void parseHooksFile(String content) { + // Parse namespaced hooks (e.g., declare namespace INpcEvent { ... }) + // The namespace name is used directly - any event interface can register hooks + Matcher namespaceMatcher = HOOKS_NAMESPACE_PATTERN.matcher(content); + while (namespaceMatcher.find()) { + String namespace = namespaceMatcher.group(1); // e.g., "INpcEvent", "IPlayerEvent", "IDBCEvent" + + // Find the body of this namespace + int bodyStart = namespaceMatcher.end(); + int bodyEnd = findMatchingBrace(content, bodyStart - 1); + if (bodyEnd > bodyStart) { + String namespaceBody = content.substring(bodyStart, bodyEnd); + + // Parse functions within this namespace + Matcher funcMatcher = GLOBAL_FUNCTION_PATTERN.matcher(namespaceBody); + while (funcMatcher.find()) { + String funcName = funcMatcher.group(1); + String params = funcMatcher.group(2); + + // Parse parameter - format is "paramName: TypeName" + if (!params.isEmpty()) { + String[] parts = params.split(":\\s*", 2); + if (parts.length == 2) { + String paramName = parts[0].trim(); + String paramType = parts[1].trim(); + // Register hook with the namespace string directly + registry.registerHook(namespace, funcName, paramName, paramType); + } + } + } + } + } + } + + /** + * Parse index.d.ts to extract global type aliases. + */ + private void parseIndexFile(String content) { + Matcher m = GLOBAL_TYPE_ALIAS_PATTERN.matcher(content); + while (m.find()) { + String aliasName = m.group(1); + String importPath = m.group(2); + String typeName = m.group(3); + registry.registerTypeAlias(aliasName, typeName); + } + } + + /** + * Parse interface and class definitions from content. + */ + private void parseInterfaceFile(String content, String parentNamespace, String packageName) { + // IMPORTANT: + // Many generated .d.ts files declare nested exported interfaces inside `namespace X { ... }` blocks. + // If we scan `content` directly for `export interface` / `export class`, we'll accidentally treat + // those nested exports as top-level for the current `parentNamespace`. + // That pollutes the registry with incorrectly-scoped type names (e.g. "DamagedEvent" instead of + // "INpcEvent.DamagedEvent"), and later registry merges (by @javaFqn) can prevent the correctly + // namespaced key from ever being registered. + // + // To avoid this, we strip namespace blocks out of the scan input and then parse namespaces + // explicitly via the NAMESPACE_PATTERN recursion further below. + String scanContent = stripNamespaceBlocks(content); + + // Find exported interfaces + Matcher interfaceMatcher = INTERFACE_PATTERN.matcher(scanContent); + while (interfaceMatcher.find()) { + String interfaceName = interfaceMatcher.group(1); + String typeParamsStr = interfaceMatcher.group(2); // e.g., "T extends EntityPlayerMP /* net.minecraft.entity.player.EntityPlayerMP */" + String extendsClause = interfaceMatcher.group(3); + + JSTypeInfo typeInfo = new JSTypeInfo(interfaceName, parentNamespace); + + JSDocInfo jsDoc = extractJSDocBefore(content, interfaceMatcher.start()); + if (jsDoc != null) { + typeInfo.setJsDocInfo(jsDoc); + } + + String javaFqn = findJavaFqn(jsDoc, packageName, typeInfo.getFullName()); + if (javaFqn != null && !javaFqn.isEmpty()) { + typeInfo.setJavaFqn(javaFqn); + } + + // Parse type parameters + if (typeParamsStr != null && !typeParamsStr.isEmpty()) { + parseTypeParameters(typeParamsStr, typeInfo); + } + + if (extendsClause != null) { + // Handle multiple extends (e.g., "IEntityLivingBase, IAnimatable") + // Take the first one, stripping generics + String extendsType = extendsClause.trim(); + // Remove generic parameters like + extendsType = extendsType.replaceAll("<[^>]*>", ""); + // If multiple types (comma-separated), take the first one + if (extendsType.contains(",")) { + extendsType = extendsType.substring(0, extendsType.indexOf(',')).trim(); + } + // Clean up import() syntax if present + extendsType = cleanType(extendsType); + typeInfo.setExtends(extendsType); + } + + // Find the body of this interface + int bodyStart = interfaceMatcher.end(); + int bodyEnd = findMatchingBrace(content, bodyStart - 1); + if (bodyEnd > bodyStart) { + String body = content.substring(bodyStart, bodyEnd); + parseInterfaceBody(body, typeInfo); + + // Parse nested interfaces and type aliases within this interface body + String fullNamespace = parentNamespace != null ? + parentNamespace + "." + interfaceName : interfaceName; + parseNestedTypes(body, fullNamespace, packageName); + } + + registry.registerType(typeInfo); + } + + // Find nested interfaces (without export keyword) + Matcher nestedInterfaceMatcher = NESTED_INTERFACE_PATTERN.matcher(scanContent); + while (nestedInterfaceMatcher.find()) { + String interfaceName = nestedInterfaceMatcher.group(1); + String typeParamsStr = nestedInterfaceMatcher.group(2); + String extendsClause = nestedInterfaceMatcher.group(3); + + JSTypeInfo typeInfo = new JSTypeInfo(interfaceName, parentNamespace); + + JSDocInfo jsDoc = extractJSDocBefore(content, nestedInterfaceMatcher.start()); + if (jsDoc != null) { + typeInfo.setJsDocInfo(jsDoc); + } + + // Parse type parameters + if (typeParamsStr != null && !typeParamsStr.isEmpty()) { + parseTypeParameters(typeParamsStr, typeInfo); + } + + if (extendsClause != null) { + String extendsType = extendsClause.trim(); + extendsType = extendsType.replaceAll("<[^>]*>", ""); + if (extendsType.contains(",")) { + extendsType = extendsType.substring(0, extendsType.indexOf(',')).trim(); + } + extendsType = cleanType(extendsType); + typeInfo.setExtends(extendsType); + } + + // Find the body of this nested interface + int bodyStart = nestedInterfaceMatcher.end(); + int bodyEnd = findMatchingBrace(content, bodyStart - 1); + if (bodyEnd > bodyStart) { + String body = content.substring(bodyStart, bodyEnd); + parseInterfaceBody(body, typeInfo); + } + + registry.registerType(typeInfo); + } + + // Find classes (same logic as interfaces) + Matcher classMatcher = CLASS_PATTERN.matcher(scanContent); + while (classMatcher.find()) { + String className = classMatcher.group(1); + String typeParamsStr = classMatcher.group(2); + String extendsClause = classMatcher.group(3); + + JSTypeInfo typeInfo = new JSTypeInfo(className, parentNamespace); + + JSDocInfo jsDoc = extractJSDocBefore(content, classMatcher.start()); + if (jsDoc != null) { + typeInfo.setJsDocInfo(jsDoc); + } + + // Parse type parameters + if (typeParamsStr != null && !typeParamsStr.isEmpty()) { + parseTypeParameters(typeParamsStr, typeInfo); + } + + if (extendsClause != null) { + String extendsType = extendsClause.trim(); + extendsType = extendsType.replaceAll("<[^>]*>", ""); + if (extendsType.contains(",")) { + extendsType = extendsType.substring(0, extendsType.indexOf(',')).trim(); + } + extendsType = cleanType(extendsType); + typeInfo.setExtends(extendsType); + } + + // Find the body of this class + int bodyStart = classMatcher.end(); + int bodyEnd = findMatchingBrace(content, bodyStart - 1); + if (bodyEnd > bodyStart) { + String body = content.substring(bodyStart, bodyEnd); + parseInterfaceBody(body, typeInfo); + } + + registry.registerType(typeInfo); + } + + // Find namespaces (which contain inner types) + Matcher namespaceMatcher = NAMESPACE_PATTERN.matcher(content); + while (namespaceMatcher.find()) { + String namespaceName = namespaceMatcher.group(1); + + // Find the body of this namespace + int bodyStart = namespaceMatcher.end(); + int bodyEnd = findMatchingBrace(content, bodyStart - 1); + if (bodyEnd > bodyStart) { + String body = content.substring(bodyStart, bodyEnd); + + // Parse inner types with namespace prefix + // Namespaces contain exported types, so use parseInterfaceFile + String fullNamespace = parentNamespace != null ? + parentNamespace + "." + namespaceName : namespaceName; + parseInterfaceFile(body, fullNamespace, packageName); + // Don't call parseNestedTypes here - namespace members are all exported + // and will be caught by parseInterfaceFile's INTERFACE_PATTERN + } + } + + // Handle top-level type aliases + if (parentNamespace == null) { + parseTypeAliases(content, null); + } + } + + /** + * Strip namespace blocks from a file-level scan to avoid incorrectly capturing nested exports. + * + * This replaces the entire `namespace X { ... }` span (including braces) with whitespace so that + * match indices remain stable when we later slice `content` for bodies. + */ + private String stripNamespaceBlocks(String content) { + if (content == null || content.isEmpty()) { + return content; + } + + Matcher m = NAMESPACE_PATTERN.matcher(content); + if (!m.find()) { + return content; + } + + char[] chars = content.toCharArray(); + + int searchFrom = 0; + m.reset(); + while (m.find(searchFrom)) { + int start = m.start(); + int bodyStart = m.end(); + int bodyEnd = findMatchingBrace(content, bodyStart - 1); + if (bodyEnd <= start) { + searchFrom = Math.max(m.end(), searchFrom + 1); + continue; + } + + int endExclusive = Math.min(chars.length, bodyEnd + 1); + for (int i = start; i < endExclusive; i++) { + chars[i] = ' '; + } + + searchFrom = endExclusive; + } + + return new String(chars); + } + + /** + * Parse type parameters from a string like "T extends EntityPlayerMP /* net.minecraft.entity.player.EntityPlayerMP *`/". + * Handles multiple parameters separated by commas. + * Stores strings only - resolution happens in Phase 2 after all types are loaded. + */ + private void parseTypeParameters(String typeParamsStr, JSTypeInfo typeInfo) { + // Split by comma, but be careful with nested generics (shouldn't happen at this level, but be safe) + String[] params = typeParamsStr.split(","); + for (String param : params) { + param = param.trim(); + if (param.isEmpty()) continue; + + Matcher m = TYPE_PARAM_PATTERN.matcher(param); + if (m.find()) { + String name = m.group(1); + String boundType = m.group(2); // Simple name like "EntityPlayerMP" + String fullBoundType = m.group(3); // Full name like "net.minecraft.entity.player.EntityPlayerMP" + + // Store strings only - resolution happens in Phase 2 + typeInfo.addTypeParam(new TypeParamInfo(name, boundType, fullBoundType)); + } + } + } + + /** + * Parse nested types (interfaces and type aliases) within a parent type or namespace. + */ + private void parseNestedTypes(String content, String namespace, String packageName) { + // Parse nested interfaces + Matcher nestedInterfaceMatcher = NESTED_INTERFACE_PATTERN.matcher(content); + while (nestedInterfaceMatcher.find()) { + String interfaceName = nestedInterfaceMatcher.group(1); + String typeParamsStr = nestedInterfaceMatcher.group(2); + String extendsClause = nestedInterfaceMatcher.group(3); + + JSTypeInfo typeInfo = new JSTypeInfo(interfaceName, namespace); + + JSDocInfo jsDoc = extractJSDocBefore(content, nestedInterfaceMatcher.start()); + if (jsDoc != null) { + typeInfo.setJsDocInfo(jsDoc); + } + + String javaFqn = findJavaFqn(jsDoc, packageName, typeInfo.getFullName()); + if (javaFqn != null && !javaFqn.isEmpty()) { + typeInfo.setJavaFqn(javaFqn); + } + + // Parse type parameters + if (typeParamsStr != null && !typeParamsStr.isEmpty()) { + parseTypeParameters(typeParamsStr, typeInfo); + } + + if (extendsClause != null) { + String extendsType = extendsClause.trim(); + extendsType = extendsType.replaceAll("<[^>]*>", ""); + if (extendsType.contains(",")) { + extendsType = extendsType.substring(0, extendsType.indexOf(',')).trim(); + } + extendsType = cleanType(extendsType); + typeInfo.setExtends(extendsType); + } + + // Find the body of this nested interface + int bodyStart = nestedInterfaceMatcher.end(); + int bodyEnd = findMatchingBrace(content, bodyStart - 1); + if (bodyEnd > bodyStart) { + String body = content.substring(bodyStart, bodyEnd); + parseInterfaceBody(body, typeInfo); + } + + registry.registerType(typeInfo); + } + + // Parse type aliases within this context + parseTypeAliases(content, namespace); + } + + private String findJavaFqn(JSDocInfo jsDoc, String packageName, String typeFullName) { + String tagged = extractJavaFqnFromJSDoc(jsDoc); + if (tagged != null && !tagged.isEmpty()) { + return tagged; + } + return buildJavaFqnFromPackage(packageName, typeFullName); + } + + private String extractJavaFqnFromJSDoc(JSDocInfo jsDoc) { + if (jsDoc == null) return null; + for (JSDocTag tag : jsDoc.getAllTags()) { + if (tag == null) continue; + if ("javaFqn".equals(tag.getTagName())) { + if (tag.getDescription() != null && !tag.getDescription().trim().isEmpty()) { + return tag.getDescription().trim(); + } + if (tag.getTypeName() != null && !tag.getTypeName().trim().isEmpty()) { + return tag.getTypeName().trim(); + } + } + } + return null; + } + + private String buildJavaFqnFromPackage(String packageName, String typeFullName) { + if (typeFullName == null || typeFullName.isEmpty()) return null; + if (packageName == null || packageName.isEmpty()) return null; + return packageName + "." + typeFullName; + } + + private String derivePackageName(String fileName) { + if (fileName == null || fileName.isEmpty()) return null; + String normalized = fileName.replace('\\', '/'); + if (normalized.endsWith(".d.ts")) { + normalized = normalized.substring(0, normalized.length() - 5); + } + int lastSlash = normalized.lastIndexOf('/'); + if (lastSlash < 0) return null; + String pkgPath = normalized.substring(0, lastSlash); + if (pkgPath.isEmpty()) return null; + return pkgPath.replace('/', '.'); + } + + /** + * Parse type aliases (export type X = Y). + */ + private void parseTypeAliases(String content, String namespace) { + Matcher m = TYPE_ALIAS_PATTERN.matcher(content); + while (m.find()) { + String aliasName = m.group(1); + String targetType = m.group(2).trim(); + + // Create a simple type that extends the target + JSTypeInfo typeInfo = new JSTypeInfo(aliasName, namespace); + typeInfo.setExtends(targetType); + registry.registerType(typeInfo); + } + } + + /** + * Parse the body of an interface to extract methods and fields. + */ + private void parseInterfaceBody(String body, JSTypeInfo typeInfo) { + // Parse methods + Matcher methodMatcher = METHOD_PATTERN.matcher(body); + while (methodMatcher.find()) { + boolean isStatic = methodMatcher.group(1) != null; + String methodName = methodMatcher.group(2); + String params = methodMatcher.group(3); + String returnType = cleanType(methodMatcher.group(4)); + + List parameters = parseParameters(params); + JSMethodInfo method = new JSMethodInfo(methodName, returnType, parameters); + method.setStatic(isStatic); + + JSDocInfo jsDoc = extractJSDocBefore(body, methodMatcher.start()); + if (jsDoc != null) { + method.setJsDocInfo(jsDoc); + } + + typeInfo.addMethod(method); + } + + // Parse fields (that aren't method signatures) + Matcher fieldMatcher = FIELD_PATTERN.matcher(body); + while (fieldMatcher.find()) { + boolean isStatic = fieldMatcher.group(1) != null; + String fieldName = fieldMatcher.group(3); + + // CNPC+ base event implementation CustomNPCsEvent exposes a public "API" field that + // ends up polluting autocomplete on every event via ICustomNPCsEvent inheritance. + // Keep parsing other fields, but skip this one. + if ("ICustomNPCsEvent".equals(typeInfo.getSimpleName()) && "API".equals(fieldName)) + continue; + + String fieldType = cleanType(fieldMatcher.group(4)); + boolean readonly = fieldMatcher.group(2) != null; + + JSFieldInfo field = new JSFieldInfo(fieldName, fieldType, readonly); + field.setStatic(isStatic); + + JSDocInfo jsDoc = extractJSDocBefore(body, fieldMatcher.start()); + if (jsDoc != null) { + field.setJsDocInfo(jsDoc); + } + + typeInfo.addField(field); + } + } + + /** + * Parse parameters string into list of parameter info. + */ + private List parseParameters(String params) { + List result = new ArrayList<>(); + if (params == null || params.trim().isEmpty()) { + return result; + } + + // Split by comma, but be careful of nested types like Map + List paramParts = splitParameters(params); + + for (String part : paramParts) { + part = part.trim(); + if (part.isEmpty()) continue; + + // Format: name: type or name?: type or ...name: type + int colonIndex = part.indexOf(':'); + if (colonIndex > 0) { + String name = part.substring(0, colonIndex).trim().replace("?", ""); + String type = cleanType(part.substring(colonIndex + 1).trim()); + boolean isVarArg = name.startsWith("..."); + if (isVarArg) { + name = name.substring(3).trim(); + // Varargs in TS are typed as arrays (e.g. ...codes: number[]) + // Strip the array wrapper to get the element type since isVarArg already implies array + if (type.endsWith("[]")) { + type = type.substring(0, type.length() - 2).trim(); + } else if (type.startsWith("Array<") && type.endsWith(">")) { + type = type.substring(6, type.length() - 1).trim(); + } + } + JSMethodInfo.JSParameterInfo param = new JSMethodInfo.JSParameterInfo(name, type); + param.setVarArg(isVarArg); + result.add(param); + } + } + + return result; + } + + /** + * Split parameters respecting nested angle brackets. + */ + private List splitParameters(String params) { + List result = new ArrayList<>(); + int depth = 0; + int start = 0; + + for (int i = 0; i < params.length(); i++) { + char c = params.charAt(i); + if (c == '<' || c == '(' || c == '[') { + depth++; + } else if (c == '>' || c == ')' || c == ']') { + depth--; + } else if (c == ',' && depth == 0) { + result.add(params.substring(start, i)); + start = i + 1; + } + } + + if (start < params.length()) { + result.add(params.substring(start)); + } + + return result; + } + + /** + * Clean up a type string (remove import() syntax, trim, etc.). + */ + private String cleanType(String type) { + if (type == null) return "any"; + return TypeStringNormalizer.stripImportTypeSyntax(type); + } + + /** + * Find the matching closing brace. + */ + private int findMatchingBrace(String text, int openBracePos) { + int depth = 1; + for (int i = openBracePos + 1; i < text.length(); i++) { + char c = text.charAt(i); + if (c == '{') depth++; + else if (c == '}') { + depth--; + if (depth == 0) return i; + } + } + return -1; + } + + /** + * Read entire content from reader. + */ + private String readFully(BufferedReader reader) throws IOException { + StringBuilder sb = new StringBuilder(); + String line; + while ((line = reader.readLine()) != null) { + sb.append(line).append("\n"); + } + return sb.toString(); + } + + private JSDocInfo extractJSDocBefore(String content, int elementStart) { + String jsDocBlock = DTSJSDocParser.extractJSDocBefore(content, elementStart); + if (jsDocBlock != null) { + return DTSJSDocParser.parseJSDocBlock(jsDocBlock); + } + return null; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocInfo.java new file mode 100644 index 000000000..899239884 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocInfo.java @@ -0,0 +1,110 @@ +package noppes.npcs.client.gui.util.script.interpreter.jsdoc; + +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +/** + * Represents parsed JSDoc comment information. + * Captures @type, @param, @return, and other JSDoc tags with their type information. + */ +public class JSDocInfo { + + private final String rawComment; + private final int startOffset; + private final int endOffset; + + private JSDocTypeTag typeTag; + private final List paramTags = new ArrayList<>(); + private JSDocReturnTag returnTag; + private final List seeTags = new ArrayList<>(); + private String description; + private final List allTags = new ArrayList<>(); + + public JSDocInfo(String rawComment, int startOffset, int endOffset) { + this.rawComment = rawComment; + this.startOffset = startOffset; + this.endOffset = endOffset; + } + + public void setTypeTag(JSDocTypeTag typeTag) { + this.typeTag = typeTag; + allTags.add(typeTag); + } + + public void addParamTag(JSDocParamTag paramTag) { + this.paramTags.add(paramTag); + allTags.add(paramTag); + } + + public void setReturnTag(JSDocReturnTag returnTag) { + this.returnTag = returnTag; + allTags.add(returnTag); + } + + + public void addSeeTag(JSDocSeeTag seeTag) { + this.seeTags.add(seeTag); + allTags.add(seeTag); + } + + public void setDescription(String description) { + this.description = description; + } + + public void addTag(JSDocTag tag) { + allTags.add(tag); + } + + public String getRawComment() { return rawComment; } + public int getStartOffset() { return startOffset; } + public int getEndOffset() { return endOffset; } + public JSDocTypeTag getTypeTag() { return typeTag; } + public boolean hasTypeTag() { return typeTag != null; } + + public TypeInfo getDeclaredType() { + return typeTag != null ? typeTag.getTypeInfo() : null; + } + + public List getParamTags() { + return Collections.unmodifiableList(paramTags); + } + + public boolean hasParamTags() { return !paramTags.isEmpty(); } + + public JSDocParamTag getParamTag(String paramName) { + for (JSDocParamTag tag : paramTags) { + String tagName = tag.getParamName(); + if (tagName != null && tagName.equals(paramName)) { + return tag; + } + } + return null; + } + + public JSDocReturnTag getReturnTag() { return returnTag; } + public boolean hasReturnTag() { return returnTag != null; } + + public TypeInfo getReturnType() { + return returnTag != null ? returnTag.getTypeInfo() : null; + } + + public List getSeeTags() { return Collections.unmodifiableList(seeTags); } + public boolean hasSeeTags() { return !seeTags.isEmpty(); } + + public String getDescription() { return description; } + public List getAllTags() { return Collections.unmodifiableList(allTags); } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("JSDocInfo{"); + if (typeTag != null) sb.append("type=").append(typeTag.getTypeName()); + if (!paramTags.isEmpty()) sb.append(", params=").append(paramTags.size()); + if (returnTag != null) sb.append(", return=").append(returnTag.getTypeName()); + if (!seeTags.isEmpty()) sb.append(", see=").append(seeTags.size()); + sb.append("}"); + return sb.toString(); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocParamTag.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocParamTag.java new file mode 100644 index 000000000..cdabdb717 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocParamTag.java @@ -0,0 +1,43 @@ +package noppes.npcs.client.gui.util.script.interpreter.jsdoc; + +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +/** + * Represents an @param JSDoc tag. + * Used to declare the type and description of a function parameter. + * Example: @param {string} name - The name of the person + */ +public class JSDocParamTag extends JSDocTag { + + private final String paramName; + private final int paramNameStart; + private final int paramNameEnd; + + public JSDocParamTag(int atSignOffset, int tagNameStart, int tagNameEnd, + String paramName, int paramNameStart, int paramNameEnd) { + super("param", atSignOffset, tagNameStart, tagNameEnd); + this.paramName = paramName; + this.paramNameStart = paramNameStart; + this.paramNameEnd = paramNameEnd; + } + + public static JSDocParamTag create(int atSignOffset, int tagNameStart, int tagNameEnd, + String typeName, TypeInfo typeInfo, int typeStart, int typeEnd, + String paramName, int paramNameStart, int paramNameEnd, + String description) { + JSDocParamTag tag = new JSDocParamTag(atSignOffset, tagNameStart, tagNameEnd, + paramName, paramNameStart, paramNameEnd); + tag.setType(typeName, typeInfo, typeStart, typeEnd); + tag.setDescription(description); + return tag; + } + + public String getParamName() { return paramName; } + public int getParamNameStart() { return paramNameStart; } + public int getParamNameEnd() { return paramNameEnd; } + + @Override + public String toString() { + return "JSDocParamTag{@param " + (typeName != null ? "{" + typeName + "} " : "") + paramName + "}"; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocParser.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocParser.java new file mode 100644 index 000000000..cbf8968ee --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocParser.java @@ -0,0 +1,330 @@ +package noppes.npcs.client.gui.util.script.interpreter.jsdoc; + +import noppes.npcs.client.gui.util.script.interpreter.ScriptDocument; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +import java.util.ArrayList; +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** + * Parses JSDoc comments to extract type information. + * Handles @type, @param, @return/@returns tags. + */ +public class JSDocParser { + + private static final Pattern JSDOC_PATTERN = Pattern.compile( + "/\\*\\*([\\s\\S]*?)\\*/", Pattern.MULTILINE); + + private static final Pattern TYPE_TAG_PATTERN = Pattern.compile( + "^@(type)\\s*(?:\\{([^}]+)\\})?(?:\\s*-?\\s*(.*))?$", Pattern.CASE_INSENSITIVE); + + private static final Pattern PARAM_TAG_PATTERN = Pattern.compile( + "^@param\\s*(?:\\{([^}]+)\\})?\\s*(\\w+)?(?:\\s*-?\\s*(.*))?$", Pattern.CASE_INSENSITIVE); + + private static final Pattern RETURN_TAG_PATTERN = Pattern.compile( + "^@(returns?)\\s*(?:\\{([^}]+)\\})?(?:\\s*-?\\s*(.*))?$", Pattern.CASE_INSENSITIVE); + + private static final Pattern GENERIC_TAG_PATTERN = Pattern.compile( + "^@(\\w+)(?:\\s*\\{([^}]+)\\})?(?:\\s*-?\\s*(.*))?$", Pattern.CASE_INSENSITIVE); + + private final ScriptDocument document; + + public JSDocParser(ScriptDocument typeResolver) { + this.document = typeResolver; + } + + public JSDocInfo parse(String comment, int commentStart) { + if (comment == null || !comment.startsWith("/**")) { + return null; + } + + int commentEnd = commentStart + comment.length(); + JSDocInfo info = new JSDocInfo(comment, commentStart, commentEnd); + + String content = comment.substring(3); + if (content.endsWith("*/")) { + content = content.substring(0, content.length() - 2); + } + + int contentOffset = commentStart + 3; + + StringBuilder descriptionBuilder = new StringBuilder(); + boolean foundFirstTag = false; + JSDocTag lastTag = null; + + int position = 0; + while (position <= content.length()) { + int lineEnd = content.indexOf('\n', position); + if (lineEnd == -1) { + lineEnd = content.length(); + } + + String rawLine = content.substring(position, lineEnd); + if (rawLine.endsWith("\r")) { + rawLine = rawLine.substring(0, rawLine.length() - 1); + } + + CleanLine cleanLine = cleanLine(rawLine, contentOffset + position); + String line = cleanLine.text; + + if (line.startsWith("@")) { + foundFirstTag = true; + lastTag = parseTagLine(line, cleanLine.offset, info); + } else if (!foundFirstTag) { + if (line.isEmpty()) { + // Preserve blank lines as paragraph gaps (only if description has started) + if (descriptionBuilder.length() > 0) { + descriptionBuilder.append("\n"); + } + } else { + if (descriptionBuilder.length() > 0) { + descriptionBuilder.append("\n"); + } + descriptionBuilder.append(line); + } + } else if (lastTag != null && !line.isEmpty()) { + String existing = lastTag.getDescription(); + if (existing == null || existing.isEmpty()) { + lastTag.setDescription(line); + } else { + lastTag.setDescription(existing + "\n" + line); + } + } + + if (lineEnd == content.length()) { + break; + } + position = lineEnd + 1; + } + + if (descriptionBuilder.length() > 0) { + info.setDescription(descriptionBuilder.toString().trim()); + } + + return info; + } + + public JSDocInfo extractJSDocBefore(String source, int position) { + if (source == null || position <= 0) { + return null; + } + + int searchStart = Math.max(0, position - 1); + + while (searchStart > 0 && Character.isWhitespace(source.charAt(searchStart))) { + searchStart--; + } + + int endCommentPos = -1; + if (searchStart >= 1 && source.charAt(searchStart) == '/' && source.charAt(searchStart - 1) == '*') { + endCommentPos = searchStart; + } else if (searchStart >= 1 && source.charAt(searchStart - 1) == '/' && searchStart > 1 && source.charAt( + searchStart - 2) == '*') { + endCommentPos = searchStart - 1; + } + + if (endCommentPos < 0) { + return null; + } + + int startCommentPos = -1; + for (int i = endCommentPos - 1; i >= 2; i--) { + if (source.charAt(i) == '*' && source.charAt(i - 1) == '*' && source.charAt(i - 2) == '/') { + startCommentPos = i - 2; + break; + } + } + + if (startCommentPos < 0) { + return null; + } + + String comment = source.substring(startCommentPos, endCommentPos + 1); + return parse(comment, startCommentPos); + } + + private JSDocTag parseTagLine(String line, int lineOffset, JSDocInfo info) { + Matcher paramMatcher = PARAM_TAG_PATTERN.matcher(line); + if (paramMatcher.matches()) { + String typeName = paramMatcher.group(1); + String paramName = paramMatcher.group(2); + String description = normalizeDescription(paramMatcher.group(3)); + + int atSignOffset = lineOffset + paramMatcher.start(); + int tagNameStart = lineOffset + 1; + int tagNameEnd = tagNameStart + "param".length(); + + int typeStart = -1; + int typeEnd = -1; + TypeInfo typeInfo = null; + + if (typeName != null) { + typeName = typeName.trim(); + typeStart = lineOffset + paramMatcher.start(1); + typeEnd = lineOffset + paramMatcher.end(1); + typeInfo = resolveType(typeName); + } + + int paramNameStart = -1; + int paramNameEnd = -1; + if (paramName != null) { + paramNameStart = lineOffset + paramMatcher.start(2); + paramNameEnd = lineOffset + paramMatcher.end(2); + } + + JSDocParamTag tag = JSDocParamTag.create(atSignOffset, tagNameStart, tagNameEnd, + typeName, typeInfo, typeStart, typeEnd, + paramName, paramNameStart, paramNameEnd, + description); + info.addParamTag(tag); + return tag; + } + + Matcher returnMatcher = RETURN_TAG_PATTERN.matcher(line); + if (returnMatcher.matches()) { + String tagName = returnMatcher.group(1); + String typeName = returnMatcher.group(2); + String description = normalizeDescription(returnMatcher.group(3)); + + int atSignOffset = lineOffset + returnMatcher.start(); + int tagNameStart = lineOffset + returnMatcher.start(1); + int tagNameEnd = lineOffset + returnMatcher.end(1); + + int typeStart = -1; + int typeEnd = -1; + TypeInfo typeInfo = null; + + if (typeName != null) { + typeName = typeName.trim(); + typeStart = lineOffset + returnMatcher.start(2); + typeEnd = lineOffset + returnMatcher.end(2); + typeInfo = resolveType(typeName); + } + + JSDocReturnTag tag = JSDocReturnTag.create(tagName, atSignOffset, tagNameStart, tagNameEnd, + typeName, typeInfo, typeStart, typeEnd, + description); + info.setReturnTag(tag); + return tag; + } + + Matcher typeMatcher = TYPE_TAG_PATTERN.matcher(line); + if (typeMatcher.matches()) { + String typeName = typeMatcher.group(2); + String description = normalizeDescription(typeMatcher.group(3)); + + int atSignOffset = lineOffset + typeMatcher.start(); + int tagNameStart = lineOffset + typeMatcher.start(1); + int tagNameEnd = lineOffset + typeMatcher.end(1); + + int typeStart = -1; + int typeEnd = -1; + TypeInfo typeInfo = null; + + if (typeName != null) { + typeName = typeName.trim(); + typeStart = lineOffset + typeMatcher.start(2); + typeEnd = lineOffset + typeMatcher.end(2); + typeInfo = resolveType(typeName); + } + + JSDocTypeTag tag = JSDocTypeTag.create(atSignOffset, tagNameStart, tagNameEnd, + typeName, typeInfo, typeStart, typeEnd, description); + info.setTypeTag(tag); + return tag; + } + + Matcher genericMatcher = GENERIC_TAG_PATTERN.matcher(line); + if (genericMatcher.matches()) { + String tagName = genericMatcher.group(1); + String typeName = genericMatcher.group(2); + String description = normalizeDescription(genericMatcher.group(3)); + + int atSignOffset = lineOffset + genericMatcher.start(); + int tagNameStart = lineOffset + genericMatcher.start(1); + int tagNameEnd = lineOffset + genericMatcher.end(1); + + JSDocTag tag = new JSDocTag(tagName, atSignOffset, tagNameStart, tagNameEnd); + + if (typeName != null) { + typeName = typeName.trim(); + int typeStart = lineOffset + genericMatcher.start(2); + int typeEnd = lineOffset + genericMatcher.end(2); + TypeInfo typeInfo = resolveType(typeName); + tag.setType(typeName, typeInfo, typeStart, typeEnd); + } + + if (description != null && !description.isEmpty()) { + tag.setDescription(description); + } + + info.addTag(tag); + return tag; + } + + return null; + } + + private String normalizeDescription(String description) { + if (description == null) { + return null; + } + String trimmed = description.trim(); + return trimmed.isEmpty() ? null : trimmed; + } + + private CleanLine cleanLine(String line, int lineStartOffset) { + int index = 0; + while (index < line.length() && Character.isWhitespace(line.charAt(index))) { + index++; + } + + if (index + 2 < line.length() && line.startsWith("/**", index)) { + index += 3; + while (index < line.length() && Character.isWhitespace(line.charAt(index))) { + index++; + } + } + + if (index < line.length() && line.charAt(index) == '*') { + index++; + if (index < line.length() && line.charAt(index) == ' ') { + index++; + } + } + + String cleaned = line.substring(index); + int end = cleaned.length(); + while (end > 0 && Character.isWhitespace(cleaned.charAt(end - 1))) { + end--; + } + cleaned = cleaned.substring(0, end); + + return new CleanLine(cleaned, lineStartOffset + index); + } + + private TypeInfo resolveType(String typeName) { + return document.resolveType(typeName); + } + + private static class CleanLine { + private final String text; + private final int offset; + + private CleanLine(String text, int offset) { + this.text = text; + this.offset = offset; + } + } + + public static List findAllJSDocComments(String source) { + List positions = new ArrayList<>(); + Matcher m = JSDOC_PATTERN.matcher(source); + while (m.find()) { + positions.add(new int[]{m.start(), m.end()}); + } + return positions; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocReturnTag.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocReturnTag.java new file mode 100644 index 000000000..0f5fca416 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocReturnTag.java @@ -0,0 +1,29 @@ +package noppes.npcs.client.gui.util.script.interpreter.jsdoc; + +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +/** + * Represents an @return or @returns JSDoc tag. + * Used to declare the return type of a function. + * Example: @return {number} The calculated result + */ +public class JSDocReturnTag extends JSDocTag { + + public JSDocReturnTag(String tagName, int atSignOffset, int tagNameStart, int tagNameEnd) { + super(tagName, atSignOffset, tagNameStart, tagNameEnd); + } + + public static JSDocReturnTag create(String tagName, int atSignOffset, int tagNameStart, int tagNameEnd, + String typeName, TypeInfo typeInfo, int typeStart, int typeEnd, + String description) { + JSDocReturnTag tag = new JSDocReturnTag(tagName, atSignOffset, tagNameStart, tagNameEnd); + tag.setType(typeName, typeInfo, typeStart, typeEnd); + tag.setDescription(description); + return tag; + } + + @Override + public String toString() { + return "JSDocReturnTag{@" + tagName + " " + (typeName != null ? "{" + typeName + "}" : "") + "}"; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocSeeTag.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocSeeTag.java new file mode 100644 index 000000000..028023c6e --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocSeeTag.java @@ -0,0 +1,75 @@ +package noppes.npcs.client.gui.util.script.interpreter.jsdoc; + +public class JSDocSeeTag extends JSDocTag { + + private final String reference; + private String url; + private String linkText; + + public JSDocSeeTag(String tagName, int atSignOffset, int tagNameStart, int tagNameEnd, String reference) { + super(tagName, atSignOffset, tagNameStart, tagNameEnd); + this.reference = reference; + this.setDescription(reference); + parseReference(reference); + } + + public static JSDocSeeTag create(String tagName, int atSignOffset, int tagNameStart, int tagNameEnd, + String reference) { + return new JSDocSeeTag(tagName, atSignOffset, tagNameStart, tagNameEnd, reference); + } + + public static JSDocSeeTag createSimple(String reference) { + return new JSDocSeeTag("see", -1, -1, -1, reference); + } + + private void parseReference(String ref) { + if (ref == null) return; + + if (ref.contains(""); + int textEnd = ref.indexOf(""); + if (textStart != -1 && textEnd != -1 && textStart < textEnd) { + this.linkText = ref.substring(textStart + 1, textEnd); + } + } else if (ref.contains("{@link")) { + int linkStart = ref.indexOf("{@link"); + int linkEnd = ref.indexOf("}", linkStart); + if (linkStart != -1 && linkEnd != -1) { + this.linkText = ref.substring(linkStart + 6, linkEnd).trim(); + } + } + } + + public String getReference() { + return reference; + } + + public String getUrl() { + return url; + } + + public boolean hasUrl() { + return url != null && !url.isEmpty(); + } + + public String getLinkText() { + return linkText; + } + + public boolean hasLinkText() { + return linkText != null && !linkText.isEmpty(); + } + + @Override + public String toString() { + return "JSDocSeeTag{@see " + reference + "}"; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocTag.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocTag.java new file mode 100644 index 000000000..82fd1edbe --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocTag.java @@ -0,0 +1,55 @@ +package noppes.npcs.client.gui.util.script.interpreter.jsdoc; + +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +/** + * Base class for JSDoc tags. + * Each tag stores its position information for syntax highlighting. + */ +public class JSDocTag { + + protected final String tagName; + protected final int atSignOffset; + protected final int tagNameStart; + protected final int tagNameEnd; + + protected String typeName; + protected TypeInfo typeInfo; + protected int typeStart = -1; + protected int typeEnd = -1; + protected String description; + + public JSDocTag(String tagName, int atSignOffset, int tagNameStart, int tagNameEnd) { + this.tagName = tagName; + this.atSignOffset = atSignOffset; + this.tagNameStart = tagNameStart; + this.tagNameEnd = tagNameEnd; + } + + public void setType(String typeName, TypeInfo typeInfo, int typeStart, int typeEnd) { + this.typeName = typeName; + this.typeInfo = typeInfo; + this.typeStart = typeStart; + this.typeEnd = typeEnd; + } + + public void setDescription(String description) { + this.description = description; + } + + public String getTagName() { return tagName; } + public int getAtSignOffset() { return atSignOffset; } + public int getTagNameStart() { return tagNameStart; } + public int getTagNameEnd() { return tagNameEnd; } + public String getTypeName() { return typeName; } + public TypeInfo getTypeInfo() { return typeInfo; } + public boolean hasType() { return typeName != null && !typeName.isEmpty(); } + public int getTypeStart() { return typeStart; } + public int getTypeEnd() { return typeEnd; } + public String getDescription() { return description; } + + @Override + public String toString() { + return "JSDocTag{@" + tagName + (typeName != null ? " {" + typeName + "}" : "") + "}"; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocTypeTag.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocTypeTag.java new file mode 100644 index 000000000..1f27f6667 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/jsdoc/JSDocTypeTag.java @@ -0,0 +1,28 @@ +package noppes.npcs.client.gui.util.script.interpreter.jsdoc; + +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +/** + * Represents an @type JSDoc tag. + * Used to declare the type of a variable. + * Example: @type {string} + */ +public class JSDocTypeTag extends JSDocTag { + + public JSDocTypeTag(int atSignOffset, int tagNameStart, int tagNameEnd) { + super("type", atSignOffset, tagNameStart, tagNameEnd); + } + + public static JSDocTypeTag create(int atSignOffset, int tagNameStart, int tagNameEnd, String typeName, + TypeInfo typeInfo, int typeStart, int typeEnd, String description) { + JSDocTypeTag tag = new JSDocTypeTag(atSignOffset, tagNameStart, tagNameEnd); + tag.setType(typeName, typeInfo, typeStart, typeEnd); + tag.setDescription(description); + return tag; + } + + @Override + public String toString() { + return "JSDocTypeTag{@type " + (typeName != null ? "{" + typeName + "}" : "") + "}"; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/method/MethodCallInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/method/MethodCallInfo.java new file mode 100644 index 000000000..9b4716ec9 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/method/MethodCallInfo.java @@ -0,0 +1,458 @@ +package noppes.npcs.client.gui.util.script.interpreter.method; + +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.token.Token; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeChecker; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +/** + * Stores information about a method call for argument validation. + * This includes the method name, the arguments passed, and validation results. + */ +public class MethodCallInfo { + + /** + * Represents a single argument in a method call. + */ + public static class Argument { + private final String text; // The text of the argument expression + private final int startOffset; // Start position in source + private final int endOffset; // End position in source + private final TypeInfo resolvedType; // The resolved type of the argument (null if unresolved) + private final boolean valid; // Whether this arg matches the expected parameter type + private final String errorMessage; // Error message if invalid + + public Argument(String text, int startOffset, int endOffset, TypeInfo resolvedType, + boolean valid, String errorMessage) { + this.text = text; + this.startOffset = startOffset; + this.endOffset = endOffset; + this.resolvedType = resolvedType; + this.valid = valid; + this.errorMessage = errorMessage; + } + + public String getText() { + return text; + } + + public int getStartOffset() { + return startOffset; + } + + public int getEndOffset() { + return endOffset; + } + + public TypeInfo getResolvedType() { + return resolvedType; + } + + public boolean isValid() { + return valid; + } + + public String getErrorMessage() { + return errorMessage; + } + + public boolean equals(Token t) { + return text.equals(t.getText()) && + startOffset == t.getGlobalStart() && + endOffset == t.getGlobalEnd(); + } + + @Override + public String toString() { + return "Arg{" + text + " [" + startOffset + "-" + endOffset + "]" + + (resolvedType != null ? " :" + resolvedType.getSimpleName() : "") + + (valid ? "" : " INVALID: " + errorMessage) + "}"; + } + } + /** + * Validation error type. + */ + public enum ErrorType { + NONE, + WRONG_ARG_COUNT, // Number of args doesn't match any overload + WRONG_ARG_TYPE, // Specific argument has wrong type + STATIC_ACCESS_ERROR, // Trying to call instance method statically or vice versa + RETURN_TYPE_MISMATCH, // Return type doesn't match expected type (e.g., assignment LHS) + UNRESOLVED_METHOD, // Method doesn't exist + UNRESOLVED_RECEIVER // Can't resolve the receiver type + } + + private final String methodName; + private final int methodNameStart; // Position of method name + private final int methodNameEnd; + private final int openParenOffset; // Position of '(' + private final int closeParenOffset; // Position of ')' + private final List arguments; + private final TypeInfo receiverType; // The type on which this method is called (null for standalone) + private final MethodInfo resolvedMethod; // The resolved method (null if unresolved) + private final boolean isStaticAccess; // True if this is Class.method() style access + private TypeInfo expectedType; // Expected return type (from assignment LHS, etc.) + + private ErrorType errorType = ErrorType.NONE; + private String errorMessage; + private int errorArgIndex = -1; // Index of the problematic argument (for WRONG_ARG_TYPE) + private List argumentTypeErrors = new ArrayList<>(); + + private boolean isConstructor; + + // For Java.type() ClassTypeInfo constructor access + // i.e var IntArray = Java.type("int[]"); var array = new IntArray() + public boolean isClassTypeAccess; + + public MethodCallInfo(String methodName, int methodNameStart, int methodNameEnd, + int openParenOffset, int closeParenOffset, + List arguments, TypeInfo receiverType, + MethodInfo resolvedMethod) { + this(methodName, methodNameStart, methodNameEnd, openParenOffset, closeParenOffset, + arguments, receiverType, resolvedMethod, false); + } + + public MethodCallInfo(String methodName, int methodNameStart, int methodNameEnd, + int openParenOffset, int closeParenOffset, + List arguments, TypeInfo receiverType, + MethodInfo resolvedMethod, boolean isStaticAccess) { + this.methodName = methodName; + this.methodNameStart = methodNameStart; + this.methodNameEnd = methodNameEnd; + this.openParenOffset = openParenOffset; + this.closeParenOffset = closeParenOffset; + this.arguments = arguments != null ? new ArrayList<>(arguments) : new ArrayList<>(); + this.receiverType = receiverType; + this.resolvedMethod = resolvedMethod; + this.isStaticAccess = isStaticAccess; + } + + /** + * Factory method to create a MethodCallInfo for a constructor call. + * Constructors are represented as method calls where the type itself is the receiver. + */ + public static MethodCallInfo constructor(TypeInfo typeInfo, MethodInfo constructor, + int typeNameStart, int typeNameEnd, + int openParenOffset, int closeParenOffset, + List arguments) { + return new MethodCallInfo( + typeInfo.getSimpleName(), // Constructor name is the type name + typeNameStart, + typeNameEnd, + openParenOffset, + closeParenOffset, + arguments, + typeInfo, // The type itself is the receiver + constructor, // The constructor MethodInfo + false // Constructors are not static access + ).setConstructor(true); + } + + // Getters + public String getMethodName() { + return methodName; + } + + public int getMethodNameStart() { + return methodNameStart; + } + + public int getMethodNameEnd() { + return methodNameEnd; + } + + public int getOpenParenOffset() { + return openParenOffset; + } + + public int getCloseParenOffset() { + return closeParenOffset; + } + + public List getArguments() { + return Collections.unmodifiableList(arguments); + } + + public int getArgumentCount() { + return arguments.size(); + } + + public TypeInfo getReceiverType() { + return receiverType; + } + + public MethodInfo getResolvedMethod() { + return resolvedMethod; + } + + public boolean isStaticAccess() { + return isStaticAccess; + } + + public TypeInfo getExpectedType() { + return expectedType; + } + + public void setExpectedType(TypeInfo expectedType) { + this.expectedType = expectedType; + } + + // Dynamically resolved return type (e.g., for Java.type() which returns ClassTypeInfo) + private TypeInfo resolvedReturnType; + + /** + * Get the resolved return type of this method call. + * This may differ from resolvedMethod.getReturnType() for methods with dynamic return types. + * @return The resolved return type, or the method's declared return type if not dynamically resolved + */ + public TypeInfo getResolvedReturnType() { + if (resolvedReturnType != null) { + return resolvedReturnType; + } + return resolvedMethod != null ? resolvedMethod.getReturnType() : null; + } + + /** + * Set a dynamically resolved return type. + * Used for methods like Java.type() where the return type depends on the arguments. + */ + public void setResolvedReturnType(TypeInfo returnType) { + this.resolvedReturnType = returnType; + } + + public boolean isConstructor() { + return isConstructor; + } + + public MethodCallInfo setConstructor(boolean isConstructor) { + this.isConstructor = isConstructor; + return this; + } + + public ErrorType getErrorType() { + return errorType; + } + + public String getErrorMessage() { + return errorMessage; + } + + /** + * Get the full span of the method call including parentheses. + * Used for underlining the entire call on arg count errors. + */ + public int getFullCallStart() { + return methodNameStart; + } + + public int getFullCallEnd() { + return closeParenOffset + 1; + } + + /** + * Check if this method call has any validation errors. + */ + public boolean hasError() { + return errorType != ErrorType.NONE; + } + + /** + * Check if this is an arg count error (underline whole call). + */ + public boolean hasArgCountError() { + return errorType == ErrorType.WRONG_ARG_COUNT; + } + + /** + * Check if this is an arg type error (underline specific arg). + */ + public boolean hasArgTypeError() { + return !this.argumentTypeErrors.isEmpty(); + } + + + /** + * Check if this is a static access error (underline method name). + */ + public boolean hasStaticAccessError() { + return errorType == ErrorType.STATIC_ACCESS_ERROR; + } + + /** + * Check if this is a return type mismatch error. + */ + public boolean hasReturnTypeMismatch() { + return errorType == ErrorType.RETURN_TYPE_MISMATCH; + } + + // Setters for validation results + public void setError(ErrorType type, String message) { + this.errorType = type; + this.errorMessage = message; + } + + public void setArgTypeError(int argIndex, String message) { + this.argumentTypeErrors.add(new ArgumentTypeError(arguments.get(argIndex), argIndex, message)); + } + + public List getArgumentTypeErrors() { + return argumentTypeErrors; + } + + public class ArgumentTypeError { + private ErrorType type = ErrorType.WRONG_ARG_TYPE; + private final Argument arg; + private final int argIndex; + private final String message; + + public ArgumentTypeError(Argument arg, int argIndex, String message) { + this.arg = arg; + this.argIndex = argIndex; + this.message = message; + } + + public int getArgIndex() { + return argIndex; + } + + public String getMessage() { + return message; + } + + public Argument getArg() { + return arg; + } + } + + /** + * Validate this method call against the resolved method signature. + * Sets error information if validation fails. + */ + public void validate() { + if (isConstructor) { + if (resolvedMethod == null) { + // Don't report missing JS constructors as unresolved method error, since they may be created dynamically at runtime + boolean isJSType = receiverType != null && receiverType.isJSType(); + if (!isJSType && !isClassTypeAccess) { + if (receiverType != null && receiverType.hasConstructors()) { + setError(ErrorType.WRONG_ARG_COUNT, + "No constructor in '" + receiverType.getSimpleName() + "' matches " + arguments.size() + " argument(s)"); + } else { + setError(ErrorType.UNRESOLVED_METHOD, + "Cannot resolve constructor for '" + methodName + "'"); + } + } + } else if (receiverType != null) { + List cParams = resolvedMethod.getParameters(); + boolean ctorVarArg = !cParams.isEmpty() && cParams.get(cParams.size() - 1).isVarArg(); + boolean ctorCountOk = ctorVarArg + ? arguments.size() >= cParams.size() - 1 + : arguments.size() == resolvedMethod.getParameterCount(); + if (ctorCountOk) validateArgTypeError(); + } + return; + } + + // Check static/instance access (skip for constructors) + // NO LONGER CHECKED HERE, BUT DIRECTLY AT MARK CREATION + if (!isConstructor && isStaticAccess && !resolvedMethod.isStatic()) { + setError(ErrorType.STATIC_ACCESS_ERROR, + "Cannot call instance method '" + methodName + "' on a class type"); + return; + } + + List params = resolvedMethod.getParameters(); + int expectedCount = params.size(); + int actualCount = arguments.size(); + boolean isVarArgMethod = expectedCount > 0 && params.get(expectedCount - 1).isVarArg(); + + // Check arg count + if (isVarArgMethod) { + if (actualCount < expectedCount - 1) { + setError(ErrorType.WRONG_ARG_COUNT, + "Expected at least " + (expectedCount - 1) + " argument(s) but got " + actualCount); + return; + } + } else { + if (actualCount != expectedCount) { + setError(ErrorType.WRONG_ARG_COUNT, + "Expected " + expectedCount + " argument(s) but got " + actualCount); + return; + } + } + + // Check each argument type + validateArgTypeError(); + + // Check return type compatibility with expected type (e.g., assignment LHS) + // ALREADY CHECKED AT AssignmentInfo LEVEL + if (expectedType != null && resolvedMethod != null) { + TypeInfo returnType = resolvedMethod.getReturnType(); + if (returnType != null && !TypeChecker.isTypeCompatible(expectedType, returnType)) { + // setError(ErrorType.RETURN_TYPE_MISMATCH, + // "Required type: " + expectedType.getSimpleName() + ", Provided: " + returnType.getSimpleName()); + } + } + } + + public void validateArgTypeError() { + List params = resolvedMethod.getParameters(); + int paramCount = params.size(); + boolean isVarArgMethod = paramCount > 0 && params.get(paramCount - 1).isVarArg(); + + for (int i = 0; i < arguments.size(); i++) { + Argument arg = arguments.get(i); + + // Surface argument-level errors (e.g., SAM conflict, ambiguous overload, bare method in Java) + if (!arg.isValid() && arg.getErrorMessage() != null) { + setArgTypeError(i, arg.getErrorMessage()); + continue; // Skip remaining checks for this argument + } + + // Varargs: all args at index >= (paramCount-1) map to the element type of the last param + FieldInfo para; + TypeInfo paramType; + if (isVarArgMethod && i >= paramCount - 1) { + para = params.get(paramCount - 1); + TypeInfo arrType = para.getTypeInfo(); + paramType = (arrType != null && arrType.isArray()) ? arrType.getElementType() : arrType; + } else { + para = params.get(i); + paramType = para.getTypeInfo(); + } + + TypeInfo argType = arg.getResolvedType(); + if (argType != null && paramType != null) { + if (!TypeChecker.isTypeCompatible(paramType, argType)) { + setArgTypeError(i, "Expected " + paramType.getDisplayName() + + " but got " + argType.getDisplayName()); + } + } else if (paramType == null) { + setArgTypeError(i, "Parameter type of '" + para.getName() + "' is unresolved"); + } else if (argType == null) { + setArgTypeError(i, "Cannot resolve type of argument '" + arg.getText() + "'"); + } + } + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("MethodCallInfo{"); + sb.append(methodName).append("("); + for (int i = 0; i < arguments.size(); i++) { + if (i > 0) + sb.append(", "); + sb.append(arguments.get(i).getText()); + } + sb.append(")"); + if (hasError()) { + sb.append(" ERROR: ").append(errorType).append(" - ").append(errorMessage); + } + sb.append("}"); + return sb.toString(); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/method/MethodInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/method/MethodInfo.java new file mode 100644 index 000000000..a16943e4b --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/method/MethodInfo.java @@ -0,0 +1,746 @@ +package noppes.npcs.client.gui.util.script.interpreter.method; + +import noppes.npcs.client.gui.util.script.interpreter.*; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.bridge.DtsJavaBridge; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSMethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeRegistry; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenType; +import noppes.npcs.client.gui.util.script.interpreter.type.GenericContext; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeChecker; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeSubstitutor; +import noppes.npcs.client.gui.util.script.interpreter.type.GenericParameterAdapter; + +import java.lang.reflect.Constructor; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.*; + +/** + * Metadata for a method declaration or method call. + * Tracks method name, parameters, return type, and containing class. + * + *

This class delegates to helper classes for specific functionality:

+ *
    + *
  • {@link ControlFlowAnalyzer} - Control flow analysis for missing return detection
  • + *
  • {@link CodeParser} - Code parsing utilities (brace matching, comment removal)
  • + *
  • {@link TypeChecker} - Type compatibility checking
  • + *
+ */ +public final class MethodInfo { + + /** + * Validation error types for method declarations. + */ + public enum ErrorType { + NONE, + MISSING_RETURN, // Non-void method missing return statement, + INTERFACE_METHOD_BODY, // Interface method has a body + MISSING_BODY, // Non-void method missing return statement + RETURN_TYPE_MISMATCH, // Return statement type doesn't match method return type + VOID_METHOD_RETURNS_VALUE, // Void method returns a value + DUPLICATE_METHOD, // Method with same signature already defined in scope + DUPLICATE_PARAMETER, // Two parameters have the same name + PARAMETER_UNDEFINED, // Parameter type cannot be resolved + SAM_TYPE_INCOMPATIBLE // Explicit param type incompatible with SAM context + } + + private final String name; + private final TypeInfo returnType; + private final TypeInfo containingType; // The class/interface that owns this method + private final List parameters; + private final int fullDeclarationOffset; // Start of full declaration (including modifiers), -1 for external + private final int typeOffset; // Start of return type + private final int nameOffset; // Start of method name + private final int bodyStart; // Start of method body (after {) + private final int bodyEnd; // End of method body (before }) + private final boolean resolved; + private final boolean isDeclaration; // true if this is a declaration, false if it's a call + private final int modifiers; // Java Modifier flags (e.g., Modifier.PUBLIC | Modifier.STATIC) + private final String documentation; // Javadoc/comment documentation for this method + private JSDocInfo jsDocInfo; // Parsed JSDoc info for this method (may be null) + private final java.lang.reflect.Method javaMethod; // The Java reflection Method, if this was created from reflection + + // Error tracking for method declarations + private ErrorType errorType = ErrorType.NONE; + private String errorMessage; + private List parameterErrors = new ArrayList<>(); + private List returnStatementErrors = new ArrayList<>(); + + // ==================== OVERRIDE/IMPLEMENTS TRACKING ==================== + + /** + * The type containing the method that this method overrides (the super class). + * Null if this method doesn't override anything. + */ + private TypeInfo overridesFrom; + + /** + * The type containing the interface method that this method implements. + * Null if this method doesn't implement an interface method. + */ + private TypeInfo implementsFrom; + + private MethodInfo(String name, TypeInfo returnType, TypeInfo containingType, + List parameters, int fullDeclarationOffset, int typeOffset, int nameOffset, + int bodyStart, int bodyEnd, boolean resolved, boolean isDeclaration, + int modifiers, String documentation, java.lang.reflect.Method javaMethod) { + this.name = name; + this.returnType = returnType; + this.containingType = containingType; + this.parameters = parameters != null ? new ArrayList<>(parameters) : new ArrayList<>(); + this.fullDeclarationOffset = fullDeclarationOffset; + this.typeOffset = typeOffset; + this.nameOffset = nameOffset; + this.bodyStart = bodyStart; + this.bodyEnd = bodyEnd; + this.resolved = resolved; + this.isDeclaration = isDeclaration; + this.modifiers = modifiers; + this.documentation = documentation; + this.javaMethod = javaMethod; + } + + public static MethodInfo declaration(String name, TypeInfo containingType, TypeInfo returnType, List params, + int fullDeclOffset, int typeOffset, int nameOffset, + int bodyStart, int bodyEnd, int modifiers, String documentation) { + return new MethodInfo(name, returnType, containingType, params, fullDeclOffset, typeOffset, nameOffset, bodyStart, bodyEnd, true, true, modifiers, documentation, null); + } + + public static MethodInfo call(String name, TypeInfo containingType, int paramCount) { + boolean resolved = containingType != null && containingType.isResolved() && + containingType.hasMethod(name); + List params = new ArrayList<>(); + for (int i = 0; i < paramCount; i++) { + params.add(FieldInfo.unresolved("arg" + i, FieldInfo.Scope.PARAMETER)); + } + return new MethodInfo(name, null, containingType, params, -1, -1, -1, -1, -1, resolved, false, 0, null, null); + } + + public static MethodInfo unresolvedCall(String name, int paramCount) { + List params = new ArrayList<>(); + for (int i = 0; i < paramCount; i++) { + params.add(FieldInfo.unresolved("arg" + i, FieldInfo.Scope.PARAMETER)); + } + return new MethodInfo(name, null, null, params, -1, -1, -1, -1, -1, false, false, 0, null, null); + } + + /** + * Create a MethodInfo for a synthetic/external method. + * Used for built-in types like Nashorn's Java object. + */ + public static MethodInfo external(String name, TypeInfo returnType, TypeInfo containingType, + List params, int modifiers, String documentation) { + return new MethodInfo(name, returnType, containingType, params, -1, -1, -1, -1, -1, true, false, modifiers, documentation, null); + } + + /** + * Create a MethodInfo from reflection data. + * Used when resolving method calls on known types. + * Preserves generic type information from reflection. + */ + public static MethodInfo fromReflection(Method method, TypeInfo containingType) { + String name = method.getName(); + // Use getGenericReturnType() to preserve generic information like List + TypeInfo returnType = TypeInfo.fromGenericType(method.getGenericReturnType()); + if (returnType == null) { + returnType = TypeInfo.fromClass(method.getReturnType()); + } + int modifiers = method.getModifiers(); + + // Try to find matching JSMethodInfo to bridge parameter names/docs and allow return overrides + JSMethodInfo jsMethod = DtsJavaBridge.findMatchingMethod(method, containingType); + if (jsMethod != null) { + // If .d.ts provides a more specific return type, use it for editor typing. + // (e.g., .d.ts override like IDBCPlayer -> IDBCAddon in npcdbc). + TypeInfo overrideReturnType = DtsJavaBridge.resolveReturnTypeOverride(method, containingType, jsMethod); + if (overrideReturnType != null && overrideReturnType.getJavaClass() != null) { + Class reflectedReturn = method.getReturnType(); + Class overrideClass = overrideReturnType.getJavaClass(); + if (reflectedReturn.isAssignableFrom(overrideClass)) { + if (reflectedReturn != overrideClass) { + returnType = overrideReturnType; + System.out.println("[DtsJavaBridge] Overrode return type for " + + method.getDeclaringClass().getName() + "." + name + + "(" + method.getParameterCount() + ") from " + + reflectedReturn.getName() + " to " + overrideClass.getName()); + } + } + } + } + + // If the receiver is parameterized (e.g., List), substitute class type variables (E -> String) + Map receiverBindings = null; + if (GenericContext.hasGenerics(containingType)) { + receiverBindings = TypeSubstitutor.createBindingsFromReceiver(containingType); + if (!receiverBindings.isEmpty()) { + returnType = TypeSubstitutor.substitute(returnType, receiverBindings); + } + } + List params = new ArrayList<>(); + // Use getGenericParameterTypes() to preserve generic information + java.lang.reflect.Type[] genericParamTypes = method.getGenericParameterTypes(); + List jsParams = jsMethod != null ? jsMethod.getParameters() : null; + for (int i = 0; i < genericParamTypes.length; i++) { + TypeInfo paramType = TypeInfo.fromGenericType(genericParamTypes[i]); + if (paramType == null) { + paramType = TypeInfo.fromClass(method.getParameterTypes()[i]); + } + + if (receiverBindings != null && !receiverBindings.isEmpty()) { + paramType = TypeSubstitutor.substitute(paramType, receiverBindings); + } + + // Adapt Object params to receiver generic type args (e.g., Map.get(Object) -> Map.get(K)) + TypeInfo adapted = GenericParameterAdapter.adaptParameterType(method, containingType, i, paramType); + if (adapted != null) { + paramType = adapted; + } + String paramName = "arg" + i; + if (jsParams != null && i < jsParams.size()) { + String jsName = jsParams.get(i).getName(); + if (jsName != null && !jsName.isEmpty()) { + paramName = jsName; + } + } + + FieldInfo fieldInfo = FieldInfo.reflectionParam(paramName, paramType); + boolean isVarArg = method.isVarArgs() && i == genericParamTypes.length - 1; + if (jsParams != null && i < jsParams.size()) { + isVarArg = isVarArg || jsParams.get(i).isVarArg(); + } + fieldInfo.setVarArg(isVarArg); + params.add(fieldInfo); + } + + String documentation = null; + JSDocInfo jsDocInfo = null; + if (jsMethod != null) { + jsDocInfo = jsMethod.getJsDocInfo(); + String jsDocDesc = jsDocInfo != null ? jsDocInfo.getDescription() : null; + documentation = jsDocDesc != null ? jsDocDesc : jsMethod.getDocumentation(); + } + + MethodInfo methodInfo = new MethodInfo(name, returnType, containingType, params, -1, -1, -1, -1, -1, true, false, modifiers, documentation, method); + if (jsDocInfo != null) { + methodInfo.setJSDocInfo(jsDocInfo); + } + return methodInfo; + } + + /** + * Create a MethodInfo from a Constructor via reflection. + * Used when resolving constructor calls on external types. + * Preserves generic type information for constructor parameters. + */ + public static MethodInfo fromReflectionConstructor(Constructor constructor, TypeInfo containingType) { + String name = containingType.getSimpleName(); // Constructor name is the type name + TypeInfo returnType = containingType; // Constructor "returns" an instance of the type + int modifiers = constructor.getModifiers(); + + List params = new ArrayList<>(); + // Use getGenericParameterTypes() to preserve generic information + java.lang.reflect.Type[] genericParamTypes = constructor.getGenericParameterTypes(); + for (int i = 0; i < genericParamTypes.length; i++) { + TypeInfo paramType = TypeInfo.fromGenericType(genericParamTypes[i]); + if (paramType == null) { + paramType = TypeInfo.fromClass(constructor.getParameterTypes()[i]); + } + FieldInfo fieldInfo = FieldInfo.reflectionParam("arg" + i, paramType); + fieldInfo.setVarArg(constructor.isVarArgs() && i == genericParamTypes.length - 1); + params.add(fieldInfo); + } + + return new MethodInfo(name, returnType, containingType, params, -1, -1, -1, -1, -1, true, true, modifiers, null, null); + } + + /** + * Create a MethodInfo from a JSMethodInfo (parsed from .d.ts files). + * Used when resolving method calls on JavaScript types. + * + * @param jsMethod The JavaScript method info from the type registry + * @param containingType The TypeInfo that owns this method + * @return A MethodInfo representing the JavaScript method + */ + public static MethodInfo fromJSMethod(JSMethodInfo jsMethod, TypeInfo containingType) { + String name = jsMethod.getName(); + + // Use the new getResolvedReturnType method + TypeInfo returnType = jsMethod.getResolvedReturnType(containingType); + + // Convert JS parameters to FieldInfo + List params = new ArrayList<>(); + List jsParams = jsMethod.getParameters(); + + for (JSMethodInfo.JSParameterInfo param : jsParams) { + String paramName = param.getName(); + + // Use the new getResolvedType method + TypeInfo paramType = param.getResolvedType(containingType); + + FieldInfo fieldInfo = FieldInfo.reflectionParam(paramName, paramType); + fieldInfo.setVarArg(param.isVarArg()); + params.add(fieldInfo); + } + + // JS methods are always public (no access modifiers in .d.ts) + int modifiers = Modifier.PUBLIC; + if (jsMethod.isStatic()) { + modifiers |= Modifier.STATIC; + } + + // Use the documentation from the method if available + JSDocInfo jsDocInfo = jsMethod.getJsDocInfo(); + String jsDocDesc = jsDocInfo != null ? jsDocInfo.getDescription() : null; + String documentation = jsDocDesc != null ? jsDocDesc : jsMethod.getDocumentation(); + + MethodInfo methodInfo = new MethodInfo(name, returnType, containingType, params, -1, -1, -1, -1, -1, true, + false, modifiers, documentation, null); + methodInfo.setJSDocInfo(jsDocInfo); + return methodInfo; + } + + + + // Getters + public String getName() { return name; } + public TypeInfo getReturnType() { return returnType; } + public TypeInfo getContainingType() { return containingType; } + public List getParameters() { return Collections.unmodifiableList(parameters); } + public int getParameterCount() { return parameters.size(); } + public Method getJavaMethod() { return javaMethod; } + /** @deprecated Use getTypeOffset() or getNameOffset() instead */ + @Deprecated + public int getDeclarationOffset() { return typeOffset; } + public int getFullDeclarationOffset() { return fullDeclarationOffset; } + public int getTypeOffset() { return typeOffset; } + public int getNameOffset() { return nameOffset; } + public int getBodyStart() { return bodyStart; } + public int getBodyEnd() { return bodyEnd; } + public boolean isResolved() { return resolved; } + public boolean isDeclaration() { return isDeclaration; } + public boolean isCall() { return !isDeclaration; } + public int getModifiers() { return modifiers; } + public boolean isStatic() { return Modifier.isStatic(modifiers); } + public boolean isFinal() { return Modifier.isFinal(modifiers); } + public boolean isAbstract() { return Modifier.isAbstract(modifiers); } + public boolean isSynchronized() { return Modifier.isSynchronized(modifiers); } + public boolean isNative() { return Modifier.isNative(modifiers); } + public boolean isPublic() { return Modifier.isPublic(modifiers); } + public boolean isPrivate() { return Modifier.isPrivate(modifiers); } + public boolean isProtected() { return Modifier.isProtected(modifiers); } + public String getDocumentation() { return documentation; } + public JSDocInfo getJSDocInfo() { return jsDocInfo; } + public void setJSDocInfo(JSDocInfo jsDocInfo) { this.jsDocInfo = jsDocInfo; } + + // ==================== OVERRIDE/IMPLEMENTS GETTERS/SETTERS ==================== + + /** + * Check if this method overrides a parent class method. + */ + public boolean isOverride() { return overridesFrom != null; } + + /** + * Get the type containing the method this overrides. + * @return The parent class TypeInfo, or null if not an override + */ + public TypeInfo getOverridesFrom() { return overridesFrom; } + + /** + * Mark this method as overriding a parent class method. + * @param parentType The type containing the overridden method + */ + public void setOverridesFrom(TypeInfo parentType) { this.overridesFrom = parentType; } + + /** + * Check if this method implements an interface method. + */ + public boolean isImplements() { return implementsFrom != null; } + + /** + * Get the interface containing the method this implements. + * @return The interface TypeInfo, or null if not implementing + */ + public TypeInfo getImplementsFrom() { return implementsFrom; } + + /** + * Mark this method as implementing an interface method. + * @param interfaceType The interface containing the implemented method + */ + public void setImplementsFrom(TypeInfo interfaceType) { this.implementsFrom = interfaceType; } + + /** + * Check if this method either overrides or implements something. + */ + public boolean hasInheritanceMarker() { return isOverride() || isImplements(); } + + /** + * Check if a position is inside this method's body. + */ + public boolean containsPosition(int position) { + return position >= bodyStart && position < bodyEnd; + } + + /** + * Get the end of the method declaration (closing paren position). + * This is used for error highlighting of duplicate methods. + */ + public int getDeclarationEnd() { + // The declaration ends just before the opening brace + // We find the closing paren by searching backwards from bodyStart + return bodyStart > 0 ? bodyStart - 1 : nameOffset + name.length(); + } + + /** + * Check if this method has a parameter with the given name. + */ + public boolean hasParameter(String paramName) { + for (FieldInfo p : parameters) { + if (p.getName().equals(paramName)) { + return true; + } + } + return false; + } + + /** + * Get parameter info by name. + */ + public FieldInfo getParameter(String paramName) { + for (FieldInfo p : parameters) { + if (p.getName().equals(paramName)) { + return p; + } + } + return null; + } + + /** + * Get method signature for duplicate detection. + * Signature = name + parameter types (ignoring parameter names). + */ + public MethodSignature cachedSignature; + + public MethodSignature getSignature() { + if (cachedSignature == null) { + List paramTypes = new ArrayList<>(); + for (FieldInfo param : parameters) + paramTypes.add(param.getTypeInfo()); + cachedSignature = new MethodSignature(name, paramTypes); + } + return cachedSignature; + } + + /** + * Get the appropriate TokenType for highlighting this method. + */ + public TokenType getTokenType() { + if (isDeclaration) { + return TokenType.METHOD_DECL; + } + return resolved ? TokenType.METHOD_CALL : TokenType.DEFAULT; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("MethodInfo{"); + sb.append(name).append("("); + for (int i = 0; i < parameters.size(); i++) { + if (i > 0) sb.append(", "); + sb.append(parameters.get(i).getName()); + } + sb.append(")"); + if (returnType != null) { + sb.append(" -> ").append(returnType.getSimpleName()); + } + sb.append(", ").append(isDeclaration ? "decl" : "call"); + sb.append(", ").append(resolved ? "resolved" : "unresolved"); + sb.append("}"); + return sb.toString(); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + MethodInfo that = (MethodInfo) o; + return name.equals(that.name) && parameters.size() == that.parameters.size(); + } + + @Override + public int hashCode() { + return name.hashCode() * 31 + parameters.size(); + } + + // ==================== ERROR HANDLING ==================== + + /** + * Represents an error with a specific parameter. + */ + public static class ParameterError { + private final FieldInfo parameter; + private final int paramIndex; + private final ErrorType errorType; + private final String message; + + public ParameterError(FieldInfo parameter, int paramIndex, ErrorType errorType, String message) { + this.parameter = parameter; + this.paramIndex = paramIndex; + this.errorType = errorType; + this.message = message; + } + + public FieldInfo getParameter() { return parameter; } + public int getParamIndex() { return paramIndex; } + public ErrorType getErrorType() { return errorType; } + public String getMessage() { return message; } + } + + /** + * Represents an error with a return statement (type mismatch). + */ + public static class ReturnStatementError { + private final int startOffset; // Start of "return" keyword (absolute position) + private final int endOffset; // End of return statement (after semicolon) + private final String message; + private final TypeInfo expectedType; + private final TypeInfo actualType; + + public ReturnStatementError(int startOffset, int endOffset, String message, TypeInfo expectedType, TypeInfo actualType) { + this.startOffset = startOffset; + this.endOffset = endOffset; + this.message = message; + this.expectedType = expectedType; + this.actualType = actualType; + } + + public int getStartOffset() { return startOffset; } + public int getEndOffset() { return endOffset; } + public String getMessage() { return message; } + public TypeInfo getExpectedType() { return expectedType; } + public TypeInfo getActualType() { return actualType; } + } + + /** + * Check if this method declaration has any errors. + */ + public boolean hasError() { + return errorType != ErrorType.NONE || !parameterErrors.isEmpty() || !returnStatementErrors.isEmpty(); + } + + /** + * Check if this has a missing return error. + */ + public boolean hasMissingReturnError() { + return errorType == ErrorType.MISSING_RETURN; + } + + /** + * Check if this has parameter errors. + */ + public boolean hasParameterErrors() { + return !parameterErrors.isEmpty(); + } + + /** + * Check if this has return statement type errors. + */ + public boolean hasReturnStatementErrors() { + return !returnStatementErrors.isEmpty(); + } + + public ErrorType getErrorType() { return errorType; } + public String getErrorMessage() { return errorMessage; } + public List getParameterErrors() { return Collections.unmodifiableList(parameterErrors); } + public List getReturnStatementErrors() { return Collections.unmodifiableList(returnStatementErrors); } + + /** + * Set the main error for this method. + */ + public void setError(ErrorType type, String message) { + this.errorType = type; + this.errorMessage = message; + } + + /** + * Add a parameter-specific error. + */ + public void addParameterError(FieldInfo param, int index, ErrorType type, String message) { + parameterErrors.add(new ParameterError(param, index, type, message)); + } + + public void addSamTypeError(int paramIndex, TypeInfo expectedSamType, TypeInfo actualDeclaredType) { + if (paramIndex < 0 || paramIndex >= parameters.size()) { + return; + } + FieldInfo param = parameters.get(paramIndex); + String message = "Explicit type '" + actualDeclaredType.getSimpleName() + + "' is incompatible with SAM parameter type '" + expectedSamType.getSimpleName() + "'"; + parameterErrors.add(new ParameterError(param, paramIndex, ErrorType.SAM_TYPE_INCOMPATIBLE, message)); + } + + /** + * Add a return statement error. + */ + public void addReturnStatementError(int startOffset, int endOffset, String message, TypeInfo expectedType, TypeInfo actualType) { + returnStatementErrors.add(new ReturnStatementError(startOffset, endOffset, message, expectedType, actualType)); + } + + /** + * Functional interface for type resolution callback. + */ + @FunctionalInterface + public interface TypeResolver { + TypeInfo resolveExpression(String expression, int position); + } + + + /** + * Validate this method declaration with type resolution for return statements. + * Checks for parameter errors, missing return statements, and return type mismatches. + * + * @param methodBodyText The text content of the method body (between { and }) + * @param typeResolver Optional callback to resolve expression types (for return type checking) + */ + public void validate(String methodBodyText, boolean hasBody, TypeResolver typeResolver) { + if (!isDeclaration) return; + + // Don't error if return type unresolved + if(returnType != null && !returnType.isResolved()) + return; + + // Validate parameters + validateParameters(); + boolean interfaceMember = containingType != null && containingType.isInterface(); + if (hasBody && (interfaceMember || isAbstract() || isNative())) { + setError(MethodInfo.ErrorType.INTERFACE_METHOD_BODY, "Interface or abstract methods cannot have a body"); + return; + } + + //No need to check for return types/statements + if(interfaceMember) + return; + + //If no body and not interface or abstract/native + if (bodyStart == bodyEnd && !isAbstract() && !isNative()) { + setError(ErrorType.MISSING_BODY, "Method must have a body or be declared abstract/native."); + return; + } + + // Validate return statement types FIRST if we have a type resolver + // This ensures type errors are shown even if there's also a missing return + if (typeResolver != null) { + validateReturnTypes(methodBodyText, typeResolver); + } + + // Validate return statement for non-void methods + // This may set the main error, but return type errors are already recorded + validateReturnStatement(methodBodyText); + } + + /** + * Check for duplicate and unresolved parameters. + */ + private void validateParameters() { + Set seenNames = new HashSet<>(); + + for (int i = 0; i < parameters.size(); i++) { + FieldInfo param = parameters.get(i); + String paramName = param.getName(); + + // Check for duplicate parameter names + if (seenNames.contains(paramName)) { + addParameterError(param, i, ErrorType.DUPLICATE_PARAMETER, + "Duplicate parameter name '" + paramName + "'"); + } else { + seenNames.add(paramName); + } + + // Check for unresolved parameter types + TypeInfo paramType = param.getTypeInfo(); + if (paramType == null || !paramType.isResolved()) { + String typeName = paramType != null ? paramType.getDisplayName() : "unknown"; + addParameterError(param, i, ErrorType.PARAMETER_UNDEFINED, + "Cannot resolve parameter type '" + typeName + "'"); + } + } + } + + /** + * Validate that a non-void method has a guaranteed return statement. + * Delegates to {@link ControlFlowAnalyzer} for control flow analysis. + */ + private void validateReturnStatement(String bodyText) { + if (bodyText == null || bodyText.isEmpty()) return; + + // void methods don't need return statements + if (TypeChecker.isVoidType(returnType)) return; + + // Abstract/native methods don't have bodies + if (isAbstract() || isNative()) return; + + // Check if the method has a guaranteed return using the control flow analyzer + if (!ControlFlowAnalyzer.hasGuaranteedReturn(bodyText)) { + setError(ErrorType.MISSING_RETURN, "Missing return statement"); + } + } + + /** + * Validate that all return statements have compatible types. + * Delegates to {@link CodeParser} for parsing and {@link TypeChecker} for type checks. + */ + private void validateReturnTypes(String bodyText, TypeResolver typeResolver) { + if (bodyText == null || bodyText.isEmpty()) return; + + boolean isVoid = TypeChecker.isVoidType(returnType); + String expectedTypeName = isVoid ? "void" : returnType.getDisplayName(); + + // Remove comments but keep strings (we need accurate positions) + String cleanBody = CodeParser.removeComments(bodyText); + + // Find all return statements + int pos = 0; + while (pos < cleanBody.length()) { + // Look for "return" keyword + int returnPos = CodeParser.findReturnKeyword(cleanBody, pos); + if (returnPos < 0) break; + + // Find the semicolon ending this return statement + int semiPos = CodeParser.findReturnSemicolon(cleanBody, returnPos + 6); + if (semiPos < 0) { + pos = returnPos + 6; + continue; + } + + // Extract the return expression + String returnExpr = cleanBody.substring(returnPos + 6, semiPos).trim(); + + // Calculate absolute position (bodyStart + 1 is after the opening brace) + int absoluteReturnStart = bodyStart + 1 + returnPos; + int absoluteSemiEnd = bodyStart + 1 + semiPos + 1; // +1 to include semicolon + + // Check void method returning a value + if (isVoid && !returnExpr.isEmpty()) { + String message = "Cannot return a value from a method with void result type"; + addReturnStatementError(absoluteReturnStart, absoluteSemiEnd, message, returnType, null); + } + // Check non-void method return type compatibility + else if (!isVoid && !returnExpr.isEmpty() && typeResolver != null) { + // Resolve the expression type + TypeInfo actualType = typeResolver.resolveExpression(returnExpr, absoluteReturnStart); + + // Check type compatibility + if (!TypeChecker.isTypeCompatible(returnType, actualType)) { + String actualTypeName = actualType != null ? actualType.getSimpleName() : "null"; + String message = "Incompatible types.\nRequired: " + expectedTypeName + "\nFound: " + actualTypeName; + addReturnStatementError(absoluteReturnStart, absoluteSemiEnd, message, returnType, actualType); + } + } + + pos = semiPos + 1; + } + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/method/MethodSignature.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/method/MethodSignature.java new file mode 100644 index 000000000..5cde0ac63 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/method/MethodSignature.java @@ -0,0 +1,95 @@ +package noppes.npcs.client.gui.util.script.interpreter.method; + +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.List; + +/** + * Represents a method signature for robust comparison. + * Compares method name and parameter types as structured data, not as strings. + */ +public final class MethodSignature { + private final String methodName; + private final List parameterTypes; + + public MethodSignature(String methodName, List parameterTypes) { + this.methodName = methodName; + this.parameterTypes = new ArrayList<>(parameterTypes); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (!(obj instanceof MethodSignature)) + return false; + + MethodSignature other = (MethodSignature) obj; + + // Compare method names + if (!this.methodName.equals(other.methodName)) + return false; + + // Compare parameter count + if (this.parameterTypes.size() != other.parameterTypes.size()) + return false; + + // Compare each parameter type + for (int i = 0; i < this.parameterTypes.size(); i++) { + TypeInfo thisType = this.parameterTypes.get(i); + TypeInfo otherType = other.parameterTypes.get(i); + + // Both null = equal + if (thisType == null && otherType == null) + continue; + + // One null, one not = not equal + if (thisType == null || otherType == null) + return false; + + // Compare full type names + if (!thisType.getFullName().equals(otherType.getFullName())) + return false; + } + + return true; + } + + @Override + public int hashCode() { + int result = methodName.hashCode(); + for (TypeInfo paramType : parameterTypes) { + result = 31 * result + (paramType != null ? paramType.getFullName().hashCode() : 0); + } + return result; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(methodName); + sb.append("("); + for (int i = 0; i < parameterTypes.size(); i++) { + if (i > 0) + sb.append(", "); + TypeInfo type = parameterTypes.get(i); + sb.append(type != null ? type.getFullName() : "?"); + } + sb.append(")"); + return sb.toString(); + } + + public static String asString(Method javaMethod) { + StringBuilder sig = new StringBuilder(javaMethod.getName()); + sig.append("("); + Class[] paramTypes = javaMethod.getParameterTypes(); + for (int i = 0; i < paramTypes.length; i++) { + if (i > 0) + sig.append(", "); + sig.append(paramTypes[i].getSimpleName()); + } + sig.append(")"); + return sig.toString(); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/package-info.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/package-info.java new file mode 100644 index 000000000..0fe302521 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/package-info.java @@ -0,0 +1,102 @@ +/** + *

Interpreter Package - Java Syntax Highlighting System

+ * + *

This package provides a clean, modular rewrite of the JavaTextContainer + * syntax highlighting system. It replaces the original implementation with + * well-structured, atomic classes that work together like LEGO pieces.

+ * + *

Architecture Overview

+ * + *
+ * ┌─────────────────────────────────────────────────────────────────┐
+ * │                    ScriptTextContainer                          │
+ * │  (Compatibility adapter extending JavaTextContainer)            │
+ * │  - USE_NEW_INTERPRETER flag to toggle between systems           │
+ * │  - Produces JavaTextContainer.LineData/Token for GUI compat     │
+ * └───────────────────────┬─────────────────────────────────────────┘
+ *                         │
+ *                         ▼
+ * ┌─────────────────────────────────────────────────────────────────┐
+ * │                     ScriptDocument                              │
+ * │  (Main document container - replaces JavaTextContainer core)    │
+ * │                                                                 │
+ * │  7-Phase Tokenization Pipeline:                                 │
+ * │  1. findExcludedRanges() - strings/comments                     │
+ * │  2. parseImports() - import statements                          │
+ * │  3. parseStructure() - methods, fields                          │
+ * │  4. buildMarks() - all highlighting marks                       │
+ * │  5. resolveConflicts() - priority-based resolution              │
+ * │  6. buildTokens() - convert marks to tokens per line            │
+ * │  7. computeIndentGuides() - visual indent guides                │
+ * └───────────────────────┬─────────────────────────────────────────┘
+ *                         │
+ *                         ▼
+ * ┌─────────────────────────────────────────────────────────────────┐
+ * │                      ScriptLine                                 │
+ * │  (Line container with token management and rendering)           │
+ * │  - Token list with navigation                                   │
+ * │  - Indent guides                                                │
+ * │  - drawString() with color codes                                │
+ * │  - drawStringHex() for direct hex color rendering               │
+ * └───────────────────────┬─────────────────────────────────────────┘
+ *                         │
+ *                         ▼
+ * ┌─────────────────────────────────────────────────────────────────┐
+ * │                        Token                                    │
+ * │  (Atomic token unit with type-specific metadata)                │
+ * │  - Text, start/end offsets                                      │
+ * │  - TokenType (with hex color and priority)                      │
+ * │  - prev()/next() navigation                                     │
+ * │  - Type-specific metadata: TypeInfo, FieldInfo, MethodInfo      │
+ * └─────────────────────────────────────────────────────────────────┘
+ * 
+ * + *

Supporting Classes

+ * + *
    + *
  • TokenType - Enum with hex colors and priorities for all token types
  • + *
  • TypeInfo - Immutable type metadata (class/interface/enum)
  • + *
  • TypeResolver - Class resolution with caching (replaces ClassPathFinder)
  • + *
  • ImportData - Import statement tracking with resolution status
  • + *
  • FieldInfo - Field/variable metadata with scope (global/local/parameter)
  • + *
  • MethodInfo - Method declaration/call metadata with parameters
  • + *
+ * + *

Key Improvements Over Original

+ * + *
    + *
  1. Single-pass tokenization - 7 distinct phases vs multiple loops
  2. + *
  3. Token navigation - prev()/next() methods for easy traversal
  4. + *
  5. Type-specific metadata - Rich information attached to tokens
  6. + *
  7. Hex color support - Direct RGB colors in addition to MC color codes
  8. + *
  9. Clean separation - Each class has one responsibility
  10. + *
  11. Immutable data - TypeInfo, FieldInfo, MethodInfo are immutable
  12. + *
  13. Feature toggle - USE_NEW_INTERPRETER flag for safe rollback
  14. + *
+ * + *

Usage

+ * + *
{@code
+ * // The new system is automatically used via ScriptTextContainer
+ * // To disable and use original JavaTextContainer:
+ * ScriptTextContainer.USE_NEW_INTERPRETER = false;
+ * 
+ * // To access the underlying ScriptDocument:
+ * ScriptTextContainer container = (ScriptTextContainer) textArea.getContainer();
+ * ScriptDocument doc = container.getDocument();
+ * 
+ * // Token navigation example:
+ * for (ScriptLine line : doc.getLines()) {
+ *     for (Token token : line.getTokens()) {
+ *         Token next = token.next();
+ *         Token prev = token.prev();
+ *     }
+ * }
+ * }
+ * + * @since 2.0 + * @see ScriptTextContainer + * @see ScriptDocument + * @see Token + */ +package noppes.npcs.client.gui.util.script.interpreter; diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/token/Token.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/token/Token.java new file mode 100644 index 000000000..b7b81af9e --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/token/Token.java @@ -0,0 +1,271 @@ +package noppes.npcs.client.gui.util.script.interpreter.token; + +import noppes.npcs.client.gui.util.script.interpreter.type.ImportData; +import noppes.npcs.client.gui.util.script.interpreter.ScriptLine; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.field.EnumConstantInfo; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldAccessInfo; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodCallInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; + +/** + * Represents a single token in the source code with its type and metadata. + * Tokens are the atomic units of the syntax highlighting system. + * + * Each token knows: + * - Its text content + * - Its position in the global source + * - Its type (for coloring) + * - Type-specific metadata (resolved class info, declaration info, etc.) + */ +public class Token { + + private final String text; + private final int globalStart; // start offset in the full document + private final int globalEnd; // end offset in the full document + private TokenType type; + + // Optional metadata based on token type + private TypeInfo typeInfo; // For class references, type declarations + private FieldInfo fieldInfo; // For field references + private MethodInfo methodInfo; // For method calls/declarations + private MethodCallInfo methodCallInfo; // For method calls with argument info + private ImportData importData; // For import statements + private FieldAccessInfo fieldAccessInfo; //For fields like Minecraft.getMinecraft.thePlayer + private TokenErrorMessage errorMessage; + + + // Navigation - set by ScriptLine + private Token prev; + private Token next; + private ScriptLine parentLine; + + public Token(String text, int globalStart, int globalEnd, TokenType type) { + this.text = text; + this.globalStart = globalStart; + this.globalEnd = globalEnd; + this.type = type; + } + + // ==================== FACTORY METHODS ==================== + + public static Token defaultToken(String text, int start, int end) { + return new Token(text, start, end, TokenType.DEFAULT); + } + + public static Token keyword(String text, int start, int end) { + return new Token(text, start, end, TokenType.KEYWORD); + } + + public static Token modifier(String text, int start, int end) { + return new Token(text, start, end, TokenType.MODIFIER); + } + + public static Token comment(String text, int start, int end) { + return new Token(text, start, end, TokenType.COMMENT); + } + + public static Token string(String text, int start, int end) { + return new Token(text, start, end, TokenType.STRING); + } + + public static Token literal(String text, int start, int end) { + return new Token(text, start, end, TokenType.LITERAL); + } + + public static Token typeReference(String text, int start, int end, TypeInfo info) { + Token t = new Token(text, start, end, info != null ? info.getTokenType() : TokenType.TYPE_DECL); + t.typeInfo = info; + return t; + } + + public static Token methodDecl(String text, int start, int end, MethodInfo info) { + Token t = new Token(text, start, end, TokenType.METHOD_DECL); + t.methodInfo = info; + return t; + } + + public static Token methodCall(String text, int start, int end, MethodInfo info, boolean resolved) { + Token t = new Token(text, start, end, resolved ? TokenType.METHOD_CALL : TokenType.DEFAULT); + t.methodInfo = info; + return t; + } + + public static Token globalField(String text, int start, int end, FieldInfo info) { + Token t = new Token(text, start, end, TokenType.GLOBAL_FIELD); + t.fieldInfo = info; + return t; + } + + public static Token localField(String text, int start, int end, FieldInfo info) { + Token t = new Token(text, start, end, TokenType.LOCAL_FIELD); + t.fieldInfo = info; + return t; + } + + public static Token parameter(String text, int start, int end, FieldInfo info) { + Token t = new Token(text, start, end, TokenType.PARAMETER); + t.fieldInfo = info; + return t; + } + + public static Token undefined(String text, int start, int end) { + return new Token(text, start, end, TokenType.UNDEFINED_VAR); + } + + // ==================== GETTERS ==================== + + public String getText() { return text; } + public int getGlobalStart() { return globalStart; } + public int getGlobalEnd() { return globalEnd; } + public int getLength() { return globalEnd - globalStart; } + public TokenType getType() { return type; } + public TypeInfo getTypeInfo() { return typeInfo; } + public FieldInfo getFieldInfo() { return fieldInfo; } + public MethodInfo getMethodInfo() { return methodInfo; } + public MethodCallInfo getMethodCallInfo() { return methodCallInfo; } + public FieldAccessInfo getFieldAccessInfo() { return fieldAccessInfo; } + public ImportData getImportData() { return importData; } + public TokenErrorMessage getErrorMessage() { return errorMessage; } + public ScriptLine getParentLine() { return parentLine; } + + // ==================== SETTERS ==================== + + public void setType(TokenType type) { this.type = type; } + public void setTypeInfo(TypeInfo info) { this.typeInfo = info; } + public void setFieldInfo(FieldInfo info) { this.fieldInfo = info; } + public void setFieldAccessInfo(FieldAccessInfo info) { this.fieldAccessInfo = info; } + public void setMethodInfo(MethodInfo info) { this.methodInfo = info; } + public void setMethodCallInfo(MethodCallInfo info) { this.methodCallInfo = info; } + public void setImportData(ImportData data) { this.importData = data; } + public void setErrorMessage(TokenErrorMessage message) { this.errorMessage = message; } + + public void setParentLine(ScriptLine line) { this.parentLine = line; } + public void setPrev(Token prev) { this.prev = prev; } + public void setNext(Token next) { this.next = next; } + + // ==================== NAVIGATION ==================== + + /** + * Get the previous token (may be on a previous line). + */ + public Token prev() { + if (prev != null) return prev; + if (parentLine == null) return null; + + ScriptLine prevLine = parentLine.prev(); + while (prevLine != null) { + Token last = prevLine.getLastToken(); + if (last != null) return last; + prevLine = prevLine.prev(); + } + return null; + } + + /** + * Get the next token (may be on a following line). + */ + public Token next() { + if (next != null) return next; + if (parentLine == null) return null; + + ScriptLine nextLine = parentLine.next(); + while (nextLine != null) { + Token first = nextLine.getFirstToken(); + if (first != null) return first; + nextLine = nextLine.next(); + } + return null; + } + + /** + * Get the previous token on the same line only. + */ + public Token prevOnLine() { + return prev; + } + + /** + * Get the next token on the same line only. + */ + public Token nextOnLine() { + return next; + } + + // ==================== TYPE CHECKS ==================== + + public boolean isKeyword() { + return type == TokenType.KEYWORD || type == TokenType.MODIFIER || + type == TokenType.CLASS_KEYWORD || type == TokenType.IMPORT_KEYWORD; + } + + public boolean isTypeReference() { + return type == TokenType.TYPE_DECL || type == TokenType.IMPORTED_CLASS || + type == TokenType.CLASS_DECL || type == TokenType.INTERFACE_DECL || + type == TokenType.ENUM_DECL; + } + + public boolean isEnumConstant() { + return type == TokenType.ENUM_CONSTANT; + } + public boolean isResolved() { + if (typeInfo != null) return typeInfo.isResolved(); + if (fieldInfo != null) return fieldInfo.isResolved(); + if (methodInfo != null) return methodInfo.isResolved(); + return type != TokenType.UNDEFINED_VAR; + } + + public boolean isIdentifier() { + if (text.isEmpty()) return false; + char first = text.charAt(0); + return Character.isJavaIdentifierStart(first); + } + + public boolean startsWithUpperCase() { + return !text.isEmpty() && Character.isUpperCase(text.charAt(0)); + } + + public boolean isMethodCall() { + return type == TokenType.METHOD_CALL || + (type == TokenType.DEFAULT && methodInfo != null); + } + + public boolean isField() { + return type == TokenType.GLOBAL_FIELD || type == TokenType.LOCAL_FIELD || + type == TokenType.PARAMETER || type == TokenType.STATIC_FINAL_FIELD || + type == TokenType.ENUM_CONSTANT; + } + + // ==================== RENDERING ==================== + + /** + * Get the hex color for this token. + */ + public int getHexColor() { + return type.getHexColor(); + } + + /** + * Get the Minecraft color code character. + */ + public char getColorCode() { + return type.toColorCode(); + } + + /** + * Get the Minecraft style prefix for this token (bold/italic codes). + * Returns empty string if no style, otherwise §l for bold, §o for italic, or both. + */ + public String getStylePrefix() { + StringBuilder sb = new StringBuilder(); + if (type.isBold()) sb.append('\u00A7').append('l'); + if (type.isItalic()) sb.append('\u00A7').append('o'); + return sb.toString(); + } + + @Override + public String toString() { + return "Token{'" + text + "', " + type + ", [" + globalStart + "-" + globalEnd + "]}"; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/token/TokenErrorMessage.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/token/TokenErrorMessage.java new file mode 100644 index 000000000..7b5115eb2 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/token/TokenErrorMessage.java @@ -0,0 +1,23 @@ +package noppes.npcs.client.gui.util.script.interpreter.token; + +public class TokenErrorMessage { + private final String message; + public boolean clearOtherErrors; + + public TokenErrorMessage(String message) { + this.message = message; + } + + public String getMessage() { + return message; + } + + public static TokenErrorMessage from(String message) { + return new TokenErrorMessage(message); + } + + public TokenErrorMessage clearOtherErrors() { + this.clearOtherErrors = true; + return this; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/token/TokenType.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/token/TokenType.java new file mode 100644 index 000000000..2cb57da62 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/token/TokenType.java @@ -0,0 +1,150 @@ +package noppes.npcs.client.gui.util.script.interpreter.token; + +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +/** + * Defines all token types for syntax highlighting with hex colors and priorities. + * Priority determines which token type wins when marks overlap. + * Higher priority = wins conflicts. + */ +public enum TokenType { + // Comments and strings have highest priority - they override everything inside them + COMMENT(0x777777, 140), + STRING(0xCC8855, 130), + + // JSDoc elements - lower priority but will fill gaps left by fragmented comment marking + JSDOC_TAG(0xCC9933, 125), // @param, @type, @return etc. (gold/orange) + JSDOC_TYPE(0x00AAAA, 124), // {TypeName} in JSDoc (aqua like types) + + UNUSED_IMPORT(0x666666, 119), // unused import statements (gray) + + // Keywords and modifiers + CLASS_KEYWORD(0xFF5555, 115), // 'class', 'interface', 'enum' keywords + IMPORT_KEYWORD(0xFFAA00, 110), // 'import' keyword + KEYWORD(0xFF5555, 100), // control flow: if, else, for, while, etc. + MODIFIER(0xFFAA00, 90), // public, private, static, final, etc. + + // Type declarations and references + INTERFACE_DECL(0x55FFFF, 85), // interface names (aqua) + ENUM_DECL(0xFF55FF, 85), // enum names (magenta) + ENUM_CONSTANT(0x55FFFF, 84, true, false), // enum constant values (blue, bold+italic) - like IntelliJ + CLASS_DECL(0x00AAAA, 85), // class names in declarations + IMPORTED_CLASS(0x00AAAA, 75), // imported class usages + TYPE_DECL(0x00AAAA, 70), // package paths, type references + + // Methods + METHOD_DECL(0x00AA00, 60), // method declarations (green) + METHOD_CALL(0x55FF55, 50), // method calls (bright green) + + // Variables and fields + UNDEFINED_VAR(0xAA0000, 20), // unresolved variables (dark red) - high priority + PARAMETER(0x5555FF, 36), // method parameters (blue) + GLOBAL_FIELD(0x55FFFF, 35), // class-level fields (aqua) + LOCAL_FIELD(0xFFFF55, 25), // local variables (yellow) + STATIC_FINAL_FIELD(0xFF55FF, 36, false, true), // static final fields (magenta, italic) + + // Literals + LITERAL(0x777777, 40), // numeric and boolean literals + + // Default + VARIABLE(0xFFFFFF, 30), // generic variables + DEFAULT(0xFFFFFF, 0); // default text color (white) + + private final int hexColor; + private final int priority; + private final boolean bold; + private final boolean italic; + + TokenType(int hexColor, int priority) { + this(hexColor, priority, false, false); + } + + TokenType(int hexColor, int priority, boolean bold, boolean italic) { + this.hexColor = hexColor; + this.priority = priority; + this.bold = bold; + this.italic = italic; + } + + public int getHexColor() { + return hexColor; + } + + public int getPriority() { + return priority; + } + + public boolean isBold() { + return bold; + } + + public boolean isItalic() { + return italic; + } + + public static TokenType getByType(TypeInfo typeInfo) { + if (typeInfo == null || !typeInfo.isResolved()) + return TokenType.UNDEFINED_VAR; + + if ("any".equals(typeInfo.getFullName())) + return TokenType.KEYWORD; + + // Use the TypeInfo's own token type, which handles ScriptTypeInfo correctly + return typeInfo.getTokenType(); + } + + public static int getColor(TypeInfo typeInfo) { + return getByType(typeInfo).getHexColor(); + } + + /** + * Convert this token type to a Minecraft color code character. + * Used for backward compatibility with the existing rendering system. + */ + public char toColorCode() { + switch (this) { + case COMMENT: + case LITERAL: + case UNUSED_IMPORT: + return '7'; // gray + case STRING: + return '5'; // purple + case JSDOC_TAG: + return '6'; // gold + case JSDOC_TYPE: + return '3'; // dark aqua (like types) + case CLASS_KEYWORD: + case KEYWORD: + return 'c'; // red + case IMPORT_KEYWORD: + case MODIFIER: + return '6'; // gold + case ENUM_DECL: + case STATIC_FINAL_FIELD: + return 'd'; // magenta + case ENUM_CONSTANT: + return '9'; // blue (same as PARAMETER) + case INTERFACE_DECL: + case GLOBAL_FIELD: + return 'b'; // aqua + case CLASS_DECL: + case IMPORTED_CLASS: + case TYPE_DECL: + return '3'; // dark aqua + case METHOD_DECL: + return '2'; // dark green + case METHOD_CALL: + return 'a'; // green + case LOCAL_FIELD: + return 'e'; // yellow + case PARAMETER: + return '9'; // blue + case UNDEFINED_VAR: + return '4'; // dark red + case VARIABLE: + case DEFAULT: + default: + return 'f'; // white + } + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/CLASSINDEX_USAGE.txt b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/CLASSINDEX_USAGE.txt new file mode 100644 index 000000000..2adbda50f --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/CLASSINDEX_USAGE.txt @@ -0,0 +1,20 @@ +/** + * Example Usage of ClassIndex: + * + * 1. Add a single class: + * ClassIndex.getInstance().addClass(EntityPlayer.class); + * + * 2. Add an entire package recursively: + * ClassIndex.getInstance().addPackage("net.minecraft.entity.player"); + * This will scan and add ALL classes in that package and subpackages. + * + * 3. Find classes by prefix: + * List matches = ClassIndex.getInstance().findByPrefix("Entity", 50); + * // Returns fully-qualified names like "net.minecraft.entity.Entity", etc. + * + * Benefits: + * - No more manual string pairs! Just pass Class objects. + * - Simple name and package are extracted automatically via reflection. + * - Can scan entire package trees recursively with one call. + * - Cleaner, more maintainable, and easier to extend. + */ diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/ClassIndex.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/ClassIndex.java new file mode 100644 index 000000000..694dd40d1 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/ClassIndex.java @@ -0,0 +1,326 @@ +package noppes.npcs.client.gui.util.script.interpreter.type; + +import java.io.File; +import java.net.URL; +import java.util.*; +import java.util.jar.JarEntry; +import java.util.jar.JarFile; + +/** + * Index of Java classes for autocomplete suggestions. + * Uses reflection to automatically extract class names and packages. + * Supports multiple classes with the same simple name (e.g., java.util.Date and java.sql.Date). + */ +public class ClassIndex { + private static ClassIndex instance; + + // Map simple names to multiple classes (handles name collisions) + private final Map>> simpleNameToClasses = new LinkedHashMap<>(); + private final Set> registeredClasses = new HashSet<>(); + + private ClassIndex() { + // Initialize with common classes + initializeCommonClasses(); + } + + public static ClassIndex getInstance() { + if (instance == null) { + instance = new ClassIndex(); + } + return instance; + } + + public static void init(){ + getInstance(); + } + /** + * Register a single class by its Class object. + * The simple name and full name are extracted via reflection. + * Supports multiple classes with the same simple name. + */ + public void addClass(Class clazz) { + if (clazz == null) return; + + // Check if already registered using the Class object itself + if (registeredClasses.contains(clazz)) { + return; // Already registered + } + + registeredClasses.add(clazz); + String simpleName = clazz.getSimpleName(); + + // Only add if simple name is not empty (avoid inner classes with $ in name) + if (!simpleName.isEmpty() && !simpleName.contains("$")) { + // Add to list of classes with this simple name + simpleNameToClasses.computeIfAbsent(simpleName, k -> new ArrayList<>()).add(clazz); + } + } + + /** + * Register all classes in a package and all subpackages recursively. + * Uses ClassLoader to scan the classpath. + */ + public void addPackage(String packageName) { + addPackage(packageName, new String[0]); + } + + /** + * Register all classes in a package and all subpackages recursively, + * excluding specified packages. + * Uses ClassLoader to scan the classpath. + * + * @param packageName The base package to scan + * @param excludedPackages Array of package names to exclude (including their subpackages) + */ + public void addPackage(String packageName, String... excludedPackages) { + try { + ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); + String path = packageName.replace('.', '/'); + Enumeration resources = classLoader.getResources(path); + + Set classNames = new HashSet<>(); + Set excludedPrefixes = new HashSet<>(); + + // Prepare excluded package prefixes for matching + for (String excluded : excludedPackages) { + if (excluded != null && !excluded.isEmpty()) { + excludedPrefixes.add(excluded + "."); + } + } + + while (resources.hasMoreElements()) { + URL resource = resources.nextElement(); + + if (resource.getProtocol().equals("file")) { + // Scan directory + File directory = new File(resource.getFile()); + scanDirectory(directory, packageName, classNames, excludedPrefixes); + } else if (resource.getProtocol().equals("jar")) { + // Scan JAR file + String jarPath = resource.getPath(); + if (jarPath.startsWith("file:")) { + jarPath = jarPath.substring(5); + } + int separatorIndex = jarPath.indexOf("!"); + if (separatorIndex != -1) { + jarPath = jarPath.substring(0, separatorIndex); + } + scanJar(jarPath, packageName, classNames, excludedPrefixes); + } + } + + // Load all discovered classes + for (String className : classNames) { + try { + Class clazz = Class.forName(className, false, classLoader); + addClass(clazz); + } catch (ClassNotFoundException | NoClassDefFoundError | ExceptionInInitializerError e) { + // Skip classes that can't be loaded + } + } + } catch (Exception e) { + // Silently fail - package might not exist + } + } + + private void scanDirectory(File directory, String packageName, Set classNames) { + scanDirectory(directory, packageName, classNames, new HashSet<>()); + } + + private void scanDirectory(File directory, String packageName, Set classNames, Set excludedPrefixes) { + if (!directory.exists() || !directory.isDirectory()) { + return; + } + + // Check if this package is excluded + for (String excludedPrefix : excludedPrefixes) { + if ((packageName + ".").startsWith(excludedPrefix) || packageName.equals(excludedPrefix.substring(0, excludedPrefix.length() - 1))) { + return; // Skip excluded package + } + } + + File[] files = directory.listFiles(); + if (files == null) { + return; + } + + for (File file : files) { + String fileName = file.getName(); + + if (file.isDirectory()) { + // Recursively scan subdirectory + scanDirectory(file, packageName + "." + fileName, classNames, excludedPrefixes); + } else if (fileName.endsWith(".class")) { + // Add class name + String className = packageName + "." + fileName.substring(0, fileName.length() - 6); + classNames.add(className); + } + } + } + + private void scanJar(String jarPath, String packageName, Set classNames) { + scanJar(jarPath, packageName, classNames, new HashSet<>()); + } + + private void scanJar(String jarPath, String packageName, Set classNames, Set excludedPrefixes) { + try { + JarFile jarFile = new JarFile(jarPath); + Enumeration entries = jarFile.entries(); + String packagePath = packageName.replace('.', '/'); + + while (entries.hasMoreElements()) { + JarEntry entry = entries.nextElement(); + String entryName = entry.getName(); + + if (entryName.startsWith(packagePath) && entryName.endsWith(".class")) { + // Convert path to class name + String className = entryName + .substring(0, entryName.length() - 6) + .replace('/', '.'); + + // Check if this class is in an excluded package + boolean excluded = false; + for (String excludedPrefix : excludedPrefixes) { + if ((className + ".").startsWith(excludedPrefix) || + className.startsWith(excludedPrefix.substring(0, excludedPrefix.length() - 1) + ".")) { + excluded = true; + break; + } + } + + if (!excluded) { + classNames.add(className); + } + } + } + + jarFile.close(); + } catch (Exception e) { + // Silently fail + } + } + + /** + * Find all classes whose simple name starts with the given prefix (case-insensitive). + * Returns fully-qualified class names for all matches, including multiple classes with the same simple name. + */ + public List findByPrefix(String prefix, int maxResults) { + List results = new ArrayList<>(); + String lowerPrefix = prefix.toLowerCase(); + + for (Map.Entry>> entry : simpleNameToClasses.entrySet()) { + if (entry.getKey().toLowerCase().startsWith(lowerPrefix)) { + // Add all classes with this simple name + for (Class clazz : entry.getValue()) { + results.add(clazz.getName()); + + if (maxResults != -1 && results.size() >= maxResults) { + return results; + } + } + } + } + + return results; + } + + /** + * Initialize the index with commonly used Java, Minecraft, and NPC classes. + */ + private void initializeCommonClasses() { + // Java standard library + addClass(String.class); + addClass(Integer.class); + addClass(Double.class); + addClass(Float.class); + addClass(Long.class); + addClass(Boolean.class); + addClass(Character.class); + addClass(Byte.class); + addClass(Short.class); + addClass(Object.class); + addClass(Math.class); + addClass(System.class); + addClass(Thread.class); + addClass(Runnable.class); + addClass(Exception.class); + addClass(RuntimeException.class); + addClass(Error.class); + addClass(Throwable.class); + + // Java collections + addClass(List.class); + addClass(ArrayList.class); + addClass(LinkedList.class); + addClass(Set.class); + addClass(HashSet.class); + addClass(LinkedHashSet.class); + addClass(TreeSet.class); + addClass(Map.class); + addClass(HashMap.class); + addClass(LinkedHashMap.class); + addClass(TreeMap.class); + addClass(Collection.class); + addClass(Iterator.class); + addClass(Comparator.class); + addClass(Collections.class); + addClass(Arrays.class); + addClass(Queue.class); + addClass(Deque.class); + addClass(Stack.class); + addClass(Vector.class); + addClass(Hashtable.class); + + // Java I/O + addClass(java.io.File.class); + addClass(java.io.InputStream.class); + addClass(java.io.OutputStream.class); + addClass(java.io.Reader.class); + addClass(java.io.Writer.class); + addClass(java.io.BufferedReader.class); + addClass(java.io.BufferedWriter.class); + addClass(java.io.FileReader.class); + addClass(java.io.FileWriter.class); + addClass(java.io.IOException.class); + + // Java utilities + addClass(java.util.Random.class); + addClass(java.util.Date.class); + addClass(java.util.Calendar.class); + addClass(java.util.UUID.class); + addClass(java.util.regex.Pattern.class); + addClass(java.util.regex.Matcher.class); + addPackage("java.util.function"); + + // Now add common Minecraft/Forge/NPC packages + addPackage("net.minecraft.entity"); + addPackage("net.minecraft.item"); + addPackage("net.minecraft.block"); + addPackage("net.minecraft.world"); + addPackage("net.minecraft.util"); + addPackage("net.minecraft.nbt"); + addPackage("net.minecraft.potion"); + addPackage("net.minecraft.enchantment"); + addPackage("net.minecraft.inventory"); + addPackage("net.minecraft.tileentity"); + addPackage("net.minecraft.command"); + addPackage("net.minecraft.client"); + + // Forge + addPackage("net.minecraftforge.common"); + addPackage("net.minecraftforge.event"); + addPackage("net.minecraftforge.fml.common"); + + // CustomNPCs + addPackage("noppes.npcs"); + + // DBC (if available) + try { + addPackage("JinRyuu.JRMCore"); + addPackage("JinRyuu.DragonBC"); + addPackage("kamkeel.npcdbc"); + } catch (Exception e) { + // DBC might not be available + } + } +} \ No newline at end of file diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/ClassTypeInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/ClassTypeInfo.java new file mode 100644 index 000000000..ab0888d5d --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/ClassTypeInfo.java @@ -0,0 +1,158 @@ +package noppes.npcs.client.gui.util.script.interpreter.type; + +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; + +import java.lang.reflect.Modifier; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +/** + * Represents a reference to a Java Class itself (not an instance). + * Used for patterns like: var File = Java.type("java.io.File"); + * + * When you have a ClassTypeInfo: + * - Accessing members should show ONLY static members (File.listRoots()) + * - Using 'new' should return an instance of the wrapped class (new File("path")) + * - Calling .constructor(...) should return an instance of the wrapped class + * + * This is distinct from a regular TypeInfo which represents an instance of that type. + */ +public class ClassTypeInfo extends TypeInfo { + + private final TypeInfo instanceType; // The type you get when you do 'new' on this class + private List constructorMethod; + private List classField; + + /** + * Create a ClassTypeInfo wrapping a Java class. + * + * @param javaClass The Java class this represents (e.g., java.io.File.class) + */ + public ClassTypeInfo(Class javaClass) { + super( + javaClass.getSimpleName(), + javaClass.getName(), + javaClass.getPackage() != null ? javaClass.getPackage().getName() : "", + javaClass.isInterface() ? Kind.INTERFACE : (javaClass.isEnum() ? Kind.ENUM : Kind.CLASS), + javaClass, + true, + null, + true // subclass marker + ); + this.instanceType = TypeInfo.fromClass(javaClass); + } + + /** + * Create a ClassTypeInfo from an existing TypeInfo. + */ + public ClassTypeInfo(TypeInfo instanceType) { + super( + instanceType.getSimpleName(), + instanceType.getFullName(), + instanceType.getPackageName(), + instanceType.getKind(), + instanceType.getJavaClass(), + instanceType.isResolved(), + instanceType.getEnclosingType(), + true // subclass marker + ); + this.instanceType = instanceType; + } + + /** + * Returns true - this TypeInfo represents a class reference, not an instance. + */ + @Override + public boolean isClassReference() { + return true; + } + + /** + * Get the TypeInfo for instances of this class. + * This is what you get when you call 'new' on this class. + */ + public TypeInfo getInstanceType() { + return instanceType; + } + + @Override + public List getSyntheticMethods() { + List base = super.getSyntheticMethods(); + + // if (constructorMethod == null) { + constructorMethod = buildConstructorMethod(); + //} + + if (constructorMethod.isEmpty()) { + return base; + } + + List merged = new ArrayList<>(base.size() + constructorMethod.size()); + merged.addAll(base); + merged.addAll(constructorMethod); + return merged; + } + + @Override + public List getSyntheticFields() { + List base = super.getSyntheticFields(); + + if (classField == null) { + classField = buildClassField(); + } + + if (classField.isEmpty()) { + return base; + } + + List merged = new ArrayList<>(base.size() + classField.size()); + merged.addAll(base); + merged.addAll(classField); + return merged; + } + + private List buildConstructorMethod() { + if (instanceType == null) { + return Collections.emptyList(); + } + + FieldInfo argsParam = FieldInfo.parameter("args", TypeInfo.OBJECT, -1, null); + argsParam.setVarArg(true); + + List params = new ArrayList<>(); + params.add(argsParam); + + MethodInfo ctor = MethodInfo.external( + "constructor", + instanceType, + this, + params, + Modifier.PUBLIC | Modifier.STATIC, + "Creates a new instance of " + instanceType.getSimpleName() + ".\n\n" + + "Equivalent to using the 'new' operator on this class reference." + ); + + return Collections.singletonList(ctor); + } + + private List buildClassField() { + if (getJavaClass() == null) { + return Collections.emptyList(); + } + try { + TypeInfo classType = TypeInfo.fromClass(Class.class).parameterize(instanceType); + FieldInfo classField = FieldInfo.external("class", classType, + "The Class object for " + getSimpleName(), Modifier.PUBLIC | Modifier.STATIC); + return Collections.singletonList(classField); + } catch (Exception e) { + return Collections.emptyList(); + } + } + + @Override + public String toString() { + return "Class<" + getSimpleName() + ">"; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/GenericContext.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/GenericContext.java new file mode 100644 index 000000000..916623586 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/GenericContext.java @@ -0,0 +1,276 @@ +package noppes.npcs.client.gui.util.script.interpreter.type; + +import noppes.npcs.client.gui.util.script.interpreter.js_parser.TypeParamInfo; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * A context for resolving and substituting declared type parameters (T, E, K, V...) + * based on a receiver type. + * + * Policy: + * - Prefer applied type arguments when present (e.g. List binds E -> String). + * - Fall back to declared bounds when no applied argument exists (e.g. T extends Entity -> Entity). + */ +public final class GenericContext { + + /** Singleton context for types with no generic parameters. Used to avoid object allocation. */ + private static final GenericContext EMPTY = new GenericContext(new HashMap<>(), new HashMap<>()); + + /** + * Map of type variable names to their applied type arguments. + * For example, in List<String>, this contains E -> TypeInfo.STRING. + * Applied bindings take precedence over bound fallbacks. + */ + private final Map appliedBindings; + + /** + * Map of type variable names to their declared upper bounds. + * For example, in <T extends Entity>, this contains T -> TypeInfo(Entity). + * Used as fallback when no applied argument exists. + */ + private final Map boundFallbacks; + + private GenericContext(Map appliedBindings, Map boundFallbacks) { + this.appliedBindings = appliedBindings != null ? appliedBindings : new HashMap<>(); + this.boundFallbacks = boundFallbacks != null ? boundFallbacks : new HashMap<>(); + } + + /** + * Create a GenericContext for a receiver type. + * + * Fast path: returns singleton EMPTY for non-generic types (no allocation overhead). + * Slow path: builds maps from type parameters and applied arguments for generic types. + * + * @param receiverType the type to extract generic bindings from (e.g., List<String>, DAO<T extends Entity>) + * @return a context with applied bindings and bound fallbacks, or EMPTY singleton if receiverType is not generic + */ + public static GenericContext forReceiver(TypeInfo receiverType) { + // Special edge case: Array.d.ts JS type, bind T to element type so Array methods resolve correctly + if (receiverType != null && receiverType.isArray() && receiverType.getElementType() != null) { + Map applied = new HashMap<>(); + applied.put("T", receiverType.getElementType()); + return new GenericContext(applied, new HashMap<>()); + } + + // Fast path: return singleton for non-generic types + if (receiverType == null || !hasGenerics(receiverType)) { + return EMPTY; + } + + TypeInfo rawType = receiverType.getRawType(); + List declaredParams = rawType != null ? rawType.getTypeParams() : null; + List appliedArgs = receiverType.getAppliedTypeArgs(); + + Map applied = new HashMap<>(); + if (declaredParams != null && appliedArgs != null) { + int count = Math.min(declaredParams.size(), appliedArgs.size()); + for (int i = 0; i < count; i++) { + TypeParamInfo declared = declaredParams.get(i); + TypeInfo arg = appliedArgs.get(i); + if (declared == null || declared.getName() == null || declared.getName().isEmpty() || arg == null) { + continue; + } + applied.put(declared.getName(), arg); + } + } + + Map bounds = new HashMap<>(); + if (declaredParams != null) { + for (TypeParamInfo declared : declaredParams) { + if (declared == null) continue; + String name = declared.getName(); + if (name == null || name.isEmpty()) continue; + TypeInfo bound = declared.getBoundTypeInfo(); + if (bound != null && bound.isResolved()) { + bounds.put(name, bound); + } + } + } + + return new GenericContext(applied, bounds); + } + + /** + * Check if a type has generics that need substitution. + * + * Returns true if: + * - Type is parameterized (e.g., List<String>) + * - Type's raw form differs from the type itself + * - Type has declared type parameters + * + * @param type the type to check + * @return true if this type contains generic information that may need substitution + */ + public static boolean hasGenerics(TypeInfo type) { + return type.isParameterized() || + type.getRawType() != type || + (type.getTypeParams() != null && !type.getTypeParams().isEmpty()); + } + + /** + * Resolve a type variable to its bound or applied type. + * + * Prefers applied bindings (e.g., E -> String in List<String>) over declared bounds. + * Falls back to bounds (e.g., T -> Entity in <T extends Entity>) if no applied argument exists. + * Returns null if the variable is not found in either map. + * + * @param name the type variable name (e.g., "T", "E", "K") + * @return the resolved TypeInfo, or null if variable not found + */ + public TypeInfo resolveTypeVariable(String name) { + if (name == null || name.isEmpty()) { + return null; + } + + TypeInfo applied = appliedBindings.get(name); + if (applied != null) { + return applied; + } + + return boundFallbacks.get(name); + } + + /** + * Substitute type variables in a TypeInfo recursively. + * + * Handles: + * - Direct type variables (unresolved types representing T, E, etc.) + * - Parameterized types (recursively substitutes inside type arguments) + * - Array types (substitutes the element type, preserves array dimensions) + * + * @param type the type to substitute (may contain type variables) + * @return the substituted type, or the original type if no substitutions apply + */ + public TypeInfo substitute(TypeInfo type) { + if (type == null) { + return null; + } + + // Direct type variable substitution (unresolved types represent type variables like T). + if (!type.isResolved()) { + TypeInfo substitution = resolveTypeVariable(type.getSimpleName()); + if (substitution != null) { + return substitution; + } + } + + // Parameterized types: substitute inside args. + if (type.isParameterized()) { + List originalArgs = type.getAppliedTypeArgs(); + List substitutedArgs = new ArrayList<>(originalArgs.size()); + boolean changed = false; + + for (TypeInfo arg : originalArgs) { + TypeInfo substitutedArg = substitute(arg); + substitutedArgs.add(substitutedArg); + if (substitutedArg != arg) { + changed = true; + } + } + + if (changed) { + return type.getRawType().parameterize(substitutedArgs); + } + } + + // Array wrapper types are represented by a display-name suffix; we can still substitute + // a plain "T[]" by looking up "T". + String simple = type.getSimpleName(); + if (simple != null && simple.endsWith("[]")) { + TypeStringNormalizer.ArraySplit split = TypeStringNormalizer.splitArraySuffixes(simple); + String elementName = split.base; + int dims = split.dimensions; + TypeInfo elementSub = resolveTypeVariable(elementName); + if (elementSub != null) { + TypeInfo result = elementSub; + for (int i = 0; i < dims; i++) { + result = TypeInfo.arrayOf(result); + } + return result; + } + } + + return type; + } + + /** + * Substitute type variables in a type string. + * + * Attempts substitution in this order: + * 1. Normalize the string (strip imports, pick union branch, remove nullable suffix, split arrays) + * 2. Try direct type variable lookup (e.g., "T" -> resolved Entity) + * 3. Fall back to full type resolution with substitution applied + * + * @param typeString the type expression as a string (e.g., "T", "T[]", "List<T>") + * @param resolver optional TypeResolver for fallback resolution; if null, returns null on failure + * @return the substituted type, or null if resolution fails + */ + public TypeInfo substituteString(String typeString, TypeResolver resolver) { + if (typeString == null || typeString.trim().isEmpty()) { + return null; + } + + String normalized = TypeStringNormalizer.stripImportTypeSyntax(typeString); + normalized = TypeStringNormalizer.pickPreferredUnionBranch(normalized); + normalized = TypeStringNormalizer.stripNullableSuffix(normalized); + + TypeStringNormalizer.ArraySplit arraySplit = TypeStringNormalizer.splitArraySuffixes(normalized); + String baseExpr = arraySplit.base; + int dims = arraySplit.dimensions; + + String bareBase = GenericTypeParser.stripGenerics(baseExpr); + TypeInfo direct = resolveTypeVariable(bareBase); + if (direct != null) { + TypeInfo result = direct; + for (int i = 0; i < dims; i++) { + result = TypeInfo.arrayOf(result); + } + return result; + } + + if (resolver == null) { + return null; + } + TypeInfo resolved = resolver.resolveJSType(typeString); + return substitute(resolved); + } + + /** + * Substitute type variables in a resolved type, with string fallback. + * + * Two-phase approach: + * 1. Try substituting the resolved type directly + * 2. If that fails, attempt substitution via the raw string as fallback + * + * This handles edge cases where the TypeInfo doesn't capture enough information + * to do proper substitution (e.g., union types, complex generics). + * + * @param resolvedType a TypeInfo that has already been resolved (may still contain type variables) + * @param rawTypeString the original type string before resolution (for fallback) + * @param resolver optional TypeResolver for string-based fallback resolution + * @return the substituted type, or the best attempt if full substitution fails + */ + public TypeInfo substituteType(TypeInfo resolvedType, String rawTypeString, TypeResolver resolver) { + if (resolvedType == null) { + return null; + } + + TypeInfo substituted = substitute(resolvedType); + if (substituted != null && substituted.isResolved()) { + return substituted; + } + + if (rawTypeString != null && !rawTypeString.trim().isEmpty()) { + TypeInfo fromString = substituteString(rawTypeString, resolver); + if (fromString != null && fromString.isResolved()) { + return fromString; + } + } + + return substituted; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/GenericParameterAdapter.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/GenericParameterAdapter.java new file mode 100644 index 000000000..cda297a4c --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/GenericParameterAdapter.java @@ -0,0 +1,171 @@ +package noppes.npcs.client.gui.util.script.interpreter.type; + +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.concurrent.BlockingDeque; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.ConcurrentMap; + +/** + * Adapts {@code Object}-typed method parameters to the receiver's generic type arguments + * for editor display (autocomplete/hover). + *

+ * Java collections use {@code Object} in certain method signatures for backward-compatibility + * (e.g., {@code Map.get(Object)} instead of {@code Map.get(K)}). This adapter maps those + * {@code Object} parameters back to the appropriate generic type argument when the receiver + * is parameterized (e.g., {@code Map}). + *

+ * Design rules: + *

    + *
  • Only contract-level checks using {@code java.util.Map}, {@code java.util.Collection}, + * {@code java.util.List} assignability — never concrete classes like HashMap/ArrayList.
  • + *
  • Only adapts when the reflected parameter type is exactly {@code java.lang.Object} + * AND the receiver is parameterized with applied type args.
  • + *
  • Table-driven: each rule is a {@link Rule} record in a static list.
  • + *
+ */ +public final class GenericParameterAdapter { + + // ==================== Rule Model ==================== + + /** + * A single adaptation rule. + * + * @see #RULES + */ + private static final class Rule { + /** The contract interface (e.g., {@code java.util.Map}). */ + final Class contractType; + /** Method name to match. */ + final String methodName; + /** Total parameter count the method must have. */ + final int paramCount; + /** The parameter index to adapt (0-based). */ + final int paramIndex; + /** Index into the receiver's applied type args (0-based). 0=K/E, 1=V, etc. */ + final int typeArgIndex; + + Rule(Class contractType, String methodName, int paramCount, int paramIndex, int typeArgIndex) { + this.contractType = contractType; + this.methodName = methodName; + this.paramCount = paramCount; + this.paramIndex = paramIndex; + this.typeArgIndex = typeArgIndex; + } + } + + // ==================== Rule Table ==================== + + private static final List RULES; + + static { + List rules = new ArrayList<>(); + + // Map + rules.add(new Rule(java.util.Map.class, "get", 1, 0, 0)); + rules.add(new Rule(java.util.Map.class, "containsKey", 1, 0, 0)); + rules.add(new Rule(java.util.Map.class, "containsValue", 1, 0, 1)); + rules.add(new Rule(java.util.Map.class, "remove", 1, 0, 0)); + rules.add(new Rule(java.util.Map.class, "remove", 2, 0, 0)); + rules.add(new Rule(java.util.Map.class, "remove", 2, 1, 1)); + rules.add(new Rule(java.util.Map.class, "getOrDefault", 2, 0, 0)); + + // ConcurrentMap (get/containsKey/containsValue inherited from Map above) + rules.add(new Rule(java.util.concurrent.ConcurrentMap.class, "remove", 2, 0, 0)); + rules.add(new Rule(java.util.concurrent.ConcurrentMap.class, "remove", 2, 1, 1)); + rules.add(new Rule(java.util.concurrent.ConcurrentMap.class, "getOrDefault", 2, 0, 0)); + + // Collection + rules.add(new Rule(java.util.Collection.class, "contains", 1, 0, 0)); + rules.add(new Rule(java.util.Collection.class, "remove", 1, 0, 0)); + + // List (contains/remove covered by Collection above) + rules.add(new Rule(java.util.List.class, "indexOf", 1, 0, 0)); + rules.add(new Rule(java.util.List.class, "lastIndexOf", 1, 0, 0)); + + // Set (contains/remove covered by Collection above) + + // Deque + rules.add(new Rule(java.util.Deque.class, "contains", 1, 0, 0)); + rules.add(new Rule(java.util.Deque.class, "remove", 1, 0, 0)); + rules.add(new Rule(java.util.Deque.class, "removeFirstOccurrence", 1, 0, 0)); + rules.add(new Rule(java.util.Deque.class, "removeLastOccurrence", 1, 0, 0)); + + // BlockingQueue (contains/remove covered by Collection above) + rules.add(new Rule(java.util.concurrent.BlockingQueue.class, "remove", 1, 0, 0)); + rules.add(new Rule(java.util.concurrent.BlockingQueue.class, "contains", 1, 0, 0)); + + // BlockingDeque + rules.add(new Rule(java.util.concurrent.BlockingDeque.class, "remove", 1, 0, 0)); + rules.add(new Rule(java.util.concurrent.BlockingDeque.class, "contains", 1, 0, 0)); + rules.add(new Rule(java.util.concurrent.BlockingDeque.class, "removeFirstOccurrence", 1, 0, 0)); + rules.add(new Rule(java.util.concurrent.BlockingDeque.class, "removeLastOccurrence", 1, 0, 0)); + + RULES = Collections.unmodifiableList(rules); + } + + // ==================== Public API ==================== + + /** + * Attempt to adapt a parameter type from {@code Object} to the receiver's generic type argument. + *

+ * Returns the adapted {@link TypeInfo} if all conditions are met: + *

    + *
  1. The receiver is parameterized and has applied type args.
  2. + *
  3. The parameter's current type is exactly {@code java.lang.Object}.
  4. + *
  5. A matching rule exists in the rule table.
  6. + *
  7. The rule's required type arg index is within bounds.
  8. + *
+ * Otherwise returns {@code null} (meaning: keep the original type). + * + * @param method the reflected Java method + * @param receiverType the parameterized receiver TypeInfo (e.g., {@code Map}) + * @param paramIndex the index of the parameter being checked + * @param currentType the current TypeInfo for that parameter (after normal substitution) + * @return adapted TypeInfo, or {@code null} if no adaptation applies + */ + public static TypeInfo adaptParameterType(Method method, TypeInfo receiverType, + int paramIndex, TypeInfo currentType) { + // Guard: only adapt Object params on parameterized receivers + if (receiverType == null || !receiverType.isParameterized()) { + return null; + } + if (currentType == null || currentType.getJavaClass() != Object.class) { + return null; + } + + List appliedArgs = receiverType.getAppliedTypeArgs(); + if (appliedArgs == null || appliedArgs.isEmpty()) { + return null; + } + + // Determine the declaring class of the method + Class declaringClass = method.getDeclaringClass(); + String methodName = method.getName(); + int paramCount = method.getParameterCount(); + + // Scan rules for a match + for (Rule rule : RULES) { + if (rule.paramIndex != paramIndex) continue; + if (rule.paramCount != paramCount) continue; + if (!rule.methodName.equals(methodName)) continue; + if (!rule.contractType.isAssignableFrom(declaringClass)) continue; + + // Rule matches — check if the type arg index is within bounds + if (rule.typeArgIndex < appliedArgs.size()) { + TypeInfo adapted = appliedArgs.get(rule.typeArgIndex); + if (adapted != null && adapted.isResolved()) { + return adapted; + } + } + } + + return null; + } + + private GenericParameterAdapter() { + // Utility class — no instantiation + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/GenericTypeParser.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/GenericTypeParser.java new file mode 100644 index 000000000..727c85388 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/GenericTypeParser.java @@ -0,0 +1,325 @@ +package noppes.npcs.client.gui.util.script.interpreter.type; + +import java.util.ArrayList; +import java.util.List; + +/** + * Parser for generic type expressions with nested type arguments. + * + * Handles type expressions like: + * - Simple types: "String", "IPlayer" + * - Qualified names: "java.util.List", "IPlayerEvent.InteractEvent" + * - Single generic: "List", "Consumer" + * - Multiple generics: "Map" + * - Nested generics: "List>" + * + * Note: union/nullability/array semantics are handled by higher-level resolvers. + * This parser only consumes suffix tokens where needed to correctly delimit type arguments. + * + * This parser produces a ParsedType tree that can be resolved into parameterized TypeInfo instances. + */ +public class GenericTypeParser { + + /** + * Represents a parsed type expression with potential generic arguments. + */ + public static class ParsedType { + /** The base type name (may be qualified, e.g., "java.util.List" or "IPlayer") */ + public final String baseName; + + /** The applied type arguments (for generics like List), each is itself a ParsedType */ + public final List typeArgs; + + /** The original raw string before parsing */ + public final String rawString; + + public ParsedType(String baseName, List typeArgs, String rawString) { + this.baseName = baseName; + this.typeArgs = typeArgs != null ? typeArgs : new ArrayList<>(); + this.rawString = rawString; + } + + /** + * Check if this parsed type has generic arguments. + */ + public boolean hasTypeArgs() { + return !typeArgs.isEmpty(); + } + + /** + * Get display string for debugging. + */ + @Override + public String toString() { + StringBuilder sb = new StringBuilder(baseName); + if (!typeArgs.isEmpty()) { + sb.append("<"); + for (int i = 0; i < typeArgs.size(); i++) { + if (i > 0) sb.append(", "); + sb.append(typeArgs.get(i).toString()); + } + sb.append(">"); + } + return sb.toString(); + } + } + + /** + * Parse a type expression string into a ParsedType tree. + * + * @param typeExpr The type expression to parse (e.g., "List>[]") + * @return The parsed type, or null if parsing fails + */ + public static ParsedType parse(String typeExpr) { + if (typeExpr == null || typeExpr.isEmpty()) { + return null; + } + + String expr = typeExpr.trim(); + + // Now parse the base type with potential generic arguments + ParseResult result = parseTypeWithGenerics(expr, 0); + if (result == null || result.type == null) { + // Fallback: treat entire expression as a simple type + return new ParsedType(expr, null, typeExpr); + } + + return result.type; + } + + /** + * Internal result class for recursive parsing. + */ + private static class ParseResult { + final ParsedType type; + final int endIndex; // position after this type in the string + + ParseResult(ParsedType type, int endIndex) { + this.type = type; + this.endIndex = endIndex; + } + } + + /** + * Parse a type expression starting at the given index, handling nested generics. + * Returns the parsed type and the index after this type expression. + */ + private static ParseResult parseTypeWithGenerics(String expr, int startIndex) { + int i = startIndex; + int len = expr.length(); + + // Skip leading whitespace + while (i < len && Character.isWhitespace(expr.charAt(i))) { + i++; + } + + if (i >= len) { + return null; + } + + // Read the base type name (can include dots for qualified names) + StringBuilder baseNameBuilder = new StringBuilder(); + while (i < len) { + char c = expr.charAt(i); + if (Character.isJavaIdentifierPart(c) || c == '.') { + baseNameBuilder.append(c); + i++; + } else { + break; + } + } + String baseName = baseNameBuilder.toString().trim(); + + if (baseName.isEmpty()) { + return null; + } + + // Remove trailing dots if any + while (baseName.endsWith(".")) { + baseName = baseName.substring(0, baseName.length() - 1); + } + + // Skip whitespace before potential < + while (i < len && Character.isWhitespace(expr.charAt(i))) { + i++; + } + + // Check for generic arguments + List typeArgs = new ArrayList<>(); + if (i < len && expr.charAt(i) == '<') { + i++; // Skip '<' + + // Parse type arguments (comma-separated, handling nested <>) + while (i < len) { + // Skip whitespace + while (i < len && Character.isWhitespace(expr.charAt(i))) { + i++; + } + + if (i >= len) break; + + char c = expr.charAt(i); + if (c == '>') { + i++; // Skip '>' + break; + } + + if (c == ',') { + i++; // Skip ',' + continue; + } + + // Parse a type argument (may itself have generics) + ParseResult argResult = parseTypeArgument(expr, i); + if (argResult != null && argResult.type != null) { + typeArgs.add(argResult.type); + i = argResult.endIndex; + } else { + // Skip forward until the next ',' or '>' at the current nesting level. + i = skipToNextTypeArgDelimiter(expr, i); + } + } + } + + ParsedType type = new ParsedType(baseName, typeArgs, expr.substring(startIndex, i)); + return new ParseResult(type, i); + } + + /** + * Skip forward until we hit ',' or '>' that would delimit a type argument. + * This prevents producing spurious additional type args when encountering unsupported syntax. + */ + private static int skipToNextTypeArgDelimiter(String expr, int startIndex) { + int i = startIndex; + int depth = 0; + boolean inString = false; + char stringChar = 0; + while (i < expr.length()) { + char c = expr.charAt(i); + if (inString) { + if (c == stringChar && (i == 0 || expr.charAt(i - 1) != '\\')) { + inString = false; + } + i++; + continue; + } + + if (c == '\'' || c == '"') { + inString = true; + stringChar = c; + i++; + continue; + } + + if (c == '<' || c == '(' || c == '[') { + depth++; + } else if (c == '>' || c == ')' || c == ']') { + if (depth > 0) { + depth--; + } else if (c == '>') { + return i; // Let caller handle closing '>' + } + } else if ((c == ',' || c == '>') && depth == 0) { + return i; + } + i++; + } + return i; + } + + /** + * Parse a single type argument, which may include nested generics and array suffixes. + */ + private static ParseResult parseTypeArgument(String expr, int startIndex) { + int i = startIndex; + int len = expr.length(); + + // Skip leading whitespace + while (i < len && Character.isWhitespace(expr.charAt(i))) { + i++; + } + + if (i >= len) { + return null; + } + + // Check for wildcard (? extends X, ? super X, or just ?) + if (expr.charAt(i) == '?') { + i++; + // Skip whitespace + while (i < len && Character.isWhitespace(expr.charAt(i))) { + i++; + } + // Check for "extends" or "super" + if (i < len && expr.substring(i).startsWith("extends ")) { + i += 8; // Skip "extends " + // Parse the bound type + ParseResult boundResult = parseTypeWithGenerics(expr, i); + if (boundResult != null) { + return boundResult; + } + } else if (i < len && expr.substring(i).startsWith("super ")) { + i += 6; // Skip "super " + // Parse the bound type + ParseResult boundResult = parseTypeWithGenerics(expr, i); + if (boundResult != null) { + return boundResult; + } + } + // Plain wildcard, treat as Object + return new ParseResult(new ParsedType("Object", null, "?"), i); + } + + // Parse regular type with potential generics + ParseResult typeResult = parseTypeWithGenerics(expr, i); + if (typeResult == null) { + return null; + } + + i = typeResult.endIndex; + ParsedType baseType = typeResult.type; + + // Skip whitespace + while (i < len && Character.isWhitespace(expr.charAt(i))) { + i++; + } + + // Consume array suffixes / nullable suffix so the caller can correctly find delimiters. + while (i + 1 < len && expr.charAt(i) == '[' && expr.charAt(i + 1) == ']') { + i += 2; + while (i < len && Character.isWhitespace(expr.charAt(i))) { + i++; + } + } + if (i < len && expr.charAt(i) == '?') { + i++; + } + + // Preserve the full raw substring (including suffixes) for higher-level resolvers. + if (i != typeResult.endIndex) { + return new ParseResult(new ParsedType(baseType.baseName, baseType.typeArgs, expr.substring(startIndex, i)), i); + } + + return new ParseResult(baseType, i); + } + + /** + * Convenience method to check if a type string contains generic arguments. + */ + public static boolean hasGenerics(String typeExpr) { + return typeExpr != null && typeExpr.contains("<") && typeExpr.contains(">"); + } + + /** + * Strip generic arguments from a type string (for base type lookup). + * Example: "List" -> "List" + */ + public static String stripGenerics(String typeExpr) { + if (typeExpr == null) return null; + int idx = typeExpr.indexOf('<'); + if (idx > 0) { + return typeExpr.substring(0, idx).trim(); + } + return typeExpr; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/ImportData.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/ImportData.java new file mode 100644 index 000000000..cda544a98 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/ImportData.java @@ -0,0 +1,183 @@ +package noppes.npcs.client.gui.util.script.interpreter.type; + +import noppes.npcs.client.gui.util.script.interpreter.token.Token; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +/** + * Represents a single import statement with all its metadata. + * Tracks the full import path, resolution status, source positions, and references. + */ +public final class ImportData { + + private final String fullPath; // e.g., "java.util.List" or "kamkeel.npcdbc.api.*" + private final String simpleName; // e.g., "List" or null for wildcard + private final boolean isWildcard; // true if ends with .* + private final boolean isStatic; // true if 'import static' + private final int startOffset; // start of 'import' keyword in source + private final int endOffset; // end of import statement (before or at semicolon) + private final int pathStartOffset; // start of the package.Class path + private final int pathEndOffset; // end of the package.Class path (before .*) + + private TypeInfo resolvedType; // null if wildcard or unresolved + private boolean resolved; // whether resolution was attempted and succeeded + + // Track usage count (simpler than tracking individual tokens) + private int usageCount = 0; + + // Track all tokens that reference this import (optional, for detailed analysis) + private final List referencingTokens = new ArrayList<>(); + + public ImportData(String fullPath, String simpleName, boolean isWildcard, boolean isStatic, + int startOffset, int endOffset, int pathStartOffset, int pathEndOffset) { + this.fullPath = fullPath; + this.simpleName = simpleName; + this.isWildcard = isWildcard; + this.isStatic = isStatic; + this.startOffset = startOffset; + this.endOffset = endOffset; + this.pathStartOffset = pathStartOffset; + this.pathEndOffset = pathEndOffset; + this.resolved = false; + } + + // Getters + public String getFullPath() { return fullPath; } + public String getSimpleName() { return simpleName; } + public boolean isWildcard() { return isWildcard; } + public boolean isStatic() { return isStatic; } + public int getStartOffset() { return startOffset; } + public int getEndOffset() { return endOffset; } + public int getPathStartOffset() { return pathStartOffset; } + public int getPathEndOffset() { return pathEndOffset; } + public TypeInfo getResolvedType() { return resolvedType; } + public boolean isResolved() { return resolved; } + + /** + * Set the resolved type information. + */ + public void setResolvedType(TypeInfo typeInfo) { + this.resolvedType = typeInfo; + this.resolved = typeInfo != null && typeInfo.isResolved(); + } + + /** + * Mark this import as resolved (for wildcard imports where we confirm the package exists). + */ + public void markResolved(boolean resolved) { + this.resolved = resolved; + } + + // ==================== REFERENCE TRACKING ==================== + + /** + * Increment the usage count for this import. + * Called during type resolution when this import is used. + */ + public void incrementUsage() { + usageCount++; + } + + /** + * Add a token that references this import. + * Called when a token is created that uses this import's type. + */ + public void addReference(Token token) { + if (token != null && !referencingTokens.contains(token)) { + referencingTokens.add(token); + } + } + + /** + * Get all tokens that reference this import. + */ + public List getReferencingTokens() { + return Collections.unmodifiableList(referencingTokens); + } + + /** + * Check if this import is used (has any references or usages). + */ + public boolean isUsed() { + return usageCount > 0 || !referencingTokens.isEmpty(); + } + + /** + * Get the usage count for this import. + */ + public int getUsageCount() { + return usageCount; + } + + /** + * Get the number of references to this import. + */ + public int getReferenceCount() { + return referencingTokens.size(); + } + + /** + * Clear all references and reset usage count (used when re-tokenizing). + */ + public void clearReferences() { + referencingTokens.clear(); + usageCount = 0; + } + + /** + * Get the package portion of the import path. + * For "java.util.List" returns "java.util" + * For wildcards like "java.util.*" returns "java.util" + */ + public String getPackagePortion() { + if (isWildcard) { + return fullPath; + } + int lastDot = fullPath.lastIndexOf('.'); + return lastDot > 0 ? fullPath.substring(0, lastDot) : ""; + } + + /** + * Get all segments of the import path. + */ + public String[] getPathSegments() { + return fullPath.split("\\."); + } + + /** + * Check if this import could provide the given simple class name. + * For wildcard imports, always returns true (might provide any class). + * For specific imports, checks if the simple name matches. + */ + public boolean couldProvide(String className) { + if (isWildcard) { + return true; + } + return className.equals(simpleName); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("import "); + if (isStatic) sb.append("static "); + sb.append(fullPath); + if (isWildcard) sb.append(".*"); + sb.append(" [").append(resolved ? "resolved" : "unresolved").append("]"); + return sb.toString(); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + ImportData that = (ImportData) o; + return fullPath.equals(that.fullPath) && isWildcard == that.isWildcard && isStatic == that.isStatic; + } + + @Override + public int hashCode() { + return fullPath.hashCode() * 31 + (isWildcard ? 1 : 0) + (isStatic ? 2 : 0); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/NashornBuiltins.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/NashornBuiltins.java new file mode 100644 index 000000000..962b5b11a --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/NashornBuiltins.java @@ -0,0 +1,282 @@ +package noppes.npcs.client.gui.util.script.interpreter.type; + +import noppes.npcs.client.gui.util.script.interpreter.type.synthetic.SyntheticMethod; +import noppes.npcs.client.gui.util.script.interpreter.type.synthetic.SyntheticParameter; +import noppes.npcs.client.gui.util.script.interpreter.type.synthetic.SyntheticTypeBuilder; +import noppes.npcs.client.gui.util.script.interpreter.type.synthetic.SyntheticType; + +import java.util.*; + +/** + * Registry for Nashorn built-in types and global functions. + * + *

Nashorn provides several built-in objects and functions:

+ *
    + *
  • Java - Object for Java interop: type(), extend(), from(), to()
  • + *
  • Packages - Root of package hierarchy for accessing Java packages
  • + *
  • JavaImporter - Creates scope with imported Java packages
  • + *
  • print() - Global print function
  • + *
  • load() - Load and execute a script
  • + *
+ */ +public class NashornBuiltins { + + private static NashornBuiltins instance; + + private final Map builtinTypes = new LinkedHashMap<>(); + private final Map globalFunctions = new LinkedHashMap<>(); + + private NashornBuiltins() { + initializeBuiltins(); + } + + public static NashornBuiltins getInstance() { + if (instance == null) { + instance = new NashornBuiltins(); + } + return instance; + } + + private void initializeBuiltins() { + // ==================== Java object ==================== + SyntheticType javaType = new SyntheticTypeBuilder("Java") + .documentation("Nashorn's Java interop object for accessing Java types and utilities.") + + .addMethod("type") + .parameter("className", "String", "Fully-qualified Java class name") + .returns("java.lang.Class") + .returnsResolved(args -> { + if (args != null && args.length > 0 && args[0] != null) { + String className = args[0]; + // Remove quotes if present + if (className.startsWith("\"") && className.endsWith("\"")) { + className = className.substring(1, className.length() - 1); + } else if (className.startsWith("'") && className.endsWith("'")) { + className = className.substring(1, className.length() - 1); + } + // Try to load the class + TypeInfo resolved = TypeResolver.getInstance().resolve(className); + if (resolved != null && resolved.isResolved()) { + return new ClassTypeInfo(resolved); + } + } + return null; + }) + .documentation("Loads a Java class by its fully-qualified name.\n\n" + + "**Usage:**\n" + + "```javascript\n" + + "var File = Java.type(\"java.io.File\");\n" + + "var file = new File(\"path/to/file\");\n" + + "```\n\n" + + "@param className The fully-qualified Java class name\n" + + "@returns The Java class reference (use with 'new' to create instances)") + .done() + + .addMethod("extend") + .parameter("type", "java.lang.Class", "Java class or interface to extend/implement") + .returns("java.lang.Class") + .documentation("Creates a subclass or implementation of a Java class or interface.\n\n" + + "**Usage:**\n" + + "```javascript\n" + + "var MyRunnable = Java.extend(Java.type(\"java.lang.Runnable\"), {\n" + + " run: function() {\n" + + " print(\"Running!\");\n" + + " }\n" + + "});\n" + + "```\n\n" + + "@param type The Java class or interface to extend\n" + + "@returns A new class that extends/implements the given type") + .done() + + .addMethod("from") + .parameter("javaArray", "Object", "A Java array or Collection") + .returns("Object[]") + .documentation("Converts a Java array or Collection to a JavaScript array.\n\n" + + "**Usage:**\n" + + "```javascript\n" + + "var jsList = Java.from(javaArrayList);\n" + + "jsList.forEach(function(item) { print(item); });\n" + + "```\n\n" + + "@param javaArray A Java array or java.util.Collection\n" + + "@returns A JavaScript array containing the elements") + .done() + + .addMethod("to") + .parameter("jsArray", "Object[]", "A JavaScript array") + .parameter("javaType", "Class", "The target Java array type") + .returns("Object") + .documentation("Converts a JavaScript array to a Java array of the specified type.\n\n" + + "**Usage:**\n" + + "```javascript\n" + + "var jsArray = [1, 2, 3];\n" + + "var intArray = Java.to(jsArray, \"int[]\");\n" + + "```\n\n" + + "@param jsArray A JavaScript array\n" + + "@param javaType The target Java array type (e.g., \"int[]\", \"java.lang.String[]\")\n" + + "@returns A Java array of the specified type") + .done() + + .addMethod("super") + .parameter("object", "Object", "A Java object created via Java.extend()") + .returns("Object") + .documentation("Gets a reference to the super class for calling super methods.\n\n" + + "**Usage:**\n" + + "```javascript\n" + + "var MyList = Java.extend(Java.type(\"java.util.ArrayList\"), {\n" + + " add: function(e) {\n" + + " print(\"Adding: \" + e);\n" + + " return Java.super(this).add(e);\n" + + " }\n" + + "});\n" + + "```\n\n" + + "@param object An extended Java object\n" + + "@returns A reference to call super methods") + .done() + + .addMethod("synchronized") + .parameter("func", "java.util.function.Function", "The function to synchronize") + .parameter("lock", "Object", "The object to synchronize on") + .returns("java.util.function.Function") + .documentation("Wraps a function to execute synchronized on a given object.\n\n" + + "**Usage:**\n" + + "```javascript\n" + + "var syncFunc = Java.synchronized(function() {\n" + + " // Thread-safe code here\n" + + "}, lockObject);\n" + + "```\n\n" + + "@param func The function to synchronize\n" + + "@param lock The object to use as the monitor\n" + + "@returns A synchronized version of the function") + .done() + + .build(); + builtinTypes.put("Java", javaType); + + // ==================== Global print function ==================== + SyntheticType printFunc = new SyntheticTypeBuilder("print") + .addMethod("print") + .parameter("message", "Object", "The message to print") + .returns("void") + .documentation("Prints a message to standard output.\n\n" + + "**Usage:**\n" + + "```javascript\n" + + "print(\"Hello, world!\");\n" + + "print(myObject);\n" + + "```") + .done() + .build(); + globalFunctions.put("print", printFunc.getMethod("print")); + + // ==================== Global load function ==================== + SyntheticType loadFunc = new SyntheticTypeBuilder("load") + .addMethod("load") + .parameter("script", "String", "Path or URL to the script") + .returns("Object") + .documentation("Loads and executes a script file or URL.\n\n" + + "**Usage:**\n" + + "```javascript\n" + + "load(\"./myScript.js\");\n" + + "load(\"http://example.com/script.js\");\n" + + "```\n\n" + + "@param script Path to a local script or URL\n" + + "@returns The result of the script execution") + .done() + .build(); + globalFunctions.put("load", loadFunc.getMethod("load")); + } + + /** + * Get a built-in type by name. + * @param name The type name (e.g., "Java") + * @return The SyntheticType or null if not found + */ + public SyntheticType getBuiltinType(String name) { + return builtinTypes.get(name); + } + + /** + * Check if a name is a built-in type. + */ + public boolean isBuiltinType(String name) { + return builtinTypes.containsKey(name); + } + + /** + * Get a global function by name. + */ + public SyntheticMethod getGlobalFunction(String name) { + return globalFunctions.get(name); + } + + /** + * Check if a name is a global function. + */ + public boolean isGlobalFunction(String name) { + return globalFunctions.containsKey(name); + } + + /** + * Get all built-in type names. + */ + public Set getBuiltinTypeNames() { + return Collections.unmodifiableSet(builtinTypes.keySet()); + } + + /** + * Get all global function names. + */ + public Set getGlobalFunctionNames() { + return Collections.unmodifiableSet(globalFunctions.keySet()); + } + + /** + * Get all built-in types. + */ + public Collection getAllBuiltinTypes() { + return Collections.unmodifiableCollection(builtinTypes.values()); + } + + /** + * Get all global functions as SyntheticTypes. + * Each function is wrapped in its own SyntheticType for the registry. + */ + public Map getAllGlobalFunctions() { + Map result = new LinkedHashMap<>(); + + // Wrap each global function in a minimal SyntheticType + for (Map.Entry entry : globalFunctions.entrySet()) { + String name = entry.getKey(); + SyntheticMethod method = entry.getValue(); + + // Create a synthetic type that just contains this one global function + SyntheticTypeBuilder builder = new SyntheticTypeBuilder(name); + builder.documentation("Global " + name + " function"); + + // Add the method + SyntheticTypeBuilder.MethodBuilder methodBuilder = builder.addMethod(name); + for (SyntheticParameter param : method.parameters) { + methodBuilder.parameter(param.name, param.typeName, param.documentation); + } + methodBuilder.returns(method.returnType); + if (method.documentation != null && !method.documentation.isEmpty()) { + methodBuilder.documentation(method.documentation); + } + methodBuilder.done(); + + result.put(name, builder.build()); + } + + return result; + } + + /** + * Resolve the return type of Java.type() given the class name argument. + */ + public TypeInfo resolveJavaType(String className) { + SyntheticType javaBuiltin = builtinTypes.get("Java"); + if (javaBuiltin != null) { + return javaBuiltin.resolveMethodReturnType("type", new String[]{className}); + } + return null; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/OverloadSelector.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/OverloadSelector.java new file mode 100644 index 000000000..6400a3f9d --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/OverloadSelector.java @@ -0,0 +1,319 @@ +package noppes.npcs.client.gui.util.script.interpreter.type; + +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; + +import java.util.List; + +/** + * Helper class for selecting the best method overload from a list of candidates. + * + * This encapsulates the scoring-based overload selection logic that considers: + * - Exact type matches + * - Numeric promotion compatibility + * - Arity (parameter count) matching + * - Varargs handling + * - Unknown (null) argument types + * + * Lower scores indicate better matches. + */ +public class OverloadSelector { + + // Scoring constants + private static final int ARITY_MISMATCH_BASE = 10000; + private static final int VARARGS_PENALTY = 50; + private static final int UNKNOWN_TYPE_PENALTY = 10; + private static final int COMPATIBLE_TYPE_PENALTY = 5; + private static final int INCOMPATIBLE_TYPE_PENALTY = 100; + + /** + * Select the best overload from a list of candidates based on argument types. + * + * Selection phases: + * 1. Exact match (all types match exactly) + * 2. Numeric promotion match (all args can promote to common param type) + * 3. Scoring-based selection (handles unknown types, varargs, etc.) + * + * @param overloads List of candidate method overloads + * @param argTypes Array of argument types (may contain nulls for unknown types) + * @return The best matching overload, or the first overload if no good match found + */ + public static MethodInfo selectBestOverload(List overloads, TypeInfo[] argTypes) { + if (overloads == null || overloads.isEmpty()) return null; + + int argCount = (argTypes == null) ? 0 : argTypes.length; + + // Fast path: If no arguments provided, try to find zero-arg method + if (argCount == 0) { + for (MethodInfo method : overloads) { + if (method.getParameterCount() == 0) { + return method; + } + } + // Fall back to closest arity + return selectClosestArity(overloads, 0); + } + + // Check if all arg types are known (non-null) + boolean allArgsKnown = true; + for (TypeInfo argType : argTypes) { + if (argType == null) { + allArgsKnown = false; + break; + } + } + + // Phase 1: Try exact match (only when all args known) + if (allArgsKnown) { + MethodInfo exactMatch = findExactMatch(overloads, argTypes, argCount); + if (exactMatch != null) return exactMatch; + } + + // Phase 2: Try numeric promotion match (only when all args known) + if (allArgsKnown) { + MethodInfo numericMatch = findNumericPromotionMatch(overloads, argTypes, argCount); + if (numericMatch != null) return numericMatch; + } + + // Phase 3: Scoring-based selection with arity-first preference + // This handles unknown (null) arg types gracefully and prefers fixed-arity over varargs + return scoringBasedSelection(overloads, argTypes, argCount); + } + + /** + * Find an overload with exact type match for all arguments. + */ + private static MethodInfo findExactMatch(List overloads, TypeInfo[] argTypes, int argCount) { + for (MethodInfo method : overloads) { + if (method.getParameterCount() == argCount) { + boolean exactMatch = true; + List params = method.getParameters(); + for (int i = 0; i < argCount; i++) { + TypeInfo paramType = params.get(i).getTypeInfo(); + TypeInfo argType = argTypes[i]; + if (paramType == null || !paramType.equals(argType)) { + exactMatch = false; + break; + } + } + if (exactMatch) return method; + } + } + return null; + } + + /** + * Find an overload where all numeric arguments can promote to a common parameter type. + * Prefers narrower numeric types (e.g., int over long over double). + */ + private static MethodInfo findNumericPromotionMatch(List overloads, TypeInfo[] argTypes, int argCount) { + MethodInfo bestNumericMatch = null; + int bestNumericRank = Integer.MAX_VALUE; + + for (MethodInfo method : overloads) { + if (method.getParameterCount() == argCount) { + List params = method.getParameters(); + + // Check if all parameters and arguments are numeric primitives + boolean allNumeric = true; + for (int i = 0; i < argCount; i++) { + TypeInfo paramType = params.get(i).getTypeInfo(); + TypeInfo argType = argTypes[i]; + if (paramType == null || + !TypeChecker.isNumericPrimitive(paramType) || !TypeChecker.isNumericPrimitive(argType)) { + allNumeric = false; + break; + } + } + + if (allNumeric) { + // Check if all parameters are the same numeric type + TypeInfo commonParamType = params.get(0).getTypeInfo(); + boolean allParamsSame = true; + for (int i = 1; i < params.size(); i++) { + TypeInfo paramType = params.get(i).getTypeInfo(); + if (!paramType.equals(commonParamType)) { + allParamsSame = false; + break; + } + } + + // If all parameters are the same numeric type, check if args can promote to it + if (allParamsSame) { + boolean canPromote = true; + for (int i = 0; i < argCount; i++) { + if (!TypeChecker.canPromoteNumeric(argTypes[i], commonParamType)) { + canPromote = false; + break; + } + } + + // If all args can promote, check if this is the narrowest match so far + if (canPromote) { + int paramRank = TypeChecker.getNumericRank(commonParamType.getJavaClass()); + if (paramRank < bestNumericRank) { + bestNumericRank = paramRank; + bestNumericMatch = method; + } + } + } + } + } + } + + return bestNumericMatch; + } + + /** + * Use scoring to select the best overload when exact/numeric matches don't apply. + */ + private static MethodInfo scoringBasedSelection(List overloads, TypeInfo[] argTypes, int argCount) { + MethodInfo bestCandidate = null; + int bestScore = Integer.MAX_VALUE; + + for (MethodInfo method : overloads) { + int score = scoreOverload(method, argTypes, argCount); + if (score < bestScore) { + bestScore = score; + bestCandidate = method; + } + } + + return (bestCandidate != null) ? bestCandidate : overloads.get(0); + } + + /** + * Score an overload for matching against provided arguments. + * Lower score = better match. + * + * Scoring priorities: + * - Arity mismatch: +10000 + |paramCount - argCount| + * - Varargs penalty: +1000 + * - Unknown arg type (null): +10 per arg + * - Compatible but not exact: +5 per arg + * - Incompatible type: +100 per arg + * - Exact type match: +0 per arg + * + * @param method The method overload to score + * @param argTypes Array of argument types (may contain nulls) + * @param argCount Number of arguments + * @return Score (lower is better) + */ + public static int scoreOverload(MethodInfo method, TypeInfo[] argTypes, int argCount) { + int score = 0; + int paramCount = method.getParameterCount(); + + // Check if method is varargs + boolean isVarArgs = false; + java.lang.reflect.Method javaMethod = method.getJavaMethod(); + if (javaMethod != null) { + isVarArgs = javaMethod.isVarArgs(); + } else { + // JS methods from .d.ts have no backing Java method; vararg info lives on the last FieldInfo + List checkParams = method.getParameters(); + if (!checkParams.isEmpty()) { + isVarArgs = checkParams.get(checkParams.size() - 1).isVarArg(); + } + } + + // Determine arity applicability + boolean arityApplicable; + if (isVarArgs) { + // Varargs methods accept argCount >= paramCount - 1 + // (the varargs array can be empty or have multiple elements) + arityApplicable = argCount >= paramCount - 1; + } else { + arityApplicable = paramCount == argCount; + } + + if (!arityApplicable) { + // Large penalty for arity mismatch, plus distance to encourage closest match + score += ARITY_MISMATCH_BASE + Math.abs(paramCount - argCount); + } + + // Varargs penalty (fixed-arity preferred over varargs when both apply) + if (isVarArgs) { + score += VARARGS_PENALTY; + } + + // Score each argument's type compatibility + List params = method.getParameters(); + int paramsToCheck = Math.min(argCount, paramCount); + + for (int i = 0; i < paramsToCheck; i++) { + TypeInfo paramType = params.get(i).getTypeInfo(); + TypeInfo argType = (argTypes != null && i < argTypes.length) ? argTypes[i] : null; + + if (argType == null) { + // Unknown arg type - don't disqualify, but add penalty + score += UNKNOWN_TYPE_PENALTY; + } else if (paramType == null) { + // Unknown param type - add penalty + score += UNKNOWN_TYPE_PENALTY; + } else if (paramType.equals(argType)) { + // Exact match - no penalty + score += 0; + } else if (TypeChecker.isTypeCompatible(paramType, argType)) { + // Compatible but not exact + score += COMPATIBLE_TYPE_PENALTY; + } else { + // Incompatible type + score += INCOMPATIBLE_TYPE_PENALTY; + } + } + + // For vararg methods, also score extra args (index >= paramCount) against the element type + if (isVarArgs && argCount > paramCount && !params.isEmpty()) { + TypeInfo varargElemType = params.get(paramCount - 1).getTypeInfo(); + for (int i = paramCount; i < argCount; i++) { + TypeInfo argType = (argTypes != null && i < argTypes.length) ? argTypes[i] : null; + if (argType == null || varargElemType == null) { + score += UNKNOWN_TYPE_PENALTY; + } else if (varargElemType.equals(argType)) { + // exact match + } else if (TypeChecker.isTypeCompatible(varargElemType, argType)) { + score += COMPATIBLE_TYPE_PENALTY; + } else { + score += INCOMPATIBLE_TYPE_PENALTY; + } + } + } + + // Penalize extra args that don't match params (for non-varargs) + if (!isVarArgs && argCount > paramCount) { + score += (argCount - paramCount) * INCOMPATIBLE_TYPE_PENALTY; + } + + return score; + } + + /** + * Select the overload with closest arity to the target. + * Tie-breaker: lower parameter count wins. + * + * @param overloads List of candidate overloads + * @param targetArity The desired number of parameters + * @return The overload with closest arity, or first overload if list is empty + */ + public static MethodInfo selectClosestArity(List overloads, int targetArity) { + if (overloads == null || overloads.isEmpty()) return null; + + MethodInfo best = null; + int bestDistance = Integer.MAX_VALUE; + int bestParamCount = Integer.MAX_VALUE; + + for (MethodInfo method : overloads) { + int paramCount = method.getParameterCount(); + int distance = Math.abs(paramCount - targetArity); + + // Prefer smaller distance; tie-break by lower paramCount + if (distance < bestDistance || (distance == bestDistance && paramCount < bestParamCount)) { + best = method; + bestDistance = distance; + bestParamCount = paramCount; + } + } + + return (best != null) ? best : overloads.get(0); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/ScriptTypeInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/ScriptTypeInfo.java new file mode 100644 index 000000000..0ed37fcdc --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/ScriptTypeInfo.java @@ -0,0 +1,945 @@ +package noppes.npcs.client.gui.util.script.interpreter.type; + +import noppes.npcs.client.gui.util.script.interpreter.field.EnumConstantInfo; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodSignature; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenType; + +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * Represents a type defined within the script itself (not from Java classpath). + * This handles classes, interfaces, and enums declared in the user's script. + * + * Unlike TypeInfo which wraps a Java Class, ScriptTypeInfo stores all metadata + * about fields, methods, and other type information parsed from the script. + */ +public class ScriptTypeInfo extends TypeInfo { + + private final String scriptClassName; + private final int declarationOffset; + private final int bodyStart; + private final int bodyEnd; + private final int modifiers; // Java reflection modifiers (public, static, final, etc.) + + // Script-defined members + private final Map fields = new HashMap<>(); + private final Map> methods = new HashMap<>(); // name -> list of overloads + private final List constructors = new ArrayList<>(); // List of constructors + private final List innerClasses = new ArrayList<>(); + + // Enum constants (for enum types only) - name -> EnumConstantInfo + private final Map enumConstants = new HashMap<>(); + + // Parent class reference (for inner class resolution) + private ScriptTypeInfo outerClass; + + // ==================== INHERITANCE ==================== + + /** + * The parent/super class for this type (from "extends ParentClass"). + * Can be a resolved TypeInfo or ScriptTypeInfo, or unresolved TypeInfo if the parent is not found. + * Null if this type doesn't extend anything (or extends Object implicitly). + */ + private TypeInfo superClass; + + /** + * The raw string name of the super class as written in the script (e.g., "ParentClass"). + * Stored for display purposes even when the type couldn't be resolved. + */ + private String superClassName; + + /** + * All implemented interfaces (from "implements Interface1, Interface2, ..."). + * Each can be resolved or unresolved. The list order matches the declaration order. + */ + private final List implementedInterfaces = new ArrayList<>(); + + /** + * The raw string names of implemented interfaces as written in the script. + * Stored for display purposes even when types couldn't be resolved. + */ + private final List implementedInterfaceNames = new ArrayList<>(); + + private ScriptTypeInfo(String simpleName, String fullName, Kind kind, + int declarationOffset, int bodyStart, int bodyEnd, int modifiers) { + super(simpleName, fullName, "", kind, null, true, null, true); + this.scriptClassName = simpleName; + this.declarationOffset = declarationOffset; + this.bodyStart = bodyStart; + this.bodyEnd = bodyEnd; + this.modifiers = modifiers; + } + + // Factory method + public static ScriptTypeInfo create(String simpleName, Kind kind, + int declarationOffset, int bodyStart, int bodyEnd, int modifiers) { + return new ScriptTypeInfo(simpleName, simpleName, kind, declarationOffset, bodyStart, bodyEnd, modifiers); + } + + public static ScriptTypeInfo createInner(String simpleName, Kind kind, ScriptTypeInfo outer, + int declarationOffset, int bodyStart, int bodyEnd, int modifiers) { + String fullName = outer.getFullName() + "$" + simpleName; + ScriptTypeInfo inner = new ScriptTypeInfo(simpleName, fullName, kind, declarationOffset, bodyStart, bodyEnd, modifiers); + inner.outerClass = outer; + outer.innerClasses.add(inner); + return inner; + } + + // Getters + public String getScriptClassName() { return scriptClassName; } + public int getDeclarationOffset() { return declarationOffset; } + public int getBodyStart() { return bodyStart; } + public int getBodyEnd() { return bodyEnd; } + public int getModifiers() { return modifiers; } + public ScriptTypeInfo getOuterClass() { return outerClass; } + public List getInnerClasses() { return innerClasses; } + + // ==================== INHERITANCE ==================== + + /** + * Get the super class (from "extends"). Can be resolved or unresolved. + * @return The parent class TypeInfo, or null if no extends clause + */ + public TypeInfo getSuperClass() { return superClass; } + + /** + * Get the raw super class name as written in the script. + * @return The super class name string, or null if no extends clause + */ + public String getSuperClassName() { return superClassName; } + + /** + * Set the super class info. Call this after resolving types. + * @param superClass The resolved or unresolved TypeInfo for the parent class + * @param superClassName The raw class name as written in the script + */ + public void setSuperClass(TypeInfo superClass, String superClassName) { + this.superClass = superClass; + this.superClassName = superClassName; + } + + /** + * Check if this type has a super class (extends something). + */ + public boolean hasSuperClass() { return superClass != null || superClassName != null; } + + /** + * Get all implemented interfaces. Each can be resolved or unresolved. + * @return Unmodifiable list of implemented interface TypeInfos + */ + public List getImplementedInterfaces() { + return new ArrayList<>(implementedInterfaces); + } + + /** + * Get the raw interface names as written in the script. + * @return Unmodifiable list of interface name strings + */ + public List getImplementedInterfaceNames() { + return new ArrayList<>(implementedInterfaceNames); + } + + /** + * Add an implemented interface. Call this after resolving types. + * @param interfaceType The resolved or unresolved TypeInfo for the interface + * @param interfaceName The raw interface name as written in the script + */ + public void addImplementedInterface(TypeInfo interfaceType, String interfaceName) { + implementedInterfaces.add(interfaceType); + implementedInterfaceNames.add(interfaceName); + } + + /** + * Check if this type implements any interfaces. + */ + public boolean hasImplementedInterfaces() { return !implementedInterfaces.isEmpty(); } + + /** + * Check if this type implements a specific interface (by simple name). + */ + public boolean implementsInterface(String interfaceName) { + for (String name : implementedInterfaceNames) { + if (name.equals(interfaceName)) return true; + } + for (TypeInfo ti : implementedInterfaces) { + if (ti.getSimpleName().equals(interfaceName)) return true; + } + return false; + } + + /** + * Check if a position is inside this type's body. + */ + public boolean containsPosition(int position) { + return position >= bodyStart && position < bodyEnd; + } + + // ==================== FIELD MANAGEMENT ==================== + + public void addField(FieldInfo field) { + fields.put(field.getName(), field); + } + + @Override + public boolean hasField(String fieldName) { + if (fields.containsKey(fieldName)) + return true; + + if (enumConstants.containsKey(fieldName)) + return true; + + return false; + } + + @Override + public FieldInfo getFieldInfo(String fieldName) { + if (fields.containsKey(fieldName)) + return fields.get(fieldName); + + if (enumConstants.containsKey(fieldName)) { + EnumConstantInfo enumConst = enumConstants.get(fieldName); + if (enumConst != null) + return enumConst.getFieldInfo(); + } + + return null; + } + + public Map getFields() { + return new HashMap<>(fields); + } + + // ==================== ENUM CONSTANT MANAGEMENT ==================== + + /** + * Add an enum constant to this enum type. + * Only valid for enum types. + */ + public void addEnumConstant(EnumConstantInfo constant) { + if (isEnum()) { + enumConstants.put(constant.getFieldInfo().getName(), constant); + } + } + + /** + * Check if this enum has a constant with the given name. + */ + public boolean hasEnumConstant(String constantName) { + return enumConstants.containsKey(constantName); + } + + /** + * Get an enum constant by name. + */ + public EnumConstantInfo getEnumConstant(String constantName) { + return enumConstants.get(constantName); + } + + /** + * Get all enum constants. + */ + public Map getEnumConstants() { + return new HashMap<>(enumConstants); + } + + /** + * Check if this is an enum type and has any constants. + */ + public boolean hasEnumConstants() { + return isEnum() && !enumConstants.isEmpty(); + } + + // ==================== METHOD MANAGEMENT ==================== + + public void addMethod(MethodInfo method) { + methods.computeIfAbsent(method.getName(), k -> new ArrayList<>()).add(method); + } + + @Override + public boolean hasMethod(String methodName) { + return methods.containsKey(methodName); + } + + @Override + public boolean hasMethod(String methodName, int paramCount) { + List overloads = methods.get(methodName); + if (overloads == null) return false; + for (MethodInfo m : overloads) { + if (m.getParameterCount() == paramCount) { + return true; + } + } + return false; + } + + @Override + public MethodInfo getMethodInfo(String methodName) { + List overloads = methods.get(methodName); + return (overloads != null && !overloads.isEmpty()) ? overloads.get(0) : null; + } + + /** + * Get all method overloads with the given name. + */ + public List getAllMethodOverloads(String methodName) { + return methods.getOrDefault(methodName, new ArrayList<>()); + } + + /** + * Get a method with specific parameter count. + */ + public MethodInfo getMethodWithParamCount(String methodName, int paramCount) { + List overloads = methods.get(methodName); + if (overloads == null) return null; + for (MethodInfo m : overloads) { + if (m.getParameterCount() == paramCount) { + return m; + } + } + return null; + } + + public Map> getMethods() { + return new HashMap<>(methods); + } + + public List getAllMethodsFlat() { + List allMethods = new ArrayList<>(); + for (List overloads : methods.values()) { + allMethods.addAll(overloads); + } + return allMethods; + } + + // ==================== CONSTRUCTOR MANAGEMENT ==================== + + public void addConstructor(MethodInfo constructor) { + constructors.add(constructor); + } + + @Override + public List getConstructors() { + return new ArrayList<>(constructors); + } + + @Override + public boolean hasConstructors() { + return !constructors.isEmpty(); + } + + /** + * Find the best matching constructor for the given argument count. + * Returns null if no constructor matches. + */ + @Override + public MethodInfo findConstructor(int argCount) { + for (MethodInfo constructor : constructors) { + if (constructor.getParameterCount() == argCount) { + return constructor; + } + } + return null; + } + + public MethodInfo findConstructor(TypeInfo[] argTypes) { + for (MethodInfo constructor : constructors) { + if (constructor.getParameterCount() == argTypes.length) { + boolean match = true; + List params = constructor.getParameters(); + for (int i = 0; i < argTypes.length; i++) { + TypeInfo paramType = params.get(i).getTypeInfo(); + if (!TypeChecker.isTypeCompatible(paramType, argTypes[i])) { + match = false; + break; + } + } + if (match) + return constructor; + } + } + return null; + } + + // ==================== INHERITANCE HIERARCHY SEARCH ==================== + + /** + * Check if this type or any of its parent classes has a field with the given name. + * This recursively searches up the inheritance tree. + */ + public boolean hasFieldInHierarchy(String fieldName) { + // Check this class first + if (hasField(fieldName)) { + return true; + } + + // Check parent class recursively + if (superClass != null && superClass.isResolved()) { + if (superClass instanceof ScriptTypeInfo) { + return ((ScriptTypeInfo) superClass).hasFieldInHierarchy(fieldName); + } else { + // For Java classes, hasField already checks inheritance via reflection + return superClass.hasField(fieldName); + } + } + + return false; + } + + /** + * Get field info from this type or any of its parent classes. + * This recursively searches up the inheritance tree. + */ + public FieldInfo getFieldInfoInHierarchy(String fieldName) { + // Check this class first + FieldInfo field = getFieldInfo(fieldName); + if (field != null) { + return field; + } + + // Check parent class recursively + if (superClass != null && superClass.isResolved()) { + if (superClass instanceof ScriptTypeInfo) { + return ((ScriptTypeInfo) superClass).getFieldInfoInHierarchy(fieldName); + } else { + // For Java classes, getFieldInfo already checks inheritance via reflection + return superClass.getFieldInfo(fieldName); + } + } + + return null; + } + + /** + * Check if this type or any of its parent classes has a method with the given name. + * This recursively searches up the inheritance tree. + */ + public boolean hasMethodInHierarchy(String methodName) { + // Check this class first + if (hasMethod(methodName)) { + return true; + } + + // Check parent class recursively + if (superClass != null && superClass.isResolved()) { + if (superClass instanceof ScriptTypeInfo) { + return ((ScriptTypeInfo) superClass).hasMethodInHierarchy(methodName); + } else { + // For Java classes, hasMethod already checks inheritance via reflection + return superClass.hasMethod(methodName); + } + } + + return false; + } + + /** + * Check if this type or any of its parent classes has a method with the given name and parameter count. + * This recursively searches up the inheritance tree. + */ + public boolean hasMethodInHierarchy(String methodName, int paramCount) { + // Check this class first + if (hasMethod(methodName, paramCount)) { + return true; + } + + // Check parent class recursively + if (superClass != null && superClass.isResolved()) { + if (superClass instanceof ScriptTypeInfo) { + return ((ScriptTypeInfo) superClass).hasMethodInHierarchy(methodName, paramCount); + } else { + // For Java classes, hasMethod already checks inheritance via reflection + return superClass.hasMethod(methodName, paramCount); + } + } + + return false; + } + + /** + * Get method info from this type or any of its parent classes. + * This recursively searches up the inheritance tree. + */ + public MethodInfo getMethodInfoInHierarchy(String methodName) { + // Check this class first + MethodInfo method = getMethodInfo(methodName); + if (method != null) { + return method; + } + + // Check parent class recursively + if (superClass != null && superClass.isResolved()) { + if (superClass instanceof ScriptTypeInfo) { + return ((ScriptTypeInfo) superClass).getMethodInfoInHierarchy(methodName); + } else { + // For Java classes, getMethodInfo already checks inheritance via reflection + return superClass.getMethodInfo(methodName); + } + } + + return null; + } + + /** + * Get method info with specific parameter count from this type or any of its parent classes. + * This recursively searches up the inheritance tree. + */ + public MethodInfo getMethodWithParamCountInHierarchy(String methodName, int paramCount) { + // Check this class first + MethodInfo method = getMethodWithParamCount(methodName, paramCount); + if (method != null) { + return method; + } + + // Check parent class recursively + if (superClass != null && superClass.isResolved()) { + if (superClass instanceof ScriptTypeInfo) { + return ((ScriptTypeInfo) superClass).getMethodWithParamCountInHierarchy(methodName, paramCount); + } else { + // For Java classes, reflection already handles inheritance + // We need to manually search for matching method + List overloads = superClass.getAllMethodOverloads(methodName); + for (MethodInfo m : overloads) { + if (m.getParameterCount() == paramCount) { + return m; + } + } + } + } + + return null; + } + + /** + * Get all method overloads with the given name from this type or any of its parent classes. + * This recursively searches up the inheritance tree and returns all matching overloads. + */ + public List getAllMethodOverloadsInHierarchy(String methodName) { + List result = new ArrayList<>(); + + // Get overloads from this class + result.addAll(getAllMethodOverloads(methodName)); + + // Get overloads from parent class recursively + if (superClass != null && superClass.isResolved()) { + if (superClass instanceof ScriptTypeInfo) { + result.addAll(((ScriptTypeInfo) superClass).getAllMethodOverloadsInHierarchy(methodName)); + } else { + // For Java classes, getAllMethodOverloads already checks inheritance via reflection + result.addAll(superClass.getAllMethodOverloads(methodName)); + } + } + + return result; + } + + /** + * Override getBestMethodOverload to search the inheritance hierarchy. + * This ensures that method overload resolution considers parent class methods. + */ + @Override + public MethodInfo getBestMethodOverload(String methodName, TypeInfo[] argTypes) { + // Get all overloads from this class and parent classes + List allOverloads = getAllMethodOverloadsInHierarchy(methodName); + if (allOverloads.isEmpty()) + return null; + + // If no arguments provided, try to find zero-arg method + if (argTypes == null || argTypes.length == 0) { + for (MethodInfo method : allOverloads) { + if (method.getParameterCount() == 0) { + return method; + } + } + // Fall back to first overload if no zero-arg found + return allOverloads.get(0); + } + + // Phase 1: Try exact match + for (MethodInfo method : allOverloads) { + if (method.getParameterCount() == argTypes.length) { + boolean exactMatch = true; + List params = method.getParameters(); + for (int i = 0; i < argTypes.length; i++) { + TypeInfo paramType = params.get(i).getTypeInfo(); + TypeInfo argType = argTypes[i]; + if (paramType == null || argType == null || !paramType.equals(argType)) { + exactMatch = false; + break; + } + } + if (exactMatch) + return method; + } + } + + // Phase 2: Try compatible type match (assignability) + for (MethodInfo method : allOverloads) { + if (method.getParameterCount() == argTypes.length) { + boolean compatible = true; + List params = method.getParameters(); + for (int i = 0; i < argTypes.length; i++) { + TypeInfo paramType = params.get(i).getTypeInfo(); + TypeInfo argType = argTypes[i]; + if (paramType == null || argType == null) { + continue; // Allow null types (unresolved) + } + // Check if argType can be assigned to paramType + if (!noppes.npcs.client.gui.util.script.interpreter.type.TypeChecker.isTypeCompatible(paramType, + argType)) { + compatible = false; + break; + } + } + if (compatible) + return method; + } + } + + // Phase 3: Fall back to first overload with matching parameter count + for (MethodInfo method : allOverloads) { + if (method.getParameterCount() == argTypes.length) { + return method; + } + } + + // No match found, return first overload + return allOverloads.get(0); + } + + /** + * Override getBestMethodOverload with return type expectation to search the inheritance hierarchy. + */ + @Override + public MethodInfo getBestMethodOverload(String methodName, TypeInfo expectedReturnType) { + List allOverloads = getAllMethodOverloadsInHierarchy(methodName); + if (allOverloads.isEmpty()) + return null; + + // If no expected return type, return first overload + if (expectedReturnType == null) { + return allOverloads.get(0); + } + + // First pass: look for return type compatible overload + for (MethodInfo method : allOverloads) { + TypeInfo returnType = method.getReturnType(); + if (returnType != null && noppes.npcs.client.gui.util.script.interpreter.type.TypeChecker.isTypeCompatible( + expectedReturnType, returnType)) { + return method; + } + } + // Second pass: return any overload (first one) + return allOverloads.get(0); + } + + // ==================== INNER CLASS LOOKUP ==================== + + /** + * Get the dot-separated display name for this type. + * Top-level: "MyClass" + * Inner: "Outer.Inner" + * Deeply nested: "Outer.Middle.Inner" + * + * This is what users write in type annotations and what resolveType() should accept. + * Recursively walks the outerClass chain to build the full user-facing qualified name. + */ + public String getDotSeparatedName() { + if (outerClass == null) { + return getSimpleName(); + } + // Recurse up the nesting hierarchy: each level prepends "Parent." to the name + return outerClass.getDotSeparatedName() + "." + getSimpleName(); + } + + /** + * Find an inner class by name. + */ + public ScriptTypeInfo getInnerClass(String name) { + for (ScriptTypeInfo inner : innerClasses) { + if (inner.getSimpleName().equals(name)) { + return inner; + } + } + return null; + } + + // Script types are always considered resolved since they're defined in the script + @Override + public boolean isResolved() { + return true; + } + + // Script types don't have a Java class + @Override + public Class getJavaClass() { + return null; + } + + @Override + public String toString() { + return "ScriptTypeInfo{" + scriptClassName + ", " + getKind() + + ", fields=" + fields.size() + ", methods=" + methods.size() + "}"; + } + + // ==================== ERROR HANDLING ==================== + + /** + * Error types for ScriptTypeInfo validation. + */ + public enum ErrorType { + NONE, + MISSING_INTERFACE_METHOD, // Class doesn't implement all interface methods + MISSING_CONSTRUCTOR_MATCH, // Class extends parent but has no matching constructor + UNRESOLVED_PARENT, // Parent class cannot be resolved + UNRESOLVED_INTERFACE // Implemented interface cannot be resolved + } + + /** + * Represents a missing interface method error. + */ + + // Error tracking + private ErrorType errorType = ErrorType.NONE; + private String errorMessage; + private final List missingMethodErrors = new ArrayList<>(); + private final List constructorMismatchErrors = new ArrayList<>(); + + // Error getters + public ErrorType getErrorType() { return errorType; } + public String getErrorMessage() { return errorMessage; } + public boolean hasError() { return errorType != ErrorType.NONE || !missingMethodErrors.isEmpty() || !constructorMismatchErrors.isEmpty(); } + public List getMissingMethodErrors() { return new ArrayList<>(missingMethodErrors); } + public List getConstructorMismatchErrors() { return new ArrayList<>(constructorMismatchErrors); } + + /** + * Set a general error on this type. + */ + public void setError(ErrorType type, String message) { + this.errorType = type; + this.errorMessage = message; + } + + /** + * Add a missing interface method error. + */ + public void addMissingMethodError(TypeInfo interfaceType, String signature) { + missingMethodErrors.add(new MissingMethodError(interfaceType, signature)); + } + + /** + * Add a constructor mismatch error. + */ + public void addConstructorMismatchError(TypeInfo parentType, String parentConstructorSignature) { + constructorMismatchErrors.add(new ConstructorMismatchError(parentType, parentConstructorSignature)); + } + + /** + * Clear all errors on this type. + */ + public void clearErrors() { + errorType = ErrorType.NONE; + errorMessage = null; + missingMethodErrors.clear(); + constructorMismatchErrors.clear(); + } + + public static class MissingMethodError { + private final TypeInfo interfaceType; + private final String signature; + + public MissingMethodError(TypeInfo interfaceType, String signature) { + this.interfaceType = interfaceType; + this.signature = signature; + } + + public String getMessage() { + return "Class must implement method '" + signature + "' from interface " + interfaceType.getSimpleName(); + } + } + + /** + * Represents a constructor mismatch error. + */ + public static class ConstructorMismatchError { + private final TypeInfo parentType; + private final String parentConstructorSignature; + + public ConstructorMismatchError(TypeInfo parentType, String parentConstructorSignature) { + this.parentType = parentType; + this.parentConstructorSignature = parentConstructorSignature; + } + + public String getMessage() { + return "Class extends " + parentType.getSimpleName() + " but has no constructor matching " + parentConstructorSignature; + } + } + + // ==================== VALIDATION ==================== + + /** + * Validate this script type for missing interface methods and constructor matching. + */ + @Override + public void validate() { + // Check that extending class has a matching constructor + if (hasSuperClass()) { + TypeInfo superClass = getSuperClass(); + if (superClass == null || !superClass.isResolved()) { + setError(ErrorType.UNRESOLVED_PARENT, + "Cannot resolve parent class " + getSuperClassName()); + } else { + validateConstructorChain(superClass); + } + } + + // Skip validation for interfaces - they don't implement methods + if (getKind() == Kind.INTERFACE) + return; + + // Check that all interface methods are implemented + if (hasImplementedInterfaces()) { + for (TypeInfo iface : getImplementedInterfaces()) { + if (iface == null || !iface.isResolved()) { + // Mark unresolved interface error + setError(ErrorType.UNRESOLVED_INTERFACE, "Cannot resolve interface"); + continue; + } + validateInterfaceImplementation(iface); + } + } + } + + /** + * Validate that this script type implements all methods from an interface. + */ + private void validateInterfaceImplementation(TypeInfo iface) { + // Handle Java interfaces + Class javaClass = iface.getJavaClass(); + if (javaClass != null && javaClass.isInterface()) { + try { + for (Method javaMethod : javaClass.getMethods()) { + // Skip static and default methods + if (Modifier.isStatic(javaMethod.getModifiers())) + continue; + + // Check if this type has a matching method + String methodName = javaMethod.getName(); + int paramCount = javaMethod.getParameterCount(); + + boolean found = false; + List overloads = getAllMethodOverloads(methodName); + for (MethodInfo method : overloads) { + if (parameterTypesMatch(method, javaMethod)) { + found = true; + break; + } + } + + //Limit to one error at a time to not spam all missing methods + if (!found && missingMethodErrors.isEmpty()) + addMissingMethodError(iface, MethodSignature.asString(javaMethod)); + } + } catch (Exception e) { + } + return; + } + + // Handle script-defined interfaces (ScriptType) + if (iface instanceof ScriptTypeInfo) { + ScriptTypeInfo ifaceType = (ScriptTypeInfo) iface; + + // Check all methods declared in the interface + for (MethodInfo ifaceMethod : ifaceType.getAllMethodsFlat()) { + MethodSignature ifaceSignature = ifaceMethod.getSignature(); + String methodName = ifaceMethod.getName(); + + boolean found = false; + List overloads = getAllMethodOverloads(methodName); + for (MethodInfo method : overloads) { + if (method.getSignature().equals(ifaceSignature)) { + found = true; + break; + } + } + + //Limit to one error at a time to not spam all missing methods + if (!found && missingMethodErrors.isEmpty()) + addMissingMethodError(iface, ifaceSignature.toString()); + } + } + } + + /** + * Validate that this script type has a constructor compatible with its parent class. + * This checks that for each parent constructor, there's a matching constructor in the child. + */ + private void validateConstructorChain(TypeInfo superClass) { + // If no constructors defined in script type, it has an implicit default constructor + // Check if parent has a no-arg constructor + if (!hasConstructors()) { + boolean parentHasNoArg = false; + + if (superClass instanceof ScriptTypeInfo) { + ScriptTypeInfo parentScript = (ScriptTypeInfo) superClass; + if (!parentScript.hasConstructors() || parentScript.findConstructor(0) != null) { + parentHasNoArg = true; + } + } else { + Class javaClass = superClass.getJavaClass(); + if (javaClass != null) { + try { + for (java.lang.reflect.Constructor ctor : javaClass.getConstructors()) { + if (ctor.getParameterCount() == 0) { + parentHasNoArg = true; + break; + } + } + } catch (Exception e) { + // Security error + } + } + } + + if (!parentHasNoArg) { + addConstructorMismatchError(superClass, superClass.getSimpleName()); + } + } + // If script type has constructors, we'd need to check super() calls - that's more complex + // For now, we just validate the implicit default constructor case + } + + /** + * Check if a MethodInfo's parameter types match a Java reflection Method's parameter types. + */ + private boolean parameterTypesMatch(MethodInfo methodInfo, Method javaMethod) { + List params = methodInfo.getParameters(); + Class[] javaParams = javaMethod.getParameterTypes(); + + if (params.size() != javaParams.length) + return false; + + for (int i = 0; i < params.size(); i++) { + TypeInfo paramType = params.get(i).getTypeInfo(); + if (paramType == null) + continue; // Unresolved param, skip check + + Class javaParamClass = javaParams[i]; + String javaParamName = javaParamClass.getName(); + + // Compare type names + if (!paramType.getFullName().equals(javaParamName) && + !paramType.getSimpleName().equals(javaParamClass.getSimpleName())) { + return false; + } + } + + return true; + } +} \ No newline at end of file diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/TypeChecker.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/TypeChecker.java new file mode 100644 index 000000000..a9516f3e5 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/TypeChecker.java @@ -0,0 +1,566 @@ +package noppes.npcs.client.gui.util.script.interpreter.type; + +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeInfo; + +import java.util.HashSet; +import java.util.Set; + +/** + * Utility class for checking type compatibility between types. + * Handles primitive widening conversions, boxing/unboxing, and inheritance. + */ +public final class TypeChecker { + + private TypeChecker() {} // Utility class + + private static boolean CURRENT_JAVASCRIPT_MODE; + + public static void enterTypeCheckingContext(boolean javaScriptMode) { + CURRENT_JAVASCRIPT_MODE = javaScriptMode; + } + + static boolean isJavaScriptMode() { + return CURRENT_JAVASCRIPT_MODE; + } + + /** + * Check if the actual type is compatible with (assignable to) the expected type. + * @param expected The expected/target type + * @param actual The actual/source type + * @return true if actual can be assigned to expected + */ + public static boolean isTypeCompatible(TypeInfo expected, TypeInfo actual) { + if (expected == null) return true; // void can accept anything (shouldn't happen) + if (actual == null) return true; // Can't verify, assume compatible + + // Handle array types: compatible if element types are compatible + if (expected.isArray() && actual.isArray()) { + TypeInfo expectedElement = expected.getElementType(); + TypeInfo actualElement = actual.getElementType(); + if (expectedElement != null && actualElement != null) + return isTypeCompatible(expectedElement, actualElement); + } + + // Script method reference placeholder: only compatible with functional interface params. + // Used to help overload selection choose SAM overloads in JavaScript. + if ("__script_method_ref__".equals(actual.getFullName())) { + return expected.isFunctionalInterface(); + } + + // Handle "any" type - universally compatible (JavaScript/TypeScript) + if ("any".equals(expected.getFullName()) || "any".equals(actual.getFullName())) { + return true; + } + + if (isJavaScriptMode()) { + // Treat java.lang.Object as "any", universally compatible + if ("Object".equals(expected.getSimpleName()) || "Object".equals(actual.getSimpleName()) ) + return true; + + // Treat String as universally compatible, since JavaScript string literals can be assigned to String + // parameters and String is commonly used as a catch-all type in JS APIs + if("String".equals(expected.getSimpleName())) + return true; + } + + // Handle null literal - null is compatible with any reference type (non-primitive) + if ("".equals(actual.getFullName())) { + Class expectedClass = expected.getJavaClass(); + if (expectedClass != null && !expectedClass.isPrimitive() || "".equals(expected.getFullName())) { + return true; // null can be assigned to any reference type and null + } + // null cannot be assigned to primitive types + return false; + } + + String expectedName = expected.getSimpleName(); + String actualName = actual.getSimpleName(); + + if (expectedName == null || actualName == null) return true; + + // Exact match by simple name + if (expectedName.equals(actualName)) return true; + + // Exact match by full name + if (expected.getFullName() != null && actual.getFullName() != null) { + if (expected.getFullName().equals(actual.getFullName())) return true; + } + + // Primitive widening conversions + if ("number".equals(expectedName) && isNumericType(actualName)) { + return true; + } + if ("number".equals(actualName) && isNumericType(expectedName)) { + return true; + } + if (isNumericType(expectedName) && isNumericType(actualName)) { + if (isJavaScriptMode()) return true; + return canWiden(actualName, expectedName); + } + + // JS/.d.ts type compatibility (check inheritance chain from actual -> parent) + if (expected.isJSType() && actual.isJSType()) { + if (isJSTypeAssignableFrom(expected.getJSTypeInfo(), actual.getJSTypeInfo())) { + return true; + } + } + + // Object type compatibility (check inheritance) + if (expected.getJavaClass() != null && actual.getJavaClass() != null) { + Class expectedClass = expected.getJavaClass(); + Class actualClass = actual.getJavaClass(); + + // Direct assignability + if (expectedClass.isAssignableFrom(actualClass)) { + return true; + } + + // Primitive widening with Class objects + if (isPrimitiveWidening(actualClass, expectedClass)) { + return true; + } + + // Boxing/unboxing compatibility + if (isBoxingCompatible(actualClass, expectedClass)) { + return true; + } + } + + // Allow boxed/unboxed conversions by name + if (isPrimitiveOrWrapper(expectedName) && isPrimitiveOrWrapper(actualName)) { + return getUnboxedName(expectedName).equals(getUnboxedName(actualName)); + } + + return false; + } + + /** + * Check assignability for JS/.d.ts types by walking the resolved parent chain. + */ + private static boolean isJSTypeAssignableFrom(JSTypeInfo expected, JSTypeInfo actual) { + if (expected == null || actual == null) { + return false; + } + + Set visited = new HashSet<>(); + JSTypeInfo current = actual; + while (current != null) { + String currentFullName = current.getFullName(); + if (currentFullName == null || !visited.add(currentFullName)) { + break; + } + + if (expected.getFullName() != null && expected.getFullName().equals(currentFullName)) { + return true; + } + + current = current.getResolvedParent(); + } + + return false; + } + + /** + * Check if the type is a numeric type (including wrappers). + */ + public static boolean isNumericType(String typeName) { + switch (typeName) { + case "number": + case "byte": case "Byte": + case "short": case "Short": + case "int": case "Integer": + case "long": case "Long": + case "float": case "Float": + case "double": case "Double": + case "char": case "Character": + return true; + default: + return false; + } + } + + /** + * Check if a primitive type can be widened to another type. + * Follows Java's widening primitive conversion rules. + */ + public static boolean canWiden(String from, String to) { + int fromRank = getNumericRank(from); + int toRank = getNumericRank(to); + return fromRank <= toRank; + } + + /** + * Get the numeric rank for primitive widening conversion. + * Higher rank can accept lower ranks. + */ + public static int getNumericRank(String typeName) { + switch (getUnboxedName(typeName)) { + case "byte": return 1; + case "short": case "char": return 2; + case "int": return 3; + case "long": return 4; + case "float": return 5; + case "number": + case "double": return 6; + default: return 0; + } + } + + /** + * Check if a type is a numeric primitive (byte, short, int, long, float, double) + */ + public static boolean isNumericPrimitive(TypeInfo type) { + if (type == null || type.getJavaClass() == null) return false; + Class cls = type.getJavaClass(); + return cls == byte.class || cls == Byte.class || + cls == short.class || cls == Short.class || + cls == int.class || cls == Integer.class || + cls == long.class || cls == Long.class || + cls == float.class || cls == Float.class || + cls == double.class || cls == Double.class; + } + + /** + * Check if a numeric type can be promoted to a target numeric type. + * Follows Java's numeric promotion hierarchy: byte -> short -> int -> long -> float -> double + */ + public static boolean canPromoteNumeric(TypeInfo from, TypeInfo to) { + if (from == null || to == null || from.getJavaClass() == null || to.getJavaClass() == null) return false; + + Class fromClass = from.getJavaClass(); + Class toClass = to.getJavaClass(); + + // Unbox if necessary + if (fromClass == Byte.class) fromClass = byte.class; + if (fromClass == Short.class) fromClass = short.class; + if (fromClass == Integer.class) fromClass = int.class; + if (fromClass == Long.class) fromClass = long.class; + if (fromClass == Float.class) fromClass = float.class; + if (fromClass == Double.class) fromClass = double.class; + + if (toClass == Byte.class) toClass = byte.class; + if (toClass == Short.class) toClass = short.class; + if (toClass == Integer.class) toClass = int.class; + if (toClass == Long.class) toClass = long.class; + if (toClass == Float.class) toClass = float.class; + if (toClass == Double.class) toClass = double.class; + + // Get numeric ranks (higher = wider type) + int fromRank = getNumericRank(fromClass); + int toRank = getNumericRank(toClass); + + return fromRank >= 0 && toRank >= 0 && fromRank <= toRank; + } + + /** + * Get the numeric rank for promotion hierarchy. + * byte=0, short=1, int=2, long=3, float=4, double=5 + */ + public static int getNumericRank(Class cls) { + if (cls == byte.class) return 0; + if (cls == short.class) return 1; + if (cls == int.class) return 2; + if (cls == long.class) return 3; + if (cls == float.class) return 4; + if (cls == double.class) return 5; + return -1; + } + + + /** + * Check if the type name is a primitive or its wrapper type. + */ + public static boolean isPrimitiveOrWrapper(String typeName) { + switch (typeName) { + case "byte": case "Byte": + case "short": case "Short": + case "int": case "Integer": + case "long": case "Long": + case "float": case "Float": + case "double": case "Double": + case "char": case "Character": + case "boolean": case "Boolean": + return true; + default: + return false; + } + } + + /** + * Get the primitive type name from a wrapper type name. + * Returns the input unchanged if already primitive or not a wrapper. + */ + public static String getUnboxedName(String typeName) { + switch (typeName) { + case "Byte": return "byte"; + case "Short": return "short"; + case "Integer": return "int"; + case "Long": return "long"; + case "Float": return "float"; + case "Double": return "double"; + case "Character": return "char"; + case "Boolean": return "boolean"; + default: return typeName; + } + } + + /** + * Get the wrapper type name from a primitive type name. + * Returns the input unchanged if already a wrapper or not a primitive. + */ + public static String getBoxedName(String typeName) { + switch (typeName) { + case "byte": return "Byte"; + case "short": return "Short"; + case "int": return "Integer"; + case "long": return "Long"; + case "float": return "Float"; + case "double": return "Double"; + case "char": return "Character"; + case "boolean": return "Boolean"; + default: return typeName; + } + } + + /** + * Check if the type name represents a void type. + */ + public static boolean isVoidType(String typeName) { + return typeName == null || typeName.equals("void") || typeName.equals("Void"); + } + + /** + * Check if the type represents a void type. + */ + public static boolean isVoidType(TypeInfo type) { + if (type == null) return true; + return isVoidType(type.getSimpleName()); + } + + /** + * Check for primitive widening conversions. + * byte -> short -> int -> long -> float -> double + * char -> int -> long -> float -> double + */ + private static boolean isPrimitiveWidening(Class from, Class to) { + if (!from.isPrimitive() || !to.isPrimitive()) { + return false; + } + + if (from == byte.class) { + return to == short.class || to == int.class || to == long.class || + to == float.class || to == double.class; + } + if (from == short.class || from == char.class) { + return to == int.class || to == long.class || to == float.class || to == double.class; + } + if (from == int.class) { + return to == long.class || to == float.class || to == double.class; + } + if (from == long.class) { + return to == float.class || to == double.class; + } + if (from == float.class) { + return to == double.class; + } + return false; + } + + /** + * Check for boxing/unboxing compatibility. + */ + private static boolean isBoxingCompatible(Class from, Class to) { + if (from.isPrimitive()) { + Class wrapper = getWrapperClassInternal(from); + if (wrapper != null && to.isAssignableFrom(wrapper)) { + return true; + } + } + if (to.isPrimitive()) { + Class wrapper = getWrapperClassInternal(to); + if (wrapper != null && wrapper.isAssignableFrom(from)) { + return true; + } + } + return false; + } + + /** + * Get the wrapper class for a primitive type. + */ + private static Class getWrapperClassInternal(Class primitive) { + if (primitive == boolean.class) return Boolean.class; + if (primitive == byte.class) return Byte.class; + if (primitive == char.class) return Character.class; + if (primitive == short.class) return Short.class; + if (primitive == int.class) return Integer.class; + if (primitive == long.class) return Long.class; + if (primitive == float.class) return Float.class; + if (primitive == double.class) return Double.class; + return null; + } + + /** + * Attempt to narrow an integer literal to byte, short, or char when the + * expected type requires it. The expression resolver normally infers integer + * literals as {@code int}; this helper allows callers to re-type a literal + * when {@code ExpressionTypeResolver.CURRENT_EXPECTED_TYPE} is set (e.g. + * method-argument second pass or assignment RHS). + * + *

Supported literal formats:

+ *
    + *
  • Decimal: {@code 42}, {@code -128}, {@code +127}
  • + *
  • Hexadecimal: {@code 0xFF}, {@code 0XAB}
  • + *
  • Binary: {@code 0b1010}, {@code 0B1111_0000}
  • + *
  • Underscores as digit separators: {@code 1_000}
  • + *
  • Optional trailing {@code l}/{@code L} suffix (stripped before parsing)
  • + *
+ * + *

Range checks:

+ *
    + *
  • byte: [-128 .. 127]
  • + *
  • short: [-32768 .. 32767]
  • + *
  • char: [0 .. 65535]
  • + *
+ * + * @param literalText the raw text of the integer literal (e.g. {@code "0xFF"}) + * @param expectedType the target type at the call/assignment site + * @return a {@link TypeInfo} for the narrowed primitive type, or {@code null} + * if the expected type is not byte/short/char, the literal is not a + * valid integer, or the value falls outside the target range + */ + public static TypeInfo narrowLiteralToExpectedType(String literalText, TypeInfo expectedType) { + if (literalText == null || literalText.isEmpty() || expectedType == null) { + return null; + } + + // Determine the narrowing target from the expected type + String expectedSimple = expectedType.getSimpleName(); + if (expectedSimple == null) { + return null; + } + String unboxed = getUnboxedName(expectedSimple); + if (!"byte".equals(unboxed) && !"short".equals(unboxed) && !"char".equals(unboxed)) { + return null; // Only narrow to byte, short, or char + } + + // Parse the literal value + Long value = parseIntegerLiteral(literalText); + if (value == null) { + return null; + } + + // Range check for the target type + long v = value; + switch (unboxed) { + case "byte": + if (v < -128 || v > 127) return null; + break; + case "short": + if (v < -32768 || v > 32767) return null; + break; + case "char": + if (v < 0 || v > 65535) return null; + break; + default: + return null; + } + + return TypeInfo.fromPrimitive(unboxed); + } + + /** + * Parse an integer literal string into a {@code Long} value. + * Supports decimal, hexadecimal (0x/0X), and binary (0b/0B) formats, + * optional leading sign (+/-), underscores as digit separators, + * and an optional trailing l/L suffix. + * + * @param text the raw literal text + * @return the parsed value, or {@code null} on parse failure + */ + private static Long parseIntegerLiteral(String text) { + String s = text.trim(); + if (s.isEmpty()) { + return null; + } + + // Determine sign + boolean negative = false; + if (s.charAt(0) == '-') { + negative = true; + s = s.substring(1); + } else if (s.charAt(0) == '+') { + s = s.substring(1); + } + + if (s.isEmpty()) { + return null; + } + + // Strip optional trailing l/L suffix + if (s.charAt(s.length() - 1) == 'l' || s.charAt(s.length() - 1) == 'L') { + s = s.substring(0, s.length() - 1); + } + + if (s.isEmpty()) { + return null; + } + + // Remove underscores (Java digit separators) + s = s.replace("_", ""); + if (s.isEmpty()) { + return null; + } + + try { + long value; + if (s.length() > 2 && s.charAt(0) == '0' && (s.charAt(1) == 'x' || s.charAt(1) == 'X')) { + // Hexadecimal + value = Long.parseUnsignedLong(s.substring(2), 16); + } else if (s.length() > 2 && s.charAt(0) == '0' && (s.charAt(1) == 'b' || s.charAt(1) == 'B')) { + // Binary + value = Long.parseUnsignedLong(s.substring(2), 2); + } else { + // Decimal + value = Long.parseLong(s); + } + return negative ? -value : value; + } catch (NumberFormatException e) { + return null; + } + } + + public static String[] getJavaKeywords() { + String[] keywords = { + "if", "else", "for", "while", "do", "switch", "case", "break", "continue", + "return", "try", "catch", "finally", "throw", "throws", "new", "this", "super", + "true", "false", "null", "instanceof", "import", "class", "interface", "enum", + "extends", "implements", "public", "private", "protected", "static", "final", + "abstract", "synchronized", "volatile", "transient", "native", "void", + "boolean", "byte", "short", "int", "long", "float", "double", "char" + }; + return keywords; + } + + public static String[] getJavaScriptKeywords() { + String[] keywords = { + "function", "var", "let", "const", "if", "else", "for", "while", "do", + "switch", "case", "break", "continue", "return", "try", "catch", "finally", + "throw", "delete", "new", "typeof", "instanceof", "in", "of", "this", "null", + "undefined", "true", "false", "async", "await", "yield", "class", "extends", + "import", "export", "default" + }; + + + return keywords; + } + + public static boolean isJavaScriptKeyword(String keyword) { + for (String k : getJavaScriptKeywords()) { + if (k.equals(keyword)) { + return true; + } + } + return false; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/TypeInfo.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/TypeInfo.java new file mode 100644 index 000000000..f7b552323 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/TypeInfo.java @@ -0,0 +1,1248 @@ +package noppes.npcs.client.gui.util.script.interpreter.type; + +import noppes.npcs.client.gui.util.script.interpreter.ObjectLiteralParser; +import noppes.npcs.client.gui.util.script.interpreter.field.EnumConstantInfo; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSFieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSMethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeRegistry; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.TypeParamInfo; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodSignature; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenType; + +import java.lang.reflect.*; +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.function.Supplier; + +/** + * Represents resolved type information for a class/interface/enum. + * + * This is the unified type system that supports: + * - Java types (via Class reflection) + * - Script-defined types (via ScriptTypeInfo subclass) + * - JavaScript/TypeScript types (via JSTypeInfo bridge) + * + * For JavaScript types, the jsTypeInfo field holds the parsed .d.ts data, + * and methods like hasMethod/getMethodInfo delegate to it. + */ +public class TypeInfo { + + public enum Kind { + CLASS, + INTERFACE, + ENUM, + UNKNOWN + } + + /** + * Singleton constant for the void type. + */ + public static final TypeInfo VOID = fromPrimitive("void"); + + public static final TypeInfo BOOLEAN = fromPrimitive("boolean"); + + public static final TypeInfo STRING = TypeInfo.fromClass(String.class); + static TypeInfo jsString = null; + + public static final TypeInfo OBJECT = TypeInfo.fromClass(Object.class); + static TypeInfo jsObject = null; + + public static TypeInfo string() { + return TypeChecker.isJavaScriptMode() && jsString != null ? jsString : STRING; + } + + public static TypeInfo object() { + return TypeChecker.isJavaScriptMode() && jsObject != null ? jsObject : OBJECT; + } + + public static final TypeInfo NULL = TypeInfo.unresolved("null", ""); + + /** + * Singleton constant for the "any" type (used in JavaScript/TypeScript). + * The "any" type is universally compatible - it can be assigned to anything + * and anything can be assigned to it. + */ + public static final TypeInfo ANY = new TypeInfo("any", "any", "", Kind.CLASS, null, true, null).setPrimitive(true); + public static final TypeInfo NUMBER = new TypeInfo("number", "number", "", Kind.CLASS, double.class, true, null).setPrimitive(true); + + public static final Supplier OBJECT_LITERAL = () -> new TypeInfo("ObjectLiteral", "ObjectLiteral", "", + Kind.CLASS, null, true, null); + + + private final String simpleName; // e.g., "List", "ColorType" + private final String fullName; // e.g., "java.util.List", "kamkeel...IOverlay$ColorType" + private final String packageName; // e.g., "java.util", "kamkeel.npcdbc.api.client.overlay" + private final Kind kind; // CLASS, INTERFACE, ENUM + private final Class javaClass; // The actual resolved Java class (null if unresolved or JS type) + private final boolean resolved; // Whether this type was successfully resolved + private final TypeInfo enclosingType; // For inner classes, the outer type (null if top-level) + + private boolean isPrimitive; // Whether this is a primitive type (e.g., int, boolean) + private boolean isObjectLiteral; + + // JavaScript/TypeScript type info (for types from .d.ts files) + private final JSTypeInfo jsTypeInfo; // The JS type info (null if Java type) + + // Declared type parameters (generics definition, e.g., "T extends Entity" on interface List) + private final List typeParams = new ArrayList<>(); + + // Applied type arguments (concrete types provided for generics, e.g., in Map) + // These are TypeInfo instances that can themselves be parameterized for nested generics + private final List appliedTypeArgs = new ArrayList<>(); + + // For parameterized types, the raw/base type (e.g., List for List) + // Null for non-parameterized types + private final TypeInfo rawType; + + // For array types, the element type (e.g., IItemStack for IItemStack[]) + // Null for non-array types + private final TypeInfo elementType; + + // Synthetic members injected at construction time (e.g. array built-ins: length, clone) + private final List syntheticFields = new ArrayList<>(); + private final List syntheticMethods = new ArrayList<>(); + + // Documentation (script-defined types) + private JSDocInfo jsDocInfo; + + // SAM (Single Abstract Method) caching for functional interface detection + private MethodInfo cachedSAM; + private boolean samCacheResolved = false; + + private TypeInfo(String simpleName, String fullName, String packageName, + Kind kind, Class javaClass, boolean resolved, TypeInfo enclosingType) { + this(simpleName, fullName, packageName, kind, javaClass, resolved, enclosingType, null, null, null, null); + } + + private TypeInfo(String simpleName, String fullName, String packageName, + Kind kind, Class javaClass, boolean resolved, TypeInfo enclosingType, + JSTypeInfo jsTypeInfo) { + this(simpleName, fullName, packageName, kind, javaClass, resolved, enclosingType, jsTypeInfo, null, null, null); + } + + private TypeInfo(String simpleName, String fullName, String packageName, + Kind kind, Class javaClass, boolean resolved, TypeInfo enclosingType, + JSTypeInfo jsTypeInfo, TypeInfo rawType, List appliedTypeArgs, TypeInfo elementType) { + this.simpleName = simpleName; + this.fullName = fullName; + this.packageName = packageName; + this.kind = kind; + this.javaClass = javaClass; + this.resolved = resolved; + this.enclosingType = enclosingType; + this.jsTypeInfo = jsTypeInfo; + this.rawType = rawType; + this.elementType = elementType; + if (appliedTypeArgs != null) { + this.appliedTypeArgs.addAll(appliedTypeArgs); + } + } + + // Protected constructor for subclasses (like ScriptTypeInfo) + protected TypeInfo(String simpleName, String fullName, String packageName, + Kind kind, Class javaClass, boolean resolved, TypeInfo enclosingType, + @SuppressWarnings("unused") boolean subclass) { + this.simpleName = simpleName; + this.fullName = fullName; + this.packageName = packageName; + this.kind = kind; + this.javaClass = javaClass; + this.resolved = resolved; + this.enclosingType = enclosingType; + this.jsTypeInfo = null; + this.rawType = null; + this.elementType = null; + } + + // Factory methods + public static TypeInfo resolved(String simpleName, String fullName, String packageName, + Kind kind, Class javaClass) { + return new TypeInfo(simpleName, fullName, packageName, kind, javaClass, true, null); + } + + public static TypeInfo resolvedInner(String simpleName, String fullName, String packageName, + Kind kind, Class javaClass, TypeInfo enclosing) { + return new TypeInfo(simpleName, fullName, packageName, kind, javaClass, true, enclosing); + } + + public static TypeInfo unresolved(String simpleName, String fullPath) { + int lastDot = fullPath.lastIndexOf('.'); + String pkg = lastDot > 0 ? fullPath.substring(0, lastDot) : ""; + return new TypeInfo(simpleName, fullPath, pkg, Kind.UNKNOWN, null, false, null); + } + + public static TypeInfo fromClass(Class clazz) { + if (clazz == null) return null; + + Kind kind; + if (clazz.isInterface()) { + kind = Kind.INTERFACE; + } else if (clazz.isEnum()) { + kind = Kind.ENUM; + } else { + kind = Kind.CLASS; + } + + String fullName = clazz.getName(); + String simpleName = clazz.getSimpleName(); + Package pkg = clazz.getPackage(); + String packageName = ""; + if (pkg != null) { + packageName = pkg.getName(); + } else if (!fullName.equals(simpleName)) { + int lastDot = fullName.lastIndexOf('.'); + if (lastDot > 0) { + packageName = fullName.substring(0, lastDot); + } + } + + TypeInfo enclosing = null; + if (clazz.getEnclosingClass() != null) { + enclosing = fromClass(clazz.getEnclosingClass()); + } + + if (clazz.isArray()) { + return arrayOf(fromClass(clazz.getComponentType())); + } + + return new TypeInfo(simpleName, fullName, packageName, kind, clazz, true, enclosing); + } + + /** + * Create a TypeInfo from a generic java.lang.reflect.Type. + * This preserves generic type arguments from reflection APIs like + * Method.getGenericReturnType() and Field.getGenericType(). + * + * Examples: + * - List -> TypeInfo(List) with appliedTypeArgs=[TypeInfo(String)] + * - Map -> TypeInfo(Map) with appliedTypeArgs=[TypeInfo(String), TypeInfo(Integer)] + * - T (type variable) -> TypeInfo representing the type variable name + * + * @param type The generic type from reflection + * @return A TypeInfo preserving the generic structure, or null if type is null + */ + public static TypeInfo fromGenericType(Type type) { + if (type == null) return null; + + if (type instanceof Class) { + // Plain class - no generic info + return fromClass((Class) type); + } + + if (type instanceof ParameterizedType) { + // Generic type like List + ParameterizedType paramType = (ParameterizedType) type; + Type rawType = paramType.getRawType(); + + if (!(rawType instanceof Class)) { + // Edge case - should not happen normally + return rawType != null ? fromGenericType(rawType) : null; + } + + // Get the raw type as TypeInfo + TypeInfo rawTypeInfo = fromClass((Class) rawType); + + // Recursively convert type arguments + Type[] typeArgs = paramType.getActualTypeArguments(); + List appliedArgs = new ArrayList<>(typeArgs.length); + for (Type arg : typeArgs) { + TypeInfo argInfo = fromGenericType(arg); + if (argInfo != null) { + appliedArgs.add(argInfo); + } + } + + // Return a parameterized TypeInfo + if (!appliedArgs.isEmpty()) { + return rawTypeInfo.parameterize(appliedArgs); + } + return rawTypeInfo; + } + + if (type instanceof GenericArrayType) { + // Array of generic type, e.g. T[] or List[] + GenericArrayType arrayType = (GenericArrayType) type; + TypeInfo elementType = fromGenericType(arrayType.getGenericComponentType()); + if (elementType != null) { + return arrayOf(elementType); + } + return fromClass(Object[].class); + } + + if (type instanceof TypeVariable) { + // Type variable like T, E, K, V + TypeVariable typeVar = (TypeVariable) type; + String varName = typeVar.getName(); + // Create an unresolved type representing the type variable + // The substitution system will handle replacing this with the actual type + return TypeInfo.unresolved(varName, varName); + } + + if (type instanceof WildcardType) { + // Wildcard like ? or ? extends Number or ? super Integer + WildcardType wildcard = (WildcardType) type; + Type[] upperBounds = wildcard.getUpperBounds(); + + // Use the upper bound if available (most useful for ? extends T) + if (upperBounds.length > 0 && upperBounds[0] != Object.class) { + return fromGenericType(upperBounds[0]); + } + + // For ? super T or plain ?, just use Object + return fromClass(Object.class); + } + + // Unknown type - shouldn't happen in practice + return null; + } + + /** + * Create a TypeInfo for a primitive type. + */ + public static TypeInfo fromPrimitive(String typeName) { + Class primitiveClass = null; + switch (typeName) { + case "boolean": primitiveClass = boolean.class; break; + case "byte": primitiveClass = byte.class; break; + case "char": primitiveClass = char.class; break; + case "short": primitiveClass = short.class; break; + case "int": primitiveClass = int.class; break; + case "long": primitiveClass = long.class; break; + case "float": primitiveClass = float.class; break; + case "double": primitiveClass = double.class; break; + case "void": primitiveClass = void.class; break; + } + return new TypeInfo(typeName, typeName, "", Kind.CLASS, primitiveClass, true, null).setPrimitive(true); + } + + /** + * Create a TypeInfo from a JavaScript/TypeScript type. + * This bridges JS types parsed from .d.ts files into the unified type system. + * + * @param jsType The parsed JS type info + * @return A TypeInfo wrapping the JS type + */ + public static TypeInfo fromJSTypeInfo(JSTypeInfo jsType) { + if (jsType == null) return null; + + String syntheticDisplayName = ObjectLiteralParser.getSyntheticObjectLiteralDisplayName(jsType); + if (syntheticDisplayName != null) { + return new TypeInfo(syntheticDisplayName, jsType.getFullName(), "", + Kind.INTERFACE, null, true, null, jsType); + } + + String simpleName = jsType.getSimpleName(); + String fullName = jsType.getFullName(); + String namespace = jsType.getNamespace(); + + // JS interfaces are always Kind.INTERFACE + return new TypeInfo(simpleName, fullName, namespace != null ? namespace : "", + Kind.INTERFACE, null, true, null, jsType); + } + + public static TypeInfo objectLiteral(List properties) { + TypeInfo t = OBJECT_LITERAL.get(); + t.isObjectLiteral = true; + if (properties != null) { + for (ObjectLiteralParser.ObjectLiteralProperty p : properties) { + TypeInfo vt = (p.valueType != null) ? p.valueType : TypeInfo.ANY; + if (p.isCallable()) { + ObjectLiteralParser.CallableInfo ci = p.callableInfo; + t.syntheticFields.add(FieldInfo.external(p.keyName, TypeInfo.ANY, null, Modifier.PUBLIC)); + TypeInfo returnType = ci.returnsThis() ? t : ci.returnType; + if (returnType == null) { + returnType = t; + } + List params = new ArrayList<>(); + for (String paramName : ci.parameterNames) { + params.add(FieldInfo.external(paramName, TypeInfo.ANY, null, Modifier.PUBLIC)); + } + t.syntheticMethods.add(MethodInfo.external(p.keyName, returnType, t, + params, Modifier.PUBLIC, null)); + } else { + t.syntheticFields.add(FieldInfo.external(p.keyName, vt, null, Modifier.PUBLIC)); + } + } + } + return t; + } + + public void addSyntheticField(String name, TypeInfo type) { + syntheticFields.add(FieldInfo.external(name, type, null, Modifier.PUBLIC)); + } + + public void removeSyntheticField(String name) { + syntheticFields.removeIf(f -> f.getName().equals(name)); + } + + public void addSyntheticMethod(String name, TypeInfo returnType, List params) { + syntheticMethods.add(MethodInfo.external(name, returnType, this, + params != null ? params : Collections.emptyList(), Modifier.PUBLIC, null)); + } + + public void removeSyntheticMethod(String name) { + syntheticMethods.removeIf(m -> m.getName().equals(name)); + } + + public static void injectJSMembers(TypeInfo target, JSTypeInfo jsExtensions) { + for (JSFieldInfo jsField : jsExtensions.getFields().values()) + target.syntheticFields.add(FieldInfo.fromJSField(jsField, target)); + for (JSMethodInfo jsMethod : jsExtensions.getMethods().values()) + target.syntheticMethods.add(MethodInfo.fromJSMethod(jsMethod, target)); + } + + public List getSyntheticMethods() { + // Merge .d.ts methods for arrays in JS + if (isArray() && TypeChecker.isJavaScriptMode()) { + JSTypeInfo arrayType = JSTypeRegistry.getInstance().getType("Array"); + if (arrayType == null) { + return syntheticMethods; + } + + Map merged = new LinkedHashMap<>(); + for (MethodInfo method : syntheticMethods) { + merged.put(method.getSignature(), method); + } + + for (JSMethodInfo jsMethod : arrayType.getMethods().values()) { + if (jsMethod.isStatic()) { + continue; + } + MethodInfo method = MethodInfo.fromJSMethod(jsMethod, this); + merged.putIfAbsent(method.getSignature(), method); + } + + return new ArrayList<>(merged.values()); + } + + return syntheticMethods; + } + + public List getSyntheticFields() { + return syntheticFields; + } + + /** + * Create an array type wrapping the given element type. + * + * @param elementType The type of elements in the array + * @return A TypeInfo representing the array type + */ + public static TypeInfo arrayOf(TypeInfo elementType) { + if (elementType == null) { + return fromClass(Object[].class); + } + + // Preserve generic display in arrays (e.g., List[]) and keep JS namespace display. + String simpleName = elementType.getDisplayName() + "[]"; + String fullName = elementType.getDisplayNameFull() + "[]"; + String pkg = elementType.getPackageName(); + + // Try to get the actual array class if we have a Java class + Class arrayClass = null; + if (elementType.getJavaClass() != null) { + try { + arrayClass = java.lang.reflect.Array.newInstance(elementType.getJavaClass(), 0).getClass(); + } catch (Exception e) { + // Fallback to Object array if we can't create the specific array type + } + } + + TypeInfo arr = new TypeInfo(simpleName, fullName, pkg, elementType.kind, arrayClass, true, null, null, null, null, elementType); + arr.setPrimitive(elementType.isPrimitive()); + arr.syntheticFields.add(FieldInfo.external("length", TypeInfo.fromPrimitive("int"), null, + Modifier.PUBLIC | Modifier.FINAL)); + arr.syntheticMethods.add(MethodInfo.external("clone", arr, null, + Collections.emptyList(), Modifier.PUBLIC, null)); + return arr; + } + + /** + * Check if this is a JavaScript type (backed by JSTypeInfo). + */ + public boolean isJSType() { + return jsTypeInfo != null; + } + + public boolean isSyntheticObjectLiteralType() { + return isObjectLiteral; + } + + /** + * Get the underlying JSTypeInfo if this is a JS type. + */ + public JSTypeInfo getJSTypeInfo() { + return jsTypeInfo; + } + + public JSDocInfo getJSDocInfo() { + if (jsDocInfo != null) { + return jsDocInfo; + } + return jsTypeInfo != null ? jsTypeInfo.getJsDocInfo() : null; + } + + public void setJSDocInfo(JSDocInfo jsDocInfo) { this.jsDocInfo = jsDocInfo; } + + // Getters + public String getSimpleName() { return simpleName; } + public String getFullName() { return fullName; } + public String getPackageName() { return packageName; } + public Kind getKind() { return kind; } + public Class getJavaClass() { return javaClass; } + public boolean isResolved() { return resolved; } + public TypeInfo getEnclosingType() { return enclosingType; } + public boolean isInnerClass() { return enclosingType != null; } + public boolean isInterface() {return kind == Kind.INTERFACE;} + public boolean isEnum() {return kind == Kind.ENUM;} + public boolean isPrimitive() {return this.isPrimitive || javaClass != null && javaClass.isPrimitive();} + private TypeInfo setPrimitive(boolean value) { this.isPrimitive = value; return this;} + + // ==================== Applied Type Arguments (Parameterized Types) ==================== + + /** + * Check if this type is parameterized (has applied type arguments). + * For example, List is parameterized, but List is not. + */ + public boolean isParameterized() { + return !appliedTypeArgs.isEmpty(); + } + + /** + * Get the raw/base type if this is parameterized. + * For List, returns the TypeInfo for List. + * For non-parameterized types, returns this. + */ + public TypeInfo getRawType() { + return rawType != null ? rawType : this; + } + + public TypeInfo getElementType() { + return elementType; + } + + public boolean isArray() { + return elementType != null || (javaClass != null && javaClass.isArray()); + } + + /** + * Get the applied type arguments. + * For List, returns [TypeInfo(String)]. + * For Map, returns [TypeInfo(String), TypeInfo(Integer)]. + * For nested generics like List>, the Map TypeInfo itself has appliedTypeArgs. + */ + public List getAppliedTypeArgs() { + return appliedTypeArgs; + } + + /** + * Create a parameterized version of this type with the given type arguments. + * For example, calling parameterize([TypeInfo(String)]) on List returns List. + * + * @param typeArgs The type arguments to apply + * @return A new parameterized TypeInfo + */ + public TypeInfo parameterize(List typeArgs) { + if (typeArgs == null || typeArgs.isEmpty()) { + return this; + } + + // Keep base names stable for logic (constructor names, lookups, etc.). + // Generic arguments are tracked via appliedTypeArgs and rendered via getDisplayName*(). + TypeInfo raw = getRawType(); + return new TypeInfo(raw.simpleName, raw.fullName, raw.packageName, raw.kind, raw.javaClass, + raw.resolved, raw.enclosingType, raw.jsTypeInfo, raw, typeArgs, null); + } + + /** + * Create a parameterized version of this type with a single type argument. + */ + public TypeInfo parameterize(TypeInfo typeArg) { + if (typeArg == null) { + return this; + } + List args = new ArrayList<>(); + args.add(typeArg); + return parameterize(args); + } + + /** + * Build the generic type arguments string like "". + * @param typeArgs The type arguments + * @param useFullNames Whether to use full names (for fullName) or simple names (for simpleName) + */ + private static String buildTypeArgsString(List typeArgs, boolean useFullNames) { + if (typeArgs == null || typeArgs.isEmpty()) { + return ""; + } + StringBuilder sb = new StringBuilder("<"); + for (int i = 0; i < typeArgs.size(); i++) { + if (i > 0) sb.append(", "); + TypeInfo arg = typeArgs.get(i); + sb.append(useFullNames ? arg.getDisplayNameFull() : arg.getDisplayNameSimple()); + } + sb.append(">"); + return sb.toString(); + } + + /** + * Get the canonical display name for this type, including generic arguments. + * This is the preferred method for UI display (hover, autocomplete, etc.). + * + * For Java types: uses simple name + generics (e.g., "List") + * For JS types: uses full name + generics (e.g., "IPlayerEvent.InteractEvent") + * For arrays: includes "[]" suffix + * For nested generics: recursively builds (e.g., "List>") + */ + public String getDisplayName() { + // Use full name for JS types, simple name for Java + return isJSType() ? getDisplayNameFull() : getDisplayNameSimple(); + } + + /** + * Get display name using simple names for all types. + * Example: "Map" instead of "java.util.Map" + */ + public String getDisplayNameSimple() { + if (appliedTypeArgs.isEmpty()) { + return simpleName; + } + + String baseName = rawType != null ? rawType.getSimpleName() : simpleName; + return baseName + buildTypeArgsString(appliedTypeArgs, false); + } + + /** + * Get display name using full qualified names. + * Example: "java.util.Map" + */ + public String getDisplayNameFull() { + if (appliedTypeArgs.isEmpty()) { + return fullName; + } + // For full display, use the raw type's full name + the args with their display names + String baseName = rawType != null ? rawType.getFullName() : fullName; + return baseName + buildTypeArgsString(appliedTypeArgs, true); + } + + /** + * Returns true if this TypeInfo represents a Class reference (not an instance). + * For example, Java.type("java.io.File") returns a Class reference. + * Override in ClassTypeInfo to return true. + */ + public boolean isClassReference() { return false; } + + /** + * Get the appropriate TokenType for highlighting this type. + */ + public TokenType getTokenType() { + if (!resolved) + return TokenType.UNDEFINED_VAR; + if(isPrimitive()) + return TokenType.KEYWORD; + + switch (kind) { + case INTERFACE: + return TokenType.INTERFACE_DECL; + case ENUM: + return TokenType.ENUM_DECL; + case CLASS: + default: + return TokenType.IMPORTED_CLASS; + } + } + + /** + * Check if this type has a method with the given name. + */ + public boolean hasMethod(String methodName) { + for (MethodInfo m : getSyntheticMethods()) + if (m.getName().equals(methodName)) + return true; + // Check JS type first + if (jsTypeInfo != null) { + if (jsTypeInfo.hasMethod(methodName)) return true; + } else if (javaClass != null) { + try { + for (java.lang.reflect.Method m : javaClass.getMethods()) { + if (m.getName().equals(methodName)) return true; + } + } catch (Exception e) { + // Security or linkage error + } + } + + TypeInfo obj = TypeInfo.object(); + if (obj != this) return obj.hasMethod(methodName); + return false; + } + + /** + * Check if this type has a method with the given name and parameter count. + */ + public boolean hasMethod(String methodName, int paramCount) { + for (MethodInfo m : getSyntheticMethods()) + if (m.getName().equals(methodName) && m.getParameterCount() == paramCount) + return true; + // Check JS type first + if (jsTypeInfo != null) { + List overloads = jsTypeInfo.getMethodOverloads(methodName); + for (JSMethodInfo m : overloads) { + if (m.getParameterCount() == paramCount) return true; + } + } else if (javaClass != null) { + try { + for (java.lang.reflect.Method m : javaClass.getMethods()) { + if (m.getName().equals(methodName) && m.getParameterCount() == paramCount) return true; + } + } catch (Exception e) { + // Security or linkage error + } + } + TypeInfo obj = TypeInfo.object(); + if (obj != this) return obj.hasMethod(methodName); + return false; + } + + /** + * Check if this type has constructors. + * Override in ScriptTypeInfo for script-defined types. + */ + public boolean hasConstructors() { + if (javaClass == null) return false; + try { + return javaClass.getConstructors().length > 0; + } catch (Exception e) { + // Security or linkage error + return false; + } + } + + /** + * Get the constructors for this type. + * Override in ScriptTypeInfo for script-defined types. + */ + public List getConstructors() { + List result = new ArrayList<>(); + if (javaClass == null) return result; + + try { + java.lang.reflect.Constructor[] constructors = javaClass.getConstructors(); + for (java.lang.reflect.Constructor ctor : constructors) { + result.add(MethodInfo.fromReflectionConstructor(ctor, this)); + } + } catch (Exception e) { + // Security or linkage error + } + return result; + } + + /** + * Find the best matching constructor for the given argument count. + * Override in ScriptTypeInfo for script-defined types. + */ + public MethodInfo findConstructor(int argCount) { + if (javaClass == null) return null; + + try { + Constructor[] constructors = javaClass.getConstructors(); + for (Constructor ctor : constructors) { + if (ctor.getParameterCount() == argCount) { + return MethodInfo.fromReflectionConstructor(ctor, this); + } + } + } catch (Exception e) { + // Security or linkage error + } + return null; + } + + public MethodInfo findConstructor(TypeInfo[] argTypes) { + if (javaClass == null) return null; + + try { + Constructor[] constructors = javaClass.getConstructors(); + for (Constructor ctor : constructors) { + if (ctor.getParameterCount() == argTypes.length) { + Class[] paramTypes = ctor.getParameterTypes(); + boolean match = true; + for (int i = 0; i < argTypes.length; i++) { + TypeInfo paramTypeInfo = TypeInfo.fromClass(paramTypes[i]); + if (!TypeChecker.isTypeCompatible(paramTypeInfo, argTypes[i])) { + match = false; + break; + } + } + if (match) { + return MethodInfo.fromReflectionConstructor(ctor, this); + } + } + } + } catch (Exception e) { + // Security or linkage error + } + return null; + } + + /** + * Check if this type has a field with the given name. + */ + public boolean hasField(String fieldName) { + for (FieldInfo f : syntheticFields) if (f.getName().equals(fieldName)) return true; + // Check JS type first + if (jsTypeInfo != null) { + return jsTypeInfo.hasField(fieldName); + } + + if (javaClass == null) return false; + try { + for (java.lang.reflect.Field f : javaClass.getFields()) { + if (f.getName().equals(fieldName)) { + return true; + } + } + } catch (Exception e) { + // Security or linkage error + } + return false; + } + + public boolean hasEnumConstant(String constantName) { + if (javaClass == null || !javaClass.isEnum()) return false; + try { + Object[] constants = javaClass.getEnumConstants(); + for (Object constant : constants) { + if (constant.toString().equals(constantName)) + return true; + } + } catch (Exception e) { + // Security or linkage error + } + return false; + } + + /** + * Get an enum constant by name. + */ + public EnumConstantInfo getEnumConstant(String constantName) { + if (javaClass == null || !javaClass.isEnum()) return null; + try { + Object[] constants = javaClass.getEnumConstants(); + for (Object constant : constants) { + if (constant.toString().equals(constantName)) + return EnumConstantInfo.fromReflection(constantName, this, null); + } + } catch (Exception e) { + // Security or linkage error + } + return null; + } + + /** + * Get MethodInfo for a method by name. Returns null if not found. + * Creates a synthetic MethodInfo based on reflection data or JS type data. + */ + public MethodInfo getMethodInfo(String methodName) { + for (MethodInfo m : getSyntheticMethods()) + if (m.getName().equals(methodName)) + return m; + if (jsTypeInfo != null) { + JSMethodInfo jsMethod = jsTypeInfo.getMethod(methodName); + if (jsMethod != null) return MethodInfo.fromJSMethod(jsMethod, this); + } else if (javaClass != null) { + try { + for (java.lang.reflect.Method m : javaClass.getMethods()) { + if (m.getName().equals(methodName)) return MethodInfo.fromReflection(m, this); + } + } catch (Exception e) { + // Security or linkage error + } + } + TypeInfo obj = TypeInfo.object(); + if (obj != this) return obj.getMethodInfo(methodName); + return null; + } + + /** + * Get all MethodInfo overloads for a method by name. + * Returns an empty list if not found. + */ + public java.util.List getAllMethodOverloads(String methodName) { + java.util.List overloads = new java.util.ArrayList<>(); + + for (MethodInfo m : getSyntheticMethods()) + if (m.getName().equals(methodName)) + overloads.add(m); + if (!overloads.isEmpty()) return overloads; + + // Check JS type first + if (jsTypeInfo != null) { + for (JSMethodInfo jsMethod : jsTypeInfo.getMethodOverloads(methodName)) { + // Type parameter resolution now happens inside fromJSMethod using this TypeInfo + overloads.add(MethodInfo.fromJSMethod(jsMethod, this)); + } + if (!overloads.isEmpty()) return overloads; + } else if (javaClass != null) { + try { + for (java.lang.reflect.Method m : javaClass.getMethods()) { + if (m.getName().equals(methodName)) { + overloads.add(MethodInfo.fromReflection(m, this)); + } + } + } catch (Exception e) { + // Security or linkage error + } + if (!overloads.isEmpty()) return overloads; + } + TypeInfo obj = TypeInfo.object(); + if (obj != this) return obj.getAllMethodOverloads(methodName); + return overloads; + } + + /** + * Find the best matching method overload considering return type. + * First tries to find a match with compatible return type, then falls back to any match. + * + * @param methodName The name of the method + * @param expectedReturnType The expected return type (can be null) + * @return The best matching MethodInfo, or null if not found + */ + public MethodInfo getBestMethodOverload(String methodName, TypeInfo expectedReturnType) { + java.util.List overloads = getAllMethodOverloads(methodName); + if (overloads.isEmpty()) return null; + + // If no expected return type, return first overload + if (expectedReturnType == null) { + return overloads.get(0); + } + + // First pass: look for return type compatible overload + for (MethodInfo method : overloads) { + TypeInfo returnType = method.getReturnType(); + if (returnType != null && TypeChecker.isTypeCompatible(expectedReturnType, returnType)) { + return method; + } + } + // Second pass: return any overload (first one) + return overloads.get(0); + } + + /** + * Find the best matching method overload based on argument types. + * Uses Java's method resolution rules: exact match, then numeric promotion, then widening conversion, then autoboxing. + * + * @param methodName The name of the method + * @param argTypes The types of the arguments being passed + * @return The best matching MethodInfo, or null if not found + */ + public MethodInfo getBestMethodOverload(String methodName, TypeInfo[] argTypes) { + for (MethodInfo m : getSyntheticMethods()) + if (m.getName().equals(methodName)) + return m; + java.util.List overloads = getAllMethodOverloads(methodName); + if (overloads.isEmpty()) return null; + return OverloadSelector.selectBestOverload(overloads, argTypes); + } + + /** + * Get FieldInfo for a field by name. Returns null if not found. + * Creates a synthetic FieldInfo based on reflection data or JS type data. + */ + public FieldInfo getFieldInfo(String fieldName) { + for (FieldInfo f : syntheticFields) if (f.getName().equals(fieldName)) return f; + // Check JS type first + if (jsTypeInfo != null) { + JSFieldInfo jsField = jsTypeInfo.getField(fieldName); + if (jsField != null) { + return FieldInfo.fromJSField(jsField, this); + } + return null; + } + + if (javaClass == null) return null; + try { + for (java.lang.reflect.Field f : javaClass.getFields()) { + if (f.getName().equals(fieldName)) { + // Create a synthetic FieldInfo from reflection + return FieldInfo.fromReflection(f, this); + } + } + } catch (Exception e) { + // Security or linkage error + } + return null; + } + + /** + * Validate this type. Default implementation does nothing (for Java types). + * Override in ScriptTypeInfo to validate script-defined types. + */ + public void validate() { + // Default: no validation for Java types + } + + // ==================== Functional Interface (SAM) Detection ==================== + + /** + * Determine whether this type is a functional interface and return its single abstract method (SAM). + * + * For Java reflection types (javaClass != null): + * - Must be an interface + * - Collects all public methods from javaClass.getMethods() + * - Filters out: static methods, default methods, and Object methods + * - If exactly one abstract instance method remains, returns it as a MethodInfo + * + * For script-defined interfaces (ScriptTypeInfo with kind == INTERFACE): + * - Identifies abstract methods (methods without body) + * - If exactly one exists, returns it as a MethodInfo + * + * @return MethodInfo for the single abstract method, or null if not a functional interface + */ + public MethodInfo getSingleAbstractMethod() { + // Return cached result if already resolved + if (samCacheResolved) { + return cachedSAM; + } + + // Mark as resolved to prevent re-computation + samCacheResolved = true; + + try { + // Handle Java reflection types + if (javaClass != null) { + // Only interfaces can be functional interfaces (for simplicity) + if (!javaClass.isInterface()) { + cachedSAM = null; + return null; + } + + // Collect all public methods + java.lang.reflect.Method[] methods = javaClass.getMethods(); + java.lang.reflect.Method singleAbstractMethod = null; + + for (java.lang.reflect.Method method : methods) { + int modifiers = method.getModifiers(); + + // Skip static methods + if (java.lang.reflect.Modifier.isStatic(modifiers)) { + continue; + } + + // Skip default methods (Java 8+) + if (method.isDefault()) { + continue; + } + + // Skip methods inherited from Object + String methodName = method.getName(); + if (isObjectMethod(methodName, method.getParameterCount())) { + continue; + } + + // This is an abstract instance method + if (singleAbstractMethod != null) { + // More than one abstract method - not a functional interface + cachedSAM = null; + return null; + } + + singleAbstractMethod = method; + } + + // If exactly one abstract method found, create MethodInfo with generic substitution + if (singleAbstractMethod != null) { + cachedSAM = MethodInfo.fromReflection(singleAbstractMethod, this); + return cachedSAM; + } + + cachedSAM = null; + return null; + } + + // Handle script-defined interfaces + if (this instanceof ScriptTypeInfo) { + ScriptTypeInfo scriptType = (ScriptTypeInfo) this; + + // Only check interfaces + if (scriptType.getKind() != Kind.INTERFACE) { + cachedSAM = null; + return null; + } + + // Find all abstract methods (methods without body) + // For script-defined interfaces, all declared methods are implicitly abstract + java.util.List allMethods = scriptType.getAllMethodsFlat(); + + if (allMethods.size() == 1) { + // Exactly one method - it's the SAM + cachedSAM = allMethods.get(0); + return cachedSAM; + } else if (allMethods.size() > 1) { + // More than one method - not a functional interface + cachedSAM = null; + return null; + } + + cachedSAM = null; + return null; + } + + // Not a functional interface + cachedSAM = null; + return null; + + } catch (Exception e) { + // Any reflection or security error - treat as not a functional interface + cachedSAM = null; + return null; + } + } + + /** + * Check if this type is a functional interface (has a single abstract method). + * + * @return true if this is a functional interface, false otherwise + */ + public boolean isFunctionalInterface() { + return getSingleAbstractMethod() != null; + } + + /** + * Helper method to check if a method is inherited from java.lang.Object. + * These methods don't count toward the SAM requirement. + * + * @param methodName The name of the method + * @param paramCount The number of parameters + * @return true if this is an Object method + */ + private boolean isObjectMethod(String methodName, int paramCount) { + switch (methodName) { + case "equals": + return paramCount == 1; + case "hashCode": + case "toString": + case "getClass": + case "notify": + case "notifyAll": + return paramCount == 0; + case "wait": + // wait() has overloads with 0, 1, and 2 parameters + return paramCount == 0 || paramCount == 1 || paramCount == 2; + default: + return false; + } + } + + // ==================== Type Parameter Methods ==================== + + /** + * Add a type parameter to this type. + * Used during parsing/construction of types with generics. + */ + public void addTypeParam(TypeParamInfo param) { + // If this is a JS type, delegate to JSTypeInfo + if (jsTypeInfo != null) { + jsTypeInfo.addTypeParam(param); + } else { + typeParams.add(param); + } + } + + /** + * Get all type parameters for this type. + * @return List of type parameters (empty if none) + */ + public List getTypeParams() { + // If this is a JS type, delegate to JSTypeInfo + if (jsTypeInfo != null) { + return jsTypeInfo.getTypeParams(); + } + + // For Java reflection types, lazily expose declared generic parameters (e.g., List, Map) + if (javaClass != null && typeParams.isEmpty()) { + try { + TypeVariable[] vars = javaClass.getTypeParameters(); + for (TypeVariable v : vars) { + if (v == null) continue; + String n = v.getName(); + if (n == null || n.isEmpty()) continue; + typeParams.add(new TypeParamInfo(n, null, null)); + } + } catch (Exception ignored) { + // Best-effort only; leave typeParams empty. + } + } + return typeParams; + } + + /** + * Resolve all type parameters for this type. + * Called during Phase 2 after all types are loaded into the registry. + */ + public void resolveTypeParameters() { + // If this is a JS type, delegate to JSTypeInfo + if (jsTypeInfo != null) { + jsTypeInfo.resolveTypeParameters(); + } else { + for (TypeParamInfo param : typeParams) { + param.resolveBoundType(); + } + } + } + + /** + * Get the type parameter info for a given parameter name (e.g., "T"). + * @return TypeParamInfo or null if not found + */ + public TypeParamInfo getTypeParam(String name) { + // If this is a JS type, delegate to JSTypeInfo + if (jsTypeInfo != null) { + return jsTypeInfo.getTypeParam(name); + } + + for (TypeParamInfo param : typeParams) { + if (param.getName().equals(name)) { + return param; + } + } + return null; + } + + /** + * Resolves a type parameter to its bound TypeInfo. + * For example, if this type has "T extends EntityPlayerMP", resolveTypeParamToTypeInfo("T") returns the TypeInfo for EntityPlayerMP. + * If no type parameter is found with that name, returns null. + */ + public TypeInfo resolveTypeParamToTypeInfo(String typeName) { + TypeParamInfo param = getTypeParam(typeName); + if (param != null) { + return param.getBoundTypeInfo(); + } + return null; + } + + @Override + public String toString() { + return "TypeInfo{" + fullName + ", " + kind + ", resolved=" + resolved + "}"; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + TypeInfo typeInfo = (TypeInfo) o; + return fullName.equals(typeInfo.fullName); + } + + @Override + public int hashCode() { + return fullName.hashCode(); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/TypeResolver.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/TypeResolver.java new file mode 100644 index 000000000..de626e96d --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/TypeResolver.java @@ -0,0 +1,1009 @@ +package noppes.npcs.client.gui.util.script.interpreter.type; + +import noppes.npcs.client.gui.util.script.PackageFinder; +import noppes.npcs.client.gui.util.script.interpreter.ScriptDocument; +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.js_parser.JSTypeRegistry; +import noppes.npcs.client.gui.util.script.interpreter.token.TokenType; +import noppes.npcs.client.gui.util.script.interpreter.type.synthetic.SyntheticType; + +import java.util.*; + +/** + * Unified type resolver for both Java and JavaScript/TypeScript types. + * Serves as the single front-end for all type resolution needs. + * + * For Java: Uses reflection and import resolution + * For JavaScript: Delegates to JSTypeRegistry for .d.ts defined types + * + * This is the ONLY class that should be used for type resolution. + */ +public class TypeResolver { + + // Cache: fully-qualified class name -> TypeInfo + private final Map typeCache = new HashMap<>(); + + // Cache: Java types that have been enriched with JS members from .d.ts types (e.g., String, Object) + private final Map jsMergeCache = new HashMap<>(); + + // Cache: validated package paths + private final Set validPackages = new HashSet<>(); + + // JavaScript type registry (lazily initialized) + private JSTypeRegistry jsTypeRegistry; + + // Synthetic type registry (e.g., Nashorn built-ins) + private final Map syntheticTypes = new LinkedHashMap<>(); + + // Auto-imported java.lang classes + public static final Set JAVA_LANG_CLASSES = Collections.unmodifiableSet(new HashSet<>(Arrays.asList( + "Object", "String", "Class", "System", "Math", "Integer", "Double", "Float", "Long", "Short", "Byte", + "Character", "Boolean", "Number", "Void", "Thread", "Runnable", "Exception", "RuntimeException", + "Error", "Throwable", "StringBuilder", "StringBuffer", "Enum", "Comparable", "Iterable", + "CharSequence", "Cloneable", "Process", "ProcessBuilder", "Runtime", "SecurityManager", + "ClassLoader", "Package", "ArithmeticException", "ArrayIndexOutOfBoundsException", + "ClassCastException", "IllegalArgumentException", "IllegalStateException", + "IndexOutOfBoundsException", "NullPointerException", "NumberFormatException", + "UnsupportedOperationException", "AssertionError", "OutOfMemoryError", "StackOverflowError" + ))); + + // JavaScript primitive type mappings + private static final Map JS_PRIMITIVE_TO_JAVA = new HashMap<>(); + static { + JS_PRIMITIVE_TO_JAVA.put("string", "String"); + JS_PRIMITIVE_TO_JAVA.put("number", "double"); + JS_PRIMITIVE_TO_JAVA.put("boolean", "boolean"); + JS_PRIMITIVE_TO_JAVA.put("any", "Object"); + JS_PRIMITIVE_TO_JAVA.put("void", "void"); + JS_PRIMITIVE_TO_JAVA.put("null", "null"); + JS_PRIMITIVE_TO_JAVA.put("undefined", "void"); + JS_PRIMITIVE_TO_JAVA.put("object", "Object"); + } + + // Singleton instance for global caching (optional - can also use per-document instances) + private static TypeResolver instance; + + public static TypeResolver getInstance() { + if (instance == null) { + instance = new TypeResolver(); + } + return instance; + } + + public TypeResolver() { + // Pre-register common packages + validPackages.add("java"); + validPackages.add("java.lang"); + validPackages.add("java.util"); + validPackages.add("java.io"); + + // Initialize built-in synthetic types + initializeSyntheticTypes(); + } + + /** + * Initialize built-in synthetic types (e.g., Nashorn built-ins). + */ + private void initializeSyntheticTypes() { + // Register all Nashorn built-in types (Java, etc.) + for (SyntheticType type : NashornBuiltins.getInstance().getAllBuiltinTypes()) { + syntheticTypes.put(type.getName(), type); + } + + // Register all Nashorn global functions (print, load, etc.) + Map nashornGlobals = NashornBuiltins.getInstance().getAllGlobalFunctions(); + syntheticTypes.putAll(nashornGlobals); + } + + // ==================== SYNTHETIC TYPE REGISTRY ==================== + + /** + * Register a synthetic type for use in scripts. + * @param name The type name (e.g., "Java", "MyCustomType") + * @param type The synthetic type definition + */ + public void registerSyntheticType(String name, SyntheticType type) { + syntheticTypes.put(name, type); + } + + /** + * Check if a name is a known synthetic type. + * @param name The type name to check + * @return true if the name is a registered synthetic type + */ + public boolean isSyntheticType(String name) { + return syntheticTypes.containsKey(name); + } + + /** + * Get a synthetic type by name. + * @param name The type name + * @return The synthetic type, or null if not found + */ + public SyntheticType getSyntheticType(String name) { + return syntheticTypes.get(name); + } + + /** + * Get all registered synthetic types. + * @return Collection of all synthetic types + */ + public Collection getAllSyntheticTypes() { + return syntheticTypes.values(); + } + + // ==================== JS TYPE REGISTRY ACCESS ==================== + + /** + * Get the JS type registry, initializing it if needed. + */ + public JSTypeRegistry getJSTypeRegistry() { + if (jsTypeRegistry == null) { + jsTypeRegistry = JSTypeRegistry.getInstance(); + if (!jsTypeRegistry.isInitialized()) { + jsTypeRegistry.initializeFromResources(); + } + jsTypeRegistry.syncHooksFromScriptHookControllerIfNeeded(); + } + return jsTypeRegistry; + } + + /** + * Check if a function name is a known JS hook. + */ + public boolean isJSHook(String functionName) { + return getJSTypeRegistry().isHook(functionName); + } + + /** + * Get the parameter type for a JS hook function. + */ + public String getJSHookParameterType(String functionName) { + return getJSTypeRegistry().getHookParameterType(functionName); + } + + /** + * Get hook signatures for a JS function. + */ + public List getJSHookSignatures(String functionName) { + return getJSTypeRegistry().getHookSignatures(functionName); + } + + // ==================== CONTEXT-AWARE HOOK METHODS ==================== + + /** + * Check if a function name is a known JS hook in a specific script context. + * Falls back to GLOBAL context if not found in the specified context. + * + * @param namespace The event interface namespace (e.g., "INpcEvent", "IPlayerEvent") + * @param functionName The function name to check + * @return true if it's a known hook in this namespace + */ + public boolean isJSHook(String namespace, String functionName) { + return getJSTypeRegistry().isHook(namespace, functionName); + } + + /** + * Get the parameter type for a JS hook function in a specific namespace. + * Falls back to "Global" namespace if not found in the specified namespace. + * + * @param namespace The event interface namespace (e.g., "INpcEvent", "IPlayerEvent") + * @param functionName The hook function name + * @return The parameter type, or null if not a hook + */ + public String getJSHookParameterType(String namespace, String functionName) { + return getJSTypeRegistry().getHookParameterType(namespace, functionName); + } + + /** + * Get hook signatures for a JS function in a specific namespace. + * Falls back to "Global" namespace if not found in the specified namespace. + * + * @param namespace The event interface namespace (e.g., "INpcEvent", "IPlayerEvent") + * @param functionName The hook function name + * @return List of hook signatures + */ + public List getJSHookSignatures(String namespace, String functionName) { + return getJSTypeRegistry().getHookSignatures(namespace, functionName); + } + + /** + * Get all hook names available in a specific namespace. + * + * @param namespace The event interface namespace + * @return Set of hook function names + */ + public Set getJSHookNames(String namespace) { + return getJSTypeRegistry().getHookNames(namespace); + } + + // ==================== MULTI-NAMESPACE HOOK METHODS ==================== + + /** + * Check if a function name is a known JS hook in any of the provided namespaces. + * Checks namespaces in order, returning true on first match. + * Falls back to GLOBAL namespace if not found in any specified namespace. + * + * @param namespaces The list of event interface namespaces to search (e.g., ["IPlayerEvent", "IAnimationEvent"]) + * @param functionName The function name to check + * @return true if it's a known hook in any of the namespaces + */ + public boolean isJSHook(List namespaces, String functionName) { + return getJSTypeRegistry().isHook(namespaces, functionName); + } + + /** + * Get the parameter type for a JS hook function, searching multiple namespaces. + * Checks namespaces in order, returning the first match found. + * Falls back to "Global" namespace if not found in any specified namespace. + * + * @param namespaces The list of event interface namespaces to search + * @param functionName The hook function name + * @return The parameter type, or null if not a hook + */ + public String getJSHookParameterType(List namespaces, String functionName) { + return getJSTypeRegistry().getHookParameterType(namespaces, functionName); + } + + /** + * Get hook signatures for a JS function, searching multiple namespaces. + * Checks namespaces in order, returning signatures from the first matching namespace. + * Falls back to "Global" namespace if not found in any specified namespace. + * + * @param namespaces The list of event interface namespaces to search + * @param functionName The hook function name + * @return List of hook signatures + */ + public List getJSHookSignatures(List namespaces, String functionName) { + return getJSTypeRegistry().getHookSignatures(namespaces, functionName); + } + + /** + * Get all hook names available in any of the provided namespaces. + * Combines hook names from all specified namespaces. + * + * @param namespaces The list of event interface namespaces + * @return Combined set of hook function names from all namespaces + */ + public Set getJSHookNames(List namespaces) { + return getJSTypeRegistry().getHookNames(namespaces); + } + + // ==================== CACHE MANAGEMENT ==================== + + /** + * Clear all caches. Call when imports change significantly. + */ + public void clearCache() { + typeCache.clear(); + validPackages.clear(); + // Re-add common packages + validPackages.add("java"); + validPackages.add("java.lang"); + validPackages.add("java.util"); + validPackages.add("java.io"); + } + + // ==================== UNIFIED TYPE RESOLUTION ==================== + + /** + * General-purpose type resolution. + * Tries JS types first, then falls back to Java types. + * + * @param typeName The type name (can be simple or fully-qualified) + * @return TypeInfo for the resolved type, or null if not found + */ + public TypeInfo resolve(String typeName) { + if (typeName == null || typeName.isEmpty()) { + return null; + } + + // Try JS resolution first (handles primitives, .d.ts types) + TypeInfo jsType = resolveJSType(typeName); + if (jsType != null && jsType.isResolved()) { + return jsType; + } + + // Try full name resolution + TypeInfo fullType = resolveFullName(typeName); + if (fullType != null && fullType.isResolved()) { + return fullType; + } + + // Return unresolved or null + return jsType; // Will be unresolved TypeInfo or null + } + + /** + * Resolve a type name for JavaScript context. + * Handles JS primitives, .d.ts types, and falls back to Java types. + * NOW preserves generic type arguments in the returned TypeInfo. + * + * @param jsTypeName The JS type name (e.g., "IPlayer", "string", "List", "Map") + * @return TypeInfo for the resolved type, or unresolved TypeInfo if not found + */ + public TypeInfo resolveJSType(String jsTypeName) { + if (jsTypeName == null || jsTypeName.isEmpty()) { + return TypeInfo.fromPrimitive("void"); + } + + // Normalize import() references first. + String normalized = TypeStringNormalizer.stripImportTypeSyntax(jsTypeName); + if (normalized == null || normalized.isEmpty()) { + return TypeInfo.fromPrimitive("void"); + } + + // Unions: pick a single "best" branch for resolution (prefer non-nullish). + normalized = TypeStringNormalizer.pickPreferredUnionBranch(normalized); + + // Nullable: treat Foo? as Foo | null (for resolution purposes this means "resolve Foo"). + normalized = TypeStringNormalizer.stripNullableSuffix(normalized); + + // Arrays: handled here, not in the generics structural parser. + TypeStringNormalizer.ArraySplit arraySplit = TypeStringNormalizer.splitArraySuffixes(normalized); + String baseExpr = arraySplit.base; + int arrayDims = arraySplit.dimensions; + + if (baseExpr == null || baseExpr.isEmpty()) { + return TypeInfo.unresolved(jsTypeName, jsTypeName); + } + + TypeInfo resolved = null; + // Fast path: no generics - skip expensive parsing + if (!baseExpr.contains("<")) { + resolved = resolveBaseType(baseExpr); + } else { + // Slow path: parse and resolve into a TypeInfo, preserving generic arguments. + GenericTypeParser.ParsedType parsed = GenericTypeParser.parse(baseExpr); + if (parsed != null) { + // Resolve the base type (without generics) + TypeInfo baseType = resolveBaseType(parsed.baseName); + + // If we have type arguments, resolve them (allowing each arg to have its own arrays/unions/etc). + if (parsed.hasTypeArgs() && baseType != null && baseType.isResolved()) { + List resolvedArgs = new ArrayList<>(); + for (GenericTypeParser.ParsedType argParsed : parsed.typeArgs) { + if (argParsed == null) { + resolvedArgs.add(TypeInfo.ANY); + continue; + } + TypeInfo argType = resolveJSType(argParsed.rawString); + resolvedArgs.add(argType != null ? argType : TypeInfo.unresolved(argParsed.baseName, + argParsed.baseName)); + } + if (!resolvedArgs.isEmpty()) { + baseType = baseType.parameterize(resolvedArgs); + } + } + resolved = baseType != null ? baseType : TypeInfo.unresolved(parsed.baseName, parsed.rawString); + } else + resolved = resolveBaseType(baseExpr); + } + + if (resolved == null) { + resolved = TypeInfo.unresolved(baseExpr, jsTypeName); + } + + for (int i = 0; i < arrayDims; i++) { + resolved = TypeInfo.arrayOf(resolved); + } + + return resolved; + } + + /** + * Resolve a base type name (without generics) to a TypeInfo. + * This handles primitives, synthetic types, JS registry types, and Java types. + */ + private TypeInfo resolveBaseType(String baseName) { + if (baseName == null || baseName.isEmpty()) { + return null; + } + + // Primitives + if (TypeResolver.isPrimitiveType(baseName)) { + return TypeInfo.fromPrimitive(baseName); + } + + // Handle "Java." prefix - convert to actual Java type + if (baseName.startsWith("Java.")) { + baseName = baseName.substring(5); + } + + // Check synthetic types (Nashorn built-ins, custom types, etc.) + if (isSyntheticType(baseName)) { + SyntheticType syntheticType = getSyntheticType(baseName); + return syntheticType.getTypeInfo(); + } + + // Check JS type registry + // Before primitive mapping, to allow .d.ts types to override primitive names for ECMAScript 5.1 globals (e.g., "String" in JS is not the same as "String" in Java)) + JSTypeInfo jsTypeInfo = getJSTypeRegistry().getType(baseName); + if (jsTypeInfo != null) { + TypeInfo merged = tryMergeJSWithJava(baseName, jsTypeInfo); + if (merged != null) return merged; + return TypeInfo.fromJSTypeInfo(jsTypeInfo); + } + + // Check primitives and common types + switch (baseName.toLowerCase()) { + case "string": + return TypeInfo.STRING; + case "number": + case "int": + case "integer": + return TypeInfo.NUMBER; + case "boolean": + case "bool": + return TypeInfo.BOOLEAN; + case "void": + return TypeInfo.VOID; + case "any": + case "object": + case "*": + return TypeInfo.ANY; + } + + // Fall back to Java type resolution + TypeInfo javaType = resolveFullName(baseName); + if (javaType != null && javaType.isResolved()) { + return javaType; + } + + // Unresolved + return TypeInfo.unresolved(baseName, baseName); + } + + private static TypeInfo getJSJavaMergeBase(String baseName) { + switch (baseName) { + case "String": + return TypeInfo.STRING; + case "Object": + return TypeInfo.OBJECT; + default: + return null; + } + } + + public JSTypeInfo findJSTypeForJavaClass(Class javaClass) { + if (javaClass == null) return null; + String simpleName = javaClass.getSimpleName(); + if (getJSJavaMergeBase(simpleName) != null) { + return getJSTypeRegistry().getType(simpleName); + } + return getJSTypeRegistry().getTypeByJavaFqn(javaClass.getName()); + } + + /** + * For certain core types (e.g., String, Object), we want to merge JS type info from .d.ts with the Java TypeInfo to create an enriched type that has both Java and JS members. + */ + private TypeInfo tryMergeJSWithJava(String baseName, JSTypeInfo jsTypeInfo) { + TypeInfo javaBase = getJSJavaMergeBase(baseName); + if (javaBase == null) return null; + + return jsMergeCache.computeIfAbsent(baseName, k -> { + TypeInfo result = TypeInfo.fromClass(javaBase.getJavaClass()); + if (result == null) result = javaBase; + TypeInfo.injectJSMembers(result, jsTypeInfo); + if (javaBase == TypeInfo.STRING) { + TypeInfo.jsString = result; + } else if (javaBase == TypeInfo.OBJECT) { + TypeInfo.jsObject = result; + } + return result; + }); + } + + /** + * Check if a JS type name is a primitive. + */ + public boolean isJSPrimitive(String typeName) { + return JS_PRIMITIVE_TO_JAVA.containsKey(typeName); + } + + // ==================== TYPE RESOLUTION ==================== + + /** + * Resolve a fully-qualified class name. + * Handles inner classes with both dot and dollar notation. + */ + public TypeInfo resolveFullName(String fullName) { + if (fullName == null || fullName.isEmpty()) { + return null; + } + + // Normalize: remove whitespace around dots + String normalized = fullName.replaceAll("\\s*\\.\\s*", ".").trim(); + + // Check cache first + if (typeCache.containsKey(normalized)) { + return typeCache.get(normalized); + } + + // Try direct resolution + TypeInfo result = tryResolveClass(normalized); + if (result != null) { + return result; + } + + // Try converting dots to $ for inner classes + // Work backwards from the end, trying each segment as an inner class + String[] segments = normalized.split("\\."); + for (int i = segments.length - 1; i > 0; i--) { + StringBuilder candidate = new StringBuilder(); + // Package portion + for (int j = 0; j < i; j++) { + if (j > 0) candidate.append('.'); + candidate.append(segments[j]); + } + // Class portion with $ + for (int j = i; j < segments.length; j++) { + candidate.append(j == i ? '.' : '$'); + candidate.append(segments[j]); + } + + result = tryResolveClass(candidate.toString()); + if (result != null) { + // Cache the original lookup + typeCache.put(normalized, result); + return result; + } + } + + // Not found - cache the miss + typeCache.put(normalized, null); + return null; + } + + /** + * Resolve a simple class name using provided import context. + */ + public TypeInfo resolveSimpleName(String simpleName, + Map imports, + Set wildcardPackages) { + if (simpleName == null || simpleName.isEmpty()) { + return TypeInfo.unresolved(simpleName,simpleName); + } + + // 1. Check explicit imports + ImportData importData = imports.get(simpleName); + if (importData != null && importData.getResolvedType() != null) { + return importData.getResolvedType(); + } + if (importData != null) { + TypeInfo resolved = resolveFullName(importData.getFullPath()); + if (resolved != null) { + importData.setResolvedType(resolved); + return resolved; + } + } + + // 2. Check java.lang + if (JAVA_LANG_CLASSES.contains(simpleName)) { + TypeInfo langType = resolveFullName("java.lang." + simpleName); + if (langType != null) { + return langType; + } + } + + // 3. Check wildcard packages + if (wildcardPackages != null) { + for (String pkg : wildcardPackages) { + // Try as package.ClassName + TypeInfo fromPkg = resolveFullName(pkg + "." + simpleName); + if (fromPkg != null) { + return fromPkg; + } + + // Try as OuterClass$InnerClass (for class-level wildcards like IOverlay.*) + TypeInfo fromInner = resolveFullName(pkg + "$" + simpleName); + if (fromInner != null) { + return fromInner; + } + } + } + + return TypeInfo.unresolved(simpleName,simpleName); + } + + /** + * Try to load a class and create TypeInfo for it. + */ + private TypeInfo tryResolveClass(String className) { + if (className == null || className.isEmpty()) { + return null; + } + + // Check cache + if (typeCache.containsKey(className)) { + return typeCache.get(className); + } + + try { + Class clazz = Class.forName(className); + TypeInfo info = TypeInfo.fromClass(clazz); + typeCache.put(className, info); + + // Register the package as valid + registerPackage(info.getPackageName()); + + return info; + } catch (ClassNotFoundException e) { + // Cache the miss + typeCache.put(className, null); + return null; + } catch (LinkageError e) { + // NoClassDefFoundError is a subclass of LinkageError + typeCache.put(className, null); + return null; + } + } + + // ==================== PACKAGE VALIDATION ==================== + + /** + * Check if a package path is valid. + */ + public boolean isValidPackage(String packagePath) { + if (packagePath == null || packagePath.isEmpty()) { + return false; + } + + if (validPackages.contains(packagePath)) { + return true; + } + + if (PackageFinder.find(packagePath)) { + registerPackage(packagePath); + return true; + } + + // Try to find a class in this package to validate it + String[] testClasses = getTestClassesForPackage(packagePath); + for (String testClass : testClasses) { + try { + Class.forName(testClass); + registerPackage(packagePath); + return true; + } catch (ClassNotFoundException | LinkageError ignored) { + } + } + + return false; + } + + /** + * Register a package path as valid (and all parent packages). + */ + private void registerPackage(String packagePath) { + if (packagePath == null || packagePath.isEmpty()) { + return; + } + validPackages.add(packagePath); + + // Also register parent packages + int lastDot; + String current = packagePath; + while ((lastDot = current.lastIndexOf('.')) > 0) { + current = current.substring(0, lastDot); + validPackages.add(current); + } + } + + private String[] getTestClassesForPackage(String packagePath) { + switch (packagePath) { + case "java": + return new String[]{"java.lang.Object"}; + case "java.util": + return new String[]{"java.util.List", "java.util.Map"}; + case "java.io": + return new String[]{"java.io.File", "java.io.InputStream"}; + case "java.net": + return new String[]{"java.net.URL", "java.net.Socket"}; + case "java.lang": + return new String[]{"java.lang.Object", "java.lang.String"}; + default: + return new String[]{}; + } + } + + // ==================== IMPORT RESOLUTION ==================== + + /** + * Resolve all imports and return a map of simple name -> ImportData. + */ + public Map resolveImports(List imports) { + Map resolved = new HashMap<>(); + + for (ImportData imp : imports) { + if (imp.isWildcard()) { + // Wildcard imports: validate the package exists + imp.markResolved(isValidPackage(imp.getFullPath()) || + resolveFullName(imp.getFullPath()) != null); + } else { + // Specific import: resolve the class + TypeInfo typeInfo = resolveFullName(imp.getFullPath()); + imp.setResolvedType(typeInfo); + if (imp.getSimpleName() != null) { + resolved.put(imp.getSimpleName(), imp); + } + } + } + + return resolved; + } + + // ==================== GENERIC TYPE PARSING ==================== + + /** + * Parse type names from generic content like "Map>". + * Returns TypeInfo for each type found. + */ + public List parseGenericTypes(String content, + Map imports, + Set wildcardPackages) { + List results = new ArrayList<>(); + parseGenericTypesRecursive(content, 0, imports, wildcardPackages, results); + return results; + } + + private void parseGenericTypesRecursive(String content, int baseOffset, + Map imports, + Set wildcardPackages, + List results) { + if (content == null || content.isEmpty()) return; + + int i = 0; + while (i < content.length()) { + char c = content.charAt(i); + + // Skip non-identifier characters + if (!Character.isJavaIdentifierStart(c)) { + i++; + continue; + } + + // Found start of identifier + int start = i; + while (i < content.length() && Character.isJavaIdentifierPart(content.charAt(i))) { + i++; + } + String typeName = content.substring(start, i); + + // Only process uppercase-starting identifiers as types + if (Character.isUpperCase(typeName.charAt(0))) { + TypeInfo info = resolveSimpleName(typeName, imports, wildcardPackages); + results.add(new GenericTypeOccurrence( + baseOffset + start, + baseOffset + i, + typeName, + info + )); + } + + // Skip whitespace + while (i < content.length() && Character.isWhitespace(content.charAt(i))) { + i++; + } + + // Check for nested generic + if (i < content.length() && content.charAt(i) == '<') { + int nestedStart = i + 1; + int depth = 1; + i++; + + while (i < content.length() && depth > 0) { + if (content.charAt(i) == '<') depth++; + else if (content.charAt(i) == '>') depth--; + i++; + } + + // Recursively parse nested content + if (nestedStart < i - 1) { + String nestedContent = content.substring(nestedStart, i - 1); + parseGenericTypesRecursive(nestedContent, baseOffset + nestedStart, + imports, wildcardPackages, results); + } + } + } + } + + + /** + * Check if a type name is a primitive type. + */ + public static boolean isPrimitiveType(String typeName) { + return typeName.equals("boolean") || typeName.equals("byte") || typeName.equals("char") || + typeName.equals("short") || typeName.equals("int") || typeName.equals("long") || + typeName.equals("float") || typeName.equals("double") || typeName.equals("void"); + } + + /** + * Check if a word is a Java modifier keyword. + */ + public static boolean isModifier(String word) { + return word.equals("public") || word.equals("private") || word.equals("protected") || + word.equals("static") || word.equals("final") || word.equals("abstract") || + word.equals("synchronized") || word.equals("volatile") || word.equals("transient") || + word.equals("native") || word.equals("strictfp"); + } + + // ==================== CLASS SEARCH ==================== + + /** + * Search for classes matching the given prefix. + * Uses ClassIndex for O(n) lookup where n is the number of indexed classes. + * + * @param prefix The prefix to match (case-sensitive for class names) + * @param maxResults Maximum number of results to return + * @return List of fully-qualified class names that match + */ + public List findClassesByPrefix(String prefix, int maxResults) { + return ClassIndex.getInstance().findByPrefix(prefix, maxResults); + } + + /** + * @deprecated Use findClassesByPrefix instead for prefix matching + */ + @Deprecated + public List findClassesBySimpleName(String simpleName, int maxResults) { + // Redirect to prefix matching for backwards compatibility + return findClassesByPrefix(simpleName, maxResults); + } + + /** + * Represents a type occurrence within generic content. + */ + public static class GenericTypeOccurrence { + public final int startOffset; + public final int endOffset; + public final String typeName; + public final TypeInfo typeInfo; + + public GenericTypeOccurrence(int startOffset, int endOffset, String typeName, TypeInfo typeInfo) { + this.startOffset = startOffset; + this.endOffset = endOffset; + this.typeName = typeName; + this.typeInfo = typeInfo; + } + + public TokenType getTokenType() { + if (typeInfo == null || !typeInfo.isResolved()) { + return TokenType.UNDEFINED_VAR; + } + return typeInfo.getTokenType(); + } + } + + /** + * Check if an expression represents static access (accessing a Class, not an instance). + * This checks if the expression STRING resolves to a TYPE name. + * + * Examples: + * - "String" -> true (it's a class name) + * - "myVar" -> false (it's a variable, even if myVar holds a ClassTypeInfo) + * - "Java" -> true (it's a synthetic type) + * + * Note: This is different from checking if a variable's TYPE is ClassTypeInfo. + * For variables holding ClassTypeInfo (like `var File = Java.type("File")`), + * the receiver type itself should be checked separately. + * + * @param typeInfo The resolved TypeInfo (can be null) + * @param wasResolvedAsType true if this was resolved as a type name (not a variable) + * @return true if this represents static access (direct class reference) + */ + public static boolean isStaticAccess(TypeInfo typeInfo, boolean wasResolvedAsType) { + // If explicitly resolved as a type name, it's static access + if (wasResolvedAsType) + return true; + + if (typeInfo == null) + return false; + + // If the typeInfo itself is a ClassTypeInfo (e.g., result of Java.type()), + // then accessing members on it should be static + if (typeInfo.isClassReference()) + return true; + + return false; + } + + /** + * Unified static access checker for expressions. + * Determines if an identifier represents static access (type name) or instance access (variable). + * + * This method is used by ScriptDocument, JavaAutocompleteProvider, and FieldChainMarker. + * + * @param identifier The identifier to check (e.g., "String", "myVar", "Java") + * @param position The position in the document for context + * @param document The script document for resolution + * @return true if this represents static access + */ + public static boolean isStaticAccessExpression(String identifier, int position, ScriptDocument document) { + if (identifier == null || identifier.isEmpty() || document == null) { + return false; + } + + // If the identifier contains dots, parentheses, brackets, or operators, it's a complex expression + // Complex expressions (method calls, field chains, arithmetic) are instance access by default + if (identifier.contains(".") || identifier.contains("(") || identifier.contains("[") || + document.containsOperators(identifier)) { + // For complex expressions, resolve as expression and check the result type + TypeInfo exprType = document.resolveExpressionType(identifier, position); + // Only static if the expression result is itself a ClassTypeInfo (e.g., Java.type("File")) + if (isStaticAccess(exprType, false)) + return true; + // Dotted script type name like "Outer.Inner" is always static access + if (!identifier.contains("(") && !identifier.contains("[") && !document.containsOperators(identifier)) { + TypeInfo dotResolved = document.resolveType(identifier); + if (dotResolved instanceof ScriptTypeInfo) + return true; + } + return false; + } + + // Simple identifier - check if it's a variable/field (instance access) + FieldInfo fieldInfo = document.resolveVariable(identifier, position); + if (fieldInfo != null && fieldInfo.isResolved()) { + // It's a variable - check if its type is a ClassTypeInfo + return isStaticAccess(fieldInfo.getTypeInfo(), false); + } + + // Not a variable - check if it's a type name by trying to resolve as type + TypeInfo typeCheck = document.resolveType(identifier); + boolean isType = typeCheck != null && typeCheck.isResolved(); + return isStaticAccess(typeCheck, isType); + } + + /** + * Parse string literal arguments from a method call. + * Used for resolving dynamic return types like Java.type("className"). + * + * @param argumentsStr The arguments string (e.g., "\"java.io.File\", 123") + * @return Array of parsed arguments + */ + public static String[] parseStringArguments(String argumentsStr) { + if (argumentsStr == null || argumentsStr.isEmpty()) { + return new String[0]; + } + + List args = new ArrayList<>(); + StringBuilder current = new StringBuilder(); + int depth = 0; + boolean inString = false; + char stringChar = 0; + + for (int i = 0; i < argumentsStr.length(); i++) { + char c = argumentsStr.charAt(i); + + if (inString) { + current.append(c); + if (c == stringChar && (i == 0 || argumentsStr.charAt(i - 1) != '\\')) { + inString = false; + } + } else if (c == '"' || c == '\'') { + current.append(c); + inString = true; + stringChar = c; + } else if (c == '(' || c == '[' || c == '{') { + depth++; + current.append(c); + } else if (c == ')' || c == ']' || c == '}') { + depth--; + current.append(c); + } else if (c == ',' && depth == 0) { + args.add(current.toString().trim()); + current = new StringBuilder(); + } else { + current.append(c); + } + } + + if (current.length() > 0) { + args.add(current.toString().trim()); + } + + return args.toArray(new String[0]); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/TypeStringNormalizer.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/TypeStringNormalizer.java new file mode 100644 index 000000000..fd464f6d3 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/TypeStringNormalizer.java @@ -0,0 +1,221 @@ +package noppes.npcs.client.gui.util.script.interpreter.type; + +import java.util.ArrayList; +import java.util.List; + +/** + * Shared utilities for cleaning and normalizing type expressions. + * + * This is intentionally a small, dependency-light helper that both the runtime resolver + * and the .d.ts parser can use. + */ +public final class TypeStringNormalizer { + + private TypeStringNormalizer() {} + + public static final class ArraySplit { + public final String base; + public final int dimensions; + + public ArraySplit(String base, int dimensions) { + this.base = base; + this.dimensions = dimensions; + } + } + + /** + * Strip TypeScript import() type references anywhere in the string. + * + * Examples: + * - import('./data/IAction').IAction -> IAction + * - Java.java.util.function.Consumer -> Java.java.util.function.Consumer + */ + public static String stripImportTypeSyntax(String type) { + if (type == null) { + return null; + } + + String out = type.trim(); + int importIdx; + while ((importIdx = out.indexOf("import(")) >= 0) { + int i = importIdx + "import(".length(); + int depth = 1; + boolean inString = false; + char stringChar = 0; + + while (i < out.length() && depth > 0) { + char c = out.charAt(i); + if (inString) { + if (c == stringChar && (i == 0 || out.charAt(i - 1) != '\\')) { + inString = false; + } + } else { + if (c == '\'' || c == '"') { + inString = true; + stringChar = c; + } else if (c == '(') { + depth++; + } else if (c == ')') { + depth--; + } + } + i++; + } + + // i is positioned just after the matching ')', if found. + if (depth != 0) { + break; // Unbalanced import( ... ) - stop trying to clean. + } + + // If immediately followed by ".", remove the "import(...)." prefix. + if (i < out.length() && out.charAt(i) == '.') { + int removeEnd = i + 1; + out = out.substring(0, importIdx) + out.substring(removeEnd); + } else { + // Remove just the import(...) portion. + out = out.substring(0, importIdx) + out.substring(i); + } + } + + return out; + } + + /** + * Split a trailing TypeScript nullable suffix: Foo? -> Foo. + */ + public static String stripNullableSuffix(String type) { + if (type == null) { + return null; + } + String out = type.trim(); + if (out.endsWith("?")) { + return out.substring(0, out.length() - 1).trim(); + } + return out; + } + + /** + * Split trailing array suffixes: Foo[][] -> base=Foo, dimensions=2. + */ + public static ArraySplit splitArraySuffixes(String type) { + if (type == null) { + return new ArraySplit(null, 0); + } + String out = type.trim(); + int dims = 0; + while (out.endsWith("[]")) { + dims++; + out = out.substring(0, out.length() - 2).trim(); + } + return new ArraySplit(out, dims); + } + + /** + * Split a top-level union (depth-aware) into branches. + */ + public static List splitTopLevelUnion(String type) { + List parts = new ArrayList<>(); + if (type == null) { + return parts; + } + + String expr = type.trim(); + if (expr.isEmpty()) { + parts.add(""); + return parts; + } + + int depth = 0; + boolean inString = false; + char stringChar = 0; + + int start = 0; + for (int i = 0; i < expr.length(); i++) { + char c = expr.charAt(i); + + if (inString) { + if (c == stringChar && (i == 0 || expr.charAt(i - 1) != '\\')) { + inString = false; + } + continue; + } + + if (c == '\'' || c == '"' || c == '`') { + inString = true; + stringChar = c; + continue; + } + + if (c == '<' || c == '(' || c == '[' || c == '{') { + depth++; + continue; + } + if (c == '>' || c == ')' || c == ']' || c == '}') { + if (depth > 0) { + depth--; + } + continue; + } + + if (c == '|' && depth == 0) { + String part = expr.substring(start, i).trim(); + if (!part.isEmpty()) { + parts.add(part); + } + start = i + 1; + } + } + + String tail = expr.substring(start).trim(); + if (!tail.isEmpty()) { + parts.add(tail); + } + + if (parts.isEmpty()) { + parts.add(expr); + } + return parts; + } + + /** + * Choose a single branch to represent a union type for resolution. + * + * Policy: + * - Prefer the first non-nullish branch (not null/undefined/void). + * - Otherwise, fall back to the first branch. + */ + public static String pickPreferredUnionBranch(String type) { + if (type == null) { + return null; + } + + List parts = splitTopLevelUnion(type); + if (parts.size() <= 1) { + return type.trim(); + } + + for (String part : parts) { + if (!isNullishBranch(part)) { + return part.trim(); + } + } + + return parts.get(0).trim(); + } + + private static boolean isNullishBranch(String part) { + if (part == null) { + return false; + } + + String s = part.trim(); + if (s.isEmpty()) { + return false; + } + + // Strip generics so "null<...>" doesn't behave weirdly. + s = GenericTypeParser.stripGenerics(s); + s = s.trim().toLowerCase(); + return "null".equals(s) || "undefined".equals(s) || "void".equals(s); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/TypeSubstitutor.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/TypeSubstitutor.java new file mode 100644 index 000000000..514174743 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/TypeSubstitutor.java @@ -0,0 +1,197 @@ +package noppes.npcs.client.gui.util.script.interpreter.type; + +import noppes.npcs.client.gui.util.script.interpreter.js_parser.TypeParamInfo; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * Utility for substituting type variables (like T, E, K, V) with concrete types. + * + * Used when resolving members on parameterized types: + * - List.get(int) returns String (not T/Object) + * - Map.get(Object) returns Integer (not V) + * + * Handles nested generics: + * - List>.get(0) returns Map + */ +public class TypeSubstitutor { + + /** + * Create a binding map from declared type parameters to applied type arguments. + * + * Example: For List where List is declared as interface List: + * - declaredParams = [TypeParamInfo("E", ...)] + * - appliedArgs = [TypeInfo(String)] + * - Result: {"E" -> TypeInfo(String)} + * + * @param declaredParams The declared type parameters (from the generic type definition) + * @param appliedArgs The applied type arguments (from the parameterized usage) + * @return A map from type parameter names to their concrete TypeInfo values + */ + public static Map createBindings(List declaredParams, List appliedArgs) { + Map bindings = new HashMap<>(); + + if (declaredParams == null || appliedArgs == null) { + return bindings; + } + + int count = Math.min(declaredParams.size(), appliedArgs.size()); + for (int i = 0; i < count; i++) { + String paramName = declaredParams.get(i).getName(); + TypeInfo argType = appliedArgs.get(i); + if (paramName != null && argType != null) { + bindings.put(paramName, argType); + } + } + + return bindings; + } + + /** + * Create bindings from a parameterized receiver type. + * + * @param receiverType The parameterized type (e.g., List) + * @return Bindings from the type's declared params to its applied args + */ + public static Map createBindingsFromReceiver(TypeInfo receiverType) { + if (receiverType == null) { + return new HashMap<>(); + } + + // Get the raw type to access declared type parameters + TypeInfo rawType = receiverType.getRawType(); + List declaredParams = null; + + // Get declared params from JSTypeInfo or reflection + if (rawType.isJSType() && rawType.getJSTypeInfo() != null) { + declaredParams = rawType.getJSTypeInfo().getTypeParams(); + } else { + declaredParams = rawType.getTypeParams(); + } + + // Get applied args from the parameterized type + List appliedArgs = receiverType.getAppliedTypeArgs(); + + return createBindings(declaredParams, appliedArgs); + } + + /** + * Substitute type variables in a type using the given bindings. + * + * @param type The type to substitute (may contain type variables like T, E) + * @param bindings The map from type variable names to concrete types + * @return The substituted type + */ + public static TypeInfo substitute(TypeInfo type, Map bindings) { + if (type == null || bindings == null || bindings.isEmpty()) { + return type; + } + + String typeName = type.getSimpleName(); + + // Check if this type is itself a type variable + if (!type.isResolved()) { + TypeInfo substitution = bindings.get(typeName); + if (substitution != null) { + return substitution; + } + } + + // If the type has applied type arguments, substitute within them recursively + if (type.isParameterized()) { + List originalArgs = type.getAppliedTypeArgs(); + List substitutedArgs = new ArrayList<>(); + boolean changed = false; + + for (TypeInfo arg : originalArgs) { + TypeInfo substitutedArg = substitute(arg, bindings); + substitutedArgs.add(substitutedArg); + if (substitutedArg != arg) { + changed = true; + } + } + + if (changed) { + // Create a new parameterized type with substituted args + return type.getRawType().parameterize(substitutedArgs); + } + } + + // Handle array types - substitute the element type + if (type.getSimpleName().endsWith("[]")) { + TypeStringNormalizer.ArraySplit split = TypeStringNormalizer.splitArraySuffixes(typeName); + String elementTypeName = split.base; + int dims = split.dimensions; + TypeInfo elementSubstitution = elementTypeName != null ? bindings.get(elementTypeName) : null; + if (elementSubstitution != null) { + TypeInfo result = elementSubstitution; + for (int i = 0; i < dims; i++) { + result = TypeInfo.arrayOf(result); + } + return result; + } + } + + return type; + } + + /** + * Substitute type variables in a type string using the given bindings. + * Used when we have a raw type string (like "T" or "List") that needs substitution. + * + * @param typeString The raw type string + * @param bindings The map from type variable names to concrete types + * @param resolver The type resolver to use for parsing + * @return The substituted TypeInfo + */ + public static TypeInfo substituteString(String typeString, Map bindings, TypeResolver resolver) { + if (typeString == null || typeString.isEmpty()) { + return null; + } + + // First check if the whole string is a type variable + String trimmed = TypeStringNormalizer.stripImportTypeSyntax(typeString); + trimmed = TypeStringNormalizer.pickPreferredUnionBranch(trimmed); + trimmed = TypeStringNormalizer.stripNullableSuffix(trimmed); + + TypeStringNormalizer.ArraySplit arraySplit = TypeStringNormalizer.splitArraySuffixes(trimmed); + String baseName = arraySplit.base; + int arrayDims = arraySplit.dimensions; + + // Strip generic args to check the base name + String bareBaseName = GenericTypeParser.stripGenerics(baseName); + + // If bare base name is a type variable, substitute + TypeInfo directSubstitution = bindings.get(bareBaseName); + if (directSubstitution != null) { + // It's a type variable, return the substitution + TypeInfo result = directSubstitution; + for (int i = 0; i < arrayDims; i++) { + result = TypeInfo.arrayOf(result); + } + return result; + } + + // Parse and resolve the type, then substitute within it + TypeInfo resolved = resolver.resolveJSType(typeString); + return substitute(resolved, bindings); + } + + /** + * Get the return type for a method on a parameterized receiver, with type variable substitution. + * + * @param rawReturnType The method's raw return type (may contain type variables) + * @param rawReturnTypeString The method's raw return type as a string (for unresolved types) + * @param receiverType The parameterized receiver type + * @param resolver The type resolver + * @return The substituted return type + */ + public static TypeInfo getSubstitutedReturnType(TypeInfo rawReturnType, String rawReturnTypeString, + TypeInfo receiverType, TypeResolver resolver) { + GenericContext ctx = GenericContext.forReceiver(receiverType); + return ctx.substituteType(rawReturnType, rawReturnTypeString, resolver); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/synthetic/SyntheticField.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/synthetic/SyntheticField.java new file mode 100644 index 000000000..4bb2bc684 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/synthetic/SyntheticField.java @@ -0,0 +1,45 @@ +package noppes.npcs.client.gui.util.script.interpreter.type.synthetic; + +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeResolver; + +import java.lang.reflect.Modifier; + +public class SyntheticField { + public final String name; + public final String typeName; + public final String documentation; + public final boolean isStatic; + + SyntheticField(String name, String typeName, String documentation, boolean isStatic) { + this.name = name; + this.typeName = typeName; + this.documentation = documentation; + this.isStatic = isStatic; + } + + /** + * Get the field type as TypeInfo. + * @return The resolved TypeInfo for the field type, or unresolved if not found + */ + public TypeInfo getTypeInfo() { + TypeInfo type = TypeResolver.getInstance().resolve(typeName); + if (type == null) { + type = TypeInfo.unresolved(typeName, typeName); + } + return type; + } + + public FieldInfo toFieldInfo() { + TypeInfo type = TypeResolver.getInstance().resolve(typeName); + if (type == null) { + type = TypeInfo.unresolved(typeName, typeName); + } + int modifiers = Modifier.PUBLIC; + if (isStatic) { + modifiers |= Modifier.STATIC; + } + return FieldInfo.external(name, type, documentation, modifiers); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/synthetic/SyntheticMethod.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/synthetic/SyntheticMethod.java new file mode 100644 index 000000000..2a7c35efc --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/synthetic/SyntheticMethod.java @@ -0,0 +1,165 @@ +package noppes.npcs.client.gui.util.script.interpreter.type.synthetic; + +import noppes.npcs.client.gui.util.script.interpreter.field.FieldInfo; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocInfo; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocParamTag; +import noppes.npcs.client.gui.util.script.interpreter.jsdoc.JSDocReturnTag; +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeResolver; + +import java.lang.reflect.Modifier; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class SyntheticMethod { + public final String name; + public final String returnType; + public final List parameters; + public final String documentation; + public final boolean isStatic; + public final SyntheticTypeBuilder.ReturnTypeResolver returnTypeResolver; + + SyntheticMethod(String name, String returnType, List parameters, + String documentation, boolean isStatic, + SyntheticTypeBuilder.ReturnTypeResolver returnTypeResolver) { + this.name = name; + this.returnType = returnType; + this.parameters = Collections.unmodifiableList(new ArrayList<>(parameters)); + this.documentation = documentation; + this.isStatic = isStatic; + this.returnTypeResolver = returnTypeResolver; + } + + /** + * Get the return type as TypeInfo. + * @return The resolved TypeInfo for the return type, or unresolved if not found + */ + public TypeInfo getReturnTypeInfo() { + TypeInfo returnTypeInfo = TypeResolver.getInstance().resolve(returnType); + if (returnTypeInfo == null) { + returnTypeInfo = TypeInfo.unresolved(returnType, returnType); + } + return returnTypeInfo; + } + + /** + * Resolve the return type with dynamic arguments (for methods like Java.type). + * @param arguments The method call arguments + * @return The dynamically resolved TypeInfo, or static return type if no resolver + */ + public TypeInfo resolveReturnType(String[] arguments) { + if (returnTypeResolver != null) { + return returnTypeResolver.resolve(arguments); + } + return getReturnTypeInfo(); + } + + /** + * Create a MethodInfo from this synthetic method. + */ + public MethodInfo toMethodInfo(TypeInfo containingType) { + List paramInfos = new ArrayList<>(); + for (SyntheticParameter param : parameters) { + String typeName = param.typeName; + boolean isVarArg = typeName != null && typeName.endsWith("..."); + if (isVarArg) typeName = typeName.substring(0, typeName.length() - 3); + TypeInfo paramType = TypeResolver.getInstance().resolve(typeName); + if (paramType == null) { + paramType = TypeInfo.unresolved(typeName, typeName); + } + FieldInfo fieldInfo = FieldInfo.parameter(param.name, paramType, -1, null); + fieldInfo.setVarArg(isVarArg); + paramInfos.add(fieldInfo); + } + + TypeInfo returnTypeInfo = TypeResolver.getInstance().resolve(returnType); + if (returnTypeInfo == null) { + returnTypeInfo = TypeInfo.unresolved(returnType, returnType); + } + + int modifiers = Modifier.PUBLIC; + if (isStatic) { + modifiers |= Modifier.STATIC; + } + + MethodInfo methodInfo = MethodInfo.external(name, returnTypeInfo, containingType, paramInfos, modifiers, null); + + // Create JSDocInfo from documentation + if (documentation != null && !documentation.isEmpty()) { + JSDocInfo jsDocInfo = createJSDocInfo(returnTypeInfo); + methodInfo.setJSDocInfo(jsDocInfo); + } + + return methodInfo; + } + + /** + * Create JSDocInfo from the documentation string. + */ + private JSDocInfo createJSDocInfo(TypeInfo returnTypeInfo) { + // Parse the documentation to extract description and separate sections + String[] lines = documentation.split("\\n"); + StringBuilder descBuilder = new StringBuilder(); + + // Extract description (everything before @param or @returns) + for (String line : lines) { + line = line.trim(); + if (line.startsWith("@param") || line.startsWith("@returns") || line.startsWith("@return")) { + break; + } + if (!line.isEmpty()) { + if (descBuilder.length() > 0) + descBuilder.append("\n"); + descBuilder.append(line); + } + } + + JSDocInfo jsDocInfo = new JSDocInfo(documentation, -1, -1); + jsDocInfo.setDescription(descBuilder.toString()); + + // Add @param tags for each parameter + for (int i = 0; i < parameters.size(); i++) { + SyntheticParameter param = parameters.get(i); + TypeInfo paramType = TypeResolver.getInstance().resolve(param.typeName); + if (paramType == null) { + paramType = TypeInfo.unresolved(param.typeName, param.typeName); + } + + JSDocParamTag paramTag = JSDocParamTag.create( + -1, -1, -1, // offsets + param.typeName, paramType, -1, -1, // type info + param.name, -1, -1, // param name + param.documentation // description + ); + jsDocInfo.addParamTag(paramTag); + } + + // Add @returns tag + JSDocReturnTag returnTag = JSDocReturnTag.create( + "returns", -1, -1, -1, // offsets + returnTypeInfo.getSimpleName(), returnTypeInfo, -1, -1, // type info + null // description extracted from main documentation + ); + jsDocInfo.setReturnTag(returnTag); + + return jsDocInfo; + } + + /** + * Get signature string for display. + */ + public String getSignature() { + StringBuilder sb = new StringBuilder(); + sb.append(name).append("("); + for (int i = 0; i < parameters.size(); i++) { + if (i > 0) + sb.append(", "); + SyntheticParameter p = parameters.get(i); + sb.append(p.name).append(": ").append(p.typeName); + } + sb.append("): ").append(returnType); + return sb.toString(); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/synthetic/SyntheticParameter.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/synthetic/SyntheticParameter.java new file mode 100644 index 000000000..bf9a5fe97 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/synthetic/SyntheticParameter.java @@ -0,0 +1,28 @@ +package noppes.npcs.client.gui.util.script.interpreter.type.synthetic; + +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeResolver; + +public class SyntheticParameter { + public final String name; + public final String typeName; + public final String documentation; + + SyntheticParameter(String name, String typeName, String documentation) { + this.name = name; + this.typeName = typeName; + this.documentation = documentation; + } + + /** + * Get the parameter type as TypeInfo. + * @return The resolved TypeInfo for the parameter type, or unresolved if not found + */ + public TypeInfo getTypeInfo() { + TypeInfo type = TypeResolver.getInstance().resolve(typeName); + if (type == null) { + type = TypeInfo.unresolved(typeName, typeName); + } + return type; + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/synthetic/SyntheticType.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/synthetic/SyntheticType.java new file mode 100644 index 000000000..01878d2f5 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/synthetic/SyntheticType.java @@ -0,0 +1,95 @@ +package noppes.npcs.client.gui.util.script.interpreter.type.synthetic; + +import noppes.npcs.client.gui.util.script.interpreter.method.MethodInfo; +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +import java.util.*; + +/** + * Represents a fully-built synthetic type. + */ +public class SyntheticType { + private final String name; + private final String documentation; + private final Map methods; + private final Map fields; + private TypeInfo typeInfo; + + SyntheticType(String name, String documentation, List methods, + List fields) { + this.name = name; + this.documentation = documentation; + this.methods = new LinkedHashMap<>(); + for (SyntheticMethod m : methods) { + this.methods.put(m.name, m); + } + this.fields = new LinkedHashMap<>(); + for (SyntheticField f : fields) { + this.fields.put(f.name, f); + } + } + + public String getName() { + return name; + } + + public String getDocumentation() { + return documentation; + } + + public SyntheticMethod getMethod(String methodName) { + return methods.get(methodName); + } + + public Collection getMethods() { + return methods.values(); + } + + public SyntheticField getField(String fieldName) { + return fields.get(fieldName); + } + + public Collection getFields() { + return fields.values(); + } + + public boolean hasMethod(String methodName) { + return methods.containsKey(methodName); + } + + public boolean hasField(String fieldName) { + return fields.containsKey(fieldName); + } + + /** + * Get or create the TypeInfo for this synthetic type. + */ + public TypeInfo getTypeInfo() { + if (typeInfo == null) { + typeInfo = TypeInfo.resolved(name, name, "", TypeInfo.Kind.CLASS, null); + } + return typeInfo; + } + + /** + * Create a MethodInfo for a method in this type. + */ + public MethodInfo getMethodInfo(String methodName) { + SyntheticMethod method = methods.get(methodName); + if (method == null) + return null; + return method.toMethodInfo(getTypeInfo()); + } + + /** + * Resolve the return type of a method given arguments. + * Used for special methods like Java.type(). + */ + public TypeInfo resolveMethodReturnType(String methodName, String[] arguments) { + SyntheticMethod method = methods.get(methodName); + if (method == null) + return null; + + return method.resolveReturnType(arguments); + } +} diff --git a/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/synthetic/SyntheticTypeBuilder.java b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/synthetic/SyntheticTypeBuilder.java new file mode 100644 index 000000000..02fc4d586 --- /dev/null +++ b/src/main/java/noppes/npcs/client/gui/util/script/interpreter/type/synthetic/SyntheticTypeBuilder.java @@ -0,0 +1,165 @@ +package noppes.npcs.client.gui.util.script.interpreter.type.synthetic; + +import noppes.npcs.client.gui.util.script.interpreter.type.TypeInfo; + +import java.util.*; + +/** + * Builder for creating synthetic (non-reflection-based) types. + * Used for built-in Nashorn objects like 'Java' that have no corresponding Java class. + * + *

Usage:

+ *
+ * SyntheticType javaType = new SyntheticTypeBuilder("Java")
+ *     .addMethod("type")
+ *         .parameter("className", "string")
+ *         .returns("Class")
+ *         .documentation("Loads a Java class by fully-qualified name.")
+ *         .done()
+ *     .build();
+ * 
+ */ +public class SyntheticTypeBuilder { + + private final String name; + private String documentation; + private final List methods = new ArrayList<>(); + private final List fields = new ArrayList<>(); + + public SyntheticTypeBuilder(String name) { + this.name = name; + } + + public SyntheticTypeBuilder documentation(String doc) { + this.documentation = doc; + return this; + } + + /** + * Start building a method for this type. + */ + public MethodBuilder addMethod(String methodName) { + return new MethodBuilder(this, methodName); + } + + /** + * Add a field to this type. + */ + public SyntheticTypeBuilder addField(String fieldName, String typeName, String doc) { + fields.add(new SyntheticField(fieldName, typeName, doc, false)); + return this; + } + + /** + * Add a static field to this type. + */ + public SyntheticTypeBuilder addStaticField(String fieldName, String typeName, String doc) { + fields.add(new SyntheticField(fieldName, typeName, doc, true)); + return this; + } + + void addBuiltMethod(SyntheticMethod method) { + methods.add(method); + } + + /** + * Build the synthetic type. + */ + public SyntheticType build() { + return new SyntheticType(name, documentation, methods, fields); + } + + // ==================== Inner classes ==================== + + /** + * Builder for methods within a synthetic type. + */ + public static class MethodBuilder { + private final SyntheticTypeBuilder parent; + private final String name; + private final List parameters = new ArrayList<>(); + private String returnType = "void"; + private String documentation; + private boolean isStatic = false; + private ReturnTypeResolver returnTypeResolver; + + MethodBuilder(SyntheticTypeBuilder parent, String name) { + this.parent = parent; + this.name = name; + } + + /** + * Add a parameter to this method. + */ + public MethodBuilder parameter(String paramName, String typeName) { + parameters.add(new SyntheticParameter(paramName, typeName, null)); + return this; + } + + /** + * Add a parameter with documentation. + */ + public MethodBuilder parameter(String paramName, String typeName, String doc) { + parameters.add(new SyntheticParameter(paramName, typeName, doc)); + return this; + } + + /** + * Set the return type. + */ + public MethodBuilder returns(String typeName) { + this.returnType = typeName; + return this; + } + + /** + * Set a dynamic return type resolver. + * Used for methods like Java.type() where return type depends on arguments. + */ + public MethodBuilder returnsResolved(ReturnTypeResolver resolver) { + this.returnTypeResolver = resolver; + return this; + } + + /** + * Set method documentation. + */ + public MethodBuilder documentation(String doc) { + this.documentation = doc; + return this; + } + + /** + * Mark this method as static. + */ + public MethodBuilder asStatic() { + this.isStatic = true; + return this; + } + + /** + * Finish building this method and return to the type builder. + */ + public SyntheticTypeBuilder done() { + parent.addBuiltMethod(new SyntheticMethod(name, returnType, parameters, documentation, isStatic, returnTypeResolver)); + return parent; + } + } + + /** + * Functional interface for resolving return types dynamically. + */ + @FunctionalInterface + public interface ReturnTypeResolver { + /** + * Resolve the return type given the arguments passed to the method. + * @param arguments The string arguments (for methods like Java.type("className")) + * @return The resolved TypeInfo, or null if cannot be resolved + */ + TypeInfo resolve(String[] arguments); + } + + // ==================== Data classes ==================== + + // ==================== SyntheticType (the result) ==================== +} diff --git a/src/main/java/noppes/npcs/client/key/KeyPreset.java b/src/main/java/noppes/npcs/client/key/KeyPreset.java index e76cf14ff..57ef067e1 100644 --- a/src/main/java/noppes/npcs/client/key/KeyPreset.java +++ b/src/main/java/noppes/npcs/client/key/KeyPreset.java @@ -94,10 +94,8 @@ public class KeyPreset { int keyCode = keyCode(); if (keyCode == -1 || keyCode == 0) return; - - boolean isDown = isMouseKey() ? Mouse.isButtonDown(keyCode + 100) : Keyboard.isKeyDown(keyCode); - isDown = isDown && (isCtrlKeyDown() == hasCtrl()) && (isAltKeyDown() == hasAlt()) && (isShiftKeyDown() == hasShift()); - setDown(isDown); + + setDown(currentState.isDown()); } private static final long SHORT_PRESS_MS = 250L; @@ -211,6 +209,11 @@ public class KeyPreset { state.setState(keyCode, hasCtrl, hasAlt, hasShift); } + public boolean isDown() { + boolean isDown = isMouseKey() ? Mouse.isButtonDown(keyCode + 100) : Keyboard.isKeyDown(keyCode); + return isDown && (isCtrlKeyDown() == hasCtrl) && (isAltKeyDown() == hasAlt) && (isShiftKeyDown() == hasShift); + } + public boolean hasState() { return keyCode != -1; } @@ -248,6 +251,19 @@ public class KeyPreset { this.hasAlt = compound.getBoolean("hasAlt"); } + public boolean matches(int keycode, boolean checkModifiers) { + if (!checkModifiers) + return this.keyCode == keycode; + + return this.keyCode == keycode && this.hasCtrl == KeyPreset.isCtrlKeyDown() + && this.hasAlt == KeyPreset.isAltKeyDown() + && this.hasShift == KeyPreset.isShiftKeyDown(); + } + + public boolean isMouseKey() { + return keyCode < -1; + } + public String getName() { int code = keyCode; String name = ""; diff --git a/src/main/java/noppes/npcs/client/key/KeyPresetManager.java b/src/main/java/noppes/npcs/client/key/KeyPresetManager.java index 1a978cdc7..df68eb812 100644 --- a/src/main/java/noppes/npcs/client/key/KeyPresetManager.java +++ b/src/main/java/noppes/npcs/client/key/KeyPresetManager.java @@ -24,6 +24,15 @@ public class KeyPresetManager { return preset; } + public boolean hasMatchingKeyPressed(int keyCode) { + for (KeyPreset key : keys) { + if (key.currentState.matches(keyCode, true)) + return true; + } + + return false; + } + public void tick() { for (KeyPreset key : keys) key.tick(); diff --git a/src/main/java/noppes/npcs/client/key/impl/ScriptEditorKeys.java b/src/main/java/noppes/npcs/client/key/impl/ScriptEditorKeys.java index 4a9e294d0..3029d4424 100644 --- a/src/main/java/noppes/npcs/client/key/impl/ScriptEditorKeys.java +++ b/src/main/java/noppes/npcs/client/key/impl/ScriptEditorKeys.java @@ -18,6 +18,11 @@ public class ScriptEditorKeys extends KeyPresetManager { public final KeyPreset FORMAT = add("Format Code").setDefaultState(Keyboard.KEY_F, false, true, false); public final KeyPreset TOGGLE_COMMENT = add("Toggle Comment").setDefaultState(Keyboard.KEY_SLASH, true, false, false); + // Editing + public final KeyPreset DELETE_LINE = add("Delete Line").setDefaultState(Keyboard.KEY_DELETE, true, false, false); + public final KeyPreset MOVE_LINE_UP = add("Move Line Up").setDefaultState(Keyboard.KEY_UP, false, true, false); + public final KeyPreset MOVE_LINE_DOWN = add("Move Line Down").setDefaultState(Keyboard.KEY_DOWN, false, true, false); + // Search/Replace public final KeyPreset SEARCH = add("Search").setDefaultState(Keyboard.KEY_F, true, false, false); public final KeyPreset SEARCH_REPLACE = add("Replace").setDefaultState(Keyboard.KEY_F, true, false, true); @@ -30,6 +35,9 @@ public class ScriptEditorKeys extends KeyPresetManager { // View public final KeyPreset FULLSCREEN = add("Toggle Fullscreen").setDefaultState(Keyboard.KEY_F11, false, false, false); + + // Autocomplete + public final KeyPreset AUTOCOMPLETE = add("Autocomplete").setDefaultState(Keyboard.KEY_SPACE, true, false, false); public ScriptEditorKeys() { super("script_editor"); diff --git a/src/main/java/noppes/npcs/config/ConfigScript.java b/src/main/java/noppes/npcs/config/ConfigScript.java index 15c2b9ca0..2b3d5d9d0 100644 --- a/src/main/java/noppes/npcs/config/ConfigScript.java +++ b/src/main/java/noppes/npcs/config/ConfigScript.java @@ -66,6 +66,9 @@ public class ConfigScript { public static Property ClearActionsOnDeathProperty; public static boolean ClearActionsOnDeath = true; + public static Property ShowImplementationFieldsInAutocompleteProperty; + public static boolean ShowImplementationFieldsInAutocomplete = false; + public static boolean IndividualPlayerScripts = false; public static void init(File configFile) { @@ -131,6 +134,11 @@ public class ConfigScript { ClearActionsOnDeathProperty = config.get(CUSTOMIZATION, "Clear Actions On Death", true, "If true, clears the Action Manager for players and NPCs when they die"); ClearActionsOnDeath = ClearActionsOnDeathProperty.getBoolean(true); + ShowImplementationFieldsInAutocompleteProperty = config.get(CUSTOMIZATION, "Autocomplete Implementation Fields", false, + "If true, shows fields from implementation classes in autocomplete menu like 'event.npc'.\n"+ + " This can be useful for advanced scripters who want to use fields from implementation classes."); + ShowImplementationFieldsInAutocomplete = ShowImplementationFieldsInAutocompleteProperty.getBoolean(false); + // Convert to Legacy if (CustomNpcs.legacyExist) { ScriptingEnabled = LegacyConfig.ScriptingEnabled; diff --git a/src/main/java/noppes/npcs/constants/ScriptContext.java b/src/main/java/noppes/npcs/constants/ScriptContext.java index 444006d30..572b8e038 100644 --- a/src/main/java/noppes/npcs/constants/ScriptContext.java +++ b/src/main/java/noppes/npcs/constants/ScriptContext.java @@ -136,6 +136,12 @@ public class ScriptContext { */ private final List namespaces; + /** + * Fully qualified names of the event interface classes this context supports. + * Only populated when registered via the Class overload. + */ + private final List namespaceFQNs = new ArrayList<>(); + // ==================== CONSTRUCTOR ==================== private ScriptContext(String id, String hookContext, String... namespaces) { @@ -155,6 +161,16 @@ public class ScriptContext { return Collections.unmodifiableList(namespaces); } + /** + * Get the fully qualified names of event interface classes this context supports. + * Only populated for contexts registered with Class references. + * + * @return Unmodifiable list of FQN strings (e.g., "noppes.npcs.api.event.INpcEvent") + */ + public List getNamespaceFQNs() { + return Collections.unmodifiableList(namespaceFQNs); + } + /** * Check if this context includes a specific namespace. * @@ -220,7 +236,11 @@ public class ScriptContext { for (int i = 0; i < eventClasses.length; i++) { namespaces[i] = eventClasses[i].getSimpleName(); } - return register(id, hookContext, namespaces); + ScriptContext context = register(id, hookContext, namespaces); + for (Class clazz : eventClasses) { + context.namespaceFQNs.add(clazz.getName().replace('$', '.')); + } + return context; } /** diff --git a/src/main/java/noppes/npcs/controllers/HookDefinition.java b/src/main/java/noppes/npcs/controllers/HookDefinition.java index 864e37ee3..be6c09397 100644 --- a/src/main/java/noppes/npcs/controllers/HookDefinition.java +++ b/src/main/java/noppes/npcs/controllers/HookDefinition.java @@ -148,9 +148,9 @@ public class HookDefinition implements IHookDefinition { } // Build required imports from event type - String importName = getImportForClass(eventType); - if (importName != null) { - builder.requiredImports(importName); + String[] importNames = getImportsForClass(eventType); + if (importNames.length > 0) { + builder.requiredImports(importNames); } } @@ -185,26 +185,31 @@ public class HookDefinition implements IHookDefinition { } /** - * Get the import statement needed for a class. - * For nested classes, returns the enclosing class. + * Get the import statements needed for a class. + * For nested classes, includes both enclosing and nested names. */ - private static String getImportForClass(Class clazz) { + private static String[] getImportsForClass(Class clazz) { if (clazz == null || clazz.isPrimitive()) { - return null; + return new String[0]; + } + + String fullName = clazz.getName(); + if (fullName.startsWith("java.lang.")) { + return new String[0]; } - // For nested classes, get the top-level enclosing class Class enclosing = clazz; while (enclosing.getEnclosingClass() != null) { enclosing = enclosing.getEnclosingClass(); } - String name = enclosing.getName(); - if (name.startsWith("java.lang.")) { - return null; + String enclosingName = enclosing.getName(); + String nestedName = fullName.replace('$', '.'); + if (!nestedName.equals(enclosingName)) { + return new String[]{enclosingName, nestedName}; } - return name; + return new String[]{enclosingName}; } // ==================== Builder ==================== @@ -231,9 +236,9 @@ public class HookDefinition implements IHookDefinition { if (clazz != null) { this.eventClassName = clazz.getName(); - String importName = getImportForClass(clazz); - if (importName != null) { - this.requiredImports = new String[]{importName}; + String[] importNames = getImportsForClass(clazz); + if (importNames.length > 0) { + this.requiredImports = importNames; } if (clazz.isAnnotationPresent(Cancelable.class)) { diff --git a/src/main/java/noppes/npcs/controllers/data/DataScript.java b/src/main/java/noppes/npcs/controllers/data/DataScript.java index b112bf470..7d9fb5c3a 100644 --- a/src/main/java/noppes/npcs/controllers/data/DataScript.java +++ b/src/main/java/noppes/npcs/controllers/data/DataScript.java @@ -20,6 +20,7 @@ import noppes.npcs.constants.EnumScriptType; import noppes.npcs.constants.ScriptContext; import noppes.npcs.controllers.ScriptContainer; import noppes.npcs.controllers.ScriptController; +import noppes.npcs.controllers.ScriptHookController; import noppes.npcs.entity.EntityNPCInterface; import noppes.npcs.janino.EventJaninoScript; import noppes.npcs.scripted.NpcAPI; @@ -28,15 +29,10 @@ import noppes.npcs.scripted.constants.EntityType; import noppes.npcs.scripted.constants.JobType; import noppes.npcs.scripted.constants.RoleType; import noppes.npcs.scripted.entity.ScriptNpc; +import noppes.npcs.api.handler.IHookDefinition; import javax.script.ScriptEngine; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.TreeMap; +import java.util.*; public class DataScript implements IScriptHandlerPacket { public List eventScripts = new ArrayList<>(); @@ -56,6 +52,17 @@ public class DataScript implements IScriptHandlerPacket { public boolean aiNeedsUpdate = false; public boolean hasInited = false; + // Editor/runtime globals descriptor used for a single source of truth. + private static final class GlobalDefinition { + private final String typeName; + private final Object value; + + private GlobalDefinition(String typeName, Object value) { + this.typeName = typeName; + this.value = value; + } + } + public DataScript(EntityNPCInterface npc) { for (int i = 0; i < 15; i++) { this.setNPCScript(i, new ScriptContainer(this)); @@ -180,21 +187,12 @@ public class DataScript implements IScriptHandlerPacket { LogWriter.postScriptLog(npc.field_110179_h, type, String.format("[%s] NPC %s (%s, %s, %s) | Objects: %s", ((String) type.function).toUpperCase(), npc.display.name, (int) npc.posX, (int) npc.posY, (int) npc.posZ, Arrays.toString(obs))); } } - return callScript(script, event); + return callScript(script, type.function, event); } - private boolean callScript(ScriptContainer script, Event event) { + private boolean callScript(ScriptContainer script, String hookName, Event event) { ScriptEngine engine = script.engine; - engine.put("npc", dummyNpc); - engine.put("world", dummyWorld); - engine.put("event", event); - engine.put("API", NpcAPI.Instance()); - engine.put("EntityType", entities); - engine.put("RoleType", roles); - engine.put("JobType", jobs); - for (Map.Entry engineObjects : NpcAPI.engineObjects.entrySet()) { - engine.put(engineObjects.getKey(), engineObjects.getValue()); - } + applyGlobalsToEngine(engine, hookName, event); script.run(engine); if (clientNeedsUpdate) { @@ -254,6 +252,61 @@ public class DataScript implements IScriptHandlerPacket { } } + public Map getEditorGlobals(String hookName) { + Map definitions = getGlobalDefinitions(hookName, null); + Map globals = new LinkedHashMap<>(); + for (Map.Entry entry : definitions.entrySet()) { + String typeName = entry.getValue().typeName; + if (typeName != null && !typeName.isEmpty()) { + globals.put(entry.getKey(), typeName); + } + } + return globals; + } + + // Apply runtime globals plus engine-only bindings. + private void applyGlobalsToEngine(ScriptEngine engine, String hookName, Event event) { + Map definitions = getGlobalDefinitions(hookName, event); + for (Map.Entry entry : definitions.entrySet()) { + engine.put(entry.getKey(), entry.getValue().value); + } + + engine.put("API", NpcAPI.Instance()); + for (Map.Entry engineObjects : NpcAPI.engineObjects.entrySet()) { + engine.put(engineObjects.getKey(), engineObjects.getValue()); + } + } + + // Build shared globals (editor types + runtime values). + private Map getGlobalDefinitions(String hookName, Event event) { + Map globals = new LinkedHashMap<>(); + globals.put("npc", new GlobalDefinition("ICustomNpc", dummyNpc)); + globals.put("world", new GlobalDefinition("IWorld", dummyWorld)); + globals.put("event", new GlobalDefinition(resolveEditorEventTypeName(hookName), event)); + globals.put("EntityType", new GlobalDefinition("noppes.npcs.scripted.constants.EntityType", entities)); + globals.put("RoleType", new GlobalDefinition("noppes.npcs.scripted.constants.RoleType", roles)); + globals.put("JobType", new GlobalDefinition("noppes.npcs.scripted.constants.JobType", jobs)); + + return globals; + } + + // Resolve editor-only event type from hook name with a single fallback. + private String resolveEditorEventTypeName(String hookName) { + final String fallback = "INpcEvent"; + if (hookName == null || hookName.isEmpty()) + return fallback; + + IHookDefinition definition = ScriptHookController.Instance.getHookDefinition(getContext().hookContext, hookName); + if (definition == null) + return fallback; + + String typeName = definition.getUsableTypeName(); + if (typeName == null || typeName.isEmpty()) + return fallback; + + return typeName; + } + public boolean isClient() { return this.npc.isRemote(); } diff --git a/src/main/java/noppes/npcs/janino/JaninoScript.java b/src/main/java/noppes/npcs/janino/JaninoScript.java index 453fb16be..f94be8acc 100644 --- a/src/main/java/noppes/npcs/janino/JaninoScript.java +++ b/src/main/java/noppes/npcs/janino/JaninoScript.java @@ -22,14 +22,7 @@ import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.security.Permissions; import java.security.PrivilegedAction; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.TreeMap; +import java.util.*; import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Supplier; @@ -50,7 +43,9 @@ public abstract class JaninoScript implements IScriptUnit { private final JaninoHookResolver hookResolver = new JaninoHookResolver(); private final String[] defaultImports; - + // Cache of imports used in the last compilation + private String[] cachedImports; + private Map hookDefCache; private int lastHookRevision = -1; private int lastSeenGlobalRevision; @@ -138,8 +133,7 @@ public abstract class JaninoScript implements IScriptUnit { public void compileScript(String code) { try { - String[] imports = collectImportsForCode(code); - builder.setDefaultImports(imports); + builder.setDefaultImports(cachedImports = collectImportsForCode(code)); this.scriptBody = builder.build(); scriptBody.setScript(code); } catch (InternalCompilerException e) { @@ -406,6 +400,56 @@ public abstract class JaninoScript implements IScriptUnit { return sb.toString(); } + /** + * Get the default imports configured for this script type. + * These are packages/classes that are automatically available without explicit import statements. + * + * @return Array of default import patterns (e.g., "noppes.npcs.api.*") + */ + public String[] getDefaultImports() { + return defaultImports; + } + + private String[] getCachedImports() { + if (cachedImports == null) { + cachedImports = collectImportsForCode(getFullCode()); + } + return cachedImports; + } + + /** + * Get all types used in hook method signatures (parameters and return types). + * This includes event types like INpcEvent.InitEvent, INpcEvent.DamagedEvent, etc., + * as well as return types like Color, String, etc. + * Useful for syntax highlighting to know what types are implicitly available. + * + * @return Set of fully qualified class names for all hook parameter and return types + */ + public Set getHookTypes() { + Set types = new HashSet<>(); + Collections.addAll(types, getCachedImports()); + return types; + } + + /** + * Add a type and all its enclosing types to the set. + * For nested classes like INpcEvent.InitEvent, this adds both INpcEvent and INpcEvent$InitEvent. + */ + private void addTypeAndEnclosingTypes(Set types, Class clazz) { + if (clazz == null || clazz.isPrimitive()) + return; + + // Add the type itself + types.add(clazz.getName()); + + // Add enclosing/declaring class if it's a nested type + Class enclosing = clazz.getDeclaringClass(); + while (enclosing != null) { + types.add(enclosing.getName()); + enclosing = enclosing.getDeclaringClass(); + } + } + // ==================== IScriptUnit ==================== @Override @@ -417,6 +461,7 @@ public abstract class JaninoScript implements IScriptUnit { public void setScript(String script) { this.script = script; this.evaluated = false; + this.cachedImports = null; hookResolver.clearResolutionCaches(); } @@ -429,6 +474,7 @@ public abstract class JaninoScript implements IScriptUnit { public void setExternalScripts(List scripts) { this.externalScripts = scripts; this.evaluated = false; + this.cachedImports = null; hookResolver.clearResolutionCaches(); } diff --git a/src/main/resources/assets/customnpcs/textures/gui/script/icons.png b/src/main/resources/assets/customnpcs/textures/gui/script/icons.png new file mode 100644 index 000000000..4e19870f3 Binary files /dev/null and b/src/main/resources/assets/customnpcs/textures/gui/script/icons.png differ