tsc-ts 0.0.4 → 0.0.6

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

@@ -0,0 +1,30 @@
+import { 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';
+import { type Symbol } from './symbol.js';
+export declare function checkClassDeclaration(c: Checker, node: Node): void;
+/** Checks a class expression each time it is checked; its members are checked deferred. */
+export declare function checkClassExpression(c: Checker, node: Node): Type;
+export declare function checkClassLikeDeferred(c: Checker, node: Node): void;
+/** Reports a class, interface, enum or type alias named after a predefined type. */
+export declare function checkTypeNameIsReserved(c: Checker, name: Node, message: DiagnosticMessage): void;
+/** Accessor checks beyond the body: returns, `constructor` names and getter/setter agreement. */
+export declare function checkAccessorDeclaration(c: Checker, node: Node): void;
+/** Whether `this.name` is definitely assigned at the end of the constructor, by control flow. */
+export declare function isPropertyInitializedInConstructor(c: Checker, propName: Node, propType: Type, constructor: Node): boolean;
+/** Whether a static block between `startPos` and `endPos` definitely assigns `this.name`. */
+export declare function isPropertyInitializedInStaticBlocks(c: Checker, propName: Node, propType: Type, staticBlocks: readonly Node[], startPos: number, endPos: number): boolean;
+/** The type of an unannotated, uninitialized property from its `this` assignments in the constructor. */
+export declare function getFlowTypeInConstructor(c: Checker, symbol: Symbol, constructor: Node): Type | undefined;
+/** The type of an unannotated, uninitialized static property from its `this` assignments in static blocks. */
+export declare function getFlowTypeInStaticBlocks(c: Checker, symbol: Symbol, staticBlocks: Node[]): Type | undefined;
+/** The control flow type of `this.x` at `reference`, from `undefined` or the base class property type. */
+export declare function getFlowTypeOfProperty(c: Checker, reference: Node, prop: Symbol): Type;
+/** Whether a property's type comes from its assignments: it has no annotation or initializer. */
+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;
+export declare function checkInterfaceDeclaration(c: Checker, node: Node): void;

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

@@ -0,0 +1,582 @@
+// Classes and interfaces.
+import { checkCollisionsForDeclarationName, markPrivateIdentifierScope } from './checker-generated-code.js';
+import { isNamedEvaluationSource } from './transformers/named-evaluation.js';
+import { classOrConstructorParameterIsDecorated } from './transformers/decorator-utilities.js';
+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 { ScriptTarget, getEmitScriptTarget, getUseDefineForClassFields } from './options.js';
+import { hasDynamicName, hasLateBindableName } from './checker-utilities.js';
+import { everyType, getTargetType, typesOf } from './checker-type-factory.js';
+import { symbolToString, typeToString } from './type-printer.js';
+import { getDeclaringClass } from './checker-property-access.js';
+import { getBaseConstructorTypeOfClass, getBaseTypes, getDeclaredTypeOfSymbol, getClassLikeDeclarationOfSymbol, getExtendsHeritageClauseElement, isMixinConstructorType, } from './checker-declared-types.js';
+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 { 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 { 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';
+export function checkClassDeclaration(c, node) {
+    checkClassLikeDeclaration(c, node);
+    checkClassMembers(c, node);
+}
+/** Checks a class expression each time it is checked; its members are checked deferred. */
+export function checkClassExpression(c, node) {
+    checkClassLikeDeclaration(c, node);
+    checkNodeDeferred(c, node);
+    checkClassExpressionExternalHelpers(c, node);
+    const symbol = getSymbolOfDeclaration(c, node);
+    return symbol !== undefined ? getTypeOfSymbol(c, symbol) : c.anyType;
+}
+/** An anonymous class expression whose emit sets its name (__setFunctionName), and computes the key (__propKey). */
+function checkClassExpressionExternalHelpers(c, node) {
+    if (getName(node) !== undefined)
+        return;
+    let parent = node.parent;
+    while (parent !== undefined && isOuterExpression(parent, 63 /* OuterExpressionKinds.All */))
+        parent = parent.parent;
+    if (parent === undefined || !isNamedEvaluationSource(parent))
+        return;
+    const willTransformESDecorators = !c.legacyDecorators && c.languageVersion < ScriptTarget.ESNext;
+    let location;
+    if (willTransformESDecorators && classOrConstructorParameterIsDecorated(false, node)) {
+        location = node;
+        for (const modifier of getModifiers(node)?.nodes ?? [])
+            if (modifier.kind === 171 /* SyntaxKind.Decorator */) {
+                location = modifier;
+                break;
+            }
+    }
+    else
+        location = getFirstTransformableStaticClassElement(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 */)
+        checkExternalEmitHelpers(c, location, 131072 /* ExternalEmitHelpers.PropKey */);
+}
+export function checkClassLikeDeferred(c, node) {
+    checkClassMembers(c, node);
+}
+function checkClassMembers(c, node) {
+    for (const member of getMembers(node).nodes)
+        checkClassMember(c, member);
+}
+function checkClassLikeDeclaration(c, node) {
+    checkDecorators(c, node);
+    checkCollisionsForDeclarationName(c, node, getName(node));
+    if (node.kind === 264 /* SyntaxKind.ClassDeclaration */)
+        checkExportsOnMergedDeclarations(c, node);
+    const typeParameters = getTypeParameters(node);
+    checkTypeParameters(c, typeParameters);
+    const symbol = getSymbolOfDeclaration(c, node);
+    if (symbol !== undefined) {
+        const t = getDeclaredTypeOfSymbol(c, symbol);
+        getTypeOfSymbol(c, symbol);
+        if ((t.flags & 1048576 /* TypeFlags.Object */) !== 0) {
+            getBaseConstructorTypeOfClass(c, t);
+            getBaseTypes(c, t);
+        }
+    }
+    const name = getName(node);
+    if (name !== undefined)
+        checkTypeNameIsReserved(c, name, 585 /* Diagnostics.Class_name_cannot_be_0 */);
+    const heritageClauses = getHeritageClauses(node);
+    if (heritageClauses !== undefined)
+        checkHeritageClauses(c, heritageClauses.nodes, true);
+    checkClassHeritage(c, node);
+    checkPropertyInitialization(c, node);
+}
+/** Reports a class, interface, enum or type alias named after a predefined type. */
+export function checkTypeNameIsReserved(c, name, message) {
+    switch (getText(name)) {
+        case 'any':
+        case 'unknown':
+        case 'never':
+        case 'number':
+        case 'bigint':
+        case 'boolean':
+        case 'string':
+        case 'symbol':
+        case 'void':
+        case 'object':
+        case 'undefined':
+            c.error(name, message, getText(name));
+    }
+}
+function checkHeritageClauses(c, clauses, isClass) {
+    // Only the first clause of each kind counts; others are syntax errors.
+    let seenExtends = false;
+    let seenImplements = false;
+    for (const clause of clauses) {
+        if (clause.token === 118 /* SyntaxKind.ImplementsKeyword */) {
+            if (seenImplements)
+                continue;
+            seenImplements = true;
+        }
+        else {
+            if (seenExtends)
+                continue;
+            seenExtends = true;
+        }
+        for (const t of clause.types.nodes) {
+            const args = getTypeArguments(t);
+            if (args !== undefined)
+                for (const a of args.nodes)
+                    checkSourceElement(c, a);
+            if (!isClass || clause.token === 118 /* SyntaxKind.ImplementsKeyword */)
+                checkSourceElement(c, t);
+        }
+    }
+}
+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 */)
+        markPrivateIdentifierScope(c, member);
+    switch (member.kind) {
+        case 173 /* 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 */: {
+            checkDecorators(c, member);
+            const name = getName(member);
+            if (name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+                checkComputedPropertyName(c, name);
+            const symbol = getSymbolOfDeclaration(c, member);
+            if (symbol !== undefined && member.kind !== 177 /* SyntaxKind.Constructor */)
+                getTypeOfSymbol(c, symbol);
+            checkFunctionLikeBody(c, member);
+            if (member.kind === 175 /* SyntaxKind.MethodDeclaration */) {
+                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 */) {
+                if (symbol !== undefined)
+                    checkFunctionOrConstructorSymbol(c, symbol);
+                checkConstructorSuperCall(c, member);
+            }
+            else
+                checkAccessorDeclaration(c, member);
+            return;
+        }
+        case 182 /* SyntaxKind.IndexSignature */:
+            checkSignatureDeclarationTypes(c, member);
+            return;
+        case 176 /* SyntaxKind.ClassStaticBlockDeclaration */: {
+            const body = getBody(member);
+            if (body !== undefined)
+                for (const s of getStatements(body).nodes)
+                    checkSourceElement(c, s);
+            return;
+        }
+    }
+}
+/** Accessor checks beyond the body: returns, `constructor` names and getter/setter agreement. */
+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 */ &&
+        (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 */);
+    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 */);
+    if (getter === undefined || setter === undefined)
+        return;
+    const links = c.nodeLinks(getter);
+    if ((links.flags & 1 /* NodeCheckFlags.TypeChecked */) !== 0)
+        return;
+    links.flags |= 1 /* NodeCheckFlags.TypeChecked */;
+    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 */);
+    }
+    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 */);
+    }
+}
+/** Derived class constructors must call `super`, at the root when properties are initialized. */
+function checkConstructorSuperCall(c, node) {
+    const body = getBody(node);
+    if (nodeIsMissing(body))
+        return;
+    const classDecl = node.parent;
+    if (getExtendsHeritageClauseElement(classDecl) === undefined)
+        return;
+    const classSymbol = getSymbolOfDeclaration(c, classDecl);
+    const classType = classSymbol !== undefined ? getDeclaredTypeOfSymbol(c, classSymbol) : undefined;
+    const classExtendsNull = classType !== undefined &&
+        (classType.flags & 1048576 /* TypeFlags.Object */) !== 0 &&
+        getBaseConstructorTypeOfClass(c, classType) === c.nullWideningType;
+    const finder = new SuperCallFinder();
+    body.forEachChild(finder);
+    const superCall = finder.superCall;
+    if (superCall === undefined) {
+        if (!classExtendsNull)
+            c.error(node, 551 /* 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 */);
+    const emitStandardClassFields = getUseDefineForClassFields(c.compilerOptions) && getEmitScriptTarget(c.compilerOptions) >= ScriptTarget.ES2022;
+    if (emitStandardClassFields)
+        return;
+    // Until there's better flow analysis, the super call must be a root statement when properties are initialized.
+    if (!needsRootLevelSuperCall(classDecl, node))
+        return;
+    let parent = superCall.parent;
+    while (parent.kind === 218 /* 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 */);
+        return;
+    }
+    for (const statement of getStatements(body).nodes) {
+        if (statement.kind === 245 /* 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 */);
+}
+function isSuperCall(node) {
+    return node.kind === 214 /* 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 */)
+        n = getExpression(n);
+    return n;
+}
+function needsRootLevelSuperCall(classDecl, constructor) {
+    for (const m of getMembers(classDecl).nodes)
+        if (isInstancePropertyWithInitializerOrPrivateIdentifierProperty(m))
+            return true;
+    for (const p of getParameters(constructor).nodes)
+        if (hasSyntacticModifier(p, 31 /* ModifierFlags.ParameterPropertyModifier */))
+            return true;
+    return false;
+}
+function isInstancePropertyWithInitializerOrPrivateIdentifierProperty(n) {
+    return (isPrivateIdentifierClassElementDeclaration(n) ||
+        (n.kind === 173 /* SyntaxKind.PropertyDeclaration */ && !isStatic(n) && getInitializer(n) !== undefined));
+}
+/** Finds the first `super(...)` call outside nested functions. */
+class SuperCallFinder extends NodeVisitor {
+    superCall = undefined;
+    visitNode(node) {
+        if (isSuperCall(node)) {
+            this.superCall = node;
+            return true;
+        }
+        if (isFunctionLike(node))
+            return false;
+        return node.forEachChild(this);
+    }
+}
+/** Finds `super` or `this` outside nested functions, properties and member bodies. */
+class SuperOrThisReferenceFinder extends NodeVisitor {
+    visitNode(node) {
+        switch (node.kind) {
+            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 */:
+                return false;
+            case 242 /* SyntaxKind.Block */:
+                switch (node.parent.kind) {
+                    case 177 /* SyntaxKind.Constructor */:
+                    case 175 /* SyntaxKind.MethodDeclaration */:
+                    case 178 /* SyntaxKind.GetAccessor */:
+                    case 179 /* SyntaxKind.SetAccessor */:
+                        return false;
+                }
+        }
+        return node.forEachChild(this);
+    }
+}
+function nodeImmediatelyReferencesSuperOrThis(node) {
+    return new SuperOrThisReferenceFinder().visitNode(node);
+}
+function checkSignatureDeclarationTypes(c, node) {
+    checkTypeNodeIfPresent(c, node);
+}
+// ---- Strict property initialization
+function checkPropertyInitialization(c, node) {
+    if (!c.strictNullChecks || !c.strictPropertyInitialization || (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
+        return;
+    const constructor = findConstructorDeclaration(node);
+    for (const member of getMembers(node).nodes) {
+        if (member.kind !== 173 /* SyntaxKind.PropertyDeclaration */)
+            continue;
+        if (hasSyntacticModifier(member, 128 /* ModifierFlags.Ambient */) ||
+            hasSyntacticModifier(member, 64 /* ModifierFlags.Abstract */) ||
+            isStatic(member))
+            continue;
+        const prop = member;
+        if (prop.initializer !== undefined || prop.postfixToken !== undefined)
+            continue;
+        const propName = prop.name;
+        if (propName.kind !== 79 /* SyntaxKind.Identifier */ &&
+            propName.kind !== 80 /* SyntaxKind.PrivateIdentifier */ &&
+            propName.kind !== 168 /* SyntaxKind.ComputedPropertyName */)
+            continue;
+        const symbol = getSymbolOfDeclaration(c, member);
+        if (symbol === undefined)
+            continue;
+        const t = getTypeOfSymbol(c, symbol);
+        if ((t.flags & 3 /* TypeFlags.AnyOrUnknown */) !== 0 || containsUndefinedType(t))
+            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));
+    }
+}
+/** Whether `this.name` is definitely assigned at the end of the constructor, by control flow. */
+export function isPropertyInitializedInConstructor(c, propName, propType, constructor) {
+    const thisExpression = new KeywordExpression(109 /* SyntaxKind.ThisKeyword */);
+    const returnFlowNode = constructor.returnFlowNode;
+    let reference;
+    if (propName.kind === 168 /* SyntaxKind.ComputedPropertyName */) {
+        const access = new ElementAccessExpression(thisExpression, undefined, getExpression(propName), 0 /* NodeFlags.None */);
+        access.flowNode = returnFlowNode;
+        reference = access;
+    }
+    else {
+        const access = new PropertyAccessExpression(thisExpression, undefined, propName, 0 /* NodeFlags.None */);
+        access.flowNode = returnFlowNode;
+        reference = access;
+    }
+    thisExpression.parent = reference;
+    reference.parent = constructor;
+    const flowType = getFlowTypeOfReference(c, reference, propType, getOptionalType(c, propType, false), undefined);
+    return !containsUndefinedType(flowType);
+}
+/** Whether a static block between `startPos` and `endPos` definitely assigns `this.name`. */
+export function isPropertyInitializedInStaticBlocks(c, propName, propType, staticBlocks, startPos, endPos) {
+    // Static blocks run in document order, unlike constructors.
+    for (const staticBlock of staticBlocks) {
+        if (staticBlock.pos < startPos || staticBlock.pos > endPos)
+            continue;
+        const thisExpression = new KeywordExpression(109 /* SyntaxKind.ThisKeyword */);
+        const reference = new PropertyAccessExpression(thisExpression, undefined, propName, 0 /* NodeFlags.None */);
+        reference.flowNode = staticBlock.returnFlowNode;
+        thisExpression.parent = reference;
+        reference.parent = staticBlock;
+        const flowType = getFlowTypeOfReference(c, reference, propType, getOptionalType(c, propType, false), undefined);
+        if (!containsUndefinedType(flowType))
+            return true;
+    }
+    return false;
+}
+/** The type of an unannotated, uninitialized property from its `this` assignments in the constructor. */
+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));
+    // Assignments of only null or undefined infer nothing.
+    if (everyType(flowType, (t) => hasTypeFacts(c, t, 50331648 /* TypeFacts.IsUndefinedOrNull */)))
+        return undefined;
+    return convertAutoToAny(c, flowType);
+}
+/** The type of an unannotated, uninitialized static property from its `this` assignments in static blocks. */
+export function getFlowTypeInStaticBlocks(c, symbol, staticBlocks) {
+    for (const staticBlock of 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));
+        if (everyType(flowType, (t) => hasTypeFacts(c, t, 50331648 /* TypeFacts.IsUndefinedOrNull */)))
+            continue;
+        return convertAutoToAny(c, flowType);
+    }
+    return undefined;
+}
+/** A synthetic `this.name` at the end of `container`. */
+function newThisPropertyReference(symbol, container, flowNode) {
+    const name = symbol.name;
+    let accessName;
+    if (name.startsWith('\ufffe#'))
+        accessName = new PrivateIdentifier(name.substring(name.indexOf('@') + 1));
+    else
+        accessName = new Identifier(name);
+    const thisExpression = new KeywordExpression(109 /* SyntaxKind.ThisKeyword */);
+    const reference = new PropertyAccessExpression(thisExpression, undefined, accessName, 0 /* NodeFlags.None */);
+    thisExpression.parent = reference;
+    accessName.parent = reference;
+    reference.parent = container;
+    reference.flowNode = flowNode;
+    return reference;
+}
+/** The control flow type of `this.x` at `reference`, from `undefined` or the base class property type. */
+export function getFlowTypeOfProperty(c, reference, prop) {
+    let initialType = c.undefinedType;
+    const declaration = prop.valueDeclaration;
+    if (declaration !== undefined &&
+        (!isAutoTypedProperty(c, prop) || hasSyntacticModifier(declaration, 128 /* ModifierFlags.Ambient */))) {
+        const baseType = getTypeOfPropertyInBaseClass(c, prop);
+        if (baseType !== undefined)
+            initialType = baseType;
+    }
+    return getFlowTypeOfReference(c, reference, c.autoType, initialType, undefined);
+}
+/** Whether a property's type comes from its assignments: it has no annotation or initializer. */
+export function isAutoTypedProperty(c, symbol) {
+    const declaration = symbol.valueDeclaration;
+    return (declaration !== undefined &&
+        declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+        getType(declaration) === undefined &&
+        getInitializer(declaration) === undefined &&
+        c.noImplicitAny);
+}
+/** The type of the property in the first base class, if it has one. */
+export function getTypeOfPropertyInBaseClass(c, property) {
+    const classType = getDeclaringClass(c, property);
+    if (classType === undefined)
+        return undefined;
+    const baseClassTypes = getBaseTypes(c, classType);
+    return baseClassTypes.length > 0 ? getTypeOfPropertyOfType(c, baseClassTypes[0], property.name) : undefined;
+}
+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;
+    }
+    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 false;
+}
+/** Whether `target` is a base class of `t`, through bases that aren't mixins. */
+function typeHasProtectedAccessibleBase(c, target, t) {
+    const baseTypes = getBaseTypes(c, getTargetType(t));
+    if (baseTypes.length === 0)
+        return false;
+    const firstBase = baseTypes[0];
+    if ((firstBase.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        const types = typesOf(firstBase);
+        const mixinFlags = findMixins(c, types);
+        for (let i = 0; i < types.length; i++) {
+            const member = types[i];
+            if (mixinFlags[i] || (member.objectFlags & (1 /* ObjectFlags.Class */ | 2 /* ObjectFlags.Interface */)) === 0)
+                continue;
+            if (member.symbol === target || typeHasProtectedAccessibleBase(c, target, member))
+                return true;
+        }
+        return false;
+    }
+    return firstBase.symbol === target || typeHasProtectedAccessibleBase(c, target, firstBase);
+}
+/** Which of an intersection's constituents are mixin constructors; one stays if all constructors are. */
+function findMixins(c, types) {
+    const mixinFlags = [];
+    let constructorTypeCount = 0;
+    let mixinCount = 0;
+    let firstMixinIndex = -1;
+    for (let i = 0; i < types.length; i++) {
+        const isMixin = isMixinConstructorType(c, types[i]);
+        mixinFlags.push(isMixin);
+        if (getSignaturesOfType(c, types[i], 1 /* SignatureKind.Construct */).length > 0)
+            constructorTypeCount++;
+        if (isMixin) {
+            if (firstMixinIndex < 0)
+                firstMixinIndex = i;
+            mixinCount++;
+        }
+    }
+    if (constructorTypeCount > 0 && constructorTypeCount === mixinCount)
+        mixinFlags[firstMixinIndex] = false;
+    return mixinFlags;
+}
+// ---- Interfaces
+export function checkInterfaceDeclaration(c, node) {
+    const decl = node;
+    checkTypeParameters(c, decl.typeParameters);
+    checkTypeNameIsReserved(c, decl.name, 596 /* Diagnostics.Interface_name_cannot_be_0 */);
+    checkExportsOnMergedDeclarations(c, node);
+    const symbol = getSymbolOfDeclaration(c, node);
+    if (symbol !== undefined) {
+        const t = getDeclaredTypeOfSymbol(c, symbol);
+        getBaseTypes(c, t);
+        getIndexInfosOfType(c, t);
+    }
+    checkInterfaceHeritage(c, node);
+    if (decl.heritageClauses !== undefined)
+        checkHeritageClauses(c, decl.heritageClauses.nodes, false);
+    for (const member of decl.members.nodes) {
+        checkJSDocLinksOfNode(c, member);
+        if (member.kind === 172 /* SyntaxKind.PropertySignature */)
+            checkVariableLikeDeclaration(c, member);
+        else
+            checkTypeNodeIfPresent(c, member);
+    }
+    checkClassOrInterfaceForDuplicateIndexSignatures(c, node);
+}