Parser error type identifier #4878
There are no files selected for viewing
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -13,6 +13,11 @@ namespace ts { | |
| return new (getNodeConstructor(kind))(pos, end); | ||
| } | ||
|
|
||
| interface ContextualError { | ||
| callback?: (node: Node) => void; | ||
| count: number; | ||
| } | ||
|
|
||
| function visitNode<T>(cbNode: (node: Node) => T, node: Node): T { | ||
| if (node) { | ||
| return cbNode(node); | ||
|
|
@@ -526,6 +531,9 @@ namespace ts { | |
| // attached to the EOF token. | ||
| let parseErrorBeforeNextFinishedNode = false; | ||
|
|
||
| // For more detailed errors, a contextual error node & callback may be used | ||
| let contextualError: ContextualError = { count: 0 }; | ||
|
|
||
| export function parseSourceFile(fileName: string, _sourceText: string, languageVersion: ScriptTarget, _syntaxCursor: IncrementalParser.SyntaxCursor, setParentNodes?: boolean): SourceFile { | ||
| initializeState(fileName, _sourceText, languageVersion, _syntaxCursor); | ||
|
|
||
|
|
@@ -548,6 +556,7 @@ namespace ts { | |
|
|
||
| contextFlags = isJavaScript(fileName) ? ParserContextFlags.JavaScriptFile : ParserContextFlags.None; | ||
| parseErrorBeforeNextFinishedNode = false; | ||
| contextualError = { count: 0 }; | ||
|
|
||
| // Initialize and prime the scanner before parsing the source elements. | ||
| scanner.setText(sourceText); | ||
|
|
@@ -804,7 +813,10 @@ namespace ts { | |
| function parseErrorAtPosition(start: number, length: number, message: DiagnosticMessage, arg0?: any): void { | ||
| // Don't report another error if it would just be at the same position as the last error. | ||
| let lastError = lastOrUndefined(parseDiagnostics); | ||
| if (contextualError.callback) { | ||
| contextualError.count++; | ||
| } | ||
| else if (!lastError || start !== lastError.start) { | ||
| parseDiagnostics.push(createFileDiagnostic(sourceFile, start, length, message, arg0)); | ||
| } | ||
|
|
||
|
|
@@ -866,6 +878,7 @@ namespace ts { | |
| // descent nature of our parser. However, we still store this here just so we can | ||
| // assert that that invariant holds. | ||
| let saveContextFlags = contextFlags; | ||
| let saveContextErrorCount = contextualError.count; | ||
|
|
||
| // If we're only looking ahead, then tell the scanner to only lookahead as well. | ||
| // Otherwise, if we're actually speculatively parsing, then tell the scanner to do the | ||
|
|
@@ -882,6 +895,7 @@ namespace ts { | |
| token = saveToken; | ||
| parseDiagnostics.length = saveParseDiagnosticsLength; | ||
| parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode; | ||
| contextualError.count = saveContextErrorCount; | ||
| } | ||
|
|
||
| return result; | ||
|
|
@@ -923,6 +937,57 @@ namespace ts { | |
| return token > SyntaxKind.LastReservedWord; | ||
| } | ||
|
|
||
| // ERRORS | ||
| function invalidTypeReferenceOrTypePredicate(node: TypeReferenceNode | TypePredicateNode): void { | ||
| if (node.kind === SyntaxKind.TypePredicate) { | ||
| if ((<TypePredicateNode>node).type.parserContextFlags & ParserContextFlags.ThisNodeHasError) { | ||
| parseErrorAtPosition((<TypePredicateNode>node).type.pos, 0, Diagnostics.Type_expected); | ||
| } | ||
| return; | ||
| } | ||
| let typeName = (<TypeReferenceNode>node).typeName; | ||
| if (typeName.flags & NodeFlags.Missing) { | ||
| onInvalidTypeReference(typeName); | ||
| } | ||
| if ((<QualifiedName>typeName).right && ((<QualifiedName>typeName).right.flags & NodeFlags.Missing)) { | ||
| onInvalidTypeQualifiedName(); | ||
| } | ||
| } | ||
|
|
||
| function onInvalidTypeReference(node: Identifier | QualifiedName): void { | ||
| let needsParentheses = true; | ||
| if (isStartOfFunctionType()) { | ||
| parseFunctionOrConstructorType(SyntaxKind.FunctionType); | ||
| } | ||
| else if (token === SyntaxKind.NewKeyword) { | ||
| parseFunctionOrConstructorType(SyntaxKind.ConstructorType); | ||
| } | ||
| else { | ||
| needsParentheses = false; | ||
| } | ||
| if (needsParentheses) { | ||
| let hint = "(" + sourceFile.text.substring(node.pos, scanner.getStartPos()).trim() + ")"; | ||
| parseErrorAtPosition(node.pos, scanner.getStartPos() - node.pos, Diagnostics.Invalid_type_To_avoid_ambiguity_add_parentheses_Colon_0, hint); | ||
| } | ||
| else { | ||
| parseErrorAtCurrentToken(Diagnostics.Type_expected); | ||
| } | ||
| } | ||
|
|
||
| function onInvalidTypeQualifiedName(): void { | ||
| if (scanner.isReservedWord()) { | ||
| parseErrorAtCurrentToken(Diagnostics.Identifier_expected_reserved_word_0_not_allowed_here, tokenToString(token)); | ||
| } | ||
| else { | ||
| if (scanner.hasPrecedingLineBreak()) { | ||
| parseErrorAtPosition(scanner.getStartPos(), 0, Diagnostics.Identifier_expected); | ||
| } | ||
| else { | ||
| parseErrorAtCurrentToken(Diagnostics.Identifier_expected); | ||
| } | ||
| } | ||
| } | ||
|
|
||
| function parseExpected(kind: SyntaxKind, diagnosticMessage?: DiagnosticMessage, shouldAdvance = true): boolean { | ||
| if (token === kind) { | ||
| if (shouldAdvance) { | ||
|
|
@@ -1013,7 +1078,20 @@ namespace ts { | |
| parseErrorBeforeNextFinishedNode = false; | ||
| node.parserContextFlags |= ParserContextFlags.ThisNodeHasError; | ||
| } | ||
| return node; | ||
| } | ||
|
|
||
| function finishNodeContextualError<T extends Node>(node: T, end?: number): T { | ||
| finishNode(node, end); | ||
|
|
||
| let errorCallback = contextualError.count ? contextualError.callback : undefined; | ||
| contextualError.callback = undefined; | ||
|
|
||
| // If contextual error, use callback for more detailed error(s) | ||
| if (errorCallback) { | ||
| errorCallback(node); | ||
| contextualError.count = 0; | ||
| } | ||
| return node; | ||
| } | ||
|
|
||
|
|
@@ -1026,6 +1104,7 @@ namespace ts { | |
| } | ||
|
|
||
| let result = createNode(kind, scanner.getStartPos()); | ||
| result.flags |= NodeFlags.Missing; | ||
| (<Identifier>result).text = ""; | ||
| return finishNode(result); | ||
| } | ||
|
|
@@ -1814,7 +1893,7 @@ namespace ts { | |
| return entity; | ||
| } | ||
|
|
||
| function parseRightSideOfDot(allowReservedWords: boolean): Identifier { | ||
| // Technically a keyword is valid here as all identifiers and keywords are identifier names. | ||
| // However, often we'll encounter this in error situations when the identifier or keyword | ||
| // is actually starting another valid construct. | ||
|
|
@@ -1844,8 +1923,7 @@ namespace ts { | |
| return <Identifier>createMissingNode(SyntaxKind.Identifier, /*reportAtCurrentToken*/ true, Diagnostics.Identifier_expected); | ||
| } | ||
| } | ||
| return allowReservedWords ? parseIdentifierName() : parseIdentifier(); | ||
| } | ||
|
|
||
| function parseTemplateExpression(): TemplateExpression { | ||
|
|
@@ -1922,20 +2000,25 @@ namespace ts { | |
| // TYPES | ||
|
|
||
| function parseTypeReferenceOrTypePredicate(): TypeReferenceNode | TypePredicateNode { | ||
| contextualError.callback = invalidTypeReferenceOrTypePredicate; | ||
|
|
||
| let typeName = parseEntityName(/*allowReservedWords*/ false); | ||
| if (typeName.kind === SyntaxKind.Identifier && token === SyntaxKind.IsKeyword && !scanner.hasPrecedingLineBreak()) { | ||
| nextToken(); | ||
| let predicateNode = <TypePredicateNode>createNode(SyntaxKind.TypePredicate, typeName.pos); | ||
| predicateNode.parameterName = <Identifier>typeName; | ||
| predicateNode.type = parseType(); | ||
| return finishNodeContextualError(predicateNode); | ||
| } | ||
|
|
||
| let node = <TypeReferenceNode>createNode(SyntaxKind.TypeReference, typeName.pos); | ||
| node.typeName = typeName; | ||
| if ((typeName.flags & NodeFlags.Missing) === 0) { | ||
|
There was a problem hiding this comment. As @CyrusNajmabadi mentioned, we already had a way of checking if something was missing, so we shouldn't introduce another. |
||
| if (token === SyntaxKind.LessThanToken && !scanner.hasPrecedingLineBreak()) { | ||
| node.typeArguments = parseBracketedList(ParsingContext.TypeArguments, parseType, SyntaxKind.LessThanToken, SyntaxKind.GreaterThanToken); | ||
| } | ||
| } | ||
| return finishNodeContextualError(node); | ||
| } | ||
|
|
||
| function parseTypeQuery(): TypeQueryNode { | ||
|
|
||
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,66 @@ | ||
| tests/cases/compiler/errorParserTypeIdentifier.ts(3,26): error TS17008: Invalid type. To avoid ambiguity, add parentheses: '(new() => void)' | ||
| tests/cases/compiler/errorParserTypeIdentifier.ts(5,16): error TS17008: Invalid type. To avoid ambiguity, add parentheses: '(new () => void)' | ||
| tests/cases/compiler/errorParserTypeIdentifier.ts(7,16): error TS17008: Invalid type. To avoid ambiguity, add parentheses: '(new () => void)' | ||
| tests/cases/compiler/errorParserTypeIdentifier.ts(8,16): error TS17008: Invalid type. To avoid ambiguity, add parentheses: '(new () => void | number)' | ||
| tests/cases/compiler/errorParserTypeIdentifier.ts(9,16): error TS17008: Invalid type. To avoid ambiguity, add parentheses: '(<T>(...) => void | void)' | ||
| tests/cases/compiler/errorParserTypeIdentifier.ts(9,24): error TS1003: Identifier expected. | ||
| tests/cases/compiler/errorParserTypeIdentifier.ts(12,8): error TS2503: Cannot find namespace 'TypeModule1'. | ||
| tests/cases/compiler/errorParserTypeIdentifier.ts(12,20): error TS1003: Identifier expected. | ||
| tests/cases/compiler/errorParserTypeIdentifier.ts(17,8): error TS2503: Cannot find namespace 'x'. | ||
| tests/cases/compiler/errorParserTypeIdentifier.ts(17,10): error TS17009: Identifier expected, reserved word 'void' not allowed here. | ||
| tests/cases/compiler/errorParserTypeIdentifier.ts(17,14): error TS1109: Expression expected. | ||
| tests/cases/compiler/errorParserTypeIdentifier.ts(18,13): error TS1110: Type expected. | ||
| tests/cases/compiler/errorParserTypeIdentifier.ts(20,1): error TS2304: Cannot find name 'Foo'. | ||
| tests/cases/compiler/errorParserTypeIdentifier.ts(20,8): error TS1110: Type expected. | ||
|
|
||
|
|
||
| ==== tests/cases/compiler/errorParserTypeIdentifier.ts (14 errors) ==== | ||
|
|
||
| // Union or intersection ambiguity | ||
| function test(x: string | new() => void) { } | ||
| ~~~~~~~~~~~~~~ | ||
| !!! error TS17008: Invalid type. To avoid ambiguity, add parentheses: '(new() => void)' | ||
|
|
||
| let a: string | new () => void; | ||
| ~~~~~~~~~~~~~~~ | ||
| !!! error TS17008: Invalid type. To avoid ambiguity, add parentheses: '(new () => void)' | ||
| let b: string | (new () => void); | ||
| let c: string | new () => void /* not part of error */ | ||
| ~~~~~~~~~~~~~~~ | ||
| !!! error TS17008: Invalid type. To avoid ambiguity, add parentheses: '(new () => void)' | ||
| let d: string | new () => void | number; | ||
| ~~~~~~~~~~~~~~~~~~~~~~~~ | ||
| !!! error TS17008: Invalid type. To avoid ambiguity, add parentheses: '(new () => void | number)' | ||
| let e: string | <T>(...) => void | void; | ||
| ~~~~~~~~~~~~~~~~~~~~~~~~ | ||
| !!! error TS17008: Invalid type. To avoid ambiguity, add parentheses: '(<T>(...) => void | void)' | ||
| ~ | ||
| !!! error TS1003: Identifier expected. | ||
|
|
||
| // Missing identifier or keyword | ||
| let f: TypeModule1. | ||
| ~~~~~~~~~~~ | ||
| !!! error TS2503: Cannot find namespace 'TypeModule1'. | ||
|
|
||
| !!! error TS1003: Identifier expected. | ||
|
|
||
| module TypeModule2 { | ||
| } | ||
|
|
||
| let g: x.void; | ||
| ~ | ||
| !!! error TS2503: Cannot find namespace 'x'. | ||
| ~~~~ | ||
| !!! error TS17009: Identifier expected, reserved word 'void' not allowed here. | ||
| ~ | ||
| !!! error TS1109: Expression expected. | ||
| let h = (a: ) => { | ||
| ~ | ||
| !!! error TS1110: Type expected. | ||
| } | ||
| Foo<a, , b>(); | ||
| ~~~ | ||
| !!! error TS2304: Cannot find name 'Foo'. | ||
| ~ | ||
| !!! error TS1110: Type expected. | ||
|
|
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,37 @@ | ||
| //// [errorParserTypeIdentifier.ts] | ||
|
|
||
| // Union or intersection ambiguity | ||
| function test(x: string | new() => void) { } | ||
|
|
||
| let a: string | new () => void; | ||
| let b: string | (new () => void); | ||
| let c: string | new () => void /* not part of error */ | ||
| let d: string | new () => void | number; | ||
| let e: string | <T>(...) => void | void; | ||
|
|
||
| // Missing identifier or keyword | ||
| let f: TypeModule1. | ||
|
|
||
| module TypeModule2 { | ||
| } | ||
|
|
||
| let g: x.void; | ||
| let h = (a: ) => { | ||
| } | ||
| Foo<a, , b>(); | ||
|
|
||
|
|
||
| //// [errorParserTypeIdentifier.js] | ||
| // Union or intersection ambiguity | ||
| function test(x) { } | ||
| var a; | ||
| var b; | ||
| var c; /* not part of error */ | ||
| var d; | ||
| var e; | ||
| // Missing identifier or keyword | ||
| var f; | ||
| var g = void ; | ||
| var h = function (a) { | ||
| }; | ||
| Foo(); |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,13 +1,13 @@ | ||
| tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens20.ts(1,8): error TS2304: Cannot find name 'X'. | ||
| tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens20.ts(1,12): error TS1005: ',' expected. | ||
| tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens20.ts(1,13): error TS1005: '>' expected. | ||
|
|
||
|
|
||
| ==== tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens20.ts (3 errors) ==== | ||
| var v: X<T \ | ||
| ~ | ||
| !!! error TS2304: Cannot find name 'X'. | ||
| ~ | ||
| !!! error TS1005: ',' expected. | ||
|
|
||
| !!! error TS1005: '>' expected. |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
This is an after-the-fact grammar check. Can you explain why you couldn't just make this part of a grammar check in
checker.ts?There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
+1