Merge branch 'master' into optimizeMaps
This commit is contained in:
commit
87393e026e
|
@ -17,6 +17,8 @@ matrix:
|
|||
node_js: stable
|
||||
osx_image: xcode7.3
|
||||
env: workerCount=2
|
||||
allow_failures:
|
||||
- os: osx
|
||||
|
||||
branches:
|
||||
only:
|
||||
|
@ -32,3 +34,6 @@ install:
|
|||
cache:
|
||||
directories:
|
||||
- node_modules
|
||||
|
||||
git:
|
||||
depth: 1
|
||||
|
|
|
@ -35,6 +35,7 @@ import merge2 = require("merge2");
|
|||
import intoStream = require("into-stream");
|
||||
import * as os from "os";
|
||||
import Linter = require("tslint");
|
||||
import fold = require("travis-fold");
|
||||
const gulp = helpMaker(originalGulp);
|
||||
const mochaParallel = require("./scripts/mocha-parallel.js");
|
||||
const {runTestsInParallel} = mochaParallel;
|
||||
|
@ -964,6 +965,7 @@ gulp.task("lint", "Runs tslint on the compiler sources. Optional arguments are:
|
|||
const fileMatcher = RegExp(cmdLineOptions["files"]);
|
||||
const lintOptions = getLinterOptions();
|
||||
let failed = 0;
|
||||
if (fold.isTravis()) console.log(fold.start("lint"));
|
||||
return gulp.src(lintTargets)
|
||||
.pipe(insert.transform((contents, file) => {
|
||||
if (!fileMatcher.test(file.path)) return contents;
|
||||
|
@ -975,6 +977,7 @@ gulp.task("lint", "Runs tslint on the compiler sources. Optional arguments are:
|
|||
return contents; // TODO (weswig): Automatically apply fixes? :3
|
||||
}))
|
||||
.on("end", () => {
|
||||
if (fold.isTravis()) console.log(fold.end("lint"));
|
||||
if (failed > 0) {
|
||||
console.error("Linter errors.");
|
||||
process.exit(1);
|
||||
|
|
27
Jakefile.js
27
Jakefile.js
|
@ -5,6 +5,7 @@ var os = require("os");
|
|||
var path = require("path");
|
||||
var child_process = require("child_process");
|
||||
var Linter = require("tslint");
|
||||
var fold = require("travis-fold");
|
||||
var runTestsInParallel = require("./scripts/mocha-parallel").runTestsInParallel;
|
||||
|
||||
// Variables
|
||||
|
@ -560,9 +561,19 @@ compileFile(
|
|||
desc("Builds language service server library");
|
||||
task("lssl", [tsserverLibraryFile, tsserverLibraryDefinitionFile]);
|
||||
|
||||
desc("Emit the start of the build fold");
|
||||
task("build-fold-start", [] , function() {
|
||||
if (fold.isTravis()) console.log(fold.start("build"));
|
||||
});
|
||||
|
||||
desc("Emit the end of the build fold");
|
||||
task("build-fold-end", [] , function() {
|
||||
if (fold.isTravis()) console.log(fold.end("build"));
|
||||
});
|
||||
|
||||
// Local target to build the compiler and services
|
||||
desc("Builds the full compiler and services");
|
||||
task("local", ["generate-diagnostics", "lib", tscFile, servicesFile, nodeDefinitionsFile, serverFile, builtGeneratedDiagnosticMessagesJSON, "lssl"]);
|
||||
task("local", ["build-fold-start", "generate-diagnostics", "lib", tscFile, servicesFile, nodeDefinitionsFile, serverFile, builtGeneratedDiagnosticMessagesJSON, "lssl", "build-fold-end"]);
|
||||
|
||||
// Local target to build only tsc.js
|
||||
desc("Builds only the compiler");
|
||||
|
@ -998,12 +1009,22 @@ var tslintRulesOutFiles = tslintRules.map(function(p) {
|
|||
return path.join(builtLocalDirectory, "tslint", p + ".js");
|
||||
});
|
||||
desc("Compiles tslint rules to js");
|
||||
task("build-rules", tslintRulesOutFiles);
|
||||
task("build-rules", ["build-rules-start"].concat(tslintRulesOutFiles).concat(["build-rules-end"]));
|
||||
tslintRulesFiles.forEach(function(ruleFile, i) {
|
||||
compileFile(tslintRulesOutFiles[i], [ruleFile], [ruleFile], [], /*useBuiltCompiler*/ false,
|
||||
{ noOutFile: true, generateDeclarations: false, outDir: path.join(builtLocalDirectory, "tslint")});
|
||||
});
|
||||
|
||||
desc("Emit the start of the build-rules fold");
|
||||
task("build-rules-start", [] , function() {
|
||||
if (fold.isTravis()) console.log(fold.start("build-rules"));
|
||||
});
|
||||
|
||||
desc("Emit the end of the build-rules fold");
|
||||
task("build-rules-end", [] , function() {
|
||||
if (fold.isTravis()) console.log(fold.end("build-rules"));
|
||||
});
|
||||
|
||||
function getLinterOptions() {
|
||||
return {
|
||||
configuration: require("./tslint.json"),
|
||||
|
@ -1047,6 +1068,7 @@ var lintTargets = compilerSources
|
|||
|
||||
desc("Runs tslint on the compiler sources. Optional arguments are: f[iles]=regex");
|
||||
task("lint", ["build-rules"], function() {
|
||||
if (fold.isTravis()) console.log(fold.start("lint"));
|
||||
var lintOptions = getLinterOptions();
|
||||
var failed = 0;
|
||||
var fileMatcher = RegExp(process.env.f || process.env.file || process.env.files || "");
|
||||
|
@ -1062,6 +1084,7 @@ task("lint", ["build-rules"], function() {
|
|||
done[target] = true;
|
||||
}
|
||||
}
|
||||
if (fold.isTravis()) console.log(fold.end("lint"));
|
||||
if (failed > 0) {
|
||||
fail('Linter errors.', failed);
|
||||
}
|
||||
|
|
|
@ -30,8 +30,8 @@
|
|||
},
|
||||
"devDependencies": {
|
||||
"@types/browserify": "latest",
|
||||
"@types/convert-source-map": "latest",
|
||||
"@types/chai": "latest",
|
||||
"@types/convert-source-map": "latest",
|
||||
"@types/del": "latest",
|
||||
"@types/glob": "latest",
|
||||
"@types/gulp": "latest",
|
||||
|
@ -72,6 +72,7 @@
|
|||
"run-sequence": "latest",
|
||||
"sorcery": "latest",
|
||||
"through2": "latest",
|
||||
"travis-fold": "latest",
|
||||
"ts-node": "latest",
|
||||
"tslint": "next",
|
||||
"typescript": "next"
|
||||
|
|
1
scripts/types/ambient.d.ts
vendored
1
scripts/types/ambient.d.ts
vendored
|
@ -22,3 +22,4 @@ declare module "into-stream" {
|
|||
}
|
||||
|
||||
declare module "sorcery";
|
||||
declare module "travis-fold";
|
||||
|
|
|
@ -1886,18 +1886,17 @@ namespace ts {
|
|||
}
|
||||
|
||||
function bindExportAssignment(node: ExportAssignment | BinaryExpression) {
|
||||
const boundExpression = node.kind === SyntaxKind.ExportAssignment ? (<ExportAssignment>node).expression : (<BinaryExpression>node).right;
|
||||
if (!container.symbol || !container.symbol.exports) {
|
||||
// Export assignment in some sort of block construct
|
||||
bindAnonymousDeclaration(node, SymbolFlags.Alias, getDeclarationName(node));
|
||||
}
|
||||
else if (boundExpression.kind === SyntaxKind.Identifier && node.kind === SyntaxKind.ExportAssignment) {
|
||||
// An export default clause with an identifier exports all meanings of that identifier
|
||||
declareSymbol(container.symbol.exports, container.symbol, node, SymbolFlags.Alias, SymbolFlags.PropertyExcludes | SymbolFlags.AliasExcludes);
|
||||
}
|
||||
else {
|
||||
// An export default clause with an expression exports a value
|
||||
declareSymbol(container.symbol.exports, container.symbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes | SymbolFlags.AliasExcludes);
|
||||
const flags = node.kind === SyntaxKind.ExportAssignment && exportAssignmentIsAlias(<ExportAssignment>node)
|
||||
// An export default clause with an EntityNameExpression exports all meanings of that identifier
|
||||
? SymbolFlags.Alias
|
||||
// An export default clause with any other expression exports a value
|
||||
: SymbolFlags.Property;
|
||||
declareSymbol(container.symbol.exports, container.symbol, node, flags, SymbolFlags.PropertyExcludes | SymbolFlags.AliasExcludes);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -245,7 +245,8 @@ namespace ts {
|
|||
NEUndefinedOrNull = 1 << 19, // x != undefined / x != null
|
||||
Truthy = 1 << 20, // x
|
||||
Falsy = 1 << 21, // !x
|
||||
All = (1 << 22) - 1,
|
||||
Discriminatable = 1 << 22, // May have discriminant property
|
||||
All = (1 << 23) - 1,
|
||||
// The following members encode facts about particular kinds of types for use in the getTypeFacts function.
|
||||
// The presence of a particular fact means that the given test is true for some (and possibly all) values
|
||||
// of that kind of type.
|
||||
|
@ -275,9 +276,9 @@ namespace ts {
|
|||
TrueFacts = BaseBooleanFacts | Truthy,
|
||||
SymbolStrictFacts = TypeofEQSymbol | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNEObject | TypeofNEFunction | TypeofNEHostObject | NEUndefined | NENull | NEUndefinedOrNull | Truthy,
|
||||
SymbolFacts = SymbolStrictFacts | EQUndefined | EQNull | EQUndefinedOrNull | Falsy,
|
||||
ObjectStrictFacts = TypeofEQObject | TypeofEQHostObject | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEFunction | NEUndefined | NENull | NEUndefinedOrNull | Truthy,
|
||||
ObjectStrictFacts = TypeofEQObject | TypeofEQHostObject | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEFunction | NEUndefined | NENull | NEUndefinedOrNull | Truthy | Discriminatable,
|
||||
ObjectFacts = ObjectStrictFacts | EQUndefined | EQNull | EQUndefinedOrNull | Falsy,
|
||||
FunctionStrictFacts = TypeofEQFunction | TypeofEQHostObject | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEObject | NEUndefined | NENull | NEUndefinedOrNull | Truthy,
|
||||
FunctionStrictFacts = TypeofEQFunction | TypeofEQHostObject | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEObject | NEUndefined | NENull | NEUndefinedOrNull | Truthy | Discriminatable,
|
||||
FunctionFacts = FunctionStrictFacts | EQUndefined | EQNull | EQUndefinedOrNull | Falsy,
|
||||
UndefinedFacts = TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEObject | TypeofNEFunction | TypeofNEHostObject | EQUndefined | EQUndefinedOrNull | NENull | Falsy,
|
||||
NullFacts = TypeofEQObject | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEFunction | TypeofNEHostObject | EQNull | EQUndefinedOrNull | NEUndefined | Falsy,
|
||||
|
@ -659,7 +660,7 @@ namespace ts {
|
|||
// Resolve a given name for a given meaning at a given location. An error is reported if the name was not found and
|
||||
// the nameNotFoundMessage argument is not undefined. Returns the resolved symbol, or undefined if no symbol with
|
||||
// the given name can be found.
|
||||
function resolveName(location: Node, name: string, meaning: SymbolFlags, nameNotFoundMessage: DiagnosticMessage, nameArg: string | Identifier): Symbol {
|
||||
function resolveName(location: Node | undefined, name: string, meaning: SymbolFlags, nameNotFoundMessage: DiagnosticMessage, nameArg: string | Identifier): Symbol {
|
||||
let result: Symbol;
|
||||
let lastLocation: Node;
|
||||
let propertyWithInvalidInitializer: Node;
|
||||
|
@ -876,7 +877,8 @@ namespace ts {
|
|||
|
||||
if (!result) {
|
||||
if (nameNotFoundMessage) {
|
||||
if (!checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) &&
|
||||
if (!errorLocation ||
|
||||
!checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) &&
|
||||
!checkAndReportErrorForExtendingInterface(errorLocation)) {
|
||||
error(errorLocation, nameNotFoundMessage, typeof nameArg === "string" ? nameArg : declarationNameToString(nameArg));
|
||||
}
|
||||
|
@ -925,7 +927,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
function checkAndReportErrorForMissingPrefix(errorLocation: Node, name: string, nameArg: string | Identifier): boolean {
|
||||
if (!errorLocation || (errorLocation.kind === SyntaxKind.Identifier && (isTypeReferenceIdentifier(<Identifier>errorLocation)) || isInTypeQuery(errorLocation))) {
|
||||
if ((errorLocation.kind === SyntaxKind.Identifier && (isTypeReferenceIdentifier(<Identifier>errorLocation)) || isInTypeQuery(errorLocation))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -963,28 +965,30 @@ namespace ts {
|
|||
|
||||
|
||||
function checkAndReportErrorForExtendingInterface(errorLocation: Node): boolean {
|
||||
let parentClassExpression = errorLocation;
|
||||
while (parentClassExpression) {
|
||||
const kind = parentClassExpression.kind;
|
||||
if (kind === SyntaxKind.Identifier || kind === SyntaxKind.PropertyAccessExpression) {
|
||||
parentClassExpression = parentClassExpression.parent;
|
||||
continue;
|
||||
}
|
||||
if (kind === SyntaxKind.ExpressionWithTypeArguments) {
|
||||
break;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if (!parentClassExpression) {
|
||||
return false;
|
||||
}
|
||||
const expression = (<ExpressionWithTypeArguments>parentClassExpression).expression;
|
||||
if (resolveEntityName(expression, SymbolFlags.Interface, /*ignoreErrors*/ true)) {
|
||||
const expression = getEntityNameForExtendingInterface(errorLocation);
|
||||
const isError = !!(expression && resolveEntityName(expression, SymbolFlags.Interface, /*ignoreErrors*/ true));
|
||||
if (isError) {
|
||||
error(errorLocation, Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements, getTextOfNode(expression));
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
return isError;
|
||||
}
|
||||
/**
|
||||
* Climbs up parents to an ExpressionWithTypeArguments, and returns its expression,
|
||||
* but returns undefined if that expression is not an EntityNameExpression.
|
||||
*/
|
||||
function getEntityNameForExtendingInterface(node: Node): EntityNameExpression | undefined {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.Identifier:
|
||||
case SyntaxKind.PropertyAccessExpression:
|
||||
return node.parent ? getEntityNameForExtendingInterface(node.parent) : undefined;
|
||||
case SyntaxKind.ExpressionWithTypeArguments:
|
||||
Debug.assert(isEntityNameExpression((<ExpressionWithTypeArguments>node).expression));
|
||||
return <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression;
|
||||
default:
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
function checkResolvedBlockScopedVariable(result: Symbol, errorLocation: Node): void {
|
||||
Debug.assert((result.flags & SymbolFlags.BlockScopedVariable) !== 0);
|
||||
|
@ -1028,7 +1032,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
function getDeclarationOfAliasSymbol(symbol: Symbol): Declaration {
|
||||
return forEach(symbol.declarations, d => isAliasSymbolDeclaration(d) ? d : undefined);
|
||||
return find(symbol.declarations, d => isAliasSymbolDeclaration(d) ? d : undefined);
|
||||
}
|
||||
|
||||
function getTargetOfImportEqualsDeclaration(node: ImportEqualsDeclaration): Symbol {
|
||||
|
@ -1163,7 +1167,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
function getTargetOfExportAssignment(node: ExportAssignment): Symbol {
|
||||
return resolveEntityName(<Identifier>node.expression, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace);
|
||||
return resolveEntityName(<EntityNameExpression>node.expression, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace);
|
||||
}
|
||||
|
||||
function getTargetOfAliasDeclaration(node: Declaration): Symbol {
|
||||
|
@ -1273,7 +1277,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
// Resolves a qualified name and any involved aliases
|
||||
function resolveEntityName(name: EntityName | Expression, meaning: SymbolFlags, ignoreErrors?: boolean, dontResolveAlias?: boolean): Symbol {
|
||||
function resolveEntityName(name: EntityNameOrEntityNameExpression, meaning: SymbolFlags, ignoreErrors?: boolean, dontResolveAlias?: boolean): Symbol | undefined {
|
||||
if (nodeIsMissing(name)) {
|
||||
return undefined;
|
||||
}
|
||||
|
@ -1288,7 +1292,7 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
else if (name.kind === SyntaxKind.QualifiedName || name.kind === SyntaxKind.PropertyAccessExpression) {
|
||||
const left = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).left : (<PropertyAccessExpression>name).expression;
|
||||
const left = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).left : (<PropertyAccessEntityNameExpression>name).expression;
|
||||
const right = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).right : (<PropertyAccessExpression>name).name;
|
||||
|
||||
const namespace = resolveEntityName(left, SymbolFlags.Namespace, ignoreErrors);
|
||||
|
@ -1533,8 +1537,8 @@ namespace ts {
|
|||
|
||||
function createType(flags: TypeFlags): Type {
|
||||
const result = new Type(checker, flags);
|
||||
result.id = typeCount;
|
||||
typeCount++;
|
||||
result.id = typeCount;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
@ -1842,7 +1846,7 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
|
||||
function isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult {
|
||||
function isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult {
|
||||
// get symbol of the first identifier of the entityName
|
||||
let meaning: SymbolFlags;
|
||||
if (entityName.parent.kind === SyntaxKind.TypeQuery || isExpressionWithTypeArgumentsInClassExtendsClause(entityName.parent)) {
|
||||
|
@ -3672,7 +3676,7 @@ namespace ts {
|
|||
const baseTypeNodes = getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration);
|
||||
if (baseTypeNodes) {
|
||||
for (const node of baseTypeNodes) {
|
||||
if (isSupportedExpressionWithTypeArguments(node)) {
|
||||
if (isEntityNameExpression(node.expression)) {
|
||||
const baseSymbol = resolveEntityName(node.expression, SymbolFlags.Type, /*ignoreErrors*/ true);
|
||||
if (!baseSymbol || !(baseSymbol.flags & SymbolFlags.Interface) || getDeclaredTypeOfClassOrInterface(baseSymbol).thisType) {
|
||||
return false;
|
||||
|
@ -3993,6 +3997,9 @@ namespace ts {
|
|||
return createTypeReference((<TypeReference>type).target,
|
||||
concatenate((<TypeReference>type).typeArguments, [thisArgument || (<TypeReference>type).target.thisType]));
|
||||
}
|
||||
if (type.flags & TypeFlags.Tuple) {
|
||||
return createTupleType((type as TupleType).elementTypes, thisArgument);
|
||||
}
|
||||
return type;
|
||||
}
|
||||
|
||||
|
@ -4096,7 +4103,8 @@ namespace ts {
|
|||
function resolveTupleTypeMembers(type: TupleType) {
|
||||
const arrayElementType = getUnionType(type.elementTypes);
|
||||
// Make the tuple type itself the 'this' type by including an extra type argument
|
||||
const arrayType = resolveStructuredTypeMembers(createTypeFromGenericGlobalType(globalArrayType, [arrayElementType, type]));
|
||||
// (Unless it's provided in the case that the tuple is a type parameter constraint)
|
||||
const arrayType = resolveStructuredTypeMembers(createTypeFromGenericGlobalType(globalArrayType, [arrayElementType, type.thisType || type]));
|
||||
const members = createTupleTypeMemberSymbols(type.elementTypes);
|
||||
addInheritedMembers(members, arrayType.properties);
|
||||
setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexInfo, arrayType.numberIndexInfo);
|
||||
|
@ -4930,25 +4938,28 @@ namespace ts {
|
|||
}
|
||||
|
||||
function getTypeListId(types: Type[]) {
|
||||
if (types) {
|
||||
switch (types.length) {
|
||||
case 1:
|
||||
return "" + types[0].id;
|
||||
case 2:
|
||||
return types[0].id + "," + types[1].id;
|
||||
default:
|
||||
let result = "";
|
||||
for (let i = 0; i < types.length; i++) {
|
||||
if (i > 0) {
|
||||
if (types) {
|
||||
const length = types.length;
|
||||
let i = 0;
|
||||
while (i < length) {
|
||||
const startId = types[i].id;
|
||||
let count = 1;
|
||||
while (i + count < length && types[i + count].id === startId + count) {
|
||||
count++;
|
||||
}
|
||||
if (result.length) {
|
||||
result += ",";
|
||||
}
|
||||
result += types[i].id;
|
||||
result += startId;
|
||||
if (count > 1) {
|
||||
result += ":" + count;
|
||||
}
|
||||
i += count;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
// This function is used to propagate certain flags when creating new object type references and union types.
|
||||
// It is only necessary to do so if a constituent type might be the undefined type, the null type, the type
|
||||
|
@ -5030,7 +5041,7 @@ namespace ts {
|
|||
return getDeclaredTypeOfSymbol(symbol);
|
||||
}
|
||||
|
||||
function getTypeReferenceName(node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference): LeftHandSideExpression | EntityName {
|
||||
function getTypeReferenceName(node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference): EntityNameOrEntityNameExpression | undefined {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.TypeReference:
|
||||
return (<TypeReferenceNode>node).typeName;
|
||||
|
@ -5039,8 +5050,9 @@ namespace ts {
|
|||
case SyntaxKind.ExpressionWithTypeArguments:
|
||||
// We only support expressions that are simple qualified names. For other
|
||||
// expressions this produces undefined.
|
||||
if (isSupportedExpressionWithTypeArguments(<ExpressionWithTypeArguments>node)) {
|
||||
return (<ExpressionWithTypeArguments>node).expression;
|
||||
const expr = (<ExpressionWithTypeArguments>node).expression;
|
||||
if (isEntityNameExpression(expr)) {
|
||||
return expr;
|
||||
}
|
||||
|
||||
// fall through;
|
||||
|
@ -5051,7 +5063,7 @@ namespace ts {
|
|||
|
||||
function resolveTypeReferenceName(
|
||||
node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference,
|
||||
typeReferenceName: LeftHandSideExpression | EntityName) {
|
||||
typeReferenceName: EntityNameExpression | EntityName) {
|
||||
|
||||
if (!typeReferenceName) {
|
||||
return unknownSymbol;
|
||||
|
@ -5092,15 +5104,14 @@ namespace ts {
|
|||
const typeReferenceName = getTypeReferenceName(node);
|
||||
symbol = resolveTypeReferenceName(node, typeReferenceName);
|
||||
type = getTypeReferenceType(node, symbol);
|
||||
|
||||
links.resolvedSymbol = symbol;
|
||||
links.resolvedType = type;
|
||||
}
|
||||
else {
|
||||
// We only support expressions that are simple qualified names. For other expressions this produces undefined.
|
||||
const typeNameOrExpression = node.kind === SyntaxKind.TypeReference ? (<TypeReferenceNode>node).typeName :
|
||||
isSupportedExpressionWithTypeArguments(<ExpressionWithTypeArguments>node) ? (<ExpressionWithTypeArguments>node).expression :
|
||||
undefined;
|
||||
const typeNameOrExpression: EntityNameOrEntityNameExpression = node.kind === SyntaxKind.TypeReference
|
||||
? (<TypeReferenceNode>node).typeName
|
||||
: isEntityNameExpression((<ExpressionWithTypeArguments>node).expression)
|
||||
? <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression
|
||||
: undefined;
|
||||
symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, SymbolFlags.Type) || unknownSymbol;
|
||||
type = symbol === unknownSymbol ? unknownType :
|
||||
symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface) ? getTypeFromClassOrInterfaceReference(node, symbol) :
|
||||
|
@ -5219,15 +5230,16 @@ namespace ts {
|
|||
return links.resolvedType;
|
||||
}
|
||||
|
||||
function createTupleType(elementTypes: Type[]) {
|
||||
const id = getTypeListId(elementTypes);
|
||||
return tupleTypes[id] || (tupleTypes[id] = createNewTupleType(elementTypes));
|
||||
function createTupleType(elementTypes: Type[], thisType?: Type) {
|
||||
const id = getTypeListId(elementTypes) + "," + (thisType ? thisType.id : 0);
|
||||
return tupleTypes[id] || (tupleTypes[id] = createNewTupleType(elementTypes, thisType));
|
||||
}
|
||||
|
||||
function createNewTupleType(elementTypes: Type[]) {
|
||||
function createNewTupleType(elementTypes: Type[], thisType?: Type) {
|
||||
const propagatedFlags = getPropagatingFlagsOfTypes(elementTypes, /*excludeKinds*/ 0);
|
||||
const type = <TupleType>createObjectType(TypeFlags.Tuple | propagatedFlags);
|
||||
type.elementTypes = elementTypes;
|
||||
type.thisType = thisType;
|
||||
return type;
|
||||
}
|
||||
|
||||
|
@ -5329,12 +5341,12 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
|
||||
// We deduplicate the constituent types based on object identity. If the subtypeReduction flag is
|
||||
// specified we also reduce the constituent type set to only include types that aren't subtypes of
|
||||
// other types. Subtype reduction is expensive for large union types and is possible only when union
|
||||
// We sort and deduplicate the constituent types based on object identity. If the subtypeReduction
|
||||
// flag is specified we also reduce the constituent type set to only include types that aren't subtypes
|
||||
// of other types. Subtype reduction is expensive for large union types and is possible only when union
|
||||
// types are known not to circularly reference themselves (as is the case with union types created by
|
||||
// expression constructs such as array literals and the || and ?: operators). Named types can
|
||||
// circularly reference themselves and therefore cannot be deduplicated during their declaration.
|
||||
// circularly reference themselves and therefore cannot be subtype reduced during their declaration.
|
||||
// For example, "type Item = string | (() => Item" is a named type that circularly references itself.
|
||||
function getUnionType(types: Type[], subtypeReduction?: boolean, aliasSymbol?: Symbol, aliasTypeArguments?: Type[]): Type {
|
||||
if (types.length === 0) {
|
||||
|
@ -5356,15 +5368,23 @@ namespace ts {
|
|||
typeSet.containsUndefined ? typeSet.containsNonWideningType ? undefinedType : undefinedWideningType :
|
||||
neverType;
|
||||
}
|
||||
else if (typeSet.length === 1) {
|
||||
return typeSet[0];
|
||||
return getUnionTypeFromSortedList(typeSet, aliasSymbol, aliasTypeArguments);
|
||||
}
|
||||
const id = getTypeListId(typeSet);
|
||||
|
||||
// This function assumes the constituent type list is sorted and deduplicated.
|
||||
function getUnionTypeFromSortedList(types: Type[], aliasSymbol?: Symbol, aliasTypeArguments?: Type[]): Type {
|
||||
if (types.length === 0) {
|
||||
return neverType;
|
||||
}
|
||||
if (types.length === 1) {
|
||||
return types[0];
|
||||
}
|
||||
const id = getTypeListId(types);
|
||||
let type = unionTypes[id];
|
||||
if (!type) {
|
||||
const propagatedFlags = getPropagatingFlagsOfTypes(typeSet, /*excludeKinds*/ TypeFlags.Nullable);
|
||||
const propagatedFlags = getPropagatingFlagsOfTypes(types, /*excludeKinds*/ TypeFlags.Nullable);
|
||||
type = unionTypes[id] = <UnionType>createObjectType(TypeFlags.Union | propagatedFlags);
|
||||
type.types = typeSet;
|
||||
type.types = types;
|
||||
type.aliasSymbol = aliasSymbol;
|
||||
type.aliasTypeArguments = aliasTypeArguments;
|
||||
}
|
||||
|
@ -7826,10 +7846,18 @@ namespace ts {
|
|||
}
|
||||
|
||||
function isDiscriminantProperty(type: Type, name: string) {
|
||||
if (type) {
|
||||
const nonNullType = getNonNullableType(type);
|
||||
if (nonNullType.flags & TypeFlags.Union) {
|
||||
const prop = getPropertyOfType(nonNullType, name);
|
||||
if (type && type.flags & TypeFlags.Union) {
|
||||
let prop = getPropertyOfType(type, name);
|
||||
if (!prop) {
|
||||
// The type may be a union that includes nullable or primitive types. If filtering
|
||||
// those out produces a different type, get the property from that type instead.
|
||||
// Effectively, we're checking if this *could* be a discriminant property once nullable
|
||||
// and primitive types are removed by other type guards.
|
||||
const filteredType = getTypeWithFacts(type, TypeFacts.Discriminatable);
|
||||
if (filteredType !== type && filteredType.flags & TypeFlags.Union) {
|
||||
prop = getPropertyOfType(filteredType, name);
|
||||
}
|
||||
}
|
||||
if (prop && prop.flags & SymbolFlags.SyntheticProperty) {
|
||||
if ((<TransientSymbol>prop).isDiscriminantProperty === undefined) {
|
||||
(<TransientSymbol>prop).isDiscriminantProperty = !(<TransientSymbol>prop).hasCommonType &&
|
||||
|
@ -7838,7 +7866,6 @@ namespace ts {
|
|||
return (<TransientSymbol>prop).isDiscriminantProperty;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -7885,10 +7912,10 @@ namespace ts {
|
|||
// For example, when a variable of type number | string | boolean is assigned a value of type number | boolean,
|
||||
// we remove type string.
|
||||
function getAssignmentReducedType(declaredType: UnionType, assignedType: Type) {
|
||||
if (declaredType !== assignedType && declaredType.flags & TypeFlags.Union) {
|
||||
const reducedTypes = filter(declaredType.types, t => typeMaybeAssignableTo(assignedType, t));
|
||||
if (reducedTypes.length) {
|
||||
return reducedTypes.length === 1 ? reducedTypes[0] : getUnionType(reducedTypes);
|
||||
if (declaredType !== assignedType) {
|
||||
const reducedType = filterType(declaredType, t => typeMaybeAssignableTo(assignedType, t));
|
||||
if (reducedType !== neverType) {
|
||||
return reducedType;
|
||||
}
|
||||
}
|
||||
return declaredType;
|
||||
|
@ -7902,6 +7929,14 @@ namespace ts {
|
|||
return result;
|
||||
}
|
||||
|
||||
function isFunctionObjectType(type: ObjectType): boolean {
|
||||
// We do a quick check for a "bind" property before performing the more expensive subtype
|
||||
// check. This gives us a quicker out in the common case where an object type is not a function.
|
||||
const resolved = resolveStructuredTypeMembers(type);
|
||||
return !!(resolved.callSignatures.length || resolved.constructSignatures.length ||
|
||||
hasProperty(resolved.members, "bind") && isTypeSubtypeOf(type, globalFunctionType));
|
||||
}
|
||||
|
||||
function getTypeFacts(type: Type): TypeFacts {
|
||||
const flags = type.flags;
|
||||
if (flags & TypeFlags.String) {
|
||||
|
@ -7930,8 +7965,7 @@ namespace ts {
|
|||
type === falseType ? TypeFacts.FalseFacts : TypeFacts.TrueFacts;
|
||||
}
|
||||
if (flags & TypeFlags.ObjectType) {
|
||||
const resolved = resolveStructuredTypeMembers(type);
|
||||
return resolved.callSignatures.length || resolved.constructSignatures.length || isTypeSubtypeOf(type, globalFunctionType) ?
|
||||
return isFunctionObjectType(<ObjectType>type) ?
|
||||
strictNullChecks ? TypeFacts.FunctionStrictFacts : TypeFacts.FunctionFacts :
|
||||
strictNullChecks ? TypeFacts.ObjectStrictFacts : TypeFacts.ObjectFacts;
|
||||
}
|
||||
|
@ -7955,26 +7989,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
function getTypeWithFacts(type: Type, include: TypeFacts) {
|
||||
if (!(type.flags & TypeFlags.Union)) {
|
||||
return getTypeFacts(type) & include ? type : neverType;
|
||||
}
|
||||
let firstType: Type;
|
||||
let types: Type[];
|
||||
for (const t of (type as UnionType).types) {
|
||||
if (getTypeFacts(t) & include) {
|
||||
if (!firstType) {
|
||||
firstType = t;
|
||||
}
|
||||
else {
|
||||
if (!types) {
|
||||
types = [firstType];
|
||||
}
|
||||
types.push(t);
|
||||
}
|
||||
}
|
||||
}
|
||||
return types ? getUnionType(types) :
|
||||
firstType ? firstType : neverType;
|
||||
return filterType(type, t => (getTypeFacts(t) & include) !== 0);
|
||||
}
|
||||
|
||||
function getTypeWithDefault(type: Type, defaultExpression: Expression) {
|
||||
|
@ -8150,9 +8165,12 @@ namespace ts {
|
|||
}
|
||||
|
||||
function filterType(type: Type, f: (t: Type) => boolean): Type {
|
||||
return type.flags & TypeFlags.Union ?
|
||||
getUnionType(filter((<UnionType>type).types, f)) :
|
||||
f(type) ? type : neverType;
|
||||
if (type.flags & TypeFlags.Union) {
|
||||
const types = (<UnionType>type).types;
|
||||
const filtered = filter(types, f);
|
||||
return filtered === types ? type : getUnionTypeFromSortedList(filtered);
|
||||
}
|
||||
return f(type) ? type : neverType;
|
||||
}
|
||||
|
||||
function isIncomplete(flowType: FlowType) {
|
||||
|
@ -8490,7 +8508,7 @@ namespace ts {
|
|||
}
|
||||
if (assumeTrue && !(type.flags & TypeFlags.Union)) {
|
||||
// We narrow a non-union type to an exact primitive type if the non-union type
|
||||
// is a supertype of that primtive type. For example, type 'any' can be narrowed
|
||||
// is a supertype of that primitive type. For example, type 'any' can be narrowed
|
||||
// to one of the primitive types.
|
||||
const targetType = getProperty(typeofTypesByName, literal.text);
|
||||
if (targetType && isTypeSubtypeOf(targetType, type)) {
|
||||
|
@ -8579,9 +8597,9 @@ namespace ts {
|
|||
// If the current type is a union type, remove all constituents that couldn't be instances of
|
||||
// the candidate type. If one or more constituents remain, return a union of those.
|
||||
if (type.flags & TypeFlags.Union) {
|
||||
const assignableConstituents = filter((<UnionType>type).types, t => isTypeInstanceOf(t, candidate));
|
||||
if (assignableConstituents.length) {
|
||||
return getUnionType(assignableConstituents);
|
||||
const assignableType = filterType(type, t => isTypeInstanceOf(t, candidate));
|
||||
if (assignableType !== neverType) {
|
||||
return assignableType;
|
||||
}
|
||||
}
|
||||
// If the candidate type is a subtype of the target type, narrow to the candidate type.
|
||||
|
@ -16367,7 +16385,7 @@ namespace ts {
|
|||
const implementedTypeNodes = getClassImplementsHeritageClauseElements(node);
|
||||
if (implementedTypeNodes) {
|
||||
for (const typeRefNode of implementedTypeNodes) {
|
||||
if (!isSupportedExpressionWithTypeArguments(typeRefNode)) {
|
||||
if (!isEntityNameExpression(typeRefNode.expression)) {
|
||||
error(typeRefNode.expression, Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
|
||||
}
|
||||
checkTypeReferenceNode(typeRefNode);
|
||||
|
@ -16609,7 +16627,7 @@ namespace ts {
|
|||
checkObjectTypeForDuplicateDeclarations(node);
|
||||
}
|
||||
forEach(getInterfaceBaseTypeNodes(node), heritageElement => {
|
||||
if (!isSupportedExpressionWithTypeArguments(heritageElement)) {
|
||||
if (!isEntityNameExpression(heritageElement.expression)) {
|
||||
error(heritageElement.expression, Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments);
|
||||
}
|
||||
checkTypeReferenceNode(heritageElement);
|
||||
|
@ -17074,20 +17092,21 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
|
||||
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);
|
||||
function getFirstIdentifier(node: EntityNameOrEntityNameExpression): Identifier {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.Identifier:
|
||||
return <Identifier>node;
|
||||
case SyntaxKind.QualifiedName:
|
||||
do {
|
||||
node = (<QualifiedName>node).left;
|
||||
} while (node.kind !== SyntaxKind.Identifier);
|
||||
return <Identifier>node;
|
||||
case SyntaxKind.PropertyAccessExpression:
|
||||
do {
|
||||
node = (<PropertyAccessEntityNameExpression>node).expression;
|
||||
} while (node.kind !== SyntaxKind.Identifier);
|
||||
return <Identifier>node;
|
||||
}
|
||||
}
|
||||
|
||||
function checkExternalImportOrExportDeclaration(node: ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration): boolean {
|
||||
|
@ -17786,7 +17805,7 @@ namespace ts {
|
|||
return getLeftSideOfImportEqualsOrExportAssignment(node) !== undefined;
|
||||
}
|
||||
|
||||
function getSymbolOfEntityNameOrPropertyAccessExpression(entityName: EntityName | PropertyAccessExpression): Symbol {
|
||||
function getSymbolOfEntityNameOrPropertyAccessExpression(entityName: EntityName | PropertyAccessExpression): Symbol | undefined {
|
||||
if (isDeclarationName(entityName)) {
|
||||
return getSymbolOfNode(entityName.parent);
|
||||
}
|
||||
|
@ -17805,22 +17824,20 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
|
||||
if (entityName.parent.kind === SyntaxKind.ExportAssignment) {
|
||||
return resolveEntityName(<Identifier>entityName,
|
||||
if (entityName.parent.kind === SyntaxKind.ExportAssignment && isEntityNameExpression(<Identifier | PropertyAccessExpression>entityName)) {
|
||||
return resolveEntityName(<EntityNameExpression>entityName,
|
||||
/*all meanings*/ SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias);
|
||||
}
|
||||
|
||||
if (entityName.kind !== SyntaxKind.PropertyAccessExpression) {
|
||||
if (isInRightSideOfImportOrExportAssignment(<EntityName>entityName)) {
|
||||
if (entityName.kind !== SyntaxKind.PropertyAccessExpression && isInRightSideOfImportOrExportAssignment(<EntityName>entityName)) {
|
||||
// Since we already checked for ExportAssignment, this really could only be an Import
|
||||
const importEqualsDeclaration = <ImportEqualsDeclaration>getAncestor(entityName, SyntaxKind.ImportEqualsDeclaration);
|
||||
Debug.assert(importEqualsDeclaration !== undefined);
|
||||
return getSymbolOfPartOfRightHandSideOfImportEquals(<EntityName>entityName, importEqualsDeclaration, /*dontResolveAlias*/ true);
|
||||
}
|
||||
}
|
||||
|
||||
if (isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
|
||||
entityName = <QualifiedName | PropertyAccessExpression>entityName.parent;
|
||||
entityName = <QualifiedName | PropertyAccessEntityNameExpression>entityName.parent;
|
||||
}
|
||||
|
||||
if (isHeritageClauseElementIdentifier(<EntityName>entityName)) {
|
||||
|
@ -18530,7 +18547,7 @@ namespace ts {
|
|||
};
|
||||
|
||||
// defined here to avoid outer scope pollution
|
||||
function getTypeReferenceDirectivesForEntityName(node: EntityName | PropertyAccessExpression): string[] {
|
||||
function getTypeReferenceDirectivesForEntityName(node: EntityNameOrEntityNameExpression): string[] {
|
||||
// program does not have any files with type reference directives - bail out
|
||||
if (!fileToDirective) {
|
||||
return undefined;
|
||||
|
|
|
@ -97,7 +97,7 @@ namespace ts {
|
|||
* returns a truthy value, then returns that value.
|
||||
* If no such value is found, the callback is applied to each element of array and undefined is returned.
|
||||
*/
|
||||
export function forEach<T, U>(array: T[], callback: (element: T, index: number) => U): U {
|
||||
export function forEach<T, U>(array: T[] | undefined, callback: (element: T, index: number) => U | undefined): U | undefined {
|
||||
if (array) {
|
||||
for (let i = 0, len = array.length; i < len; i++) {
|
||||
const result = callback(array[i], i);
|
||||
|
@ -109,6 +109,17 @@ namespace ts {
|
|||
return undefined;
|
||||
}
|
||||
|
||||
/** Like `forEach`, but assumes existence of array and fails if no truthy value is found. */
|
||||
export function find<T, U>(array: T[], callback: (element: T, index: number) => U | undefined): U {
|
||||
for (let i = 0, len = array.length; i < len; i++) {
|
||||
const result = callback(array[i], i);
|
||||
if (result) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
Debug.fail();
|
||||
}
|
||||
|
||||
export function contains<T>(array: T[], value: T): boolean {
|
||||
if (array) {
|
||||
for (const v of array) {
|
||||
|
@ -152,18 +163,30 @@ namespace ts {
|
|||
return count;
|
||||
}
|
||||
|
||||
/**
|
||||
* Filters an array by a predicate function. Returns the same array instance if the predicate is
|
||||
* true for all elements, otherwise returns a new array instance containing the filtered subset.
|
||||
*/
|
||||
export function filter<T>(array: T[], f: (x: T) => boolean): T[] {
|
||||
let result: T[];
|
||||
if (array) {
|
||||
result = [];
|
||||
for (const item of array) {
|
||||
const len = array.length;
|
||||
let i = 0;
|
||||
while (i < len && f(array[i])) i++;
|
||||
if (i < len) {
|
||||
const result = array.slice(0, i);
|
||||
i++;
|
||||
while (i < len) {
|
||||
const item = array[i];
|
||||
if (f(item)) {
|
||||
result.push(item);
|
||||
}
|
||||
}
|
||||
i++;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
export function filterMutate<T>(array: T[], f: (x: T) => boolean): void {
|
||||
let outIndex = 0;
|
||||
|
|
|
@ -441,7 +441,7 @@ namespace ts {
|
|||
}
|
||||
}
|
||||
|
||||
function emitEntityName(entityName: EntityName | PropertyAccessExpression) {
|
||||
function emitEntityName(entityName: EntityNameOrEntityNameExpression) {
|
||||
const visibilityResult = resolver.isEntityNameVisible(entityName,
|
||||
// Aliases can be written asynchronously so use correct enclosing declaration
|
||||
entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration ? entityName.parent : enclosingDeclaration);
|
||||
|
@ -452,9 +452,9 @@ namespace ts {
|
|||
}
|
||||
|
||||
function emitExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {
|
||||
if (isSupportedExpressionWithTypeArguments(node)) {
|
||||
if (isEntityNameExpression(node.expression)) {
|
||||
Debug.assert(node.expression.kind === SyntaxKind.Identifier || node.expression.kind === SyntaxKind.PropertyAccessExpression);
|
||||
emitEntityName(<Identifier | PropertyAccessExpression>node.expression);
|
||||
emitEntityName(node.expression);
|
||||
if (node.typeArguments) {
|
||||
write("<");
|
||||
emitCommaList(node.typeArguments, emitType);
|
||||
|
@ -1019,7 +1019,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
function emitTypeOfTypeReference(node: ExpressionWithTypeArguments) {
|
||||
if (isSupportedExpressionWithTypeArguments(node)) {
|
||||
if (isEntityNameExpression(node.expression)) {
|
||||
emitTypeWithNewGetSymbolAccessibilityDiagnostic(node, getHeritageClauseVisibilityError);
|
||||
}
|
||||
else if (!isImplementsList && node.expression.kind === SyntaxKind.NullKeyword) {
|
||||
|
|
|
@ -119,49 +119,31 @@ namespace ts {
|
|||
}
|
||||
|
||||
function tryReadTypesSection(packageJsonPath: string, baseDirectory: string, state: ModuleResolutionState): string {
|
||||
let jsonContent: { typings?: string, types?: string, main?: string };
|
||||
try {
|
||||
const jsonText = state.host.readFile(packageJsonPath);
|
||||
jsonContent = jsonText ? <{ typings?: string, types?: string, main?: string }>JSON.parse(jsonText) : {};
|
||||
}
|
||||
catch (e) {
|
||||
// gracefully handle if readFile fails or returns not JSON
|
||||
jsonContent = {};
|
||||
}
|
||||
const jsonContent = readJson(packageJsonPath, state.host);
|
||||
|
||||
let typesFile: string;
|
||||
let fieldName: string;
|
||||
// first try to read content of 'typings' section (backward compatibility)
|
||||
if (jsonContent.typings) {
|
||||
if (typeof jsonContent.typings === "string") {
|
||||
fieldName = "typings";
|
||||
typesFile = jsonContent.typings;
|
||||
}
|
||||
else {
|
||||
if (state.traceEnabled) {
|
||||
trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_string_got_1, "typings", typeof jsonContent.typings);
|
||||
}
|
||||
}
|
||||
}
|
||||
// then read 'types'
|
||||
if (!typesFile && jsonContent.types) {
|
||||
if (typeof jsonContent.types === "string") {
|
||||
fieldName = "types";
|
||||
typesFile = jsonContent.types;
|
||||
}
|
||||
else {
|
||||
if (state.traceEnabled) {
|
||||
trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_string_got_1, "types", typeof jsonContent.types);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (typesFile) {
|
||||
function tryReadFromField(fieldName: string) {
|
||||
if (hasProperty(jsonContent, fieldName)) {
|
||||
const typesFile = (<any>jsonContent)[fieldName];
|
||||
if (typeof typesFile === "string") {
|
||||
const typesFilePath = normalizePath(combinePaths(baseDirectory, typesFile));
|
||||
if (state.traceEnabled) {
|
||||
trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, typesFile, typesFilePath);
|
||||
}
|
||||
return typesFilePath;
|
||||
}
|
||||
else {
|
||||
if (state.traceEnabled) {
|
||||
trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_string_got_1, fieldName, typeof typesFile);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const typesFilePath = tryReadFromField("typings") || tryReadFromField("types");
|
||||
if (typesFilePath) {
|
||||
return typesFilePath;
|
||||
}
|
||||
|
||||
// Use the main module for inferring types if no types package specified and the allowJs is set
|
||||
if (state.compilerOptions.allowJs && jsonContent.main && typeof jsonContent.main === "string") {
|
||||
if (state.traceEnabled) {
|
||||
|
@ -173,6 +155,17 @@ namespace ts {
|
|||
return undefined;
|
||||
}
|
||||
|
||||
function readJson(path: string, host: ModuleResolutionHost): { typings?: string, types?: string, main?: string } {
|
||||
try {
|
||||
const jsonText = host.readFile(path);
|
||||
return jsonText ? JSON.parse(jsonText) : {};
|
||||
}
|
||||
catch (e) {
|
||||
// gracefully handle if readFile fails or returns not JSON
|
||||
return {};
|
||||
}
|
||||
}
|
||||
|
||||
const typeReferenceExtensions = [".d.ts"];
|
||||
|
||||
function getEffectiveTypeRoots(options: CompilerOptions, host: ModuleResolutionHost) {
|
||||
|
@ -717,7 +710,7 @@ namespace ts {
|
|||
}
|
||||
|
||||
function loadNodeModuleFromDirectory(extensions: string[], candidate: string, failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string {
|
||||
const packageJsonPath = combinePaths(candidate, "package.json");
|
||||
const packageJsonPath = pathToPackageJson(candidate);
|
||||
const directoryExists = !onlyRecordFailures && directoryProbablyExists(candidate, state.host);
|
||||
if (directoryExists && state.host.fileExists(packageJsonPath)) {
|
||||
if (state.traceEnabled) {
|
||||
|
@ -747,6 +740,10 @@ namespace ts {
|
|||
return loadModuleFromFile(combinePaths(candidate, "index"), extensions, failedLookupLocation, !directoryExists, state);
|
||||
}
|
||||
|
||||
function pathToPackageJson(directory: string): string {
|
||||
return combinePaths(directory, "package.json");
|
||||
}
|
||||
|
||||
function loadModuleFromNodeModulesFolder(moduleName: string, directory: string, failedLookupLocations: string[], state: ModuleResolutionState): string {
|
||||
const nodeModulesFolder = combinePaths(directory, "node_modules");
|
||||
const nodeModulesFolderExists = directoryProbablyExists(nodeModulesFolder, state.host);
|
||||
|
@ -1070,15 +1067,21 @@ namespace ts {
|
|||
}
|
||||
|
||||
// Walk the primary type lookup locations
|
||||
let result: string[] = [];
|
||||
const result: string[] = [];
|
||||
if (host.directoryExists && host.getDirectories) {
|
||||
const typeRoots = getEffectiveTypeRoots(options, host);
|
||||
if (typeRoots) {
|
||||
for (const root of typeRoots) {
|
||||
if (host.directoryExists(root)) {
|
||||
for (const typeDirectivePath of host.getDirectories(root)) {
|
||||
const normalized = normalizePath(typeDirectivePath);
|
||||
const packageJsonPath = pathToPackageJson(combinePaths(root, normalized));
|
||||
// tslint:disable-next-line:no-null-keyword
|
||||
const isNotNeededPackage = host.fileExists(packageJsonPath) && readJson(packageJsonPath, host).typings === null;
|
||||
if (!isNotNeededPackage) {
|
||||
// Return just the type directive names
|
||||
result = result.concat(getBaseFileName(normalizePath(typeDirectivePath)));
|
||||
result.push(getBaseFileName(normalized));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -986,13 +986,19 @@ namespace ts {
|
|||
multiLine?: boolean;
|
||||
}
|
||||
|
||||
export type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression;
|
||||
export type EntityNameOrEntityNameExpression = EntityName | EntityNameExpression;
|
||||
|
||||
// @kind(SyntaxKind.PropertyAccessExpression)
|
||||
export interface PropertyAccessExpression extends MemberExpression, Declaration {
|
||||
expression: LeftHandSideExpression;
|
||||
name: Identifier;
|
||||
}
|
||||
|
||||
export type IdentifierOrPropertyAccess = Identifier | PropertyAccessExpression;
|
||||
/** Brand for a PropertyAccessExpression which, like a QualifiedName, consists of a sequence of identifiers separated by dots. */
|
||||
export interface PropertyAccessEntityNameExpression extends PropertyAccessExpression {
|
||||
_propertyAccessExpressionLikeQualifiedNameBrand?: any;
|
||||
expression: EntityNameExpression;
|
||||
}
|
||||
|
||||
// @kind(SyntaxKind.ElementAccessExpression)
|
||||
export interface ElementAccessExpression extends MemberExpression {
|
||||
|
@ -2035,7 +2041,7 @@ namespace ts {
|
|||
writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
|
||||
writeBaseConstructorTypeOfClass(node: ClassLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
|
||||
isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessibilityResult;
|
||||
isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult;
|
||||
// Returns the constant value this property access resolves to, or 'undefined' for a non-constant
|
||||
getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
|
||||
getReferencedValueDeclaration(reference: Identifier): Declaration;
|
||||
|
@ -2044,7 +2050,7 @@ namespace ts {
|
|||
moduleExportsSomeValue(moduleReferenceExpression: Expression): boolean;
|
||||
isArgumentsLocalBinding(node: Identifier): boolean;
|
||||
getExternalModuleFileFromDeclaration(declaration: ImportEqualsDeclaration | ImportDeclaration | ExportDeclaration | ModuleDeclaration): SourceFile;
|
||||
getTypeReferenceDirectivesForEntityName(name: EntityName | PropertyAccessExpression): string[];
|
||||
getTypeReferenceDirectivesForEntityName(name: EntityNameOrEntityNameExpression): string[];
|
||||
getTypeReferenceDirectivesForSymbol(symbol: Symbol, meaning?: SymbolFlags): string[];
|
||||
}
|
||||
|
||||
|
@ -2373,6 +2379,7 @@ namespace ts {
|
|||
|
||||
export interface TupleType extends ObjectType {
|
||||
elementTypes: Type[]; // Element types
|
||||
thisType?: Type; // This-type of tuple (only needed for tuples that are constraints of type parameters)
|
||||
}
|
||||
|
||||
export interface UnionOrIntersectionType extends Type {
|
||||
|
|
|
@ -1033,14 +1033,14 @@ namespace ts {
|
|||
&& (<PropertyAccessExpression | ElementAccessExpression>node).expression.kind === SyntaxKind.SuperKeyword;
|
||||
}
|
||||
|
||||
|
||||
export function getEntityNameFromTypeNode(node: TypeNode): EntityName | Expression {
|
||||
export function getEntityNameFromTypeNode(node: TypeNode): EntityNameOrEntityNameExpression {
|
||||
if (node) {
|
||||
switch (node.kind) {
|
||||
case SyntaxKind.TypeReference:
|
||||
return (<TypeReferenceNode>node).typeName;
|
||||
case SyntaxKind.ExpressionWithTypeArguments:
|
||||
return (<ExpressionWithTypeArguments>node).expression;
|
||||
Debug.assert(isEntityNameExpression((<ExpressionWithTypeArguments>node).expression));
|
||||
return <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression;
|
||||
case SyntaxKind.Identifier:
|
||||
case SyntaxKind.QualifiedName:
|
||||
return (<EntityName><Node>node);
|
||||
|
@ -1694,8 +1694,8 @@ namespace ts {
|
|||
// import * as <symbol> from ...
|
||||
// import { x as <symbol> } from ...
|
||||
// export { x as <symbol> } from ...
|
||||
// export = ...
|
||||
// export default ...
|
||||
// export = <EntityNameExpression>
|
||||
// export default <EntityNameExpression>
|
||||
export function isAliasSymbolDeclaration(node: Node): boolean {
|
||||
return node.kind === SyntaxKind.ImportEqualsDeclaration ||
|
||||
node.kind === SyntaxKind.NamespaceExportDeclaration ||
|
||||
|
@ -1703,7 +1703,11 @@ namespace ts {
|
|||
node.kind === SyntaxKind.NamespaceImport ||
|
||||
node.kind === SyntaxKind.ImportSpecifier ||
|
||||
node.kind === SyntaxKind.ExportSpecifier ||
|
||||
node.kind === SyntaxKind.ExportAssignment && (<ExportAssignment>node).expression.kind === SyntaxKind.Identifier;
|
||||
node.kind === SyntaxKind.ExportAssignment && exportAssignmentIsAlias(<ExportAssignment>node);
|
||||
}
|
||||
|
||||
export function exportAssignmentIsAlias(node: ExportAssignment): boolean {
|
||||
return isEntityNameExpression(node.expression);
|
||||
}
|
||||
|
||||
export function getClassExtendsHeritageClauseElement(node: ClassLikeDeclaration | InterfaceDeclaration) {
|
||||
|
@ -2676,22 +2680,9 @@ namespace ts {
|
|||
isClassLike(node.parent.parent);
|
||||
}
|
||||
|
||||
// Returns false if this heritage clause element's expression contains something unsupported
|
||||
// (i.e. not a name or dotted name).
|
||||
export function isSupportedExpressionWithTypeArguments(node: ExpressionWithTypeArguments): boolean {
|
||||
return isSupportedExpressionWithTypeArgumentsRest(node.expression);
|
||||
}
|
||||
|
||||
function isSupportedExpressionWithTypeArgumentsRest(node: Expression): boolean {
|
||||
if (node.kind === SyntaxKind.Identifier) {
|
||||
return true;
|
||||
}
|
||||
else if (isPropertyAccessExpression(node)) {
|
||||
return isSupportedExpressionWithTypeArgumentsRest(node.expression);
|
||||
}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
export function isEntityNameExpression(node: Expression): node is EntityNameExpression {
|
||||
return node.kind === SyntaxKind.Identifier ||
|
||||
node.kind === SyntaxKind.PropertyAccessExpression && isEntityNameExpression((<PropertyAccessExpression>node).expression);
|
||||
}
|
||||
|
||||
export function isRightSideOfQualifiedNameOrPropertyAccess(node: Node) {
|
||||
|
|
|
@ -52,7 +52,7 @@ class CompilerBaselineRunner extends RunnerBase {
|
|||
private makeUnitName(name: string, root: string) {
|
||||
const path = ts.toPath(name, root, (fileName) => Harness.Compiler.getCanonicalFileName(fileName));
|
||||
const pathStart = ts.toPath(Harness.IO.getCurrentDirectory(), "", (fileName) => Harness.Compiler.getCanonicalFileName(fileName));
|
||||
return path.replace(pathStart, "/");
|
||||
return pathStart ? path.replace(pathStart, "/") : path;
|
||||
};
|
||||
|
||||
public checkTestCodeOutput(fileName: string) {
|
||||
|
|
|
@ -2395,13 +2395,14 @@ ${code}
|
|||
// Comment line, check for global/file @options and record them
|
||||
const match = optionRegex.exec(line.substr(2));
|
||||
if (match) {
|
||||
const fileMetadataNamesIndex = fileMetadataNames.indexOf(match[1]);
|
||||
const [key, value] = match.slice(1);
|
||||
const fileMetadataNamesIndex = fileMetadataNames.indexOf(key);
|
||||
if (fileMetadataNamesIndex === -1) {
|
||||
// Check if the match is already existed in the global options
|
||||
if (globalOptions[match[1]] !== undefined) {
|
||||
throw new Error("Global Option : '" + match[1] + "' is already existed");
|
||||
if (globalOptions[key] !== undefined) {
|
||||
throw new Error(`Global option '${key}' already exists`);
|
||||
}
|
||||
globalOptions[match[1]] = match[2];
|
||||
globalOptions[key] = value;
|
||||
}
|
||||
else {
|
||||
if (fileMetadataNamesIndex === fileMetadataNames.indexOf(metadataOptionNames.fileName)) {
|
||||
|
@ -2416,12 +2417,12 @@ ${code}
|
|||
resetLocalData();
|
||||
}
|
||||
|
||||
currentFileName = basePath + "/" + match[2];
|
||||
currentFileOptions[match[1]] = match[2];
|
||||
currentFileName = basePath + "/" + value;
|
||||
currentFileOptions[key] = value;
|
||||
}
|
||||
else {
|
||||
// Add other fileMetadata flag
|
||||
currentFileOptions[match[1]] = match[2];
|
||||
currentFileOptions[key] = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -2509,7 +2510,7 @@ ${code}
|
|||
}
|
||||
|
||||
const marker: Marker = {
|
||||
fileName: fileName,
|
||||
fileName,
|
||||
position: location.position,
|
||||
data: markerValue
|
||||
};
|
||||
|
@ -2526,7 +2527,7 @@ ${code}
|
|||
|
||||
function recordMarker(fileName: string, location: LocationInformation, name: string, markerMap: MarkerMap, markers: Marker[]): Marker {
|
||||
const marker: Marker = {
|
||||
fileName: fileName,
|
||||
fileName,
|
||||
position: location.position
|
||||
};
|
||||
|
||||
|
|
|
@ -106,7 +106,7 @@ namespace ts.server {
|
|||
describe("onMessage", () => {
|
||||
it("should not throw when commands are executed with invalid arguments", () => {
|
||||
let i = 0;
|
||||
for (name in CommandNames) {
|
||||
for (const name in CommandNames) {
|
||||
if (!Object.prototype.hasOwnProperty.call(CommandNames, name)) {
|
||||
continue;
|
||||
}
|
||||
|
|
20
src/lib/es2015.iterable.d.ts
vendored
20
src/lib/es2015.iterable.d.ts
vendored
|
@ -63,6 +63,26 @@ interface ArrayConstructor {
|
|||
from<T>(iterable: Iterable<T>): Array<T>;
|
||||
}
|
||||
|
||||
interface ReadonlyArray<T> {
|
||||
/** Iterator */
|
||||
[Symbol.iterator](): IterableIterator<T>;
|
||||
|
||||
/**
|
||||
* Returns an array of key, value pairs for every entry in the array
|
||||
*/
|
||||
entries(): IterableIterator<[number, T]>;
|
||||
|
||||
/**
|
||||
* Returns an list of keys in the array
|
||||
*/
|
||||
keys(): IterableIterator<number>;
|
||||
|
||||
/**
|
||||
* Returns an list of values in the array
|
||||
*/
|
||||
values(): IterableIterator<T>;
|
||||
}
|
||||
|
||||
interface IArguments {
|
||||
/** Iterator */
|
||||
[Symbol.iterator](): IterableIterator<any>;
|
||||
|
|
84
tests/baselines/reference/discriminantsAndPrimitives.js
Normal file
84
tests/baselines/reference/discriminantsAndPrimitives.js
Normal file
|
@ -0,0 +1,84 @@
|
|||
//// [discriminantsAndPrimitives.ts]
|
||||
|
||||
// Repro from #10257 plus other tests
|
||||
|
||||
interface Foo {
|
||||
kind: "foo";
|
||||
name: string;
|
||||
}
|
||||
|
||||
interface Bar {
|
||||
kind: "bar";
|
||||
length: string;
|
||||
}
|
||||
|
||||
function f1(x: Foo | Bar | string) {
|
||||
if (typeof x !== 'string') {
|
||||
switch(x.kind) {
|
||||
case 'foo':
|
||||
x.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f2(x: Foo | Bar | string | undefined) {
|
||||
if (typeof x === "object") {
|
||||
switch(x.kind) {
|
||||
case 'foo':
|
||||
x.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f3(x: Foo | Bar | string | null) {
|
||||
if (x && typeof x !== "string") {
|
||||
switch(x.kind) {
|
||||
case 'foo':
|
||||
x.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f4(x: Foo | Bar | string | number | null) {
|
||||
if (x && typeof x === "object") {
|
||||
switch(x.kind) {
|
||||
case 'foo':
|
||||
x.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//// [discriminantsAndPrimitives.js]
|
||||
// Repro from #10257 plus other tests
|
||||
function f1(x) {
|
||||
if (typeof x !== 'string') {
|
||||
switch (x.kind) {
|
||||
case 'foo':
|
||||
x.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
function f2(x) {
|
||||
if (typeof x === "object") {
|
||||
switch (x.kind) {
|
||||
case 'foo':
|
||||
x.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
function f3(x) {
|
||||
if (x && typeof x !== "string") {
|
||||
switch (x.kind) {
|
||||
case 'foo':
|
||||
x.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
function f4(x) {
|
||||
if (x && typeof x === "object") {
|
||||
switch (x.kind) {
|
||||
case 'foo':
|
||||
x.name;
|
||||
}
|
||||
}
|
||||
}
|
117
tests/baselines/reference/discriminantsAndPrimitives.symbols
Normal file
117
tests/baselines/reference/discriminantsAndPrimitives.symbols
Normal file
|
@ -0,0 +1,117 @@
|
|||
=== tests/cases/compiler/discriminantsAndPrimitives.ts ===
|
||||
|
||||
// Repro from #10257 plus other tests
|
||||
|
||||
interface Foo {
|
||||
>Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0))
|
||||
|
||||
kind: "foo";
|
||||
>kind : Symbol(Foo.kind, Decl(discriminantsAndPrimitives.ts, 3, 15))
|
||||
|
||||
name: string;
|
||||
>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
|
||||
}
|
||||
|
||||
interface Bar {
|
||||
>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1))
|
||||
|
||||
kind: "bar";
|
||||
>kind : Symbol(Bar.kind, Decl(discriminantsAndPrimitives.ts, 8, 15))
|
||||
|
||||
length: string;
|
||||
>length : Symbol(Bar.length, Decl(discriminantsAndPrimitives.ts, 9, 16))
|
||||
}
|
||||
|
||||
function f1(x: Foo | Bar | string) {
|
||||
>f1 : Symbol(f1, Decl(discriminantsAndPrimitives.ts, 11, 1))
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12))
|
||||
>Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0))
|
||||
>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1))
|
||||
|
||||
if (typeof x !== 'string') {
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12))
|
||||
|
||||
switch(x.kind) {
|
||||
>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12))
|
||||
>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
|
||||
|
||||
case 'foo':
|
||||
x.name;
|
||||
>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12))
|
||||
>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f2(x: Foo | Bar | string | undefined) {
|
||||
>f2 : Symbol(f2, Decl(discriminantsAndPrimitives.ts, 20, 1))
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12))
|
||||
>Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0))
|
||||
>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1))
|
||||
|
||||
if (typeof x === "object") {
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12))
|
||||
|
||||
switch(x.kind) {
|
||||
>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12))
|
||||
>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
|
||||
|
||||
case 'foo':
|
||||
x.name;
|
||||
>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12))
|
||||
>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f3(x: Foo | Bar | string | null) {
|
||||
>f3 : Symbol(f3, Decl(discriminantsAndPrimitives.ts, 29, 1))
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12))
|
||||
>Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0))
|
||||
>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1))
|
||||
|
||||
if (x && typeof x !== "string") {
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12))
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12))
|
||||
|
||||
switch(x.kind) {
|
||||
>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12))
|
||||
>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
|
||||
|
||||
case 'foo':
|
||||
x.name;
|
||||
>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12))
|
||||
>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f4(x: Foo | Bar | string | number | null) {
|
||||
>f4 : Symbol(f4, Decl(discriminantsAndPrimitives.ts, 38, 1))
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12))
|
||||
>Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0))
|
||||
>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1))
|
||||
|
||||
if (x && typeof x === "object") {
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12))
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12))
|
||||
|
||||
switch(x.kind) {
|
||||
>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12))
|
||||
>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
|
||||
|
||||
case 'foo':
|
||||
x.name;
|
||||
>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
|
||||
>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12))
|
||||
>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
|
||||
}
|
||||
}
|
||||
}
|
141
tests/baselines/reference/discriminantsAndPrimitives.types
Normal file
141
tests/baselines/reference/discriminantsAndPrimitives.types
Normal file
|
@ -0,0 +1,141 @@
|
|||
=== tests/cases/compiler/discriminantsAndPrimitives.ts ===
|
||||
|
||||
// Repro from #10257 plus other tests
|
||||
|
||||
interface Foo {
|
||||
>Foo : Foo
|
||||
|
||||
kind: "foo";
|
||||
>kind : "foo"
|
||||
|
||||
name: string;
|
||||
>name : string
|
||||
}
|
||||
|
||||
interface Bar {
|
||||
>Bar : Bar
|
||||
|
||||
kind: "bar";
|
||||
>kind : "bar"
|
||||
|
||||
length: string;
|
||||
>length : string
|
||||
}
|
||||
|
||||
function f1(x: Foo | Bar | string) {
|
||||
>f1 : (x: string | Foo | Bar) => void
|
||||
>x : string | Foo | Bar
|
||||
>Foo : Foo
|
||||
>Bar : Bar
|
||||
|
||||
if (typeof x !== 'string') {
|
||||
>typeof x !== 'string' : boolean
|
||||
>typeof x : string
|
||||
>x : string | Foo | Bar
|
||||
>'string' : "string"
|
||||
|
||||
switch(x.kind) {
|
||||
>x.kind : "foo" | "bar"
|
||||
>x : Foo | Bar
|
||||
>kind : "foo" | "bar"
|
||||
|
||||
case 'foo':
|
||||
>'foo' : "foo"
|
||||
|
||||
x.name;
|
||||
>x.name : string
|
||||
>x : Foo
|
||||
>name : string
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f2(x: Foo | Bar | string | undefined) {
|
||||
>f2 : (x: string | Foo | Bar | undefined) => void
|
||||
>x : string | Foo | Bar | undefined
|
||||
>Foo : Foo
|
||||
>Bar : Bar
|
||||
|
||||
if (typeof x === "object") {
|
||||
>typeof x === "object" : boolean
|
||||
>typeof x : string
|
||||
>x : string | Foo | Bar | undefined
|
||||
>"object" : "object"
|
||||
|
||||
switch(x.kind) {
|
||||
>x.kind : "foo" | "bar"
|
||||
>x : Foo | Bar
|
||||
>kind : "foo" | "bar"
|
||||
|
||||
case 'foo':
|
||||
>'foo' : "foo"
|
||||
|
||||
x.name;
|
||||
>x.name : string
|
||||
>x : Foo
|
||||
>name : string
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f3(x: Foo | Bar | string | null) {
|
||||
>f3 : (x: string | Foo | Bar | null) => void
|
||||
>x : string | Foo | Bar | null
|
||||
>Foo : Foo
|
||||
>Bar : Bar
|
||||
>null : null
|
||||
|
||||
if (x && typeof x !== "string") {
|
||||
>x && typeof x !== "string" : boolean | "" | null
|
||||
>x : string | Foo | Bar | null
|
||||
>typeof x !== "string" : boolean
|
||||
>typeof x : string
|
||||
>x : string | Foo | Bar
|
||||
>"string" : "string"
|
||||
|
||||
switch(x.kind) {
|
||||
>x.kind : "foo" | "bar"
|
||||
>x : Foo | Bar
|
||||
>kind : "foo" | "bar"
|
||||
|
||||
case 'foo':
|
||||
>'foo' : "foo"
|
||||
|
||||
x.name;
|
||||
>x.name : string
|
||||
>x : Foo
|
||||
>name : string
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f4(x: Foo | Bar | string | number | null) {
|
||||
>f4 : (x: string | number | Foo | Bar | null) => void
|
||||
>x : string | number | Foo | Bar | null
|
||||
>Foo : Foo
|
||||
>Bar : Bar
|
||||
>null : null
|
||||
|
||||
if (x && typeof x === "object") {
|
||||
>x && typeof x === "object" : boolean | "" | 0 | null
|
||||
>x : string | number | Foo | Bar | null
|
||||
>typeof x === "object" : boolean
|
||||
>typeof x : string
|
||||
>x : string | number | Foo | Bar
|
||||
>"object" : "object"
|
||||
|
||||
switch(x.kind) {
|
||||
>x.kind : "foo" | "bar"
|
||||
>x : Foo | Bar
|
||||
>kind : "foo" | "bar"
|
||||
|
||||
case 'foo':
|
||||
>'foo' : "foo"
|
||||
|
||||
x.name;
|
||||
>x.name : string
|
||||
>x : Foo
|
||||
>name : string
|
||||
}
|
||||
}
|
||||
}
|
76
tests/baselines/reference/exportDefaultProperty.js
Normal file
76
tests/baselines/reference/exportDefaultProperty.js
Normal file
|
@ -0,0 +1,76 @@
|
|||
//// [tests/cases/compiler/exportDefaultProperty.ts] ////
|
||||
|
||||
//// [declarations.d.ts]
|
||||
// This test is just like exportEqualsProperty, but with `export default`.
|
||||
|
||||
declare namespace foo.bar {
|
||||
export type X = number;
|
||||
export const X: number;
|
||||
}
|
||||
|
||||
declare module "foobar" {
|
||||
export default foo.bar;
|
||||
}
|
||||
|
||||
declare module "foobarx" {
|
||||
export default foo.bar.X;
|
||||
}
|
||||
|
||||
//// [a.ts]
|
||||
namespace A {
|
||||
export class B { constructor(b: number) {} }
|
||||
export namespace B { export const b: number = 0; }
|
||||
}
|
||||
export default A.B;
|
||||
|
||||
//// [b.ts]
|
||||
export default "foo".length;
|
||||
|
||||
//// [index.ts]
|
||||
/// <reference path="declarations.d.ts" />
|
||||
import fooBar from "foobar";
|
||||
import X = fooBar.X;
|
||||
import X2 from "foobarx";
|
||||
const x: X = X;
|
||||
const x2: X2 = X2;
|
||||
|
||||
import B from "./a";
|
||||
const b: B = new B(B.b);
|
||||
|
||||
import fooLength from "./b";
|
||||
fooLength + 1;
|
||||
|
||||
|
||||
//// [a.js]
|
||||
"use strict";
|
||||
var A;
|
||||
(function (A) {
|
||||
var B = (function () {
|
||||
function B(b) {
|
||||
}
|
||||
return B;
|
||||
}());
|
||||
A.B = B;
|
||||
var B;
|
||||
(function (B) {
|
||||
B.b = 0;
|
||||
})(B = A.B || (A.B = {}));
|
||||
})(A || (A = {}));
|
||||
exports.__esModule = true;
|
||||
exports["default"] = A.B;
|
||||
//// [b.js]
|
||||
"use strict";
|
||||
exports.__esModule = true;
|
||||
exports["default"] = "foo".length;
|
||||
//// [index.js]
|
||||
"use strict";
|
||||
/// <reference path="declarations.d.ts" />
|
||||
var foobar_1 = require("foobar");
|
||||
var X = foobar_1["default"].X;
|
||||
var foobarx_1 = require("foobarx");
|
||||
var x = X;
|
||||
var x2 = foobarx_1["default"];
|
||||
var a_1 = require("./a");
|
||||
var b = new a_1["default"](a_1["default"].b);
|
||||
var b_1 = require("./b");
|
||||
b_1["default"] + 1;
|
92
tests/baselines/reference/exportDefaultProperty.symbols
Normal file
92
tests/baselines/reference/exportDefaultProperty.symbols
Normal file
|
@ -0,0 +1,92 @@
|
|||
=== tests/cases/compiler/index.ts ===
|
||||
/// <reference path="declarations.d.ts" />
|
||||
import fooBar from "foobar";
|
||||
>fooBar : Symbol(fooBar, Decl(index.ts, 1, 6))
|
||||
|
||||
import X = fooBar.X;
|
||||
>X : Symbol(X, Decl(index.ts, 1, 28))
|
||||
>fooBar : Symbol(fooBar, Decl(index.ts, 1, 6))
|
||||
>X : Symbol(fooBar.X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
|
||||
import X2 from "foobarx";
|
||||
>X2 : Symbol(X2, Decl(index.ts, 3, 6))
|
||||
|
||||
const x: X = X;
|
||||
>x : Symbol(x, Decl(index.ts, 4, 5))
|
||||
>X : Symbol(X, Decl(index.ts, 1, 28))
|
||||
>X : Symbol(X, Decl(index.ts, 1, 28))
|
||||
|
||||
const x2: X2 = X2;
|
||||
>x2 : Symbol(x2, Decl(index.ts, 5, 5))
|
||||
>X2 : Symbol(X2, Decl(index.ts, 3, 6))
|
||||
>X2 : Symbol(X2, Decl(index.ts, 3, 6))
|
||||
|
||||
import B from "./a";
|
||||
>B : Symbol(B, Decl(index.ts, 7, 6))
|
||||
|
||||
const b: B = new B(B.b);
|
||||
>b : Symbol(b, Decl(index.ts, 8, 5))
|
||||
>B : Symbol(B, Decl(index.ts, 7, 6))
|
||||
>B : Symbol(B, Decl(index.ts, 7, 6))
|
||||
>B.b : Symbol(B.b, Decl(a.ts, 2, 37))
|
||||
>B : Symbol(B, Decl(index.ts, 7, 6))
|
||||
>b : Symbol(B.b, Decl(a.ts, 2, 37))
|
||||
|
||||
import fooLength from "./b";
|
||||
>fooLength : Symbol(fooLength, Decl(index.ts, 10, 6))
|
||||
|
||||
fooLength + 1;
|
||||
>fooLength : Symbol(fooLength, Decl(index.ts, 10, 6))
|
||||
|
||||
=== tests/cases/compiler/declarations.d.ts ===
|
||||
// This test is just like exportEqualsProperty, but with `export default`.
|
||||
|
||||
declare namespace foo.bar {
|
||||
>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
|
||||
>bar : Symbol(bar, Decl(declarations.d.ts, 2, 22))
|
||||
|
||||
export type X = number;
|
||||
>X : Symbol(X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
|
||||
export const X: number;
|
||||
>X : Symbol(X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
}
|
||||
|
||||
declare module "foobar" {
|
||||
export default foo.bar;
|
||||
>foo.bar : Symbol(default, Decl(declarations.d.ts, 2, 22))
|
||||
>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
|
||||
>bar : Symbol(default, Decl(declarations.d.ts, 2, 22))
|
||||
}
|
||||
|
||||
declare module "foobarx" {
|
||||
export default foo.bar.X;
|
||||
>foo.bar.X : Symbol(default, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
>foo.bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
|
||||
>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
|
||||
>bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
|
||||
>X : Symbol(default, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
}
|
||||
|
||||
=== tests/cases/compiler/a.ts ===
|
||||
namespace A {
|
||||
>A : Symbol(A, Decl(a.ts, 0, 0))
|
||||
|
||||
export class B { constructor(b: number) {} }
|
||||
>B : Symbol(B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
|
||||
>b : Symbol(b, Decl(a.ts, 1, 33))
|
||||
|
||||
export namespace B { export const b: number = 0; }
|
||||
>B : Symbol(B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
|
||||
>b : Symbol(b, Decl(a.ts, 2, 37))
|
||||
}
|
||||
export default A.B;
|
||||
>A.B : Symbol(default, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
|
||||
>A : Symbol(A, Decl(a.ts, 0, 0))
|
||||
>B : Symbol(default, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
|
||||
|
||||
=== tests/cases/compiler/b.ts ===
|
||||
export default "foo".length;
|
||||
>"foo".length : Symbol(String.length, Decl(lib.d.ts, --, --))
|
||||
>length : Symbol(String.length, Decl(lib.d.ts, --, --))
|
||||
|
97
tests/baselines/reference/exportDefaultProperty.types
Normal file
97
tests/baselines/reference/exportDefaultProperty.types
Normal file
|
@ -0,0 +1,97 @@
|
|||
=== tests/cases/compiler/index.ts ===
|
||||
/// <reference path="declarations.d.ts" />
|
||||
import fooBar from "foobar";
|
||||
>fooBar : typeof fooBar
|
||||
|
||||
import X = fooBar.X;
|
||||
>X : number
|
||||
>fooBar : typeof fooBar
|
||||
>X : number
|
||||
|
||||
import X2 from "foobarx";
|
||||
>X2 : number
|
||||
|
||||
const x: X = X;
|
||||
>x : number
|
||||
>X : number
|
||||
>X : number
|
||||
|
||||
const x2: X2 = X2;
|
||||
>x2 : number
|
||||
>X2 : number
|
||||
>X2 : number
|
||||
|
||||
import B from "./a";
|
||||
>B : typeof B
|
||||
|
||||
const b: B = new B(B.b);
|
||||
>b : B
|
||||
>B : B
|
||||
>new B(B.b) : B
|
||||
>B : typeof B
|
||||
>B.b : number
|
||||
>B : typeof B
|
||||
>b : number
|
||||
|
||||
import fooLength from "./b";
|
||||
>fooLength : number
|
||||
|
||||
fooLength + 1;
|
||||
>fooLength + 1 : number
|
||||
>fooLength : number
|
||||
>1 : number
|
||||
|
||||
=== tests/cases/compiler/declarations.d.ts ===
|
||||
// This test is just like exportEqualsProperty, but with `export default`.
|
||||
|
||||
declare namespace foo.bar {
|
||||
>foo : typeof foo
|
||||
>bar : typeof bar
|
||||
|
||||
export type X = number;
|
||||
>X : number
|
||||
|
||||
export const X: number;
|
||||
>X : number
|
||||
}
|
||||
|
||||
declare module "foobar" {
|
||||
export default foo.bar;
|
||||
>foo.bar : typeof default
|
||||
>foo : typeof foo
|
||||
>bar : typeof default
|
||||
}
|
||||
|
||||
declare module "foobarx" {
|
||||
export default foo.bar.X;
|
||||
>foo.bar.X : number
|
||||
>foo.bar : typeof foo.bar
|
||||
>foo : typeof foo
|
||||
>bar : typeof foo.bar
|
||||
>X : number
|
||||
}
|
||||
|
||||
=== tests/cases/compiler/a.ts ===
|
||||
namespace A {
|
||||
>A : typeof A
|
||||
|
||||
export class B { constructor(b: number) {} }
|
||||
>B : B
|
||||
>b : number
|
||||
|
||||
export namespace B { export const b: number = 0; }
|
||||
>B : typeof B
|
||||
>b : number
|
||||
>0 : number
|
||||
}
|
||||
export default A.B;
|
||||
>A.B : typeof default
|
||||
>A : typeof A
|
||||
>B : typeof default
|
||||
|
||||
=== tests/cases/compiler/b.ts ===
|
||||
export default "foo".length;
|
||||
>"foo".length : number
|
||||
>"foo" : string
|
||||
>length : number
|
||||
|
72
tests/baselines/reference/exportEqualsProperty.js
Normal file
72
tests/baselines/reference/exportEqualsProperty.js
Normal file
|
@ -0,0 +1,72 @@
|
|||
//// [tests/cases/compiler/exportEqualsProperty.ts] ////
|
||||
|
||||
//// [declarations.d.ts]
|
||||
// This test is just like exportDefaultProperty, but with `export =`.
|
||||
|
||||
declare namespace foo.bar {
|
||||
export type X = number;
|
||||
export const X: number;
|
||||
}
|
||||
|
||||
declare module "foobar" {
|
||||
export = foo.bar;
|
||||
}
|
||||
|
||||
declare module "foobarx" {
|
||||
export = foo.bar.X;
|
||||
}
|
||||
|
||||
//// [a.ts]
|
||||
namespace A {
|
||||
export class B { constructor(b: number) {} }
|
||||
export namespace B { export const b: number = 0; }
|
||||
}
|
||||
export = A.B;
|
||||
|
||||
//// [b.ts]
|
||||
export = "foo".length;
|
||||
|
||||
//// [index.ts]
|
||||
/// <reference path="declarations.d.ts" />
|
||||
import { X } from "foobar";
|
||||
import X2 = require("foobarx");
|
||||
const x: X = X;
|
||||
const x2: X2 = X2;
|
||||
|
||||
import B = require("./a");
|
||||
const b: B = new B(B.b);
|
||||
|
||||
import fooLength = require("./b");
|
||||
fooLength + 1;
|
||||
|
||||
|
||||
//// [a.js]
|
||||
"use strict";
|
||||
var A;
|
||||
(function (A) {
|
||||
var B = (function () {
|
||||
function B(b) {
|
||||
}
|
||||
return B;
|
||||
}());
|
||||
A.B = B;
|
||||
var B;
|
||||
(function (B) {
|
||||
B.b = 0;
|
||||
})(B = A.B || (A.B = {}));
|
||||
})(A || (A = {}));
|
||||
module.exports = A.B;
|
||||
//// [b.js]
|
||||
"use strict";
|
||||
module.exports = "foo".length;
|
||||
//// [index.js]
|
||||
"use strict";
|
||||
/// <reference path="declarations.d.ts" />
|
||||
var foobar_1 = require("foobar");
|
||||
var X2 = require("foobarx");
|
||||
var x = foobar_1.X;
|
||||
var x2 = X2;
|
||||
var B = require("./a");
|
||||
var b = new B(B.b);
|
||||
var fooLength = require("./b");
|
||||
fooLength + 1;
|
87
tests/baselines/reference/exportEqualsProperty.symbols
Normal file
87
tests/baselines/reference/exportEqualsProperty.symbols
Normal file
|
@ -0,0 +1,87 @@
|
|||
=== tests/cases/compiler/index.ts ===
|
||||
/// <reference path="declarations.d.ts" />
|
||||
import { X } from "foobar";
|
||||
>X : Symbol(X, Decl(index.ts, 1, 8))
|
||||
|
||||
import X2 = require("foobarx");
|
||||
>X2 : Symbol(X2, Decl(index.ts, 1, 27))
|
||||
|
||||
const x: X = X;
|
||||
>x : Symbol(x, Decl(index.ts, 3, 5))
|
||||
>X : Symbol(X, Decl(index.ts, 1, 8))
|
||||
>X : Symbol(X, Decl(index.ts, 1, 8))
|
||||
|
||||
const x2: X2 = X2;
|
||||
>x2 : Symbol(x2, Decl(index.ts, 4, 5))
|
||||
>X2 : Symbol(X2, Decl(index.ts, 1, 27))
|
||||
>X2 : Symbol(X2, Decl(index.ts, 1, 27))
|
||||
|
||||
import B = require("./a");
|
||||
>B : Symbol(B, Decl(index.ts, 4, 18))
|
||||
|
||||
const b: B = new B(B.b);
|
||||
>b : Symbol(b, Decl(index.ts, 7, 5))
|
||||
>B : Symbol(B, Decl(index.ts, 4, 18))
|
||||
>B : Symbol(B, Decl(index.ts, 4, 18))
|
||||
>B.b : Symbol(B.b, Decl(a.ts, 2, 37))
|
||||
>B : Symbol(B, Decl(index.ts, 4, 18))
|
||||
>b : Symbol(B.b, Decl(a.ts, 2, 37))
|
||||
|
||||
import fooLength = require("./b");
|
||||
>fooLength : Symbol(fooLength, Decl(index.ts, 7, 24))
|
||||
|
||||
fooLength + 1;
|
||||
>fooLength : Symbol(fooLength, Decl(index.ts, 7, 24))
|
||||
|
||||
=== tests/cases/compiler/declarations.d.ts ===
|
||||
// This test is just like exportDefaultProperty, but with `export =`.
|
||||
|
||||
declare namespace foo.bar {
|
||||
>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
|
||||
>bar : Symbol(bar, Decl(declarations.d.ts, 2, 22))
|
||||
|
||||
export type X = number;
|
||||
>X : Symbol(X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
|
||||
export const X: number;
|
||||
>X : Symbol(X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
}
|
||||
|
||||
declare module "foobar" {
|
||||
export = foo.bar;
|
||||
>foo.bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
|
||||
>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
|
||||
>bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
|
||||
}
|
||||
|
||||
declare module "foobarx" {
|
||||
export = foo.bar.X;
|
||||
>foo.bar.X : Symbol(foo.bar.X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
>foo.bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
|
||||
>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
|
||||
>bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
|
||||
>X : Symbol(foo.bar.X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
|
||||
}
|
||||
|
||||
=== tests/cases/compiler/a.ts ===
|
||||
namespace A {
|
||||
>A : Symbol(A, Decl(a.ts, 0, 0))
|
||||
|
||||
export class B { constructor(b: number) {} }
|
||||
>B : Symbol(B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
|
||||
>b : Symbol(b, Decl(a.ts, 1, 33))
|
||||
|
||||
export namespace B { export const b: number = 0; }
|
||||
>B : Symbol(B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
|
||||
>b : Symbol(b, Decl(a.ts, 2, 37))
|
||||
}
|
||||
export = A.B;
|
||||
>A.B : Symbol(A.B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
|
||||
>A : Symbol(A, Decl(a.ts, 0, 0))
|
||||
>B : Symbol(A.B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
|
||||
|
||||
=== tests/cases/compiler/b.ts ===
|
||||
export = "foo".length;
|
||||
>"foo".length : Symbol(String.length, Decl(lib.d.ts, --, --))
|
||||
>length : Symbol(String.length, Decl(lib.d.ts, --, --))
|
||||
|
92
tests/baselines/reference/exportEqualsProperty.types
Normal file
92
tests/baselines/reference/exportEqualsProperty.types
Normal file
|
@ -0,0 +1,92 @@
|
|||
=== tests/cases/compiler/index.ts ===
|
||||
/// <reference path="declarations.d.ts" />
|
||||
import { X } from "foobar";
|
||||
>X : number
|
||||
|
||||
import X2 = require("foobarx");
|
||||
>X2 : number
|
||||
|
||||
const x: X = X;
|
||||
>x : number
|
||||
>X : number
|
||||
>X : number
|
||||
|
||||
const x2: X2 = X2;
|
||||
>x2 : number
|
||||
>X2 : number
|
||||
>X2 : number
|
||||
|
||||
import B = require("./a");
|
||||
>B : typeof B
|
||||
|
||||
const b: B = new B(B.b);
|
||||
>b : B
|
||||
>B : B
|
||||
>new B(B.b) : B
|
||||
>B : typeof B
|
||||
>B.b : number
|
||||
>B : typeof B
|
||||
>b : number
|
||||
|
||||
import fooLength = require("./b");
|
||||
>fooLength : number
|
||||
|
||||
fooLength + 1;
|
||||
>fooLength + 1 : number
|
||||
>fooLength : number
|
||||
>1 : number
|
||||
|
||||
=== tests/cases/compiler/declarations.d.ts ===
|
||||
// This test is just like exportDefaultProperty, but with `export =`.
|
||||
|
||||
declare namespace foo.bar {
|
||||
>foo : typeof foo
|
||||
>bar : typeof bar
|
||||
|
||||
export type X = number;
|
||||
>X : number
|
||||
|
||||
export const X: number;
|
||||
>X : number
|
||||
}
|
||||
|
||||
declare module "foobar" {
|
||||
export = foo.bar;
|
||||
>foo.bar : typeof foo.bar
|
||||
>foo : typeof foo
|
||||
>bar : typeof foo.bar
|
||||
}
|
||||
|
||||
declare module "foobarx" {
|
||||
export = foo.bar.X;
|
||||
>foo.bar.X : number
|
||||
>foo.bar : typeof foo.bar
|
||||
>foo : typeof foo
|
||||
>bar : typeof foo.bar
|
||||
>X : number
|
||||
}
|
||||
|
||||
=== tests/cases/compiler/a.ts ===
|
||||
namespace A {
|
||||
>A : typeof A
|
||||
|
||||
export class B { constructor(b: number) {} }
|
||||
>B : B
|
||||
>b : number
|
||||
|
||||
export namespace B { export const b: number = 0; }
|
||||
>B : typeof B
|
||||
>b : number
|
||||
>0 : number
|
||||
}
|
||||
export = A.B;
|
||||
>A.B : typeof A.B
|
||||
>A : typeof A
|
||||
>B : typeof A.B
|
||||
|
||||
=== tests/cases/compiler/b.ts ===
|
||||
export = "foo".length;
|
||||
>"foo".length : number
|
||||
>"foo" : string
|
||||
>length : number
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
//// [thisInTupleTypeParameterConstraints.ts]
|
||||
/// <reference no-default-lib="true"/>
|
||||
|
||||
interface Boolean {}
|
||||
interface IArguments {}
|
||||
interface Function {}
|
||||
interface Number {}
|
||||
interface RegExp {}
|
||||
interface Object {}
|
||||
interface String {}
|
||||
|
||||
interface Array<T> {
|
||||
// 4 methods will run out of memory if this-types are not instantiated
|
||||
// correctly for tuple types that are type parameter constraints
|
||||
map<U>(arg: this): void;
|
||||
reduceRight<U>(arg: this): void;
|
||||
reduce<U>(arg: this): void;
|
||||
reduce2<U>(arg: this): void;
|
||||
}
|
||||
|
||||
declare function f<T extends [(x: number) => number]>(a: T): void;
|
||||
let x: [(x: number) => number];
|
||||
f(x);
|
||||
|
||||
|
||||
//// [thisInTupleTypeParameterConstraints.js]
|
||||
/// <reference no-default-lib="true"/>
|
||||
var x;
|
||||
f(x);
|
|
@ -0,0 +1,66 @@
|
|||
=== tests/cases/compiler/thisInTupleTypeParameterConstraints.ts ===
|
||||
/// <reference no-default-lib="true"/>
|
||||
|
||||
interface Boolean {}
|
||||
>Boolean : Symbol(Boolean, Decl(thisInTupleTypeParameterConstraints.ts, 0, 0))
|
||||
|
||||
interface IArguments {}
|
||||
>IArguments : Symbol(IArguments, Decl(thisInTupleTypeParameterConstraints.ts, 2, 20))
|
||||
|
||||
interface Function {}
|
||||
>Function : Symbol(Function, Decl(thisInTupleTypeParameterConstraints.ts, 3, 23))
|
||||
|
||||
interface Number {}
|
||||
>Number : Symbol(Number, Decl(thisInTupleTypeParameterConstraints.ts, 4, 21))
|
||||
|
||||
interface RegExp {}
|
||||
>RegExp : Symbol(RegExp, Decl(thisInTupleTypeParameterConstraints.ts, 5, 19))
|
||||
|
||||
interface Object {}
|
||||
>Object : Symbol(Object, Decl(thisInTupleTypeParameterConstraints.ts, 6, 19))
|
||||
|
||||
interface String {}
|
||||
>String : Symbol(String, Decl(thisInTupleTypeParameterConstraints.ts, 7, 19))
|
||||
|
||||
interface Array<T> {
|
||||
>Array : Symbol(Array, Decl(thisInTupleTypeParameterConstraints.ts, 8, 19))
|
||||
>T : Symbol(T, Decl(thisInTupleTypeParameterConstraints.ts, 10, 16))
|
||||
|
||||
// 4 methods will run out of memory if this-types are not instantiated
|
||||
// correctly for tuple types that are type parameter constraints
|
||||
map<U>(arg: this): void;
|
||||
>map : Symbol(Array.map, Decl(thisInTupleTypeParameterConstraints.ts, 10, 20))
|
||||
>U : Symbol(U, Decl(thisInTupleTypeParameterConstraints.ts, 13, 8))
|
||||
>arg : Symbol(arg, Decl(thisInTupleTypeParameterConstraints.ts, 13, 11))
|
||||
|
||||
reduceRight<U>(arg: this): void;
|
||||
>reduceRight : Symbol(Array.reduceRight, Decl(thisInTupleTypeParameterConstraints.ts, 13, 28))
|
||||
>U : Symbol(U, Decl(thisInTupleTypeParameterConstraints.ts, 14, 16))
|
||||
>arg : Symbol(arg, Decl(thisInTupleTypeParameterConstraints.ts, 14, 19))
|
||||
|
||||
reduce<U>(arg: this): void;
|
||||
>reduce : Symbol(Array.reduce, Decl(thisInTupleTypeParameterConstraints.ts, 14, 36))
|
||||
>U : Symbol(U, Decl(thisInTupleTypeParameterConstraints.ts, 15, 11))
|
||||
>arg : Symbol(arg, Decl(thisInTupleTypeParameterConstraints.ts, 15, 14))
|
||||
|
||||
reduce2<U>(arg: this): void;
|
||||
>reduce2 : Symbol(Array.reduce2, Decl(thisInTupleTypeParameterConstraints.ts, 15, 31))
|
||||
>U : Symbol(U, Decl(thisInTupleTypeParameterConstraints.ts, 16, 12))
|
||||
>arg : Symbol(arg, Decl(thisInTupleTypeParameterConstraints.ts, 16, 15))
|
||||
}
|
||||
|
||||
declare function f<T extends [(x: number) => number]>(a: T): void;
|
||||
>f : Symbol(f, Decl(thisInTupleTypeParameterConstraints.ts, 17, 1))
|
||||
>T : Symbol(T, Decl(thisInTupleTypeParameterConstraints.ts, 19, 19))
|
||||
>x : Symbol(x, Decl(thisInTupleTypeParameterConstraints.ts, 19, 31))
|
||||
>a : Symbol(a, Decl(thisInTupleTypeParameterConstraints.ts, 19, 54))
|
||||
>T : Symbol(T, Decl(thisInTupleTypeParameterConstraints.ts, 19, 19))
|
||||
|
||||
let x: [(x: number) => number];
|
||||
>x : Symbol(x, Decl(thisInTupleTypeParameterConstraints.ts, 20, 3))
|
||||
>x : Symbol(x, Decl(thisInTupleTypeParameterConstraints.ts, 20, 9))
|
||||
|
||||
f(x);
|
||||
>f : Symbol(f, Decl(thisInTupleTypeParameterConstraints.ts, 17, 1))
|
||||
>x : Symbol(x, Decl(thisInTupleTypeParameterConstraints.ts, 20, 3))
|
||||
|
|
@ -0,0 +1,67 @@
|
|||
=== tests/cases/compiler/thisInTupleTypeParameterConstraints.ts ===
|
||||
/// <reference no-default-lib="true"/>
|
||||
|
||||
interface Boolean {}
|
||||
>Boolean : Boolean
|
||||
|
||||
interface IArguments {}
|
||||
>IArguments : IArguments
|
||||
|
||||
interface Function {}
|
||||
>Function : Function
|
||||
|
||||
interface Number {}
|
||||
>Number : Number
|
||||
|
||||
interface RegExp {}
|
||||
>RegExp : RegExp
|
||||
|
||||
interface Object {}
|
||||
>Object : Object
|
||||
|
||||
interface String {}
|
||||
>String : String
|
||||
|
||||
interface Array<T> {
|
||||
>Array : T[]
|
||||
>T : T
|
||||
|
||||
// 4 methods will run out of memory if this-types are not instantiated
|
||||
// correctly for tuple types that are type parameter constraints
|
||||
map<U>(arg: this): void;
|
||||
>map : <U>(arg: this) => void
|
||||
>U : U
|
||||
>arg : this
|
||||
|
||||
reduceRight<U>(arg: this): void;
|
||||
>reduceRight : <U>(arg: this) => void
|
||||
>U : U
|
||||
>arg : this
|
||||
|
||||
reduce<U>(arg: this): void;
|
||||
>reduce : <U>(arg: this) => void
|
||||
>U : U
|
||||
>arg : this
|
||||
|
||||
reduce2<U>(arg: this): void;
|
||||
>reduce2 : <U>(arg: this) => void
|
||||
>U : U
|
||||
>arg : this
|
||||
}
|
||||
|
||||
declare function f<T extends [(x: number) => number]>(a: T): void;
|
||||
>f : <T extends [(x: number) => number]>(a: T) => void
|
||||
>T : T
|
||||
>x : number
|
||||
>a : T
|
||||
>T : T
|
||||
|
||||
let x: [(x: number) => number];
|
||||
>x : [(x: number) => number]
|
||||
>x : number
|
||||
|
||||
f(x);
|
||||
>f(x) : void
|
||||
>f : <T extends [(x: number) => number]>(a: T) => void
|
||||
>x : [(x: number) => number]
|
||||
|
9
tests/baselines/reference/typingsLookup2.js
Normal file
9
tests/baselines/reference/typingsLookup2.js
Normal file
|
@ -0,0 +1,9 @@
|
|||
//// [tests/cases/conformance/typings/typingsLookup2.ts] ////
|
||||
|
||||
//// [package.json]
|
||||
{ "typings": null }
|
||||
|
||||
//// [a.ts]
|
||||
|
||||
|
||||
//// [a.js]
|
3
tests/baselines/reference/typingsLookup2.symbols
Normal file
3
tests/baselines/reference/typingsLookup2.symbols
Normal file
|
@ -0,0 +1,3 @@
|
|||
=== /a.ts ===
|
||||
|
||||
No type information for this code.
|
1
tests/baselines/reference/typingsLookup2.trace.json
Normal file
1
tests/baselines/reference/typingsLookup2.trace.json
Normal file
|
@ -0,0 +1 @@
|
|||
[]
|
3
tests/baselines/reference/typingsLookup2.types
Normal file
3
tests/baselines/reference/typingsLookup2.types
Normal file
|
@ -0,0 +1,3 @@
|
|||
=== /a.ts ===
|
||||
|
||||
No type information for this code.
|
49
tests/cases/compiler/discriminantsAndPrimitives.ts
Normal file
49
tests/cases/compiler/discriminantsAndPrimitives.ts
Normal file
|
@ -0,0 +1,49 @@
|
|||
// @strictNullChecks: true
|
||||
|
||||
// Repro from #10257 plus other tests
|
||||
|
||||
interface Foo {
|
||||
kind: "foo";
|
||||
name: string;
|
||||
}
|
||||
|
||||
interface Bar {
|
||||
kind: "bar";
|
||||
length: string;
|
||||
}
|
||||
|
||||
function f1(x: Foo | Bar | string) {
|
||||
if (typeof x !== 'string') {
|
||||
switch(x.kind) {
|
||||
case 'foo':
|
||||
x.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f2(x: Foo | Bar | string | undefined) {
|
||||
if (typeof x === "object") {
|
||||
switch(x.kind) {
|
||||
case 'foo':
|
||||
x.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f3(x: Foo | Bar | string | null) {
|
||||
if (x && typeof x !== "string") {
|
||||
switch(x.kind) {
|
||||
case 'foo':
|
||||
x.name;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function f4(x: Foo | Bar | string | number | null) {
|
||||
if (x && typeof x === "object") {
|
||||
switch(x.kind) {
|
||||
case 'foo':
|
||||
x.name;
|
||||
}
|
||||
}
|
||||
}
|
39
tests/cases/compiler/exportDefaultProperty.ts
Normal file
39
tests/cases/compiler/exportDefaultProperty.ts
Normal file
|
@ -0,0 +1,39 @@
|
|||
// This test is just like exportEqualsProperty, but with `export default`.
|
||||
|
||||
// @Filename: declarations.d.ts
|
||||
declare namespace foo.bar {
|
||||
export type X = number;
|
||||
export const X: number;
|
||||
}
|
||||
|
||||
declare module "foobar" {
|
||||
export default foo.bar;
|
||||
}
|
||||
|
||||
declare module "foobarx" {
|
||||
export default foo.bar.X;
|
||||
}
|
||||
|
||||
// @Filename: a.ts
|
||||
namespace A {
|
||||
export class B { constructor(b: number) {} }
|
||||
export namespace B { export const b: number = 0; }
|
||||
}
|
||||
export default A.B;
|
||||
|
||||
// @Filename: b.ts
|
||||
export default "foo".length;
|
||||
|
||||
// @Filename: index.ts
|
||||
/// <reference path="declarations.d.ts" />
|
||||
import fooBar from "foobar";
|
||||
import X = fooBar.X;
|
||||
import X2 from "foobarx";
|
||||
const x: X = X;
|
||||
const x2: X2 = X2;
|
||||
|
||||
import B from "./a";
|
||||
const b: B = new B(B.b);
|
||||
|
||||
import fooLength from "./b";
|
||||
fooLength + 1;
|
38
tests/cases/compiler/exportEqualsProperty.ts
Normal file
38
tests/cases/compiler/exportEqualsProperty.ts
Normal file
|
@ -0,0 +1,38 @@
|
|||
// This test is just like exportDefaultProperty, but with `export =`.
|
||||
|
||||
// @Filename: declarations.d.ts
|
||||
declare namespace foo.bar {
|
||||
export type X = number;
|
||||
export const X: number;
|
||||
}
|
||||
|
||||
declare module "foobar" {
|
||||
export = foo.bar;
|
||||
}
|
||||
|
||||
declare module "foobarx" {
|
||||
export = foo.bar.X;
|
||||
}
|
||||
|
||||
// @Filename: a.ts
|
||||
namespace A {
|
||||
export class B { constructor(b: number) {} }
|
||||
export namespace B { export const b: number = 0; }
|
||||
}
|
||||
export = A.B;
|
||||
|
||||
// @Filename: b.ts
|
||||
export = "foo".length;
|
||||
|
||||
// @Filename: index.ts
|
||||
/// <reference path="declarations.d.ts" />
|
||||
import { X } from "foobar";
|
||||
import X2 = require("foobarx");
|
||||
const x: X = X;
|
||||
const x2: X2 = X2;
|
||||
|
||||
import B = require("./a");
|
||||
const b: B = new B(B.b);
|
||||
|
||||
import fooLength = require("./b");
|
||||
fooLength + 1;
|
22
tests/cases/compiler/thisInTupleTypeParameterConstraints.ts
Normal file
22
tests/cases/compiler/thisInTupleTypeParameterConstraints.ts
Normal file
|
@ -0,0 +1,22 @@
|
|||
/// <reference no-default-lib="true"/>
|
||||
|
||||
interface Boolean {}
|
||||
interface IArguments {}
|
||||
interface Function {}
|
||||
interface Number {}
|
||||
interface RegExp {}
|
||||
interface Object {}
|
||||
interface String {}
|
||||
|
||||
interface Array<T> {
|
||||
// 4 methods will run out of memory if this-types are not instantiated
|
||||
// correctly for tuple types that are type parameter constraints
|
||||
map<U>(arg: this): void;
|
||||
reduceRight<U>(arg: this): void;
|
||||
reduce<U>(arg: this): void;
|
||||
reduce2<U>(arg: this): void;
|
||||
}
|
||||
|
||||
declare function f<T extends [(x: number) => number]>(a: T): void;
|
||||
let x: [(x: number) => number];
|
||||
f(x);
|
13
tests/cases/conformance/typings/typingsLookup2.ts
Normal file
13
tests/cases/conformance/typings/typingsLookup2.ts
Normal file
|
@ -0,0 +1,13 @@
|
|||
// @traceResolution: true
|
||||
// @noImplicitReferences: true
|
||||
// @currentDirectory: /
|
||||
// This tests that an @types package with `"typings": null` is not automatically included.
|
||||
// (If it were, this test would break because there are no typings to be found.)
|
||||
|
||||
// @filename: /tsconfig.json
|
||||
{}
|
||||
|
||||
// @filename: /node_modules/@types/angular2/package.json
|
||||
{ "typings": null }
|
||||
|
||||
// @filename: /a.ts
|
Loading…
Reference in a new issue