tsc-ts 0.0.9 → 0.1.0

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

@@ -71,16 +71,16 @@ class OverloadChecker {
             const parent = node.parent;
             const inAmbientContextOrInterface = inAmbientContext ||
                 (parent !== undefined &&
-                    (parent.kind === 265 /* SyntaxKind.InterfaceDeclaration */ || parent.kind === 188 /* SyntaxKind.TypeLiteral */));
+                    (parent.kind === 266 /* SyntaxKind.InterfaceDeclaration */ || parent.kind === 189 /* SyntaxKind.TypeLiteral */));
             // Only non-ambient declarations must be consecutive.
             if (inAmbientContextOrInterface)
                 previousDeclaration = undefined;
             if (isClassLike(node) && !inAmbientContext)
                 hasNonAmbientClass = true;
-            if (node.kind !== 263 /* SyntaxKind.FunctionDeclaration */ &&
-                node.kind !== 175 /* SyntaxKind.MethodDeclaration */ &&
-                node.kind !== 174 /* SyntaxKind.MethodSignature */ &&
-                node.kind !== 177 /* SyntaxKind.Constructor */)
+            if (node.kind !== 264 /* SyntaxKind.FunctionDeclaration */ &&
+                node.kind !== 176 /* SyntaxKind.MethodDeclaration */ &&
+                node.kind !== 175 /* SyntaxKind.MethodSignature */ &&
+                node.kind !== 178 /* SyntaxKind.Constructor */)
                 continue;
             functionDeclarations.push(node);
             const currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck());
@@ -113,10 +113,10 @@ class OverloadChecker {
         }
         if (multipleConstructorImplementation)
             for (const d of functionDeclarations)
-                c.error(d, 563 /* Diagnostics.Multiple_constructor_implementations_are_not_allowed */);
+                c.error(d, 570 /* Diagnostics.Multiple_constructor_implementations_are_not_allowed */);
         if (duplicateFunctionDeclaration)
             for (const d of functionDeclarations)
-                c.error(getNameOfDeclaration(d) ?? d, 564 /* Diagnostics.Duplicate_function_implementation */);
+                c.error(getNameOfDeclaration(d) ?? d, 571 /* Diagnostics.Duplicate_function_implementation */);
         if (hasNonAmbientClass &&
             !this.isConstructor &&
             (this.symbol.flags & 16 /* SymbolFlags.Function */) !== 0 &&
@@ -135,7 +135,7 @@ class OverloadChecker {
             const canonical = isOptionalDeclaration(getCanonicalOverload(declarations, bodyDeclaration));
             for (const d of declarations)
                 if (isOptionalDeclaration(d) !== canonical)
-                    c.error(getNameOfDeclaration(d), 557 /* Diagnostics.Overload_signatures_must_all_be_optional_or_required */);
+                    c.error(getNameOfDeclaration(d), 564 /* Diagnostics.Overload_signatures_must_all_be_optional_or_required */);
         }
         if (bodyDeclaration === undefined)
             return;
@@ -143,7 +143,7 @@ class OverloadChecker {
         for (const signature of getSignaturesOfSymbol(c, this.symbol)) {
             if (isImplementationCompatibleWithOverload(c, bodySignature, signature))
                 continue;
-            c.error(signature.declaration, 565 /* Diagnostics.This_overload_signature_is_not_compatible_with_its_implementation_signature */).addRelatedInfo(createDiagnosticForNode(bodyDeclaration, 882 /* Diagnostics.The_implementation_signature_is_declared_here */, []));
+            c.error(signature.declaration, 572 /* Diagnostics.This_overload_signature_is_not_compatible_with_its_implementation_signature */).addRelatedInfo(createDiagnosticForNode(bodyDeclaration, 889 /* Diagnostics.The_implementation_signature_is_declared_here */, []));
             break;
         }
     }
@@ -151,19 +151,19 @@ class OverloadChecker {
         const c = this.c;
         const classes = [];
         for (const d of getDeclarations(this.symbol))
-            if (d.kind === 264 /* SyntaxKind.ClassDeclaration */)
+            if (d.kind === 265 /* SyntaxKind.ClassDeclaration */)
                 classes.push(d);
         for (const d of getDeclarations(this.symbol)) {
             let message;
-            if (d.kind === 264 /* SyntaxKind.ClassDeclaration */)
-                message = 944 /* Diagnostics.Class_declaration_cannot_implement_overload_list_for_0 */;
-            else if (d.kind === 263 /* SyntaxKind.FunctionDeclaration */)
-                message = 945 /* Diagnostics.Function_with_bodies_can_only_merge_with_classes_that_are_ambient */;
+            if (d.kind === 265 /* SyntaxKind.ClassDeclaration */)
+                message = 951 /* Diagnostics.Class_declaration_cannot_implement_overload_list_for_0 */;
+            else if (d.kind === 264 /* SyntaxKind.FunctionDeclaration */)
+                message = 952 /* Diagnostics.Function_with_bodies_can_only_merge_with_classes_that_are_ambient */;
             else
                 continue;
             const err = c.error(getNameOfDeclaration(d) ?? d, message, this.symbol.name);
             for (const r of classes)
-                err.addRelatedInfo(createDiagnosticForNode(r, 1521 /* Diagnostics.Consider_adding_a_declare_modifier_to_this_class */, []));
+                err.addRelatedInfo(createDiagnosticForNode(r, 1532 /* Diagnostics.Consider_adding_a_declare_modifier_to_this_class */, []));
         }
     }
     checkFlagAgreement(overloads, implementation, someOverloadFlags, allOverloadFlags) {
@@ -190,13 +190,13 @@ class OverloadChecker {
                 const deviation = flags ^ canonicalFlags;
                 const deviationInFile = flags ^ canonicalFlagsForFile;
                 if ((deviationInFile & 32 /* ModifierFlags.Export */) !== 0)
-                    c.error(getNameOfDeclaration(o), 554 /* Diagnostics.Overload_signatures_must_all_be_exported_or_non_exported */);
+                    c.error(getNameOfDeclaration(o), 561 /* Diagnostics.Overload_signatures_must_all_be_exported_or_non_exported */);
                 else if ((deviationInFile & 128 /* ModifierFlags.Ambient */) !== 0)
-                    c.error(getNameOfDeclaration(o), 555 /* Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient */);
+                    c.error(getNameOfDeclaration(o), 562 /* Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient */);
                 else if ((deviation & (2 /* ModifierFlags.Private */ | 4 /* ModifierFlags.Protected */)) !== 0)
-                    c.error(getNameOfDeclaration(o) ?? o, 556 /* Diagnostics.Overload_signatures_must_all_be_public_private_or_protected */);
+                    c.error(getNameOfDeclaration(o) ?? o, 563 /* Diagnostics.Overload_signatures_must_all_be_public_private_or_protected */);
                 else if ((deviation & 64 /* ModifierFlags.Abstract */) !== 0)
-                    c.error(getNameOfDeclaration(o), 672 /* Diagnostics.Overload_signatures_must_all_be_abstract_or_non_abstract */);
+                    c.error(getNameOfDeclaration(o), 679 /* Diagnostics.Overload_signatures_must_all_be_abstract_or_non_abstract */);
             }
         }
     }
@@ -212,25 +212,25 @@ class OverloadChecker {
             const errorNode = subsequentName ?? subsequentNode;
             if (name !== undefined && subsequentName !== undefined && isSameMemberName(c, name, subsequentName)) {
                 // Mixed static and instance members; other conflicts are reported by the binder.
-                if ((node.kind === 175 /* SyntaxKind.MethodDeclaration */ || node.kind === 174 /* SyntaxKind.MethodSignature */) &&
+                if ((node.kind === 176 /* SyntaxKind.MethodDeclaration */ || node.kind === 175 /* SyntaxKind.MethodSignature */) &&
                     isStatic(node) !== isStatic(subsequentNode))
                     c.error(errorNode, isStatic(node)
-                        ? 558 /* Diagnostics.Function_overload_must_be_static */
-                        : 559 /* Diagnostics.Function_overload_must_not_be_static */);
+                        ? 565 /* Diagnostics.Function_overload_must_be_static */
+                        : 566 /* Diagnostics.Function_overload_must_not_be_static */);
                 return;
             }
             if (nodeIsPresent(getBody(subsequentNode))) {
-                c.error(errorNode, 560 /* Diagnostics.Function_implementation_name_must_be_0 */, declarationNameToString(getSourceFileOfNode(node), name));
+                c.error(errorNode, 567 /* Diagnostics.Function_implementation_name_must_be_0 */, declarationNameToString(getSourceFileOfNode(node), name));
                 return;
             }
         }
         const errorNode = name ?? node;
         if (this.isConstructor)
-            c.error(errorNode, 561 /* Diagnostics.Constructor_implementation_is_missing */);
+            c.error(errorNode, 568 /* Diagnostics.Constructor_implementation_is_missing */);
         else if (hasSyntacticModifier(node, 64 /* ModifierFlags.Abstract */))
-            c.error(errorNode, 676 /* Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive */);
+            c.error(errorNode, 683 /* Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive */);
         else
-            c.error(errorNode, 562 /* Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration */);
+            c.error(errorNode, 569 /* Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration */);
     }
 }
 /**
@@ -253,7 +253,7 @@ function getNextSibling(node) {
 function isSameMemberName(c, name, other) {
     if (name.kind === 80 /* SyntaxKind.PrivateIdentifier */ && other.kind === 80 /* SyntaxKind.PrivateIdentifier */)
         return getText(name) === getText(other);
-    if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */ && other.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+    if (name.kind === 169 /* SyntaxKind.ComputedPropertyName */ && other.kind === 169 /* SyntaxKind.ComputedPropertyName */)
         return isTypeIdenticalTo(c, checkComputedPropertyName(c, name), checkComputedPropertyName(c, other));
     return isPropertyNameLiteral(name) && isPropertyNameLiteral(other) && getText(name) === getText(other);
 }

package/dist/api/compiler/checker-property-access.js

@@ -50,13 +50,13 @@ export function checkPropertyAccessExpressionOrQualifiedName(c, node, left, left
         if (assignmentKind !== 0 /* AssignmentKind.None */ &&
             lexicallyScopedSymbol !== undefined &&
             lexicallyScopedSymbol.valueDeclaration !== undefined &&
-            lexicallyScopedSymbol.valueDeclaration.kind === 175 /* SyntaxKind.MethodDeclaration */)
-            grammarErrorOnNode(c, right, 935 /* Diagnostics.Cannot_assign_to_private_method_0_Private_methods_are_not_writable */, name);
+            lexicallyScopedSymbol.valueDeclaration.kind === 176 /* SyntaxKind.MethodDeclaration */)
+            grammarErrorOnNode(c, right, 942 /* Diagnostics.Cannot_assign_to_private_method_0_Private_methods_are_not_writable */, name);
         if (isAnyLike) {
             if (lexicallyScopedSymbol !== undefined)
                 return isErrorType(c, apparentType) ? c.errorType : apparentType;
             if (getContainingClassExcludingClassDecorators(right) === undefined) {
-                grammarErrorOnNode(c, right, 1838 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
+                grammarErrorOnNode(c, right, 1858 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
                 return c.anyType;
             }
         }
@@ -70,7 +70,7 @@ export function checkPropertyAccessExpressionOrQualifiedName(c, node, left, left
         else if ((prop.flags & 65536 /* SymbolFlags.SetAccessor */) !== 0 &&
             (prop.flags & 32768 /* SymbolFlags.GetAccessor */) === 0 &&
             assignmentKind !== 1 /* AssignmentKind.Definite */)
-            c.error(node, 937 /* Diagnostics.Private_accessor_was_defined_without_a_getter */);
+            c.error(node, 944 /* Diagnostics.Private_accessor_was_defined_without_a_getter */);
     }
     else {
         if (isAnyLike) {
@@ -78,7 +78,7 @@ export function checkPropertyAccessExpressionOrQualifiedName(c, node, left, left
                 markPropertyAliasReferenced(c, node, undefined, leftType);
             return isErrorType(c, apparentType) ? c.errorType : apparentType;
         }
-        prop = getPropertyOfTypeEx(c, apparentType, name, isConstEnumObjectType(apparentType), node.kind === 167 /* SyntaxKind.QualifiedName */);
+        prop = getPropertyOfTypeEx(c, apparentType, name, isConstEnumObjectType(apparentType), node.kind === 168 /* SyntaxKind.QualifiedName */);
     }
     markPropertyAliasReferenced(c, node, prop, leftType);
     let propType;
@@ -93,23 +93,27 @@ export function checkPropertyAccessExpressionOrQualifiedName(c, node, left, left
             if (leftType.symbol === c.globalThisSymbol) {
                 const globalSymbol = c.globalThisSymbol.exports?.get(name);
                 if (globalSymbol !== undefined && (globalSymbol.flags & 418 /* SymbolFlags.BlockScoped */) !== 0)
-                    c.error(right, 516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, name, typeToString(c, leftType));
+                    c.error(right, 523 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, name, typeToString(c, leftType));
                 else if (c.noImplicitAny)
-                    c.error(right, 1689 /* Diagnostics.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature */, typeToString(c, leftType));
+                    c.error(right, 1708 /* Diagnostics.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature */, typeToString(c, leftType));
                 return c.anyType;
             }
-            if (name !== '')
-                reportNonexistentProperty(c, right, isThisTypeParameter(leftType) ? apparentType : leftType);
+            if (name !== '') {
+                // Deferred, since printing the containing type can resolve it completely, and report circularities
+                // while it is being resolved.
+                const containingType = isThisTypeParameter(leftType) ? apparentType : leftType;
+                c.deferDiagnostic(right, () => reportNonexistentProperty(c, right, containingType));
+            }
             return c.errorType;
         }
         if (indexInfo.isReadonly && (assignmentKind !== 0 /* AssignmentKind.None */ || isDeleteTarget(node)))
-            c.error(node, 698 /* Diagnostics.Index_signature_in_type_0_only_permits_reading */, typeToString(c, apparentType));
+            c.error(node, 705 /* Diagnostics.Index_signature_in_type_0_only_permits_reading */, typeToString(c, apparentType));
         propType = indexInfo.valueType;
         if (c.noUncheckedIndexedAccess && assignmentKind !== 1 /* AssignmentKind.Definite */)
             propType = getUnionType(c, [propType, c.missingType]);
         if (c.compilerOptions.noPropertyAccessFromIndexSignature === true &&
-            node.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
-            c.error(right, 1097 /* Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0 */, name);
+            node.kind === 213 /* SyntaxKind.PropertyAccessExpression */)
+            c.error(right, 1104 /* Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0 */, name);
         checkDeprecatedIndexSignature(c, right, indexInfo.declaration);
     }
     else {
@@ -121,7 +125,7 @@ export function checkPropertyAccessExpressionOrQualifiedName(c, node, left, left
             c.resolvedSymbols.set(node.id, prop);
         checkPropertyAccessibility(c, node, left.kind === 107 /* SyntaxKind.SuperKeyword */, assignmentKind !== 0 /* AssignmentKind.None */, apparentType, prop);
         if (isAssignmentToReadonlyEntity(c, node, prop, assignmentKind)) {
-            c.error(right, 697 /* Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property */, name);
+            c.error(right, 704 /* Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property */, name);
             return c.errorType;
         }
         if (isThisPropertyAccessInConstructor(c, node, prop))
@@ -136,15 +140,15 @@ export function checkPropertyAccessExpressionOrQualifiedName(c, node, left, left
 }
 /** Whether `node` is a property of an object destructuring assignment from `this`. */
 function isThisInitializedObjectBindingExpression(node) {
-    if (node.kind !== 304 /* SyntaxKind.ShorthandPropertyAssignment */ && node.kind !== 303 /* SyntaxKind.PropertyAssignment */)
+    if (node.kind !== 305 /* SyntaxKind.ShorthandPropertyAssignment */ && node.kind !== 304 /* SyntaxKind.PropertyAssignment */)
         return false;
     const binary = node.parent.parent;
-    return (binary.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+    return (binary.kind === 228 /* SyntaxKind.BinaryExpression */ &&
         binary.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ &&
         binary.right.kind === 109 /* SyntaxKind.ThisKeyword */);
 }
 function isThisInitializedDeclaration(node) {
-    if (node.kind !== 261 /* SyntaxKind.VariableDeclaration */)
+    if (node.kind !== 262 /* SyntaxKind.VariableDeclaration */)
         return false;
     const initializer = getInitializer(node);
     return initializer !== undefined && initializer.kind === 109 /* SyntaxKind.ThisKeyword */;
@@ -183,7 +187,7 @@ function getContainingClassExcludingClassDecorators(node) {
     for (let current = node.parent; current !== undefined; current = current.parent) {
         if (isClassLike(current))
             break;
-        if (current.kind === 171 /* SyntaxKind.Decorator */) {
+        if (current.kind === 172 /* SyntaxKind.Decorator */) {
             if (current.parent !== undefined && isClassLike(current.parent))
                 return getContainingClass(current.parent);
             break;
@@ -215,15 +219,15 @@ function checkPrivateIdentifierPropertyAccess(c, leftType, right, lexicallyScope
         for (let n = getContainingClass(lexicalValueDecl); n !== undefined; n = n.parent) {
             if (n !== typeClass)
                 continue;
-            const diagnostic = c.error(right, 1836 /* Diagnostics.The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_private_identifier_with_the_same_spelling */, diagName, typeToString(c, leftType));
-            diagnostic.addRelatedInfo(createDiagnosticForNode(lexicalValueDecl, 1839 /* Diagnostics.The_shadowing_declaration_of_0_is_defined_here */, [
+            const diagnostic = c.error(right, 1856 /* Diagnostics.The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_private_identifier_with_the_same_spelling */, diagName, typeToString(c, leftType));
+            diagnostic.addRelatedInfo(createDiagnosticForNode(lexicalValueDecl, 1859 /* Diagnostics.The_shadowing_declaration_of_0_is_defined_here */, [
                 diagName,
             ]));
-            diagnostic.addRelatedInfo(createDiagnosticForNode(typeValueDecl, 1840 /* Diagnostics.The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here */, [diagName]));
+            diagnostic.addRelatedInfo(createDiagnosticForNode(typeValueDecl, 1860 /* Diagnostics.The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here */, [diagName]));
             return true;
         }
     }
-    c.error(right, 1835 /* Diagnostics.Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier */, diagName, symbolToString(c, getSymbol(typeClass)));
+    c.error(right, 1855 /* Diagnostics.Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier */, diagName, symbolToString(c, getSymbol(typeClass)));
     return true;
 }
 function isThisTypeParameter(t) {
@@ -236,10 +240,10 @@ function isConstEnumObjectType(t) {
 }
 export function isMethodAccessForCall(node) {
     let current = node;
-    while (current.parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+    while (current.parent.kind === 219 /* SyntaxKind.ParenthesizedExpression */)
         current = current.parent;
     const parent = current.parent;
-    return ((parent.kind === 214 /* SyntaxKind.CallExpression */ || parent.kind === 215 /* SyntaxKind.NewExpression */) &&
+    return ((parent.kind === 215 /* SyntaxKind.CallExpression */ || parent.kind === 216 /* SyntaxKind.NewExpression */) &&
         getExpression(parent) === current);
 }
 /** Whether `node` is the operand of `delete`, through parentheses. */
@@ -247,9 +251,9 @@ export function isDeleteTarget(node) {
     if (!isAccessExpression(node))
         return false;
     let current = node.parent;
-    while (current.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+    while (current.kind === 219 /* SyntaxKind.ParenthesizedExpression */)
         current = current.parent;
-    return current.kind === 221 /* SyntaxKind.DeleteExpression */;
+    return current.kind === 222 /* SyntaxKind.DeleteExpression */;
 }
 /** Whether assigning through `expr` targets a readonly entity, outside of initialization. */
 export function isAssignmentToReadonlyEntity(c, expr, symbol, assignmentKind) {
@@ -267,14 +271,14 @@ export function isAssignmentToReadonlyEntity(c, expr, symbol, assignmentKind) {
             isAccessExpression(expr) &&
             getExpression(expr).kind === 109 /* SyntaxKind.ThisKeyword */) {
             const ctor = getControlFlowContainer(expr);
-            if (ctor.kind !== 177 /* SyntaxKind.Constructor */)
+            if (ctor.kind !== 178 /* SyntaxKind.Constructor */)
                 return true;
             const declaration = symbol.valueDeclaration;
             if (declaration !== undefined) {
                 const isLocalPropertyDeclaration = ctor.parent === declaration.parent;
                 const isLocalParameterProperty = ctor === declaration.parent;
                 // A JavaScript `this.x = …` declaration of this class or constructor function.
-                const isAssignmentDeclaration = declaration.kind === 227 /* SyntaxKind.BinaryExpression */;
+                const isAssignmentDeclaration = declaration.kind === 228 /* SyntaxKind.BinaryExpression */;
                 const parentDeclaration = symbol.parent?.valueDeclaration;
                 const isLocalThisPropertyAssignment = isAssignmentDeclaration && (parentDeclaration === ctor.parent || parentDeclaration === ctor);
                 return !isLocalPropertyDeclaration && !isLocalParameterProperty && !isLocalThisPropertyAssignment;
@@ -289,7 +293,7 @@ export function isAssignmentToReadonlyEntity(c, expr, symbol, assignmentKind) {
             const expressionSymbol = getResolvedSymbol(c, node);
             if ((expressionSymbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
                 const declaration = getDeclarationOfAliasSymbol(expressionSymbol);
-                return declaration !== undefined && declaration.kind === 275 /* SyntaxKind.NamespaceImport */;
+                return declaration !== undefined && declaration.kind === 276 /* SyntaxKind.NamespaceImport */;
             }
         }
     }
@@ -299,13 +303,13 @@ export function isAssignmentToReadonlyEntity(c, expr, symbol, assignmentKind) {
 /** Checks that `prop` of `containingType` may be accessed at `node`; reports and returns false otherwise. */
 export function checkPropertyAccessibility(c, node, isSuper, writing, containingType, prop) {
     let errorNode;
-    if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+    if (node.kind === 213 /* SyntaxKind.PropertyAccessExpression */)
         errorNode = node.name;
-    else if (node.kind === 167 /* SyntaxKind.QualifiedName */)
+    else if (node.kind === 168 /* SyntaxKind.QualifiedName */)
         errorNode = node.right;
-    else if (node.kind === 206 /* SyntaxKind.ImportType */)
+    else if (node.kind === 207 /* SyntaxKind.ImportType */)
         errorNode = node;
-    else if (node.kind === 209 /* SyntaxKind.BindingElement */)
+    else if (node.kind === 210 /* SyntaxKind.BindingElement */)
         errorNode = node.propertyName ?? node.name;
     else
         errorNode = getName(node) ?? node;
@@ -329,13 +333,13 @@ function checkPropertyAccessibilityAtLocation(c, location, isSuper, writing, con
         // Abstract methods can't be reached through `super`.
         if ((flags & 64 /* ModifierFlags.Abstract */) !== 0) {
             if (errorNode !== undefined)
-                c.error(errorNode, 673 /* Diagnostics.Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression */, symbolToString(c, prop), typeToString(c, getDeclaringClass(c, prop)));
+                c.error(errorNode, 680 /* Diagnostics.Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression */, symbolToString(c, prop), typeToString(c, getDeclaringClass(c, prop)));
             return false;
         }
         // Class fields of the parent aren't on the prototype.
         if ((flags & 256 /* ModifierFlags.Static */) === 0 && hasClassInstancePropertyDeclaration(prop)) {
             if (errorNode !== undefined)
-                c.error(errorNode, 975 /* Diagnostics.Class_field_0_defined_by_the_parent_class_is_not_accessible_in_the_child_class_via_super */, symbolToString(c, prop));
+                c.error(errorNode, 982 /* Diagnostics.Class_field_0_defined_by_the_parent_class_is_not_accessible_in_the_child_class_via_super */, symbolToString(c, prop));
             return false;
         }
     }
@@ -344,14 +348,14 @@ function checkPropertyAccessibilityAtLocation(c, location, isSuper, writing, con
         symbolHasNonMethodDeclaration(c, prop) &&
         (isThisProperty(location) ||
             isThisInitializedObjectBindingExpression(location) ||
-            (location.parent.kind === 207 /* SyntaxKind.ObjectBindingPattern */ &&
+            (location.parent.kind === 208 /* SyntaxKind.ObjectBindingPattern */ &&
                 isThisInitializedDeclaration(location.parent.parent)))) {
         const parentSymbol = getParentOfSymbol(c, prop);
         if (parentSymbol !== undefined &&
             (parentSymbol.flags & 32 /* SymbolFlags.Class */) !== 0 &&
             isNodeUsedDuringClassInitialization(location)) {
             if (errorNode !== undefined)
-                c.error(errorNode, 847 /* Diagnostics.Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor */, symbolToString(c, prop), symbolToString(c, parentSymbol));
+                c.error(errorNode, 854 /* Diagnostics.Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor */, symbolToString(c, prop), symbolToString(c, parentSymbol));
             return false;
         }
     }
@@ -363,7 +367,7 @@ function checkPropertyAccessibilityAtLocation(c, location, isSuper, writing, con
         const declaringClassDeclaration = parent !== undefined ? getClassLikeDeclarationOfSymbol(parent) : undefined;
         if (!isNodeWithinClass(location, declaringClassDeclaration)) {
             if (errorNode !== undefined)
-                c.error(errorNode, 518 /* Diagnostics.Property_0_is_private_and_only_accessible_within_class_1 */, symbolToString(c, prop), typeToString(c, getDeclaringClass(c, prop)));
+                c.error(errorNode, 525 /* Diagnostics.Property_0_is_private_and_only_accessible_within_class_1 */, symbolToString(c, prop), typeToString(c, getDeclaringClass(c, prop) ?? containingTypeIn));
             return false;
         }
         return true;
@@ -390,7 +394,7 @@ function checkPropertyAccessibilityAtLocation(c, location, isSuper, writing, con
             enclosingClass = thisClass;
         if ((flags & 256 /* ModifierFlags.Static */) !== 0 || enclosingClass === undefined) {
             if (errorNode !== undefined)
-                c.error(errorNode, 613 /* Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses */, symbolToString(c, prop), typeToString(c, getDeclaringClass(c, prop) ?? containingTypeIn));
+                c.error(errorNode, 620 /* Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses */, symbolToString(c, prop), typeToString(c, getDeclaringClass(c, prop) ?? containingTypeIn));
             return false;
         }
     }
@@ -403,7 +407,7 @@ function checkPropertyAccessibilityAtLocation(c, location, isSuper, writing, con
             : getBaseConstraintOfType(c, containingType);
     if (containingType === undefined || !hasBaseType(c, containingType, enclosingClass)) {
         if (containingType !== undefined && errorNode !== undefined)
-            c.error(errorNode, 614 /* Diagnostics.Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1_This_is_an_instance_of_class_2 */, symbolToString(c, prop), typeToString(c, enclosingClass), typeToString(c, containingType));
+            c.error(errorNode, 621 /* Diagnostics.Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1_This_is_an_instance_of_class_2 */, symbolToString(c, prop), typeToString(c, enclosingClass), typeToString(c, containingType));
         return false;
     }
     return true;
@@ -423,7 +427,7 @@ function isClassInstanceProperty(node) {
     }
     return (node.parent !== undefined &&
         isClassLike(node.parent) &&
-        node.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+        node.kind === 174 /* SyntaxKind.PropertyDeclaration */ &&
         !isStatic(node) &&
         !hasSyntacticModifier(node, 512 /* ModifierFlags.Accessor */));
 }
@@ -438,8 +442,8 @@ function isThisProperty(node) {
 }
 function isNodeUsedDuringClassInitialization(node) {
     for (let element = node.parent; element !== undefined; element = element.parent) {
-        if ((element.kind === 177 /* SyntaxKind.Constructor */ && getBody(element) !== undefined) ||
-            element.kind === 173 /* SyntaxKind.PropertyDeclaration */)
+        if ((element.kind === 178 /* SyntaxKind.Constructor */ && getBody(element) !== undefined) ||
+            element.kind === 174 /* SyntaxKind.PropertyDeclaration */)
             return true;
         if (isClassLike(element) || isFunctionLike(element))
             return false;
@@ -537,7 +541,7 @@ export function reportNonexistentProperty(c, propNode, containingType) {
         for (const subtype of typesOf(containingType)) {
             if (getPropertyOfType(c, subtype, name) === undefined &&
                 getApplicableIndexInfoForName(c, subtype, name) === undefined) {
-                chain = createDiagnosticForNode(propNode, 516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [
+                chain = createDiagnosticForNode(propNode, 523 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [
                     missingProperty,
                     typeToString(c, subtype),
                 ]);
@@ -547,35 +551,35 @@ export function reportNonexistentProperty(c, propNode, containingType) {
     }
     let diagnostic;
     if (typeHasStaticProperty(c, name, containingType))
-        diagnostic = createDiagnosticForNode(propNode, 727 /* Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead */, [missingProperty, container, container + '.' + missingProperty]);
+        diagnostic = createDiagnosticForNode(propNode, 734 /* Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead */, [missingProperty, container, container + '.' + missingProperty]);
     else {
         const promisedType = getPromisedTypeOfPromise(c, containingType);
         if (promisedType !== undefined && getPropertyOfType(c, promisedType, name) !== undefined) {
-            diagnostic = createDiagnosticForNode(propNode, 516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [
+            diagnostic = createDiagnosticForNode(propNode, 523 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [
                 missingProperty,
                 container,
             ]);
-            diagnostic.addRelatedInfo(createDiagnosticForNode(propNode, 905 /* Diagnostics.Did_you_forget_to_use_await */, []));
+            diagnostic.addRelatedInfo(createDiagnosticForNode(propNode, 912 /* Diagnostics.Did_you_forget_to_use_await */, []));
         }
         else {
             const libSuggestion = getSuggestedLibForNonExistentProperty(c, missingProperty, containingType);
             const suggestion = libSuggestion === '' ? getSuggestedSymbolForNonexistentProperty(c, propNode, containingType) : undefined;
             if (libSuggestion !== '')
-                diagnostic = createDiagnosticForNode(propNode, 705 /* Diagnostics.Property_0_does_not_exist_on_type_1_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2_or_later */, [missingProperty, container, libSuggestion]);
+                diagnostic = createDiagnosticForNode(propNode, 712 /* Diagnostics.Property_0_does_not_exist_on_type_1_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2_or_later */, [missingProperty, container, libSuggestion]);
             else if (suggestion !== undefined) {
-                diagnostic = createDiagnosticForNode(propNode, 706 /* Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2 */, [
+                diagnostic = createDiagnosticForNode(propNode, 713 /* Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2 */, [
                     missingProperty,
                     container,
                     suggestion.name,
                 ]);
                 if (suggestion.valueDeclaration !== undefined)
-                    diagnostic.addRelatedInfo(createDiagnosticForNode(suggestion.valueDeclaration, 860 /* Diagnostics.X_0_is_declared_here */, [suggestion.name]));
+                    diagnostic.addRelatedInfo(createDiagnosticForNode(suggestion.valueDeclaration, 867 /* Diagnostics.X_0_is_declared_here */, [suggestion.name]));
             }
             else {
                 chain = elaborateNeverIntersection(c, chain, propNode, containingType);
                 diagnostic = createDiagnosticForNode(propNode, containerSeemsToBeEmptyDomElement(c, containingType)
-                    ? 943 /* Diagnostics.Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom */
-                    : 516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [missingProperty, container]);
+                    ? 950 /* Diagnostics.Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom */
+                    : 523 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [missingProperty, container]);
             }
         }
     }
@@ -591,11 +595,11 @@ export function elaborateNeverIntersection(c, chain, node, t) {
     if ((t.flags & 268435456 /* TypeFlags.Intersection */) === 0 || (lazyObjectFlags(c, t) & 67108864 /* ObjectFlags.IsNeverIntersection */) === 0)
         return chain;
     const props = getPropertiesOfUnionOrIntersectionType(c, t);
-    let message = 1848 /* Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents */;
+    let message = 1868 /* Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents */;
     let prop = props.find((p) => isDiscriminantWithNeverType(c, p));
     if (prop === undefined) {
         message =
-            1849 /* Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_private_in_some */;
+            1869 /* Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_private_in_some */;
         prop = props.find(isConflictingPrivateProperty);
     }
     if (prop === undefined)
@@ -644,7 +648,7 @@ export function typeHasStaticProperty(c, name, containingType) {
 export function getSuggestedSymbolForNonexistentProperty(c, name, containingType) {
     let props = getPropertiesOfType(c, containingType);
     const parent = name.parent;
-    if (parent.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+    if (parent.kind === 213 /* SyntaxKind.PropertyAccessExpression */) {
         const valid = [];
         for (const prop of props)
             if (isValidPropertyAccessForCompletions(c, parent, containingType, prop))
@@ -659,7 +663,7 @@ export function getSuggestionForNonexistentProperty(c, name, containingType) {
 }
 /** Whether `property` of `t` may be accessed at `node` without an error, as completions decide. */
 function isValidPropertyAccessForCompletions(c, node, t, property) {
-    const isSuper = node.kind === 212 /* SyntaxKind.PropertyAccessExpression */ && getExpression(node).kind === 107 /* SyntaxKind.SuperKeyword */;
+    const isSuper = node.kind === 213 /* SyntaxKind.PropertyAccessExpression */ && getExpression(node).kind === 107 /* SyntaxKind.SuperKeyword */;
     if ((t.flags & 1 /* TypeFlags.Any */) !== 0)
         return true;
     // `#private` access in an optional chain is a parse error.

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

@@ -8,6 +8,7 @@ export declare function getSymbolAtLocation(c: Checker, node: Node): Symbol | un
 export declare function getSymbolAtLocationWorker(c: Checker, node: Node, ignoreErrors: boolean): Symbol | undefined;
 /** The type of the expression, type node or declaration at `node`. */
 export declare function getTypeAtLocation(c: Checker, node: Node): Type;
+export declare function getTypeOfNode(c: Checker, node: Node): Type;
 /** The narrowed type of `symbol` at `location`, or its declared type when `location` doesn't reference it. */
 export declare function getTypeOfSymbolAtLocation(c: Checker, symbolIn: Symbol, locationIn: Node | undefined): Type;
 /** The value symbol of a shorthand property assignment's name. */