tsc-ts 0.0.4 → 0.0.5

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

@@ -0,0 +1,888 @@
+// Declarations: variables, parameters, functions, type aliases, enums, namespaces, imports, exports.
+import { checkCollisionsForDeclarationName } from './checker-generated-code.js';
+import { checkExternalEmitHelpers } from './checker-emit-helpers.js';
+import { convertAutoToAny } from './checker-narrowing.js';
+import { markPropertyAsReferenced } from './checker-unused.js';
+import { NodeVisitor, getExpression, getInitializer, getName, getType, getElements, getSymbol, getLocalSymbol, getBody, getDotDotDotToken, getParameters, getStatements, getText, getTypeArguments, getModifiers, } from './ast.js';
+import { ModuleKind, ScriptTarget } from './options.js';
+import { isExternalModuleNameRelative } from './path.js';
+import { checkTypeNameIsReserved } from './checker-classes.js';
+import { getPropertyNameFromType, isBindingPattern, isTypeUsableAsPropertyName } from './checker-utilities.js';
+import { checkPropertyAccessibility } from './checker-property-access.js';
+import { declarationNameToString, getNameOfDeclaration, getSourceFileOfNode, getAssignmentDeclarationKind, getCombinedModifierFlags, getCombinedNodeFlags, isPartOfParameterDeclaration, getRootDeclaration, getDeclarationOfKind, getModifierFlags, getModuleInstanceState, getRangeOfTokenAtPosition, hasSyntacticModifier, isEntityNameExpression, isEnumConst, isExternalModule, isModuleAugmentationExternal, isVariableDeclarationInitializedToRequire, isClassLike, } from './binder-utilities.js';
+import { Diagnostic } from './diagnostics.js';
+import { getSymbolId } from './symbol.js';
+import { createDiagnosticForNode } from './checker.js';
+import { getLiteralTypeFromPropertyName, intrinsicTypeKind } from './checker-type-operators.js';
+import { SimpleTypeMapper, } from './checker-types.js';
+import { checkTypeArgumentConstraints } from './checker-heritage.js';
+import { getUnionType, isErrorType } from './checker-type-factory.js';
+import { getTypeFromTypeNode } from './checker-type-nodes.js';
+import { computeEnumMemberValues, getConstraintOfTypeParameter, getDeclaredTypeOfSymbol, getDeclaredTypeOfTypeParameter, getDefaultFromTypeParameter, getResolvedTypeParameterDefault, } from './checker-declared-types.js';
+import { getDeclarationOfAliasSymbol, getExportsOfModule, getSymbolFlags, getSymbolOfDeclaration, resolveAlias, resolveName, getCachedGlobalType, } from './checker-symbols.js';
+import { getTypeOfSymbol, getWidenedTypeForVariableLikeDeclaration, widenTypeForVariableLikeDeclaration, isOptionalDeclaration, } from './checker-symbol-types.js';
+import { checkComputedPropertyName, checkExpression, checkExpressionCached, checkNonNullNonVoidType, checkTypeAssignableToAndOptionallyElaborate, isInAmbientOrTypeNode, } from './checker-expressions.js';
+import { checkIteratedTypeOrElementType } from './checker-iteration.js';
+import { isTypeAssignableTo, isTypeIdenticalTo, checkTypeAssignableTo, createMarkerType, getTypeParameterModifiers, } from './relations.js';
+import { getBaseConstraintOfType, getPropertyOfType, getReducedType, getTypeWithThisArgument, } from './checker-members.js';
+import { instantiateType } from './instantiation.js';
+import { symbolToString, typeToString } from './type-printer.js';
+import { checkNodeDeferred, checkSourceElement, checkTypeNodeIfPresent } from './checker-source-file.js';
+import { checkFunctionLikeBody } from './checker-functions.js';
+import { getContainerFlags } from './binder.js';
+import { isAmbientModule, isFunctionLike, isGlobalScopeAugmentation, isInJSFile, nodeIsMissing, nodeIsPresent, } from './ast-utilities.js';
+import { getTypeForBindingElementParent } from './checker-destructuring.js';
+import { checkFunctionOrMethodSymbols } from './checker-overloads.js';
+import { checkJSDocFullSignature } from './checker-jsdoc.js';
+import { checkAliasSymbol } from './checker-modules.js';
+import { checkDecorators } from './checker-decorators.js';
+// ---- Variables and parameters
+export function checkVariableStatement(c, node) {
+    checkVariableDeclarationList(c, node.declarationList);
+}
+export function checkVariableDeclarationList(c, node) {
+    // `using` and `await using` before ESNext use __addDisposableResource and __disposeResources.
+    const blockScopeKind = getCombinedNodeFlags(node) & 7 /* NodeFlags.BlockScoped */;
+    if ((blockScopeKind === 4 /* NodeFlags.Using */ || blockScopeKind === 6 /* NodeFlags.AwaitUsing */) &&
+        c.languageVersion < ScriptTarget.ESNext)
+        checkExternalEmitHelpers(c, node, 262144 /* ExternalEmitHelpers.AddDisposableResourceAndDisposeResources */);
+    for (const d of node.declarations.nodes)
+        checkVariableLikeDeclaration(c, d);
+}
+/** The initializer of a `using` or `await using` declaration must be disposable, `null` or `undefined`. */
+function checkUsingDeclarationInitializer(c, node, initializer, initType) {
+    const blockScopeKind = getCombinedNodeFlags(node) & 7 /* NodeFlags.BlockScoped */;
+    if (blockScopeKind === 6 /* NodeFlags.AwaitUsing */) {
+        const globalAsyncDisposableType = getCachedGlobalType(c, 'AsyncDisposable', 0, true);
+        const globalDisposableType = getCachedGlobalType(c, 'Disposable', 0, true);
+        if (globalAsyncDisposableType !== c.emptyObjectType && globalDisposableType !== c.emptyObjectType)
+            checkTypeAssignableTo(c, widenTypeForVariableLikeDeclaration(c, initType, node, false), getUnionType(c, [globalAsyncDisposableType, globalDisposableType, c.nullType, c.undefinedType]), initializer, 971 /* Diagnostics.The_initializer_of_an_await_using_declaration_must_be_either_an_object_with_a_Symbol_asyncDispose_or_Symbol_dispose_method_or_be_null_or_undefined */);
+    }
+    else if (blockScopeKind === 4 /* NodeFlags.Using */) {
+        const globalDisposableType = getCachedGlobalType(c, 'Disposable', 0, true);
+        if (globalDisposableType !== c.emptyObjectType)
+            checkTypeAssignableTo(c, widenTypeForVariableLikeDeclaration(c, initType, node, false), getUnionType(c, [globalDisposableType, c.nullType, c.undefinedType]), initializer, 970 /* Diagnostics.The_initializer_of_a_using_declaration_must_be_either_an_object_with_a_Symbol_dispose_method_or_be_null_or_undefined */);
+    }
+}
+/** Checks a variable, parameter, property or binding element declaration. */
+export function checkVariableLikeDeclaration(c, node) {
+    checkDecorators(c, node);
+    if (node.kind === 170 /* SyntaxKind.Parameter */)
+        checkParameter(c, node);
+    const typeNode = getType(node);
+    checkTypeNodeIfPresent(c, typeNode);
+    const name = getName(node);
+    if (node.kind === 172 /* SyntaxKind.PropertySignature */ && name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+        c.error(node, 1838 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
+    if (name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+        checkComputedPropertyName(c, name);
+    const initializer = getInitializer(node);
+    // Parameter initializers need an implementation.
+    const initializerNotAllowed = initializer !== undefined && node.kind === 170 /* SyntaxKind.Parameter */ && nodeIsMissing(getBody(node.parent));
+    if (name !== undefined &&
+        (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)) {
+        if (initializerNotAllowed)
+            c.error(node, 545 /* Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation */);
+        for (const element of getElements(name).nodes)
+            checkBindingElement(c, element);
+        if (!initializerNotAllowed)
+            checkBindingPatternInitializer(c, node, name, initializer);
+        return;
+    }
+    if (initializerNotAllowed) {
+        c.error(node, 545 /* Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation */);
+        return;
+    }
+    if (name !== undefined && name.kind === 9 /* SyntaxKind.BigIntLiteral */)
+        c.error(name, 454 /* Diagnostics.A_bigint_literal_cannot_be_used_as_a_property_name */);
+    const symbol = getSymbolOfDeclaration(c, node);
+    if (symbol === undefined) {
+        if (initializer !== undefined)
+            checkExpressionCached(c, initializer);
+        return;
+    }
+    // `const x = require("m")` declares an alias.
+    if ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0 && isVariableDeclarationInitializedToRequire(node)) {
+        checkAliasSymbol(c, node);
+        return;
+    }
+    if (name !== undefined &&
+        name.kind === 79 /* SyntaxKind.Identifier */ &&
+        node.kind !== 173 /* SyntaxKind.PropertyDeclaration */ &&
+        node.kind !== 172 /* SyntaxKind.PropertySignature */)
+        checkCollisionsForDeclarationName(c, node, name);
+    const t = convertAutoToAny(c, getTypeOfSymbol(c, symbol));
+    if (node.kind !== 173 /* SyntaxKind.PropertyDeclaration */ &&
+        node.kind !== 172 /* SyntaxKind.PropertySignature */ &&
+        node.kind !== 170 /* SyntaxKind.Parameter */) {
+        checkExportsOnMergedDeclarations(c, node);
+        if (node.kind === 261 /* SyntaxKind.VariableDeclaration */)
+            checkVarDeclaredNamesNotShadowed(c, node, symbol);
+    }
+    if (node === symbol.valueDeclaration) {
+        // A for-in initializer is already an error.
+        if (initializer !== undefined && node.parent.parent.kind !== 250 /* SyntaxKind.ForInStatement */) {
+            const initType = checkExpressionCached(c, initializer);
+            checkTypeAssignableToAndOptionallyElaborate(c, initType, t, node, initializer);
+            checkUsingDeclarationInitializer(c, node, initializer, initType);
+        }
+        if (name !== undefined && symbol.declarations.length > 1) {
+            for (const d of symbol.declarations) {
+                if (d !== node && isVariableLike(d) && !areDeclarationFlagsIdentical(d, node)) {
+                    reportNonIdenticalModifiers(c, name);
+                    break;
+                }
+            }
+        }
+        return;
+    }
+    if (name !== undefined &&
+        symbol.valueDeclaration !== undefined &&
+        !areDeclarationFlagsIdentical(node, symbol.valueDeclaration))
+        reportNonIdenticalModifiers(c, name);
+    // A redeclaration: types must be identical.
+    const declarationType = convertAutoToAny(c, getWidenedTypeForVariableLikeDeclaration(c, node, false));
+    if (!isErrorType(c, t) &&
+        !isErrorType(c, declarationType) &&
+        !isTypeIdenticalTo(c, t, declarationType) &&
+        (symbol.flags & 67108864 /* SymbolFlags.Assignment */) === 0)
+        errorNextVariableOrPropertyDeclarationMustHaveSameType(c, symbol.valueDeclaration, t, node, declarationType);
+    if (initializer !== undefined) {
+        const initType = checkExpressionCached(c, initializer);
+        if (!isErrorType(c, declarationType))
+            checkTypeAssignableToAndOptionallyElaborate(c, initType, declarationType, node, initializer);
+    }
+}
+/** Checks the initializer of a binding pattern, and that a pattern without names destructures a valid type. */
+function checkBindingPatternInitializer(c, node, name, initializer) {
+    if (isInAmbientOrTypeNode(node))
+        return;
+    // A for-in initializer is already an error.
+    const needCheckInitializer = initializer !== undefined && node.parent.parent.kind !== 250 /* SyntaxKind.ForInStatement */;
+    let needCheckWidenedType = true;
+    for (const e of getElements(name).nodes) {
+        if (getName(e) !== undefined) {
+            needCheckWidenedType = false;
+            break;
+        }
+    }
+    if (!needCheckInitializer && !needCheckWidenedType)
+        return;
+    const widenedType = getWidenedTypeForVariableLikeDeclaration(c, node, false);
+    if (needCheckInitializer) {
+        const initializerType = checkExpressionCached(c, initializer);
+        if (c.strictNullChecks && needCheckWidenedType)
+            checkNonNullNonVoidType(c, initializerType, node);
+        else
+            checkTypeAssignableToAndOptionallyElaborate(c, initializerType, getWidenedTypeForVariableLikeDeclaration(c, node, false), node, initializer);
+    }
+    if (needCheckWidenedType) {
+        if (name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)
+            checkIteratedTypeOrElementType(c, 65 /* IterationUse.Destructuring */, widenedType, c.undefinedType, node);
+        else if (c.strictNullChecks)
+            checkNonNullNonVoidType(c, widenedType, node);
+    }
+}
+/**
+ * Reports a `var` that would hoist past a `let` or `const` of the same name declared in an inner
+ * scope: the initializer would write to the block-scoped variable.
+ */
+function checkVarDeclaredNamesNotShadowed(c, node, symbol) {
+    if ((getCombinedNodeFlags(node) & 7 /* NodeFlags.BlockScoped */) !== 0 || isPartOfParameterDeclaration(node))
+        return;
+    const name = getName(node);
+    if ((symbol.flags & 1 /* SymbolFlags.FunctionScopedVariable */) === 0 || name === undefined)
+        return;
+    if (name.kind !== 79 /* SyntaxKind.Identifier */)
+        return;
+    const local = resolveName(c, node, getText(name), 3 /* SymbolFlags.Variable */, undefined, false, false);
+    if (local === undefined || local === symbol || (local.flags & 2 /* SymbolFlags.BlockScopedVariable */) === 0)
+        return;
+    const declaration = local.valueDeclaration;
+    if (declaration === undefined || (getCombinedNodeFlags(declaration) & 7 /* NodeFlags.BlockScoped */) === 0)
+        return;
+    let list = declaration;
+    while (list !== undefined && list.kind !== 262 /* SyntaxKind.VariableDeclarationList */)
+        list = list.parent;
+    const statement = list?.parent;
+    const container = statement !== undefined && statement.kind === 244 /* SyntaxKind.VariableStatement */ ? statement.parent : undefined;
+    // Block-scoped variables of the function, module or file scope share it with hoisted `var`s.
+    const namesShareScope = container !== undefined &&
+        ((container.kind === 242 /* SyntaxKind.Block */ && isFunctionLike(container.parent)) ||
+            container.kind === 269 /* SyntaxKind.ModuleBlock */ ||
+            container.kind === 268 /* SyntaxKind.ModuleDeclaration */ ||
+            container.kind === 307 /* SyntaxKind.SourceFile */);
+    if (namesShareScope)
+        return;
+    const localName = symbolToString(c, local);
+    c.error(node, 644 /* Diagnostics.Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1 */, localName, localName);
+}
+/** Parameter properties, `this` parameters and rest parameter types. */
+function checkParameter(c, node) {
+    const fn = node.parent;
+    const name = getName(node);
+    const paramName = name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */ ? getText(name) : '';
+    if (hasSyntacticModifier(node, 31 /* ModifierFlags.ParameterPropertyModifier */)) {
+        if (shouldCheckErasableSyntax(c, node))
+            c.error(node, 243 /* Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled */);
+        if (fn.kind !== 177 /* SyntaxKind.Constructor */ || !nodeIsPresent(getBody(fn)))
+            c.error(node, 543 /* Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation */);
+        if (fn.kind === 177 /* SyntaxKind.Constructor */ && paramName === 'constructor')
+            c.error(name, 569 /* Diagnostics.X_constructor_cannot_be_used_as_a_parameter_property_name */);
+    }
+    if (getInitializer(node) === undefined &&
+        isOptionalDeclaration(node) &&
+        isBindingPattern(name) &&
+        getBody(fn) !== undefined)
+        c.error(node, 629 /* Diagnostics.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature */);
+    if (paramName === 'this' || paramName === 'new') {
+        if (getParameters(fn).nodes.indexOf(node) !== 0)
+            c.error(node, 814 /* Diagnostics.A_0_parameter_must_be_the_first_parameter */, paramName);
+        if (fn.kind === 177 /* SyntaxKind.Constructor */ ||
+            fn.kind === 181 /* SyntaxKind.ConstructSignature */ ||
+            fn.kind === 186 /* SyntaxKind.ConstructorType */)
+            c.error(node, 815 /* Diagnostics.A_constructor_cannot_have_a_this_parameter */);
+        if (fn.kind === 220 /* SyntaxKind.ArrowFunction */)
+            c.error(node, 862 /* Diagnostics.An_arrow_function_cannot_have_a_this_parameter */);
+        if (fn.kind === 178 /* SyntaxKind.GetAccessor */ || fn.kind === 179 /* SyntaxKind.SetAccessor */)
+            c.error(node, 916 /* Diagnostics.X_get_and_set_accessors_cannot_declare_this_parameters */);
+    }
+    // Binding patterns in rest parameters are a grammar error. Generic rest types are skipped: the
+    // implied `any[]` constraints of `infer` positions aren't computed yet.
+    if (getDotDotDotToken(node) !== undefined && !isBindingPattern(name)) {
+        const symbol = getSymbolOfDeclaration(c, node);
+        const t = symbol !== undefined ? getReducedType(c, getTypeOfSymbol(c, symbol)) : undefined;
+        if (t !== undefined && !isTypeAssignableTo(c, t, c.anyReadonlyArrayType))
+            c.error(node, 544 /* Diagnostics.A_rest_parameter_must_be_of_an_array_type */);
+    }
+}
+function isVariableLike(node) {
+    switch (node.kind) {
+        case 209 /* SyntaxKind.BindingElement */:
+        case 306 /* SyntaxKind.EnumMember */:
+        case 170 /* SyntaxKind.Parameter */:
+        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 172 /* SyntaxKind.PropertySignature */:
+        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 261 /* SyntaxKind.VariableDeclaration */:
+            return true;
+    }
+    return false;
+}
+function areDeclarationFlagsIdentical(left, right) {
+    // Parameters and variables may differ in optionality.
+    if ((left.kind === 170 /* SyntaxKind.Parameter */ && right.kind === 261 /* SyntaxKind.VariableDeclaration */) ||
+        (left.kind === 261 /* SyntaxKind.VariableDeclaration */ && right.kind === 170 /* SyntaxKind.Parameter */))
+        return true;
+    if (isOptionalDeclaration(left) !== isOptionalDeclaration(right))
+        return false;
+    const interestingFlags = 2 /* ModifierFlags.Private */ |
+        4 /* ModifierFlags.Protected */ |
+        1024 /* ModifierFlags.Async */ |
+        64 /* ModifierFlags.Abstract */ |
+        8 /* ModifierFlags.Readonly */ |
+        256 /* ModifierFlags.Static */;
+    return (getModifierFlags(left) & interestingFlags) === (getModifierFlags(right) & interestingFlags);
+}
+function reportNonIdenticalModifiers(c, name) {
+    c.error(name, 820 /* Diagnostics.All_declarations_of_0_must_have_identical_modifiers */, declarationNameToString(getSourceFileOfNode(name), name));
+}
+function checkBindingElement(c, element) {
+    // Missing array binding elements have no name.
+    if (element.name === undefined)
+        return;
+    if (element.propertyName !== undefined &&
+        element.name.kind === 79 /* SyntaxKind.Identifier */ &&
+        isPartOfParameterDeclaration(element) &&
+        nodeIsMissing(getBody(getRootDeclaration(element).parent))) {
+        // Renaming in `type F = ({ a: string }) => void` is confusing, so it's an error once the file is
+        // checked if the name is unused, even without noUnusedLocals.
+        c.renamedBindingElementsInTypes.push(element);
+        return;
+    }
+    if (element.name.kind === 79 /* SyntaxKind.Identifier */)
+        checkCollisionsForDeclarationName(c, element, element.name);
+    // An object rest binding before ES2018 uses __rest.
+    if (element.parent.kind === 207 /* SyntaxKind.ObjectBindingPattern */ &&
+        element.dotDotDotToken !== undefined &&
+        c.languageVersion < ScriptTarget.ES2018)
+        checkExternalEmitHelpers(c, element, 1 /* ExternalEmitHelpers.Rest */);
+    if (element.propertyName !== undefined && element.propertyName.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+        checkComputedPropertyName(c, element.propertyName);
+    // Private and protected properties can't be destructured outside their classes.
+    const parent = element.parent.parent;
+    const parentType = getTypeForBindingElementParent(c, parent, element.dotDotDotToken !== undefined ? 32 /* CheckMode.RestBindingElement */ : 0 /* CheckMode.Normal */);
+    const propertyName = element.propertyName ?? element.name;
+    if (parentType !== undefined && !isBindingPattern(propertyName)) {
+        const exprType = getLiteralTypeFromPropertyName(c, propertyName);
+        if (exprType !== undefined && isTypeUsableAsPropertyName(exprType)) {
+            const property = getPropertyOfType(c, parentType, getPropertyNameFromType(exprType));
+            if (property !== undefined) {
+                markPropertyAsReferenced(c, property, undefined, false);
+                const initializer = getInitializer(parent);
+                checkPropertyAccessibility(c, element, initializer !== undefined && initializer.kind === 107 /* SyntaxKind.SuperKeyword */, false, parentType, property);
+            }
+        }
+    }
+    const name = element.name;
+    if (name !== undefined &&
+        (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)) {
+        for (const e of getElements(name).nodes)
+            checkBindingElement(c, e);
+    }
+    // Initializers in parameters need an implementation.
+    if (element.initializer !== undefined &&
+        isPartOfParameterDeclaration(element) &&
+        nodeIsMissing(getBody(getRootDeclaration(element).parent))) {
+        c.error(element, 545 /* Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation */);
+        return;
+    }
+    if (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */) {
+        checkBindingPatternInitializer(c, element, name, element.initializer);
+        return;
+    }
+    {
+        const symbol = getSymbolOfDeclaration(c, element);
+        if (symbol !== undefined &&
+            (symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0 &&
+            isVariableDeclarationInitializedToRequire(element)) {
+            checkAliasSymbol(c, element);
+            return;
+        }
+        if (symbol !== undefined) {
+            const t = convertAutoToAny(c, getTypeOfSymbol(c, symbol));
+            const initializer = element.initializer;
+            if (element === symbol.valueDeclaration) {
+                // A for-in initializer is already an error.
+                if (initializer !== undefined && getRootDeclaration(element).parent.parent.kind !== 250 /* SyntaxKind.ForInStatement */)
+                    checkTypeAssignableToAndOptionallyElaborate(c, checkExpressionCached(c, initializer), t, element, initializer);
+            }
+            else if (symbol.valueDeclaration !== undefined) {
+                // A redeclaration must have the type of the first declaration.
+                const declarationType = convertAutoToAny(c, getWidenedTypeForVariableLikeDeclaration(c, element, false));
+                if (!isErrorType(c, t) &&
+                    !isErrorType(c, declarationType) &&
+                    !isTypeIdenticalTo(c, t, declarationType) &&
+                    (symbol.flags & 67108864 /* SymbolFlags.Assignment */) === 0)
+                    errorNextVariableOrPropertyDeclarationMustHaveSameType(c, symbol.valueDeclaration, t, element, declarationType);
+                if (initializer !== undefined)
+                    checkTypeAssignableToAndOptionallyElaborate(c, checkExpressionCached(c, initializer), declarationType, element, initializer);
+                if (!areDeclarationFlagsIdentical(element, symbol.valueDeclaration))
+                    reportNonIdenticalModifiers(c, name);
+            }
+            checkExportsOnMergedDeclarations(c, element);
+            checkVarDeclaredNamesNotShadowed(c, element, symbol);
+            return;
+        }
+    }
+    if (element.initializer !== undefined)
+        checkExpressionCached(c, element.initializer);
+}
+function errorNextVariableOrPropertyDeclarationMustHaveSameType(c, firstDeclaration, firstType, nextDeclaration, nextType) {
+    const nextDeclarationName = getNameOfDeclaration(nextDeclaration);
+    const message = nextDeclaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ || nextDeclaration.kind === 172 /* SyntaxKind.PropertySignature */
+        ? 849 /* Diagnostics.Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_type_2 */
+        : 574 /* Diagnostics.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2 */;
+    const declName = declarationNameToString(getSourceFileOfNode(nextDeclaration), nextDeclarationName);
+    const err = c.error(nextDeclarationName, message, declName, typeToString(c, firstType), typeToString(c, nextType));
+    if (firstDeclaration !== undefined)
+        err.addRelatedInfo(createDiagnosticForNode(getNameOfDeclaration(firstDeclaration) ?? firstDeclaration, 1356 /* Diagnostics.X_0_was_also_declared_here */, [declName]));
+}
+// ---- Functions
+export function checkFunctionDeclaration(c, node) {
+    const symbol = getSymbolOfDeclaration(c, node);
+    if (symbol !== undefined)
+        getTypeOfSymbol(c, symbol);
+    checkFunctionLikeBody(c, node);
+    checkJSDocFullSignature(c, node);
+    checkFunctionOrMethodSymbols(c, node);
+    checkCollisionsForDeclarationName(c, node, getName(node));
+}
+// ---- Types
+export function checkTypeParameter(c, node) {
+    const tp = node;
+    checkTypeNodeIfPresent(c, tp.constraint);
+    checkTypeNodeIfPresent(c, tp.defaultType);
+    const symbol = getSymbol(node);
+    if (symbol === undefined)
+        return;
+    const typeParameter = getDeclaredTypeOfTypeParameter(c, symbol);
+    // Resolving the base constraint reveals circularities.
+    getBaseConstraintOfType(c, typeParameter);
+    if (getResolvedTypeParameterDefault(c, typeParameter) === c.circularConstraintType)
+        c.error(tp.defaultType, 848 /* Diagnostics.Type_parameter_0_has_a_circular_default */, typeToString(c, typeParameter));
+    const constraintType = getConstraintOfTypeParameter(c, typeParameter);
+    const defaultType = getDefaultFromTypeParameter(c, typeParameter);
+    if (constraintType !== undefined && defaultType !== undefined)
+        checkTypeAssignableTo(c, defaultType, getTypeWithThisArgument(c, instantiateType(c, constraintType, new SimpleTypeMapper(typeParameter, defaultType)), defaultType, false), tp.defaultType, 520 /* Diagnostics.Type_0_does_not_satisfy_the_constraint_1 */);
+    checkTypeNameIsReserved(c, tp.name, 542 /* Diagnostics.Type_parameter_name_cannot_be_0 */);
+    checkNodeDeferred(c, node);
+}
+/** Variance annotations are only allowed on type aliases of object, function, constructor and mapped types. */
+export function checkTypeParameterDeferred(c, node) {
+    const parent = node.parent;
+    const isTypeAlias = parent.kind === 266 /* SyntaxKind.TypeAliasDeclaration */ || parent.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */;
+    if (!isTypeAlias && parent.kind !== 265 /* SyntaxKind.InterfaceDeclaration */ && !isClassLike(parent))
+        return;
+    const typeParameterSymbol = getSymbolOfDeclaration(c, node);
+    if (typeParameterSymbol === undefined)
+        return;
+    const typeParameter = getDeclaredTypeOfTypeParameter(c, typeParameterSymbol);
+    const modifiers = getTypeParameterModifiers(typeParameter) & (8192 /* ModifierFlags.In */ | 16384 /* ModifierFlags.Out */);
+    if (modifiers === 0)
+        return;
+    const symbol = getSymbolOfDeclaration(c, parent);
+    if (symbol === undefined)
+        return;
+    if (isTypeAlias &&
+        (getDeclaredTypeOfSymbol(c, symbol).objectFlags & (16 /* ObjectFlags.Anonymous */ | 32 /* ObjectFlags.Mapped */)) === 0)
+        c.error(node, 780 /* Diagnostics.Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_types */);
+    else if (modifiers === 8192 /* ModifierFlags.In */ || modifiers === 16384 /* ModifierFlags.Out */) {
+        // The declared variance must hold between instantiations with marker sub- and supertypes.
+        const isOut = modifiers === 16384 /* ModifierFlags.Out */;
+        const source = createMarkerType(c, symbol, typeParameter, isOut ? c.markerSubTypeForCheck : c.markerSuperTypeForCheck);
+        const target = createMarkerType(c, symbol, typeParameter, isOut ? c.markerSuperTypeForCheck : c.markerSubTypeForCheck);
+        const saveVarianceTypeParameter = c.varianceTypeParameter;
+        c.varianceTypeParameter = typeParameter;
+        checkTypeAssignableTo(c, source, target, node, 779 /* Diagnostics.Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation */);
+        c.varianceTypeParameter = saveVarianceTypeParameter;
+    }
+}
+/** Checks a type parameter list: each parameter, default ordering and duplicate names. */
+export function checkTypeParameters(c, list) {
+    if (list === undefined)
+        return;
+    const typeParameters = list.nodes;
+    let seenDefault = false;
+    for (let i = 0; i < typeParameters.length; i++) {
+        const node = typeParameters[i];
+        checkTypeParameter(c, node);
+        if (node.defaultType !== undefined) {
+            seenDefault = true;
+            const finder = new LaterTypeParameterReferenceFinder(c, typeParameters, i);
+            finder.visitNode(node.defaultType);
+        }
+        else if (seenDefault)
+            c.error(node, 838 /* Diagnostics.Required_type_parameters_may_not_follow_optional_type_parameters */);
+        for (let j = 0; j < i; j++)
+            if (getSymbol(typeParameters[j]) === getSymbol(node))
+                c.error(node.name, 478 /* Diagnostics.Duplicate_identifier_0 */, declarationNameToString(getSourceFileOfNode(node), node.name));
+    }
+}
+/** Reports references in a type parameter default to the parameter itself or later ones. */
+class LaterTypeParameterReferenceFinder extends NodeVisitor {
+    c;
+    typeParameters;
+    index;
+    constructor(c, typeParameters, index) {
+        super();
+        this.c = c;
+        this.typeParameters = typeParameters;
+        this.index = index;
+    }
+    visitNode(node) {
+        if (node.kind === 184 /* SyntaxKind.TypeReference */) {
+            const t = getTypeFromTypeNode(this.c, node);
+            if ((t.flags & 524288 /* TypeFlags.TypeParameter */) !== 0)
+                for (let i = this.index; i < this.typeParameters.length; i++)
+                    if (t.symbol === getSymbolOfDeclaration(this.c, this.typeParameters[i]))
+                        this.c.error(node, 876 /* Diagnostics.Type_parameter_defaults_can_only_reference_previously_declared_type_parameters */);
+        }
+        return node.forEachChild(this);
+    }
+}
+export function checkTypeAliasDeclaration(c, node) {
+    const alias = node;
+    const typeParameters = alias.typeParameters;
+    checkTypeNameIsReserved(c, alias.name, 623 /* Diagnostics.Type_alias_name_cannot_be_0 */);
+    checkExportsOnMergedDeclarations(c, node);
+    checkTypeParameters(c, typeParameters);
+    if (alias.type.kind === 141 /* SyntaxKind.IntrinsicKeyword */) {
+        const name = getText(alias.name);
+        const count = typeParameters !== undefined ? typeParameters.nodes.length : 0;
+        if (!(count === 0 && name === 'BuiltinIteratorReturn') &&
+            !(count === 1 && intrinsicTypeKind(name) !== 0 /* IntrinsicTypeKind.Unknown */))
+            c.error(alias.type, 927 /* Diagnostics.The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types */);
+    }
+    else
+        checkSourceElement(c, alias.type);
+}
+/**
+ * Checks the type arguments of a type reference, an import type or a heritage type reference against the
+ * constraints of the type parameters of what it references, as tsgo's checkTypeReferenceOrImport does;
+ * not when `type`, the type of the reference, is the error type.
+ */
+export function checkTypeArgumentConstraintsOfReference(c, node, type) {
+    if (isErrorType(c, type) || (getTypeArguments(node)?.nodes.length ?? 0) === 0)
+        return;
+    const symbol = c.resolvedSymbols.get(node.id);
+    if (symbol === undefined)
+        return;
+    let typeParameters = undefined;
+    if ((symbol.flags & 524288 /* SymbolFlags.TypeAlias */) !== 0)
+        typeParameters = c.symbolLinks(symbol).typeParameters;
+    if ((typeParameters === undefined || typeParameters.length === 0) && (type.objectFlags & 4 /* ObjectFlags.Reference */) !== 0)
+        typeParameters = type.target.localTypeParameters();
+    if (typeParameters !== undefined && typeParameters.length > 0)
+        checkTypeArgumentConstraints(c, node, typeParameters);
+}
+export function checkEnumMember(c, node) {
+    const name = getName(node);
+    if (name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+        c.error(node, 1842 /* Diagnostics.An_enum_member_cannot_be_named_with_a_private_identifier */);
+    const initializer = getInitializer(node);
+    if (initializer !== undefined)
+        checkExpression(c, initializer);
+}
+export function checkEnumDeclaration(c, node) {
+    const name = getName(node);
+    checkCollisionsForDeclarationName(c, node, name);
+    checkTypeNameIsReserved(c, name, 599 /* Diagnostics.Enum_name_cannot_be_0 */);
+    checkExportsOnMergedDeclarations(c, node);
+    for (const member of node.members.nodes)
+        checkSourceElement(c, member);
+    if (shouldCheckErasableSyntax(c, node) && (node.flags & 8388608 /* NodeFlags.Ambient */) === 0)
+        c.error(node, 243 /* Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled */);
+    computeEnumMemberValues(c, node);
+    const symbol = getSymbolOfDeclaration(c, node);
+    if (symbol === undefined)
+        return;
+    const links = c.symbolLinks(symbol);
+    if (links.enumChecked)
+        return;
+    links.enumChecked = true;
+    if (symbol.declarations.length > 1) {
+        const enumIsConst = isEnumConst(node);
+        for (const d of symbol.declarations)
+            if (d.kind === 267 /* SyntaxKind.EnumDeclaration */ && isEnumConst(d) !== enumIsConst)
+                c.error(getNameOfDeclaration(d), 637 /* Diagnostics.Enum_declarations_must_all_be_const_or_non_const */);
+    }
+    // Only one declaration of a merged enum may continue automatic numbering from zero.
+    let seenEnumMissingInitialInitializer = false;
+    for (const d of symbol.declarations) {
+        if (d.kind !== 267 /* SyntaxKind.EnumDeclaration */)
+            continue;
+        const members = d.members.nodes;
+        if (members.length === 0 || getInitializer(members[0]) !== undefined)
+            continue;
+        if (seenEnumMissingInitialInitializer)
+            c.error(getName(members[0]), 600 /* Diagnostics.In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element */);
+        else
+            seenEnumMissingInitialInitializer = true;
+    }
+}
+/** Whether erasableSyntaxOnly applies at `node`: it is set, and `node` is in a TypeScript file. */
+export function shouldCheckErasableSyntax(c, node) {
+    return c.compilerOptions.erasableSyntaxOnly === true && !isInJSFile(node);
+}
+export function checkModuleDeclaration(c, node) {
+    const module = node;
+    const body = module.body;
+    if (body !== undefined)
+        checkSourceElement(c, body);
+    const isGlobalAugmentation = isGlobalScopeAugmentation(node);
+    const inAmbientContext = (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0;
+    if (isGlobalAugmentation && !inAmbientContext)
+        c.error(module.name, 804 /* Diagnostics.Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context */);
+    const contextMessage = isAmbientModule(node)
+        ? 184 /* Diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file */
+        : 185 /* Diagnostics.A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module */;
+    if (checkModuleElementContext(c, node, contextMessage))
+        return;
+    if (module.name.kind === 79 /* SyntaxKind.Identifier */)
+        checkCollisionsForDeclarationName(c, node, module.name);
+    if (module.name.kind === 79 /* SyntaxKind.Identifier */ && module.keyword === 144 /* SyntaxKind.ModuleKeyword */)
+        c.error(module.name, 455 /* Diagnostics.A_namespace_declaration_should_not_be_declared_using_the_module_keyword_Please_use_the_namespace_keyword_instead */);
+    checkExportsOnMergedDeclarations(c, node);
+    const symbol = getSymbolOfDeclaration(c, node);
+    // Only non-ambient instantiated namespaces.
+    if (symbol !== undefined &&
+        (symbol.flags & 512 /* SymbolFlags.ValueModule */) !== 0 &&
+        !inAmbientContext &&
+        isInstantiatedModule(node, c.preserveConstEnums)) {
+        if (shouldCheckErasableSyntax(c, node))
+            c.error(node, 243 /* Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled */);
+        // Namespaces of global scripts can merge across files, which a transpiler of one file cannot see.
+        if (c.isolatedModules && getSourceFileOfNode(node).externalModuleIndicator === undefined)
+            c.error(module.name, 229 /* Diagnostics.Namespaces_are_not_allowed_in_global_script_files_when_0_is_enabled_If_this_file_is_not_intended_to_be_a_global_script_set_moduleDetection_to_force_or_add_an_empty_export_statement */, c.compilerOptions.verbatimModuleSyntax === true ? 'verbatimModuleSyntax' : 'isolatedModules');
+        if (symbol.declarations.length > 1) {
+            const classOrFunction = getFirstNonAmbientClassOrFunctionDeclaration(symbol);
+            if (classOrFunction !== undefined) {
+                if (getSourceFileOfNode(node) !== getSourceFileOfNode(classOrFunction))
+                    c.error(module.name, 601 /* Diagnostics.A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged */);
+                else if (node.pos < classOrFunction.pos)
+                    c.error(module.name, 602 /* Diagnostics.A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged */);
+            }
+        }
+        if (c.compilerOptions.verbatimModuleSyntax === true &&
+            node.parent.kind === 307 /* SyntaxKind.SourceFile */ &&
+            hasSyntacticModifier(node, 32 /* ModifierFlags.Export */) &&
+            c.host.getEmitModuleFormatOfFile(node.parent) === ModuleKind.CommonJS) {
+            const exportModifier = getModifiers(node).nodes.find((m) => m.kind === 94 /* SyntaxKind.ExportKeyword */);
+            c.error(exportModifier, 236 /* Diagnostics.A_top_level_export_modifier_cannot_be_used_on_value_declarations_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled */);
+        }
+    }
+    if (!isAmbientModule(node))
+        return;
+    if (isModuleAugmentationExternal(node)) {
+        // Check an augmentation's body only when it merged with its target.
+        const checkBody = isGlobalAugmentation || (symbol !== undefined && (symbol.flags & 33554432 /* SymbolFlags.Transient */) !== 0);
+        if (checkBody && body !== undefined && body.kind === 269 /* SyntaxKind.ModuleBlock */)
+            for (const statement of getStatements(body).nodes)
+                checkModuleAugmentationElement(c, statement);
+        return;
+    }
+    const parent = node.parent;
+    if (isGlobalAugmentation)
+        c.error(module.name, 803 /* Diagnostics.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations */);
+    else if (parent.kind === 307 /* SyntaxKind.SourceFile */ && !isExternalModule(parent)) {
+        if (isExternalModuleNameRelative(getText(module.name)))
+            c.error(module.name, 604 /* Diagnostics.Ambient_module_declaration_cannot_specify_relative_module_name */);
+    }
+    else
+        c.error(module.name, 603 /* Diagnostics.Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces */);
+}
+export function isInstantiatedModule(node, preserveConstEnums) {
+    const state = getModuleInstanceState(node);
+    return (state === 2 /* ModuleInstanceState.Instantiated */ || (preserveConstEnums && state === 3 /* ModuleInstanceState.ConstEnumOnly */));
+}
+function getFirstNonAmbientClassOrFunctionDeclaration(symbol) {
+    for (const d of symbol.declarations)
+        if ((d.kind === 264 /* SyntaxKind.ClassDeclaration */ ||
+            (d.kind === 263 /* SyntaxKind.FunctionDeclaration */ && nodeIsPresent(getBody(d)))) &&
+            (d.flags & 8388608 /* NodeFlags.Ambient */) === 0)
+            return d;
+    return undefined;
+}
+function checkModuleAugmentationElement(c, node) {
+    switch (node.kind) {
+        case 244 /* SyntaxKind.VariableStatement */:
+            // Each name, rather than the whole statement.
+            for (const d of node.declarationList.declarations.nodes)
+                checkModuleAugmentationElement(c, d);
+            return;
+        case 278 /* SyntaxKind.ExportAssignment */:
+        case 279 /* SyntaxKind.ExportDeclaration */:
+            grammarErrorOnFirstToken(c, node, 800 /* Diagnostics.Exports_and_export_assignments_are_not_permitted_in_module_augmentations */);
+            return;
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            // `import a = e.x` is allowed; `import a = require("m")` isn't.
+            if (node.moduleReference.kind !== 284 /* SyntaxKind.ExternalModuleReference */)
+                return;
+            grammarErrorOnFirstToken(c, node, 801 /* Diagnostics.Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module */);
+            return;
+        case 273 /* SyntaxKind.ImportDeclaration */:
+            grammarErrorOnFirstToken(c, node, 801 /* Diagnostics.Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module */);
+            return;
+    }
+}
+/** Reports at the first token of `node` unless the file has syntax errors. */
+function grammarErrorOnFirstToken(c, node, message) {
+    const file = getSourceFileOfNode(node);
+    if (file.diagnostics.length > 0)
+        return;
+    const span = getRangeOfTokenAtPosition(file, node.pos);
+    c.addDiagnostic(new Diagnostic(file.diagnosticFile(), span.pos, span.end, message, []));
+}
+// ---- Imports and exports
+/**
+ * Reports a module element (import, export, namespace) outside a file, namespace or module body.
+ * Callers stop checking the element when this returns true.
+ */
+function checkModuleElementContext(c, node, message) {
+    const parent = node.parent.kind;
+    if (parent === 307 /* SyntaxKind.SourceFile */ || parent === 269 /* SyntaxKind.ModuleBlock */ || parent === 268 /* SyntaxKind.ModuleDeclaration */)
+        return false;
+    grammarErrorOnFirstToken(c, node, message);
+    return true;
+}
+/** Reports `export =` mixed with other exports, and names exported by more than one declaration. */
+export function checkExternalModuleExports(c, node) {
+    const moduleSymbol = getSymbolOfDeclaration(c, node);
+    if (moduleSymbol === undefined)
+        return;
+    const links = c.symbolLinks(moduleSymbol);
+    if (links.exportsChecked)
+        return;
+    links.exportsChecked = true;
+    const exportEquals = moduleSymbol.exports?.get("export=" /* InternalSymbolName.ExportEquals */);
+    // `export =` conflicts with exported values, and with exported types or namespaces the target also exports.
+    if (exportEquals !== undefined &&
+        (hasExportedMembersOfKind(c, moduleSymbol, 111551 /* SymbolFlags.Value */) || hasShadowedNamespace(c, exportEquals))) {
+        const declaration = getDeclarationOfAliasSymbol(exportEquals) ?? exportEquals.valueDeclaration;
+        if (declaration !== undefined && !isTopLevelInExternalModuleAugmentation(declaration))
+            c.error(declaration, 487 /* Diagnostics.An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements */);
+    }
+    for (const [id, symbol] of getExportsOfModule(c, moduleSymbol)) {
+        // Namespaces, enums, interfaces and overloads may have several declarations.
+        if (id === "\uFFFEexport" /* InternalSymbolName.ExportStar */ || (symbol.flags & (1920 /* SymbolFlags.Namespace */ | 384 /* SymbolFlags.Enum */)) !== 0)
+            continue;
+        let count = 0;
+        for (const d of symbol.declarations)
+            if (isNotOverload(d) && !isAccessorDeclaration(d) && d.kind !== 265 /* SyntaxKind.InterfaceDeclaration */)
+                count++;
+        // A type alias may merge with one value.
+        if ((symbol.flags & 524288 /* SymbolFlags.TypeAlias */) !== 0 && count <= 2)
+            continue;
+        if (count <= 1)
+            continue;
+        let allExportsProperties = true;
+        for (const d of symbol.declarations)
+            if (getAssignmentDeclarationKind(d) !== 2 /* JSDeclarationKind.ExportsProperty */)
+                allExportsProperties = false;
+        if (allExportsProperties)
+            continue;
+        for (const d of symbol.declarations)
+            if (isNotOverload(d))
+                c.error(d, 501 /* Diagnostics.Cannot_redeclare_exported_variable_0 */, id);
+    }
+}
+function hasExportedMembersOfKind(c, moduleSymbol, kind) {
+    if (moduleSymbol.exports === undefined)
+        return false;
+    for (const [name, symbol] of moduleSymbol.exports)
+        if (name !== "export=" /* InternalSymbolName.ExportEquals */ && (getSymbolFlags(c, symbol) & kind) !== 0)
+            return true;
+    return false;
+}
+function hasShadowedNamespace(c, symbol) {
+    if ((symbol.flags & 1024 /* SymbolFlags.NamespaceModule */) === 0 || (symbol.flags & 2097152 /* SymbolFlags.Alias */) === 0)
+        return false;
+    const target = resolveAlias(c, symbol);
+    return ((target.flags & 1920 /* SymbolFlags.Namespace */) !== 0 &&
+        hasExportedMembersOfKind(c, target, 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */));
+}
+function isNotOverload(node) {
+    return ((node.kind !== 263 /* SyntaxKind.FunctionDeclaration */ && node.kind !== 175 /* SyntaxKind.MethodDeclaration */) ||
+        getBody(node) !== undefined);
+}
+function isAccessorDeclaration(node) {
+    return node.kind === 178 /* SyntaxKind.GetAccessor */ || node.kind === 179 /* SyntaxKind.SetAccessor */;
+}
+function isTopLevelInExternalModuleAugmentation(node) {
+    const parent = node.parent;
+    if (parent === undefined || parent.kind !== 269 /* SyntaxKind.ModuleBlock */)
+        return false;
+    const module = parent.parent;
+    return isAmbientModule(module) && isModuleAugmentationExternal(module);
+}
+/** Reports merged declarations that mix exported and local (or default-exported) declarations. */
+export function checkExportsOnMergedDeclarations(c, node) {
+    let symbol = getLocalSymbol(node);
+    if (symbol === undefined) {
+        symbol = getSymbolOfDeclaration(c, node);
+        if (symbol === undefined || symbol.exportSymbol === undefined)
+            return;
+    }
+    if (getDeclarationOfKind(symbol, node.kind) !== node)
+        return;
+    let exported = 0 /* DeclarationSpaces.None */;
+    let nonExported = 0 /* DeclarationSpaces.None */;
+    let defaultExported = 0 /* DeclarationSpaces.None */;
+    for (const d of symbol.declarations) {
+        const spaces = getDeclarationSpaces(c, d);
+        const flags = getEffectiveDeclarationFlags(d, 32 /* ModifierFlags.Export */ | 2048 /* ModifierFlags.Default */);
+        if ((flags & 32 /* ModifierFlags.Export */) !== 0) {
+            if ((flags & 2048 /* ModifierFlags.Default */) !== 0)
+                defaultExported |= spaces;
+            else
+                exported |= spaces;
+        }
+        else
+            nonExported |= spaces;
+    }
+    const nonDefaultExported = exported | nonExported;
+    const commonForExportsAndLocals = exported & nonExported;
+    const commonForDefaultAndNonDefault = defaultExported & nonDefaultExported;
+    if (commonForExportsAndLocals === 0 && commonForDefaultAndNonDefault === 0)
+        return;
+    for (const d of symbol.declarations) {
+        const spaces = getDeclarationSpaces(c, d);
+        const name = getNameOfDeclaration(d);
+        const text = declarationNameToString(getSourceFileOfNode(d), name);
+        if ((spaces & commonForDefaultAndNonDefault) !== 0)
+            c.error(name, 786 /* Diagnostics.Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead */, text);
+        else if ((spaces & commonForExportsAndLocals) !== 0)
+            c.error(name, 566 /* Diagnostics.Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local */, text);
+    }
+}
+function getDeclarationSpaces(c, node) {
+    switch (node.kind) {
+        case 265 /* SyntaxKind.InterfaceDeclaration */:
+        case 266 /* SyntaxKind.TypeAliasDeclaration */:
+        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            return 2 /* DeclarationSpaces.ExportType */;
+        case 268 /* SyntaxKind.ModuleDeclaration */:
+            return isAmbientModule(node) || getModuleInstanceState(node) !== 1 /* ModuleInstanceState.NonInstantiated */
+                ? 4 /* DeclarationSpaces.ExportNamespace */ | 1 /* DeclarationSpaces.ExportValue */
+                : 4 /* DeclarationSpaces.ExportNamespace */;
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 267 /* SyntaxKind.EnumDeclaration */:
+        case 306 /* SyntaxKind.EnumMember */:
+            return 2 /* DeclarationSpaces.ExportType */ | 1 /* DeclarationSpaces.ExportValue */;
+        case 307 /* SyntaxKind.SourceFile */:
+            return 2 /* DeclarationSpaces.ExportType */ | 1 /* DeclarationSpaces.ExportValue */ | 4 /* DeclarationSpaces.ExportNamespace */;
+        case 278 /* SyntaxKind.ExportAssignment */: {
+            const expression = getExpression(node);
+            const symbol = getSymbolOfDeclaration(c, node);
+            if (!isEntityNameExpression(expression, false) ||
+                symbol === undefined ||
+                (symbol.flags & 2097152 /* SymbolFlags.Alias */) === 0)
+                return 1 /* DeclarationSpaces.ExportValue */;
+            return getAliasDeclarationSpaces(c, node);
+        }
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 275 /* SyntaxKind.NamespaceImport */:
+        case 274 /* SyntaxKind.ImportClause */:
+            return getAliasDeclarationSpaces(c, node);
+        case 174 /* SyntaxKind.MethodSignature */:
+        case 172 /* SyntaxKind.PropertySignature */:
+            return 2 /* DeclarationSpaces.ExportType */;
+    }
+    return 1 /* DeclarationSpaces.ExportValue */;
+}
+function getAliasDeclarationSpaces(c, node) {
+    const symbol = getSymbolOfDeclaration(c, node);
+    if (symbol === undefined)
+        return 0 /* DeclarationSpaces.None */;
+    let result = 0 /* DeclarationSpaces.None */;
+    for (const d of resolveAlias(c, symbol).declarations)
+        result |= getDeclarationSpaces(c, d);
+    return result;
+}
+export function getEffectiveDeclarationFlags(node, flagsToCheck) {
+    let flags = getCombinedModifierFlags(node);
+    const parent = node.parent;
+    if (parent.kind !== 265 /* SyntaxKind.InterfaceDeclaration */ &&
+        parent.kind !== 264 /* SyntaxKind.ClassDeclaration */ &&
+        parent.kind !== 232 /* SyntaxKind.ClassExpression */ &&
+        (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0) {
+        let container = node.parent;
+        while (container !== undefined && (getContainerFlags(container) & 1 /* ContainerFlags.IsContainer */) === 0)
+            container = container.parent;
+        if (container !== undefined &&
+            (container.flags & 64 /* NodeFlags.ExportContext */) !== 0 &&
+            (flags & 128 /* ModifierFlags.Ambient */) === 0 &&
+            !(parent.kind === 269 /* SyntaxKind.ModuleBlock */ && isGlobalScopeAugmentation(parent.parent)))
+            flags |= 32 /* ModifierFlags.Export */;
+        flags |= 128 /* ModifierFlags.Ambient */;
+    }
+    return flags & flagsToCheck;
+}
+/** Reports renamings in parameters of bodiless signatures whose new names are unused. */
+export function checkUnusedRenamedBindingElements(c) {
+    for (const element of c.renamedBindingElementsInTypes) {
+        const symbol = getSymbolOfDeclaration(c, element);
+        if (symbol !== undefined && c.symbolReferenceKinds.get(getSymbolId(symbol)) !== 0)
+            continue;
+        const file = getSourceFileOfNode(element);
+        const name = element.name;
+        const propertyName = declarationNameToString(file, element.propertyName);
+        const diagnostic = c.error(name, 963 /* Diagnostics.X_0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation */, declarationNameToString(file, name), propertyName);
+        const parameter = getRootDeclaration(element);
+        if (getType(parameter) === undefined)
+            diagnostic.addRelatedInfo(new Diagnostic(file.diagnosticFile(), parameter.end, parameter.end, 964 /* Diagnostics.We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here */, [propertyName]));
+    }
+    c.renamedBindingElementsInTypes.length = 0;
+}