Constants hover support

Author: Deep Furiya

src/artifacts/TemplateSectionDocs.ts

@@ -206,5 +206,21 @@ function getTemplateSectionDocsMap(): Map<TopLevelSection, string> {
             '[Source Documentation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-description-structure.html)',
         ].join('\n'),
     );
+    // TODO: Update with official AWS documentation when available
+    templateSectionDocsMap.set(
+        TopLevelSection.Constants,
+        [
+            '**Constants**',
+            '\n',
+            '---',
+            'The optional `Constants` section allows you to define reusable values that can be referenced throughout your template. Constants can be strings or objects and are referenced directly by their name in intrinsic functions like `Ref` and `Sub`.',
+            '\n',
+            'Constants are useful for defining values that are used multiple times in your template, making your templates more maintainable and reducing duplication.',
+            '\n',
+            '**Note:** This feature requires the `AWS::LanguageExtensions` transform.',
+            '\n',
+            '[Source Documentation](https://docs.aws.amazon.com/)',
+        ].join('\n'),
+    );
     return templateSectionDocsMap;
 }

src/context/ContextWithRelatedEntities.ts

@@ -72,6 +72,7 @@ export class ContextWithRelatedEntities extends Context {
                 TopLevelSection.Mappings,
                 TopLevelSection.Conditions,
                 TopLevelSection.Resources,
+                TopLevelSection.Constants,
             ]);
 
             const logicalIds = referencedLogicalIds(

src/hover/ConstantHoverProvider.ts

@@ -0,0 +1,17 @@
+import { Context } from '../context/Context';
+import { Constant } from '../context/semantic/Entity';
+import { Measure } from '../telemetry/TelemetryDecorator';
+import { formatConstantHover } from './HoverFormatter';
+import { HoverProvider } from './HoverProvider';
+
+export class ConstantHoverProvider implements HoverProvider {
+    @Measure({ name: 'getInformation' })
+    getInformation(context: Context): string | undefined {
+        const constant = context.entity as Constant;
+        if (!constant?.name) {
+            return undefined;
+        }
+
+        return formatConstantHover(constant);
+    }
+}

src/hover/HoverFormatter.ts

@@ -2,7 +2,7 @@ import { deletionPolicyValueDocsMap } from '../artifacts/resourceAttributes/Dele
 import { updateReplacePolicyValueDocsMap } from '../artifacts/resourceAttributes/UpdateReplacePolicyPropertyDocs-1';
 import { Context } from '../context/Context';
 import { ResourceAttribute } from '../context/ContextType';
-import { Condition, Entity, Mapping, Parameter, Resource } from '../context/semantic/Entity';
+import { Condition, Constant, Entity, Mapping, Parameter, Resource } from '../context/semantic/Entity';
 import { EntityType } from '../context/semantic/SemanticTypes';
 import { PropertyType } from '../schema/ResourceSchema';
 
@@ -887,6 +887,11 @@ export function formatIntrinsicArgumentHover(context: Context): string {
             doc.push(`**Mapping:** ${mapping.name}`);
             break;
         }
+
+        case EntityType.Constant: {
+            doc.push(formatConstantHover(context.entity as Constant));
+            break;
+        }
     }
 
     return doc.filter((item) => item.trim() !== '').join('\n\n');
@@ -1105,6 +1110,24 @@ export function formatParameterHover(parameter: Parameter): string {
     return doc.filter((item) => item.trim() !== '').join('\n\n');
 }
 
+/**
+ * Formats hover information for a constant entity
+ */
+export function formatConstantHover(constant: Constant): string {
+    const doc: string[] = [];
+
+    const valueType = typeof constant.value === 'string' ? 'string' : 'object';
+    doc.push(`\`\`\`typescript\n(constant) ${constant.name}: ${valueType}\n\`\`\``, '---');
+
+    if (typeof constant.value === 'string') {
+        doc.push(`**Value:** ${constant.value}`);
+    } else if (typeof constant.value === 'object') {
+        doc.push(`**Value:** [Object]`);
+    }
+
+    return doc.filter((item) => item.trim() !== '').join('\n\n');
+}
+
 /**
  * Formats hover information for a resource entity
  */

src/hover/HoverRouter.ts

@@ -4,13 +4,15 @@ import { ContextManager } from '../context/ContextManager';
 import { TopLevelSection, IntrinsicFunction } from '../context/ContextType';
 import { ContextWithRelatedEntities } from '../context/ContextWithRelatedEntities';
 import { EntityType } from '../context/semantic/SemanticTypes';
+import { FeatureFlag } from '../featureFlag/FeatureFlagI';
 import { SchemaRetriever } from '../schema/SchemaRetriever';
 import { ISettingsSubscriber, SettingsConfigurable, SettingsSubscription } from '../settings/ISettingsSubscriber';
 import { DefaultSettings, HoverSettings } from '../settings/Settings';
 import { LoggerFactory } from '../telemetry/LoggerFactory';
 import { Track } from '../telemetry/TelemetryDecorator';
 import { Closeable } from '../utils/Closeable';
 import { ConditionHoverProvider } from './ConditionHoverProvider';
+import { ConstantHoverProvider } from './ConstantHoverProvider';
 import { HoverProvider } from './HoverProvider';
 import { IntrinsicFunctionArgumentHoverProvider } from './IntrinsicFunctionArgumentHoverProvider';
 import { IntrinsicFunctionHoverProvider } from './IntrinsicFunctionHoverProvider';
@@ -31,6 +33,7 @@ export class HoverRouter implements SettingsConfigurable, Closeable {
     constructor(
         private readonly contextManager: ContextManager,
         schemaRetriever: SchemaRetriever,
+        private readonly constantsFeatureFlag: FeatureFlag,
     ) {
         this.hoverProviderMap = this.createHoverProviders(schemaRetriever);
     }
@@ -102,6 +105,11 @@ export class HoverRouter implements SettingsConfigurable, Closeable {
             if (doc) {
                 return doc;
             }
+        } else if (context.section === TopLevelSection.Constants && this.constantsFeatureFlag.isEnabled()) {
+            const doc = this.hoverProviderMap.get(HoverType.Constant)?.getInformation(context);
+            if (doc) {
+                return doc;
+            }
         } else if (context.section === TopLevelSection.Outputs && this.isOutputAttribute(context)) {
             const doc = this.hoverProviderMap.get(HoverType.OutputSectionField)?.getInformation(context);
             if (doc) {
@@ -136,6 +144,7 @@ export class HoverRouter implements SettingsConfigurable, Closeable {
         hoverProviderMap.set(HoverType.PseudoParameter, new PseudoParameterHoverProvider());
         hoverProviderMap.set(HoverType.Condition, new ConditionHoverProvider());
         hoverProviderMap.set(HoverType.Mapping, new MappingHoverProvider());
+        hoverProviderMap.set(HoverType.Constant, new ConstantHoverProvider());
         hoverProviderMap.set(HoverType.IntrinsicFunction, new IntrinsicFunctionHoverProvider());
         hoverProviderMap.set(
             HoverType.IntrinsicFunctionArgument,
@@ -184,6 +193,12 @@ export class HoverRouter implements SettingsConfigurable, Closeable {
             case EntityType.Resource: {
                 return this.hoverProviderMap.get(HoverType.ResourceSection)?.getInformation(context);
             }
+            case EntityType.Constant: {
+                if (this.constantsFeatureFlag.isEnabled()) {
+                    return this.hoverProviderMap.get(HoverType.Constant)?.getInformation(context);
+                }
+                return undefined;
+            }
         }
 
         return undefined;
@@ -201,4 +216,5 @@ enum HoverType {
     PseudoParameter,
     Condition,
     Mapping,
+    Constant,
 }

src/server/CfnLspProviders.ts

@@ -80,7 +80,9 @@ export class CfnLspProviders implements Configurables, Closeable {
             new RelatedResourcesSnippetProvider(core.documentManager, core.syntaxTreeManager, external.schemaRetriever);
         this.s3Service = overrides.s3Service ?? new S3Service(external.awsClient);
 
-        this.hoverRouter = overrides.hoverRouter ?? new HoverRouter(core.contextManager, external.schemaRetriever);
+        this.hoverRouter =
+            overrides.hoverRouter ??
+            new HoverRouter(core.contextManager, external.schemaRetriever, external.featureFlags.get('Constants'));
         this.completionRouter = overrides.completionRouter ?? CompletionRouter.create(core, external, this);
 
         this.definitionProvider = overrides.definitionProvider ?? new DefinitionProvider(core.contextManager);

tst/resources/templates/constants.json

@@ -3,7 +3,9 @@
   "Transform": "AWS::LanguageExtensions",
   "Constants": {
     "foo": "bar",
-    "sub": "${foo}-abc-${AWS::AccountId}",
+    "sub": {
+      "Fn::Sub": "${foo}-abc-${AWS::AccountId}"
+    },
     "obj": {
       "TestObject": {
         "A": "b"

tst/resources/templates/constants.yaml

@@ -3,7 +3,7 @@ Transform: AWS::LanguageExtensions
 
 Constants:
   foo: bar
-  sub: "${foo}-abc-${AWS::AccountId}"
+  sub: !Sub ${foo}-abc-${AWS::AccountId}
   obj:
     TestObject:
       A: b

tst/unit/context/Context.test.ts

@@ -867,7 +867,7 @@ Resources:
                 expect(constant.value).toBe('bar');
             });
 
-            it('should create Constant entity with string interpolation', () => {
+            it('should create Constant entity with Sub intrinsic function', () => {
                 const context = getContextAt(5, 2, constantsYamlUri); // sub constant
 
                 expect(context).toBeDefined();
@@ -876,8 +876,8 @@ Resources:
 
                 const constant = entity as Constant;
                 expect(constant.name).toBe('sub');
-                expect(constant.value).toContain('${foo}');
-                expect(constant.value).toContain('${AWS::AccountId}');
+                expect(constant.value).toBeDefined();
+                expect(typeof constant.value).toBe('object');
             });
 
             it('should create Constant entity with object value', () => {
@@ -923,7 +923,7 @@ Resources:
             });
 
             it('should parse constant with object value in JSON', () => {
-                const context = getContextAt(6, 6, constantsJsonUri); // Position at "obj"
+                const context = getContextAt(9, 6, constantsJsonUri); // Position at "obj"
 
                 expect(context).toBeDefined();
                 const entity = context!.entity;

tst/unit/hover/ConstantHoverProvider.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { Constant } from '../../../src/context/semantic/Entity';
+import { ConstantHoverProvider } from '../../../src/hover/ConstantHoverProvider';
+import { createMockContext } from '../../utils/MockContext';
+
+describe('ConstantHoverProvider', () => {
+    const provider = new ConstantHoverProvider();
+
+    it('should return hover information for string constant', () => {
+        const constant = new Constant('foo', 'bar');
+        const context = createMockContext('Constants', 'foo');
+        Object.defineProperty(context, 'entity', { value: constant, writable: false });
+
+        const result = provider.getInformation(context);
+
+        expect(result).toBeDefined();
+        expect(result).toContain('(constant) foo: string');
+        expect(result).toContain('**Value:** bar');
+    });
+
+    it('should return hover information for object constant', () => {
+        const constant = new Constant('obj', { TestObject: { A: 'b' } });
+        const context = createMockContext('Constants', 'obj');
+        Object.defineProperty(context, 'entity', { value: constant, writable: false });
+
+        const result = provider.getInformation(context);
+
+        expect(result).toBeDefined();
+        expect(result).toContain('(constant) obj: object');
+        expect(result).toContain('**Value:** [Object]');
+    });
+
+    it('should return undefined when entity is not present', () => {
+        const context = createMockContext('Constants', 'foo');
+
+        const result = provider.getInformation(context);
+
+        expect(result).toBeUndefined();
+    });
+});