tsc-ts 0.0.4 → 0.0.5

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

@@ -0,0 +1,672 @@
+// Property access: member lookup on `a.b` and `A.B`, accessibility and readonly checks, and
+// errors for missing members.
+import { ScriptTarget, getUseDefineForClassFields } from './options.js';
+import { checkExternalEmitHelpers } from './checker-emit-helpers.js';
+import { getBody, getExpression, getName, getParameters, getSymbol, getText, getType, BinaryExpression, getInitializer, } from './ast.js';
+import { declarationNameToString, getContainingClass, getSourceFileOfNode, getThisContainer, isAccessExpression, hasSyntacticModifier, isClassLike, isOptionalChain, isPrivateIdentifierClassElementDeclaration, isStatic, skipParentheses, getElementOrPropertyAccessName, isBindableStaticAccessExpression, isBindableStaticNameExpression, } from './binder-utilities.js';
+import { isFunctionLike, isInJSFile } from './ast-utilities.js';
+import { createDiagnosticForNode } from './checker.js';
+import { getSymbolId } from './symbol.js';
+import { everyContainedType, getTargetType, getUnionType, isEmptyObjectType, isErrorType, typesOf, } from './checker-type-factory.js';
+import { getApparentType, getApplicableIndexInfoForName, getDeclarationModifierFlagsFromSymbol, getPropertiesOfType, getPropertiesOfUnionOrIntersectionType, getPropertyOfType, getPropertyOfTypeEx, isConflictingPrivateProperty, isDiscriminantWithNeverType, } from './checker-members.js';
+import { getDeclarationOfAliasSymbol, getParentOfSymbol, getSpellingSuggestionForName, getSymbolOfDeclaration, } from './checker-symbols.js';
+import { getFeatureMap } from './checker-features.js';
+import { lazyObjectFlags } from './side-state.js';
+import { isNodeDescendantOf } from './instantiation.js';
+import { getTypeOfSymbol, getWidenedType, getWriteTypeOfSymbol, isReadonlySymbol } from './checker-symbol-types.js';
+import { getClassLikeDeclarationOfSymbol, getConstraintOfTypeParameter, getDeclaredTypeOfSymbol, hasBaseType, } from './checker-declared-types.js';
+import { getBaseConstraintOfType } from './checker-members.js';
+import { getTypeFromTypeNode } from './checker-type-nodes.js';
+import { isGenericObjectType } from './checker-type-operators.js';
+import { typeToString, symbolToString } from './type-printer.js';
+import { getPromisedTypeOfPromise } from './checker-iteration.js';
+import { getAssignmentTargetKind, getControlFlowContainer } from './checker-narrowing.js';
+import { getSymbolNameForPrivateIdentifier } from './binder.js';
+import { checkPropertyNotUsedBeforeDeclaration } from './checker-declaration-order.js';
+import { grammarErrorOnNode } from './checker-operators.js';
+import { markPropertyAliasReferenced } from './checker-modules.js';
+import { checkDeprecatedIndexSignature, checkDeprecatedProperty } from './checker-deprecation.js';
+import { isSelfTypeAccess, markPropertyAsReferenced } from './checker-unused.js';
+import { getContextualThisParameterType, getFlowTypeOfAccessExpression, getResolvedSymbol, } from './checker-expressions.js';
+import { isJSLiteralType, isThisPropertyAccessInConstructor } from './checker-javascript.js';
+export function checkPropertyAccessExpressionOrQualifiedName(c, node, left, leftType, right, writeOnly, checkMode = 0 /* CheckMode.Normal */) {
+    const parentSymbol = c.resolvedSymbols.get(left.id);
+    const assignmentKind = getAssignmentTargetKind(node);
+    const widenedType = assignmentKind !== 0 /* AssignmentKind.None */ || isMethodAccessForCall(node) ? getWidenedType(c, leftType) : leftType;
+    const apparentType = getApparentType(c, widenedType);
+    const isAnyLike = (apparentType.flags & 1 /* TypeFlags.Any */) !== 0 || apparentType === c.silentNeverType;
+    const name = getText(right);
+    const isPrivate = right.kind === 80 /* SyntaxKind.PrivateIdentifier */;
+    let prop = undefined;
+    if (isPrivate) {
+        // Downleveled private names use __classPrivateFieldGet and __classPrivateFieldSet.
+        if (c.languageVersion < ScriptTarget.ESNext || !getUseDefineForClassFields(c.compilerOptions)) {
+            if (assignmentKind !== 0 /* AssignmentKind.None */)
+                checkExternalEmitHelpers(c, node, 16384 /* ExternalEmitHelpers.ClassPrivateFieldSet */);
+            if (assignmentKind !== 1 /* AssignmentKind.Definite */)
+                checkExternalEmitHelpers(c, node, 8192 /* ExternalEmitHelpers.ClassPrivateFieldGet */);
+        }
+        const lexicallyScopedSymbol = lookupSymbolForPrivateIdentifierDeclaration(name, right);
+        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);
+        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 */);
+                return c.anyType;
+            }
+        }
+        if (lexicallyScopedSymbol !== undefined)
+            prop = getPropertyOfType(c, leftType, lexicallyScopedSymbol.name);
+        if (prop === undefined) {
+            // Shadowing and lexical scoping errors specific to private names.
+            if (checkPrivateIdentifierPropertyAccess(c, leftType, right, lexicallyScopedSymbol))
+                return c.errorType;
+        }
+        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 */);
+    }
+    else {
+        if (isAnyLike) {
+            if (left.kind === 79 /* SyntaxKind.Identifier */ && c.resolvedSymbols.get(left.id) !== undefined)
+                markPropertyAliasReferenced(c, node, undefined, leftType);
+            return isErrorType(c, apparentType) ? c.errorType : apparentType;
+        }
+        prop = getPropertyOfTypeEx(c, apparentType, name, isConstEnumObjectType(apparentType), node.kind === 167 /* SyntaxKind.QualifiedName */);
+    }
+    markPropertyAliasReferenced(c, node, prop, leftType);
+    let propType;
+    if (prop === undefined) {
+        const indexInfo = !isPrivate &&
+            (assignmentKind === 0 /* AssignmentKind.None */ || !isGenericObjectType(c, leftType) || isThisTypeParameter(leftType))
+            ? getApplicableIndexInfoForName(c, apparentType, name)
+            : undefined;
+        if (indexInfo === undefined) {
+            if (isJSLiteralType(c, leftType))
+                return c.anyType;
+            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));
+                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));
+                return c.anyType;
+            }
+            if (name !== '')
+                reportNonexistentProperty(c, right, isThisTypeParameter(leftType) ? apparentType : leftType);
+            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));
+        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);
+        checkDeprecatedIndexSignature(c, right, indexInfo.declaration);
+    }
+    else {
+        checkDeprecatedProperty(c, node, right, prop);
+        checkPropertyNotUsedBeforeDeclaration(c, prop, node, right);
+        markPropertyAsReferenced(c, prop, node, isSelfTypeAccess(c, left, parentSymbol));
+        // An access checked again (under another check mode) usually resolves to the same property.
+        if (c.resolvedSymbols.get(node.id) !== prop)
+            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);
+            return c.errorType;
+        }
+        if (isThisPropertyAccessInConstructor(c, node, prop))
+            propType = c.autoType;
+        else
+            propType =
+                writeOnly || assignmentKind === 1 /* AssignmentKind.Definite */
+                    ? getWriteTypeOfSymbol(c, prop)
+                    : getTypeOfSymbol(c, prop);
+    }
+    return getFlowTypeOfAccessExpression(c, node, prop, propType, right, checkMode);
+}
+/** 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 */)
+        return false;
+    const binary = node.parent.parent;
+    return (binary.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+        binary.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ &&
+        binary.right.kind === 109 /* SyntaxKind.ThisKeyword */);
+}
+function isThisInitializedDeclaration(node) {
+    if (node.kind !== 261 /* SyntaxKind.VariableDeclaration */)
+        return false;
+    const initializer = getInitializer(node);
+    return initializer !== undefined && initializer.kind === 109 /* SyntaxKind.ThisKeyword */;
+}
+// ---- Private names
+/** A private name used as an expression, as in `#x in obj`; records its declaration. */
+export function checkPrivateIdentifierExpression(c, node) {
+    const symbol = getSymbolForPrivateIdentifierExpression(c, node);
+    if (symbol !== undefined)
+        markPropertyAsReferenced(c, symbol, undefined, false);
+    return c.anyType;
+}
+export function getSymbolForPrivateIdentifierExpression(c, node) {
+    let symbol = c.resolvedSymbols.get(node.id);
+    if (symbol === undefined) {
+        symbol = lookupSymbolForPrivateIdentifierDeclaration(getText(node), node);
+        c.resolvedSymbols.set(node.id, symbol);
+    }
+    return symbol;
+}
+/** The declaration of a private name in the enclosing classes, innermost first. */
+function lookupSymbolForPrivateIdentifierDeclaration(name, location) {
+    for (let containingClass = getContainingClassExcludingClassDecorators(location); containingClass !== undefined; containingClass = getContainingClass(containingClass)) {
+        const symbol = getSymbol(containingClass);
+        if (symbol === undefined)
+            continue;
+        const memberName = getSymbolNameForPrivateIdentifier(symbol, name);
+        const prop = symbol.members?.get(memberName) ?? symbol.exports?.get(memberName);
+        if (prop !== undefined)
+            return prop;
+    }
+    return undefined;
+}
+/** The containing class of `node`, skipping classes whose decorators contain it. */
+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.parent !== undefined && isClassLike(current.parent))
+                return getContainingClass(current.parent);
+            break;
+        }
+    }
+    return getContainingClass(node);
+}
+/**
+ * Reports a private name that's on the type but not reachable here: shadowed by another
+ * private name of the same spelling, or accessed outside its class.
+ */
+function checkPrivateIdentifierPropertyAccess(c, leftType, right, lexicallyScopedIdentifier) {
+    let propertyOnType = undefined;
+    for (const symbol of getPropertiesOfType(c, leftType)) {
+        const declaration = symbol.valueDeclaration;
+        const name = declaration !== undefined ? getName(declaration) : undefined;
+        if (name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */ && getText(name) === getText(right)) {
+            propertyOnType = symbol;
+            break;
+        }
+    }
+    if (propertyOnType === undefined)
+        return false;
+    const diagName = declarationNameToString(getSourceFileOfNode(right), right);
+    const typeValueDecl = propertyOnType.valueDeclaration;
+    const typeClass = getContainingClass(typeValueDecl);
+    const lexicalValueDecl = lexicallyScopedIdentifier?.valueDeclaration;
+    if (lexicalValueDecl !== undefined) {
+        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 */, [
+                diagName,
+            ]));
+            diagnostic.addRelatedInfo(createDiagnosticForNode(typeValueDecl, 1840 /* 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)));
+    return true;
+}
+function isThisTypeParameter(t) {
+    return (t.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 && t.isThisType;
+}
+function isConstEnumObjectType(t) {
+    return ((t.objectFlags & 16 /* ObjectFlags.Anonymous */) !== 0 &&
+        t.symbol !== undefined &&
+        (t.symbol.flags & 128 /* SymbolFlags.ConstEnum */) !== 0);
+}
+export function isMethodAccessForCall(node) {
+    let current = node;
+    while (current.parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+        current = current.parent;
+    const parent = current.parent;
+    return ((parent.kind === 214 /* SyntaxKind.CallExpression */ || parent.kind === 215 /* SyntaxKind.NewExpression */) &&
+        getExpression(parent) === current);
+}
+/** Whether `node` is the operand of `delete`, through parentheses. */
+export function isDeleteTarget(node) {
+    if (!isAccessExpression(node))
+        return false;
+    let current = node.parent;
+    while (current.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+        current = current.parent;
+    return current.kind === 221 /* SyntaxKind.DeleteExpression */;
+}
+/** Whether assigning through `expr` targets a readonly entity, outside of initialization. */
+export function isAssignmentToReadonlyEntity(c, expr, symbol, assignmentKind) {
+    if (assignmentKind === 0 /* AssignmentKind.None */)
+        return false;
+    // CommonJS `module.exports` is never readonly.
+    if (isAccessExpression(expr)) {
+        const target = skipParentheses(getExpression(expr));
+        if (target.kind === 79 /* SyntaxKind.Identifier */ && (getResolvedSymbol(c, target).flags & 134217728 /* SymbolFlags.ModuleExports */) !== 0)
+            return false;
+    }
+    if (isReadonlySymbol(c, symbol)) {
+        // Readonly properties may be assigned through `this` in the constructor of their class.
+        if ((symbol.flags & 4 /* SymbolFlags.Property */) !== 0 &&
+            isAccessExpression(expr) &&
+            getExpression(expr).kind === 109 /* SyntaxKind.ThisKeyword */) {
+            const ctor = getControlFlowContainer(expr);
+            if (ctor.kind !== 177 /* 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 parentDeclaration = symbol.parent?.valueDeclaration;
+                const isLocalThisPropertyAssignment = isAssignmentDeclaration && (parentDeclaration === ctor.parent || parentDeclaration === ctor);
+                return !isLocalPropertyDeclaration && !isLocalParameterProperty && !isLocalThisPropertyAssignment;
+            }
+        }
+        return true;
+    }
+    if (isAccessExpression(expr)) {
+        // References through namespace imports are readonly.
+        const node = skipParentheses(getExpression(expr));
+        if (node.kind === 79 /* SyntaxKind.Identifier */) {
+            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 false;
+}
+// ---- Accessibility
+/** 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 */)
+        errorNode = node.name;
+    else if (node.kind === 167 /* SyntaxKind.QualifiedName */)
+        errorNode = node.right;
+    else if (node.kind === 206 /* SyntaxKind.ImportType */)
+        errorNode = node;
+    else if (node.kind === 209 /* SyntaxKind.BindingElement */)
+        errorNode = node.propertyName ?? node.name;
+    else
+        errorNode = getName(node) ?? node;
+    return checkPropertyAccessibilityAtLocation(c, node, isSuper, writing, containingType, prop, errorNode);
+}
+/** Whether `prop` of `containingType` may be accessed at `node`, without reporting errors. */
+export function isPropertyAccessible(c, node, isSuper, isWrite, containingType, prop) {
+    if ((containingType.flags & 1 /* TypeFlags.Any */) !== 0)
+        return true;
+    // A #private property access in an optional chain is an error the parser reports.
+    const declaration = prop.valueDeclaration;
+    if (declaration !== undefined && isPrivateIdentifierClassElementDeclaration(declaration)) {
+        const declaringClass = getContainingClass(declaration);
+        return !isOptionalChain(node) && declaringClass !== undefined && isNodeDescendantOf(node, declaringClass);
+    }
+    return checkPropertyAccessibilityAtLocation(c, node, isSuper, isWrite, containingType, prop, undefined);
+}
+function checkPropertyAccessibilityAtLocation(c, location, isSuper, writing, containingTypeIn, prop, errorNode) {
+    const flags = getDeclarationModifierFlagsFromSymbol(c, prop, writing);
+    if (isSuper) {
+        // 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)));
+            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));
+            return false;
+        }
+    }
+    // Abstract properties can't be read during initialization of their class.
+    if ((flags & 64 /* ModifierFlags.Abstract */) !== 0 &&
+        symbolHasNonMethodDeclaration(c, prop) &&
+        (isThisProperty(location) ||
+            isThisInitializedObjectBindingExpression(location) ||
+            (location.parent.kind === 207 /* 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));
+            return false;
+        }
+    }
+    if ((flags & 6 /* ModifierFlags.NonPublicAccessibilityModifier */) === 0)
+        return true;
+    // Private members are accessible within their declaring class.
+    if ((flags & 2 /* ModifierFlags.Private */) !== 0) {
+        const parent = getParentOfSymbol(c, prop);
+        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)));
+            return false;
+        }
+        return true;
+    }
+    // Protected members of a supertype are accessible through `super`.
+    if (isSuper)
+        return true;
+    // The first enclosing class deriving from the declaring classes of the protected constituents.
+    let enclosingClass = undefined;
+    for (let container = getContainingClass(location); container !== undefined; container = getContainingClass(container)) {
+        const classSymbol = getSymbolOfDeclaration(c, container);
+        if (classSymbol === undefined)
+            continue;
+        const classType = getDeclaredTypeOfSymbol(c, classSymbol);
+        if (isClassDerivedFromDeclaringClasses(c, classType, prop, writing)) {
+            enclosingClass = classType;
+            break;
+        }
+    }
+    if (enclosingClass === undefined) {
+        // Functions with a `this` parameter of a derived class may access instance members.
+        const thisClass = getEnclosingClassFromThisParameter(c, location);
+        if (thisClass !== undefined && isClassDerivedFromDeclaringClasses(c, thisClass, prop, writing))
+            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));
+            return false;
+        }
+    }
+    if ((flags & 256 /* ModifierFlags.Static */) !== 0)
+        return true;
+    let containingType = containingTypeIn;
+    if ((containingType.flags & 524288 /* TypeFlags.TypeParameter */) !== 0)
+        containingType = containingType.isThisType
+            ? getConstraintOfTypeParameter(c, containingType)
+            : 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));
+        return false;
+    }
+    return true;
+}
+function hasClassInstancePropertyDeclaration(symbol) {
+    for (const d of symbol.declarations)
+        if (isClassInstanceProperty(d))
+            return true;
+    return false;
+}
+function isClassInstanceProperty(node) {
+    // `this.x = v` in JavaScript declares a field, but `C.prototype.x = v` and `C.x = v` don't.
+    if (isInJSFile(node) && node instanceof BinaryExpression) {
+        const left = node.left;
+        return ((!isBindableStaticAccessExpression(left, false) || !isPrototypeAccess(getExpression(left))) &&
+            !isBindableStaticNameExpression(left, true));
+    }
+    return (node.parent !== undefined &&
+        isClassLike(node.parent) &&
+        node.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+        !isStatic(node) &&
+        !hasSyntacticModifier(node, 512 /* ModifierFlags.Accessor */));
+}
+function isPrototypeAccess(node) {
+    if (!isBindableStaticAccessExpression(node, false))
+        return false;
+    const name = getElementOrPropertyAccessName(node);
+    return name !== undefined && getText(name) === 'prototype';
+}
+function isThisProperty(node) {
+    return isAccessExpression(node) && getExpression(node).kind === 109 /* SyntaxKind.ThisKeyword */;
+}
+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 */)
+            return true;
+        if (isClassLike(element) || isFunctionLike(element))
+            return false;
+    }
+    return false;
+}
+/** The declaring class of a class member. */
+export function getDeclaringClass(c, prop) {
+    if (prop.parent === undefined || (prop.parent.flags & 32 /* SymbolFlags.Class */) === 0)
+        return undefined;
+    return getDeclaredTypeOfSymbol(c, getParentOfSymbol(c, prop));
+}
+function isNodeWithinClass(node, classDeclaration) {
+    for (let container = getContainingClass(node); container !== undefined; container = getContainingClass(container))
+        if (container === classDeclaration)
+            return true;
+    return false;
+}
+/** The properties a possibly synthetic union or intersection property stands for. */
+function getUnderlyingProperties(c, prop, out) {
+    if ((prop.checkFlags & 6 /* CheckFlags.Synthetic */) === 0) {
+        out.push(prop);
+        return;
+    }
+    const containingType = c.symbolContainingTypes.get(getSymbolId(prop));
+    if (containingType === undefined)
+        return;
+    for (const t of typesOf(containingType)) {
+        const p = getPropertyOfType(c, t, prop.name);
+        if (p !== undefined)
+            getUnderlyingProperties(c, p, out);
+    }
+}
+function symbolHasNonMethodDeclaration(c, symbol) {
+    const props = [];
+    getUnderlyingProperties(c, symbol, props);
+    for (const p of props)
+        if ((p.flags & 8192 /* SymbolFlags.Method */) === 0)
+            return true;
+    return false;
+}
+function isClassDerivedFromDeclaringClasses(c, checkClass, prop, writing) {
+    const props = [];
+    getUnderlyingProperties(c, prop, props);
+    for (const p of props) {
+        if ((getDeclarationModifierFlagsFromSymbol(c, p, writing) & 4 /* ModifierFlags.Protected */) === 0)
+            continue;
+        const declaringClass = getDeclaringClass(c, p);
+        if (declaringClass === undefined || !hasBaseType(c, checkClass, declaringClass))
+            return false;
+    }
+    return true;
+}
+function getEnclosingClassFromThisParameter(c, node) {
+    const thisContainer = getThisContainer(node, false, false);
+    let thisType = undefined;
+    if (isFunctionLike(thisContainer)) {
+        const thisParameter = getThisParameterDeclaration(thisContainer);
+        const typeNode = thisParameter !== undefined ? getType(thisParameter) : undefined;
+        if (typeNode !== undefined) {
+            thisType = getTypeFromTypeNode(c, typeNode);
+            if ((thisType.flags & 524288 /* TypeFlags.TypeParameter */) !== 0)
+                thisType = getConstraintOfTypeParameter(c, thisType);
+        }
+        else
+            thisType = getContextualThisParameterType(c, thisContainer);
+    }
+    if (thisType !== undefined && (thisType.objectFlags & (3 /* ObjectFlags.ClassOrInterface */ | 4 /* ObjectFlags.Reference */)) !== 0)
+        return getTargetType(thisType);
+    return undefined;
+}
+/** The explicit `this` parameter of a function, if any. */
+function getThisParameterDeclaration(func) {
+    const parameters = getParameters(func);
+    if (parameters === undefined || parameters.nodes.length === 0)
+        return undefined;
+    const first = parameters.nodes[0];
+    const name = getName(first);
+    return name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */ && getText(name) === 'this' ? first : undefined;
+}
+// ---- Missing properties
+/** Reports a missing property once per name node, with the most helpful message available. */
+export function reportNonexistentProperty(c, propNode, containingType) {
+    const links = c.nodeLinks(propNode);
+    if ((links.flags & 1) !== 0)
+        return;
+    links.flags |= 1;
+    const name = getText(propNode);
+    const missingProperty = declarationNameToString(getSourceFileOfNode(propNode), propNode);
+    const container = typeToString(c, containingType);
+    let chain = undefined;
+    if (propNode.kind !== 80 /* SyntaxKind.PrivateIdentifier */ &&
+        (containingType.flags & 134217728 /* TypeFlags.Union */) !== 0 &&
+        (containingType.flags & 12713980 /* TypeFlags.Primitive */) === 0) {
+        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 */, [
+                    missingProperty,
+                    typeToString(c, subtype),
+                ]);
+                break;
+            }
+        }
+    }
+    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]);
+    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 */, [
+                missingProperty,
+                container,
+            ]);
+            diagnostic.addRelatedInfo(createDiagnosticForNode(propNode, 905 /* 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]);
+            else if (suggestion !== undefined) {
+                diagnostic = createDiagnosticForNode(propNode, 706 /* 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]));
+            }
+            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]);
+            }
+        }
+    }
+    if (chain !== undefined)
+        diagnostic.addMessageChain(chain);
+    c.addDiagnostic(diagnostic);
+}
+/**
+ * `chain` under the reason an intersection reduced to `never` when `t` is one: a property with conflicting
+ * literal types, or one private in some constituents.
+ */
+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 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 */;
+        prop = props.find(isConflictingPrivateProperty);
+    }
+    if (prop === undefined)
+        return chain;
+    const result = createDiagnosticForNode(node, message, [
+        typeToString(c, t, undefined, 536870912 /* TypeFormatFlags.NoTypeReduction */),
+        symbolToString(c, prop),
+    ]);
+    return result.addMessageChain(chain);
+}
+/** The library that adds `missingProperty` to the apparent type's global, or '' if none does. */
+function getSuggestedLibForNonExistentProperty(c, missingProperty, containingType) {
+    const container = getApparentType(c, containingType).symbol;
+    if (container === undefined)
+        return '';
+    const entries = getFeatureMap().get(container.name);
+    if (entries !== undefined)
+        for (const entry of entries)
+            if (entry.props.includes(missingProperty))
+                return entry.lib;
+    return '';
+}
+/** Whether the type looks like an empty DOM type, as when the DOM lib is missing. */
+function containerSeemsToBeEmptyDomElement(c, containingType) {
+    return (!(c.compilerOptions.lib ?? []).includes('lib.dom.d.ts') &&
+        everyContainedType(containingType, hasCommonDomTypeName) &&
+        isEmptyObjectType(c, containingType));
+}
+function hasCommonDomTypeName(t) {
+    if (t.symbol === undefined)
+        return false;
+    const name = t.symbol.name;
+    return (name === 'EventTarget' ||
+        name === 'Node' ||
+        name === 'Element' ||
+        (name.startsWith('HTML') && name.endsWith('Element')));
+}
+/** Whether the type's symbol has a static member `name`, as when an instance member was expected. */
+export function typeHasStaticProperty(c, name, containingType) {
+    if (containingType.symbol === undefined)
+        return false;
+    const prop = getPropertyOfType(c, getTypeOfSymbol(c, containingType.symbol), name);
+    return prop !== undefined && prop.valueDeclaration !== undefined && isStatic(prop.valueDeclaration);
+}
+/** The value member with the closest name, for "Did you mean" suggestions. */
+export function getSuggestedSymbolForNonexistentProperty(c, name, containingType) {
+    let props = getPropertiesOfType(c, containingType);
+    const parent = name.parent;
+    if (parent.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+        const valid = [];
+        for (const prop of props)
+            if (isValidPropertyAccessForCompletions(c, parent, containingType, prop))
+                valid.push(prop);
+        props = valid;
+    }
+    return getSpellingSuggestionForName(c, getText(name), props, 111551 /* SymbolFlags.Value */);
+}
+/** The value property of `containingType` with the closest name to `name`. */
+export function getSuggestionForNonexistentProperty(c, name, containingType) {
+    return getSpellingSuggestionForName(c, name, getPropertiesOfType(c, containingType), 111551 /* SymbolFlags.Value */);
+}
+/** 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 */;
+    if ((t.flags & 1 /* TypeFlags.Any */) !== 0)
+        return true;
+    // `#private` access in an optional chain is a parse error.
+    const declaration = property.valueDeclaration;
+    if (declaration !== undefined && isPrivateIdentifierClassElementDeclaration(declaration)) {
+        const declClass = getContainingClass(declaration);
+        return !isOptionalChain(node) && declClass !== undefined && isNodeDescendantOf(node, declClass);
+    }
+    return checkPropertyAccessibilityAtLocation(c, node, isSuper, false, t, property, undefined);
+}