From 50ebc2bf8a785cd3f1d436282118e5ee0b6bb81b Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 26 May 2015 16:38:17 -0700 Subject: [PATCH] Addressing CR feedback --- src/compiler/checker.ts | 6 ++++-- src/compiler/parser.ts | 26 +++++++++++++++++++------- src/compiler/types.ts | 12 +++--------- 3 files changed, 26 insertions(+), 18 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 538afdf1ea3..4d1f57c33b6 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -340,8 +340,10 @@ module ts { if (result = getSymbol(location.locals, name, meaning)) { // Type parameters of a function are in scope in the entire function declaration, including the parameter // list and return type. However, local types are only in scope in the function body. - if (!(meaning & SymbolFlags.Type) || !(result.flags & (SymbolFlags.Type & ~SymbolFlags.TypeParameter)) || - !isFunctionLike(location) || lastLocation === (location).body) { + if (!(meaning & SymbolFlags.Type) || + !(result.flags & (SymbolFlags.Type & ~SymbolFlags.TypeParameter)) || + !isFunctionLike(location) || + lastLocation === (location).body) { break loop; } result = undefined; diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index f2b951b7d90..2a724bc7e9b 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -436,6 +436,13 @@ module ts { // attached to the EOF token. let parseErrorBeforeNextFinishedNode: boolean = false; + export const enum StatementFlags { + None = 0, + Statement = 1, + ModuleElement = 2, + StatementOrModuleElement = Statement | ModuleElement + } + export function parseSourceFile(fileName: string, _sourceText: string, languageVersion: ScriptTarget, _syntaxCursor: IncrementalParser.SyntaxCursor, setParentNodes?: boolean): SourceFile { sourceText = _sourceText; syntaxCursor = _syntaxCursor; @@ -1001,9 +1008,11 @@ module ts { switch (parsingContext) { case ParsingContext.SourceElements: case ParsingContext.ModuleElements: + // During error recovery we don't treat empty statements as statements return !(token === SyntaxKind.SemicolonToken && inErrorRecovery) && isModuleElement(); case ParsingContext.BlockStatements: case ParsingContext.SwitchClauseStatements: + // During error recovery we don't treat empty statements as statements return !(token === SyntaxKind.SemicolonToken && inErrorRecovery) && isStatement(); case ParsingContext.SwitchClauses: return token === SyntaxKind.CaseKeyword || token === SyntaxKind.DefaultKeyword; @@ -3374,7 +3383,7 @@ module ts { function parseBlock(ignoreMissingOpenBrace: boolean, checkForStrictMode: boolean, diagnosticMessage?: DiagnosticMessage): Block { let node = createNode(SyntaxKind.Block); if (parseExpected(SyntaxKind.OpenBraceToken, diagnosticMessage) || ignoreMissingOpenBrace) { - node.statements = >parseList(ParsingContext.BlockStatements, checkForStrictMode, parseStatement); + node.statements = parseList(ParsingContext.BlockStatements, checkForStrictMode, parseStatement); parseExpected(SyntaxKind.CloseBraceToken); } else { @@ -3662,16 +3671,16 @@ module ts { case SyntaxKind.InterfaceKeyword: case SyntaxKind.TypeKeyword: nextToken(); - return isIdentifierOrKeyword() ? StatementFlags.Statement : 0; + return isIdentifierOrKeyword() ? StatementFlags.Statement : StatementFlags.None; case SyntaxKind.ModuleKeyword: case SyntaxKind.NamespaceKeyword: nextToken(); - return isIdentifierOrKeyword() || token === SyntaxKind.StringLiteral ? StatementFlags.ModuleElement : 0; + return isIdentifierOrKeyword() || token === SyntaxKind.StringLiteral ? StatementFlags.ModuleElement : StatementFlags.None; case SyntaxKind.ImportKeyword: nextToken(); return token === SyntaxKind.StringLiteral || token === SyntaxKind.AsteriskToken || token === SyntaxKind.OpenBraceToken || isIdentifierOrKeyword() ? - StatementFlags.ModuleElement : 0; + StatementFlags.ModuleElement : StatementFlags.None; case SyntaxKind.ExportKeyword: nextToken(); if (token === SyntaxKind.EqualsToken || token === SyntaxKind.AsteriskToken || @@ -3687,7 +3696,7 @@ module ts { nextToken(); continue; default: - return 0; + return StatementFlags.None; } } } @@ -3734,17 +3743,20 @@ module ts { case SyntaxKind.ModuleKeyword: case SyntaxKind.NamespaceKeyword: case SyntaxKind.TypeKeyword: + // When these don't start a declaration, they're an identifier in an expression statement return getDeclarationFlags() || StatementFlags.Statement; case SyntaxKind.PublicKeyword: case SyntaxKind.PrivateKeyword: case SyntaxKind.ProtectedKeyword: case SyntaxKind.StaticKeyword: + // When these don't start a declaration, they may be the start of a class member if an identifier + // immediately follows. Otherwise they're an identifier in an expression statement. return getDeclarationFlags() || - (!lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine) ? StatementFlags.Statement : 0); + (lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine) ? StatementFlags.None : StatementFlags.Statement); default: - return isStartOfExpression() ? StatementFlags.Statement : 0; + return isStartOfExpression() ? StatementFlags.Statement : StatementFlags.None; } } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 9f83e84e34b..742daa2664c 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -300,12 +300,6 @@ module ts { FirstNode = QualifiedName, } - export const enum StatementFlags { - Statement = 1, - ModuleElement = 2, - StatementOrModuleElement = Statement | ModuleElement - } - export const enum NodeFlags { Export = 0x00000001, // Declarations Ambient = 0x00000002, // Declarations @@ -890,7 +884,7 @@ module ts { _classElementBrand: any; } - export interface InterfaceDeclaration extends Declaration, ModuleElement { + export interface InterfaceDeclaration extends Declaration, Statement { name: Identifier; typeParameters?: NodeArray; heritageClauses?: NodeArray; @@ -902,7 +896,7 @@ module ts { types?: NodeArray; } - export interface TypeAliasDeclaration extends Declaration, ModuleElement { + export interface TypeAliasDeclaration extends Declaration, Statement { name: Identifier; type: TypeNode; } @@ -914,7 +908,7 @@ module ts { initializer?: Expression; } - export interface EnumDeclaration extends Declaration, ModuleElement { + export interface EnumDeclaration extends Declaration, Statement { name: Identifier; members: NodeArray; }