tsc-ts 0.0.10 → 0.1.1

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

@@ -1,6 +1,6 @@
 // JSX: element and fragment types, the `JSX` namespace, intrinsic elements, attributes and children.
-import { checkDeprecatedJsxAttribute, checkDeprecatedSignature } from './checker-deprecation.js';
-import { getSymbol, getTagName, getText, getTypeArguments, getExpression, Identifier, PropertySignatureDeclaration, } from './ast.js';
+import { checkDeprecatedSignature } from './checker-deprecation.js';
+import { NodeVisitor, getSymbol, getTagName, getText, getTypeArguments, getExpression, Identifier, PropertySignatureDeclaration, } from './ast.js';
 import { getSourceFileOfNode, getSourceTextOfNode } from './binder-utilities.js';
 import { Diagnostic, chainDiagnostic } from './diagnostics.js';
 import { JsxEmit } from './options.js';
@@ -38,6 +38,7 @@ import { filterType, isTupleType } from './checker-type-factory.js';
 import { createTypeFromGenericGlobalType } from './checker-type-factory.js';
 import { isTypeAssignableTo } from './relations.js';
 import { copyDeclarations, declarationCount, getSymbolId, } from './symbol.js';
+import { IdentifierName } from './identifier-name.js';
 // Names in the `JSX` namespace.
 const jsxNamespaceName = 'JSX';
 const jsxIntrinsicElementsName = 'IntrinsicElements';
@@ -94,7 +95,7 @@ function fileLinks(c, file) {
 }
 // ---- Syntax helpers
 export function isJsxOpeningLikeElement(node) {
-    return node.kind === 287 /* SyntaxKind.JsxOpeningElement */ || node.kind === 286 /* SyntaxKind.JsxSelfClosingElement */;
+    return node.kind === 288 /* SyntaxKind.JsxOpeningElement */ || node.kind === 287 /* SyntaxKind.JsxSelfClosingElement */;
 }
 function isIntrinsicJsxName(name) {
     if (name.length === 0)
@@ -105,11 +106,11 @@ function isIntrinsicJsxName(name) {
 /** Whether a tag name refers to an intrinsic element: a lowercase or dashed identifier, or `ns:name`. */
 export function isJsxIntrinsicTagName(tagName) {
     return ((tagName.kind === 79 /* SyntaxKind.Identifier */ && isIntrinsicJsxName(getText(tagName))) ||
-        tagName.kind === 296 /* SyntaxKind.JsxNamespacedName */);
+        tagName.kind === 297 /* SyntaxKind.JsxNamespacedName */);
 }
 /** The text of an identifier or `ns:name`. */
 function jsxNameText(node) {
-    if (node.kind === 296 /* SyntaxKind.JsxNamespacedName */) {
+    if (node.kind === 297 /* SyntaxKind.JsxNamespacedName */) {
         const name = node;
         return name.namespace.text + ':' + name.name.text;
     }
@@ -122,13 +123,13 @@ function entityNameToString(node) {
     switch (node.kind) {
         case 109 /* SyntaxKind.ThisKeyword */:
             return 'this';
-        case 212 /* SyntaxKind.PropertyAccessExpression */: {
+        case 213 /* SyntaxKind.PropertyAccessExpression */: {
             const access = node;
             return entityNameToString(access.expression) + '.' + entityNameToString(access.name);
         }
-        case 167 /* SyntaxKind.QualifiedName */:
-            return entityNameToString(node.left) + '.' + node.right.text;
-        case 296 /* SyntaxKind.JsxNamespacedName */:
+        case 168 /* SyntaxKind.QualifiedName */:
+            return entityNameToString(node.left) + '.' + getText(node.right);
+        case 297 /* SyntaxKind.JsxNamespacedName */:
             return jsxNameText(node);
     }
     return getText(node);
@@ -137,7 +138,7 @@ export function getTagNameOf(node) {
     return getTagName(node);
 }
 export function getAttributesOf(node) {
-    return node.kind === 286 /* SyntaxKind.JsxSelfClosingElement */
+    return node.kind === 287 /* SyntaxKind.JsxSelfClosingElement */
         ? node.attributes
         : node.attributes;
 }
@@ -145,9 +146,9 @@ function getTypeArgumentListOf(node) {
     return getTypeArguments(node);
 }
 function getChildrenOf(node) {
-    if (node.kind === 285 /* SyntaxKind.JsxElement */)
+    if (node.kind === 286 /* SyntaxKind.JsxElement */)
         return node.children.nodes;
-    if (node.kind === 289 /* SyntaxKind.JsxFragment */)
+    if (node.kind === 290 /* SyntaxKind.JsxFragment */)
         return node.children.nodes;
     return [];
 }
@@ -155,7 +156,7 @@ function getChildrenOf(node) {
 export function getSemanticJsxChildren(children) {
     const result = [];
     for (const child of children) {
-        if (child.kind === 295 /* SyntaxKind.JsxExpression */) {
+        if (child.kind === 296 /* SyntaxKind.JsxExpression */) {
             if (child.expression !== undefined)
                 result.push(child);
         }
@@ -202,7 +203,7 @@ export function getJsxNamespace(c, location) {
     if (location !== undefined) {
         const file = getSourceFileOfNode(location);
         const links = fileLinks(c, file);
-        if (location.kind === 290 /* SyntaxKind.JsxOpeningFragment */) {
+        if (location.kind === 291 /* SyntaxKind.JsxOpeningFragment */) {
             if (links.localJsxFragmentNamespace !== '')
                 return links.localJsxFragmentNamespace;
             const fragmentPragma = getPragma(file, 'jsxfrag', 'factory');
@@ -293,12 +294,30 @@ export function getJsxNamespaceContainerForImplicitImport(c, location) {
         links.jsxImplicitImportContainer = c.unknownSymbol;
         return undefined;
     }
-    const mod = resolveExternalModule(c, specifier, getText(specifier), 995 /* Diagnostics.This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed */, location, false);
+    // A missing module is reported once, at the first JSX tag of the file, whichever tag is checked first.
+    const finder = new FirstJsxTagFinder();
+    file.forEachChild(finder);
+    const mod = resolveExternalModule(c, specifier, getText(specifier), 1002 /* Diagnostics.This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed */, finder.tag ?? location, false, undefined);
     const resolved = mod !== undefined && mod !== c.unknownSymbol ? resolveSymbol(c, mod) : undefined;
     const result = resolved !== undefined ? getMergedSymbol(c, resolved) : undefined;
     links.jsxImplicitImportContainer = result ?? c.unknownSymbol;
     return result;
 }
+/** The first JSX element or self-closing element of a file, or the opening tag of its first fragment. */
+class FirstJsxTagFinder extends NodeVisitor {
+    tag = undefined;
+    visitNode(node) {
+        if (node.kind === 286 /* SyntaxKind.JsxElement */ || node.kind === 287 /* SyntaxKind.JsxSelfClosingElement */) {
+            this.tag = node;
+            return true;
+        }
+        if (node.kind === 290 /* SyntaxKind.JsxFragment */) {
+            this.tag = node.openingFragment;
+            return true;
+        }
+        return node.forEachChild(this);
+    }
+}
 /** The `JSX` namespace for `location`: the factory's, the runtime module's, or the global one. */
 export function getJsxNamespaceAt(c, location) {
     const links = elementLinks(c, location);
@@ -385,7 +404,7 @@ function getNameFromJsxElementAttributesContainer(c, containerName, ns) {
             if (props.length === 1)
                 return props[0].name;
             if (declarationCount(sym) !== 0)
-                c.error(sym.declaration, 752 /* Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property */, containerName);
+                c.error(sym.declaration, 759 /* Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property */, containerName);
         }
     }
     return "\uFFFEmissing" /* InternalSymbolName.Missing */;
@@ -431,12 +450,12 @@ export function getIntrinsicTagSymbol(c, node) {
             links.resolvedSymbol = intrinsicElementsType.symbol ?? c.unknownSymbol;
             return links.resolvedSymbol;
         }
-        c.error(node, 516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, propName, 'JSX.' + jsxIntrinsicElementsName);
+        c.error(node, 523 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, propName, 'JSX.' + jsxIntrinsicElementsName);
         links.resolvedSymbol = c.unknownSymbol;
         return c.unknownSymbol;
     }
     if (c.noImplicitAny)
-        c.error(node, 1697 /* Diagnostics.JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists */, jsxIntrinsicElementsName);
+        c.error(node, 1716 /* Diagnostics.JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists */, jsxIntrinsicElementsName);
     links.resolvedSymbol = c.unknownSymbol;
     return c.unknownSymbol;
 }
@@ -521,7 +540,7 @@ function getUninstantiatedJsxSignaturesOfType(c, elementType, caller) {
     if ((elementType.flags & 1024 /* TypeFlags.StringLiteral */) !== 0) {
         const intrinsicType = getIntrinsicAttributesTypeFromStringLiteralType(c, elementType, caller);
         if (intrinsicType === undefined) {
-            c.error(caller, 516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, elementType.stringValue, 'JSX.' + jsxIntrinsicElementsName);
+            c.error(caller, 523 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, elementType.stringValue, 'JSX.' + jsxIntrinsicElementsName);
             return [];
         }
         return [createSignatureForJSXIntrinsic(c, caller, intrinsicType)];
@@ -544,7 +563,7 @@ function getTypeOfFirstParameterOfSignatureWithFallback(c, sig, fallback) {
 }
 /** The props type a signature expects of an element's attributes. */
 export function getEffectiveFirstArgumentForJsxSignature(c, signature, node) {
-    if (node.kind === 290 /* SyntaxKind.JsxOpeningFragment */ || getJsxReferenceKind(c, node) !== 0 /* JsxReferenceKind.Component */)
+    if (node.kind === 291 /* SyntaxKind.JsxOpeningFragment */ || getJsxReferenceKind(c, node) !== 0 /* JsxReferenceKind.Component */)
         return getJsxPropsTypeFromCallSignature(c, signature, node);
     return getJsxPropsTypeFromClassType(c, signature, node);
 }
@@ -567,7 +586,7 @@ function getJsxPropsTypeFromClassType(c, sig, context) {
     else {
         attributesType = getJsxPropsTypeForSignatureFromMember(c, sig, forcedLookupLocation);
         if (attributesType === undefined && getAttributesOf(context).properties.nodes.length !== 0)
-            c.error(context, 751 /* Diagnostics.JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property */, forcedLookupLocation);
+            c.error(context, 758 /* Diagnostics.JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property */, forcedLookupLocation);
     }
     if (attributesType === undefined)
         return c.unknownType;
@@ -622,7 +641,7 @@ function getJsxManagedAttributesFromLocatedAttributes(c, context, ns, attributes
     return attributesType;
 }
 function getStaticTypeOfReferencedJsxConstructor(c, context) {
-    if (context.kind === 290 /* SyntaxKind.JsxOpeningFragment */)
+    if (context.kind === 291 /* SyntaxKind.JsxOpeningFragment */)
         return getJSXFragmentType(c, context);
     const tagName = getTagNameOf(context);
     if (isJsxIntrinsicTagName(tagName)) {
@@ -658,7 +677,7 @@ function getJSXFragmentType(c, node) {
         let flags = 111551 /* SymbolFlags.Value */;
         if (!shouldModuleRefErr)
             flags &= ~384 /* SymbolFlags.Enum */;
-        jsxFactorySymbol = resolveName(c, node, jsxFragmentFactoryName, flags, 999 /* Diagnostics.Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found */, true, false);
+        jsxFactorySymbol = resolveName(c, node, jsxFragmentFactoryName, flags, 1006 /* Diagnostics.Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found */, true, false);
     }
     if (jsxFactorySymbol === undefined) {
         links.jsxFragmentType = c.errorType;
@@ -687,7 +706,7 @@ export function checkJsxChildren(c, node, checkMode) {
             if (!child.containsOnlyTriviaWhiteSpaces)
                 childTypes.push(c.stringType);
         }
-        else if (child.kind === 295 /* SyntaxKind.JsxExpression */ && child.expression === undefined)
+        else if (child.kind === 296 /* SyntaxKind.JsxExpression */ && child.expression === undefined)
             continue;
         else
             childTypes.push(checkExpressionForMutableLocationEx(c, child, checkMode));
@@ -698,9 +717,9 @@ function parentHasSemanticJsxChildren(openingLikeElement) {
     const parent = openingLikeElement.parent;
     if (parent === undefined)
         return false;
-    if (parent.kind === 285 /* SyntaxKind.JsxElement */ && parent.openingElement === openingLikeElement)
+    if (parent.kind === 286 /* SyntaxKind.JsxElement */ && parent.openingElement === openingLikeElement)
         return getSemanticJsxChildren(parent.children.nodes).length !== 0;
-    if (parent.kind === 289 /* SyntaxKind.JsxFragment */ && parent.openingFragment === openingLikeElement)
+    if (parent.kind === 290 /* SyntaxKind.JsxFragment */ && parent.openingFragment === openingLikeElement)
         return getSemanticJsxChildren(parent.children.nodes).length !== 0;
     return false;
 }
@@ -722,13 +741,13 @@ export function createJsxAttributesTypeFromAttributesProperty(c, openingLikeElem
     let explicitlySpecifyChildrenAttribute = false;
     let objectFlags = 2048 /* ObjectFlags.JsxAttributes */;
     const jsxChildrenPropertyName = getJsxElementChildrenPropertyName(c, getJsxNamespaceAt(c, openingLikeElement));
-    if (openingLikeElement.kind !== 290 /* SyntaxKind.JsxOpeningFragment */) {
+    if (openingLikeElement.kind !== 291 /* SyntaxKind.JsxOpeningFragment */) {
         const attributes = getAttributesOf(openingLikeElement);
         attributesSymbol = attributes.symbol;
         attributeParent = attributes;
         const contextualType = getContextualType(c, attributes);
         for (const attributeDecl of attributes.properties.nodes) {
-            if (attributeDecl.kind === 292 /* SyntaxKind.JsxAttribute */) {
+            if (attributeDecl.kind === 293 /* SyntaxKind.JsxAttribute */) {
                 const member = getSymbol(attributeDecl);
                 const exprType = checkJsxAttribute(c, attributeDecl, checkMode);
                 objectFlags |= exprType.objectFlags & 458752 /* ObjectFlags.PropagatingFlags */;
@@ -745,8 +764,6 @@ export function createJsxAttributesTypeFromAttributesProperty(c, openingLikeElem
                     allAttributesTable.set(attributeSymbol.name, attributeSymbol);
                 if (jsxNameText(attributeDecl.name) === jsxChildrenPropertyName)
                     explicitlySpecifyChildrenAttribute = true;
-                if (contextualType !== undefined)
-                    checkDeprecatedJsxAttribute(c, contextualType, attributeDecl);
                 if (contextualType !== undefined &&
                     (checkMode & 2 /* CheckMode.Inferential */) !== 0 &&
                     (checkMode & 4 /* CheckMode.SkipContextSensitive */) === 0 &&
@@ -775,7 +792,7 @@ export function createJsxAttributesTypeFromAttributesProperty(c, openingLikeElem
                         checkSpreadPropOverrides(c, exprType, allAttributesTable, attributeDecl);
                 }
                 else {
-                    c.error(expression, 830 /* Diagnostics.Spread_types_may_only_be_created_from_object_types */);
+                    c.error(expression, 837 /* Diagnostics.Spread_types_may_only_be_created_from_object_types */);
                     typeToIntersect =
                         typeToIntersect !== undefined ? getIntersectionType(c, [typeToIntersect, exprType]) : exprType;
                 }
@@ -791,9 +808,9 @@ export function createJsxAttributesTypeFromAttributesProperty(c, openingLikeElem
         if (!hasSpreadAnyType && jsxChildrenPropertyName !== "\uFFFEmissing" /* InternalSymbolName.Missing */ && jsxChildrenPropertyName !== '') {
             // Children overwrite a `children` attribute; one from a spread isn't reported.
             if (explicitlySpecifyChildrenAttribute)
-                c.error(attributeParent, 842 /* Diagnostics.X_0_are_specified_twice_The_attribute_named_0_will_be_overwritten */, jsxChildrenPropertyName);
+                c.error(attributeParent, 849 /* Diagnostics.X_0_are_specified_twice_The_attribute_named_0_will_be_overwritten */, jsxChildrenPropertyName);
             let childrenContextualType = undefined;
-            if (openingLikeElement.kind === 287 /* SyntaxKind.JsxOpeningElement */) {
+            if (openingLikeElement.kind === 288 /* SyntaxKind.JsxOpeningElement */) {
                 const contextualType = getApparentTypeOfContextualType(c, getAttributesOf(openingLikeElement));
                 if (contextualType !== undefined)
                     childrenContextualType = getTypeOfPropertyOfContextualType(c, contextualType, jsxChildrenPropertyName);
@@ -808,7 +825,7 @@ export function createJsxAttributesTypeFromAttributesProperty(c, openingLikeElem
                 c.symbolTypes.set(id, createArrayType(c, getUnionType(c, childTypes)));
             // A property signature in the attributes declares the synthetic `children` property, so it is
             // checked as an excess property like the attributes.
-            const childrenDeclaration = new PropertySignatureDeclaration(undefined, new Identifier(jsxChildrenPropertyName), undefined, undefined, undefined);
+            const childrenDeclaration = new PropertySignatureDeclaration(undefined, new Identifier(new IdentifierName(jsxChildrenPropertyName)), undefined, undefined, undefined);
             childrenDeclaration.parent = attributeParent;
             childrenDeclaration.symbol = childrenPropSymbol;
             childrenPropSymbol.valueDeclaration = childrenDeclaration;
@@ -843,7 +860,7 @@ export function isArrayOrTupleLikeType(c, t) {
 export function getEffectiveJsxArguments(node) {
     const attributes = getAttributesOf(node);
     if (attributes.properties.nodes.length !== 0 ||
-        (node.kind === 287 /* SyntaxKind.JsxOpeningElement */ && node.parent.children.nodes.length !== 0))
+        (node.kind === 288 /* SyntaxKind.JsxOpeningElement */ && node.parent.children.nodes.length !== 0))
         return [attributes];
     return [];
 }
@@ -851,7 +868,7 @@ export function getEffectiveJsxArguments(node) {
 export function checkApplicableSignatureForJsxCallLikeElement(c, node, signature, relation, checkMode, reportErrors, diagnosticOutput) {
     // Function components get props, context and an updater; only props come from attributes.
     const paramType = getEffectiveFirstArgumentForJsxSignature(c, signature, node);
-    const attributesType = node.kind === 290 /* SyntaxKind.JsxOpeningFragment */
+    const attributesType = node.kind === 291 /* SyntaxKind.JsxOpeningFragment */
         ? createJsxAttributesTypeFromAttributesProperty(c, node, 0 /* CheckMode.Normal */)
         : checkExpressionWithContextualType(c, getAttributesOf(node), paramType, undefined, checkMode);
     const checkAttributesType = (checkMode & 4 /* CheckMode.SkipContextSensitive */) !== 0
@@ -860,11 +877,11 @@ export function checkApplicableSignatureForJsxCallLikeElement(c, node, signature
     if (!checkTagNameDoesNotExpectTooManyArguments(c, node, reportErrors, diagnosticOutput))
         return false;
     const errorNode = reportErrors
-        ? node.kind === 290 /* SyntaxKind.JsxOpeningFragment */
+        ? node.kind === 291 /* SyntaxKind.JsxOpeningFragment */
             ? node
             : getTagNameOf(node)
         : undefined;
-    const attributes = node.kind === 290 /* SyntaxKind.JsxOpeningFragment */ ? undefined : getAttributesOf(node);
+    const attributes = node.kind === 291 /* SyntaxKind.JsxOpeningFragment */ ? undefined : getAttributesOf(node);
     return checkTypeRelatedToAndOptionallyElaborate(c, checkAttributesType, paramType, relation, errorNode, attributes, undefined, diagnosticOutput);
 }
 /** Whether a function component's required parameters fit what the factory passes it. */
@@ -872,7 +889,7 @@ function checkTagNameDoesNotExpectTooManyArguments(c, node, reportErrors, diagno
     // The automatic runtime's factories aren't looked at.
     if (getJsxNamespaceContainerForImplicitImport(c, node) !== undefined)
         return true;
-    if (node.kind === 290 /* SyntaxKind.JsxOpeningFragment */)
+    if (node.kind === 291 /* SyntaxKind.JsxOpeningFragment */)
         return true;
     const tagName = getTagNameOf(node);
     if (isJsxIntrinsicTagName(tagName))
@@ -911,10 +928,10 @@ function checkTagNameDoesNotExpectTooManyArguments(c, node, reportErrors, diagno
     if (absoluteMinArgCount <= maxParamCount)
         return true;
     if (reportErrors) {
-        const diagnostic = createDiagnosticForNode(tagName, 1381 /* Diagnostics.Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3 */, [entityNameToString(tagName), String(absoluteMinArgCount), entityNameToString(factory), String(maxParamCount)]);
+        const diagnostic = createDiagnosticForNode(tagName, 1392 /* Diagnostics.Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3 */, [entityNameToString(tagName), String(absoluteMinArgCount), entityNameToString(factory), String(maxParamCount)]);
         const tagNameSymbol = getSymbolOfTagName(c, tagName);
         if (tagNameSymbol !== undefined && tagNameSymbol.valueDeclaration !== undefined)
-            diagnostic.addRelatedInfo(createDiagnosticForNode(tagNameSymbol.valueDeclaration, 860 /* Diagnostics.X_0_is_declared_here */, [
+            diagnostic.addRelatedInfo(createDiagnosticForNode(tagNameSymbol.valueDeclaration, 867 /* Diagnostics.X_0_is_declared_here */, [
                 entityNameToString(tagName),
             ]));
         reportDiagnostic(c, diagnostic, diagnosticOutput);
@@ -922,7 +939,7 @@ function checkTagNameDoesNotExpectTooManyArguments(c, node, reportErrors, diagno
     return false;
 }
 function getSymbolOfTagName(c, tagName) {
-    if (tagName.kind === 79 /* SyntaxKind.Identifier */ || tagName.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+    if (tagName.kind === 79 /* SyntaxKind.Identifier */ || tagName.kind === 213 /* SyntaxKind.PropertyAccessExpression */)
         return resolveEntityName(c, tagName, 111551 /* SymbolFlags.Value */, true, false, undefined);
     return undefined;
 }
@@ -933,7 +950,7 @@ function reportDiagnostic(c, diagnostic, output) {
         c.addDiagnostic(diagnostic);
 }
 export function resolveJsxOpeningLikeElement(c, node, checkMode) {
-    const isJsxOpenFragment = node.kind === 290 /* SyntaxKind.JsxOpeningFragment */;
+    const isJsxOpenFragment = node.kind === 291 /* SyntaxKind.JsxOpeningFragment */;
     let exprTypes;
     if (!isJsxOpenFragment) {
         const tagName = getTagNameOf(node);
@@ -947,7 +964,7 @@ export function resolveJsxOpeningLikeElement(c, node, checkMode) {
                 for (const t of typeArguments.nodes)
                     checkSourceElement(c, t);
                 const file = getSourceFileOfNode(node);
-                c.addDiagnostic(new Diagnostic(file.diagnosticFile(), skipTrivia(file.text, typeArguments.pos), typeArguments.end, 712 /* Diagnostics.Expected_0_type_arguments_but_got_1 */, ['0', String(typeArguments.nodes.length)]));
+                c.addDiagnostic(new Diagnostic(file.diagnosticFile(), skipTrivia(file.text, typeArguments.pos), typeArguments.end, 719 /* Diagnostics.Expected_0_type_arguments_but_got_1 */, ['0', String(typeArguments.nodes.length)]));
             }
             return fakeSignature;
         }
@@ -963,7 +980,7 @@ export function resolveJsxOpeningLikeElement(c, node, checkMode) {
         return resolveUntypedCall(c, node);
     if (signatures.length === 0) {
         const errorNode = isJsxOpenFragment ? node : getTagNameOf(node);
-        c.error(errorNode, 749 /* Diagnostics.JSX_element_type_0_does_not_have_any_construct_or_call_signatures */, getTextOfNode(errorNode));
+        c.error(errorNode, 756 /* Diagnostics.JSX_element_type_0_does_not_have_any_construct_or_call_signatures */, getTextOfNode(errorNode));
         return resolveErrorCall(c, node);
     }
     return resolveCall(c, node, signatures, checkMode, 0 /* SignatureFlags.None */, undefined);
@@ -984,7 +1001,7 @@ function isUntypedFunctionCall(c, funcType, apparentFuncType, numCallSignatures)
         isTypeAssignableTo(c, funcType, c.globalFunctionType));
 }
 function resolveUntypedCall(c, node) {
-    if (node.kind !== 290 /* SyntaxKind.JsxOpeningFragment */) {
+    if (node.kind !== 291 /* SyntaxKind.JsxOpeningFragment */) {
         // Type arguments are checked even though an untyped element can't accept them: they get their
         // diagnostics and mark what they reference as used.
         const typeArguments = getTypeArgumentListOf(node);
@@ -1014,16 +1031,17 @@ export function inferJsxTypeArguments(c, node, signature, checkMode, context) {
 /** Checks a JSX expression, element, fragment or attributes node. */
 export function checkJsx(c, node, checkMode) {
     switch (node.kind) {
-        case 295 /* SyntaxKind.JsxExpression */:
+        case 296 /* SyntaxKind.JsxExpression */:
             return checkJsxExpression(c, node, checkMode);
-        case 285 /* SyntaxKind.JsxElement */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */: {
+        case 286 /* SyntaxKind.JsxElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */: {
             checkNodeDeferred(c, node);
             return getJsxElementTypeAt(c, node);
         }
-        case 289 /* SyntaxKind.JsxFragment */:
+        case 290 /* SyntaxKind.JsxFragment */:
             return checkJsxFragment(c, node);
-        case 293 /* SyntaxKind.JsxAttributes */:
+        case 294 /* SyntaxKind.JsxAttributes */:
+            checkNodeDeferred(c, node);
             return createJsxAttributesTypeFromAttributesProperty(c, node.parent, checkMode);
     }
     return c.errorType;
@@ -1034,7 +1052,7 @@ function checkJsxExpression(c, node, checkMode) {
         return c.errorType;
     const t = checkExpressionEx(c, node.expression, checkMode);
     if (node.dotDotDotToken !== undefined && t !== c.anyType && !isArrayType(c, t))
-        c.error(node, 753 /* Diagnostics.JSX_spread_child_must_be_an_array_type */);
+        c.error(node, 760 /* Diagnostics.JSX_spread_child_must_be_an_array_type */);
     return t;
 }
 function checkJsxFragment(c, node) {
@@ -1049,15 +1067,15 @@ function checkJsxFragment(c, node) {
         !hasFragmentFactory &&
         getPragma(file, 'jsxfrag', 'factory') === undefined)
         c.error(node, hasFactory
-            ? 1819 /* Diagnostics.The_jsxFragmentFactory_compiler_option_must_be_provided_to_use_JSX_fragments_with_the_jsxFactory_compiler_option */
-            : 1820 /* Diagnostics.An_jsxFrag_pragma_is_required_when_using_an_jsx_pragma_with_JSX_fragments */);
+            ? 1839 /* Diagnostics.The_jsxFragmentFactory_compiler_option_must_be_provided_to_use_JSX_fragments_with_the_jsxFactory_compiler_option */
+            : 1840 /* Diagnostics.An_jsxFrag_pragma_is_required_when_using_an_jsx_pragma_with_JSX_fragments */);
     checkJsxChildren(c, node, 0 /* CheckMode.Normal */);
     const t = getJsxElementTypeAt(c, node);
     return isErrorType(c, t) ? c.anyType : t;
 }
 /** The deferred check of an element: its signature, closing tag and children. */
 export function checkJsxElementDeferred(c, node) {
-    if (node.kind === 286 /* SyntaxKind.JsxSelfClosingElement */) {
+    if (node.kind === 287 /* SyntaxKind.JsxSelfClosingElement */) {
         checkJsxOpeningLikeElementOrOpeningFragment(c, node);
         return;
     }
@@ -1087,15 +1105,15 @@ function checkJsxOpeningLikeElementOrOpeningFragment(c, node) {
             ? getStringLiteralType(c, jsxNameText(tagName))
             : checkExpression(c, tagName);
         const diagnostics = [];
-        if (!checkTypeRelatedTo(c, tagType, elementTypeConstraint, c.assignableRelation, tagName, 1868 /* Diagnostics.Its_type_0_is_not_a_valid_JSX_element_type */, diagnostics))
-            c.addDiagnostic(chainDiagnostic(diagnostics[0], 918 /* Diagnostics.X_0_cannot_be_used_as_a_JSX_component */, getTextOfNode(tagName)));
+        if (!checkTypeRelatedTo(c, tagType, elementTypeConstraint, c.assignableRelation, tagName, 1888 /* Diagnostics.Its_type_0_is_not_a_valid_JSX_element_type */, diagnostics))
+            c.addDiagnostic(chainDiagnostic(diagnostics[0], 925 /* Diagnostics.X_0_cannot_be_used_as_a_JSX_component */, getTextOfNode(tagName)));
     }
     else
         checkJsxReturnAssignableToAppropriateBound(c, getJsxReferenceKind(c, node), getReturnTypeOfSignature(c, sig), node);
 }
 function checkJsxPreconditions(c, errorNode) {
     if (c.compilerOptions.jsx === undefined)
-        c.error(errorNode, 1807 /* Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided */);
+        c.error(errorNode, 1827 /* Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided */);
     // A missing `JSX.Element` is the error type rather than absent, so TS2602 is never reported.
 }
 function checkJsxReturnAssignableToAppropriateBound(c, refKind, elemInstanceType, openingLikeElement) {
@@ -1104,12 +1122,12 @@ function checkJsxReturnAssignableToAppropriateBound(c, refKind, elemInstanceType
     if (refKind === 1 /* JsxReferenceKind.Function */) {
         const sfcReturnConstraint = getJsxStatelessElementTypeAt(c, openingLikeElement);
         if (sfcReturnConstraint !== undefined)
-            checkTypeRelatedTo(c, elemInstanceType, sfcReturnConstraint, c.assignableRelation, tagName, 919 /* Diagnostics.Its_return_type_0_is_not_a_valid_JSX_element */, diagnostics);
+            checkTypeRelatedTo(c, elemInstanceType, sfcReturnConstraint, c.assignableRelation, tagName, 926 /* Diagnostics.Its_return_type_0_is_not_a_valid_JSX_element */, diagnostics);
     }
     else if (refKind === 0 /* JsxReferenceKind.Component */) {
         const classConstraint = getJsxElementClassTypeAt(c, openingLikeElement);
         if (classConstraint !== undefined)
-            checkTypeRelatedTo(c, elemInstanceType, classConstraint, c.assignableRelation, tagName, 920 /* Diagnostics.Its_instance_type_0_is_not_a_valid_JSX_element */, diagnostics);
+            checkTypeRelatedTo(c, elemInstanceType, classConstraint, c.assignableRelation, tagName, 927 /* Diagnostics.Its_instance_type_0_is_not_a_valid_JSX_element */, diagnostics);
     }
     else {
         const sfcReturnConstraint = getJsxStatelessElementTypeAt(c, openingLikeElement);
@@ -1117,17 +1135,17 @@ function checkJsxReturnAssignableToAppropriateBound(c, refKind, elemInstanceType
         if (sfcReturnConstraint === undefined || classConstraint === undefined)
             return;
         const combined = getUnionType(c, [sfcReturnConstraint, classConstraint]);
-        checkTypeRelatedTo(c, elemInstanceType, combined, c.assignableRelation, tagName, 921 /* Diagnostics.Its_element_type_0_is_not_a_valid_JSX_element */, diagnostics);
+        checkTypeRelatedTo(c, elemInstanceType, combined, c.assignableRelation, tagName, 928 /* Diagnostics.Its_element_type_0_is_not_a_valid_JSX_element */, diagnostics);
     }
     if (diagnostics.length !== 0)
-        c.addDiagnostic(chainDiagnostic(diagnostics[0], 918 /* Diagnostics.X_0_cannot_be_used_as_a_JSX_component */, getTextOfNode(tagName)));
+        c.addDiagnostic(chainDiagnostic(diagnostics[0], 925 /* Diagnostics.X_0_cannot_be_used_as_a_JSX_component */, getTextOfNode(tagName)));
 }
 /** Resolves the factory namespace, which must be in scope for the classic React transform. */
 function markJsxAliasReferenced(c, node) {
     if (getJsxNamespaceContainerForImplicitImport(c, node) !== undefined)
         return;
     const jsxFactoryRefErr = c.compilerOptions.jsx === JsxEmit.React
-        ? 994 /* Diagnostics.This_JSX_tag_requires_0_to_be_in_scope_but_it_could_not_be_found */
+        ? 1001 /* Diagnostics.This_JSX_tag_requires_0_to_be_in_scope_but_it_could_not_be_found */
         : undefined;
     const jsxFactoryNamespace = getJsxNamespace(c, node);
     const jsxFactoryLocation = isJsxOpeningLikeElement(node) ? getTagNameOf(node) : node;
@@ -1136,9 +1154,9 @@ function markJsxAliasReferenced(c, node) {
     if (!shouldFactoryRefErr)
         flags &= ~384 /* SymbolFlags.Enum */;
     // `null` is allowed as the fragment factory.
-    if (!(node.kind === 290 /* SyntaxKind.JsxOpeningFragment */ && jsxFactoryNamespace === 'null'))
+    if (!(node.kind === 291 /* SyntaxKind.JsxOpeningFragment */ && jsxFactoryNamespace === 'null'))
         resolveName(c, jsxFactoryLocation, jsxFactoryNamespace, flags, jsxFactoryRefErr, true, false);
-    if (node.kind === 290 /* SyntaxKind.JsxOpeningFragment */) {
+    if (node.kind === 291 /* SyntaxKind.JsxOpeningFragment */) {
         const file = getSourceFileOfNode(node);
         const entity = getJsxFactoryEntity(c, file);
         if (entity !== undefined)
@@ -1151,29 +1169,29 @@ function checkGrammarJsxElement(c, node) {
     checkGrammarTypeArguments(c, node, getTypeArgumentListOf(node));
     const seen = new Set();
     for (const attrNode of getAttributesOf(node).properties.nodes) {
-        if (attrNode.kind === 294 /* SyntaxKind.JsxSpreadAttribute */)
+        if (attrNode.kind === 295 /* SyntaxKind.JsxSpreadAttribute */)
             continue;
         const attr = attrNode;
         const textOfName = jsxNameText(attr.name);
         if (seen.has(textOfName))
-            return grammarErrorOnNode(c, attr.name, 1805 /* Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name */);
+            return grammarErrorOnNode(c, attr.name, 1825 /* Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name */);
         seen.add(textOfName);
         const initializer = attr.initializer;
         if (initializer !== undefined &&
-            initializer.kind === 295 /* SyntaxKind.JsxExpression */ &&
+            initializer.kind === 296 /* SyntaxKind.JsxExpression */ &&
             initializer.expression === undefined)
-            return grammarErrorOnNode(c, initializer, 1804 /* Diagnostics.JSX_attributes_must_only_be_assigned_a_non_empty_expression */);
+            return grammarErrorOnNode(c, initializer, 1824 /* Diagnostics.JSX_attributes_must_only_be_assigned_a_non_empty_expression */);
     }
     return false;
 }
 function checkGrammarJsxName(c, node) {
-    if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */ &&
-        node.expression.kind === 296 /* SyntaxKind.JsxNamespacedName */)
-        return grammarErrorOnNode(c, node.expression, 776 /* Diagnostics.JSX_property_access_expressions_cannot_include_JSX_namespace_names */);
-    if (node.kind === 296 /* SyntaxKind.JsxNamespacedName */ &&
+    if (node.kind === 213 /* SyntaxKind.PropertyAccessExpression */ &&
+        node.expression.kind === 297 /* SyntaxKind.JsxNamespacedName */)
+        return grammarErrorOnNode(c, node.expression, 783 /* Diagnostics.JSX_property_access_expressions_cannot_include_JSX_namespace_names */);
+    if (node.kind === 297 /* SyntaxKind.JsxNamespacedName */ &&
         isJsxTransformEnabled(c) &&
         !isIntrinsicJsxName(node.namespace.text))
-        return grammarErrorOnNode(c, node, 782 /* Diagnostics.React_components_cannot_include_JSX_namespace_names */);
+        return grammarErrorOnNode(c, node, 789 /* Diagnostics.React_components_cannot_include_JSX_namespace_names */);
     return false;
 }
 function checkGrammarTypeArguments(c, node, typeArguments) {
@@ -1192,23 +1210,23 @@ function checkGrammarTypeArguments(c, node, typeArguments) {
 function checkGrammarJsxExpression(c, node) {
     const expression = node.expression;
     if (expression !== undefined &&
-        expression.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+        expression.kind === 228 /* SyntaxKind.BinaryExpression */ &&
         expression.operatorToken.kind === 27 /* SyntaxKind.CommaToken */)
-        return grammarErrorOnNode(c, expression, 1830 /* Diagnostics.JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array */);
+        return grammarErrorOnNode(c, expression, 1850 /* Diagnostics.JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array */);
     return false;
 }
 // ---- Contextual types
 export function getContextualTypeForJsxExpression(c, node, contextFlags) {
     const parent = node.parent;
-    if (parent.kind === 292 /* SyntaxKind.JsxAttribute */ || parent.kind === 294 /* SyntaxKind.JsxSpreadAttribute */)
+    if (parent.kind === 293 /* SyntaxKind.JsxAttribute */ || parent.kind === 295 /* SyntaxKind.JsxSpreadAttribute */)
         return getContextualTypeEx(c, node, contextFlags);
-    if (parent.kind === 285 /* SyntaxKind.JsxElement */)
+    if (parent.kind === 286 /* SyntaxKind.JsxElement */)
         return getContextualTypeForChildJsxExpression(c, parent, node, contextFlags);
     return undefined;
 }
 export function getContextualTypeForJsxAttribute(c, attribute, contextFlags) {
     // While a function component's signature is tried, its attributes carry the parameter type.
-    if (attribute.kind === 292 /* SyntaxKind.JsxAttribute */) {
+    if (attribute.kind === 293 /* SyntaxKind.JsxAttribute */) {
         const attributesType = getApparentTypeOfContextualTypeEx(c, attribute.parent, contextFlags);
         if (attributesType === undefined || (attributesType.flags & 1 /* TypeFlags.Any */) !== 0)
             return undefined;
@@ -1217,7 +1235,7 @@ export function getContextualTypeForJsxAttribute(c, attribute, contextFlags) {
     return getContextualTypeEx(c, attribute.parent, contextFlags);
 }
 export function getContextualJsxElementAttributesType(c, node, contextFlags) {
-    if (node.kind === 287 /* SyntaxKind.JsxOpeningElement */) {
+    if (node.kind === 288 /* SyntaxKind.JsxOpeningElement */) {
         // Contextual types of an element's attributes are pushed onto the element, which spans the children.
         // Cached contextual types were obtained without flags.
         const index = findContextualNode(c, node.parent, contextFlags === 0 /* ContextFlags.None */);
@@ -1252,7 +1270,7 @@ export function isJsxAttributesContextSensitive(c, node) {
     for (const p of node.properties.nodes)
         if (isContextSensitive(c, p))
             return true;
-    if (node.parent.kind === 287 /* SyntaxKind.JsxOpeningElement */)
+    if (node.parent.kind === 288 /* SyntaxKind.JsxOpeningElement */)
         for (const child of node.parent.parent.children.nodes)
             if (isContextSensitive(c, child))
                 return true;
@@ -1276,7 +1294,7 @@ class JsxElaborationElement {
 }
 function getElaborationElementForJsxChild(child, nameType) {
     switch (child.kind) {
-        case 295 /* SyntaxKind.JsxExpression */:
+        case 296 /* SyntaxKind.JsxExpression */:
             return new JsxElaborationElement(child, child.expression, nameType, false);
         case 11 /* SyntaxKind.JsxText */:
             // Whitespace-only text isn't a child.
@@ -1290,7 +1308,7 @@ function getElaborationElementForJsxChild(child, nameType) {
 export function elaborateJsxComponents(c, node, source, target, relation, diagnosticOutput) {
     let reportedError = false;
     for (const prop of node.properties.nodes) {
-        if (prop.kind === 294 /* SyntaxKind.JsxSpreadAttribute */)
+        if (prop.kind === 295 /* SyntaxKind.JsxSpreadAttribute */)
             continue;
         const attr = prop;
         const name = jsxNameText(attr.name);
@@ -1301,7 +1319,7 @@ export function elaborateJsxComponents(c, node, source, target, relation, diagno
             elaborateElement(c, source, target, relation, attr.name, attr.initializer, nameType, undefined, undefined, [], diagnosticOutput) || reportedError;
     }
     const opening = node.parent;
-    if (opening.kind !== 287 /* SyntaxKind.JsxOpeningElement */ || opening.parent.kind !== 285 /* SyntaxKind.JsxElement */)
+    if (opening.kind !== 288 /* SyntaxKind.JsxOpeningElement */ || opening.parent.kind !== 286 /* SyntaxKind.JsxElement */)
         return reportedError;
     const containingElement = opening.parent;
     let childrenPropName = getJsxElementChildrenPropertyName(c, getJsxNamespaceAt(c, node));
@@ -1325,9 +1343,9 @@ export function elaborateJsxComponents(c, node, source, target, relation, diagno
         arrayLikeTargetParts = filterType(c, childrenTargetType, (t) => isArrayOrTupleLikeType(c, t));
         nonArrayLikeTargetParts = filterType(c, childrenTargetType, (t) => !isArrayOrTupleLikeType(c, t));
     }
-    const textMessage = 879 /* Diagnostics.X_0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_type_of_1_is_2 */;
+    const textMessage = 886 /* Diagnostics.X_0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_type_of_1_is_2 */;
     const textArgs = [
-        getTextOfNode(opening.kind === 287 /* SyntaxKind.JsxOpeningElement */ ? getTagNameOf(opening) : opening),
+        getTextOfNode(opening.kind === 288 /* SyntaxKind.JsxOpeningElement */ ? getTagNameOf(opening) : opening),
         childrenPropName,
         typeToString(c, childrenTargetType),
     ];
@@ -1349,7 +1367,7 @@ export function elaborateJsxComponents(c, node, source, target, relation, diagno
         }
         else if (!isTypeRelatedTo(c, getIndexedAccessType(c, source, childrenNameType), childrenTargetType, relation)) {
             // Arity errors are reported both directly and through the output.
-            const diagnostic = c.error(containingElement.openingElement.tagName, 878 /* Diagnostics.This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided */, childrenPropName, typeToString(c, childrenTargetType));
+            const diagnostic = c.error(containingElement.openingElement.tagName, 885 /* Diagnostics.This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided */, childrenPropName, typeToString(c, childrenTargetType));
             reportDiagnostic(c, diagnostic, diagnosticOutput);
             reportedError = true;
         }
@@ -1361,7 +1379,7 @@ export function elaborateJsxComponents(c, node, source, target, relation, diagno
                 elaborateElement(c, source, target, relation, e.errorNode, e.innerExpression, e.nameType, undefined, e.isText ? textMessage : undefined, textArgs, diagnosticOutput) || reportedError;
     }
     else if (!isTypeRelatedTo(c, getIndexedAccessType(c, source, childrenNameType), childrenTargetType, relation)) {
-        const diagnostic = c.error(containingElement.openingElement.tagName, 877 /* Diagnostics.This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_provided */, childrenPropName, typeToString(c, childrenTargetType));
+        const diagnostic = c.error(containingElement.openingElement.tagName, 884 /* Diagnostics.This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_provided */, childrenPropName, typeToString(c, childrenTargetType));
         reportDiagnostic(c, diagnostic, diagnosticOutput);
         reportedError = true;
     }
@@ -1405,7 +1423,7 @@ function elaborateIterableOrArrayLikeTargetElementwise(c, elements, source, targ
             continue;
         }
         if (c.exactOptionalPropertyTypes && isExactOptionalPropertyMismatch(c, specificSource, targetPropType)) {
-            reportDiagnostic(c, createDiagnosticForNode(e.errorNode, 583 /* Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target */, [typeToString(c, specificSource), typeToString(c, targetPropType)]), diagnosticOutput);
+            reportDiagnostic(c, createDiagnosticForNode(e.errorNode, 590 /* Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target */, [typeToString(c, specificSource), typeToString(c, targetPropType)]), diagnosticOutput);
             continue;
         }
         const propName = getPropertyNameFromIndex(e.nameType);