Merge pull request #6773 from Microsoft/nodeFlagsCleanup
Merge ParserContextFlags into NodeFlags
This commit is contained in:
Anders Hejlsberg
commit
8ad6e74e97
9 changed files with 100 additions and 137 deletions
|
|
@ -1110,7 +1110,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
function checkStrictModeNumericLiteral(node: LiteralExpression) {
|
||||
if (inStrictMode && node.flags & NodeFlags.OctalLiteral) {
|
||||
if (inStrictMode && node.isOctalLiteral) {
|
||||
file.bindDiagnostics.push(createDiagnosticForNode(node, Diagnostics.Octal_literals_are_not_allowed_in_strict_mode));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2641,7 +2641,7 @@ namespace ts {
|
|||
|
||||
// Return the inferred type for a variable, parameter, or property declaration
|
||||
function getTypeForVariableLikeDeclaration(declaration: VariableLikeDeclaration): Type {
|
||||
if (declaration.parserContextFlags & ParserContextFlags.JavaScriptFile) {
|
||||
if (declaration.flags & NodeFlags.JavaScriptFile) {
|
||||
// If this is a variable in a JavaScript file, then use the JSDoc type (if it has
|
||||
// one as its type), otherwise fallback to the below standard TS codepaths to
|
||||
// try to figure it out.
|
||||
|
|
@ -3988,7 +3988,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
function getTypeParametersFromJSDocTemplate(declaration: SignatureDeclaration): TypeParameter[] {
|
||||
if (declaration.parserContextFlags & ParserContextFlags.JavaScriptFile) {
|
||||
if (declaration.flags & NodeFlags.JavaScriptFile) {
|
||||
const templateTag = getJSDocTemplateTag(declaration);
|
||||
if (templateTag) {
|
||||
return getTypeParametersFromDeclaration(templateTag.typeParameters);
|
||||
|
|
@ -4022,7 +4022,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
function isOptionalParameter(node: ParameterDeclaration) {
|
||||
if (node.parserContextFlags & ParserContextFlags.JavaScriptFile) {
|
||||
if (node.flags & NodeFlags.JavaScriptFile) {
|
||||
if (node.type && node.type.kind === SyntaxKind.JSDocOptionalType) {
|
||||
return true;
|
||||
}
|
||||
|
|
@ -4131,7 +4131,7 @@ namespace ts {
|
|||
returnType = getTypeFromTypeNode(declaration.type);
|
||||
}
|
||||
else {
|
||||
if (declaration.parserContextFlags & ParserContextFlags.JavaScriptFile) {
|
||||
if (declaration.flags & NodeFlags.JavaScriptFile) {
|
||||
const type = getReturnTypeFromJSDocComment(declaration);
|
||||
if (type && type !== unknownType) {
|
||||
returnType = type;
|
||||
|
|
@ -7190,7 +7190,7 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
|
||||
if (node.parserContextFlags & ParserContextFlags.Await) {
|
||||
if (node.flags & NodeFlags.AwaitContext) {
|
||||
getNodeLinks(container).flags |= NodeCheckFlags.CaptureArguments;
|
||||
}
|
||||
}
|
||||
|
|
@ -10790,7 +10790,7 @@ namespace ts {
|
|||
function checkAwaitExpression(node: AwaitExpression): Type {
|
||||
// Grammar checking
|
||||
if (produceDiagnostics) {
|
||||
if (!(node.parserContextFlags & ParserContextFlags.Await)) {
|
||||
if (!(node.flags & NodeFlags.AwaitContext)) {
|
||||
grammarErrorOnFirstToken(node, Diagnostics.await_expression_is_only_allowed_within_an_async_function);
|
||||
}
|
||||
|
||||
|
|
@ -11246,7 +11246,7 @@ namespace ts {
|
|||
function checkYieldExpression(node: YieldExpression): Type {
|
||||
// Grammar checking
|
||||
if (produceDiagnostics) {
|
||||
if (!(node.parserContextFlags & ParserContextFlags.Yield) || isYieldExpressionInClass(node)) {
|
||||
if (!(node.flags & NodeFlags.YieldContext) || isYieldExpressionInClass(node)) {
|
||||
grammarErrorOnFirstToken(node, Diagnostics.A_yield_expression_is_only_allowed_in_a_generator_body);
|
||||
}
|
||||
|
||||
|
|
@ -13708,7 +13708,7 @@ namespace ts {
|
|||
function checkWithStatement(node: WithStatement) {
|
||||
// Grammar checking for withStatement
|
||||
if (!checkGrammarStatementInAmbientContext(node)) {
|
||||
if (node.parserContextFlags & ParserContextFlags.Await) {
|
||||
if (node.flags & NodeFlags.AwaitContext) {
|
||||
grammarErrorOnFirstToken(node, Diagnostics.with_statements_are_not_allowed_in_an_async_function_block);
|
||||
}
|
||||
}
|
||||
|
|
@ -16756,7 +16756,7 @@ namespace ts {
|
|||
// Grammar checking for computedPropertName and shorthandPropertyAssignment
|
||||
checkGrammarForInvalidQuestionMark(prop, (<PropertyAssignment>prop).questionToken, Diagnostics.An_object_member_cannot_be_declared_optional);
|
||||
if (name.kind === SyntaxKind.NumericLiteral) {
|
||||
checkGrammarNumericLiteral(<Identifier>name);
|
||||
checkGrammarNumericLiteral(<LiteralExpression>name);
|
||||
}
|
||||
currentKind = Property;
|
||||
}
|
||||
|
|
@ -17257,9 +17257,9 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
|
||||
function checkGrammarNumericLiteral(node: Identifier): boolean {
|
||||
function checkGrammarNumericLiteral(node: LiteralExpression): boolean {
|
||||
// Grammar checking
|
||||
if (node.flags & NodeFlags.OctalLiteral && languageVersion >= ScriptTarget.ES5) {
|
||||
if (node.isOctalLiteral && languageVersion >= ScriptTarget.ES5) {
|
||||
return grammarErrorOnNode(node, Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1780,7 +1780,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
|
|||
write("]");
|
||||
}
|
||||
else {
|
||||
emitListWithSpread(elements, /*needsUniqueCopy*/ true, /*multiLine*/(node.flags & NodeFlags.MultiLine) !== 0,
|
||||
emitListWithSpread(elements, /*needsUniqueCopy*/ true, /*multiLine*/ node.multiLine,
|
||||
/*trailingComma*/ elements.hasTrailingComma, /*useConcat*/ true);
|
||||
}
|
||||
}
|
||||
|
|
@ -1803,7 +1803,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
|
|||
emitLinePreservingList(node, properties, /*allowTrailingComma*/ languageVersion >= ScriptTarget.ES5, /*spacesBetweenBraces*/ true);
|
||||
}
|
||||
else {
|
||||
const multiLine = (node.flags & NodeFlags.MultiLine) !== 0;
|
||||
const multiLine = node.multiLine;
|
||||
if (!multiLine) {
|
||||
write(" ");
|
||||
}
|
||||
|
|
@ -1826,7 +1826,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
|
|||
}
|
||||
|
||||
function emitDownlevelObjectLiteralWithComputedProperties(node: ObjectLiteralExpression, firstComputedPropertyIndex: number) {
|
||||
const multiLine = (node.flags & NodeFlags.MultiLine) !== 0;
|
||||
const multiLine = node.multiLine;
|
||||
const properties = node.properties;
|
||||
|
||||
write("(");
|
||||
|
|
|
|||
|
|
@ -438,7 +438,7 @@ namespace ts {
|
|||
// Share a single scanner across all calls to parse a source file. This helps speed things
|
||||
// up by avoiding the cost of creating/compiling scanners over and over again.
|
||||
const scanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ true);
|
||||
const disallowInAndDecoratorContext = ParserContextFlags.DisallowIn | ParserContextFlags.Decorator;
|
||||
const disallowInAndDecoratorContext = NodeFlags.DisallowInContext | NodeFlags.DecoratorContext;
|
||||
|
||||
// capture constructors in 'initializeState' to avoid null checks
|
||||
let NodeConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;
|
||||
|
|
@ -502,7 +502,7 @@ namespace ts {
|
|||
// Note: it should not be necessary to save/restore these flags during speculative/lookahead
|
||||
// parsing. These context flags are naturally stored and restored through normal recursive
|
||||
// descent parsing and unwinding.
|
||||
let contextFlags: ParserContextFlags;
|
||||
let contextFlags: NodeFlags;
|
||||
|
||||
// Whether or not we've had a parse error since creating the last AST node. If we have
|
||||
// encountered an error, it will be stored on the next AST node we create. Parse errors
|
||||
|
|
@ -562,7 +562,7 @@ namespace ts {
|
|||
identifierCount = 0;
|
||||
nodeCount = 0;
|
||||
|
||||
contextFlags = isJavaScriptFile ? ParserContextFlags.JavaScriptFile : ParserContextFlags.None;
|
||||
contextFlags = isJavaScriptFile ? NodeFlags.JavaScriptFile : NodeFlags.None;
|
||||
parseErrorBeforeNextFinishedNode = false;
|
||||
|
||||
// Initialize and prime the scanner before parsing the source elements.
|
||||
|
|
@ -587,10 +587,7 @@ namespace ts {
|
|||
|
||||
function parseSourceFileWorker(fileName: string, languageVersion: ScriptTarget, setParentNodes: boolean): SourceFile {
|
||||
sourceFile = createSourceFile(fileName, languageVersion);
|
||||
|
||||
if (contextFlags & ParserContextFlags.JavaScriptFile) {
|
||||
sourceFile.parserContextFlags = ParserContextFlags.JavaScriptFile;
|
||||
}
|
||||
sourceFile.flags = contextFlags;
|
||||
|
||||
// Prime the scanner.
|
||||
token = nextToken();
|
||||
|
|
@ -616,7 +613,7 @@ namespace ts {
|
|||
|
||||
|
||||
function addJSDocComment<T extends Node>(node: T): T {
|
||||
if (contextFlags & ParserContextFlags.JavaScriptFile) {
|
||||
if (contextFlags & NodeFlags.JavaScriptFile) {
|
||||
const comments = getLeadingCommentRangesOfNode(node, sourceFile);
|
||||
if (comments) {
|
||||
for (const comment of comments) {
|
||||
|
|
@ -666,13 +663,13 @@ namespace ts {
|
|||
sourceFile.bindDiagnostics = [];
|
||||
sourceFile.languageVersion = languageVersion;
|
||||
sourceFile.fileName = normalizePath(fileName);
|
||||
sourceFile.flags = fileExtensionIs(sourceFile.fileName, ".d.ts") ? NodeFlags.DeclarationFile : 0;
|
||||
sourceFile.languageVariant = getLanguageVariant(sourceFile.fileName);
|
||||
sourceFile.isDeclarationFile = fileExtensionIs(sourceFile.fileName, ".d.ts");
|
||||
|
||||
return sourceFile;
|
||||
}
|
||||
|
||||
function setContextFlag(val: boolean, flag: ParserContextFlags) {
|
||||
function setContextFlag(val: boolean, flag: NodeFlags) {
|
||||
if (val) {
|
||||
contextFlags |= flag;
|
||||
}
|
||||
|
|
@ -682,22 +679,22 @@ namespace ts {
|
|||
}
|
||||
|
||||
function setDisallowInContext(val: boolean) {
|
||||
setContextFlag(val, ParserContextFlags.DisallowIn);
|
||||
setContextFlag(val, NodeFlags.DisallowInContext);
|
||||
}
|
||||
|
||||
function setYieldContext(val: boolean) {
|
||||
setContextFlag(val, ParserContextFlags.Yield);
|
||||
setContextFlag(val, NodeFlags.YieldContext);
|
||||
}
|
||||
|
||||
function setDecoratorContext(val: boolean) {
|
||||
setContextFlag(val, ParserContextFlags.Decorator);
|
||||
setContextFlag(val, NodeFlags.DecoratorContext);
|
||||
}
|
||||
|
||||
function setAwaitContext(val: boolean) {
|
||||
setContextFlag(val, ParserContextFlags.Await);
|
||||
setContextFlag(val, NodeFlags.AwaitContext);
|
||||
}
|
||||
|
||||
function doOutsideOfContext<T>(context: ParserContextFlags, func: () => T): T {
|
||||
function doOutsideOfContext<T>(context: NodeFlags, func: () => T): T {
|
||||
// contextFlagsToClear will contain only the context flags that are
|
||||
// currently set that we need to temporarily clear
|
||||
// We don't just blindly reset to the previous flags to ensure
|
||||
|
|
@ -718,7 +715,7 @@ namespace ts {
|
|||
return func();
|
||||
}
|
||||
|
||||
function doInsideOfContext<T>(context: ParserContextFlags, func: () => T): T {
|
||||
function doInsideOfContext<T>(context: NodeFlags, func: () => T): T {
|
||||
// contextFlagsToSet will contain only the context flags that
|
||||
// are not currently set that we need to temporarily enable.
|
||||
// We don't just blindly reset to the previous flags to ensure
|
||||
|
|
@ -740,51 +737,51 @@ namespace ts {
|
|||
}
|
||||
|
||||
function allowInAnd<T>(func: () => T): T {
|
||||
return doOutsideOfContext(ParserContextFlags.DisallowIn, func);
|
||||
return doOutsideOfContext(NodeFlags.DisallowInContext, func);
|
||||
}
|
||||
|
||||
function disallowInAnd<T>(func: () => T): T {
|
||||
return doInsideOfContext(ParserContextFlags.DisallowIn, func);
|
||||
return doInsideOfContext(NodeFlags.DisallowInContext, func);
|
||||
}
|
||||
|
||||
function doInYieldContext<T>(func: () => T): T {
|
||||
return doInsideOfContext(ParserContextFlags.Yield, func);
|
||||
return doInsideOfContext(NodeFlags.YieldContext, func);
|
||||
}
|
||||
|
||||
function doInDecoratorContext<T>(func: () => T): T {
|
||||
return doInsideOfContext(ParserContextFlags.Decorator, func);
|
||||
return doInsideOfContext(NodeFlags.DecoratorContext, func);
|
||||
}
|
||||
|
||||
function doInAwaitContext<T>(func: () => T): T {
|
||||
return doInsideOfContext(ParserContextFlags.Await, func);
|
||||
return doInsideOfContext(NodeFlags.AwaitContext, func);
|
||||
}
|
||||
|
||||
function doOutsideOfAwaitContext<T>(func: () => T): T {
|
||||
return doOutsideOfContext(ParserContextFlags.Await, func);
|
||||
return doOutsideOfContext(NodeFlags.AwaitContext, func);
|
||||
}
|
||||
|
||||
function doInYieldAndAwaitContext<T>(func: () => T): T {
|
||||
return doInsideOfContext(ParserContextFlags.Yield | ParserContextFlags.Await, func);
|
||||
return doInsideOfContext(NodeFlags.YieldContext | NodeFlags.AwaitContext, func);
|
||||
}
|
||||
|
||||
function inContext(flags: ParserContextFlags) {
|
||||
function inContext(flags: NodeFlags) {
|
||||
return (contextFlags & flags) !== 0;
|
||||
}
|
||||
|
||||
function inYieldContext() {
|
||||
return inContext(ParserContextFlags.Yield);
|
||||
return inContext(NodeFlags.YieldContext);
|
||||
}
|
||||
|
||||
function inDisallowInContext() {
|
||||
return inContext(ParserContextFlags.DisallowIn);
|
||||
return inContext(NodeFlags.DisallowInContext);
|
||||
}
|
||||
|
||||
function inDecoratorContext() {
|
||||
return inContext(ParserContextFlags.Decorator);
|
||||
return inContext(NodeFlags.DecoratorContext);
|
||||
}
|
||||
|
||||
function inAwaitContext() {
|
||||
return inContext(ParserContextFlags.Await);
|
||||
return inContext(NodeFlags.AwaitContext);
|
||||
}
|
||||
|
||||
function parseErrorAtCurrentToken(message: DiagnosticMessage, arg0?: any): void {
|
||||
|
|
@ -996,7 +993,7 @@ namespace ts {
|
|||
node.end = end === undefined ? scanner.getStartPos() : end;
|
||||
|
||||
if (contextFlags) {
|
||||
node.parserContextFlags = contextFlags;
|
||||
node.flags |= contextFlags;
|
||||
}
|
||||
|
||||
// Keep track on the node if we encountered an error while parsing it. If we did, then
|
||||
|
|
@ -1004,7 +1001,7 @@ namespace ts {
|
|||
// flag so that we don't mark any subsequent nodes.
|
||||
if (parseErrorBeforeNextFinishedNode) {
|
||||
parseErrorBeforeNextFinishedNode = false;
|
||||
node.parserContextFlags |= ParserContextFlags.ThisNodeHasError;
|
||||
node.flags |= NodeFlags.ThisNodeHasError;
|
||||
}
|
||||
|
||||
return node;
|
||||
|
|
@ -1453,7 +1450,7 @@ namespace ts {
|
|||
// differently depending on what mode it is in.
|
||||
//
|
||||
// This also applies to all our other context flags as well.
|
||||
const nodeContextFlags = node.parserContextFlags & ParserContextFlags.ParserGeneratedFlags;
|
||||
const nodeContextFlags = node.flags & NodeFlags.ContextFlags;
|
||||
if (nodeContextFlags !== contextFlags) {
|
||||
return undefined;
|
||||
}
|
||||
|
|
@ -1922,7 +1919,7 @@ namespace ts {
|
|||
&& sourceText.charCodeAt(tokenPos) === CharacterCodes._0
|
||||
&& isOctalDigit(sourceText.charCodeAt(tokenPos + 1))) {
|
||||
|
||||
node.flags |= NodeFlags.OctalLiteral;
|
||||
node.isOctalLiteral = true;
|
||||
}
|
||||
|
||||
return node;
|
||||
|
|
@ -2512,7 +2509,7 @@ namespace ts {
|
|||
function parseType(): TypeNode {
|
||||
// The rules about 'yield' only apply to actual code/expression contexts. They don't
|
||||
// apply to 'type' contexts. So we disable these parameters here before moving on.
|
||||
return doOutsideOfContext(ParserContextFlags.TypeExcludesFlags, parseTypeWorker);
|
||||
return doOutsideOfContext(NodeFlags.TypeExcludesFlags, parseTypeWorker);
|
||||
}
|
||||
|
||||
function parseTypeWorker(): TypeNode {
|
||||
|
|
@ -3907,7 +3904,9 @@ namespace ts {
|
|||
function parseArrayLiteralExpression(): ArrayLiteralExpression {
|
||||
const node = <ArrayLiteralExpression>createNode(SyntaxKind.ArrayLiteralExpression);
|
||||
parseExpected(SyntaxKind.OpenBracketToken);
|
||||
if (scanner.hasPrecedingLineBreak()) node.flags |= NodeFlags.MultiLine;
|
||||
if (scanner.hasPrecedingLineBreak()) {
|
||||
node.multiLine = true;
|
||||
}
|
||||
node.elements = parseDelimitedList(ParsingContext.ArrayLiteralMembers, parseArgumentOrArrayLiteralElement);
|
||||
parseExpected(SyntaxKind.CloseBracketToken);
|
||||
return finishNode(node);
|
||||
|
|
@ -3978,7 +3977,7 @@ namespace ts {
|
|||
const node = <ObjectLiteralExpression>createNode(SyntaxKind.ObjectLiteralExpression);
|
||||
parseExpected(SyntaxKind.OpenBraceToken);
|
||||
if (scanner.hasPrecedingLineBreak()) {
|
||||
node.flags |= NodeFlags.MultiLine;
|
||||
node.multiLine = true;
|
||||
}
|
||||
|
||||
node.properties = parseDelimitedList(ParsingContext.ObjectLiteralMembers, parseObjectLiteralElement, /*considerSemicolonAsDelimeter*/ true);
|
||||
|
|
@ -4783,7 +4782,7 @@ namespace ts {
|
|||
// The checker may still error in the static case to explicitly disallow the yield expression.
|
||||
property.initializer = modifiers && modifiers.flags & NodeFlags.Static
|
||||
? allowInAnd(parseNonParameterInitializer)
|
||||
: doOutsideOfContext(ParserContextFlags.Yield | ParserContextFlags.DisallowIn, parseNonParameterInitializer);
|
||||
: doOutsideOfContext(NodeFlags.YieldContext | NodeFlags.DisallowInContext, parseNonParameterInitializer);
|
||||
|
||||
parseSemicolon();
|
||||
return finishNode(property);
|
||||
|
|
|
|||
|
|
@ -381,22 +381,26 @@ namespace ts {
|
|||
Abstract = 1 << 7, // Class/Method/ConstructSignature
|
||||
Async = 1 << 8, // Property/Method/Function
|
||||
Default = 1 << 9, // Function/Class (export default declaration)
|
||||
MultiLine = 1 << 10, // Multi-line array or object literal
|
||||
Synthetic = 1 << 11, // Synthetic node (for full fidelity)
|
||||
DeclarationFile = 1 << 12, // Node is a .d.ts file
|
||||
Let = 1 << 13, // Variable declaration
|
||||
Const = 1 << 14, // Variable declaration
|
||||
OctalLiteral = 1 << 15, // Octal numeric literal
|
||||
Namespace = 1 << 16, // Namespace declaration
|
||||
ExportContext = 1 << 17, // Export context (initialized by binding)
|
||||
ContainsThis = 1 << 18, // Interface contains references to "this"
|
||||
HasImplicitReturn = 1 << 19, // If function implicitly returns on one of codepaths (initialized by binding)
|
||||
HasExplicitReturn = 1 << 20, // If function has explicit reachable return on one of codepaths (initialized by binding)
|
||||
GlobalAugmentation = 1 << 21, // Set if module declaration is an augmentation for the global scope
|
||||
HasClassExtends = 1 << 22, // If the file has a non-ambient class with an extends clause in ES5 or lower (initialized by binding)
|
||||
HasDecorators = 1 << 23, // If the file has decorators (initialized by binding)
|
||||
HasParamDecorators = 1 << 24, // If the file has parameter decorators (initialized by binding)
|
||||
HasAsyncFunctions = 1 << 25, // If the file has async functions (initialized by binding)
|
||||
Let = 1 << 10, // Variable declaration
|
||||
Const = 1 << 11, // Variable declaration
|
||||
Namespace = 1 << 12, // Namespace declaration
|
||||
ExportContext = 1 << 13, // Export context (initialized by binding)
|
||||
ContainsThis = 1 << 14, // Interface contains references to "this"
|
||||
HasImplicitReturn = 1 << 15, // If function implicitly returns on one of codepaths (initialized by binding)
|
||||
HasExplicitReturn = 1 << 16, // If function has explicit reachable return on one of codepaths (initialized by binding)
|
||||
GlobalAugmentation = 1 << 17, // Set if module declaration is an augmentation for the global scope
|
||||
HasClassExtends = 1 << 18, // If the file has a non-ambient class with an extends clause in ES5 or lower (initialized by binding)
|
||||
HasDecorators = 1 << 19, // If the file has decorators (initialized by binding)
|
||||
HasParamDecorators = 1 << 20, // If the file has parameter decorators (initialized by binding)
|
||||
HasAsyncFunctions = 1 << 21, // If the file has async functions (initialized by binding)
|
||||
DisallowInContext = 1 << 22, // If node was parsed in a context where 'in-expressions' are not allowed
|
||||
YieldContext = 1 << 23, // If node was parsed in the 'yield' context created when parsing a generator
|
||||
DecoratorContext = 1 << 24, // If node was parsed as part of a decorator
|
||||
AwaitContext = 1 << 25, // If node was parsed in the 'await' context created when parsing an async function
|
||||
ThisNodeHasError = 1 << 26, // If the parser encountered an error when parsing the code that created this node
|
||||
JavaScriptFile = 1 << 27, // If node was parsed in a JavaScript
|
||||
ThisNodeOrAnySubNodesHasError = 1 << 28, // If this node or any of its children had an error
|
||||
HasAggregatedChildData = 1 << 29, // If we've computed data from children and cached it in this node
|
||||
|
||||
Modifier = Export | Ambient | Public | Private | Protected | Static | Abstract | Default | Async,
|
||||
AccessibilityModifier = Public | Private | Protected,
|
||||
|
|
@ -404,47 +408,12 @@ namespace ts {
|
|||
|
||||
ReachabilityCheckFlags = HasImplicitReturn | HasExplicitReturn,
|
||||
EmitHelperFlags = HasClassExtends | HasDecorators | HasParamDecorators | HasAsyncFunctions,
|
||||
}
|
||||
|
||||
/* @internal */
|
||||
export const enum ParserContextFlags {
|
||||
None = 0,
|
||||
|
||||
// If this node was parsed in a context where 'in-expressions' are not allowed.
|
||||
DisallowIn = 1 << 0,
|
||||
|
||||
// If this node was parsed in the 'yield' context created when parsing a generator.
|
||||
Yield = 1 << 1,
|
||||
|
||||
// If this node was parsed as part of a decorator
|
||||
Decorator = 1 << 2,
|
||||
|
||||
// If this node was parsed in the 'await' context created when parsing an async function.
|
||||
Await = 1 << 3,
|
||||
|
||||
// If the parser encountered an error when parsing the code that created this node. Note
|
||||
// the parser only sets this directly on the node it creates right after encountering the
|
||||
// error.
|
||||
ThisNodeHasError = 1 << 4,
|
||||
|
||||
// This node was parsed in a JavaScript file and can be processed differently. For example
|
||||
// its type can be specified usign a JSDoc comment.
|
||||
JavaScriptFile = 1 << 5,
|
||||
|
||||
// Context flags set directly by the parser.
|
||||
ParserGeneratedFlags = DisallowIn | Yield | Decorator | ThisNodeHasError | Await,
|
||||
// Parsing context flags
|
||||
ContextFlags = DisallowInContext | YieldContext | DecoratorContext | AwaitContext,
|
||||
|
||||
// Exclude these flags when parsing a Type
|
||||
TypeExcludesFlags = Yield | Await,
|
||||
|
||||
// Context flags computed by aggregating child flags upwards.
|
||||
|
||||
// Used during incremental parsing to determine if this node or any of its children had an
|
||||
// error. Computed only once and then cached.
|
||||
ThisNodeOrAnySubNodesHasError = 1 << 6,
|
||||
|
||||
// Used to know if we've computed data from children and cached it in this node.
|
||||
HasAggregatedChildData = 1 << 7
|
||||
TypeExcludesFlags = YieldContext | AwaitContext,
|
||||
}
|
||||
|
||||
export const enum JsxFlags {
|
||||
|
|
@ -472,9 +441,6 @@ namespace ts {
|
|||
export interface Node extends TextRange {
|
||||
kind: SyntaxKind;
|
||||
flags: NodeFlags;
|
||||
// Specific context the parser was in when this node was created. Normally undefined.
|
||||
// Only set when the parser was in some interesting context (like async/yield).
|
||||
/* @internal */ parserContextFlags?: ParserContextFlags;
|
||||
decorators?: NodeArray<Decorator>; // Array of decorators (in document order)
|
||||
modifiers?: ModifiersArray; // Array of modifiers
|
||||
/* @internal */ id?: number; // Unique id (used to look up NodeLinks)
|
||||
|
|
@ -938,6 +904,8 @@ namespace ts {
|
|||
text: string;
|
||||
isUnterminated?: boolean;
|
||||
hasExtendedUnicodeEscape?: boolean;
|
||||
/* @internal */
|
||||
isOctalLiteral?: boolean;
|
||||
}
|
||||
|
||||
// The text property of a LiteralExpression stores the interpreted value of the literal in text form. For a StringLiteral,
|
||||
|
|
@ -979,6 +947,8 @@ namespace ts {
|
|||
// @kind(SyntaxKind.ArrayLiteralExpression)
|
||||
export interface ArrayLiteralExpression extends PrimaryExpression {
|
||||
elements: NodeArray<Expression>;
|
||||
/* @internal */
|
||||
multiLine?: boolean;
|
||||
}
|
||||
|
||||
// @kind(SyntaxKind.SpreadElementExpression)
|
||||
|
|
@ -990,6 +960,8 @@ namespace ts {
|
|||
// @kind(SyntaxKind.ObjectLiteralExpression)
|
||||
export interface ObjectLiteralExpression extends PrimaryExpression, Declaration {
|
||||
properties: NodeArray<ObjectLiteralElement>;
|
||||
/* @internal */
|
||||
multiLine?: boolean;
|
||||
}
|
||||
|
||||
// @kind(SyntaxKind.PropertyAccessExpression)
|
||||
|
|
@ -1546,6 +1518,7 @@ namespace ts {
|
|||
moduleName: string;
|
||||
referencedFiles: FileReference[];
|
||||
languageVariant: LanguageVariant;
|
||||
isDeclarationFile: boolean;
|
||||
|
||||
// this map is used by transpiler to supply alternative names for dependencies (i.e. in case of bundling)
|
||||
/* @internal */
|
||||
|
|
|
|||
|
|
@ -121,26 +121,26 @@ namespace ts {
|
|||
// Returns true if this node contains a parse error anywhere underneath it.
|
||||
export function containsParseError(node: Node): boolean {
|
||||
aggregateChildData(node);
|
||||
return (node.parserContextFlags & ParserContextFlags.ThisNodeOrAnySubNodesHasError) !== 0;
|
||||
return (node.flags & NodeFlags.ThisNodeOrAnySubNodesHasError) !== 0;
|
||||
}
|
||||
|
||||
function aggregateChildData(node: Node): void {
|
||||
if (!(node.parserContextFlags & ParserContextFlags.HasAggregatedChildData)) {
|
||||
if (!(node.flags & NodeFlags.HasAggregatedChildData)) {
|
||||
// A node is considered to contain a parse error if:
|
||||
// a) the parser explicitly marked that it had an error
|
||||
// b) any of it's children reported that it had an error.
|
||||
const thisNodeOrAnySubNodesHasError = ((node.parserContextFlags & ParserContextFlags.ThisNodeHasError) !== 0) ||
|
||||
const thisNodeOrAnySubNodesHasError = ((node.flags & NodeFlags.ThisNodeHasError) !== 0) ||
|
||||
forEachChild(node, containsParseError);
|
||||
|
||||
// If so, mark ourselves accordingly.
|
||||
if (thisNodeOrAnySubNodesHasError) {
|
||||
node.parserContextFlags |= ParserContextFlags.ThisNodeOrAnySubNodesHasError;
|
||||
node.flags |= NodeFlags.ThisNodeOrAnySubNodesHasError;
|
||||
}
|
||||
|
||||
// Also mark that we've propogated the child information to this node. This way we can
|
||||
// always consult the bit directly on this node without needing to check its children
|
||||
// again.
|
||||
node.parserContextFlags |= ParserContextFlags.HasAggregatedChildData;
|
||||
node.flags |= NodeFlags.HasAggregatedChildData;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -414,7 +414,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
export function isDeclarationFile(file: SourceFile): boolean {
|
||||
return (file.flags & NodeFlags.DeclarationFile) !== 0;
|
||||
return file.isDeclarationFile;
|
||||
}
|
||||
|
||||
export function isConstEnumDeclaration(node: Node): boolean {
|
||||
|
|
@ -1078,7 +1078,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
export function isInJavaScriptFile(node: Node): boolean {
|
||||
return node && !!(node.parserContextFlags & ParserContextFlags.JavaScriptFile);
|
||||
return node && !!(node.flags & NodeFlags.JavaScriptFile);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1266,7 +1266,7 @@ namespace ts {
|
|||
|
||||
export function isRestParameter(node: ParameterDeclaration) {
|
||||
if (node) {
|
||||
if (node.parserContextFlags & ParserContextFlags.JavaScriptFile) {
|
||||
if (node.flags & NodeFlags.JavaScriptFile) {
|
||||
if (node.type && node.type.kind === SyntaxKind.JSDocVariadicType) {
|
||||
return true;
|
||||
}
|
||||
|
|
@ -1309,10 +1309,9 @@ namespace ts {
|
|||
|
||||
export function isInAmbientContext(node: Node): boolean {
|
||||
while (node) {
|
||||
if (node.flags & (NodeFlags.Ambient | NodeFlags.DeclarationFile)) {
|
||||
if (node.flags & NodeFlags.Ambient || (node.kind === SyntaxKind.SourceFile && (node as SourceFile).isDeclarationFile)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
node = node.parent;
|
||||
}
|
||||
return false;
|
||||
|
|
|
|||
|
|
@ -245,7 +245,6 @@ namespace Utils {
|
|||
}
|
||||
|
||||
function getNodeFlagName(f: number) { return getFlagName((<any>ts).NodeFlags, f); }
|
||||
function getParserContextFlagName(f: number) { return getFlagName((<any>ts).ParserContextFlags, f); }
|
||||
|
||||
function serializeNode(n: ts.Node): any {
|
||||
const o: any = { kind: getKindName(n.kind) };
|
||||
|
|
@ -274,19 +273,12 @@ namespace Utils {
|
|||
break;
|
||||
|
||||
case "flags":
|
||||
// Print out flags with their enum names.
|
||||
if (n.flags) {
|
||||
o[propertyName] = getNodeFlagName(n.flags);
|
||||
}
|
||||
break;
|
||||
|
||||
case "parserContextFlags":
|
||||
// Clear the flag that are produced by aggregating child values.. That is ephemeral
|
||||
// data we don't care about in the dump. We only care what the parser set directly
|
||||
// on the ast.
|
||||
let value = n.parserContextFlags & ts.ParserContextFlags.ParserGeneratedFlags;
|
||||
if (value) {
|
||||
o[propertyName] = getParserContextFlagName(value);
|
||||
// Clear the flags that are produced by aggregating child values. That is ephemeral
|
||||
// data we don't care about in the dump. We only care what the parser set directly
|
||||
// on the AST.
|
||||
const flags = n.flags & ~(ts.NodeFlags.JavaScriptFile | ts.NodeFlags.HasAggregatedChildData);
|
||||
if (flags) {
|
||||
o[propertyName] = getNodeFlagName(flags);
|
||||
}
|
||||
break;
|
||||
|
||||
|
|
@ -353,12 +345,11 @@ namespace Utils {
|
|||
assert.equal(node1.pos, node2.pos, "node1.pos !== node2.pos");
|
||||
assert.equal(node1.end, node2.end, "node1.end !== node2.end");
|
||||
assert.equal(node1.kind, node2.kind, "node1.kind !== node2.kind");
|
||||
assert.equal(node1.flags, node2.flags, "node1.flags !== node2.flags");
|
||||
|
||||
// call this on both nodes to ensure all propagated flags have been set (and thus can be
|
||||
// compared).
|
||||
assert.equal(ts.containsParseError(node1), ts.containsParseError(node2));
|
||||
assert.equal(node1.parserContextFlags, node2.parserContextFlags, "node1.parserContextFlags !== node2.parserContextFlags");
|
||||
assert.equal(node1.flags, node2.flags, "node1.flags !== node2.flags");
|
||||
|
||||
ts.forEachChild(node1,
|
||||
child1 => {
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ namespace ts.BreakpointResolver {
|
|||
*/
|
||||
export function spanInSourceFileAtLocation(sourceFile: SourceFile, position: number) {
|
||||
// Cannot set breakpoint in dts file
|
||||
if (sourceFile.flags & NodeFlags.DeclarationFile) {
|
||||
if (sourceFile.isDeclarationFile) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -237,14 +237,14 @@ namespace ts {
|
|||
while (pos < end) {
|
||||
const token = scanner.scan();
|
||||
const textPos = scanner.getTextPos();
|
||||
nodes.push(createNode(token, pos, textPos, NodeFlags.Synthetic, this));
|
||||
nodes.push(createNode(token, pos, textPos, 0, this));
|
||||
pos = textPos;
|
||||
}
|
||||
return pos;
|
||||
}
|
||||
|
||||
private createSyntaxList(nodes: NodeArray<Node>): Node {
|
||||
const list = createNode(SyntaxKind.SyntaxList, nodes.pos, nodes.end, NodeFlags.Synthetic, this);
|
||||
const list = createNode(SyntaxKind.SyntaxList, nodes.pos, nodes.end, 0, this);
|
||||
list._children = [];
|
||||
let pos = nodes.pos;
|
||||
|
||||
|
|
@ -797,6 +797,7 @@ namespace ts {
|
|||
public parseDiagnostics: Diagnostic[];
|
||||
public bindDiagnostics: Diagnostic[];
|
||||
|
||||
public isDeclarationFile: boolean;
|
||||
public isDefaultLib: boolean;
|
||||
public hasNoDefaultLib: boolean;
|
||||
public externalModuleIndicator: Node; // The first node that causes this file to be an external module
|
||||
|
|
|
|||
Loading…
Reference in a new issue