@typespec/compiler 1.15.0-dev.8 → 1.15.0

package/dist/src/core/checker.js

@@ -22,7 +22,7 @@ import { Numeric } from "./numeric.js";
 import { exprIsBareIdentifier, getFirstAncestor, getIdentifierContext, hasParseError, visitChildren, } from "./parser.js";
 import { createTypeRelationChecker } from "./type-relation-checker.js";
 import { getFullyQualifiedSymbolName, getParentTemplateNode, isArrayModelType, isErrorType, isNullType, isTemplateInstance, isType, isValue, } from "./type-utils.js";
-import { IdentifierKind, ResolutionResultFlags, SyntaxKind, } from "./types.js";
+import { IdentifierKind, ModifierFlags, ResolutionResultFlags, SymbolFlags, SyntaxKind, } from "./types.js";
 var CheckFlags;
 (function (CheckFlags) {
     /** No flags set. */
@@ -229,7 +229,7 @@ export function createChecker(program, resolver) {
     function initializeTypeSpecIntrinsics() {
         // a utility function to log strings or numbers
         mutate(typespecNamespaceBinding.exports).set("log", {
-            flags: 2048 /* SymbolFlags.Function */,
+            flags: SymbolFlags.Function,
             name: "log",
             value(p, ...strs) {
                 program.trace("log", strs.join(" "));
@@ -245,7 +245,7 @@ export function createChecker(program, resolver) {
         ];
         for (const decorator of internalDecorators) {
             if (decorator) {
-                mutate(decorator).flags |= 8388608 /* SymbolFlags.Internal */;
+                mutate(decorator).flags |= SymbolFlags.Internal;
             }
         }
         // Until we have an `unit` type for `null`
@@ -259,7 +259,7 @@ export function createChecker(program, resolver) {
         }
         const sym = typespecNamespaceBinding?.exports?.get(name);
         compilerAssert(sym, `Unexpected missing symbol to std type "${name}"`);
-        if (sym.flags & 2 /* SymbolFlags.Model */) {
+        if (sym.flags & SymbolFlags.Model) {
             checkModelStatement(CheckContext.DEFAULT, sym.declarations[0]);
         }
         else {
@@ -1013,27 +1013,27 @@ export function createChecker(program, resolver) {
         return entity;
     }
     function checkTypeOrValueReferenceSymbolWorker(ctx, sym, node, instantiateTemplates = true) {
-        if (sym.flags & 131072 /* SymbolFlags.Const */) {
+        if (sym.flags & SymbolFlags.Const) {
             return getValueForNode(sym.declarations[0], ctx.mapper);
         }
-        if (sym.flags & 512 /* SymbolFlags.Decorator */) {
+        if (sym.flags & SymbolFlags.Decorator) {
             reportCheckerDiagnostic(createDiagnostic({ code: "invalid-type-ref", messageId: "decorator", target: sym }));
             return errorType;
         }
-        if (sym.flags & 2048 /* SymbolFlags.Function */) {
+        if (sym.flags & SymbolFlags.Function) {
             return getValueForNode(sym.declarations[0], ctx);
         }
         const argumentNodes = node.kind === SyntaxKind.TypeReference ? node.arguments : [];
         const symbolLinks = getSymbolLinks(sym);
         let baseType;
-        if (sym.flags & 1048576 /* SymbolFlags.Declaration */ &&
+        if (sym.flags & SymbolFlags.Declaration &&
             sym.flags &
-                (2 /* SymbolFlags.Model */ |
-                    4 /* SymbolFlags.Scalar */ |
-                    128 /* SymbolFlags.Alias */ |
-                    32 /* SymbolFlags.Interface */ |
-                    8 /* SymbolFlags.Operation */ |
-                    64 /* SymbolFlags.Union */)) {
+                (SymbolFlags.Model |
+                    SymbolFlags.Scalar |
+                    SymbolFlags.Alias |
+                    SymbolFlags.Interface |
+                    SymbolFlags.Operation |
+                    SymbolFlags.Union)) {
             const decl = sym.declarations[0];
             if (!isTemplatedNode(decl)) {
                 // Not a templated node, and we are moving through a typeref to a new declaration.
@@ -1049,14 +1049,14 @@ export function createChecker(program, resolver) {
                         target: node,
                     }));
                 }
-                if (sym.flags & 4194304 /* SymbolFlags.LateBound */) {
+                if (sym.flags & 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 & 65536 /* SymbolFlags.Member */) {
+                else if (sym.flags & SymbolFlags.Member) {
                     baseType = checkMemberSym(innerCtx, sym);
                 }
                 else {
@@ -1089,11 +1089,11 @@ export function createChecker(program, resolver) {
                     target: node,
                 }));
             }
-            if (sym.flags & 4194304 /* SymbolFlags.LateBound */) {
+            if (sym.flags & SymbolFlags.LateBound) {
                 compilerAssert(sym.type, `Expected late bound symbol to have type`);
                 return sym.type;
             }
-            else if (sym.flags & 1024 /* SymbolFlags.TemplateParameter */) {
+            else if (sym.flags & SymbolFlags.TemplateParameter) {
                 const mapped = checkTemplateParameterDeclaration(ctx, symNode);
                 baseType = mapped;
             }
@@ -1105,7 +1105,7 @@ export function createChecker(program, resolver) {
                 baseType = symbolLinks.declaredType;
             }
             else {
-                if (sym.flags & 65536 /* SymbolFlags.Member */) {
+                if (sym.flags & SymbolFlags.Member) {
                     baseType = checkMemberSym(ctx, sym);
                 }
                 else {
@@ -1143,11 +1143,11 @@ export function createChecker(program, resolver) {
         if (symbolLinks.declaredType) {
             return symbolLinks.declaredType;
         }
-        if (sym.flags & 4194304 /* SymbolFlags.LateBound */) {
+        if (sym.flags & SymbolFlags.LateBound) {
             compilerAssert(sym.type, "Expected late bound symbol to have type");
             return sym.type;
         }
-        if (sym.flags & 65536 /* SymbolFlags.Member */) {
+        if (sym.flags & SymbolFlags.Member) {
             return checkMemberSym(ctx, sym);
         }
         else {
@@ -1162,15 +1162,15 @@ export function createChecker(program, resolver) {
      * @returns The declared type for the given node.
      */
     function checkDeclaredTypeOrIndeterminate(ctx, sym, node) {
-        const type = sym.flags & 2 /* SymbolFlags.Model */
+        const type = sym.flags & SymbolFlags.Model
             ? checkModelStatement(ctx, node)
-            : sym.flags & 4 /* SymbolFlags.Scalar */
+            : sym.flags & SymbolFlags.Scalar
                 ? checkScalar(ctx, node)
-                : sym.flags & 128 /* SymbolFlags.Alias */
+                : sym.flags & SymbolFlags.Alias
                     ? checkAlias(ctx, node)
-                    : sym.flags & 32 /* SymbolFlags.Interface */
+                    : sym.flags & SymbolFlags.Interface
                         ? checkInterface(ctx, node)
-                        : sym.flags & 8 /* SymbolFlags.Operation */
+                        : sym.flags & SymbolFlags.Operation
                             ? checkOperation(ctx, node)
                             : checkUnion(ctx, node);
         return type;
@@ -1372,7 +1372,7 @@ export function createChecker(program, resolver) {
         const namespace = getParentNamespaceType(node);
         compilerAssert(namespace, `Decorator ${node.id.sv} should have resolved a namespace or found the global namespace.`);
         const name = node.id.sv;
-        const isAuto = (node.modifierFlags & 8 /* ModifierFlags.Auto */) !== 0;
+        const isAuto = (node.modifierFlags & ModifierFlags.Auto) !== 0;
         if (isAuto && !isCompilerFeatureEnabled(program, "auto-decorators", node)) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "auto-decorator-disabled",
@@ -1733,12 +1733,21 @@ export function createChecker(program, resolver) {
         if (ctx.mapper === undefined && inInterface) {
             compilerAssert(parentInterface, "Operation in interface should already have been checked.", node.parent);
         }
+        // Enter the template declaration scope before checking the template declaration itself.
+        // `checkTemplateDeclaration` resolves template parameter defaults (e.g.
+        // `Properties extends {} = TagsUpdateModel<Resource>`), which can instantiate types and run
+        // their decorators. Those instantiations still reference the enclosing template parameters, so
+        // they must be treated as being in a template declaration (skipDecorators) to avoid running
+        // decorators with unresolved template parameters. This mirrors what `checkModelStatement` does.
+        if (ctx.mapper === undefined && node.templateParameters.length > 0) {
+            ctx = ctx.withFlags(CheckFlags.InTemplateDeclaration);
+        }
         checkTemplateDeclaration(ctx, node);
         // If we are instantating operation inside of interface
         if (isTemplatedNode(node) && ctx.mapper !== undefined && parentInterface) {
             ctx = ctx.withMapper({ ...ctx.mapper, partial: true });
         }
-        if ((ctx.mapper === undefined || ctx.mapper.partial) && node.templateParameters.length > 0) {
+        if (ctx.mapper?.partial && node.templateParameters.length > 0) {
             ctx = ctx.withFlags(CheckFlags.InTemplateDeclaration);
         }
         const namespace = getParentNamespaceType(node);
@@ -1927,7 +1936,7 @@ export function createChecker(program, resolver) {
         if (sym) {
             const relatedSource = getRelatedSymbolSource(sym);
             if (relatedSource) {
-                return sym.flags & 4194304 /* SymbolFlags.LateBound */ ? [sym, relatedSource] : [relatedSource];
+                return sym.flags & SymbolFlags.LateBound ? [sym, relatedSource] : [relatedSource];
             }
             return [sym];
         }
@@ -2227,13 +2236,13 @@ export function createChecker(program, resolver) {
             const memberExpression = identifier.parent;
             let baseType = getCompletionBaseType(memberExpression.base);
             let base = resolver.getNodeLinks(memberExpression.base).resolvedSymbol;
-            if (base && base.flags & 128 /* SymbolFlags.Alias */) {
+            if (base && base.flags & SymbolFlags.Alias) {
                 base = getAliasedSymbol(CheckContext.DEFAULT, base);
             }
             if (!baseType && base) {
                 baseType = getCompletionBaseTypeFromSymbol(base);
             }
-            if (baseType && (!base || !!(base.flags & 1024 /* SymbolFlags.TemplateParameter */))) {
+            if (baseType && (!base || !!(base.flags & SymbolFlags.TemplateParameter))) {
                 if (memberExpression.selector === "::") {
                     addMetaCompletionsForType(baseType);
                 }
@@ -2289,10 +2298,13 @@ export function createChecker(program, resolver) {
                 scope = scope.parent;
             }
             if (scope && scope.kind === SyntaxKind.TypeSpecScript) {
-                // check any blockless namespace decls
-                for (const ns of scope.inScopeNamespaces) {
-                    const mergedSymbol = getMergedSymbol(ns.symbol);
-                    addCompletions(mergedSymbol.exports);
+                // The name of a `using` declared before the file namespace resolves from the global namespace only.
+                if (!isUsingBeforeFileNamespace(identifier)) {
+                    // check any blockless namespace decls
+                    for (const ns of scope.inScopeNamespaces) {
+                        const mergedSymbol = getMergedSymbol(ns.symbol);
+                        addCompletions(mergedSymbol.exports);
+                    }
                 }
                 // check "global scope" declarations
                 addCompletions(resolver.symbols.global.exports);
@@ -2321,13 +2333,13 @@ export function createChecker(program, resolver) {
         }
         /** Resolve a completion base type from a symbol when node-based typing is unavailable. */
         function getCompletionBaseTypeFromSymbol(base) {
-            if (base.flags & 4194304 /* SymbolFlags.LateBound */) {
+            if (base.flags & SymbolFlags.LateBound) {
                 const lateBoundType = base.type;
                 return lateBoundType && isType(lateBoundType)
                     ? resolveCompletionType(lateBoundType)
                     : undefined;
             }
-            if (base.flags & 1024 /* SymbolFlags.TemplateParameter */) {
+            if (base.flags & SymbolFlags.TemplateParameter) {
                 const mapped = checkTemplateParameterDeclaration(CheckContext.DEFAULT, getSymNode(base));
                 return isType(mapped) ? resolveCompletionType(mapped) : undefined;
             }
@@ -2402,10 +2414,10 @@ export function createChecker(program, resolver) {
             }
             table = resolver.getAugmentedSymbolTable(table);
             for (const [key, sym] of table) {
-                if (sym.flags & 16384 /* SymbolFlags.DuplicateUsing */) {
+                if (sym.flags & SymbolFlags.DuplicateUsing) {
                     const duplicates = table.duplicates.get(sym);
                     for (const duplicate of duplicates) {
-                        if (duplicate.flags & 8192 /* SymbolFlags.Using */) {
+                        if (duplicate.flags & SymbolFlags.Using) {
                             const fqn = getFullyQualifiedSymbolName(duplicate.symbolSource);
                             addCompletion(fqn, duplicate);
                         }
@@ -2417,7 +2429,7 @@ export function createChecker(program, resolver) {
             }
         }
         function addCompletion(key, sym, options = {}) {
-            if (sym.symbolSource && !(sym.flags & 4194304 /* SymbolFlags.LateBound */)) {
+            if (sym.symbolSource && !(sym.flags & SymbolFlags.LateBound)) {
                 sym = sym.symbolSource;
             }
             if (!shouldAddCompletion(sym)) {
@@ -2435,21 +2447,21 @@ export function createChecker(program, resolver) {
                 case IdentifierKind.ModelExpressionProperty:
                 case IdentifierKind.ModelStatementProperty:
                 case IdentifierKind.ObjectLiteralProperty:
-                    return !!(sym.flags & 65536 /* SymbolFlags.Member */);
+                    return !!(sym.flags & SymbolFlags.Member);
                 case IdentifierKind.Decorator:
                     // Only return decorators and namespaces when completing decorator
-                    return !!(sym.flags & (512 /* SymbolFlags.Decorator */ | 256 /* SymbolFlags.Namespace */));
+                    return !!(sym.flags & (SymbolFlags.Decorator | SymbolFlags.Namespace));
                 case IdentifierKind.Function:
                     // Only return functions and namespaces when completing function calls
-                    return !!(sym.flags & (2048 /* SymbolFlags.Function */ | 256 /* SymbolFlags.Namespace */));
+                    return !!(sym.flags & (SymbolFlags.Function | SymbolFlags.Namespace));
                 case IdentifierKind.Using:
                     // Only return namespaces when completing using
-                    return !!(sym.flags & 256 /* SymbolFlags.Namespace */);
+                    return !!(sym.flags & SymbolFlags.Namespace);
                 case IdentifierKind.TypeReference:
                     // Do not return decorators when completing types
-                    return !(sym.flags & 512 /* SymbolFlags.Decorator */);
+                    return !(sym.flags & SymbolFlags.Decorator);
                 case IdentifierKind.TemplateArgument:
-                    return !!(sym.flags & 1024 /* SymbolFlags.TemplateParameter */);
+                    return !!(sym.flags & SymbolFlags.TemplateParameter);
                 default:
                     compilerAssert(false, "We should have bailed up-front on other kinds.");
             }
@@ -2522,7 +2534,7 @@ export function createChecker(program, resolver) {
                 return directTemplateAccessSym;
             }
             // when resolving a type reference based on an alias, unwrap the alias.
-            if (base.flags & 128 /* SymbolFlags.Alias */) {
+            if (base.flags & SymbolFlags.Alias) {
                 if (!options.resolveDeclarationOfTemplate && isTemplatedNode(getSymNode(base))) {
                     // This is a bare identifier reference to a templated alias, so we need to actually check this type.
                     const ty = checkTypeReferenceSymbol(ctx.withMapper(undefined), base, node.base, 
@@ -2620,7 +2632,7 @@ export function createChecker(program, resolver) {
      * @returns A concrete or late-bound symbol for the mapped access, or `undefined`.
      */
     function tryResolveMappedTemplateAccessSymbol(ctx, node, baseSym) {
-        if (!ctx.mapper || !(baseSym.flags & 1024 /* SymbolFlags.TemplateParameter */)) {
+        if (!ctx.mapper || !(baseSym.flags & SymbolFlags.TemplateParameter)) {
             return undefined;
         }
         const declared = checkTemplateParameterDeclaration(CheckContext.DEFAULT, getSymNode(baseSym));
@@ -2696,14 +2708,14 @@ export function createChecker(program, resolver) {
      * Resolve the template entity (parameter or access) that acts as the base for a member expression.
      */
     function getTemplateAccessBaseEntity(_ctx, baseNode, baseSym) {
-        if (baseSym.flags & 4194304 /* SymbolFlags.LateBound */) {
+        if (baseSym.flags & SymbolFlags.LateBound) {
             const lateBoundType = baseSym.type;
             if (lateBoundType && lateBoundType.kind === "TemplateParameterAccess") {
                 return lateBoundType;
             }
             return undefined;
         }
-        if (baseSym.flags & 1024 /* SymbolFlags.TemplateParameter */) {
+        if (baseSym.flags & SymbolFlags.TemplateParameter) {
             const baseSymbolNode = getSymNode(baseSym);
             const mapped = checkTemplateParameterDeclaration(CheckContext.DEFAULT, baseSymbolNode);
             return isType(mapped) && isTemplateAccessType(mapped) ? mapped : undefined;
@@ -2899,7 +2911,7 @@ export function createChecker(program, resolver) {
             return undefined;
         }
         let memberSymbol = getMemberSymbol(containerSymbol, memberName);
-        if (!memberSymbol?.type && containerSymbol.flags & 4194304 /* SymbolFlags.LateBound */) {
+        if (!memberSymbol?.type && containerSymbol.flags & SymbolFlags.LateBound) {
             lateBindMembers(containerType);
             memberSymbol = getMemberSymbol(containerSymbol, memberName);
         }
@@ -3021,7 +3033,7 @@ export function createChecker(program, resolver) {
             constraint,
         });
         templateAccessCacheKeys.set(type, cacheKey);
-        const symbol = createSymbol(node, node.id.sv, 4194304 /* SymbolFlags.LateBound */);
+        const symbol = createSymbol(node, node.id.sv, SymbolFlags.LateBound);
         mutate(symbol).type = type;
         if (useCache) {
             templateAccessSymbolCache.set(cacheKey, symbol);
@@ -3062,8 +3074,8 @@ export function createChecker(program, resolver) {
     function checkSymbolAccess(sourceLocation, node, symbol) {
         if (!symbol)
             return;
-        const isInternalDeclaration = (symbol.flags & (8388608 /* SymbolFlags.Internal */ | 1048576 /* SymbolFlags.Declaration */)) ===
-            (8388608 /* SymbolFlags.Internal */ | 1048576 /* SymbolFlags.Declaration */);
+        const isInternalDeclaration = (symbol.flags & (SymbolFlags.Internal | SymbolFlags.Declaration)) ===
+            (SymbolFlags.Internal | SymbolFlags.Declaration);
         if (isInternalDeclaration) {
             // The source location can access internal declaration symbols if:
             // 1. The source location is synthetic.
@@ -3115,13 +3127,13 @@ export function createChecker(program, resolver) {
         // When the member wasn't found but the container has unknown members (e.g. from
         // template spreads or `is`), force-check the container type so that late-bound
         // members become available, then retry the lookup.
-        if (node.selector === "." && base.flags & 118 /* SymbolFlags.MemberContainer */) {
+        if (node.selector === "." && base.flags & SymbolFlags.MemberContainer) {
             const resolvedMember = tryForceResolveLateBoundMember(ctx, base, node);
             if (resolvedMember) {
                 return resolvedMember;
             }
         }
-        if (base.flags & 256 /* SymbolFlags.Namespace */) {
+        if (base.flags & SymbolFlags.Namespace) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "invalid-ref",
                 messageId: "underNamespace",
@@ -3132,7 +3144,7 @@ export function createChecker(program, resolver) {
                 target: node,
             }));
         }
-        else if (base.flags & 512 /* SymbolFlags.Decorator */) {
+        else if (base.flags & SymbolFlags.Decorator) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "invalid-ref",
                 messageId: "inDecorator",
@@ -3140,7 +3152,7 @@ export function createChecker(program, resolver) {
                 target: node,
             }));
         }
-        else if (base.flags & 2048 /* SymbolFlags.Function */) {
+        else if (base.flags & SymbolFlags.Function) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "invalid-ref",
                 messageId: "node",
@@ -3148,7 +3160,7 @@ export function createChecker(program, resolver) {
                 target: node,
             }));
         }
-        else if (base.flags & 118 /* SymbolFlags.MemberContainer */) {
+        else if (base.flags & SymbolFlags.MemberContainer) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "invalid-ref",
                 messageId: node.selector === "." ? "member" : "metaProperty",
@@ -3275,17 +3287,17 @@ export function createChecker(program, resolver) {
     }
     /** Resolve the effective type used for member lookup on a base symbol. */
     function getMemberResolutionType(_ctx, base) {
-        if (base.flags & 4194304 /* SymbolFlags.LateBound */) {
+        if (base.flags & SymbolFlags.LateBound) {
             return base.type && isType(base.type) ? base.type : undefined;
         }
-        if (base.flags & 65536 /* SymbolFlags.Member */) {
+        if (base.flags & SymbolFlags.Member) {
             return base.type && isType(base.type) ? base.type : undefined;
         }
         return undefined;
     }
     /** Create a late-bound symbol carrying a precomputed type for member resolution. */
     function createLateBoundTypeSymbol(node, type) {
-        const symbol = createSymbol(node, node.id.sv, 4194304 /* SymbolFlags.LateBound */);
+        const symbol = createSymbol(node, node.id.sv, SymbolFlags.LateBound);
         mutate(symbol).type = type;
         const symbolSource = getTemplateAccessSymbolSource(type);
         if (symbolSource) {
@@ -3582,7 +3594,7 @@ export function createChecker(program, resolver) {
         if (!exports)
             return;
         for (const sym of exports.values()) {
-            if (sym.flags & 2048 /* SymbolFlags.Function */ && sym.flags & 2097152 /* SymbolFlags.Implementation */) {
+            if (sym.flags & SymbolFlags.Function && sym.flags & SymbolFlags.Implementation) {
                 const merged = getMergedSymbol(sym);
                 const hasFunctionDeclaration = merged.declarations.some((d) => d.kind === SyntaxKind.FunctionDeclarationStatement);
                 if (!hasFunctionDeclaration) {
@@ -3594,7 +3606,7 @@ export function createChecker(program, resolver) {
                 }
             }
             // Recurse into namespace symbols
-            if (sym.flags & 256 /* SymbolFlags.Namespace */ && sym.exports) {
+            if (sym.flags & SymbolFlags.Namespace && sym.exports) {
                 checkSymbolTableForOrphanedFunctions(sym.exports, sourceFile);
             }
         }
@@ -4683,22 +4695,22 @@ export function createChecker(program, resolver) {
     function lateBindMemberContainer(type) {
         const existingSymbol = type.symbol;
         if (existingSymbol &&
-            !(isTemplateInstance(type) && !(existingSymbol.flags & 4194304 /* SymbolFlags.LateBound */))) {
+            !(isTemplateInstance(type) && !(existingSymbol.flags & SymbolFlags.LateBound))) {
             return;
         }
         switch (type.kind) {
             case "Model":
-                type.symbol = createSymbol(type.node, type.name, 2 /* SymbolFlags.Model */ | 4194304 /* SymbolFlags.LateBound */);
+                type.symbol = createSymbol(type.node, type.name, SymbolFlags.Model | SymbolFlags.LateBound);
                 mutate(type.symbol).type = type;
                 break;
             case "Interface":
-                type.symbol = createSymbol(type.node, type.name, 32 /* SymbolFlags.Interface */ | 4194304 /* SymbolFlags.LateBound */);
+                type.symbol = createSymbol(type.node, type.name, SymbolFlags.Interface | SymbolFlags.LateBound);
                 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, 64 /* SymbolFlags.Union */ | 4194304 /* SymbolFlags.LateBound */);
+                type.symbol = createSymbol(type.node, type.name, SymbolFlags.Union | SymbolFlags.LateBound);
                 mutate(type.symbol).type = type;
                 break;
         }
@@ -4711,27 +4723,27 @@ export function createChecker(program, resolver) {
         switch (type.kind) {
             case "Model":
                 for (const prop of walkPropertiesInherited(type)) {
-                    lateBindMember(prop, 65536 /* SymbolFlags.Member */ | 1048576 /* SymbolFlags.Declaration */);
+                    lateBindMember(prop, SymbolFlags.Member | SymbolFlags.Declaration);
                 }
                 break;
             case "Scalar":
                 for (const member of type.constructors.values()) {
-                    lateBindMember(member, 65536 /* SymbolFlags.Member */ | 1048576 /* SymbolFlags.Declaration */);
+                    lateBindMember(member, SymbolFlags.Member | SymbolFlags.Declaration);
                 }
                 break;
             case "Enum":
                 for (const member of type.members.values()) {
-                    lateBindMember(member, 65536 /* SymbolFlags.Member */ | 1048576 /* SymbolFlags.Declaration */);
+                    lateBindMember(member, SymbolFlags.Member | SymbolFlags.Declaration);
                 }
                 break;
             case "Interface":
                 for (const member of type.operations.values()) {
-                    lateBindMember(member, 65536 /* SymbolFlags.Member */ | 8 /* SymbolFlags.Operation */ | 1048576 /* SymbolFlags.Declaration */);
+                    lateBindMember(member, SymbolFlags.Member | SymbolFlags.Operation | SymbolFlags.Declaration);
                 }
                 break;
             case "Union":
                 for (const variant of type.variants.values()) {
-                    lateBindMember(variant, 65536 /* SymbolFlags.Member */ | 1048576 /* SymbolFlags.Declaration */);
+                    lateBindMember(variant, SymbolFlags.Member | SymbolFlags.Declaration);
                 }
                 break;
         }
@@ -4740,7 +4752,7 @@ export function createChecker(program, resolver) {
                 // don't bind anything for union expressions
                 return;
             }
-            const sym = createSymbol(member.node, member.name, kind | 4194304 /* SymbolFlags.LateBound */, containerSym);
+            const sym = createSymbol(member.node, member.name, kind | SymbolFlags.LateBound, containerSym);
             mutate(sym).type = member;
             const symbolSource = getTypeSymbol(member);
             if (symbolSource) {
@@ -5029,7 +5041,7 @@ export function createChecker(program, resolver) {
         const relatedSource = getRelatedSymbolSource(sym);
         return (docFromCommentForSym.get(sym) ??
             (relatedSource && docFromCommentForSym.get(relatedSource)) ??
-            (sym.flags & 4194304 /* SymbolFlags.LateBound */ && sym.type && isType(sym.type)
+            (sym.flags & SymbolFlags.LateBound && sym.type && isType(sym.type)
                 ? getDocCommentForType(sym.type)
                 : undefined));
     }
@@ -5080,7 +5092,7 @@ export function createChecker(program, resolver) {
             // Error should already have been reported above
             return undefined;
         }
-        if (!(sym.flags & 512 /* SymbolFlags.Decorator */)) {
+        if (!(sym.flags & SymbolFlags.Decorator)) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "invalid-decorator",
                 format: { id: sym.name },
@@ -5318,19 +5330,19 @@ export function createChecker(program, resolver) {
             }));
         }
         else if (links.finalSymbol?.flags &&
-            ~links.finalSymbol.flags & 1048576 /* SymbolFlags.Declaration */ &&
-            ~links.finalSymbol.flags & 65536 /* SymbolFlags.Member */) {
+            ~links.finalSymbol.flags & SymbolFlags.Declaration &&
+            ~links.finalSymbol.flags & SymbolFlags.Member) {
             program.reportDiagnostic(createDiagnostic({
                 code: "augment-decorator-target",
-                messageId: links.finalSymbol.flags & 2 /* SymbolFlags.Model */
+                messageId: links.finalSymbol.flags & SymbolFlags.Model
                     ? "noModelExpression"
-                    : links.finalSymbol.flags & 64 /* SymbolFlags.Union */
+                    : links.finalSymbol.flags & SymbolFlags.Union
                         ? "noUnionExpression"
                         : "default",
                 target: node.targetType,
             }));
         }
-        else if (links.finalSymbol?.flags && links.finalSymbol.flags & 128 /* SymbolFlags.Alias */) {
+        else if (links.finalSymbol?.flags && links.finalSymbol.flags & SymbolFlags.Alias) {
             const aliasNode = getSymNode(links.finalSymbol);
             program.reportDiagnostic(createDiagnostic({
                 code: "augment-decorator-target",
@@ -5347,13 +5359,24 @@ export function createChecker(program, resolver) {
     function checkUsings(ctx, node) {
         const usedSym = resolveTypeReferenceSym(ctx.withMapper(undefined), node.name);
         if (usedSym) {
-            if (~usedSym.flags & 256 /* SymbolFlags.Namespace */) {
+            if (~usedSym.flags & 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;
     }
+    /**
+     * Check whether the given identifier is part of the name of a `using` statement declared at the file level,
+     * before the blockless namespace declaration.
+     */
+    function isUsingBeforeFileNamespace(identifier) {
+        let node = identifier.parent;
+        while (node?.kind === SyntaxKind.MemberExpression) {
+            node = node.parent;
+        }
+        return node?.kind === SyntaxKind.UsingStatement && node.scopeNamespace === undefined;
+    }
     function checkDecorators(ctx, targetType, node) {
         const sym = isMemberNode(node)
             ? (getSymbolForMember(node) ?? node.symbol)
@@ -5817,7 +5840,7 @@ export function createChecker(program, resolver) {
         });
     }
     function isMemberNode(node) {
-        return node.symbol && !!(node.symbol.flags & 65536 /* SymbolFlags.Member */);
+        return node.symbol && !!(node.symbol.flags & SymbolFlags.Member);
     }
     function getMemberSymbol(parentSym, name) {
         return parentSym ? resolver.getAugmentedSymbolTable(parentSym.members).get(name) : undefined;