@typespec/compiler 1.17.0-dev.0 → 1.17.0-dev.11

package/dist/src/core/checker.js

@@ -299,13 +299,17 @@ export function createChecker(program, resolver) {
      */
     function checkMemberSym(ctx, sym) {
         const symbolLinks = getSymbolLinks(sym);
-        const memberContainer = getTypeForNode(getSymNode(sym.parent), ctx);
+        const parentNode = getSymNode(sym.parent);
+        compilerAssert(parentNode, "Expected member container parent symbol to have a node");
+        const memberContainer = getTypeForNode(parentNode, ctx);
         const type = symbolLinks.declaredType ?? symbolLinks.type;
         if (type) {
             return type;
         }
         else {
-            return checkMember(ctx, getSymNode(sym), memberContainer);
+            const memberNode = getSymNode(sym);
+            compilerAssert(memberNode, "Expected member symbol to have a node");
+            return checkMember(ctx, memberNode, memberContainer);
         }
     }
     /**
@@ -558,20 +562,28 @@ export function createChecker(program, resolver) {
                 return checkModel(ctx, node);
             case SyntaxKind.ModelStatement:
                 return checkModel(ctx, node);
+            case SyntaxKind.ModelDeclarationExpression:
+                return checkModel(ctx, node);
             case SyntaxKind.ModelProperty:
                 return checkModelProperty(ctx, node);
             case SyntaxKind.ScalarStatement:
                 return checkScalar(ctx, node);
+            case SyntaxKind.ScalarDeclarationExpression:
+                return checkScalar(ctx, node);
             case SyntaxKind.AliasStatement:
                 return checkAlias(ctx, node);
             case SyntaxKind.EnumStatement:
                 return checkEnum(ctx, node);
+            case SyntaxKind.EnumDeclarationExpression:
+                return checkEnum(ctx, node);
             case SyntaxKind.EnumMember:
                 return checkEnumMember(ctx, node);
             case SyntaxKind.InterfaceStatement:
                 return checkInterface(ctx, node);
             case SyntaxKind.UnionStatement:
                 return checkUnion(ctx, node);
+            case SyntaxKind.UnionDeclarationExpression:
+                return checkUnion(ctx, node);
             case SyntaxKind.UnionVariant:
                 return checkUnionVariant(ctx, node);
             case SyntaxKind.NamespaceStatement:
@@ -631,6 +643,21 @@ export function createChecker(program, resolver) {
                 return errorType;
         }
     }
+    function reportDeclarationExpressionFeature(node) {
+        const isExpression = node.kind === SyntaxKind.ModelDeclarationExpression ||
+            node.kind === SyntaxKind.ScalarDeclarationExpression ||
+            node.kind === SyntaxKind.EnumDeclarationExpression ||
+            node.kind === SyntaxKind.UnionDeclarationExpression;
+        if (!isExpression) {
+            return;
+        }
+        if (!isCompilerFeatureEnabled(program, "declaration-expressions", node)) {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "declaration-expression-disabled",
+                target: node,
+            }));
+        }
+    }
     /**
      * Return a fully qualified id of node
      */
@@ -673,7 +700,7 @@ export function createChecker(program, resolver) {
         let type = links.declaredType;
         if (type === undefined) {
             if (grandParentNode) {
-                if (grandParentNode.locals?.has(node.id.sv)) {
+                if ("locals" in grandParentNode && grandParentNode.locals?.has(node.id.sv)) {
                     reportCheckerDiagnostic(createDiagnostic({
                         code: "shadow",
                         format: { name: node.id.sv },
@@ -1096,6 +1123,7 @@ export function createChecker(program, resolver) {
                 return sym.type;
             }
             else if (sym.flags & SymbolFlags.TemplateParameter) {
+                compilerAssert(symNode, "Expected template parameter symbol to have a node");
                 const mapped = checkTemplateParameterDeclaration(ctx, symNode);
                 baseType = mapped;
             }
@@ -1112,6 +1140,7 @@ export function createChecker(program, resolver) {
                 }
                 else {
                     // don't have a cached type for this symbol, so go grab it and cache it
+                    compilerAssert(symNode, "Expected symbol to have a node to resolve type");
                     baseType = getTypeForNode(symNode, ctx);
                     symbolLinks.type = baseType;
                 }
@@ -1295,7 +1324,12 @@ export function createChecker(program, resolver) {
             if (type === neverType) {
                 continue;
             }
-            if (type.kind === "Union" && type.expression) {
+            // Flatten nested union expressions (e.g. `(a | b) | c` or an alias to a union
+            // expression). Only the `|`-operator form is flattened: its variants are
+            // anonymous (symbol-keyed) and cannot collide. Keyword-form unions used in
+            // expression position (`union { a, b }`) are also `expression: true` but can have
+            // named variants, so flattening them would silently drop colliding members.
+            if (type.kind === "Union" && type.node?.kind === SyntaxKind.UnionExpression) {
                 for (const [name, variant] of type.variants) {
                     unionType.variants.set(name, variant);
                 }
@@ -1673,7 +1707,11 @@ export function createChecker(program, resolver) {
             return undefined;
         if (node.kind === SyntaxKind.ModelExpression ||
             node.kind === SyntaxKind.IntersectionExpression ||
-            node.kind === SyntaxKind.UnionExpression) {
+            node.kind === SyntaxKind.UnionExpression ||
+            node.kind === SyntaxKind.ModelDeclarationExpression ||
+            node.kind === SyntaxKind.EnumDeclarationExpression ||
+            node.kind === SyntaxKind.UnionDeclarationExpression ||
+            node.kind === SyntaxKind.ScalarDeclarationExpression) {
             let parent = node.parent;
             while (parent !== undefined) {
                 if (parent.kind === SyntaxKind.AliasStatement ||
@@ -3221,17 +3259,20 @@ export function createChecker(program, resolver) {
         return getCanonicalResolvedMemberSymbol(type, node.id.sv);
     }
     function getMemberKindName(node) {
-        switch (node.kind) {
+        switch (node?.kind) {
             case SyntaxKind.ModelStatement:
+            case SyntaxKind.ModelDeclarationExpression:
             case SyntaxKind.ModelExpression:
                 return "Model";
             case SyntaxKind.ModelProperty:
                 return "ModelProperty";
             case SyntaxKind.EnumStatement:
+            case SyntaxKind.EnumDeclarationExpression:
                 return "Enum";
             case SyntaxKind.InterfaceStatement:
                 return "Interface";
             case SyntaxKind.UnionStatement:
+            case SyntaxKind.UnionDeclarationExpression:
                 return "Union";
             default:
                 return "Type";
@@ -3339,6 +3380,7 @@ export function createChecker(program, resolver) {
      */
     function getAliasedSymbol(ctx, aliasSymbol) {
         const node = getSymNode(aliasSymbol);
+        compilerAssert(node, "Expected alias symbol to have a node");
         const links = resolver.getSymbolLinks(aliasSymbol);
         if (!links.aliasResolutionIsTemplate) {
             const aliased = links.aliasedSymbol ?? resolver.getNodeLinks(node).resolvedSymbol;
@@ -3670,11 +3712,26 @@ export function createChecker(program, resolver) {
         }
     }
     function checkModel(ctx, node) {
-        if (node.kind === SyntaxKind.ModelStatement) {
-            return checkModelStatement(ctx, node);
+        if (node.kind === SyntaxKind.ModelExpression) {
+            return checkModelExpression(ctx, node);
         }
         else {
-            return checkModelExpression(ctx, node);
+            return checkModelStatement(ctx, node);
+        }
+    }
+    /**
+     * A declaration used in expression position is anonymous and cannot be referenced or
+     * instantiated, so template parameters on it are meaningless. Report a diagnostic when present.
+     */
+    function checkExpressionDeclarationConstraints(node) {
+        const isExpression = node.kind === SyntaxKind.ModelDeclarationExpression ||
+            node.kind === SyntaxKind.UnionDeclarationExpression ||
+            node.kind === SyntaxKind.ScalarDeclarationExpression;
+        if (isExpression && node.templateParameters.length > 0) {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "templated-declaration-in-expression",
+                target: node.templateParameters[0],
+            }));
         }
     }
     function checkModelStatement(ctx, node) {
@@ -3690,16 +3747,21 @@ export function createChecker(program, resolver) {
             checkModifiers(program, node);
         }
         checkTemplateDeclaration(ctx, node);
+        checkExpressionDeclarationConstraints(node);
+        if (ctx.mapper === undefined) {
+            reportDeclarationExpressionFeature(node);
+        }
         const decorators = [];
         const type = createType({
             kind: "Model",
-            name: node.id.sv,
+            name: node.id?.sv ?? "",
             node: node,
             properties: createRekeyableMap(),
             namespace: getParentNamespaceType(node),
             decorators,
             sourceModels: [],
             derivedModels: [],
+            expression: node.kind === SyntaxKind.ModelDeclarationExpression,
         });
         linkType(ctx, links, type);
         if (node.symbol.members) {
@@ -3750,7 +3812,7 @@ export function createChecker(program, resolver) {
             }
             // Hold on to the model type that's being defined so that it
             // can be referenced
-            if (ctx.mapper === undefined) {
+            if (ctx.mapper === undefined && !type.expression) {
                 type.namespace?.models.set(type.name, type);
             }
             // Evaluate the properties after
@@ -3841,6 +3903,14 @@ export function createChecker(program, resolver) {
             else {
                 // spread property
                 const [newProperties, additionalIndexer] = checkSpreadProperty(ctx, node.symbol, prop.target, parentModel);
+                if (findIndexer(parentModel)?.key.name === "integer" &&
+                    (newProperties.length > 0 || additionalIndexer !== undefined)) {
+                    reportCheckerDiagnostic(createDiagnostic({
+                        code: "no-array-properties",
+                        target: prop,
+                    }));
+                    continue;
+                }
                 if (additionalIndexer) {
                     if (spreadIndexers) {
                         spreadIndexers.push(additionalIndexer);
@@ -3892,6 +3962,7 @@ export function createChecker(program, resolver) {
             decorators: [],
             derivedModels: [],
             sourceModels: [],
+            expression: true,
         });
         for (const prop of properties.values()) {
             model.properties.set(prop.name, createModelPropertyForObjectPropertyDescriptor(prop, model));
@@ -5333,7 +5404,8 @@ export function createChecker(program, resolver) {
         }
         else if (links.finalSymbol?.flags &&
             ~links.finalSymbol.flags & SymbolFlags.Declaration &&
-            ~links.finalSymbol.flags & SymbolFlags.Member) {
+            ~links.finalSymbol.flags & SymbolFlags.Member &&
+            !isDeclarationExpressionSym(links.finalSymbol)) {
             program.reportDiagnostic(createDiagnostic({
                 code: "augment-decorator-target",
                 messageId: links.finalSymbol.flags & SymbolFlags.Model
@@ -5346,6 +5418,7 @@ export function createChecker(program, resolver) {
         }
         else if (links.finalSymbol?.flags && links.finalSymbol.flags & SymbolFlags.Alias) {
             const aliasNode = getSymNode(links.finalSymbol);
+            compilerAssert(aliasNode, "Expected alias symbol to have a node");
             program.reportDiagnostic(createDiagnostic({
                 code: "augment-decorator-target",
                 messageId: aliasNode.value.kind === SyntaxKind.UnionExpression ? "noUnionExpression" : "default",
@@ -5355,6 +5428,23 @@ export function createChecker(program, resolver) {
         // If this was used to get a type this is invalid, only used for validation.
         return errorType;
     }
+    /**
+     * A declaration expression (e.g. the `enum { a, b }` in `model Foo { x: enum { a, b } }`)
+     * is bound as a non-declaration symbol but is still a real, referenceable type
+     * (e.g. via `Foo.x::type`) and therefore a valid augment target. Statement-position
+     * declarations carry {@link SymbolFlags.Declaration} and never reach this check.
+     */
+    function isDeclarationExpressionSym(sym) {
+        switch (getSymNode(sym)?.kind) {
+            case SyntaxKind.ModelDeclarationExpression:
+            case SyntaxKind.EnumDeclarationExpression:
+            case SyntaxKind.UnionDeclarationExpression:
+            case SyntaxKind.ScalarDeclarationExpression:
+                return true;
+            default:
+                return false;
+        }
+    }
     /**
      * Check that using statements are targeting valid symbols.
      */
@@ -5427,15 +5517,20 @@ export function createChecker(program, resolver) {
             checkModifiers(program, node);
         }
         checkTemplateDeclaration(ctx, node);
+        checkExpressionDeclarationConstraints(node);
+        if (ctx.mapper === undefined) {
+            reportDeclarationExpressionFeature(node);
+        }
         const decorators = [];
         const type = createType({
             kind: "Scalar",
-            name: node.id.sv,
+            name: node.id?.sv ?? "",
             node: node,
             constructors: new Map(),
             namespace: getParentNamespaceType(node),
             decorators,
             derivedScalars: [],
+            expression: node.kind === SyntaxKind.ScalarDeclarationExpression,
         });
         linkType(ctx, links, type);
         if (node.extends) {
@@ -5447,7 +5542,7 @@ export function createChecker(program, resolver) {
         }
         checkScalarConstructors(ctx, type, node, type.constructors);
         decorators.push(...checkDecorators(ctx, type, node));
-        if (ctx.mapper === undefined) {
+        if (ctx.mapper === undefined && !type.expression) {
             type.namespace?.scalars.set(type.name, type);
         }
         linkMapper(type, ctx.mapper);
@@ -5631,46 +5726,57 @@ export function createChecker(program, resolver) {
     }
     function checkEnum(ctx, node) {
         const links = getSymbolLinks(node.symbol);
-        if (!links.type) {
+        if (links.declaredType && ctx.mapper === undefined) {
+            // we're not instantiating this enum and we've already checked it
+            return links.declaredType;
+        }
+        if (ctx.mapper === undefined) {
             checkModifiers(program, node);
-            const enumType = (links.type = createType({
-                kind: "Enum",
-                name: node.id.sv,
-                node,
-                members: createRekeyableMap(),
-                decorators: [],
-            }));
-            const memberNames = new Set();
-            for (const member of node.members) {
-                if (member.kind === SyntaxKind.EnumMember) {
-                    const memberType = checkEnumMember(ctx, member, enumType);
-                    if (memberNames.has(memberType.name)) {
-                        reportCheckerDiagnostic(createDiagnostic({
-                            code: "enum-member-duplicate",
-                            format: { name: memberType.name },
-                            target: node,
-                        }));
-                        continue;
-                    }
-                    memberNames.add(memberType.name);
-                    enumType.members.set(memberType.name, memberType);
+            reportDeclarationExpressionFeature(node);
+        }
+        const enumType = createType({
+            kind: "Enum",
+            name: node.id?.sv ?? "",
+            node,
+            members: createRekeyableMap(),
+            decorators: [],
+            expression: node.kind === SyntaxKind.EnumDeclarationExpression,
+        });
+        // Link the type before resolving the parent namespace: resolving the namespace may run
+        // its decorators which can reference this enum, and we must not create a second instance.
+        linkType(ctx, links, enumType);
+        const memberNames = new Set();
+        for (const member of node.members) {
+            if (member.kind === SyntaxKind.EnumMember) {
+                const memberType = checkEnumMember(ctx, member, enumType);
+                if (memberNames.has(memberType.name)) {
+                    reportCheckerDiagnostic(createDiagnostic({
+                        code: "enum-member-duplicate",
+                        format: { name: memberType.name },
+                        target: node,
+                    }));
+                    continue;
                 }
-                else {
-                    const members = checkEnumSpreadMember(ctx, node.symbol, enumType, member.target, memberNames);
-                    for (const memberType of members) {
-                        linkIndirectMember(ctx, node, memberType);
-                        enumType.members.set(memberType.name, memberType);
-                    }
+                memberNames.add(memberType.name);
+                enumType.members.set(memberType.name, memberType);
+            }
+            else {
+                const members = checkEnumSpreadMember(ctx, node.symbol, enumType, member.target, memberNames);
+                for (const memberType of members) {
+                    linkIndirectMember(ctx, node, memberType);
+                    enumType.members.set(memberType.name, memberType);
                 }
             }
-            const namespace = getParentNamespaceType(node);
-            enumType.namespace = namespace;
+        }
+        enumType.namespace = getParentNamespaceType(node);
+        if (ctx.mapper === undefined && !enumType.expression) {
             enumType.namespace?.enums.set(enumType.name, enumType);
-            enumType.decorators = checkDecorators(ctx, enumType, node);
-            linkMapper(enumType, ctx.mapper);
-            finishType(enumType);
         }
-        return links.type;
+        enumType.decorators = checkDecorators(ctx, enumType, node);
+        linkMapper(enumType, ctx.mapper);
+        return finishType(enumType, {
+            skipDecorators: ctx.hasFlags(CheckFlags.InTemplateDeclaration),
+        });
     }
     function checkInterface(ctx, node) {
         const links = getSymbolLinks(node.symbol);
@@ -5781,18 +5887,22 @@ export function createChecker(program, resolver) {
             }
         }
         checkTemplateDeclaration(ctx, node);
+        checkExpressionDeclarationConstraints(node);
+        if (ctx.mapper === undefined) {
+            reportDeclarationExpressionFeature(node);
+        }
         const variants = createRekeyableMap();
         const unionType = createType({
             kind: "Union",
             decorators: [],
             node,
             namespace: getParentNamespaceType(node),
-            name: node.id.sv,
+            name: node.id?.sv,
             variants,
             get options() {
                 return Array.from(this.variants.values()).map((v) => v.type);
             },
-            expression: false,
+            expression: node.kind === SyntaxKind.UnionDeclarationExpression,
         });
         linkType(ctx, links, unionType);
         if (node.extends) {
@@ -5801,11 +5911,13 @@ export function createChecker(program, resolver) {
         unionType.decorators = checkDecorators(ctx, unionType, node);
         checkUnionVariants(ctx, unionType, node, variants);
         linkMapper(unionType, ctx.mapper);
-        if (ctx.mapper === undefined) {
+        if (ctx.mapper === undefined && !unionType.expression) {
             unionType.namespace?.unions.set(unionType.name, unionType);
         }
         lateBindMemberContainer(unionType);
-        lateBindMembers(unionType);
+        if (unionType.symbol) {
+            lateBindMembers(unionType);
+        }
         return finishType(unionType, {
             skipDecorators: ctx.hasFlags(CheckFlags.InTemplateDeclaration),
         });
@@ -5876,7 +5988,7 @@ export function createChecker(program, resolver) {
                 if (ctx.mapper === undefined) {
                     reportCheckerDiagnostic(createDiagnostic({
                         code: "circular-base-type",
-                        format: { typeName: union.id.sv },
+                        format: { typeName: union.id?.sv ?? "(anonymous union)" },
                         target: extendsRef,
                     }));
                 }
@@ -6080,6 +6192,7 @@ export function createChecker(program, resolver) {
             decorators: [],
             derivedModels: [],
             sourceModels: [],
+            expression: true,
         });
     }
     /**
@@ -6786,6 +6899,8 @@ function createFunctionContext(program, fnCall) {
     };
 }
 function isTemplatedNode(node) {
+    if (node === undefined)
+        return false;
     return "templateParameters" in node && node.templateParameters.length > 0;
 }
 var ResolutionKind;