3134 lines
124 KiB
TypeScript
3134 lines
124 KiB
TypeScript
/*! *****************************************************************************
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
|
this file except in compliance with the License. You may obtain a copy of the
|
|
License at http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
|
|
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
|
|
MERCHANTABLITY OR NON-INFRINGEMENT.
|
|
|
|
See the Apache Version 2.0 License for specific language governing permissions
|
|
and limitations under the License.
|
|
***************************************************************************** */
|
|
|
|
declare namespace ts {
|
|
interface MapLike<T> {
|
|
[index: string]: T;
|
|
}
|
|
interface Map<T> extends MapLike<T> {
|
|
__mapBrand: any;
|
|
}
|
|
type Path = string & {
|
|
__pathBrand: any;
|
|
};
|
|
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;
|
|
getKeys(): Path[];
|
|
clear(): void;
|
|
}
|
|
interface TextRange {
|
|
pos: number;
|
|
end: number;
|
|
}
|
|
enum SyntaxKind {
|
|
Unknown = 0,
|
|
EndOfFileToken = 1,
|
|
SingleLineCommentTrivia = 2,
|
|
MultiLineCommentTrivia = 3,
|
|
NewLineTrivia = 4,
|
|
WhitespaceTrivia = 5,
|
|
ShebangTrivia = 6,
|
|
ConflictMarkerTrivia = 7,
|
|
NumericLiteral = 8,
|
|
StringLiteral = 9,
|
|
JsxText = 10,
|
|
RegularExpressionLiteral = 11,
|
|
NoSubstitutionTemplateLiteral = 12,
|
|
TemplateHead = 13,
|
|
TemplateMiddle = 14,
|
|
TemplateTail = 15,
|
|
OpenBraceToken = 16,
|
|
CloseBraceToken = 17,
|
|
OpenParenToken = 18,
|
|
CloseParenToken = 19,
|
|
OpenBracketToken = 20,
|
|
CloseBracketToken = 21,
|
|
DotToken = 22,
|
|
DotDotDotToken = 23,
|
|
SemicolonToken = 24,
|
|
CommaToken = 25,
|
|
LessThanToken = 26,
|
|
LessThanSlashToken = 27,
|
|
GreaterThanToken = 28,
|
|
LessThanEqualsToken = 29,
|
|
GreaterThanEqualsToken = 30,
|
|
EqualsEqualsToken = 31,
|
|
ExclamationEqualsToken = 32,
|
|
EqualsEqualsEqualsToken = 33,
|
|
ExclamationEqualsEqualsToken = 34,
|
|
EqualsGreaterThanToken = 35,
|
|
PlusToken = 36,
|
|
MinusToken = 37,
|
|
AsteriskToken = 38,
|
|
AsteriskAsteriskToken = 39,
|
|
SlashToken = 40,
|
|
PercentToken = 41,
|
|
PlusPlusToken = 42,
|
|
MinusMinusToken = 43,
|
|
LessThanLessThanToken = 44,
|
|
GreaterThanGreaterThanToken = 45,
|
|
GreaterThanGreaterThanGreaterThanToken = 46,
|
|
AmpersandToken = 47,
|
|
BarToken = 48,
|
|
CaretToken = 49,
|
|
ExclamationToken = 50,
|
|
TildeToken = 51,
|
|
AmpersandAmpersandToken = 52,
|
|
BarBarToken = 53,
|
|
QuestionToken = 54,
|
|
ColonToken = 55,
|
|
AtToken = 56,
|
|
EqualsToken = 57,
|
|
PlusEqualsToken = 58,
|
|
MinusEqualsToken = 59,
|
|
AsteriskEqualsToken = 60,
|
|
AsteriskAsteriskEqualsToken = 61,
|
|
SlashEqualsToken = 62,
|
|
PercentEqualsToken = 63,
|
|
LessThanLessThanEqualsToken = 64,
|
|
GreaterThanGreaterThanEqualsToken = 65,
|
|
GreaterThanGreaterThanGreaterThanEqualsToken = 66,
|
|
AmpersandEqualsToken = 67,
|
|
BarEqualsToken = 68,
|
|
CaretEqualsToken = 69,
|
|
Identifier = 70,
|
|
BreakKeyword = 71,
|
|
CaseKeyword = 72,
|
|
CatchKeyword = 73,
|
|
ClassKeyword = 74,
|
|
ConstKeyword = 75,
|
|
ContinueKeyword = 76,
|
|
DebuggerKeyword = 77,
|
|
DefaultKeyword = 78,
|
|
DeleteKeyword = 79,
|
|
DoKeyword = 80,
|
|
ElseKeyword = 81,
|
|
EnumKeyword = 82,
|
|
ExportKeyword = 83,
|
|
ExtendsKeyword = 84,
|
|
FalseKeyword = 85,
|
|
FinallyKeyword = 86,
|
|
ForKeyword = 87,
|
|
FunctionKeyword = 88,
|
|
IfKeyword = 89,
|
|
ImportKeyword = 90,
|
|
InKeyword = 91,
|
|
InstanceOfKeyword = 92,
|
|
NewKeyword = 93,
|
|
NullKeyword = 94,
|
|
ReturnKeyword = 95,
|
|
SuperKeyword = 96,
|
|
SwitchKeyword = 97,
|
|
ThisKeyword = 98,
|
|
ThrowKeyword = 99,
|
|
TrueKeyword = 100,
|
|
TryKeyword = 101,
|
|
TypeOfKeyword = 102,
|
|
VarKeyword = 103,
|
|
VoidKeyword = 104,
|
|
WhileKeyword = 105,
|
|
WithKeyword = 106,
|
|
ImplementsKeyword = 107,
|
|
InterfaceKeyword = 108,
|
|
LetKeyword = 109,
|
|
PackageKeyword = 110,
|
|
PrivateKeyword = 111,
|
|
ProtectedKeyword = 112,
|
|
PublicKeyword = 113,
|
|
StaticKeyword = 114,
|
|
YieldKeyword = 115,
|
|
AbstractKeyword = 116,
|
|
AsKeyword = 117,
|
|
AnyKeyword = 118,
|
|
AsyncKeyword = 119,
|
|
AwaitKeyword = 120,
|
|
BooleanKeyword = 121,
|
|
ConstructorKeyword = 122,
|
|
DeclareKeyword = 123,
|
|
GetKeyword = 124,
|
|
IsKeyword = 125,
|
|
KeyOfKeyword = 126,
|
|
ModuleKeyword = 127,
|
|
NamespaceKeyword = 128,
|
|
NeverKeyword = 129,
|
|
ReadonlyKeyword = 130,
|
|
RequireKeyword = 131,
|
|
NumberKeyword = 132,
|
|
SetKeyword = 133,
|
|
StringKeyword = 134,
|
|
SymbolKeyword = 135,
|
|
TypeKeyword = 136,
|
|
UndefinedKeyword = 137,
|
|
FromKeyword = 138,
|
|
GlobalKeyword = 139,
|
|
OfKeyword = 140,
|
|
QualifiedName = 141,
|
|
ComputedPropertyName = 142,
|
|
TypeParameter = 143,
|
|
Parameter = 144,
|
|
Decorator = 145,
|
|
PropertySignature = 146,
|
|
PropertyDeclaration = 147,
|
|
MethodSignature = 148,
|
|
MethodDeclaration = 149,
|
|
Constructor = 150,
|
|
GetAccessor = 151,
|
|
SetAccessor = 152,
|
|
CallSignature = 153,
|
|
ConstructSignature = 154,
|
|
IndexSignature = 155,
|
|
TypePredicate = 156,
|
|
TypeReference = 157,
|
|
FunctionType = 158,
|
|
ConstructorType = 159,
|
|
TypeQuery = 160,
|
|
TypeLiteral = 161,
|
|
ArrayType = 162,
|
|
TupleType = 163,
|
|
UnionType = 164,
|
|
IntersectionType = 165,
|
|
ParenthesizedType = 166,
|
|
ThisType = 167,
|
|
TypeOperator = 168,
|
|
IndexedAccessType = 169,
|
|
MappedType = 170,
|
|
LiteralType = 171,
|
|
ObjectBindingPattern = 172,
|
|
ArrayBindingPattern = 173,
|
|
BindingElement = 174,
|
|
ArrayLiteralExpression = 175,
|
|
ObjectLiteralExpression = 176,
|
|
PropertyAccessExpression = 177,
|
|
ElementAccessExpression = 178,
|
|
CallExpression = 179,
|
|
NewExpression = 180,
|
|
TaggedTemplateExpression = 181,
|
|
TypeAssertionExpression = 182,
|
|
ParenthesizedExpression = 183,
|
|
FunctionExpression = 184,
|
|
ArrowFunction = 185,
|
|
DeleteExpression = 186,
|
|
TypeOfExpression = 187,
|
|
VoidExpression = 188,
|
|
AwaitExpression = 189,
|
|
PrefixUnaryExpression = 190,
|
|
PostfixUnaryExpression = 191,
|
|
BinaryExpression = 192,
|
|
ConditionalExpression = 193,
|
|
TemplateExpression = 194,
|
|
YieldExpression = 195,
|
|
SpreadElement = 196,
|
|
ClassExpression = 197,
|
|
OmittedExpression = 198,
|
|
ExpressionWithTypeArguments = 199,
|
|
AsExpression = 200,
|
|
NonNullExpression = 201,
|
|
TemplateSpan = 202,
|
|
SemicolonClassElement = 203,
|
|
Block = 204,
|
|
VariableStatement = 205,
|
|
EmptyStatement = 206,
|
|
ExpressionStatement = 207,
|
|
IfStatement = 208,
|
|
DoStatement = 209,
|
|
WhileStatement = 210,
|
|
ForStatement = 211,
|
|
ForInStatement = 212,
|
|
ForOfStatement = 213,
|
|
ContinueStatement = 214,
|
|
BreakStatement = 215,
|
|
ReturnStatement = 216,
|
|
WithStatement = 217,
|
|
SwitchStatement = 218,
|
|
LabeledStatement = 219,
|
|
ThrowStatement = 220,
|
|
TryStatement = 221,
|
|
DebuggerStatement = 222,
|
|
VariableDeclaration = 223,
|
|
VariableDeclarationList = 224,
|
|
FunctionDeclaration = 225,
|
|
ClassDeclaration = 226,
|
|
InterfaceDeclaration = 227,
|
|
TypeAliasDeclaration = 228,
|
|
EnumDeclaration = 229,
|
|
ModuleDeclaration = 230,
|
|
ModuleBlock = 231,
|
|
CaseBlock = 232,
|
|
NamespaceExportDeclaration = 233,
|
|
ImportEqualsDeclaration = 234,
|
|
ImportDeclaration = 235,
|
|
ImportClause = 236,
|
|
NamespaceImport = 237,
|
|
NamedImports = 238,
|
|
ImportSpecifier = 239,
|
|
ExportAssignment = 240,
|
|
ExportDeclaration = 241,
|
|
NamedExports = 242,
|
|
ExportSpecifier = 243,
|
|
MissingDeclaration = 244,
|
|
ExternalModuleReference = 245,
|
|
JsxElement = 246,
|
|
JsxSelfClosingElement = 247,
|
|
JsxOpeningElement = 248,
|
|
JsxClosingElement = 249,
|
|
JsxAttribute = 250,
|
|
JsxSpreadAttribute = 251,
|
|
JsxExpression = 252,
|
|
CaseClause = 253,
|
|
DefaultClause = 254,
|
|
HeritageClause = 255,
|
|
CatchClause = 256,
|
|
PropertyAssignment = 257,
|
|
ShorthandPropertyAssignment = 258,
|
|
SpreadAssignment = 259,
|
|
EnumMember = 260,
|
|
SourceFile = 261,
|
|
JSDocTypeExpression = 262,
|
|
JSDocAllType = 263,
|
|
JSDocUnknownType = 264,
|
|
JSDocArrayType = 265,
|
|
JSDocUnionType = 266,
|
|
JSDocTupleType = 267,
|
|
JSDocNullableType = 268,
|
|
JSDocNonNullableType = 269,
|
|
JSDocRecordType = 270,
|
|
JSDocRecordMember = 271,
|
|
JSDocTypeReference = 272,
|
|
JSDocOptionalType = 273,
|
|
JSDocFunctionType = 274,
|
|
JSDocVariadicType = 275,
|
|
JSDocConstructorType = 276,
|
|
JSDocThisType = 277,
|
|
JSDocComment = 278,
|
|
JSDocTag = 279,
|
|
JSDocAugmentsTag = 280,
|
|
JSDocParameterTag = 281,
|
|
JSDocReturnTag = 282,
|
|
JSDocTypeTag = 283,
|
|
JSDocTemplateTag = 284,
|
|
JSDocTypedefTag = 285,
|
|
JSDocPropertyTag = 286,
|
|
JSDocTypeLiteral = 287,
|
|
JSDocLiteralType = 288,
|
|
JSDocNullKeyword = 289,
|
|
JSDocUndefinedKeyword = 290,
|
|
JSDocNeverKeyword = 291,
|
|
SyntaxList = 292,
|
|
NotEmittedStatement = 293,
|
|
PartiallyEmittedExpression = 294,
|
|
MergeDeclarationMarker = 295,
|
|
EndOfDeclarationMarker = 296,
|
|
RawExpression = 297,
|
|
Count = 298,
|
|
FirstAssignment = 57,
|
|
LastAssignment = 69,
|
|
FirstCompoundAssignment = 58,
|
|
LastCompoundAssignment = 69,
|
|
FirstReservedWord = 71,
|
|
LastReservedWord = 106,
|
|
FirstKeyword = 71,
|
|
LastKeyword = 140,
|
|
FirstFutureReservedWord = 107,
|
|
LastFutureReservedWord = 115,
|
|
FirstTypeNode = 156,
|
|
LastTypeNode = 171,
|
|
FirstPunctuation = 16,
|
|
LastPunctuation = 69,
|
|
FirstToken = 0,
|
|
LastToken = 140,
|
|
FirstTriviaToken = 2,
|
|
LastTriviaToken = 7,
|
|
FirstLiteralToken = 8,
|
|
LastLiteralToken = 12,
|
|
FirstTemplateToken = 12,
|
|
LastTemplateToken = 15,
|
|
FirstBinaryOperator = 26,
|
|
LastBinaryOperator = 69,
|
|
FirstNode = 141,
|
|
FirstJSDocNode = 262,
|
|
LastJSDocNode = 288,
|
|
FirstJSDocTagNode = 278,
|
|
LastJSDocTagNode = 291,
|
|
}
|
|
enum NodeFlags {
|
|
None = 0,
|
|
Let = 1,
|
|
Const = 2,
|
|
NestedNamespace = 4,
|
|
Synthesized = 8,
|
|
Namespace = 16,
|
|
ExportContext = 32,
|
|
ContainsThis = 64,
|
|
HasImplicitReturn = 128,
|
|
HasExplicitReturn = 256,
|
|
GlobalAugmentation = 512,
|
|
HasAsyncFunctions = 1024,
|
|
DisallowInContext = 2048,
|
|
YieldContext = 4096,
|
|
DecoratorContext = 8192,
|
|
AwaitContext = 16384,
|
|
ThisNodeHasError = 32768,
|
|
JavaScriptFile = 65536,
|
|
ThisNodeOrAnySubNodesHasError = 131072,
|
|
HasAggregatedChildData = 262144,
|
|
BlockScoped = 3,
|
|
ReachabilityCheckFlags = 384,
|
|
ReachabilityAndEmitFlags = 1408,
|
|
ContextFlags = 96256,
|
|
TypeExcludesFlags = 20480,
|
|
}
|
|
enum ModifierFlags {
|
|
None = 0,
|
|
Export = 1,
|
|
Ambient = 2,
|
|
Public = 4,
|
|
Private = 8,
|
|
Protected = 16,
|
|
Static = 32,
|
|
Readonly = 64,
|
|
Abstract = 128,
|
|
Async = 256,
|
|
Default = 512,
|
|
Const = 2048,
|
|
HasComputedFlags = 536870912,
|
|
AccessibilityModifier = 28,
|
|
ParameterPropertyModifier = 92,
|
|
NonPublicAccessibilityModifier = 24,
|
|
TypeScriptModifier = 2270,
|
|
ExportDefault = 513,
|
|
}
|
|
enum JsxFlags {
|
|
None = 0,
|
|
/** An element from a named property of the JSX.IntrinsicElements interface */
|
|
IntrinsicNamedElement = 1,
|
|
/** An element inferred from the string index signature of the JSX.IntrinsicElements interface */
|
|
IntrinsicIndexedElement = 2,
|
|
IntrinsicElement = 3,
|
|
}
|
|
interface Node extends TextRange {
|
|
kind: SyntaxKind;
|
|
flags: NodeFlags;
|
|
decorators?: NodeArray<Decorator>;
|
|
modifiers?: ModifiersArray;
|
|
parent?: Node;
|
|
}
|
|
interface NodeArray<T extends Node> extends Array<T>, TextRange {
|
|
hasTrailingComma?: boolean;
|
|
}
|
|
interface Token<TKind extends SyntaxKind> extends Node {
|
|
kind: TKind;
|
|
}
|
|
type DotDotDotToken = Token<SyntaxKind.DotDotDotToken>;
|
|
type QuestionToken = Token<SyntaxKind.QuestionToken>;
|
|
type ColonToken = Token<SyntaxKind.ColonToken>;
|
|
type EqualsToken = Token<SyntaxKind.EqualsToken>;
|
|
type AsteriskToken = Token<SyntaxKind.AsteriskToken>;
|
|
type EqualsGreaterThanToken = Token<SyntaxKind.EqualsGreaterThanToken>;
|
|
type EndOfFileToken = Token<SyntaxKind.EndOfFileToken>;
|
|
type AtToken = Token<SyntaxKind.AtToken>;
|
|
type ReadonlyToken = Token<SyntaxKind.ReadonlyKeyword>;
|
|
type Modifier = Token<SyntaxKind.AbstractKeyword> | Token<SyntaxKind.AsyncKeyword> | Token<SyntaxKind.ConstKeyword> | Token<SyntaxKind.DeclareKeyword> | Token<SyntaxKind.DefaultKeyword> | Token<SyntaxKind.ExportKeyword> | Token<SyntaxKind.PublicKeyword> | Token<SyntaxKind.PrivateKeyword> | Token<SyntaxKind.ProtectedKeyword> | Token<SyntaxKind.ReadonlyKeyword> | Token<SyntaxKind.StaticKeyword>;
|
|
type ModifiersArray = NodeArray<Modifier>;
|
|
interface Identifier extends PrimaryExpression {
|
|
kind: SyntaxKind.Identifier;
|
|
text: string;
|
|
originalKeywordKind?: SyntaxKind;
|
|
isInJSDocNamespace?: boolean;
|
|
}
|
|
interface TransientIdentifier extends Identifier {
|
|
resolvedSymbol: Symbol;
|
|
}
|
|
interface QualifiedName extends Node {
|
|
kind: SyntaxKind.QualifiedName;
|
|
left: EntityName;
|
|
right: Identifier;
|
|
}
|
|
type EntityName = Identifier | QualifiedName;
|
|
type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName;
|
|
type DeclarationName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | BindingPattern;
|
|
interface Declaration extends Node {
|
|
_declarationBrand: any;
|
|
name?: DeclarationName;
|
|
}
|
|
interface DeclarationStatement extends Declaration, Statement {
|
|
name?: Identifier | StringLiteral | NumericLiteral;
|
|
}
|
|
interface ComputedPropertyName extends Node {
|
|
kind: SyntaxKind.ComputedPropertyName;
|
|
expression: Expression;
|
|
}
|
|
interface Decorator extends Node {
|
|
kind: SyntaxKind.Decorator;
|
|
expression: LeftHandSideExpression;
|
|
}
|
|
interface TypeParameterDeclaration extends Declaration {
|
|
kind: SyntaxKind.TypeParameter;
|
|
name: Identifier;
|
|
constraint?: TypeNode;
|
|
expression?: Expression;
|
|
}
|
|
interface SignatureDeclaration extends Declaration {
|
|
name?: PropertyName;
|
|
typeParameters?: NodeArray<TypeParameterDeclaration>;
|
|
parameters: NodeArray<ParameterDeclaration>;
|
|
type?: TypeNode;
|
|
}
|
|
interface CallSignatureDeclaration extends SignatureDeclaration, TypeElement {
|
|
kind: SyntaxKind.CallSignature;
|
|
}
|
|
interface ConstructSignatureDeclaration extends SignatureDeclaration, TypeElement {
|
|
kind: SyntaxKind.ConstructSignature;
|
|
}
|
|
type BindingName = Identifier | BindingPattern;
|
|
interface VariableDeclaration extends Declaration {
|
|
kind: SyntaxKind.VariableDeclaration;
|
|
parent?: VariableDeclarationList;
|
|
name: BindingName;
|
|
type?: TypeNode;
|
|
initializer?: Expression;
|
|
}
|
|
interface VariableDeclarationList extends Node {
|
|
kind: SyntaxKind.VariableDeclarationList;
|
|
declarations: NodeArray<VariableDeclaration>;
|
|
}
|
|
interface ParameterDeclaration extends Declaration {
|
|
kind: SyntaxKind.Parameter;
|
|
dotDotDotToken?: DotDotDotToken;
|
|
name: BindingName;
|
|
questionToken?: QuestionToken;
|
|
type?: TypeNode;
|
|
initializer?: Expression;
|
|
}
|
|
interface BindingElement extends Declaration {
|
|
kind: SyntaxKind.BindingElement;
|
|
propertyName?: PropertyName;
|
|
dotDotDotToken?: DotDotDotToken;
|
|
name: BindingName;
|
|
initializer?: Expression;
|
|
}
|
|
interface PropertySignature extends TypeElement {
|
|
kind: SyntaxKind.PropertySignature | SyntaxKind.JSDocRecordMember;
|
|
name: PropertyName;
|
|
questionToken?: QuestionToken;
|
|
type?: TypeNode;
|
|
initializer?: Expression;
|
|
}
|
|
interface PropertyDeclaration extends ClassElement {
|
|
kind: SyntaxKind.PropertyDeclaration;
|
|
questionToken?: QuestionToken;
|
|
name: PropertyName;
|
|
type?: TypeNode;
|
|
initializer?: Expression;
|
|
}
|
|
interface ObjectLiteralElement extends Declaration {
|
|
_objectLiteralBrandBrand: any;
|
|
name?: PropertyName;
|
|
}
|
|
type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | MethodDeclaration | AccessorDeclaration | SpreadAssignment;
|
|
interface PropertyAssignment extends ObjectLiteralElement {
|
|
kind: SyntaxKind.PropertyAssignment;
|
|
name: PropertyName;
|
|
questionToken?: QuestionToken;
|
|
initializer: Expression;
|
|
}
|
|
interface ShorthandPropertyAssignment extends ObjectLiteralElement {
|
|
kind: SyntaxKind.ShorthandPropertyAssignment;
|
|
name: Identifier;
|
|
questionToken?: QuestionToken;
|
|
equalsToken?: Token<SyntaxKind.EqualsToken>;
|
|
objectAssignmentInitializer?: Expression;
|
|
}
|
|
interface SpreadAssignment extends ObjectLiteralElement {
|
|
kind: SyntaxKind.SpreadAssignment;
|
|
expression: Expression;
|
|
}
|
|
interface VariableLikeDeclaration extends Declaration {
|
|
propertyName?: PropertyName;
|
|
dotDotDotToken?: DotDotDotToken;
|
|
name: DeclarationName;
|
|
questionToken?: QuestionToken;
|
|
type?: TypeNode;
|
|
initializer?: Expression;
|
|
}
|
|
interface PropertyLikeDeclaration extends Declaration {
|
|
name: PropertyName;
|
|
}
|
|
interface ObjectBindingPattern extends Node {
|
|
kind: SyntaxKind.ObjectBindingPattern;
|
|
elements: NodeArray<BindingElement>;
|
|
}
|
|
interface ArrayBindingPattern extends Node {
|
|
kind: SyntaxKind.ArrayBindingPattern;
|
|
elements: NodeArray<ArrayBindingElement>;
|
|
}
|
|
type BindingPattern = ObjectBindingPattern | ArrayBindingPattern;
|
|
type ArrayBindingElement = BindingElement | OmittedExpression;
|
|
/**
|
|
* 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
|
|
*/
|
|
interface FunctionLikeDeclaration extends SignatureDeclaration {
|
|
_functionLikeDeclarationBrand: any;
|
|
asteriskToken?: AsteriskToken;
|
|
questionToken?: QuestionToken;
|
|
body?: Block | Expression;
|
|
}
|
|
interface FunctionDeclaration extends FunctionLikeDeclaration, DeclarationStatement {
|
|
kind: SyntaxKind.FunctionDeclaration;
|
|
name?: Identifier;
|
|
body?: FunctionBody;
|
|
}
|
|
interface MethodSignature extends SignatureDeclaration, TypeElement {
|
|
kind: SyntaxKind.MethodSignature;
|
|
name: PropertyName;
|
|
}
|
|
interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
|
|
kind: SyntaxKind.MethodDeclaration;
|
|
name: PropertyName;
|
|
body?: FunctionBody;
|
|
}
|
|
interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {
|
|
kind: SyntaxKind.Constructor;
|
|
body?: FunctionBody;
|
|
}
|
|
interface SemicolonClassElement extends ClassElement {
|
|
kind: SyntaxKind.SemicolonClassElement;
|
|
}
|
|
interface GetAccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
|
|
kind: SyntaxKind.GetAccessor;
|
|
name: PropertyName;
|
|
body: FunctionBody;
|
|
}
|
|
interface SetAccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
|
|
kind: SyntaxKind.SetAccessor;
|
|
name: PropertyName;
|
|
body: FunctionBody;
|
|
}
|
|
type AccessorDeclaration = GetAccessorDeclaration | SetAccessorDeclaration;
|
|
interface IndexSignatureDeclaration extends SignatureDeclaration, ClassElement, TypeElement {
|
|
kind: SyntaxKind.IndexSignature;
|
|
}
|
|
interface TypeNode extends Node {
|
|
_typeNodeBrand: any;
|
|
}
|
|
interface KeywordTypeNode extends TypeNode {
|
|
kind: SyntaxKind.AnyKeyword | SyntaxKind.NumberKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.VoidKeyword;
|
|
}
|
|
interface ThisTypeNode extends TypeNode {
|
|
kind: SyntaxKind.ThisType;
|
|
}
|
|
interface FunctionOrConstructorTypeNode extends TypeNode, SignatureDeclaration {
|
|
kind: SyntaxKind.FunctionType | SyntaxKind.ConstructorType;
|
|
}
|
|
interface FunctionTypeNode extends FunctionOrConstructorTypeNode {
|
|
kind: SyntaxKind.FunctionType;
|
|
}
|
|
interface ConstructorTypeNode extends FunctionOrConstructorTypeNode {
|
|
kind: SyntaxKind.ConstructorType;
|
|
}
|
|
interface TypeReferenceNode extends TypeNode {
|
|
kind: SyntaxKind.TypeReference;
|
|
typeName: EntityName;
|
|
typeArguments?: NodeArray<TypeNode>;
|
|
}
|
|
interface TypePredicateNode extends TypeNode {
|
|
kind: SyntaxKind.TypePredicate;
|
|
parameterName: Identifier | ThisTypeNode;
|
|
type: TypeNode;
|
|
}
|
|
interface TypeQueryNode extends TypeNode {
|
|
kind: SyntaxKind.TypeQuery;
|
|
exprName: EntityName;
|
|
}
|
|
interface TypeLiteralNode extends TypeNode, Declaration {
|
|
kind: SyntaxKind.TypeLiteral;
|
|
members: NodeArray<TypeElement>;
|
|
}
|
|
interface ArrayTypeNode extends TypeNode {
|
|
kind: SyntaxKind.ArrayType;
|
|
elementType: TypeNode;
|
|
}
|
|
interface TupleTypeNode extends TypeNode {
|
|
kind: SyntaxKind.TupleType;
|
|
elementTypes: NodeArray<TypeNode>;
|
|
}
|
|
interface UnionOrIntersectionTypeNode extends TypeNode {
|
|
kind: SyntaxKind.UnionType | SyntaxKind.IntersectionType;
|
|
types: NodeArray<TypeNode>;
|
|
}
|
|
interface UnionTypeNode extends UnionOrIntersectionTypeNode {
|
|
kind: SyntaxKind.UnionType;
|
|
}
|
|
interface IntersectionTypeNode extends UnionOrIntersectionTypeNode {
|
|
kind: SyntaxKind.IntersectionType;
|
|
}
|
|
interface ParenthesizedTypeNode extends TypeNode {
|
|
kind: SyntaxKind.ParenthesizedType;
|
|
type: TypeNode;
|
|
}
|
|
interface TypeOperatorNode extends TypeNode {
|
|
kind: SyntaxKind.TypeOperator;
|
|
operator: SyntaxKind.KeyOfKeyword;
|
|
type: TypeNode;
|
|
}
|
|
interface IndexedAccessTypeNode extends TypeNode {
|
|
kind: SyntaxKind.IndexedAccessType;
|
|
objectType: TypeNode;
|
|
indexType: TypeNode;
|
|
}
|
|
interface MappedTypeNode extends TypeNode, Declaration {
|
|
kind: SyntaxKind.MappedType;
|
|
readonlyToken?: ReadonlyToken;
|
|
typeParameter: TypeParameterDeclaration;
|
|
questionToken?: QuestionToken;
|
|
type?: TypeNode;
|
|
}
|
|
interface LiteralTypeNode extends TypeNode {
|
|
kind: SyntaxKind.LiteralType;
|
|
literal: Expression;
|
|
}
|
|
interface StringLiteral extends LiteralExpression {
|
|
kind: SyntaxKind.StringLiteral;
|
|
}
|
|
interface Expression extends Node {
|
|
_expressionBrand: any;
|
|
contextualType?: Type;
|
|
}
|
|
interface OmittedExpression extends Expression {
|
|
kind: SyntaxKind.OmittedExpression;
|
|
}
|
|
interface UnaryExpression extends Expression {
|
|
_unaryExpressionBrand: any;
|
|
}
|
|
interface IncrementExpression extends UnaryExpression {
|
|
_incrementExpressionBrand: any;
|
|
}
|
|
type PrefixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.TildeToken | SyntaxKind.ExclamationToken;
|
|
interface PrefixUnaryExpression extends IncrementExpression {
|
|
kind: SyntaxKind.PrefixUnaryExpression;
|
|
operator: PrefixUnaryOperator;
|
|
operand: UnaryExpression;
|
|
}
|
|
type PostfixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken;
|
|
interface PostfixUnaryExpression extends IncrementExpression {
|
|
kind: SyntaxKind.PostfixUnaryExpression;
|
|
operand: LeftHandSideExpression;
|
|
operator: PostfixUnaryOperator;
|
|
}
|
|
interface LeftHandSideExpression extends IncrementExpression {
|
|
_leftHandSideExpressionBrand: any;
|
|
}
|
|
interface MemberExpression extends LeftHandSideExpression {
|
|
_memberExpressionBrand: any;
|
|
}
|
|
interface PrimaryExpression extends MemberExpression {
|
|
_primaryExpressionBrand: any;
|
|
}
|
|
interface NullLiteral extends PrimaryExpression {
|
|
kind: SyntaxKind.NullKeyword;
|
|
}
|
|
interface BooleanLiteral extends PrimaryExpression {
|
|
kind: SyntaxKind.TrueKeyword | SyntaxKind.FalseKeyword;
|
|
}
|
|
interface ThisExpression extends PrimaryExpression {
|
|
kind: SyntaxKind.ThisKeyword;
|
|
}
|
|
interface SuperExpression extends PrimaryExpression {
|
|
kind: SyntaxKind.SuperKeyword;
|
|
}
|
|
interface DeleteExpression extends UnaryExpression {
|
|
kind: SyntaxKind.DeleteExpression;
|
|
expression: UnaryExpression;
|
|
}
|
|
interface TypeOfExpression extends UnaryExpression {
|
|
kind: SyntaxKind.TypeOfExpression;
|
|
expression: UnaryExpression;
|
|
}
|
|
interface VoidExpression extends UnaryExpression {
|
|
kind: SyntaxKind.VoidExpression;
|
|
expression: UnaryExpression;
|
|
}
|
|
interface AwaitExpression extends UnaryExpression {
|
|
kind: SyntaxKind.AwaitExpression;
|
|
expression: UnaryExpression;
|
|
}
|
|
interface YieldExpression extends Expression {
|
|
kind: SyntaxKind.YieldExpression;
|
|
asteriskToken?: AsteriskToken;
|
|
expression?: Expression;
|
|
}
|
|
type ExponentiationOperator = SyntaxKind.AsteriskAsteriskToken;
|
|
type MultiplicativeOperator = SyntaxKind.AsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken;
|
|
type MultiplicativeOperatorOrHigher = ExponentiationOperator | MultiplicativeOperator;
|
|
type AdditiveOperator = SyntaxKind.PlusToken | SyntaxKind.MinusToken;
|
|
type AdditiveOperatorOrHigher = MultiplicativeOperatorOrHigher | AdditiveOperator;
|
|
type ShiftOperator = SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken;
|
|
type ShiftOperatorOrHigher = AdditiveOperatorOrHigher | ShiftOperator;
|
|
type RelationalOperator = SyntaxKind.LessThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.InstanceOfKeyword | SyntaxKind.InKeyword;
|
|
type RelationalOperatorOrHigher = ShiftOperatorOrHigher | RelationalOperator;
|
|
type EqualityOperator = SyntaxKind.EqualsEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.ExclamationEqualsToken;
|
|
type EqualityOperatorOrHigher = RelationalOperatorOrHigher | EqualityOperator;
|
|
type BitwiseOperator = SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken;
|
|
type BitwiseOperatorOrHigher = EqualityOperatorOrHigher | BitwiseOperator;
|
|
type LogicalOperator = SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken;
|
|
type LogicalOperatorOrHigher = BitwiseOperatorOrHigher | LogicalOperator;
|
|
type CompoundAssignmentOperator = SyntaxKind.PlusEqualsToken | SyntaxKind.MinusEqualsToken | SyntaxKind.AsteriskAsteriskEqualsToken | SyntaxKind.AsteriskEqualsToken | SyntaxKind.SlashEqualsToken | SyntaxKind.PercentEqualsToken | SyntaxKind.AmpersandEqualsToken | SyntaxKind.BarEqualsToken | SyntaxKind.CaretEqualsToken | SyntaxKind.LessThanLessThanEqualsToken | SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken | SyntaxKind.GreaterThanGreaterThanEqualsToken;
|
|
type AssignmentOperator = SyntaxKind.EqualsToken | CompoundAssignmentOperator;
|
|
type AssignmentOperatorOrHigher = LogicalOperatorOrHigher | AssignmentOperator;
|
|
type BinaryOperator = AssignmentOperatorOrHigher | SyntaxKind.CommaToken;
|
|
type BinaryOperatorToken = Token<BinaryOperator>;
|
|
interface BinaryExpression extends Expression, Declaration {
|
|
kind: SyntaxKind.BinaryExpression;
|
|
left: Expression;
|
|
operatorToken: BinaryOperatorToken;
|
|
right: Expression;
|
|
}
|
|
type AssignmentOperatorToken = Token<AssignmentOperator>;
|
|
interface AssignmentExpression<TOperator extends AssignmentOperatorToken> extends BinaryExpression {
|
|
left: LeftHandSideExpression;
|
|
operatorToken: TOperator;
|
|
}
|
|
interface ObjectDestructuringAssignment extends AssignmentExpression<EqualsToken> {
|
|
left: ObjectLiteralExpression;
|
|
}
|
|
interface ArrayDestructuringAssignment extends AssignmentExpression<EqualsToken> {
|
|
left: ArrayLiteralExpression;
|
|
}
|
|
type DestructuringAssignment = ObjectDestructuringAssignment | ArrayDestructuringAssignment;
|
|
type BindingOrAssignmentElement = VariableDeclaration | ParameterDeclaration | BindingElement | PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment | OmittedExpression | SpreadElement | ArrayLiteralExpression | ObjectLiteralExpression | AssignmentExpression<EqualsToken> | Identifier | PropertyAccessExpression | ElementAccessExpression;
|
|
type BindingOrAssignmentElementRestIndicator = DotDotDotToken | SpreadElement | SpreadAssignment;
|
|
type BindingOrAssignmentElementTarget = BindingOrAssignmentPattern | Expression;
|
|
type ObjectBindingOrAssignmentPattern = ObjectBindingPattern | ObjectLiteralExpression;
|
|
type ArrayBindingOrAssignmentPattern = ArrayBindingPattern | ArrayLiteralExpression;
|
|
type AssignmentPattern = ObjectLiteralExpression | ArrayLiteralExpression;
|
|
type BindingOrAssignmentPattern = ObjectBindingOrAssignmentPattern | ArrayBindingOrAssignmentPattern;
|
|
interface ConditionalExpression extends Expression {
|
|
kind: SyntaxKind.ConditionalExpression;
|
|
condition: Expression;
|
|
questionToken: QuestionToken;
|
|
whenTrue: Expression;
|
|
colonToken: ColonToken;
|
|
whenFalse: Expression;
|
|
}
|
|
type FunctionBody = Block;
|
|
type ConciseBody = FunctionBody | Expression;
|
|
interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclaration {
|
|
kind: SyntaxKind.FunctionExpression;
|
|
name?: Identifier;
|
|
body: FunctionBody;
|
|
}
|
|
interface ArrowFunction extends Expression, FunctionLikeDeclaration {
|
|
kind: SyntaxKind.ArrowFunction;
|
|
equalsGreaterThanToken: EqualsGreaterThanToken;
|
|
body: ConciseBody;
|
|
}
|
|
interface LiteralLikeNode extends Node {
|
|
text: string;
|
|
isUnterminated?: boolean;
|
|
hasExtendedUnicodeEscape?: boolean;
|
|
}
|
|
interface LiteralExpression extends LiteralLikeNode, PrimaryExpression {
|
|
_literalExpressionBrand: any;
|
|
}
|
|
interface RegularExpressionLiteral extends LiteralExpression {
|
|
kind: SyntaxKind.RegularExpressionLiteral;
|
|
}
|
|
interface NoSubstitutionTemplateLiteral extends LiteralExpression {
|
|
kind: SyntaxKind.NoSubstitutionTemplateLiteral;
|
|
}
|
|
interface NumericLiteral extends LiteralExpression {
|
|
kind: SyntaxKind.NumericLiteral;
|
|
trailingComment?: string;
|
|
}
|
|
interface TemplateHead extends LiteralLikeNode {
|
|
kind: SyntaxKind.TemplateHead;
|
|
}
|
|
interface TemplateMiddle extends LiteralLikeNode {
|
|
kind: SyntaxKind.TemplateMiddle;
|
|
}
|
|
interface TemplateTail extends LiteralLikeNode {
|
|
kind: SyntaxKind.TemplateTail;
|
|
}
|
|
type TemplateLiteral = TemplateExpression | NoSubstitutionTemplateLiteral;
|
|
interface TemplateExpression extends PrimaryExpression {
|
|
kind: SyntaxKind.TemplateExpression;
|
|
head: TemplateHead;
|
|
templateSpans: NodeArray<TemplateSpan>;
|
|
}
|
|
interface TemplateSpan extends Node {
|
|
kind: SyntaxKind.TemplateSpan;
|
|
expression: Expression;
|
|
literal: TemplateMiddle | TemplateTail;
|
|
}
|
|
interface ParenthesizedExpression extends PrimaryExpression {
|
|
kind: SyntaxKind.ParenthesizedExpression;
|
|
expression: Expression;
|
|
}
|
|
interface ArrayLiteralExpression extends PrimaryExpression {
|
|
kind: SyntaxKind.ArrayLiteralExpression;
|
|
elements: NodeArray<Expression>;
|
|
}
|
|
interface SpreadElement extends Expression {
|
|
kind: SyntaxKind.SpreadElement;
|
|
expression: Expression;
|
|
}
|
|
/**
|
|
* This interface is a base interface for ObjectLiteralExpression and JSXAttributes to extend from. JSXAttributes is similar to
|
|
* ObjectLiteralExpression in that it contains array of properties; however, JSXAttributes' properties can only be
|
|
* JSXAttribute or JSXSpreadAttribute. ObjectLiteralExpression, on the other hand, can only have properties of type
|
|
* ObjectLiteralElement (e.g. PropertyAssignment, ShorthandPropertyAssignment etc.)
|
|
**/
|
|
interface ObjectLiteralExpressionBase<T extends ObjectLiteralElement> extends PrimaryExpression, Declaration {
|
|
properties: NodeArray<T>;
|
|
}
|
|
interface ObjectLiteralExpression extends ObjectLiteralExpressionBase<ObjectLiteralElementLike> {
|
|
kind: SyntaxKind.ObjectLiteralExpression;
|
|
}
|
|
type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression;
|
|
type EntityNameOrEntityNameExpression = EntityName | EntityNameExpression;
|
|
interface PropertyAccessExpression extends MemberExpression, Declaration {
|
|
kind: SyntaxKind.PropertyAccessExpression;
|
|
expression: LeftHandSideExpression;
|
|
name: Identifier;
|
|
}
|
|
interface SuperPropertyAccessExpression extends PropertyAccessExpression {
|
|
expression: SuperExpression;
|
|
}
|
|
/** Brand for a PropertyAccessExpression which, like a QualifiedName, consists of a sequence of identifiers separated by dots. */
|
|
interface PropertyAccessEntityNameExpression extends PropertyAccessExpression {
|
|
_propertyAccessExpressionLikeQualifiedNameBrand?: any;
|
|
expression: EntityNameExpression;
|
|
}
|
|
interface ElementAccessExpression extends MemberExpression {
|
|
kind: SyntaxKind.ElementAccessExpression;
|
|
expression: LeftHandSideExpression;
|
|
argumentExpression?: Expression;
|
|
}
|
|
interface SuperElementAccessExpression extends ElementAccessExpression {
|
|
expression: SuperExpression;
|
|
}
|
|
type SuperProperty = SuperPropertyAccessExpression | SuperElementAccessExpression;
|
|
interface CallExpression extends LeftHandSideExpression, Declaration {
|
|
kind: SyntaxKind.CallExpression;
|
|
expression: LeftHandSideExpression;
|
|
typeArguments?: NodeArray<TypeNode>;
|
|
arguments: NodeArray<Expression>;
|
|
}
|
|
interface SuperCall extends CallExpression {
|
|
expression: SuperExpression;
|
|
}
|
|
interface ExpressionWithTypeArguments extends TypeNode {
|
|
kind: SyntaxKind.ExpressionWithTypeArguments;
|
|
expression: LeftHandSideExpression;
|
|
typeArguments?: NodeArray<TypeNode>;
|
|
}
|
|
interface NewExpression extends PrimaryExpression, Declaration {
|
|
kind: SyntaxKind.NewExpression;
|
|
expression: LeftHandSideExpression;
|
|
typeArguments?: NodeArray<TypeNode>;
|
|
arguments: NodeArray<Expression>;
|
|
}
|
|
interface TaggedTemplateExpression extends MemberExpression {
|
|
kind: SyntaxKind.TaggedTemplateExpression;
|
|
tag: LeftHandSideExpression;
|
|
template: TemplateLiteral;
|
|
}
|
|
type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression | Decorator;
|
|
interface AsExpression extends Expression {
|
|
kind: SyntaxKind.AsExpression;
|
|
expression: Expression;
|
|
type: TypeNode;
|
|
}
|
|
interface TypeAssertion extends UnaryExpression {
|
|
kind: SyntaxKind.TypeAssertionExpression;
|
|
type: TypeNode;
|
|
expression: UnaryExpression;
|
|
}
|
|
type AssertionExpression = TypeAssertion | AsExpression;
|
|
interface NonNullExpression extends LeftHandSideExpression {
|
|
kind: SyntaxKind.NonNullExpression;
|
|
expression: Expression;
|
|
}
|
|
interface JsxElement extends PrimaryExpression {
|
|
kind: SyntaxKind.JsxElement;
|
|
openingElement: JsxOpeningElement;
|
|
children: NodeArray<JsxChild>;
|
|
closingElement: JsxClosingElement;
|
|
}
|
|
type JsxTagNameExpression = PrimaryExpression | PropertyAccessExpression;
|
|
interface JsxOpeningElement extends Expression {
|
|
kind: SyntaxKind.JsxOpeningElement;
|
|
tagName: JsxTagNameExpression;
|
|
attributes: NodeArray<JsxAttribute | JsxSpreadAttribute>;
|
|
}
|
|
interface JsxSelfClosingElement extends PrimaryExpression {
|
|
kind: SyntaxKind.JsxSelfClosingElement;
|
|
tagName: JsxTagNameExpression;
|
|
attributes: NodeArray<JsxAttribute | JsxSpreadAttribute>;
|
|
}
|
|
type JsxOpeningLikeElement = JsxSelfClosingElement | JsxOpeningElement;
|
|
type JsxAttributeLike = JsxAttribute | JsxSpreadAttribute;
|
|
interface JsxAttribute extends Node {
|
|
kind: SyntaxKind.JsxAttribute;
|
|
name: Identifier;
|
|
initializer?: StringLiteral | JsxExpression;
|
|
}
|
|
interface JsxSpreadAttribute extends Node {
|
|
kind: SyntaxKind.JsxSpreadAttribute;
|
|
expression: Expression;
|
|
}
|
|
interface JsxClosingElement extends Node {
|
|
kind: SyntaxKind.JsxClosingElement;
|
|
tagName: JsxTagNameExpression;
|
|
}
|
|
interface JsxExpression extends Expression {
|
|
kind: SyntaxKind.JsxExpression;
|
|
expression?: Expression;
|
|
}
|
|
interface JsxText extends Node {
|
|
kind: SyntaxKind.JsxText;
|
|
}
|
|
type JsxChild = JsxText | JsxExpression | JsxElement | JsxSelfClosingElement;
|
|
interface Statement extends Node {
|
|
_statementBrand: any;
|
|
}
|
|
interface EmptyStatement extends Statement {
|
|
kind: SyntaxKind.EmptyStatement;
|
|
}
|
|
interface DebuggerStatement extends Statement {
|
|
kind: SyntaxKind.DebuggerStatement;
|
|
}
|
|
interface MissingDeclaration extends DeclarationStatement, ClassElement, ObjectLiteralElement, TypeElement {
|
|
kind: SyntaxKind.MissingDeclaration;
|
|
name?: Identifier;
|
|
}
|
|
type BlockLike = SourceFile | Block | ModuleBlock | CaseClause;
|
|
interface Block extends Statement {
|
|
kind: SyntaxKind.Block;
|
|
statements: NodeArray<Statement>;
|
|
}
|
|
interface VariableStatement extends Statement {
|
|
kind: SyntaxKind.VariableStatement;
|
|
declarationList: VariableDeclarationList;
|
|
}
|
|
interface ExpressionStatement extends Statement {
|
|
kind: SyntaxKind.ExpressionStatement;
|
|
expression: Expression;
|
|
}
|
|
interface IfStatement extends Statement {
|
|
kind: SyntaxKind.IfStatement;
|
|
expression: Expression;
|
|
thenStatement: Statement;
|
|
elseStatement?: Statement;
|
|
}
|
|
interface IterationStatement extends Statement {
|
|
statement: Statement;
|
|
}
|
|
interface DoStatement extends IterationStatement {
|
|
kind: SyntaxKind.DoStatement;
|
|
expression: Expression;
|
|
}
|
|
interface WhileStatement extends IterationStatement {
|
|
kind: SyntaxKind.WhileStatement;
|
|
expression: Expression;
|
|
}
|
|
type ForInitializer = VariableDeclarationList | Expression;
|
|
interface ForStatement extends IterationStatement {
|
|
kind: SyntaxKind.ForStatement;
|
|
initializer?: ForInitializer;
|
|
condition?: Expression;
|
|
incrementor?: Expression;
|
|
}
|
|
interface ForInStatement extends IterationStatement {
|
|
kind: SyntaxKind.ForInStatement;
|
|
initializer: ForInitializer;
|
|
expression: Expression;
|
|
}
|
|
interface ForOfStatement extends IterationStatement {
|
|
kind: SyntaxKind.ForOfStatement;
|
|
initializer: ForInitializer;
|
|
expression: Expression;
|
|
}
|
|
interface BreakStatement extends Statement {
|
|
kind: SyntaxKind.BreakStatement;
|
|
label?: Identifier;
|
|
}
|
|
interface ContinueStatement extends Statement {
|
|
kind: SyntaxKind.ContinueStatement;
|
|
label?: Identifier;
|
|
}
|
|
type BreakOrContinueStatement = BreakStatement | ContinueStatement;
|
|
interface ReturnStatement extends Statement {
|
|
kind: SyntaxKind.ReturnStatement;
|
|
expression?: Expression;
|
|
}
|
|
interface WithStatement extends Statement {
|
|
kind: SyntaxKind.WithStatement;
|
|
expression: Expression;
|
|
statement: Statement;
|
|
}
|
|
interface SwitchStatement extends Statement {
|
|
kind: SyntaxKind.SwitchStatement;
|
|
expression: Expression;
|
|
caseBlock: CaseBlock;
|
|
possiblyExhaustive?: boolean;
|
|
}
|
|
interface CaseBlock extends Node {
|
|
kind: SyntaxKind.CaseBlock;
|
|
clauses: NodeArray<CaseOrDefaultClause>;
|
|
}
|
|
interface CaseClause extends Node {
|
|
kind: SyntaxKind.CaseClause;
|
|
expression: Expression;
|
|
statements: NodeArray<Statement>;
|
|
}
|
|
interface DefaultClause extends Node {
|
|
kind: SyntaxKind.DefaultClause;
|
|
statements: NodeArray<Statement>;
|
|
}
|
|
type CaseOrDefaultClause = CaseClause | DefaultClause;
|
|
interface LabeledStatement extends Statement {
|
|
kind: SyntaxKind.LabeledStatement;
|
|
label: Identifier;
|
|
statement: Statement;
|
|
}
|
|
interface ThrowStatement extends Statement {
|
|
kind: SyntaxKind.ThrowStatement;
|
|
expression: Expression;
|
|
}
|
|
interface TryStatement extends Statement {
|
|
kind: SyntaxKind.TryStatement;
|
|
tryBlock: Block;
|
|
catchClause?: CatchClause;
|
|
finallyBlock?: Block;
|
|
}
|
|
interface CatchClause extends Node {
|
|
kind: SyntaxKind.CatchClause;
|
|
variableDeclaration: VariableDeclaration;
|
|
block: Block;
|
|
}
|
|
type DeclarationWithTypeParameters = SignatureDeclaration | ClassLikeDeclaration | InterfaceDeclaration | TypeAliasDeclaration;
|
|
interface ClassLikeDeclaration extends Declaration {
|
|
name?: Identifier;
|
|
typeParameters?: NodeArray<TypeParameterDeclaration>;
|
|
heritageClauses?: NodeArray<HeritageClause>;
|
|
members: NodeArray<ClassElement>;
|
|
}
|
|
interface ClassDeclaration extends ClassLikeDeclaration, DeclarationStatement {
|
|
kind: SyntaxKind.ClassDeclaration;
|
|
name?: Identifier;
|
|
}
|
|
interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
|
|
kind: SyntaxKind.ClassExpression;
|
|
}
|
|
interface ClassElement extends Declaration {
|
|
_classElementBrand: any;
|
|
name?: PropertyName;
|
|
}
|
|
interface TypeElement extends Declaration {
|
|
_typeElementBrand: any;
|
|
name?: PropertyName;
|
|
questionToken?: QuestionToken;
|
|
}
|
|
interface InterfaceDeclaration extends DeclarationStatement {
|
|
kind: SyntaxKind.InterfaceDeclaration;
|
|
name: Identifier;
|
|
typeParameters?: NodeArray<TypeParameterDeclaration>;
|
|
heritageClauses?: NodeArray<HeritageClause>;
|
|
members: NodeArray<TypeElement>;
|
|
}
|
|
interface HeritageClause extends Node {
|
|
kind: SyntaxKind.HeritageClause;
|
|
token: SyntaxKind;
|
|
types?: NodeArray<ExpressionWithTypeArguments>;
|
|
}
|
|
interface TypeAliasDeclaration extends DeclarationStatement {
|
|
kind: SyntaxKind.TypeAliasDeclaration;
|
|
name: Identifier;
|
|
typeParameters?: NodeArray<TypeParameterDeclaration>;
|
|
type: TypeNode;
|
|
}
|
|
interface EnumMember extends Declaration {
|
|
kind: SyntaxKind.EnumMember;
|
|
name: PropertyName;
|
|
initializer?: Expression;
|
|
}
|
|
interface EnumDeclaration extends DeclarationStatement {
|
|
kind: SyntaxKind.EnumDeclaration;
|
|
name: Identifier;
|
|
members: NodeArray<EnumMember>;
|
|
}
|
|
type ModuleBody = ModuleBlock | ModuleDeclaration;
|
|
type ModuleName = Identifier | StringLiteral;
|
|
interface ModuleDeclaration extends DeclarationStatement {
|
|
kind: SyntaxKind.ModuleDeclaration;
|
|
name: Identifier | StringLiteral;
|
|
body?: ModuleBlock | NamespaceDeclaration | JSDocNamespaceDeclaration | Identifier;
|
|
}
|
|
interface NamespaceDeclaration extends ModuleDeclaration {
|
|
name: Identifier;
|
|
body: ModuleBlock | NamespaceDeclaration;
|
|
}
|
|
interface JSDocNamespaceDeclaration extends ModuleDeclaration {
|
|
name: Identifier;
|
|
body: JSDocNamespaceDeclaration | Identifier;
|
|
}
|
|
interface ModuleBlock extends Node, Statement {
|
|
kind: SyntaxKind.ModuleBlock;
|
|
statements: NodeArray<Statement>;
|
|
}
|
|
type ModuleReference = EntityName | ExternalModuleReference;
|
|
interface ImportEqualsDeclaration extends DeclarationStatement {
|
|
kind: SyntaxKind.ImportEqualsDeclaration;
|
|
name: Identifier;
|
|
moduleReference: ModuleReference;
|
|
}
|
|
interface ExternalModuleReference extends Node {
|
|
kind: SyntaxKind.ExternalModuleReference;
|
|
expression?: Expression;
|
|
}
|
|
interface ImportDeclaration extends Statement {
|
|
kind: SyntaxKind.ImportDeclaration;
|
|
importClause?: ImportClause;
|
|
moduleSpecifier: Expression;
|
|
}
|
|
type NamedImportBindings = NamespaceImport | NamedImports;
|
|
interface ImportClause extends Declaration {
|
|
kind: SyntaxKind.ImportClause;
|
|
name?: Identifier;
|
|
namedBindings?: NamedImportBindings;
|
|
}
|
|
interface NamespaceImport extends Declaration {
|
|
kind: SyntaxKind.NamespaceImport;
|
|
name: Identifier;
|
|
}
|
|
interface NamespaceExportDeclaration extends DeclarationStatement {
|
|
kind: SyntaxKind.NamespaceExportDeclaration;
|
|
name: Identifier;
|
|
moduleReference: LiteralLikeNode;
|
|
}
|
|
interface ExportDeclaration extends DeclarationStatement {
|
|
kind: SyntaxKind.ExportDeclaration;
|
|
exportClause?: NamedExports;
|
|
moduleSpecifier?: Expression;
|
|
}
|
|
interface NamedImports extends Node {
|
|
kind: SyntaxKind.NamedImports;
|
|
elements: NodeArray<ImportSpecifier>;
|
|
}
|
|
interface NamedExports extends Node {
|
|
kind: SyntaxKind.NamedExports;
|
|
elements: NodeArray<ExportSpecifier>;
|
|
}
|
|
type NamedImportsOrExports = NamedImports | NamedExports;
|
|
interface ImportSpecifier extends Declaration {
|
|
kind: SyntaxKind.ImportSpecifier;
|
|
propertyName?: Identifier;
|
|
name: Identifier;
|
|
}
|
|
interface ExportSpecifier extends Declaration {
|
|
kind: SyntaxKind.ExportSpecifier;
|
|
propertyName?: Identifier;
|
|
name: Identifier;
|
|
}
|
|
type ImportOrExportSpecifier = ImportSpecifier | ExportSpecifier;
|
|
interface ExportAssignment extends DeclarationStatement {
|
|
kind: SyntaxKind.ExportAssignment;
|
|
isExportEquals?: boolean;
|
|
expression: Expression;
|
|
}
|
|
interface FileReference extends TextRange {
|
|
fileName: string;
|
|
}
|
|
interface CommentRange extends TextRange {
|
|
hasTrailingNewLine?: boolean;
|
|
kind: SyntaxKind;
|
|
}
|
|
interface JSDocTypeExpression extends Node {
|
|
kind: SyntaxKind.JSDocTypeExpression;
|
|
type: JSDocType;
|
|
}
|
|
interface JSDocType extends TypeNode {
|
|
_jsDocTypeBrand: any;
|
|
}
|
|
interface JSDocAllType extends JSDocType {
|
|
kind: SyntaxKind.JSDocAllType;
|
|
}
|
|
interface JSDocUnknownType extends JSDocType {
|
|
kind: SyntaxKind.JSDocUnknownType;
|
|
}
|
|
interface JSDocArrayType extends JSDocType {
|
|
kind: SyntaxKind.JSDocArrayType;
|
|
elementType: JSDocType;
|
|
}
|
|
interface JSDocUnionType extends JSDocType {
|
|
kind: SyntaxKind.JSDocUnionType;
|
|
types: NodeArray<JSDocType>;
|
|
}
|
|
interface JSDocTupleType extends JSDocType {
|
|
kind: SyntaxKind.JSDocTupleType;
|
|
types: NodeArray<JSDocType>;
|
|
}
|
|
interface JSDocNonNullableType extends JSDocType {
|
|
kind: SyntaxKind.JSDocNonNullableType;
|
|
type: JSDocType;
|
|
}
|
|
interface JSDocNullableType extends JSDocType {
|
|
kind: SyntaxKind.JSDocNullableType;
|
|
type: JSDocType;
|
|
}
|
|
interface JSDocRecordType extends JSDocType {
|
|
kind: SyntaxKind.JSDocRecordType;
|
|
literal: TypeLiteralNode;
|
|
}
|
|
interface JSDocTypeReference extends JSDocType {
|
|
kind: SyntaxKind.JSDocTypeReference;
|
|
name: EntityName;
|
|
typeArguments: NodeArray<JSDocType>;
|
|
}
|
|
interface JSDocOptionalType extends JSDocType {
|
|
kind: SyntaxKind.JSDocOptionalType;
|
|
type: JSDocType;
|
|
}
|
|
interface JSDocFunctionType extends JSDocType, SignatureDeclaration {
|
|
kind: SyntaxKind.JSDocFunctionType;
|
|
parameters: NodeArray<ParameterDeclaration>;
|
|
type: JSDocType;
|
|
}
|
|
interface JSDocVariadicType extends JSDocType {
|
|
kind: SyntaxKind.JSDocVariadicType;
|
|
type: JSDocType;
|
|
}
|
|
interface JSDocConstructorType extends JSDocType {
|
|
kind: SyntaxKind.JSDocConstructorType;
|
|
type: JSDocType;
|
|
}
|
|
interface JSDocThisType extends JSDocType {
|
|
kind: SyntaxKind.JSDocThisType;
|
|
type: JSDocType;
|
|
}
|
|
interface JSDocLiteralType extends JSDocType {
|
|
kind: SyntaxKind.JSDocLiteralType;
|
|
literal: LiteralTypeNode;
|
|
}
|
|
type JSDocTypeReferencingNode = JSDocThisType | JSDocConstructorType | JSDocVariadicType | JSDocOptionalType | JSDocNullableType | JSDocNonNullableType;
|
|
interface JSDocRecordMember extends PropertySignature {
|
|
kind: SyntaxKind.JSDocRecordMember;
|
|
name: Identifier | StringLiteral | NumericLiteral;
|
|
type?: JSDocType;
|
|
}
|
|
interface JSDoc extends Node {
|
|
kind: SyntaxKind.JSDocComment;
|
|
tags: NodeArray<JSDocTag> | undefined;
|
|
comment: string | undefined;
|
|
}
|
|
interface JSDocTag extends Node {
|
|
atToken: AtToken;
|
|
tagName: Identifier;
|
|
comment: string | undefined;
|
|
}
|
|
interface JSDocUnknownTag extends JSDocTag {
|
|
kind: SyntaxKind.JSDocTag;
|
|
}
|
|
interface JSDocAugmentsTag extends JSDocTag {
|
|
kind: SyntaxKind.JSDocAugmentsTag;
|
|
typeExpression: JSDocTypeExpression;
|
|
}
|
|
interface JSDocTemplateTag extends JSDocTag {
|
|
kind: SyntaxKind.JSDocTemplateTag;
|
|
typeParameters: NodeArray<TypeParameterDeclaration>;
|
|
}
|
|
interface JSDocReturnTag extends JSDocTag {
|
|
kind: SyntaxKind.JSDocReturnTag;
|
|
typeExpression: JSDocTypeExpression;
|
|
}
|
|
interface JSDocTypeTag extends JSDocTag {
|
|
kind: SyntaxKind.JSDocTypeTag;
|
|
typeExpression: JSDocTypeExpression;
|
|
}
|
|
interface JSDocTypedefTag extends JSDocTag, Declaration {
|
|
kind: SyntaxKind.JSDocTypedefTag;
|
|
fullName?: JSDocNamespaceDeclaration | Identifier;
|
|
name?: Identifier;
|
|
typeExpression?: JSDocTypeExpression;
|
|
jsDocTypeLiteral?: JSDocTypeLiteral;
|
|
}
|
|
interface JSDocPropertyTag extends JSDocTag, TypeElement {
|
|
kind: SyntaxKind.JSDocPropertyTag;
|
|
name: Identifier;
|
|
typeExpression: JSDocTypeExpression;
|
|
}
|
|
interface JSDocTypeLiteral extends JSDocType {
|
|
kind: SyntaxKind.JSDocTypeLiteral;
|
|
jsDocPropertyTags?: NodeArray<JSDocPropertyTag>;
|
|
jsDocTypeTag?: JSDocTypeTag;
|
|
}
|
|
interface JSDocParameterTag extends JSDocTag {
|
|
kind: SyntaxKind.JSDocParameterTag;
|
|
/** the parameter name, if provided *before* the type (TypeScript-style) */
|
|
preParameterName?: Identifier;
|
|
typeExpression?: JSDocTypeExpression;
|
|
/** the parameter name, if provided *after* the type (JSDoc-standard) */
|
|
postParameterName?: Identifier;
|
|
/** the parameter name, regardless of the location it was provided */
|
|
parameterName: Identifier;
|
|
isBracketed: boolean;
|
|
}
|
|
enum FlowFlags {
|
|
Unreachable = 1,
|
|
Start = 2,
|
|
BranchLabel = 4,
|
|
LoopLabel = 8,
|
|
Assignment = 16,
|
|
TrueCondition = 32,
|
|
FalseCondition = 64,
|
|
SwitchClause = 128,
|
|
ArrayMutation = 256,
|
|
Referenced = 512,
|
|
Shared = 1024,
|
|
Label = 12,
|
|
Condition = 96,
|
|
}
|
|
interface FlowNode {
|
|
flags: FlowFlags;
|
|
id?: number;
|
|
}
|
|
interface FlowStart extends FlowNode {
|
|
container?: FunctionExpression | ArrowFunction | MethodDeclaration;
|
|
}
|
|
interface FlowLabel extends FlowNode {
|
|
antecedents: FlowNode[];
|
|
}
|
|
interface FlowAssignment extends FlowNode {
|
|
node: Expression | VariableDeclaration | BindingElement;
|
|
antecedent: FlowNode;
|
|
}
|
|
interface FlowCondition extends FlowNode {
|
|
expression: Expression;
|
|
antecedent: FlowNode;
|
|
}
|
|
interface FlowSwitchClause extends FlowNode {
|
|
switchStatement: SwitchStatement;
|
|
clauseStart: number;
|
|
clauseEnd: number;
|
|
antecedent: FlowNode;
|
|
}
|
|
interface FlowArrayMutation extends FlowNode {
|
|
node: CallExpression | BinaryExpression;
|
|
antecedent: FlowNode;
|
|
}
|
|
type FlowType = Type | IncompleteType;
|
|
interface IncompleteType {
|
|
flags: TypeFlags;
|
|
type: Type;
|
|
}
|
|
interface AmdDependency {
|
|
path: string;
|
|
name: string;
|
|
}
|
|
interface SourceFile extends Declaration {
|
|
kind: SyntaxKind.SourceFile;
|
|
statements: NodeArray<Statement>;
|
|
endOfFileToken: Token<SyntaxKind.EndOfFileToken>;
|
|
fileName: string;
|
|
path: Path;
|
|
text: string;
|
|
amdDependencies: AmdDependency[];
|
|
moduleName: string;
|
|
referencedFiles: FileReference[];
|
|
typeReferenceDirectives: FileReference[];
|
|
languageVariant: LanguageVariant;
|
|
isDeclarationFile: boolean;
|
|
/**
|
|
* lib.d.ts should have a reference comment like
|
|
*
|
|
* /// <reference no-default-lib="true"/>
|
|
*
|
|
* If any other file has this comment, it signals not to include lib.d.ts
|
|
* because this containing file is intended to act as a default library.
|
|
*/
|
|
hasNoDefaultLib: boolean;
|
|
languageVersion: ScriptTarget;
|
|
}
|
|
interface ScriptReferenceHost {
|
|
getCompilerOptions(): CompilerOptions;
|
|
getSourceFile(fileName: string): SourceFile;
|
|
getSourceFileByPath(path: Path): SourceFile;
|
|
getCurrentDirectory(): string;
|
|
}
|
|
interface ParseConfigHost {
|
|
useCaseSensitiveFileNames: boolean;
|
|
readDirectory(rootDir: string, extensions: string[], excludes: string[], includes: string[]): string[];
|
|
/**
|
|
* Gets a value indicating whether the specified path exists and is a file.
|
|
* @param path The path to test.
|
|
*/
|
|
fileExists(path: string): boolean;
|
|
readFile(path: string): string;
|
|
}
|
|
interface WriteFileCallback {
|
|
(fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void, sourceFiles?: SourceFile[]): void;
|
|
}
|
|
class OperationCanceledException {
|
|
}
|
|
interface CancellationToken {
|
|
isCancellationRequested(): boolean;
|
|
/** @throws OperationCanceledException if isCancellationRequested is true */
|
|
throwIfCancellationRequested(): void;
|
|
}
|
|
interface Program extends ScriptReferenceHost {
|
|
/**
|
|
* Get a list of root file names that were passed to a 'createProgram'
|
|
*/
|
|
getRootFileNames(): string[];
|
|
/**
|
|
* Get a list of files in the program
|
|
*/
|
|
getSourceFiles(): SourceFile[];
|
|
/**
|
|
* Emits the JavaScript and declaration files. If targetSourceFile is not specified, then
|
|
* the JavaScript and declaration files will be produced for all the files in this program.
|
|
* If targetSourceFile is specified, then only the JavaScript and declaration for that
|
|
* specific file will be generated.
|
|
*
|
|
* If writeFile is not specified then the writeFile callback from the compiler host will be
|
|
* used for writing the JavaScript and declaration files. Otherwise, the writeFile parameter
|
|
* will be invoked when writing the JavaScript and declaration files.
|
|
*/
|
|
emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean): EmitResult;
|
|
getOptionsDiagnostics(cancellationToken?: CancellationToken): Diagnostic[];
|
|
getGlobalDiagnostics(cancellationToken?: CancellationToken): Diagnostic[];
|
|
getSyntacticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[];
|
|
getSemanticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[];
|
|
getDeclarationDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[];
|
|
/**
|
|
* Gets a type checker that can be used to semantically analyze source fils in the program.
|
|
*/
|
|
getTypeChecker(): TypeChecker;
|
|
}
|
|
interface SourceMapSpan {
|
|
/** Line number in the .js file. */
|
|
emittedLine: number;
|
|
/** Column number in the .js file. */
|
|
emittedColumn: number;
|
|
/** Line number in the .ts file. */
|
|
sourceLine: number;
|
|
/** Column number in the .ts file. */
|
|
sourceColumn: number;
|
|
/** Optional name (index into names array) associated with this span. */
|
|
nameIndex?: number;
|
|
/** .ts file (index into sources array) associated with this span */
|
|
sourceIndex: number;
|
|
}
|
|
interface SourceMapData {
|
|
sourceMapFilePath: string;
|
|
jsSourceMappingURL: string;
|
|
sourceMapFile: string;
|
|
sourceMapSourceRoot: string;
|
|
sourceMapSources: string[];
|
|
sourceMapSourcesContent?: string[];
|
|
inputSourceFileNames: string[];
|
|
sourceMapNames?: string[];
|
|
sourceMapMappings: string;
|
|
sourceMapDecodedMappings: SourceMapSpan[];
|
|
}
|
|
/** Return code used by getEmitOutput function to indicate status of the function */
|
|
enum ExitStatus {
|
|
Success = 0,
|
|
DiagnosticsPresent_OutputsSkipped = 1,
|
|
DiagnosticsPresent_OutputsGenerated = 2,
|
|
}
|
|
interface EmitResult {
|
|
emitSkipped: boolean;
|
|
/** Contains declaration emit diagnostics */
|
|
diagnostics: Diagnostic[];
|
|
emittedFiles: string[];
|
|
}
|
|
interface TypeChecker {
|
|
getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type;
|
|
getDeclaredTypeOfSymbol(symbol: Symbol): Type;
|
|
getPropertiesOfType(type: Type): Symbol[];
|
|
getPropertyOfType(type: Type, propertyName: string): Symbol;
|
|
getSignaturesOfType(type: Type, kind: SignatureKind): Signature[];
|
|
getIndexTypeOfType(type: Type, kind: IndexKind): Type;
|
|
getBaseTypes(type: InterfaceType): ObjectType[];
|
|
getReturnTypeOfSignature(signature: Signature): Type;
|
|
getNonNullableType(type: Type): Type;
|
|
getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];
|
|
getSymbolAtLocation(node: Node): Symbol;
|
|
getSymbolsOfParameterPropertyDeclaration(parameter: ParameterDeclaration, parameterName: string): Symbol[];
|
|
getShorthandAssignmentValueSymbol(location: Node): Symbol;
|
|
getExportSpecifierLocalTargetSymbol(location: ExportSpecifier): Symbol;
|
|
getPropertySymbolOfDestructuringAssignment(location: Identifier): Symbol;
|
|
getTypeAtLocation(node: Node): Type;
|
|
typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
|
|
symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;
|
|
getSymbolDisplayBuilder(): SymbolDisplayBuilder;
|
|
getFullyQualifiedName(symbol: Symbol): string;
|
|
getAugmentedPropertiesOfType(type: Type): Symbol[];
|
|
getRootSymbols(symbol: Symbol): Symbol[];
|
|
getContextualType(node: Expression): Type;
|
|
getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature;
|
|
getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature;
|
|
isImplementationOfOverload(node: FunctionLikeDeclaration): boolean;
|
|
isUndefinedSymbol(symbol: Symbol): boolean;
|
|
isArgumentsSymbol(symbol: Symbol): boolean;
|
|
isUnknownSymbol(symbol: Symbol): boolean;
|
|
getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
|
|
isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean;
|
|
getAliasedSymbol(symbol: Symbol): Symbol;
|
|
getExportsOfModule(moduleSymbol: Symbol): Symbol[];
|
|
getJsxElementAttributesType(elementNode: JsxOpeningLikeElement): Type;
|
|
getJsxIntrinsicTagNames(): Symbol[];
|
|
isOptionalParameter(node: ParameterDeclaration): boolean;
|
|
getAmbientModules(): Symbol[];
|
|
tryGetMemberInModuleExports(memberName: string, moduleSymbol: Symbol): Symbol | undefined;
|
|
}
|
|
interface SymbolDisplayBuilder {
|
|
buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
|
|
buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): void;
|
|
buildSignatureDisplay(signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, kind?: SignatureKind): void;
|
|
buildParameterDisplay(parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
|
|
buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
|
|
buildTypePredicateDisplay(predicate: TypePredicate, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
|
|
buildTypeParameterDisplayFromSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
|
|
buildDisplayForParametersAndDelimiters(thisParameter: Symbol, parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
|
|
buildDisplayForTypeParametersAndDelimiters(typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
|
|
buildReturnTypeDisplay(signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
|
|
}
|
|
interface SymbolWriter {
|
|
writeKeyword(text: string): void;
|
|
writeOperator(text: string): void;
|
|
writePunctuation(text: string): void;
|
|
writeSpace(text: string): void;
|
|
writeStringLiteral(text: string): void;
|
|
writeParameter(text: string): void;
|
|
writeProperty(text: string): void;
|
|
writeSymbol(text: string, symbol: Symbol): void;
|
|
writeLine(): void;
|
|
increaseIndent(): void;
|
|
decreaseIndent(): void;
|
|
clear(): void;
|
|
trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
|
|
reportInaccessibleThisError(): void;
|
|
}
|
|
enum TypeFormatFlags {
|
|
None = 0,
|
|
WriteArrayAsGenericType = 1,
|
|
UseTypeOfFunction = 2,
|
|
NoTruncation = 4,
|
|
WriteArrowStyleSignature = 8,
|
|
WriteOwnNameForAnyLike = 16,
|
|
WriteTypeArgumentsOfSignature = 32,
|
|
InElementType = 64,
|
|
UseFullyQualifiedType = 128,
|
|
InFirstTypeArgument = 256,
|
|
InTypeAlias = 512,
|
|
UseTypeAliasValue = 1024,
|
|
}
|
|
enum SymbolFormatFlags {
|
|
None = 0,
|
|
WriteTypeParametersOrArguments = 1,
|
|
UseOnlyExternalAliasing = 2,
|
|
}
|
|
enum TypePredicateKind {
|
|
This = 0,
|
|
Identifier = 1,
|
|
}
|
|
interface TypePredicateBase {
|
|
kind: TypePredicateKind;
|
|
type: Type;
|
|
}
|
|
interface ThisTypePredicate extends TypePredicateBase {
|
|
kind: TypePredicateKind.This;
|
|
}
|
|
interface IdentifierTypePredicate extends TypePredicateBase {
|
|
kind: TypePredicateKind.Identifier;
|
|
parameterName: string;
|
|
parameterIndex: number;
|
|
}
|
|
type TypePredicate = IdentifierTypePredicate | ThisTypePredicate;
|
|
enum SymbolFlags {
|
|
None = 0,
|
|
FunctionScopedVariable = 1,
|
|
BlockScopedVariable = 2,
|
|
Property = 4,
|
|
EnumMember = 8,
|
|
Function = 16,
|
|
Class = 32,
|
|
Interface = 64,
|
|
ConstEnum = 128,
|
|
RegularEnum = 256,
|
|
ValueModule = 512,
|
|
NamespaceModule = 1024,
|
|
TypeLiteral = 2048,
|
|
ObjectLiteral = 4096,
|
|
Method = 8192,
|
|
Constructor = 16384,
|
|
GetAccessor = 32768,
|
|
SetAccessor = 65536,
|
|
Signature = 131072,
|
|
TypeParameter = 262144,
|
|
TypeAlias = 524288,
|
|
ExportValue = 1048576,
|
|
ExportType = 2097152,
|
|
ExportNamespace = 4194304,
|
|
Alias = 8388608,
|
|
Instantiated = 16777216,
|
|
Merged = 33554432,
|
|
Transient = 67108864,
|
|
Prototype = 134217728,
|
|
SyntheticProperty = 268435456,
|
|
Optional = 536870912,
|
|
ExportStar = 1073741824,
|
|
Enum = 384,
|
|
Variable = 3,
|
|
Value = 107455,
|
|
Type = 793064,
|
|
Namespace = 1920,
|
|
Module = 1536,
|
|
Accessor = 98304,
|
|
FunctionScopedVariableExcludes = 107454,
|
|
BlockScopedVariableExcludes = 107455,
|
|
ParameterExcludes = 107455,
|
|
PropertyExcludes = 0,
|
|
EnumMemberExcludes = 900095,
|
|
FunctionExcludes = 106927,
|
|
ClassExcludes = 899519,
|
|
InterfaceExcludes = 792968,
|
|
RegularEnumExcludes = 899327,
|
|
ConstEnumExcludes = 899967,
|
|
ValueModuleExcludes = 106639,
|
|
NamespaceModuleExcludes = 0,
|
|
MethodExcludes = 99263,
|
|
GetAccessorExcludes = 41919,
|
|
SetAccessorExcludes = 74687,
|
|
TypeParameterExcludes = 530920,
|
|
TypeAliasExcludes = 793064,
|
|
AliasExcludes = 8388608,
|
|
ModuleMember = 8914931,
|
|
ExportHasLocal = 944,
|
|
HasExports = 1952,
|
|
HasMembers = 6240,
|
|
BlockScoped = 418,
|
|
PropertyOrAccessor = 98308,
|
|
Export = 7340032,
|
|
ClassMember = 106500,
|
|
}
|
|
interface Symbol {
|
|
flags: SymbolFlags;
|
|
name: string;
|
|
declarations?: Declaration[];
|
|
valueDeclaration?: Declaration;
|
|
members?: SymbolTable;
|
|
exports?: SymbolTable;
|
|
globalExports?: SymbolTable;
|
|
}
|
|
type SymbolTable = Map<Symbol>;
|
|
enum TypeFlags {
|
|
Any = 1,
|
|
String = 2,
|
|
Number = 4,
|
|
Boolean = 8,
|
|
Enum = 16,
|
|
StringLiteral = 32,
|
|
NumberLiteral = 64,
|
|
BooleanLiteral = 128,
|
|
EnumLiteral = 256,
|
|
ESSymbol = 512,
|
|
Void = 1024,
|
|
Undefined = 2048,
|
|
Null = 4096,
|
|
Never = 8192,
|
|
TypeParameter = 16384,
|
|
Object = 32768,
|
|
Union = 65536,
|
|
Intersection = 131072,
|
|
Index = 262144,
|
|
IndexedAccess = 524288,
|
|
Literal = 480,
|
|
StringOrNumberLiteral = 96,
|
|
PossiblyFalsy = 7406,
|
|
StringLike = 262178,
|
|
NumberLike = 340,
|
|
BooleanLike = 136,
|
|
EnumLike = 272,
|
|
UnionOrIntersection = 196608,
|
|
StructuredType = 229376,
|
|
StructuredOrTypeParameter = 507904,
|
|
TypeVariable = 540672,
|
|
Narrowable = 1033215,
|
|
NotUnionOrUnit = 33281,
|
|
}
|
|
type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
|
|
interface Type {
|
|
flags: TypeFlags;
|
|
symbol?: Symbol;
|
|
pattern?: DestructuringPattern;
|
|
aliasSymbol?: Symbol;
|
|
aliasTypeArguments?: Type[];
|
|
}
|
|
interface LiteralType extends Type {
|
|
text: string;
|
|
freshType?: LiteralType;
|
|
regularType?: LiteralType;
|
|
}
|
|
interface EnumType extends Type {
|
|
memberTypes: Map<EnumLiteralType>;
|
|
}
|
|
interface EnumLiteralType extends LiteralType {
|
|
baseType: EnumType & UnionType;
|
|
}
|
|
enum ObjectFlags {
|
|
Class = 1,
|
|
Interface = 2,
|
|
Reference = 4,
|
|
Tuple = 8,
|
|
Anonymous = 16,
|
|
Mapped = 32,
|
|
Instantiated = 64,
|
|
ObjectLiteral = 128,
|
|
EvolvingArray = 256,
|
|
ObjectLiteralPatternWithComputedProperties = 512,
|
|
ClassOrInterface = 3,
|
|
}
|
|
interface ObjectType extends Type {
|
|
objectFlags: ObjectFlags;
|
|
}
|
|
interface InterfaceType extends ObjectType {
|
|
typeParameters: TypeParameter[];
|
|
outerTypeParameters: TypeParameter[];
|
|
localTypeParameters: TypeParameter[];
|
|
thisType: TypeParameter;
|
|
}
|
|
interface InterfaceTypeWithDeclaredMembers extends InterfaceType {
|
|
declaredProperties: Symbol[];
|
|
declaredCallSignatures: Signature[];
|
|
declaredConstructSignatures: Signature[];
|
|
declaredStringIndexInfo: IndexInfo;
|
|
declaredNumberIndexInfo: IndexInfo;
|
|
}
|
|
interface TypeReference extends ObjectType {
|
|
target: GenericType;
|
|
typeArguments: Type[];
|
|
}
|
|
interface GenericType extends InterfaceType, TypeReference {
|
|
}
|
|
interface UnionOrIntersectionType extends Type {
|
|
types: Type[];
|
|
}
|
|
interface UnionType extends UnionOrIntersectionType {
|
|
}
|
|
interface IntersectionType extends UnionOrIntersectionType {
|
|
}
|
|
type StructuredType = ObjectType | UnionType | IntersectionType;
|
|
interface EvolvingArrayType extends ObjectType {
|
|
elementType: Type;
|
|
finalArrayType?: Type;
|
|
}
|
|
interface TypeVariable extends Type {
|
|
}
|
|
interface TypeParameter extends TypeVariable {
|
|
constraint: Type;
|
|
}
|
|
interface IndexedAccessType extends TypeVariable {
|
|
objectType: Type;
|
|
indexType: Type;
|
|
constraint?: Type;
|
|
}
|
|
interface IndexType extends Type {
|
|
type: TypeVariable | UnionOrIntersectionType;
|
|
}
|
|
enum SignatureKind {
|
|
Call = 0,
|
|
Construct = 1,
|
|
}
|
|
interface Signature {
|
|
declaration: SignatureDeclaration;
|
|
typeParameters: TypeParameter[];
|
|
parameters: Symbol[];
|
|
}
|
|
enum IndexKind {
|
|
String = 0,
|
|
Number = 1,
|
|
}
|
|
interface IndexInfo {
|
|
type: Type;
|
|
isReadonly: boolean;
|
|
declaration?: SignatureDeclaration;
|
|
}
|
|
interface FileExtensionInfo {
|
|
extension: string;
|
|
scriptKind: ScriptKind;
|
|
isMixedContent: boolean;
|
|
}
|
|
interface DiagnosticMessage {
|
|
key: string;
|
|
category: DiagnosticCategory;
|
|
code: number;
|
|
message: string;
|
|
}
|
|
/**
|
|
* A linked list of formatted diagnostic messages to be used as part of a multiline message.
|
|
* It is built from the bottom up, leaving the head to be the "main" diagnostic.
|
|
* While it seems that DiagnosticMessageChain is structurally similar to DiagnosticMessage,
|
|
* the difference is that messages are all preformatted in DMC.
|
|
*/
|
|
interface DiagnosticMessageChain {
|
|
messageText: string;
|
|
category: DiagnosticCategory;
|
|
code: number;
|
|
next?: DiagnosticMessageChain;
|
|
}
|
|
interface Diagnostic {
|
|
file: SourceFile;
|
|
start: number;
|
|
length: number;
|
|
messageText: string | DiagnosticMessageChain;
|
|
category: DiagnosticCategory;
|
|
code: number;
|
|
}
|
|
enum DiagnosticCategory {
|
|
Warning = 0,
|
|
Error = 1,
|
|
Message = 2,
|
|
}
|
|
enum ModuleResolutionKind {
|
|
Classic = 1,
|
|
NodeJs = 2,
|
|
}
|
|
type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]>;
|
|
interface CompilerOptions {
|
|
allowJs?: boolean;
|
|
allowSyntheticDefaultImports?: boolean;
|
|
allowUnreachableCode?: boolean;
|
|
allowUnusedLabels?: boolean;
|
|
alwaysStrict?: boolean;
|
|
baseUrl?: string;
|
|
charset?: string;
|
|
declaration?: boolean;
|
|
declarationDir?: string;
|
|
disableSizeLimit?: boolean;
|
|
emitBOM?: boolean;
|
|
emitDecoratorMetadata?: boolean;
|
|
experimentalDecorators?: boolean;
|
|
forceConsistentCasingInFileNames?: boolean;
|
|
importHelpers?: boolean;
|
|
inlineSourceMap?: boolean;
|
|
inlineSources?: boolean;
|
|
isolatedModules?: boolean;
|
|
jsx?: JsxEmit;
|
|
lib?: string[];
|
|
locale?: string;
|
|
mapRoot?: string;
|
|
maxNodeModuleJsDepth?: number;
|
|
module?: ModuleKind;
|
|
moduleResolution?: ModuleResolutionKind;
|
|
newLine?: NewLineKind;
|
|
noEmit?: boolean;
|
|
noEmitHelpers?: boolean;
|
|
noEmitOnError?: boolean;
|
|
noErrorTruncation?: boolean;
|
|
noFallthroughCasesInSwitch?: boolean;
|
|
noImplicitAny?: boolean;
|
|
noImplicitReturns?: boolean;
|
|
noImplicitThis?: boolean;
|
|
noUnusedLocals?: boolean;
|
|
noUnusedParameters?: boolean;
|
|
noImplicitUseStrict?: boolean;
|
|
noLib?: boolean;
|
|
noResolve?: boolean;
|
|
out?: string;
|
|
outDir?: string;
|
|
outFile?: string;
|
|
paths?: MapLike<string[]>;
|
|
preserveConstEnums?: boolean;
|
|
project?: string;
|
|
reactNamespace?: string;
|
|
jsxFactory?: string;
|
|
removeComments?: boolean;
|
|
rootDir?: string;
|
|
rootDirs?: string[];
|
|
skipLibCheck?: boolean;
|
|
skipDefaultLibCheck?: boolean;
|
|
sourceMap?: boolean;
|
|
sourceRoot?: string;
|
|
strictNullChecks?: boolean;
|
|
suppressExcessPropertyErrors?: boolean;
|
|
suppressImplicitAnyIndexErrors?: boolean;
|
|
target?: ScriptTarget;
|
|
traceResolution?: boolean;
|
|
types?: string[];
|
|
/** Paths used to compute primary types search locations */
|
|
typeRoots?: string[];
|
|
[option: string]: CompilerOptionsValue | undefined;
|
|
}
|
|
interface TypeAcquisition {
|
|
enableAutoDiscovery?: boolean;
|
|
enable?: boolean;
|
|
include?: string[];
|
|
exclude?: string[];
|
|
[option: string]: string[] | boolean | undefined;
|
|
}
|
|
interface DiscoverTypingsInfo {
|
|
fileNames: string[];
|
|
projectRootPath: string;
|
|
safeListPath: string;
|
|
packageNameToTypingLocation: Map<string>;
|
|
typeAcquisition: TypeAcquisition;
|
|
compilerOptions: CompilerOptions;
|
|
unresolvedImports: ReadonlyArray<string>;
|
|
}
|
|
enum ModuleKind {
|
|
None = 0,
|
|
CommonJS = 1,
|
|
AMD = 2,
|
|
UMD = 3,
|
|
System = 4,
|
|
ES2015 = 5,
|
|
}
|
|
enum JsxEmit {
|
|
None = 0,
|
|
Preserve = 1,
|
|
React = 2,
|
|
}
|
|
enum NewLineKind {
|
|
CarriageReturnLineFeed = 0,
|
|
LineFeed = 1,
|
|
}
|
|
interface LineAndCharacter {
|
|
line: number;
|
|
character: number;
|
|
}
|
|
enum ScriptKind {
|
|
Unknown = 0,
|
|
JS = 1,
|
|
JSX = 2,
|
|
TS = 3,
|
|
TSX = 4,
|
|
}
|
|
enum ScriptTarget {
|
|
ES3 = 0,
|
|
ES5 = 1,
|
|
ES2015 = 2,
|
|
ES2016 = 3,
|
|
ES2017 = 4,
|
|
ESNext = 5,
|
|
Latest = 5,
|
|
}
|
|
enum LanguageVariant {
|
|
Standard = 0,
|
|
JSX = 1,
|
|
}
|
|
/** Either a parsed command line or a parsed tsconfig.json */
|
|
interface ParsedCommandLine {
|
|
options: CompilerOptions;
|
|
typeAcquisition?: TypeAcquisition;
|
|
fileNames: string[];
|
|
raw?: any;
|
|
errors: Diagnostic[];
|
|
wildcardDirectories?: MapLike<WatchDirectoryFlags>;
|
|
compileOnSave?: boolean;
|
|
}
|
|
enum WatchDirectoryFlags {
|
|
None = 0,
|
|
Recursive = 1,
|
|
}
|
|
interface ExpandResult {
|
|
fileNames: string[];
|
|
wildcardDirectories: MapLike<WatchDirectoryFlags>;
|
|
}
|
|
interface ModuleResolutionHost {
|
|
fileExists(fileName: string): boolean;
|
|
readFile(fileName: string): string;
|
|
trace?(s: string): void;
|
|
directoryExists?(directoryName: string): boolean;
|
|
realpath?(path: string): string;
|
|
getCurrentDirectory?(): string;
|
|
getDirectories?(path: string): string[];
|
|
}
|
|
/**
|
|
* Represents the result of module resolution.
|
|
* Module resolution will pick up tsx/jsx/js files even if '--jsx' and '--allowJs' are turned off.
|
|
* The Program will then filter results based on these flags.
|
|
*
|
|
* Prefer to return a `ResolvedModuleFull` so that the file type does not have to be inferred.
|
|
*/
|
|
interface ResolvedModule {
|
|
/** Path of the file the module was resolved to. */
|
|
resolvedFileName: string;
|
|
/**
|
|
* Denotes if 'resolvedFileName' is isExternalLibraryImport and thus should be a proper external module:
|
|
* - be a .d.ts file
|
|
* - use top level imports\exports
|
|
* - don't use tripleslash references
|
|
*/
|
|
isExternalLibraryImport?: boolean;
|
|
}
|
|
/**
|
|
* ResolvedModule with an explicitly provided `extension` property.
|
|
* Prefer this over `ResolvedModule`.
|
|
*/
|
|
interface ResolvedModuleFull extends ResolvedModule {
|
|
/**
|
|
* Extension of resolvedFileName. This must match what's at the end of resolvedFileName.
|
|
* This is optional for backwards-compatibility, but will be added if not provided.
|
|
*/
|
|
extension: Extension;
|
|
}
|
|
enum Extension {
|
|
Ts = 0,
|
|
Tsx = 1,
|
|
Dts = 2,
|
|
Js = 3,
|
|
Jsx = 4,
|
|
LastTypeScriptExtension = 2,
|
|
}
|
|
interface ResolvedModuleWithFailedLookupLocations {
|
|
resolvedModule: ResolvedModuleFull | undefined;
|
|
failedLookupLocations: string[];
|
|
}
|
|
interface ResolvedTypeReferenceDirective {
|
|
primary: boolean;
|
|
resolvedFileName?: string;
|
|
}
|
|
interface ResolvedTypeReferenceDirectiveWithFailedLookupLocations {
|
|
resolvedTypeReferenceDirective: ResolvedTypeReferenceDirective;
|
|
failedLookupLocations: string[];
|
|
}
|
|
interface CompilerHost extends ModuleResolutionHost {
|
|
getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile;
|
|
getSourceFileByPath?(fileName: string, path: Path, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile;
|
|
getCancellationToken?(): CancellationToken;
|
|
getDefaultLibFileName(options: CompilerOptions): string;
|
|
getDefaultLibLocation?(): string;
|
|
writeFile: WriteFileCallback;
|
|
getCurrentDirectory(): string;
|
|
getDirectories(path: string): string[];
|
|
getCanonicalFileName(fileName: string): string;
|
|
useCaseSensitiveFileNames(): boolean;
|
|
getNewLine(): string;
|
|
resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[];
|
|
/**
|
|
* This method is a companion for 'resolveModuleNames' and is used to resolve 'types' references to actual type declaration files
|
|
*/
|
|
resolveTypeReferenceDirectives?(typeReferenceDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[];
|
|
getEnvironmentVariable?(name: string): string;
|
|
}
|
|
interface TextSpan {
|
|
start: number;
|
|
length: number;
|
|
}
|
|
interface TextChangeRange {
|
|
span: TextSpan;
|
|
newLength: number;
|
|
}
|
|
interface SyntaxList extends Node {
|
|
_children: Node[];
|
|
}
|
|
}
|
|
declare namespace ts {
|
|
/** The version of the TypeScript compiler release */
|
|
const version = "2.2.0";
|
|
}
|
|
declare namespace ts {
|
|
type FileWatcherCallback = (fileName: string, removed?: boolean) => void;
|
|
type DirectoryWatcherCallback = (fileName: string) => void;
|
|
interface WatchedFile {
|
|
fileName: string;
|
|
callback: FileWatcherCallback;
|
|
mtime?: Date;
|
|
}
|
|
interface System {
|
|
args: string[];
|
|
newLine: string;
|
|
useCaseSensitiveFileNames: boolean;
|
|
write(s: string): void;
|
|
readFile(path: string, encoding?: string): string;
|
|
getFileSize?(path: string): number;
|
|
writeFile(path: string, data: string, writeByteOrderMark?: boolean): void;
|
|
/**
|
|
* @pollingInterval - this parameter is used in polling-based watchers and ignored in watchers that
|
|
* use native OS file watching
|
|
*/
|
|
watchFile?(path: string, callback: FileWatcherCallback, pollingInterval?: number): FileWatcher;
|
|
watchDirectory?(path: string, callback: DirectoryWatcherCallback, recursive?: boolean): FileWatcher;
|
|
resolvePath(path: string): string;
|
|
fileExists(path: string): boolean;
|
|
directoryExists(path: string): boolean;
|
|
createDirectory(path: string): void;
|
|
getExecutingFilePath(): string;
|
|
getCurrentDirectory(): string;
|
|
getDirectories(path: string): string[];
|
|
readDirectory(path: string, extensions?: string[], exclude?: string[], include?: string[]): string[];
|
|
getModifiedTime?(path: string): Date;
|
|
createHash?(data: string): string;
|
|
getMemoryUsage?(): number;
|
|
exit(exitCode?: number): void;
|
|
realpath?(path: string): string;
|
|
setTimeout?(callback: (...args: any[]) => void, ms: number, ...args: any[]): any;
|
|
clearTimeout?(timeoutId: any): void;
|
|
}
|
|
interface FileWatcher {
|
|
close(): void;
|
|
}
|
|
interface DirectoryWatcher extends FileWatcher {
|
|
directoryName: string;
|
|
referenceCount: number;
|
|
}
|
|
let sys: System;
|
|
}
|
|
declare namespace ts {
|
|
interface ErrorCallback {
|
|
(message: DiagnosticMessage, length: number): void;
|
|
}
|
|
interface Scanner {
|
|
getStartPos(): number;
|
|
getToken(): SyntaxKind;
|
|
getTextPos(): number;
|
|
getTokenPos(): number;
|
|
getTokenText(): string;
|
|
getTokenValue(): string;
|
|
hasExtendedUnicodeEscape(): boolean;
|
|
hasPrecedingLineBreak(): boolean;
|
|
isIdentifier(): boolean;
|
|
isReservedWord(): boolean;
|
|
isUnterminated(): boolean;
|
|
reScanGreaterToken(): SyntaxKind;
|
|
reScanSlashToken(): SyntaxKind;
|
|
reScanTemplateToken(): SyntaxKind;
|
|
scanJsxIdentifier(): SyntaxKind;
|
|
scanJsxAttributeValue(): SyntaxKind;
|
|
reScanJsxToken(): SyntaxKind;
|
|
scanJsxToken(): SyntaxKind;
|
|
scanJSDocToken(): SyntaxKind;
|
|
scan(): SyntaxKind;
|
|
getText(): string;
|
|
setText(text: string, start?: number, length?: number): void;
|
|
setOnError(onError: ErrorCallback): void;
|
|
setScriptTarget(scriptTarget: ScriptTarget): void;
|
|
setLanguageVariant(variant: LanguageVariant): void;
|
|
setTextPos(textPos: number): void;
|
|
lookAhead<T>(callback: () => T): T;
|
|
scanRange<T>(start: number, length: number, callback: () => T): T;
|
|
tryScan<T>(callback: () => T): T;
|
|
}
|
|
function tokenToString(t: SyntaxKind): string;
|
|
function getPositionOfLineAndCharacter(sourceFile: SourceFile, line: number, character: number): number;
|
|
function getLineAndCharacterOfPosition(sourceFile: SourceFile, position: number): LineAndCharacter;
|
|
function isWhiteSpace(ch: number): boolean;
|
|
/** Does not include line breaks. For that, see isWhiteSpaceLike. */
|
|
function isWhiteSpaceSingleLine(ch: number): boolean;
|
|
function isLineBreak(ch: number): boolean;
|
|
function couldStartTrivia(text: string, pos: number): boolean;
|
|
function forEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T) => U, state?: T): U;
|
|
function forEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T) => U, state?: T): U;
|
|
function reduceEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial: U): U;
|
|
function reduceEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial: U): U;
|
|
function getLeadingCommentRanges(text: string, pos: number): CommentRange[];
|
|
function getTrailingCommentRanges(text: string, pos: number): CommentRange[];
|
|
/** Optionally, get the shebang */
|
|
function getShebang(text: string): string;
|
|
function isIdentifierStart(ch: number, languageVersion: ScriptTarget): boolean;
|
|
function isIdentifierPart(ch: number, languageVersion: ScriptTarget): boolean;
|
|
function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, languageVariant?: LanguageVariant, text?: string, onError?: ErrorCallback, start?: number, length?: number): Scanner;
|
|
}
|
|
declare namespace ts {
|
|
function getDefaultLibFileName(options: CompilerOptions): string;
|
|
function textSpanEnd(span: TextSpan): number;
|
|
function textSpanIsEmpty(span: TextSpan): boolean;
|
|
function textSpanContainsPosition(span: TextSpan, position: number): boolean;
|
|
function textSpanContainsTextSpan(span: TextSpan, other: TextSpan): boolean;
|
|
function textSpanOverlapsWith(span: TextSpan, other: TextSpan): boolean;
|
|
function textSpanOverlap(span1: TextSpan, span2: TextSpan): TextSpan;
|
|
function textSpanIntersectsWithTextSpan(span: TextSpan, other: TextSpan): boolean;
|
|
function textSpanIntersectsWith(span: TextSpan, start: number, length: number): boolean;
|
|
function decodedTextSpanIntersectsWith(start1: number, length1: number, start2: number, length2: number): boolean;
|
|
function textSpanIntersectsWithPosition(span: TextSpan, position: number): boolean;
|
|
function textSpanIntersection(span1: TextSpan, span2: TextSpan): TextSpan;
|
|
function createTextSpan(start: number, length: number): TextSpan;
|
|
function createTextSpanFromBounds(start: number, end: number): TextSpan;
|
|
function textChangeRangeNewSpan(range: TextChangeRange): TextSpan;
|
|
function textChangeRangeIsUnchanged(range: TextChangeRange): boolean;
|
|
function createTextChangeRange(span: TextSpan, newLength: number): TextChangeRange;
|
|
let unchangedTextChangeRange: TextChangeRange;
|
|
/**
|
|
* Called to merge all the changes that occurred across several versions of a script snapshot
|
|
* into a single change. i.e. if a user keeps making successive edits to a script we will
|
|
* have a text change from V1 to V2, V2 to V3, ..., Vn.
|
|
*
|
|
* This function will then merge those changes into a single change range valid between V1 and
|
|
* Vn.
|
|
*/
|
|
function collapseTextChangeRangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange;
|
|
function getTypeParameterOwner(d: Declaration): Declaration;
|
|
function isParameterPropertyDeclaration(node: Node): boolean;
|
|
function getCombinedModifierFlags(node: Node): ModifierFlags;
|
|
function getCombinedNodeFlags(node: Node): NodeFlags;
|
|
/**
|
|
* Checks to see if the locale is in the appropriate format,
|
|
* and if it is, attempts to set the appropriate language.
|
|
*/
|
|
function validateLocaleAndSetLanguage(locale: string, sys: {
|
|
getExecutingFilePath(): string;
|
|
resolvePath(path: string): string;
|
|
fileExists(fileName: string): boolean;
|
|
readFile(fileName: string): string;
|
|
}, errors?: Diagnostic[]): void;
|
|
}
|
|
declare namespace ts {
|
|
function createNode(kind: SyntaxKind, pos?: number, end?: number): Node;
|
|
function forEachChild<T>(node: Node, cbNode: (node: Node) => T, cbNodeArray?: (nodes: Node[]) => T): T;
|
|
function createSourceFile(fileName: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes?: boolean, scriptKind?: ScriptKind): SourceFile;
|
|
function parseIsolatedEntityName(text: string, languageVersion: ScriptTarget): EntityName;
|
|
function isExternalModule(file: SourceFile): boolean;
|
|
function updateSourceFile(sourceFile: SourceFile, newText: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;
|
|
}
|
|
declare namespace ts {
|
|
function moduleHasNonRelativeName(moduleName: string): boolean;
|
|
function getEffectiveTypeRoots(options: CompilerOptions, host: {
|
|
directoryExists?: (directoryName: string) => boolean;
|
|
getCurrentDirectory?: () => string;
|
|
}): string[] | undefined;
|
|
/**
|
|
* @param {string | undefined} containingFile - file that contains type reference directive, can be undefined if containing file is unknown.
|
|
* This is possible in case if resolution is performed for directives specified via 'types' parameter. In this case initial path for secondary lookups
|
|
* is assumed to be the same as root directory of the project.
|
|
*/
|
|
function resolveTypeReferenceDirective(typeReferenceDirectiveName: string, containingFile: string | undefined, options: CompilerOptions, host: ModuleResolutionHost): ResolvedTypeReferenceDirectiveWithFailedLookupLocations;
|
|
/**
|
|
* Given a set of options, returns the set of type directive names
|
|
* that should be included for this program automatically.
|
|
* This list could either come from the config file,
|
|
* or from enumerating the types root + initial secondary types lookup location.
|
|
* More type directives might appear in the program later as a result of loading actual source files;
|
|
* this list is only the set of defaults that are implicitly included.
|
|
*/
|
|
function getAutomaticTypeDirectiveNames(options: CompilerOptions, host: ModuleResolutionHost): string[];
|
|
function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations;
|
|
function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations;
|
|
function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations;
|
|
}
|
|
declare namespace ts {
|
|
function findConfigFile(searchPath: string, fileExists: (fileName: string) => boolean, configName?: string): string;
|
|
function resolveTripleslashReference(moduleName: string, containingFile: string): string;
|
|
function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost;
|
|
function getPreEmitDiagnostics(program: Program, sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[];
|
|
interface FormatDiagnosticsHost {
|
|
getCurrentDirectory(): string;
|
|
getCanonicalFileName(fileName: string): string;
|
|
getNewLine(): string;
|
|
}
|
|
function formatDiagnostics(diagnostics: Diagnostic[], host: FormatDiagnosticsHost): string;
|
|
function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;
|
|
function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost, oldProgram?: Program): Program;
|
|
}
|
|
declare namespace ts {
|
|
function parseCommandLine(commandLine: string[], readFile?: (path: string) => string): ParsedCommandLine;
|
|
/**
|
|
* Read tsconfig.json file
|
|
* @param fileName The path to the config file
|
|
*/
|
|
function readConfigFile(fileName: string, readFile: (path: string) => string): {
|
|
config?: any;
|
|
error?: Diagnostic;
|
|
};
|
|
/**
|
|
* Parse the text of the tsconfig.json file
|
|
* @param fileName The path to the config file
|
|
* @param jsonText The text of the config file
|
|
*/
|
|
function parseConfigFileTextToJson(fileName: string, jsonText: string, stripComments?: boolean): {
|
|
config?: any;
|
|
error?: Diagnostic;
|
|
};
|
|
/**
|
|
* Parse the contents of a config file (tsconfig.json).
|
|
* @param json The contents of the config file to parse
|
|
* @param host Instance of ParseConfigHost used to enumerate files in folder.
|
|
* @param basePath A root directory to resolve relative path entries in the config
|
|
* file to. e.g. outDir
|
|
*/
|
|
function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: FileExtensionInfo[]): ParsedCommandLine;
|
|
function convertCompileOnSaveOptionFromJson(jsonOption: any, basePath: string, errors: Diagnostic[]): boolean;
|
|
function convertCompilerOptionsFromJson(jsonOptions: any, basePath: string, configFileName?: string): {
|
|
options: CompilerOptions;
|
|
errors: Diagnostic[];
|
|
};
|
|
function convertTypeAcquisitionFromJson(jsonOptions: any, basePath: string, configFileName?: string): {
|
|
options: TypeAcquisition;
|
|
errors: Diagnostic[];
|
|
};
|
|
}
|
|
declare namespace ts {
|
|
interface Node {
|
|
getSourceFile(): SourceFile;
|
|
getChildCount(sourceFile?: SourceFile): number;
|
|
getChildAt(index: number, sourceFile?: SourceFile): Node;
|
|
getChildren(sourceFile?: SourceFile): Node[];
|
|
getStart(sourceFile?: SourceFile, includeJsDocComment?: boolean): number;
|
|
getFullStart(): number;
|
|
getEnd(): number;
|
|
getWidth(sourceFile?: SourceFile): number;
|
|
getFullWidth(): number;
|
|
getLeadingTriviaWidth(sourceFile?: SourceFile): number;
|
|
getFullText(sourceFile?: SourceFile): string;
|
|
getText(sourceFile?: SourceFile): string;
|
|
getFirstToken(sourceFile?: SourceFile): Node;
|
|
getLastToken(sourceFile?: SourceFile): Node;
|
|
}
|
|
interface Symbol {
|
|
getFlags(): SymbolFlags;
|
|
getName(): string;
|
|
getDeclarations(): Declaration[];
|
|
getDocumentationComment(): SymbolDisplayPart[];
|
|
}
|
|
interface Type {
|
|
getFlags(): TypeFlags;
|
|
getSymbol(): Symbol;
|
|
getProperties(): Symbol[];
|
|
getProperty(propertyName: string): Symbol;
|
|
getApparentProperties(): Symbol[];
|
|
getCallSignatures(): Signature[];
|
|
getConstructSignatures(): Signature[];
|
|
getStringIndexType(): Type;
|
|
getNumberIndexType(): Type;
|
|
getBaseTypes(): ObjectType[];
|
|
getNonNullableType(): Type;
|
|
}
|
|
interface Signature {
|
|
getDeclaration(): SignatureDeclaration;
|
|
getTypeParameters(): Type[];
|
|
getParameters(): Symbol[];
|
|
getReturnType(): Type;
|
|
getDocumentationComment(): SymbolDisplayPart[];
|
|
}
|
|
interface SourceFile {
|
|
getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
|
|
getLineEndOfPosition(pos: number): number;
|
|
getLineStarts(): number[];
|
|
getPositionOfLineAndCharacter(line: number, character: number): number;
|
|
update(newText: string, textChangeRange: TextChangeRange): SourceFile;
|
|
}
|
|
/**
|
|
* Represents an immutable snapshot of a script at a specified time.Once acquired, the
|
|
* snapshot is observably immutable. i.e. the same calls with the same parameters will return
|
|
* the same values.
|
|
*/
|
|
interface IScriptSnapshot {
|
|
/** Gets a portion of the script snapshot specified by [start, end). */
|
|
getText(start: number, end: number): string;
|
|
/** Gets the length of this script snapshot. */
|
|
getLength(): number;
|
|
/**
|
|
* Gets the TextChangeRange that describe how the text changed between this text and
|
|
* an older version. This information is used by the incremental parser to determine
|
|
* what sections of the script need to be re-parsed. 'undefined' can be returned if the
|
|
* change range cannot be determined. However, in that case, incremental parsing will
|
|
* not happen and the entire document will be re - parsed.
|
|
*/
|
|
getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange | undefined;
|
|
/** Releases all resources held by this script snapshot */
|
|
dispose?(): void;
|
|
}
|
|
namespace ScriptSnapshot {
|
|
function fromString(text: string): IScriptSnapshot;
|
|
}
|
|
interface PreProcessedFileInfo {
|
|
referencedFiles: FileReference[];
|
|
typeReferenceDirectives: FileReference[];
|
|
importedFiles: FileReference[];
|
|
ambientExternalModules: string[];
|
|
isLibFile: boolean;
|
|
}
|
|
interface HostCancellationToken {
|
|
isCancellationRequested(): boolean;
|
|
}
|
|
interface LanguageServiceHost {
|
|
getCompilationSettings(): CompilerOptions;
|
|
getNewLine?(): string;
|
|
getProjectVersion?(): string;
|
|
getScriptFileNames(): string[];
|
|
getScriptKind?(fileName: string): ScriptKind;
|
|
getScriptVersion(fileName: string): string;
|
|
getScriptSnapshot(fileName: string): IScriptSnapshot | undefined;
|
|
getLocalizedDiagnosticMessages?(): any;
|
|
getCancellationToken?(): HostCancellationToken;
|
|
getCurrentDirectory(): string;
|
|
getDefaultLibFileName(options: CompilerOptions): string;
|
|
log?(s: string): void;
|
|
trace?(s: string): void;
|
|
error?(s: string): void;
|
|
useCaseSensitiveFileNames?(): boolean;
|
|
readDirectory?(path: string, extensions?: string[], exclude?: string[], include?: string[]): string[];
|
|
readFile?(path: string, encoding?: string): string;
|
|
fileExists?(path: string): boolean;
|
|
getTypeRootsVersion?(): number;
|
|
resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[];
|
|
resolveTypeReferenceDirectives?(typeDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[];
|
|
directoryExists?(directoryName: string): boolean;
|
|
getDirectories?(directoryName: string): string[];
|
|
}
|
|
interface LanguageService {
|
|
cleanupSemanticCache(): void;
|
|
getSyntacticDiagnostics(fileName: string): Diagnostic[];
|
|
getSemanticDiagnostics(fileName: string): Diagnostic[];
|
|
getCompilerOptionsDiagnostics(): Diagnostic[];
|
|
/**
|
|
* @deprecated Use getEncodedSyntacticClassifications instead.
|
|
*/
|
|
getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
|
|
/**
|
|
* @deprecated Use getEncodedSemanticClassifications instead.
|
|
*/
|
|
getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
|
|
getEncodedSyntacticClassifications(fileName: string, span: TextSpan): Classifications;
|
|
getEncodedSemanticClassifications(fileName: string, span: TextSpan): Classifications;
|
|
getCompletionsAtPosition(fileName: string, position: number): CompletionInfo;
|
|
getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails;
|
|
getCompletionEntrySymbol(fileName: string, position: number, entryName: string): Symbol;
|
|
getQuickInfoAtPosition(fileName: string, position: number): QuickInfo;
|
|
getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): TextSpan;
|
|
getBreakpointStatementAtPosition(fileName: string, position: number): TextSpan;
|
|
getSignatureHelpItems(fileName: string, position: number): SignatureHelpItems;
|
|
getRenameInfo(fileName: string, position: number): RenameInfo;
|
|
findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[];
|
|
getDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[];
|
|
getTypeDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[];
|
|
getImplementationAtPosition(fileName: string, position: number): ImplementationLocation[];
|
|
getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[];
|
|
findReferences(fileName: string, position: number): ReferencedSymbol[];
|
|
getDocumentHighlights(fileName: string, position: number, filesToSearch: string[]): DocumentHighlights[];
|
|
/** @deprecated */
|
|
getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[];
|
|
getNavigateToItems(searchValue: string, maxResultCount?: number, fileName?: string, excludeDtsFiles?: boolean): NavigateToItem[];
|
|
getNavigationBarItems(fileName: string): NavigationBarItem[];
|
|
getNavigationTree(fileName: string): NavigationTree;
|
|
getOutliningSpans(fileName: string): OutliningSpan[];
|
|
getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[];
|
|
getBraceMatchingAtPosition(fileName: string, position: number): TextSpan[];
|
|
getIndentationAtPosition(fileName: string, position: number, options: EditorOptions | EditorSettings): number;
|
|
getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
|
|
getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
|
|
getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
|
|
getDocCommentTemplateAtPosition(fileName: string, position: number): TextInsertion;
|
|
isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): boolean;
|
|
getCodeFixesAtPosition(fileName: string, start: number, end: number, errorCodes: number[]): CodeAction[];
|
|
getEmitOutput(fileName: string, emitOnlyDtsFiles?: boolean): EmitOutput;
|
|
getProgram(): Program;
|
|
dispose(): void;
|
|
}
|
|
interface Classifications {
|
|
spans: number[];
|
|
endOfLineState: EndOfLineState;
|
|
}
|
|
interface ClassifiedSpan {
|
|
textSpan: TextSpan;
|
|
classificationType: string;
|
|
}
|
|
/**
|
|
* Navigation bar interface designed for visual studio's dual-column layout.
|
|
* This does not form a proper tree.
|
|
* The navbar is returned as a list of top-level items, each of which has a list of child items.
|
|
* Child items always have an empty array for their `childItems`.
|
|
*/
|
|
interface NavigationBarItem {
|
|
text: string;
|
|
kind: string;
|
|
kindModifiers: string;
|
|
spans: TextSpan[];
|
|
childItems: NavigationBarItem[];
|
|
indent: number;
|
|
bolded: boolean;
|
|
grayed: boolean;
|
|
}
|
|
/**
|
|
* Node in a tree of nested declarations in a file.
|
|
* The top node is always a script or module node.
|
|
*/
|
|
interface NavigationTree {
|
|
/** Name of the declaration, or a short description, e.g. "<class>". */
|
|
text: string;
|
|
/** A ScriptElementKind */
|
|
kind: string;
|
|
/** ScriptElementKindModifier separated by commas, e.g. "public,abstract" */
|
|
kindModifiers: string;
|
|
/**
|
|
* Spans of the nodes that generated this declaration.
|
|
* There will be more than one if this is the result of merging.
|
|
*/
|
|
spans: TextSpan[];
|
|
/** Present if non-empty */
|
|
childItems?: NavigationTree[];
|
|
}
|
|
interface TodoCommentDescriptor {
|
|
text: string;
|
|
priority: number;
|
|
}
|
|
interface TodoComment {
|
|
descriptor: TodoCommentDescriptor;
|
|
message: string;
|
|
position: number;
|
|
}
|
|
class TextChange {
|
|
span: TextSpan;
|
|
newText: string;
|
|
}
|
|
interface FileTextChanges {
|
|
fileName: string;
|
|
textChanges: TextChange[];
|
|
}
|
|
interface CodeAction {
|
|
/** Description of the code action to display in the UI of the editor */
|
|
description: string;
|
|
/** Text changes to apply to each file as part of the code action */
|
|
changes: FileTextChanges[];
|
|
}
|
|
interface TextInsertion {
|
|
newText: string;
|
|
/** The position in newText the caret should point to after the insertion. */
|
|
caretOffset: number;
|
|
}
|
|
interface RenameLocation {
|
|
textSpan: TextSpan;
|
|
fileName: string;
|
|
}
|
|
interface ReferenceEntry {
|
|
textSpan: TextSpan;
|
|
fileName: string;
|
|
isWriteAccess: boolean;
|
|
isDefinition: boolean;
|
|
}
|
|
interface ImplementationLocation {
|
|
textSpan: TextSpan;
|
|
fileName: string;
|
|
}
|
|
interface DocumentHighlights {
|
|
fileName: string;
|
|
highlightSpans: HighlightSpan[];
|
|
}
|
|
namespace HighlightSpanKind {
|
|
const none = "none";
|
|
const definition = "definition";
|
|
const reference = "reference";
|
|
const writtenReference = "writtenReference";
|
|
}
|
|
interface HighlightSpan {
|
|
fileName?: string;
|
|
textSpan: TextSpan;
|
|
kind: string;
|
|
}
|
|
interface NavigateToItem {
|
|
name: string;
|
|
kind: string;
|
|
kindModifiers: string;
|
|
matchKind: string;
|
|
isCaseSensitive: boolean;
|
|
fileName: string;
|
|
textSpan: TextSpan;
|
|
containerName: string;
|
|
containerKind: string;
|
|
}
|
|
enum IndentStyle {
|
|
None = 0,
|
|
Block = 1,
|
|
Smart = 2,
|
|
}
|
|
interface EditorOptions {
|
|
BaseIndentSize?: number;
|
|
IndentSize: number;
|
|
TabSize: number;
|
|
NewLineCharacter: string;
|
|
ConvertTabsToSpaces: boolean;
|
|
IndentStyle: IndentStyle;
|
|
}
|
|
interface EditorSettings {
|
|
baseIndentSize?: number;
|
|
indentSize?: number;
|
|
tabSize?: number;
|
|
newLineCharacter?: string;
|
|
convertTabsToSpaces?: boolean;
|
|
indentStyle?: IndentStyle;
|
|
}
|
|
interface FormatCodeOptions extends EditorOptions {
|
|
InsertSpaceAfterCommaDelimiter: boolean;
|
|
InsertSpaceAfterSemicolonInForStatements: boolean;
|
|
InsertSpaceBeforeAndAfterBinaryOperators: boolean;
|
|
InsertSpaceAfterKeywordsInControlFlowStatements: boolean;
|
|
InsertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean;
|
|
InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean;
|
|
InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: boolean;
|
|
InsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean;
|
|
InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: boolean;
|
|
InsertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
|
|
InsertSpaceAfterTypeAssertion?: boolean;
|
|
PlaceOpenBraceOnNewLineForFunctions: boolean;
|
|
PlaceOpenBraceOnNewLineForControlBlocks: boolean;
|
|
}
|
|
interface FormatCodeSettings extends EditorSettings {
|
|
insertSpaceAfterCommaDelimiter?: boolean;
|
|
insertSpaceAfterSemicolonInForStatements?: boolean;
|
|
insertSpaceBeforeAndAfterBinaryOperators?: boolean;
|
|
insertSpaceAfterKeywordsInControlFlowStatements?: boolean;
|
|
insertSpaceAfterFunctionKeywordForAnonymousFunctions?: boolean;
|
|
insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis?: boolean;
|
|
insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets?: boolean;
|
|
insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean;
|
|
insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean;
|
|
insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
|
|
insertSpaceAfterTypeAssertion?: boolean;
|
|
placeOpenBraceOnNewLineForFunctions?: boolean;
|
|
placeOpenBraceOnNewLineForControlBlocks?: boolean;
|
|
}
|
|
interface DefinitionInfo {
|
|
fileName: string;
|
|
textSpan: TextSpan;
|
|
kind: string;
|
|
name: string;
|
|
containerKind: string;
|
|
containerName: string;
|
|
}
|
|
interface ReferencedSymbolDefinitionInfo extends DefinitionInfo {
|
|
displayParts: SymbolDisplayPart[];
|
|
}
|
|
interface ReferencedSymbol {
|
|
definition: ReferencedSymbolDefinitionInfo;
|
|
references: ReferenceEntry[];
|
|
}
|
|
enum SymbolDisplayPartKind {
|
|
aliasName = 0,
|
|
className = 1,
|
|
enumName = 2,
|
|
fieldName = 3,
|
|
interfaceName = 4,
|
|
keyword = 5,
|
|
lineBreak = 6,
|
|
numericLiteral = 7,
|
|
stringLiteral = 8,
|
|
localName = 9,
|
|
methodName = 10,
|
|
moduleName = 11,
|
|
operator = 12,
|
|
parameterName = 13,
|
|
propertyName = 14,
|
|
punctuation = 15,
|
|
space = 16,
|
|
text = 17,
|
|
typeParameterName = 18,
|
|
enumMemberName = 19,
|
|
functionName = 20,
|
|
regularExpressionLiteral = 21,
|
|
}
|
|
interface SymbolDisplayPart {
|
|
text: string;
|
|
kind: string;
|
|
}
|
|
interface QuickInfo {
|
|
kind: string;
|
|
kindModifiers: string;
|
|
textSpan: TextSpan;
|
|
displayParts: SymbolDisplayPart[];
|
|
documentation: SymbolDisplayPart[];
|
|
}
|
|
interface RenameInfo {
|
|
canRename: boolean;
|
|
localizedErrorMessage: string;
|
|
displayName: string;
|
|
fullDisplayName: string;
|
|
kind: string;
|
|
kindModifiers: string;
|
|
triggerSpan: TextSpan;
|
|
}
|
|
interface SignatureHelpParameter {
|
|
name: string;
|
|
documentation: SymbolDisplayPart[];
|
|
displayParts: SymbolDisplayPart[];
|
|
isOptional: boolean;
|
|
}
|
|
/**
|
|
* Represents a single signature to show in signature help.
|
|
* The id is used for subsequent calls into the language service to ask questions about the
|
|
* signature help item in the context of any documents that have been updated. i.e. after
|
|
* an edit has happened, while signature help is still active, the host can ask important
|
|
* questions like 'what parameter is the user currently contained within?'.
|
|
*/
|
|
interface SignatureHelpItem {
|
|
isVariadic: boolean;
|
|
prefixDisplayParts: SymbolDisplayPart[];
|
|
suffixDisplayParts: SymbolDisplayPart[];
|
|
separatorDisplayParts: SymbolDisplayPart[];
|
|
parameters: SignatureHelpParameter[];
|
|
documentation: SymbolDisplayPart[];
|
|
}
|
|
/**
|
|
* Represents a set of signature help items, and the preferred item that should be selected.
|
|
*/
|
|
interface SignatureHelpItems {
|
|
items: SignatureHelpItem[];
|
|
applicableSpan: TextSpan;
|
|
selectedItemIndex: number;
|
|
argumentIndex: number;
|
|
argumentCount: number;
|
|
}
|
|
interface CompletionInfo {
|
|
isGlobalCompletion: boolean;
|
|
isMemberCompletion: boolean;
|
|
/**
|
|
* true when the current location also allows for a new identifier
|
|
*/
|
|
isNewIdentifierLocation: boolean;
|
|
entries: CompletionEntry[];
|
|
}
|
|
interface CompletionEntry {
|
|
name: string;
|
|
kind: string;
|
|
kindModifiers: string;
|
|
sortText: string;
|
|
/**
|
|
* An optional span that indicates the text to be replaced by this completion item. It will be
|
|
* set if the required span differs from the one generated by the default replacement behavior and should
|
|
* be used in that case
|
|
*/
|
|
replacementSpan?: TextSpan;
|
|
}
|
|
interface CompletionEntryDetails {
|
|
name: string;
|
|
kind: string;
|
|
kindModifiers: string;
|
|
displayParts: SymbolDisplayPart[];
|
|
documentation: SymbolDisplayPart[];
|
|
}
|
|
interface OutliningSpan {
|
|
/** The span of the document to actually collapse. */
|
|
textSpan: TextSpan;
|
|
/** The span of the document to display when the user hovers over the collapsed span. */
|
|
hintSpan: TextSpan;
|
|
/** The text to display in the editor for the collapsed region. */
|
|
bannerText: string;
|
|
/**
|
|
* Whether or not this region should be automatically collapsed when
|
|
* the 'Collapse to Definitions' command is invoked.
|
|
*/
|
|
autoCollapse: boolean;
|
|
}
|
|
interface EmitOutput {
|
|
outputFiles: OutputFile[];
|
|
emitSkipped: boolean;
|
|
}
|
|
enum OutputFileType {
|
|
JavaScript = 0,
|
|
SourceMap = 1,
|
|
Declaration = 2,
|
|
}
|
|
interface OutputFile {
|
|
name: string;
|
|
writeByteOrderMark: boolean;
|
|
text: string;
|
|
}
|
|
enum EndOfLineState {
|
|
None = 0,
|
|
InMultiLineCommentTrivia = 1,
|
|
InSingleQuoteStringLiteral = 2,
|
|
InDoubleQuoteStringLiteral = 3,
|
|
InTemplateHeadOrNoSubstitutionTemplate = 4,
|
|
InTemplateMiddleOrTail = 5,
|
|
InTemplateSubstitutionPosition = 6,
|
|
}
|
|
enum TokenClass {
|
|
Punctuation = 0,
|
|
Keyword = 1,
|
|
Operator = 2,
|
|
Comment = 3,
|
|
Whitespace = 4,
|
|
Identifier = 5,
|
|
NumberLiteral = 6,
|
|
StringLiteral = 7,
|
|
RegExpLiteral = 8,
|
|
}
|
|
interface ClassificationResult {
|
|
finalLexState: EndOfLineState;
|
|
entries: ClassificationInfo[];
|
|
}
|
|
interface ClassificationInfo {
|
|
length: number;
|
|
classification: TokenClass;
|
|
}
|
|
interface Classifier {
|
|
/**
|
|
* Gives lexical classifications of tokens on a line without any syntactic context.
|
|
* For instance, a token consisting of the text 'string' can be either an identifier
|
|
* named 'string' or the keyword 'string', however, because this classifier is not aware,
|
|
* it relies on certain heuristics to give acceptable results. For classifications where
|
|
* speed trumps accuracy, this function is preferable; however, for true accuracy, the
|
|
* syntactic classifier is ideal. In fact, in certain editing scenarios, combining the
|
|
* lexical, syntactic, and semantic classifiers may issue the best user experience.
|
|
*
|
|
* @param text The text of a line to classify.
|
|
* @param lexState The state of the lexical classifier at the end of the previous line.
|
|
* @param syntacticClassifierAbsent Whether the client is *not* using a syntactic classifier.
|
|
* If there is no syntactic classifier (syntacticClassifierAbsent=true),
|
|
* certain heuristics may be used in its place; however, if there is a
|
|
* syntactic classifier (syntacticClassifierAbsent=false), certain
|
|
* classifications which may be incorrectly categorized will be given
|
|
* back as Identifiers in order to allow the syntactic classifier to
|
|
* subsume the classification.
|
|
* @deprecated Use getLexicalClassifications instead.
|
|
*/
|
|
getClassificationsForLine(text: string, lexState: EndOfLineState, syntacticClassifierAbsent: boolean): ClassificationResult;
|
|
getEncodedLexicalClassifications(text: string, endOfLineState: EndOfLineState, syntacticClassifierAbsent: boolean): Classifications;
|
|
}
|
|
namespace ScriptElementKind {
|
|
const unknown = "";
|
|
const warning = "warning";
|
|
/** predefined type (void) or keyword (class) */
|
|
const keyword = "keyword";
|
|
/** top level script node */
|
|
const scriptElement = "script";
|
|
/** module foo {} */
|
|
const moduleElement = "module";
|
|
/** class X {} */
|
|
const classElement = "class";
|
|
/** var x = class X {} */
|
|
const localClassElement = "local class";
|
|
/** interface Y {} */
|
|
const interfaceElement = "interface";
|
|
/** type T = ... */
|
|
const typeElement = "type";
|
|
/** enum E */
|
|
const enumElement = "enum";
|
|
const enumMemberElement = "const";
|
|
/**
|
|
* Inside module and script only
|
|
* const v = ..
|
|
*/
|
|
const variableElement = "var";
|
|
/** Inside function */
|
|
const localVariableElement = "local var";
|
|
/**
|
|
* Inside module and script only
|
|
* function f() { }
|
|
*/
|
|
const functionElement = "function";
|
|
/** Inside function */
|
|
const localFunctionElement = "local function";
|
|
/** class X { [public|private]* foo() {} } */
|
|
const memberFunctionElement = "method";
|
|
/** class X { [public|private]* [get|set] foo:number; } */
|
|
const memberGetAccessorElement = "getter";
|
|
const memberSetAccessorElement = "setter";
|
|
/**
|
|
* class X { [public|private]* foo:number; }
|
|
* interface Y { foo:number; }
|
|
*/
|
|
const memberVariableElement = "property";
|
|
/** class X { constructor() { } } */
|
|
const constructorImplementationElement = "constructor";
|
|
/** interface Y { ():number; } */
|
|
const callSignatureElement = "call";
|
|
/** interface Y { []:number; } */
|
|
const indexSignatureElement = "index";
|
|
/** interface Y { new():Y; } */
|
|
const constructSignatureElement = "construct";
|
|
/** function foo(*Y*: string) */
|
|
const parameterElement = "parameter";
|
|
const typeParameterElement = "type parameter";
|
|
const primitiveType = "primitive type";
|
|
const label = "label";
|
|
const alias = "alias";
|
|
const constElement = "const";
|
|
const letElement = "let";
|
|
const directory = "directory";
|
|
const externalModuleName = "external module name";
|
|
}
|
|
namespace ScriptElementKindModifier {
|
|
const none = "";
|
|
const publicMemberModifier = "public";
|
|
const privateMemberModifier = "private";
|
|
const protectedMemberModifier = "protected";
|
|
const exportedModifier = "export";
|
|
const ambientModifier = "declare";
|
|
const staticModifier = "static";
|
|
const abstractModifier = "abstract";
|
|
}
|
|
class ClassificationTypeNames {
|
|
static comment: string;
|
|
static identifier: string;
|
|
static keyword: string;
|
|
static numericLiteral: string;
|
|
static operator: string;
|
|
static stringLiteral: string;
|
|
static whiteSpace: string;
|
|
static text: string;
|
|
static punctuation: string;
|
|
static className: string;
|
|
static enumName: string;
|
|
static interfaceName: string;
|
|
static moduleName: string;
|
|
static typeParameterName: string;
|
|
static typeAliasName: string;
|
|
static parameterName: string;
|
|
static docCommentTagName: string;
|
|
static jsxOpenTagName: string;
|
|
static jsxCloseTagName: string;
|
|
static jsxSelfClosingTagName: string;
|
|
static jsxAttribute: string;
|
|
static jsxText: string;
|
|
static jsxAttributeStringLiteralValue: string;
|
|
}
|
|
enum ClassificationType {
|
|
comment = 1,
|
|
identifier = 2,
|
|
keyword = 3,
|
|
numericLiteral = 4,
|
|
operator = 5,
|
|
stringLiteral = 6,
|
|
regularExpressionLiteral = 7,
|
|
whiteSpace = 8,
|
|
text = 9,
|
|
punctuation = 10,
|
|
className = 11,
|
|
enumName = 12,
|
|
interfaceName = 13,
|
|
moduleName = 14,
|
|
typeParameterName = 15,
|
|
typeAliasName = 16,
|
|
parameterName = 17,
|
|
docCommentTagName = 18,
|
|
jsxOpenTagName = 19,
|
|
jsxCloseTagName = 20,
|
|
jsxSelfClosingTagName = 21,
|
|
jsxAttribute = 22,
|
|
jsxText = 23,
|
|
jsxAttributeStringLiteralValue = 24,
|
|
}
|
|
}
|
|
declare namespace ts {
|
|
function createClassifier(): Classifier;
|
|
}
|
|
declare namespace ts {
|
|
/**
|
|
* The document registry represents a store of SourceFile objects that can be shared between
|
|
* multiple LanguageService instances. A LanguageService instance holds on the SourceFile (AST)
|
|
* of files in the context.
|
|
* SourceFile objects account for most of the memory usage by the language service. Sharing
|
|
* the same DocumentRegistry instance between different instances of LanguageService allow
|
|
* for more efficient memory utilization since all projects will share at least the library
|
|
* file (lib.d.ts).
|
|
*
|
|
* A more advanced use of the document registry is to serialize sourceFile objects to disk
|
|
* and re-hydrate them when needed.
|
|
*
|
|
* To create a default DocumentRegistry, use createDocumentRegistry to create one, and pass it
|
|
* to all subsequent createLanguageService calls.
|
|
*/
|
|
interface DocumentRegistry {
|
|
/**
|
|
* Request a stored SourceFile with a given fileName and compilationSettings.
|
|
* The first call to acquire will call createLanguageServiceSourceFile to generate
|
|
* the SourceFile if was not found in the registry.
|
|
*
|
|
* @param fileName The name of the file requested
|
|
* @param compilationSettings Some compilation settings like target affects the
|
|
* shape of a the resulting SourceFile. This allows the DocumentRegistry to store
|
|
* multiple copies of the same file for different compilation settings.
|
|
* @parm scriptSnapshot Text of the file. Only used if the file was not found
|
|
* in the registry and a new one was created.
|
|
* @parm version Current version of the file. Only used if the file was not found
|
|
* in the registry and a new one was created.
|
|
*/
|
|
acquireDocument(fileName: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile;
|
|
acquireDocumentWithKey(fileName: string, path: Path, compilationSettings: CompilerOptions, key: DocumentRegistryBucketKey, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile;
|
|
/**
|
|
* Request an updated version of an already existing SourceFile with a given fileName
|
|
* and compilationSettings. The update will in-turn call updateLanguageServiceSourceFile
|
|
* to get an updated SourceFile.
|
|
*
|
|
* @param fileName The name of the file requested
|
|
* @param compilationSettings Some compilation settings like target affects the
|
|
* shape of a the resulting SourceFile. This allows the DocumentRegistry to store
|
|
* multiple copies of the same file for different compilation settings.
|
|
* @param scriptSnapshot Text of the file.
|
|
* @param version Current version of the file.
|
|
*/
|
|
updateDocument(fileName: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile;
|
|
updateDocumentWithKey(fileName: string, path: Path, compilationSettings: CompilerOptions, key: DocumentRegistryBucketKey, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile;
|
|
getKeyForCompilationSettings(settings: CompilerOptions): DocumentRegistryBucketKey;
|
|
/**
|
|
* Informs the DocumentRegistry that a file is not needed any longer.
|
|
*
|
|
* Note: It is not allowed to call release on a SourceFile that was not acquired from
|
|
* this registry originally.
|
|
*
|
|
* @param fileName The name of the file to be released
|
|
* @param compilationSettings The compilation settings used to acquire the file
|
|
*/
|
|
releaseDocument(fileName: string, compilationSettings: CompilerOptions): void;
|
|
releaseDocumentWithKey(path: Path, key: DocumentRegistryBucketKey): void;
|
|
reportStats(): string;
|
|
}
|
|
type DocumentRegistryBucketKey = string & {
|
|
__bucketKey: any;
|
|
};
|
|
function createDocumentRegistry(useCaseSensitiveFileNames?: boolean, currentDirectory?: string): DocumentRegistry;
|
|
}
|
|
declare namespace ts {
|
|
function preProcessFile(sourceText: string, readImportFiles?: boolean, detectJavaScriptImports?: boolean): PreProcessedFileInfo;
|
|
}
|
|
declare namespace ts {
|
|
interface TranspileOptions {
|
|
compilerOptions?: CompilerOptions;
|
|
fileName?: string;
|
|
reportDiagnostics?: boolean;
|
|
moduleName?: string;
|
|
renamedDependencies?: MapLike<string>;
|
|
}
|
|
interface TranspileOutput {
|
|
outputText: string;
|
|
diagnostics?: Diagnostic[];
|
|
sourceMapText?: string;
|
|
}
|
|
function transpileModule(input: string, transpileOptions: TranspileOptions): TranspileOutput;
|
|
function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[], moduleName?: string): string;
|
|
}
|
|
declare namespace ts {
|
|
/** The version of the language service API */
|
|
const servicesVersion = "0.5";
|
|
interface DisplayPartsSymbolWriter extends SymbolWriter {
|
|
displayParts(): SymbolDisplayPart[];
|
|
}
|
|
function toEditorSettings(options: EditorOptions | EditorSettings): EditorSettings;
|
|
function displayPartsToString(displayParts: SymbolDisplayPart[]): string;
|
|
function getDefaultCompilerOptions(): CompilerOptions;
|
|
function getSupportedCodeFixes(): string[];
|
|
function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean, scriptKind?: ScriptKind): SourceFile;
|
|
let disableIncrementalParsing: boolean;
|
|
function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;
|
|
function createLanguageService(host: LanguageServiceHost, documentRegistry?: DocumentRegistry): LanguageService;
|
|
/**
|
|
* Get the path of the default library files (lib.d.ts) as distributed with the typescript
|
|
* node package.
|
|
* The functionality is not supported if the ts module is consumed outside of a node module.
|
|
*/
|
|
function getDefaultLibFilePath(options: CompilerOptions): string;
|
|
}
|