Merge branch 'master' into exportDefaultReference
Conflicts: src/compiler/utilities.ts
This commit is contained in:
commit
f75c1dd7b6
9
Jakefile
9
Jakefile
|
@ -111,6 +111,7 @@ var definitionsRoots = [
|
|||
"compiler/parser.d.ts",
|
||||
"compiler/checker.d.ts",
|
||||
"compiler/program.d.ts",
|
||||
"compiler/commandLineParser.d.ts",
|
||||
"services/services.d.ts",
|
||||
];
|
||||
|
||||
|
@ -222,15 +223,17 @@ function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, noOu
|
|||
var dir = useBuiltCompiler ? builtLocalDirectory : LKGDirectory;
|
||||
var options = "--module commonjs -noImplicitAny";
|
||||
|
||||
if (!keepComments) {
|
||||
options += " -removeComments";
|
||||
// Keep comments when specifically requested
|
||||
// or when in debug mode.
|
||||
if (!(keepComments || useDebugMode)) {
|
||||
options += " --removeComments";
|
||||
}
|
||||
|
||||
if (generateDeclarations) {
|
||||
options += " --declaration";
|
||||
}
|
||||
|
||||
if (useDebugMode || preserveConstEnums) {
|
||||
if (preserveConstEnums || useDebugMode) {
|
||||
options += " --preserveConstEnums";
|
||||
}
|
||||
|
||||
|
|
|
@ -168,7 +168,7 @@ module ts {
|
|||
addDeclarationToSymbol(symbol, node, includes);
|
||||
symbol.parent = parent;
|
||||
|
||||
if (node.kind === SyntaxKind.ClassDeclaration && symbol.exports) {
|
||||
if ((node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression) && symbol.exports) {
|
||||
// TypeScript 1.0 spec (April 2014): 8.4
|
||||
// Every class automatically contains a static property member named 'prototype',
|
||||
// the type of which is an instantiation of the class type with type Any supplied as a type argument for each type parameter.
|
||||
|
@ -286,6 +286,7 @@ module ts {
|
|||
case SyntaxKind.ArrowFunction:
|
||||
declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes);
|
||||
break;
|
||||
case SyntaxKind.ClassExpression:
|
||||
case SyntaxKind.ClassDeclaration:
|
||||
if (node.flags & NodeFlags.Static) {
|
||||
declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes);
|
||||
|
@ -485,6 +486,9 @@ module ts {
|
|||
case SyntaxKind.ArrowFunction:
|
||||
bindAnonymousDeclaration(<FunctionExpression>node, SymbolFlags.Function, "__function", /*isBlockScopeContainer*/ true);
|
||||
break;
|
||||
case SyntaxKind.ClassExpression:
|
||||
bindAnonymousDeclaration(<ClassExpression>node, SymbolFlags.Class, "__class", /*isBlockScopeContainer*/ false);
|
||||
break;
|
||||
case SyntaxKind.CatchClause:
|
||||
bindCatchVariableDeclaration(<CatchClause>node);
|
||||
break;
|
||||
|
@ -584,9 +588,9 @@ module ts {
|
|||
// containing class.
|
||||
if (node.flags & NodeFlags.AccessibilityModifier &&
|
||||
node.parent.kind === SyntaxKind.Constructor &&
|
||||
node.parent.parent.kind === SyntaxKind.ClassDeclaration) {
|
||||
(node.parent.parent.kind === SyntaxKind.ClassDeclaration || node.parent.parent.kind === SyntaxKind.ClassExpression)) {
|
||||
|
||||
let classDeclaration = <ClassDeclaration>node.parent.parent;
|
||||
let classDeclaration = <ClassLikeDeclaration>node.parent.parent;
|
||||
declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -430,8 +430,15 @@ module ts {
|
|||
result = argumentsSymbol;
|
||||
break loop;
|
||||
}
|
||||
let id = (<FunctionExpression>location).name;
|
||||
if (id && name === id.text) {
|
||||
let functionName = (<FunctionExpression>location).name;
|
||||
if (functionName && name === functionName.text) {
|
||||
result = location.symbol;
|
||||
break loop;
|
||||
}
|
||||
break;
|
||||
case SyntaxKind.ClassExpression:
|
||||
let className = (<ClassExpression>location).name;
|
||||
if (className && name === className.text) {
|
||||
result = location.symbol;
|
||||
break loop;
|
||||
}
|
||||
|
@ -590,7 +597,7 @@ module ts {
|
|||
if (moduleSymbol.flags & SymbolFlags.Variable) {
|
||||
let typeAnnotation = (<VariableDeclaration>moduleSymbol.valueDeclaration).type;
|
||||
if (typeAnnotation) {
|
||||
return getPropertyOfType(getTypeFromTypeNode(typeAnnotation), name);
|
||||
return getPropertyOfType(getTypeFromTypeNodeOrHeritageClauseElement(typeAnnotation), name);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -639,7 +646,7 @@ module ts {
|
|||
if (symbol.flags & SymbolFlags.Variable) {
|
||||
var typeAnnotation = (<VariableDeclaration>symbol.valueDeclaration).type;
|
||||
if (typeAnnotation) {
|
||||
return resolveSymbol(getPropertyOfType(getTypeFromTypeNode(typeAnnotation), name));
|
||||
return resolveSymbol(getPropertyOfType(getTypeFromTypeNodeOrHeritageClauseElement(typeAnnotation), name));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -721,8 +728,14 @@ module ts {
|
|||
function markExportAsReferenced(node: ImportEqualsDeclaration | ExportAssignment | ExportSpecifier) {
|
||||
let symbol = getSymbolOfNode(node);
|
||||
let target = resolveAlias(symbol);
|
||||
if (target && target !== unknownSymbol && target.flags & SymbolFlags.Value && !isConstEnumOrConstEnumOnlyModule(target)) {
|
||||
markAliasSymbolAsReferenced(symbol);
|
||||
if (target) {
|
||||
let markAlias =
|
||||
(target === unknownSymbol && compilerOptions.separateCompilation) ||
|
||||
(target !== unknownSymbol && (target.flags & SymbolFlags.Value) && !isConstEnumOrConstEnumOnlyModule(target));
|
||||
|
||||
if (markAlias) {
|
||||
markAliasSymbolAsReferenced(symbol);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -781,8 +794,8 @@ module ts {
|
|||
}
|
||||
|
||||
// Resolves a qualified name and any involved aliases
|
||||
function resolveEntityName(name: EntityName, meaning: SymbolFlags): Symbol {
|
||||
if (getFullWidth(name) === 0) {
|
||||
function resolveEntityName(name: EntityName | Expression, meaning: SymbolFlags): Symbol {
|
||||
if (nodeIsMissing(name)) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
|
@ -793,18 +806,23 @@ module ts {
|
|||
return undefined;
|
||||
}
|
||||
}
|
||||
else if (name.kind === SyntaxKind.QualifiedName) {
|
||||
let namespace = resolveEntityName((<QualifiedName>name).left, SymbolFlags.Namespace);
|
||||
if (!namespace || namespace === unknownSymbol || getFullWidth((<QualifiedName>name).right) === 0) {
|
||||
else if (name.kind === SyntaxKind.QualifiedName || name.kind === SyntaxKind.PropertyAccessExpression) {
|
||||
let left = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).left : (<PropertyAccessExpression>name).expression;
|
||||
let right = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).right : (<PropertyAccessExpression>name).name;
|
||||
|
||||
let namespace = resolveEntityName(left, SymbolFlags.Namespace);
|
||||
if (!namespace || namespace === unknownSymbol || nodeIsMissing(right)) {
|
||||
return undefined;
|
||||
}
|
||||
let right = (<QualifiedName>name).right;
|
||||
symbol = getSymbol(getExportsOfSymbol(namespace), right.text, meaning);
|
||||
if (!symbol) {
|
||||
error(right, Diagnostics.Module_0_has_no_exported_member_1, getFullyQualifiedName(namespace), declarationNameToString(right));
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
else {
|
||||
Debug.fail("Unknown entity name kind.");
|
||||
}
|
||||
Debug.assert((symbol.flags & SymbolFlags.Instantiated) === 0, "Should never get an instantiated symbol here.");
|
||||
return symbol.flags & meaning ? symbol : resolveAlias(symbol);
|
||||
}
|
||||
|
@ -1099,7 +1117,7 @@ module ts {
|
|||
|
||||
// Check if symbol is any of the alias
|
||||
return forEachValue(symbols, symbolFromSymbolTable => {
|
||||
if (symbolFromSymbolTable.flags & SymbolFlags.Alias) {
|
||||
if (symbolFromSymbolTable.flags & SymbolFlags.Alias && symbolFromSymbolTable.name !== "export=") {
|
||||
if (!useOnlyExternalAliasing || // We can use any type of alias to get the name
|
||||
// Is this external alias, then use it to name
|
||||
ts.forEach(symbolFromSymbolTable.declarations, isExternalModuleImportEqualsDeclaration)) {
|
||||
|
@ -1263,14 +1281,14 @@ module ts {
|
|||
}
|
||||
}
|
||||
|
||||
function isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult {
|
||||
function isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult {
|
||||
// get symbol of the first identifier of the entityName
|
||||
let meaning: SymbolFlags;
|
||||
if (entityName.parent.kind === SyntaxKind.TypeQuery) {
|
||||
// Typeof value
|
||||
meaning = SymbolFlags.Value | SymbolFlags.ExportValue;
|
||||
}
|
||||
else if (entityName.kind === SyntaxKind.QualifiedName ||
|
||||
else if (entityName.kind === SyntaxKind.QualifiedName || entityName.kind === SyntaxKind.PropertyAccessExpression ||
|
||||
entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration) {
|
||||
// Left identifier from type reference or TypeAlias
|
||||
// Entity name of the import declaration
|
||||
|
@ -1940,6 +1958,10 @@ module ts {
|
|||
case SyntaxKind.SourceFile:
|
||||
return true;
|
||||
|
||||
// Export assignements do not create name bindings outside the module
|
||||
case SyntaxKind.ExportAssignment:
|
||||
return false;
|
||||
|
||||
default:
|
||||
Debug.fail("isDeclarationVisible unknown: SyntaxKind: " + node.kind);
|
||||
}
|
||||
|
@ -2096,7 +2118,7 @@ module ts {
|
|||
}
|
||||
// Use type from type annotation if one is present
|
||||
if (declaration.type) {
|
||||
return getTypeFromTypeNode(declaration.type);
|
||||
return getTypeFromTypeNodeOrHeritageClauseElement(declaration.type);
|
||||
}
|
||||
if (declaration.kind === SyntaxKind.Parameter) {
|
||||
let func = <FunctionLikeDeclaration>declaration.parent;
|
||||
|
@ -2233,7 +2255,7 @@ module ts {
|
|||
return links.type = checkExpression(exportAssignment.expression);
|
||||
}
|
||||
else if (exportAssignment.type) {
|
||||
return links.type = getTypeFromTypeNode(exportAssignment.type);
|
||||
return links.type = getTypeFromTypeNodeOrHeritageClauseElement(exportAssignment.type);
|
||||
}
|
||||
else {
|
||||
return links.type = anyType;
|
||||
|
@ -2265,11 +2287,11 @@ module ts {
|
|||
function getAnnotatedAccessorType(accessor: AccessorDeclaration): Type {
|
||||
if (accessor) {
|
||||
if (accessor.kind === SyntaxKind.GetAccessor) {
|
||||
return accessor.type && getTypeFromTypeNode(accessor.type);
|
||||
return accessor.type && getTypeFromTypeNodeOrHeritageClauseElement(accessor.type);
|
||||
}
|
||||
else {
|
||||
let setterTypeAnnotation = getSetAccessorTypeAnnotationNode(accessor);
|
||||
return setterTypeAnnotation && getTypeFromTypeNode(setterTypeAnnotation);
|
||||
return setterTypeAnnotation && getTypeFromTypeNodeOrHeritageClauseElement(setterTypeAnnotation);
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
|
@ -2435,9 +2457,9 @@ module ts {
|
|||
}
|
||||
type.baseTypes = [];
|
||||
let declaration = <ClassDeclaration>getDeclarationOfKind(symbol, SyntaxKind.ClassDeclaration);
|
||||
let baseTypeNode = getClassBaseTypeNode(declaration);
|
||||
let baseTypeNode = getClassExtendsHeritageClauseElement(declaration);
|
||||
if (baseTypeNode) {
|
||||
let baseType = getTypeFromTypeReferenceNode(baseTypeNode);
|
||||
let baseType = getTypeFromHeritageClauseElement(baseTypeNode);
|
||||
if (baseType !== unknownType) {
|
||||
if (getTargetType(baseType).flags & TypeFlags.Class) {
|
||||
if (type !== baseType && !hasBaseType(<InterfaceType>baseType, type)) {
|
||||
|
@ -2478,7 +2500,8 @@ module ts {
|
|||
forEach(symbol.declarations, declaration => {
|
||||
if (declaration.kind === SyntaxKind.InterfaceDeclaration && getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration)) {
|
||||
forEach(getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration), node => {
|
||||
let baseType = getTypeFromTypeReferenceNode(node);
|
||||
let baseType = getTypeFromHeritageClauseElement(node);
|
||||
|
||||
if (baseType !== unknownType) {
|
||||
if (getTargetType(baseType).flags & (TypeFlags.Class | TypeFlags.Interface)) {
|
||||
if (type !== baseType && !hasBaseType(<InterfaceType>baseType, type)) {
|
||||
|
@ -2509,7 +2532,7 @@ module ts {
|
|||
if (!links.declaredType) {
|
||||
links.declaredType = resolvingType;
|
||||
let declaration = <TypeAliasDeclaration>getDeclarationOfKind(symbol, SyntaxKind.TypeAliasDeclaration);
|
||||
let type = getTypeFromTypeNode(declaration.type);
|
||||
let type = getTypeFromTypeNodeOrHeritageClauseElement(declaration.type);
|
||||
if (links.declaredType === resolvingType) {
|
||||
links.declaredType = type;
|
||||
}
|
||||
|
@ -3051,7 +3074,7 @@ module ts {
|
|||
returnType = classType;
|
||||
}
|
||||
else if (declaration.type) {
|
||||
returnType = getTypeFromTypeNode(declaration.type);
|
||||
returnType = getTypeFromTypeNodeOrHeritageClauseElement(declaration.type);
|
||||
}
|
||||
else {
|
||||
// TypeScript 1.0 spec (April 2014):
|
||||
|
@ -3209,7 +3232,7 @@ module ts {
|
|||
function getIndexTypeOfSymbol(symbol: Symbol, kind: IndexKind): Type {
|
||||
let declaration = getIndexDeclarationOfSymbol(symbol, kind);
|
||||
return declaration
|
||||
? declaration.type ? getTypeFromTypeNode(declaration.type) : anyType
|
||||
? declaration.type ? getTypeFromTypeNodeOrHeritageClauseElement(declaration.type) : anyType
|
||||
: undefined;
|
||||
}
|
||||
|
||||
|
@ -3220,7 +3243,7 @@ module ts {
|
|||
type.constraint = targetConstraint ? instantiateType(targetConstraint, type.mapper) : noConstraintType;
|
||||
}
|
||||
else {
|
||||
type.constraint = getTypeFromTypeNode((<TypeParameterDeclaration>getDeclarationOfKind(type.symbol, SyntaxKind.TypeParameter)).constraint);
|
||||
type.constraint = getTypeFromTypeNodeOrHeritageClauseElement((<TypeParameterDeclaration>getDeclarationOfKind(type.symbol, SyntaxKind.TypeParameter)).constraint);
|
||||
}
|
||||
}
|
||||
return type.constraint === noConstraintType ? undefined : type.constraint;
|
||||
|
@ -3268,7 +3291,7 @@ module ts {
|
|||
return type;
|
||||
}
|
||||
|
||||
function isTypeParameterReferenceIllegalInConstraint(typeReferenceNode: TypeReferenceNode, typeParameterSymbol: Symbol): boolean {
|
||||
function isTypeParameterReferenceIllegalInConstraint(typeReferenceNode: TypeReferenceNode | HeritageClauseElement, typeParameterSymbol: Symbol): boolean {
|
||||
let links = getNodeLinks(typeReferenceNode);
|
||||
if (links.isIllegalTypeReferenceInConstraint !== undefined) {
|
||||
return links.isIllegalTypeReferenceInConstraint;
|
||||
|
@ -3317,39 +3340,57 @@ module ts {
|
|||
}
|
||||
}
|
||||
|
||||
function getTypeFromTypeReferenceNode(node: TypeReferenceNode): Type {
|
||||
function getTypeFromTypeReference(node: TypeReferenceNode): Type {
|
||||
return getTypeFromTypeReferenceOrHeritageClauseElement(node);
|
||||
}
|
||||
|
||||
function getTypeFromHeritageClauseElement(node: HeritageClauseElement): Type {
|
||||
return getTypeFromTypeReferenceOrHeritageClauseElement(node);
|
||||
}
|
||||
|
||||
function getTypeFromTypeReferenceOrHeritageClauseElement(node: TypeReferenceNode | HeritageClauseElement): Type {
|
||||
let links = getNodeLinks(node);
|
||||
if (!links.resolvedType) {
|
||||
let symbol = resolveEntityName(node.typeName, SymbolFlags.Type);
|
||||
let type: Type;
|
||||
if (symbol) {
|
||||
if ((symbol.flags & SymbolFlags.TypeParameter) && isTypeParameterReferenceIllegalInConstraint(node, symbol)) {
|
||||
// TypeScript 1.0 spec (April 2014): 3.4.1
|
||||
// Type parameters declared in a particular type parameter list
|
||||
// may not be referenced in constraints in that type parameter list
|
||||
// Implementation: such type references are resolved to 'unknown' type that usually denotes error
|
||||
type = unknownType;
|
||||
}
|
||||
else {
|
||||
type = getDeclaredTypeOfSymbol(symbol);
|
||||
if (type.flags & (TypeFlags.Class | TypeFlags.Interface) && type.flags & TypeFlags.Reference) {
|
||||
let typeParameters = (<InterfaceType>type).typeParameters;
|
||||
if (node.typeArguments && node.typeArguments.length === typeParameters.length) {
|
||||
type = createTypeReference(<GenericType>type, map(node.typeArguments, getTypeFromTypeNode));
|
||||
}
|
||||
else {
|
||||
error(node, Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, /*enclosingDeclaration*/ undefined, TypeFormatFlags.WriteArrayAsGenericType), typeParameters.length);
|
||||
type = undefined;
|
||||
}
|
||||
|
||||
// We don't currently support heritage clauses with complex expressions in them.
|
||||
// For these cases, we just set the type to be the unknownType.
|
||||
if (node.kind !== SyntaxKind.HeritageClauseElement || isSupportedHeritageClauseElement(<HeritageClauseElement>node)) {
|
||||
let typeNameOrExpression = node.kind === SyntaxKind.TypeReference
|
||||
? (<TypeReferenceNode>node).typeName
|
||||
: (<HeritageClauseElement>node).expression;
|
||||
|
||||
let symbol = resolveEntityName(typeNameOrExpression, SymbolFlags.Type);
|
||||
if (symbol) {
|
||||
if ((symbol.flags & SymbolFlags.TypeParameter) && isTypeParameterReferenceIllegalInConstraint(node, symbol)) {
|
||||
// TypeScript 1.0 spec (April 2014): 3.4.1
|
||||
// Type parameters declared in a particular type parameter list
|
||||
// may not be referenced in constraints in that type parameter list
|
||||
// Implementation: such type references are resolved to 'unknown' type that usually denotes error
|
||||
type = unknownType;
|
||||
}
|
||||
else {
|
||||
if (node.typeArguments) {
|
||||
error(node, Diagnostics.Type_0_is_not_generic, typeToString(type));
|
||||
type = undefined;
|
||||
type = getDeclaredTypeOfSymbol(symbol);
|
||||
if (type.flags & (TypeFlags.Class | TypeFlags.Interface) && type.flags & TypeFlags.Reference) {
|
||||
let typeParameters = (<InterfaceType>type).typeParameters;
|
||||
if (node.typeArguments && node.typeArguments.length === typeParameters.length) {
|
||||
type = createTypeReference(<GenericType>type, map(node.typeArguments, getTypeFromTypeNodeOrHeritageClauseElement));
|
||||
}
|
||||
else {
|
||||
error(node, Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, /*enclosingDeclaration*/ undefined, TypeFormatFlags.WriteArrayAsGenericType), typeParameters.length);
|
||||
type = undefined;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (node.typeArguments) {
|
||||
error(node, Diagnostics.Type_0_is_not_generic, typeToString(type));
|
||||
type = undefined;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
links.resolvedType = type || unknownType;
|
||||
}
|
||||
return links.resolvedType;
|
||||
|
@ -3427,7 +3468,7 @@ module ts {
|
|||
function getTypeFromArrayTypeNode(node: ArrayTypeNode): Type {
|
||||
let links = getNodeLinks(node);
|
||||
if (!links.resolvedType) {
|
||||
links.resolvedType = createArrayType(getTypeFromTypeNode(node.elementType));
|
||||
links.resolvedType = createArrayType(getTypeFromTypeNodeOrHeritageClauseElement(node.elementType));
|
||||
}
|
||||
return links.resolvedType;
|
||||
}
|
||||
|
@ -3445,7 +3486,7 @@ module ts {
|
|||
function getTypeFromTupleTypeNode(node: TupleTypeNode): Type {
|
||||
let links = getNodeLinks(node);
|
||||
if (!links.resolvedType) {
|
||||
links.resolvedType = createTupleType(map(node.elementTypes, getTypeFromTypeNode));
|
||||
links.resolvedType = createTupleType(map(node.elementTypes, getTypeFromTypeNodeOrHeritageClauseElement));
|
||||
}
|
||||
return links.resolvedType;
|
||||
}
|
||||
|
@ -3541,7 +3582,7 @@ module ts {
|
|||
function getTypeFromUnionTypeNode(node: UnionTypeNode): Type {
|
||||
let links = getNodeLinks(node);
|
||||
if (!links.resolvedType) {
|
||||
links.resolvedType = getUnionType(map(node.types, getTypeFromTypeNode), /*noSubtypeReduction*/ true);
|
||||
links.resolvedType = getUnionType(map(node.types, getTypeFromTypeNodeOrHeritageClauseElement), /*noSubtypeReduction*/ true);
|
||||
}
|
||||
return links.resolvedType;
|
||||
}
|
||||
|
@ -3573,7 +3614,7 @@ module ts {
|
|||
return links.resolvedType;
|
||||
}
|
||||
|
||||
function getTypeFromTypeNode(node: TypeNode | LiteralExpression): Type {
|
||||
function getTypeFromTypeNodeOrHeritageClauseElement(node: TypeNode | LiteralExpression | HeritageClauseElement): Type {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.AnyKeyword:
|
||||
return anyType;
|
||||
|
@ -3590,7 +3631,9 @@ module ts {
|
|||
case SyntaxKind.StringLiteral:
|
||||
return getTypeFromStringLiteral(<LiteralExpression>node);
|
||||
case SyntaxKind.TypeReference:
|
||||
return getTypeFromTypeReferenceNode(<TypeReferenceNode>node);
|
||||
return getTypeFromTypeReference(<TypeReferenceNode>node);
|
||||
case SyntaxKind.HeritageClauseElement:
|
||||
return getTypeFromHeritageClauseElement(<HeritageClauseElement>node);
|
||||
case SyntaxKind.TypeQuery:
|
||||
return getTypeFromTypeQueryNode(<TypeQueryNode>node);
|
||||
case SyntaxKind.ArrayType:
|
||||
|
@ -3600,7 +3643,7 @@ module ts {
|
|||
case SyntaxKind.UnionType:
|
||||
return getTypeFromUnionTypeNode(<UnionTypeNode>node);
|
||||
case SyntaxKind.ParenthesizedType:
|
||||
return getTypeFromTypeNode((<ParenthesizedTypeNode>node).type);
|
||||
return getTypeFromTypeNodeOrHeritageClauseElement((<ParenthesizedTypeNode>node).type);
|
||||
case SyntaxKind.FunctionType:
|
||||
case SyntaxKind.ConstructorType:
|
||||
case SyntaxKind.TypeLiteral:
|
||||
|
@ -4963,7 +5006,7 @@ module ts {
|
|||
function getResolvedSymbol(node: Identifier): Symbol {
|
||||
let links = getNodeLinks(node);
|
||||
if (!links.resolvedSymbol) {
|
||||
links.resolvedSymbol = (getFullWidth(node) > 0 && resolveName(node, node.text, SymbolFlags.Value | SymbolFlags.ExportValue, Diagnostics.Cannot_find_name_0, node)) || unknownSymbol;
|
||||
links.resolvedSymbol = (!nodeIsMissing(node) && resolveName(node, node.text, SymbolFlags.Value | SymbolFlags.ExportValue, Diagnostics.Cannot_find_name_0, node)) || unknownSymbol;
|
||||
}
|
||||
return links.resolvedSymbol;
|
||||
}
|
||||
|
@ -5469,7 +5512,7 @@ module ts {
|
|||
let isCallExpression = node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).expression === node;
|
||||
let enclosingClass = <ClassDeclaration>getAncestor(node, SyntaxKind.ClassDeclaration);
|
||||
let baseClass: Type;
|
||||
if (enclosingClass && getClassBaseTypeNode(enclosingClass)) {
|
||||
if (enclosingClass && getClassExtendsHeritageClauseElement(enclosingClass)) {
|
||||
let classType = <InterfaceType>getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClass));
|
||||
baseClass = classType.baseTypes.length && classType.baseTypes[0];
|
||||
}
|
||||
|
@ -5601,7 +5644,7 @@ module ts {
|
|||
let declaration = <VariableLikeDeclaration>node.parent;
|
||||
if (node === declaration.initializer) {
|
||||
if (declaration.type) {
|
||||
return getTypeFromTypeNode(declaration.type);
|
||||
return getTypeFromTypeNodeOrHeritageClauseElement(declaration.type);
|
||||
}
|
||||
if (declaration.kind === SyntaxKind.Parameter) {
|
||||
let type = getContextuallyTypedParameterType(<ParameterDeclaration>declaration);
|
||||
|
@ -5804,7 +5847,7 @@ module ts {
|
|||
case SyntaxKind.NewExpression:
|
||||
return getContextualTypeForArgument(<CallExpression>parent, node);
|
||||
case SyntaxKind.TypeAssertionExpression:
|
||||
return getTypeFromTypeNode((<TypeAssertion>parent).type);
|
||||
return getTypeFromTypeNodeOrHeritageClauseElement((<TypeAssertion>parent).type);
|
||||
case SyntaxKind.BinaryExpression:
|
||||
return getContextualTypeForBinaryOperand(node);
|
||||
case SyntaxKind.PropertyAssignment:
|
||||
|
@ -6461,7 +6504,7 @@ module ts {
|
|||
let templateExpression = <TemplateExpression>tagExpression.template;
|
||||
let lastSpan = lastOrUndefined(templateExpression.templateSpans);
|
||||
Debug.assert(lastSpan !== undefined); // we should always have at least one span.
|
||||
callIsIncomplete = getFullWidth(lastSpan.literal) === 0 || !!lastSpan.literal.isUnterminated;
|
||||
callIsIncomplete = nodeIsMissing(lastSpan.literal) || !!lastSpan.literal.isUnterminated;
|
||||
}
|
||||
else {
|
||||
// If the template didn't end in a backtick, or its beginning occurred right prior to EOF,
|
||||
|
@ -6605,7 +6648,7 @@ module ts {
|
|||
let typeArgumentsAreAssignable = true;
|
||||
for (let i = 0; i < typeParameters.length; i++) {
|
||||
let typeArgNode = typeArguments[i];
|
||||
let typeArgument = getTypeFromTypeNode(typeArgNode);
|
||||
let typeArgument = getTypeFromTypeNodeOrHeritageClauseElement(typeArgNode);
|
||||
// Do not push on this array! It has a preallocated length
|
||||
typeArgumentResultTypes[i] = typeArgument;
|
||||
if (typeArgumentsAreAssignable /* so far */) {
|
||||
|
@ -6679,7 +6722,7 @@ module ts {
|
|||
function getEffectiveTypeArguments(callExpression: CallExpression): TypeNode[] {
|
||||
if (callExpression.expression.kind === SyntaxKind.SuperKeyword) {
|
||||
let containingClass = <ClassDeclaration>getAncestor(callExpression, SyntaxKind.ClassDeclaration);
|
||||
let baseClassTypeNode = containingClass && getClassBaseTypeNode(containingClass);
|
||||
let baseClassTypeNode = containingClass && getClassExtendsHeritageClauseElement(containingClass);
|
||||
return baseClassTypeNode && baseClassTypeNode.typeArguments;
|
||||
}
|
||||
else {
|
||||
|
@ -7087,7 +7130,7 @@ module ts {
|
|||
|
||||
function checkTypeAssertion(node: TypeAssertion): Type {
|
||||
let exprType = checkExpression(node.expression);
|
||||
let targetType = getTypeFromTypeNode(node.type);
|
||||
let targetType = getTypeFromTypeNodeOrHeritageClauseElement(node.type);
|
||||
if (produceDiagnostics && targetType !== unknownType) {
|
||||
let widenedType = getWidenedType(exprType);
|
||||
if (!(isTypeAssignableTo(targetType, widenedType))) {
|
||||
|
@ -7266,7 +7309,7 @@ module ts {
|
|||
function checkFunctionExpressionOrObjectLiteralMethodBody(node: FunctionExpression | MethodDeclaration) {
|
||||
Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node));
|
||||
if (node.type) {
|
||||
checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type));
|
||||
checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNodeOrHeritageClauseElement(node.type));
|
||||
}
|
||||
|
||||
if (node.body) {
|
||||
|
@ -7276,7 +7319,7 @@ module ts {
|
|||
else {
|
||||
let exprType = checkExpression(<Expression>node.body);
|
||||
if (node.type) {
|
||||
checkTypeAssignableTo(exprType, getTypeFromTypeNode(node.type), node.body, /*headMessage*/ undefined);
|
||||
checkTypeAssignableTo(exprType, getTypeFromTypeNodeOrHeritageClauseElement(node.type), node.body, /*headMessage*/ undefined);
|
||||
}
|
||||
checkFunctionExpressionBodies(node.body);
|
||||
}
|
||||
|
@ -7356,23 +7399,6 @@ module ts {
|
|||
}
|
||||
}
|
||||
|
||||
function isImportedNameFromExternalModule(n: Node): boolean {
|
||||
switch (n.kind) {
|
||||
case SyntaxKind.ElementAccessExpression:
|
||||
case SyntaxKind.PropertyAccessExpression: {
|
||||
// all bindings for external module should be immutable
|
||||
// so attempt to use a.b or a[b] as lhs will always fail
|
||||
// no matter what b is
|
||||
let symbol = findSymbol((<PropertyAccessExpression | ElementAccessExpression>n).expression);
|
||||
return symbol && symbol.flags & SymbolFlags.Alias && isExternalModuleSymbol(resolveAlias(symbol));
|
||||
}
|
||||
case SyntaxKind.ParenthesizedExpression:
|
||||
return isImportedNameFromExternalModule((<ParenthesizedExpression>n).expression);
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (!isReferenceOrErrorExpression(n)) {
|
||||
error(n, invalidReferenceMessage);
|
||||
return false;
|
||||
|
@ -7383,10 +7409,6 @@ module ts {
|
|||
return false;
|
||||
}
|
||||
|
||||
if (isImportedNameFromExternalModule(n)) {
|
||||
error(n, invalidReferenceMessage);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
@ -7982,6 +8004,8 @@ module ts {
|
|||
return checkTypeAssertion(<TypeAssertion>node);
|
||||
case SyntaxKind.ParenthesizedExpression:
|
||||
return checkExpression((<ParenthesizedExpression>node).expression, contextualMapper);
|
||||
case SyntaxKind.ClassExpression:
|
||||
return checkClassExpression(<ClassExpression>node);
|
||||
case SyntaxKind.FunctionExpression:
|
||||
case SyntaxKind.ArrowFunction:
|
||||
return checkFunctionExpressionOrObjectLiteralMethod(<FunctionExpression>node, contextualMapper);
|
||||
|
@ -8209,7 +8233,7 @@ module ts {
|
|||
// TS 1.0 spec (April 2014): 8.3.2
|
||||
// Constructors of classes with no extends clause may not contain super calls, whereas
|
||||
// constructors of derived classes must contain at least one super call somewhere in their function body.
|
||||
if (getClassBaseTypeNode(<ClassDeclaration>node.parent)) {
|
||||
if (getClassExtendsHeritageClauseElement(<ClassDeclaration>node.parent)) {
|
||||
|
||||
if (containsSuperCall(node.body)) {
|
||||
// The first statement in the body of a constructor must be a super call if both of the following are true:
|
||||
|
@ -8280,11 +8304,19 @@ module ts {
|
|||
checkDecorators(node);
|
||||
}
|
||||
|
||||
function checkTypeReference(node: TypeReferenceNode) {
|
||||
function checkTypeReferenceNode(node: TypeReferenceNode) {
|
||||
return checkTypeReferenceOrHeritageClauseElement(node);
|
||||
}
|
||||
|
||||
function checkHeritageClauseElement(node: HeritageClauseElement) {
|
||||
return checkTypeReferenceOrHeritageClauseElement(node);
|
||||
}
|
||||
|
||||
function checkTypeReferenceOrHeritageClauseElement(node: TypeReferenceNode | HeritageClauseElement) {
|
||||
// Grammar checking
|
||||
checkGrammarTypeArguments(node, node.typeArguments);
|
||||
|
||||
let type = getTypeFromTypeReferenceNode(node);
|
||||
let type = getTypeFromTypeReferenceOrHeritageClauseElement(node);
|
||||
if (type !== unknownType && node.typeArguments) {
|
||||
// Do type argument local checks only if referenced type is successfully resolved
|
||||
let len = node.typeArguments.length;
|
||||
|
@ -8452,7 +8484,7 @@ module ts {
|
|||
let isConstructor = (symbol.flags & SymbolFlags.Constructor) !== 0;
|
||||
|
||||
function reportImplementationExpectedError(node: FunctionLikeDeclaration): void {
|
||||
if (node.name && getFullWidth(node.name) === 0) {
|
||||
if (node.name && nodeIsMissing(node.name)) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -8775,7 +8807,7 @@ module ts {
|
|||
|
||||
checkSourceElement(node.body);
|
||||
if (node.type && !isAccessor(node.kind)) {
|
||||
checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type));
|
||||
checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNodeOrHeritageClauseElement(node.type));
|
||||
}
|
||||
|
||||
// Report an implicit any error if there is no body, no explicit return type, and node is not a private method
|
||||
|
@ -8875,7 +8907,7 @@ module ts {
|
|||
return;
|
||||
}
|
||||
|
||||
if (getClassBaseTypeNode(enclosingClass)) {
|
||||
if (getClassExtendsHeritageClauseElement(enclosingClass)) {
|
||||
let isDeclaration = node.kind !== SyntaxKind.Identifier;
|
||||
if (isDeclaration) {
|
||||
error(node, Diagnostics.Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference);
|
||||
|
@ -9723,8 +9755,18 @@ module ts {
|
|||
}
|
||||
}
|
||||
|
||||
function checkClassExpression(node: ClassExpression): Type {
|
||||
grammarErrorOnNode(node, Diagnostics.class_expressions_are_not_currently_supported);
|
||||
forEach(node.members, checkSourceElement);
|
||||
return unknownType;
|
||||
}
|
||||
|
||||
function checkClassDeclaration(node: ClassDeclaration) {
|
||||
// Grammar checking
|
||||
if (node.parent.kind !== SyntaxKind.ModuleBlock && node.parent.kind !== SyntaxKind.SourceFile) {
|
||||
grammarErrorOnNode(node, Diagnostics.class_declarations_are_only_supported_directly_inside_a_module_or_as_a_top_level_declaration);
|
||||
}
|
||||
|
||||
checkGrammarClassDeclarationHeritageClauses(node);
|
||||
checkDecorators(node);
|
||||
if (node.name) {
|
||||
|
@ -9737,10 +9779,14 @@ module ts {
|
|||
let symbol = getSymbolOfNode(node);
|
||||
let type = <InterfaceType>getDeclaredTypeOfSymbol(symbol);
|
||||
let staticType = <ObjectType>getTypeOfSymbol(symbol);
|
||||
let baseTypeNode = getClassBaseTypeNode(node);
|
||||
let baseTypeNode = getClassExtendsHeritageClauseElement(node);
|
||||
if (baseTypeNode) {
|
||||
if (!isSupportedHeritageClauseElement(baseTypeNode)) {
|
||||
error(baseTypeNode.expression, Diagnostics.Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses);
|
||||
}
|
||||
|
||||
emitExtends = emitExtends || !isInAmbientContext(node);
|
||||
checkTypeReference(baseTypeNode);
|
||||
checkHeritageClauseElement(baseTypeNode);
|
||||
}
|
||||
if (type.baseTypes.length) {
|
||||
if (produceDiagnostics) {
|
||||
|
@ -9749,23 +9795,30 @@ module ts {
|
|||
let staticBaseType = getTypeOfSymbol(baseType.symbol);
|
||||
checkTypeAssignableTo(staticType, getTypeWithoutConstructors(staticBaseType), node.name || node,
|
||||
Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1);
|
||||
if (baseType.symbol !== resolveEntityName(baseTypeNode.typeName, SymbolFlags.Value)) {
|
||||
|
||||
if (baseType.symbol !== resolveEntityName(baseTypeNode.expression, SymbolFlags.Value)) {
|
||||
error(baseTypeNode, Diagnostics.Type_name_0_in_extends_clause_does_not_reference_constructor_function_for_0, typeToString(baseType));
|
||||
}
|
||||
|
||||
checkKindsOfPropertyMemberOverrides(type, baseType);
|
||||
}
|
||||
|
||||
// Check that base type can be evaluated as expression
|
||||
checkExpressionOrQualifiedName(baseTypeNode.typeName);
|
||||
}
|
||||
|
||||
let implementedTypeNodes = getClassImplementedTypeNodes(node);
|
||||
if (type.baseTypes.length || (baseTypeNode && compilerOptions.separateCompilation)) {
|
||||
// Check that base type can be evaluated as expression
|
||||
checkExpressionOrQualifiedName(baseTypeNode.expression);
|
||||
}
|
||||
|
||||
let implementedTypeNodes = getClassImplementsHeritageClauseElements(node);
|
||||
if (implementedTypeNodes) {
|
||||
forEach(implementedTypeNodes, typeRefNode => {
|
||||
checkTypeReference(typeRefNode);
|
||||
if (!isSupportedHeritageClauseElement(typeRefNode)) {
|
||||
error(typeRefNode.expression, Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
|
||||
}
|
||||
|
||||
checkHeritageClauseElement(typeRefNode);
|
||||
if (produceDiagnostics) {
|
||||
let t = getTypeFromTypeReferenceNode(typeRefNode);
|
||||
let t = getTypeFromHeritageClauseElement(typeRefNode);
|
||||
if (t !== unknownType) {
|
||||
let declaredType = (t.flags & TypeFlags.Reference) ? (<TypeReference>t).target : t;
|
||||
if (declaredType.flags & (TypeFlags.Class | TypeFlags.Interface)) {
|
||||
|
@ -9887,7 +9940,7 @@ module ts {
|
|||
if (!tp1.constraint || !tp2.constraint) {
|
||||
return false;
|
||||
}
|
||||
if (!isTypeIdenticalTo(getTypeFromTypeNode(tp1.constraint), getTypeFromTypeNode(tp2.constraint))) {
|
||||
if (!isTypeIdenticalTo(getTypeFromTypeNodeOrHeritageClauseElement(tp1.constraint), getTypeFromTypeNodeOrHeritageClauseElement(tp2.constraint))) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
@ -9958,7 +10011,13 @@ module ts {
|
|||
}
|
||||
}
|
||||
}
|
||||
forEach(getInterfaceBaseTypeNodes(node), checkTypeReference);
|
||||
forEach(getInterfaceBaseTypeNodes(node), heritageElement => {
|
||||
if (!isSupportedHeritageClauseElement(heritageElement)) {
|
||||
error(heritageElement.expression, Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments);
|
||||
}
|
||||
|
||||
checkHeritageClauseElement(heritageElement);
|
||||
});
|
||||
forEach(node.members, checkSourceElement);
|
||||
|
||||
if (produceDiagnostics) {
|
||||
|
@ -10159,6 +10218,11 @@ module ts {
|
|||
|
||||
computeEnumMemberValues(node);
|
||||
|
||||
let enumIsConst = isConst(node);
|
||||
if (compilerOptions.separateCompilation && enumIsConst && isInAmbientContext(node)) {
|
||||
error(node.name, Diagnostics.Ambient_const_enums_are_not_allowed_when_the_separateCompilation_flag_is_provided);
|
||||
}
|
||||
|
||||
// Spec 2014 - Section 9.3:
|
||||
// It isn't possible for one enum declaration to continue the automatic numbering sequence of another,
|
||||
// and when an enum type has multiple declarations, only one declaration is permitted to omit a value
|
||||
|
@ -10169,7 +10233,6 @@ module ts {
|
|||
let firstDeclaration = getDeclarationOfKind(enumSymbol, node.kind);
|
||||
if (node === firstDeclaration) {
|
||||
if (enumSymbol.declarations.length > 1) {
|
||||
let enumIsConst = isConst(node);
|
||||
// check that const is placed\omitted on all enum declarations
|
||||
forEach(enumSymbol.declarations, decl => {
|
||||
if (isConstEnumDeclaration(decl) !== enumIsConst) {
|
||||
|
@ -10231,7 +10294,7 @@ module ts {
|
|||
if (symbol.flags & SymbolFlags.ValueModule
|
||||
&& symbol.declarations.length > 1
|
||||
&& !isInAmbientContext(node)
|
||||
&& isInstantiatedModule(node, compilerOptions.preserveConstEnums)) {
|
||||
&& isInstantiatedModule(node, compilerOptions.preserveConstEnums || compilerOptions.separateCompilation)) {
|
||||
let classOrFunc = getFirstNonAmbientClassOrFunctionDeclaration(symbol);
|
||||
if (classOrFunc) {
|
||||
if (getSourceFileOfNode(node) !== getSourceFileOfNode(classOrFunc)) {
|
||||
|
@ -10256,16 +10319,25 @@ module ts {
|
|||
checkSourceElement(node.body);
|
||||
}
|
||||
|
||||
function getFirstIdentifier(node: EntityName): Identifier {
|
||||
while (node.kind === SyntaxKind.QualifiedName) {
|
||||
node = (<QualifiedName>node).left;
|
||||
function getFirstIdentifier(node: EntityName | Expression): Identifier {
|
||||
while (true) {
|
||||
if (node.kind === SyntaxKind.QualifiedName) {
|
||||
node = (<QualifiedName>node).left;
|
||||
}
|
||||
else if (node.kind === SyntaxKind.PropertyAccessExpression) {
|
||||
node = (<PropertyAccessExpression>node).expression;
|
||||
}
|
||||
else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Debug.assert(node.kind === SyntaxKind.Identifier);
|
||||
return <Identifier>node;
|
||||
}
|
||||
|
||||
function checkExternalImportOrExportDeclaration(node: ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration): boolean {
|
||||
let moduleName = getExternalModuleName(node);
|
||||
if (getFullWidth(moduleName) !== 0 && moduleName.kind !== SyntaxKind.StringLiteral) {
|
||||
if (!nodeIsMissing(moduleName) && moduleName.kind !== SyntaxKind.StringLiteral) {
|
||||
error(moduleName, Diagnostics.String_literal_expected);
|
||||
return false;
|
||||
}
|
||||
|
@ -10486,7 +10558,7 @@ module ts {
|
|||
case SyntaxKind.SetAccessor:
|
||||
return checkAccessorDeclaration(<AccessorDeclaration>node);
|
||||
case SyntaxKind.TypeReference:
|
||||
return checkTypeReference(<TypeReferenceNode>node);
|
||||
return checkTypeReferenceNode(<TypeReferenceNode>node);
|
||||
case SyntaxKind.TypeQuery:
|
||||
return checkTypeQuery(<TypeQueryNode>node);
|
||||
case SyntaxKind.TypeLiteral:
|
||||
|
@ -10862,11 +10934,23 @@ module ts {
|
|||
// True if the given identifier is part of a type reference
|
||||
function isTypeReferenceIdentifier(entityName: EntityName): boolean {
|
||||
let node: Node = entityName;
|
||||
while (node.parent && node.parent.kind === SyntaxKind.QualifiedName) node = node.parent;
|
||||
while (node.parent && node.parent.kind === SyntaxKind.QualifiedName) {
|
||||
node = node.parent;
|
||||
}
|
||||
|
||||
return node.parent && node.parent.kind === SyntaxKind.TypeReference;
|
||||
}
|
||||
|
||||
function isTypeNode(node: Node): boolean {
|
||||
function isHeritageClauseElementIdentifier(entityName: Node): boolean {
|
||||
let node = entityName;
|
||||
while (node.parent && node.parent.kind === SyntaxKind.PropertyAccessExpression) {
|
||||
node = node.parent;
|
||||
}
|
||||
|
||||
return node.parent && node.parent.kind === SyntaxKind.HeritageClauseElement;
|
||||
}
|
||||
|
||||
function isTypeNodeOrHeritageClauseElement(node: Node): boolean {
|
||||
if (SyntaxKind.FirstTypeNode <= node.kind && node.kind <= SyntaxKind.LastTypeNode) {
|
||||
return true;
|
||||
}
|
||||
|
@ -10883,6 +10967,8 @@ module ts {
|
|||
case SyntaxKind.StringLiteral:
|
||||
// Specialized signatures can have string literals as their parameters' type names
|
||||
return node.parent.kind === SyntaxKind.Parameter;
|
||||
case SyntaxKind.HeritageClauseElement:
|
||||
return true;
|
||||
|
||||
// Identifiers and qualified names may be type nodes, depending on their context. Climb
|
||||
// above them to find the lowest container
|
||||
|
@ -10891,10 +10977,15 @@ module ts {
|
|||
if (node.parent.kind === SyntaxKind.QualifiedName && (<QualifiedName>node.parent).right === node) {
|
||||
node = node.parent;
|
||||
}
|
||||
else if (node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node) {
|
||||
node = node.parent;
|
||||
}
|
||||
// fall through
|
||||
case SyntaxKind.QualifiedName:
|
||||
case SyntaxKind.PropertyAccessExpression:
|
||||
// At this point, node is either a qualified name or an identifier
|
||||
Debug.assert(node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName, "'node' was expected to be a qualified name or identifier in 'isTypeNode'.");
|
||||
Debug.assert(node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName || node.kind === SyntaxKind.PropertyAccessExpression,
|
||||
"'node' was expected to be a qualified name, identifier or property access in 'isTypeNode'.");
|
||||
|
||||
let parent = node.parent;
|
||||
if (parent.kind === SyntaxKind.TypeQuery) {
|
||||
|
@ -10910,6 +11001,8 @@ module ts {
|
|||
return true;
|
||||
}
|
||||
switch (parent.kind) {
|
||||
case SyntaxKind.HeritageClauseElement:
|
||||
return true;
|
||||
case SyntaxKind.TypeParameter:
|
||||
return node === (<TypeParameterDeclaration>parent).constraint;
|
||||
case SyntaxKind.PropertyDeclaration:
|
||||
|
@ -10964,11 +11057,6 @@ module ts {
|
|||
return getLeftSideOfImportEqualsOrExportAssignment(node) !== undefined;
|
||||
}
|
||||
|
||||
function isRightSideOfQualifiedNameOrPropertyAccess(node: Node) {
|
||||
return (node.parent.kind === SyntaxKind.QualifiedName && (<QualifiedName>node.parent).right === node) ||
|
||||
(node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node);
|
||||
}
|
||||
|
||||
function getSymbolOfEntityNameOrPropertyAccessExpression(entityName: EntityName | PropertyAccessExpression): Symbol {
|
||||
if (isDeclarationName(entityName)) {
|
||||
return getSymbolOfNode(entityName.parent);
|
||||
|
@ -10990,8 +11078,13 @@ module ts {
|
|||
entityName = <QualifiedName | PropertyAccessExpression>entityName.parent;
|
||||
}
|
||||
|
||||
if (isExpression(entityName)) {
|
||||
if (getFullWidth(entityName) === 0) {
|
||||
if (isHeritageClauseElementIdentifier(<EntityName>entityName)) {
|
||||
let meaning = entityName.parent.kind === SyntaxKind.HeritageClauseElement ? SymbolFlags.Type : SymbolFlags.Namespace;
|
||||
meaning |= SymbolFlags.Alias;
|
||||
return resolveEntityName(<EntityName>entityName, meaning);
|
||||
}
|
||||
else if (isExpression(entityName)) {
|
||||
if (nodeIsMissing(entityName)) {
|
||||
// Missing entity name.
|
||||
return undefined;
|
||||
}
|
||||
|
@ -11106,12 +11199,12 @@ module ts {
|
|||
return unknownType;
|
||||
}
|
||||
|
||||
if (isExpression(node)) {
|
||||
return getTypeOfExpression(<Expression>node);
|
||||
if (isTypeNodeOrHeritageClauseElement(node)) {
|
||||
return getTypeFromTypeNodeOrHeritageClauseElement(<TypeNode | HeritageClauseElement>node);
|
||||
}
|
||||
|
||||
if (isTypeNode(node)) {
|
||||
return getTypeFromTypeNode(<TypeNode>node);
|
||||
if (isExpression(node)) {
|
||||
return getTypeOfExpression(<Expression>node);
|
||||
}
|
||||
|
||||
if (isTypeDeclaration(node)) {
|
||||
|
@ -11274,13 +11367,18 @@ module ts {
|
|||
// parent is not source file or it is not reference to internal module
|
||||
return false;
|
||||
}
|
||||
return isAliasResolvedToValue(getSymbolOfNode(node));
|
||||
|
||||
var isValue = isAliasResolvedToValue(getSymbolOfNode(node));
|
||||
return isValue && node.moduleReference && !nodeIsMissing(node.moduleReference);
|
||||
}
|
||||
|
||||
function isAliasResolvedToValue(symbol: Symbol): boolean {
|
||||
let target = resolveAlias(symbol);
|
||||
if (target === unknownSymbol && compilerOptions.separateCompilation) {
|
||||
return true;
|
||||
}
|
||||
// const enums and modules that contain only const enums are not considered values from the emit perespective
|
||||
return target !== unknownSymbol && target.flags & SymbolFlags.Value && !isConstEnumOrConstEnumOnlyModule(target);
|
||||
return target !== unknownSymbol && target && target.flags & SymbolFlags.Value && !isConstEnumOrConstEnumOnlyModule(target);
|
||||
}
|
||||
|
||||
function isConstEnumOrConstEnumOnlyModule(s: Symbol): boolean {
|
||||
|
@ -12181,9 +12279,6 @@ module ts {
|
|||
function checkGrammarVariableDeclaration(node: VariableDeclaration) {
|
||||
if (node.parent.parent.kind !== SyntaxKind.ForInStatement && node.parent.parent.kind !== SyntaxKind.ForOfStatement) {
|
||||
if (isInAmbientContext(node)) {
|
||||
if (isBindingPattern(node.name)) {
|
||||
return grammarErrorOnNode(node, Diagnostics.Destructuring_declarations_are_not_allowed_in_ambient_contexts);
|
||||
}
|
||||
if (node.initializer) {
|
||||
// Error on equals token which immediate precedes the initializer
|
||||
let equalsTokenLength = "=".length;
|
||||
|
|
|
@ -4,15 +4,12 @@
|
|||
/// <reference path="scanner.ts"/>
|
||||
|
||||
module ts {
|
||||
/* @internal */
|
||||
export var optionDeclarations: CommandLineOption[] = [
|
||||
{
|
||||
name: "charset",
|
||||
type: "string",
|
||||
},
|
||||
{
|
||||
name: "codepage",
|
||||
type: "number",
|
||||
},
|
||||
{
|
||||
name: "declaration",
|
||||
shortName: "d",
|
||||
|
@ -78,10 +75,6 @@ module ts {
|
|||
name: "noLib",
|
||||
type: "boolean",
|
||||
},
|
||||
{
|
||||
name: "noLibCheck",
|
||||
type: "boolean",
|
||||
},
|
||||
{
|
||||
name: "noResolve",
|
||||
type: "boolean",
|
||||
|
@ -117,6 +110,10 @@ module ts {
|
|||
type: "boolean",
|
||||
description: Diagnostics.Do_not_emit_comments_to_output,
|
||||
},
|
||||
{
|
||||
name: "separateCompilation",
|
||||
type: "boolean",
|
||||
},
|
||||
{
|
||||
name: "sourceMap",
|
||||
type: "boolean",
|
||||
|
@ -161,7 +158,8 @@ module ts {
|
|||
description: Diagnostics.Watch_input_files,
|
||||
}
|
||||
];
|
||||
|
||||
|
||||
/* @internal */
|
||||
export function parseCommandLine(commandLine: string[]): ParsedCommandLine {
|
||||
var options: CompilerOptions = {};
|
||||
var fileNames: string[] = [];
|
||||
|
@ -271,6 +269,10 @@ module ts {
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Read tsconfig.json file
|
||||
* @param fileName The path to the config file
|
||||
*/
|
||||
export function readConfigFile(fileName: string): any {
|
||||
try {
|
||||
var text = sys.readFile(fileName);
|
||||
|
@ -280,6 +282,12 @@ module ts {
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse the contents of a config file (tsconfig.json).
|
||||
* @param json The contents of the config file to parse
|
||||
* @param basePath A root directory to resolve relative path entries in the config
|
||||
* file to. e.g. outDir
|
||||
*/
|
||||
export function parseConfigFile(json: any, basePath?: string): ParsedCommandLine {
|
||||
var errors: Diagnostic[] = [];
|
||||
|
||||
|
|
|
@ -314,12 +314,12 @@ module ts {
|
|||
}
|
||||
}
|
||||
|
||||
function emitTypeWithNewGetSymbolAccessibilityDiagnostic(type: TypeNode | EntityName, getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic) {
|
||||
function emitTypeWithNewGetSymbolAccessibilityDiagnostic(type: TypeNode | EntityName | HeritageClauseElement, getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic) {
|
||||
writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic;
|
||||
emitType(type);
|
||||
}
|
||||
|
||||
function emitType(type: TypeNode | StringLiteralExpression | Identifier | QualifiedName) {
|
||||
function emitType(type: TypeNode | StringLiteralExpression | Identifier | QualifiedName | HeritageClauseElement) {
|
||||
switch (type.kind) {
|
||||
case SyntaxKind.AnyKeyword:
|
||||
case SyntaxKind.StringKeyword:
|
||||
|
@ -329,6 +329,8 @@ module ts {
|
|||
case SyntaxKind.VoidKeyword:
|
||||
case SyntaxKind.StringLiteral:
|
||||
return writeTextOfNode(currentSourceFile, type);
|
||||
case SyntaxKind.HeritageClauseElement:
|
||||
return emitHeritageClauseElement(<HeritageClauseElement>type);
|
||||
case SyntaxKind.TypeReference:
|
||||
return emitTypeReference(<TypeReferenceNode>type);
|
||||
case SyntaxKind.TypeQuery:
|
||||
|
@ -350,11 +352,9 @@ module ts {
|
|||
return emitEntityName(<Identifier>type);
|
||||
case SyntaxKind.QualifiedName:
|
||||
return emitEntityName(<QualifiedName>type);
|
||||
default:
|
||||
Debug.fail("Unknown type annotation: " + type.kind);
|
||||
}
|
||||
|
||||
function emitEntityName(entityName: EntityName) {
|
||||
function emitEntityName(entityName: EntityName | PropertyAccessExpression) {
|
||||
let visibilityResult = resolver.isEntityNameVisible(entityName,
|
||||
// Aliases can be written asynchronously so use correct enclosing declaration
|
||||
entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration ? entityName.parent : enclosingDeclaration);
|
||||
|
@ -362,15 +362,28 @@ module ts {
|
|||
handleSymbolAccessibilityError(visibilityResult);
|
||||
writeEntityName(entityName);
|
||||
|
||||
function writeEntityName(entityName: EntityName) {
|
||||
function writeEntityName(entityName: EntityName | Expression) {
|
||||
if (entityName.kind === SyntaxKind.Identifier) {
|
||||
writeTextOfNode(currentSourceFile, entityName);
|
||||
}
|
||||
else {
|
||||
let qualifiedName = <QualifiedName>entityName;
|
||||
writeEntityName(qualifiedName.left);
|
||||
let left = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).left : (<PropertyAccessExpression>entityName).expression;
|
||||
let right = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).right : (<PropertyAccessExpression>entityName).name;
|
||||
writeEntityName(left);
|
||||
write(".");
|
||||
writeTextOfNode(currentSourceFile, qualifiedName.right);
|
||||
writeTextOfNode(currentSourceFile, right);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function emitHeritageClauseElement(node: HeritageClauseElement) {
|
||||
if (isSupportedHeritageClauseElement(node)) {
|
||||
Debug.assert(node.expression.kind === SyntaxKind.Identifier || node.expression.kind === SyntaxKind.PropertyAccessExpression);
|
||||
emitEntityName(<Identifier | PropertyAccessExpression>node.expression);
|
||||
if (node.typeArguments) {
|
||||
write("<");
|
||||
emitCommaList(node.typeArguments, emitType);
|
||||
write(">");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -827,14 +840,16 @@ module ts {
|
|||
}
|
||||
}
|
||||
|
||||
function emitHeritageClause(typeReferences: TypeReferenceNode[], isImplementsList: boolean) {
|
||||
function emitHeritageClause(typeReferences: HeritageClauseElement[], isImplementsList: boolean) {
|
||||
if (typeReferences) {
|
||||
write(isImplementsList ? " implements " : " extends ");
|
||||
emitCommaList(typeReferences, emitTypeOfTypeReference);
|
||||
}
|
||||
|
||||
function emitTypeOfTypeReference(node: TypeReferenceNode) {
|
||||
emitTypeWithNewGetSymbolAccessibilityDiagnostic(node, getHeritageClauseVisibilityError);
|
||||
function emitTypeOfTypeReference(node: HeritageClauseElement) {
|
||||
if (isSupportedHeritageClauseElement(node)) {
|
||||
emitTypeWithNewGetSymbolAccessibilityDiagnostic(node, getHeritageClauseVisibilityError);
|
||||
}
|
||||
|
||||
function getHeritageClauseVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
|
||||
let diagnosticMessage: DiagnosticMessage;
|
||||
|
@ -877,11 +892,11 @@ module ts {
|
|||
let prevEnclosingDeclaration = enclosingDeclaration;
|
||||
enclosingDeclaration = node;
|
||||
emitTypeParameters(node.typeParameters);
|
||||
let baseTypeNode = getClassBaseTypeNode(node);
|
||||
let baseTypeNode = getClassExtendsHeritageClauseElement(node);
|
||||
if (baseTypeNode) {
|
||||
emitHeritageClause([baseTypeNode], /*isImplementsList*/ false);
|
||||
}
|
||||
emitHeritageClause(getClassImplementedTypeNodes(node), /*isImplementsList*/ true);
|
||||
emitHeritageClause(getClassImplementsHeritageClauseElements(node), /*isImplementsList*/ true);
|
||||
write(" {");
|
||||
writeLine();
|
||||
increaseIndent();
|
||||
|
@ -993,7 +1008,18 @@ module ts {
|
|||
}
|
||||
|
||||
function emitBindingPattern(bindingPattern: BindingPattern) {
|
||||
emitCommaList(bindingPattern.elements, emitBindingElement);
|
||||
// Only select non-omitted expression from the bindingPattern's elements.
|
||||
// We have to do this to avoid emitting trailing commas.
|
||||
// For example:
|
||||
// original: var [, c,,] = [ 2,3,4]
|
||||
// emitted: declare var c: number; // instead of declare var c:number, ;
|
||||
let elements: Node[] = [];
|
||||
for (let element of bindingPattern.elements) {
|
||||
if (element.kind !== SyntaxKind.OmittedExpression){
|
||||
elements.push(element);
|
||||
}
|
||||
}
|
||||
emitCommaList(elements, emitBindingElement);
|
||||
}
|
||||
|
||||
function emitBindingElement(bindingElement: BindingElement) {
|
||||
|
@ -1291,7 +1317,10 @@ module ts {
|
|||
write("...");
|
||||
}
|
||||
if (isBindingPattern(node.name)) {
|
||||
write("_" + indexOf((<FunctionLikeDeclaration>node.parent).parameters, node));
|
||||
// For bindingPattern, we can't simply writeTextOfNode from the source file
|
||||
// because we want to omit the initializer and using writeTextOfNode will result in initializer get emitted.
|
||||
// Therefore, we will have to recursively emit each element in the bindingPattern.
|
||||
emitBindingPattern(<BindingPattern>node.name);
|
||||
}
|
||||
else {
|
||||
writeTextOfNode(currentSourceFile, node.name);
|
||||
|
@ -1311,41 +1340,46 @@ module ts {
|
|||
}
|
||||
|
||||
function getParameterDeclarationTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
|
||||
let diagnosticMessage: DiagnosticMessage;
|
||||
let diagnosticMessage: DiagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
|
||||
return diagnosticMessage !== undefined ? {
|
||||
diagnosticMessage,
|
||||
errorNode: node,
|
||||
typeName: node.name
|
||||
} : undefined;
|
||||
}
|
||||
|
||||
function getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult: SymbolAccessiblityResult): DiagnosticMessage {
|
||||
switch (node.parent.kind) {
|
||||
case SyntaxKind.Constructor:
|
||||
diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
|
||||
return symbolAccesibilityResult.errorModuleName ?
|
||||
symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
|
||||
Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
|
||||
Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
|
||||
Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1;
|
||||
break;
|
||||
|
||||
case SyntaxKind.ConstructSignature:
|
||||
// Interfaces cannot have parameter types that cannot be named
|
||||
diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
|
||||
return symbolAccesibilityResult.errorModuleName ?
|
||||
Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
|
||||
Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1;
|
||||
break;
|
||||
|
||||
case SyntaxKind.CallSignature:
|
||||
// Interfaces cannot have parameter types that cannot be named
|
||||
diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
|
||||
return symbolAccesibilityResult.errorModuleName ?
|
||||
Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
|
||||
Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1;
|
||||
break;
|
||||
|
||||
case SyntaxKind.MethodDeclaration:
|
||||
case SyntaxKind.MethodSignature:
|
||||
if (node.parent.flags & NodeFlags.Static) {
|
||||
diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
|
||||
return symbolAccesibilityResult.errorModuleName ?
|
||||
symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
|
||||
Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
|
||||
Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
|
||||
Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;
|
||||
}
|
||||
else if (node.parent.parent.kind === SyntaxKind.ClassDeclaration) {
|
||||
diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
|
||||
return symbolAccesibilityResult.errorModuleName ?
|
||||
symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
|
||||
Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
|
||||
Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
|
||||
|
@ -1353,30 +1387,99 @@ module ts {
|
|||
}
|
||||
else {
|
||||
// Interfaces cannot have parameter types that cannot be named
|
||||
diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
|
||||
return symbolAccesibilityResult.errorModuleName ?
|
||||
Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
|
||||
Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1;
|
||||
}
|
||||
break;
|
||||
|
||||
case SyntaxKind.FunctionDeclaration:
|
||||
diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
|
||||
return symbolAccesibilityResult.errorModuleName ?
|
||||
symbolAccesibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
|
||||
Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
|
||||
Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2 :
|
||||
Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1;
|
||||
break;
|
||||
|
||||
default:
|
||||
Debug.fail("This is unknown parent for parameter: " + node.parent.kind);
|
||||
}
|
||||
|
||||
return {
|
||||
diagnosticMessage,
|
||||
errorNode: node,
|
||||
typeName: node.name
|
||||
};
|
||||
}
|
||||
|
||||
function emitBindingPattern(bindingPattern: BindingPattern) {
|
||||
// We have to explicitly emit square bracket and bracket because these tokens are not store inside the node.
|
||||
if (bindingPattern.kind === SyntaxKind.ObjectBindingPattern) {
|
||||
write("{");
|
||||
emitCommaList(bindingPattern.elements, emitBindingElement);
|
||||
write("}");
|
||||
}
|
||||
else if (bindingPattern.kind === SyntaxKind.ArrayBindingPattern) {
|
||||
write("[");
|
||||
let elements = bindingPattern.elements;
|
||||
emitCommaList(elements, emitBindingElement);
|
||||
if (elements && elements.hasTrailingComma) {
|
||||
write(", ");
|
||||
}
|
||||
write("]");
|
||||
}
|
||||
}
|
||||
|
||||
function emitBindingElement(bindingElement: BindingElement) {
|
||||
function getBindingElementTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
|
||||
let diagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
|
||||
return diagnosticMessage !== undefined ? {
|
||||
diagnosticMessage,
|
||||
errorNode: bindingElement,
|
||||
typeName: bindingElement.name
|
||||
} : undefined;
|
||||
}
|
||||
|
||||
if (bindingElement.kind === SyntaxKind.OmittedExpression) {
|
||||
// If bindingElement is an omittedExpression (i.e. containing elision),
|
||||
// we will emit blank space (although this may differ from users' original code,
|
||||
// it allows emitSeparatedList to write separator appropriately)
|
||||
// Example:
|
||||
// original: function foo([, x, ,]) {}
|
||||
// emit : function foo([ , x, , ]) {}
|
||||
write(" ");
|
||||
}
|
||||
else if (bindingElement.kind === SyntaxKind.BindingElement) {
|
||||
if (bindingElement.propertyName) {
|
||||
// bindingElement has propertyName property in the following case:
|
||||
// { y: [a,b,c] ...} -> bindingPattern will have a property called propertyName for "y"
|
||||
// We have to explicitly emit the propertyName before descending into its binding elements.
|
||||
// Example:
|
||||
// original: function foo({y: [a,b,c]}) {}
|
||||
// emit : declare function foo({y: [a, b, c]}: { y: [any, any, any] }) void;
|
||||
writeTextOfNode(currentSourceFile, bindingElement.propertyName);
|
||||
write(": ");
|
||||
|
||||
// If bindingElement has propertyName property, then its name must be another bindingPattern of SyntaxKind.ObjectBindingPattern
|
||||
emitBindingPattern(<BindingPattern>bindingElement.name);
|
||||
}
|
||||
else if (bindingElement.name) {
|
||||
if (isBindingPattern(bindingElement.name)) {
|
||||
// If it is a nested binding pattern, we will recursively descend into each element and emit each one separately.
|
||||
// In the case of rest element, we will omit rest element.
|
||||
// Example:
|
||||
// original: function foo([a, [[b]], c] = [1,[["string"]], 3]) {}
|
||||
// emit : declare function foo([a, [[b]], c]: [number, [[string]], number]): void;
|
||||
// original with rest: function foo([a, ...c]) {}
|
||||
// emit : declare function foo([a, ...c]): void;
|
||||
emitBindingPattern(<BindingPattern>bindingElement.name);
|
||||
}
|
||||
else {
|
||||
Debug.assert(bindingElement.name.kind === SyntaxKind.Identifier);
|
||||
// If the node is just an identifier, we will simply emit the text associated with the node's name
|
||||
// Example:
|
||||
// original: function foo({y = 10, x}) {}
|
||||
// emit : declare function foo({y, x}: {number, any}): void;
|
||||
if (bindingElement.dotDotDotToken) {
|
||||
write("...");
|
||||
}
|
||||
writeTextOfNode(currentSourceFile, bindingElement.name);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function emitNode(node: Node) {
|
||||
|
|
|
@ -165,6 +165,8 @@ module ts {
|
|||
Decorators_are_only_available_when_targeting_ECMAScript_5_and_higher: { code: 1205, category: DiagnosticCategory.Error, key: "Decorators are only available when targeting ECMAScript 5 and higher." },
|
||||
Decorators_are_not_valid_here: { code: 1206, category: DiagnosticCategory.Error, key: "Decorators are not valid here." },
|
||||
Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name: { code: 1207, category: DiagnosticCategory.Error, key: "Decorators cannot be applied to multiple get/set accessors of the same name." },
|
||||
Cannot_compile_non_external_modules_when_the_separateCompilation_flag_is_provided: { code: 1208, category: DiagnosticCategory.Error, key: "Cannot compile non-external modules when the '--separateCompilation' flag is provided." },
|
||||
Ambient_const_enums_are_not_allowed_when_the_separateCompilation_flag_is_provided: { code: 1209, category: DiagnosticCategory.Error, key: "Ambient const enums are not allowed when the '--separateCompilation' flag is provided." },
|
||||
Duplicate_identifier_0: { code: 2300, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." },
|
||||
Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: DiagnosticCategory.Error, key: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor." },
|
||||
Static_members_cannot_reference_class_type_parameters: { code: 2302, category: DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." },
|
||||
|
@ -351,6 +353,8 @@ module ts {
|
|||
The_arguments_object_cannot_be_referenced_in_an_arrow_function_Consider_using_a_standard_function_expression: { code: 2496, category: DiagnosticCategory.Error, key: "The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression." },
|
||||
External_module_0_resolves_to_a_non_module_entity_and_cannot_be_imported_using_this_construct: { code: 2497, category: DiagnosticCategory.Error, key: "External module '{0}' resolves to a non-module entity and cannot be imported using this construct." },
|
||||
External_module_0_uses_export_and_cannot_be_used_with_export_Asterisk: { code: 2498, category: DiagnosticCategory.Error, key: "External module '{0}' uses 'export =' and cannot be used with 'export *'." },
|
||||
An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2499, category: DiagnosticCategory.Error, key: "An interface can only extend an identifier/qualified-name with optional type arguments." },
|
||||
A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2500, category: DiagnosticCategory.Error, key: "A class can only implement an identifier/qualified-name with optional type arguments." },
|
||||
Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." },
|
||||
Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." },
|
||||
Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." },
|
||||
|
@ -434,6 +438,11 @@ module ts {
|
|||
Option_noEmit_cannot_be_specified_with_option_out_or_outDir: { code: 5040, category: DiagnosticCategory.Error, key: "Option 'noEmit' cannot be specified with option 'out' or 'outDir'." },
|
||||
Option_noEmit_cannot_be_specified_with_option_declaration: { code: 5041, category: DiagnosticCategory.Error, key: "Option 'noEmit' cannot be specified with option 'declaration'." },
|
||||
Option_project_cannot_be_mixed_with_source_files_on_a_command_line: { code: 5042, category: DiagnosticCategory.Error, key: "Option 'project' cannot be mixed with source files on a command line." },
|
||||
Option_sourceMap_cannot_be_specified_with_option_separateCompilation: { code: 5043, category: DiagnosticCategory.Error, key: "Option 'sourceMap' cannot be specified with option 'separateCompilation'." },
|
||||
Option_declaration_cannot_be_specified_with_option_separateCompilation: { code: 5044, category: DiagnosticCategory.Error, key: "Option 'declaration' cannot be specified with option 'separateCompilation'." },
|
||||
Option_noEmitOnError_cannot_be_specified_with_option_separateCompilation: { code: 5045, category: DiagnosticCategory.Error, key: "Option 'noEmitOnError' cannot be specified with option 'separateCompilation'." },
|
||||
Option_out_cannot_be_specified_with_option_separateCompilation: { code: 5046, category: DiagnosticCategory.Error, key: "Option 'out' cannot be specified with option 'separateCompilation'." },
|
||||
Option_separateCompilation_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES6_or_higher: { code: 5047, category: DiagnosticCategory.Error, key: "Option 'separateCompilation' can only be used when either option'--module' is provided or option 'target' is 'ES6' or higher." },
|
||||
Concatenate_and_emit_output_to_single_file: { code: 6001, category: DiagnosticCategory.Message, key: "Concatenate and emit output to single file." },
|
||||
Generates_corresponding_d_ts_file: { code: 6002, category: DiagnosticCategory.Message, key: "Generates corresponding '.d.ts' file." },
|
||||
Specifies_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations: { code: 6003, category: DiagnosticCategory.Message, key: "Specifies the location where debugger should locate map files instead of generated locations." },
|
||||
|
@ -498,5 +507,8 @@ module ts {
|
|||
You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: { code: 8001, category: DiagnosticCategory.Error, key: "You cannot rename elements that are defined in the standard TypeScript library." },
|
||||
yield_expressions_are_not_currently_supported: { code: 9000, category: DiagnosticCategory.Error, key: "'yield' expressions are not currently supported." },
|
||||
Generators_are_not_currently_supported: { code: 9001, category: DiagnosticCategory.Error, key: "Generators are not currently supported." },
|
||||
Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses: { code: 9002, category: DiagnosticCategory.Error, key: "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses." },
|
||||
class_expressions_are_not_currently_supported: { code: 9003, category: DiagnosticCategory.Error, key: "'class' expressions are not currently supported." },
|
||||
class_declarations_are_only_supported_directly_inside_a_module_or_as_a_top_level_declaration: { code: 9004, category: DiagnosticCategory.Error, key: "'class' declarations are only supported directly inside a module or as a top level declaration." },
|
||||
};
|
||||
}
|
|
@ -651,7 +651,14 @@
|
|||
"category": "Error",
|
||||
"code": 1207
|
||||
},
|
||||
|
||||
"Cannot compile non-external modules when the '--separateCompilation' flag is provided.": {
|
||||
"category": "Error",
|
||||
"code": 1208
|
||||
},
|
||||
"Ambient const enums are not allowed when the '--separateCompilation' flag is provided.": {
|
||||
"category": "Error",
|
||||
"code": 1209
|
||||
},
|
||||
"Duplicate identifier '{0}'.": {
|
||||
"category": "Error",
|
||||
"code": 2300
|
||||
|
@ -1396,6 +1403,14 @@
|
|||
"category": "Error",
|
||||
"code": 2498
|
||||
},
|
||||
"An interface can only extend an identifier/qualified-name with optional type arguments.": {
|
||||
"category": "Error",
|
||||
"code": 2499
|
||||
},
|
||||
"A class can only implement an identifier/qualified-name with optional type arguments.": {
|
||||
"category": "Error",
|
||||
"code": 2500
|
||||
},
|
||||
|
||||
"Import declaration '{0}' is using private name '{1}'.": {
|
||||
"category": "Error",
|
||||
|
@ -1729,6 +1744,26 @@
|
|||
"category": "Error",
|
||||
"code": 5042
|
||||
},
|
||||
"Option 'sourceMap' cannot be specified with option 'separateCompilation'.": {
|
||||
"category": "Error",
|
||||
"code": 5043
|
||||
},
|
||||
"Option 'declaration' cannot be specified with option 'separateCompilation'.": {
|
||||
"category": "Error",
|
||||
"code": 5044
|
||||
},
|
||||
"Option 'noEmitOnError' cannot be specified with option 'separateCompilation'.": {
|
||||
"category": "Error",
|
||||
"code": 5045
|
||||
},
|
||||
"Option 'out' cannot be specified with option 'separateCompilation'.": {
|
||||
"category": "Error",
|
||||
"code": 5046
|
||||
},
|
||||
"Option 'separateCompilation' can only be used when either option'--module' is provided or option 'target' is 'ES6' or higher.": {
|
||||
"category": "Error",
|
||||
"code": 5047
|
||||
},
|
||||
"Concatenate and emit output to single file.": {
|
||||
"category": "Message",
|
||||
"code": 6001
|
||||
|
@ -1985,5 +2020,17 @@
|
|||
"Generators are not currently supported.": {
|
||||
"category": "Error",
|
||||
"code": 9001
|
||||
},
|
||||
"Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.": {
|
||||
"category": "Error",
|
||||
"code": 9002
|
||||
},
|
||||
"'class' expressions are not currently supported.": {
|
||||
"category": "Error",
|
||||
"code": 9003
|
||||
},
|
||||
"'class' declarations are only supported directly inside a module or as a top level declaration.": {
|
||||
"category": "Error",
|
||||
"code": 9004
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1641,6 +1641,11 @@ module ts {
|
|||
}
|
||||
|
||||
function tryEmitConstantValue(node: PropertyAccessExpression | ElementAccessExpression): boolean {
|
||||
if (compilerOptions.separateCompilation) {
|
||||
// do not inline enum values in separate compilation mode
|
||||
return false;
|
||||
}
|
||||
|
||||
let constantValue = resolver.getConstantValue(node);
|
||||
if (constantValue !== undefined) {
|
||||
write(constantValue.toString());
|
||||
|
@ -3193,7 +3198,7 @@ module ts {
|
|||
}
|
||||
}
|
||||
|
||||
function emitMemberAssignments(node: ClassDeclaration, staticFlag: NodeFlags) {
|
||||
function emitMemberAssignments(node: ClassLikeDeclaration, staticFlag: NodeFlags) {
|
||||
forEach(node.members, member => {
|
||||
if (member.kind === SyntaxKind.PropertyDeclaration && (member.flags & NodeFlags.Static) === staticFlag && (<PropertyDeclaration>member).initializer) {
|
||||
writeLine();
|
||||
|
@ -3217,9 +3222,13 @@ module ts {
|
|||
});
|
||||
}
|
||||
|
||||
function emitMemberFunctionsForES5AndLower(node: ClassDeclaration) {
|
||||
function emitMemberFunctionsForES5AndLower(node: ClassLikeDeclaration) {
|
||||
forEach(node.members, member => {
|
||||
if (member.kind === SyntaxKind.MethodDeclaration || node.kind === SyntaxKind.MethodSignature) {
|
||||
if (member.kind === SyntaxKind.SemicolonClassElement) {
|
||||
writeLine();
|
||||
write(";");
|
||||
}
|
||||
else if (member.kind === SyntaxKind.MethodDeclaration || node.kind === SyntaxKind.MethodSignature) {
|
||||
if (!(<MethodDeclaration>member).body) {
|
||||
return emitOnlyPinnedOrTripleSlashComments(member);
|
||||
}
|
||||
|
@ -3287,12 +3296,14 @@ module ts {
|
|||
});
|
||||
}
|
||||
|
||||
function emitMemberFunctionsForES6AndHigher(node: ClassDeclaration) {
|
||||
function emitMemberFunctionsForES6AndHigher(node: ClassLikeDeclaration) {
|
||||
for (let member of node.members) {
|
||||
if ((member.kind === SyntaxKind.MethodDeclaration || node.kind === SyntaxKind.MethodSignature) && !(<MethodDeclaration>member).body) {
|
||||
emitOnlyPinnedOrTripleSlashComments(member);
|
||||
}
|
||||
else if (member.kind === SyntaxKind.MethodDeclaration || node.kind === SyntaxKind.MethodSignature || member.kind === SyntaxKind.GetAccessor || member.kind === SyntaxKind.SetAccessor) {
|
||||
else if (member.kind === SyntaxKind.MethodDeclaration ||
|
||||
member.kind === SyntaxKind.GetAccessor ||
|
||||
member.kind === SyntaxKind.SetAccessor) {
|
||||
writeLine();
|
||||
emitLeadingComments(member);
|
||||
emitStart(member);
|
||||
|
@ -3311,10 +3322,14 @@ module ts {
|
|||
emitEnd(member);
|
||||
emitTrailingComments(member);
|
||||
}
|
||||
else if (member.kind === SyntaxKind.SemicolonClassElement) {
|
||||
writeLine();
|
||||
write(";");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function emitConstructor(node: ClassDeclaration, baseTypeNode: TypeReferenceNode) {
|
||||
function emitConstructor(node: ClassLikeDeclaration, baseTypeElement: HeritageClauseElement) {
|
||||
let saveTempFlags = tempFlags;
|
||||
let saveTempVariables = tempVariables;
|
||||
let saveTempParameters = tempParameters;
|
||||
|
@ -3368,7 +3383,7 @@ module ts {
|
|||
// Let constructor be the result of parsing the String "constructor(... args){ super (...args);}" using the syntactic grammar with the goal symbol MethodDefinition.
|
||||
// Else,
|
||||
// Let constructor be the result of parsing the String "constructor( ){ }" using the syntactic grammar with the goal symbol MethodDefinition
|
||||
if (baseTypeNode) {
|
||||
if (baseTypeElement) {
|
||||
write("(...args)");
|
||||
}
|
||||
else {
|
||||
|
@ -3387,7 +3402,7 @@ module ts {
|
|||
if (ctor) {
|
||||
emitDefaultValueAssignments(ctor);
|
||||
emitRestParameter(ctor);
|
||||
if (baseTypeNode) {
|
||||
if (baseTypeElement) {
|
||||
var superCall = findInitialSuperCall(ctor);
|
||||
if (superCall) {
|
||||
writeLine();
|
||||
|
@ -3397,16 +3412,16 @@ module ts {
|
|||
emitParameterPropertyAssignments(ctor);
|
||||
}
|
||||
else {
|
||||
if (baseTypeNode) {
|
||||
if (baseTypeElement) {
|
||||
writeLine();
|
||||
emitStart(baseTypeNode);
|
||||
emitStart(baseTypeElement);
|
||||
if (languageVersion < ScriptTarget.ES6) {
|
||||
write("_super.apply(this, arguments);");
|
||||
}
|
||||
else {
|
||||
write("super(...args);");
|
||||
}
|
||||
emitEnd(baseTypeNode);
|
||||
emitEnd(baseTypeElement);
|
||||
}
|
||||
}
|
||||
emitMemberAssignments(node, /*staticFlag*/0);
|
||||
|
@ -3435,82 +3450,92 @@ module ts {
|
|||
tempParameters = saveTempParameters;
|
||||
}
|
||||
|
||||
function emitClassExpression(node: ClassExpression) {
|
||||
return emitClassLikeDeclaration(node);
|
||||
}
|
||||
|
||||
function emitClassDeclaration(node: ClassDeclaration) {
|
||||
return emitClassLikeDeclaration(node);
|
||||
}
|
||||
|
||||
function emitClassLikeDeclaration(node: ClassLikeDeclaration) {
|
||||
if (languageVersion < ScriptTarget.ES6) {
|
||||
emitClassDeclarationBelowES6(<ClassDeclaration>node);
|
||||
emitClassLikeDeclarationBelowES6(node);
|
||||
}
|
||||
else {
|
||||
emitClassDeclarationForES6AndHigher(<ClassDeclaration>node);
|
||||
emitClassLikeDeclarationForES6AndHigher(node);
|
||||
}
|
||||
}
|
||||
|
||||
function emitClassDeclarationForES6AndHigher(node: ClassDeclaration) {
|
||||
function emitClassLikeDeclarationForES6AndHigher(node: ClassLikeDeclaration) {
|
||||
let thisNodeIsDecorated = nodeIsDecorated(node);
|
||||
if (thisNodeIsDecorated) {
|
||||
// To preserve the correct runtime semantics when decorators are applied to the class,
|
||||
// the emit needs to follow one of the following rules:
|
||||
//
|
||||
// * For a local class declaration:
|
||||
//
|
||||
// @dec class C {
|
||||
// }
|
||||
//
|
||||
// The emit should be:
|
||||
//
|
||||
// let C = class {
|
||||
// };
|
||||
// Object.defineProperty(C, "name", { value: "C", configurable: true });
|
||||
// C = __decorate([dec], C);
|
||||
//
|
||||
// * For an exported class declaration:
|
||||
//
|
||||
// @dec export class C {
|
||||
// }
|
||||
//
|
||||
// The emit should be:
|
||||
//
|
||||
// export let C = class {
|
||||
// };
|
||||
// Object.defineProperty(C, "name", { value: "C", configurable: true });
|
||||
// C = __decorate([dec], C);
|
||||
//
|
||||
// * For a default export of a class declaration with a name:
|
||||
//
|
||||
// @dec default export class C {
|
||||
// }
|
||||
//
|
||||
// The emit should be:
|
||||
//
|
||||
// let C = class {
|
||||
// }
|
||||
// Object.defineProperty(C, "name", { value: "C", configurable: true });
|
||||
// C = __decorate([dec], C);
|
||||
// export default C;
|
||||
//
|
||||
// * For a default export of a class declaration without a name:
|
||||
//
|
||||
// @dec default export class {
|
||||
// }
|
||||
//
|
||||
// The emit should be:
|
||||
//
|
||||
// let _default = class {
|
||||
// }
|
||||
// _default = __decorate([dec], _default);
|
||||
// export default _default;
|
||||
//
|
||||
if (isES6ExportedDeclaration(node) && !(node.flags & NodeFlags.Default)) {
|
||||
write("export ");
|
||||
}
|
||||
if (node.kind === SyntaxKind.ClassDeclaration) {
|
||||
if (thisNodeIsDecorated) {
|
||||
// To preserve the correct runtime semantics when decorators are applied to the class,
|
||||
// the emit needs to follow one of the following rules:
|
||||
//
|
||||
// * For a local class declaration:
|
||||
//
|
||||
// @dec class C {
|
||||
// }
|
||||
//
|
||||
// The emit should be:
|
||||
//
|
||||
// let C = class {
|
||||
// };
|
||||
// Object.defineProperty(C, "name", { value: "C", configurable: true });
|
||||
// C = __decorate([dec], C);
|
||||
//
|
||||
// * For an exported class declaration:
|
||||
//
|
||||
// @dec export class C {
|
||||
// }
|
||||
//
|
||||
// The emit should be:
|
||||
//
|
||||
// export let C = class {
|
||||
// };
|
||||
// Object.defineProperty(C, "name", { value: "C", configurable: true });
|
||||
// C = __decorate([dec], C);
|
||||
//
|
||||
// * For a default export of a class declaration with a name:
|
||||
//
|
||||
// @dec default export class C {
|
||||
// }
|
||||
//
|
||||
// The emit should be:
|
||||
//
|
||||
// let C = class {
|
||||
// }
|
||||
// Object.defineProperty(C, "name", { value: "C", configurable: true });
|
||||
// C = __decorate([dec], C);
|
||||
// export default C;
|
||||
//
|
||||
// * For a default export of a class declaration without a name:
|
||||
//
|
||||
// @dec default export class {
|
||||
// }
|
||||
//
|
||||
// The emit should be:
|
||||
//
|
||||
// let _default = class {
|
||||
// }
|
||||
// _default = __decorate([dec], _default);
|
||||
// export default _default;
|
||||
//
|
||||
if (isES6ExportedDeclaration(node) && !(node.flags & NodeFlags.Default)) {
|
||||
write("export ");
|
||||
}
|
||||
|
||||
write("let ");
|
||||
emitDeclarationName(node);
|
||||
write(" = ");
|
||||
}
|
||||
else if (isES6ExportedDeclaration(node)) {
|
||||
write("export ");
|
||||
if (node.flags & NodeFlags.Default) {
|
||||
write("default ");
|
||||
write("let ");
|
||||
emitDeclarationName(node);
|
||||
write(" = ");
|
||||
}
|
||||
else if (isES6ExportedDeclaration(node)) {
|
||||
write("export ");
|
||||
if (node.flags & NodeFlags.Default) {
|
||||
write("default ");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -3522,10 +3547,10 @@ module ts {
|
|||
emitDeclarationName(node);
|
||||
}
|
||||
|
||||
var baseTypeNode = getClassBaseTypeNode(node);
|
||||
var baseTypeNode = getClassExtendsHeritageClauseElement(node);
|
||||
if (baseTypeNode) {
|
||||
write(" extends ");
|
||||
emit(baseTypeNode.typeName);
|
||||
emit(baseTypeNode.expression);
|
||||
}
|
||||
|
||||
write(" {");
|
||||
|
@ -3588,11 +3613,15 @@ module ts {
|
|||
}
|
||||
}
|
||||
|
||||
function emitClassDeclarationBelowES6(node: ClassDeclaration) {
|
||||
write("var ");
|
||||
emitDeclarationName(node);
|
||||
write(" = (function (");
|
||||
let baseTypeNode = getClassBaseTypeNode(node);
|
||||
function emitClassLikeDeclarationBelowES6(node: ClassLikeDeclaration) {
|
||||
if (node.kind === SyntaxKind.ClassDeclaration) {
|
||||
write("var ");
|
||||
emitDeclarationName(node);
|
||||
write(" = ");
|
||||
}
|
||||
|
||||
write("(function (");
|
||||
let baseTypeNode = getClassExtendsHeritageClauseElement(node);
|
||||
if (baseTypeNode) {
|
||||
write("_super");
|
||||
}
|
||||
|
@ -3639,32 +3668,37 @@ module ts {
|
|||
emitStart(node);
|
||||
write(")(");
|
||||
if (baseTypeNode) {
|
||||
emit(baseTypeNode.typeName);
|
||||
emit(baseTypeNode.expression);
|
||||
}
|
||||
write(")");
|
||||
if (node.kind === SyntaxKind.ClassDeclaration) {
|
||||
write(";");
|
||||
}
|
||||
write(");");
|
||||
emitEnd(node);
|
||||
|
||||
emitExportMemberAssignment(node);
|
||||
if (node.kind === SyntaxKind.ClassDeclaration) {
|
||||
emitExportMemberAssignment(<ClassDeclaration>node);
|
||||
}
|
||||
|
||||
if (languageVersion < ScriptTarget.ES6 && node.parent === currentSourceFile && node.name) {
|
||||
emitExportMemberAssignments(node.name);
|
||||
}
|
||||
}
|
||||
|
||||
function emitClassMemberPrefix(node: ClassDeclaration, member: Node) {
|
||||
function emitClassMemberPrefix(node: ClassLikeDeclaration, member: Node) {
|
||||
emitDeclarationName(node);
|
||||
if (!(member.flags & NodeFlags.Static)) {
|
||||
write(".prototype");
|
||||
}
|
||||
}
|
||||
|
||||
function emitDecoratorsOfClass(node: ClassDeclaration) {
|
||||
function emitDecoratorsOfClass(node: ClassLikeDeclaration) {
|
||||
emitDecoratorsOfMembers(node, /*staticFlag*/ 0);
|
||||
emitDecoratorsOfMembers(node, NodeFlags.Static);
|
||||
emitDecoratorsOfConstructor(node);
|
||||
}
|
||||
|
||||
function emitDecoratorsOfConstructor(node: ClassDeclaration) {
|
||||
function emitDecoratorsOfConstructor(node: ClassLikeDeclaration) {
|
||||
let constructor = getFirstConstructorWithBody(node);
|
||||
if (constructor) {
|
||||
emitDecoratorsOfParameters(node, constructor);
|
||||
|
@ -3696,7 +3730,7 @@ module ts {
|
|||
writeLine();
|
||||
}
|
||||
|
||||
function emitDecoratorsOfMembers(node: ClassDeclaration, staticFlag: NodeFlags) {
|
||||
function emitDecoratorsOfMembers(node: ClassLikeDeclaration, staticFlag: NodeFlags) {
|
||||
forEach(node.members, member => {
|
||||
if ((member.flags & NodeFlags.Static) !== staticFlag) {
|
||||
return;
|
||||
|
@ -3800,7 +3834,7 @@ module ts {
|
|||
});
|
||||
}
|
||||
|
||||
function emitDecoratorsOfParameters(node: ClassDeclaration, member: FunctionLikeDeclaration) {
|
||||
function emitDecoratorsOfParameters(node: ClassLikeDeclaration, member: FunctionLikeDeclaration) {
|
||||
forEach(member.parameters, (parameter, parameterIndex) => {
|
||||
if (!nodeIsDecorated(parameter)) {
|
||||
return;
|
||||
|
@ -3872,7 +3906,7 @@ module ts {
|
|||
|
||||
function shouldEmitEnumDeclaration(node: EnumDeclaration) {
|
||||
let isConstEnum = isConst(node);
|
||||
return !isConstEnum || compilerOptions.preserveConstEnums;
|
||||
return !isConstEnum || compilerOptions.preserveConstEnums || compilerOptions.separateCompilation;
|
||||
}
|
||||
|
||||
function emitEnumDeclaration(node: EnumDeclaration) {
|
||||
|
@ -3964,7 +3998,7 @@ module ts {
|
|||
}
|
||||
|
||||
function shouldEmitModuleDeclaration(node: ModuleDeclaration) {
|
||||
return isInstantiatedModule(node, compilerOptions.preserveConstEnums);
|
||||
return isInstantiatedModule(node, compilerOptions.preserveConstEnums || compilerOptions.separateCompilation);
|
||||
}
|
||||
|
||||
function emitModuleDeclaration(node: ModuleDeclaration) {
|
||||
|
@ -4768,6 +4802,8 @@ var __decorate = this.__decorate || function (decorators, target, key, value) {
|
|||
return emitDebuggerStatement(node);
|
||||
case SyntaxKind.VariableDeclaration:
|
||||
return emitVariableDeclaration(<VariableDeclaration>node);
|
||||
case SyntaxKind.ClassExpression:
|
||||
return emitClassExpression(<ClassExpression>node);
|
||||
case SyntaxKind.ClassDeclaration:
|
||||
return emitClassDeclaration(<ClassDeclaration>node);
|
||||
case SyntaxKind.InterfaceDeclaration:
|
||||
|
|
|
@ -237,12 +237,13 @@ module ts {
|
|||
case SyntaxKind.Decorator:
|
||||
return visitNode(cbNode, (<Decorator>node).expression);
|
||||
case SyntaxKind.ClassDeclaration:
|
||||
case SyntaxKind.ClassExpression:
|
||||
return visitNodes(cbNodes, node.decorators) ||
|
||||
visitNodes(cbNodes, node.modifiers) ||
|
||||
visitNode(cbNode, (<ClassDeclaration>node).name) ||
|
||||
visitNodes(cbNodes, (<ClassDeclaration>node).typeParameters) ||
|
||||
visitNodes(cbNodes, (<ClassDeclaration>node).heritageClauses) ||
|
||||
visitNodes(cbNodes, (<ClassDeclaration>node).members);
|
||||
visitNode(cbNode, (<ClassLikeDeclaration>node).name) ||
|
||||
visitNodes(cbNodes, (<ClassLikeDeclaration>node).typeParameters) ||
|
||||
visitNodes(cbNodes, (<ClassLikeDeclaration>node).heritageClauses) ||
|
||||
visitNodes(cbNodes, (<ClassLikeDeclaration>node).members);
|
||||
case SyntaxKind.InterfaceDeclaration:
|
||||
return visitNodes(cbNodes, node.decorators) ||
|
||||
visitNodes(cbNodes, node.modifiers) ||
|
||||
|
@ -308,6 +309,9 @@ module ts {
|
|||
return visitNode(cbNode, (<ComputedPropertyName>node).expression);
|
||||
case SyntaxKind.HeritageClause:
|
||||
return visitNodes(cbNodes, (<HeritageClause>node).types);
|
||||
case SyntaxKind.HeritageClauseElement:
|
||||
return visitNode(cbNode, (<HeritageClauseElement>node).expression) ||
|
||||
visitNodes(cbNodes, (<HeritageClauseElement>node).typeArguments);
|
||||
case SyntaxKind.ExternalModuleReference:
|
||||
return visitNode(cbNode, (<ExternalModuleReference>node).expression);
|
||||
case SyntaxKind.MissingDeclaration:
|
||||
|
@ -324,7 +328,7 @@ module ts {
|
|||
TypeMembers, // Members in interface or type literal
|
||||
ClassMembers, // Members in class declaration
|
||||
EnumMembers, // Members in enum declaration
|
||||
TypeReferences, // Type references in extends or implements clause
|
||||
HeritageClauseElement, // Elements in a heritage clause
|
||||
VariableDeclarations, // Variable declarations in variable statement
|
||||
ObjectBindingElements, // Binding elements in object binding list
|
||||
ArrayBindingElements, // Binding elements in array binding list
|
||||
|
@ -356,7 +360,7 @@ module ts {
|
|||
case ParsingContext.TypeMembers: return Diagnostics.Property_or_signature_expected;
|
||||
case ParsingContext.ClassMembers: return Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected;
|
||||
case ParsingContext.EnumMembers: return Diagnostics.Enum_member_expected;
|
||||
case ParsingContext.TypeReferences: return Diagnostics.Type_reference_expected;
|
||||
case ParsingContext.HeritageClauseElement: return Diagnostics.Expression_expected;
|
||||
case ParsingContext.VariableDeclarations: return Diagnostics.Variable_declaration_expected;
|
||||
case ParsingContext.ObjectBindingElements: return Diagnostics.Property_destructuring_pattern_expected;
|
||||
case ParsingContext.ArrayBindingElements: return Diagnostics.Array_element_destructuring_pattern_expected;
|
||||
|
@ -1605,7 +1609,11 @@ module ts {
|
|||
case ParsingContext.TypeMembers:
|
||||
return isStartOfTypeMember();
|
||||
case ParsingContext.ClassMembers:
|
||||
return lookAhead(isClassMemberStart);
|
||||
// We allow semicolons as class elements (as specified by ES6) as long as we're
|
||||
// not in error recovery. If we're in error recovery, we don't want an errant
|
||||
// semicolon to be treated as a class member (since they're almost always used
|
||||
// for statements.
|
||||
return lookAhead(isClassMemberStart) || (token === SyntaxKind.SemicolonToken && !inErrorRecovery);
|
||||
case ParsingContext.EnumMembers:
|
||||
// Include open bracket computed properties. This technically also lets in indexers,
|
||||
// which would be a candidate for improved error reporting.
|
||||
|
@ -1614,10 +1622,22 @@ module ts {
|
|||
return token === SyntaxKind.OpenBracketToken || token === SyntaxKind.AsteriskToken || isLiteralPropertyName();
|
||||
case ParsingContext.ObjectBindingElements:
|
||||
return isLiteralPropertyName();
|
||||
case ParsingContext.TypeReferences:
|
||||
// We want to make sure that the "extends" in "extends foo" or the "implements" in
|
||||
// "implements foo" is not considered a type name.
|
||||
return isIdentifier() && !isNotHeritageClauseTypeName();
|
||||
case ParsingContext.HeritageClauseElement:
|
||||
// If we see { } then only consume it as an expression if it is followed by , or {
|
||||
// That way we won't consume the body of a class in its heritage clause.
|
||||
if (token === SyntaxKind.OpenBraceToken) {
|
||||
return lookAhead(isValidHeritageClauseObjectLiteral);
|
||||
}
|
||||
|
||||
if (!inErrorRecovery) {
|
||||
return isStartOfLeftHandSideExpression() && !isHeritageClauseExtendsOrImplementsKeyword();
|
||||
}
|
||||
else {
|
||||
// If we're in error recovery we tighten up what we're willing to match.
|
||||
// That way we don't treat something like "this" as a valid heritage clause
|
||||
// element during recovery.
|
||||
return isIdentifier() && !isHeritageClauseExtendsOrImplementsKeyword();
|
||||
}
|
||||
case ParsingContext.VariableDeclarations:
|
||||
return isIdentifierOrPattern();
|
||||
case ParsingContext.ArrayBindingElements:
|
||||
|
@ -1641,21 +1661,44 @@ module ts {
|
|||
Debug.fail("Non-exhaustive case in 'isListElement'.");
|
||||
}
|
||||
|
||||
function isValidHeritageClauseObjectLiteral() {
|
||||
Debug.assert(token === SyntaxKind.OpenBraceToken);
|
||||
if (nextToken() === SyntaxKind.CloseBraceToken) {
|
||||
// if we see "extends {}" then only treat the {} as what we're extending (and not
|
||||
// the class body) if we have:
|
||||
//
|
||||
// extends {} {
|
||||
// extends {},
|
||||
// extends {} extends
|
||||
// extends {} implements
|
||||
|
||||
let next = nextToken();
|
||||
return next === SyntaxKind.CommaToken || next === SyntaxKind.OpenBraceToken || next === SyntaxKind.ExtendsKeyword || next === SyntaxKind.ImplementsKeyword;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
function nextTokenIsIdentifier() {
|
||||
nextToken();
|
||||
return isIdentifier();
|
||||
}
|
||||
|
||||
function isNotHeritageClauseTypeName(): boolean {
|
||||
function isHeritageClauseExtendsOrImplementsKeyword(): boolean {
|
||||
if (token === SyntaxKind.ImplementsKeyword ||
|
||||
token === SyntaxKind.ExtendsKeyword) {
|
||||
|
||||
return lookAhead(nextTokenIsIdentifier);
|
||||
return lookAhead(nextTokenIsStartOfExpression);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
function nextTokenIsStartOfExpression() {
|
||||
nextToken();
|
||||
return isStartOfExpression();
|
||||
}
|
||||
|
||||
// True if positioned at a list terminator
|
||||
function isListTerminator(kind: ParsingContext): boolean {
|
||||
if (token === SyntaxKind.EndOfFileToken) {
|
||||
|
@ -1676,7 +1719,7 @@ module ts {
|
|||
return token === SyntaxKind.CloseBraceToken;
|
||||
case ParsingContext.SwitchClauseStatements:
|
||||
return token === SyntaxKind.CloseBraceToken || token === SyntaxKind.CaseKeyword || token === SyntaxKind.DefaultKeyword;
|
||||
case ParsingContext.TypeReferences:
|
||||
case ParsingContext.HeritageClauseElement:
|
||||
return token === SyntaxKind.OpenBraceToken || token === SyntaxKind.ExtendsKeyword || token === SyntaxKind.ImplementsKeyword;
|
||||
case ParsingContext.VariableDeclarations:
|
||||
return isVariableDeclaratorListTerminator();
|
||||
|
@ -1891,12 +1934,6 @@ module ts {
|
|||
// This would probably be safe to reuse. There is no speculative parsing with
|
||||
// heritage clauses.
|
||||
|
||||
case ParsingContext.TypeReferences:
|
||||
// This would probably be safe to reuse. There is no speculative parsing with
|
||||
// type names in a heritage clause. There can be generic names in the type
|
||||
// name list. But because it is a type context, we never use speculative
|
||||
// parsing on the type argument list.
|
||||
|
||||
case ParsingContext.TypeParameters:
|
||||
// This would probably be safe to reuse. There is no speculative parsing with
|
||||
// type parameters. Note that that's because type *parameters* only occur in
|
||||
|
@ -1923,6 +1960,12 @@ module ts {
|
|||
// cases. i.e. a property assignment may end with an expression, and thus might
|
||||
// have lookahead far beyond it's old node.
|
||||
case ParsingContext.ObjectLiteralMembers:
|
||||
|
||||
// This is probably not safe to reuse. There can be speculative parsing with
|
||||
// type names in a heritage clause. There can be generic names in the type
|
||||
// name list, and there can be left hand side expressions (which can have type
|
||||
// arguments.)
|
||||
case ParsingContext.HeritageClauseElement:
|
||||
}
|
||||
|
||||
return false;
|
||||
|
@ -1957,6 +2000,7 @@ module ts {
|
|||
case SyntaxKind.GetAccessor:
|
||||
case SyntaxKind.SetAccessor:
|
||||
case SyntaxKind.PropertyDeclaration:
|
||||
case SyntaxKind.SemicolonClassElement:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
@ -2846,8 +2890,7 @@ module ts {
|
|||
}
|
||||
|
||||
// EXPRESSIONS
|
||||
|
||||
function isStartOfExpression(): boolean {
|
||||
function isStartOfLeftHandSideExpression(): boolean {
|
||||
switch (token) {
|
||||
case SyntaxKind.ThisKeyword:
|
||||
case SyntaxKind.SuperKeyword:
|
||||
|
@ -2862,9 +2905,23 @@ module ts {
|
|||
case SyntaxKind.OpenBracketToken:
|
||||
case SyntaxKind.OpenBraceToken:
|
||||
case SyntaxKind.FunctionKeyword:
|
||||
case SyntaxKind.ClassKeyword:
|
||||
case SyntaxKind.NewKeyword:
|
||||
case SyntaxKind.SlashToken:
|
||||
case SyntaxKind.SlashEqualsToken:
|
||||
case SyntaxKind.Identifier:
|
||||
return true;
|
||||
default:
|
||||
return isIdentifier();
|
||||
}
|
||||
}
|
||||
|
||||
function isStartOfExpression(): boolean {
|
||||
if (isStartOfLeftHandSideExpression()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
switch (token) {
|
||||
case SyntaxKind.PlusToken:
|
||||
case SyntaxKind.MinusToken:
|
||||
case SyntaxKind.TildeToken:
|
||||
|
@ -2875,7 +2932,6 @@ module ts {
|
|||
case SyntaxKind.PlusPlusToken:
|
||||
case SyntaxKind.MinusMinusToken:
|
||||
case SyntaxKind.LessThanToken:
|
||||
case SyntaxKind.Identifier:
|
||||
case SyntaxKind.YieldKeyword:
|
||||
// Yield always starts an expression. Either it is an identifier (in which case
|
||||
// it is definitely an expression). Or it's a keyword (either because we're in
|
||||
|
@ -2895,8 +2951,12 @@ module ts {
|
|||
}
|
||||
|
||||
function isStartOfExpressionStatement(): boolean {
|
||||
// As per the grammar, neither '{' nor 'function' can start an expression statement.
|
||||
return token !== SyntaxKind.OpenBraceToken && token !== SyntaxKind.FunctionKeyword && token !== SyntaxKind.AtToken && isStartOfExpression();
|
||||
// As per the grammar, none of '{' or 'function' or 'class' can start an expression statement.
|
||||
return token !== SyntaxKind.OpenBraceToken &&
|
||||
token !== SyntaxKind.FunctionKeyword &&
|
||||
token !== SyntaxKind.ClassKeyword &&
|
||||
token !== SyntaxKind.AtToken &&
|
||||
isStartOfExpression();
|
||||
}
|
||||
|
||||
function parseExpression(): Expression {
|
||||
|
@ -3241,8 +3301,12 @@ module ts {
|
|||
return parseFunctionBlock(/*allowYield:*/ false, /* ignoreMissingOpenBrace */ false);
|
||||
}
|
||||
|
||||
if (isStartOfStatement(/*inErrorRecovery:*/ true) && !isStartOfExpressionStatement() && token !== SyntaxKind.FunctionKeyword) {
|
||||
// Check if we got a plain statement (i.e. no expression-statements, no functions expressions/declarations)
|
||||
if (isStartOfStatement(/*inErrorRecovery:*/ true) &&
|
||||
!isStartOfExpressionStatement() &&
|
||||
token !== SyntaxKind.FunctionKeyword &&
|
||||
token !== SyntaxKind.ClassKeyword) {
|
||||
|
||||
// Check if we got a plain statement (i.e. no expression-statements, no function/class expressions/declarations)
|
||||
//
|
||||
// Here we try to recover from a potential error situation in the case where the
|
||||
// user meant to supply a block. For example, if the user wrote:
|
||||
|
@ -3667,7 +3731,6 @@ module ts {
|
|||
case SyntaxKind.CloseBracketToken: // foo<x>]
|
||||
case SyntaxKind.ColonToken: // foo<x>:
|
||||
case SyntaxKind.SemicolonToken: // foo<x>;
|
||||
case SyntaxKind.CommaToken: // foo<x>,
|
||||
case SyntaxKind.QuestionToken: // foo<x>?
|
||||
case SyntaxKind.EqualsEqualsToken: // foo<x> ==
|
||||
case SyntaxKind.EqualsEqualsEqualsToken: // foo<x> ===
|
||||
|
@ -3685,6 +3748,12 @@ module ts {
|
|||
// treat it as such.
|
||||
return true;
|
||||
|
||||
case SyntaxKind.CommaToken: // foo<x>,
|
||||
case SyntaxKind.OpenBraceToken: // foo<x> {
|
||||
// We don't want to treat these as type arguments. Otherwise we'll parse this
|
||||
// as an invocation expression. Instead, we want to parse out the expression
|
||||
// in isolation from the type arguments.
|
||||
|
||||
default:
|
||||
// Anything else treat as an expression.
|
||||
return false;
|
||||
|
@ -3709,6 +3778,8 @@ module ts {
|
|||
return parseArrayLiteralExpression();
|
||||
case SyntaxKind.OpenBraceToken:
|
||||
return parseObjectLiteralExpression();
|
||||
case SyntaxKind.ClassKeyword:
|
||||
return parseClassExpression();
|
||||
case SyntaxKind.FunctionKeyword:
|
||||
return parseFunctionExpression();
|
||||
case SyntaxKind.NewKeyword:
|
||||
|
@ -4129,13 +4200,14 @@ module ts {
|
|||
}
|
||||
|
||||
function isStartOfStatement(inErrorRecovery: boolean): boolean {
|
||||
// Functions and variable statements are allowed as a statement. But as per the grammar,
|
||||
// they also allow modifiers. So we have to check for those statements that might be
|
||||
// following modifiers.This ensures that things work properly when incrementally parsing
|
||||
// as the parser will produce the same FunctionDeclaraiton or VariableStatement if it has
|
||||
// the same text regardless of whether it is inside a block or not.
|
||||
// Functions, variable statements and classes are allowed as a statement. But as per
|
||||
// the grammar, they also allow modifiers. So we have to check for those statements
|
||||
// that might be following modifiers.This ensures that things work properly when
|
||||
// incrementally parsing as the parser will produce the same FunctionDeclaraiton,
|
||||
// VariableStatement or ClassDeclaration, if it has the same text regardless of whether
|
||||
// it is inside a block or not.
|
||||
if (isModifier(token)) {
|
||||
let result = lookAhead(parseVariableStatementOrFunctionDeclarationWithDecoratorsOrModifiers);
|
||||
let result = lookAhead(parseVariableStatementOrFunctionDeclarationOrClassDeclarationWithDecoratorsOrModifiers);
|
||||
if (result) {
|
||||
return true;
|
||||
}
|
||||
|
@ -4154,6 +4226,7 @@ module ts {
|
|||
case SyntaxKind.VarKeyword:
|
||||
case SyntaxKind.LetKeyword:
|
||||
case SyntaxKind.FunctionKeyword:
|
||||
case SyntaxKind.ClassKeyword:
|
||||
case SyntaxKind.IfKeyword:
|
||||
case SyntaxKind.DoKeyword:
|
||||
case SyntaxKind.WhileKeyword:
|
||||
|
@ -4178,7 +4251,6 @@ module ts {
|
|||
let isConstEnum = lookAhead(nextTokenIsEnumKeyword);
|
||||
return !isConstEnum;
|
||||
case SyntaxKind.InterfaceKeyword:
|
||||
case SyntaxKind.ClassKeyword:
|
||||
case SyntaxKind.ModuleKeyword:
|
||||
case SyntaxKind.EnumKeyword:
|
||||
case SyntaxKind.TypeKeyword:
|
||||
|
@ -4222,6 +4294,8 @@ module ts {
|
|||
return parseVariableStatement(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers:*/ undefined);
|
||||
case SyntaxKind.FunctionKeyword:
|
||||
return parseFunctionDeclaration(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers:*/ undefined);
|
||||
case SyntaxKind.ClassKeyword:
|
||||
return parseClassDeclaration(scanner.getStartPos(), /*decorators*/ undefined, /*modifiers:*/ undefined);
|
||||
case SyntaxKind.SemicolonToken:
|
||||
return parseEmptyStatement();
|
||||
case SyntaxKind.IfKeyword:
|
||||
|
@ -4267,7 +4341,7 @@ module ts {
|
|||
// Even though variable statements and function declarations cannot have decorators,
|
||||
// we parse them here to provide better error recovery.
|
||||
if (isModifier(token) || token === SyntaxKind.AtToken) {
|
||||
let result = tryParse(parseVariableStatementOrFunctionDeclarationWithDecoratorsOrModifiers);
|
||||
let result = tryParse(parseVariableStatementOrFunctionDeclarationOrClassDeclarationWithDecoratorsOrModifiers);
|
||||
if (result) {
|
||||
return result;
|
||||
}
|
||||
|
@ -4277,7 +4351,7 @@ module ts {
|
|||
}
|
||||
}
|
||||
|
||||
function parseVariableStatementOrFunctionDeclarationWithDecoratorsOrModifiers(): FunctionDeclaration | VariableStatement {
|
||||
function parseVariableStatementOrFunctionDeclarationOrClassDeclarationWithDecoratorsOrModifiers(): FunctionDeclaration | VariableStatement | ClassDeclaration {
|
||||
let start = scanner.getStartPos();
|
||||
let decorators = parseDecorators();
|
||||
let modifiers = parseModifiers();
|
||||
|
@ -4297,8 +4371,12 @@ module ts {
|
|||
|
||||
case SyntaxKind.VarKeyword:
|
||||
return parseVariableStatement(start, decorators, modifiers);
|
||||
|
||||
case SyntaxKind.FunctionKeyword:
|
||||
return parseFunctionDeclaration(start, decorators, modifiers);
|
||||
|
||||
case SyntaxKind.ClassKeyword:
|
||||
return parseClassDeclaration(start, decorators, modifiers);
|
||||
}
|
||||
|
||||
return undefined;
|
||||
|
@ -4619,6 +4697,12 @@ module ts {
|
|||
}
|
||||
|
||||
function parseClassElement(): ClassElement {
|
||||
if (token === SyntaxKind.SemicolonToken) {
|
||||
let result = <SemicolonClassElement>createNode(SyntaxKind.SemicolonClassElement);
|
||||
nextToken();
|
||||
return finishNode(result);
|
||||
}
|
||||
|
||||
let fullStart = getNodePos();
|
||||
let decorators = parseDecorators();
|
||||
let modifiers = parseModifiers();
|
||||
|
@ -4657,14 +4741,26 @@ module ts {
|
|||
Debug.fail("Should not have attempted to parse class member declaration.");
|
||||
}
|
||||
|
||||
function parseClassExpression(): ClassExpression {
|
||||
return <ClassExpression>parseClassDeclarationOrExpression(
|
||||
/*fullStart:*/ scanner.getStartPos(),
|
||||
/*decorators:*/ undefined,
|
||||
/*modifiers:*/ undefined,
|
||||
SyntaxKind.ClassExpression);
|
||||
}
|
||||
|
||||
function parseClassDeclaration(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray): ClassDeclaration {
|
||||
return <ClassDeclaration>parseClassDeclarationOrExpression(fullStart, decorators, modifiers, SyntaxKind.ClassDeclaration);
|
||||
}
|
||||
|
||||
function parseClassDeclarationOrExpression(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray, kind: SyntaxKind): ClassLikeDeclaration {
|
||||
// In ES6 specification, All parts of a ClassDeclaration or a ClassExpression are strict mode code
|
||||
let savedStrictModeContext = inStrictModeContext();
|
||||
if (languageVersion >= ScriptTarget.ES6) {
|
||||
setStrictModeContext(true);
|
||||
}
|
||||
|
||||
var node = <ClassDeclaration>createNode(SyntaxKind.ClassDeclaration, fullStart);
|
||||
var node = <ClassLikeDeclaration>createNode(kind, fullStart);
|
||||
node.decorators = decorators;
|
||||
setModifiers(node, modifiers);
|
||||
parseExpected(SyntaxKind.ClassKeyword);
|
||||
|
@ -4714,13 +4810,23 @@ module ts {
|
|||
let node = <HeritageClause>createNode(SyntaxKind.HeritageClause);
|
||||
node.token = token;
|
||||
nextToken();
|
||||
node.types = parseDelimitedList(ParsingContext.TypeReferences, parseTypeReference);
|
||||
node.types = parseDelimitedList(ParsingContext.HeritageClauseElement, parseHeritageClauseElement);
|
||||
return finishNode(node);
|
||||
}
|
||||
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function parseHeritageClauseElement(): HeritageClauseElement {
|
||||
let node = <HeritageClauseElement>createNode(SyntaxKind.HeritageClauseElement);
|
||||
node.expression = parseLeftHandSideExpressionOrHigher();
|
||||
if (token === SyntaxKind.LessThanToken) {
|
||||
node.typeArguments = parseBracketedList(ParsingContext.TypeArguments, parseType, SyntaxKind.LessThanToken, SyntaxKind.GreaterThanToken);
|
||||
}
|
||||
|
||||
return finishNode(node);
|
||||
}
|
||||
|
||||
function isHeritageClause(): boolean {
|
||||
return token === SyntaxKind.ExtendsKeyword || token === SyntaxKind.ImplementsKeyword;
|
||||
}
|
||||
|
@ -5263,6 +5369,7 @@ module ts {
|
|||
case SyntaxKind.ArrayLiteralExpression:
|
||||
case SyntaxKind.ParenthesizedExpression:
|
||||
case SyntaxKind.ObjectLiteralExpression:
|
||||
case SyntaxKind.ClassExpression:
|
||||
case SyntaxKind.FunctionExpression:
|
||||
case SyntaxKind.Identifier:
|
||||
case SyntaxKind.RegularExpressionLiteral:
|
||||
|
|
|
@ -454,6 +454,24 @@ module ts {
|
|||
}
|
||||
|
||||
function verifyCompilerOptions() {
|
||||
if (options.separateCompilation) {
|
||||
if (options.sourceMap) {
|
||||
diagnostics.add(createCompilerDiagnostic(Diagnostics.Option_sourceMap_cannot_be_specified_with_option_separateCompilation));
|
||||
}
|
||||
|
||||
if (options.declaration) {
|
||||
diagnostics.add(createCompilerDiagnostic(Diagnostics.Option_declaration_cannot_be_specified_with_option_separateCompilation));
|
||||
}
|
||||
|
||||
if (options.noEmitOnError) {
|
||||
diagnostics.add(createCompilerDiagnostic(Diagnostics.Option_noEmitOnError_cannot_be_specified_with_option_separateCompilation));
|
||||
}
|
||||
|
||||
if (options.out) {
|
||||
diagnostics.add(createCompilerDiagnostic(Diagnostics.Option_out_cannot_be_specified_with_option_separateCompilation));
|
||||
}
|
||||
}
|
||||
|
||||
if (!options.sourceMap && (options.mapRoot || options.sourceRoot)) {
|
||||
// Error to specify --mapRoot or --sourceRoot without mapSourceFiles
|
||||
if (options.mapRoot) {
|
||||
|
@ -468,12 +486,21 @@ module ts {
|
|||
let languageVersion = options.target || ScriptTarget.ES3;
|
||||
|
||||
let firstExternalModuleSourceFile = forEach(files, f => isExternalModule(f) ? f : undefined);
|
||||
if (firstExternalModuleSourceFile && !options.module) {
|
||||
if (options.separateCompilation) {
|
||||
if (!options.module && languageVersion < ScriptTarget.ES6) {
|
||||
// We cannot use createDiagnosticFromNode because nodes do not have parents yet
|
||||
let span = getErrorSpanForNode(firstExternalModuleSourceFile, firstExternalModuleSourceFile.externalModuleIndicator);
|
||||
diagnostics.add(createFileDiagnostic(firstExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_compile_external_modules_unless_the_module_flag_is_provided));
|
||||
diagnostics.add(createCompilerDiagnostic(Diagnostics.Option_separateCompilation_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES6_or_higher));
|
||||
}
|
||||
|
||||
let firstNonExternalModuleSourceFile = forEach(files, f => !isExternalModule(f) && !isDeclarationFile(f) ? f : undefined);
|
||||
if (firstNonExternalModuleSourceFile) {
|
||||
let span = getErrorSpanForNode(firstNonExternalModuleSourceFile, firstNonExternalModuleSourceFile);
|
||||
diagnostics.add(createFileDiagnostic(firstNonExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_compile_non_external_modules_when_the_separateCompilation_flag_is_provided));
|
||||
}
|
||||
}
|
||||
else if (firstExternalModuleSourceFile && languageVersion < ScriptTarget.ES6 && !options.module) {
|
||||
// We cannot use createDiagnosticFromNode because nodes do not have parents yet
|
||||
let span = getErrorSpanForNode(firstExternalModuleSourceFile, firstExternalModuleSourceFile.externalModuleIndicator);
|
||||
diagnostics.add(createFileDiagnostic(firstExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_compile_external_modules_unless_the_module_flag_is_provided));
|
||||
}
|
||||
|
||||
// Cannot specify module gen target when in es6 or above
|
||||
|
@ -481,11 +508,11 @@ module ts {
|
|||
diagnostics.add(createCompilerDiagnostic(Diagnostics.Cannot_compile_external_modules_into_amd_or_commonjs_when_targeting_es6_or_higher));
|
||||
}
|
||||
|
||||
// there has to be common source directory if user specified --outdir || --sourcRoot
|
||||
// there has to be common source directory if user specified --outdir || --sourceRoot
|
||||
// if user specified --mapRoot, there needs to be common source directory if there would be multiple files being emitted
|
||||
if (options.outDir || // there is --outDir specified
|
||||
options.sourceRoot || // there is --sourceRoot specified
|
||||
(options.mapRoot && // there is --mapRoot Specified and there would be multiple js files generated
|
||||
(options.mapRoot && // there is --mapRoot specified and there would be multiple js files generated
|
||||
(!options.out || firstExternalModuleSourceFile !== undefined))) {
|
||||
|
||||
let commonPathComponents: string[];
|
||||
|
|
|
@ -203,9 +203,12 @@ module ts {
|
|||
TemplateExpression,
|
||||
YieldExpression,
|
||||
SpreadElementExpression,
|
||||
ClassExpression,
|
||||
OmittedExpression,
|
||||
// Misc
|
||||
TemplateSpan,
|
||||
HeritageClauseElement,
|
||||
SemicolonClassElement,
|
||||
// Element
|
||||
Block,
|
||||
VariableStatement,
|
||||
|
@ -536,6 +539,11 @@ module ts {
|
|||
body?: Block;
|
||||
}
|
||||
|
||||
// For when we encounter a semicolon in a class declaration. ES6 allows these as class elements.
|
||||
export interface SemicolonClassElement extends ClassElement {
|
||||
_semicolonClassElementBrand: any;
|
||||
}
|
||||
|
||||
// See the comment on MethodDeclaration for the intuition behind AccessorDeclaration being a
|
||||
// ClassElement and an ObjectLiteralElement.
|
||||
export interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
|
||||
|
@ -728,6 +736,11 @@ module ts {
|
|||
arguments: NodeArray<Expression>;
|
||||
}
|
||||
|
||||
export interface HeritageClauseElement extends Node {
|
||||
expression: LeftHandSideExpression;
|
||||
typeArguments?: NodeArray<TypeNode>;
|
||||
}
|
||||
|
||||
export interface NewExpression extends CallExpression, PrimaryExpression { }
|
||||
|
||||
export interface TaggedTemplateExpression extends MemberExpression {
|
||||
|
@ -849,13 +862,19 @@ module ts {
|
|||
_moduleElementBrand: any;
|
||||
}
|
||||
|
||||
export interface ClassDeclaration extends Declaration, ModuleElement {
|
||||
export interface ClassLikeDeclaration extends Declaration {
|
||||
name?: Identifier;
|
||||
typeParameters?: NodeArray<TypeParameterDeclaration>;
|
||||
heritageClauses?: NodeArray<HeritageClause>;
|
||||
members: NodeArray<ClassElement>;
|
||||
}
|
||||
|
||||
export interface ClassDeclaration extends ClassLikeDeclaration, Statement {
|
||||
}
|
||||
|
||||
export interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
|
||||
}
|
||||
|
||||
export interface ClassElement extends Declaration {
|
||||
_classElementBrand: any;
|
||||
}
|
||||
|
@ -869,7 +888,7 @@ module ts {
|
|||
|
||||
export interface HeritageClause extends Node {
|
||||
token: SyntaxKind;
|
||||
types?: NodeArray<TypeReferenceNode>;
|
||||
types?: NodeArray<HeritageClauseElement>;
|
||||
}
|
||||
|
||||
export interface TypeAliasDeclaration extends Declaration, ModuleElement {
|
||||
|
@ -1231,7 +1250,7 @@ module ts {
|
|||
writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
|
||||
writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
|
||||
isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
|
||||
isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
// Returns the constant value this property access resolves to, or 'undefined' for a non-constant
|
||||
getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
|
||||
resolvesToSomeValue(location: Node, name: string): boolean;
|
||||
|
@ -1560,7 +1579,6 @@ module ts {
|
|||
export interface CompilerOptions {
|
||||
allowNonTsExtensions?: boolean;
|
||||
charset?: string;
|
||||
codepage?: number;
|
||||
declaration?: boolean;
|
||||
diagnostics?: boolean;
|
||||
emitBOM?: boolean;
|
||||
|
@ -1574,7 +1592,6 @@ module ts {
|
|||
noErrorTruncation?: boolean;
|
||||
noImplicitAny?: boolean;
|
||||
noLib?: boolean;
|
||||
noLibCheck?: boolean;
|
||||
noResolve?: boolean;
|
||||
out?: string;
|
||||
outDir?: string;
|
||||
|
@ -1587,6 +1604,7 @@ module ts {
|
|||
target?: ScriptTarget;
|
||||
version?: boolean;
|
||||
watch?: boolean;
|
||||
separateCompilation?: boolean;
|
||||
/* @internal */ stripInternal?: boolean;
|
||||
[option: string]: string | number | boolean;
|
||||
}
|
||||
|
|
|
@ -274,11 +274,19 @@ module ts {
|
|||
export function getErrorSpanForNode(sourceFile: SourceFile, node: Node): TextSpan {
|
||||
let errorNode = node;
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.SourceFile:
|
||||
let pos = skipTrivia(sourceFile.text, 0, /*stopAfterLineBreak*/ false);
|
||||
if (pos === sourceFile.text.length) {
|
||||
// file is empty - return span for the beginning of the file
|
||||
return createTextSpan(0, 0);
|
||||
}
|
||||
return getSpanOfTokenAtPosition(sourceFile, pos);
|
||||
// This list is a work in progress. Add missing node kinds to improve their error
|
||||
// spans.
|
||||
case SyntaxKind.VariableDeclaration:
|
||||
case SyntaxKind.BindingElement:
|
||||
case SyntaxKind.ClassDeclaration:
|
||||
case SyntaxKind.ClassExpression:
|
||||
case SyntaxKind.InterfaceDeclaration:
|
||||
case SyntaxKind.ModuleDeclaration:
|
||||
case SyntaxKind.EnumDeclaration:
|
||||
|
@ -670,6 +678,7 @@ module ts {
|
|||
case SyntaxKind.TypeAssertionExpression:
|
||||
case SyntaxKind.ParenthesizedExpression:
|
||||
case SyntaxKind.FunctionExpression:
|
||||
case SyntaxKind.ClassExpression:
|
||||
case SyntaxKind.ArrowFunction:
|
||||
case SyntaxKind.VoidExpression:
|
||||
case SyntaxKind.DeleteExpression:
|
||||
|
@ -942,12 +951,12 @@ module ts {
|
|||
node.kind === SyntaxKind.ExportAssignment && (<ExportAssignment>node).expression.kind === SyntaxKind.Identifier;
|
||||
}
|
||||
|
||||
export function getClassBaseTypeNode(node: ClassDeclaration) {
|
||||
export function getClassExtendsHeritageClauseElement(node: ClassLikeDeclaration) {
|
||||
let heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ExtendsKeyword);
|
||||
return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : undefined;
|
||||
}
|
||||
|
||||
export function getClassImplementedTypeNodes(node: ClassDeclaration) {
|
||||
export function getClassImplementsHeritageClauseElements(node: ClassDeclaration) {
|
||||
let heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ImplementsKeyword);
|
||||
return heritageClause ? heritageClause.types : undefined;
|
||||
}
|
||||
|
@ -1573,7 +1582,7 @@ module ts {
|
|||
return getLineAndCharacterOfPosition(currentSourceFile, pos).line;
|
||||
}
|
||||
|
||||
export function getFirstConstructorWithBody(node: ClassDeclaration): ConstructorDeclaration {
|
||||
export function getFirstConstructorWithBody(node: ClassLikeDeclaration): ConstructorDeclaration {
|
||||
return forEach(node.members, member => {
|
||||
if (member.kind === SyntaxKind.Constructor && nodeIsPresent((<ConstructorDeclaration>member).body)) {
|
||||
return <ConstructorDeclaration>member;
|
||||
|
@ -1768,7 +1777,30 @@ module ts {
|
|||
}
|
||||
}
|
||||
|
||||
// Returns false if this heritage clause element's expression contains something unsupported
|
||||
// (i.e. not a name or dotted name).
|
||||
export function isSupportedHeritageClauseElement(node: HeritageClauseElement): boolean {
|
||||
return isSupportedHeritageClauseElementExpression(node.expression);
|
||||
}
|
||||
|
||||
function isSupportedHeritageClauseElementExpression(node: Expression): boolean {
|
||||
if (node.kind === SyntaxKind.Identifier) {
|
||||
return true;
|
||||
}
|
||||
else if (node.kind === SyntaxKind.PropertyAccessExpression) {
|
||||
return isSupportedHeritageClauseElementExpression((<PropertyAccessExpression>node).expression);
|
||||
}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
export function isRightSideOfQualifiedNameOrPropertyAccess(node: Node) {
|
||||
return (node.parent.kind === SyntaxKind.QualifiedName && (<QualifiedName>node.parent).right === node) ||
|
||||
(node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node);
|
||||
}
|
||||
|
||||
export function getLocalSymbolForExportDefault(symbol: Symbol) {
|
||||
return symbol && symbol.valueDeclaration && (symbol.valueDeclaration.flags & NodeFlags.Default) ? symbol.valueDeclaration.localSymbol : undefined;
|
||||
return symbol && symbol.valueDeclaration && (symbol.valueDeclaration.flags & NodeFlags.Default) ? symbol.valueDeclaration.localSymbol : undefined;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1036,17 +1036,7 @@ module Harness {
|
|||
useCaseSensitiveFileNames = setting.value === 'true';
|
||||
break;
|
||||
|
||||
case 'mapsourcefiles':
|
||||
case 'maproot':
|
||||
case 'generatedeclarationfiles':
|
||||
case 'gatherDiagnostics':
|
||||
case 'codepage':
|
||||
case 'createFileLog':
|
||||
case 'filename':
|
||||
case 'removecomments':
|
||||
case 'watch':
|
||||
case 'allowautomaticsemicoloninsertion':
|
||||
case 'locale':
|
||||
// Not supported yet
|
||||
break;
|
||||
|
||||
|
@ -1062,6 +1052,10 @@ module Harness {
|
|||
options.preserveConstEnums = setting.value === 'true';
|
||||
break;
|
||||
|
||||
case 'separatecompilation':
|
||||
options.separateCompilation = setting.value === 'true';
|
||||
break;
|
||||
|
||||
case 'suppressimplicitanyindexerrors':
|
||||
options.suppressImplicitAnyIndexErrors = setting.value === 'true';
|
||||
break;
|
||||
|
@ -1461,7 +1455,12 @@ module Harness {
|
|||
var optionRegex = /^[\/]{2}\s*@(\w+)\s*:\s*(\S*)/gm; // multiple matches on multiple lines
|
||||
|
||||
// List of allowed metadata names
|
||||
var fileMetadataNames = ["filename", "comments", "declaration", "module", "nolib", "sourcemap", "target", "out", "outdir", "noemitonerror", "noimplicitany", "noresolve", "newline", "newlines", "emitbom", "errortruncation", "usecasesensitivefilenames", "preserveconstenums", "includebuiltfile", "suppressimplicitanyindexerrors", "stripinternal"];
|
||||
var fileMetadataNames = ["filename", "comments", "declaration", "module",
|
||||
"nolib", "sourcemap", "target", "out", "outdir", "noemitonerror",
|
||||
"noimplicitany", "noresolve", "newline", "newlines", "emitbom",
|
||||
"errortruncation", "usecasesensitivefilenames", "preserveconstenums",
|
||||
"includebuiltfile", "suppressimplicitanyindexerrors", "stripinternal",
|
||||
"separatecompilation"];
|
||||
|
||||
function extractCompilerSettings(content: string): CompilerSetting[] {
|
||||
|
||||
|
|
|
@ -38,7 +38,6 @@ class TypeWriterWalker {
|
|||
case ts.SyntaxKind.SuperKeyword:
|
||||
case ts.SyntaxKind.ArrayLiteralExpression:
|
||||
case ts.SyntaxKind.ObjectLiteralExpression:
|
||||
case ts.SyntaxKind.PropertyAccessExpression:
|
||||
case ts.SyntaxKind.ElementAccessExpression:
|
||||
case ts.SyntaxKind.CallExpression:
|
||||
case ts.SyntaxKind.NewExpression:
|
||||
|
@ -56,6 +55,14 @@ class TypeWriterWalker {
|
|||
this.log(node, this.getTypeOfNode(node));
|
||||
break;
|
||||
|
||||
case ts.SyntaxKind.PropertyAccessExpression:
|
||||
for (var current = node; current.kind === ts.SyntaxKind.PropertyAccessExpression; current = current.parent) {
|
||||
}
|
||||
if (current.kind !== ts.SyntaxKind.HeritageClauseElement) {
|
||||
this.log(node, this.getTypeOfNode(node));
|
||||
}
|
||||
break;
|
||||
|
||||
// Should not change expression status (maybe expressions)
|
||||
// TODO: Again, ideally should log number and string literals too,
|
||||
// but to be consistent with the old typeWriter, just log identifiers
|
||||
|
|
166
src/lib/scriptHost.d.ts
vendored
166
src/lib/scriptHost.d.ts
vendored
|
@ -4,7 +4,11 @@
|
|||
/// Windows Script Host APIS
|
||||
/////////////////////////////
|
||||
|
||||
declare var ActiveXObject: { new (s: string): any; };
|
||||
|
||||
interface ActiveXObject {
|
||||
new (s: string): any;
|
||||
}
|
||||
declare var ActiveXObject: ActiveXObject;
|
||||
|
||||
interface ITextWriter {
|
||||
Write(s: string): void;
|
||||
|
@ -12,11 +16,157 @@ interface ITextWriter {
|
|||
Close(): void;
|
||||
}
|
||||
|
||||
declare var WScript: {
|
||||
Echo(s: any): void;
|
||||
StdErr: ITextWriter;
|
||||
StdOut: ITextWriter;
|
||||
Arguments: { length: number; Item(n: number): string; };
|
||||
ScriptFullName: string;
|
||||
Quit(exitCode?: number): number;
|
||||
interface TextStreamBase {
|
||||
/**
|
||||
* The column number of the current character position in an input stream.
|
||||
*/
|
||||
Column: number;
|
||||
/**
|
||||
* The current line number in an input stream.
|
||||
*/
|
||||
Line: number;
|
||||
/**
|
||||
* Closes a text stream.
|
||||
* It is not necessary to close standard streams; they close automatically when the process ends. If you close a standard stream, be aware that any other pointers to that standard stream become invalid.
|
||||
*/
|
||||
Close(): void;
|
||||
}
|
||||
|
||||
interface TextStreamWriter extends TextStreamBase {
|
||||
/**
|
||||
* Sends a string to an output stream.
|
||||
*/
|
||||
Write(s: string): void;
|
||||
/**
|
||||
* Sends a specified number of blank lines (newline characters) to an output stream.
|
||||
*/
|
||||
WriteBlankLines(intLines: number): void;
|
||||
/**
|
||||
* Sends a string followed by a newline character to an output stream.
|
||||
*/
|
||||
WriteLine(s: string): void;
|
||||
}
|
||||
|
||||
interface TextStreamReader extends TextStreamBase {
|
||||
/**
|
||||
* Returns a specified number of characters from an input stream, beginning at the current pointer position.
|
||||
* Does not return until the ENTER key is pressed.
|
||||
* Can only be used on a stream in reading mode; causes an error in writing or appending mode.
|
||||
*/
|
||||
Read(characters: number): string;
|
||||
/**
|
||||
* Returns all characters from an input stream.
|
||||
* Can only be used on a stream in reading mode; causes an error in writing or appending mode.
|
||||
*/
|
||||
ReadAll(): string;
|
||||
/**
|
||||
* Returns an entire line from an input stream.
|
||||
* Although this method extracts the newline character, it does not add it to the returned string.
|
||||
* Can only be used on a stream in reading mode; causes an error in writing or appending mode.
|
||||
*/
|
||||
ReadLine(): string;
|
||||
/**
|
||||
* Skips a specified number of characters when reading from an input text stream.
|
||||
* Can only be used on a stream in reading mode; causes an error in writing or appending mode.
|
||||
* @param characters Positive number of characters to skip forward. (Backward skipping is not supported.)
|
||||
*/
|
||||
Skip(characters: number): void;
|
||||
/**
|
||||
* Skips the next line when reading from an input text stream.
|
||||
* Can only be used on a stream in reading mode, not writing or appending mode.
|
||||
*/
|
||||
SkipLine(): void;
|
||||
/**
|
||||
* Indicates whether the stream pointer position is at the end of a line.
|
||||
*/
|
||||
AtEndOfLine: boolean;
|
||||
/**
|
||||
* Indicates whether the stream pointer position is at the end of a stream.
|
||||
*/
|
||||
AtEndOfStream: boolean;
|
||||
}
|
||||
|
||||
declare var WScript: {
|
||||
/**
|
||||
* Outputs text to either a message box (under WScript.exe) or the command console window followed by a newline (under CScript.ext).
|
||||
*/
|
||||
Echo(s: any): void;
|
||||
/**
|
||||
* Exposes the write-only error output stream for the current script.
|
||||
* Can be accessed only while using CScript.exe.
|
||||
*/
|
||||
StdErr: TextStreamWriter;
|
||||
/**
|
||||
* Exposes the write-only output stream for the current script.
|
||||
* Can be accessed only while using CScript.exe.
|
||||
*/
|
||||
StdOut: TextStreamWriter;
|
||||
Arguments: { length: number; Item(n: number): string; };
|
||||
/**
|
||||
* The full path of the currently running script.
|
||||
*/
|
||||
ScriptFullName: string;
|
||||
/**
|
||||
* Forces the script to stop immediately, with an optional exit code.
|
||||
*/
|
||||
Quit(exitCode?: number): number;
|
||||
/**
|
||||
* The Windows Script Host build version number.
|
||||
*/
|
||||
BuildVersion: number;
|
||||
/**
|
||||
* Fully qualified path of the host executable.
|
||||
*/
|
||||
FullName: string;
|
||||
/**
|
||||
* Gets/sets the script mode - interactive(true) or batch(false).
|
||||
*/
|
||||
Interactive: boolean;
|
||||
/**
|
||||
* The name of the host executable (WScript.exe or CScript.exe).
|
||||
*/
|
||||
Name: string;
|
||||
/**
|
||||
* Path of the directory containing the host executable.
|
||||
*/
|
||||
Path: string;
|
||||
/**
|
||||
* The filename of the currently running script.
|
||||
*/
|
||||
ScriptName: string;
|
||||
/**
|
||||
* Exposes the read-only input stream for the current script.
|
||||
* Can be accessed only while using CScript.exe.
|
||||
*/
|
||||
StdIn: TextStreamReader;
|
||||
/**
|
||||
* Windows Script Host version
|
||||
*/
|
||||
Version: string;
|
||||
/**
|
||||
* Connects a COM object's event sources to functions named with a given prefix, in the form prefix_event.
|
||||
*/
|
||||
ConnectObject(objEventSource: any, strPrefix: string): void;
|
||||
/**
|
||||
* Creates a COM object.
|
||||
* @param strProgiID
|
||||
* @param strPrefix Function names in the form prefix_event will be bound to this object's COM events.
|
||||
*/
|
||||
CreateObject(strProgID: string, strPrefix?: string): any;
|
||||
/**
|
||||
* Disconnects a COM object from its event sources.
|
||||
*/
|
||||
DisconnectObject(obj: any): void;
|
||||
/**
|
||||
* Retrieves an existing object with the specified ProgID from memory, or creates a new one from a file.
|
||||
* @param strPathname Fully qualified path to the file containing the object persisted to disk. For objects in memory, pass a zero-length string.
|
||||
* @param strProgID
|
||||
* @param strPrefix Function names in the form prefix_event will be bound to this object's COM events.
|
||||
*/
|
||||
GetObject(strPathname: string, strProgID?: string, strPrefix?: string): any;
|
||||
/**
|
||||
* Suspends script execution for a specified length of time, then continues execution.
|
||||
* @param intTime Interval (in milliseconds) to suspend script execution.
|
||||
*/
|
||||
Sleep(intTime: number): void;
|
||||
};
|
||||
|
|
|
@ -1635,6 +1635,61 @@ module ts {
|
|||
sourceFile.scriptSnapshot = scriptSnapshot;
|
||||
}
|
||||
|
||||
/*
|
||||
* This function will compile source text from 'input' argument using specified compiler options.
|
||||
* If not options are provided - it will use a set of default compiler options.
|
||||
* Extra compiler options that will unconditionally be used bu this function are:
|
||||
* - separateCompilation = true
|
||||
* - allowNonTsExtensions = true
|
||||
*/
|
||||
export function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string {
|
||||
let options = compilerOptions ? clone(compilerOptions) : getDefaultCompilerOptions();
|
||||
|
||||
options.separateCompilation = true;
|
||||
|
||||
// Filename can be non-ts file.
|
||||
options.allowNonTsExtensions = true;
|
||||
|
||||
// Parse
|
||||
var inputFileName = fileName || "module.ts";
|
||||
var sourceFile = createSourceFile(inputFileName, input, options.target);
|
||||
|
||||
// Store syntactic diagnostics
|
||||
if (diagnostics && sourceFile.parseDiagnostics) {
|
||||
diagnostics.push(...sourceFile.parseDiagnostics);
|
||||
}
|
||||
|
||||
// Output
|
||||
let outputText: string;
|
||||
|
||||
// Create a compilerHost object to allow the compiler to read and write files
|
||||
var compilerHost: CompilerHost = {
|
||||
getSourceFile: (fileName, target) => fileName === inputFileName ? sourceFile : undefined,
|
||||
writeFile: (name, text, writeByteOrderMark) => {
|
||||
Debug.assert(outputText === undefined, "Unexpected multiple outputs for the file: " + name);
|
||||
outputText = text;
|
||||
},
|
||||
getDefaultLibFileName: () => "lib.d.ts",
|
||||
useCaseSensitiveFileNames: () => false,
|
||||
getCanonicalFileName: fileName => fileName,
|
||||
getCurrentDirectory: () => "",
|
||||
getNewLine: () => "\r\n"
|
||||
};
|
||||
|
||||
var program = createProgram([inputFileName], options, compilerHost);
|
||||
|
||||
if (diagnostics) {
|
||||
diagnostics.push(...program.getGlobalDiagnostics());
|
||||
}
|
||||
|
||||
// Emit
|
||||
program.emit();
|
||||
|
||||
Debug.assert(outputText !== undefined, "Output generation failed");
|
||||
|
||||
return outputText;
|
||||
}
|
||||
|
||||
export function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile {
|
||||
let sourceFile = createSourceFile(fileName, scriptSnapshot.getText(0, scriptSnapshot.getLength()), scriptTarget, setNodeParents);
|
||||
setSourceFileFields(sourceFile, scriptSnapshot, version);
|
||||
|
@ -2940,7 +2995,7 @@ module ts {
|
|||
|
||||
function getCompletionsAtPosition(fileName: string, position: number): CompletionInfo {
|
||||
synchronizeHostData();
|
||||
|
||||
|
||||
let completionData = getCompletionData(fileName, position);
|
||||
if (!completionData) {
|
||||
return undefined;
|
||||
|
@ -3649,8 +3704,24 @@ module ts {
|
|||
}
|
||||
}
|
||||
|
||||
/// References and Occurrences
|
||||
function getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[] {
|
||||
let results = getOccurrencesAtPositionCore(fileName, position);
|
||||
|
||||
if (results) {
|
||||
let sourceFile = getCanonicalFileName(normalizeSlashes(fileName));
|
||||
|
||||
// ensure the results are in the file we're interested in
|
||||
results.forEach((value) => {
|
||||
let targetFile = getCanonicalFileName(normalizeSlashes(value.fileName));
|
||||
Debug.assert(sourceFile == targetFile, `Unexpected file in results. Found results in ${targetFile} expected only results in ${sourceFile}.`);
|
||||
});
|
||||
}
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
/// References and Occurrences
|
||||
function getOccurrencesAtPositionCore(fileName: string, position: number): ReferenceEntry[] {
|
||||
synchronizeHostData();
|
||||
|
||||
let sourceFile = getValidSourceFile(fileName);
|
||||
|
@ -4885,8 +4956,8 @@ module ts {
|
|||
if (symbol && symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
|
||||
forEach(symbol.getDeclarations(), declaration => {
|
||||
if (declaration.kind === SyntaxKind.ClassDeclaration) {
|
||||
getPropertySymbolFromTypeReference(getClassBaseTypeNode(<ClassDeclaration>declaration));
|
||||
forEach(getClassImplementedTypeNodes(<ClassDeclaration>declaration), getPropertySymbolFromTypeReference);
|
||||
getPropertySymbolFromTypeReference(getClassExtendsHeritageClauseElement(<ClassDeclaration>declaration));
|
||||
forEach(getClassImplementsHeritageClauseElements(<ClassDeclaration>declaration), getPropertySymbolFromTypeReference);
|
||||
}
|
||||
else if (declaration.kind === SyntaxKind.InterfaceDeclaration) {
|
||||
forEach(getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration), getPropertySymbolFromTypeReference);
|
||||
|
@ -4895,7 +4966,7 @@ module ts {
|
|||
}
|
||||
return;
|
||||
|
||||
function getPropertySymbolFromTypeReference(typeReference: TypeReferenceNode) {
|
||||
function getPropertySymbolFromTypeReference(typeReference: HeritageClauseElement) {
|
||||
if (typeReference) {
|
||||
let type = typeInfoResolver.getTypeAtLocation(typeReference);
|
||||
if (type) {
|
||||
|
@ -5152,19 +5223,44 @@ module ts {
|
|||
}
|
||||
|
||||
function isTypeReference(node: Node): boolean {
|
||||
if (isRightSideOfQualifiedName(node)) {
|
||||
if (isRightSideOfQualifiedNameOrPropertyAccess(node) ) {
|
||||
node = node.parent;
|
||||
}
|
||||
|
||||
return node.parent.kind === SyntaxKind.TypeReference;
|
||||
return node.parent.kind === SyntaxKind.TypeReference || node.parent.kind === SyntaxKind.HeritageClauseElement;
|
||||
}
|
||||
|
||||
function isNamespaceReference(node: Node): boolean {
|
||||
return isQualifiedNameNamespaceReference(node) || isPropertyAccessNamespaceReference(node);
|
||||
}
|
||||
|
||||
function isPropertyAccessNamespaceReference(node: Node): boolean {
|
||||
let root = node;
|
||||
let isLastClause = true;
|
||||
if (root.parent.kind === SyntaxKind.PropertyAccessExpression) {
|
||||
while (root.parent && root.parent.kind === SyntaxKind.PropertyAccessExpression) {
|
||||
root = root.parent;
|
||||
}
|
||||
|
||||
isLastClause = (<PropertyAccessExpression>root).name === node;
|
||||
}
|
||||
|
||||
if (!isLastClause && root.parent.kind === SyntaxKind.HeritageClauseElement && root.parent.parent.kind === SyntaxKind.HeritageClause) {
|
||||
let decl = root.parent.parent.parent;
|
||||
return (decl.kind === SyntaxKind.ClassDeclaration && (<HeritageClause>root.parent.parent).token === SyntaxKind.ImplementsKeyword) ||
|
||||
(decl.kind === SyntaxKind.InterfaceDeclaration && (<HeritageClause>root.parent.parent).token === SyntaxKind.ExtendsKeyword);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
function isQualifiedNameNamespaceReference(node: Node): boolean {
|
||||
let root = node;
|
||||
let isLastClause = true;
|
||||
if (root.parent.kind === SyntaxKind.QualifiedName) {
|
||||
while (root.parent && root.parent.kind === SyntaxKind.QualifiedName)
|
||||
while (root.parent && root.parent.kind === SyntaxKind.QualifiedName) {
|
||||
root = root.parent;
|
||||
}
|
||||
|
||||
isLastClause = (<QualifiedName>root).right === node;
|
||||
}
|
||||
|
|
|
@ -233,59 +233,62 @@ declare module "typescript" {
|
|||
TemplateExpression = 171,
|
||||
YieldExpression = 172,
|
||||
SpreadElementExpression = 173,
|
||||
OmittedExpression = 174,
|
||||
TemplateSpan = 175,
|
||||
Block = 176,
|
||||
VariableStatement = 177,
|
||||
EmptyStatement = 178,
|
||||
ExpressionStatement = 179,
|
||||
IfStatement = 180,
|
||||
DoStatement = 181,
|
||||
WhileStatement = 182,
|
||||
ForStatement = 183,
|
||||
ForInStatement = 184,
|
||||
ForOfStatement = 185,
|
||||
ContinueStatement = 186,
|
||||
BreakStatement = 187,
|
||||
ReturnStatement = 188,
|
||||
WithStatement = 189,
|
||||
SwitchStatement = 190,
|
||||
LabeledStatement = 191,
|
||||
ThrowStatement = 192,
|
||||
TryStatement = 193,
|
||||
DebuggerStatement = 194,
|
||||
VariableDeclaration = 195,
|
||||
VariableDeclarationList = 196,
|
||||
FunctionDeclaration = 197,
|
||||
ClassDeclaration = 198,
|
||||
InterfaceDeclaration = 199,
|
||||
TypeAliasDeclaration = 200,
|
||||
EnumDeclaration = 201,
|
||||
ModuleDeclaration = 202,
|
||||
ModuleBlock = 203,
|
||||
CaseBlock = 204,
|
||||
ImportEqualsDeclaration = 205,
|
||||
ImportDeclaration = 206,
|
||||
ImportClause = 207,
|
||||
NamespaceImport = 208,
|
||||
NamedImports = 209,
|
||||
ImportSpecifier = 210,
|
||||
ExportAssignment = 211,
|
||||
ExportDeclaration = 212,
|
||||
NamedExports = 213,
|
||||
ExportSpecifier = 214,
|
||||
MissingDeclaration = 215,
|
||||
ExternalModuleReference = 216,
|
||||
CaseClause = 217,
|
||||
DefaultClause = 218,
|
||||
HeritageClause = 219,
|
||||
CatchClause = 220,
|
||||
PropertyAssignment = 221,
|
||||
ShorthandPropertyAssignment = 222,
|
||||
EnumMember = 223,
|
||||
SourceFile = 224,
|
||||
SyntaxList = 225,
|
||||
Count = 226,
|
||||
ClassExpression = 174,
|
||||
OmittedExpression = 175,
|
||||
TemplateSpan = 176,
|
||||
HeritageClauseElement = 177,
|
||||
SemicolonClassElement = 178,
|
||||
Block = 179,
|
||||
VariableStatement = 180,
|
||||
EmptyStatement = 181,
|
||||
ExpressionStatement = 182,
|
||||
IfStatement = 183,
|
||||
DoStatement = 184,
|
||||
WhileStatement = 185,
|
||||
ForStatement = 186,
|
||||
ForInStatement = 187,
|
||||
ForOfStatement = 188,
|
||||
ContinueStatement = 189,
|
||||
BreakStatement = 190,
|
||||
ReturnStatement = 191,
|
||||
WithStatement = 192,
|
||||
SwitchStatement = 193,
|
||||
LabeledStatement = 194,
|
||||
ThrowStatement = 195,
|
||||
TryStatement = 196,
|
||||
DebuggerStatement = 197,
|
||||
VariableDeclaration = 198,
|
||||
VariableDeclarationList = 199,
|
||||
FunctionDeclaration = 200,
|
||||
ClassDeclaration = 201,
|
||||
InterfaceDeclaration = 202,
|
||||
TypeAliasDeclaration = 203,
|
||||
EnumDeclaration = 204,
|
||||
ModuleDeclaration = 205,
|
||||
ModuleBlock = 206,
|
||||
CaseBlock = 207,
|
||||
ImportEqualsDeclaration = 208,
|
||||
ImportDeclaration = 209,
|
||||
ImportClause = 210,
|
||||
NamespaceImport = 211,
|
||||
NamedImports = 212,
|
||||
ImportSpecifier = 213,
|
||||
ExportAssignment = 214,
|
||||
ExportDeclaration = 215,
|
||||
NamedExports = 216,
|
||||
ExportSpecifier = 217,
|
||||
MissingDeclaration = 218,
|
||||
ExternalModuleReference = 219,
|
||||
CaseClause = 220,
|
||||
DefaultClause = 221,
|
||||
HeritageClause = 222,
|
||||
CatchClause = 223,
|
||||
PropertyAssignment = 224,
|
||||
ShorthandPropertyAssignment = 225,
|
||||
EnumMember = 226,
|
||||
SourceFile = 227,
|
||||
SyntaxList = 228,
|
||||
Count = 229,
|
||||
FirstAssignment = 53,
|
||||
LastAssignment = 64,
|
||||
FirstReservedWord = 66,
|
||||
|
@ -469,6 +472,9 @@ declare module "typescript" {
|
|||
interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {
|
||||
body?: Block;
|
||||
}
|
||||
interface SemicolonClassElement extends ClassElement {
|
||||
_semicolonClassElementBrand: any;
|
||||
}
|
||||
interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
|
||||
_accessorDeclarationBrand: any;
|
||||
body: Block;
|
||||
|
@ -607,6 +613,10 @@ declare module "typescript" {
|
|||
typeArguments?: NodeArray<TypeNode>;
|
||||
arguments: NodeArray<Expression>;
|
||||
}
|
||||
interface HeritageClauseElement extends Node {
|
||||
expression: LeftHandSideExpression;
|
||||
typeArguments?: NodeArray<TypeNode>;
|
||||
}
|
||||
interface NewExpression extends CallExpression, PrimaryExpression {
|
||||
}
|
||||
interface TaggedTemplateExpression extends MemberExpression {
|
||||
|
@ -701,12 +711,16 @@ declare module "typescript" {
|
|||
interface ModuleElement extends Node {
|
||||
_moduleElementBrand: any;
|
||||
}
|
||||
interface ClassDeclaration extends Declaration, ModuleElement {
|
||||
interface ClassLikeDeclaration extends Declaration {
|
||||
name?: Identifier;
|
||||
typeParameters?: NodeArray<TypeParameterDeclaration>;
|
||||
heritageClauses?: NodeArray<HeritageClause>;
|
||||
members: NodeArray<ClassElement>;
|
||||
}
|
||||
interface ClassDeclaration extends ClassLikeDeclaration, Statement {
|
||||
}
|
||||
interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
|
||||
}
|
||||
interface ClassElement extends Declaration {
|
||||
_classElementBrand: any;
|
||||
}
|
||||
|
@ -718,7 +732,7 @@ declare module "typescript" {
|
|||
}
|
||||
interface HeritageClause extends Node {
|
||||
token: SyntaxKind;
|
||||
types?: NodeArray<TypeReferenceNode>;
|
||||
types?: NodeArray<HeritageClauseElement>;
|
||||
}
|
||||
interface TypeAliasDeclaration extends Declaration, ModuleElement {
|
||||
name: Identifier;
|
||||
|
@ -960,7 +974,7 @@ declare module "typescript" {
|
|||
writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
|
||||
writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
|
||||
isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
|
||||
isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
|
||||
resolvesToSomeValue(location: Node, name: string): boolean;
|
||||
getBlockScopedVariableId(node: Identifier): number;
|
||||
|
@ -1216,7 +1230,6 @@ declare module "typescript" {
|
|||
interface CompilerOptions {
|
||||
allowNonTsExtensions?: boolean;
|
||||
charset?: string;
|
||||
codepage?: number;
|
||||
declaration?: boolean;
|
||||
diagnostics?: boolean;
|
||||
emitBOM?: boolean;
|
||||
|
@ -1230,7 +1243,6 @@ declare module "typescript" {
|
|||
noErrorTruncation?: boolean;
|
||||
noImplicitAny?: boolean;
|
||||
noLib?: boolean;
|
||||
noLibCheck?: boolean;
|
||||
noResolve?: boolean;
|
||||
out?: string;
|
||||
outDir?: string;
|
||||
|
@ -1243,6 +1255,7 @@ declare module "typescript" {
|
|||
target?: ScriptTarget;
|
||||
version?: boolean;
|
||||
watch?: boolean;
|
||||
separateCompilation?: boolean;
|
||||
[option: string]: string | number | boolean;
|
||||
}
|
||||
const enum ModuleKind {
|
||||
|
@ -1491,6 +1504,20 @@ declare module "typescript" {
|
|||
function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;
|
||||
function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost): Program;
|
||||
}
|
||||
declare module "typescript" {
|
||||
/**
|
||||
* Read tsconfig.json file
|
||||
* @param fileName The path to the config file
|
||||
*/
|
||||
function readConfigFile(fileName: string): any;
|
||||
/**
|
||||
* Parse the contents of a config file (tsconfig.json).
|
||||
* @param json The contents of the config file to parse
|
||||
* @param basePath A root directory to resolve relative path entries in the config
|
||||
* file to. e.g. outDir
|
||||
*/
|
||||
function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
|
||||
}
|
||||
declare module "typescript" {
|
||||
/** The version of the language service API */
|
||||
let servicesVersion: string;
|
||||
|
@ -1984,6 +2011,7 @@ declare module "typescript" {
|
|||
isCancellationRequested(): boolean;
|
||||
throwIfCancellationRequested(): void;
|
||||
}
|
||||
function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
|
||||
function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
|
||||
let disableIncrementalParsing: boolean;
|
||||
function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;
|
||||
|
|
|
@ -717,163 +717,172 @@ declare module "typescript" {
|
|||
SpreadElementExpression = 173,
|
||||
>SpreadElementExpression : SyntaxKind
|
||||
|
||||
OmittedExpression = 174,
|
||||
ClassExpression = 174,
|
||||
>ClassExpression : SyntaxKind
|
||||
|
||||
OmittedExpression = 175,
|
||||
>OmittedExpression : SyntaxKind
|
||||
|
||||
TemplateSpan = 175,
|
||||
TemplateSpan = 176,
|
||||
>TemplateSpan : SyntaxKind
|
||||
|
||||
Block = 176,
|
||||
HeritageClauseElement = 177,
|
||||
>HeritageClauseElement : SyntaxKind
|
||||
|
||||
SemicolonClassElement = 178,
|
||||
>SemicolonClassElement : SyntaxKind
|
||||
|
||||
Block = 179,
|
||||
>Block : SyntaxKind
|
||||
|
||||
VariableStatement = 177,
|
||||
VariableStatement = 180,
|
||||
>VariableStatement : SyntaxKind
|
||||
|
||||
EmptyStatement = 178,
|
||||
EmptyStatement = 181,
|
||||
>EmptyStatement : SyntaxKind
|
||||
|
||||
ExpressionStatement = 179,
|
||||
ExpressionStatement = 182,
|
||||
>ExpressionStatement : SyntaxKind
|
||||
|
||||
IfStatement = 180,
|
||||
IfStatement = 183,
|
||||
>IfStatement : SyntaxKind
|
||||
|
||||
DoStatement = 181,
|
||||
DoStatement = 184,
|
||||
>DoStatement : SyntaxKind
|
||||
|
||||
WhileStatement = 182,
|
||||
WhileStatement = 185,
|
||||
>WhileStatement : SyntaxKind
|
||||
|
||||
ForStatement = 183,
|
||||
ForStatement = 186,
|
||||
>ForStatement : SyntaxKind
|
||||
|
||||
ForInStatement = 184,
|
||||
ForInStatement = 187,
|
||||
>ForInStatement : SyntaxKind
|
||||
|
||||
ForOfStatement = 185,
|
||||
ForOfStatement = 188,
|
||||
>ForOfStatement : SyntaxKind
|
||||
|
||||
ContinueStatement = 186,
|
||||
ContinueStatement = 189,
|
||||
>ContinueStatement : SyntaxKind
|
||||
|
||||
BreakStatement = 187,
|
||||
BreakStatement = 190,
|
||||
>BreakStatement : SyntaxKind
|
||||
|
||||
ReturnStatement = 188,
|
||||
ReturnStatement = 191,
|
||||
>ReturnStatement : SyntaxKind
|
||||
|
||||
WithStatement = 189,
|
||||
WithStatement = 192,
|
||||
>WithStatement : SyntaxKind
|
||||
|
||||
SwitchStatement = 190,
|
||||
SwitchStatement = 193,
|
||||
>SwitchStatement : SyntaxKind
|
||||
|
||||
LabeledStatement = 191,
|
||||
LabeledStatement = 194,
|
||||
>LabeledStatement : SyntaxKind
|
||||
|
||||
ThrowStatement = 192,
|
||||
ThrowStatement = 195,
|
||||
>ThrowStatement : SyntaxKind
|
||||
|
||||
TryStatement = 193,
|
||||
TryStatement = 196,
|
||||
>TryStatement : SyntaxKind
|
||||
|
||||
DebuggerStatement = 194,
|
||||
DebuggerStatement = 197,
|
||||
>DebuggerStatement : SyntaxKind
|
||||
|
||||
VariableDeclaration = 195,
|
||||
VariableDeclaration = 198,
|
||||
>VariableDeclaration : SyntaxKind
|
||||
|
||||
VariableDeclarationList = 196,
|
||||
VariableDeclarationList = 199,
|
||||
>VariableDeclarationList : SyntaxKind
|
||||
|
||||
FunctionDeclaration = 197,
|
||||
FunctionDeclaration = 200,
|
||||
>FunctionDeclaration : SyntaxKind
|
||||
|
||||
ClassDeclaration = 198,
|
||||
ClassDeclaration = 201,
|
||||
>ClassDeclaration : SyntaxKind
|
||||
|
||||
InterfaceDeclaration = 199,
|
||||
InterfaceDeclaration = 202,
|
||||
>InterfaceDeclaration : SyntaxKind
|
||||
|
||||
TypeAliasDeclaration = 200,
|
||||
TypeAliasDeclaration = 203,
|
||||
>TypeAliasDeclaration : SyntaxKind
|
||||
|
||||
EnumDeclaration = 201,
|
||||
EnumDeclaration = 204,
|
||||
>EnumDeclaration : SyntaxKind
|
||||
|
||||
ModuleDeclaration = 202,
|
||||
ModuleDeclaration = 205,
|
||||
>ModuleDeclaration : SyntaxKind
|
||||
|
||||
ModuleBlock = 203,
|
||||
ModuleBlock = 206,
|
||||
>ModuleBlock : SyntaxKind
|
||||
|
||||
CaseBlock = 204,
|
||||
CaseBlock = 207,
|
||||
>CaseBlock : SyntaxKind
|
||||
|
||||
ImportEqualsDeclaration = 205,
|
||||
ImportEqualsDeclaration = 208,
|
||||
>ImportEqualsDeclaration : SyntaxKind
|
||||
|
||||
ImportDeclaration = 206,
|
||||
ImportDeclaration = 209,
|
||||
>ImportDeclaration : SyntaxKind
|
||||
|
||||
ImportClause = 207,
|
||||
ImportClause = 210,
|
||||
>ImportClause : SyntaxKind
|
||||
|
||||
NamespaceImport = 208,
|
||||
NamespaceImport = 211,
|
||||
>NamespaceImport : SyntaxKind
|
||||
|
||||
NamedImports = 209,
|
||||
NamedImports = 212,
|
||||
>NamedImports : SyntaxKind
|
||||
|
||||
ImportSpecifier = 210,
|
||||
ImportSpecifier = 213,
|
||||
>ImportSpecifier : SyntaxKind
|
||||
|
||||
ExportAssignment = 211,
|
||||
ExportAssignment = 214,
|
||||
>ExportAssignment : SyntaxKind
|
||||
|
||||
ExportDeclaration = 212,
|
||||
ExportDeclaration = 215,
|
||||
>ExportDeclaration : SyntaxKind
|
||||
|
||||
NamedExports = 213,
|
||||
NamedExports = 216,
|
||||
>NamedExports : SyntaxKind
|
||||
|
||||
ExportSpecifier = 214,
|
||||
ExportSpecifier = 217,
|
||||
>ExportSpecifier : SyntaxKind
|
||||
|
||||
MissingDeclaration = 215,
|
||||
MissingDeclaration = 218,
|
||||
>MissingDeclaration : SyntaxKind
|
||||
|
||||
ExternalModuleReference = 216,
|
||||
ExternalModuleReference = 219,
|
||||
>ExternalModuleReference : SyntaxKind
|
||||
|
||||
CaseClause = 217,
|
||||
CaseClause = 220,
|
||||
>CaseClause : SyntaxKind
|
||||
|
||||
DefaultClause = 218,
|
||||
DefaultClause = 221,
|
||||
>DefaultClause : SyntaxKind
|
||||
|
||||
HeritageClause = 219,
|
||||
HeritageClause = 222,
|
||||
>HeritageClause : SyntaxKind
|
||||
|
||||
CatchClause = 220,
|
||||
CatchClause = 223,
|
||||
>CatchClause : SyntaxKind
|
||||
|
||||
PropertyAssignment = 221,
|
||||
PropertyAssignment = 224,
|
||||
>PropertyAssignment : SyntaxKind
|
||||
|
||||
ShorthandPropertyAssignment = 222,
|
||||
ShorthandPropertyAssignment = 225,
|
||||
>ShorthandPropertyAssignment : SyntaxKind
|
||||
|
||||
EnumMember = 223,
|
||||
EnumMember = 226,
|
||||
>EnumMember : SyntaxKind
|
||||
|
||||
SourceFile = 224,
|
||||
SourceFile = 227,
|
||||
>SourceFile : SyntaxKind
|
||||
|
||||
SyntaxList = 225,
|
||||
SyntaxList = 228,
|
||||
>SyntaxList : SyntaxKind
|
||||
|
||||
Count = 226,
|
||||
Count = 229,
|
||||
>Count : SyntaxKind
|
||||
|
||||
FirstAssignment = 53,
|
||||
|
@ -1430,6 +1439,13 @@ declare module "typescript" {
|
|||
body?: Block;
|
||||
>body : Block
|
||||
>Block : Block
|
||||
}
|
||||
interface SemicolonClassElement extends ClassElement {
|
||||
>SemicolonClassElement : SemicolonClassElement
|
||||
>ClassElement : ClassElement
|
||||
|
||||
_semicolonClassElementBrand: any;
|
||||
>_semicolonClassElementBrand : any
|
||||
}
|
||||
interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
|
||||
>AccessorDeclaration : AccessorDeclaration
|
||||
|
@ -1831,6 +1847,19 @@ declare module "typescript" {
|
|||
>arguments : NodeArray<Expression>
|
||||
>NodeArray : NodeArray<T>
|
||||
>Expression : Expression
|
||||
}
|
||||
interface HeritageClauseElement extends Node {
|
||||
>HeritageClauseElement : HeritageClauseElement
|
||||
>Node : Node
|
||||
|
||||
expression: LeftHandSideExpression;
|
||||
>expression : LeftHandSideExpression
|
||||
>LeftHandSideExpression : LeftHandSideExpression
|
||||
|
||||
typeArguments?: NodeArray<TypeNode>;
|
||||
>typeArguments : NodeArray<TypeNode>
|
||||
>NodeArray : NodeArray<T>
|
||||
>TypeNode : TypeNode
|
||||
}
|
||||
interface NewExpression extends CallExpression, PrimaryExpression {
|
||||
>NewExpression : NewExpression
|
||||
|
@ -2115,10 +2144,9 @@ declare module "typescript" {
|
|||
_moduleElementBrand: any;
|
||||
>_moduleElementBrand : any
|
||||
}
|
||||
interface ClassDeclaration extends Declaration, ModuleElement {
|
||||
>ClassDeclaration : ClassDeclaration
|
||||
interface ClassLikeDeclaration extends Declaration {
|
||||
>ClassLikeDeclaration : ClassLikeDeclaration
|
||||
>Declaration : Declaration
|
||||
>ModuleElement : ModuleElement
|
||||
|
||||
name?: Identifier;
|
||||
>name : Identifier
|
||||
|
@ -2138,6 +2166,16 @@ declare module "typescript" {
|
|||
>members : NodeArray<ClassElement>
|
||||
>NodeArray : NodeArray<T>
|
||||
>ClassElement : ClassElement
|
||||
}
|
||||
interface ClassDeclaration extends ClassLikeDeclaration, Statement {
|
||||
>ClassDeclaration : ClassDeclaration
|
||||
>ClassLikeDeclaration : ClassLikeDeclaration
|
||||
>Statement : Statement
|
||||
}
|
||||
interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
|
||||
>ClassExpression : ClassExpression
|
||||
>ClassLikeDeclaration : ClassLikeDeclaration
|
||||
>PrimaryExpression : PrimaryExpression
|
||||
}
|
||||
interface ClassElement extends Declaration {
|
||||
>ClassElement : ClassElement
|
||||
|
@ -2178,10 +2216,10 @@ declare module "typescript" {
|
|||
>token : SyntaxKind
|
||||
>SyntaxKind : SyntaxKind
|
||||
|
||||
types?: NodeArray<TypeReferenceNode>;
|
||||
>types : NodeArray<TypeReferenceNode>
|
||||
types?: NodeArray<HeritageClauseElement>;
|
||||
>types : NodeArray<HeritageClauseElement>
|
||||
>NodeArray : NodeArray<T>
|
||||
>TypeReferenceNode : TypeReferenceNode
|
||||
>HeritageClauseElement : HeritageClauseElement
|
||||
}
|
||||
interface TypeAliasDeclaration extends Declaration, ModuleElement {
|
||||
>TypeAliasDeclaration : TypeAliasDeclaration
|
||||
|
@ -3125,10 +3163,11 @@ declare module "typescript" {
|
|||
>SymbolFlags : SymbolFlags
|
||||
>SymbolAccessiblityResult : SymbolAccessiblityResult
|
||||
|
||||
isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
>isEntityNameVisible : (entityName: Identifier | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
|
||||
>entityName : Identifier | QualifiedName
|
||||
isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
>isEntityNameVisible : (entityName: Identifier | Expression | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
|
||||
>entityName : Identifier | Expression | QualifiedName
|
||||
>EntityName : Identifier | QualifiedName
|
||||
>Expression : Expression
|
||||
>enclosingDeclaration : Node
|
||||
>Node : Node
|
||||
>SymbolVisibilityResult : SymbolVisibilityResult
|
||||
|
@ -3901,9 +3940,6 @@ declare module "typescript" {
|
|||
charset?: string;
|
||||
>charset : string
|
||||
|
||||
codepage?: number;
|
||||
>codepage : number
|
||||
|
||||
declaration?: boolean;
|
||||
>declaration : boolean
|
||||
|
||||
|
@ -3944,9 +3980,6 @@ declare module "typescript" {
|
|||
noLib?: boolean;
|
||||
>noLib : boolean
|
||||
|
||||
noLibCheck?: boolean;
|
||||
>noLibCheck : boolean
|
||||
|
||||
noResolve?: boolean;
|
||||
>noResolve : boolean
|
||||
|
||||
|
@ -3984,6 +4017,9 @@ declare module "typescript" {
|
|||
watch?: boolean;
|
||||
>watch : boolean
|
||||
|
||||
separateCompilation?: boolean;
|
||||
>separateCompilation : boolean
|
||||
|
||||
[option: string]: string | number | boolean;
|
||||
>option : string
|
||||
}
|
||||
|
@ -4802,6 +4838,27 @@ declare module "typescript" {
|
|||
>CompilerHost : CompilerHost
|
||||
>Program : Program
|
||||
}
|
||||
declare module "typescript" {
|
||||
/**
|
||||
* Read tsconfig.json file
|
||||
* @param fileName The path to the config file
|
||||
*/
|
||||
function readConfigFile(fileName: string): any;
|
||||
>readConfigFile : (fileName: string) => any
|
||||
>fileName : string
|
||||
|
||||
/**
|
||||
* Parse the contents of a config file (tsconfig.json).
|
||||
* @param json The contents of the config file to parse
|
||||
* @param basePath A root directory to resolve relative path entries in the config
|
||||
* file to. e.g. outDir
|
||||
*/
|
||||
function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
|
||||
>parseConfigFile : (json: any, basePath?: string) => ParsedCommandLine
|
||||
>json : any
|
||||
>basePath : string
|
||||
>ParsedCommandLine : ParsedCommandLine
|
||||
}
|
||||
declare module "typescript" {
|
||||
/** The version of the language service API */
|
||||
let servicesVersion: string;
|
||||
|
@ -6160,6 +6217,15 @@ declare module "typescript" {
|
|||
throwIfCancellationRequested(): void;
|
||||
>throwIfCancellationRequested : () => void
|
||||
}
|
||||
function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
|
||||
>transpile : (input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]) => string
|
||||
>input : string
|
||||
>compilerOptions : CompilerOptions
|
||||
>CompilerOptions : CompilerOptions
|
||||
>fileName : string
|
||||
>diagnostics : Diagnostic[]
|
||||
>Diagnostic : Diagnostic
|
||||
|
||||
function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
|
||||
>createLanguageServiceSourceFile : (fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean) => SourceFile
|
||||
>fileName : string
|
||||
|
|
|
@ -264,59 +264,62 @@ declare module "typescript" {
|
|||
TemplateExpression = 171,
|
||||
YieldExpression = 172,
|
||||
SpreadElementExpression = 173,
|
||||
OmittedExpression = 174,
|
||||
TemplateSpan = 175,
|
||||
Block = 176,
|
||||
VariableStatement = 177,
|
||||
EmptyStatement = 178,
|
||||
ExpressionStatement = 179,
|
||||
IfStatement = 180,
|
||||
DoStatement = 181,
|
||||
WhileStatement = 182,
|
||||
ForStatement = 183,
|
||||
ForInStatement = 184,
|
||||
ForOfStatement = 185,
|
||||
ContinueStatement = 186,
|
||||
BreakStatement = 187,
|
||||
ReturnStatement = 188,
|
||||
WithStatement = 189,
|
||||
SwitchStatement = 190,
|
||||
LabeledStatement = 191,
|
||||
ThrowStatement = 192,
|
||||
TryStatement = 193,
|
||||
DebuggerStatement = 194,
|
||||
VariableDeclaration = 195,
|
||||
VariableDeclarationList = 196,
|
||||
FunctionDeclaration = 197,
|
||||
ClassDeclaration = 198,
|
||||
InterfaceDeclaration = 199,
|
||||
TypeAliasDeclaration = 200,
|
||||
EnumDeclaration = 201,
|
||||
ModuleDeclaration = 202,
|
||||
ModuleBlock = 203,
|
||||
CaseBlock = 204,
|
||||
ImportEqualsDeclaration = 205,
|
||||
ImportDeclaration = 206,
|
||||
ImportClause = 207,
|
||||
NamespaceImport = 208,
|
||||
NamedImports = 209,
|
||||
ImportSpecifier = 210,
|
||||
ExportAssignment = 211,
|
||||
ExportDeclaration = 212,
|
||||
NamedExports = 213,
|
||||
ExportSpecifier = 214,
|
||||
MissingDeclaration = 215,
|
||||
ExternalModuleReference = 216,
|
||||
CaseClause = 217,
|
||||
DefaultClause = 218,
|
||||
HeritageClause = 219,
|
||||
CatchClause = 220,
|
||||
PropertyAssignment = 221,
|
||||
ShorthandPropertyAssignment = 222,
|
||||
EnumMember = 223,
|
||||
SourceFile = 224,
|
||||
SyntaxList = 225,
|
||||
Count = 226,
|
||||
ClassExpression = 174,
|
||||
OmittedExpression = 175,
|
||||
TemplateSpan = 176,
|
||||
HeritageClauseElement = 177,
|
||||
SemicolonClassElement = 178,
|
||||
Block = 179,
|
||||
VariableStatement = 180,
|
||||
EmptyStatement = 181,
|
||||
ExpressionStatement = 182,
|
||||
IfStatement = 183,
|
||||
DoStatement = 184,
|
||||
WhileStatement = 185,
|
||||
ForStatement = 186,
|
||||
ForInStatement = 187,
|
||||
ForOfStatement = 188,
|
||||
ContinueStatement = 189,
|
||||
BreakStatement = 190,
|
||||
ReturnStatement = 191,
|
||||
WithStatement = 192,
|
||||
SwitchStatement = 193,
|
||||
LabeledStatement = 194,
|
||||
ThrowStatement = 195,
|
||||
TryStatement = 196,
|
||||
DebuggerStatement = 197,
|
||||
VariableDeclaration = 198,
|
||||
VariableDeclarationList = 199,
|
||||
FunctionDeclaration = 200,
|
||||
ClassDeclaration = 201,
|
||||
InterfaceDeclaration = 202,
|
||||
TypeAliasDeclaration = 203,
|
||||
EnumDeclaration = 204,
|
||||
ModuleDeclaration = 205,
|
||||
ModuleBlock = 206,
|
||||
CaseBlock = 207,
|
||||
ImportEqualsDeclaration = 208,
|
||||
ImportDeclaration = 209,
|
||||
ImportClause = 210,
|
||||
NamespaceImport = 211,
|
||||
NamedImports = 212,
|
||||
ImportSpecifier = 213,
|
||||
ExportAssignment = 214,
|
||||
ExportDeclaration = 215,
|
||||
NamedExports = 216,
|
||||
ExportSpecifier = 217,
|
||||
MissingDeclaration = 218,
|
||||
ExternalModuleReference = 219,
|
||||
CaseClause = 220,
|
||||
DefaultClause = 221,
|
||||
HeritageClause = 222,
|
||||
CatchClause = 223,
|
||||
PropertyAssignment = 224,
|
||||
ShorthandPropertyAssignment = 225,
|
||||
EnumMember = 226,
|
||||
SourceFile = 227,
|
||||
SyntaxList = 228,
|
||||
Count = 229,
|
||||
FirstAssignment = 53,
|
||||
LastAssignment = 64,
|
||||
FirstReservedWord = 66,
|
||||
|
@ -500,6 +503,9 @@ declare module "typescript" {
|
|||
interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {
|
||||
body?: Block;
|
||||
}
|
||||
interface SemicolonClassElement extends ClassElement {
|
||||
_semicolonClassElementBrand: any;
|
||||
}
|
||||
interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
|
||||
_accessorDeclarationBrand: any;
|
||||
body: Block;
|
||||
|
@ -638,6 +644,10 @@ declare module "typescript" {
|
|||
typeArguments?: NodeArray<TypeNode>;
|
||||
arguments: NodeArray<Expression>;
|
||||
}
|
||||
interface HeritageClauseElement extends Node {
|
||||
expression: LeftHandSideExpression;
|
||||
typeArguments?: NodeArray<TypeNode>;
|
||||
}
|
||||
interface NewExpression extends CallExpression, PrimaryExpression {
|
||||
}
|
||||
interface TaggedTemplateExpression extends MemberExpression {
|
||||
|
@ -732,12 +742,16 @@ declare module "typescript" {
|
|||
interface ModuleElement extends Node {
|
||||
_moduleElementBrand: any;
|
||||
}
|
||||
interface ClassDeclaration extends Declaration, ModuleElement {
|
||||
interface ClassLikeDeclaration extends Declaration {
|
||||
name?: Identifier;
|
||||
typeParameters?: NodeArray<TypeParameterDeclaration>;
|
||||
heritageClauses?: NodeArray<HeritageClause>;
|
||||
members: NodeArray<ClassElement>;
|
||||
}
|
||||
interface ClassDeclaration extends ClassLikeDeclaration, Statement {
|
||||
}
|
||||
interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
|
||||
}
|
||||
interface ClassElement extends Declaration {
|
||||
_classElementBrand: any;
|
||||
}
|
||||
|
@ -749,7 +763,7 @@ declare module "typescript" {
|
|||
}
|
||||
interface HeritageClause extends Node {
|
||||
token: SyntaxKind;
|
||||
types?: NodeArray<TypeReferenceNode>;
|
||||
types?: NodeArray<HeritageClauseElement>;
|
||||
}
|
||||
interface TypeAliasDeclaration extends Declaration, ModuleElement {
|
||||
name: Identifier;
|
||||
|
@ -991,7 +1005,7 @@ declare module "typescript" {
|
|||
writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
|
||||
writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
|
||||
isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
|
||||
isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
|
||||
resolvesToSomeValue(location: Node, name: string): boolean;
|
||||
getBlockScopedVariableId(node: Identifier): number;
|
||||
|
@ -1247,7 +1261,6 @@ declare module "typescript" {
|
|||
interface CompilerOptions {
|
||||
allowNonTsExtensions?: boolean;
|
||||
charset?: string;
|
||||
codepage?: number;
|
||||
declaration?: boolean;
|
||||
diagnostics?: boolean;
|
||||
emitBOM?: boolean;
|
||||
|
@ -1261,7 +1274,6 @@ declare module "typescript" {
|
|||
noErrorTruncation?: boolean;
|
||||
noImplicitAny?: boolean;
|
||||
noLib?: boolean;
|
||||
noLibCheck?: boolean;
|
||||
noResolve?: boolean;
|
||||
out?: string;
|
||||
outDir?: string;
|
||||
|
@ -1274,6 +1286,7 @@ declare module "typescript" {
|
|||
target?: ScriptTarget;
|
||||
version?: boolean;
|
||||
watch?: boolean;
|
||||
separateCompilation?: boolean;
|
||||
[option: string]: string | number | boolean;
|
||||
}
|
||||
const enum ModuleKind {
|
||||
|
@ -1522,6 +1535,20 @@ declare module "typescript" {
|
|||
function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;
|
||||
function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost): Program;
|
||||
}
|
||||
declare module "typescript" {
|
||||
/**
|
||||
* Read tsconfig.json file
|
||||
* @param fileName The path to the config file
|
||||
*/
|
||||
function readConfigFile(fileName: string): any;
|
||||
/**
|
||||
* Parse the contents of a config file (tsconfig.json).
|
||||
* @param json The contents of the config file to parse
|
||||
* @param basePath A root directory to resolve relative path entries in the config
|
||||
* file to. e.g. outDir
|
||||
*/
|
||||
function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
|
||||
}
|
||||
declare module "typescript" {
|
||||
/** The version of the language service API */
|
||||
let servicesVersion: string;
|
||||
|
@ -2015,6 +2042,7 @@ declare module "typescript" {
|
|||
isCancellationRequested(): boolean;
|
||||
throwIfCancellationRequested(): void;
|
||||
}
|
||||
function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
|
||||
function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
|
||||
let disableIncrementalParsing: boolean;
|
||||
function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;
|
||||
|
@ -2042,21 +2070,21 @@ function delint(sourceFile) {
|
|||
delintNode(sourceFile);
|
||||
function delintNode(node) {
|
||||
switch (node.kind) {
|
||||
case 183 /* ForStatement */:
|
||||
case 184 /* ForInStatement */:
|
||||
case 182 /* WhileStatement */:
|
||||
case 181 /* DoStatement */:
|
||||
if (node.statement.kind !== 176 /* Block */) {
|
||||
case 186 /* ForStatement */:
|
||||
case 187 /* ForInStatement */:
|
||||
case 185 /* WhileStatement */:
|
||||
case 184 /* DoStatement */:
|
||||
if (node.statement.kind !== 179 /* Block */) {
|
||||
report(node, "A looping statement's contents should be wrapped in a block body.");
|
||||
}
|
||||
break;
|
||||
case 180 /* IfStatement */:
|
||||
case 183 /* IfStatement */:
|
||||
var ifStatement = node;
|
||||
if (ifStatement.thenStatement.kind !== 176 /* Block */) {
|
||||
if (ifStatement.thenStatement.kind !== 179 /* Block */) {
|
||||
report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body.");
|
||||
}
|
||||
if (ifStatement.elseStatement &&
|
||||
ifStatement.elseStatement.kind !== 176 /* Block */ && ifStatement.elseStatement.kind !== 180 /* IfStatement */) {
|
||||
ifStatement.elseStatement.kind !== 179 /* Block */ && ifStatement.elseStatement.kind !== 183 /* IfStatement */) {
|
||||
report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body.");
|
||||
}
|
||||
break;
|
||||
|
|
|
@ -863,163 +863,172 @@ declare module "typescript" {
|
|||
SpreadElementExpression = 173,
|
||||
>SpreadElementExpression : SyntaxKind
|
||||
|
||||
OmittedExpression = 174,
|
||||
ClassExpression = 174,
|
||||
>ClassExpression : SyntaxKind
|
||||
|
||||
OmittedExpression = 175,
|
||||
>OmittedExpression : SyntaxKind
|
||||
|
||||
TemplateSpan = 175,
|
||||
TemplateSpan = 176,
|
||||
>TemplateSpan : SyntaxKind
|
||||
|
||||
Block = 176,
|
||||
HeritageClauseElement = 177,
|
||||
>HeritageClauseElement : SyntaxKind
|
||||
|
||||
SemicolonClassElement = 178,
|
||||
>SemicolonClassElement : SyntaxKind
|
||||
|
||||
Block = 179,
|
||||
>Block : SyntaxKind
|
||||
|
||||
VariableStatement = 177,
|
||||
VariableStatement = 180,
|
||||
>VariableStatement : SyntaxKind
|
||||
|
||||
EmptyStatement = 178,
|
||||
EmptyStatement = 181,
|
||||
>EmptyStatement : SyntaxKind
|
||||
|
||||
ExpressionStatement = 179,
|
||||
ExpressionStatement = 182,
|
||||
>ExpressionStatement : SyntaxKind
|
||||
|
||||
IfStatement = 180,
|
||||
IfStatement = 183,
|
||||
>IfStatement : SyntaxKind
|
||||
|
||||
DoStatement = 181,
|
||||
DoStatement = 184,
|
||||
>DoStatement : SyntaxKind
|
||||
|
||||
WhileStatement = 182,
|
||||
WhileStatement = 185,
|
||||
>WhileStatement : SyntaxKind
|
||||
|
||||
ForStatement = 183,
|
||||
ForStatement = 186,
|
||||
>ForStatement : SyntaxKind
|
||||
|
||||
ForInStatement = 184,
|
||||
ForInStatement = 187,
|
||||
>ForInStatement : SyntaxKind
|
||||
|
||||
ForOfStatement = 185,
|
||||
ForOfStatement = 188,
|
||||
>ForOfStatement : SyntaxKind
|
||||
|
||||
ContinueStatement = 186,
|
||||
ContinueStatement = 189,
|
||||
>ContinueStatement : SyntaxKind
|
||||
|
||||
BreakStatement = 187,
|
||||
BreakStatement = 190,
|
||||
>BreakStatement : SyntaxKind
|
||||
|
||||
ReturnStatement = 188,
|
||||
ReturnStatement = 191,
|
||||
>ReturnStatement : SyntaxKind
|
||||
|
||||
WithStatement = 189,
|
||||
WithStatement = 192,
|
||||
>WithStatement : SyntaxKind
|
||||
|
||||
SwitchStatement = 190,
|
||||
SwitchStatement = 193,
|
||||
>SwitchStatement : SyntaxKind
|
||||
|
||||
LabeledStatement = 191,
|
||||
LabeledStatement = 194,
|
||||
>LabeledStatement : SyntaxKind
|
||||
|
||||
ThrowStatement = 192,
|
||||
ThrowStatement = 195,
|
||||
>ThrowStatement : SyntaxKind
|
||||
|
||||
TryStatement = 193,
|
||||
TryStatement = 196,
|
||||
>TryStatement : SyntaxKind
|
||||
|
||||
DebuggerStatement = 194,
|
||||
DebuggerStatement = 197,
|
||||
>DebuggerStatement : SyntaxKind
|
||||
|
||||
VariableDeclaration = 195,
|
||||
VariableDeclaration = 198,
|
||||
>VariableDeclaration : SyntaxKind
|
||||
|
||||
VariableDeclarationList = 196,
|
||||
VariableDeclarationList = 199,
|
||||
>VariableDeclarationList : SyntaxKind
|
||||
|
||||
FunctionDeclaration = 197,
|
||||
FunctionDeclaration = 200,
|
||||
>FunctionDeclaration : SyntaxKind
|
||||
|
||||
ClassDeclaration = 198,
|
||||
ClassDeclaration = 201,
|
||||
>ClassDeclaration : SyntaxKind
|
||||
|
||||
InterfaceDeclaration = 199,
|
||||
InterfaceDeclaration = 202,
|
||||
>InterfaceDeclaration : SyntaxKind
|
||||
|
||||
TypeAliasDeclaration = 200,
|
||||
TypeAliasDeclaration = 203,
|
||||
>TypeAliasDeclaration : SyntaxKind
|
||||
|
||||
EnumDeclaration = 201,
|
||||
EnumDeclaration = 204,
|
||||
>EnumDeclaration : SyntaxKind
|
||||
|
||||
ModuleDeclaration = 202,
|
||||
ModuleDeclaration = 205,
|
||||
>ModuleDeclaration : SyntaxKind
|
||||
|
||||
ModuleBlock = 203,
|
||||
ModuleBlock = 206,
|
||||
>ModuleBlock : SyntaxKind
|
||||
|
||||
CaseBlock = 204,
|
||||
CaseBlock = 207,
|
||||
>CaseBlock : SyntaxKind
|
||||
|
||||
ImportEqualsDeclaration = 205,
|
||||
ImportEqualsDeclaration = 208,
|
||||
>ImportEqualsDeclaration : SyntaxKind
|
||||
|
||||
ImportDeclaration = 206,
|
||||
ImportDeclaration = 209,
|
||||
>ImportDeclaration : SyntaxKind
|
||||
|
||||
ImportClause = 207,
|
||||
ImportClause = 210,
|
||||
>ImportClause : SyntaxKind
|
||||
|
||||
NamespaceImport = 208,
|
||||
NamespaceImport = 211,
|
||||
>NamespaceImport : SyntaxKind
|
||||
|
||||
NamedImports = 209,
|
||||
NamedImports = 212,
|
||||
>NamedImports : SyntaxKind
|
||||
|
||||
ImportSpecifier = 210,
|
||||
ImportSpecifier = 213,
|
||||
>ImportSpecifier : SyntaxKind
|
||||
|
||||
ExportAssignment = 211,
|
||||
ExportAssignment = 214,
|
||||
>ExportAssignment : SyntaxKind
|
||||
|
||||
ExportDeclaration = 212,
|
||||
ExportDeclaration = 215,
|
||||
>ExportDeclaration : SyntaxKind
|
||||
|
||||
NamedExports = 213,
|
||||
NamedExports = 216,
|
||||
>NamedExports : SyntaxKind
|
||||
|
||||
ExportSpecifier = 214,
|
||||
ExportSpecifier = 217,
|
||||
>ExportSpecifier : SyntaxKind
|
||||
|
||||
MissingDeclaration = 215,
|
||||
MissingDeclaration = 218,
|
||||
>MissingDeclaration : SyntaxKind
|
||||
|
||||
ExternalModuleReference = 216,
|
||||
ExternalModuleReference = 219,
|
||||
>ExternalModuleReference : SyntaxKind
|
||||
|
||||
CaseClause = 217,
|
||||
CaseClause = 220,
|
||||
>CaseClause : SyntaxKind
|
||||
|
||||
DefaultClause = 218,
|
||||
DefaultClause = 221,
|
||||
>DefaultClause : SyntaxKind
|
||||
|
||||
HeritageClause = 219,
|
||||
HeritageClause = 222,
|
||||
>HeritageClause : SyntaxKind
|
||||
|
||||
CatchClause = 220,
|
||||
CatchClause = 223,
|
||||
>CatchClause : SyntaxKind
|
||||
|
||||
PropertyAssignment = 221,
|
||||
PropertyAssignment = 224,
|
||||
>PropertyAssignment : SyntaxKind
|
||||
|
||||
ShorthandPropertyAssignment = 222,
|
||||
ShorthandPropertyAssignment = 225,
|
||||
>ShorthandPropertyAssignment : SyntaxKind
|
||||
|
||||
EnumMember = 223,
|
||||
EnumMember = 226,
|
||||
>EnumMember : SyntaxKind
|
||||
|
||||
SourceFile = 224,
|
||||
SourceFile = 227,
|
||||
>SourceFile : SyntaxKind
|
||||
|
||||
SyntaxList = 225,
|
||||
SyntaxList = 228,
|
||||
>SyntaxList : SyntaxKind
|
||||
|
||||
Count = 226,
|
||||
Count = 229,
|
||||
>Count : SyntaxKind
|
||||
|
||||
FirstAssignment = 53,
|
||||
|
@ -1576,6 +1585,13 @@ declare module "typescript" {
|
|||
body?: Block;
|
||||
>body : Block
|
||||
>Block : Block
|
||||
}
|
||||
interface SemicolonClassElement extends ClassElement {
|
||||
>SemicolonClassElement : SemicolonClassElement
|
||||
>ClassElement : ClassElement
|
||||
|
||||
_semicolonClassElementBrand: any;
|
||||
>_semicolonClassElementBrand : any
|
||||
}
|
||||
interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
|
||||
>AccessorDeclaration : AccessorDeclaration
|
||||
|
@ -1977,6 +1993,19 @@ declare module "typescript" {
|
|||
>arguments : NodeArray<Expression>
|
||||
>NodeArray : NodeArray<T>
|
||||
>Expression : Expression
|
||||
}
|
||||
interface HeritageClauseElement extends Node {
|
||||
>HeritageClauseElement : HeritageClauseElement
|
||||
>Node : Node
|
||||
|
||||
expression: LeftHandSideExpression;
|
||||
>expression : LeftHandSideExpression
|
||||
>LeftHandSideExpression : LeftHandSideExpression
|
||||
|
||||
typeArguments?: NodeArray<TypeNode>;
|
||||
>typeArguments : NodeArray<TypeNode>
|
||||
>NodeArray : NodeArray<T>
|
||||
>TypeNode : TypeNode
|
||||
}
|
||||
interface NewExpression extends CallExpression, PrimaryExpression {
|
||||
>NewExpression : NewExpression
|
||||
|
@ -2261,10 +2290,9 @@ declare module "typescript" {
|
|||
_moduleElementBrand: any;
|
||||
>_moduleElementBrand : any
|
||||
}
|
||||
interface ClassDeclaration extends Declaration, ModuleElement {
|
||||
>ClassDeclaration : ClassDeclaration
|
||||
interface ClassLikeDeclaration extends Declaration {
|
||||
>ClassLikeDeclaration : ClassLikeDeclaration
|
||||
>Declaration : Declaration
|
||||
>ModuleElement : ModuleElement
|
||||
|
||||
name?: Identifier;
|
||||
>name : Identifier
|
||||
|
@ -2284,6 +2312,16 @@ declare module "typescript" {
|
|||
>members : NodeArray<ClassElement>
|
||||
>NodeArray : NodeArray<T>
|
||||
>ClassElement : ClassElement
|
||||
}
|
||||
interface ClassDeclaration extends ClassLikeDeclaration, Statement {
|
||||
>ClassDeclaration : ClassDeclaration
|
||||
>ClassLikeDeclaration : ClassLikeDeclaration
|
||||
>Statement : Statement
|
||||
}
|
||||
interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
|
||||
>ClassExpression : ClassExpression
|
||||
>ClassLikeDeclaration : ClassLikeDeclaration
|
||||
>PrimaryExpression : PrimaryExpression
|
||||
}
|
||||
interface ClassElement extends Declaration {
|
||||
>ClassElement : ClassElement
|
||||
|
@ -2324,10 +2362,10 @@ declare module "typescript" {
|
|||
>token : SyntaxKind
|
||||
>SyntaxKind : SyntaxKind
|
||||
|
||||
types?: NodeArray<TypeReferenceNode>;
|
||||
>types : NodeArray<TypeReferenceNode>
|
||||
types?: NodeArray<HeritageClauseElement>;
|
||||
>types : NodeArray<HeritageClauseElement>
|
||||
>NodeArray : NodeArray<T>
|
||||
>TypeReferenceNode : TypeReferenceNode
|
||||
>HeritageClauseElement : HeritageClauseElement
|
||||
}
|
||||
interface TypeAliasDeclaration extends Declaration, ModuleElement {
|
||||
>TypeAliasDeclaration : TypeAliasDeclaration
|
||||
|
@ -3271,10 +3309,11 @@ declare module "typescript" {
|
|||
>SymbolFlags : SymbolFlags
|
||||
>SymbolAccessiblityResult : SymbolAccessiblityResult
|
||||
|
||||
isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
>isEntityNameVisible : (entityName: Identifier | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
|
||||
>entityName : Identifier | QualifiedName
|
||||
isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
>isEntityNameVisible : (entityName: Identifier | Expression | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
|
||||
>entityName : Identifier | Expression | QualifiedName
|
||||
>EntityName : Identifier | QualifiedName
|
||||
>Expression : Expression
|
||||
>enclosingDeclaration : Node
|
||||
>Node : Node
|
||||
>SymbolVisibilityResult : SymbolVisibilityResult
|
||||
|
@ -4047,9 +4086,6 @@ declare module "typescript" {
|
|||
charset?: string;
|
||||
>charset : string
|
||||
|
||||
codepage?: number;
|
||||
>codepage : number
|
||||
|
||||
declaration?: boolean;
|
||||
>declaration : boolean
|
||||
|
||||
|
@ -4090,9 +4126,6 @@ declare module "typescript" {
|
|||
noLib?: boolean;
|
||||
>noLib : boolean
|
||||
|
||||
noLibCheck?: boolean;
|
||||
>noLibCheck : boolean
|
||||
|
||||
noResolve?: boolean;
|
||||
>noResolve : boolean
|
||||
|
||||
|
@ -4130,6 +4163,9 @@ declare module "typescript" {
|
|||
watch?: boolean;
|
||||
>watch : boolean
|
||||
|
||||
separateCompilation?: boolean;
|
||||
>separateCompilation : boolean
|
||||
|
||||
[option: string]: string | number | boolean;
|
||||
>option : string
|
||||
}
|
||||
|
@ -4948,6 +4984,27 @@ declare module "typescript" {
|
|||
>CompilerHost : CompilerHost
|
||||
>Program : Program
|
||||
}
|
||||
declare module "typescript" {
|
||||
/**
|
||||
* Read tsconfig.json file
|
||||
* @param fileName The path to the config file
|
||||
*/
|
||||
function readConfigFile(fileName: string): any;
|
||||
>readConfigFile : (fileName: string) => any
|
||||
>fileName : string
|
||||
|
||||
/**
|
||||
* Parse the contents of a config file (tsconfig.json).
|
||||
* @param json The contents of the config file to parse
|
||||
* @param basePath A root directory to resolve relative path entries in the config
|
||||
* file to. e.g. outDir
|
||||
*/
|
||||
function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
|
||||
>parseConfigFile : (json: any, basePath?: string) => ParsedCommandLine
|
||||
>json : any
|
||||
>basePath : string
|
||||
>ParsedCommandLine : ParsedCommandLine
|
||||
}
|
||||
declare module "typescript" {
|
||||
/** The version of the language service API */
|
||||
let servicesVersion: string;
|
||||
|
@ -6306,6 +6363,15 @@ declare module "typescript" {
|
|||
throwIfCancellationRequested(): void;
|
||||
>throwIfCancellationRequested : () => void
|
||||
}
|
||||
function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
|
||||
>transpile : (input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]) => string
|
||||
>input : string
|
||||
>compilerOptions : CompilerOptions
|
||||
>CompilerOptions : CompilerOptions
|
||||
>fileName : string
|
||||
>diagnostics : Diagnostic[]
|
||||
>Diagnostic : Diagnostic
|
||||
|
||||
function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
|
||||
>createLanguageServiceSourceFile : (fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean) => SourceFile
|
||||
>fileName : string
|
||||
|
|
6433
tests/baselines/reference/APISample_linter.types.pull
Normal file
6433
tests/baselines/reference/APISample_linter.types.pull
Normal file
File diff suppressed because it is too large
Load diff
|
@ -265,59 +265,62 @@ declare module "typescript" {
|
|||
TemplateExpression = 171,
|
||||
YieldExpression = 172,
|
||||
SpreadElementExpression = 173,
|
||||
OmittedExpression = 174,
|
||||
TemplateSpan = 175,
|
||||
Block = 176,
|
||||
VariableStatement = 177,
|
||||
EmptyStatement = 178,
|
||||
ExpressionStatement = 179,
|
||||
IfStatement = 180,
|
||||
DoStatement = 181,
|
||||
WhileStatement = 182,
|
||||
ForStatement = 183,
|
||||
ForInStatement = 184,
|
||||
ForOfStatement = 185,
|
||||
ContinueStatement = 186,
|
||||
BreakStatement = 187,
|
||||
ReturnStatement = 188,
|
||||
WithStatement = 189,
|
||||
SwitchStatement = 190,
|
||||
LabeledStatement = 191,
|
||||
ThrowStatement = 192,
|
||||
TryStatement = 193,
|
||||
DebuggerStatement = 194,
|
||||
VariableDeclaration = 195,
|
||||
VariableDeclarationList = 196,
|
||||
FunctionDeclaration = 197,
|
||||
ClassDeclaration = 198,
|
||||
InterfaceDeclaration = 199,
|
||||
TypeAliasDeclaration = 200,
|
||||
EnumDeclaration = 201,
|
||||
ModuleDeclaration = 202,
|
||||
ModuleBlock = 203,
|
||||
CaseBlock = 204,
|
||||
ImportEqualsDeclaration = 205,
|
||||
ImportDeclaration = 206,
|
||||
ImportClause = 207,
|
||||
NamespaceImport = 208,
|
||||
NamedImports = 209,
|
||||
ImportSpecifier = 210,
|
||||
ExportAssignment = 211,
|
||||
ExportDeclaration = 212,
|
||||
NamedExports = 213,
|
||||
ExportSpecifier = 214,
|
||||
MissingDeclaration = 215,
|
||||
ExternalModuleReference = 216,
|
||||
CaseClause = 217,
|
||||
DefaultClause = 218,
|
||||
HeritageClause = 219,
|
||||
CatchClause = 220,
|
||||
PropertyAssignment = 221,
|
||||
ShorthandPropertyAssignment = 222,
|
||||
EnumMember = 223,
|
||||
SourceFile = 224,
|
||||
SyntaxList = 225,
|
||||
Count = 226,
|
||||
ClassExpression = 174,
|
||||
OmittedExpression = 175,
|
||||
TemplateSpan = 176,
|
||||
HeritageClauseElement = 177,
|
||||
SemicolonClassElement = 178,
|
||||
Block = 179,
|
||||
VariableStatement = 180,
|
||||
EmptyStatement = 181,
|
||||
ExpressionStatement = 182,
|
||||
IfStatement = 183,
|
||||
DoStatement = 184,
|
||||
WhileStatement = 185,
|
||||
ForStatement = 186,
|
||||
ForInStatement = 187,
|
||||
ForOfStatement = 188,
|
||||
ContinueStatement = 189,
|
||||
BreakStatement = 190,
|
||||
ReturnStatement = 191,
|
||||
WithStatement = 192,
|
||||
SwitchStatement = 193,
|
||||
LabeledStatement = 194,
|
||||
ThrowStatement = 195,
|
||||
TryStatement = 196,
|
||||
DebuggerStatement = 197,
|
||||
VariableDeclaration = 198,
|
||||
VariableDeclarationList = 199,
|
||||
FunctionDeclaration = 200,
|
||||
ClassDeclaration = 201,
|
||||
InterfaceDeclaration = 202,
|
||||
TypeAliasDeclaration = 203,
|
||||
EnumDeclaration = 204,
|
||||
ModuleDeclaration = 205,
|
||||
ModuleBlock = 206,
|
||||
CaseBlock = 207,
|
||||
ImportEqualsDeclaration = 208,
|
||||
ImportDeclaration = 209,
|
||||
ImportClause = 210,
|
||||
NamespaceImport = 211,
|
||||
NamedImports = 212,
|
||||
ImportSpecifier = 213,
|
||||
ExportAssignment = 214,
|
||||
ExportDeclaration = 215,
|
||||
NamedExports = 216,
|
||||
ExportSpecifier = 217,
|
||||
MissingDeclaration = 218,
|
||||
ExternalModuleReference = 219,
|
||||
CaseClause = 220,
|
||||
DefaultClause = 221,
|
||||
HeritageClause = 222,
|
||||
CatchClause = 223,
|
||||
PropertyAssignment = 224,
|
||||
ShorthandPropertyAssignment = 225,
|
||||
EnumMember = 226,
|
||||
SourceFile = 227,
|
||||
SyntaxList = 228,
|
||||
Count = 229,
|
||||
FirstAssignment = 53,
|
||||
LastAssignment = 64,
|
||||
FirstReservedWord = 66,
|
||||
|
@ -501,6 +504,9 @@ declare module "typescript" {
|
|||
interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {
|
||||
body?: Block;
|
||||
}
|
||||
interface SemicolonClassElement extends ClassElement {
|
||||
_semicolonClassElementBrand: any;
|
||||
}
|
||||
interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
|
||||
_accessorDeclarationBrand: any;
|
||||
body: Block;
|
||||
|
@ -639,6 +645,10 @@ declare module "typescript" {
|
|||
typeArguments?: NodeArray<TypeNode>;
|
||||
arguments: NodeArray<Expression>;
|
||||
}
|
||||
interface HeritageClauseElement extends Node {
|
||||
expression: LeftHandSideExpression;
|
||||
typeArguments?: NodeArray<TypeNode>;
|
||||
}
|
||||
interface NewExpression extends CallExpression, PrimaryExpression {
|
||||
}
|
||||
interface TaggedTemplateExpression extends MemberExpression {
|
||||
|
@ -733,12 +743,16 @@ declare module "typescript" {
|
|||
interface ModuleElement extends Node {
|
||||
_moduleElementBrand: any;
|
||||
}
|
||||
interface ClassDeclaration extends Declaration, ModuleElement {
|
||||
interface ClassLikeDeclaration extends Declaration {
|
||||
name?: Identifier;
|
||||
typeParameters?: NodeArray<TypeParameterDeclaration>;
|
||||
heritageClauses?: NodeArray<HeritageClause>;
|
||||
members: NodeArray<ClassElement>;
|
||||
}
|
||||
interface ClassDeclaration extends ClassLikeDeclaration, Statement {
|
||||
}
|
||||
interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
|
||||
}
|
||||
interface ClassElement extends Declaration {
|
||||
_classElementBrand: any;
|
||||
}
|
||||
|
@ -750,7 +764,7 @@ declare module "typescript" {
|
|||
}
|
||||
interface HeritageClause extends Node {
|
||||
token: SyntaxKind;
|
||||
types?: NodeArray<TypeReferenceNode>;
|
||||
types?: NodeArray<HeritageClauseElement>;
|
||||
}
|
||||
interface TypeAliasDeclaration extends Declaration, ModuleElement {
|
||||
name: Identifier;
|
||||
|
@ -992,7 +1006,7 @@ declare module "typescript" {
|
|||
writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
|
||||
writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
|
||||
isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
|
||||
isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
|
||||
resolvesToSomeValue(location: Node, name: string): boolean;
|
||||
getBlockScopedVariableId(node: Identifier): number;
|
||||
|
@ -1248,7 +1262,6 @@ declare module "typescript" {
|
|||
interface CompilerOptions {
|
||||
allowNonTsExtensions?: boolean;
|
||||
charset?: string;
|
||||
codepage?: number;
|
||||
declaration?: boolean;
|
||||
diagnostics?: boolean;
|
||||
emitBOM?: boolean;
|
||||
|
@ -1262,7 +1275,6 @@ declare module "typescript" {
|
|||
noErrorTruncation?: boolean;
|
||||
noImplicitAny?: boolean;
|
||||
noLib?: boolean;
|
||||
noLibCheck?: boolean;
|
||||
noResolve?: boolean;
|
||||
out?: string;
|
||||
outDir?: string;
|
||||
|
@ -1275,6 +1287,7 @@ declare module "typescript" {
|
|||
target?: ScriptTarget;
|
||||
version?: boolean;
|
||||
watch?: boolean;
|
||||
separateCompilation?: boolean;
|
||||
[option: string]: string | number | boolean;
|
||||
}
|
||||
const enum ModuleKind {
|
||||
|
@ -1523,6 +1536,20 @@ declare module "typescript" {
|
|||
function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;
|
||||
function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost): Program;
|
||||
}
|
||||
declare module "typescript" {
|
||||
/**
|
||||
* Read tsconfig.json file
|
||||
* @param fileName The path to the config file
|
||||
*/
|
||||
function readConfigFile(fileName: string): any;
|
||||
/**
|
||||
* Parse the contents of a config file (tsconfig.json).
|
||||
* @param json The contents of the config file to parse
|
||||
* @param basePath A root directory to resolve relative path entries in the config
|
||||
* file to. e.g. outDir
|
||||
*/
|
||||
function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
|
||||
}
|
||||
declare module "typescript" {
|
||||
/** The version of the language service API */
|
||||
let servicesVersion: string;
|
||||
|
@ -2016,6 +2043,7 @@ declare module "typescript" {
|
|||
isCancellationRequested(): boolean;
|
||||
throwIfCancellationRequested(): void;
|
||||
}
|
||||
function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
|
||||
function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
|
||||
let disableIncrementalParsing: boolean;
|
||||
function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;
|
||||
|
|
|
@ -813,163 +813,172 @@ declare module "typescript" {
|
|||
SpreadElementExpression = 173,
|
||||
>SpreadElementExpression : SyntaxKind
|
||||
|
||||
OmittedExpression = 174,
|
||||
ClassExpression = 174,
|
||||
>ClassExpression : SyntaxKind
|
||||
|
||||
OmittedExpression = 175,
|
||||
>OmittedExpression : SyntaxKind
|
||||
|
||||
TemplateSpan = 175,
|
||||
TemplateSpan = 176,
|
||||
>TemplateSpan : SyntaxKind
|
||||
|
||||
Block = 176,
|
||||
HeritageClauseElement = 177,
|
||||
>HeritageClauseElement : SyntaxKind
|
||||
|
||||
SemicolonClassElement = 178,
|
||||
>SemicolonClassElement : SyntaxKind
|
||||
|
||||
Block = 179,
|
||||
>Block : SyntaxKind
|
||||
|
||||
VariableStatement = 177,
|
||||
VariableStatement = 180,
|
||||
>VariableStatement : SyntaxKind
|
||||
|
||||
EmptyStatement = 178,
|
||||
EmptyStatement = 181,
|
||||
>EmptyStatement : SyntaxKind
|
||||
|
||||
ExpressionStatement = 179,
|
||||
ExpressionStatement = 182,
|
||||
>ExpressionStatement : SyntaxKind
|
||||
|
||||
IfStatement = 180,
|
||||
IfStatement = 183,
|
||||
>IfStatement : SyntaxKind
|
||||
|
||||
DoStatement = 181,
|
||||
DoStatement = 184,
|
||||
>DoStatement : SyntaxKind
|
||||
|
||||
WhileStatement = 182,
|
||||
WhileStatement = 185,
|
||||
>WhileStatement : SyntaxKind
|
||||
|
||||
ForStatement = 183,
|
||||
ForStatement = 186,
|
||||
>ForStatement : SyntaxKind
|
||||
|
||||
ForInStatement = 184,
|
||||
ForInStatement = 187,
|
||||
>ForInStatement : SyntaxKind
|
||||
|
||||
ForOfStatement = 185,
|
||||
ForOfStatement = 188,
|
||||
>ForOfStatement : SyntaxKind
|
||||
|
||||
ContinueStatement = 186,
|
||||
ContinueStatement = 189,
|
||||
>ContinueStatement : SyntaxKind
|
||||
|
||||
BreakStatement = 187,
|
||||
BreakStatement = 190,
|
||||
>BreakStatement : SyntaxKind
|
||||
|
||||
ReturnStatement = 188,
|
||||
ReturnStatement = 191,
|
||||
>ReturnStatement : SyntaxKind
|
||||
|
||||
WithStatement = 189,
|
||||
WithStatement = 192,
|
||||
>WithStatement : SyntaxKind
|
||||
|
||||
SwitchStatement = 190,
|
||||
SwitchStatement = 193,
|
||||
>SwitchStatement : SyntaxKind
|
||||
|
||||
LabeledStatement = 191,
|
||||
LabeledStatement = 194,
|
||||
>LabeledStatement : SyntaxKind
|
||||
|
||||
ThrowStatement = 192,
|
||||
ThrowStatement = 195,
|
||||
>ThrowStatement : SyntaxKind
|
||||
|
||||
TryStatement = 193,
|
||||
TryStatement = 196,
|
||||
>TryStatement : SyntaxKind
|
||||
|
||||
DebuggerStatement = 194,
|
||||
DebuggerStatement = 197,
|
||||
>DebuggerStatement : SyntaxKind
|
||||
|
||||
VariableDeclaration = 195,
|
||||
VariableDeclaration = 198,
|
||||
>VariableDeclaration : SyntaxKind
|
||||
|
||||
VariableDeclarationList = 196,
|
||||
VariableDeclarationList = 199,
|
||||
>VariableDeclarationList : SyntaxKind
|
||||
|
||||
FunctionDeclaration = 197,
|
||||
FunctionDeclaration = 200,
|
||||
>FunctionDeclaration : SyntaxKind
|
||||
|
||||
ClassDeclaration = 198,
|
||||
ClassDeclaration = 201,
|
||||
>ClassDeclaration : SyntaxKind
|
||||
|
||||
InterfaceDeclaration = 199,
|
||||
InterfaceDeclaration = 202,
|
||||
>InterfaceDeclaration : SyntaxKind
|
||||
|
||||
TypeAliasDeclaration = 200,
|
||||
TypeAliasDeclaration = 203,
|
||||
>TypeAliasDeclaration : SyntaxKind
|
||||
|
||||
EnumDeclaration = 201,
|
||||
EnumDeclaration = 204,
|
||||
>EnumDeclaration : SyntaxKind
|
||||
|
||||
ModuleDeclaration = 202,
|
||||
ModuleDeclaration = 205,
|
||||
>ModuleDeclaration : SyntaxKind
|
||||
|
||||
ModuleBlock = 203,
|
||||
ModuleBlock = 206,
|
||||
>ModuleBlock : SyntaxKind
|
||||
|
||||
CaseBlock = 204,
|
||||
CaseBlock = 207,
|
||||
>CaseBlock : SyntaxKind
|
||||
|
||||
ImportEqualsDeclaration = 205,
|
||||
ImportEqualsDeclaration = 208,
|
||||
>ImportEqualsDeclaration : SyntaxKind
|
||||
|
||||
ImportDeclaration = 206,
|
||||
ImportDeclaration = 209,
|
||||
>ImportDeclaration : SyntaxKind
|
||||
|
||||
ImportClause = 207,
|
||||
ImportClause = 210,
|
||||
>ImportClause : SyntaxKind
|
||||
|
||||
NamespaceImport = 208,
|
||||
NamespaceImport = 211,
|
||||
>NamespaceImport : SyntaxKind
|
||||
|
||||
NamedImports = 209,
|
||||
NamedImports = 212,
|
||||
>NamedImports : SyntaxKind
|
||||
|
||||
ImportSpecifier = 210,
|
||||
ImportSpecifier = 213,
|
||||
>ImportSpecifier : SyntaxKind
|
||||
|
||||
ExportAssignment = 211,
|
||||
ExportAssignment = 214,
|
||||
>ExportAssignment : SyntaxKind
|
||||
|
||||
ExportDeclaration = 212,
|
||||
ExportDeclaration = 215,
|
||||
>ExportDeclaration : SyntaxKind
|
||||
|
||||
NamedExports = 213,
|
||||
NamedExports = 216,
|
||||
>NamedExports : SyntaxKind
|
||||
|
||||
ExportSpecifier = 214,
|
||||
ExportSpecifier = 217,
|
||||
>ExportSpecifier : SyntaxKind
|
||||
|
||||
MissingDeclaration = 215,
|
||||
MissingDeclaration = 218,
|
||||
>MissingDeclaration : SyntaxKind
|
||||
|
||||
ExternalModuleReference = 216,
|
||||
ExternalModuleReference = 219,
|
||||
>ExternalModuleReference : SyntaxKind
|
||||
|
||||
CaseClause = 217,
|
||||
CaseClause = 220,
|
||||
>CaseClause : SyntaxKind
|
||||
|
||||
DefaultClause = 218,
|
||||
DefaultClause = 221,
|
||||
>DefaultClause : SyntaxKind
|
||||
|
||||
HeritageClause = 219,
|
||||
HeritageClause = 222,
|
||||
>HeritageClause : SyntaxKind
|
||||
|
||||
CatchClause = 220,
|
||||
CatchClause = 223,
|
||||
>CatchClause : SyntaxKind
|
||||
|
||||
PropertyAssignment = 221,
|
||||
PropertyAssignment = 224,
|
||||
>PropertyAssignment : SyntaxKind
|
||||
|
||||
ShorthandPropertyAssignment = 222,
|
||||
ShorthandPropertyAssignment = 225,
|
||||
>ShorthandPropertyAssignment : SyntaxKind
|
||||
|
||||
EnumMember = 223,
|
||||
EnumMember = 226,
|
||||
>EnumMember : SyntaxKind
|
||||
|
||||
SourceFile = 224,
|
||||
SourceFile = 227,
|
||||
>SourceFile : SyntaxKind
|
||||
|
||||
SyntaxList = 225,
|
||||
SyntaxList = 228,
|
||||
>SyntaxList : SyntaxKind
|
||||
|
||||
Count = 226,
|
||||
Count = 229,
|
||||
>Count : SyntaxKind
|
||||
|
||||
FirstAssignment = 53,
|
||||
|
@ -1526,6 +1535,13 @@ declare module "typescript" {
|
|||
body?: Block;
|
||||
>body : Block
|
||||
>Block : Block
|
||||
}
|
||||
interface SemicolonClassElement extends ClassElement {
|
||||
>SemicolonClassElement : SemicolonClassElement
|
||||
>ClassElement : ClassElement
|
||||
|
||||
_semicolonClassElementBrand: any;
|
||||
>_semicolonClassElementBrand : any
|
||||
}
|
||||
interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
|
||||
>AccessorDeclaration : AccessorDeclaration
|
||||
|
@ -1927,6 +1943,19 @@ declare module "typescript" {
|
|||
>arguments : NodeArray<Expression>
|
||||
>NodeArray : NodeArray<T>
|
||||
>Expression : Expression
|
||||
}
|
||||
interface HeritageClauseElement extends Node {
|
||||
>HeritageClauseElement : HeritageClauseElement
|
||||
>Node : Node
|
||||
|
||||
expression: LeftHandSideExpression;
|
||||
>expression : LeftHandSideExpression
|
||||
>LeftHandSideExpression : LeftHandSideExpression
|
||||
|
||||
typeArguments?: NodeArray<TypeNode>;
|
||||
>typeArguments : NodeArray<TypeNode>
|
||||
>NodeArray : NodeArray<T>
|
||||
>TypeNode : TypeNode
|
||||
}
|
||||
interface NewExpression extends CallExpression, PrimaryExpression {
|
||||
>NewExpression : NewExpression
|
||||
|
@ -2211,10 +2240,9 @@ declare module "typescript" {
|
|||
_moduleElementBrand: any;
|
||||
>_moduleElementBrand : any
|
||||
}
|
||||
interface ClassDeclaration extends Declaration, ModuleElement {
|
||||
>ClassDeclaration : ClassDeclaration
|
||||
interface ClassLikeDeclaration extends Declaration {
|
||||
>ClassLikeDeclaration : ClassLikeDeclaration
|
||||
>Declaration : Declaration
|
||||
>ModuleElement : ModuleElement
|
||||
|
||||
name?: Identifier;
|
||||
>name : Identifier
|
||||
|
@ -2234,6 +2262,16 @@ declare module "typescript" {
|
|||
>members : NodeArray<ClassElement>
|
||||
>NodeArray : NodeArray<T>
|
||||
>ClassElement : ClassElement
|
||||
}
|
||||
interface ClassDeclaration extends ClassLikeDeclaration, Statement {
|
||||
>ClassDeclaration : ClassDeclaration
|
||||
>ClassLikeDeclaration : ClassLikeDeclaration
|
||||
>Statement : Statement
|
||||
}
|
||||
interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
|
||||
>ClassExpression : ClassExpression
|
||||
>ClassLikeDeclaration : ClassLikeDeclaration
|
||||
>PrimaryExpression : PrimaryExpression
|
||||
}
|
||||
interface ClassElement extends Declaration {
|
||||
>ClassElement : ClassElement
|
||||
|
@ -2274,10 +2312,10 @@ declare module "typescript" {
|
|||
>token : SyntaxKind
|
||||
>SyntaxKind : SyntaxKind
|
||||
|
||||
types?: NodeArray<TypeReferenceNode>;
|
||||
>types : NodeArray<TypeReferenceNode>
|
||||
types?: NodeArray<HeritageClauseElement>;
|
||||
>types : NodeArray<HeritageClauseElement>
|
||||
>NodeArray : NodeArray<T>
|
||||
>TypeReferenceNode : TypeReferenceNode
|
||||
>HeritageClauseElement : HeritageClauseElement
|
||||
}
|
||||
interface TypeAliasDeclaration extends Declaration, ModuleElement {
|
||||
>TypeAliasDeclaration : TypeAliasDeclaration
|
||||
|
@ -3221,10 +3259,11 @@ declare module "typescript" {
|
|||
>SymbolFlags : SymbolFlags
|
||||
>SymbolAccessiblityResult : SymbolAccessiblityResult
|
||||
|
||||
isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
>isEntityNameVisible : (entityName: Identifier | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
|
||||
>entityName : Identifier | QualifiedName
|
||||
isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
>isEntityNameVisible : (entityName: Identifier | Expression | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
|
||||
>entityName : Identifier | Expression | QualifiedName
|
||||
>EntityName : Identifier | QualifiedName
|
||||
>Expression : Expression
|
||||
>enclosingDeclaration : Node
|
||||
>Node : Node
|
||||
>SymbolVisibilityResult : SymbolVisibilityResult
|
||||
|
@ -3997,9 +4036,6 @@ declare module "typescript" {
|
|||
charset?: string;
|
||||
>charset : string
|
||||
|
||||
codepage?: number;
|
||||
>codepage : number
|
||||
|
||||
declaration?: boolean;
|
||||
>declaration : boolean
|
||||
|
||||
|
@ -4040,9 +4076,6 @@ declare module "typescript" {
|
|||
noLib?: boolean;
|
||||
>noLib : boolean
|
||||
|
||||
noLibCheck?: boolean;
|
||||
>noLibCheck : boolean
|
||||
|
||||
noResolve?: boolean;
|
||||
>noResolve : boolean
|
||||
|
||||
|
@ -4080,6 +4113,9 @@ declare module "typescript" {
|
|||
watch?: boolean;
|
||||
>watch : boolean
|
||||
|
||||
separateCompilation?: boolean;
|
||||
>separateCompilation : boolean
|
||||
|
||||
[option: string]: string | number | boolean;
|
||||
>option : string
|
||||
}
|
||||
|
@ -4898,6 +4934,27 @@ declare module "typescript" {
|
|||
>CompilerHost : CompilerHost
|
||||
>Program : Program
|
||||
}
|
||||
declare module "typescript" {
|
||||
/**
|
||||
* Read tsconfig.json file
|
||||
* @param fileName The path to the config file
|
||||
*/
|
||||
function readConfigFile(fileName: string): any;
|
||||
>readConfigFile : (fileName: string) => any
|
||||
>fileName : string
|
||||
|
||||
/**
|
||||
* Parse the contents of a config file (tsconfig.json).
|
||||
* @param json The contents of the config file to parse
|
||||
* @param basePath A root directory to resolve relative path entries in the config
|
||||
* file to. e.g. outDir
|
||||
*/
|
||||
function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
|
||||
>parseConfigFile : (json: any, basePath?: string) => ParsedCommandLine
|
||||
>json : any
|
||||
>basePath : string
|
||||
>ParsedCommandLine : ParsedCommandLine
|
||||
}
|
||||
declare module "typescript" {
|
||||
/** The version of the language service API */
|
||||
let servicesVersion: string;
|
||||
|
@ -6256,6 +6313,15 @@ declare module "typescript" {
|
|||
throwIfCancellationRequested(): void;
|
||||
>throwIfCancellationRequested : () => void
|
||||
}
|
||||
function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
|
||||
>transpile : (input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]) => string
|
||||
>input : string
|
||||
>compilerOptions : CompilerOptions
|
||||
>CompilerOptions : CompilerOptions
|
||||
>fileName : string
|
||||
>diagnostics : Diagnostic[]
|
||||
>Diagnostic : Diagnostic
|
||||
|
||||
function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
|
||||
>createLanguageServiceSourceFile : (fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean) => SourceFile
|
||||
>fileName : string
|
||||
|
|
|
@ -302,59 +302,62 @@ declare module "typescript" {
|
|||
TemplateExpression = 171,
|
||||
YieldExpression = 172,
|
||||
SpreadElementExpression = 173,
|
||||
OmittedExpression = 174,
|
||||
TemplateSpan = 175,
|
||||
Block = 176,
|
||||
VariableStatement = 177,
|
||||
EmptyStatement = 178,
|
||||
ExpressionStatement = 179,
|
||||
IfStatement = 180,
|
||||
DoStatement = 181,
|
||||
WhileStatement = 182,
|
||||
ForStatement = 183,
|
||||
ForInStatement = 184,
|
||||
ForOfStatement = 185,
|
||||
ContinueStatement = 186,
|
||||
BreakStatement = 187,
|
||||
ReturnStatement = 188,
|
||||
WithStatement = 189,
|
||||
SwitchStatement = 190,
|
||||
LabeledStatement = 191,
|
||||
ThrowStatement = 192,
|
||||
TryStatement = 193,
|
||||
DebuggerStatement = 194,
|
||||
VariableDeclaration = 195,
|
||||
VariableDeclarationList = 196,
|
||||
FunctionDeclaration = 197,
|
||||
ClassDeclaration = 198,
|
||||
InterfaceDeclaration = 199,
|
||||
TypeAliasDeclaration = 200,
|
||||
EnumDeclaration = 201,
|
||||
ModuleDeclaration = 202,
|
||||
ModuleBlock = 203,
|
||||
CaseBlock = 204,
|
||||
ImportEqualsDeclaration = 205,
|
||||
ImportDeclaration = 206,
|
||||
ImportClause = 207,
|
||||
NamespaceImport = 208,
|
||||
NamedImports = 209,
|
||||
ImportSpecifier = 210,
|
||||
ExportAssignment = 211,
|
||||
ExportDeclaration = 212,
|
||||
NamedExports = 213,
|
||||
ExportSpecifier = 214,
|
||||
MissingDeclaration = 215,
|
||||
ExternalModuleReference = 216,
|
||||
CaseClause = 217,
|
||||
DefaultClause = 218,
|
||||
HeritageClause = 219,
|
||||
CatchClause = 220,
|
||||
PropertyAssignment = 221,
|
||||
ShorthandPropertyAssignment = 222,
|
||||
EnumMember = 223,
|
||||
SourceFile = 224,
|
||||
SyntaxList = 225,
|
||||
Count = 226,
|
||||
ClassExpression = 174,
|
||||
OmittedExpression = 175,
|
||||
TemplateSpan = 176,
|
||||
HeritageClauseElement = 177,
|
||||
SemicolonClassElement = 178,
|
||||
Block = 179,
|
||||
VariableStatement = 180,
|
||||
EmptyStatement = 181,
|
||||
ExpressionStatement = 182,
|
||||
IfStatement = 183,
|
||||
DoStatement = 184,
|
||||
WhileStatement = 185,
|
||||
ForStatement = 186,
|
||||
ForInStatement = 187,
|
||||
ForOfStatement = 188,
|
||||
ContinueStatement = 189,
|
||||
BreakStatement = 190,
|
||||
ReturnStatement = 191,
|
||||
WithStatement = 192,
|
||||
SwitchStatement = 193,
|
||||
LabeledStatement = 194,
|
||||
ThrowStatement = 195,
|
||||
TryStatement = 196,
|
||||
DebuggerStatement = 197,
|
||||
VariableDeclaration = 198,
|
||||
VariableDeclarationList = 199,
|
||||
FunctionDeclaration = 200,
|
||||
ClassDeclaration = 201,
|
||||
InterfaceDeclaration = 202,
|
||||
TypeAliasDeclaration = 203,
|
||||
EnumDeclaration = 204,
|
||||
ModuleDeclaration = 205,
|
||||
ModuleBlock = 206,
|
||||
CaseBlock = 207,
|
||||
ImportEqualsDeclaration = 208,
|
||||
ImportDeclaration = 209,
|
||||
ImportClause = 210,
|
||||
NamespaceImport = 211,
|
||||
NamedImports = 212,
|
||||
ImportSpecifier = 213,
|
||||
ExportAssignment = 214,
|
||||
ExportDeclaration = 215,
|
||||
NamedExports = 216,
|
||||
ExportSpecifier = 217,
|
||||
MissingDeclaration = 218,
|
||||
ExternalModuleReference = 219,
|
||||
CaseClause = 220,
|
||||
DefaultClause = 221,
|
||||
HeritageClause = 222,
|
||||
CatchClause = 223,
|
||||
PropertyAssignment = 224,
|
||||
ShorthandPropertyAssignment = 225,
|
||||
EnumMember = 226,
|
||||
SourceFile = 227,
|
||||
SyntaxList = 228,
|
||||
Count = 229,
|
||||
FirstAssignment = 53,
|
||||
LastAssignment = 64,
|
||||
FirstReservedWord = 66,
|
||||
|
@ -538,6 +541,9 @@ declare module "typescript" {
|
|||
interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {
|
||||
body?: Block;
|
||||
}
|
||||
interface SemicolonClassElement extends ClassElement {
|
||||
_semicolonClassElementBrand: any;
|
||||
}
|
||||
interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
|
||||
_accessorDeclarationBrand: any;
|
||||
body: Block;
|
||||
|
@ -676,6 +682,10 @@ declare module "typescript" {
|
|||
typeArguments?: NodeArray<TypeNode>;
|
||||
arguments: NodeArray<Expression>;
|
||||
}
|
||||
interface HeritageClauseElement extends Node {
|
||||
expression: LeftHandSideExpression;
|
||||
typeArguments?: NodeArray<TypeNode>;
|
||||
}
|
||||
interface NewExpression extends CallExpression, PrimaryExpression {
|
||||
}
|
||||
interface TaggedTemplateExpression extends MemberExpression {
|
||||
|
@ -770,12 +780,16 @@ declare module "typescript" {
|
|||
interface ModuleElement extends Node {
|
||||
_moduleElementBrand: any;
|
||||
}
|
||||
interface ClassDeclaration extends Declaration, ModuleElement {
|
||||
interface ClassLikeDeclaration extends Declaration {
|
||||
name?: Identifier;
|
||||
typeParameters?: NodeArray<TypeParameterDeclaration>;
|
||||
heritageClauses?: NodeArray<HeritageClause>;
|
||||
members: NodeArray<ClassElement>;
|
||||
}
|
||||
interface ClassDeclaration extends ClassLikeDeclaration, Statement {
|
||||
}
|
||||
interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
|
||||
}
|
||||
interface ClassElement extends Declaration {
|
||||
_classElementBrand: any;
|
||||
}
|
||||
|
@ -787,7 +801,7 @@ declare module "typescript" {
|
|||
}
|
||||
interface HeritageClause extends Node {
|
||||
token: SyntaxKind;
|
||||
types?: NodeArray<TypeReferenceNode>;
|
||||
types?: NodeArray<HeritageClauseElement>;
|
||||
}
|
||||
interface TypeAliasDeclaration extends Declaration, ModuleElement {
|
||||
name: Identifier;
|
||||
|
@ -1029,7 +1043,7 @@ declare module "typescript" {
|
|||
writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
|
||||
writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
|
||||
isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
|
||||
isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
|
||||
resolvesToSomeValue(location: Node, name: string): boolean;
|
||||
getBlockScopedVariableId(node: Identifier): number;
|
||||
|
@ -1285,7 +1299,6 @@ declare module "typescript" {
|
|||
interface CompilerOptions {
|
||||
allowNonTsExtensions?: boolean;
|
||||
charset?: string;
|
||||
codepage?: number;
|
||||
declaration?: boolean;
|
||||
diagnostics?: boolean;
|
||||
emitBOM?: boolean;
|
||||
|
@ -1299,7 +1312,6 @@ declare module "typescript" {
|
|||
noErrorTruncation?: boolean;
|
||||
noImplicitAny?: boolean;
|
||||
noLib?: boolean;
|
||||
noLibCheck?: boolean;
|
||||
noResolve?: boolean;
|
||||
out?: string;
|
||||
outDir?: string;
|
||||
|
@ -1312,6 +1324,7 @@ declare module "typescript" {
|
|||
target?: ScriptTarget;
|
||||
version?: boolean;
|
||||
watch?: boolean;
|
||||
separateCompilation?: boolean;
|
||||
[option: string]: string | number | boolean;
|
||||
}
|
||||
const enum ModuleKind {
|
||||
|
@ -1560,6 +1573,20 @@ declare module "typescript" {
|
|||
function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;
|
||||
function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost): Program;
|
||||
}
|
||||
declare module "typescript" {
|
||||
/**
|
||||
* Read tsconfig.json file
|
||||
* @param fileName The path to the config file
|
||||
*/
|
||||
function readConfigFile(fileName: string): any;
|
||||
/**
|
||||
* Parse the contents of a config file (tsconfig.json).
|
||||
* @param json The contents of the config file to parse
|
||||
* @param basePath A root directory to resolve relative path entries in the config
|
||||
* file to. e.g. outDir
|
||||
*/
|
||||
function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
|
||||
}
|
||||
declare module "typescript" {
|
||||
/** The version of the language service API */
|
||||
let servicesVersion: string;
|
||||
|
@ -2053,6 +2080,7 @@ declare module "typescript" {
|
|||
isCancellationRequested(): boolean;
|
||||
throwIfCancellationRequested(): void;
|
||||
}
|
||||
function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
|
||||
function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
|
||||
let disableIncrementalParsing: boolean;
|
||||
function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;
|
||||
|
|
|
@ -986,163 +986,172 @@ declare module "typescript" {
|
|||
SpreadElementExpression = 173,
|
||||
>SpreadElementExpression : SyntaxKind
|
||||
|
||||
OmittedExpression = 174,
|
||||
ClassExpression = 174,
|
||||
>ClassExpression : SyntaxKind
|
||||
|
||||
OmittedExpression = 175,
|
||||
>OmittedExpression : SyntaxKind
|
||||
|
||||
TemplateSpan = 175,
|
||||
TemplateSpan = 176,
|
||||
>TemplateSpan : SyntaxKind
|
||||
|
||||
Block = 176,
|
||||
HeritageClauseElement = 177,
|
||||
>HeritageClauseElement : SyntaxKind
|
||||
|
||||
SemicolonClassElement = 178,
|
||||
>SemicolonClassElement : SyntaxKind
|
||||
|
||||
Block = 179,
|
||||
>Block : SyntaxKind
|
||||
|
||||
VariableStatement = 177,
|
||||
VariableStatement = 180,
|
||||
>VariableStatement : SyntaxKind
|
||||
|
||||
EmptyStatement = 178,
|
||||
EmptyStatement = 181,
|
||||
>EmptyStatement : SyntaxKind
|
||||
|
||||
ExpressionStatement = 179,
|
||||
ExpressionStatement = 182,
|
||||
>ExpressionStatement : SyntaxKind
|
||||
|
||||
IfStatement = 180,
|
||||
IfStatement = 183,
|
||||
>IfStatement : SyntaxKind
|
||||
|
||||
DoStatement = 181,
|
||||
DoStatement = 184,
|
||||
>DoStatement : SyntaxKind
|
||||
|
||||
WhileStatement = 182,
|
||||
WhileStatement = 185,
|
||||
>WhileStatement : SyntaxKind
|
||||
|
||||
ForStatement = 183,
|
||||
ForStatement = 186,
|
||||
>ForStatement : SyntaxKind
|
||||
|
||||
ForInStatement = 184,
|
||||
ForInStatement = 187,
|
||||
>ForInStatement : SyntaxKind
|
||||
|
||||
ForOfStatement = 185,
|
||||
ForOfStatement = 188,
|
||||
>ForOfStatement : SyntaxKind
|
||||
|
||||
ContinueStatement = 186,
|
||||
ContinueStatement = 189,
|
||||
>ContinueStatement : SyntaxKind
|
||||
|
||||
BreakStatement = 187,
|
||||
BreakStatement = 190,
|
||||
>BreakStatement : SyntaxKind
|
||||
|
||||
ReturnStatement = 188,
|
||||
ReturnStatement = 191,
|
||||
>ReturnStatement : SyntaxKind
|
||||
|
||||
WithStatement = 189,
|
||||
WithStatement = 192,
|
||||
>WithStatement : SyntaxKind
|
||||
|
||||
SwitchStatement = 190,
|
||||
SwitchStatement = 193,
|
||||
>SwitchStatement : SyntaxKind
|
||||
|
||||
LabeledStatement = 191,
|
||||
LabeledStatement = 194,
|
||||
>LabeledStatement : SyntaxKind
|
||||
|
||||
ThrowStatement = 192,
|
||||
ThrowStatement = 195,
|
||||
>ThrowStatement : SyntaxKind
|
||||
|
||||
TryStatement = 193,
|
||||
TryStatement = 196,
|
||||
>TryStatement : SyntaxKind
|
||||
|
||||
DebuggerStatement = 194,
|
||||
DebuggerStatement = 197,
|
||||
>DebuggerStatement : SyntaxKind
|
||||
|
||||
VariableDeclaration = 195,
|
||||
VariableDeclaration = 198,
|
||||
>VariableDeclaration : SyntaxKind
|
||||
|
||||
VariableDeclarationList = 196,
|
||||
VariableDeclarationList = 199,
|
||||
>VariableDeclarationList : SyntaxKind
|
||||
|
||||
FunctionDeclaration = 197,
|
||||
FunctionDeclaration = 200,
|
||||
>FunctionDeclaration : SyntaxKind
|
||||
|
||||
ClassDeclaration = 198,
|
||||
ClassDeclaration = 201,
|
||||
>ClassDeclaration : SyntaxKind
|
||||
|
||||
InterfaceDeclaration = 199,
|
||||
InterfaceDeclaration = 202,
|
||||
>InterfaceDeclaration : SyntaxKind
|
||||
|
||||
TypeAliasDeclaration = 200,
|
||||
TypeAliasDeclaration = 203,
|
||||
>TypeAliasDeclaration : SyntaxKind
|
||||
|
||||
EnumDeclaration = 201,
|
||||
EnumDeclaration = 204,
|
||||
>EnumDeclaration : SyntaxKind
|
||||
|
||||
ModuleDeclaration = 202,
|
||||
ModuleDeclaration = 205,
|
||||
>ModuleDeclaration : SyntaxKind
|
||||
|
||||
ModuleBlock = 203,
|
||||
ModuleBlock = 206,
|
||||
>ModuleBlock : SyntaxKind
|
||||
|
||||
CaseBlock = 204,
|
||||
CaseBlock = 207,
|
||||
>CaseBlock : SyntaxKind
|
||||
|
||||
ImportEqualsDeclaration = 205,
|
||||
ImportEqualsDeclaration = 208,
|
||||
>ImportEqualsDeclaration : SyntaxKind
|
||||
|
||||
ImportDeclaration = 206,
|
||||
ImportDeclaration = 209,
|
||||
>ImportDeclaration : SyntaxKind
|
||||
|
||||
ImportClause = 207,
|
||||
ImportClause = 210,
|
||||
>ImportClause : SyntaxKind
|
||||
|
||||
NamespaceImport = 208,
|
||||
NamespaceImport = 211,
|
||||
>NamespaceImport : SyntaxKind
|
||||
|
||||
NamedImports = 209,
|
||||
NamedImports = 212,
|
||||
>NamedImports : SyntaxKind
|
||||
|
||||
ImportSpecifier = 210,
|
||||
ImportSpecifier = 213,
|
||||
>ImportSpecifier : SyntaxKind
|
||||
|
||||
ExportAssignment = 211,
|
||||
ExportAssignment = 214,
|
||||
>ExportAssignment : SyntaxKind
|
||||
|
||||
ExportDeclaration = 212,
|
||||
ExportDeclaration = 215,
|
||||
>ExportDeclaration : SyntaxKind
|
||||
|
||||
NamedExports = 213,
|
||||
NamedExports = 216,
|
||||
>NamedExports : SyntaxKind
|
||||
|
||||
ExportSpecifier = 214,
|
||||
ExportSpecifier = 217,
|
||||
>ExportSpecifier : SyntaxKind
|
||||
|
||||
MissingDeclaration = 215,
|
||||
MissingDeclaration = 218,
|
||||
>MissingDeclaration : SyntaxKind
|
||||
|
||||
ExternalModuleReference = 216,
|
||||
ExternalModuleReference = 219,
|
||||
>ExternalModuleReference : SyntaxKind
|
||||
|
||||
CaseClause = 217,
|
||||
CaseClause = 220,
|
||||
>CaseClause : SyntaxKind
|
||||
|
||||
DefaultClause = 218,
|
||||
DefaultClause = 221,
|
||||
>DefaultClause : SyntaxKind
|
||||
|
||||
HeritageClause = 219,
|
||||
HeritageClause = 222,
|
||||
>HeritageClause : SyntaxKind
|
||||
|
||||
CatchClause = 220,
|
||||
CatchClause = 223,
|
||||
>CatchClause : SyntaxKind
|
||||
|
||||
PropertyAssignment = 221,
|
||||
PropertyAssignment = 224,
|
||||
>PropertyAssignment : SyntaxKind
|
||||
|
||||
ShorthandPropertyAssignment = 222,
|
||||
ShorthandPropertyAssignment = 225,
|
||||
>ShorthandPropertyAssignment : SyntaxKind
|
||||
|
||||
EnumMember = 223,
|
||||
EnumMember = 226,
|
||||
>EnumMember : SyntaxKind
|
||||
|
||||
SourceFile = 224,
|
||||
SourceFile = 227,
|
||||
>SourceFile : SyntaxKind
|
||||
|
||||
SyntaxList = 225,
|
||||
SyntaxList = 228,
|
||||
>SyntaxList : SyntaxKind
|
||||
|
||||
Count = 226,
|
||||
Count = 229,
|
||||
>Count : SyntaxKind
|
||||
|
||||
FirstAssignment = 53,
|
||||
|
@ -1699,6 +1708,13 @@ declare module "typescript" {
|
|||
body?: Block;
|
||||
>body : Block
|
||||
>Block : Block
|
||||
}
|
||||
interface SemicolonClassElement extends ClassElement {
|
||||
>SemicolonClassElement : SemicolonClassElement
|
||||
>ClassElement : ClassElement
|
||||
|
||||
_semicolonClassElementBrand: any;
|
||||
>_semicolonClassElementBrand : any
|
||||
}
|
||||
interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
|
||||
>AccessorDeclaration : AccessorDeclaration
|
||||
|
@ -2100,6 +2116,19 @@ declare module "typescript" {
|
|||
>arguments : NodeArray<Expression>
|
||||
>NodeArray : NodeArray<T>
|
||||
>Expression : Expression
|
||||
}
|
||||
interface HeritageClauseElement extends Node {
|
||||
>HeritageClauseElement : HeritageClauseElement
|
||||
>Node : Node
|
||||
|
||||
expression: LeftHandSideExpression;
|
||||
>expression : LeftHandSideExpression
|
||||
>LeftHandSideExpression : LeftHandSideExpression
|
||||
|
||||
typeArguments?: NodeArray<TypeNode>;
|
||||
>typeArguments : NodeArray<TypeNode>
|
||||
>NodeArray : NodeArray<T>
|
||||
>TypeNode : TypeNode
|
||||
}
|
||||
interface NewExpression extends CallExpression, PrimaryExpression {
|
||||
>NewExpression : NewExpression
|
||||
|
@ -2384,10 +2413,9 @@ declare module "typescript" {
|
|||
_moduleElementBrand: any;
|
||||
>_moduleElementBrand : any
|
||||
}
|
||||
interface ClassDeclaration extends Declaration, ModuleElement {
|
||||
>ClassDeclaration : ClassDeclaration
|
||||
interface ClassLikeDeclaration extends Declaration {
|
||||
>ClassLikeDeclaration : ClassLikeDeclaration
|
||||
>Declaration : Declaration
|
||||
>ModuleElement : ModuleElement
|
||||
|
||||
name?: Identifier;
|
||||
>name : Identifier
|
||||
|
@ -2407,6 +2435,16 @@ declare module "typescript" {
|
|||
>members : NodeArray<ClassElement>
|
||||
>NodeArray : NodeArray<T>
|
||||
>ClassElement : ClassElement
|
||||
}
|
||||
interface ClassDeclaration extends ClassLikeDeclaration, Statement {
|
||||
>ClassDeclaration : ClassDeclaration
|
||||
>ClassLikeDeclaration : ClassLikeDeclaration
|
||||
>Statement : Statement
|
||||
}
|
||||
interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
|
||||
>ClassExpression : ClassExpression
|
||||
>ClassLikeDeclaration : ClassLikeDeclaration
|
||||
>PrimaryExpression : PrimaryExpression
|
||||
}
|
||||
interface ClassElement extends Declaration {
|
||||
>ClassElement : ClassElement
|
||||
|
@ -2447,10 +2485,10 @@ declare module "typescript" {
|
|||
>token : SyntaxKind
|
||||
>SyntaxKind : SyntaxKind
|
||||
|
||||
types?: NodeArray<TypeReferenceNode>;
|
||||
>types : NodeArray<TypeReferenceNode>
|
||||
types?: NodeArray<HeritageClauseElement>;
|
||||
>types : NodeArray<HeritageClauseElement>
|
||||
>NodeArray : NodeArray<T>
|
||||
>TypeReferenceNode : TypeReferenceNode
|
||||
>HeritageClauseElement : HeritageClauseElement
|
||||
}
|
||||
interface TypeAliasDeclaration extends Declaration, ModuleElement {
|
||||
>TypeAliasDeclaration : TypeAliasDeclaration
|
||||
|
@ -3394,10 +3432,11 @@ declare module "typescript" {
|
|||
>SymbolFlags : SymbolFlags
|
||||
>SymbolAccessiblityResult : SymbolAccessiblityResult
|
||||
|
||||
isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
>isEntityNameVisible : (entityName: Identifier | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
|
||||
>entityName : Identifier | QualifiedName
|
||||
isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
>isEntityNameVisible : (entityName: Identifier | Expression | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
|
||||
>entityName : Identifier | Expression | QualifiedName
|
||||
>EntityName : Identifier | QualifiedName
|
||||
>Expression : Expression
|
||||
>enclosingDeclaration : Node
|
||||
>Node : Node
|
||||
>SymbolVisibilityResult : SymbolVisibilityResult
|
||||
|
@ -4170,9 +4209,6 @@ declare module "typescript" {
|
|||
charset?: string;
|
||||
>charset : string
|
||||
|
||||
codepage?: number;
|
||||
>codepage : number
|
||||
|
||||
declaration?: boolean;
|
||||
>declaration : boolean
|
||||
|
||||
|
@ -4213,9 +4249,6 @@ declare module "typescript" {
|
|||
noLib?: boolean;
|
||||
>noLib : boolean
|
||||
|
||||
noLibCheck?: boolean;
|
||||
>noLibCheck : boolean
|
||||
|
||||
noResolve?: boolean;
|
||||
>noResolve : boolean
|
||||
|
||||
|
@ -4253,6 +4286,9 @@ declare module "typescript" {
|
|||
watch?: boolean;
|
||||
>watch : boolean
|
||||
|
||||
separateCompilation?: boolean;
|
||||
>separateCompilation : boolean
|
||||
|
||||
[option: string]: string | number | boolean;
|
||||
>option : string
|
||||
}
|
||||
|
@ -5071,6 +5107,27 @@ declare module "typescript" {
|
|||
>CompilerHost : CompilerHost
|
||||
>Program : Program
|
||||
}
|
||||
declare module "typescript" {
|
||||
/**
|
||||
* Read tsconfig.json file
|
||||
* @param fileName The path to the config file
|
||||
*/
|
||||
function readConfigFile(fileName: string): any;
|
||||
>readConfigFile : (fileName: string) => any
|
||||
>fileName : string
|
||||
|
||||
/**
|
||||
* Parse the contents of a config file (tsconfig.json).
|
||||
* @param json The contents of the config file to parse
|
||||
* @param basePath A root directory to resolve relative path entries in the config
|
||||
* file to. e.g. outDir
|
||||
*/
|
||||
function parseConfigFile(json: any, basePath?: string): ParsedCommandLine;
|
||||
>parseConfigFile : (json: any, basePath?: string) => ParsedCommandLine
|
||||
>json : any
|
||||
>basePath : string
|
||||
>ParsedCommandLine : ParsedCommandLine
|
||||
}
|
||||
declare module "typescript" {
|
||||
/** The version of the language service API */
|
||||
let servicesVersion: string;
|
||||
|
@ -6429,6 +6486,15 @@ declare module "typescript" {
|
|||
throwIfCancellationRequested(): void;
|
||||
>throwIfCancellationRequested : () => void
|
||||
}
|
||||
function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]): string;
|
||||
>transpile : (input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[]) => string
|
||||
>input : string
|
||||
>compilerOptions : CompilerOptions
|
||||
>CompilerOptions : CompilerOptions
|
||||
>fileName : string
|
||||
>diagnostics : Diagnostic[]
|
||||
>Diagnostic : Diagnostic
|
||||
|
||||
function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
|
||||
>createLanguageServiceSourceFile : (fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean) => SourceFile
|
||||
>fileName : string
|
||||
|
|
|
@ -52,7 +52,7 @@ import Backbone = require("aliasUsage1_backbone");
|
|||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
|
||||
// interesting stuff here
|
||||
|
|
|
@ -40,7 +40,7 @@ import Backbone = require("aliasUsageInArray_backbone");
|
|||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
|
||||
// interesting stuff here
|
||||
|
|
|
@ -41,7 +41,7 @@ import Backbone = require("aliasUsageInFunctionExpression_backbone");
|
|||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
|
||||
// interesting stuff here
|
||||
|
|
|
@ -55,7 +55,7 @@ import Backbone = require("aliasUsageInGenericFunction_backbone");
|
|||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
|
||||
// interesting stuff here
|
||||
|
|
|
@ -49,7 +49,7 @@ import Backbone = require("aliasUsageInIndexerOfClass_backbone");
|
|||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
|
||||
// interesting stuff here
|
||||
|
|
|
@ -54,7 +54,7 @@ import Backbone = require("aliasUsageInObjectLiteral_backbone");
|
|||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
|
||||
// interesting stuff here
|
||||
|
|
|
@ -75,7 +75,7 @@ import Backbone = require("aliasUsageInOrExpression_backbone");
|
|||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
|
||||
// interesting stuff here
|
||||
|
|
|
@ -75,7 +75,7 @@ import Backbone = require("aliasUsageInOrExpression_backbone");
|
|||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
|
||||
// interesting stuff here
|
||||
|
|
|
@ -45,7 +45,7 @@ import Backbone = require("aliasUsageInTypeArgumentOfExtendsClause_backbone");
|
|||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
|
||||
// interesting stuff here
|
||||
|
|
|
@ -36,7 +36,7 @@ import Backbone = require("aliasUsageInVarAssignment_backbone");
|
|||
|
||||
export class VisualizationModel extends Backbone.Model {
|
||||
>VisualizationModel : VisualizationModel
|
||||
>Backbone : unknown
|
||||
>Backbone : typeof Backbone
|
||||
>Model : Backbone.Model
|
||||
|
||||
// interesting stuff here
|
||||
|
|
|
@ -10,7 +10,7 @@ module B {
|
|||
|
||||
export class D extends a.C {
|
||||
>D : D
|
||||
>a : unknown
|
||||
>a : typeof a
|
||||
>C : a.C
|
||||
|
||||
id: number;
|
||||
|
|
|
@ -18,7 +18,7 @@ module M {
|
|||
|
||||
export class O extends M.N {
|
||||
>O : O
|
||||
>M : unknown
|
||||
>M : typeof M
|
||||
>N : N
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,36 +1,24 @@
|
|||
tests/cases/conformance/classes/classExpression.ts(1,9): error TS1109: Expression expected.
|
||||
tests/cases/conformance/classes/classExpression.ts(5,10): error TS1109: Expression expected.
|
||||
tests/cases/conformance/classes/classExpression.ts(5,16): error TS1005: ':' expected.
|
||||
tests/cases/conformance/classes/classExpression.ts(5,16): error TS2304: Cannot find name 'C2'.
|
||||
tests/cases/conformance/classes/classExpression.ts(5,19): error TS1005: ',' expected.
|
||||
tests/cases/conformance/classes/classExpression.ts(7,1): error TS1128: Declaration or statement expected.
|
||||
tests/cases/conformance/classes/classExpression.ts(10,13): error TS1109: Expression expected.
|
||||
tests/cases/conformance/classes/classExpression.ts(1,15): error TS9003: 'class' expressions are not currently supported.
|
||||
tests/cases/conformance/classes/classExpression.ts(5,16): error TS9003: 'class' expressions are not currently supported.
|
||||
tests/cases/conformance/classes/classExpression.ts(10,19): error TS9003: 'class' expressions are not currently supported.
|
||||
|
||||
|
||||
==== tests/cases/conformance/classes/classExpression.ts (7 errors) ====
|
||||
==== tests/cases/conformance/classes/classExpression.ts (3 errors) ====
|
||||
var x = class C {
|
||||
~~~~~
|
||||
!!! error TS1109: Expression expected.
|
||||
~
|
||||
!!! error TS9003: 'class' expressions are not currently supported.
|
||||
}
|
||||
|
||||
var y = {
|
||||
foo: class C2 {
|
||||
~~~~~
|
||||
!!! error TS1109: Expression expected.
|
||||
~~
|
||||
!!! error TS1005: ':' expected.
|
||||
~~
|
||||
!!! error TS2304: Cannot find name 'C2'.
|
||||
~
|
||||
!!! error TS1005: ',' expected.
|
||||
!!! error TS9003: 'class' expressions are not currently supported.
|
||||
}
|
||||
}
|
||||
~
|
||||
!!! error TS1128: Declaration or statement expected.
|
||||
|
||||
module M {
|
||||
var z = class C4 {
|
||||
~~~~~
|
||||
!!! error TS1109: Expression expected.
|
||||
~~
|
||||
!!! error TS9003: 'class' expressions are not currently supported.
|
||||
}
|
||||
}
|
|
@ -13,18 +13,21 @@ module M {
|
|||
}
|
||||
|
||||
//// [classExpression.js]
|
||||
var x = ;
|
||||
var C = (function () {
|
||||
var x = (function () {
|
||||
function C() {
|
||||
}
|
||||
return C;
|
||||
})();
|
||||
var y = {
|
||||
foo: , class: C2 }, _a = void 0;
|
||||
foo: (function () {
|
||||
function C2() {
|
||||
}
|
||||
return C2;
|
||||
})()
|
||||
};
|
||||
var M;
|
||||
(function (M) {
|
||||
var z = ;
|
||||
var C4 = (function () {
|
||||
var z = (function () {
|
||||
function C4() {
|
||||
}
|
||||
return C4;
|
||||
|
|
7
tests/baselines/reference/classExpression1.errors.txt
Normal file
7
tests/baselines/reference/classExpression1.errors.txt
Normal file
|
@ -0,0 +1,7 @@
|
|||
tests/cases/conformance/classes/classExpressions/classExpression1.ts(1,15): error TS9003: 'class' expressions are not currently supported.
|
||||
|
||||
|
||||
==== tests/cases/conformance/classes/classExpressions/classExpression1.ts (1 errors) ====
|
||||
var v = class C {};
|
||||
~
|
||||
!!! error TS9003: 'class' expressions are not currently supported.
|
9
tests/baselines/reference/classExpression1.js
Normal file
9
tests/baselines/reference/classExpression1.js
Normal file
|
@ -0,0 +1,9 @@
|
|||
//// [classExpression1.ts]
|
||||
var v = class C {};
|
||||
|
||||
//// [classExpression1.js]
|
||||
var v = (function () {
|
||||
function C() {
|
||||
}
|
||||
return C;
|
||||
})();
|
8
tests/baselines/reference/classExpression2.errors.txt
Normal file
8
tests/baselines/reference/classExpression2.errors.txt
Normal file
|
@ -0,0 +1,8 @@
|
|||
tests/cases/conformance/classes/classExpressions/classExpression2.ts(2,15): error TS9003: 'class' expressions are not currently supported.
|
||||
|
||||
|
||||
==== tests/cases/conformance/classes/classExpressions/classExpression2.ts (1 errors) ====
|
||||
class D { }
|
||||
var v = class C extends D {};
|
||||
~
|
||||
!!! error TS9003: 'class' expressions are not currently supported.
|
17
tests/baselines/reference/classExpression2.js
Normal file
17
tests/baselines/reference/classExpression2.js
Normal file
|
@ -0,0 +1,17 @@
|
|||
//// [classExpression2.ts]
|
||||
class D { }
|
||||
var v = class C extends D {};
|
||||
|
||||
//// [classExpression2.js]
|
||||
var D = (function () {
|
||||
function D() {
|
||||
}
|
||||
return D;
|
||||
})();
|
||||
var v = (function (_super) {
|
||||
__extends(C, _super);
|
||||
function C() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return C;
|
||||
})(D);
|
7
tests/baselines/reference/classExpressionES61.errors.txt
Normal file
7
tests/baselines/reference/classExpressionES61.errors.txt
Normal file
|
@ -0,0 +1,7 @@
|
|||
tests/cases/conformance/es6/classExpressions/classExpressionES61.ts(1,15): error TS9003: 'class' expressions are not currently supported.
|
||||
|
||||
|
||||
==== tests/cases/conformance/es6/classExpressions/classExpressionES61.ts (1 errors) ====
|
||||
var v = class C {};
|
||||
~
|
||||
!!! error TS9003: 'class' expressions are not currently supported.
|
7
tests/baselines/reference/classExpressionES61.js
Normal file
7
tests/baselines/reference/classExpressionES61.js
Normal file
|
@ -0,0 +1,7 @@
|
|||
//// [classExpressionES61.ts]
|
||||
var v = class C {};
|
||||
|
||||
//// [classExpressionES61.js]
|
||||
var v = class C {
|
||||
}
|
||||
;
|
8
tests/baselines/reference/classExpressionES62.errors.txt
Normal file
8
tests/baselines/reference/classExpressionES62.errors.txt
Normal file
|
@ -0,0 +1,8 @@
|
|||
tests/cases/conformance/es6/classExpressions/classExpressionES62.ts(2,15): error TS9003: 'class' expressions are not currently supported.
|
||||
|
||||
|
||||
==== tests/cases/conformance/es6/classExpressions/classExpressionES62.ts (1 errors) ====
|
||||
class D { }
|
||||
var v = class C extends D {};
|
||||
~
|
||||
!!! error TS9003: 'class' expressions are not currently supported.
|
10
tests/baselines/reference/classExpressionES62.js
Normal file
10
tests/baselines/reference/classExpressionES62.js
Normal file
|
@ -0,0 +1,10 @@
|
|||
//// [classExpressionES62.ts]
|
||||
class D { }
|
||||
var v = class C extends D {};
|
||||
|
||||
//// [classExpressionES62.js]
|
||||
class D {
|
||||
}
|
||||
var v = class C extends D {
|
||||
}
|
||||
;
|
18
tests/baselines/reference/classExpressionTest1.errors.txt
Normal file
18
tests/baselines/reference/classExpressionTest1.errors.txt
Normal file
|
@ -0,0 +1,18 @@
|
|||
tests/cases/compiler/classExpressionTest1.ts(2,11): error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
|
||||
|
||||
|
||||
==== tests/cases/compiler/classExpressionTest1.ts (1 errors) ====
|
||||
function M() {
|
||||
class C<X> {
|
||||
~
|
||||
!!! error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
|
||||
f<T>() {
|
||||
var t: T;
|
||||
var x: X;
|
||||
return { t, x };
|
||||
}
|
||||
}
|
||||
|
||||
var v = new C<number>();
|
||||
return v.f<string>();
|
||||
}
|
29
tests/baselines/reference/classExpressionTest1.js
Normal file
29
tests/baselines/reference/classExpressionTest1.js
Normal file
|
@ -0,0 +1,29 @@
|
|||
//// [classExpressionTest1.ts]
|
||||
function M() {
|
||||
class C<X> {
|
||||
f<T>() {
|
||||
var t: T;
|
||||
var x: X;
|
||||
return { t, x };
|
||||
}
|
||||
}
|
||||
|
||||
var v = new C<number>();
|
||||
return v.f<string>();
|
||||
}
|
||||
|
||||
//// [classExpressionTest1.js]
|
||||
function M() {
|
||||
var C = (function () {
|
||||
function C() {
|
||||
}
|
||||
C.prototype.f = function () {
|
||||
var t;
|
||||
var x;
|
||||
return { t: t, x: x };
|
||||
};
|
||||
return C;
|
||||
})();
|
||||
var v = new C();
|
||||
return v.f();
|
||||
}
|
21
tests/baselines/reference/classExpressionTest2.errors.txt
Normal file
21
tests/baselines/reference/classExpressionTest2.errors.txt
Normal file
|
@ -0,0 +1,21 @@
|
|||
tests/cases/compiler/classExpressionTest2.ts(2,19): error TS9003: 'class' expressions are not currently supported.
|
||||
tests/cases/compiler/classExpressionTest2.ts(5,20): error TS2304: Cannot find name 'X'.
|
||||
|
||||
|
||||
==== tests/cases/compiler/classExpressionTest2.ts (2 errors) ====
|
||||
function M() {
|
||||
var m = class C<X> {
|
||||
~
|
||||
!!! error TS9003: 'class' expressions are not currently supported.
|
||||
f<T>() {
|
||||
var t: T;
|
||||
var x: X;
|
||||
~
|
||||
!!! error TS2304: Cannot find name 'X'.
|
||||
return { t, x };
|
||||
}
|
||||
}
|
||||
|
||||
var v = new m<number>();
|
||||
return v.f<string>();
|
||||
}
|
29
tests/baselines/reference/classExpressionTest2.js
Normal file
29
tests/baselines/reference/classExpressionTest2.js
Normal file
|
@ -0,0 +1,29 @@
|
|||
//// [classExpressionTest2.ts]
|
||||
function M() {
|
||||
var m = class C<X> {
|
||||
f<T>() {
|
||||
var t: T;
|
||||
var x: X;
|
||||
return { t, x };
|
||||
}
|
||||
}
|
||||
|
||||
var v = new m<number>();
|
||||
return v.f<string>();
|
||||
}
|
||||
|
||||
//// [classExpressionTest2.js]
|
||||
function M() {
|
||||
var m = (function () {
|
||||
function C() {
|
||||
}
|
||||
C.prototype.f = function () {
|
||||
var t;
|
||||
var x;
|
||||
return { t: t, x: x };
|
||||
};
|
||||
return C;
|
||||
})();
|
||||
var v = new m();
|
||||
return v.f();
|
||||
}
|
|
@ -2,16 +2,15 @@ tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/cla
|
|||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(4,18): error TS2304: Cannot find name 'string'.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(5,18): error TS2304: Cannot find name 'boolean'.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(6,18): error TS2304: Cannot find name 'Void'.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(7,19): error TS1133: Type reference expected.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(7,19): error TS1109: Expression expected.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(8,18): error TS2304: Cannot find name 'Null'.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(9,19): error TS1133: Type reference expected.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(9,24): error TS1005: ';' expected.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(9,19): error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(10,18): error TS2304: Cannot find name 'undefined'.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(11,18): error TS2304: Cannot find name 'Undefined'.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(14,18): error TS2311: A class may only extend another class.
|
||||
|
||||
|
||||
==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts (11 errors) ====
|
||||
==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts (10 errors) ====
|
||||
// classes cannot extend primitives
|
||||
|
||||
class C extends number { }
|
||||
|
@ -28,15 +27,13 @@ tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/cla
|
|||
!!! error TS2304: Cannot find name 'Void'.
|
||||
class C4a extends void {}
|
||||
~~~~
|
||||
!!! error TS1133: Type reference expected.
|
||||
!!! error TS1109: Expression expected.
|
||||
class C5 extends Null { }
|
||||
~~~~
|
||||
!!! error TS2304: Cannot find name 'Null'.
|
||||
class C5a extends null { }
|
||||
~~~~
|
||||
!!! error TS1133: Type reference expected.
|
||||
~
|
||||
!!! error TS1005: ';' expected.
|
||||
!!! error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
|
||||
class C6 extends undefined { }
|
||||
~~~~~~~~~
|
||||
!!! error TS2304: Cannot find name 'undefined'.
|
||||
|
|
|
@ -63,13 +63,13 @@ var C5 = (function (_super) {
|
|||
}
|
||||
return C5;
|
||||
})(Null);
|
||||
var C5a = (function () {
|
||||
var C5a = (function (_super) {
|
||||
__extends(C5a, _super);
|
||||
function C5a() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return C5a;
|
||||
})();
|
||||
null;
|
||||
{ }
|
||||
})(null);
|
||||
var C6 = (function (_super) {
|
||||
__extends(C6, _super);
|
||||
function C6() {
|
||||
|
|
|
@ -1,16 +1,13 @@
|
|||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive2.ts(3,19): error TS1133: Type reference expected.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive2.ts(4,19): error TS1133: Type reference expected.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive2.ts(4,24): error TS1005: ';' expected.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive2.ts(3,19): error TS1109: Expression expected.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive2.ts(4,19): error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
|
||||
|
||||
|
||||
==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive2.ts (3 errors) ====
|
||||
==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive2.ts (2 errors) ====
|
||||
// classes cannot extend primitives
|
||||
|
||||
class C4a extends void {}
|
||||
~~~~
|
||||
!!! error TS1133: Type reference expected.
|
||||
!!! error TS1109: Expression expected.
|
||||
class C5a extends null { }
|
||||
~~~~
|
||||
!!! error TS1133: Type reference expected.
|
||||
~
|
||||
!!! error TS1005: ';' expected.
|
||||
!!! error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
|
|
@ -6,16 +6,22 @@ class C5a extends null { }
|
|||
|
||||
//// [classExtendingPrimitive2.js]
|
||||
// classes cannot extend primitives
|
||||
var __extends = this.__extends || function (d, b) {
|
||||
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
|
||||
function __() { this.constructor = d; }
|
||||
__.prototype = b.prototype;
|
||||
d.prototype = new __();
|
||||
};
|
||||
var C4a = (function () {
|
||||
function C4a() {
|
||||
}
|
||||
return C4a;
|
||||
})();
|
||||
void {};
|
||||
var C5a = (function () {
|
||||
var C5a = (function (_super) {
|
||||
__extends(C5a, _super);
|
||||
function C5a() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return C5a;
|
||||
})();
|
||||
null;
|
||||
{ }
|
||||
})(null);
|
||||
|
|
|
@ -8,7 +8,7 @@ module M {
|
|||
|
||||
class D extends M.C {
|
||||
>D : D
|
||||
>M : unknown
|
||||
>M : typeof M
|
||||
>C : C
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,12 +1,13 @@
|
|||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(4,17): error TS2311: A class may only extend another class.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(6,18): error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(6,31): error TS1005: ',' expected.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(8,18): error TS2304: Cannot find name 'x'.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(11,18): error TS2304: Cannot find name 'M'.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(14,18): error TS2304: Cannot find name 'foo'.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(16,18): error TS1133: Type reference expected.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(16,20): error TS1005: ';' expected.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(16,18): error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
|
||||
|
||||
|
||||
==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts (6 errors) ====
|
||||
==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts (7 errors) ====
|
||||
interface I {
|
||||
foo: string;
|
||||
}
|
||||
|
@ -15,6 +16,10 @@ tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/cla
|
|||
!!! error TS2311: A class may only extend another class.
|
||||
|
||||
class C2 extends { foo: string; } { } // error
|
||||
~~~~~~~~~~~~~~~~
|
||||
!!! error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
|
||||
~
|
||||
!!! error TS1005: ',' expected.
|
||||
var x: { foo: string; }
|
||||
class C3 extends x { } // error
|
||||
~
|
||||
|
@ -31,7 +36,5 @@ tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/cla
|
|||
!!! error TS2304: Cannot find name 'foo'.
|
||||
|
||||
class C6 extends []{ } // error
|
||||
~
|
||||
!!! error TS1133: Type reference expected.
|
||||
~
|
||||
!!! error TS1005: ';' expected.
|
||||
~~
|
||||
!!! error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
|
|
@ -30,12 +30,13 @@ var C = (function (_super) {
|
|||
}
|
||||
return C;
|
||||
})(I); // error
|
||||
var C2 = (function () {
|
||||
var C2 = (function (_super) {
|
||||
__extends(C2, _super);
|
||||
function C2() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return C2;
|
||||
})();
|
||||
{ } // error
|
||||
})({ foo: string }); // error
|
||||
var x;
|
||||
var C3 = (function (_super) {
|
||||
__extends(C3, _super);
|
||||
|
@ -63,10 +64,10 @@ var C5 = (function (_super) {
|
|||
}
|
||||
return C5;
|
||||
})(foo); // error
|
||||
var C6 = (function () {
|
||||
var C6 = (function (_super) {
|
||||
__extends(C6, _super);
|
||||
function C6() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return C6;
|
||||
})();
|
||||
[];
|
||||
{ } // error
|
||||
})([]); // error
|
||||
|
|
|
@ -1,12 +1,15 @@
|
|||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType2.ts(3,18): error TS1133: Type reference expected.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType2.ts(3,20): error TS1005: ';' expected.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType2.ts(1,18): error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType2.ts(1,31): error TS1005: ',' expected.
|
||||
tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType2.ts(3,18): error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
|
||||
|
||||
|
||||
==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType2.ts (2 errors) ====
|
||||
==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType2.ts (3 errors) ====
|
||||
class C2 extends { foo: string; } { } // error
|
||||
~~~~~~~~~~~~~~~~
|
||||
!!! error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
|
||||
~
|
||||
!!! error TS1005: ',' expected.
|
||||
|
||||
class C6 extends []{ } // error
|
||||
~
|
||||
!!! error TS1133: Type reference expected.
|
||||
~
|
||||
!!! error TS1005: ';' expected.
|
||||
~~
|
||||
!!! error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
|
|
@ -4,16 +4,23 @@ class C2 extends { foo: string; } { } // error
|
|||
class C6 extends []{ } // error
|
||||
|
||||
//// [classExtendsEveryObjectType2.js]
|
||||
var C2 = (function () {
|
||||
var __extends = this.__extends || function (d, b) {
|
||||
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
|
||||
function __() { this.constructor = d; }
|
||||
__.prototype = b.prototype;
|
||||
d.prototype = new __();
|
||||
};
|
||||
var C2 = (function (_super) {
|
||||
__extends(C2, _super);
|
||||
function C2() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return C2;
|
||||
})();
|
||||
{ } // error
|
||||
var C6 = (function () {
|
||||
})({ foo: string }); // error
|
||||
var C6 = (function (_super) {
|
||||
__extends(C6, _super);
|
||||
function C6() {
|
||||
_super.apply(this, arguments);
|
||||
}
|
||||
return C6;
|
||||
})();
|
||||
[];
|
||||
{ } // error
|
||||
})([]); // error
|
||||
|
|
9
tests/baselines/reference/classInsideBlock.errors.txt
Normal file
9
tests/baselines/reference/classInsideBlock.errors.txt
Normal file
|
@ -0,0 +1,9 @@
|
|||
tests/cases/conformance/classes/classDeclarations/classInsideBlock.ts(2,11): error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
|
||||
|
||||
|
||||
==== tests/cases/conformance/classes/classDeclarations/classInsideBlock.ts (1 errors) ====
|
||||
function foo() {
|
||||
class C { }
|
||||
~
|
||||
!!! error TS9004: 'class' declarations are only supported directly inside a module or as a top level declaration.
|
||||
}
|
13
tests/baselines/reference/classInsideBlock.js
Normal file
13
tests/baselines/reference/classInsideBlock.js
Normal file
|
@ -0,0 +1,13 @@
|
|||
//// [classInsideBlock.ts]
|
||||
function foo() {
|
||||
class C { }
|
||||
}
|
||||
|
||||
//// [classInsideBlock.js]
|
||||
function foo() {
|
||||
var C = (function () {
|
||||
function C() {
|
||||
}
|
||||
return C;
|
||||
})();
|
||||
}
|
12
tests/baselines/reference/classWithSemicolonClassElement1.js
Normal file
12
tests/baselines/reference/classWithSemicolonClassElement1.js
Normal file
|
@ -0,0 +1,12 @@
|
|||
//// [classWithSemicolonClassElement1.ts]
|
||||
class C {
|
||||
;
|
||||
}
|
||||
|
||||
//// [classWithSemicolonClassElement1.js]
|
||||
var C = (function () {
|
||||
function C() {
|
||||
}
|
||||
;
|
||||
return C;
|
||||
})();
|
|
@ -0,0 +1,6 @@
|
|||
=== tests/cases/conformance/classes/classDeclarations/classWithSemicolonClassElement1.ts ===
|
||||
class C {
|
||||
>C : C
|
||||
|
||||
;
|
||||
}
|
14
tests/baselines/reference/classWithSemicolonClassElement2.js
Normal file
14
tests/baselines/reference/classWithSemicolonClassElement2.js
Normal file
|
@ -0,0 +1,14 @@
|
|||
//// [classWithSemicolonClassElement2.ts]
|
||||
class C {
|
||||
;
|
||||
;
|
||||
}
|
||||
|
||||
//// [classWithSemicolonClassElement2.js]
|
||||
var C = (function () {
|
||||
function C() {
|
||||
}
|
||||
;
|
||||
;
|
||||
return C;
|
||||
})();
|
|
@ -0,0 +1,7 @@
|
|||
=== tests/cases/conformance/classes/classDeclarations/classWithSemicolonClassElement2.ts ===
|
||||
class C {
|
||||
>C : C
|
||||
|
||||
;
|
||||
;
|
||||
}
|
|
@ -0,0 +1,9 @@
|
|||
//// [classWithSemicolonClassElementES61.ts]
|
||||
class C {
|
||||
;
|
||||
}
|
||||
|
||||
//// [classWithSemicolonClassElementES61.js]
|
||||
class C {
|
||||
;
|
||||
}
|
|
@ -0,0 +1,6 @@
|
|||
=== tests/cases/conformance/es6/classDeclaration/classWithSemicolonClassElementES61.ts ===
|
||||
class C {
|
||||
>C : C
|
||||
|
||||
;
|
||||
}
|
|
@ -0,0 +1,11 @@
|
|||
//// [classWithSemicolonClassElementES62.ts]
|
||||
class C {
|
||||
;
|
||||
;
|
||||
}
|
||||
|
||||
//// [classWithSemicolonClassElementES62.js]
|
||||
class C {
|
||||
;
|
||||
;
|
||||
}
|
|
@ -0,0 +1,7 @@
|
|||
=== tests/cases/conformance/es6/classDeclaration/classWithSemicolonClassElementES62.ts ===
|
||||
class C {
|
||||
>C : C
|
||||
|
||||
;
|
||||
;
|
||||
}
|
|
@ -5,7 +5,7 @@ declare module E {
|
|||
|
||||
class foobar extends D.bar {
|
||||
>foobar : foobar
|
||||
>D : unknown
|
||||
>D : typeof D
|
||||
>bar : D.bar
|
||||
|
||||
foo();
|
||||
|
|
|
@ -147,14 +147,14 @@ export var g = C.F5<C.A<C.B>>();
|
|||
|
||||
export class h extends C.A<C.B>{ }
|
||||
>h : h
|
||||
>C : unknown
|
||||
>C : typeof C
|
||||
>A : C.A<T>
|
||||
>C : unknown
|
||||
>B : C.B
|
||||
|
||||
export interface i extends C.A<C.B> { }
|
||||
>i : i
|
||||
>C : unknown
|
||||
>C : typeof C
|
||||
>A : C.A<T>
|
||||
>C : unknown
|
||||
>B : C.B
|
||||
|
|
|
@ -30,7 +30,7 @@ declare module templa.mvc {
|
|||
>templa : unknown
|
||||
>mvc : unknown
|
||||
>IModel : IModel
|
||||
>mvc : unknown
|
||||
>mvc : typeof mvc
|
||||
>IController : IController<ModelType>
|
||||
>ModelType : ModelType
|
||||
}
|
||||
|
@ -42,7 +42,7 @@ declare module templa.mvc.composite {
|
|||
|
||||
interface ICompositeControllerModel extends mvc.IModel {
|
||||
>ICompositeControllerModel : ICompositeControllerModel
|
||||
>mvc : unknown
|
||||
>mvc : typeof mvc
|
||||
>IModel : IModel
|
||||
|
||||
getControllers(): mvc.IController<mvc.IModel>[];
|
||||
|
@ -64,8 +64,8 @@ module templa.dom.mvc {
|
|||
>templa : unknown
|
||||
>mvc : unknown
|
||||
>IModel : templa.mvc.IModel
|
||||
>templa : unknown
|
||||
>mvc : unknown
|
||||
>templa : typeof templa
|
||||
>mvc : typeof templa.mvc
|
||||
>IController : templa.mvc.IController<ModelType>
|
||||
>ModelType : ModelType
|
||||
}
|
||||
|
@ -82,8 +82,8 @@ module templa.dom.mvc {
|
|||
>templa : unknown
|
||||
>mvc : unknown
|
||||
>IModel : templa.mvc.IModel
|
||||
>templa : unknown
|
||||
>mvc : unknown
|
||||
>templa : typeof templa
|
||||
>mvc : typeof templa.mvc
|
||||
>AbstractController : templa.mvc.AbstractController<ModelType>
|
||||
>ModelType : ModelType
|
||||
>IElementController : IElementController<ModelType>
|
||||
|
@ -110,9 +110,9 @@ module templa.dom.mvc.composite {
|
|||
>mvc : unknown
|
||||
>composite : unknown
|
||||
>ICompositeControllerModel : templa.mvc.composite.ICompositeControllerModel
|
||||
>templa : unknown
|
||||
>dom : unknown
|
||||
>mvc : unknown
|
||||
>templa : typeof templa
|
||||
>dom : typeof dom
|
||||
>mvc : typeof mvc
|
||||
>AbstractElementController : AbstractElementController<ModelType>
|
||||
>ModelType : ModelType
|
||||
|
||||
|
|
|
@ -42,23 +42,23 @@ module m2 {
|
|||
|
||||
}
|
||||
var m2: {
|
||||
>m2 : { (): export=.connectExport; test1: export=.connectModule; test2(): export=.connectModule; }
|
||||
>m2 : { (): m2.connectExport; test1: m2.connectModule; test2(): m2.connectModule; }
|
||||
|
||||
(): m2.connectExport;
|
||||
>m2 : unknown
|
||||
>connectExport : export=.connectExport
|
||||
>connectExport : m2.connectExport
|
||||
|
||||
test1: m2.connectModule;
|
||||
>test1 : export=.connectModule
|
||||
>test1 : m2.connectModule
|
||||
>m2 : unknown
|
||||
>connectModule : export=.connectModule
|
||||
>connectModule : m2.connectModule
|
||||
|
||||
test2(): m2.connectModule;
|
||||
>test2 : () => export=.connectModule
|
||||
>test2 : () => m2.connectModule
|
||||
>m2 : unknown
|
||||
>connectModule : export=.connectModule
|
||||
>connectModule : m2.connectModule
|
||||
|
||||
};
|
||||
export = m2;
|
||||
>m2 : { (): export=.connectExport; test1: export=.connectModule; test2(): export=.connectModule; }
|
||||
>m2 : { (): m2.connectExport; test1: m2.connectModule; test2(): m2.connectModule; }
|
||||
|
||||
|
|
|
@ -15,7 +15,7 @@ module A.B.C {
|
|||
|
||||
export class W implements A.C.Z {
|
||||
>W : W
|
||||
>A : unknown
|
||||
>A : typeof A
|
||||
>C : unknown
|
||||
>Z : A.C.Z
|
||||
}
|
||||
|
|
|
@ -19,9 +19,9 @@ module X.Y.base {
|
|||
|
||||
export class W extends A.B.Base.W {
|
||||
>W : W
|
||||
>A : unknown
|
||||
>B : unknown
|
||||
>Base : unknown
|
||||
>A : typeof A
|
||||
>B : typeof A.B
|
||||
>Base : typeof A.B.Base
|
||||
>W : A.B.Base.W
|
||||
|
||||
name: string;
|
||||
|
@ -38,9 +38,9 @@ module X.Y.base.Z {
|
|||
export class W<TValue> extends X.Y.base.W {
|
||||
>W : W<TValue>
|
||||
>TValue : TValue
|
||||
>X : unknown
|
||||
>Y : unknown
|
||||
>base : unknown
|
||||
>X : typeof X
|
||||
>Y : typeof Y
|
||||
>base : typeof base
|
||||
>W : base.W
|
||||
|
||||
value: boolean;
|
||||
|
|
|
@ -20,8 +20,8 @@ module X.A.B.C {
|
|||
}
|
||||
export class W implements X.A.C.Z { // This needs to be refered as X.A.C.Z as A has conflict
|
||||
>W : W
|
||||
>X : unknown
|
||||
>A : unknown
|
||||
>X : typeof X
|
||||
>A : typeof A
|
||||
>C : unknown
|
||||
>Z : X.A.C.Z
|
||||
}
|
||||
|
|
|
@ -17,7 +17,7 @@ module X.A.B.C {
|
|||
|
||||
export class W implements A.C.Z { // This can refer to it as A.C.Z
|
||||
>W : W
|
||||
>A : unknown
|
||||
>A : typeof A
|
||||
>C : unknown
|
||||
>Z : A.C.Z
|
||||
}
|
||||
|
|
|
@ -17,8 +17,8 @@ module X.A.B.C {
|
|||
|
||||
export class W implements X.A.C.Z { // This needs to be refered as X.A.C.Z as A has conflict
|
||||
>W : W
|
||||
>X : unknown
|
||||
>A : unknown
|
||||
>X : typeof X
|
||||
>A : typeof A
|
||||
>C : unknown
|
||||
>Z : X.A.C.Z
|
||||
}
|
||||
|
|
37
tests/baselines/reference/declarationEmitDestructuring1.js
Normal file
37
tests/baselines/reference/declarationEmitDestructuring1.js
Normal file
|
@ -0,0 +1,37 @@
|
|||
//// [declarationEmitDestructuring1.ts]
|
||||
function foo([a, b, c]: [string, string, string]): void { }
|
||||
function far([a, [b], [[c]]]: [number, boolean[], string[][]]): void { }
|
||||
function bar({a1, b1, c1}: { a1: number, b1: boolean, c1: string }): void { }
|
||||
function baz({a2, b2: {b1, c1}}: { a2: number, b2: { b1: boolean, c1: string } }): void { }
|
||||
|
||||
|
||||
//// [declarationEmitDestructuring1.js]
|
||||
function foo(_a) {
|
||||
var a = _a[0], b = _a[1], c = _a[2];
|
||||
}
|
||||
function far(_a) {
|
||||
var a = _a[0], b = _a[1][0], c = _a[2][0][0];
|
||||
}
|
||||
function bar(_a) {
|
||||
var a1 = _a.a1, b1 = _a.b1, c1 = _a.c1;
|
||||
}
|
||||
function baz(_a) {
|
||||
var a2 = _a.a2, _b = _a.b2, b1 = _b.b1, c1 = _b.c1;
|
||||
}
|
||||
|
||||
|
||||
//// [declarationEmitDestructuring1.d.ts]
|
||||
declare function foo([a, b, c]: [string, string, string]): void;
|
||||
declare function far([a, [b], [[c]]]: [number, boolean[], string[][]]): void;
|
||||
declare function bar({a1, b1, c1}: {
|
||||
a1: number;
|
||||
b1: boolean;
|
||||
c1: string;
|
||||
}): void;
|
||||
declare function baz({a2, b2: {b1, c1}}: {
|
||||
a2: number;
|
||||
b2: {
|
||||
b1: boolean;
|
||||
c1: string;
|
||||
};
|
||||
}): void;
|
|
@ -0,0 +1,33 @@
|
|||
=== tests/cases/compiler/declarationEmitDestructuring1.ts ===
|
||||
function foo([a, b, c]: [string, string, string]): void { }
|
||||
>foo : ([a, b, c]: [string, string, string]) => void
|
||||
>a : string
|
||||
>b : string
|
||||
>c : string
|
||||
|
||||
function far([a, [b], [[c]]]: [number, boolean[], string[][]]): void { }
|
||||
>far : ([a, [b], [[c]]]: [number, boolean[], string[][]]) => void
|
||||
>a : number
|
||||
>b : boolean
|
||||
>c : string
|
||||
|
||||
function bar({a1, b1, c1}: { a1: number, b1: boolean, c1: string }): void { }
|
||||
>bar : ({a1, b1, c1}: { a1: number; b1: boolean; c1: string; }) => void
|
||||
>a1 : number
|
||||
>b1 : boolean
|
||||
>c1 : string
|
||||
>a1 : number
|
||||
>b1 : boolean
|
||||
>c1 : string
|
||||
|
||||
function baz({a2, b2: {b1, c1}}: { a2: number, b2: { b1: boolean, c1: string } }): void { }
|
||||
>baz : ({a2, b2: {b1, c1}}: { a2: number; b2: { b1: boolean; c1: string; }; }) => void
|
||||
>a2 : number
|
||||
>b2 : unknown
|
||||
>b1 : boolean
|
||||
>c1 : string
|
||||
>a2 : number
|
||||
>b2 : { b1: boolean; c1: string; }
|
||||
>b1 : boolean
|
||||
>c1 : string
|
||||
|
43
tests/baselines/reference/declarationEmitDestructuring2.js
Normal file
43
tests/baselines/reference/declarationEmitDestructuring2.js
Normal file
|
@ -0,0 +1,43 @@
|
|||
//// [declarationEmitDestructuring2.ts]
|
||||
function f({x = 10, y: [a, b, c, d] = [1, 2, 3, 4]} = { x: 10, y: [2, 4, 6, 8] }) { }
|
||||
function g([a, b, c, d] = [1, 2, 3, 4]) { }
|
||||
function h([a, [b], [[c]], {x = 10, y: [a, b, c], z: {a1, b1}}]){ }
|
||||
function h1([a, [b], [[c]], {x = 10, y = [1, 2, 3], z: {a1, b1}}]){ }
|
||||
|
||||
//// [declarationEmitDestructuring2.js]
|
||||
function f(_a) {
|
||||
var _b = _a === void 0 ? { x: 10, y: [2, 4, 6, 8] } : _a, _c = _b.x, x = _c === void 0 ? 10 : _c, _d = _b.y, _e = _d === void 0 ? [1, 2, 3, 4] : _d, a = _e[0], b = _e[1], c = _e[2], d = _e[3];
|
||||
}
|
||||
function g(_a) {
|
||||
var _b = _a === void 0 ? [1, 2, 3, 4] : _a, a = _b[0], b = _b[1], c = _b[2], d = _b[3];
|
||||
}
|
||||
function h(_a) {
|
||||
var a = _a[0], b = _a[1][0], c = _a[2][0][0], _b = _a[3], _c = _b.x, x = _c === void 0 ? 10 : _c, _d = _b.y, a = _d[0], b = _d[1], c = _d[2], _e = _b.z, a1 = _e.a1, b1 = _e.b1;
|
||||
}
|
||||
function h1(_a) {
|
||||
var a = _a[0], b = _a[1][0], c = _a[2][0][0], _b = _a[3], _c = _b.x, x = _c === void 0 ? 10 : _c, _d = _b.y, y = _d === void 0 ? [1, 2, 3] : _d, _e = _b.z, a1 = _e.a1, b1 = _e.b1;
|
||||
}
|
||||
|
||||
|
||||
//// [declarationEmitDestructuring2.d.ts]
|
||||
declare function f({x, y: [a, b, c, d]}?: {
|
||||
x: number;
|
||||
y: [number, number, number, number];
|
||||
}): void;
|
||||
declare function g([a, b, c, d]?: [number, number, number, number]): void;
|
||||
declare function h([a, [b], [[c]], {x, y: [a, b, c], z: {a1, b1}}]: [any, [any], [[any]], {
|
||||
x?: number;
|
||||
y: [any, any, any];
|
||||
z: {
|
||||
a1: any;
|
||||
b1: any;
|
||||
};
|
||||
}]): void;
|
||||
declare function h1([a, [b], [[c]], {x, y, z: {a1, b1}}]: [any, [any], [[any]], {
|
||||
x?: number;
|
||||
y?: number[];
|
||||
z: {
|
||||
a1: any;
|
||||
b1: any;
|
||||
};
|
||||
}]): void;
|
|
@ -0,0 +1,49 @@
|
|||
=== tests/cases/compiler/declarationEmitDestructuring2.ts ===
|
||||
function f({x = 10, y: [a, b, c, d] = [1, 2, 3, 4]} = { x: 10, y: [2, 4, 6, 8] }) { }
|
||||
>f : ({x = 10, y: [a, b, c, d] = [1, 2, 3, 4]}?: { x: number; y: [number, number, number, number]; }) => void
|
||||
>x : number
|
||||
>y : unknown
|
||||
>a : number
|
||||
>b : number
|
||||
>c : number
|
||||
>d : number
|
||||
>[1, 2, 3, 4] : [number, number, number, number]
|
||||
>{ x: 10, y: [2, 4, 6, 8] } : { x: number; y: [number, number, number, number]; }
|
||||
>x : number
|
||||
>y : [number, number, number, number]
|
||||
>[2, 4, 6, 8] : [number, number, number, number]
|
||||
|
||||
function g([a, b, c, d] = [1, 2, 3, 4]) { }
|
||||
>g : ([a, b, c, d]?: [number, number, number, number]) => void
|
||||
>a : number
|
||||
>b : number
|
||||
>c : number
|
||||
>d : number
|
||||
>[1, 2, 3, 4] : [number, number, number, number]
|
||||
|
||||
function h([a, [b], [[c]], {x = 10, y: [a, b, c], z: {a1, b1}}]){ }
|
||||
>h : ([a, [b], [[c]], {x = 10, y: [a, b, c], z: {a1, b1}}]: [any, [any], [[any]], { x?: number; y: [any, any, any]; z: { a1: any; b1: any; }; }]) => void
|
||||
>a : any
|
||||
>b : any
|
||||
>c : any
|
||||
>x : number
|
||||
>y : unknown
|
||||
>a : any
|
||||
>b : any
|
||||
>c : any
|
||||
>z : unknown
|
||||
>a1 : any
|
||||
>b1 : any
|
||||
|
||||
function h1([a, [b], [[c]], {x = 10, y = [1, 2, 3], z: {a1, b1}}]){ }
|
||||
>h1 : ([a, [b], [[c]], {x = 10, y = [1, 2, 3], z: {a1, b1}}]: [any, [any], [[any]], { x?: number; y?: number[]; z: { a1: any; b1: any; }; }]) => void
|
||||
>a : any
|
||||
>b : any
|
||||
>c : any
|
||||
>x : number
|
||||
>y : number[]
|
||||
>[1, 2, 3] : number[]
|
||||
>z : unknown
|
||||
>a1 : any
|
||||
>b1 : any
|
||||
|
18
tests/baselines/reference/declarationEmitDestructuring3.js
Normal file
18
tests/baselines/reference/declarationEmitDestructuring3.js
Normal file
|
@ -0,0 +1,18 @@
|
|||
//// [declarationEmitDestructuring3.ts]
|
||||
function bar([x, z, ...w]) { }
|
||||
function foo([x, ...y] = [1, "string", true]) { }
|
||||
|
||||
|
||||
|
||||
//// [declarationEmitDestructuring3.js]
|
||||
function bar(_a) {
|
||||
var x = _a[0], z = _a[1], w = _a.slice(2);
|
||||
}
|
||||
function foo(_a) {
|
||||
var _b = _a === void 0 ? [1, "string", true] : _a, x = _b[0], y = _b.slice(1);
|
||||
}
|
||||
|
||||
|
||||
//// [declarationEmitDestructuring3.d.ts]
|
||||
declare function bar([x, z, ...w]: any[]): void;
|
||||
declare function foo([x, ...y]?: (string | number | boolean)[]): void;
|
|
@ -0,0 +1,14 @@
|
|||
=== tests/cases/compiler/declarationEmitDestructuring3.ts ===
|
||||
function bar([x, z, ...w]) { }
|
||||
>bar : ([x, z, ...w]: any[]) => void
|
||||
>x : any
|
||||
>z : any
|
||||
>w : any[]
|
||||
|
||||
function foo([x, ...y] = [1, "string", true]) { }
|
||||
>foo : ([x, ...y]?: (string | number | boolean)[]) => void
|
||||
>x : string | number | boolean
|
||||
>y : (string | number | boolean)[]
|
||||
>[1, "string", true] : (string | number | boolean)[]
|
||||
|
||||
|
42
tests/baselines/reference/declarationEmitDestructuring4.js
Normal file
42
tests/baselines/reference/declarationEmitDestructuring4.js
Normal file
|
@ -0,0 +1,42 @@
|
|||
//// [declarationEmitDestructuring4.ts]
|
||||
// For an array binding pattern with empty elements,
|
||||
// we will not make any modification and will emit
|
||||
// the similar binding pattern users' have written
|
||||
function baz([]) { }
|
||||
function baz1([] = [1,2,3]) { }
|
||||
function baz2([[]] = [[1,2,3]]) { }
|
||||
|
||||
function baz3({}) { }
|
||||
function baz4({} = { x: 10 }) { }
|
||||
|
||||
|
||||
|
||||
//// [declarationEmitDestructuring4.js]
|
||||
// For an array binding pattern with empty elements,
|
||||
// we will not make any modification and will emit
|
||||
// the similar binding pattern users' have written
|
||||
function baz(_a) {
|
||||
var ;
|
||||
}
|
||||
function baz1(_a) {
|
||||
var _b = _a === void 0 ? [1, 2, 3] : _a;
|
||||
}
|
||||
function baz2(_a) {
|
||||
var _b = (_a === void 0 ? [[1, 2, 3]] : _a)[0];
|
||||
}
|
||||
function baz3(_a) {
|
||||
var ;
|
||||
}
|
||||
function baz4(_a) {
|
||||
var _b = _a === void 0 ? { x: 10 } : _a;
|
||||
}
|
||||
|
||||
|
||||
//// [declarationEmitDestructuring4.d.ts]
|
||||
declare function baz([]: any[]): void;
|
||||
declare function baz1([]?: number[]): void;
|
||||
declare function baz2([[]]?: [number[]]): void;
|
||||
declare function baz3({}: {}): void;
|
||||
declare function baz4({}?: {
|
||||
x: number;
|
||||
}): void;
|
|
@ -0,0 +1,25 @@
|
|||
=== tests/cases/compiler/declarationEmitDestructuring4.ts ===
|
||||
// For an array binding pattern with empty elements,
|
||||
// we will not make any modification and will emit
|
||||
// the similar binding pattern users' have written
|
||||
function baz([]) { }
|
||||
>baz : ([]: any[]) => void
|
||||
|
||||
function baz1([] = [1,2,3]) { }
|
||||
>baz1 : ([]?: number[]) => void
|
||||
>[1,2,3] : number[]
|
||||
|
||||
function baz2([[]] = [[1,2,3]]) { }
|
||||
>baz2 : ([[]]?: [number[]]) => void
|
||||
>[[1,2,3]] : [number[]]
|
||||
>[1,2,3] : number[]
|
||||
|
||||
function baz3({}) { }
|
||||
>baz3 : ({}: {}) => void
|
||||
|
||||
function baz4({} = { x: 10 }) { }
|
||||
>baz4 : ({}?: { x: number; }) => void
|
||||
>{ x: 10 } : { x: number; }
|
||||
>x : number
|
||||
|
||||
|
31
tests/baselines/reference/declarationEmitDestructuring5.js
Normal file
31
tests/baselines/reference/declarationEmitDestructuring5.js
Normal file
|
@ -0,0 +1,31 @@
|
|||
//// [declarationEmitDestructuring5.ts]
|
||||
function baz([, z, , ]) { }
|
||||
function foo([, b, ]: [any, any]): void { }
|
||||
function bar([z, , , ]) { }
|
||||
function bar1([z, , , ] = [1, 3, 4, 6, 7]) { }
|
||||
function bar2([,,z, , , ]) { }
|
||||
|
||||
//// [declarationEmitDestructuring5.js]
|
||||
function baz(_a) {
|
||||
var z = _a[1];
|
||||
}
|
||||
function foo(_a) {
|
||||
var b = _a[1];
|
||||
}
|
||||
function bar(_a) {
|
||||
var z = _a[0];
|
||||
}
|
||||
function bar1(_a) {
|
||||
var _b = _a === void 0 ? [1, 3, 4, 6, 7] : _a, z = _b[0];
|
||||
}
|
||||
function bar2(_a) {
|
||||
var z = _a[2];
|
||||
}
|
||||
|
||||
|
||||
//// [declarationEmitDestructuring5.d.ts]
|
||||
declare function baz([ , z, , ]: [any, any, any]): void;
|
||||
declare function foo([ , b, ]: [any, any]): void;
|
||||
declare function bar([z, , , ]: [any, any, any]): void;
|
||||
declare function bar1([z, , , ]?: [number, number, number, number, number]): void;
|
||||
declare function bar2([ , , z, , , ]: [any, any, any, any, any]): void;
|
|
@ -0,0 +1,22 @@
|
|||
=== tests/cases/compiler/declarationEmitDestructuring5.ts ===
|
||||
function baz([, z, , ]) { }
|
||||
>baz : ([, z, , ]: [any, any, any]) => void
|
||||
>z : any
|
||||
|
||||
function foo([, b, ]: [any, any]): void { }
|
||||
>foo : ([, b, ]: [any, any]) => void
|
||||
>b : any
|
||||
|
||||
function bar([z, , , ]) { }
|
||||
>bar : ([z, , , ]: [any, any, any]) => void
|
||||
>z : any
|
||||
|
||||
function bar1([z, , , ] = [1, 3, 4, 6, 7]) { }
|
||||
>bar1 : ([z, , , ]?: [number, number, number, number, number]) => void
|
||||
>z : number
|
||||
>[1, 3, 4, 6, 7] : [number, number, number, number, number]
|
||||
|
||||
function bar2([,,z, , , ]) { }
|
||||
>bar2 : ([,,z, , , ]: [any, any, any, any, any]) => void
|
||||
>z : any
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
//// [declarationEmitDestructuringArrayPattern5.ts]
|
||||
var [, , z] = [1, 2, 4];
|
||||
var [, a, , ] = [3, 4, 5];
|
||||
var [, , [, b, ]] = [3,5,[0, 1]];
|
||||
|
||||
//// [declarationEmitDestructuringArrayPattern5.js]
|
||||
var _a = [1, 2, 4], z = _a[2];
|
||||
var _b = [3, 4, 5], a = _b[1];
|
||||
var _c = [3, 5, [0, 1]], _d = _c[2], b = _d[1];
|
||||
|
||||
|
||||
//// [declarationEmitDestructuringArrayPattern5.d.ts]
|
||||
declare var z: number;
|
||||
declare var a: number;
|
||||
declare var b: number;
|
|
@ -0,0 +1,14 @@
|
|||
=== tests/cases/compiler/declarationEmitDestructuringArrayPattern5.ts ===
|
||||
var [, , z] = [1, 2, 4];
|
||||
>z : number
|
||||
>[1, 2, 4] : [number, number, number]
|
||||
|
||||
var [, a, , ] = [3, 4, 5];
|
||||
>a : number
|
||||
>[3, 4, 5] : [number, number, number]
|
||||
|
||||
var [, , [, b, ]] = [3,5,[0, 1]];
|
||||
>b : number
|
||||
>[3,5,[0, 1]] : [number, number, [number, number]]
|
||||
>[0, 1] : [number, number]
|
||||
|
|
@ -25,8 +25,8 @@ function foo2() {
|
|||
|
||||
|
||||
//// [declarationEmitDestructuringOptionalBindingParametersInOverloads.d.ts]
|
||||
declare function foo(_0?: [string, number, boolean]): any;
|
||||
declare function foo2(_0?: {
|
||||
declare function foo([x, y, z]?: [string, number, boolean]): any;
|
||||
declare function foo2({x, y, z}?: {
|
||||
x: string;
|
||||
y: number;
|
||||
z: boolean;
|
||||
|
|
|
@ -43,12 +43,12 @@ var C3 = (function () {
|
|||
//// [declarationEmitDestructuringParameterProperties.d.ts]
|
||||
declare class C1 {
|
||||
x: string, y: string, z: string;
|
||||
constructor(_0: string[]);
|
||||
constructor([x, y, z]: string[]);
|
||||
}
|
||||
declare type TupleType1 = [string, number, boolean];
|
||||
declare class C2 {
|
||||
x: string, y: number, z: boolean;
|
||||
constructor(_0: TupleType1);
|
||||
constructor([x, y, z]: TupleType1);
|
||||
}
|
||||
declare type ObjType1 = {
|
||||
x: number;
|
||||
|
@ -57,5 +57,5 @@ declare type ObjType1 = {
|
|||
};
|
||||
declare class C3 {
|
||||
x: number, y: string, z: boolean;
|
||||
constructor(_0: ObjType1);
|
||||
constructor({x, y, z}: ObjType1);
|
||||
}
|
||||
|
|
|
@ -14,8 +14,8 @@ function foo1(_a) {
|
|||
|
||||
|
||||
//// [declarationEmitDestructuringWithOptionalBindingParameters.d.ts]
|
||||
declare function foo(_0?: [string, number, boolean]): void;
|
||||
declare function foo1(_0?: {
|
||||
declare function foo([x, y, z]?: [string, number, boolean]): void;
|
||||
declare function foo1({x, y, z}?: {
|
||||
x: string;
|
||||
y: number;
|
||||
z: boolean;
|
||||
|
|
|
@ -119,13 +119,13 @@ export module M.Q {
|
|||
}
|
||||
export interface b extends M.b { } // ok
|
||||
>b : b
|
||||
>M : unknown
|
||||
>M : typeof M
|
||||
>b : M.C
|
||||
|
||||
export interface I extends M.c.I { } // ok
|
||||
>I : I
|
||||
>M : unknown
|
||||
>c : unknown
|
||||
>M : typeof M
|
||||
>c : typeof M.N
|
||||
>I : M.c.I
|
||||
|
||||
export module c {
|
||||
|
@ -133,8 +133,8 @@ export module M.Q {
|
|||
|
||||
export interface I extends M.c.I { } // ok
|
||||
>I : I
|
||||
>M : unknown
|
||||
>c : unknown
|
||||
>M : typeof M
|
||||
>c : typeof M.N
|
||||
>I : M.c.I
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,12 +0,0 @@
|
|||
tests/cases/conformance/es6/destructuring/declarationInAmbientContext.ts(1,13): error TS1183: Destructuring declarations are not allowed in ambient contexts.
|
||||
tests/cases/conformance/es6/destructuring/declarationInAmbientContext.ts(2,13): error TS1183: Destructuring declarations are not allowed in ambient contexts.
|
||||
|
||||
|
||||
==== tests/cases/conformance/es6/destructuring/declarationInAmbientContext.ts (2 errors) ====
|
||||
declare var [a, b]; // Error, destructuring declaration not allowed in ambient context
|
||||
~~~~~~
|
||||
!!! error TS1183: Destructuring declarations are not allowed in ambient contexts.
|
||||
declare var {c, d}; // Error, destructuring declaration not allowed in ambient context
|
||||
~~~~~~
|
||||
!!! error TS1183: Destructuring declarations are not allowed in ambient contexts.
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
=== tests/cases/conformance/es6/destructuring/declarationInAmbientContext.ts ===
|
||||
declare var [a, b]; // Error, destructuring declaration not allowed in ambient context
|
||||
>a : any
|
||||
>b : any
|
||||
|
||||
declare var {c, d}; // Error, destructuring declaration not allowed in ambient context
|
||||
>c : any
|
||||
>d : any
|
||||
|
|
@ -14,12 +14,12 @@ import ab = A.B;
|
|||
|
||||
class D extends ab.C{ }
|
||||
>D : D
|
||||
>ab : unknown
|
||||
>ab : typeof ab
|
||||
>C : ab.C
|
||||
|
||||
class E extends A.B.C{ }
|
||||
>E : E
|
||||
>A : unknown
|
||||
>B : unknown
|
||||
>A : typeof A
|
||||
>B : typeof ab
|
||||
>C : ab.C
|
||||
|
||||
|
|
|
@ -7,7 +7,7 @@ declare module "express" {
|
|||
function express(): express.ExpressServer;
|
||||
>express : typeof express
|
||||
>express : unknown
|
||||
>ExpressServer : export=.ExpressServer
|
||||
>ExpressServer : express.ExpressServer
|
||||
|
||||
module express {
|
||||
>express : typeof express
|
||||
|
|
|
@ -27,24 +27,24 @@ module m2 {
|
|||
}
|
||||
|
||||
var m2: {
|
||||
>m2 : { (): export=.connectExport; test1: export=.connectModule; test2(): export=.connectModule; }
|
||||
>m2 : { (): m2.connectExport; test1: m2.connectModule; test2(): m2.connectModule; }
|
||||
|
||||
(): m2.connectExport;
|
||||
>m2 : unknown
|
||||
>connectExport : export=.connectExport
|
||||
>connectExport : m2.connectExport
|
||||
|
||||
test1: m2.connectModule;
|
||||
>test1 : export=.connectModule
|
||||
>test1 : m2.connectModule
|
||||
>m2 : unknown
|
||||
>connectModule : export=.connectModule
|
||||
>connectModule : m2.connectModule
|
||||
|
||||
test2(): m2.connectModule;
|
||||
>test2 : () => export=.connectModule
|
||||
>test2 : () => m2.connectModule
|
||||
>m2 : unknown
|
||||
>connectModule : export=.connectModule
|
||||
>connectModule : m2.connectModule
|
||||
|
||||
};
|
||||
|
||||
export = m2;
|
||||
>m2 : { (): export=.connectExport; test1: export=.connectModule; test2(): export=.connectModule; }
|
||||
>m2 : { (): m2.connectExport; test1: m2.connectModule; test2(): m2.connectModule; }
|
||||
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue