From 556e268bd0b0f065038143c6a724a11677705e7e Mon Sep 17 00:00:00 2001 From: Charles Pierce Date: Thu, 1 Jun 2017 20:37:52 -0700 Subject: [PATCH] #15943 #15981 Update special cases for await / yield parsing --- src/compiler/parser.ts | 8 ++-- .../reference/awaitLiteralValues.errors.txt | 45 +++++++++++++++++++ .../baselines/reference/awaitLiteralValues.js | 45 +++++++++++++++++++ .../reference/yieldStringLiteral.errors.txt | 10 +++++ .../baselines/reference/yieldStringLiteral.js | 10 +++++ tests/cases/compiler/awaitLiteralValues.ts | 23 ++++++++++ tests/cases/compiler/yieldStringLiteral.ts | 3 ++ 7 files changed, 140 insertions(+), 4 deletions(-) create mode 100644 tests/baselines/reference/awaitLiteralValues.errors.txt create mode 100644 tests/baselines/reference/awaitLiteralValues.js create mode 100644 tests/baselines/reference/yieldStringLiteral.errors.txt create mode 100644 tests/baselines/reference/yieldStringLiteral.js create mode 100644 tests/cases/compiler/awaitLiteralValues.ts create mode 100644 tests/cases/compiler/yieldStringLiteral.ts diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 849f97bbba..966a6d432c 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -2960,7 +2960,7 @@ namespace ts { // for now we just check if the next token is an identifier. More heuristics // can be added here later as necessary. We just need to make sure that we // don't accidentally consume something legal. - return lookAhead(nextTokenIsIdentifierOrKeywordOrNumberOnSameLine); + return lookAhead(nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine); } return false; @@ -3478,7 +3478,7 @@ namespace ts { } // here we are using similar heuristics as 'isYieldExpression' - return lookAhead(nextTokenIsIdentifierOnSameLine); + return lookAhead(nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine); } return false; @@ -4677,9 +4677,9 @@ namespace ts { return token() === SyntaxKind.FunctionKeyword && !scanner.hasPrecedingLineBreak(); } - function nextTokenIsIdentifierOrKeywordOrNumberOnSameLine() { + function nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine() { nextToken(); - return (tokenIsIdentifierOrKeyword(token()) || token() === SyntaxKind.NumericLiteral) && !scanner.hasPrecedingLineBreak(); + return (tokenIsIdentifierOrKeyword(token()) || token() === SyntaxKind.NumericLiteral || token() === SyntaxKind.StringLiteral) && !scanner.hasPrecedingLineBreak(); } function isDeclaration(): boolean { diff --git a/tests/baselines/reference/awaitLiteralValues.errors.txt b/tests/baselines/reference/awaitLiteralValues.errors.txt new file mode 100644 index 0000000000..cf3e155c28 --- /dev/null +++ b/tests/baselines/reference/awaitLiteralValues.errors.txt @@ -0,0 +1,45 @@ +tests/cases/compiler/awaitLiteralValues.ts(2,5): error TS1308: 'await' expression is only allowed within an async function. +tests/cases/compiler/awaitLiteralValues.ts(6,5): error TS1308: 'await' expression is only allowed within an async function. +tests/cases/compiler/awaitLiteralValues.ts(10,5): error TS1308: 'await' expression is only allowed within an async function. +tests/cases/compiler/awaitLiteralValues.ts(14,5): error TS1308: 'await' expression is only allowed within an async function. +tests/cases/compiler/awaitLiteralValues.ts(18,5): error TS1308: 'await' expression is only allowed within an async function. +tests/cases/compiler/awaitLiteralValues.ts(22,5): error TS1308: 'await' expression is only allowed within an async function. + + +==== tests/cases/compiler/awaitLiteralValues.ts (6 errors) ==== + function awaitString() { + await 'literal'; + ~~~~~ +!!! error TS1308: 'await' expression is only allowed within an async function. + } + + function awaitNumber() { + await 1; + ~~~~~ +!!! error TS1308: 'await' expression is only allowed within an async function. + } + + function awaitTrue() { + await true; + ~~~~~ +!!! error TS1308: 'await' expression is only allowed within an async function. + } + + function awaitFalse() { + await false; + ~~~~~ +!!! error TS1308: 'await' expression is only allowed within an async function. + } + + function awaitNull() { + await null; + ~~~~~ +!!! error TS1308: 'await' expression is only allowed within an async function. + } + + function awaitUndefined() { + await undefined; + ~~~~~ +!!! error TS1308: 'await' expression is only allowed within an async function. + } + \ No newline at end of file diff --git a/tests/baselines/reference/awaitLiteralValues.js b/tests/baselines/reference/awaitLiteralValues.js new file mode 100644 index 0000000000..cc5a06a0c1 --- /dev/null +++ b/tests/baselines/reference/awaitLiteralValues.js @@ -0,0 +1,45 @@ +//// [awaitLiteralValues.ts] +function awaitString() { + await 'literal'; +} + +function awaitNumber() { + await 1; +} + +function awaitTrue() { + await true; +} + +function awaitFalse() { + await false; +} + +function awaitNull() { + await null; +} + +function awaitUndefined() { + await undefined; +} + + +//// [awaitLiteralValues.js] +function awaitString() { + yield 'literal'; +} +function awaitNumber() { + yield 1; +} +function awaitTrue() { + yield true; +} +function awaitFalse() { + yield false; +} +function awaitNull() { + yield null; +} +function awaitUndefined() { + yield undefined; +} diff --git a/tests/baselines/reference/yieldStringLiteral.errors.txt b/tests/baselines/reference/yieldStringLiteral.errors.txt new file mode 100644 index 0000000000..6d3cf56575 --- /dev/null +++ b/tests/baselines/reference/yieldStringLiteral.errors.txt @@ -0,0 +1,10 @@ +tests/cases/compiler/yieldStringLiteral.ts(2,5): error TS1163: A 'yield' expression is only allowed in a generator body. + + +==== tests/cases/compiler/yieldStringLiteral.ts (1 errors) ==== + function yieldString() { + yield 'literal'; + ~~~~~ +!!! error TS1163: A 'yield' expression is only allowed in a generator body. + } + \ No newline at end of file diff --git a/tests/baselines/reference/yieldStringLiteral.js b/tests/baselines/reference/yieldStringLiteral.js new file mode 100644 index 0000000000..99f5c49709 --- /dev/null +++ b/tests/baselines/reference/yieldStringLiteral.js @@ -0,0 +1,10 @@ +//// [yieldStringLiteral.ts] +function yieldString() { + yield 'literal'; +} + + +//// [yieldStringLiteral.js] +function yieldString() { + yield 'literal'; +} diff --git a/tests/cases/compiler/awaitLiteralValues.ts b/tests/cases/compiler/awaitLiteralValues.ts new file mode 100644 index 0000000000..ab7de0d156 --- /dev/null +++ b/tests/cases/compiler/awaitLiteralValues.ts @@ -0,0 +1,23 @@ +function awaitString() { + await 'literal'; +} + +function awaitNumber() { + await 1; +} + +function awaitTrue() { + await true; +} + +function awaitFalse() { + await false; +} + +function awaitNull() { + await null; +} + +function awaitUndefined() { + await undefined; +} diff --git a/tests/cases/compiler/yieldStringLiteral.ts b/tests/cases/compiler/yieldStringLiteral.ts new file mode 100644 index 0000000000..3faa03345a --- /dev/null +++ b/tests/cases/compiler/yieldStringLiteral.ts @@ -0,0 +1,3 @@ +function yieldString() { + yield 'literal'; +}