namespace ts {

export interface Map<T> {

[index: string]: T;

}

// branded string type used to store absolute, normalized and canonicalized paths

// arbitrary file name can be converted to Path via toPath function

export type Path = string & { __pathBrand: any };

export interface FileMap<T> {

get(fileName: Path): T;

set(fileName: Path, value: T): void;

contains(fileName: Path): boolean;

remove(fileName: Path): void;

forEachValue(f: (key: Path, v: T) => void): void;

clear(): void;

}

export interface TextRange {

pos: number;

end: number;

}

// token > SyntaxKind.Identifer => token is a keyword

// Also, If you add a new SyntaxKind be sure to keep the `Markers` section at the bottom in sync

export const enum SyntaxKind {

Unknown,

EndOfFileToken,

SingleLineCommentTrivia,

MultiLineCommentTrivia,

NewLineTrivia,

WhitespaceTrivia,

// We detect and preserve #! on the first line

ShebangTrivia,

// We detect and provide better error recovery when we encounter a git merge marker. This

// allows us to edit files with git-conflict markers in them in a much more pleasant manner.

ConflictMarkerTrivia,

// Literals

NumericLiteral,

StringLiteral,

RegularExpressionLiteral,

NoSubstitutionTemplateLiteral,

// Pseudo-literals

TemplateHead,

TemplateMiddle,

TemplateTail,

// Punctuation

OpenBraceToken,

CloseBraceToken,

OpenParenToken,

CloseParenToken,

OpenBracketToken,

CloseBracketToken,

DotToken,

DotDotDotToken,

SemicolonToken,

CommaToken,

LessThanToken,

LessThanSlashToken,

GreaterThanToken,

LessThanEqualsToken,

GreaterThanEqualsToken,

EqualsEqualsToken,

ExclamationEqualsToken,

EqualsEqualsEqualsToken,

ExclamationEqualsEqualsToken,

EqualsGreaterThanToken,

PlusToken,

MinusToken,

AsteriskToken,

AsteriskAsteriskToken,

SlashToken,

PercentToken,

PlusPlusToken,

MinusMinusToken,

LessThanLessThanToken,

GreaterThanGreaterThanToken,

GreaterThanGreaterThanGreaterThanToken,

AmpersandToken,

BarToken,

CaretToken,

ExclamationToken,

TildeToken,

AmpersandAmpersandToken,

BarBarToken,

QuestionToken,

ColonToken,

AtToken,

// Assignments

EqualsToken,

PlusEqualsToken,

MinusEqualsToken,

AsteriskEqualsToken,

AsteriskAsteriskEqualsToken,

SlashEqualsToken,

PercentEqualsToken,

LessThanLessThanEqualsToken,

GreaterThanGreaterThanEqualsToken,

GreaterThanGreaterThanGreaterThanEqualsToken,

AmpersandEqualsToken,

BarEqualsToken,

CaretEqualsToken,

// Identifiers

Identifier,

// Reserved words

BreakKeyword,

CaseKeyword,

CatchKeyword,

ClassKeyword,

ConstKeyword,

ContinueKeyword,

DebuggerKeyword,

DefaultKeyword,

DeleteKeyword,

DoKeyword,

ElseKeyword,

EnumKeyword,

ExportKeyword,

ExtendsKeyword,

FalseKeyword,

FinallyKeyword,

ForKeyword,

FunctionKeyword,

IfKeyword,

ImportKeyword,

InKeyword,

InstanceOfKeyword,

NewKeyword,

NullKeyword,

ReturnKeyword,

SuperKeyword,

SwitchKeyword,

ThisKeyword,

ThrowKeyword,

TrueKeyword,

TryKeyword,

TypeOfKeyword,

VarKeyword,

VoidKeyword,

WhileKeyword,

WithKeyword,

// Strict mode reserved words

ImplementsKeyword,

InterfaceKeyword,

LetKeyword,

PackageKeyword,

PrivateKeyword,

ProtectedKeyword,

PublicKeyword,

StaticKeyword,

YieldKeyword,

// Contextual keywords

AbstractKeyword,

AsKeyword,

AnyKeyword,

AsyncKeyword,

AwaitKeyword,

BooleanKeyword,

ConstructorKeyword,

DeclareKeyword,

GetKeyword,

IsKeyword,

ModuleKeyword,

NamespaceKeyword,

NeverKeyword,

ReadonlyKeyword,

RequireKeyword,

NumberKeyword,

SetKeyword,

StringKeyword,

SymbolKeyword,

TypeKeyword,

UndefinedKeyword,

FromKeyword,

GlobalKeyword,

OfKeyword, // LastKeyword and LastToken

// Parse tree nodes

// Names

QualifiedName,

ComputedPropertyName,

// Signature elements

TypeParameter,

Parameter,

Decorator,

// TypeMember

PropertySignature,

PropertyDeclaration,

MethodSignature,

MethodDeclaration,

Constructor,

GetAccessor,

SetAccessor,

CallSignature,

ConstructSignature,

IndexSignature,

// Type

TypePredicate,

TypeReference,

FunctionType,

ConstructorType,

TypeQuery,

TypeLiteral,

ArrayType,

TupleType,

UnionType,

IntersectionType,

ParenthesizedType,

ThisType,

StringLiteralType,

// Binding patterns

ObjectBindingPattern,

ArrayBindingPattern,

BindingElement,

// Expression

ArrayLiteralExpression,

ObjectLiteralExpression,

PropertyAccessExpression,

ElementAccessExpression,

CallExpression,

NewExpression,

TaggedTemplateExpression,

TypeAssertionExpression,

ParenthesizedExpression,

FunctionExpression,

ArrowFunction,

DeleteExpression,

TypeOfExpression,

VoidExpression,

AwaitExpression,

PrefixUnaryExpression,

PostfixUnaryExpression,

BinaryExpression,

ConditionalExpression,

TemplateExpression,

YieldExpression,

SpreadElementExpression,

ClassExpression,

OmittedExpression,

ExpressionWithTypeArguments,

AsExpression,

NonNullExpression,

// Misc

TemplateSpan,

SemicolonClassElement,

// Element

Block,

VariableStatement,

EmptyStatement,

ExpressionStatement,

IfStatement,

DoStatement,

WhileStatement,

ForStatement,

ForInStatement,

ForOfStatement,

ContinueStatement,

BreakStatement,

ReturnStatement,

WithStatement,

SwitchStatement,

LabeledStatement,

ThrowStatement,

TryStatement,

DebuggerStatement,

VariableDeclaration,

VariableDeclarationList,

FunctionDeclaration,

ClassDeclaration,

InterfaceDeclaration,

TypeAliasDeclaration,

EnumDeclaration,

ModuleDeclaration,

ModuleBlock,

CaseBlock,

GlobalModuleExportDeclaration,

ImportEqualsDeclaration,

ImportDeclaration,

ImportClause,

NamespaceImport,

NamedImports,

ImportSpecifier,

ExportAssignment,

ExportDeclaration,

NamedExports,

ExportSpecifier,

MissingDeclaration,

// Module references

ExternalModuleReference,

// JSX

JsxElement,

JsxSelfClosingElement,

JsxOpeningElement,

JsxText,

JsxClosingElement,

JsxAttribute,

JsxSpreadAttribute,

JsxExpression,

// Clauses

CaseClause,

DefaultClause,

HeritageClause,

CatchClause,

// Property assignments

PropertyAssignment,

ShorthandPropertyAssignment,

// Enum

EnumMember,

// Top-level nodes

SourceFile,

// JSDoc nodes

JSDocTypeExpression,

// The * type

JSDocAllType,

// The ? type

JSDocUnknownType,

JSDocArrayType,

JSDocUnionType,

JSDocTupleType,

JSDocNullableType,

JSDocNonNullableType,

JSDocRecordType,

JSDocRecordMember,

JSDocTypeReference,

JSDocOptionalType,

JSDocFunctionType,

JSDocVariadicType,

JSDocConstructorType,

JSDocThisType,

JSDocComment,

JSDocTag,

JSDocParameterTag,

JSDocReturnTag,

JSDocTypeTag,

JSDocTemplateTag,

// Synthesized list

SyntaxList,

// Enum value count

Count,

// Markers

FirstAssignment = EqualsToken,

LastAssignment = CaretEqualsToken,

FirstReservedWord = BreakKeyword,

LastReservedWord = WithKeyword,

FirstKeyword = BreakKeyword,

LastKeyword = OfKeyword,

FirstFutureReservedWord = ImplementsKeyword,

LastFutureReservedWord = YieldKeyword,

FirstTypeNode = TypePredicate,

LastTypeNode = StringLiteralType,

FirstPunctuation = OpenBraceToken,

LastPunctuation = CaretEqualsToken,

FirstToken = Unknown,

LastToken = LastKeyword,

FirstTriviaToken = SingleLineCommentTrivia,

LastTriviaToken = ConflictMarkerTrivia,

FirstLiteralToken = NumericLiteral,

LastLiteralToken = NoSubstitutionTemplateLiteral,

FirstTemplateToken = NoSubstitutionTemplateLiteral,

LastTemplateToken = TemplateTail,

FirstBinaryOperator = LessThanToken,

LastBinaryOperator = CaretEqualsToken,

FirstNode = QualifiedName,

}

export const enum NodeFlags {

None = 0,

Export = 1 << 0, // Declarations

Ambient = 1 << 1, // Declarations

Public = 1 << 2, // Property/Method

Private = 1 << 3, // Property/Method

Protected = 1 << 4, // Property/Method

Static = 1 << 5, // Property/Method

Readonly = 1 << 6, // Property/Method

Abstract = 1 << 7, // Class/Method/ConstructSignature

Async = 1 << 8, // Property/Method/Function

Default = 1 << 9, // Function/Class (export default declaration)

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

HasJsxSpreadAttribute = 1 << 30,

Modifier = Export | Ambient | Public | Private | Protected | Static | Abstract | Default | Async | Readonly,

AccessibilityModifier = Public | Private | Protected,

// Accessibility modifiers and 'readonly' can be attached to a parameter in a constructor to make it a property.

ParameterPropertyModifier = AccessibilityModifier | Readonly,

BlockScoped = Let | Const,

ReachabilityCheckFlags = HasImplicitReturn | HasExplicitReturn,

EmitHelperFlags = HasClassExtends | HasDecorators | HasParamDecorators | HasAsyncFunctions,

// Parsing context flags

ContextFlags = DisallowInContext | YieldContext | DecoratorContext | AwaitContext | JavaScriptFile,

// Exclude these flags when parsing a Type

TypeExcludesFlags = YieldContext | AwaitContext,

}

export const enum JsxFlags {

None = 0,

/** An element from a named property of the JSX.IntrinsicElements interface */

IntrinsicNamedElement = 1 << 0,

/** An element inferred from the string index signature of the JSX.IntrinsicElements interface */

IntrinsicIndexedElement = 1 << 1,

IntrinsicElement = IntrinsicNamedElement | IntrinsicIndexedElement,

}

/* @internal */

export const enum RelationComparisonResult {

Succeeded = 1, // Should be truthy

Failed = 2,

FailedAndReported = 3

}

export interface Node extends TextRange {

kind: SyntaxKind;

flags: NodeFlags;

decorators?: NodeArray<Decorator>; // Array of decorators (in document order)

modifiers?: ModifiersArray; // Array of modifiers

/* @internal */ id?: number; // Unique id (used to look up NodeLinks)

parent?: Node; // Parent node (initialized by binding

/* @internal */ jsDocComment?: JSDocComment; // JSDoc for the node, if it has any. Only for .js files.

/* @internal */ symbol?: Symbol; // Symbol declared by node (initialized by binding)

/* @internal */ locals?: SymbolTable; // Locals associated with node (initialized by binding)

/* @internal */ nextContainer?: Node; // Next container in declaration order (initialized by binding)

/* @internal */ localSymbol?: Symbol; // Local symbol declared by node (initialized by binding only for exported nodes)

/* @internal */ flowNode?: FlowNode; // Associated FlowNode (initialized by binding)

}

export interface NodeArray<T> extends Array<T>, TextRange {

hasTrailingComma?: boolean;

}

export interface ModifiersArray extends NodeArray<Modifier> {

flags: number;

}

// @kind(SyntaxKind.AbstractKeyword)

// @kind(SyntaxKind.AsyncKeyword)

// @kind(SyntaxKind.ConstKeyword)

// @kind(SyntaxKind.DeclareKeyword)

// @kind(SyntaxKind.DefaultKeyword)

// @kind(SyntaxKind.ExportKeyword)

// @kind(SyntaxKind.PublicKeyword)

// @kind(SyntaxKind.PrivateKeyword)

// @kind(SyntaxKind.ProtectedKeyword)

// @kind(SyntaxKind.StaticKeyword)

export interface Modifier extends Node { }

// @kind(SyntaxKind.Identifier)

export interface Identifier extends PrimaryExpression {

text: string; // Text of identifier (with escapes converted to characters)

originalKeywordKind?: SyntaxKind; // Original syntaxKind which get set so that we can report an error later

}

// @kind(SyntaxKind.QualifiedName)

export interface QualifiedName extends Node {

// Must have same layout as PropertyAccess

left: EntityName;

right: Identifier;

}

export type EntityName = Identifier | QualifiedName;

export type PropertyName = Identifier | LiteralExpression | ComputedPropertyName;

export type DeclarationName = Identifier | LiteralExpression | ComputedPropertyName | BindingPattern;

export interface Declaration extends Node {

_declarationBrand: any;

name?: DeclarationName;

}

export interface DeclarationStatement extends Declaration, Statement {

name?: Identifier;

}

// @kind(SyntaxKind.ComputedPropertyName)

export interface ComputedPropertyName extends Node {

expression: Expression;

}

// @kind(SyntaxKind.Decorator)

export interface Decorator extends Node {

expression: LeftHandSideExpression;

}

// @kind(SyntaxKind.TypeParameter)

export interface TypeParameterDeclaration extends Declaration {

name: Identifier;

constraint?: TypeNode;

// For error recovery purposes.

expression?: Expression;

}

export interface SignatureDeclaration extends Declaration {

name?: PropertyName;

typeParameters?: NodeArray<TypeParameterDeclaration>;

parameters: NodeArray<ParameterDeclaration>;

type?: TypeNode;

}

// @kind(SyntaxKind.CallSignature)

export interface CallSignatureDeclaration extends SignatureDeclaration, TypeElement { }

// @kind(SyntaxKind.ConstructSignature)

export interface ConstructSignatureDeclaration extends SignatureDeclaration, TypeElement { }

// @kind(SyntaxKind.VariableDeclaration)

export interface VariableDeclaration extends Declaration {

parent?: VariableDeclarationList;

name: Identifier | BindingPattern; // Declared variable name

type?: TypeNode; // Optional type annotation

initializer?: Expression; // Optional initializer

}

// @kind(SyntaxKind.VariableDeclarationList)

export interface VariableDeclarationList extends Node {

declarations: NodeArray<VariableDeclaration>;

}

// @kind(SyntaxKind.Parameter)

export interface ParameterDeclaration extends Declaration {

dotDotDotToken?: Node; // Present on rest parameter

name: Identifier | BindingPattern; // Declared parameter name

questionToken?: Node; // Present on optional parameter

type?: TypeNode; // Optional type annotation

initializer?: Expression; // Optional initializer

}

// @kind(SyntaxKind.BindingElement)

export interface BindingElement extends Declaration {

propertyName?: PropertyName; // Binding property name (in object binding pattern)

dotDotDotToken?: Node; // Present on rest binding element

name: Identifier | BindingPattern; // Declared binding element name

initializer?: Expression; // Optional initializer

}

// @kind(SyntaxKind.PropertySignature)

export interface PropertySignature extends TypeElement {

name: PropertyName; // Declared property name

questionToken?: Node; // Present on optional property

type?: TypeNode; // Optional type annotation

initializer?: Expression; // Optional initializer

}

// @kind(SyntaxKind.PropertyDeclaration)

export interface PropertyDeclaration extends ClassElement {

questionToken?: Node; // Present for use with reporting a grammar error

name: PropertyName;

type?: TypeNode;

initializer?: Expression; // Optional initializer

}

export interface ObjectLiteralElement extends Declaration {

_objectLiteralBrandBrand: any;

name?: PropertyName;

}

// @kind(SyntaxKind.PropertyAssignment)

export interface PropertyAssignment extends ObjectLiteralElement {

_propertyAssignmentBrand: any;

name: PropertyName;

questionToken?: Node;

initializer: Expression;

}

// @kind(SyntaxKind.ShorthandPropertyAssignment)

export interface ShorthandPropertyAssignment extends ObjectLiteralElement {

name: Identifier;

questionToken?: Node;

// used when ObjectLiteralExpression is used in ObjectAssignmentPattern

// it is grammar error to appear in actual object initializer

equalsToken?: Node;

objectAssignmentInitializer?: Expression;

}

// SyntaxKind.VariableDeclaration

// SyntaxKind.Parameter

// SyntaxKind.BindingElement

// SyntaxKind.Property

// SyntaxKind.PropertyAssignment

// SyntaxKind.ShorthandPropertyAssignment

// SyntaxKind.EnumMember

export interface VariableLikeDeclaration extends Declaration {

propertyName?: PropertyName;

dotDotDotToken?: Node;

name: DeclarationName;

questionToken?: Node;

type?: TypeNode;

initializer?: Expression;

}

export interface PropertyLikeDeclaration extends Declaration {

name: PropertyName;

}

export interface BindingPattern extends Node {

elements: NodeArray<BindingElement>;

}

// @kind(SyntaxKind.ObjectBindingPattern)

export interface ObjectBindingPattern extends BindingPattern { }

// @kind(SyntaxKind.ArrayBindingPattern)

export interface ArrayBindingPattern extends BindingPattern { }

/**

* Several node kinds share function-like features such as a signature,

* a name, and a body. These nodes should extend FunctionLikeDeclaration.

* Examples:

* - FunctionDeclaration

* - MethodDeclaration

* - AccessorDeclaration

*/

export interface FunctionLikeDeclaration extends SignatureDeclaration {

_functionLikeDeclarationBrand: any;

asteriskToken?: Node;

questionToken?: Node;

body?: Block | Expression;

}

// @kind(SyntaxKind.FunctionDeclaration)

export interface FunctionDeclaration extends FunctionLikeDeclaration, DeclarationStatement {

name?: Identifier;

body?: FunctionBody;

}

// @kind(SyntaxKind.MethodSignature)

export interface MethodSignature extends SignatureDeclaration, TypeElement {

name: PropertyName;

}

// Note that a MethodDeclaration is considered both a ClassElement and an ObjectLiteralElement.

// Both the grammars for ClassDeclaration and ObjectLiteralExpression allow for MethodDeclarations

// as child elements, and so a MethodDeclaration satisfies both interfaces. This avoids the

// alternative where we would need separate kinds/types for ClassMethodDeclaration and

// ObjectLiteralMethodDeclaration, which would look identical.

//

// Because of this, it may be necessary to determine what sort of MethodDeclaration you have

// at later stages of the compiler pipeline. In that case, you can either check the parent kind

// of the method, or use helpers like isObjectLiteralMethodDeclaration

// @kind(SyntaxKind.MethodDeclaration)

export interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {

name: PropertyName;

body?: FunctionBody;

}

// @kind(SyntaxKind.Constructor)

export interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {

body?: FunctionBody;

}

// For when we encounter a semicolon in a class declaration. ES6 allows these as class elements.

// @kind(SyntaxKind.SemicolonClassElement)

export interface SemicolonClassElement extends ClassElement {

_semicolonClassElementBrand: any;

}

// See the comment on MethodDeclaration for the intuition behind AccessorDeclaration being a

// ClassElement and an ObjectLiteralElement.

export interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {

_accessorDeclarationBrand: any;

name: PropertyName;

body: FunctionBody;

}

// @kind(SyntaxKind.GetAccessor)

export interface GetAccessorDeclaration extends AccessorDeclaration { }

// @kind(SyntaxKind.SetAccessor)

export interface SetAccessorDeclaration extends AccessorDeclaration { }

// @kind(SyntaxKind.IndexSignature)

export interface IndexSignatureDeclaration extends SignatureDeclaration, ClassElement, TypeElement {

_indexSignatureDeclarationBrand: any;

}

// @kind(SyntaxKind.AnyKeyword)

// @kind(SyntaxKind.NumberKeyword)

// @kind(SyntaxKind.BooleanKeyword)

// @kind(SyntaxKind.StringKeyword)

// @kind(SyntaxKind.SymbolKeyword)

// @kind(SyntaxKind.VoidKeyword)

export interface TypeNode extends Node {

_typeNodeBrand: any;

}

// @kind(SyntaxKind.ThisType)

export interface ThisTypeNode extends TypeNode {

_thisTypeNodeBrand: any;

}

export interface FunctionOrConstructorTypeNode extends TypeNode, SignatureDeclaration {

_functionOrConstructorTypeNodeBrand: any;

}

// @kind(SyntaxKind.FunctionType)

export interface FunctionTypeNode extends FunctionOrConstructorTypeNode { }

// @kind(SyntaxKind.ConstructorType)

export interface ConstructorTypeNode extends FunctionOrConstructorTypeNode { }

// @kind(SyntaxKind.TypeReference)

export interface TypeReferenceNode extends TypeNode {

typeName: EntityName;

typeArguments?: NodeArray<TypeNode>;

}

// @kind(SyntaxKind.TypePredicate)

export interface TypePredicateNode extends TypeNode {

parameterName: Identifier | ThisTypeNode;

type: TypeNode;

}

// @kind(SyntaxKind.TypeQuery)

export interface TypeQueryNode extends TypeNode {

exprName: EntityName;

}

// A TypeLiteral is the declaration node for an anonymous symbol.

// @kind(SyntaxKind.TypeLiteral)

export interface TypeLiteralNode extends TypeNode, Declaration {

members: NodeArray<TypeElement>;

}

// @kind(SyntaxKind.ArrayType)

export interface ArrayTypeNode extends TypeNode {

elementType: TypeNode;

}

// @kind(SyntaxKind.TupleType)

export interface TupleTypeNode extends TypeNode {

elementTypes: NodeArray<TypeNode>;

}

export interface UnionOrIntersectionTypeNode extends TypeNode {

types: NodeArray<TypeNode>;

}

// @kind(SyntaxKind.UnionType)

export interface UnionTypeNode extends UnionOrIntersectionTypeNode { }

// @kind(SyntaxKind.IntersectionType)

export interface IntersectionTypeNode extends UnionOrIntersectionTypeNode { }

// @kind(SyntaxKind.ParenthesizedType)

export interface ParenthesizedTypeNode extends TypeNode {

type: TypeNode;

}

// @kind(SyntaxKind.StringLiteralType)

export interface StringLiteralTypeNode extends LiteralLikeNode, TypeNode {

_stringLiteralTypeBrand: any;

}

// @kind(SyntaxKind.StringLiteral)

export interface StringLiteral extends LiteralExpression {

_stringLiteralBrand: any;

}

// Note: 'brands' in our syntax nodes serve to give us a small amount of nominal typing.

// Consider 'Expression'. Without the brand, 'Expression' is actually no different

// (structurally) than 'Node'. Because of this you can pass any Node to a function that

// takes an Expression without any error. By using the 'brands' we ensure that the type

// checker actually thinks you have something of the right type. Note: the brands are

// never actually given values. At runtime they have zero cost.

export interface Expression extends Node {

_expressionBrand: any;

contextualType?: Type; // Used to temporarily assign a contextual type during overload resolution

}

// @kind(SyntaxKind.OmittedExpression)

export interface OmittedExpression extends Expression { }

export interface UnaryExpression extends Expression {

_unaryExpressionBrand: any;

}

export interface IncrementExpression extends UnaryExpression {

_incrementExpressionBrand: any;

}

// @kind(SyntaxKind.PrefixUnaryExpression)

export interface PrefixUnaryExpression extends IncrementExpression {

operator: SyntaxKind;

operand: UnaryExpression;

}

// @kind(SyntaxKind.PostfixUnaryExpression)

export interface PostfixUnaryExpression extends IncrementExpression {

operand: LeftHandSideExpression;

operator: SyntaxKind;

}

export interface PostfixExpression extends UnaryExpression {

_postfixExpressionBrand: any;

}

export interface LeftHandSideExpression extends IncrementExpression {

_leftHandSideExpressionBrand: any;

}

export interface MemberExpression extends LeftHandSideExpression {

_memberExpressionBrand: any;

}

// @kind(SyntaxKind.TrueKeyword)

// @kind(SyntaxKind.FalseKeyword)

// @kind(SyntaxKind.NullKeyword)

// @kind(SyntaxKind.ThisKeyword)

// @kind(SyntaxKind.SuperKeyword)

export interface PrimaryExpression extends MemberExpression {

_primaryExpressionBrand: any;

}

// @kind(SyntaxKind.DeleteExpression)

export interface DeleteExpression extends UnaryExpression {

expression: UnaryExpression;

}

// @kind(SyntaxKind.TypeOfExpression)

export interface TypeOfExpression extends UnaryExpression {

expression: UnaryExpression;

}

// @kind(SyntaxKind.VoidExpression)

export interface VoidExpression extends UnaryExpression {

expression: UnaryExpression;

}

// @kind(SyntaxKind.AwaitExpression)

export interface AwaitExpression extends UnaryExpression {

expression: UnaryExpression;

}

// @kind(SyntaxKind.YieldExpression)

export interface YieldExpression extends Expression {

asteriskToken?: Node;

expression?: Expression;

}

// @kind(SyntaxKind.BinaryExpression)

// Binary expressions can be declarations if they are 'exports.foo = bar' expressions in JS files

export interface BinaryExpression extends Expression, Declaration {

left: Expression;

operatorToken: Node;

right: Expression;

}

// @kind(SyntaxKind.ConditionalExpression)

export interface ConditionalExpression extends Expression {

condition: Expression;

questionToken: Node;

whenTrue: Expression;

colonToken: Node;

whenFalse: Expression;

}

export type FunctionBody = Block;

export type ConciseBody = FunctionBody | Expression;

// @kind(SyntaxKind.FunctionExpression)

export interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclaration {

name?: Identifier;

body: FunctionBody; // Required, whereas the member inherited from FunctionDeclaration is optional

}

// @kind(SyntaxKind.ArrowFunction)

export interface ArrowFunction extends Expression, FunctionLikeDeclaration {

equalsGreaterThanToken: Node;

body: ConciseBody;

}

export interface LiteralLikeNode extends Node {

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,

// or any literal of a template, this means quotes have been removed and escapes have been converted to actual characters.

// For a NumericLiteral, the stored value is the toString() representation of the number. For example 1, 1.00, and 1e0 are all stored as just "1".

// @kind(SyntaxKind.NumericLiteral)

// @kind(SyntaxKind.RegularExpressionLiteral)

// @kind(SyntaxKind.NoSubstitutionTemplateLiteral)

export interface LiteralExpression extends LiteralLikeNode, PrimaryExpression {

_literalExpressionBrand: any;

}

// @kind(SyntaxKind.TemplateHead)

// @kind(SyntaxKind.TemplateMiddle)

// @kind(SyntaxKind.TemplateTail)

export interface TemplateLiteralFragment extends LiteralLikeNode {

_templateLiteralFragmentBrand: any;

}

// @kind(SyntaxKind.TemplateExpression)

export interface TemplateExpression extends PrimaryExpression {

head: TemplateLiteralFragment;

templateSpans: NodeArray<TemplateSpan>;

}

// Each of these corresponds to a substitution expression and a template literal, in that order.

// The template literal must have kind TemplateMiddleLiteral or TemplateTailLiteral.

// @kind(SyntaxKind.TemplateSpan)

export interface TemplateSpan extends Node {

expression: Expression;

literal: TemplateLiteralFragment;

}

// @kind(SyntaxKind.ParenthesizedExpression)

export interface ParenthesizedExpression extends PrimaryExpression {

expression: Expression;

}

// @kind(SyntaxKind.ArrayLiteralExpression)

export interface ArrayLiteralExpression extends PrimaryExpression {

elements: NodeArray<Expression>;

/* @internal */

multiLine?: boolean;

}

// @kind(SyntaxKind.SpreadElementExpression)

export interface SpreadElementExpression extends Expression {

expression: Expression;

}

// An ObjectLiteralExpression is the declaration node for an anonymous symbol.

// @kind(SyntaxKind.ObjectLiteralExpression)

export interface ObjectLiteralExpression extends PrimaryExpression, Declaration {

properties: NodeArray<ObjectLiteralElement>;

/* @internal */

multiLine?: boolean;

}

// @kind(SyntaxKind.PropertyAccessExpression)

export interface PropertyAccessExpression extends MemberExpression, Declaration {

expression: LeftHandSideExpression;

dotToken: Node;

name: Identifier;

}

export type IdentifierOrPropertyAccess = Identifier | PropertyAccessExpression;

// @kind(SyntaxKind.ElementAccessExpression)

export interface ElementAccessExpression extends MemberExpression {

expression: LeftHandSideExpression;

argumentExpression?: Expression;

}

// @kind(SyntaxKind.CallExpression)

export interface CallExpression extends LeftHandSideExpression, Declaration {

expression: LeftHandSideExpression;

typeArguments?: NodeArray<TypeNode>;

arguments: NodeArray<Expression>;

}

// @kind(SyntaxKind.ExpressionWithTypeArguments)

export interface ExpressionWithTypeArguments extends TypeNode {

expression: LeftHandSideExpression;

typeArguments?: NodeArray<TypeNode>;

}

// @kind(SyntaxKind.NewExpression)

export interface NewExpression extends CallExpression, PrimaryExpression { }