diff --git a/packages/compiler/src/core/checker.ts b/packages/compiler/src/core/checker.ts index cd23221098d..d25eeec1fdc 100644 --- a/packages/compiler/src/core/checker.ts +++ b/packages/compiler/src/core/checker.ts @@ -39,6 +39,10 @@ import { } from "./parser.js"; import type { Program } from "./program.js"; import { createTypeRelationChecker } from "./type-relation-checker.js"; +import { + ResolutionKind as NewResolutionKind, + TypeResolver, +} from "./type-resolver.js"; import { getFullyQualifiedSymbolName, getParentTemplateNode, @@ -529,6 +533,7 @@ export function createChecker(program: Program, resolver: NameResolver): Checker * Key is the SymId of a node. It can be retrieved with getNodeSymId(node) */ const pendingResolutions = new PendingResolutions(); + const typeResolver = new TypeResolver(); const postCheckValidators: ValidatorFn[] = []; const typespecNamespaceBinding = resolver.symbols.global.exports!.get("TypeSpec"); @@ -1183,8 +1188,24 @@ export function createChecker(program: Program, resolver: NameResolver): Checker if (node.constraint) { pendingResolutions.start(getNodeSym(node), ResolutionKind.Constraint); + if (ctx.mapper === undefined) { + typeResolver.startResolution({ + kind: NewResolutionKind.Constraint, + sym: getNodeSym(node), + node: node, + description: `Constraint of '${node.id.sv}'`, + }); + } type.constraint = getParamConstraintEntityForNode(ctx, node.constraint); pendingResolutions.finish(getNodeSym(node), ResolutionKind.Constraint); + if (ctx.mapper === undefined) { + typeResolver.finishResolution({ + kind: NewResolutionKind.Constraint, + sym: getNodeSym(node), + node: node, + description: `Constraint of '${node.id.sv}'`, + }); + } } if (node.default) { // Set this to unknownType in case the default points back to the template itself causing failures @@ -2075,11 +2096,21 @@ export function createChecker(program: Program, resolver: NameResolver): Checker } } + const description = `${awaitingType.kind}${ + "name" in awaitingType ? ` '${String(awaitingType.name)}'` : "" + }`; + function check() { if (waitingFor.size === 0) { + typeResolver.resolveDeferredCompletion(description); callback(); } } + + if (waitingFor.size > 0) { + typeResolver.trackDeferredCompletion(description, waitingFor.size); + } + for (const type of waitingFor) { waitingForResolution.set(type, [ ...(waitingForResolution.get(type) || []), @@ -2729,6 +2760,28 @@ export function createChecker(program: Program, resolver: NameResolver): Checker if (opSymId) { pendingResolutions.start(opSymId, ResolutionKind.BaseType); } + // In non-template contexts, also use the stack-based resolver for richer cycle diagnostics + if (opSymId && ctx.mapper === undefined) { + const resolution = typeResolver.startResolution({ + kind: NewResolutionKind.BaseType, + sym: opSymId, + node: opReference, + description: `Operation '${opSymId.name}' is`, + }); + if (resolution.status === "cycle") { + reportCheckerDiagnostic( + createDiagnostic({ + code: "circular-op-signature", + format: { typeName: opSymId.name }, + target: opReference, + }), + ); + if (opSymId) { + pendingResolutions.finish(opSymId, ResolutionKind.BaseType); + } + return undefined; + } + } const target = resolver.getNodeLinks(opReference).resolvedSymbol; @@ -2742,8 +2795,19 @@ export function createChecker(program: Program, resolver: NameResolver): Checker target: opReference, }), ); - } + if (opSymId) { + typeResolver.finishResolution({ + kind: NewResolutionKind.BaseType, + sym: opSymId, + node: opReference, + description: `Operation '${opSymId.name}' is`, + }); + } + } + if (opSymId) { + pendingResolutions.finish(opSymId, ResolutionKind.BaseType); + } return undefined; } @@ -2752,6 +2816,14 @@ export function createChecker(program: Program, resolver: NameResolver): Checker if (opSymId) { pendingResolutions.finish(opSymId, ResolutionKind.BaseType); } + if (opSymId && ctx.mapper === undefined) { + typeResolver.finishResolution({ + kind: NewResolutionKind.BaseType, + sym: opSymId, + node: opReference, + description: `Operation '${opSymId.name}' is`, + }); + } if (isErrorType(baseOperation)) { return undefined; @@ -4063,7 +4135,22 @@ export function createChecker(program: Program, resolver: NameResolver): Checker let memberSymbol = getMemberSymbol(containerSymbol, memberName); if (!memberSymbol?.type && containerSymbol.flags & SymbolFlags.LateBound) { + // Late-bind members on demand — track this in the resolver for visibility + const containerName = "name" in containerType ? containerType.name : containerSymbol.name; + const request = { + kind: NewResolutionKind.MemberType, + sym: containerSymbol, + node: containerType.node!, + description: `Member '${memberName}' of ${containerType.kind} '${containerName}'`, + }; + const result = typeResolver.startResolution(request); + if (result.status === "cycle") { + // Cycle in member resolution — return undefined to propagate the error + typeResolver.finishResolution(request); + return undefined; + } lateBindMembers(containerType); + typeResolver.finishResolution(request); memberSymbol = getMemberSymbol(containerSymbol, memberName); } @@ -4438,6 +4525,16 @@ export function createChecker(program: Program, resolver: NameResolver): Checker return undefined; } + // If the type is still being created (e.g., model A is Template<{t: B}> where B + // references A.t), check if we can find the member from its `is` base or spreads + // that are already resolved. + if (type.creating && type.kind === "Model") { + const memberFromCreating = tryResolveMemberFromCreatingModel(ctx, type, node.id.sv); + if (memberFromCreating) { + return memberFromCreating; + } + } + // Late-bind the container and its members. switch (type.kind) { case "Model": @@ -4455,6 +4552,178 @@ export function createChecker(program: Program, resolver: NameResolver): Checker return getCanonicalResolvedMemberSymbol(type, node.id.sv); } + /** + * Try to resolve a member from a model that is still being created. + * This handles the case where `model A is Template<{t: B}>` and B references `A.t`. + * The member 't' comes from the `is` base (the template instantiation) which may + * already have its properties resolved even though A hasn't copied them yet. + */ + function tryResolveMemberFromCreatingModel( + ctx: CheckContext, + model: Model, + memberName: string, + ): Sym | undefined { + // First check if the model already has the property (from its own declared properties) + const existingProp = model.properties.get(memberName); + if (existingProp) { + return getTypeSymbol(existingProp) ?? undefined; + } + + // Check the model's AST node for `is` base and spreads + const modelNode = model.node; + if (!modelNode || modelNode.kind !== SyntaxKind.ModelStatement) { + return undefined; + } + + // If there's an `is` clause, resolve the `is` expression type. + // getTypeForNode will return a cached type if the `is` target was already checked. + if (modelNode.is) { + const isBaseType = getTypeForNode(modelNode.is, ctx); + if (isBaseType && isBaseType.kind === "Model") { + // First check if the is-base already has the member (even if creating) + const prop = isBaseType.properties.get(memberName); + if (prop) { + return createLateBoundMemberSym(model, prop, memberName, modelNode); + } + // If the is-base is still creating, look at ITS spread sources recursively + if (isBaseType.creating) { + const found = findMemberInCreatingModelSources(ctx, isBaseType, memberName); + if (found) { + return createLateBoundMemberSym(model, found, memberName, modelNode); + } + } + } + } + + // Check spread targets + for (const propNode of modelNode.properties) { + if (propNode.kind === SyntaxKind.ModelSpreadProperty) { + const spreadType = getTypeForNode(propNode.target, ctx); + if (spreadType && spreadType.kind === "Model") { + const prop = spreadType.properties.get(memberName); + if (prop) { + return createLateBoundMemberSym(model, prop, memberName, modelNode); + } + if (spreadType.creating) { + const found = findMemberInCreatingModelSources(ctx, spreadType, memberName); + if (found) { + return createLateBoundMemberSym(model, found, memberName, modelNode); + } + } + } + } + } + + return undefined; + } + + function createLateBoundMemberSym( + model: Model, + prop: ModelProperty, + memberName: string, + containerNode: Node, + ): Sym | undefined { + const sym = createSymbol( + prop.node ?? containerNode, + memberName, + SymbolFlags.Member | SymbolFlags.Declaration | SymbolFlags.LateBound, + model.symbol, + ); + mutate(sym).type = prop; + if (model.symbol?.members) { + const containerMembers: Mutable = resolver.getAugmentedSymbolTable( + model.symbol.members, + ); + containerMembers.set(memberName, sym); + } + return sym; + } + + /** + * Search for a member in a model that's still being created by looking at its + * source models (spreads and `is` targets). This handles the case where: + * model Template {...T} + * model A is Template<{t: B}> + * When A is creating and its properties haven't been copied yet, we can look + * at Template<{t:B}>'s spread sources to find property `t`. + */ + function findMemberInCreatingModelSources( + ctx: CheckContext, + model: Model, + memberName: string, + visited: Set = new Set(), + ): ModelProperty | undefined { + if (visited.has(model)) return undefined; + visited.add(model); + + // Check own properties first (already resolved) + const ownProp = model.properties.get(memberName); + if (ownProp) return ownProp; + + // Look at the model's AST node for spread sources. + // Use the model's templateMapper when resolving references in its body, + // since template instances share the same AST node as the template declaration. + const modelNode = model.node; + if (!modelNode) return undefined; + + const resolveCtx = model.templateMapper ? ctx.withMapper(model.templateMapper) : ctx; + + if ( + modelNode.kind === SyntaxKind.ModelStatement || + modelNode.kind === SyntaxKind.ModelExpression + ) { + // Check direct property declarations that might not be resolved yet. + // If the model expression has `t: B` as a declared property but hasn't + // been fully checked, we can still resolve the property from its member symbol. + // Due to early linkType on properties, the symbol may already have a type. + if (model.creating) { + const memberSym = model.node?.symbol?.members + ? getMemberSymbol(model.node.symbol, memberName) + : undefined; + if (memberSym) { + const memberLinks = resolver.getSymbolLinks(memberSym); + if (memberLinks.declaredType && memberLinks.declaredType.kind === "ModelProperty") { + return memberLinks.declaredType as ModelProperty; + } + } + } + + for (const propNode of modelNode.properties) { + if (propNode.kind === SyntaxKind.ModelSpreadProperty) { + const spreadType = getTypeForNode(propNode.target, resolveCtx); + if (spreadType && spreadType.kind === "Model") { + const prop = spreadType.properties.get(memberName); + if (prop) return prop; + if (spreadType.creating) { + const found = findMemberInCreatingModelSources(ctx, spreadType, memberName, visited); + if (found) return found; + } + } + } + } + + // For model statements, also check the `is` base + if (modelNode.kind === SyntaxKind.ModelStatement && modelNode.is) { + const isBaseType = getTypeForNode(modelNode.is, resolveCtx); + if (isBaseType && isBaseType.kind === "Model") { + const prop = isBaseType.properties.get(memberName); + if (prop) return prop; + if (isBaseType.creating) { + const found = findMemberInCreatingModelSources( + ctx, + isBaseType, + memberName, + visited, + ); + if (found) return found; + } + } + } + } + + return undefined; + } + function getMemberKindName(node: Node) { switch (node.kind) { case SyntaxKind.ModelStatement: @@ -4639,8 +4908,24 @@ export function createChecker(program: Program, resolver: NameResolver): Checker } pendingResolutions.start(sym, ResolutionKind.Type); + if (ctx.mapper === undefined) { + typeResolver.startResolution({ + kind: NewResolutionKind.AliasTarget, + sym: sym, + node: node, + description: `Template container '${sym.name}'`, + }); + } const type = checkTypeReferenceSymbol(ctx, sym, node); pendingResolutions.finish(sym, ResolutionKind.Type); + if (ctx.mapper === undefined) { + typeResolver.finishResolution({ + kind: NewResolutionKind.AliasTarget, + sym: sym, + node: node, + description: `Template container '${sym.name}'`, + }); + } return lateBindContainer(type, sym); } @@ -4858,6 +5143,7 @@ export function createChecker(program: Program, resolver: NameResolver): Checker return; } + const unresolvedDeferred = typeResolver.unresolvedDeferredCompletions; const message = [ "Unexpected pending resolutions found", ...[...waitingForResolution.entries()].flatMap(([type, items]) => { @@ -4866,6 +5152,14 @@ export function createChecker(program: Program, resolver: NameResolver): Checker ([item], index) => `${index === 0 ? base : " ".repeat(base.length)}${getTypeName(item)}`, ); }), + ...(unresolvedDeferred.length > 0 + ? [ + " Deferred completions still pending:", + ...unresolvedDeferred.map( + (d) => ` ${d.description} (waiting for ${d.dependencyCount} dependencies)`, + ), + ] + : []), ].join("\n"); compilerAssert(false, message); } @@ -4980,6 +5274,9 @@ export function createChecker(program: Program, resolver: NameResolver): Checker derivedModels: [], }); linkType(ctx, links, type); + // Set templateMapper early so that member lookups on this creating model + // can resolve spread targets through the correct mapper context. + linkMapper(type, ctx.mapper); if (node.symbol.members) { const members = resolver.getAugmentedSymbolTable(node.symbol.members); @@ -5045,7 +5342,6 @@ export function createChecker(program: Program, resolver: NameResolver): Checker decorators.push(...checkDecorators(ctx, type, node)); - linkMapper(type, ctx.mapper); finishType(type, { skipDecorators: ctx.hasFlags(CheckFlags.InTemplateDeclaration) }); lateBindMemberContainer(type); @@ -6411,6 +6707,26 @@ export function createChecker(program: Program, resolver: NameResolver): Checker } const modelSymId = getNodeSym(model); pendingResolutions.start(modelSymId, ResolutionKind.BaseType); + // In non-template contexts, also use the stack-based resolver for richer cycle diagnostics + if (ctx.mapper === undefined) { + const resolution = typeResolver.startResolution({ + kind: NewResolutionKind.BaseType, + sym: modelSymId, + node: heritageRef, + description: `Model '${modelSymId.name}' extends`, + }); + if (resolution.status === "cycle") { + reportCheckerDiagnostic( + createDiagnostic({ + code: "circular-base-type", + format: { typeName: modelSymId.name }, + target: heritageRef, + }), + ); + pendingResolutions.finish(modelSymId, ResolutionKind.BaseType); + return undefined; + } + } const target = resolver.getNodeLinks(heritageRef).resolvedSymbol; if (target && pendingResolutions.has(target, ResolutionKind.BaseType)) { @@ -6422,11 +6738,26 @@ export function createChecker(program: Program, resolver: NameResolver): Checker target: target, }), ); + typeResolver.finishResolution({ + kind: NewResolutionKind.BaseType, + sym: modelSymId, + node: heritageRef, + description: `Model '${modelSymId.name}' extends`, + }); } + pendingResolutions.finish(modelSymId, ResolutionKind.BaseType); return undefined; } const heritageType = getTypeForNode(heritageRef, ctx); pendingResolutions.finish(modelSymId, ResolutionKind.BaseType); + if (ctx.mapper === undefined) { + typeResolver.finishResolution({ + kind: NewResolutionKind.BaseType, + sym: modelSymId, + node: heritageRef, + description: `Model '${modelSymId.name}' extends`, + }); + } if (isErrorType(heritageType)) { compilerAssert(program.hasError(), "Should already have reported an error.", heritageRef); return undefined; @@ -6459,6 +6790,26 @@ export function createChecker(program: Program, resolver: NameResolver): Checker const modelSymId = getNodeSym(model); pendingResolutions.start(modelSymId, ResolutionKind.BaseType); + // In non-template contexts, also use the stack-based resolver for richer cycle diagnostics + if (ctx.mapper === undefined) { + const resolution = typeResolver.startResolution({ + kind: NewResolutionKind.BaseType, + sym: modelSymId, + node: isExpr, + description: `Model '${modelSymId.name}' is`, + }); + if (resolution.status === "cycle") { + reportCheckerDiagnostic( + createDiagnostic({ + code: "circular-base-type", + format: { typeName: modelSymId.name }, + target: isExpr, + }), + ); + pendingResolutions.finish(modelSymId, ResolutionKind.BaseType); + return undefined; + } + } let isType; if (isExpr.kind === SyntaxKind.ModelExpression) { reportCheckerDiagnostic( @@ -6468,6 +6819,14 @@ export function createChecker(program: Program, resolver: NameResolver): Checker target: isExpr, }), ); + if (ctx.mapper === undefined) { + typeResolver.finishResolution({ + kind: NewResolutionKind.BaseType, + sym: modelSymId, + node: isExpr, + description: `Model '${modelSymId.name}' is`, + }); + } pendingResolutions.finish(modelSymId, ResolutionKind.BaseType); return undefined; } else if (isExpr.kind === SyntaxKind.ArrayExpression) { @@ -6483,6 +6842,12 @@ export function createChecker(program: Program, resolver: NameResolver): Checker target: target, }), ); + typeResolver.finishResolution({ + kind: NewResolutionKind.BaseType, + sym: modelSymId, + node: isExpr, + description: `Model '${modelSymId.name}' is`, + }); } pendingResolutions.finish(modelSymId, ResolutionKind.BaseType); return undefined; @@ -6490,11 +6855,27 @@ export function createChecker(program: Program, resolver: NameResolver): Checker isType = getTypeForNode(isExpr, ctx); } else { reportCheckerDiagnostic(createDiagnostic({ code: "is-model", target: isExpr })); + if (ctx.mapper === undefined) { + typeResolver.finishResolution({ + kind: NewResolutionKind.BaseType, + sym: modelSymId, + node: isExpr, + description: `Model '${modelSymId.name}' is`, + }); + } pendingResolutions.finish(modelSymId, ResolutionKind.BaseType); return undefined; } pendingResolutions.finish(modelSymId, ResolutionKind.BaseType); + if (ctx.mapper === undefined) { + typeResolver.finishResolution({ + kind: NewResolutionKind.BaseType, + sym: modelSymId, + node: isExpr, + description: `Model '${modelSymId.name}' is`, + }); + } if (isType.kind !== "Model") { reportCheckerDiagnostic(createDiagnostic({ code: "is-model", target: isExpr })); @@ -6633,6 +7014,14 @@ export function createChecker(program: Program, resolver: NameResolver): Checker linkType(ctx, links, type); } + if (ctx.mapper === undefined) { + typeResolver.startResolution({ + kind: NewResolutionKind.PropertyType, + sym: sym, + node: prop, + description: `Property '${name}'`, + }); + } type.type = getTypeForNode(prop.value, ctx); // Detect property-to-property cycles (e.g., A.a -> B.a -> A.a) @@ -6668,6 +7057,14 @@ export function createChecker(program: Program, resolver: NameResolver): Checker } } + if (ctx.mapper === undefined) { + typeResolver.finishResolution({ + kind: NewResolutionKind.PropertyType, + sym: sym, + node: prop, + description: `Property '${name}'`, + }); + } return finishType(type, { skipDecorators: !shouldRunDecorators }); } @@ -7233,6 +7630,26 @@ export function createChecker(program: Program, resolver: NameResolver): Checker ): Scalar | undefined { const symId = getNodeSym(scalar); pendingResolutions.start(symId, ResolutionKind.BaseType); + // In non-template contexts, also use the stack-based resolver for richer cycle diagnostics + if (ctx.mapper === undefined) { + const resolution = typeResolver.startResolution({ + kind: NewResolutionKind.BaseType, + sym: symId, + node: extendsRef, + description: `Scalar '${symId.name}' extends`, + }); + if (resolution.status === "cycle") { + reportCheckerDiagnostic( + createDiagnostic({ + code: "circular-base-type", + format: { typeName: symId.name }, + target: extendsRef, + }), + ); + pendingResolutions.finish(symId, ResolutionKind.BaseType); + return undefined; + } + } const target = resolver.getNodeLinks(extendsRef).resolvedSymbol; @@ -7245,11 +7662,26 @@ export function createChecker(program: Program, resolver: NameResolver): Checker target: target, }), ); + typeResolver.finishResolution({ + kind: NewResolutionKind.BaseType, + sym: symId, + node: extendsRef, + description: `Scalar '${symId.name}' extends`, + }); } + pendingResolutions.finish(symId, ResolutionKind.BaseType); return undefined; } const extendsType = getTypeForNode(extendsRef, ctx); pendingResolutions.finish(symId, ResolutionKind.BaseType); + if (ctx.mapper === undefined) { + typeResolver.finishResolution({ + kind: NewResolutionKind.BaseType, + sym: symId, + node: extendsRef, + description: `Scalar '${symId.name}' extends`, + }); + } if (isErrorType(extendsType)) { compilerAssert(program.hasError(), "Should already have reported an error.", extendsRef); return undefined; @@ -7375,18 +7807,53 @@ export function createChecker(program: Program, resolver: NameResolver): Checker } pendingResolutions.start(aliasSymId, ResolutionKind.Type); + // In non-template contexts, also use the stack-based resolver for richer cycle diagnostics + if (ctx.mapper === undefined) { + typeResolver.startResolution({ + kind: NewResolutionKind.AliasTarget, + sym: aliasSymId, + node: node, + description: `Alias '${node.id.sv}'`, + }); + } const type = checkNode(ctx, node.value); if (type === null) { links.declaredType = errorType; + pendingResolutions.finish(aliasSymId, ResolutionKind.Type); + if (ctx.mapper === undefined) { + typeResolver.finishResolution({ + kind: NewResolutionKind.AliasTarget, + sym: aliasSymId, + node: node, + description: `Alias '${node.id.sv}'`, + }); + } return errorType; } if (isValue(type)) { reportCheckerDiagnostic(createDiagnostic({ code: "value-in-type", target: node.value })); links.declaredType = errorType; + pendingResolutions.finish(aliasSymId, ResolutionKind.Type); + if (ctx.mapper === undefined) { + typeResolver.finishResolution({ + kind: NewResolutionKind.AliasTarget, + sym: aliasSymId, + node: node, + description: `Alias '${node.id.sv}'`, + }); + } return errorType; } linkType(ctx, links, type as any); pendingResolutions.finish(aliasSymId, ResolutionKind.Type); + if (ctx.mapper === undefined) { + typeResolver.finishResolution({ + kind: NewResolutionKind.AliasTarget, + sym: aliasSymId, + node: node, + description: `Alias '${node.id.sv}'`, + }); + } return type; } @@ -7412,8 +7879,21 @@ export function createChecker(program: Program, resolver: NameResolver): Checker } pendingResolutions.start(node.symbol, ResolutionKind.Value); + // Also track on the stack-based resolver for richer diagnostics + typeResolver.startResolution({ + kind: NewResolutionKind.ConstValue, + sym: node.symbol, + node: node, + description: `Const '${node.id.sv}'`, + }); const value = getValueForNode(node.value, undefined, type && { kind: "assignment", type }); pendingResolutions.finish(node.symbol, ResolutionKind.Value); + typeResolver.finishResolution({ + kind: NewResolutionKind.ConstValue, + sym: node.symbol, + node: node, + description: `Const '${node.id.sv}'`, + }); if (value === null || (type && !checkValueOfType(value, type, node.id))) { links.value = null; return links.value; diff --git a/packages/compiler/src/core/type-resolver.ts b/packages/compiler/src/core/type-resolver.ts new file mode 100644 index 00000000000..653b1faf274 --- /dev/null +++ b/packages/compiler/src/core/type-resolver.ts @@ -0,0 +1,290 @@ +import type { Diagnostic, DiagnosticTarget, Node, Sym } from "./types.js"; + +/** + * Identifies the kind of resolution being performed. + * Each kind represents a distinct "question" that can be asked about a symbol. + */ +export enum ResolutionKind { + /** Resolving the type of an alias */ + AliasTarget = "AliasTarget", + /** Resolving the base type (extends/is) of a model or scalar */ + BaseType = "BaseType", + /** Resolving a template constraint */ + Constraint = "Constraint", + /** Resolving the value of a const statement */ + ConstValue = "ConstValue", + /** Resolving an operation signature (op is) */ + OperationSignature = "OperationSignature", + /** Resolving the type of a model property */ + PropertyType = "PropertyType", + /** Resolving the type of a member accessed off a template parameter */ + MemberType = "MemberType", +} + +/** + * A resolution request represents a single unit of work the resolver is asked to compute. + * The combination of (sym, kind) uniquely identifies a request. + */ +export interface ResolutionRequest { + /** The kind of resolution being performed */ + readonly kind: ResolutionKind; + /** The symbol whose resolution is requested */ + readonly sym: Sym; + /** The AST node that triggered this resolution (used for diagnostics) */ + readonly node: Node; + /** Human-readable description for cycle diagnostics (e.g., "Model 'Foo'") */ + readonly description: string; +} + +/** + * A step in a cycle chain, used for rich cycle diagnostics. + */ +export interface CycleStep { + /** The request that formed this step */ + readonly request: ResolutionRequest; + /** The node where this step originates (for source location) */ + readonly target: DiagnosticTarget; +} + +/** + * Result of attempting to start a resolution. + * If a cycle is detected, `cycle` contains the full chain. + */ +export type ResolutionResult = + | { readonly status: "ok" } + | { readonly status: "cycle"; readonly steps: readonly CycleStep[] }; + +/** + * A centralized type resolver that provides: + * - Stack-based cycle detection with full cycle chain visibility + * - Result caching per (sym, kind) pair + * - Rich cycle diagnostics showing the complete dependency chain + * + * Inspired by Swift's request-based Evaluator architecture. + * + * Usage pattern: + * ``` + * const result = resolver.startResolution(request); + * if (result.status === "cycle") { + * // report cycle diagnostic using result.steps + * return errorType; + * } + * try { + * // ... perform the actual resolution work ... + * } finally { + * resolver.finishResolution(request); + * } + * ``` + */ +export class TypeResolver { + /** + * The active request stack. Uses an array for ordering (cycle chain extraction) + * and a Set for O(1) membership testing. + */ + readonly #stack: ResolutionRequest[] = []; + readonly #stackKeys = new Set(); + + /** + * Cache of completed resolutions. + * Key: `${sym.id}:${kind}` + */ + readonly #cache = new Map(); + + /** + * Generate a unique key for a (sym, kind) pair. + */ + #key(sym: Sym, kind: ResolutionKind): string { + return `${sym.id}:${kind}`; + } + + /** + * Attempt to begin resolving a request. + * + * If the same (sym, kind) is already on the active stack, returns a cycle result + * containing the full chain of requests that form the cycle. + * + * Otherwise, pushes the request onto the stack and returns "ok". + */ + startResolution(request: ResolutionRequest): ResolutionResult { + const key = this.#key(request.sym, request.kind); + + // Check if this request is already in progress → cycle + if (this.#stackKeys.has(key)) { + return { status: "cycle", steps: this.#extractCycleChain(key, request) }; + } + + // Push onto the stack + this.#stack.push(request); + this.#stackKeys.add(key); + return { status: "ok" }; + } + + /** + * Mark a resolution as complete. Must be called after startResolution returned "ok". + */ + finishResolution(request: ResolutionRequest): void { + const key = this.#key(request.sym, request.kind); + const top = this.#stack[this.#stack.length - 1]; + + // The resolution being finished should be on top of the stack. + // If not, it means resolutions are not properly nested. + if (top && this.#key(top.sym, top.kind) === key) { + this.#stack.pop(); + } else { + // Non-top finish: find and remove from stack (shouldn't normally happen) + const idx = this.#stack.findIndex( + (r) => this.#key(r.sym, r.kind) === key, + ); + if (idx >= 0) { + this.#stack.splice(idx, 1); + } + } + this.#stackKeys.delete(key); + } + + /** + * Check if a particular (sym, kind) is currently being resolved. + * Useful for checking dependencies without starting a full resolution. + */ + isResolving(sym: Sym, kind: ResolutionKind): boolean { + return this.#stackKeys.has(this.#key(sym, kind)); + } + + /** + * Get a cached resolution result, if available. + */ + getCached(sym: Sym, kind: ResolutionKind): T | undefined { + return this.#cache.get(this.#key(sym, kind)) as T | undefined; + } + + /** + * Store a resolution result in the cache. + */ + setCached(sym: Sym, kind: ResolutionKind, value: T): void { + this.#cache.set(this.#key(sym, kind), value); + } + + /** + * Get the current depth of the resolution stack. + * Useful for debugging and assertions. + */ + get depth(): number { + return this.#stack.length; + } + + /** + * Check whether any resolutions are still in progress. + * Should be empty at end of type checking. + */ + get hasPendingResolutions(): boolean { + return this.#stack.length > 0; + } + + /** + * Get all pending resolution requests (for debugging/assertions). + */ + get pendingRequests(): readonly ResolutionRequest[] { + return this.#stack; + } + + /** + * Extract the cycle chain from the stack. + * Returns the sub-stack from the first occurrence of the cycling key + * to the current request (inclusive), forming a complete cycle. + */ + #extractCycleChain(key: string, closingRequest: ResolutionRequest): CycleStep[] { + const steps: CycleStep[] = []; + + // Find where the cycle starts in the stack + let cycleStart = -1; + for (let i = 0; i < this.#stack.length; i++) { + const req = this.#stack[i]; + if (this.#key(req.sym, req.kind) === key) { + cycleStart = i; + break; + } + } + + if (cycleStart === -1) { + // Shouldn't happen since we checked #stackKeys, but be defensive + return [{ request: closingRequest, target: closingRequest.node }]; + } + + // Collect all steps from the cycle start to end of stack + for (let i = cycleStart; i < this.#stack.length; i++) { + steps.push({ + request: this.#stack[i], + target: this.#stack[i].node, + }); + } + + // Add the closing request that completes the cycle + steps.push({ + request: closingRequest, + target: closingRequest.node, + }); + + return steps; + } + + /** + * Format cycle steps into diagnostic notes for rich error reporting. + * Returns an array of related diagnostic information showing the full cycle chain. + * + * Example output when formatted: + * note: 'A' extends 'B' here + * note: 'B' extends 'C' here + * note: 'C' extends 'A' here (cycle closes) + */ + static formatCycleDiagnostics(steps: readonly CycleStep[]): string[] { + return steps.map((step, i) => { + const isLast = i === steps.length - 1; + const suffix = isLast ? " (cycle closes)" : ""; + return `${step.request.description}${suffix}`; + }); + } + + /** + * Track a deferred completion. This records that a type's finalization + * is waiting for one or more dependencies to finish being created. + * Used for integration with the ensureResolved/waitingForResolution system. + */ + trackDeferredCompletion(description: string, dependencyCount: number): void { + this.#deferredCompletions.push({ description, dependencyCount, resolved: false }); + } + + /** + * Mark a deferred completion as resolved. + */ + resolveDeferredCompletion(description: string): void { + const entry = this.#deferredCompletions.find( + (d) => d.description === description && !d.resolved, + ); + if (entry) { + entry.resolved = true; + } + } + + /** + * Get all unresolved deferred completions (for debugging/assertions). + */ + get unresolvedDeferredCompletions(): readonly { description: string; dependencyCount: number }[] { + return this.#deferredCompletions.filter((d) => !d.resolved); + } + + readonly #deferredCompletions: { + description: string; + dependencyCount: number; + resolved: boolean; + }[] = []; + + /** + * Reset the resolver state. Used between compilations or for testing. + */ + reset(): void { + this.#stack.length = 0; + this.#stackKeys.clear(); + this.#cache.clear(); + this.#deferredCompletions.length = 0; + } +} diff --git a/packages/compiler/test/checker/circular-spread-access.test.ts b/packages/compiler/test/checker/circular-spread-access.test.ts new file mode 100644 index 00000000000..74ad1805d5f --- /dev/null +++ b/packages/compiler/test/checker/circular-spread-access.test.ts @@ -0,0 +1,19 @@ +import { describe, it, expect } from "vitest"; +import { Model } from "../../src/core/types.js"; +import { Tester } from "../tester.js"; + +describe("circular reference with template spread and member access", () => { + it("model A is Template<{t: B}> with B accessing A.t", async () => { + const diagnostics = await Tester.diagnose(` + model Template {...T} + + model A is Template<{t: B}>; + + model B { + a: A.t; + } + `); + // Should have no errors — A.t should resolve to the 't' property + expect(diagnostics.map(d => `${d.code}: ${d.message}`)).toEqual([]); + }); +}); diff --git a/packages/compiler/test/core/type-resolver.test.ts b/packages/compiler/test/core/type-resolver.test.ts new file mode 100644 index 00000000000..91ba0af5515 --- /dev/null +++ b/packages/compiler/test/core/type-resolver.test.ts @@ -0,0 +1,386 @@ +import { describe, expect, it } from "vitest"; +import { + CycleStep, + ResolutionKind, + ResolutionRequest, + TypeResolver, +} from "../../src/core/type-resolver.js"; +import type { Sym } from "../../src/core/types.js"; + +/** Create a minimal mock Sym for testing */ +function createMockSym(id: number, name: string = `sym${id}`): Sym { + return { + flags: 0, + declarations: [], + node: {} as any, + name, + id, + } as unknown as Sym; +} + +/** Create a resolution request for testing */ +function createRequest( + sym: Sym, + kind: ResolutionKind, + description?: string, +): ResolutionRequest { + return { + kind, + sym, + node: sym.node ?? ({} as any), + description: description ?? `${kind} of '${sym.name}'`, + }; +} + +describe("TypeResolver", () => { + describe("startResolution / finishResolution", () => { + it("returns ok for a new resolution", () => { + const resolver = new TypeResolver(); + const sym = createMockSym(1); + const req = createRequest(sym, ResolutionKind.BaseType); + + const result = resolver.startResolution(req); + expect(result.status).toBe("ok"); + + resolver.finishResolution(req); + }); + + it("returns ok for different kinds on the same symbol", () => { + const resolver = new TypeResolver(); + const sym = createMockSym(1); + const req1 = createRequest(sym, ResolutionKind.BaseType); + const req2 = createRequest(sym, ResolutionKind.Constraint); + + const result1 = resolver.startResolution(req1); + expect(result1.status).toBe("ok"); + + const result2 = resolver.startResolution(req2); + expect(result2.status).toBe("ok"); + + resolver.finishResolution(req2); + resolver.finishResolution(req1); + }); + + it("returns ok for the same kind on different symbols", () => { + const resolver = new TypeResolver(); + const sym1 = createMockSym(1); + const sym2 = createMockSym(2); + const req1 = createRequest(sym1, ResolutionKind.BaseType); + const req2 = createRequest(sym2, ResolutionKind.BaseType); + + const result1 = resolver.startResolution(req1); + expect(result1.status).toBe("ok"); + + const result2 = resolver.startResolution(req2); + expect(result2.status).toBe("ok"); + + resolver.finishResolution(req2); + resolver.finishResolution(req1); + }); + + it("finishResolution removes from stack", () => { + const resolver = new TypeResolver(); + const sym = createMockSym(1); + const req = createRequest(sym, ResolutionKind.BaseType); + + resolver.startResolution(req); + expect(resolver.depth).toBe(1); + + resolver.finishResolution(req); + expect(resolver.depth).toBe(0); + + // Can start the same resolution again after finishing + const result = resolver.startResolution(req); + expect(result.status).toBe("ok"); + resolver.finishResolution(req); + }); + }); + + describe("cycle detection", () => { + it("detects direct self-cycle", () => { + const resolver = new TypeResolver(); + const sym = createMockSym(1, "A"); + const req = createRequest(sym, ResolutionKind.BaseType); + + const result1 = resolver.startResolution(req); + expect(result1.status).toBe("ok"); + + // Attempting to resolve the same (sym, kind) again → cycle + const result2 = resolver.startResolution(req); + expect(result2.status).toBe("cycle"); + + resolver.finishResolution(req); + }); + + it("detects indirect cycle (A → B → A)", () => { + const resolver = new TypeResolver(); + const symA = createMockSym(1, "A"); + const symB = createMockSym(2, "B"); + const reqA = createRequest(symA, ResolutionKind.BaseType, "Model 'A'"); + const reqB = createRequest(symB, ResolutionKind.BaseType, "Model 'B'"); + + resolver.startResolution(reqA); + resolver.startResolution(reqB); + + // B tries to resolve A's base type → cycle + const result = resolver.startResolution(reqA); + expect(result.status).toBe("cycle"); + + resolver.finishResolution(reqB); + resolver.finishResolution(reqA); + }); + + it("detects longer cycle chains (A → B → C → A)", () => { + const resolver = new TypeResolver(); + const symA = createMockSym(1, "A"); + const symB = createMockSym(2, "B"); + const symC = createMockSym(3, "C"); + const reqA = createRequest(symA, ResolutionKind.BaseType, "Model 'A'"); + const reqB = createRequest(symB, ResolutionKind.BaseType, "Model 'B'"); + const reqC = createRequest(symC, ResolutionKind.BaseType, "Model 'C'"); + + resolver.startResolution(reqA); + resolver.startResolution(reqB); + resolver.startResolution(reqC); + + // C tries to resolve A's base type → cycle + const result = resolver.startResolution(reqA); + expect(result.status).toBe("cycle"); + if (result.status === "cycle") { + // Chain should be: A, B, C, A (closing) + expect(result.steps).toHaveLength(4); + expect(result.steps[0].request.description).toBe("Model 'A'"); + expect(result.steps[1].request.description).toBe("Model 'B'"); + expect(result.steps[2].request.description).toBe("Model 'C'"); + expect(result.steps[3].request.description).toBe("Model 'A'"); + } + + resolver.finishResolution(reqC); + resolver.finishResolution(reqB); + resolver.finishResolution(reqA); + }); + + it("does not detect cycle across different resolution kinds", () => { + const resolver = new TypeResolver(); + const sym = createMockSym(1, "A"); + const reqBase = createRequest(sym, ResolutionKind.BaseType); + const reqConstraint = createRequest(sym, ResolutionKind.Constraint); + + resolver.startResolution(reqBase); + + // Same symbol, different kind → not a cycle + const result = resolver.startResolution(reqConstraint); + expect(result.status).toBe("ok"); + + resolver.finishResolution(reqConstraint); + resolver.finishResolution(reqBase); + }); + + it("cycle detection works after a previous resolution completed", () => { + const resolver = new TypeResolver(); + const symA = createMockSym(1, "A"); + const symB = createMockSym(2, "B"); + const reqA = createRequest(symA, ResolutionKind.BaseType); + const reqB = createRequest(symB, ResolutionKind.BaseType); + + // Complete A's resolution normally + resolver.startResolution(reqA); + resolver.finishResolution(reqA); + + // Now start B, which tries A again — should NOT be a cycle since A is finished + resolver.startResolution(reqB); + const result = resolver.startResolution(reqA); + expect(result.status).toBe("ok"); + + resolver.finishResolution(reqA); + resolver.finishResolution(reqB); + }); + }); + + describe("isResolving", () => { + it("returns false when nothing is being resolved", () => { + const resolver = new TypeResolver(); + const sym = createMockSym(1); + expect(resolver.isResolving(sym, ResolutionKind.BaseType)).toBe(false); + }); + + it("returns true when a resolution is in progress", () => { + const resolver = new TypeResolver(); + const sym = createMockSym(1); + const req = createRequest(sym, ResolutionKind.BaseType); + + resolver.startResolution(req); + expect(resolver.isResolving(sym, ResolutionKind.BaseType)).toBe(true); + + resolver.finishResolution(req); + expect(resolver.isResolving(sym, ResolutionKind.BaseType)).toBe(false); + }); + + it("returns false for different kind", () => { + const resolver = new TypeResolver(); + const sym = createMockSym(1); + const req = createRequest(sym, ResolutionKind.BaseType); + + resolver.startResolution(req); + expect(resolver.isResolving(sym, ResolutionKind.Constraint)).toBe(false); + + resolver.finishResolution(req); + }); + }); + + describe("caching", () => { + it("getCached returns undefined when no cache exists", () => { + const resolver = new TypeResolver(); + const sym = createMockSym(1); + expect(resolver.getCached(sym, ResolutionKind.BaseType)).toBeUndefined(); + }); + + it("getCached returns cached value after setCached", () => { + const resolver = new TypeResolver(); + const sym = createMockSym(1); + const value = { kind: "Model", name: "Foo" }; + + resolver.setCached(sym, ResolutionKind.BaseType, value); + expect(resolver.getCached(sym, ResolutionKind.BaseType)).toBe(value); + }); + + it("different kinds have independent caches", () => { + const resolver = new TypeResolver(); + const sym = createMockSym(1); + const value1 = { kind: "base" }; + const value2 = { kind: "constraint" }; + + resolver.setCached(sym, ResolutionKind.BaseType, value1); + resolver.setCached(sym, ResolutionKind.Constraint, value2); + + expect(resolver.getCached(sym, ResolutionKind.BaseType)).toBe(value1); + expect(resolver.getCached(sym, ResolutionKind.Constraint)).toBe(value2); + }); + }); + + describe("depth and hasPendingResolutions", () => { + it("starts at depth 0 with no pending", () => { + const resolver = new TypeResolver(); + expect(resolver.depth).toBe(0); + expect(resolver.hasPendingResolutions).toBe(false); + }); + + it("tracks depth correctly through nested resolutions", () => { + const resolver = new TypeResolver(); + const sym1 = createMockSym(1); + const sym2 = createMockSym(2); + const req1 = createRequest(sym1, ResolutionKind.BaseType); + const req2 = createRequest(sym2, ResolutionKind.BaseType); + + resolver.startResolution(req1); + expect(resolver.depth).toBe(1); + expect(resolver.hasPendingResolutions).toBe(true); + + resolver.startResolution(req2); + expect(resolver.depth).toBe(2); + + resolver.finishResolution(req2); + expect(resolver.depth).toBe(1); + + resolver.finishResolution(req1); + expect(resolver.depth).toBe(0); + expect(resolver.hasPendingResolutions).toBe(false); + }); + }); + + describe("pendingRequests", () => { + it("returns current stack contents", () => { + const resolver = new TypeResolver(); + const sym1 = createMockSym(1, "A"); + const sym2 = createMockSym(2, "B"); + const req1 = createRequest(sym1, ResolutionKind.BaseType, "Model 'A'"); + const req2 = createRequest(sym2, ResolutionKind.AliasTarget, "Alias 'B'"); + + resolver.startResolution(req1); + resolver.startResolution(req2); + + const pending = resolver.pendingRequests; + expect(pending).toHaveLength(2); + expect(pending[0].description).toBe("Model 'A'"); + expect(pending[1].description).toBe("Alias 'B'"); + + resolver.finishResolution(req2); + resolver.finishResolution(req1); + }); + }); + + describe("formatCycleDiagnostics", () => { + it("formats cycle steps into readable messages", () => { + const steps: CycleStep[] = [ + { request: { description: "Model 'A' extends 'B'" } as any, target: {} as any }, + { request: { description: "Model 'B' extends 'C'" } as any, target: {} as any }, + { request: { description: "Model 'C' extends 'A'" } as any, target: {} as any }, + ]; + + const messages = TypeResolver.formatCycleDiagnostics(steps); + expect(messages).toHaveLength(3); + expect(messages[0]).toBe("Model 'A' extends 'B'"); + expect(messages[1]).toBe("Model 'B' extends 'C'"); + expect(messages[2]).toBe("Model 'C' extends 'A' (cycle closes)"); + }); + }); + + describe("reset", () => { + it("clears all state", () => { + const resolver = new TypeResolver(); + const sym = createMockSym(1); + const req = createRequest(sym, ResolutionKind.BaseType); + + resolver.startResolution(req); + resolver.setCached(sym, ResolutionKind.BaseType, { value: "test" }); + + resolver.reset(); + + expect(resolver.depth).toBe(0); + expect(resolver.hasPendingResolutions).toBe(false); + expect(resolver.getCached(sym, ResolutionKind.BaseType)).toBeUndefined(); + expect(resolver.isResolving(sym, ResolutionKind.BaseType)).toBe(false); + }); + + it("clears deferred completions", () => { + const resolver = new TypeResolver(); + resolver.trackDeferredCompletion("Model 'A'", 2); + expect(resolver.unresolvedDeferredCompletions).toHaveLength(1); + + resolver.reset(); + expect(resolver.unresolvedDeferredCompletions).toHaveLength(0); + }); + }); + + describe("deferred completions", () => { + it("tracks deferred completions", () => { + const resolver = new TypeResolver(); + resolver.trackDeferredCompletion("Model 'A'", 2); + resolver.trackDeferredCompletion("Model 'B'", 1); + + expect(resolver.unresolvedDeferredCompletions).toHaveLength(2); + expect(resolver.unresolvedDeferredCompletions[0]).toMatchObject({ + description: "Model 'A'", + dependencyCount: 2, + }); + }); + + it("resolves deferred completions", () => { + const resolver = new TypeResolver(); + resolver.trackDeferredCompletion("Model 'A'", 2); + resolver.trackDeferredCompletion("Model 'B'", 1); + + resolver.resolveDeferredCompletion("Model 'A'"); + + expect(resolver.unresolvedDeferredCompletions).toHaveLength(1); + expect(resolver.unresolvedDeferredCompletions[0].description).toBe("Model 'B'"); + }); + + it("resolving non-existent completion is a no-op", () => { + const resolver = new TypeResolver(); + resolver.trackDeferredCompletion("Model 'A'", 1); + resolver.resolveDeferredCompletion("Model 'X'"); + expect(resolver.unresolvedDeferredCompletions).toHaveLength(1); + }); + }); +}); diff --git a/packages/http-client-python/package-lock.json b/packages/http-client-python/package-lock.json index 610a53f6ae3..503b37172d2 100644 --- a/packages/http-client-python/package-lock.json +++ b/packages/http-client-python/package-lock.json @@ -46,7 +46,7 @@ "vitest": "^4.0.15" }, "engines": { - "node": ">=20.0.0" + "node": ">=22.0.0" }, "peerDependencies": { "@azure-tools/typespec-autorest": ">=0.68.0 <1.0.0",