@@ -120,7 +120,6 @@ import {
120120 ImportClause,
121121 ImportDeclaration,
122122 ImportEqualsDeclaration,
123- ImportOrExportSpecifier,
124123 ImportSpecifier,
125124 ImportTypeAssertionContainer,
126125 ImportTypeNode,
@@ -253,6 +252,7 @@ import {
253252 modifiersToFlags,
254253 ModuleBlock,
255254 ModuleDeclaration,
255+ ModuleExportName,
256256 ModuleKind,
257257 Mutable,
258258 NamedExportBindings,
@@ -2869,7 +2869,13 @@ namespace Parser {
28692869 case ParsingContext.HeritageClauses:
28702870 return isHeritageClause();
28712871 case ParsingContext.ImportOrExportSpecifiers:
2872- return tokenIsIdentifierOrKeyword(token());
2872+ // bail out if the next token is Identifier(from) StringLiteral.
2873+ // That means we're in something like `import { from "mod"`
2874+ // In this case we don't want parse it as import { from <missing SyntaxKind.AsKeyword> "mod", ...
2875+ if (token() === SyntaxKind.FromKeyword && lookAhead(nextTokenIsStringLiteral)) {
2876+ return false;
2877+ }
2878+ return token() === SyntaxKind.StringLiteral || tokenIsIdentifierOrKeyword(token());
28732879 case ParsingContext.JsxAttributes:
28742880 return tokenIsIdentifierOrKeyword(token()) || token() === SyntaxKind.OpenBraceToken;
28752881 case ParsingContext.JsxChildren:
@@ -3390,7 +3396,11 @@ namespace Parser {
33903396 case ParsingContext.TypeArguments: return parseErrorAtCurrentToken(Diagnostics.Type_argument_expected);
33913397 case ParsingContext.TupleElementTypes: return parseErrorAtCurrentToken(Diagnostics.Type_expected);
33923398 case ParsingContext.HeritageClauses: return parseErrorAtCurrentToken(Diagnostics.Unexpected_token_expected);
3393- case ParsingContext.ImportOrExportSpecifiers: return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
3399+ case ParsingContext.ImportOrExportSpecifiers:
3400+ if (token() === SyntaxKind.FromKeyword) {
3401+ return parseErrorAtCurrentToken(Diagnostics._0_expected, "}");
3402+ }
3403+ return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
33943404 case ParsingContext.JsxAttributes: return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
33953405 case ParsingContext.JsxChildren: return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
33963406 case ParsingContext.AssertEntries: return parseErrorAtCurrentToken(Diagnostics.Identifier_or_string_literal_expected); // AssertionKey.
@@ -7358,6 +7368,9 @@ namespace Parser {
73587368 }
73597369 }
73607370
7371+ function nextTokenIsStringLiteral() {
7372+ return nextToken() === SyntaxKind.StringLiteral;
7373+ }
73617374 function nextTokenIsIdentifierOrStringLiteralOnSameLine() {
73627375 nextToken();
73637376 return !scanner.hasPrecedingLineBreak() && (isIdentifier() || token() === SyntaxKind.StringLiteral);
@@ -8345,29 +8358,34 @@ namespace Parser {
83458358 return parseImportOrExportSpecifier(SyntaxKind.ImportSpecifier) as ImportSpecifier;
83468359 }
83478360
8348- function parseImportOrExportSpecifier(kind: SyntaxKind): ImportOrExportSpecifier {
8361+ function parseImportOrExportSpecifier(kind: SyntaxKind) {
83498362 const pos = getNodePos();
8363+ // ModuleExportName:
8364+ // Identifier
8365+ // StringLiteral
83508366 // ImportSpecifier:
83518367 // BindingIdentifier
8352- // IdentifierName as BindingIdentifier
8368+ // ModuleExportName as BindingIdentifier
83538369 // ExportSpecifier:
8354- // IdentifierName
8355- // IdentifierName as IdentifierName
8370+ // ModuleExportName
8371+ // ModuleExportName as ModuleExportName
83568372 let checkIdentifierIsKeyword = isKeyword(token()) && !isIdentifier();
83578373 let checkIdentifierStart = scanner.getTokenStart();
83588374 let checkIdentifierEnd = scanner.getTokenEnd();
83598375 let isTypeOnly = false;
8360- let propertyName: Identifier | undefined;
8376+ let propertyName: ModuleExportName | undefined;
83618377 let canParseAsKeyword = true;
8362- let name = parseIdentifierName();
8363- if (name.escapedText === "type") {
8378+ let mustParseAsKeyword = false;
8379+ let name = parseModuleExportName(parseIdentifierName);
8380+ if (name.kind === SyntaxKind.Identifier && name.escapedText === "type") {
83648381 // If the first token of an import specifier is 'type', there are a lot of possibilities,
83658382 // especially if we see 'as' afterwards:
83668383 //
83678384 // import { type } from "mod"; - isTypeOnly: false, name: type
83688385 // import { type as } from "mod"; - isTypeOnly: true, name: as
83698386 // import { type as as } from "mod"; - isTypeOnly: false, name: as, propertyName: type
83708387 // import { type as as as } from "mod"; - isTypeOnly: true, name: as, propertyName: as
8388+ // export { type as as "s" } from "mod";- isTypeOnly: true, name: "s", propertyName: as
83718389 if (token() === SyntaxKind.AsKeyword) {
83728390 // { type as ...? }
83738391 const firstAs = parseIdentifierName();
@@ -8376,9 +8394,10 @@ namespace Parser {
83768394 const secondAs = parseIdentifierName();
83778395 if (tokenIsIdentifierOrKeyword(token())) {
83788396 // { type as as something }
8397+ // { type as as "something" } (only in exports)
83798398 isTypeOnly = true;
83808399 propertyName = firstAs;
8381- name = parseNameWithKeywordCheck ();
8400+ name = parseModuleExportNameOnlyForExports ();
83828401 canParseAsKeyword = false;
83838402 }
83848403 else {
@@ -8392,31 +8411,43 @@ namespace Parser {
83928411 // { type as something }
83938412 propertyName = name;
83948413 canParseAsKeyword = false;
8395- name = parseNameWithKeywordCheck ();
8414+ name = parseModuleExportNameOnlyForExports ();
83968415 }
83978416 else {
83988417 // { type as }
83998418 isTypeOnly = true;
84008419 name = firstAs;
84018420 }
84028421 }
8422+ // export { type "x" }
8423+ // import { type "x" as ... }
8424+ else if (token() === SyntaxKind.StringLiteral) {
8425+ isTypeOnly = true;
8426+ if (kind === SyntaxKind.ImportSpecifier) mustParseAsKeyword = true;
8427+ name = parseModuleExportName(parseNameWithKeywordCheck);
8428+ }
84038429 else if (tokenIsIdentifierOrKeyword(token())) {
84048430 // { type something ...? }
84058431 isTypeOnly = true;
84068432 name = parseNameWithKeywordCheck();
84078433 }
84088434 }
8435+ // import { "x" as ... }
8436+ else if (kind === SyntaxKind.ImportSpecifier && name.kind === SyntaxKind.StringLiteral) {
8437+ mustParseAsKeyword = true;
8438+ }
84098439
8410- if (canParseAsKeyword && token() === SyntaxKind.AsKeyword) {
8440+ if (mustParseAsKeyword || ( canParseAsKeyword && token() === SyntaxKind.AsKeyword) ) {
84118441 propertyName = name;
84128442 parseExpected(SyntaxKind.AsKeyword);
8413- name = parseNameWithKeywordCheck ();
8443+ name = parseModuleExportNameOnlyForExports ();
84148444 }
84158445 if (kind === SyntaxKind.ImportSpecifier && checkIdentifierIsKeyword) {
84168446 parseErrorAt(checkIdentifierStart, checkIdentifierEnd, Diagnostics.Identifier_expected);
84178447 }
8448+ if (kind === SyntaxKind.ImportSpecifier) Debug.assert(name.kind === SyntaxKind.Identifier);
84188449 const node = kind === SyntaxKind.ImportSpecifier
8419- ? factory.createImportSpecifier(isTypeOnly, propertyName, name)
8450+ ? factory.createImportSpecifier(isTypeOnly, propertyName, name as Identifier )
84208451 : factory.createExportSpecifier(isTypeOnly, propertyName, name);
84218452 return finishNode(node, pos);
84228453
@@ -8426,10 +8457,22 @@ namespace Parser {
84268457 checkIdentifierEnd = scanner.getTokenEnd();
84278458 return parseIdentifierName();
84288459 }
8460+ function parseModuleExportNameOnlyForExports() {
8461+ if (kind === SyntaxKind.ImportSpecifier) return parseNameWithKeywordCheck();
8462+ return parseModuleExportName(parseNameWithKeywordCheck);
8463+ }
8464+ function parseModuleExportName(parser: () => Identifier): ModuleExportName {
8465+ if (token() === SyntaxKind.StringLiteral) return parseStringLiteral();
8466+ return parser();
8467+ }
8468+ function parseStringLiteral(): StringLiteral {
8469+ // TODO: the spec requires it pass IsStringWellFormedUnicode
8470+ return parseLiteralLikeNode(SyntaxKind.StringLiteral) as StringLiteral;
8471+ }
84298472 }
84308473
84318474 function parseNamespaceExport(pos: number): NamespaceExport {
8432- return finishNode(factory.createNamespaceExport(parseIdentifierName()), pos);
8475+ return finishNode(factory.createNamespaceExport(token() === SyntaxKind.StringLiteral ? parseLiteralLikeNode(SyntaxKind.StringLiteral) as StringLiteral : parseIdentifierName()), pos);
84338476 }
84348477
84358478 function parseExportDeclaration(pos: number, hasJSDoc: boolean, modifiers: NodeArray<ModifierLike> | undefined): ExportDeclaration {
0 commit comments