Add CDATA LSP support for SceneGraph XML files

src/ProgramBuilder.ts

@@ -250,6 +250,11 @@ export class ProgramBuilder {
                 throw new Error('Internal invariant exception: somehow file watcher ran before `ProgramBuilder.run()`');
             }
             thePath = s`${path.resolve(this.rootDir, thePath)}`;
+            //ignore file events for synthetic files (e.g. extracted CDATA scripts) — they are managed
+            //programmatically by XmlFile and don't exist on disk in the source directory
+            if (this.program.getFile(thePath)?.isSynthetic) {
+                return;
+            }
             if (event === 'add' || event === 'change') {
                 const fileObj = {
                     src: thePath,

src/bscPlugin/SignatureHelpUtil.ts

@@ -113,7 +113,11 @@ export class SignatureHelpUtil {
 
         const documentation = functionComments.join('').trim();
 
-        const lines = util.splitIntoLines(file.fileContents);
+        // Synthetic BrsFiles (inline CDATA blocks) store only the raw CDATA text, so their
+        // fileContents cannot be indexed by XML-space line numbers. Use the parent XML file's
+        // contents instead — it has the correct text at every XML-coordinate line number.
+        const contentsForLines = file.parentXmlFile?.fileContents ?? file.fileContents;
+        const lines = util.splitIntoLines(contentsForLines);
         let key = statement.name.text + documentation;
         const params = [] as ParameterInformation[];
         for (const param of func.parameters) {

src/bscPlugin/symbols/WorkspaceSymbolProcessor.ts

@@ -1,7 +1,9 @@
-import { isBrsFile } from '../../astUtils/reflection';
+import { isBrsFile, isXmlFile } from '../../astUtils/reflection';
 import type { BrsFile } from '../../files/BrsFile';
+import type { XmlFile } from '../../files/XmlFile';
 import type { ProvideWorkspaceSymbolsEvent } from '../../interfaces';
 import { getWorkspaceSymbolsFromBrsFile } from './symbolUtils';
+import util from '../../util';
 
 export class WorkspaceSymbolProcessor {
     public constructor(
@@ -12,17 +14,30 @@ export class WorkspaceSymbolProcessor {
 
     public process() {
         const results = Object.values(this.event.program.files).map(file => {
-            if (isBrsFile(file)) {
+            if (isBrsFile(file) && !file.isSynthetic) {
                 return this.getBrsFileWorkspaceSymbols(file);
+            } else if (isXmlFile(file)) {
+                return this.getXmlFileWorkspaceSymbols(file);
             }
             return [];
         });
         return results.flat();
     }
 
-    private getBrsFileWorkspaceSymbols(file: BrsFile) {
-        const symbols = getWorkspaceSymbolsFromBrsFile(file);
+    private getBrsFileWorkspaceSymbols(file: BrsFile, uriOverride?: string) {
+        const symbols = getWorkspaceSymbolsFromBrsFile(file, uriOverride);
         this.event.workspaceSymbols.push(...symbols);
         return this.event.workspaceSymbols;
     }
+
+    private getXmlFileWorkspaceSymbols(file: XmlFile) {
+        const xmlUri = util.pathToUri(file.srcPath);
+        for (const pkgPath of file.inlineScriptPkgPaths) {
+            const brsFile = this.event.program.getFile<BrsFile>(pkgPath);
+            if (brsFile) {
+                this.getBrsFileWorkspaceSymbols(brsFile, xmlUri);
+            }
+        }
+        return this.event.workspaceSymbols;
+    }
 }

src/bscPlugin/symbols/symbolUtils.ts

@@ -28,9 +28,9 @@ export function getDocumentSymbolsFromBrsFile(file: BrsFile) {
     }
 }
 
-export function getWorkspaceSymbolsFromBrsFile(file: BrsFile) {
+export function getWorkspaceSymbolsFromBrsFile(file: BrsFile, uriOverride?: string) {
     const result: WorkspaceSymbol[] = [];
-    const uri = util.pathToUri(file.srcPath);
+    const uri = uriOverride ?? util.pathToUri(file.srcPath);
     let symbolsToProcess = getSymbolsFromAstNode(file.ast);
     while (symbolsToProcess.length > 0) {
         //get the symbol

src/files/BrsFile.ts

@@ -16,6 +16,8 @@ import { Parser, ParseMode } from '../parser/Parser';
 import type { FunctionExpression, VariableExpression } from '../parser/Expression';
 import type { ClassStatement, NamespaceStatement, AssignmentStatement, MethodStatement, FieldStatement } from '../parser/Statement';
 import type { Program } from '../Program';
+import type { XmlFile } from './XmlFile';
+import type { SGScript } from '../parser/SGTypes';
 import { DynamicType } from '../types/DynamicType';
 import { FunctionType } from '../types/FunctionType';
 import { VoidType } from '../types/VoidType';
@@ -79,6 +81,28 @@ export class BrsFile {
         this.srcPath = value;
     }
 
+    /**
+     * When true, this file was generated from inline CDATA content in an XML file and is not backed by a file on disk.
+     * The file watcher should ignore change events for paths that match a synthetic file.
+     */
+    public isSynthetic = false;
+
+    /**
+     * The XML file this synthetic BrsFile was extracted from. Only set when `isSynthetic` is true.
+     */
+    public parentXmlFile: XmlFile | undefined;
+
+    /**
+     * The SGScript AST node whose CDATA block this file was extracted from. Only set when `isSynthetic` is true.
+     * Provides access to the CDATA range (`cdataScript.cdata.range`), raw text, and script type.
+     */
+    public cdataScript: SGScript | undefined;
+
+    /**
+     * When true, this file will not be written as a standalone output file during transpile.
+     */
+    public excludeFromOutput = false;
+
     /**
      * Will this file result in only comment or whitespace output? If so, it can be excluded from the output if that bsconfig setting is enabled.
      */
@@ -309,9 +333,13 @@ export class BrsFile {
 
     /**
      * Calculate the AST for this file
-     * @param fileContents the raw source code to parse
+     * @param fileContents the raw source to parse and store
+     * @param options optional scan options forwarded to the lexer
+     * @param options.startLine the zero-indexed line to start position tracking from (used for
+     *   inline CDATA fragments so token ranges are in parent XML coordinate space)
+     * @param options.startCharacter the zero-indexed character offset on the first line
      */
-    public parse(fileContents: string) {
+    public parse(fileContents: string, options?: { startLine?: number; startCharacter?: number }) {
         try {
             this.fileContents = fileContents;
             this.diagnostics = [];
@@ -326,7 +354,9 @@ export class BrsFile {
             //tokenize the input file
             let lexer = this.program.logger.time('debug', ['lexer.lex', chalk.green(this.srcPath)], () => {
                 return Lexer.scan(fileContents, {
-                    includeWhitespace: false
+                    includeWhitespace: false,
+                    startLine: options?.startLine,
+                    startCharacter: options?.startCharacter
                 });
             });