@colbymchenry/codegraph 0.6.6 → 0.7.2

package/dist/resolution/index.js

@@ -45,13 +45,88 @@ exports.ReferenceResolver = void 0;
 exports.createResolver = createResolver;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const sentry_1 = require("../sentry");
 const name_matcher_1 = require("./name-matcher");
 const import_resolver_1 = require("./import-resolver");
 const frameworks_1 = require("./frameworks");
 const errors_1 = require("../errors");
 // Re-export types
 __exportStar(require("./types"), exports);
+// Pre-built Sets for O(1) built-in lookups (allocated once, shared across all instances)
+const JS_BUILT_INS = new Set([
+    'console', 'window', 'document', 'global', 'process',
+    'Promise', 'Array', 'Object', 'String', 'Number', 'Boolean',
+    'Date', 'Math', 'JSON', 'RegExp', 'Error', 'Map', 'Set',
+    'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval',
+    'fetch', 'require', 'module', 'exports', '__dirname', '__filename',
+]);
+const REACT_HOOKS = new Set([
+    'useState', 'useEffect', 'useContext', 'useReducer', 'useCallback',
+    'useMemo', 'useRef', 'useLayoutEffect', 'useImperativeHandle', 'useDebugValue',
+]);
+const PYTHON_BUILT_INS = new Set([
+    'print', 'len', 'range', 'str', 'int', 'float', 'list', 'dict', 'set', 'tuple',
+    'open', 'input', 'type', 'isinstance', 'hasattr', 'getattr', 'setattr',
+    'super', 'self', 'cls', 'None', 'True', 'False',
+]);
+const PYTHON_BUILT_IN_TYPES = new Set([
+    'list', 'dict', 'set', 'tuple', 'str', 'int', 'float', 'bool',
+    'bytes', 'bytearray', 'frozenset', 'object', 'super',
+]);
+const PYTHON_BUILT_IN_METHODS = new Set([
+    'append', 'extend', 'insert', 'remove', 'pop', 'clear', 'sort', 'reverse', 'copy',
+    'update', 'keys', 'values', 'items', 'get',
+    'add', 'discard', 'union', 'intersection', 'difference',
+    'split', 'join', 'strip', 'lstrip', 'rstrip', 'replace', 'lower', 'upper',
+    'startswith', 'endswith', 'find', 'index', 'count', 'encode', 'decode',
+    'format', 'isdigit', 'isalpha', 'isalnum',
+    'read', 'write', 'readline', 'readlines', 'close', 'flush', 'seek',
+]);
+const GO_STDLIB_PACKAGES = new Set([
+    'fmt', 'os', 'io', 'net', 'http', 'log', 'math', 'sort', 'sync',
+    'time', 'path', 'bytes', 'strings', 'strconv', 'errors', 'context',
+    'json', 'xml', 'csv', 'html', 'template', 'regexp', 'reflect',
+    'runtime', 'testing', 'flag', 'bufio', 'crypto', 'encoding',
+    'filepath', 'hash', 'mime', 'rand', 'signal', 'sql', 'syscall',
+    'unicode', 'unsafe', 'atomic', 'binary', 'debug', 'exec', 'heap',
+    'ring', 'scanner', 'tar', 'zip', 'gzip', 'zlib', 'tls', 'url',
+    'user', 'pprof', 'trace', 'ast', 'build', 'parser', 'printer',
+    'token', 'types', 'cgo', 'plugin', 'race', 'ioutil',
+    // Kubernetes-common stdlib aliases
+    'utilruntime', 'utilwait', 'utilnet',
+]);
+const GO_BUILT_INS = new Set([
+    'make', 'new', 'len', 'cap', 'append', 'copy', 'delete', 'close',
+    'panic', 'recover', 'print', 'println', 'complex', 'real', 'imag',
+    'error', 'nil', 'true', 'false', 'iota',
+    'int', 'int8', 'int16', 'int32', 'int64',
+    'uint', 'uint8', 'uint16', 'uint32', 'uint64', 'uintptr',
+    'float32', 'float64', 'complex64', 'complex128',
+    'string', 'bool', 'byte', 'rune', 'any',
+]);
+const PASCAL_UNIT_PREFIXES = [
+    'System.', 'Winapi.', 'Vcl.', 'Fmx.', 'Data.', 'Datasnap.',
+    'Soap.', 'Xml.', 'Web.', 'REST.', 'FireDAC.', 'IBX.',
+    'IdHTTP', 'IdTCP', 'IdSSL',
+];
+const PASCAL_BUILT_INS = new Set([
+    'System', 'SysUtils', 'Classes', 'Types', 'Variants', 'StrUtils',
+    'Math', 'DateUtils', 'IOUtils', 'Generics.Collections', 'Generics.Defaults',
+    'Rtti', 'TypInfo', 'SyncObjs', 'RegularExpressions',
+    'SysInit', 'Windows', 'Messages', 'Graphics', 'Controls', 'Forms',
+    'Dialogs', 'StdCtrls', 'ExtCtrls', 'ComCtrls', 'Menus', 'ActnList',
+    'WriteLn', 'Write', 'ReadLn', 'Read', 'Inc', 'Dec', 'Ord', 'Chr',
+    'Length', 'SetLength', 'High', 'Low', 'Assigned', 'FreeAndNil',
+    'Format', 'IntToStr', 'StrToInt', 'FloatToStr', 'StrToFloat',
+    'Trim', 'UpperCase', 'LowerCase', 'Pos', 'Copy', 'Delete', 'Insert',
+    'Now', 'Date', 'Time', 'DateToStr', 'StrToDate',
+    'Raise', 'Exit', 'Break', 'Continue', 'Abort',
+    'True', 'False', 'nil', 'Self', 'Result',
+    'Create', 'Destroy', 'Free',
+    'TObject', 'TComponent', 'TPersistent', 'TInterfacedObject',
+    'TList', 'TStringList', 'TStrings', 'TStream', 'TMemoryStream', 'TFileStream',
+    'Exception', 'EAbort', 'EConvertError', 'EAccessViolation',
+    'IInterface', 'IUnknown',
+]);
 /**
  * Reference Resolver
  *
@@ -62,14 +137,13 @@ class ReferenceResolver {
     queries;
     context;
     frameworks = [];
-    nodeCache = new Map();
-    fileCache = new Map();
-    nameCache = new Map();
-    qualifiedNameCache = new Map();
-    kindCache = new Map();
-    nodeByIdCache = new Map();
-    lowerNameCache = new Map();
+    nodeCache = new Map(); // per-file node cache (bounded)
+    fileCache = new Map(); // per-file content cache (bounded)
     importMappingCache = new Map();
+    nameCache = new Map(); // name → nodes cache
+    lowerNameCache = new Map(); // lower(name) → nodes cache
+    qualifiedNameCache = new Map(); // qualified_name → nodes cache
+    knownNames = null; // all known symbol names for fast pre-filtering
     knownFiles = null;
     cachesWarmed = false;
     constructor(projectRoot, queries) {
@@ -85,52 +159,18 @@ class ReferenceResolver {
         this.clearCaches();
     }
     /**
-     * Pre-load all nodes into memory maps for fast lookup during resolution.
-     * This eliminates repeated SQLite queries and provides the core speedup.
+     * Pre-build lightweight caches for resolution.
+     * Node lookups are now handled by indexed SQLite queries instead of
+     * loading all nodes into memory (which caused OOM on large codebases).
+     * We cache the set of known symbol names for fast pre-filtering.
      */
     warmCaches() {
         if (this.cachesWarmed)
             return;
-        const allNodes = this.queries.getAllNodes();
-        for (const node of allNodes) {
-            // Index by name
-            const byName = this.nameCache.get(node.name);
-            if (byName) {
-                byName.push(node);
-            }
-            else {
-                this.nameCache.set(node.name, [node]);
-            }
-            // Index by qualified name
-            const byQName = this.qualifiedNameCache.get(node.qualifiedName);
-            if (byQName) {
-                byQName.push(node);
-            }
-            else {
-                this.qualifiedNameCache.set(node.qualifiedName, [node]);
-            }
-            // Index by kind
-            const byKind = this.kindCache.get(node.kind);
-            if (byKind) {
-                byKind.push(node);
-            }
-            else {
-                this.kindCache.set(node.kind, [node]);
-            }
-            // Index by ID
-            this.nodeByIdCache.set(node.id, node);
-            // Index by lowercase name (for fuzzy matching)
-            const lowerName = node.name.toLowerCase();
-            const byLower = this.lowerNameCache.get(lowerName);
-            if (byLower) {
-                byLower.push(node);
-            }
-            else {
-                this.lowerNameCache.set(lowerName, [node]);
-            }
-        }
-        // Pre-build known files set from index
-        this.knownFiles = new Set(this.queries.getAllFiles().map((f) => f.path));
+        // Only cache the set of known file paths (lightweight string set)
+        this.knownFiles = new Set(this.queries.getAllFilePaths());
+        // Cache all distinct symbol names for fast pre-filtering (just strings, not full nodes)
+        this.knownNames = new Set(this.queries.getAllNodeNames());
         this.cachesWarmed = true;
     }
     /**
@@ -139,12 +179,11 @@ class ReferenceResolver {
     clearCaches() {
         this.nodeCache.clear();
         this.fileCache.clear();
+        this.importMappingCache.clear();
         this.nameCache.clear();
-        this.qualifiedNameCache.clear();
-        this.kindCache.clear();
-        this.nodeByIdCache.clear();
         this.lowerNameCache.clear();
-        this.importMappingCache.clear();
+        this.qualifiedNameCache.clear();
+        this.knownNames = null;
         this.knownFiles = null;
         this.cachesWarmed = false;
     }
@@ -160,26 +199,22 @@ class ReferenceResolver {
                 return this.nodeCache.get(filePath);
             },
             getNodesByName: (name) => {
-                // Use warm cache if available, otherwise fall back to search
-                if (this.cachesWarmed) {
-                    return this.nameCache.get(name) ?? [];
-                }
-                return this.queries.searchNodes(name, { limit: 100 }).map((r) => r.node);
+                const cached = this.nameCache.get(name);
+                if (cached !== undefined)
+                    return cached;
+                const result = this.queries.getNodesByName(name);
+                this.nameCache.set(name, result);
+                return result;
             },
             getNodesByQualifiedName: (qualifiedName) => {
-                // Use warm cache if available, otherwise fall back to search + filter
-                if (this.cachesWarmed) {
-                    return this.qualifiedNameCache.get(qualifiedName) ?? [];
-                }
-                return this.queries
-                    .searchNodes(qualifiedName, { limit: 50 })
-                    .filter((r) => r.node.qualifiedName === qualifiedName)
-                    .map((r) => r.node);
+                const cached = this.qualifiedNameCache.get(qualifiedName);
+                if (cached !== undefined)
+                    return cached;
+                const result = this.queries.getNodesByQualifiedNameExact(qualifiedName);
+                this.qualifiedNameCache.set(qualifiedName, result);
+                return result;
             },
             getNodesByKind: (kind) => {
-                if (this.cachesWarmed) {
-                    return this.kindCache.get(kind) ?? [];
-                }
                 return this.queries.getNodesByKind(kind);
             },
             fileExists: (filePath) => {
@@ -196,7 +231,6 @@ class ReferenceResolver {
                     return fs.existsSync(fullPath);
                 }
                 catch (error) {
-                    (0, sentry_1.captureException)(error, { operation: 'resolution-file-exists', filePath });
                     (0, errors_1.logDebug)('Error checking file existence', { filePath, error: String(error) });
                     return false;
                 }
@@ -212,7 +246,6 @@ class ReferenceResolver {
                     return content;
                 }
                 catch (error) {
-                    (0, sentry_1.captureException)(error, { operation: 'resolution-read-file', filePath });
                     (0, errors_1.logDebug)('Failed to read file for resolution', { filePath, error: String(error) });
                     this.fileCache.set(filePath, null);
                     return null;
@@ -220,14 +253,15 @@ class ReferenceResolver {
             },
             getProjectRoot: () => this.projectRoot,
             getAllFiles: () => {
-                return this.queries.getAllFiles().map((f) => f.path);
+                return this.queries.getAllFilePaths();
             },
             getNodesByLowerName: (lowerName) => {
-                if (this.cachesWarmed) {
-                    return this.lowerNameCache.get(lowerName) ?? [];
-                }
-                // Fallback: scan all nodes (expensive, but only used if cache not warm)
-                return this.queries.getAllNodes().filter((n) => n.name.toLowerCase() === lowerName);
+                const cached = this.lowerNameCache.get(lowerName);
+                if (cached !== undefined)
+                    return cached;
+                const result = this.queries.getNodesByLowerName(lowerName);
+                this.lowerNameCache.set(lowerName, result);
+                return result;
             },
             getImportMappings: (filePath, language) => {
                 const cacheKey = filePath;
@@ -300,6 +334,45 @@ class ReferenceResolver {
             },
         };
     }
+    /**
+     * Check if a reference name has any possible match in the codebase.
+     * Uses the pre-built knownNames set to skip expensive resolution
+     * for names that definitely don't exist as symbols.
+     */
+    hasAnyPossibleMatch(name) {
+        if (!this.knownNames)
+            return true; // no pre-filter available
+        // Direct name match
+        if (this.knownNames.has(name))
+            return true;
+        // For qualified names like "obj.method" or "Class::method", check the parts
+        const dotIdx = name.indexOf('.');
+        if (dotIdx > 0) {
+            const receiver = name.substring(0, dotIdx);
+            const member = name.substring(dotIdx + 1);
+            if (this.knownNames.has(receiver) || this.knownNames.has(member))
+                return true;
+            // Also check capitalized receiver (instance-method resolution)
+            const capitalized = receiver.charAt(0).toUpperCase() + receiver.slice(1);
+            if (this.knownNames.has(capitalized))
+                return true;
+        }
+        const colonIdx = name.indexOf('::');
+        if (colonIdx > 0) {
+            const receiver = name.substring(0, colonIdx);
+            const member = name.substring(colonIdx + 2);
+            if (this.knownNames.has(receiver) || this.knownNames.has(member))
+                return true;
+        }
+        // For path-like references (e.g., "snippets/drawer-menu.liquid"), check the filename
+        const slashIdx = name.lastIndexOf('/');
+        if (slashIdx > 0) {
+            const fileName = name.substring(slashIdx + 1);
+            if (this.knownNames.has(fileName))
+                return true;
+        }
+        return false;
+    }
     /**
      * Resolve a single reference
      */
@@ -308,6 +381,10 @@ class ReferenceResolver {
         if (this.isBuiltInOrExternal(ref)) {
             return null;
         }
+        // Fast pre-filter: skip if no symbol with this name exists anywhere
+        if (!this.hasAnyPossibleMatch(ref.referenceName)) {
+            return null;
+        }
         const candidates = [];
         // Strategy 1: Try framework-specific resolution
         for (const framework of this.frameworks) {
@@ -339,17 +416,30 @@ class ReferenceResolver {
      * Create edges from resolved references
      */
     createEdges(resolved) {
-        return resolved.map((ref) => ({
-            source: ref.original.fromNodeId,
-            target: ref.targetNodeId,
-            kind: ref.original.referenceKind,
-            line: ref.original.line,
-            column: ref.original.column,
-            metadata: {
-                confidence: ref.confidence,
-                resolvedBy: ref.resolvedBy,
-            },
-        }));
+        return resolved.map((ref) => {
+            let kind = ref.original.referenceKind;
+            // Promote "extends" to "implements" when a class/struct targets an interface
+            if (kind === 'extends') {
+                const targetNode = this.queries.getNodeById(ref.targetNodeId);
+                if (targetNode && (targetNode.kind === 'interface' || targetNode.kind === 'protocol')) {
+                    const sourceNode = this.queries.getNodeById(ref.original.fromNodeId);
+                    if (sourceNode && sourceNode.kind !== 'interface' && sourceNode.kind !== 'protocol') {
+                        kind = 'implements';
+                    }
+                }
+            }
+            return {
+                source: ref.original.fromNodeId,
+                target: ref.targetNodeId,
+                kind,
+                line: ref.original.line,
+                column: ref.original.column,
+                metadata: {
+                    confidence: ref.confidence,
+                    resolvedBy: ref.resolvedBy,
+                },
+            };
+        });
     }
     /**
      * Resolve and persist edges to database
@@ -362,8 +452,82 @@ class ReferenceResolver {
         if (edges.length > 0) {
             this.queries.insertEdges(edges);
         }
+        // Clean up resolved refs from unresolved_refs table so metrics are accurate
+        if (result.resolved.length > 0) {
+            this.queries.deleteSpecificResolvedReferences(result.resolved.map((r) => ({
+                fromNodeId: r.original.fromNodeId,
+                referenceName: r.original.referenceName,
+                referenceKind: r.original.referenceKind,
+            })));
+        }
         return result;
     }
+    /**
+     * Resolve and persist in batches to keep memory bounded.
+     * Processes unresolved references in chunks, persisting edges and cleaning
+     * up resolved refs after each batch to avoid accumulating large arrays.
+     */
+    async resolveAndPersistBatched(onProgress, batchSize = 5000) {
+        this.warmCaches();
+        const total = this.queries.getUnresolvedReferencesCount();
+        let processed = 0;
+        const aggregateStats = {
+            total: 0,
+            resolved: 0,
+            unresolved: 0,
+            byMethod: {},
+        };
+        // Process in batches. We always read from offset 0 because resolved refs
+        // are deleted after each batch, shifting the remaining rows forward.
+        while (true) {
+            const batch = this.queries.getUnresolvedReferencesBatch(0, batchSize);
+            if (batch.length === 0)
+                break;
+            const result = this.resolveAll(batch);
+            // Persist edges immediately
+            const edges = this.createEdges(result.resolved);
+            if (edges.length > 0) {
+                this.queries.insertEdges(edges);
+            }
+            // Clean up resolved refs so they don't appear in the next batch
+            if (result.resolved.length > 0) {
+                this.queries.deleteSpecificResolvedReferences(result.resolved.map((r) => ({
+                    fromNodeId: r.original.fromNodeId,
+                    referenceName: r.original.referenceName,
+                    referenceKind: r.original.referenceKind,
+                })));
+            }
+            // Delete unresolvable refs from this batch to avoid re-processing them
+            if (result.unresolved.length > 0) {
+                this.queries.deleteSpecificResolvedReferences(result.unresolved.map((r) => ({
+                    fromNodeId: r.fromNodeId,
+                    referenceName: r.referenceName,
+                    referenceKind: r.referenceKind,
+                })));
+            }
+            // Aggregate stats
+            aggregateStats.total += result.stats.total;
+            aggregateStats.resolved += result.stats.resolved;
+            aggregateStats.unresolved += result.stats.unresolved;
+            for (const [method, count] of Object.entries(result.stats.byMethod)) {
+                aggregateStats.byMethod[method] = (aggregateStats.byMethod[method] || 0) + count;
+            }
+            processed += batch.length;
+            onProgress?.(processed, total);
+            // Yield so progress UI can render between batches
+            await new Promise(resolve => setImmediate(resolve));
+            // If nothing was resolved or removed in this batch, we'd loop forever
+            // on the same rows. Break to avoid infinite loop.
+            if (result.resolved.length === 0 && result.unresolved.length === batch.length) {
+                break;
+            }
+        }
+        return {
+            resolved: [],
+            unresolved: [],
+            stats: aggregateStats,
+        };
+    }
     /**
      * Get detected frameworks
      */
@@ -375,67 +539,67 @@ class ReferenceResolver {
      */
     isBuiltInOrExternal(ref) {
         const name = ref.referenceName;
+        const isJsTs = ref.language === 'typescript' || ref.language === 'javascript'
+            || ref.language === 'tsx' || ref.language === 'jsx';
         // JavaScript/TypeScript built-ins
-        const jsBuiltIns = [
-            'console', 'window', 'document', 'global', 'process',
-            'Promise', 'Array', 'Object', 'String', 'Number', 'Boolean',
-            'Date', 'Math', 'JSON', 'RegExp', 'Error', 'Map', 'Set',
-            'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval',
-            'fetch', 'require', 'module', 'exports', '__dirname', '__filename',
-        ];
-        if (jsBuiltIns.includes(name)) {
+        if (isJsTs && JS_BUILT_INS.has(name)) {
             return true;
         }
-        // Common library calls
-        if (name.startsWith('console.') || name.startsWith('Math.') || name.startsWith('JSON.')) {
+        // Common JS/TS library calls (console.log, Math.floor, JSON.parse)
+        if (isJsTs && (name.startsWith('console.') || name.startsWith('Math.') || name.startsWith('JSON.'))) {
             return true;
         }
         // React hooks from React itself
-        const reactHooks = ['useState', 'useEffect', 'useContext', 'useReducer', 'useCallback', 'useMemo', 'useRef', 'useLayoutEffect', 'useImperativeHandle', 'useDebugValue'];
-        if (reactHooks.includes(name)) {
+        if (isJsTs && REACT_HOOKS.has(name)) {
             return true;
         }
-        // Python built-ins
-        const pythonBuiltIns = [
-            'print', 'len', 'range', 'str', 'int', 'float', 'list', 'dict', 'set', 'tuple',
-            'open', 'input', 'type', 'isinstance', 'hasattr', 'getattr', 'setattr',
-            'super', 'self', 'cls', 'None', 'True', 'False',
-        ];
-        if (ref.language === 'python' && pythonBuiltIns.includes(name)) {
+        // Python built-ins (bare calls only — dotted calls like console.print are method calls)
+        if (ref.language === 'python' && PYTHON_BUILT_INS.has(name)) {
             return true;
         }
+        // Python built-in method calls (e.g., list.extend, dict.update)
+        if (ref.language === 'python') {
+            const dotIdx = name.indexOf('.');
+            if (dotIdx > 0) {
+                const receiver = name.substring(0, dotIdx);
+                const method = name.substring(dotIdx + 1);
+                // Filter calls on built-in types (list.append, dict.update, etc.)
+                if (PYTHON_BUILT_IN_TYPES.has(receiver)) {
+                    return true;
+                }
+                // Filter built-in methods on non-class receivers
+                // (e.g., items.append where items is a local list variable)
+                // But allow if the capitalized receiver matches a known codebase class
+                if (PYTHON_BUILT_IN_METHODS.has(method)) {
+                    const capitalized = receiver.charAt(0).toUpperCase() + receiver.slice(1);
+                    if (!this.knownNames?.has(capitalized)) {
+                        return true;
+                    }
+                }
+            }
+            if (PYTHON_BUILT_IN_METHODS.has(name)) {
+                return true;
+            }
+        }
+        // Go standard library packages — refs like "fmt.Println", "http.ListenAndServe", etc.
+        if (ref.language === 'go') {
+            const dotIdx = name.indexOf('.');
+            if (dotIdx > 0) {
+                const pkg = name.substring(0, dotIdx);
+                if (GO_STDLIB_PACKAGES.has(pkg)) {
+                    return true;
+                }
+            }
+            if (GO_BUILT_INS.has(name)) {
+                return true;
+            }
+        }
         // Pascal/Delphi built-ins and standard library units
         if (ref.language === 'pascal') {
-            // Standard RTL/VCL/FMX unit prefixes — these are external dependencies
-            const pascalUnitPrefixes = [
-                'System.', 'Winapi.', 'Vcl.', 'Fmx.', 'Data.', 'Datasnap.',
-                'Soap.', 'Xml.', 'Web.', 'REST.', 'FireDAC.', 'IBX.',
-                'IdHTTP', 'IdTCP', 'IdSSL',
-            ];
-            if (pascalUnitPrefixes.some((p) => name.startsWith(p))) {
+            if (PASCAL_UNIT_PREFIXES.some((p) => name.startsWith(p))) {
                 return true;
             }
-            // Common standalone RTL units and built-in identifiers
-            const pascalBuiltIns = [
-                'System', 'SysUtils', 'Classes', 'Types', 'Variants', 'StrUtils',
-                'Math', 'DateUtils', 'IOUtils', 'Generics.Collections', 'Generics.Defaults',
-                'Rtti', 'TypInfo', 'SyncObjs', 'RegularExpressions',
-                'SysInit', 'Windows', 'Messages', 'Graphics', 'Controls', 'Forms',
-                'Dialogs', 'StdCtrls', 'ExtCtrls', 'ComCtrls', 'Menus', 'ActnList',
-                'WriteLn', 'Write', 'ReadLn', 'Read', 'Inc', 'Dec', 'Ord', 'Chr',
-                'Length', 'SetLength', 'High', 'Low', 'Assigned', 'FreeAndNil',
-                'Format', 'IntToStr', 'StrToInt', 'FloatToStr', 'StrToFloat',
-                'Trim', 'UpperCase', 'LowerCase', 'Pos', 'Copy', 'Delete', 'Insert',
-                'Now', 'Date', 'Time', 'DateToStr', 'StrToDate',
-                'Raise', 'Exit', 'Break', 'Continue', 'Abort',
-                'True', 'False', 'nil', 'Self', 'Result',
-                'Create', 'Destroy', 'Free',
-                'TObject', 'TComponent', 'TPersistent', 'TInterfacedObject',
-                'TList', 'TStringList', 'TStrings', 'TStream', 'TMemoryStream', 'TFileStream',
-                'Exception', 'EAbort', 'EConvertError', 'EAccessViolation',
-                'IInterface', 'IUnknown',
-            ];
-            if (pascalBuiltIns.includes(name)) {
+            if (PASCAL_BUILT_INS.has(name)) {
                 return true;
             }
         }
@@ -445,10 +609,6 @@ class ReferenceResolver {
      * Get file path from node ID
      */
     getFilePathFromNodeId(nodeId) {
-        // Check warm cache first
-        const cached = this.nodeByIdCache.get(nodeId);
-        if (cached)
-            return cached.filePath;
         const node = this.queries.getNodeById(nodeId);
         return node?.filePath || '';
     }
@@ -456,10 +616,6 @@ class ReferenceResolver {
      * Get language from node ID
      */
     getLanguageFromNodeId(nodeId) {
-        // Check warm cache first
-        const cached = this.nodeByIdCache.get(nodeId);
-        if (cached)
-            return cached.language;
         const node = this.queries.getNodeById(nodeId);
         return node?.language || 'unknown';
     }