Add SyntaxTreeFactory with WasmParser feature flag

Introduce SyntaxTreeFactory to control parser selection (native/wasm)
at initialization time via a feature flag, replacing the static
ParserType export.

- Create SyntaxTreeFactory that resolves parser type once on init
- Route all syntax tree creation through the factory
- Add WasmParser feature flag (disabled, buildLocalHost)
- Emit parser.type metric on each tree creation
- Remove static ParserType.ts and init-time parser logging
- Wire feature flag from CfnInfraCore during server startup

Author: kddejong

assets/featureFlag/alpha.json

@@ -48,6 +48,10 @@
         "FileDb": {
             "enabled": true,
             "fleetPercentage": 100
+        },
+        "WasmParser": {
+            "enabled": false,
+            "fleetPercentage": 0
         }
     }
 }

assets/featureFlag/beta.json

@@ -47,6 +47,10 @@
         "FileDb": {
             "enabled": false,
             "fleetPercentage": 100
+        },
+        "WasmParser": {
+            "enabled": false,
+            "fleetPercentage": 0
         }
     }
 }

assets/featureFlag/prod.json

@@ -47,6 +47,10 @@
         "FileDb": {
             "enabled": false,
             "fleetPercentage": 0
+        },
+        "WasmParser": {
+            "enabled": false,
+            "fleetPercentage": 0
         }
     }
 }

src/app/initialize.ts

@@ -1,5 +1,4 @@
 import { arch, machine, platform, release, type } from 'os';
-import { parserType } from '../parser/ParserType';
 import { AwsMetadata, ClientInfo } from '../server/InitParams';
 import { LoggerFactory } from '../telemetry/LoggerFactory';
 import { TelemetryService } from '../telemetry/TelemetryService';
@@ -18,7 +17,6 @@ export function staticInitialize(ClientInfo?: ClientInfo, AwsMetadata?: AwsMetad
                 Process: ProcessType,
                 Machine: `${type()}-${platform()}-${arch()}-${machine()}-${release()}`,
                 Runtime: `node=${process.versions.node} v8=${process.versions.v8} uv=${process.versions.uv} modules=${process.versions.modules}`,
-                Parser: parserType,
                 ClientInfo,
                 aws: {
                     clientInfo: AwsMetadata?.clientInfo,

src/app/standalone.ts

@@ -14,12 +14,15 @@ async function onInitialize(params: ExtendedInitializeParams) {
     staticInitialize(params.clientInfo, params.initializationOptions?.['aws']);
 
     // Dynamically load these modules so that OTEL can instrument all the libraries first
-    const { parserFactoryReady } = await import('../parser/ParserFactory');
-    await parserFactoryReady;
+    const { syntaxTreeFactory } = await import('../context/syntaxtree/SyntaxTreeFactory');
+    await syntaxTreeFactory.ready;
 
     const { CfnInfraCore } = await import('../server/CfnInfraCore');
     const core = new CfnInfraCore(lsp.components, params);
 
+    // CfnInfraCore.initialize may switch to WASM based on feature flag
+    await syntaxTreeFactory.ready;
+
     const { CfnServer } = await import('../server/CfnServer');
     server = new CfnServer(lsp.components, core);
     return LspCapabilities;

src/context/syntaxtree/JsonSyntaxTree.ts

@@ -1,8 +1,10 @@
 import { DocumentType } from '../../document/Document';
+import { ParserFactory } from '../../parser/ParserFactory';
 import { SyntaxTree } from './SyntaxTree';
+import { ParserType } from './SyntaxTreeFactory';
 
 export class JsonSyntaxTree extends SyntaxTree {
-    constructor(content: string) {
-        super(DocumentType.JSON, content);
+    constructor(content: string, factory: ParserFactory, parserType: ParserType) {
+        super(DocumentType.JSON, content, factory, parserType);
     }
 }

src/context/syntaxtree/SyntaxTree.ts

@@ -2,11 +2,11 @@ import { Edit, Point, SyntaxNode, Tree } from 'tree-sitter';
 import { Position } from 'vscode-languageserver-textdocument';
 import { DocumentType } from '../../document/Document';
 import { createEdit } from '../../document/DocumentUtils';
-import { parserFactory } from '../../parser/ParserFactory';
-import { parserType } from '../../parser/ParserType';
+import { ParserFactory } from '../../parser/ParserFactory';
 import { Measure } from '../../telemetry/TelemetryDecorator';
 import { TopLevelSection, TopLevelSections, IntrinsicsSet } from '../CloudFormationEnums';
 import { normalizeIntrinsicFunction } from '../semantic/Intrinsics';
+import { ParserType } from './SyntaxTreeFactory';
 import { extractEntityFromNodeTextYaml } from './utils/NodeParse';
 import { NodeSearch } from './utils/NodeSearch';
 import { NodeStructure } from './utils/NodeStructure';
@@ -29,15 +29,19 @@ export abstract class SyntaxTree {
     private readonly parser;
     private rawContent: string;
     private _lines: string[] | undefined;
+    private readonly parserType: ParserType;
 
     protected constructor(
         public readonly type: DocumentType,
         content: string,
+        factory: ParserFactory,
+        parserType: ParserType,
     ) {
+        this.parserType = parserType;
         if (type === DocumentType.YAML) {
-            this.parser = parserFactory.createYamlParser();
+            this.parser = factory.createYamlParser();
         } else {
-            this.parser = parserFactory.createJsonParser();
+            this.parser = factory.createJsonParser();
         }
         this.rawContent = content;
         this.tree = this.parser.parse(this.rawContent);
@@ -48,21 +52,21 @@ export abstract class SyntaxTree {
         return this._lines;
     }
 
-    @Measure({ name: 'updateWithEdit', captureErrorAttributes: true, attributes: { 'parser.type': parserType } })
+    @Measure({ name: 'updateWithEdit', captureErrorAttributes: true })
     public updateWithEdit(content: string, edit: Edit) {
         this._lines = undefined; // Invalidate cache
         this.rawContent = content; // Update raw content
         this.tree.edit(edit);
         this.tree = this.parser.parse(content, this.tree);
     }
 
-    @Measure({ name: 'update', captureErrorAttributes: true, attributes: { 'parser.type': parserType } })
+    @Measure({ name: 'update', captureErrorAttributes: true })
     public update(textToInsert: string, start: Point, end: Point) {
         const { newContent, edit } = createEdit(this.content(), textToInsert, start, end);
         this.updateWithEdit(newContent, edit);
     }
 
-    @Measure({ name: 'getNodeAtPosition', captureErrorAttributes: true, attributes: { 'parser.type': parserType } })
+    @Measure({ name: 'getNodeAtPosition', captureErrorAttributes: true })
     public getNodeAtPosition(position: Position): SyntaxNode {
         const point: Point = {
             row: position.line,
@@ -416,7 +420,7 @@ export abstract class SyntaxTree {
      * Analyzes a node to determine its semantic path within the document.
      * It walks up the tree from the given node, building a property path and identifying the entity root.
      */
-    @Measure({ name: 'getPathAndEntityInfo', captureErrorAttributes: true, attributes: { 'parser.type': parserType } })
+    @Measure({ name: 'getPathAndEntityInfo', captureErrorAttributes: true })
     public getPathAndEntityInfo(node: SyntaxNode): PathAndEntity {
         if (!node) {
             return {
@@ -842,7 +846,7 @@ export abstract class SyntaxTree {
      * @param pathSegments Array like ["Resources", "MyBucket", "Properties", "BucketName"] or ["Resources", "MyBucket", "Properties", 0]
      * @returns Object with the node and whether the full path was resolved
      */
-    @Measure({ name: 'getNodeByPath', captureErrorAttributes: true, attributes: { 'parser.type': parserType } })
+    @Measure({ name: 'getNodeByPath', captureErrorAttributes: true })
     getNodeByPath(pathSegments: ReadonlyArray<string | number>): {
         node: SyntaxNode | undefined;
         fullyResolved: boolean;
@@ -962,7 +966,7 @@ export abstract class SyntaxTree {
     }
 
     // Finds CloudFormation sections (Parameters, Resources, etc.)
-    @Measure({ name: 'findTopLevelSections', attributes: { 'parser.type': parserType } })
+    @Measure({ name: 'findTopLevelSections' })
     public findTopLevelSections(sectionsToFind: TopLevelSection[]): Map<TopLevelSection, SyntaxNode> {
         const result = new Map<TopLevelSection, SyntaxNode>();
         if (sectionsToFind.length === 0) {

src/context/syntaxtree/SyntaxTreeFactory.ts

@@ -0,0 +1,70 @@
+import { DocumentType } from '../../document/Document';
+import { FeatureFlag } from '../../featureFlag/FeatureFlagI';
+import { ParserFactory, parserFactory, parserFactoryReady } from '../../parser/ParserFactory';
+import { WasmParserFactory } from '../../parser/WasmParserFactory';
+import { LoggerFactory } from '../../telemetry/LoggerFactory';
+import { ScopedTelemetry } from '../../telemetry/ScopedTelemetry';
+import { Telemetry } from '../../telemetry/TelemetryDecorator';
+import { JsonSyntaxTree } from './JsonSyntaxTree';
+import { SyntaxTree } from './SyntaxTree';
+import { YamlSyntaxTree } from './YamlSyntaxTree';
+
+export type ParserType = 'native' | 'wasm';
+
+const log = LoggerFactory.getLogger('SyntaxTreeFactory');
+const isLegacyLinux = process.env.BUILD_TARGET === 'legacy';
+
+export class SyntaxTreeFactory {
+    @Telemetry() private readonly telemetry!: ScopedTelemetry;
+
+    private factory: ParserFactory;
+    private type: ParserType;
+    private readyPromise: Promise<void>;
+
+    constructor(nativeFactory: ParserFactory = parserFactory) {
+        this.factory = nativeFactory;
+        this.type = isLegacyLinux ? 'wasm' : 'native';
+        this.readyPromise = parserFactoryReady;
+    }
+
+    /**
+     * Called once during server initialization to lock in the parser type
+     * for the lifetime of the session based on the feature flag state.
+     */
+    initialize(wasmFlag: FeatureFlag): void {
+        if (isLegacyLinux) {
+            return; // Already using WASM via parserFactory
+        }
+        if (wasmFlag.isEnabled()) {
+            log.info('WasmParser feature flag enabled, switching to WASM parser');
+            const wasm = new WasmParserFactory();
+            this.factory = wasm;
+            this.type = 'wasm';
+            this.readyPromise = wasm.initialize().catch((error: unknown) => {
+                log.error(error, 'WASM initialization failed, falling back to native');
+                this.factory = parserFactory;
+                this.type = 'native';
+            });
+        }
+    }
+
+    get parserType(): ParserType {
+        return this.type;
+    }
+
+    get ready(): Promise<void> {
+        return this.readyPromise;
+    }
+
+    createSyntaxTree(content: string, documentType: DocumentType): SyntaxTree {
+        this.telemetry.count('createSyntaxTree', 1, {
+            attributes: { 'parser.type': this.type },
+        });
+        if (documentType === DocumentType.JSON) {
+            return new JsonSyntaxTree(content, this.factory, this.type);
+        }
+        return new YamlSyntaxTree(content, this.factory, this.type);
+    }
+}
+
+export const syntaxTreeFactory = new SyntaxTreeFactory();

src/context/syntaxtree/SyntaxTreeManager.ts

@@ -3,9 +3,8 @@ import { CloudFormationFileType, DocumentType } from '../../document/Document';
 import { detectDocumentType } from '../../document/DocumentUtils';
 import { LoggerFactory } from '../../telemetry/LoggerFactory';
 import { Measure } from '../../telemetry/TelemetryDecorator';
-import { JsonSyntaxTree } from './JsonSyntaxTree';
 import { SyntaxTree } from './SyntaxTree';
-import { YamlSyntaxTree } from './YamlSyntaxTree';
+import { syntaxTreeFactory } from './SyntaxTreeFactory';
 
 const logger = LoggerFactory.getLogger('SyntaxTreeManager');
 
@@ -50,11 +49,11 @@ export class SyntaxTreeManager {
     }
 
     private createJsonSyntaxTree(uri: string, content: string) {
-        this.syntaxTrees.set(uri, new JsonSyntaxTree(content));
+        this.syntaxTrees.set(uri, syntaxTreeFactory.createSyntaxTree(content, DocumentType.JSON));
     }
 
     private createYamlSyntaxTree(uri: string, content: string) {
-        this.syntaxTrees.set(uri, new YamlSyntaxTree(content));
+        this.syntaxTrees.set(uri, syntaxTreeFactory.createSyntaxTree(content, DocumentType.YAML));
     }
 
     public getSyntaxTree(uri: string): SyntaxTree | undefined {

src/context/syntaxtree/YamlSyntaxTree.ts

@@ -1,8 +1,10 @@
 import { DocumentType } from '../../document/Document';
+import { ParserFactory } from '../../parser/ParserFactory';
 import { SyntaxTree } from './SyntaxTree';
+import { ParserType } from './SyntaxTreeFactory';
 
 export class YamlSyntaxTree extends SyntaxTree {
-    constructor(content: string) {
-        super(DocumentType.YAML, content);
+    constructor(content: string, factory: ParserFactory, parserType: ParserType) {
+        super(DocumentType.YAML, content, factory, parserType);
     }
 }