@typespec/compiler 0.62.0-dev.11 → 0.62.0-dev.12

package/dist/src/core/checker.js

@@ -1,6 +1,7 @@
-import { $docFromComment, getIndexer } from "../lib/intrinsic-decorators.js";
+import { docFromCommentDecorator, getIndexer } from "../lib/intrinsic/decorators.js";
+import { DuplicateTracker } from "../utils/duplicate-tracker.js";
 import { MultiKeyMap, createRekeyableMap, isArray, mutate } from "../utils/misc.js";
-import { createSymbol, createSymbolTable } from "./binder.js";
+import { createSymbol, getSymNode } from "./binder.js";
 import { createChangeIdentifierCodeFix } from "./compiler-code-fixes/change-identifier.codefix.js";
 import { createModelToObjectValueCodeFix } from "./compiler-code-fixes/model-to-object-literal.codefix.js";
 import { createTupleToArrayValueCodeFix } from "./compiler-code-fixes/tuple-to-array-value.codefix.js";
@@ -9,6 +10,7 @@ import { ProjectionError, compilerAssert, ignoreDiagnostics } from "./diagnostic
 import { validateInheritanceDiscriminatedUnions } from "./helpers/discriminator-utils.js";
 import { getLocationContext } from "./helpers/location-context.js";
 import { explainStringTemplateNotSerializable } from "./helpers/string-template-utils.js";
+import { typeReferenceToString } from "./helpers/syntax-utils.js";
 import { getEntityName, getNamespaceFullName, getTypeName, } from "./helpers/type-name-utils.js";
 import { legacyMarshallTypeForJS, marshallTypeForJS } from "./js-marshaller.js";
 import { createDiagnostic } from "./messages.js";
@@ -17,20 +19,15 @@ import { exprIsBareIdentifier, getFirstAncestor, getIdentifierContext, hasParseE
 import { createProjectionMembers } from "./projection-members.js";
 import { createTypeRelationChecker } from "./type-relation-checker.js";
 import { getFullyQualifiedSymbolName, getParentTemplateNode, isArrayModelType, isErrorType, isNullType, isTemplateInstance, isType, isValue, } from "./type-utils.js";
-import { IdentifierKind, SyntaxKind, } from "./types.js";
+import { IdentifierKind, ResolutionResultFlags, SyntaxKind, } from "./types.js";
 /**
  * Maps type arguments to type instantiation.
  */
 const TypeInstantiationMap = class extends MultiKeyMap {
 };
-let currentSymbolId = 0;
-export function createChecker(program) {
+export function createChecker(program, resolver) {
     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();
     const valueExactTypes = new WeakMap();
     let onCheckerDiagnostic = (x) => {
@@ -44,7 +41,6 @@ export function createChecker(program) {
             return this.projections.filter((p) => p.id.sv === name);
         },
     };
-    const globalNamespaceNode = createGlobalNamespaceNode();
     const globalNamespaceType = createGlobalNamespaceType();
     // Caches the deprecation test of nodes in the program
     const nodeDeprecationMap = new Map();
@@ -53,7 +49,6 @@ export function createChecker(program) {
     const neverType = createType({ kind: "Intrinsic", name: "never" });
     const unknownType = createType({ kind: "Intrinsic", name: "unknown" });
     const nullType = createType({ kind: "Intrinsic", name: "null" });
-    const nullSym = createSymbol(undefined, "null", 0 /* SymbolFlags.None */);
     const projectionsByTypeKind = new Map([
         ["Model", []],
         ["ModelProperty", []],
@@ -76,21 +71,9 @@ export function createChecker(program) {
      * Key is the SymId of a node. It can be retrieved with getNodeSymId(node)
      */
     const pendingResolutions = new PendingResolutions();
-    for (const file of program.jsSourceFiles.values()) {
-        mergeSourceFile(file);
-    }
-    for (const file of program.sourceFiles.values()) {
-        mergeSourceFile(file);
-    }
-    const typespecNamespaceBinding = globalNamespaceNode.symbol.exports.get("TypeSpec");
+    const typespecNamespaceBinding = resolver.symbols.global.exports.get("TypeSpec");
     if (typespecNamespaceBinding) {
         initializeTypeSpecIntrinsics();
-        for (const file of program.sourceFiles.values()) {
-            addUsingSymbols(typespecNamespaceBinding.exports, file.locals);
-        }
-    }
-    for (const file of program.sourceFiles.values()) {
-        setUsingsForFile(file);
     }
     let evalContext = undefined;
     const checker = {
@@ -102,9 +85,7 @@ export function createChecker(program) {
         getNamespaceString: getNamespaceFullName,
         getGlobalNamespaceType,
         getGlobalNamespaceNode,
-        setUsingsForFile,
         getMergedSymbol,
-        mergeSourceFile,
         cloneType,
         resolveIdentifier,
         resolveCompletions,
@@ -153,18 +134,18 @@ export function createChecker(program) {
     function initializeTypeSpecIntrinsics() {
         // a utility function to log strings or numbers
         mutate(typespecNamespaceBinding.exports).set("log", {
-            flags: 131072 /* SymbolFlags.Function */,
+            flags: 8192 /* SymbolFlags.Function */,
             name: "log",
             value(p, ...strs) {
                 program.trace("projection.log", strs.join(" "));
                 return voidType;
             },
             declarations: [],
+            node: undefined, // TODO: is this correct?
         });
         // Until we have an `unit` type for `null`
-        mutate(typespecNamespaceBinding.exports).set("null", nullSym);
-        mutate(nullSym).type = nullType;
-        getSymbolLinks(nullSym).type = nullType;
+        mutate(resolver.symbols.null).type = nullType;
+        getSymbolLinks(resolver.symbols.null).type = nullType;
     }
     function getStdType(name) {
         const type = stdTypes[name];
@@ -172,7 +153,8 @@ export function createChecker(program) {
             return type;
         }
         const sym = typespecNamespaceBinding?.exports?.get(name);
-        if (sym && sym.flags & 2 /* SymbolFlags.Model */) {
+        compilerAssert(sym, `Unexpected missing symbol to std type "${name}"`);
+        if (sym.flags & 2 /* SymbolFlags.Model */) {
             checkModelStatement(sym.declarations[0], undefined);
         }
         else {
@@ -182,105 +164,6 @@ export function createChecker(program) {
         compilerAssert(loadedType, `TypeSpec std type "${name}" should have been initalized before using array syntax.`);
         return loadedType;
     }
-    function mergeSourceFile(file) {
-        mergeSymbolTable(file.symbol.exports, mutate(globalNamespaceNode.symbol.exports));
-    }
-    function setUsingsForFile(file) {
-        const usedUsing = new Set();
-        for (const using of file.usings) {
-            const parentNs = using.parent;
-            const sym = resolveTypeReferenceSym(using.name, undefined);
-            if (!sym) {
-                continue;
-            }
-            if (!(sym.flags & 4096 /* SymbolFlags.Namespace */)) {
-                reportCheckerDiagnostic(createDiagnostic({ code: "using-invalid-ref", target: using }));
-                continue;
-            }
-            const namespaceSym = getMergedSymbol(sym);
-            if (usedUsing.has(namespaceSym)) {
-                reportCheckerDiagnostic(createDiagnostic({
-                    code: "duplicate-using",
-                    format: { usingName: memberExpressionToString(using.name) },
-                    target: using,
-                }));
-                continue;
-            }
-            usedUsing.add(namespaceSym);
-            addUsingSymbols(sym.exports, parentNs.locals);
-        }
-    }
-    function applyAugmentDecorators(node) {
-        if (!node.statements || !isArray(node.statements)) {
-            return;
-        }
-        const augmentDecorators = node.statements.filter((x) => x.kind === SyntaxKind.AugmentDecoratorStatement);
-        for (const decNode of augmentDecorators) {
-            const ref = resolveTypeReferenceSym(decNode.targetType, undefined);
-            if (ref) {
-                let args = [];
-                if (ref.declarations[0].kind === SyntaxKind.AliasStatement) {
-                    const aliasNode = ref.declarations[0];
-                    if (aliasNode.value.kind === SyntaxKind.TypeReference) {
-                        args = aliasNode.value.arguments;
-                    }
-                }
-                else {
-                    args = decNode.targetType.arguments;
-                }
-                if (ref.flags & 4096 /* SymbolFlags.Namespace */) {
-                    const links = getSymbolLinks(getMergedSymbol(ref));
-                    const type = links.type;
-                    const decApp = checkDecoratorApplication(type, decNode, undefined);
-                    if (decApp) {
-                        type.decorators.push(decApp);
-                        applyDecoratorToType(program, decApp, type);
-                    }
-                }
-                else if (args.length > 0 || ref.flags & 67108864 /* SymbolFlags.LateBound */) {
-                    reportCheckerDiagnostic(createDiagnostic({
-                        code: "augment-decorator-target",
-                        messageId: "noInstance",
-                        target: decNode.target,
-                    }));
-                }
-                else {
-                    let list = augmentDecoratorsForSym.get(ref);
-                    if (list === undefined) {
-                        list = [];
-                        augmentDecoratorsForSym.set(ref, list);
-                    }
-                    list.unshift(decNode);
-                }
-            }
-        }
-    }
-    function addUsingSymbols(source, destination) {
-        const augmented = getOrCreateAugmentedSymbolTable(destination);
-        for (const symbolSource of source.values()) {
-            const sym = {
-                flags: 524288 /* SymbolFlags.Using */,
-                declarations: [],
-                name: symbolSource.name,
-                symbolSource: symbolSource,
-            };
-            augmented.set(sym.name, sym);
-        }
-    }
-    /**
-     * We cannot inject symbols into the symbol tables hanging off syntax tree nodes as
-     * syntax tree nodes can be shared by other programs. This is called as a copy-on-write
-     * to inject using and late-bound symbols, and then we use the copy when resolving
-     * in the table.
-     */
-    function getOrCreateAugmentedSymbolTable(table) {
-        let augmented = augmentedSymbolTables.get(table);
-        if (!augmented) {
-            augmented = createSymbolTable(table);
-            augmentedSymbolTables.set(table, augmented);
-        }
-        return mutate(augmented);
-    }
     /**
      * Create the link for the given type to the symbol links.
      * If currently instantiating a template it will link to the instantiations.
@@ -311,13 +194,13 @@ export function createChecker(program) {
      */
     function checkMemberSym(sym, mapper) {
         const symbolLinks = getSymbolLinks(sym);
-        const memberContainer = getTypeForNode(sym.parent.declarations[0], mapper);
+        const memberContainer = getTypeForNode(getSymNode(sym.parent), mapper);
         const type = symbolLinks.declaredType ?? symbolLinks.type;
         if (type) {
             return type;
         }
         else {
-            return checkMember(sym.declarations[0], mapper, memberContainer);
+            return checkMember(getSymNode(sym), mapper, memberContainer);
         }
     }
     /**
@@ -671,6 +554,10 @@ export function createChecker(program) {
                 return checkCallExpression(node, mapper);
             case SyntaxKind.TypeOfExpression:
                 return checkTypeOfExpression(node, mapper);
+            case SyntaxKind.AugmentDecoratorStatement:
+                return checkAugmentDecorator(node);
+            case SyntaxKind.UsingStatement:
+                return checkUsings(node);
             default:
                 return errorType;
         }
@@ -678,13 +565,12 @@ export function createChecker(program) {
     /**
      * Return a fully qualified id of node
      */
-    function getNodeSymId(node) {
+    function getNodeSym(node) {
         const symbol = node.kind === SyntaxKind.OperationStatement &&
             node.parent?.kind === SyntaxKind.InterfaceStatement
             ? getSymbolForMember(node)
             : node.symbol;
-        // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
-        return symbol?.id;
+        return symbol;
     }
     /**
      * Check if the given namespace is the standard library `TypeSpec` namespace.
@@ -704,7 +590,7 @@ export function createChecker(program) {
         const parentNode = node.parent;
         const grandParentNode = parentNode.parent;
         const links = getSymbolLinks(node.symbol);
-        if (pendingResolutions.has(getNodeSymId(node), ResolutionKind.Constraint)) {
+        if (pendingResolutions.has(getNodeSym(node), ResolutionKind.Constraint)) {
             if (mapper === undefined) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "circular-constraint",
@@ -731,9 +617,9 @@ export function createChecker(program) {
                 node: node,
             });
             if (node.constraint) {
-                pendingResolutions.start(getNodeSymId(node), ResolutionKind.Constraint);
+                pendingResolutions.start(getNodeSym(node), ResolutionKind.Constraint);
                 type.constraint = getParamConstraintEntityForNode(node.constraint);
-                pendingResolutions.finish(getNodeSymId(node), ResolutionKind.Constraint);
+                pendingResolutions.finish(getNodeSym(node), ResolutionKind.Constraint);
             }
             if (node.default) {
                 type.default = checkTemplateParameterDefault(node.default, parentNode.templateParameters, index, type.constraint);
@@ -1031,27 +917,28 @@ export function createChecker(program) {
         return result;
     }
     function checkTypeOrValueReferenceSymbol(sym, node, mapper, instantiateTemplates = true) {
-        if (sym.flags & 16777216 /* SymbolFlags.Const */) {
+        if (sym.flags & 524288 /* SymbolFlags.Const */) {
             return getValueForNode(sym.declarations[0], mapper);
         }
-        if (sym.flags & 16384 /* SymbolFlags.Decorator */) {
+        if (sym.flags & 1024 /* SymbolFlags.Decorator */) {
             reportCheckerDiagnostic(createDiagnostic({ code: "invalid-type-ref", messageId: "decorator", target: sym }));
             return errorType;
         }
-        if (sym.flags & 131072 /* SymbolFlags.Function */) {
+        if (sym.flags & 8192 /* SymbolFlags.Function */) {
             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;
-        if (sym.flags &
-            (2 /* SymbolFlags.Model */ |
-                8 /* SymbolFlags.Scalar */ |
-                2048 /* SymbolFlags.Alias */ |
-                128 /* SymbolFlags.Interface */ |
-                16 /* SymbolFlags.Operation */ |
-                512 /* SymbolFlags.Union */)) {
+        if (sym.flags & 1048576 /* SymbolFlags.Declaration */ &&
+            sym.flags &
+                (2 /* SymbolFlags.Model */ |
+                    4 /* SymbolFlags.Scalar */ |
+                    128 /* SymbolFlags.Alias */ |
+                    32 /* SymbolFlags.Interface */ |
+                    8 /* SymbolFlags.Operation */ |
+                    64 /* SymbolFlags.Union */)) {
             const decl = sym.declarations[0];
             if (!isTemplatedNode(decl)) {
                 if (argumentNodes.length > 0) {
@@ -1061,14 +948,14 @@ export function createChecker(program) {
                         target: node,
                     }));
                 }
-                if (sym.flags & 67108864 /* SymbolFlags.LateBound */) {
+                if (sym.flags & 4194304 /* SymbolFlags.LateBound */) {
                     compilerAssert(sym.type, "Expected late bound symbol to have type");
                     return sym.type;
                 }
                 else if (symbolLinks.declaredType) {
                     baseType = symbolLinks.declaredType;
                 }
-                else if (sym.flags & 33555780 /* SymbolFlags.Member */) {
+                else if (sym.flags & 262144 /* SymbolFlags.Member */) {
                     baseType = checkMemberSym(sym, mapper);
                 }
                 else {
@@ -1083,6 +970,7 @@ export function createChecker(program) {
             }
         }
         else {
+            const symNode = getSymNode(sym);
             // some other kind of reference
             if (argumentNodes.length > 0) {
                 reportCheckerDiagnostic(createDiagnostic({
@@ -1091,12 +979,12 @@ export function createChecker(program) {
                     target: node,
                 }));
             }
-            if (sym.flags & 67108864 /* SymbolFlags.LateBound */) {
+            if (sym.flags & 4194304 /* SymbolFlags.LateBound */) {
                 compilerAssert(sym.type, `Expected late bound symbol to have type`);
                 return sym.type;
             }
-            else if (sym.flags & 32768 /* SymbolFlags.TemplateParameter */) {
-                const mapped = checkTemplateParameterDeclaration(sym.declarations[0], mapper);
+            else if (sym.flags & 2048 /* SymbolFlags.TemplateParameter */) {
+                const mapped = checkTemplateParameterDeclaration(symNode, mapper);
                 baseType = mapped;
             }
             else if (symbolLinks.type) {
@@ -1107,12 +995,12 @@ export function createChecker(program) {
                 baseType = symbolLinks.declaredType;
             }
             else {
-                if (sym.flags & 33555780 /* SymbolFlags.Member */) {
+                if (sym.flags & 262144 /* SymbolFlags.Member */) {
                     baseType = checkMemberSym(sym, mapper);
                 }
                 else {
                     // don't have a cached type for this symbol, so go grab it and cache it
-                    baseType = getTypeForNode(sym.declarations[0], mapper);
+                    baseType = getTypeForNode(symNode, mapper);
                     symbolLinks.type = baseType;
                 }
             }
@@ -1120,7 +1008,7 @@ export function createChecker(program) {
         // Check for deprecations here, first on symbol, then on type.  However,
         // don't raise deprecation when the usage site is also a deprecated
         // declaration.
-        const declarationNode = sym?.declarations[0];
+        const declarationNode = getSymNode(sym);
         if (declarationNode && mapper === undefined && isType(baseType)) {
             if (!isTypeReferenceContextDeprecated(node.parent)) {
                 checkDeprecated(baseType, declarationNode, node);
@@ -1145,11 +1033,11 @@ export function createChecker(program) {
         if (symbolLinks.declaredType) {
             return symbolLinks.declaredType;
         }
-        if (sym.flags & 67108864 /* SymbolFlags.LateBound */) {
+        if (sym.flags & 4194304 /* SymbolFlags.LateBound */) {
             compilerAssert(sym.type, "Expected late bound symbol to have type");
             return sym.type;
         }
-        if (sym.flags & 33555780 /* SymbolFlags.Member */) {
+        if (sym.flags & 262144 /* SymbolFlags.Member */) {
             return checkMemberSym(sym, mapper);
         }
         else {
@@ -1166,13 +1054,13 @@ export function createChecker(program) {
     function checkDeclaredTypeOrIndeterminate(sym, node, mapper) {
         const type = sym.flags & 2 /* SymbolFlags.Model */
             ? checkModelStatement(node, mapper)
-            : sym.flags & 8 /* SymbolFlags.Scalar */
+            : sym.flags & 4 /* SymbolFlags.Scalar */
                 ? checkScalar(node, mapper)
-                : sym.flags & 2048 /* SymbolFlags.Alias */
+                : sym.flags & 128 /* SymbolFlags.Alias */
                     ? checkAlias(node, mapper)
-                    : sym.flags & 128 /* SymbolFlags.Interface */
+                    : sym.flags & 32 /* SymbolFlags.Interface */
                         ? checkInterface(node, mapper)
-                        : sym.flags & 16 /* SymbolFlags.Operation */
+                        : sym.flags & 8 /* SymbolFlags.Operation */
                             ? checkOperation(node, mapper)
                             : checkUnion(node, mapper);
         return type;
@@ -1320,8 +1208,15 @@ export function createChecker(program) {
      * with unions). The resulting model is anonymous.
      */
     function checkIntersectionExpression(node, mapper) {
+        const links = getSymbolLinks(node.symbol);
+        if (links.declaredType && mapper === undefined) {
+            // we're not instantiating this model and we've already checked it
+            return links.declaredType;
+        }
         const options = node.options.map((o) => [o, getTypeForNode(o, mapper)]);
-        return mergeModelTypes(node, options, mapper);
+        const type = mergeModelTypes(node.symbol, node, options, mapper);
+        linkType(links, type, mapper);
+        return type;
     }
     function checkDecoratorDeclaration(node, mapper) {
         const symbol = getMergedSymbol(node.symbol);
@@ -1452,7 +1347,7 @@ export function createChecker(program) {
                 };
         }
     }
-    function mergeModelTypes(node, options, mapper) {
+    function mergeModelTypes(parentModelSym, node, options, mapper) {
         const properties = createRekeyableMap();
         const intersection = createType({
             kind: "Model",
@@ -1502,11 +1397,16 @@ export function createChecker(program) {
                     }));
                     continue;
                 }
-                const newPropType = cloneType(prop, {
+                const memberSym = parentModelSym && getMemberSymbol(parentModelSym, prop.name);
+                const overrides = {
                     sourceProperty: prop,
                     model: intersection,
-                });
+                };
+                const newPropType = memberSym
+                    ? cloneTypeForSymbol(memberSym, prop, overrides)
+                    : cloneType(prop, overrides);
                 properties.set(prop.name, newPropType);
+                linkIndirectMember(node, newPropType, mapper);
                 for (const indexer of indexers.filter((x) => x !== option.indexer)) {
                     checkPropertyCompatibleWithIndexer(indexer, prop, node);
                 }
@@ -1518,7 +1418,7 @@ export function createChecker(program) {
         else if (indexers.length > 1) {
             intersection.indexer = {
                 key: indexers[0].key,
-                value: mergeModelTypes(node, indexers.map((x) => [x.value.node, x.value]), mapper),
+                value: mergeModelTypes(undefined, node, indexers.map((x) => [x.value.node, x.value]), mapper),
             };
         }
         linkMapper(intersection, mapper);
@@ -1654,9 +1554,9 @@ export function createChecker(program) {
         const namespace = getParentNamespaceType(node);
         const name = node.id.sv;
         let decorators = [];
-        const parameterModelSym = getOrCreateAugmentedSymbolTable(symbol.metatypeMembers).get("parameters");
+        const { resolvedSymbol: parameterModelSym } = resolver.resolveMetaMemberByName(symbol, "parameters");
         if (parameterModelSym?.members) {
-            const members = getOrCreateAugmentedSymbolTable(parameterModelSym.members);
+            const members = resolver.getAugmentedSymbolTable(parameterModelSym.members);
             const paramDocs = extractParamDocs(node);
             for (const [name, memberSym] of members) {
                 const doc = paramDocs.get(name);
@@ -1743,27 +1643,24 @@ export function createChecker(program) {
         if (!opReference)
             return undefined;
         // Ensure that we don't end up with a circular reference to the same operation
-        const opSymId = getNodeSymId(operation);
+        const opSymId = getNodeSym(operation);
         if (opSymId) {
             pendingResolutions.start(opSymId, ResolutionKind.BaseType);
         }
-        const target = resolveTypeReferenceSym(opReference, mapper);
-        if (target === undefined) {
-            return undefined;
-        }
+        const target = resolver.getNodeLinks(opReference).resolvedSymbol;
         // Did we encounter a circular operation reference?
-        if (pendingResolutions.has(getNodeSymId(target.declarations[0]), ResolutionKind.BaseType)) {
+        if (target && pendingResolutions.has(target, ResolutionKind.BaseType)) {
             if (mapper === undefined) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "circular-op-signature",
-                    format: { typeName: target.declarations[0].id.sv },
+                    format: { typeName: target.name },
                     target: opReference,
                 }));
             }
             return undefined;
         }
         // Resolve the base operation type
-        const baseOperation = checkTypeReferenceSymbol(target, opReference, mapper);
+        const baseOperation = getTypeForNode(opReference, mapper);
         if (opSymId) {
             pendingResolutions.finish(opSymId, ResolutionKind.BaseType);
         }
@@ -1781,7 +1678,7 @@ export function createChecker(program) {
         return globalNamespaceType;
     }
     function getGlobalNamespaceNode() {
-        return globalNamespaceNode;
+        return resolver.symbols.global.declarations[0];
     }
     function checkTupleExpression(node, mapper) {
         return createAndFinishType({
@@ -1791,47 +1688,7 @@ export function createChecker(program) {
         });
     }
     function getSymbolLinks(s) {
-        const id = getSymbolId(s);
-        if (symbolLinks.has(id)) {
-            return symbolLinks.get(id);
-        }
-        const links = {};
-        symbolLinks.set(id, links);
-        return links;
-    }
-    function getSymbolId(s) {
-        if (s.id === undefined) {
-            mutate(s).id = currentSymbolId++;
-        }
-        return s.id;
-    }
-    function resolveIdentifierInTable(node, table, options) {
-        if (!table) {
-            return undefined;
-        }
-        table = augmentedSymbolTables.get(table) ?? table;
-        let sym;
-        if (options.resolveDecorators) {
-            sym = table.get("@" + node.sv);
-        }
-        else {
-            sym = table.get(node.sv);
-        }
-        if (!sym)
-            return sym;
-        if (sym.flags & 1048576 /* SymbolFlags.DuplicateUsing */) {
-            reportAmbiguousIdentifier(node, [...(table.duplicates.get(sym) ?? [])]);
-            return sym;
-        }
-        return getMergedSymbol(sym);
-    }
-    function reportAmbiguousIdentifier(node, symbols) {
-        const duplicateNames = symbols.map((s) => getFullyQualifiedSymbolName(s, { useGlobalPrefixAtTopLevel: true }));
-        reportCheckerDiagnostic(createDiagnostic({
-            code: "ambiguous-symbol",
-            format: { name: node.sv, duplicateNames: duplicateNames.join(", ") },
-            target: node,
-        }));
+        return resolver.getSymbolLinks(s);
     }
     function resolveIdentifier(id, mapper) {
         let sym;
@@ -1849,29 +1706,8 @@ export function createChecker(program) {
                 break;
             case IdentifierKind.ModelStatementProperty:
             case IdentifierKind.Declaration:
-                if (node.symbol && (!isTemplatedNode(node) || mapper === undefined)) {
-                    sym = getMergedSymbol(node.symbol);
-                    break;
-                }
-                compilerAssert(node.parent, "Parent expected.");
-                const containerType = getTypeOrValueForNode(node.parent, mapper);
-                if (containerType === null || isValue(containerType)) {
-                    return undefined;
-                }
-                if (isAnonymous(containerType)) {
-                    return undefined; // member of anonymous type cannot be referenced.
-                }
-                lateBindMemberContainer(containerType);
-                let container = node.parent.symbol;
-                if (!container && "symbol" in containerType && containerType.symbol) {
-                    container = containerType.symbol;
-                }
-                if (!container) {
-                    return undefined;
-                }
-                lateBindMembers(containerType, container);
-                sym = resolveIdentifierInTable(id, container.exports ?? container.members, defaultSymbolResolutionOptions);
-                break;
+                const links = resolver.getNodeLinks(id);
+                return links.resolvedSymbol;
             case IdentifierKind.Other:
                 return undefined;
             case IdentifierKind.Decorator:
@@ -2158,19 +1994,12 @@ export function createChecker(program) {
             }
         }
         else if (identifier.parent && identifier.parent.kind === SyntaxKind.MemberExpression) {
-            let base = resolveTypeReferenceSym(identifier.parent.base, undefined, false);
+            let base = resolver.getNodeLinks(identifier.parent.base).resolvedSymbol;
             if (base) {
-                if (base.flags & 2048 /* SymbolFlags.Alias */) {
-                    base = getAliasedSymbol(base, undefined, defaultSymbolResolutionOptions);
+                if (base.flags & 128 /* SymbolFlags.Alias */) {
+                    base = getAliasedSymbol(base, undefined);
                 }
                 if (base) {
-                    if (isTemplatedNode(base.declarations[0])) {
-                        const type = base.type ?? getTypeForNode(base.declarations[0], undefined);
-                        if (isTemplateInstance(type)) {
-                            lateBindMemberContainer(type);
-                            lateBindMembers(type, base);
-                        }
-                    }
                     addCompletions(base.exports ?? base.members);
                 }
             }
@@ -2207,7 +2036,7 @@ export function createChecker(program) {
                     addCompletions(mergedSymbol.exports);
                 }
                 // check "global scope" declarations
-                addCompletions(globalNamespaceNode.symbol.exports);
+                addCompletions(resolver.symbols.global.exports);
                 // check "global scope" usings
                 addCompletions(scope.locals);
             }
@@ -2217,12 +2046,12 @@ export function createChecker(program) {
             if (!table) {
                 return;
             }
-            table = augmentedSymbolTables.get(table) ?? table;
+            table = resolver.getAugmentedSymbolTable(table);
             for (const [key, sym] of table) {
-                if (sym.flags & 1048576 /* SymbolFlags.DuplicateUsing */) {
+                if (sym.flags & 65536 /* SymbolFlags.DuplicateUsing */) {
                     const duplicates = table.duplicates.get(sym);
                     for (const duplicate of duplicates) {
-                        if (duplicate.flags & 524288 /* SymbolFlags.Using */) {
+                        if (duplicate.flags & 32768 /* SymbolFlags.Using */) {
                             const fqn = getFullyQualifiedSymbolName(duplicate.symbolSource);
                             addCompletion(fqn, duplicate);
                         }
@@ -2252,79 +2081,23 @@ export function createChecker(program) {
                 case IdentifierKind.ModelExpressionProperty:
                 case IdentifierKind.ModelStatementProperty:
                 case IdentifierKind.ObjectLiteralProperty:
-                    return !!(sym.flags & 4 /* SymbolFlags.ModelProperty */);
+                    return !!(sym.flags & 262144 /* SymbolFlags.Member */);
                 case IdentifierKind.Decorator:
                     // Only return decorators and namespaces when completing decorator
-                    return !!(sym.flags & (16384 /* SymbolFlags.Decorator */ | 4096 /* SymbolFlags.Namespace */));
+                    return !!(sym.flags & (1024 /* SymbolFlags.Decorator */ | 256 /* SymbolFlags.Namespace */));
                 case IdentifierKind.Using:
                     // Only return namespaces when completing using
-                    return !!(sym.flags & 4096 /* SymbolFlags.Namespace */);
+                    return !!(sym.flags & 256 /* SymbolFlags.Namespace */);
                 case IdentifierKind.TypeReference:
                     // Do not return functions or decorators when completing types
-                    return !(sym.flags & (131072 /* SymbolFlags.Function */ | 16384 /* SymbolFlags.Decorator */));
+                    return !(sym.flags & (8192 /* SymbolFlags.Function */ | 1024 /* SymbolFlags.Decorator */));
                 case IdentifierKind.TemplateArgument:
-                    return !!(sym.flags & 32768 /* SymbolFlags.TemplateParameter */);
+                    return !!(sym.flags & 2048 /* SymbolFlags.TemplateParameter */);
                 default:
                     compilerAssert(false, "We should have bailed up-front on other kinds.");
             }
         }
     }
-    function resolveIdentifierInScope(node, mapper, options) {
-        compilerAssert(node.parent?.kind !== SyntaxKind.MemberExpression || node.parent.id !== node, "This function should not be used to resolve Y in member expression X.Y. Use resolveIdentifier() to resolve an arbitrary identifier.");
-        if (hasParseError(node)) {
-            // Don't report synthetic identifiers used for parser error recovery.
-            // The parse error is the root cause and will already have been logged.
-            return undefined;
-        }
-        let scope = node.parent;
-        let binding;
-        while (scope && scope.kind !== SyntaxKind.TypeSpecScript) {
-            if (scope.symbol && "exports" in scope.symbol) {
-                const mergedSymbol = getMergedSymbol(scope.symbol);
-                binding = resolveIdentifierInTable(node, mergedSymbol.exports, options);
-                if (binding)
-                    return binding;
-            }
-            if ("locals" in scope) {
-                binding = resolveIdentifierInTable(node, scope.locals, options);
-                if (binding)
-                    return binding;
-            }
-            scope = scope.parent;
-        }
-        if (!binding && scope && scope.kind === SyntaxKind.TypeSpecScript) {
-            // check any blockless namespace decls
-            for (const ns of scope.inScopeNamespaces) {
-                const mergedSymbol = getMergedSymbol(ns.symbol);
-                binding = resolveIdentifierInTable(node, mergedSymbol.exports, options);
-                if (binding)
-                    return binding;
-            }
-            // check "global scope" declarations
-            const globalBinding = resolveIdentifierInTable(node, globalNamespaceNode.symbol.exports, options);
-            // check using types
-            const usingBinding = resolveIdentifierInTable(node, scope.locals, options);
-            if (globalBinding && usingBinding) {
-                reportAmbiguousIdentifier(node, [globalBinding, usingBinding]);
-                return globalBinding;
-            }
-            else if (globalBinding) {
-                return globalBinding;
-            }
-            else if (usingBinding) {
-                return usingBinding.flags & 1048576 /* SymbolFlags.DuplicateUsing */ ? undefined : usingBinding;
-            }
-        }
-        if (mapper === undefined) {
-            reportCheckerDiagnostic(createDiagnostic({
-                code: "unknown-identifier",
-                format: { id: node.sv },
-                target: node,
-                codefixes: getCodefixesForUnknownIdentifier(node),
-            }));
-        }
-        return undefined;
-    }
     function getCodefixesForUnknownIdentifier(node) {
         switch (node.sv) {
             case "number":
@@ -2355,14 +2128,37 @@ export function createChecker(program) {
         if (node.kind === SyntaxKind.TypeReference) {
             return resolveTypeReferenceSym(node.target, mapper, options);
         }
-        if (node.kind === SyntaxKind.MemberExpression) {
-            let base = resolveTypeReferenceSym(node.base, mapper);
+        else if (node.kind === SyntaxKind.Identifier) {
+            const links = resolver.getNodeLinks(node);
+            if (mapper === undefined && links.resolutionResult) {
+                if (mapper === undefined && // do not report error when instantiating
+                    links.resolutionResult & (ResolutionResultFlags.NotFound | ResolutionResultFlags.Unknown)) {
+                    reportCheckerDiagnostic(createDiagnostic({
+                        code: "invalid-ref",
+                        messageId: options.resolveDecorators ? "decorator" : "identifier",
+                        format: { id: printTypeReferenceNode(node) },
+                        target: node,
+                        codefixes: getCodefixesForUnknownIdentifier(node),
+                    }));
+                }
+                else if (links.resolutionResult & ResolutionResultFlags.Ambiguous) {
+                    reportAmbiguousIdentifier(node, links.ambiguousSymbols);
+                }
+            }
+            const sym = links.resolvedSymbol;
+            return sym?.symbolSource ?? sym;
+        }
+        else if (node.kind === SyntaxKind.MemberExpression) {
+            let base = resolveTypeReferenceSym(node.base, mapper, {
+                ...options,
+                resolveDecorators: false, // when resolving decorator the base cannot also be one
+            });
             if (!base) {
                 return undefined;
             }
             // when resolving a type reference based on an alias, unwrap the alias.
-            if (base.flags & 2048 /* SymbolFlags.Alias */) {
-                const aliasedSym = getAliasedSymbol(base, mapper, options);
+            if (base.flags & 128 /* SymbolFlags.Alias */) {
+                const aliasedSym = getAliasedSymbol(base, mapper);
                 if (!aliasedSym) {
                     reportCheckerDiagnostic(createDiagnostic({
                         code: "invalid-ref",
@@ -2379,104 +2175,72 @@ export function createChecker(program) {
                 }
                 base = aliasedSym;
             }
-            if (node.selector === ".") {
-                return resolveMemberInContainer(node, base, mapper, options);
-            }
-            else {
-                return resolveMetaProperty(node, base);
-            }
-        }
-        if (node.kind === SyntaxKind.Identifier) {
-            const sym = resolveIdentifierInScope(node, mapper, options);
-            if (!sym)
-                return undefined;
-            return sym.flags & 524288 /* SymbolFlags.Using */ ? sym.symbolSource : sym;
+            return resolveMemberInContainer(base, node, options);
         }
         compilerAssert(false, `Unknown type reference kind "${SyntaxKind[node.kind]}"`, node);
     }
-    function resolveMemberInContainer(node, base, mapper, options) {
-        if (base.flags & 4096 /* SymbolFlags.Namespace */) {
-            const symbol = resolveIdentifierInTable(node.id, base.exports, options);
-            if (!symbol) {
-                reportCheckerDiagnostic(createDiagnostic({
-                    code: "invalid-ref",
-                    messageId: "underNamespace",
-                    format: {
-                        namespace: getFullyQualifiedSymbolName(base),
-                        id: node.id.sv,
-                    },
-                    target: node,
-                }));
-                return undefined;
-            }
+    function reportAmbiguousIdentifier(node, symbols) {
+        const duplicateNames = symbols.map((s) => getFullyQualifiedSymbolName(s, { useGlobalPrefixAtTopLevel: true }));
+        program.reportDiagnostic(createDiagnostic({
+            code: "ambiguous-symbol",
+            format: { name: node.sv, duplicateNames: duplicateNames.join(", ") },
+            target: node,
+        }));
+    }
+    function resolveMemberInContainer(base, node, options) {
+        const { finalSymbol: sym, resolvedSymbol: nextSym } = resolver.resolveMemberExpressionForSym(base, node, options);
+        const symbol = nextSym ?? sym;
+        if (symbol) {
             return symbol;
         }
-        else if (base.flags & 16384 /* SymbolFlags.Decorator */) {
+        if (base.flags & 256 /* SymbolFlags.Namespace */) {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "invalid-ref",
+                messageId: "underNamespace",
+                format: {
+                    namespace: getFullyQualifiedSymbolName(base),
+                    id: node.id.sv,
+                },
+                target: node,
+            }));
+        }
+        else if (base.flags & 1024 /* SymbolFlags.Decorator */) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "invalid-ref",
                 messageId: "inDecorator",
                 format: { id: node.id.sv },
                 target: node,
             }));
-            return undefined;
         }
-        else if (base.flags & 131072 /* SymbolFlags.Function */) {
+        else if (base.flags & 8192 /* SymbolFlags.Function */) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "invalid-ref",
                 messageId: "node",
                 format: { id: node.id.sv, nodeName: "function" },
                 target: node,
             }));
-            return undefined;
         }
-        else if (base.flags & 682 /* SymbolFlags.MemberContainer */) {
-            if (options.checkTemplateTypes && isTemplatedNode(base.declarations[0])) {
-                const type = base.flags & 67108864 /* SymbolFlags.LateBound */
-                    ? base.type
-                    : getTypeForNode(base.declarations[0], mapper);
-                if (isTemplateInstance(type)) {
-                    lateBindMembers(type, base);
-                }
-            }
-            const sym = resolveIdentifierInTable(node.id, base.members, options);
-            if (!sym) {
-                reportCheckerDiagnostic(createDiagnostic({
-                    code: "invalid-ref",
-                    messageId: "underContainer",
-                    format: { kind: getMemberKindName(base.declarations[0]), id: node.id.sv },
-                    target: node,
-                }));
-                return undefined;
-            }
-            return sym;
+        else if (base.flags & 118 /* SymbolFlags.MemberContainer */) {
+            reportCheckerDiagnostic(createDiagnostic({
+                code: "invalid-ref",
+                messageId: node.selector === "." ? "member" : "metaProperty",
+                format: { kind: getMemberKindName(getSymNode(base)), id: node.id.sv },
+                target: node,
+            }));
         }
         else {
+            const symNode = getSymNode(base);
             reportCheckerDiagnostic(createDiagnostic({
                 code: "invalid-ref",
                 messageId: "node",
                 format: {
                     id: node.id.sv,
-                    nodeName: base.declarations[0] ? SyntaxKind[base.declarations[0].kind] : "Unknown node",
+                    nodeName: symNode ? SyntaxKind[symNode.kind] : "Unknown node",
                 },
                 target: node,
             }));
-            return undefined;
-        }
-    }
-    function resolveMetaProperty(node, base) {
-        const resolved = resolveIdentifierInTable(node.id, base.metatypeMembers, {
-            resolveDecorators: false,
-            checkTemplateTypes: false,
-        });
-        if (!resolved) {
-            reportCheckerDiagnostic(createDiagnostic({
-                code: "invalid-ref",
-                messageId: "metaProperty",
-                format: { kind: getMemberKindName(base.declarations[0]), id: node.id.sv },
-                target: node,
-            }));
         }
-        return resolved;
+        return undefined;
     }
     function getMemberKindName(node) {
         switch (node.kind) {
@@ -2501,30 +2265,13 @@ export function createChecker(program) {
      * (i.e. they contain symbols we don't know until we've instantiated the type and the type is an
      * instantiation) we late bind the container which creates the symbol that will hold its members.
      */
-    function getAliasedSymbol(aliasSymbol, mapper, options) {
-        let current = aliasSymbol;
-        while (current.flags & 2048 /* SymbolFlags.Alias */) {
-            const node = current.declarations[0];
-            const targetNode = node.kind === SyntaxKind.AliasStatement ? node.value : node;
-            if (targetNode.kind === SyntaxKind.TypeReference ||
-                targetNode.kind === SyntaxKind.MemberExpression ||
-                targetNode.kind === SyntaxKind.Identifier) {
-                const sym = resolveTypeReferenceSymInternal(targetNode, mapper, options);
-                if (sym === undefined) {
-                    return undefined;
-                }
-                current = sym;
-            }
-            else {
-                return undefined;
-            }
-        }
-        const sym = current;
-        const node = aliasSymbol.declarations[0];
-        const resolvedTargetNode = sym.declarations[0];
-        if (!options.checkTemplateTypes || !isTemplatedNode(resolvedTargetNode)) {
-            return sym;
+    function getAliasedSymbol(aliasSymbol, mapper) {
+        const node = getSymNode(aliasSymbol);
+        const links = resolver.getSymbolLinks(aliasSymbol);
+        if (!links.aliasResolutionIsTemplate) {
+            return links.aliasedSymbol ?? resolver.getNodeLinks(node).resolvedSymbol;
         }
+        // Otherwise for templates we need to get the type and retrieve the late bound symbol.
         const aliasType = getTypeForNode(node, mapper);
         if (isErrorType(aliasType)) {
             return undefined;
@@ -2688,27 +2435,58 @@ export function createChecker(program) {
         };
     }
     function checkProgram() {
-        program.reportDuplicateSymbols(globalNamespaceNode.symbol.exports);
+        checkDuplicateSymbols();
         for (const file of program.sourceFiles.values()) {
-            bindAllMembers(file);
+            checkDuplicateUsings(file);
+            for (const ns of file.namespaces) {
+                initializeTypeForNamespace(ns);
+            }
         }
         for (const file of program.sourceFiles.values()) {
-            bindMetaTypes(file);
+            checkSourceFile(file);
         }
+        internalDecoratorValidation();
+    }
+    function checkDuplicateSymbols() {
+        program.reportDuplicateSymbols(resolver.symbols.global.exports);
         for (const file of program.sourceFiles.values()) {
             for (const ns of file.namespaces) {
-                const exports = mergedSymbols.get(ns.symbol)?.exports ?? ns.symbol.exports;
+                const exports = getMergedSymbol(ns.symbol).exports ?? ns.symbol.exports;
                 program.reportDuplicateSymbols(exports);
-                initializeTypeForNamespace(ns);
             }
         }
-        for (const file of program.sourceFiles.values()) {
-            applyAugmentDecoratorsInScope(file);
+    }
+    /** Report error with duplicate using in the same scope. */
+    function checkDuplicateUsings(file) {
+        const duplicateTrackers = new Map();
+        function getTracker(sym) {
+            const existing = duplicateTrackers.get(sym);
+            if (existing)
+                return existing;
+            const newTacker = new DuplicateTracker();
+            duplicateTrackers.set(sym, newTacker);
+            return newTacker;
         }
-        for (const file of program.sourceFiles.values()) {
-            checkSourceFile(file);
+        for (const using of file.usings) {
+            const ns = using.parent;
+            const sym = getMergedSymbol(ns.symbol);
+            const tracker = getTracker(sym);
+            const targetSym = resolver.getNodeLinks(using.name).resolvedSymbol;
+            if (!targetSym)
+                continue;
+            tracker.track(targetSym, using);
+        }
+        for (const tracker of duplicateTrackers.values()) {
+            for (const [_, nodes] of tracker.entries()) {
+                for (const node of nodes) {
+                    program.reportDiagnostic(createDiagnostic({
+                        code: "duplicate-using",
+                        format: { usingName: typeReferenceToString(node.name) },
+                        target: node,
+                    }));
+                }
+            }
         }
-        internalDecoratorValidation();
     }
     /**
      * Post checking validation for internal decorators.
@@ -2716,22 +2494,6 @@ export function createChecker(program) {
     function internalDecoratorValidation() {
         validateInheritanceDiscriminatedUnions(program);
     }
-    function applyAugmentDecoratorsInScope(scope) {
-        applyAugmentDecorators(scope);
-        if (scope.statements === undefined) {
-            return;
-        }
-        if (isArray(scope.statements)) {
-            for (const statement of scope.statements) {
-                if (statement.kind === SyntaxKind.NamespaceStatement) {
-                    applyAugmentDecoratorsInScope(statement);
-                }
-            }
-        }
-        else {
-            applyAugmentDecoratorsInScope(scope.statements);
-        }
-    }
     function checkSourceFile(file) {
         for (const statement of file.statements) {
             checkNode(statement, undefined);
@@ -2778,7 +2540,7 @@ export function createChecker(program) {
         });
         linkType(links, type, mapper);
         if (node.symbol.members) {
-            const members = getOrCreateAugmentedSymbolTable(node.symbol.members);
+            const members = resolver.getAugmentedSymbolTable(node.symbol.members);
             const propDocs = extractPropDocs(node);
             for (const [name, memberSym] of members) {
                 const doc = propDocs.get(name);
@@ -2842,6 +2604,8 @@ export function createChecker(program) {
         if (indexer) {
             type.indexer = indexer;
         }
+        lateBindMemberContainer(type);
+        lateBindMembers(type);
         return type;
     }
     function shouldCreateTypeForTemplate(node, mapper) {
@@ -2858,6 +2622,11 @@ export function createChecker(program) {
             mapper.args.every((t) => isValue(t) || t.entityKind === "Indeterminate" || t.kind !== "TemplateParameter"));
     }
     function checkModelExpression(node, mapper) {
+        const links = getSymbolLinks(node.symbol);
+        if (links.declaredType && mapper === undefined) {
+            // we're not instantiating this model and we've already checked it
+            return links.declaredType;
+        }
         const properties = createRekeyableMap();
         const type = createType({
             kind: "Model",
@@ -2870,6 +2639,7 @@ export function createChecker(program) {
             derivedModels: [],
             sourceModels: [],
         });
+        linkType(links, type, mapper);
         linkMapper(type, mapper);
         checkModelProperties(node, properties, type, mapper);
         return finishType(type);
@@ -3429,190 +3199,6 @@ export function createChecker(program) {
         }
         properties.set(newProp.name, newProp);
     }
-    function bindAllMembers(node) {
-        const bound = new Set();
-        if (node.symbol) {
-            bindMembers(node, node.symbol);
-        }
-        visitChildren(node, (child) => {
-            bindAllMembers(child);
-        });
-        function bindMembers(node, containerSym) {
-            if (bound.has(containerSym)) {
-                return;
-            }
-            bound.add(containerSym);
-            let containerMembers;
-            switch (node.kind) {
-                case SyntaxKind.ModelStatement:
-                    if (node.extends && node.extends.kind === SyntaxKind.TypeReference) {
-                        resolveAndCopyMembers(node.extends);
-                    }
-                    if (node.is && node.is.kind === SyntaxKind.TypeReference) {
-                        resolveAndCopyMembers(node.is);
-                    }
-                    for (const prop of node.properties) {
-                        if (prop.kind === SyntaxKind.ModelSpreadProperty) {
-                            resolveAndCopyMembers(prop.target);
-                        }
-                        else {
-                            const name = prop.id.sv;
-                            bindMember(name, prop, 4 /* SymbolFlags.ModelProperty */);
-                        }
-                    }
-                    break;
-                case SyntaxKind.ScalarStatement:
-                    if (node.extends && node.extends.kind === SyntaxKind.TypeReference) {
-                        resolveAndCopyMembers(node.extends);
-                    }
-                    for (const member of node.members) {
-                        const name = member.id.sv;
-                        bindMember(name, member, 33554432 /* SymbolFlags.ScalarMember */);
-                    }
-                    break;
-                case SyntaxKind.ModelExpression:
-                    for (const prop of node.properties) {
-                        if (prop.kind === SyntaxKind.ModelSpreadProperty) {
-                            resolveAndCopyMembers(prop.target);
-                        }
-                        else {
-                            const name = prop.id.sv;
-                            bindMember(name, prop, 4 /* SymbolFlags.ModelProperty */);
-                        }
-                    }
-                    break;
-                case SyntaxKind.EnumStatement:
-                    for (const member of node.members.values()) {
-                        if (member.kind === SyntaxKind.EnumSpreadMember) {
-                            resolveAndCopyMembers(member.target);
-                        }
-                        else {
-                            const name = member.id.sv;
-                            bindMember(name, member, 64 /* SymbolFlags.EnumMember */);
-                        }
-                    }
-                    break;
-                case SyntaxKind.InterfaceStatement:
-                    for (const member of node.operations.values()) {
-                        bindMember(member.id.sv, member, 256 /* SymbolFlags.InterfaceMember */ | 16 /* SymbolFlags.Operation */);
-                    }
-                    if (node.extends) {
-                        for (const ext of node.extends) {
-                            resolveAndCopyMembers(ext);
-                        }
-                    }
-                    break;
-                case SyntaxKind.UnionStatement:
-                    for (const variant of node.options.values()) {
-                        if (!variant.id) {
-                            continue;
-                        }
-                        const name = variant.id.sv;
-                        bindMember(name, variant, 1024 /* SymbolFlags.UnionVariant */);
-                    }
-                    break;
-            }
-            function resolveAndCopyMembers(node) {
-                let ref = resolveTypeReferenceSym(node, undefined);
-                if (ref && ref.flags & 2048 /* SymbolFlags.Alias */) {
-                    ref = resolveAliasedSymbol(ref);
-                }
-                if (ref && ref.members) {
-                    bindMembers(ref.declarations[0], ref);
-                    copyMembers(ref.members);
-                }
-            }
-            function resolveAliasedSymbol(ref) {
-                const node = ref.declarations[0];
-                switch (node.value.kind) {
-                    case SyntaxKind.MemberExpression:
-                    case SyntaxKind.TypeReference:
-                        const resolvedSym = resolveTypeReferenceSym(node.value, undefined);
-                        if (resolvedSym && resolvedSym.flags & 2048 /* SymbolFlags.Alias */) {
-                            return resolveAliasedSymbol(resolvedSym);
-                        }
-                        return resolvedSym;
-                    default:
-                        return undefined;
-                }
-            }
-            function copyMembers(table) {
-                const members = augmentedSymbolTables.get(table) ?? table;
-                for (const member of members.values()) {
-                    bindMember(member.name, member.declarations[0], member.flags);
-                }
-            }
-            function bindMember(name, node, kind) {
-                const sym = createSymbol(node, name, kind, containerSym);
-                compilerAssert(containerSym.members, "containerSym.members is undefined");
-                containerMembers ??= getOrCreateAugmentedSymbolTable(containerSym.members);
-                containerMembers.set(name, sym);
-            }
-        }
-    }
-    function copyMembersToContainer(targetContainerSym, table) {
-        const members = augmentedSymbolTables.get(table) ?? table;
-        compilerAssert(targetContainerSym.members, "containerSym.members is undefined");
-        const containerMembers = getOrCreateAugmentedSymbolTable(targetContainerSym.members);
-        for (const member of members.values()) {
-            bindMemberToContainer(targetContainerSym, containerMembers, member.name, member.declarations[0], member.flags);
-        }
-    }
-    function bindMemberToContainer(containerSym, containerMembers, name, node, kind) {
-        const sym = createSymbol(node, name, kind, containerSym);
-        compilerAssert(containerSym.members, "containerSym.members is undefined");
-        containerMembers.set(name, sym);
-    }
-    function bindMetaTypes(node) {
-        const visited = new Set();
-        function visit(node, symbol) {
-            if (visited.has(node)) {
-                return;
-            }
-            visited.add(node);
-            switch (node.kind) {
-                case SyntaxKind.ModelProperty: {
-                    const sym = getSymbolForMember(node);
-                    if (sym) {
-                        const table = getOrCreateAugmentedSymbolTable(sym.metatypeMembers);
-                        table.set("type", node.value.kind === SyntaxKind.TypeReference
-                            ? createSymbol(node.value, "", 2048 /* SymbolFlags.Alias */)
-                            : node.value.symbol);
-                    }
-                    break;
-                }
-                case SyntaxKind.OperationStatement: {
-                    const sym = symbol ?? node.symbol ?? getSymbolForMember(node);
-                    const table = getOrCreateAugmentedSymbolTable(sym.metatypeMembers);
-                    if (node.signature.kind === SyntaxKind.OperationSignatureDeclaration) {
-                        table.set("parameters", node.signature.parameters.symbol);
-                        table.set("returnType", node.signature.returnType.symbol);
-                    }
-                    else {
-                        const sig = resolveTypeReferenceSym(node.signature.baseOperation, undefined, {
-                            checkTemplateTypes: false,
-                        });
-                        if (sig) {
-                            visit(sig.declarations[0], sig);
-                            const sigTable = getOrCreateAugmentedSymbolTable(sig.metatypeMembers);
-                            const sigParameterSym = sigTable.get("parameters");
-                            if (sigParameterSym !== undefined) {
-                                const parametersSym = createSymbol(sigParameterSym.declarations[0], "parameters", 2 /* SymbolFlags.Model */ & 682 /* SymbolFlags.MemberContainer */);
-                                copyMembersToContainer(parametersSym, sigParameterSym.members);
-                                table.set("parameters", parametersSym);
-                                table.set("returnType", sigTable.get("returnType"));
-                            }
-                        }
-                    }
-                    break;
-                }
-            }
-            visitChildren(node, (child) => {
-                bindMetaTypes(child);
-            });
-        }
-        visit(node);
-    }
     /**
      * Initializes a late bound symbol for the type. This is generally necessary when attempting to
      * access a symbol for a type that is created during the check phase.
@@ -3622,47 +3208,53 @@ export function createChecker(program) {
             return;
         switch (type.kind) {
             case "Model":
-                type.symbol = createSymbol(type.node, type.name, 2 /* SymbolFlags.Model */ | 67108864 /* SymbolFlags.LateBound */);
+                type.symbol = createSymbol(type.node, type.name, 2 /* SymbolFlags.Model */ | 4194304 /* SymbolFlags.LateBound */);
                 mutate(type.symbol).type = type;
                 break;
             case "Interface":
-                type.symbol = createSymbol(type.node, type.name, 128 /* SymbolFlags.Interface */ | 67108864 /* SymbolFlags.LateBound */);
+                type.symbol = createSymbol(type.node, type.name, 32 /* SymbolFlags.Interface */ | 4194304 /* SymbolFlags.LateBound */);
+                if (isTemplateInstance(type) && type.name === "Foo") {
+                    getSymbolLinks(type.symbol);
+                }
                 mutate(type.symbol).type = type;
                 break;
             case "Union":
                 if (!type.name)
                     return; // don't make a symbol for anonymous unions
-                type.symbol = createSymbol(type.node, type.name, 512 /* SymbolFlags.Union */ | 67108864 /* SymbolFlags.LateBound */);
+                type.symbol = createSymbol(type.node, type.name, 64 /* SymbolFlags.Union */ | 4194304 /* SymbolFlags.LateBound */);
                 mutate(type.symbol).type = type;
                 break;
         }
     }
-    function lateBindMembers(type, containerSym) {
-        let containerMembers;
+    function lateBindMembers(type) {
+        compilerAssert(type.symbol, "Type must have a symbol to late bind members");
+        const containerSym = type.symbol;
+        compilerAssert(containerSym.members, "Container symbol didn't have members at late-bind");
+        const containerMembers = resolver.getAugmentedSymbolTable(containerSym.members);
         switch (type.kind) {
             case "Model":
                 for (const prop of walkPropertiesInherited(type)) {
-                    lateBindMember(prop, 4 /* SymbolFlags.ModelProperty */);
+                    lateBindMember(prop, 262144 /* SymbolFlags.Member */ | 1048576 /* SymbolFlags.Declaration */);
                 }
                 break;
             case "Scalar":
                 for (const member of type.constructors.values()) {
-                    lateBindMember(member, 33555780 /* SymbolFlags.Member */);
+                    lateBindMember(member, 262144 /* SymbolFlags.Member */ | 1048576 /* SymbolFlags.Declaration */);
                 }
                 break;
             case "Enum":
                 for (const member of type.members.values()) {
-                    lateBindMember(member, 64 /* SymbolFlags.EnumMember */);
+                    lateBindMember(member, 262144 /* SymbolFlags.Member */ | 1048576 /* SymbolFlags.Declaration */);
                 }
                 break;
             case "Interface":
                 for (const member of type.operations.values()) {
-                    lateBindMember(member, 256 /* SymbolFlags.InterfaceMember */ | 16 /* SymbolFlags.Operation */);
+                    lateBindMember(member, 262144 /* SymbolFlags.Member */ | 8 /* SymbolFlags.Operation */ | 1048576 /* SymbolFlags.Declaration */);
                 }
                 break;
             case "Union":
                 for (const variant of type.variants.values()) {
-                    lateBindMember(variant, 1024 /* SymbolFlags.UnionVariant */);
+                    lateBindMember(variant, 262144 /* SymbolFlags.Member */ | 1048576 /* SymbolFlags.Declaration */);
                 }
                 break;
         }
@@ -3671,10 +3263,9 @@ export function createChecker(program) {
                 // don't bind anything for union expressions
                 return;
             }
-            const sym = createSymbol(member.node, member.name, kind | 67108864 /* SymbolFlags.LateBound */, containerSym);
+            const sym = createSymbol(member.node, member.name, kind | 4194304 /* SymbolFlags.LateBound */, containerSym);
             mutate(sym).type = member;
             compilerAssert(containerSym.members, "containerSym.members is undefined");
-            containerMembers ??= getOrCreateAugmentedSymbolTable(containerSym.members);
             containerMembers.set(member.name, sym);
         }
     }
@@ -3694,23 +3285,20 @@ export function createChecker(program) {
             }));
             return undefined;
         }
-        const modelSymId = getNodeSymId(model);
+        const modelSymId = getNodeSym(model);
         pendingResolutions.start(modelSymId, ResolutionKind.BaseType);
-        const target = resolveTypeReferenceSym(heritageRef, mapper);
-        if (target === undefined) {
-            return undefined;
-        }
-        if (pendingResolutions.has(getNodeSymId(target.declarations[0]), ResolutionKind.BaseType)) {
+        const target = resolver.getNodeLinks(heritageRef).resolvedSymbol;
+        if (target && pendingResolutions.has(target, ResolutionKind.BaseType)) {
             if (mapper === undefined) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "circular-base-type",
-                    format: { typeName: target.declarations[0].id.sv },
+                    format: { typeName: target.name },
                     target: target,
                 }));
             }
             return undefined;
         }
-        const heritageType = checkTypeReferenceSymbol(target, heritageRef, mapper);
+        const heritageType = getTypeForNode(heritageRef, mapper);
         pendingResolutions.finish(modelSymId, ResolutionKind.BaseType);
         if (isErrorType(heritageType)) {
             compilerAssert(program.hasError(), "Should already have reported an error.", heritageRef);
@@ -3732,7 +3320,7 @@ export function createChecker(program) {
     function checkModelIs(model, isExpr, mapper) {
         if (!isExpr)
             return undefined;
-        const modelSymId = getNodeSymId(model);
+        const modelSymId = getNodeSym(model);
         pendingResolutions.start(modelSymId, ResolutionKind.BaseType);
         let isType;
         if (isExpr.kind === SyntaxKind.ModelExpression) {
@@ -3747,21 +3335,18 @@ export function createChecker(program) {
             isType = checkArrayExpression(isExpr, mapper);
         }
         else if (isExpr.kind === SyntaxKind.TypeReference) {
-            const target = resolveTypeReferenceSym(isExpr, mapper);
-            if (target === undefined) {
-                return undefined;
-            }
-            if (pendingResolutions.has(getNodeSymId(target.declarations[0]), ResolutionKind.BaseType)) {
+            const target = resolver.getNodeLinks(isExpr).resolvedSymbol;
+            if (target && pendingResolutions.has(target, ResolutionKind.BaseType)) {
                 if (mapper === undefined) {
                     reportCheckerDiagnostic(createDiagnostic({
                         code: "circular-base-type",
-                        format: { typeName: target.declarations[0].id.sv },
+                        format: { typeName: target.name },
                         target: target,
                     }));
                 }
                 return undefined;
             }
-            isType = checkTypeReferenceSymbol(target, isExpr, mapper);
+            isType = getTypeForNode(isExpr, mapper);
         }
         else {
             reportCheckerDiagnostic(createDiagnostic({ code: "is-model", target: isExpr }));
@@ -3824,16 +3409,14 @@ export function createChecker(program) {
         if (containerNode.symbol === undefined) {
             return;
         }
-        compilerAssert(containerNode.symbol.members, `Expected container node ${SyntaxKind[containerNode.kind]} to have members.`);
-        const memberSym = getOrCreateAugmentedSymbolTable(containerNode.symbol.members).get(member.name);
+        const memberSym = getMemberSymbol(containerNode.symbol, member.name);
         if (memberSym) {
-            const links = getSymbolLinks(memberSym);
+            const links = resolver.getSymbolLinks(memberSym);
             linkMemberType(links, member, mapper);
         }
     }
     function checkModelProperty(prop, mapper) {
         const sym = getSymbolForMember(prop);
-        const symId = getSymbolId(sym);
         const links = getSymbolLinksForMember(prop);
         if (links && links.declaredType && mapper === undefined) {
             return links.declaredType;
@@ -3847,7 +3430,7 @@ export function createChecker(program) {
             type: undefined,
             decorators: [],
         });
-        if (pendingResolutions.has(symId, ResolutionKind.Type) && mapper === undefined) {
+        if (pendingResolutions.has(sym, ResolutionKind.Type) && mapper === undefined) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "circular-prop",
                 format: { propName: name },
@@ -3856,7 +3439,7 @@ export function createChecker(program) {
             type.type = errorType;
         }
         else {
-            pendingResolutions.start(symId, ResolutionKind.Type);
+            pendingResolutions.start(sym, ResolutionKind.Type);
             type.type = getTypeForNode(prop.value, mapper);
             if (prop.default) {
                 const defaultValue = checkDefaultValue(prop.default, type.type);
@@ -3880,12 +3463,12 @@ export function createChecker(program) {
             }
             finishType(type);
         }
-        pendingResolutions.finish(symId, ResolutionKind.Type);
+        pendingResolutions.finish(sym, ResolutionKind.Type);
         return type;
     }
     function createDocFromCommentDecorator(key, doc) {
         return {
-            decorator: $docFromComment,
+            decorator: docFromCommentDecorator,
             args: [
                 { value: createLiteralType(key), jsValue: key },
                 { value: createLiteralType(doc), jsValue: doc },
@@ -3930,13 +3513,10 @@ export function createChecker(program) {
     function checkDecoratorApplication(targetType, decNode, mapper) {
         const sym = resolveTypeReferenceSym(decNode.target, undefined, true);
         if (!sym) {
-            reportCheckerDiagnostic(createDiagnostic({
-                code: "unknown-decorator",
-                target: decNode,
-            }));
+            // Error should already have been reported above
             return undefined;
         }
-        if (!(sym.flags & 16384 /* SymbolFlags.Decorator */)) {
+        if (!(sym.flags & 1024 /* SymbolFlags.Decorator */)) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "invalid-decorator",
                 format: { id: sym.name },
@@ -3953,7 +3533,7 @@ export function createChecker(program) {
             }
         }
         if (symbolLinks.declaredType) {
-            compilerAssert(symbolLinks.declaredType.kind === "Decorator", "Expected to find a decorator type.");
+            compilerAssert(symbolLinks.declaredType.kind === "Decorator", `Expected to find a decorator type but got ${symbolLinks.declaredType.kind}`);
             if (!checkDecoratorTarget(targetType, symbolLinks.declaredType, decNode)) {
                 hasError = true;
             }
@@ -4162,7 +3742,7 @@ export function createChecker(program) {
         return valid;
     }
     function checkAugmentDecorators(sym, targetType, mapper) {
-        const augmentDecoratorNodes = augmentDecoratorsForSym.get(sym) ?? [];
+        const augmentDecoratorNodes = resolver.getAugmentDecoratorsForSym(sym);
         const decorators = [];
         for (const decNode of augmentDecoratorNodes) {
             const decorator = checkDecoratorApplication(targetType, decNode, mapper);
@@ -4172,10 +3752,42 @@ export function createChecker(program) {
         }
         return decorators;
     }
+    /**
+     * Check that augment decorator are targeting valid symbols.
+     */
+    function checkAugmentDecorator(node) {
+        // This will validate the target type is pointing to a valid ref.
+        resolveTypeReferenceSym(node.targetType, undefined);
+        const links = resolver.getNodeLinks(node.targetType);
+        if (links.isTemplateInstantiation) {
+            program.reportDiagnostic(createDiagnostic({
+                code: "augment-decorator-target",
+                messageId: "noInstance",
+                target: node.targetType,
+            }));
+        }
+        // If this was used to get a type this is invalid, only used for validation.
+        return errorType;
+    }
+    /**
+     * Check that using statements are targeting valid symbols.
+     */
+    function checkUsings(node) {
+        const usedSym = resolveTypeReferenceSym(node.name, undefined);
+        if (usedSym) {
+            if (~usedSym.flags & 256 /* SymbolFlags.Namespace */) {
+                reportCheckerDiagnostic(createDiagnostic({ code: "using-invalid-ref", target: node.name }));
+            }
+        }
+        // If this was used to get a type this is invalid, only used for validation.
+        return errorType;
+    }
     function checkDecorators(targetType, node, mapper) {
-        const sym = isMemberNode(node) ? (getSymbolForMember(node) ?? node.symbol) : node.symbol;
+        const sym = isMemberNode(node)
+            ? (getSymbolForMember(node) ?? node.symbol)
+            : getMergedSymbol(node.symbol);
         const decorators = [];
-        const augmentDecoratorNodes = augmentDecoratorsForSym.get(sym) ?? [];
+        const augmentDecoratorNodes = resolver.getAugmentDecoratorsForSym(sym);
         const decoratorNodes = [
             ...augmentDecoratorNodes, // the first decorator will be executed at last, so augmented decorator should be placed at first.
             ...node.decorators,
@@ -4244,13 +3856,10 @@ export function createChecker(program) {
         return type;
     }
     function checkScalarExtends(scalar, extendsRef, mapper) {
-        const symId = getNodeSymId(scalar);
+        const symId = getNodeSym(scalar);
         pendingResolutions.start(symId, ResolutionKind.BaseType);
-        const target = resolveTypeReferenceSym(extendsRef, mapper);
-        if (target === undefined) {
-            return undefined;
-        }
-        if (pendingResolutions.has(getNodeSymId(target.declarations[0]), ResolutionKind.BaseType)) {
+        const target = resolver.getNodeLinks(extendsRef).resolvedSymbol;
+        if (target && pendingResolutions.has(target, ResolutionKind.BaseType)) {
             if (mapper === undefined) {
                 reportCheckerDiagnostic(createDiagnostic({
                     code: "circular-base-type",
@@ -4260,7 +3869,7 @@ export function createChecker(program) {
             }
             return undefined;
         }
-        const extendsType = checkTypeReferenceSymbol(target, extendsRef, mapper);
+        const extendsType = getTypeForNode(extendsRef, mapper);
         pendingResolutions.finish(symId, ResolutionKind.BaseType);
         if (isErrorType(extendsType)) {
             compilerAssert(program.hasError(), "Should already have reported an error.", extendsRef);
@@ -4325,7 +3934,7 @@ export function createChecker(program) {
             return links.declaredType;
         }
         checkTemplateDeclaration(node, mapper);
-        const aliasSymId = getNodeSymId(node);
+        const aliasSymId = getNodeSym(node);
         if (pendingResolutions.has(aliasSymId, ResolutionKind.Type)) {
             if (mapper === undefined) {
                 reportCheckerDiagnostic(createDiagnostic({
@@ -4358,8 +3967,7 @@ export function createChecker(program) {
             return links.value;
         }
         const type = node.type ? getTypeForNode(node.type, undefined) : undefined;
-        const symId = getSymbolId(node.symbol);
-        if (pendingResolutions.has(symId, ResolutionKind.Value)) {
+        if (pendingResolutions.has(node.symbol, ResolutionKind.Value)) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "circular-const",
                 format: { name: node.id.sv },
@@ -4367,9 +3975,9 @@ export function createChecker(program) {
             }));
             return null;
         }
-        pendingResolutions.start(symId, ResolutionKind.Value);
+        pendingResolutions.start(node.symbol, ResolutionKind.Value);
         const value = getValueForNode(node.value, undefined, type && { kind: "assignment", type });
-        pendingResolutions.finish(symId, ResolutionKind.Value);
+        pendingResolutions.finish(node.symbol, ResolutionKind.Value);
         if (value === null || (type && !checkValueOfType(value, type, node.id))) {
             links.value = null;
             return links.value;
@@ -4493,6 +4101,8 @@ export function createChecker(program) {
         if (mapper === undefined) {
             interfaceType.namespace?.interfaces.set(interfaceType.name, interfaceType);
         }
+        lateBindMemberContainer(interfaceType);
+        lateBindMembers(interfaceType);
         return interfaceType;
     }
     function checkInterfaceMembers(node, mapper, interfaceType) {
@@ -4541,6 +4151,8 @@ export function createChecker(program) {
         if (mapper === undefined) {
             unionType.namespace?.unions.set(unionType.name, unionType);
         }
+        lateBindMemberContainer(unionType);
+        lateBindMembers(unionType);
         return unionType;
     }
     function checkUnionVariants(parentUnion, node, variants, mapper) {
@@ -4585,13 +4197,10 @@ export function createChecker(program) {
         return variantType;
     }
     function isMemberNode(node) {
-        return (node.kind === SyntaxKind.ModelProperty ||
-            node.kind === SyntaxKind.EnumMember ||
-            node.kind === SyntaxKind.OperationStatement ||
-            node.kind === SyntaxKind.UnionVariant);
+        return node.symbol && !!(node.symbol.flags & 262144 /* SymbolFlags.Member */);
     }
     function getMemberSymbol(parentSym, name) {
-        return parentSym ? getOrCreateAugmentedSymbolTable(parentSym.members).get(name) : undefined;
+        return parentSym ? resolver.getAugmentedSymbolTable(parentSym.members).get(name) : undefined;
     }
     function getSymbolForMember(node) {
         if (!node.id) {
@@ -4599,11 +4208,11 @@ export function createChecker(program) {
         }
         const name = node.id.sv;
         const parentSym = node.parent?.symbol;
-        return parentSym ? getOrCreateAugmentedSymbolTable(parentSym.members).get(name) : undefined;
+        return parentSym ? getMemberSymbol(parentSym, name) : undefined;
     }
     function getSymbolLinksForMember(node) {
         const sym = getSymbolForMember(node);
-        return sym ? (sym.declarations[0] === node ? getSymbolLinks(sym) : undefined) : undefined;
+        return sym ? (getSymNode(sym) === node ? getSymbolLinks(sym) : undefined) : undefined;
     }
     function checkEnumMember(node, mapper, parentEnum) {
         const name = node.id.sv;
@@ -4723,119 +4332,17 @@ export function createChecker(program) {
     function getLiteralType(node) {
         return createLiteralType(node.value, node);
     }
-    function mergeSymbolTable(source, target) {
-        for (const [sym, duplicates] of source.duplicates) {
-            const targetSet = target.duplicates.get(sym);
-            if (targetSet === undefined) {
-                mutate(target.duplicates).set(sym, new Set([...duplicates]));
-            }
-            else {
-                for (const duplicate of duplicates) {
-                    mutate(targetSet).add(duplicate);
-                }
-            }
-        }
-        for (const [key, sourceBinding] of source) {
-            if (sourceBinding.flags & 4096 /* SymbolFlags.Namespace */) {
-                let targetBinding = target.get(key);
-                if (!targetBinding) {
-                    targetBinding = {
-                        ...sourceBinding,
-                        declarations: [],
-                        exports: createSymbolTable(),
-                    };
-                    target.set(key, targetBinding);
-                }
-                if (targetBinding.flags & 4096 /* SymbolFlags.Namespace */) {
-                    mergedSymbols.set(sourceBinding, targetBinding);
-                    mutate(targetBinding.declarations).push(...sourceBinding.declarations);
-                    mergeSymbolTable(sourceBinding.exports, mutate(targetBinding.exports));
-                }
-                else {
-                    // this will set a duplicate error
-                    target.set(key, sourceBinding);
-                }
-            }
-            else if (sourceBinding.flags & 4194304 /* SymbolFlags.Declaration */ ||
-                sourceBinding.flags & 8388608 /* SymbolFlags.Implementation */) {
-                if (sourceBinding.flags & 16384 /* SymbolFlags.Decorator */) {
-                    mergeDeclarationOrImplementation(key, sourceBinding, target, 16384 /* SymbolFlags.Decorator */);
-                }
-                else if (sourceBinding.flags & 131072 /* SymbolFlags.Function */) {
-                    mergeDeclarationOrImplementation(key, sourceBinding, target, 131072 /* SymbolFlags.Function */);
-                }
-                else {
-                    target.set(key, sourceBinding);
-                }
-            }
-            else {
-                target.set(key, sourceBinding);
-            }
-        }
-    }
-    function mergeDeclarationOrImplementation(key, sourceBinding, target, expectTargetFlags) {
-        const targetBinding = target.get(key);
-        if (!targetBinding || !(targetBinding.flags & expectTargetFlags)) {
-            target.set(key, sourceBinding);
-            return;
-        }
-        const isSourceDeclaration = sourceBinding.flags & 4194304 /* SymbolFlags.Declaration */;
-        const isSourceImplementation = sourceBinding.flags & 8388608 /* SymbolFlags.Implementation */;
-        const isTargetDeclaration = targetBinding.flags & 4194304 /* SymbolFlags.Declaration */;
-        const isTargetImplementation = targetBinding.flags & 8388608 /* SymbolFlags.Implementation */;
-        if (isTargetDeclaration && isTargetImplementation) {
-            // If the target already has both a declration and implementation set the symbol which will mark it as duplicate
-            target.set(key, sourceBinding);
-        }
-        else if (isTargetDeclaration && isSourceImplementation) {
-            mergedSymbols.set(sourceBinding, targetBinding);
-            mutate(targetBinding).value = sourceBinding.value;
-            mutate(targetBinding).flags |= sourceBinding.flags;
-            mutate(targetBinding.declarations).push(...sourceBinding.declarations);
-        }
-        else if (isTargetImplementation && isSourceDeclaration) {
-            mergedSymbols.set(sourceBinding, targetBinding);
-            mutate(targetBinding).flags |= sourceBinding.flags;
-            mutate(targetBinding.declarations).unshift(...sourceBinding.declarations);
-        }
-        else {
-            // this will set a duplicate error
-            target.set(key, sourceBinding);
-        }
-    }
     function getMergedSymbol(sym) {
-        if (!sym)
-            return sym;
-        return mergedSymbols.get(sym) || sym;
-    }
-    function createGlobalNamespaceNode() {
-        const nsId = {
-            kind: SyntaxKind.Identifier,
-            pos: 0,
-            end: 0,
-            sv: "global",
-            symbol: undefined,
-            flags: 8 /* NodeFlags.Synthetic */,
-        };
-        const nsNode = {
-            kind: SyntaxKind.NamespaceStatement,
-            decorators: [],
-            pos: 0,
-            end: 0,
-            id: nsId,
-            symbol: undefined,
-            locals: createSymbolTable(),
-            flags: 8 /* NodeFlags.Synthetic */,
-        };
-        mutate(nsNode).symbol = createSymbol(nsNode, nsId.sv, 4096 /* SymbolFlags.Namespace */);
-        mutate(nsNode.symbol.exports).set(nsId.sv, nsNode.symbol);
-        return nsNode;
+        // if (!sym) return sym;
+        // return mergedSymbols.get(sym) || sym;
+        return resolver.getMergedSymbol(sym);
     }
     function createGlobalNamespaceType() {
-        const type = createAndFinishType({
+        const sym = resolver.symbols.global;
+        const type = createType({
             kind: "Namespace",
             name: "",
-            node: globalNamespaceNode,
+            node: getGlobalNamespaceNode(),
             models: new Map(),
             scalars: new Map(),
             operations: new Map(),
@@ -4847,8 +4354,9 @@ export function createChecker(program) {
             functionDeclarations: new Map(),
             decorators: [],
         });
-        getSymbolLinks(globalNamespaceNode.symbol).type = type;
-        return type;
+        getSymbolLinks(sym).type = type;
+        type.decorators = checkAugmentDecorators(sym, type, undefined);
+        return finishType(type);
     }
     function initializeClone(type, additionalProps) {
         let clone;
@@ -5475,7 +4983,7 @@ export function createChecker(program) {
         const ref = resolveTypeReferenceSym(node.target, undefined, true);
         if (!ref)
             throw new ProjectionError("Can't find decorator.");
-        compilerAssert(ref.flags & 16384 /* SymbolFlags.Decorator */, "should only resolve decorator symbols");
+        compilerAssert(ref.flags & 1024 /* SymbolFlags.Decorator */, "should only resolve decorator symbols");
         return createFunctionType((...args) => {
             ref.value({ program }, ...args.map(unsafe_projectionArgumentMarshalForJS));
             return voidType;
@@ -5491,15 +4999,15 @@ export function createChecker(program) {
             currentContext = currentContext.parent;
         }
         // next, resolve outside
-        const ref = resolveTypeReferenceSym(node, undefined);
+        const { finalSymbol: ref } = resolver.resolveTypeReference(node);
         if (!ref)
             throw new ProjectionError("Unknown identifier " + node.sv);
-        if (ref.flags & 16384 /* SymbolFlags.Decorator */) {
+        if (ref.flags & 1024 /* SymbolFlags.Decorator */) {
             // shouldn't ever resolve a decorator symbol here (without passing
             // true to resolveTypeReference)
             return errorType;
         }
-        else if (ref.flags & 131072 /* SymbolFlags.Function */) {
+        else if (ref.flags & 8192 /* SymbolFlags.Function */) {
             // TODO: store this in a symbol link probably?
             const t = createFunctionType((...args) => {
                 const retval = ref.value(program, ...args.map(unsafe_projectionArgumentMarshalForJS));
@@ -5566,16 +5074,6 @@ export function createChecker(program) {
     function project(target, projection, args = []) {
         return evalProjection(projection, target, args.map((x) => marshalProjectionReturn(x)));
     }
-    function memberExpressionToString(expr) {
-        let current = expr;
-        const parts = [];
-        while (current.kind === SyntaxKind.MemberExpression) {
-            parts.push(current.id.sv);
-            current = current.base;
-        }
-        parts.push(current.sv);
-        return parts.reverse().join(".");
-    }
     /**
      * Check if the source type can be assigned to the target type and emit diagnostics
      * @param source Type of a value
@@ -5641,9 +5139,6 @@ export function createChecker(program) {
         return valueExactTypes.get(value);
     }
 }
-function isAnonymous(type) {
-    return !("name" in type) || typeof type.name !== "string" || !type.name;
-}
 /**
  * Find all named models that could have been the source of the given
  * property. This includes the named parents of all property sources in a
@@ -6067,4 +5562,14 @@ function unsafe_projectionArgumentMarshalForJS(arg) {
     }
     return arg;
 }
+function printTypeReferenceNode(node) {
+    switch (node.kind) {
+        case SyntaxKind.MemberExpression:
+            return `${printTypeReferenceNode(node.base)}.${printTypeReferenceNode(node.id)}`;
+        case SyntaxKind.TypeReference:
+            return printTypeReferenceNode(node.target);
+        case SyntaxKind.Identifier:
+            return node.sv;
+    }
+}
 //# sourceMappingURL=checker.js.map