@typespec/compiler 0.67.0-dev.8 → 0.67.0

package/dist/src/core/checker.js

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-deprecated */
 import { Realm } from "../experimental/realm.js";
 import { $ } from "../experimental/typekit/index.js";
 import { docFromCommentDecorator, getIndexer } from "../lib/intrinsic/decorators.js";
@@ -8,17 +7,15 @@ import { createSymbol, getSymNode } from "./binder.js";
 import { createChangeIdentifierCodeFix } from "./compiler-code-fixes/change-identifier.codefix.js";
 import { createModelToObjectValueCodeFix, createTupleToArrayValueCodeFix, } from "./compiler-code-fixes/convert-to-value.codefix.js";
 import { getDeprecationDetails, markDeprecated } from "./deprecation.js";
-import { ProjectionError, compilerAssert, ignoreDiagnostics } from "./diagnostics.js";
+import { compilerAssert, ignoreDiagnostics } from "./diagnostics.js";
 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, getTypeName } from "./helpers/type-name-utils.js";
-import { legacyMarshallTypeForJS, marshallTypeForJS } from "./js-marshaller.js";
+import { marshallTypeForJS } from "./js-marshaller.js";
 import { createDiagnostic } from "./messages.js";
 import { Numeric } from "./numeric.js";
 import { exprIsBareIdentifier, getFirstAncestor, getIdentifierContext, hasParseError, visitChildren, } from "./parser.js";
-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, ResolutionResultFlags, SyntaxKind, } from "./types.js";
@@ -36,14 +33,7 @@ export function createChecker(program, resolver) {
     let onCheckerDiagnostic = (x) => {
         program.reportDiagnostic(x);
     };
-    const typePrototype = {
-        get projections() {
-            return (projectionsByTypeKind.get(this.kind) || []).concat(projectionsByType.get(this) || []);
-        },
-        projectionsByName(name) {
-            return this.projections.filter((p) => p.id.sv === name);
-        },
-    };
+    const typePrototype = {};
     const globalNamespaceType = createGlobalNamespaceType();
     // Caches the deprecation test of nodes in the program
     const nodeDeprecationMap = new Map();
@@ -52,23 +42,6 @@ export function createChecker(program, resolver) {
     const neverType = createType({ kind: "Intrinsic", name: "never" });
     const unknownType = createType({ kind: "Intrinsic", name: "unknown" });
     const nullType = createType({ kind: "Intrinsic", name: "null" });
-    const projectionsByTypeKind = new Map([
-        ["Model", []],
-        ["ModelProperty", []],
-        ["Scalar", []],
-        ["Union", []],
-        ["UnionVariant", []],
-        ["Operation", []],
-        ["Interface", []],
-        ["Enum", []],
-        ["EnumMember", []],
-    ]);
-    const projectionsByType = new Map();
-    // whether we've checked this specific projection statement before
-    // and added it to the various projection maps.
-    const processedProjections = new Set();
-    // interpreter state
-    let currentProjectionDirection;
     /**
      * Set keeping track of node pending type resolution.
      * Key is the SymId of a node. It can be retrieved with getNodeSymId(node)
@@ -78,7 +51,6 @@ export function createChecker(program, resolver) {
     if (typespecNamespaceBinding) {
         initializeTypeSpecIntrinsics();
     }
-    let evalContext = undefined;
     /**
      * Tracking the template parameters used or not.
      */
@@ -92,8 +64,6 @@ export function createChecker(program, resolver) {
         cloneType,
         resolveRelatedSymbols,
         resolveCompletions,
-        evalProjection,
-        project,
         neverType,
         errorType,
         nullType,
@@ -102,7 +72,6 @@ export function createChecker(program, resolver) {
         typePrototype,
         createType,
         createAndFinishType,
-        createFunctionType,
         createLiteralType,
         finishType,
         isStdType,
@@ -116,7 +85,6 @@ export function createChecker(program, resolver) {
     };
     const relation = createTypeRelationChecker(program, checker);
     checker.isTypeAssignableTo = relation.isTypeAssignableTo;
-    const projectionMembers = createProjectionMembers(checker);
     return checker;
     function getTemplateParameterUsageMap() {
         return templateParameterUsageMap;
@@ -141,10 +109,10 @@ export function createChecker(program, resolver) {
     function initializeTypeSpecIntrinsics() {
         // a utility function to log strings or numbers
         mutate(typespecNamespaceBinding.exports).set("log", {
-            flags: 8192 /* SymbolFlags.Function */,
+            flags: 2048 /* SymbolFlags.Function */,
             name: "log",
             value(p, ...strs) {
-                program.trace("projection.log", strs.join(" "));
+                program.trace("log", strs.join(" "));
                 return voidType;
             },
             declarations: [],
@@ -276,9 +244,9 @@ export function createChecker(program, resolver) {
         else {
             entity = initial;
         }
-        if (options.legacyTupleAndModelCast && entity !== null && isType(entity)) {
-            entity = legacy_tryTypeToValueCast(entity, constraint, node);
-        }
+        // if (options.legacyTupleAndModelCast && entity !== null && isType(entity)) {
+        //   entity = legacy_tryTypeToValueCast(entity, constraint, node);
+        // }
         if (entity === null) {
             return null;
         }
@@ -339,105 +307,48 @@ export function createChecker(program, resolver) {
                 return type;
         }
     }
-    function legacy_tryTypeToValueCast(type, constraint, node) {
+    /**
+     * Try to intercept types used as values, either return null and emit a diagnostic with a codefix or return the type as is to be dealt with the normal way.
+     */
+    function interceptTypesUsedAsValue(type) {
         switch (type.kind) {
             case "Tuple":
-                return legacy_tryUsingTupleAsArrayValue(type, constraint?.type, node);
+                return interceptTupleUsedAsValue(type);
             case "Model":
-                return legacy_tryUsingModelAsObjectValue(type, constraint?.type, node);
+                return interceptModelExpressionUsedAsValue(type);
             default:
                 return type;
         }
     }
     // Legacy behavior to smooth transition to object values.
-    function legacy_tryUsingModelAsObjectValue(model, type, node) {
+    function interceptModelExpressionUsedAsValue(model) {
         if (model.node?.kind !== SyntaxKind.ModelExpression) {
             return model; // we only want to convert model expressions
         }
         reportCheckerDiagnostic(createDiagnostic({
-            code: "deprecated",
+            code: "expect-value",
             codefixes: [createModelToObjectValueCodeFix(model.node)],
-            format: {
-                message: "Using a model as a value is deprecated. Use an object value instead(with #{}).",
-            },
+            messageId: "modelExpression",
             target: model.node,
         }));
-        const value = {
-            entityKind: "Value",
-            valueKind: "ObjectValue",
-            type: type ?? model,
-            node: model.node,
-            properties: new Map(),
-        };
-        for (const prop of model.properties.values()) {
-            let propValue = getValueFromIndeterminate(prop.type, { kind: "assignment", type: prop.type }, node);
-            if (propValue !== null && isType(propValue)) {
-                propValue = legacy_tryTypeToValueCast(propValue, { kind: "assignment", type: prop.type }, node);
-            }
-            if (propValue == null) {
-                return null;
-            }
-            else if (!isValue(propValue)) {
-                return model;
-            }
-            value.properties.set(prop.name, {
-                name: prop.name,
-                value: propValue,
-                node: prop.node,
-            });
-        }
-        if (type !== undefined && !checkTypeAssignable(model, type, node)) {
-            return null;
-        }
-        return value;
+        return null;
     }
-    // Legacy behavior to smooth transition to array values.
-    function legacy_tryUsingTupleAsArrayValue(tuple, type, node) {
+    // Intercept tuple used as value and report diagnostic with a codefix
+    function interceptTupleUsedAsValue(tuple) {
         if (tuple.node.kind !== SyntaxKind.TupleExpression) {
             return tuple; // we won't convert dynamic tuples to array values
         }
         reportCheckerDiagnostic(createDiagnostic({
-            code: "deprecated",
+            code: "expect-value",
             codefixes: [createTupleToArrayValueCodeFix(tuple.node)],
-            format: {
-                message: "Using a tuple as a value is deprecated. Use an array value instead(with #[]).",
-            },
+            messageId: "tuple",
             target: tuple.node,
         }));
-        const values = [];
-        for (const [index, item] of tuple.values.entries()) {
-            const itemType = type?.kind === "Model" && isArrayModelType(program, type)
-                ? type.indexer.value
-                : type?.kind === "Tuple"
-                    ? type.values[index]
-                    : undefined;
-            let value = getValueFromIndeterminate(item, itemType && { kind: "assignment", type: itemType }, node);
-            if (value !== null && isType(value)) {
-                value = legacy_tryTypeToValueCast(value, itemType && { kind: "assignment", type: itemType }, node);
-            }
-            if (value === null) {
-                return null;
-            }
-            else if (!isValue(value)) {
-                return tuple;
-            }
-            values.push(value);
-        }
-        if (type !== undefined && !checkTypeAssignable(tuple, type, node)) {
-            return null;
-        }
-        return {
-            entityKind: "Value",
-            valueKind: "ArrayValue",
-            type: type ?? tuple,
-            node: tuple.node,
-            values,
-        };
+        return null;
     }
-    function canTryLegacyCast(target, constraint) {
-        return Boolean(constraint?.valueType &&
-            !(constraint.type &&
-                ignoreDiagnostics(relation.isTypeAssignableTo(target, constraint.type, target))));
+    /** If the constraint only expect a value we can try to intercept types passed to it and call `interceptTypeUsedAsValue` to get a better error */
+    function shouldTryInterceptTypeUsedAsValue(constraint) {
+        return Boolean(constraint?.valueType && !constraint.type);
     }
     /**
      * Gets a type or value depending on the node and current constraint.
@@ -451,8 +362,8 @@ export function createChecker(program, resolver) {
             return entity;
         }
         else if (isType(entity)) {
-            if (canTryLegacyCast(entity, constraint?.constraint)) {
-                return legacy_tryTypeToValueCast(entity, valueConstraint, node);
+            if (shouldTryInterceptTypeUsedAsValue(constraint?.constraint)) {
+                return interceptTypesUsedAsValue(entity);
             }
             else {
                 return entity;
@@ -543,8 +454,6 @@ export function createChecker(program, resolver) {
                 return checkTemplateArgument(node, mapper);
             case SyntaxKind.TemplateParameterDeclaration:
                 return checkTemplateParameterDeclaration(node, mapper);
-            case SyntaxKind.ProjectionStatement:
-                return checkProjectionDeclaration(node);
             case SyntaxKind.VoidKeyword:
                 return voidType;
             case SyntaxKind.NeverKeyword:
@@ -583,9 +492,7 @@ export function createChecker(program, resolver) {
      * Check if the given namespace is the standard library `TypeSpec` namespace.
      */
     function isTypeSpecNamespace(namespace) {
-        return (namespace.name === "TypeSpec" &&
-            (namespace.namespace === globalNamespaceType ||
-                namespace.namespace?.projectionBase === globalNamespaceType));
+        return namespace.name === "TypeSpec" && namespace.namespace === globalNamespaceType;
     }
     /**
      * Check if the given type is defined right in the TypeSpec namespace.
@@ -873,8 +780,8 @@ export function createChecker(program, resolver) {
                 const constraint = param.constraint.type?.kind === "TemplateParameter"
                     ? finalMap.get(param.constraint.type)
                     : param.constraint;
-                if (isType(type) && canTryLegacyCast(type, param.constraint)) {
-                    const converted = legacy_tryTypeToValueCast(type, { kind: "argument", type: param.constraint.valueType }, argNode);
+                if (isType(type) && shouldTryInterceptTypeUsedAsValue(param.constraint)) {
+                    const converted = interceptTypesUsedAsValue(type);
                     // If we manage to convert it means this might be convertable so we skip type checking.
                     // However we still return the original entity
                     if (converted !== type) {
@@ -934,14 +841,14 @@ export function createChecker(program, resolver) {
         return entity;
     }
     function checkTypeOrValueReferenceSymbolWorker(sym, node, mapper, instantiateTemplates = true) {
-        if (sym.flags & 524288 /* SymbolFlags.Const */) {
+        if (sym.flags & 131072 /* SymbolFlags.Const */) {
             return getValueForNode(sym.declarations[0], mapper);
         }
-        if (sym.flags & 1024 /* SymbolFlags.Decorator */) {
+        if (sym.flags & 512 /* SymbolFlags.Decorator */) {
             reportCheckerDiagnostic(createDiagnostic({ code: "invalid-type-ref", messageId: "decorator", target: sym }));
             return errorType;
         }
-        if (sym.flags & 8192 /* SymbolFlags.Function */) {
+        if (sym.flags & 2048 /* SymbolFlags.Function */) {
             reportCheckerDiagnostic(createDiagnostic({ code: "invalid-type-ref", messageId: "function", target: sym }));
             return errorType;
         }
@@ -972,7 +879,7 @@ export function createChecker(program, resolver) {
                 else if (symbolLinks.declaredType) {
                     baseType = symbolLinks.declaredType;
                 }
-                else if (sym.flags & 262144 /* SymbolFlags.Member */) {
+                else if (sym.flags & 65536 /* SymbolFlags.Member */) {
                     baseType = checkMemberSym(sym, mapper);
                 }
                 else {
@@ -1000,7 +907,7 @@ export function createChecker(program, resolver) {
                 compilerAssert(sym.type, `Expected late bound symbol to have type`);
                 return sym.type;
             }
-            else if (sym.flags & 2048 /* SymbolFlags.TemplateParameter */) {
+            else if (sym.flags & 1024 /* SymbolFlags.TemplateParameter */) {
                 const mapped = checkTemplateParameterDeclaration(symNode, mapper);
                 baseType = mapped;
             }
@@ -1012,7 +919,7 @@ export function createChecker(program, resolver) {
                 baseType = symbolLinks.declaredType;
             }
             else {
-                if (sym.flags & 262144 /* SymbolFlags.Member */) {
+                if (sym.flags & 65536 /* SymbolFlags.Member */) {
                     baseType = checkMemberSym(sym, mapper);
                 }
                 else {
@@ -1054,7 +961,7 @@ export function createChecker(program, resolver) {
             compilerAssert(sym.type, "Expected late bound symbol to have type");
             return sym.type;
         }
-        if (sym.flags & 262144 /* SymbolFlags.Member */) {
+        if (sym.flags & 65536 /* SymbolFlags.Member */) {
             return checkMemberSym(sym, mapper);
         }
         else {
@@ -1266,34 +1173,8 @@ export function createChecker(program, resolver) {
         return decoratorType;
     }
     function checkFunctionDeclaration(node, mapper) {
-        const symbol = getMergedSymbol(node.symbol);
-        const links = getSymbolLinks(symbol);
-        if (links.declaredType && mapper === undefined) {
-            // we're not instantiating this operation and we've already checked it
-            return links.declaredType;
-        }
-        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;
-        if (!(node.modifierFlags & 2 /* ModifierFlags.Extern */)) {
-            reportCheckerDiagnostic(createDiagnostic({ code: "function-extern", target: node }));
-        }
-        const implementation = symbol.value;
-        if (implementation === undefined) {
-            reportCheckerDiagnostic(createDiagnostic({ code: "missing-implementation", target: node }));
-        }
-        const functionType = createType({
-            kind: "Function",
-            name,
-            namespace,
-            node,
-            parameters: node.parameters.map((x) => checkFunctionParameter(x, mapper, true)),
-            returnType: node.returnType ? getTypeForNode(node.returnType, mapper) : unknownType,
-            implementation: implementation ?? (() => { }),
-        });
-        namespace.functionDeclarations.set(name, functionType);
-        linkType(links, functionType, mapper);
-        return functionType;
+        reportCheckerDiagnostic(createDiagnostic({ code: "function-unsupported", target: node }));
+        return errorType;
     }
     function checkFunctionParameter(node, mapper, mixed) {
         const links = getSymbolLinks(node.symbol);
@@ -2118,10 +1999,10 @@ export function createChecker(program, resolver) {
             }
             table = resolver.getAugmentedSymbolTable(table);
             for (const [key, sym] of table) {
-                if (sym.flags & 65536 /* SymbolFlags.DuplicateUsing */) {
+                if (sym.flags & 16384 /* SymbolFlags.DuplicateUsing */) {
                     const duplicates = table.duplicates.get(sym);
                     for (const duplicate of duplicates) {
-                        if (duplicate.flags & 32768 /* SymbolFlags.Using */) {
+                        if (duplicate.flags & 8192 /* SymbolFlags.Using */) {
                             const fqn = getFullyQualifiedSymbolName(duplicate.symbolSource);
                             addCompletion(fqn, duplicate);
                         }
@@ -2151,18 +2032,18 @@ export function createChecker(program, resolver) {
                 case IdentifierKind.ModelExpressionProperty:
                 case IdentifierKind.ModelStatementProperty:
                 case IdentifierKind.ObjectLiteralProperty:
-                    return !!(sym.flags & 262144 /* SymbolFlags.Member */);
+                    return !!(sym.flags & 65536 /* SymbolFlags.Member */);
                 case IdentifierKind.Decorator:
                     // Only return decorators and namespaces when completing decorator
-                    return !!(sym.flags & (1024 /* SymbolFlags.Decorator */ | 256 /* SymbolFlags.Namespace */));
+                    return !!(sym.flags & (512 /* SymbolFlags.Decorator */ | 256 /* SymbolFlags.Namespace */));
                 case IdentifierKind.Using:
                     // Only return namespaces when completing using
                     return !!(sym.flags & 256 /* SymbolFlags.Namespace */);
                 case IdentifierKind.TypeReference:
                     // Do not return functions or decorators when completing types
-                    return !(sym.flags & (8192 /* SymbolFlags.Function */ | 1024 /* SymbolFlags.Decorator */));
+                    return !(sym.flags & (2048 /* SymbolFlags.Function */ | 512 /* SymbolFlags.Decorator */));
                 case IdentifierKind.TemplateArgument:
-                    return !!(sym.flags & 2048 /* SymbolFlags.TemplateParameter */);
+                    return !!(sym.flags & 1024 /* SymbolFlags.TemplateParameter */);
                 default:
                     compilerAssert(false, "We should have bailed up-front on other kinds.");
             }
@@ -2274,7 +2155,7 @@ export function createChecker(program, resolver) {
                 target: node,
             }));
         }
-        else if (base.flags & 1024 /* SymbolFlags.Decorator */) {
+        else if (base.flags & 512 /* SymbolFlags.Decorator */) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "invalid-ref",
                 messageId: "inDecorator",
@@ -2282,7 +2163,7 @@ export function createChecker(program, resolver) {
                 target: node,
             }));
         }
-        else if (base.flags & 8192 /* SymbolFlags.Function */) {
+        else if (base.flags & 2048 /* SymbolFlags.Function */) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "invalid-ref",
                 messageId: "node",
@@ -3301,27 +3182,27 @@ export function createChecker(program, resolver) {
         switch (type.kind) {
             case "Model":
                 for (const prop of walkPropertiesInherited(type)) {
-                    lateBindMember(prop, 262144 /* SymbolFlags.Member */ | 1048576 /* SymbolFlags.Declaration */);
+                    lateBindMember(prop, 65536 /* SymbolFlags.Member */ | 1048576 /* SymbolFlags.Declaration */);
                 }
                 break;
             case "Scalar":
                 for (const member of type.constructors.values()) {
-                    lateBindMember(member, 262144 /* SymbolFlags.Member */ | 1048576 /* SymbolFlags.Declaration */);
+                    lateBindMember(member, 65536 /* SymbolFlags.Member */ | 1048576 /* SymbolFlags.Declaration */);
                 }
                 break;
             case "Enum":
                 for (const member of type.members.values()) {
-                    lateBindMember(member, 262144 /* SymbolFlags.Member */ | 1048576 /* SymbolFlags.Declaration */);
+                    lateBindMember(member, 65536 /* SymbolFlags.Member */ | 1048576 /* SymbolFlags.Declaration */);
                 }
                 break;
             case "Interface":
                 for (const member of type.operations.values()) {
-                    lateBindMember(member, 262144 /* SymbolFlags.Member */ | 8 /* SymbolFlags.Operation */ | 1048576 /* SymbolFlags.Declaration */);
+                    lateBindMember(member, 65536 /* SymbolFlags.Member */ | 8 /* SymbolFlags.Operation */ | 1048576 /* SymbolFlags.Declaration */);
                 }
                 break;
             case "Union":
                 for (const variant of type.variants.values()) {
-                    lateBindMember(variant, 262144 /* SymbolFlags.Member */ | 1048576 /* SymbolFlags.Declaration */);
+                    lateBindMember(variant, 65536 /* SymbolFlags.Member */ | 1048576 /* SymbolFlags.Declaration */);
                 }
                 break;
         }
@@ -3567,7 +3448,7 @@ export function createChecker(program, resolver) {
             // Error should already have been reported above
             return undefined;
         }
-        if (!(sym.flags & 1024 /* SymbolFlags.Decorator */)) {
+        if (!(sym.flags & 512 /* SymbolFlags.Decorator */)) {
             reportCheckerDiagnostic(createDiagnostic({
                 code: "invalid-decorator",
                 format: { id: sym.name },
@@ -3600,22 +3481,6 @@ export function createChecker(program, resolver) {
             args,
         };
     }
-    function resolveDecoratorArgMarshalling(declaredType) {
-        if (declaredType) {
-            const location = getLocationContext(program, declaredType);
-            if (location.type === "compiler") {
-                return "new";
-            }
-            else if ((location.type === "library" || location.type === "project") &&
-                location.flags?.decoratorArgMarshalling) {
-                return location.flags.decoratorArgMarshalling;
-            }
-            else {
-                return "new";
-            }
-        }
-        return "new";
-    }
     /** Check the decorator target is valid */
     function checkDecoratorTarget(targetType, declaration, decoratorNode) {
         const [targetValid] = relation.isTypeAssignableTo(targetType, declaration.target.type, decoratorNode);
@@ -3681,7 +3546,6 @@ export function createChecker(program, resolver) {
             }
         }
         const resolvedArgs = [];
-        const jsMarshalling = resolveDecoratorArgMarshalling(declaration);
         function resolveArg(argNode, perParamType) {
             const arg = getTypeOrValueForNode(argNode, mapper, {
                 kind: "argument",
@@ -3696,7 +3560,7 @@ export function createChecker(program, resolver) {
                     jsValue: resolveDecoratorArgJsValue(arg, extractValueOfConstraints({
                         kind: "argument",
                         constraint: perParamType,
-                    }), jsMarshalling),
+                    })),
                 };
             }
             else {
@@ -3765,12 +3629,10 @@ export function createChecker(program, resolver) {
     function getIndexType(type) {
         return type.kind === "Model" ? type.indexer?.value : undefined;
     }
-    function resolveDecoratorArgJsValue(value, valueConstraint, jsMarshalling) {
+    function resolveDecoratorArgJsValue(value, valueConstraint) {
         if (valueConstraint !== undefined) {
             if (isValue(value)) {
-                return jsMarshalling === "legacy"
-                    ? legacyMarshallTypeForJS(checker, value)
-                    : marshallTypeForJS(value, valueConstraint.type);
+                return marshallTypeForJS(value, valueConstraint.type);
             }
             else {
                 return value;
@@ -3819,7 +3681,7 @@ export function createChecker(program, resolver) {
         }
         else if (links.finalSymbol?.flags &&
             ~links.finalSymbol.flags & 1048576 /* SymbolFlags.Declaration */ &&
-            ~links.finalSymbol.flags & 262144 /* SymbolFlags.Member */) {
+            ~links.finalSymbol.flags & 65536 /* SymbolFlags.Member */) {
             program.reportDiagnostic(createDiagnostic({
                 code: "augment-decorator-target",
                 messageId: links.finalSymbol.flags & 2 /* SymbolFlags.Model */
@@ -4269,7 +4131,7 @@ export function createChecker(program, resolver) {
         return variantType;
     }
     function isMemberNode(node) {
-        return node.symbol && !!(node.symbol.flags & 262144 /* SymbolFlags.Member */);
+        return node.symbol && !!(node.symbol.flags & 65536 /* SymbolFlags.Member */);
     }
     function getMemberSymbol(parentSym, name) {
         return parentSym ? resolver.getAugmentedSymbolTable(parentSym.members).get(name) : undefined;
@@ -4383,8 +4245,6 @@ export function createChecker(program, resolver) {
     }
     /**
      * Given the own-properties of a type, returns a fully-initialized type.
-     * So far, that amounts to setting the prototype to typePrototype which
-     * contains the `projections` getter.
      */
     function createType(typeDef) {
         Object.setPrototypeOf(typeDef, typePrototype);
@@ -4526,10 +4386,6 @@ export function createChecker(program, resolver) {
         if (type.isFinished) {
             clone = finishType(clone);
         }
-        const projection = projectionsByType.get(type);
-        if (projection) {
-            projectionsByType.set(clone, projection);
-        }
         compilerAssert(clone.kind === type.kind, "cloneType must not change type kind");
         return clone;
     }
@@ -4557,472 +4413,6 @@ export function createChecker(program, resolver) {
         compilerAssert(clone.kind === type.kind, "cloneType must not change type kind");
         return clone;
     }
-    function checkProjectionDeclaration(node) {
-        // todo: check for duplicate projection decls on individual types
-        // right now you can declare the same projection on a specific type
-        // this could maybe go in the binder? But right now we don't know
-        // what an identifier resolves to until check time.
-        const links = getSymbolLinks(node.symbol);
-        if (processedProjections.has(node)) {
-            return links.declaredType;
-        }
-        processedProjections.add(node);
-        reportCheckerDiagnostic(createDiagnostic({
-            code: "deprecated",
-            format: { message: "Projection are deprecated and will be removed in next version" },
-            target: node,
-        }));
-        let type;
-        if (links.declaredType) {
-            type = links.declaredType;
-        }
-        else {
-            type = links.declaredType = createType({
-                kind: "Projection",
-                node: undefined,
-                nodeByKind: new Map(),
-                nodeByType: new Map(),
-            });
-        }
-        switch (node.selector.kind) {
-            case SyntaxKind.ProjectionModelSelector:
-                projectionsByTypeKind.get("Model").push(node);
-                type.nodeByKind.set("Model", node);
-                break;
-            case SyntaxKind.ProjectionModelPropertySelector:
-                projectionsByTypeKind.get("ModelProperty").push(node);
-                type.nodeByKind.set("ModelProperty", node);
-                break;
-            case SyntaxKind.ProjectionScalarSelector:
-                projectionsByTypeKind.get("Scalar").push(node);
-                type.nodeByKind.set("Scalar", node);
-                break;
-            case SyntaxKind.ProjectionOperationSelector:
-                projectionsByTypeKind.get("Operation").push(node);
-                type.nodeByKind.set("Operation", node);
-                break;
-            case SyntaxKind.ProjectionUnionSelector:
-                projectionsByTypeKind.get("Union").push(node);
-                type.nodeByKind.set("Union", node);
-                break;
-            case SyntaxKind.ProjectionUnionVariantSelector:
-                projectionsByTypeKind.get("UnionVariant").push(node);
-                type.nodeByKind.set("UnionVariant", node);
-                break;
-            case SyntaxKind.ProjectionInterfaceSelector:
-                projectionsByTypeKind.get("Interface").push(node);
-                type.nodeByKind.set("Interface", node);
-                break;
-            case SyntaxKind.ProjectionEnumSelector:
-                projectionsByTypeKind.get("Enum").push(node);
-                type.nodeByKind.set("Enum", node);
-                break;
-            case SyntaxKind.ProjectionEnumMemberSelector:
-                projectionsByTypeKind.get("EnumMember").push(node);
-                type.nodeByKind.set("EnumMember", node);
-                break;
-            default:
-                const projected = checkTypeReference(node.selector, undefined);
-                let current = projectionsByType.get(projected);
-                if (!current) {
-                    current = [];
-                    projectionsByType.set(projected, current);
-                }
-                current.push(node);
-                type.nodeByType.set(projected, node);
-                break;
-        }
-        return type;
-    }
-    function evalProjectionNode(node) {
-        switch (node.kind) {
-            case SyntaxKind.ProjectionExpressionStatement:
-                return evalProjectionExpressionStatement(node);
-            case SyntaxKind.ProjectionCallExpression:
-                return evalProjectionCallExpression(node);
-            case SyntaxKind.ProjectionMemberExpression:
-                return evalProjectionMemberExpression(node);
-            case SyntaxKind.ProjectionDecoratorReferenceExpression:
-                return evalProjectionDecoratorReference(node);
-            case SyntaxKind.Identifier:
-                return evalProjectionIdentifier(node);
-            case SyntaxKind.ProjectionLambdaExpression:
-                return evalProjectionLambdaExpression(node);
-            case SyntaxKind.StringLiteral:
-                return evalStringLiteral(node);
-            case SyntaxKind.NumericLiteral:
-                return evalNumericLiteral(node);
-            case SyntaxKind.BooleanLiteral:
-                return evalBooleanLiteral(node);
-            case SyntaxKind.ProjectionBlockExpression:
-                return evalProjectionBlockExpression(node);
-            case SyntaxKind.ProjectionArithmeticExpression:
-                return evalProjectionArithmeticExpression(node);
-            case SyntaxKind.ProjectionIfExpression:
-                return evalProjectionIfExpression(node);
-            case SyntaxKind.ProjectionEqualityExpression:
-                return evalProjectionEqualityExpression(node);
-            case SyntaxKind.ProjectionUnaryExpression:
-                return evalProjectionUnaryExpression(node);
-            case SyntaxKind.ProjectionRelationalExpression:
-                return evalProjectionRelationalExpression(node);
-            case SyntaxKind.ProjectionModelExpression:
-                return evalProjectionModelExpression(node);
-            case SyntaxKind.VoidKeyword:
-                return voidType;
-            case SyntaxKind.NeverKeyword:
-                return neverType;
-            case SyntaxKind.UnknownKeyword:
-                return unknownType;
-            case SyntaxKind.Return:
-                return evalReturnKeyword(node);
-            default:
-                compilerAssert(false, `Can't eval the node ${SyntaxKind[node.kind]}`);
-        }
-    }
-    function evalReturnKeyword(node) {
-        const value = evalProjectionNode(node.value);
-        if (value.kind === "Return") {
-            return value;
-        }
-        return {
-            kind: "Return",
-            value,
-        };
-    }
-    function evalProjectionModelExpression(node) {
-        const modelType = createType({
-            kind: "Model",
-            name: "",
-            node: node,
-            decorators: [],
-            properties: createRekeyableMap(),
-            derivedModels: [],
-            sourceModels: [],
-        });
-        for (const propNode of node.properties) {
-            if (propNode.kind === SyntaxKind.ProjectionModelProperty) {
-                const prop = evalProjectionModelProperty(propNode, modelType);
-                if (prop.kind === "Return") {
-                    return prop;
-                }
-                modelType.properties.set(prop.name, prop);
-            }
-            else {
-                const props = evalProjectionModelSpreadProperty(propNode);
-                if (!Array.isArray(props)) {
-                    // return record
-                    return props;
-                }
-                for (const newProp of props) {
-                    modelType.properties.set(newProp.name, newProp);
-                }
-            }
-        }
-        return modelType;
-    }
-    function evalProjectionModelProperty(node, model) {
-        const type = evalProjectionNode(node.value);
-        if (type.kind === "Return") {
-            return type;
-        }
-        return createType({
-            kind: "ModelProperty",
-            name: node.id.sv,
-            node: node,
-            decorators: [],
-            optional: node.optional,
-            type,
-            model,
-        });
-    }
-    function evalProjectionModelSpreadProperty(node) {
-        const target = evalProjectionNode(node.target);
-        if (target.kind === "Return") {
-            return target;
-        }
-        if (target.kind !== "Model") {
-            throw new ProjectionError(`Can only spread models`);
-        }
-        const props = [];
-        // copy each property
-        for (const prop of walkPropertiesInherited(target)) {
-            const newProp = cloneType(prop, { sourceProperty: prop });
-            props.push(newProp);
-        }
-        return props;
-    }
-    function evalProjectionRelationalExpression(node) {
-        const left = evalProjectionNode(node.left);
-        if (left.kind === "Return") {
-            return left;
-        }
-        else if (left.kind !== "Number" && left.kind !== "String") {
-            throw new ProjectionError("Can only compare numbers or strings");
-        }
-        const right = evalProjectionNode(node.right);
-        if (right.kind === "Return") {
-            return right;
-        }
-        else if (right.kind !== "Number" && right.kind !== "String") {
-            throw new ProjectionError("Can only compare numbers or strings");
-        }
-        if (left.kind !== right.kind) {
-            throw new ProjectionError("Can't compare numbers and strings");
-        }
-        switch (node.op) {
-            case "<":
-                return createLiteralType(left.value < right.value);
-            case "<=":
-                return createLiteralType(left.value <= right.value);
-            case ">":
-                return createLiteralType(left.value > right.value);
-            case ">=":
-                return createLiteralType(left.value >= right.value);
-        }
-    }
-    function evalProjectionUnaryExpression(node) {
-        const target = evalProjectionNode(node.target);
-        if (target.kind !== "Boolean") {
-            throw new ProjectionError("Can't negate a non-boolean");
-        }
-        switch (node.op) {
-            case "!":
-                return createLiteralType(!target.value);
-        }
-    }
-    function evalProjectionEqualityExpression(node) {
-        const left = evalProjectionNode(node.left);
-        if (left.kind === "Return") {
-            return left;
-        }
-        else if (left.kind !== "Number" && left.kind !== "String") {
-            throw new ProjectionError("Comparisons must be strings or numbers");
-        }
-        const right = evalProjectionNode(node.right);
-        if (right.kind === "Return") {
-            return right;
-        }
-        else if (right.kind !== "Number" && right.kind !== "String") {
-            throw new ProjectionError("Comparisons must be strings or numbers");
-        }
-        if (right.kind !== left.kind) {
-            throw new ProjectionError("Can't compare number and string");
-        }
-        switch (node.op) {
-            case "==":
-                return createLiteralType(left.value === right.value);
-            case "!=":
-                return createLiteralType(left.value !== right.value);
-        }
-    }
-    function evalProjectionIfExpression(node) {
-        let ifExpr = node;
-        while (ifExpr) {
-            const test = evalProjectionNode(ifExpr.test);
-            if (test.kind === "Return") {
-                return test;
-            }
-            if (typeIsTruthy(test)) {
-                return evalProjectionBlockExpression(ifExpr.consequent);
-            }
-            else if (ifExpr.alternate &&
-                ifExpr.alternate.kind === SyntaxKind.ProjectionBlockExpression) {
-                return evalProjectionBlockExpression(ifExpr.alternate);
-            }
-            else {
-                ifExpr = ifExpr.alternate;
-            }
-        }
-        return voidType;
-    }
-    function typeIsTruthy(t) {
-        switch (t.kind) {
-            case "Boolean":
-                return t.value;
-            case "Number":
-                return !!t.value;
-            case "String":
-                return !!t.value;
-            default:
-                return true;
-        }
-    }
-    function createEvalContext(node, parent) {
-        return {
-            node,
-            locals: new Map(),
-            parent,
-        };
-    }
-    function evalProjectionBlockExpression(node) {
-        let lastVal = voidType;
-        for (const stmt of node.statements) {
-            const stmtValue = evalProjectionNode(stmt);
-            if (stmtValue.kind === "Return") {
-                return stmtValue;
-            }
-            lastVal = stmtValue;
-        }
-        return lastVal;
-    }
-    function evalProjectionArithmeticExpression(node) {
-        const lhs = evalProjectionNode(node.left);
-        if (lhs.kind === "Return") {
-            return lhs;
-        }
-        if (lhs.kind !== "Number" && lhs.kind !== "String") {
-            throw new ProjectionError(`Operator ${node.op} can only apply to strings or numbers`);
-        }
-        const rhs = evalProjectionNode(node.right);
-        if (rhs.kind === "Return") {
-            return rhs;
-        }
-        if (rhs.kind !== "Number" && rhs.kind !== "String") {
-            throw new ProjectionError(`Operator ${node.op} can only apply to strings or numbers`);
-        }
-        if (rhs.kind !== lhs.kind) {
-            throw new ProjectionError(`Operator ${node.op}'s operands need to be the same type`);
-        }
-        if (lhs.kind === "String") {
-            return createLiteralType(lhs.value + rhs.value);
-        }
-        else {
-            return createLiteralType(lhs.value + rhs.value);
-        }
-    }
-    function evalProjection(node, target, args) {
-        if (node.direction === "<error>") {
-            throw new ProjectionError("Cannot evaluate projection with invalid direction.");
-        }
-        let topLevelProjection = false;
-        if (!currentProjectionDirection) {
-            topLevelProjection = true;
-            currentProjectionDirection = node.direction;
-        }
-        if (currentProjectionDirection === "from" && !target.projectionSource) {
-            // this model wasn't projected, so we'll just return the target
-            return target;
-        }
-        const originalContext = evalContext;
-        evalContext = createEvalContext(node);
-        for (const [i, param] of node.parameters.entries()) {
-            if (!args[i]) {
-                throw new ProjectionError("need argument for parameter " + SyntaxKind[node.parameters[i].kind]);
-            }
-            const argVal = args[i];
-            let typeVal;
-            if (typeof argVal === "number" || typeof argVal === "string" || typeof argVal === "boolean") {
-                typeVal = createLiteralType(argVal);
-            }
-            else {
-                typeVal = argVal;
-            }
-            evalContext.locals.set(param.id.sv, typeVal);
-        }
-        evalContext.locals.set("self", target);
-        let lastVal = voidType;
-        for (const item of node.body) {
-            lastVal = evalProjectionNode(item);
-            if (lastVal.kind === "Return") {
-                break;
-            }
-        }
-        if (topLevelProjection) {
-            currentProjectionDirection = undefined;
-        }
-        const selfResult = evalContext.locals.get("self");
-        evalContext = originalContext;
-        if (lastVal.kind === "Return") {
-            return lastVal.value;
-        }
-        else {
-            return selfResult;
-        }
-    }
-    function evalProjectionExpressionStatement(node) {
-        return evalProjectionNode(node.expr);
-    }
-    function evalProjectionCallExpression(node) {
-        const target = evalProjectionNode(node.target);
-        if (!target)
-            throw new ProjectionError("target undefined");
-        const args = [];
-        for (const arg of node.arguments) {
-            args.push(evalProjectionNode(arg));
-        }
-        if (target.kind !== "Function") {
-            throw new ProjectionError("Can't call non-function, got type " + target.kind);
-        }
-        return target.implementation(...args);
-    }
-    function evalProjectionMemberExpression(node) {
-        const base = evalProjectionNode(node.base);
-        if (base.kind === "Return") {
-            return base;
-        }
-        const member = node.id.sv;
-        const selector = node.selector;
-        if (selector === ".") {
-            switch (base.kind) {
-                case "Namespace":
-                    const sym = base.node.symbol.exports.get(member);
-                    if (sym) {
-                        const links = getSymbolLinks(sym);
-                        return links.declaredType || links.type || errorType;
-                    }
-                    else {
-                        throw new ProjectionError(`Namespace doesn't have member ${member}`);
-                    }
-                case "Model":
-                    const prop = base.properties.get(member);
-                    if (!prop) {
-                        throw new ProjectionError(`Model doesn't have property ${member}`);
-                    }
-                    return prop;
-                case "Enum":
-                    const enumMember = base.members.get(member);
-                    if (!enumMember) {
-                        throw new ProjectionError(`Enum doesn't have member ${member}`);
-                    }
-                    return enumMember;
-                case "Union":
-                    const variant = base.variants.get(member);
-                    if (!variant) {
-                        throw new ProjectionError(`Union doesn't have variant ${member}`);
-                    }
-                    return variant;
-                default:
-                    throw new ProjectionError(`Can't get member "${member}" of type ${base.kind} because it has no members. Did you mean to use "::" instead of "."?`);
-            }
-        }
-        switch (base.kind) {
-            case "Object":
-                return base.properties[member] || errorType;
-            default:
-                const typeOps = projectionMembers[base.kind];
-                if (!typeOps) {
-                    throw new ProjectionError(`${base.kind} doesn't have an object model member named ${member}`);
-                }
-                // any cast needed to ensure we don't get a too complex union error on the call
-                // to op further down.
-                const op = typeOps[member];
-                if (!op) {
-                    throw new ProjectionError(`${base.kind} doesn't have an object model member named ${member}`);
-                }
-                return op(base);
-        }
-    }
-    function createFunctionType(fn) {
-        const parameters = [];
-        return createType({
-            kind: "Function",
-            name: "",
-            parameters,
-            returnType: unknownType,
-            implementation: fn,
-        });
-    }
     function createLiteralType(value, node) {
         if (program.literalTypes.has(value)) {
             return program.literalTypes.get(value);
@@ -5055,101 +4445,6 @@ export function createChecker(program, resolver) {
         program.literalTypes.set(value, type);
         return type;
     }
-    function evalProjectionDecoratorReference(node) {
-        const ref = resolveTypeReferenceSym(node.target, undefined, true);
-        if (!ref)
-            throw new ProjectionError("Can't find decorator.");
-        compilerAssert(ref.flags & 1024 /* SymbolFlags.Decorator */, "should only resolve decorator symbols");
-        return createFunctionType((...args) => {
-            ref.value({ program }, ...args.map(unsafe_projectionArgumentMarshalForJS));
-            return voidType;
-        });
-    }
-    function evalProjectionIdentifier(node) {
-        // first check the eval context
-        let currentContext = evalContext;
-        while (currentContext) {
-            if (currentContext.locals.has(node.sv)) {
-                return currentContext.locals.get(node.sv);
-            }
-            currentContext = currentContext.parent;
-        }
-        // next, resolve outside
-        const { finalSymbol: ref } = resolver.resolveTypeReference(node);
-        if (!ref)
-            throw new ProjectionError("Unknown identifier " + node.sv);
-        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 & 8192 /* SymbolFlags.Function */) {
-            // TODO: store this in a symbol link probably?
-            const t = createFunctionType((...args) => {
-                const retval = ref.value(program, ...args.map(unsafe_projectionArgumentMarshalForJS));
-                return marshalProjectionReturn(retval, { functionName: node.sv });
-            });
-            return t;
-        }
-        else {
-            const links = getSymbolLinks(ref);
-            compilerAssert(links.declaredType, "Should have checked all types by now");
-            return links.declaredType;
-        }
-    }
-    function marshalProjectionReturn(value, options = {}) {
-        if (typeof value === "boolean" || typeof value === "string" || typeof value === "number") {
-            return createLiteralType(value);
-        }
-        if (typeof value === "object" && value !== null) {
-            if ("kind" in value) {
-                return value;
-            }
-            else {
-                // this could probably be more robust
-                return createType({
-                    kind: "Object",
-                    properties: value,
-                });
-            }
-        }
-        if (options.functionName) {
-            throw new ProjectionError(`Can't marshal value "${value}" returned from JS function "${options.functionName}" into typespec`);
-        }
-        else {
-            throw new ProjectionError(`Can't marshal value "${value}" into typespec`);
-        }
-    }
-    function evalProjectionLambdaExpression(node) {
-        return createFunctionType((...args) => {
-            return callLambdaExpression(node, args);
-        });
-    }
-    function callLambdaExpression(node, args) {
-        const originalContext = evalContext;
-        evalContext = createEvalContext(node, originalContext);
-        for (const [i, param] of node.parameters.entries()) {
-            evalContext.locals.set(param.id.sv, args[i]);
-        }
-        const retval = evalProjectionBlockExpression(node.body);
-        evalContext = originalContext;
-        if (retval.kind === "Return") {
-            return retval.value;
-        }
-        return retval;
-    }
-    function evalStringLiteral(node) {
-        return createLiteralType(node.value, node);
-    }
-    function evalNumericLiteral(node) {
-        return createLiteralType(node.value, node);
-    }
-    function evalBooleanLiteral(node) {
-        return createLiteralType(node.value, node);
-    }
-    function project(target, projection, args = []) {
-        return evalProjection(projection, target, args.map((x) => marshalProjectionReturn(x)));
-    }
     /**
      * Check if the source type can be assigned to the target type and emit diagnostics
      * @param source Type of a value
@@ -5196,7 +4491,6 @@ export function createChecker(program, resolver) {
         return related;
     }
     function isStdType(type, stdType) {
-        type = type.projectionBase ?? type;
         if ((type.kind !== "Model" && type.kind !== "Scalar") ||
             type.namespace === undefined ||
             !isTypeSpecNamespace(type.namespace))
@@ -5624,21 +4918,6 @@ const defaultSymbolResolutionOptions = {
     resolveDecorators: false,
     checkTemplateTypes: true,
 };
-/**
- * Convert LEGACY for projection.
- * THIS IS BROKEN. Some decorators will not receive the correct type.
- * It has been broken since the introduction of valueof.
- * As projection as put on hold as long as versioning works we are in a good state.
- */
-function unsafe_projectionArgumentMarshalForJS(arg) {
-    if (arg.kind === "Boolean" || arg.kind === "String" || arg.kind === "Number") {
-        return arg.value;
-    }
-    else if (arg.kind === "StringTemplate") {
-        return arg.stringValue;
-    }
-    return arg;
-}
 function printTypeReferenceNode(node) {
     switch (node.kind) {
         case SyntaxKind.MemberExpression: