tsc-ts 0.0.9 → 0.1.0

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

@@ -2,6 +2,7 @@
 import { checkCollisionsForDeclarationName } from './checker-generated-code.js';
 import { checkExternalEmitHelpers } from './checker-emit-helpers.js';
 import { convertAutoToAny } from './checker-narrowing.js';
+import { grammarErrorOnNode } from './checker-operators.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';
@@ -32,7 +33,7 @@ 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 { checkJSDocFullSignature, checkJSDocFullSignatureType } from './checker-jsdoc.js';
 import { checkAliasSymbol } from './checker-modules.js';
 import { checkDecorators } from './checker-decorators.js';
 import { declarationCount, getDeclarations, getSymbolId, } from './symbol.js';
@@ -56,33 +57,33 @@ function checkUsingDeclarationInitializer(c, node, initializer, initType) {
         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 */);
+            checkTypeAssignableTo(c, widenTypeForVariableLikeDeclaration(c, initType, node, false), getUnionType(c, [globalAsyncDisposableType, globalDisposableType, c.nullType, c.undefinedType]), initializer, 978 /* 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 */);
+            checkTypeAssignableTo(c, widenTypeForVariableLikeDeclaration(c, initType, node, false), getUnionType(c, [globalDisposableType, c.nullType, c.undefinedType]), initializer, 977 /* 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 */)
+    if (node.kind === 171 /* 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 */)
+    if (node.kind === 173 /* SyntaxKind.PropertySignature */ && name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+        c.error(node, 1858 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
+    if (name !== undefined && name.kind === 169 /* 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));
+    const initializerNotAllowed = initializer !== undefined && node.kind === 171 /* SyntaxKind.Parameter */ && nodeIsMissing(getBody(node.parent));
     if (name !== undefined &&
-        (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)) {
+        (name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 209 /* SyntaxKind.ArrayBindingPattern */)) {
         if (initializerNotAllowed)
-            c.error(node, 545 /* Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation */);
+            c.error(node, 552 /* 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)
@@ -90,11 +91,11 @@ export function checkVariableLikeDeclaration(c, node) {
         return;
     }
     if (initializerNotAllowed) {
-        c.error(node, 545 /* Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation */);
+        c.error(node, 552 /* 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 */);
+        c.error(name, 452 /* Diagnostics.A_bigint_literal_cannot_be_used_as_a_property_name */);
     const symbol = getSymbolOfDeclaration(c, node);
     if (symbol === undefined) {
         if (initializer !== undefined)
@@ -108,20 +109,20 @@ export function checkVariableLikeDeclaration(c, node) {
     }
     if (name !== undefined &&
         name.kind === 79 /* SyntaxKind.Identifier */ &&
-        node.kind !== 173 /* SyntaxKind.PropertyDeclaration */ &&
-        node.kind !== 172 /* SyntaxKind.PropertySignature */)
+        node.kind !== 174 /* SyntaxKind.PropertyDeclaration */ &&
+        node.kind !== 173 /* 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 */) {
+    if (node.kind !== 174 /* SyntaxKind.PropertyDeclaration */ &&
+        node.kind !== 173 /* SyntaxKind.PropertySignature */ &&
+        node.kind !== 171 /* SyntaxKind.Parameter */) {
         checkExportsOnMergedDeclarations(c, node);
-        if (node.kind === 261 /* SyntaxKind.VariableDeclaration */)
+        if (node.kind === 262 /* 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 */) {
+        if (initializer !== undefined && node.parent.parent.kind !== 251 /* SyntaxKind.ForInStatement */) {
             const initType = checkExpressionCached(c, initializer);
             checkTypeAssignableToAndOptionallyElaborate(c, initType, t, node, initializer);
             checkUsingDeclarationInitializer(c, node, initializer, initType);
@@ -158,7 +159,7 @@ 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 */;
+    const needCheckInitializer = initializer !== undefined && node.parent.parent.kind !== 251 /* SyntaxKind.ForInStatement */;
     let needCheckWidenedType = true;
     for (const e of getElements(name).nodes) {
         if (getName(e) !== undefined) {
@@ -177,7 +178,7 @@ function checkBindingPatternInitializer(c, node, name, initializer) {
             checkTypeAssignableToAndOptionallyElaborate(c, initializerType, getWidenedTypeForVariableLikeDeclaration(c, node, false), node, initializer);
     }
     if (needCheckWidenedType) {
-        if (name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)
+        if (name.kind === 209 /* SyntaxKind.ArrayBindingPattern */)
             checkIteratedTypeOrElementType(c, 65 /* IterationUse.Destructuring */, widenedType, c.undefinedType, node);
         else if (c.strictNullChecks)
             checkNonNullNonVoidType(c, widenedType, node);
@@ -202,20 +203,20 @@ function checkVarDeclaredNamesNotShadowed(c, node, symbol) {
     if (declaration === undefined || (getCombinedNodeFlags(declaration) & 7 /* NodeFlags.BlockScoped */) === 0)
         return;
     let list = declaration;
-    while (list !== undefined && list.kind !== 262 /* SyntaxKind.VariableDeclarationList */)
+    while (list !== undefined && list.kind !== 263 /* SyntaxKind.VariableDeclarationList */)
         list = list.parent;
     const statement = list?.parent;
-    const container = statement !== undefined && statement.kind === 244 /* SyntaxKind.VariableStatement */ ? statement.parent : undefined;
+    const container = statement !== undefined && statement.kind === 245 /* 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 */);
+        ((container.kind === 243 /* SyntaxKind.Block */ && isFunctionLike(container.parent)) ||
+            container.kind === 270 /* SyntaxKind.ModuleBlock */ ||
+            container.kind === 269 /* SyntaxKind.ModuleDeclaration */ ||
+            container.kind === 308 /* 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);
+    c.error(node, 651 /* 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) {
@@ -225,27 +226,27 @@ function checkParameter(c, node) {
     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 (fn.kind !== 178 /* SyntaxKind.Constructor */ || !nodeIsPresent(getBody(fn)))
+            c.error(node, 550 /* Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation */);
+        if (fn.kind === 178 /* SyntaxKind.Constructor */ && paramName === 'constructor')
+            c.error(name, 576 /* 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 */);
+        c.error(node, 636 /* 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 */);
+            c.error(node, 821 /* Diagnostics.A_0_parameter_must_be_the_first_parameter */, paramName);
+        if (fn.kind === 178 /* SyntaxKind.Constructor */ ||
+            fn.kind === 182 /* SyntaxKind.ConstructSignature */ ||
+            fn.kind === 187 /* SyntaxKind.ConstructorType */)
+            c.error(node, 822 /* Diagnostics.A_constructor_cannot_have_a_this_parameter */);
+        if (fn.kind === 221 /* SyntaxKind.ArrowFunction */)
+            c.error(node, 869 /* Diagnostics.An_arrow_function_cannot_have_a_this_parameter */);
+        if (fn.kind === 179 /* SyntaxKind.GetAccessor */ || fn.kind === 180 /* SyntaxKind.SetAccessor */)
+            c.error(node, 923 /* 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.
@@ -253,27 +254,27 @@ function checkParameter(c, node) {
         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 */);
+            c.error(node, 551 /* Diagnostics.A_rest_parameter_must_be_of_an_array_type */);
     }
 }
-function isVariableLike(node) {
+export 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 */:
+        case 210 /* SyntaxKind.BindingElement */:
+        case 307 /* SyntaxKind.EnumMember */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 262 /* 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 */))
+    if ((left.kind === 171 /* SyntaxKind.Parameter */ && right.kind === 262 /* SyntaxKind.VariableDeclaration */) ||
+        (left.kind === 262 /* SyntaxKind.VariableDeclaration */ && right.kind === 171 /* SyntaxKind.Parameter */))
         return true;
     if (isOptionalDeclaration(left) !== isOptionalDeclaration(right))
         return false;
@@ -286,12 +287,14 @@ function areDeclarationFlagsIdentical(left, right) {
     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));
+    c.error(name, 827 /* 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.propertyName.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+        grammarErrorOnNode(c, element.propertyName, 1899 /* Diagnostics.Private_identifiers_cannot_be_used_in_destructuring_patterns */);
     if (element.propertyName !== undefined &&
         element.name.kind === 79 /* SyntaxKind.Identifier */ &&
         isPartOfParameterDeclaration(element) &&
@@ -304,11 +307,11 @@ function checkBindingElement(c, element) {
     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 */ &&
+    if (element.parent.kind === 208 /* 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 */)
+    if (element.propertyName !== undefined && element.propertyName.kind === 169 /* SyntaxKind.ComputedPropertyName */)
         checkComputedPropertyName(c, element.propertyName);
     // Private and protected properties can't be destructured outside their classes.
     const parent = element.parent.parent;
@@ -327,7 +330,7 @@ function checkBindingElement(c, element) {
     }
     const name = element.name;
     if (name !== undefined &&
-        (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)) {
+        (name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 209 /* SyntaxKind.ArrayBindingPattern */)) {
         for (const e of getElements(name).nodes)
             checkBindingElement(c, e);
     }
@@ -335,10 +338,10 @@ function checkBindingElement(c, element) {
     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 */);
+        c.error(element, 552 /* 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 */) {
+    if (name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 209 /* SyntaxKind.ArrayBindingPattern */) {
         checkBindingPatternInitializer(c, element, name, element.initializer);
         return;
     }
@@ -355,7 +358,7 @@ function checkBindingElement(c, element) {
             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 */)
+                if (initializer !== undefined && getRootDeclaration(element).parent.parent.kind !== 251 /* SyntaxKind.ForInStatement */)
                     checkTypeAssignableToAndOptionallyElaborate(c, checkExpressionCached(c, initializer), t, element, initializer);
             }
             else if (symbol.valueDeclaration !== undefined) {
@@ -381,13 +384,13 @@ function checkBindingElement(c, element) {
 }
 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 message = nextDeclaration.kind === 174 /* SyntaxKind.PropertyDeclaration */ || nextDeclaration.kind === 173 /* SyntaxKind.PropertySignature */
+        ? 856 /* Diagnostics.Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_type_2 */
+        : 581 /* 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]));
+        err.addRelatedInfo(createDiagnosticForNode(getNameOfDeclaration(firstDeclaration) ?? firstDeclaration, 1367 /* Diagnostics.X_0_was_also_declared_here */, [declName]));
 }
 // ---- Functions
 export function checkFunctionDeclaration(c, node) {
@@ -395,6 +398,7 @@ export function checkFunctionDeclaration(c, node) {
     if (symbol !== undefined)
         getTypeOfSymbol(c, symbol);
     checkFunctionLikeBody(c, node);
+    checkJSDocFullSignatureType(c, node);
     checkJSDocFullSignature(c, node);
     checkFunctionOrMethodSymbols(c, node);
     checkCollisionsForDeclarationName(c, node, getName(node));
@@ -411,19 +415,19 @@ export function checkTypeParameter(c, node) {
     // 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));
+        c.error(tp.defaultType, 855 /* 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 */);
+        checkTypeAssignableTo(c, defaultType, getTypeWithThisArgument(c, instantiateType(c, constraintType, new SimpleTypeMapper(typeParameter, defaultType)), defaultType, false), tp.defaultType, 527 /* Diagnostics.Type_0_does_not_satisfy_the_constraint_1 */);
+    checkTypeNameIsReserved(c, tp.name, 549 /* 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))
+    const isTypeAlias = parent.kind === 267 /* SyntaxKind.TypeAliasDeclaration */ || parent.kind === 346 /* SyntaxKind.JSTypeAliasDeclaration */;
+    if (!isTypeAlias && parent.kind !== 266 /* SyntaxKind.InterfaceDeclaration */ && !isClassLike(parent))
         return;
     const typeParameterSymbol = getSymbolOfDeclaration(c, node);
     if (typeParameterSymbol === undefined)
@@ -437,7 +441,7 @@ export function checkTypeParameterDeferred(c, node) {
         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 */);
+        c.error(node, 787 /* 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 */;
@@ -445,7 +449,7 @@ export function checkTypeParameterDeferred(c, node) {
         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 */);
+        checkTypeAssignableTo(c, source, target, node, 786 /* Diagnostics.Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation */);
         c.varianceTypeParameter = saveVarianceTypeParameter;
     }
 }
@@ -464,10 +468,10 @@ export function checkTypeParameters(c, list) {
             finder.visitNode(node.defaultType);
         }
         else if (seenDefault)
-            c.error(node, 838 /* Diagnostics.Required_type_parameters_may_not_follow_optional_type_parameters */);
+            c.error(node, 845 /* 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));
+                c.error(node.name, 485 /* Diagnostics.Duplicate_identifier_0 */, declarationNameToString(getSourceFileOfNode(node), node.name));
     }
 }
 /** Reports references in a type parameter default to the parameter itself or later ones. */
@@ -482,12 +486,12 @@ class LaterTypeParameterReferenceFinder extends NodeVisitor {
         this.index = index;
     }
     visitNode(node) {
-        if (node.kind === 184 /* SyntaxKind.TypeReference */) {
+        if (node.kind === 185 /* 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 */);
+                        this.c.error(node, 883 /* Diagnostics.Type_parameter_defaults_can_only_reference_previously_declared_type_parameters */);
         }
         return node.forEachChild(this);
     }
@@ -495,7 +499,7 @@ class LaterTypeParameterReferenceFinder extends NodeVisitor {
 export function checkTypeAliasDeclaration(c, node) {
     const alias = node;
     const typeParameters = alias.typeParameters;
-    checkTypeNameIsReserved(c, alias.name, 623 /* Diagnostics.Type_alias_name_cannot_be_0 */);
+    checkTypeNameIsReserved(c, alias.name, 630 /* Diagnostics.Type_alias_name_cannot_be_0 */);
     checkExportsOnMergedDeclarations(c, node);
     checkTypeParameters(c, typeParameters);
     if (alias.type.kind === 141 /* SyntaxKind.IntrinsicKeyword */) {
@@ -503,7 +507,7 @@ export function checkTypeAliasDeclaration(c, node) {
         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 */);
+            c.error(alias.type, 934 /* Diagnostics.The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types */);
     }
     else
         checkSourceElement(c, alias.type);
@@ -530,7 +534,10 @@ export function checkTypeArgumentConstraintsOfReference(c, node, type) {
 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 */);
+        c.error(node, 1862 /* Diagnostics.An_enum_member_cannot_be_named_with_a_private_identifier */);
+    // A computed name is a grammar error, but its expression is checked.
+    if (name !== undefined && name.kind === 169 /* SyntaxKind.ComputedPropertyName */)
+        checkExpression(c, getExpression(name));
     const initializer = getInitializer(node);
     if (initializer !== undefined)
         checkExpression(c, initializer);
@@ -538,7 +545,7 @@ export function checkEnumMember(c, node) {
 export function checkEnumDeclaration(c, node) {
     const name = getName(node);
     checkCollisionsForDeclarationName(c, node, name);
-    checkTypeNameIsReserved(c, name, 599 /* Diagnostics.Enum_name_cannot_be_0 */);
+    checkTypeNameIsReserved(c, name, 606 /* Diagnostics.Enum_name_cannot_be_0 */);
     checkExportsOnMergedDeclarations(c, node);
     for (const member of node.members.nodes)
         checkSourceElement(c, member);
@@ -553,25 +560,33 @@ export function checkEnumDeclaration(c, node) {
         return;
     links.enumChecked = true;
     if (declarationCount(symbol) > 1) {
-        const enumIsConst = isEnumConst(node);
+        // Reported against the first enum declaration, whichever declaration is checked first.
+        const enumIsConst = isEnumConst(getDeclarationOfKind(symbol, 268 /* SyntaxKind.EnumDeclaration */));
         for (const d of getDeclarations(symbol))
-            if (d.kind === 267 /* SyntaxKind.EnumDeclaration */ && isEnumConst(d) !== enumIsConst)
-                c.error(getNameOfDeclaration(d), 637 /* Diagnostics.Enum_declarations_must_all_be_const_or_non_const */);
+            if (d.kind === 268 /* SyntaxKind.EnumDeclaration */ && isEnumConst(d) !== enumIsConst)
+                c.error(getNameOfDeclaration(d), 644 /* 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 getDeclarations(symbol)) {
-        if (d.kind !== 267 /* SyntaxKind.EnumDeclaration */)
+        if (d.kind !== 268 /* 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 */);
+            c.error(getName(members[0]), 607 /* Diagnostics.In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element */);
         else
             seenEnumMissingInitialInitializer = true;
     }
 }
+/** An ambient module's import attributes type must be assignable to the global `ImportAttributes`. */
+function checkImportAttributesType(c, attributes) {
+    checkSourceElement(c, attributes);
+    const importAttributesType = getCachedGlobalType(c, 'ImportAttributes', 0, true);
+    if (importAttributesType !== c.emptyObjectType)
+        checkTypeAssignableTo(c, getTypeFromTypeNode(c, attributes), importAttributesType, attributes, undefined);
+}
 /** 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);
@@ -584,7 +599,10 @@ export function checkModuleDeclaration(c, node) {
     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 */);
+        c.error(module.name, 811 /* Diagnostics.Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context */);
+    const attributes = module.attributes;
+    if (attributes !== undefined)
+        checkImportAttributesType(c, attributes);
     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 */;
@@ -593,7 +611,7 @@ export function checkModuleDeclaration(c, node) {
     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 */);
+        c.error(module.name, 453 /* 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.
@@ -610,13 +628,13 @@ export function checkModuleDeclaration(c, node) {
             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 */);
+                    c.error(module.name, 608 /* 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 */);
+                    c.error(module.name, 609 /* 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 */ &&
+            node.parent.kind === 308 /* 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 */);
@@ -626,22 +644,24 @@ export function checkModuleDeclaration(c, node) {
     if (!isAmbientModule(node))
         return;
     if (isModuleAugmentationExternal(node)) {
+        if (attributes !== undefined)
+            c.error(attributes, 464 /* Diagnostics.Import_attributes_are_not_allowed_on_a_module_augmentation */);
         // 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 */)
+        if (checkBody && body !== undefined && body.kind === 270 /* 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)) {
+        c.error(module.name, 810 /* Diagnostics.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations */);
+    else if (parent.kind === 308 /* SyntaxKind.SourceFile */ && !isExternalModule(parent)) {
         if (isExternalModuleNameRelative(getText(module.name)))
-            c.error(module.name, 604 /* Diagnostics.Ambient_module_declaration_cannot_specify_relative_module_name */);
+            c.error(module.name, 611 /* 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 */);
+        c.error(module.name, 610 /* Diagnostics.Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces */);
 }
 export function isInstantiatedModule(node, preserveConstEnums) {
     const state = getModuleInstanceState(node);
@@ -649,31 +669,31 @@ export function isInstantiatedModule(node, preserveConstEnums) {
 }
 function getFirstNonAmbientClassOrFunctionDeclaration(symbol) {
     for (const d of getDeclarations(symbol))
-        if ((d.kind === 264 /* SyntaxKind.ClassDeclaration */ ||
-            (d.kind === 263 /* SyntaxKind.FunctionDeclaration */ && nodeIsPresent(getBody(d)))) &&
+        if ((d.kind === 265 /* SyntaxKind.ClassDeclaration */ ||
+            (d.kind === 264 /* 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 */:
+        case 245 /* 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 */);
+        case 279 /* SyntaxKind.ExportAssignment */:
+        case 280 /* SyntaxKind.ExportDeclaration */:
+            grammarErrorOnFirstToken(c, node, 807 /* Diagnostics.Exports_and_export_assignments_are_not_permitted_in_module_augmentations */);
             return;
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
             // `import a = e.x` is allowed; `import a = require("m")` isn't.
-            if (node.moduleReference.kind !== 284 /* SyntaxKind.ExternalModuleReference */)
+            if (node.moduleReference.kind !== 285 /* SyntaxKind.ExternalModuleReference */)
                 return;
-            grammarErrorOnFirstToken(c, node, 801 /* Diagnostics.Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module */);
+            grammarErrorOnFirstToken(c, node, 808 /* 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 */);
+        case 274 /* SyntaxKind.ImportDeclaration */:
+            grammarErrorOnFirstToken(c, node, 808 /* Diagnostics.Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module */);
             return;
     }
 }
@@ -692,7 +712,7 @@ function grammarErrorOnFirstToken(c, node, message) {
  */
 function checkModuleElementContext(c, node, message) {
     const parent = node.parent.kind;
-    if (parent === 307 /* SyntaxKind.SourceFile */ || parent === 269 /* SyntaxKind.ModuleBlock */ || parent === 268 /* SyntaxKind.ModuleDeclaration */)
+    if (parent === 308 /* SyntaxKind.SourceFile */ || parent === 270 /* SyntaxKind.ModuleBlock */ || parent === 269 /* SyntaxKind.ModuleDeclaration */)
         return false;
     grammarErrorOnFirstToken(c, node, message);
     return true;
@@ -712,7 +732,7 @@ export function checkExternalModuleExports(c, node) {
         (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 */);
+            c.error(declaration, 494 /* 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.
@@ -720,7 +740,7 @@ export function checkExternalModuleExports(c, node) {
             continue;
         let count = 0;
         for (const d of getDeclarations(symbol))
-            if (isNotOverload(d) && !isAccessorDeclaration(d) && d.kind !== 265 /* SyntaxKind.InterfaceDeclaration */)
+            if (isNotOverload(d) && !isAccessorDeclaration(d) && d.kind !== 266 /* SyntaxKind.InterfaceDeclaration */)
                 count++;
         // A type alias may merge with one value.
         if ((symbol.flags & 524288 /* SymbolFlags.TypeAlias */) !== 0 && count <= 2)
@@ -735,7 +755,7 @@ export function checkExternalModuleExports(c, node) {
             continue;
         for (const d of getDeclarations(symbol))
             if (isNotOverload(d))
-                c.error(d, 501 /* Diagnostics.Cannot_redeclare_exported_variable_0 */, id);
+                c.error(d, 508 /* Diagnostics.Cannot_redeclare_exported_variable_0 */, id);
     }
 }
 function hasExportedMembersOfKind(c, moduleSymbol, kind) {
@@ -754,15 +774,15 @@ function hasShadowedNamespace(c, symbol) {
         hasExportedMembersOfKind(c, target, 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */));
 }
 function isNotOverload(node) {
-    return ((node.kind !== 263 /* SyntaxKind.FunctionDeclaration */ && node.kind !== 175 /* SyntaxKind.MethodDeclaration */) ||
+    return ((node.kind !== 264 /* SyntaxKind.FunctionDeclaration */ && node.kind !== 176 /* SyntaxKind.MethodDeclaration */) ||
         getBody(node) !== undefined);
 }
 function isAccessorDeclaration(node) {
-    return node.kind === 178 /* SyntaxKind.GetAccessor */ || node.kind === 179 /* SyntaxKind.SetAccessor */;
+    return node.kind === 179 /* SyntaxKind.GetAccessor */ || node.kind === 180 /* SyntaxKind.SetAccessor */;
 }
 function isTopLevelInExternalModuleAugmentation(node) {
     const parent = node.parent;
-    if (parent === undefined || parent.kind !== 269 /* SyntaxKind.ModuleBlock */)
+    if (parent === undefined || parent.kind !== 270 /* SyntaxKind.ModuleBlock */)
         return false;
     const module = parent.parent;
     return isAmbientModule(module) && isModuleAugmentationExternal(module);
@@ -775,8 +795,12 @@ export function checkExportsOnMergedDeclarations(c, node) {
         if (symbol === undefined || symbol.exportSymbol === undefined)
             return;
     }
-    if (getDeclarationOfKind(symbol, node.kind) !== node)
+    if (declarationCount(symbol) < 2)
+        return;
+    const links = c.symbolLinks(symbol);
+    if (links.mergedExportsChecked)
         return;
+    links.mergedExportsChecked = true;
     let exported = 0 /* DeclarationSpaces.None */;
     let nonExported = 0 /* DeclarationSpaces.None */;
     let defaultExported = 0 /* DeclarationSpaces.None */;
@@ -802,28 +826,28 @@ export function checkExportsOnMergedDeclarations(c, node) {
         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);
+            c.error(name, 793 /* 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);
+            c.error(name, 573 /* 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 */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
+        case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
             return 2 /* DeclarationSpaces.ExportType */;
-        case 268 /* SyntaxKind.ModuleDeclaration */:
+        case 269 /* 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 */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
+        case 307 /* SyntaxKind.EnumMember */:
             return 2 /* DeclarationSpaces.ExportType */ | 1 /* DeclarationSpaces.ExportValue */;
-        case 307 /* SyntaxKind.SourceFile */:
+        case 308 /* SyntaxKind.SourceFile */:
             return 2 /* DeclarationSpaces.ExportType */ | 1 /* DeclarationSpaces.ExportValue */ | 4 /* DeclarationSpaces.ExportNamespace */;
-        case 278 /* SyntaxKind.ExportAssignment */: {
+        case 279 /* SyntaxKind.ExportAssignment */: {
             const expression = getExpression(node);
             const symbol = getSymbolOfDeclaration(c, node);
             if (!isEntityNameExpression(expression, false) ||
@@ -832,12 +856,12 @@ function getDeclarationSpaces(c, node) {
                 return 1 /* DeclarationSpaces.ExportValue */;
             return getAliasDeclarationSpaces(c, node);
         }
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
-        case 275 /* SyntaxKind.NamespaceImport */:
-        case 274 /* SyntaxKind.ImportClause */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 276 /* SyntaxKind.NamespaceImport */:
+        case 275 /* SyntaxKind.ImportClause */:
             return getAliasDeclarationSpaces(c, node);
-        case 174 /* SyntaxKind.MethodSignature */:
-        case 172 /* SyntaxKind.PropertySignature */:
+        case 175 /* SyntaxKind.MethodSignature */:
+        case 173 /* SyntaxKind.PropertySignature */:
             return 2 /* DeclarationSpaces.ExportType */;
     }
     return 1 /* DeclarationSpaces.ExportValue */;
@@ -854,9 +878,9 @@ function getAliasDeclarationSpaces(c, node) {
 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 */ &&
+    if (parent.kind !== 266 /* SyntaxKind.InterfaceDeclaration */ &&
+        parent.kind !== 265 /* SyntaxKind.ClassDeclaration */ &&
+        parent.kind !== 233 /* SyntaxKind.ClassExpression */ &&
         (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0) {
         let container = node.parent;
         while (container !== undefined && (getContainerFlags(container) & 1 /* ContainerFlags.IsContainer */) === 0)
@@ -864,7 +888,7 @@ export function getEffectiveDeclarationFlags(node, flagsToCheck) {
         if (container !== undefined &&
             (container.flags & 64 /* NodeFlags.ExportContext */) !== 0 &&
             (flags & 128 /* ModifierFlags.Ambient */) === 0 &&
-            !(parent.kind === 269 /* SyntaxKind.ModuleBlock */ && isGlobalScopeAugmentation(parent.parent)))
+            !(parent.kind === 270 /* SyntaxKind.ModuleBlock */ && isGlobalScopeAugmentation(parent.parent)))
             flags |= 32 /* ModifierFlags.Export */;
         flags |= 128 /* ModifierFlags.Ambient */;
     }
@@ -879,10 +903,10 @@ export function checkUnusedRenamedBindingElements(c) {
         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 diagnostic = c.error(name, 970 /* 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]));
+            diagnostic.addRelatedInfo(new Diagnostic(file.diagnosticFile(), parameter.end, parameter.end, 971 /* Diagnostics.We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here */, [propertyName]));
     }
     c.renamedBindingElementsInTypes.length = 0;
 }