tsc-ts 0.0.10 → 0.1.1

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

@@ -1,4 +1,4 @@
-import { type Node } from './ast.js';
+import { ModifierFlags, type Node } from './ast.js';
 import { type DiagnosticMessage } from './diagnostics.js';
 import type { Checker } from './checker.js';
 import { type Signature, type Type } from './checker-types.js';
@@ -25,6 +25,17 @@ export declare function getFlowTypeOfProperty(c: Checker, reference: Node, prop:
 export declare function isAutoTypedProperty(c: Checker, symbol: Symbol): boolean;
 /** The type of the property in the first base class, if it has one. */
 export declare function getTypeOfPropertyInBaseClass(c: Checker, property: Symbol): Type | undefined;
-/** Whether `new` at `node` may call a constructor, reporting private and protected ones out of reach. */
-export declare function isConstructorAccessible(c: Checker, node: Node, signature: Signature | undefined): boolean;
+/** A constructor that `node` may not call: the modifiers that forbid it, and the class that declares it. */
+export declare class ConstructorAccessibilityError {
+    readonly kind: ModifierFlags;
+    readonly declaringClass: Type;
+    constructor(kind: ModifierFlags, declaringClass: Type);
+}
+/**
+ * The first of `signatures` whose constructor `node` may not call because of the modifiers in `modifiersMask`:
+ * private and protected constructors are only callable within their class, or subclasses if protected.
+ */
+export declare function getConstructorAccessibilityError(c: Checker, node: Node, signatures: readonly Signature[], modifiersMask: ModifierFlags): ConstructorAccessibilityError | undefined;
+/** Whether `new` at `node` may call the constructors of `signatures`, reporting private and protected ones out of reach. */
+export declare function isConstructorAccessible(c: Checker, node: Node, signatures: readonly Signature[]): boolean;
 export declare function checkInterfaceDeclaration(c: Checker, node: Node): void;

package/dist/api/compiler/checker-classes.js

@@ -6,7 +6,7 @@ import { isOuterExpression } from './transformers/utilities.js';
 import { checkExternalEmitHelpers } from './checker-emit-helpers.js';
 import { Identifier, PrivateIdentifier, getType, getSymbol, ElementAccessExpression, KeywordExpression, NodeVisitor, PropertyAccessExpression, getBody, getName, getStatements, getExpression, getTypeArguments, getHeritageClauses, getMembers, getText, getTypeParameters, getInitializer, getParameters, getModifiers, } from './ast.js';
 import { declarationNameToString, findConstructorDeclaration, getContainingClass, getDeclarationOfKind, getModifierFlags, getSourceFileOfNode, hasSyntacticModifier, isClassLike, isPrivateIdentifierClassElementDeclaration, isStatic, } from './binder-utilities.js';
-import { isFunctionLike, nodeIsMissing, nodeIsPresent } from './ast-utilities.js';
+import { isFunctionLike, isInJSFile, nodeIsMissing, nodeIsPresent } from './ast-utilities.js';
 import { ScriptTarget, getEmitScriptTarget, getUseDefineForClassFields } from './options.js';
 import { hasDynamicName, hasLateBindableName } from './checker-utilities.js';
 import { everyType, getTargetType, typesOf } from './checker-type-factory.js';
@@ -17,15 +17,18 @@ import { getSymbolOfDeclaration } from './checker-symbols.js';
 import { getOptionalType, getTypeOfSymbol } from './checker-symbol-types.js';
 import { convertAutoToAny, getFlowTypeOfReference } from './checker-narrowing.js';
 import { hasTypeFacts } from './checker-flow.js';
-import { getIndexInfosOfType, getSignaturesOfType, getTypeOfPropertyOfType } from './checker-members.js';
+import { getIndexInfosOfType, getPropertiesOfType, getSignaturesOfType, getTypeOfPropertyOfType, } from './checker-members.js';
+import { isConstructorDeclaredThisProperty } from './checker-javascript.js';
 import { checkJSDocLinksOfNode, checkNodeDeferred, checkSourceElement, checkTypeNodeIfPresent, } from './checker-source-file.js';
 import { checkVariableLikeDeclaration, checkTypeParameters, checkExportsOnMergedDeclarations, } from './checker-declarations.js';
 import { checkFunctionLikeBody } from './checker-functions.js';
-import { checkJSDocFullSignature } from './checker-jsdoc.js';
+import { checkJSDocFullSignature, checkJSDocFullSignatureType } from './checker-jsdoc.js';
 import { checkComputedPropertyName } from './checker-expressions.js';
 import { checkFunctionOrConstructorSymbol, checkFunctionOrMethodSymbols } from './checker-overloads.js';
 import { checkClassHeritage, checkClassOrInterfaceForDuplicateIndexSignatures, checkInterfaceHeritage, } from './checker-heritage.js';
 import { checkDecorators, getFirstTransformableStaticClassElement } from './checker-decorators.js';
+import { getTypeOfNode } from './checker-services.js';
+import { IdentifierName } from './identifier-name.js';
 export function checkClassDeclaration(c, node) {
     checkClassLikeDeclaration(c, node);
     checkClassMembers(c, node);
@@ -52,7 +55,7 @@ function checkClassExpressionExternalHelpers(c, node) {
     if (willTransformESDecorators && classOrConstructorParameterIsDecorated(false, node)) {
         location = node;
         for (const modifier of getModifiers(node)?.nodes ?? [])
-            if (modifier.kind === 171 /* SyntaxKind.Decorator */) {
+            if (modifier.kind === 172 /* SyntaxKind.Decorator */) {
                 location = modifier;
                 break;
             }
@@ -62,10 +65,10 @@ function checkClassExpressionExternalHelpers(c, node) {
     if (location === undefined)
         return;
     checkExternalEmitHelpers(c, location, 65536 /* ExternalEmitHelpers.SetFunctionName */);
-    if ((parent.kind === 303 /* SyntaxKind.PropertyAssignment */ ||
-        parent.kind === 173 /* SyntaxKind.PropertyDeclaration */ ||
-        parent.kind === 209 /* SyntaxKind.BindingElement */) &&
-        getName(parent).kind === 168 /* SyntaxKind.ComputedPropertyName */)
+    if ((parent.kind === 304 /* SyntaxKind.PropertyAssignment */ ||
+        parent.kind === 174 /* SyntaxKind.PropertyDeclaration */ ||
+        parent.kind === 210 /* SyntaxKind.BindingElement */) &&
+        getName(parent).kind === 169 /* SyntaxKind.ComputedPropertyName */)
         checkExternalEmitHelpers(c, location, 131072 /* ExternalEmitHelpers.PropKey */);
 }
 export function checkClassLikeDeferred(c, node) {
@@ -74,11 +77,27 @@ export function checkClassLikeDeferred(c, node) {
 function checkClassMembers(c, node) {
     for (const member of getMembers(node).nodes)
         checkClassMember(c, member);
+    checkConstructorDeclaredProperties(c, node);
+}
+/**
+ * Resolves the types of a JavaScript class's properties declared by `this.x` assignments in its
+ * constructor, so the diagnostics of their initializers don't depend on which use is checked first.
+ */
+function checkConstructorDeclaredProperties(c, node) {
+    if (!isInJSFile(node))
+        return;
+    const symbol = getSymbolOfDeclaration(c, node);
+    if (symbol === undefined)
+        return;
+    for (const property of getPropertiesOfType(c, getDeclaredTypeOfSymbol(c, symbol)))
+        if (isConstructorDeclaredThisProperty(c, property) &&
+            c.symbolLinks(property).thisAssignmentLocation.parent === node)
+            getTypeOfSymbol(c, property);
 }
 function checkClassLikeDeclaration(c, node) {
     checkDecorators(c, node);
     checkCollisionsForDeclarationName(c, node, getName(node));
-    if (node.kind === 264 /* SyntaxKind.ClassDeclaration */)
+    if (node.kind === 265 /* SyntaxKind.ClassDeclaration */)
         checkExportsOnMergedDeclarations(c, node);
     const typeParameters = getTypeParameters(node);
     checkTypeParameters(c, typeParameters);
@@ -93,7 +112,7 @@ function checkClassLikeDeclaration(c, node) {
     }
     const name = getName(node);
     if (name !== undefined)
-        checkTypeNameIsReserved(c, name, 585 /* Diagnostics.Class_name_cannot_be_0 */);
+        checkTypeNameIsReserved(c, name, 592 /* Diagnostics.Class_name_cannot_be_0 */);
     const heritageClauses = getHeritageClauses(node);
     if (heritageClauses !== undefined)
         checkHeritageClauses(c, heritageClauses.nodes, true);
@@ -144,36 +163,37 @@ function checkHeritageClauses(c, clauses, isClass) {
 }
 function checkClassMember(c, member) {
     checkJSDocLinksOfNode(c, member);
-    if (member.kind === 173 /* SyntaxKind.PropertyDeclaration */ ||
-        member.kind === 175 /* SyntaxKind.MethodDeclaration */ ||
-        member.kind === 178 /* SyntaxKind.GetAccessor */ ||
-        member.kind === 179 /* SyntaxKind.SetAccessor */)
+    if (member.kind === 174 /* SyntaxKind.PropertyDeclaration */ ||
+        member.kind === 176 /* SyntaxKind.MethodDeclaration */ ||
+        member.kind === 179 /* SyntaxKind.GetAccessor */ ||
+        member.kind === 180 /* SyntaxKind.SetAccessor */)
         markPrivateIdentifierScope(c, member);
     switch (member.kind) {
-        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
             checkVariableLikeDeclaration(c, member);
             if (hasSyntacticModifier(member, 64 /* ModifierFlags.Abstract */) && getInitializer(member) !== undefined)
                 c.error(member, 216 /* Diagnostics.Property_0_cannot_have_an_initializer_because_it_is_marked_abstract */, declarationNameToString(getSourceFileOfNode(member), getName(member)));
             return;
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 177 /* SyntaxKind.Constructor */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */: {
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */: {
             checkDecorators(c, member);
             const name = getName(member);
-            if (name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+            if (name !== undefined && name.kind === 169 /* SyntaxKind.ComputedPropertyName */)
                 checkComputedPropertyName(c, name);
             const symbol = getSymbolOfDeclaration(c, member);
-            if (symbol !== undefined && member.kind !== 177 /* SyntaxKind.Constructor */)
+            if (symbol !== undefined && member.kind !== 178 /* SyntaxKind.Constructor */)
                 getTypeOfSymbol(c, symbol);
             checkFunctionLikeBody(c, member);
-            if (member.kind === 175 /* SyntaxKind.MethodDeclaration */) {
+            if (member.kind === 176 /* SyntaxKind.MethodDeclaration */) {
+                checkJSDocFullSignatureType(c, member);
                 checkJSDocFullSignature(c, member);
                 checkFunctionOrMethodSymbols(c, member);
                 if (hasSyntacticModifier(member, 64 /* ModifierFlags.Abstract */) && getBody(member) !== undefined)
                     c.error(member, 195 /* Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract */, declarationNameToString(getSourceFileOfNode(member), name));
             }
-            else if (member.kind === 177 /* SyntaxKind.Constructor */) {
+            else if (member.kind === 178 /* SyntaxKind.Constructor */) {
                 if (symbol !== undefined)
                     checkFunctionOrConstructorSymbol(c, symbol);
                 checkConstructorSuperCall(c, member);
@@ -182,10 +202,10 @@ function checkClassMember(c, member) {
                 checkAccessorDeclaration(c, member);
             return;
         }
-        case 182 /* SyntaxKind.IndexSignature */:
+        case 183 /* SyntaxKind.IndexSignature */:
             checkSignatureDeclarationTypes(c, member);
             return;
-        case 176 /* SyntaxKind.ClassStaticBlockDeclaration */: {
+        case 177 /* SyntaxKind.ClassStaticBlockDeclaration */: {
             const body = getBody(member);
             if (body !== undefined)
                 for (const s of getStatements(body).nodes)
@@ -199,20 +219,20 @@ export function checkAccessorDeclaration(c, node) {
     const name = getName(node);
     if (name.kind === 79 /* SyntaxKind.Identifier */ && getText(name) === 'constructor' && isClassLike(node.parent))
         c.error(name, 276 /* Diagnostics.Class_constructor_may_not_be_an_accessor */);
-    if (node.kind === 178 /* SyntaxKind.GetAccessor */ &&
+    if (node.kind === 179 /* SyntaxKind.GetAccessor */ &&
         (node.flags & 8388608 /* NodeFlags.Ambient */) === 0 &&
         nodeIsPresent(getBody(node)) &&
         (node.flags & 256 /* NodeFlags.HasImplicitReturn */) !== 0 &&
         (node.flags & 512 /* NodeFlags.HasExplicitReturn */) === 0)
-        c.error(name, 552 /* Diagnostics.A_get_accessor_must_return_a_value */);
+        c.error(name, 559 /* Diagnostics.A_get_accessor_must_return_a_value */);
     if (hasDynamicName(node) && !hasLateBindableName(c, node))
         return;
     // Accessors of one member must agree on accessibility and abstractness; checked once, at the getter.
     const symbol = getSymbolOfDeclaration(c, node);
     if (symbol === undefined)
         return;
-    const getter = getDeclarationOfKind(symbol, 178 /* SyntaxKind.GetAccessor */);
-    const setter = getDeclarationOfKind(symbol, 179 /* SyntaxKind.SetAccessor */);
+    const getter = getDeclarationOfKind(symbol, 179 /* SyntaxKind.GetAccessor */);
+    const setter = getDeclarationOfKind(symbol, 180 /* SyntaxKind.SetAccessor */);
     if (getter === undefined || setter === undefined)
         return;
     const links = c.nodeLinks(getter);
@@ -222,14 +242,14 @@ export function checkAccessorDeclaration(c, node) {
     const getterFlags = getModifierFlags(getter);
     const setterFlags = getModifierFlags(setter);
     if ((getterFlags & 64 /* ModifierFlags.Abstract */) !== (setterFlags & 64 /* ModifierFlags.Abstract */)) {
-        c.error(getName(getter), 810 /* Diagnostics.Accessors_must_both_be_abstract_or_non_abstract */);
-        c.error(getName(setter), 810 /* Diagnostics.Accessors_must_both_be_abstract_or_non_abstract */);
+        c.error(getName(getter), 817 /* Diagnostics.Accessors_must_both_be_abstract_or_non_abstract */);
+        c.error(getName(setter), 817 /* Diagnostics.Accessors_must_both_be_abstract_or_non_abstract */);
     }
     if (((getterFlags & 4 /* ModifierFlags.Protected */) !== 0 &&
         (setterFlags & (4 /* ModifierFlags.Protected */ | 2 /* ModifierFlags.Private */)) === 0) ||
         ((getterFlags & 2 /* ModifierFlags.Private */) !== 0 && (setterFlags & 2 /* ModifierFlags.Private */) === 0)) {
-        c.error(getName(getter), 939 /* Diagnostics.A_get_accessor_must_be_at_least_as_accessible_as_the_setter */);
-        c.error(getName(setter), 939 /* Diagnostics.A_get_accessor_must_be_at_least_as_accessible_as_the_setter */);
+        c.error(getName(getter), 946 /* Diagnostics.A_get_accessor_must_be_at_least_as_accessible_as_the_setter */);
+        c.error(getName(setter), 946 /* Diagnostics.A_get_accessor_must_be_at_least_as_accessible_as_the_setter */);
     }
 }
 /** Derived class constructors must call `super`, at the root when properties are initialized. */
@@ -250,11 +270,11 @@ function checkConstructorSuperCall(c, node) {
     const superCall = finder.superCall;
     if (superCall === undefined) {
         if (!classExtendsNull)
-            c.error(node, 551 /* Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call */);
+            c.error(node, 558 /* Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call */);
         return;
     }
     if (classExtendsNull)
-        c.error(superCall, 1808 /* Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null */);
+        c.error(superCall, 1828 /* Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null */);
     const emitStandardClassFields = getUseDefineForClassFields(c.compilerOptions) && getEmitScriptTarget(c.compilerOptions) >= ScriptTarget.ES2022;
     if (emitStandardClassFields)
         return;
@@ -262,31 +282,31 @@ function checkConstructorSuperCall(c, node) {
     if (!needsRootLevelSuperCall(classDecl, node))
         return;
     let parent = superCall.parent;
-    while (parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+    while (parent.kind === 219 /* SyntaxKind.ParenthesizedExpression */)
         parent = parent.parent;
-    if (parent.kind !== 245 /* SyntaxKind.ExpressionStatement */ || parent.parent !== body) {
-        c.error(superCall, 572 /* Diagnostics.A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_initialized_properties_parameter_properties_or_private_identifiers */);
+    if (parent.kind !== 246 /* SyntaxKind.ExpressionStatement */ || parent.parent !== body) {
+        c.error(superCall, 579 /* Diagnostics.A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_initialized_properties_parameter_properties_or_private_identifiers */);
         return;
     }
     for (const statement of getStatements(body).nodes) {
-        if (statement.kind === 245 /* SyntaxKind.ExpressionStatement */ &&
+        if (statement.kind === 246 /* SyntaxKind.ExpressionStatement */ &&
             isSuperCall(skipOuterExpressions(getExpression(statement))))
             return;
         if (nodeImmediatelyReferencesSuperOrThis(statement))
             break;
     }
-    c.error(node, 550 /* Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_to_refer_to_super_or_this_when_a_derived_class_contains_initialized_properties_parameter_properties_or_private_identifiers */);
+    c.error(node, 557 /* Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_to_refer_to_super_or_this_when_a_derived_class_contains_initialized_properties_parameter_properties_or_private_identifiers */);
 }
 function isSuperCall(node) {
-    return node.kind === 214 /* SyntaxKind.CallExpression */ && getExpression(node).kind === 107 /* SyntaxKind.SuperKeyword */;
+    return node.kind === 215 /* SyntaxKind.CallExpression */ && getExpression(node).kind === 107 /* SyntaxKind.SuperKeyword */;
 }
 function skipOuterExpressions(node) {
     let n = node;
-    while (n.kind === 218 /* SyntaxKind.ParenthesizedExpression */ ||
-        n.kind === 235 /* SyntaxKind.AsExpression */ ||
-        n.kind === 239 /* SyntaxKind.SatisfiesExpression */ ||
-        n.kind === 217 /* SyntaxKind.TypeAssertionExpression */ ||
-        n.kind === 236 /* SyntaxKind.NonNullExpression */)
+    while (n.kind === 219 /* SyntaxKind.ParenthesizedExpression */ ||
+        n.kind === 236 /* SyntaxKind.AsExpression */ ||
+        n.kind === 240 /* SyntaxKind.SatisfiesExpression */ ||
+        n.kind === 218 /* SyntaxKind.TypeAssertionExpression */ ||
+        n.kind === 237 /* SyntaxKind.NonNullExpression */)
         n = getExpression(n);
     return n;
 }
@@ -301,7 +321,7 @@ function needsRootLevelSuperCall(classDecl, constructor) {
 }
 function isInstancePropertyWithInitializerOrPrivateIdentifierProperty(n) {
     return (isPrivateIdentifierClassElementDeclaration(n) ||
-        (n.kind === 173 /* SyntaxKind.PropertyDeclaration */ && !isStatic(n) && getInitializer(n) !== undefined));
+        (n.kind === 174 /* SyntaxKind.PropertyDeclaration */ && !isStatic(n) && getInitializer(n) !== undefined));
 }
 /** Finds the first `super(...)` call outside nested functions. */
 class SuperCallFinder extends NodeVisitor {
@@ -323,17 +343,17 @@ class SuperOrThisReferenceFinder extends NodeVisitor {
             case 107 /* SyntaxKind.SuperKeyword */:
             case 109 /* SyntaxKind.ThisKeyword */:
                 return true;
-            case 220 /* SyntaxKind.ArrowFunction */:
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 221 /* SyntaxKind.ArrowFunction */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
                 return false;
-            case 242 /* SyntaxKind.Block */:
+            case 243 /* SyntaxKind.Block */:
                 switch (node.parent.kind) {
-                    case 177 /* SyntaxKind.Constructor */:
-                    case 175 /* SyntaxKind.MethodDeclaration */:
-                    case 178 /* SyntaxKind.GetAccessor */:
-                    case 179 /* SyntaxKind.SetAccessor */:
+                    case 178 /* SyntaxKind.Constructor */:
+                    case 176 /* SyntaxKind.MethodDeclaration */:
+                    case 179 /* SyntaxKind.GetAccessor */:
+                    case 180 /* SyntaxKind.SetAccessor */:
                         return false;
                 }
         }
@@ -352,7 +372,7 @@ function checkPropertyInitialization(c, node) {
         return;
     const constructor = findConstructorDeclaration(node);
     for (const member of getMembers(node).nodes) {
-        if (member.kind !== 173 /* SyntaxKind.PropertyDeclaration */)
+        if (member.kind !== 174 /* SyntaxKind.PropertyDeclaration */)
             continue;
         if (hasSyntacticModifier(member, 128 /* ModifierFlags.Ambient */) ||
             hasSyntacticModifier(member, 64 /* ModifierFlags.Abstract */) ||
@@ -364,7 +384,7 @@ function checkPropertyInitialization(c, node) {
         const propName = prop.name;
         if (propName.kind !== 79 /* SyntaxKind.Identifier */ &&
             propName.kind !== 80 /* SyntaxKind.PrivateIdentifier */ &&
-            propName.kind !== 168 /* SyntaxKind.ComputedPropertyName */)
+            propName.kind !== 169 /* SyntaxKind.ComputedPropertyName */)
             continue;
         const symbol = getSymbolOfDeclaration(c, member);
         if (symbol === undefined)
@@ -374,7 +394,7 @@ function checkPropertyInitialization(c, node) {
             continue;
         if (constructor !== undefined && isPropertyInitializedInConstructor(c, propName, t, constructor))
             continue;
-        c.error(propName, 718 /* Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor */, declarationNameToString(getSourceFileOfNode(propName), propName));
+        c.error(propName, 725 /* Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor */, declarationNameToString(getSourceFileOfNode(propName), propName));
     }
 }
 /** Whether `this.name` is definitely assigned at the end of the constructor, by control flow. */
@@ -382,7 +402,7 @@ export function isPropertyInitializedInConstructor(c, propName, propType, constr
     const thisExpression = new KeywordExpression(109 /* SyntaxKind.ThisKeyword */);
     const returnFlowNode = constructor.returnFlowNode;
     let reference;
-    if (propName.kind === 168 /* SyntaxKind.ComputedPropertyName */) {
+    if (propName.kind === 169 /* SyntaxKind.ComputedPropertyName */) {
         const access = new ElementAccessExpression(thisExpression, undefined, getExpression(propName), 0 /* NodeFlags.None */);
         access.flowNode = returnFlowNode;
         reference = access;
@@ -419,7 +439,7 @@ export function getFlowTypeInConstructor(c, symbol, constructor) {
     const reference = newThisPropertyReference(symbol, constructor, constructor.returnFlowNode);
     const flowType = getFlowTypeOfProperty(c, reference, symbol);
     if (c.noImplicitAny && (flowType === c.autoType || flowType === c.autoArrayType))
-        c.error(symbol.valueDeclaration, 1680 /* Diagnostics.Member_0_implicitly_has_an_1_type */, symbolToString(c, symbol), typeToString(c, flowType));
+        c.error(symbol.valueDeclaration, 1699 /* Diagnostics.Member_0_implicitly_has_an_1_type */, symbolToString(c, symbol), typeToString(c, flowType));
     // Assignments of only null or undefined infer nothing.
     if (everyType(flowType, (t) => hasTypeFacts(c, t, 50331648 /* TypeFacts.IsUndefinedOrNull */)))
         return undefined;
@@ -431,7 +451,7 @@ export function getFlowTypeInStaticBlocks(c, symbol, staticBlocks) {
         const reference = newThisPropertyReference(symbol, staticBlock, staticBlock.returnFlowNode);
         const flowType = getFlowTypeOfProperty(c, reference, symbol);
         if (c.noImplicitAny && (flowType === c.autoType || flowType === c.autoArrayType))
-            c.error(symbol.valueDeclaration, 1680 /* Diagnostics.Member_0_implicitly_has_an_1_type */, symbolToString(c, symbol), typeToString(c, flowType));
+            c.error(symbol.valueDeclaration, 1699 /* Diagnostics.Member_0_implicitly_has_an_1_type */, symbolToString(c, symbol), typeToString(c, flowType));
         if (everyType(flowType, (t) => hasTypeFacts(c, t, 50331648 /* TypeFacts.IsUndefinedOrNull */)))
             continue;
         return convertAutoToAny(c, flowType);
@@ -445,7 +465,7 @@ function newThisPropertyReference(symbol, container, flowNode) {
     if (name.startsWith('\ufffe#'))
         accessName = new PrivateIdentifier(name.substring(name.indexOf('@') + 1));
     else
-        accessName = new Identifier(name);
+        accessName = new Identifier(new IdentifierName(name));
     const thisExpression = new KeywordExpression(109 /* SyntaxKind.ThisKeyword */);
     const reference = new PropertyAccessExpression(thisExpression, undefined, accessName, 0 /* NodeFlags.None */);
     thisExpression.parent = reference;
@@ -470,7 +490,7 @@ export function getFlowTypeOfProperty(c, reference, prop) {
 export function isAutoTypedProperty(c, symbol) {
     const declaration = symbol.valueDeclaration;
     return (declaration !== undefined &&
-        declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+        declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */ &&
         getType(declaration) === undefined &&
         getInitializer(declaration) === undefined &&
         c.noImplicitAny);
@@ -487,32 +507,57 @@ function containsUndefinedType(t) {
     const first = (t.flags & 134217728 /* TypeFlags.Union */) !== 0 ? typesOf(t)[0] : t;
     return (first.flags & 4 /* TypeFlags.Undefined */) !== 0;
 }
-/** Whether `new` at `node` may call a constructor, reporting private and protected ones out of reach. */
-export function isConstructorAccessible(c, node, signature) {
-    if (signature === undefined || signature.declaration === undefined)
-        return true;
-    const declaration = signature.declaration;
-    const modifiers = getModifierFlags(declaration) & 6 /* ModifierFlags.NonPublicAccessibilityModifier */;
-    // Public constructors and constructor functions are always accessible.
-    if (modifiers === 0 || declaration.kind !== 177 /* SyntaxKind.Constructor */)
-        return true;
-    const classSymbol = getSymbol(declaration.parent);
-    const declaringClassDeclaration = getClassLikeDeclarationOfSymbol(classSymbol);
-    const declaringClass = getDeclaredTypeOfSymbol(c, classSymbol);
-    // Private and protected constructors are only callable within their class, or subclasses if protected.
-    for (let container = getContainingClass(node); container !== undefined; container = getContainingClass(container))
-        if (container === declaringClassDeclaration)
-            return true;
-    const containingClass = getContainingClass(node);
-    if (containingClass !== undefined && (modifiers & 4 /* ModifierFlags.Protected */) !== 0) {
-        const containingType = getDeclaredTypeOfSymbol(c, getSymbol(containingClass));
-        if (typeHasProtectedAccessibleBase(c, classSymbol, containingType))
-            return true;
+/** A constructor that `node` may not call: the modifiers that forbid it, and the class that declares it. */
+export class ConstructorAccessibilityError {
+    kind;
+    declaringClass;
+    constructor(kind, declaringClass) {
+        this.kind = kind;
+        this.declaringClass = declaringClass;
+    }
+}
+/**
+ * The first of `signatures` whose constructor `node` may not call because of the modifiers in `modifiersMask`:
+ * private and protected constructors are only callable within their class, or subclasses if protected.
+ */
+export function getConstructorAccessibilityError(c, node, signatures, modifiersMask) {
+    for (const signature of signatures) {
+        const declaration = signature.declaration;
+        if (declaration === undefined)
+            continue;
+        const modifiers = getModifierFlags(declaration) & modifiersMask;
+        // Public constructors and constructor functions are always accessible.
+        if (modifiers === 0 || declaration.kind !== 178 /* SyntaxKind.Constructor */)
+            continue;
+        const classSymbol = getSymbol(declaration.parent);
+        const declaringClassDeclaration = getClassLikeDeclarationOfSymbol(classSymbol);
+        let withinClass = false;
+        for (let container = getContainingClass(node); container !== undefined; container = getContainingClass(container))
+            if (container === declaringClassDeclaration) {
+                withinClass = true;
+                break;
+            }
+        if (withinClass)
+            continue;
+        const containingClass = getContainingClass(node);
+        if (containingClass !== undefined && (modifiers & 4 /* ModifierFlags.Protected */) !== 0) {
+            const containingType = getTypeOfNode(c, containingClass);
+            if (typeHasProtectedAccessibleBase(c, classSymbol, containingType))
+                continue;
+        }
+        return new ConstructorAccessibilityError(modifiers, getDeclaredTypeOfSymbol(c, classSymbol));
     }
-    if ((modifiers & 2 /* ModifierFlags.Private */) !== 0)
-        c.error(node, 807 /* Diagnostics.Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration */, typeToString(c, declaringClass));
-    if ((modifiers & 4 /* ModifierFlags.Protected */) !== 0)
-        c.error(node, 808 /* Diagnostics.Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration */, typeToString(c, declaringClass));
+    return undefined;
+}
+/** Whether `new` at `node` may call the constructors of `signatures`, reporting private and protected ones out of reach. */
+export function isConstructorAccessible(c, node, signatures) {
+    const error = getConstructorAccessibilityError(c, node, signatures, 6 /* ModifierFlags.NonPublicAccessibilityModifier */);
+    if (error === undefined)
+        return true;
+    if ((error.kind & 2 /* ModifierFlags.Private */) !== 0)
+        c.error(node, 814 /* Diagnostics.Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration */, typeToString(c, error.declaringClass));
+    if ((error.kind & 4 /* ModifierFlags.Protected */) !== 0)
+        c.error(node, 815 /* Diagnostics.Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration */, typeToString(c, error.declaringClass));
     return false;
 }
 /** Whether `target` is a base class of `t`, through bases that aren't mixins. */
@@ -560,7 +605,7 @@ function findMixins(c, types) {
 export function checkInterfaceDeclaration(c, node) {
     const decl = node;
     checkTypeParameters(c, decl.typeParameters);
-    checkTypeNameIsReserved(c, decl.name, 596 /* Diagnostics.Interface_name_cannot_be_0 */);
+    checkTypeNameIsReserved(c, decl.name, 603 /* Diagnostics.Interface_name_cannot_be_0 */);
     checkExportsOnMergedDeclarations(c, node);
     const symbol = getSymbolOfDeclaration(c, node);
     if (symbol !== undefined) {
@@ -573,7 +618,7 @@ export function checkInterfaceDeclaration(c, node) {
         checkHeritageClauses(c, decl.heritageClauses.nodes, false);
     for (const member of decl.members.nodes) {
         checkJSDocLinksOfNode(c, member);
-        if (member.kind === 172 /* SyntaxKind.PropertySignature */)
+        if (member.kind === 173 /* SyntaxKind.PropertySignature */)
             checkVariableLikeDeclaration(c, member);
         else
             checkTypeNodeIfPresent(c, member);

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

@@ -18,6 +18,26 @@ export declare function pushCachedContextualType(c: Checker, node: Node): void;
 export declare function popContextualType(c: Checker): void;
 /** The index of the contextual type pushed onto `node`, or -1. */
 export declare function findContextualNode(c: Checker, node: Node, includeCaches: boolean): number;
+/**
+ * The id of the contextual type in force for `node`, or -1 if the node's contextual type is not on
+ * the stack. A key built from -1 can't tell a check under a contextual type that was not pushed from
+ * a check with no contextual type, so callers record nothing under -1.
+ */
+export declare function getContextualTypeId(c: Checker, node: Node): number;
+/**
+ * Whether a check of `node` has no contextual type and no inference context, so its type is a
+ * function of the node and the check mode alone: the node is not on the contextual stack, no
+ * inference context contains it, and its parent gives it no contextual type. The parents answered
+ * here are the ones `getContextualTypeEx` returns `undefined` for without computing anything; a
+ * parent it computes a type for is not answered, so the result is never "yes" for a check that
+ * could have a contextual type.
+ *
+ * Types computed inside a flow loop are provisional (the checker does not cache them either), so a
+ * check in a loop is not context-free. The same holds while a reduce label is in force, as when
+ * flow analysis revisits a `finally` block with the antecedents of one outgoing path: the flow
+ * state differs from the one the earlier check of the block saw.
+ */
+export declare function isCheckedWithoutContextualType(c: Checker, node: Node): boolean;
 export declare function pushInferenceContext(c: Checker, node: Node, context: InferenceContext | undefined): void;
 export declare function popInferenceContext(c: Checker): void;
 /** The inference context of the innermost call argument containing `node`. */