fix: JSON resource type value completion formatted as key (#520)

* fix: JSON resource type value completion formatted as key

CompletionFormatter.formatForJson treated all completions as key
insertions — wrapping in quotes with trailing colon and replacing
from column 0. This broke resource type value completion in JSON
(e.g. typing AWS::S3::B inside "Type": "") because:

1. newText was '"AWS::S3::Bucket":' (colon appended to value)
2. textEdit range started at column 0, wiping out the "Type" key
3. filterText was '"AWS::S3::Bu"' which editors couldn't match

Fix: detect value completions via CompletionItemKind.Class (used
exclusively for resource types) and replace only the quoted value
token with the correct text.

Also fixes debug_tree.ts crash on undefined cfnFileType.

Adds e2e and unit tests for JSON resource type value completion.

* refactor: use syntax tree to detect JSON value position

Replace item.kind === CompletionItemKind.Class check with proper
syntax tree inspection. A node is a value completion when it is
the value child of a pair node in the JSON tree-sitter AST:
  node.parent?.type === 'pair' && parent.childForFieldName('value') === node

This is more precise than checking item.kind since
TopLevelSectionCompletionProvider also uses CompletionItemKind.Class
for key completions.

* test: add e2e test for JSON enum value completion

Adds test for DeletionPolicy enum values in JSON templates.
This was also affected by the value formatting bug.

* refactor: move JSON value detection to Context.isJsonPairValue()

Add isJsonPairValue() to Context that uses the tree-sitter pair
node structure to reliably detect value positions in JSON. A node
is a value when it is the value child of a pair node.

This is consistent with how YAML key/value detection works in
Context (using synthetic nodes) and avoids relying on item.kind
or the unreliable propertyPath heuristic for JSON.

Author: kddejong

src/autocomplete/CompletionFormatter.ts

@@ -95,7 +95,10 @@ export class CompletionFormatter {
 
         // Set filterText for ALL items (including snippets) when in JSON with quotes
         const isInJsonString = documentType === DocumentType.JSON && context.syntaxNode.type === 'string';
-        if (isInJsonString) {
+        const isJsonValueNode = isInJsonString && context.isJsonPairValue();
+        if (isJsonValueNode) {
+            formattedItem.filterText = `"${item.label}"`;
+        } else if (isInJsonString) {
             formattedItem.filterText = `"${context.text}"`;
         }
 
@@ -171,6 +174,20 @@ export class CompletionFormatter {
         const indentation = ' '.repeat(context.startPosition.column);
         const indentString = getIndentationString(editorSettings, DocumentType.JSON);
 
+        // When completing a value (e.g. resource type "AWS::S3::Bucket"), just replace the value text
+        // Check the syntax tree: if the node is the value child of a JSON pair, it's a value completion
+        const isValueCompletion = context.isJsonPairValue();
+        if (isValueCompletion) {
+            // Include surrounding quotes in the range so VS Code matches the full token
+            const startCol = Math.max(0, context.startPosition.column - 1);
+            const endCol = context.endPosition.column + 1;
+            const range = Range.create(
+                Position.create(context.startPosition.row, startCol),
+                Position.create(context.endPosition.row, endCol),
+            );
+            return { text: `"${label}"`, range, isSnippet: false };
+        }
+
         let replacementText = `${indentation}"${label}":`;
         let isSnippet = false;
 

src/context/Context.ts

@@ -19,7 +19,7 @@ import { entityTypeFromSection, nodeToEntity } from './semantic/EntityBuilder';
 import { normalizeIntrinsicFunction } from './semantic/Intrinsics';
 import { PropertyPath } from './syntaxtree/SyntaxTree';
 import { NodeType } from './syntaxtree/utils/NodeType';
-import { YamlNodeTypes, CommonNodeTypes } from './syntaxtree/utils/TreeSitterTypes';
+import { YamlNodeTypes, CommonNodeTypes, JsonNodeTypes, FieldNames } from './syntaxtree/utils/TreeSitterTypes';
 import { TransformContext } from './TransformContext';
 
 type QuoteCharacter = '"' | "'";
@@ -179,6 +179,18 @@ export class Context {
         return !(this.propertyPath.at(-1) === this.text);
     }
 
+    /**
+     * Check if the cursor is at a JSON value position using the syntax tree.
+     * Uses the tree-sitter pair node structure: a node is a value when it is
+     * the value child of a pair node.
+     */
+    public isJsonPairValue(): boolean {
+        return (
+            this.node.parent?.type === JsonNodeTypes.PAIR &&
+            this.node.parent.childForFieldName(FieldNames.VALUE) === this.node
+        );
+    }
+
     public isResourceAttributeProperty(): boolean {
         if (this.section !== TopLevelSection.Resources || !this.hasLogicalId) {
             return false;

tools/debug_tree.ts

@@ -143,7 +143,7 @@ class DebugTreeTool {
                 path: filePath,
                 extension: fileExtension,
                 size: content.length,
-                cloudFormationFileType: cloudFormationFileType!.toString(),
+                cloudFormationFileType: cloudFormationFileType?.toString() ?? 'unknown',
             },
             syntaxTree: {
                 rootNodeType: '',

tst/e2e/Completion.test.ts

@@ -2508,6 +2508,75 @@ Resources:
             });
         });
 
+        describe('Resource Type Value', () => {
+            it('should provide resource type value completions when typing in Type field', async () => {
+                const template = getSimpleJsonTemplateText();
+                const updatedTemplate = `{
+  "AWSTemplateFormatVersion": "2010-09-09",
+  "Resources": {
+    "MyBucket": {
+      "Type": "AWS::S3::B"
+    }
+  }
+}`;
+                const uri = await client.openJsonTemplate(template);
+
+                await client.changeDocument({
+                    textDocument: { uri, version: 2 },
+                    contentChanges: [{ text: updatedTemplate }],
+                });
+
+                const completions: any = await client.completion({
+                    textDocument: { uri },
+                    position: { line: 4, character: 23 },
+                });
+
+                expect(completions).toBeDefined();
+                expect(completions?.items).toBeDefined();
+                expect(completions.items.length).toBeGreaterThan(0);
+
+                const labels = completions.items.map((item: any) => item.label);
+                expect(labels).toContain('AWS::S3::Bucket');
+
+                await client.closeDocument({ textDocument: { uri } });
+            });
+        });
+
+        describe('Enum Value Completions', () => {
+            it('should provide enum value completions for DeletionPolicy in JSON', async () => {
+                const template = getSimpleJsonTemplateText();
+                const updatedTemplate = `{
+  "AWSTemplateFormatVersion": "2010-09-09",
+  "Resources": {
+    "MyBucket": {
+      "Type": "AWS::S3::Bucket",
+      "DeletionPolicy": ""
+    }
+  }
+}`;
+                const uri = await client.openJsonTemplate(template);
+
+                await client.changeDocument({
+                    textDocument: { uri, version: 2 },
+                    contentChanges: [{ text: updatedTemplate }],
+                });
+
+                const completions: any = await client.completion({
+                    textDocument: { uri },
+                    position: { line: 5, character: 24 },
+                });
+
+                expect(completions).toBeDefined();
+                expect(completions?.items).toBeDefined();
+                expect(completions.items.length).toBeGreaterThan(0);
+
+                const labels = completions.items.map((item: any) => item.label);
+                expect(labels).toContain('Retain');
+                expect(labels).toContain('Delete');
+
+                await client.closeDocument({ textDocument: { uri } });
+            });
+        });
         describe('Resource Attributes', () => {
             it('should provide Type attribute completion', async () => {
                 const template = getSimpleJsonTemplateText();

tst/unit/autocomplete/CompletionFormatter.test.ts

@@ -542,7 +542,7 @@ describe('CompletionFormatAdapter', () => {
             const mockContext = createResourceContext('MyBucket', {
                 type: DocumentType.JSON,
                 text: 'BucketEncryption',
-                propertyPath: ['Resources', 'MyBucket', 'Properties'],
+                propertyPath: ['Resources', 'MyBucket', 'Properties', 'BucketEncryption'],
                 data: { Type: 'AWS::S3::Bucket' },
                 nodeType: 'string',
             });
@@ -779,10 +779,11 @@ describe('CompletionFormatAdapter', () => {
 
     describe('JSON filterText handling', () => {
         test('should set filterText with quotes when in JSON string context', () => {
-            const mockContext = createTopLevelContext('Resources', {
+            const mockContext = createTopLevelContext('Unknown', {
                 type: DocumentType.JSON,
                 nodeType: 'string',
                 text: 'Res',
+                propertyPath: ['Res'],
             });
             const completions: CompletionList = {
                 isIncomplete: false,
@@ -869,4 +870,76 @@ describe('CompletionFormatAdapter', () => {
             expect(result.items[0].textEdit?.newText).toContain('"MultiTypeProperty": "$0"');
         });
     });
+
+    describe('JSON value completions', () => {
+        function mockValueNode(context: any) {
+            const node = context.syntaxNode;
+            const pairParent = {
+                type: 'pair',
+                childForFieldName: (name: string) => (name === 'value' ? node : null),
+            };
+            Object.defineProperty(node, 'parent', { value: pairParent, writable: true });
+        }
+
+        test('should format resource type value completion without colon', () => {
+            const mockContext = createResourceContext('MyBucket', {
+                type: DocumentType.JSON,
+                text: 'AWS::S3::B',
+                propertyPath: ['Resources', 'MyBucket', 'Type'],
+                data: { Type: 'AWS::S3::B' },
+                nodeType: 'string',
+            });
+            mockValueNode(mockContext);
+
+            const completions: CompletionList = {
+                isIncomplete: false,
+                items: [
+                    {
+                        label: 'AWS::S3::Bucket',
+                        kind: CompletionItemKind.Class,
+                    },
+                ],
+            };
+
+            const lineContent = '      "Type": "AWS::S3::B"';
+            const result = formatter.format(completions, mockContext, defaultEditorSettings, lineContent);
+
+            expect(result.items[0].textEdit).toBeDefined();
+            // Value completions should not append a colon after the value
+            expect(result.items[0].textEdit?.newText).not.toMatch(/:$/);
+            expect(result.items[0].textEdit?.newText).not.toMatch(/:\s*$/);
+            // Should include quotes around the value
+            expect(result.items[0].textEdit?.newText).toContain('"AWS::S3::Bucket"');
+            // filterText should include quotes for VS Code matching
+            expect(result.items[0].filterText).toBe('"AWS::S3::Bucket"');
+        });
+
+        test('should not replace the key when completing a value', () => {
+            const mockContext = createResourceContext('MyBucket', {
+                type: DocumentType.JSON,
+                text: 'AWS::S3::B',
+                propertyPath: ['Resources', 'MyBucket', 'Type'],
+                data: { Type: 'AWS::S3::B' },
+                nodeType: 'string',
+            });
+            mockValueNode(mockContext);
+
+            const completions: CompletionList = {
+                isIncomplete: false,
+                items: [
+                    {
+                        label: 'AWS::S3::Bucket',
+                        kind: CompletionItemKind.Class,
+                    },
+                ],
+            };
+
+            const lineContent = '      "Type": "AWS::S3::B"';
+            const result = formatter.format(completions, mockContext, defaultEditorSettings, lineContent);
+
+            // Range should start near the value, not at column 0
+            const textEdit = result.items[0].textEdit as any;
+            expect(textEdit.range.start.character).toBeGreaterThan(0);
+        });
+    });
 });