tsc-ts 0.0.10 → 0.1.1

package/dist/api/compiler/checker-symbol-types.js

@@ -28,14 +28,22 @@ import { getTypeWithFacts, hasTypeFacts, getNonNullableType } from './checker-fl
 import { getTypeOfModuleExportsSymbol, getWidenedTypeForAssignmentDeclaration } from './checker-javascript.js';
 import { copyDeclarations, declarationAt, declarationCount, getDeclarations, getSymbolId, } from './symbol.js';
 export function getTypeOfSymbol(c, symbol) {
+    // TSC_TS_SHARE: checker threads share the value types of variables and properties (shared-results.ts).
+    if (c.threadSharing !== undefined && isSharedValueSymbol(symbol)) {
+        const sharing = c.threadSharing;
+        if (sharing.computing === symbol)
+            sharing.computing = undefined;
+        else
+            return threadTypeOfSymbol(c, symbol);
+    }
     const checkFlags = symbol.checkFlags;
-    if ((checkFlags & 65536 /* CheckFlags.DeferredType */) !== 0)
+    if ((checkFlags & 524288 /* CheckFlags.DeferredType */) !== 0)
         return getTypeOfSymbolWithDeferredType(c, symbol);
     if ((checkFlags & 1 /* CheckFlags.Instantiated */) !== 0)
         return getTypeOfInstantiatedSymbol(c, symbol);
-    if ((checkFlags & 262144 /* CheckFlags.Mapped */) !== 0)
+    if ((checkFlags & 2097152 /* CheckFlags.Mapped */) !== 0)
         return getTypeOfMappedSymbol(c, symbol);
-    if ((checkFlags & 8192 /* CheckFlags.ReverseMapped */) !== 0)
+    if ((checkFlags & 65536 /* CheckFlags.ReverseMapped */) !== 0)
         return getTypeOfReverseMappedSymbol(c, symbol);
     const flags = symbol.flags;
     if ((flags & 98304 /* SymbolFlags.Accessor */) !== 0)
@@ -94,7 +102,7 @@ function getTypeOfInstantiatedSymbol(c, symbol) {
 }
 export function getWriteTypeOfSymbol(c, symbol) {
     if ((symbol.checkFlags & 2 /* CheckFlags.SyntheticProperty */) !== 0) {
-        if ((symbol.checkFlags & 65536 /* CheckFlags.DeferredType */) !== 0)
+        if ((symbol.checkFlags & 524288 /* CheckFlags.DeferredType */) !== 0)
             return getWriteTypeOfSymbolWithDeferredType(c, symbol);
         const id = getSymbolId(symbol);
         return c.symbolLinkTable.get(id)?.writeType ?? c.symbolTypes.get(id) ?? getTypeOfSymbol(c, symbol);
@@ -129,9 +137,9 @@ function isParameterOfContextSensitiveSignature(c, symbol) {
     let decl = symbol.valueDeclaration;
     if (decl === undefined)
         return false;
-    if (decl.kind === 209 /* SyntaxKind.BindingElement */)
+    if (decl.kind === 210 /* SyntaxKind.BindingElement */)
         decl = getRootDeclaration(decl);
-    return decl.kind === 170 /* SyntaxKind.Parameter */ && isContextSensitiveFunctionLikeLazy(c, decl.parent);
+    return decl.kind === 171 /* SyntaxKind.Parameter */ && isContextSensitiveFunctionLikeLazy(c, decl.parent);
 }
 import { isContextSensitiveFunctionOrObjectLiteralMethod as isContextSensitiveFunctionLikeLazy } from './checker-expressions.js';
 function getTypeOfVariableOrParameterOrPropertyWorker(c, symbol) {
@@ -143,7 +151,7 @@ function getTypeOfVariableOrParameterOrPropertyWorker(c, symbol) {
     if (declaration === undefined)
         return c.errorType;
     // The `export=` symbol of a JSON file has the type of its value.
-    if (declaration.kind === 307 /* SyntaxKind.SourceFile */ && isJsonSourceFile(declaration)) {
+    if (declaration.kind === 308 /* SyntaxKind.SourceFile */ && isJsonSourceFile(declaration)) {
         const statements = declaration.statements.nodes;
         if (statements.length === 0)
             return c.emptyObjectType;
@@ -157,28 +165,30 @@ function getTypeOfVariableOrParameterOrPropertyWorker(c, symbol) {
         return getTypeOfModuleExportsSymbol(c, symbol);
     let result;
     switch (declaration.kind) {
-        case 170 /* SyntaxKind.Parameter */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 172 /* SyntaxKind.PropertySignature */:
-        case 261 /* SyntaxKind.VariableDeclaration */:
-        case 209 /* SyntaxKind.BindingElement */:
-            result = getWidenedTypeForVariableLikeDeclaration(c, declaration, true);
+        case 171 /* SyntaxKind.Parameter */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 210 /* SyntaxKind.BindingElement */:
+            // A parameter of a context sensitive function may get another type when its context is known, so
+            // its widening errors are left to that.
+            result = getWidenedTypeForVariableLikeDeclaration(c, declaration, !isParameterOfContextSensitiveSignature(c, symbol));
             break;
-        case 303 /* SyntaxKind.PropertyAssignment */:
-        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
             // The declared symbol of an object literal member, as opposed to the checked literal's property.
-            if (declaration.kind === 303 /* SyntaxKind.PropertyAssignment */)
+            if (declaration.kind === 304 /* SyntaxKind.PropertyAssignment */)
                 result = checkPropertyAssignment(c, declaration, 0 /* CheckMode.Normal */);
-            else if (declaration.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */)
+            else if (declaration.kind === 305 /* SyntaxKind.ShorthandPropertyAssignment */)
                 result = checkShorthandPropertyAssignment(c, declaration, true, 0 /* CheckMode.Normal */);
             else
                 result = getTypeOfObjectLiteralMethod(c, declaration, 0 /* CheckMode.Normal */);
             break;
-        case 292 /* SyntaxKind.JsxAttribute */:
+        case 293 /* SyntaxKind.JsxAttribute */:
             result = checkJsxAttribute(c, declaration, 0 /* CheckMode.Normal */);
             break;
-        case 278 /* SyntaxKind.ExportAssignment */: {
+        case 279 /* SyntaxKind.ExportAssignment */: {
             const typeNode = getType(declaration);
             result =
                 typeNode !== undefined
@@ -186,11 +196,11 @@ function getTypeOfVariableOrParameterOrPropertyWorker(c, symbol) {
                     : widenTypeForVariableLikeDeclaration(c, checkExpressionCached(c, getExpression(declaration)), declaration, false);
             break;
         }
-        case 306 /* SyntaxKind.EnumMember */:
+        case 307 /* SyntaxKind.EnumMember */:
             result = getTypeOfEnumMember(c, symbol);
             break;
-        case 227 /* SyntaxKind.BinaryExpression */:
-        case 214 /* SyntaxKind.CallExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
             result = getWidenedTypeForAssignmentDeclaration(c, symbol);
             break;
         default:
@@ -212,23 +222,23 @@ export function isOptionalDeclaration(node) {
     return postfix !== undefined && postfix.kind === 57 /* SyntaxKind.QuestionToken */;
 }
 function isEmptyArrayLiteral(node) {
-    return node.kind === 210 /* SyntaxKind.ArrayLiteralExpression */ && getElements(node).nodes.length === 0;
+    return node.kind === 211 /* SyntaxKind.ArrayLiteralExpression */ && getElements(node).nodes.length === 0;
 }
 function isNullOrUndefined(node) {
     let n = node;
-    while (n.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+    while (n.kind === 219 /* SyntaxKind.ParenthesizedExpression */)
         n = getExpression(n);
     return n.kind === 105 /* SyntaxKind.NullKeyword */ || (n.kind === 79 /* SyntaxKind.Identifier */ && getText(n) === 'undefined');
 }
 function isBindingPattern(node) {
     return (node !== undefined &&
-        (node.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 208 /* SyntaxKind.ArrayBindingPattern */));
+        (node.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 209 /* SyntaxKind.ArrayBindingPattern */));
 }
 /** The declared or inferred type of a variable-like declaration; undefined when nothing can be inferred. */
 export function getTypeForVariableLikeDeclaration(c, declaration, includeOptionality, checkMode = 0 /* CheckMode.Normal */) {
-    if (declaration.kind === 261 /* SyntaxKind.VariableDeclaration */) {
+    if (declaration.kind === 262 /* SyntaxKind.VariableDeclaration */) {
         const grandParent = declaration.parent.parent;
-        if (grandParent.kind === 250 /* SyntaxKind.ForInStatement */) {
+        if (grandParent.kind === 251 /* SyntaxKind.ForInStatement */) {
             // `for (k in x)` declares k as string, or keyof T for generic x.
             let objectType = checkExpressionEx(c, getExpression(grandParent), checkMode);
             if (hasTypeFacts(c, objectType, 50331648 /* TypeFacts.IsUndefinedOrNull */))
@@ -238,14 +248,14 @@ export function getTypeForVariableLikeDeclaration(c, declaration, includeOptiona
                 ? getExtractStringType(c, indexType)
                 : c.stringType;
         }
-        if (grandParent.kind === 251 /* SyntaxKind.ForOfStatement */)
+        if (grandParent.kind === 252 /* SyntaxKind.ForOfStatement */)
             return checkRightHandSideOfForOf(c, grandParent);
     }
-    else if (declaration.kind === 209 /* SyntaxKind.BindingElement */)
+    else if (declaration.kind === 210 /* SyntaxKind.BindingElement */)
         return getTypeForBindingElement(c, declaration);
-    const isProperty = (declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+    const isProperty = (declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */ &&
         (getCombinedModifierFlags(declaration) & 512 /* ModifierFlags.Accessor */) === 0) ||
-        declaration.kind === 172 /* SyntaxKind.PropertySignature */;
+        declaration.kind === 173 /* SyntaxKind.PropertySignature */;
     const isOptional = includeOptionality && isOptionalDeclaration(declaration);
     const typeNode = getType(declaration);
     const declaredType = typeNode !== undefined ? getTypeFromTypeNode(c, typeNode) : undefined;
@@ -257,7 +267,7 @@ export function getTypeForVariableLikeDeclaration(c, declaration, includeOptiona
     if (declaredType !== undefined)
         return addOptionality(c, declaredType, isProperty, isOptional);
     if (c.noImplicitAny &&
-        declaration.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
+        declaration.kind === 262 /* SyntaxKind.VariableDeclaration */ &&
         !isBindingPattern(getName(declaration)) &&
         (getCombinedModifierFlags(declaration) & 32 /* ModifierFlags.Export */) === 0 &&
         (declaration.flags & 8388608 /* NodeFlags.Ambient */) === 0) {
@@ -269,14 +279,14 @@ export function getTypeForVariableLikeDeclaration(c, declaration, includeOptiona
         if (initializer !== undefined && isEmptyArrayLiteral(initializer))
             return c.autoArrayType;
     }
-    if (declaration.kind === 170 /* SyntaxKind.Parameter */) {
+    if (declaration.kind === 171 /* SyntaxKind.Parameter */) {
         if (getSymbol(declaration) === undefined)
             return undefined;
         const fn = declaration.parent;
         // A set accessor parameter takes the getter's type.
-        if (fn.kind === 179 /* SyntaxKind.SetAccessor */) {
+        if (fn.kind === 180 /* SyntaxKind.SetAccessor */) {
             const fnSymbol = getSymbolOfDeclaration(c, fn);
-            const getter = fnSymbol !== undefined ? getDeclarations(fnSymbol).find((d) => d.kind === 178 /* SyntaxKind.GetAccessor */) : undefined;
+            const getter = fnSymbol !== undefined ? getDeclarations(fnSymbol).find((d) => d.kind === 179 /* SyntaxKind.GetAccessor */) : undefined;
             if (getter !== undefined) {
                 const getterSignature = getSignatureFromDeclaration(c, getter);
                 // An unannotated `this` of a setter takes the getter's `this` type.
@@ -302,7 +312,7 @@ export function getTypeForVariableLikeDeclaration(c, declaration, includeOptiona
         const t = widenTypeInferredFromInitializer(c, declaration, checkDeclarationInitializer(c, declaration, checkMode));
         return addOptionality(c, t, isProperty, isOptional);
     }
-    if (c.noImplicitAny && declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */) {
+    if (c.noImplicitAny && declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */) {
         // Without an annotation or initializer, the type comes from `this` assignments in the
         // constructor or static blocks.
         const symbol = getSymbol(declaration);
@@ -318,7 +328,7 @@ export function getTypeForVariableLikeDeclaration(c, declaration, includeOptiona
         else {
             const staticBlocks = [];
             for (const member of getMembers(declaration.parent).nodes)
-                if (member.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+                if (member.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */)
                     staticBlocks.push(member);
             if (staticBlocks.length !== 0)
                 t = getFlowTypeInStaticBlocks(c, symbol, staticBlocks);
@@ -327,7 +337,7 @@ export function getTypeForVariableLikeDeclaration(c, declaration, includeOptiona
         }
         return t !== undefined ? addOptionality(c, t, true, isOptional) : undefined;
     }
-    if (declaration.kind === 292 /* SyntaxKind.JsxAttribute */)
+    if (declaration.kind === 293 /* SyntaxKind.JsxAttribute */)
         return c.trueType;
     if (isBindingPattern(getName(declaration)))
         return getTypeFromBindingPattern(c, getName(declaration), false, true);
@@ -354,7 +364,7 @@ export function getWidenedLiteralTypeForInitializer(c, declaration, t) {
     return getWidenedLiteralType(c, t);
 }
 function isDeclarationReadonly(declaration) {
-    return ((getCombinedModifierFlags(declaration) & 8 /* ModifierFlags.Readonly */) !== 0 && declaration.kind !== 170 /* SyntaxKind.Parameter */);
+    return ((getCombinedModifierFlags(declaration) & 8 /* ModifierFlags.Readonly */) !== 0 && declaration.kind !== 171 /* SyntaxKind.Parameter */);
 }
 function isGlobalSymbolConstructor(c, node) {
     const symbol = getSymbolOfDeclaration(c, node);
@@ -370,13 +380,13 @@ export function widenTypeForVariableLikeDeclaration(c, t, declaration, reportErr
             reportErrorsFromWidening(c, declaration, t, 0 /* WideningKind.Normal */);
         // A unique symbol type from another declaration widens.
         if ((t.flags & 16384 /* TypeFlags.UniqueESSymbol */) !== 0 &&
-            (declaration.kind === 209 /* SyntaxKind.BindingElement */ || getType(declaration) === undefined) &&
+            (declaration.kind === 210 /* SyntaxKind.BindingElement */ || getType(declaration) === undefined) &&
             t.symbol !== getSymbolOfDeclaration(c, declaration))
             t = c.esSymbolType;
         return getWidenedType(c, t);
     }
     // Rest parameters default to any[], others to any.
-    const isRest = declaration.kind === 170 /* SyntaxKind.Parameter */ && getDotDotDotToken(declaration) !== undefined;
+    const isRest = declaration.kind === 171 /* SyntaxKind.Parameter */ && getDotDotDotToken(declaration) !== undefined;
     const result = isRest ? c.anyArrayType : c.anyType;
     if (reportErrors && !declarationBelongsToPrivateAmbientMember(declaration))
         reportImplicitAny(c, declaration, result);
@@ -384,7 +394,7 @@ export function widenTypeForVariableLikeDeclaration(c, t, declaration, reportErr
 }
 export function declarationBelongsToPrivateAmbientMember(declaration) {
     const root = getRootDeclaration(declaration);
-    const member = root.kind === 170 /* SyntaxKind.Parameter */ ? root.parent : root;
+    const member = root.kind === 171 /* SyntaxKind.Parameter */ ? root.parent : root;
     return isPrivateWithinAmbient(member);
 }
 export function isPrivateWithinAmbient(node) {
@@ -443,7 +453,7 @@ function reportWideningErrorsInType(c, t) {
                 }
             }
             if (valueDeclaration !== undefined) {
-                c.error(valueDeclaration, 1690 /* Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type */, symbolToString(c, p), typeToString(c, getWidenedType(c, s)));
+                c.error(valueDeclaration, 1709 /* Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type */, symbolToString(c, p), typeToString(c, getWidenedType(c, s)));
                 errorReported = true;
             }
         }
@@ -458,29 +468,29 @@ export function reportImplicitAny(c, declaration, t, wideningKind = 0 /* Widenin
     const typeAsString = typeToString(c, getWidenedType(c, t));
     let message;
     switch (declaration.kind) {
-        case 227 /* SyntaxKind.BinaryExpression */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 172 /* SyntaxKind.PropertySignature */:
+        case 228 /* SyntaxKind.BinaryExpression */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
             message = c.noImplicitAny
-                ? 1680 /* Diagnostics.Member_0_implicitly_has_an_1_type */
-                : 1716 /* Diagnostics.Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage */;
+                ? 1699 /* Diagnostics.Member_0_implicitly_has_an_1_type */
+                : 1735 /* Diagnostics.Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage */;
             break;
-        case 170 /* SyntaxKind.Parameter */: {
+        case 171 /* SyntaxKind.Parameter */: {
             const isRest = getDotDotDotToken(declaration) !== undefined;
             // `(string) => void` most likely meant a parameter of type `string`.
             const name = getName(declaration);
             const parent = declaration.parent;
             if (name !== undefined &&
                 name.kind === 79 /* SyntaxKind.Identifier */ &&
-                (parent.kind === 180 /* SyntaxKind.CallSignature */ ||
-                    parent.kind === 174 /* SyntaxKind.MethodSignature */ ||
-                    parent.kind === 185 /* SyntaxKind.FunctionType */)) {
+                (parent.kind === 181 /* SyntaxKind.CallSignature */ ||
+                    parent.kind === 175 /* SyntaxKind.MethodSignature */ ||
+                    parent.kind === 186 /* SyntaxKind.FunctionType */)) {
                 const index = getParameters(parent).nodes.indexOf(declaration);
                 const text = getText(name);
                 if (index >= 0 &&
                     (isTypeNodeKind(identifierToKeywordKind(text)) ||
                         resolveName(c, declaration, text, 788968 /* SymbolFlags.Type */, undefined, true, false) !== undefined)) {
-                    c.addErrorOrSuggestion(c.noImplicitAny, createDiagnosticForNode(declaration, 1722 /* Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1 */, [
+                    c.addErrorOrSuggestion(c.noImplicitAny, createDiagnosticForNode(declaration, 1741 /* Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1 */, [
                         'arg' + index,
                         declarationNameToString(file, name) + (isRest ? '[]' : ''),
                     ]));
@@ -489,51 +499,56 @@ export function reportImplicitAny(c, declaration, t, wideningKind = 0 /* Widenin
             }
             if (isRest)
                 message = c.noImplicitAny
-                    ? 1691 /* Diagnostics.Rest_parameter_0_implicitly_has_an_any_type */
-                    : 1718 /* Diagnostics.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage */;
+                    ? 1710 /* Diagnostics.Rest_parameter_0_implicitly_has_an_any_type */
+                    : 1737 /* Diagnostics.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage */;
             else
                 message = c.noImplicitAny
-                    ? 1679 /* Diagnostics.Parameter_0_implicitly_has_an_1_type */
-                    : 1715 /* Diagnostics.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage */;
+                    ? 1698 /* Diagnostics.Parameter_0_implicitly_has_an_1_type */
+                    : 1734 /* Diagnostics.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage */;
             break;
         }
-        case 209 /* SyntaxKind.BindingElement */:
+        case 210 /* SyntaxKind.BindingElement */:
             if (!c.noImplicitAny)
                 return;
-            message = 1702 /* Diagnostics.Binding_element_0_implicitly_has_an_1_type */;
+            message = 1721 /* Diagnostics.Binding_element_0_implicitly_has_an_1_type */;
             break;
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 174 /* SyntaxKind.MethodSignature */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 175 /* SyntaxKind.MethodSignature */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             if (c.noImplicitAny && getName(declaration) === undefined) {
                 c.error(declaration, wideningKind === 3 /* WideningKind.GeneratorYield */
-                    ? 1696 /* Diagnostics.Generator_implicitly_has_yield_type_0_Consider_supplying_a_return_type_annotation */
-                    : 1683 /* Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type */, typeAsString);
+                    ? 1715 /* Diagnostics.Generator_implicitly_has_yield_type_0_Consider_supplying_a_return_type_annotation */
+                    : 1702 /* Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type */, typeAsString);
                 return;
             }
             if (c.noImplicitAny && (declaration.flags & 8 /* NodeFlags.Reparsed */) !== 0) {
-                c.error(declaration, 1684 /* Diagnostics.This_overload_implicitly_returns_the_type_0_because_it_lacks_a_return_type_annotation */, typeAsString);
+                // A JSDoc `@overload`.
+                const nameText = declarationNameToString(file, getNameOfDeclaration(declaration));
+                if (nameText !== '')
+                    c.error(declaration, 1701 /* Diagnostics.X_0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type */, nameText, typeAsString);
+                else
+                    c.error(declaration, 1703 /* Diagnostics.This_overload_implicitly_returns_the_type_0_because_it_lacks_a_return_type_annotation */, typeAsString);
                 return;
             }
             if (!c.noImplicitAny)
-                message = 1721 /* Diagnostics.X_0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage */;
+                message = 1740 /* Diagnostics.X_0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage */;
             else if (wideningKind === 3 /* WideningKind.GeneratorYield */)
-                message = 1726 /* Diagnostics.X_0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type */;
+                message = 1745 /* Diagnostics.X_0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type */;
             else
-                message = 1682 /* Diagnostics.X_0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type */;
+                message = 1701 /* Diagnostics.X_0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type */;
             break;
-        case 201 /* SyntaxKind.MappedType */:
+        case 202 /* SyntaxKind.MappedType */:
             if (c.noImplicitAny)
-                c.error(declaration, 1710 /* Diagnostics.Mapped_object_type_implicitly_has_an_any_template_type */);
+                c.error(declaration, 1729 /* Diagnostics.Mapped_object_type_implicitly_has_an_any_template_type */);
             return;
         default:
             message = c.noImplicitAny
-                ? 1678 /* Diagnostics.Variable_0_implicitly_has_an_1_type */
-                : 1714 /* Diagnostics.Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage */;
+                ? 1697 /* Diagnostics.Variable_0_implicitly_has_an_1_type */
+                : 1733 /* Diagnostics.Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage */;
     }
     const name = getNameOfDeclaration(declaration);
     c.addErrorOrSuggestion(c.noImplicitAny, createDiagnosticForNode(declaration, message, [declarationNameToString(file, name), typeAsString]));
@@ -758,7 +773,7 @@ function someReadonlyAssignmentDeclaration(c, symbol) {
 }
 /** An `Object.defineProperty` call with a value and no `writable: true`, or without a setter. */
 function isReadonlyAssignmentDeclaration(c, node) {
-    if (node.kind !== 214 /* SyntaxKind.CallExpression */)
+    if (node.kind !== 215 /* SyntaxKind.CallExpression */)
         return false;
     const args = getArguments(node);
     if (args === undefined || args.nodes.length < 3)
@@ -769,7 +784,7 @@ function isReadonlyAssignmentDeclaration(c, node) {
         if (writable === undefined)
             return true;
         const declaration = writable.valueDeclaration;
-        const writableType = declaration !== undefined && declaration.kind === 303 /* SyntaxKind.PropertyAssignment */
+        const writableType = declaration !== undefined && declaration.kind === 304 /* SyntaxKind.PropertyAssignment */
             ? checkExpression(c, getInitializer(declaration))
             : getTypeOfSymbol(c, writable);
         return writableType === c.falseType || writableType === c.regularFalseType;
@@ -782,6 +797,7 @@ import { getParameterTypeOfFullSignature } from './checker-jsdoc.js';
 import { isFunctionLikeDeclarationKind, isInJSFile } from './ast-utilities.js';
 import { isEmptyArrayLiteralType } from './relations.js';
 import { isCheckJsEnabledForFile } from './program-utilities.js';
+import { isSharedValueSymbol, threadTypeOfSymbol } from './shared-results.js';
 function getDeclarationModifierFlags(c, symbol) {
     return getDeclarationModifierFlagsFromSymbol(c, symbol, false);
 }
@@ -792,9 +808,9 @@ function getDeclarationNodeFlagsFromSymbol(symbol) {
 export function getAnnotatedAccessorTypeNode(accessor) {
     if (accessor === undefined)
         return undefined;
-    if (accessor.kind === 178 /* SyntaxKind.GetAccessor */ || accessor.kind === 173 /* SyntaxKind.PropertyDeclaration */)
+    if (accessor.kind === 179 /* SyntaxKind.GetAccessor */ || accessor.kind === 174 /* SyntaxKind.PropertyDeclaration */)
         return getType(accessor);
-    if (accessor.kind === 179 /* SyntaxKind.SetAccessor */) {
+    if (accessor.kind === 180 /* SyntaxKind.SetAccessor */) {
         const params = getParameters(accessor)?.nodes ?? [];
         if (params.length === 0)
             return undefined;
@@ -809,7 +825,7 @@ function getAnnotatedAccessorType(c, accessor) {
 /** The `accessor` property declaration of `symbol`, if any. */
 function getAutoAccessorDeclaration(symbol) {
     for (const d of getDeclarations(symbol))
-        if (d.kind === 173 /* SyntaxKind.PropertyDeclaration */ && (getCombinedModifierFlags(d) & 512 /* ModifierFlags.Accessor */) !== 0)
+        if (d.kind === 174 /* SyntaxKind.PropertyDeclaration */ && (getCombinedModifierFlags(d) & 512 /* ModifierFlags.Accessor */) !== 0)
             return d;
     return undefined;
 }
@@ -820,8 +836,8 @@ function getTypeOfAccessors(c, symbol) {
         return type;
     if (!pushTypeResolution(c, symbol, 0 /* TypeSystemPropertyName.Type */))
         return c.errorType;
-    const getter = getDeclarations(symbol).find((d) => d.kind === 178 /* SyntaxKind.GetAccessor */);
-    const setter = getDeclarations(symbol).find((d) => d.kind === 179 /* SyntaxKind.SetAccessor */);
+    const getter = getDeclarations(symbol).find((d) => d.kind === 179 /* SyntaxKind.GetAccessor */);
+    const setter = getDeclarations(symbol).find((d) => d.kind === 180 /* SyntaxKind.SetAccessor */);
     const accessor = getAutoAccessorDeclaration(symbol);
     // Getter annotation, setter annotation, accessor annotation, then getter body.
     let t = getAnnotatedAccessorType(c, getter) ?? getAnnotatedAccessorType(c, setter) ?? getAnnotatedAccessorType(c, accessor);
@@ -831,18 +847,18 @@ function getTypeOfAccessors(c, symbol) {
         t = getWidenedTypeForVariableLikeDeclaration(c, accessor, true);
     if (t === undefined) {
         if (setter !== undefined && !isPrivateWithinAmbient(setter))
-            c.addErrorOrSuggestion(c.noImplicitAny, createDiagnosticForNode(setter, 1703 /* Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation */, [symbolToString(c, symbol)]));
+            c.addErrorOrSuggestion(c.noImplicitAny, createDiagnosticForNode(setter, 1722 /* Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation */, [symbolToString(c, symbol)]));
         else if (getter !== undefined && !isPrivateWithinAmbient(getter))
-            c.addErrorOrSuggestion(c.noImplicitAny, createDiagnosticForNode(getter, 1704 /* Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation */, [symbolToString(c, symbol)]));
+            c.addErrorOrSuggestion(c.noImplicitAny, createDiagnosticForNode(getter, 1723 /* Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation */, [symbolToString(c, symbol)]));
         t = c.anyType;
     }
     if (!popTypeResolution(c)) {
         if (getAnnotatedAccessorTypeNode(getter) !== undefined)
-            c.error(getter, 662 /* Diagnostics.X_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation */, symbolToString(c, symbol));
+            c.error(getter, 669 /* Diagnostics.X_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation */, symbolToString(c, symbol));
         else if (getAnnotatedAccessorTypeNode(setter) !== undefined)
-            c.error(setter, 662 /* Diagnostics.X_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation */, symbolToString(c, symbol));
+            c.error(setter, 669 /* Diagnostics.X_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation */, symbolToString(c, symbol));
         else if (getter !== undefined && c.noImplicitAny)
-            c.error(getter, 1694 /* Diagnostics.X_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions */, symbolToString(c, symbol));
+            c.error(getter, 1713 /* Diagnostics.X_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions */, symbolToString(c, symbol));
         t = c.anyType;
     }
     let cached = c.symbolTypes.get(id);
@@ -858,11 +874,11 @@ export function getWriteTypeOfAccessors(c, symbol) {
         return links.writeType;
     if (!pushTypeResolution(c, symbol, 7 /* TypeSystemPropertyName.WriteType */))
         return c.errorType;
-    const setter = getDeclarations(symbol).find((d) => d.kind === 179 /* SyntaxKind.SetAccessor */) ?? getAutoAccessorDeclaration(symbol);
+    const setter = getDeclarations(symbol).find((d) => d.kind === 180 /* SyntaxKind.SetAccessor */) ?? getAutoAccessorDeclaration(symbol);
     let writeType = getAnnotatedAccessorType(c, setter);
     if (!popTypeResolution(c)) {
         if (getAnnotatedAccessorTypeNode(setter) !== undefined)
-            c.error(setter, 662 /* Diagnostics.X_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation */, symbolToString(c, symbol));
+            c.error(setter, 669 /* Diagnostics.X_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation */, symbolToString(c, symbol));
         writeType = c.anyType;
     }
     // Without a setter annotation, the write type is the read type.
@@ -885,7 +901,7 @@ function getTypeOfFuncClassEnumModuleWorker(c, symbol) {
         return c.anyType;
     if ((symbol.flags & 512 /* SymbolFlags.ValueModule */) !== 0 &&
         symbol.valueDeclaration !== undefined &&
-        symbol.valueDeclaration.kind === 307 /* SyntaxKind.SourceFile */) {
+        symbol.valueDeclaration.kind === 308 /* SyntaxKind.SourceFile */) {
         const resolvedModule = resolveExternalModuleSymbol(c, symbol, false);
         if (resolvedModule !== undefined && resolvedModule !== symbol)
             return getTypeOfSymbol(c, resolvedModule);
@@ -901,7 +917,7 @@ function getTypeOfFuncClassEnumModuleWorker(c, symbol) {
 }
 function isShorthandAmbientModuleSymbol(symbol) {
     const d = symbol.valueDeclaration;
-    return d !== undefined && d.kind === 268 /* SyntaxKind.ModuleDeclaration */ && getBody(d) === undefined;
+    return d !== undefined && d.kind === 269 /* SyntaxKind.ModuleDeclaration */ && getBody(d) === undefined;
 }
 export function getBaseTypeVariableOfClass(c, symbol) {
     const baseConstructorType = getBaseConstructorTypeOfClass(c, getDeclaredTypeOfClassOrInterface(c, symbol));

package/dist/api/compiler/checker-symbols.d.ts

@@ -1,4 +1,4 @@
-import { type Identifier, type Node, type PatternAmbientModule, type SourceFile, Tristate } from './ast.js';
+import { type Identifier, type Node, PatternAmbientModule, type SourceFile, Tristate } from './ast.js';
 import { getSourceFileOfNode } from './binder-utilities.js';
 import { type Diagnostic, type DiagnosticMessage } from './diagnostics.js';
 import { NameResolver } from './name-resolver.js';
@@ -28,6 +28,12 @@ export declare class CheckerNameResolver extends NameResolver {
 export declare function resolveName(c: Checker, location: Node | undefined, name: string, meaning: SymbolFlags, nameNotFoundMessage: DiagnosticMessage | undefined, isUse: boolean, excludeGlobals: boolean): Symbol | undefined;
 /** `symbols[name]` (merged) if it has `meaning`, directly or through an alias. */
 export declare function getSymbolOfMeaning(c: Checker, symbols: SymbolTable, name: string, meaning: SymbolFlags): Symbol | undefined;
+/**
+ * The name-not-found message of an identifier resolved from its own location, chosen only once the name
+ * isn't found (`onFailedToResolveSymbol`). Choosing it up front, as tsgo does, compares every resolved
+ * identifier's text with the list of names `getCannotFindNameDiagnosticForName` has messages for.
+ */
+export declare const cannotFindNameAtLocation: DiagnosticMessage;
 /** Resolves names to their closest misspelling in scope, for "Did you mean" suggestions. */
 export declare class SuggestionNameResolver extends CheckerNameResolver {
     lookup(symbols: SymbolTable, name: string, meaning: SymbolFlags): Symbol | undefined;
@@ -78,6 +84,7 @@ export declare class MergedGlobals {
     readonly ambientModuleSymbols: Symbol[];
     readonly patternAmbientModules: PatternAmbientModule[];
     readonly patternAmbientModuleAugmentations: Map<string, Symbol>;
+    readonly patternAmbientModuleAugmentationTargets: Map<string, Symbol>;
     /** Whether the global `undefined` is the checker's own (no declaration of `undefined` merged). */
     readonly ownUndefined: boolean;
     /** Ids of the symbols merged into each shared symbol. */
@@ -147,6 +154,11 @@ export declare function isReservedMemberName(name: string): boolean;
 export declare function symbolIsValue(c: Checker, symbol: Symbol): boolean;
 /** Value members other than signatures and index signatures, declared ones first, each part ordered by declaration. */
 export declare function getNamedMembers(c: Checker, members: SymbolTable | undefined, container: Symbol | undefined): Symbol[];
+/**
+ * `getNamedMembers(c, table, container)` for a table that holds `members` in this order under their names, as
+ * positions in `members`; undefined where a member is an alias (`symbolIsValue` then resolves it) or a name repeats.
+ */
+export declare function getNamedMemberPositions(c: Checker, members: Symbol[], container: Symbol | undefined): number[] | undefined;
 export declare function getFirstIdentifier(node: Node): Identifier;
 export declare function resolveEntityName(c: Checker, name: Node, meaning: SymbolFlags, ignoreErrors: boolean, dontResolveAlias: boolean, location: Node | undefined): Symbol | undefined;
 /**