@typespec/compiler 0.52.0-dev.0 → 0.52.0-dev.10

package/dist/src/core/checker.js

@@ -12,7 +12,7 @@ import { validateInheritanceDiscriminatedUnions } from "./helpers/discriminator-
 import { getNamespaceFullName, getTypeName, stringTemplateToString, } from "./helpers/index.js";
 import { isStringTemplateSerializable } from "./helpers/string-template-utils.js";
 import { createDiagnostic } from "./messages.js";
-import { getIdentifierContext, hasParseError, visitChildren } from "./parser.js";
+import { exprIsBareIdentifier, getIdentifierContext, hasParseError, visitChildren, } from "./parser.js";
 import { createProjectionMembers } from "./projection-members.js";
 import { getFullyQualifiedSymbolName, getParentTemplateNode, isNeverType, isTemplateInstance, isUnknownType, isVoidType, } from "./type-utils.js";
 import { IdentifierKind, SyntaxKind, } from "./types.js";
@@ -372,6 +372,8 @@ export function createChecker(program) {
                 return checkFunctionDeclaration(node, mapper);
             case SyntaxKind.TypeReference:
                 return checkTypeReference(node, mapper);
+            case SyntaxKind.TemplateArgument:
+                return checkTemplateArgument(node, mapper);
             case SyntaxKind.TemplateParameterDeclaration:
                 return checkTemplateParameterDeclaration(node, mapper);
             case SyntaxKind.ProjectionStatement:
@@ -498,6 +500,9 @@ export function createChecker(program) {
         const type = checkTypeReferenceSymbol(sym, node, mapper, instantiateTemplate);
         return type;
     }
+    function checkTemplateArgument(node, mapper) {
+        return getTypeForNode(node.argument, mapper);
+    }
     function resolveTypeReference(node) {
         const oldDiagnosticHook = onCheckerDiagnostic;
         const diagnostics = [];
@@ -560,69 +565,117 @@ export function createChecker(program) {
                 return false;
         }
     }
-    function checkTypeReferenceArgs(node, mapper) {
-        const args = [];
-        if (node.kind !== SyntaxKind.TypeReference) {
-            return args;
-        }
-        for (const arg of node.arguments) {
-            const value = getTypeForNode(arg, mapper);
-            args.push([arg, value]);
-        }
-        return args;
-    }
-    function checkTemplateInstantiationArgs(node, args, declarations) {
-        var _a, _b, _c;
-        if (args.length > declarations.length) {
-            reportCheckerDiagnostic(createDiagnostic({
-                code: "invalid-template-args",
-                messageId: "tooMany",
-                target: node,
-            }));
-            // Too many args shouldn't matter for instantiating we can still go ahead
-        }
-        const values = [];
-        const params = [];
-        let tooFew = false;
-        for (let i = 0; i < declarations.length; i++) {
-            const declaration = declarations[i];
-            const declaredType = getTypeForNode(declaration);
-            params.push(declaredType);
-            if (i < args.length) {
-                let [valueNode, value] = args[i];
-                if (declaredType.constraint) {
-                    if (!checkTypeAssignable(value, declaredType.constraint, valueNode)) {
-                        // TODO-TIM check if we expose this below
-                        value =
-                            ((_a = declaredType.constraint) === null || _a === void 0 ? void 0 : _a.kind) === "Value" ? unknownType : declaredType.constraint;
-                    }
+    function checkTemplateInstantiationArgs(node, args, decls, mapper) {
+        var _a, _b, _c, _d;
+        var _e;
+        const params = new Map();
+        const positional = [];
+        const initMap = new Map(decls.map(function (decl) {
+            const declaredType = getTypeForNode(decl);
+            positional.push(declaredType);
+            params.set(decl.id.sv, declaredType);
+            return [
+                declaredType,
+                {
+                    decl,
+                    checkArgument: null,
+                },
+            ];
+        }));
+        let named = false;
+        for (const [arg, idx] of args.map((v, i) => [v, i])) {
+            function deferredCheck() {
+                return [arg, getTypeForNode(arg.argument, mapper)];
+            }
+            if (arg.name) {
+                named = true;
+                const param = params.get(arg.name.sv);
+                if (!param) {
+                    reportCheckerDiagnostic(createDiagnostic({
+                        code: "invalid-template-args",
+                        messageId: "unknownName",
+                        format: {
+                            name: arg.name.sv,
+                        },
+                        target: arg,
+                    }));
+                    continue;
+                }
+                if (initMap.get(param).checkArgument !== null) {
+                    reportCheckerDiagnostic(createDiagnostic({
+                        code: "invalid-template-args",
+                        messageId: "specifiedAgain",
+                        format: {
+                            name: arg.name.sv,
+                        },
+                        target: arg,
+                    }));
+                    continue;
                 }
-                values.push(value);
+                initMap.get(param).checkArgument = deferredCheck;
             }
             else {
-                const mapper = createTypeMapper(params, values);
-                const defaultValue = getResolvedTypeParameterDefault(declaredType, declaration, mapper);
+                if (named) {
+                    reportCheckerDiagnostic(createDiagnostic({
+                        code: "invalid-template-args",
+                        messageId: "positionalAfterNamed",
+                        target: arg,
+                    }));
+                    // we just throw this arg away. any missing args will be filled with ErrorType
+                }
+                if (idx >= positional.length) {
+                    reportCheckerDiagnostic(createDiagnostic({
+                        code: "invalid-template-args",
+                        messageId: "tooMany",
+                        target: node,
+                    }));
+                    continue;
+                }
+                const param = positional[idx];
+                (_a = (_e = initMap.get(param)).checkArgument) !== null && _a !== void 0 ? _a : (_e.checkArgument = deferredCheck);
+            }
+        }
+        const finalMap = initMap;
+        const mapperParams = [];
+        const mapperArgs = [];
+        for (const [param, { decl, checkArgument: init }] of [...initMap]) {
+            function commit(param, type) {
+                finalMap.set(param, type);
+                mapperParams.push(param);
+                mapperArgs.push(type);
+            }
+            if (init === null) {
+                const argumentMapper = createTypeMapper(mapperParams, mapperArgs);
+                const defaultValue = getResolvedTypeParameterDefault(param, decl, argumentMapper);
                 if (defaultValue) {
-                    values.push(defaultValue);
+                    commit(param, defaultValue);
                 }
                 else {
-                    tooFew = true;
-                    values.push(
+                    reportCheckerDiagnostic(createDiagnostic({
+                        code: "invalid-template-args",
+                        messageId: "missing",
+                        format: {
+                            name: decl.id.sv,
+                        },
+                        target: node,
+                    }));
                     // TODO-TIM check if we expose this below
-                    ((_b = declaredType.constraint) === null || _b === void 0 ? void 0 : _b.kind) === "Value"
-                        ? unknownType
-                        : (_c = declaredType.constraint) !== null && _c !== void 0 ? _c : unknownType);
+                    commit(param, ((_b = param.constraint) === null || _b === void 0 ? void 0 : _b.kind) === "Value" ? unknownType : (_c = param.constraint) !== null && _c !== void 0 ? _c : unknownType);
                 }
+                continue;
             }
+            const [argNode, type] = init();
+            if (param.constraint) {
+                if (!checkTypeAssignable(type, param.constraint, argNode)) {
+                    // TODO-TIM check if we expose this below
+                    const effectiveType = ((_d = param.constraint) === null || _d === void 0 ? void 0 : _d.kind) === "Value" ? unknownType : param.constraint;
+                    commit(param, effectiveType);
+                    continue;
+                }
+            }
+            commit(param, type);
         }
-        if (tooFew) {
-            reportCheckerDiagnostic(createDiagnostic({
-                code: "invalid-template-args",
-                messageId: "tooFew",
-                target: node,
-            }));
-        }
-        return [params, values];
+        return finalMap;
     }
     /**
      * Check and resolve the type for the given symbol + node.
@@ -641,9 +694,9 @@ export function createChecker(program) {
             reportCheckerDiagnostic(createDiagnostic({ code: "invalid-type-ref", messageId: "function", target: sym }));
             return errorType;
         }
+        const argumentNodes = node.kind === SyntaxKind.TypeReference ? node.arguments : [];
         const symbolLinks = getSymbolLinks(sym);
         let baseType;
-        const args = checkTypeReferenceArgs(node, mapper);
         if (sym.flags &
             (2 /* SymbolFlags.Model */ |
                 8 /* SymbolFlags.Scalar */ |
@@ -653,7 +706,7 @@ export function createChecker(program) {
                 512 /* SymbolFlags.Union */)) {
             const decl = sym.declarations[0];
             if (!isTemplatedNode(decl)) {
-                if (args.length > 0) {
+                if (argumentNodes.length > 0) {
                     reportCheckerDiagnostic(createDiagnostic({
                         code: "invalid-template-args",
                         messageId: "notTemplate",
@@ -677,13 +730,13 @@ export function createChecker(program) {
             else {
                 const declaredType = getOrCheckDeclaredType(sym, decl, mapper);
                 const templateParameters = decl.templateParameters;
-                const [params, instantiationArgs] = checkTemplateInstantiationArgs(node, args, templateParameters);
-                baseType = getOrInstantiateTemplate(decl, params, instantiationArgs, declaredType.templateMapper, instantiateTemplates);
+                const instantiation = checkTemplateInstantiationArgs(node, argumentNodes, templateParameters, mapper);
+                baseType = getOrInstantiateTemplate(decl, [...instantiation.keys()], [...instantiation.values()], declaredType.templateMapper, instantiateTemplates);
             }
         }
         else {
             // some other kind of reference
-            if (args.length > 0) {
+            if (argumentNodes.length > 0) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "invalid-template-args",
                     messageId: "notTemplate",
@@ -1356,16 +1409,30 @@ export function createChecker(program) {
                 }
                 sym = resolveTypeReferenceSym(ref, mapper, resolveDecorator);
                 break;
+            case IdentifierKind.TemplateArgument:
+                const templates = getTemplateDeclarationsForArgument(node, mapper);
+                const firstMatchingParameter = templates
+                    .flatMap((t) => t.templateParameters)
+                    .find((p) => p.id.sv === id.sv);
+                if (firstMatchingParameter) {
+                    sym = getMergedSymbol(firstMatchingParameter.symbol);
+                }
+                break;
             default:
                 const _assertNever = kind;
                 compilerAssert(false, "Unreachable");
         }
         return (_c = sym === null || sym === void 0 ? void 0 : sym.symbolSource) !== null && _c !== void 0 ? _c : sym;
     }
+    function getTemplateDeclarationsForArgument(node, mapper) {
+        var _a;
+        const resolved = resolveTypeReferenceSym(node.parent, mapper, false);
+        return ((_a = resolved === null || resolved === void 0 ? void 0 : resolved.declarations.filter((n) => isTemplatedNode(n))) !== null && _a !== void 0 ? _a : []);
+    }
     function resolveCompletions(identifier) {
-        var _a, _b;
+        var _a, _b, _c;
         const completions = new Map();
-        const { kind } = getIdentifierContext(identifier);
+        const { kind, node: ancestor } = getIdentifierContext(identifier);
         switch (kind) {
             case IdentifierKind.Using:
             case IdentifierKind.Decorator:
@@ -1376,6 +1443,15 @@ export function createChecker(program) {
                 return completions; // not implemented
             case IdentifierKind.Declaration:
                 return completions; // cannot complete, name can be chosen arbitrarily
+            case IdentifierKind.TemplateArgument: {
+                const templates = getTemplateDeclarationsForArgument(ancestor, undefined);
+                for (const template of templates) {
+                    for (const param of template.templateParameters) {
+                        addCompletion(param.id.sv, param.symbol);
+                    }
+                }
+                return completions;
+            }
             default:
                 const _assertNever = kind;
                 compilerAssert(false, "Unreachable");
@@ -1399,6 +1475,19 @@ export function createChecker(program) {
             }
         }
         else {
+            // We will only add template arguments if the template isn't already named
+            // to avoid completing the name of the argument again.
+            if (kind === IdentifierKind.TypeReference &&
+                exprIsBareIdentifier(ancestor) &&
+                ((_c = ancestor.parent) === null || _c === void 0 ? void 0 : _c.kind) === SyntaxKind.TemplateArgument &&
+                ancestor.parent.name === undefined) {
+                const templates = getTemplateDeclarationsForArgument(ancestor.parent, undefined);
+                for (const template of templates) {
+                    for (const param of template.templateParameters) {
+                        addCompletion(param.id.sv, param.symbol, { suffix: " = " });
+                    }
+                }
+            }
             let scope = identifier.parent;
             while (scope && scope.kind !== SyntaxKind.TypeSpecScript) {
                 if (scope.symbol && scope.symbol.exports) {
@@ -1444,7 +1533,7 @@ export function createChecker(program) {
                 }
             }
         }
-        function addCompletion(key, sym) {
+        function addCompletion(key, sym, options = {}) {
             if (sym.symbolSource) {
                 sym = sym.symbolSource;
             }
@@ -1455,7 +1544,7 @@ export function createChecker(program) {
                 key = key.slice(1);
             }
             if (!completions.has(key)) {
-                completions.set(key, { sym });
+                completions.set(key, { ...options, sym });
             }
         }
         function shouldAddCompletion(sym) {
@@ -1469,6 +1558,8 @@ export function createChecker(program) {
                 case IdentifierKind.TypeReference:
                     // Do not return functions or decorators when completing types
                     return !(sym.flags & (131072 /* SymbolFlags.Function */ | 16384 /* SymbolFlags.Decorator */));
+                case IdentifierKind.TemplateArgument:
+                    return !!(sym.flags & 32768 /* SymbolFlags.TemplateParameter */);
                 default:
                     compilerAssert(false, "We should have bailed up-front on other kinds.");
             }
@@ -2086,7 +2177,6 @@ export function createChecker(program) {
                 switch (node.value.kind) {
                     case SyntaxKind.MemberExpression:
                     case SyntaxKind.TypeReference:
-                    case SyntaxKind.Identifier:
                         const resolvedSym = resolveTypeReferenceSym(node.value, undefined);
                         if (resolvedSym && resolvedSym.flags & 2048 /* SymbolFlags.Alias */) {
                             return resolveAliasedSymbol(resolvedSym);
@@ -2635,7 +2725,7 @@ export function createChecker(program) {
         const decorators = [];
         const augmentDecoratorNodes = (_b = augmentDecoratorsForSym.get(sym)) !== null && _b !== void 0 ? _b : [];
         const decoratorNodes = [
-            ...augmentDecoratorNodes,
+            ...augmentDecoratorNodes, // the first decorator will be executed at last, so augmented decorator should be placed at first.
             ...node.decorators,
         ];
         for (const decNode of decoratorNodes) {