@typespec/compiler 0.57.0-dev.8 → 0.58.0-dev.0

package/dist/src/core/checker.js

@@ -15,7 +15,7 @@ import { canNumericConstraintBeJsNumber, legacyMarshallTypeForJS, marshallTypeFo
 import { createDiagnostic } from "./messages.js";
 import { numericRanges } from "./numeric-ranges.js";
 import { Numeric } from "./numeric.js";
-import { exprIsBareIdentifier, getIdentifierContext, hasParseError, visitChildren, } from "./parser.js";
+import { exprIsBareIdentifier, getFirstAncestor, getIdentifierContext, hasParseError, visitChildren, } from "./parser.js";
 import { createProjectionMembers } from "./projection-members.js";
 import { getFullyQualifiedSymbolName, getParentTemplateNode, isArrayModelType, isErrorType, isNeverType, isNullType, isTemplateInstance, isType, isUnknownType, isValue, isVoidType, } from "./type-utils.js";
 import { IdentifierKind, SyntaxKind, } from "./types.js";
@@ -29,6 +29,7 @@ export function createChecker(program) {
     const stdTypes = {};
     const symbolLinks = new Map();
     const mergedSymbols = new Map();
+    const docFromCommentForSym = new Map();
     const augmentDecoratorsForSym = new Map();
     const augmentedSymbolTables = new Map();
     const referenceSymCache = new WeakMap();
@@ -1661,6 +1662,17 @@ export function createChecker(program) {
         const namespace = getParentNamespaceType(node);
         const name = node.id.sv;
         let decorators = [];
+        const parameterModelSym = getOrCreateAugmentedSymbolTable(symbol.metatypeMembers).get("parameters");
+        if (parameterModelSym?.members) {
+            const members = getOrCreateAugmentedSymbolTable(parameterModelSym.members);
+            const paramDocs = extractParamDocs(node);
+            for (const [name, memberSym] of members) {
+                const doc = paramDocs.get(name);
+                if (doc) {
+                    docFromCommentForSym.set(memberSym, doc);
+                }
+            }
+        }
         // Is this a definition or reference?
         let parameters, returnType, sourceOperation;
         if (node.signature.kind === SyntaxKind.OperationSignatureReference) {
@@ -1668,7 +1680,6 @@ export function createChecker(program) {
             const baseOperation = checkOperationIs(node, node.signature.baseOperation, mapper);
             if (baseOperation) {
                 sourceOperation = baseOperation;
-                const parameterModelSym = getOrCreateAugmentedSymbolTable(symbol.metatypeMembers).get("parameters");
                 // Reference the same return type and create the parameters type
                 const clone = initializeClone(baseOperation.parameters, {
                     properties: createRekeyableMap(),
@@ -1834,6 +1845,17 @@ export function createChecker(program) {
         let sym;
         const { node, kind } = getIdentifierContext(id);
         switch (kind) {
+            case IdentifierKind.ModelExpressionProperty:
+            case IdentifierKind.ObjectLiteralProperty:
+                const model = getReferencedModel(node);
+                if (model) {
+                    sym = getMemberSymbol(model.node.symbol, id.sv);
+                }
+                else {
+                    return undefined;
+                }
+                break;
+            case IdentifierKind.ModelStatementProperty:
             case IdentifierKind.Declaration:
                 if (node.symbol && (!isTemplatedNode(node) || mapper === undefined)) {
                     sym = getMergedSymbol(node.symbol);
@@ -1898,6 +1920,164 @@ export function createChecker(program) {
         const resolved = resolveTypeReferenceSym(node.parent, mapper, false);
         return (resolved?.declarations.filter((n) => isTemplatedNode(n)) ?? []);
     }
+    function getReferencedModel(propertyNode) {
+        const isModelOrArrayValue = (n) => n?.kind === SyntaxKind.ArrayLiteral || n?.kind === SyntaxKind.ObjectLiteral;
+        const isModelOrArrayType = (n) => n?.kind === SyntaxKind.ModelExpression || n?.kind === SyntaxKind.TupleExpression;
+        const isModelOrArray = (n) => isModelOrArrayValue(n) || isModelOrArrayType(n);
+        const path = [];
+        let preNode;
+        const foundNode = getFirstAncestor(propertyNode, (n) => {
+            pushToModelPath(n, preNode, path);
+            preNode = n;
+            return ((isModelOrArray(n) &&
+                (n.parent?.kind === SyntaxKind.TemplateParameterDeclaration ||
+                    n.parent?.kind === SyntaxKind.DecoratorExpression)) ||
+                (isModelOrArrayValue(n) &&
+                    (n.parent?.kind === SyntaxKind.CallExpression ||
+                        n.parent?.kind === SyntaxKind.ConstStatement)));
+        });
+        let refType;
+        switch (foundNode?.parent?.kind) {
+            case SyntaxKind.TemplateParameterDeclaration:
+                refType = getReferencedTypeFromTemplateDeclaration(foundNode);
+                break;
+            case SyntaxKind.DecoratorExpression:
+                refType = getReferencedTypeFromDecoratorArgument(foundNode);
+                break;
+            case SyntaxKind.CallExpression:
+                refType = getReferencedTypeFromScalarConstructor(foundNode);
+                break;
+            case SyntaxKind.ConstStatement:
+                refType = getReferencedTypeFromConstAssignment(foundNode);
+                break;
+        }
+        return refType?.kind === "Model" || refType?.kind === "Tuple"
+            ? getNestedModel(refType, path)
+            : undefined;
+        function pushToModelPath(node, preNode, path) {
+            if (node.kind === SyntaxKind.ArrayLiteral || node.kind === SyntaxKind.TupleExpression) {
+                const index = node.values.findIndex((n) => n === preNode);
+                if (index >= 0) {
+                    path.unshift({ tupleIndex: index });
+                }
+                else {
+                    compilerAssert(false, "not expected, can't find child from the parent?");
+                }
+            }
+            if (node.kind === SyntaxKind.ModelProperty ||
+                node.kind === SyntaxKind.ObjectLiteralProperty) {
+                path.unshift({ propertyName: node.id.sv });
+            }
+        }
+        function getNestedModel(modelOrTuple, path) {
+            let cur = modelOrTuple;
+            for (const seg of path) {
+                switch (cur?.kind) {
+                    case "Tuple":
+                        if (seg.tupleIndex !== undefined &&
+                            seg.tupleIndex >= 0 &&
+                            seg.tupleIndex < cur.values.length) {
+                            cur = cur.values[seg.tupleIndex];
+                        }
+                        else {
+                            return undefined;
+                        }
+                        break;
+                    case "Model":
+                        if (cur.name === "Array" && seg.tupleIndex !== undefined) {
+                            cur = cur.templateMapper?.args[0];
+                        }
+                        else if (cur.name !== "Array" && seg.propertyName) {
+                            cur = cur.properties.get(seg.propertyName)?.type;
+                        }
+                        else {
+                            return undefined;
+                        }
+                        break;
+                    default:
+                        return undefined;
+                }
+            }
+            return cur?.kind === "Model" ? cur : undefined;
+        }
+        function getReferencedTypeFromTemplateDeclaration(dftNode) {
+            const templateParmaeterDeclNode = dftNode?.parent;
+            if (templateParmaeterDeclNode?.kind !== SyntaxKind.TemplateParameterDeclaration ||
+                !templateParmaeterDeclNode.constraint ||
+                !templateParmaeterDeclNode.default ||
+                templateParmaeterDeclNode.default !== dftNode) {
+                return undefined;
+            }
+            let constraintType;
+            if (isModelOrArrayValue(dftNode) &&
+                templateParmaeterDeclNode.constraint.kind === SyntaxKind.ValueOfExpression) {
+                constraintType = program.checker.getTypeForNode(templateParmaeterDeclNode.constraint.target);
+            }
+            else if (isModelOrArrayType(dftNode) &&
+                templateParmaeterDeclNode.constraint.kind !== SyntaxKind.ValueOfExpression) {
+                constraintType = program.checker.getTypeForNode(templateParmaeterDeclNode.constraint);
+            }
+            return constraintType;
+        }
+        function getReferencedTypeFromScalarConstructor(argNode) {
+            const callExpNode = argNode?.parent;
+            if (callExpNode?.kind !== SyntaxKind.CallExpression) {
+                return undefined;
+            }
+            const ctorType = checkCallExpressionTarget(callExpNode, undefined);
+            if (ctorType?.kind !== "ScalarConstructor") {
+                return undefined;
+            }
+            const argIndex = callExpNode.arguments.findIndex((n) => n === argNode);
+            if (argIndex < 0 || argIndex >= ctorType.parameters.length) {
+                return undefined;
+            }
+            const arg = ctorType.parameters[argIndex];
+            return arg.type;
+        }
+        function getReferencedTypeFromConstAssignment(valueNode) {
+            const constNode = valueNode?.parent;
+            if (!constNode ||
+                constNode.kind !== SyntaxKind.ConstStatement ||
+                !constNode.type ||
+                constNode.value !== valueNode) {
+                return undefined;
+            }
+            return program.checker.getTypeForNode(constNode.type);
+        }
+        function getReferencedTypeFromDecoratorArgument(decArgNode) {
+            const decNode = decArgNode?.parent;
+            if (decNode?.kind !== SyntaxKind.DecoratorExpression) {
+                return undefined;
+            }
+            const decSym = program.checker.resolveIdentifier(decNode.target.kind === SyntaxKind.MemberExpression ? decNode.target.id : decNode.target);
+            if (!decSym) {
+                return undefined;
+            }
+            const decDecl = decSym.declarations.find((x) => x.kind === SyntaxKind.DecoratorDeclarationStatement);
+            if (!decDecl) {
+                return undefined;
+            }
+            const decType = program.checker.getTypeForNode(decDecl);
+            compilerAssert(decType.kind === "Decorator", "Expected type to be a Decorator.");
+            const argIndex = decNode.arguments.findIndex((n) => n === decArgNode);
+            if (argIndex < 0 || argIndex >= decType.parameters.length) {
+                return undefined;
+            }
+            const decArg = decType.parameters[argIndex];
+            let type;
+            if (isModelOrArrayValue(decArgNode)) {
+                type = decArg.type.valueType;
+            }
+            else if (isModelOrArrayType(decArgNode)) {
+                type = decArg.type.type ?? decArg.type.valueType;
+            }
+            else {
+                compilerAssert(false, "not expected node type to get reference model from decorator argument");
+            }
+            return type;
+        }
+    }
     function resolveCompletions(identifier) {
         const completions = new Map();
         const { kind, node: ancestor } = getIdentifierContext(identifier);
@@ -1906,6 +2086,9 @@ export function createChecker(program) {
             case IdentifierKind.Decorator:
             case IdentifierKind.Function:
             case IdentifierKind.TypeReference:
+            case IdentifierKind.ModelExpressionProperty:
+            case IdentifierKind.ModelStatementProperty:
+            case IdentifierKind.ObjectLiteralProperty:
                 break; // supported
             case IdentifierKind.Other:
                 return completions; // not implemented
@@ -1924,7 +2107,43 @@ export function createChecker(program) {
                 const _assertNever = kind;
                 compilerAssert(false, "Unreachable");
         }
-        if (identifier.parent && identifier.parent.kind === SyntaxKind.MemberExpression) {
+        if (kind === IdentifierKind.ModelStatementProperty) {
+            const model = ancestor.parent;
+            const modelType = program.checker.getTypeForNode(model);
+            const baseType = modelType.baseModel;
+            const baseNode = baseType?.node;
+            if (!baseNode) {
+                return completions;
+            }
+            for (const prop of baseType.properties.values()) {
+                if (identifier.sv === prop.name || !modelType.properties.has(prop.name)) {
+                    const sym = getMemberSymbol(baseNode.symbol, prop.name);
+                    if (sym) {
+                        addCompletion(prop.name, sym);
+                    }
+                }
+            }
+        }
+        else if (kind === IdentifierKind.ModelExpressionProperty ||
+            kind === IdentifierKind.ObjectLiteralProperty) {
+            const model = getReferencedModel(ancestor);
+            if (!model) {
+                return completions;
+            }
+            const curModelNode = ancestor.parent;
+            for (const prop of walkPropertiesInherited(model)) {
+                if (identifier.sv === prop.name ||
+                    !curModelNode.properties.find((p) => (p.kind === SyntaxKind.ModelProperty ||
+                        p.kind === SyntaxKind.ObjectLiteralProperty) &&
+                        p.id.sv === prop.name)) {
+                    const sym = getMemberSymbol(model.node.symbol, prop.name);
+                    if (sym) {
+                        addCompletion(prop.name, sym);
+                    }
+                }
+            }
+        }
+        else if (identifier.parent && identifier.parent.kind === SyntaxKind.MemberExpression) {
             let base = resolveTypeReferenceSym(identifier.parent.base, undefined, false);
             if (base) {
                 if (base.flags & 2048 /* SymbolFlags.Alias */) {
@@ -2016,6 +2235,10 @@ export function createChecker(program) {
         }
         function shouldAddCompletion(sym) {
             switch (kind) {
+                case IdentifierKind.ModelExpressionProperty:
+                case IdentifierKind.ModelStatementProperty:
+                case IdentifierKind.ObjectLiteralProperty:
+                    return !!(sym.flags & 4 /* SymbolFlags.ModelProperty */);
                 case IdentifierKind.Decorator:
                     // Only return decorators and namespaces when completing decorator
                     return !!(sym.flags & (16384 /* SymbolFlags.Decorator */ | 4096 /* SymbolFlags.Namespace */));
@@ -2540,6 +2763,16 @@ export function createChecker(program) {
             derivedModels: [],
         });
         linkType(links, type, mapper);
+        if (node.symbol.members) {
+            const members = getOrCreateAugmentedSymbolTable(node.symbol.members);
+            const propDocs = extractPropDocs(node);
+            for (const [name, memberSym] of members) {
+                const doc = propDocs.get(name);
+                if (doc) {
+                    docFromCommentForSym.set(memberSym, doc);
+                }
+            }
+        }
         const isBase = checkModelIs(node, node.is, mapper);
         if (isBase) {
             type.sourceModel = isBase;
@@ -2553,7 +2786,8 @@ export function createChecker(program) {
         decorators.push(...checkDecorators(type, node, mapper));
         if (isBase) {
             for (const prop of isBase.properties.values()) {
-                const newProp = cloneType(prop, {
+                const memberSym = getMemberSymbol(node.symbol, prop.name);
+                const newProp = cloneTypeForSymbol(memberSym, prop, {
                     sourceProperty: prop,
                     model: type,
                 });
@@ -3559,7 +3793,8 @@ export function createChecker(program) {
         }
     }
     function checkModelProperty(prop, mapper) {
-        const symId = getSymbolId(getSymbolForMember(prop));
+        const sym = getSymbolForMember(prop);
+        const symId = getSymbolId(sym);
         const links = getSymbolLinksForMember(prop);
         if (links && links.declaredType && mapper === undefined) {
             return links.declaredType;
@@ -3600,12 +3835,9 @@ export function createChecker(program) {
         const parentTemplate = getParentTemplateNode(prop);
         linkMapper(type, mapper);
         if (!parentTemplate || shouldCreateTypeForTemplate(parentTemplate, mapper)) {
-            if (prop.parent?.parent?.kind === SyntaxKind.OperationSignatureDeclaration &&
-                prop.parent.parent.parent?.kind === SyntaxKind.OperationStatement) {
-                const doc = extractParamDoc(prop.parent.parent.parent, type.name);
-                if (doc) {
-                    type.decorators.unshift(createDocFromCommentDecorator("self", doc));
-                }
+            const docComment = docFromCommentForSym.get(sym);
+            if (docComment) {
+                type.decorators.unshift(createDocFromCommentDecorator("self", docComment));
             }
             finishType(type);
         }
@@ -3929,6 +4161,8 @@ export function createChecker(program) {
                 decorators.unshift(createDocFromCommentDecorator("errors", returnTypesDocs.errors));
             }
         }
+        else if (targetType.kind === "ModelProperty") {
+        }
         return decorators;
     }
     function checkScalar(node, mapper) {
@@ -3948,7 +4182,6 @@ export function createChecker(program) {
             decorators,
             derivedScalars: [],
         });
-        checkScalarConstructors(type, node, type.constructors, mapper);
         linkType(links, type, mapper);
         if (node.extends) {
             type.baseScalar = checkScalarExtends(node, node.extends, mapper);
@@ -3957,6 +4190,7 @@ export function createChecker(program) {
                 type.baseScalar.derivedScalars.push(type);
             }
         }
+        checkScalarConstructors(type, node, type.constructors, mapper);
         decorators.push(...checkDecorators(type, node, mapper));
         if (mapper === undefined) {
             type.namespace?.scalars.set(type.name, type);
@@ -4000,6 +4234,16 @@ export function createChecker(program) {
         return extendsType;
     }
     function checkScalarConstructors(parentScalar, node, constructors, mapper) {
+        if (parentScalar.baseScalar) {
+            for (const member of parentScalar.baseScalar.constructors.values()) {
+                const newConstructor = cloneTypeForSymbol(getMemberSymbol(node.symbol, member.name), {
+                    ...member,
+                    scalar: parentScalar,
+                });
+                linkIndirectMember(node, newConstructor, mapper);
+                constructors.set(member.name, newConstructor);
+            }
+        }
         for (const member of node.members) {
             const constructor = checkScalarConstructor(member, mapper, parentScalar);
             if (constructors.has(constructor.name)) {
@@ -4659,7 +4903,10 @@ export function createChecker(program) {
      * recursively by the caller.
      */
     function cloneType(type, additionalProps = {}) {
-        const clone = finishType(initializeClone(type, additionalProps));
+        let clone = initializeClone(type, additionalProps);
+        if (type.isFinished) {
+            clone = finishType(clone);
+        }
         const projection = projectionsByType.get(type);
         if (projection) {
             projectionsByType.set(clone, projection);
@@ -4677,6 +4924,10 @@ export function createChecker(program) {
     function cloneTypeForSymbol(sym, type, additionalProps = {}) {
         let clone = initializeClone(type, additionalProps);
         if ("decorators" in clone) {
+            const docComment = docFromCommentForSym.get(sym);
+            if (docComment) {
+                clone.decorators.push(createDocFromCommentDecorator("self", docComment));
+            }
             for (const dec of checkAugmentDecorators(sym, clone, undefined)) {
                 clone.decorators.push(dec);
             }
@@ -6138,18 +6389,33 @@ function extractReturnsDocs(type) {
     }
     return result;
 }
-function extractParamDoc(node, paramName) {
+function extractParamDocs(node) {
     if (node.docs === undefined) {
-        return undefined;
+        return new Map();
     }
+    const paramDocs = new Map();
     for (const doc of node.docs) {
         for (const tag of doc.tags) {
-            if (tag.kind === SyntaxKind.DocParamTag && tag.paramName.sv === paramName) {
-                return getDocContent(tag.content);
+            if (tag.kind === SyntaxKind.DocParamTag) {
+                paramDocs.set(tag.paramName.sv, getDocContent(tag.content));
             }
         }
     }
-    return undefined;
+    return paramDocs;
+}
+function extractPropDocs(node) {
+    if (node.docs === undefined) {
+        return new Map();
+    }
+    const propDocs = new Map();
+    for (const doc of node.docs) {
+        for (const tag of doc.tags) {
+            if (tag.kind === SyntaxKind.DocPropTag) {
+                propDocs.set(tag.propName.sv, getDocContent(tag.content));
+            }
+        }
+    }
+    return propDocs;
 }
 function getDocContent(content) {
     const docs = [];