Merge branch 'master' into asyncGenerators

This commit is contained in:
Ron Buckton committed 2017-02-10 09:46:06 -08:00
commit 3e427f4860
356 files changed
+7991 -4413

No files matched your search

+31 -169
View File
@@ -6,6 +6,8 @@ var path = require("path");
var child_process = require("child_process");
var fold = require("travis-fold");
var runTestsInParallel = require("./scripts/mocha-parallel").runTestsInParallel;
var ts = require("./lib/typescript");
// Variables
var compilerDirectory = "src/compiler/";
@@ -34,6 +36,24 @@ if (process.env.path !== undefined) {
process.env.PATH = nodeModulesPathPrefix + process.env.PATH;
}
function filesFromConfig(configPath) {
var configText = fs.readFileSync(configPath).toString();
var config = ts.parseConfigFileTextToJson(configPath, configText, /*stripComments*/ true);
if (config.error) {
throw new Error(diagnosticsToString([config.error]));
}
const configFileContent = ts.parseJsonConfigFileContent(config.config, ts.sys, path.dirname(configPath));
if (configFileContent.errors && configFileContent.errors.length) {
throw new Error(diagnosticsToString(configFileContent.errors));
}
return configFileContent.fileNames;
function diagnosticsToString(s) {
return s.map(function(e) { return ts.flattenDiagnosticMessageText(e.messageText, ts.sys.newLine); }).join(ts.sys.newLine);
}
}
function toNs(diff) {
return diff[0] * 1e9 + diff[1];
}
@@ -56,173 +76,12 @@ function measure(marker) {
console.log("travis_time:end:" + marker.id + ":start=" + toNs(marker.stamp) + ",finish=" + toNs(total) + ",duration=" + toNs(diff) + "\r");
}
var compilerSources = [
"core.ts",
"performance.ts",
"sys.ts",
"types.ts",
"scanner.ts",
"parser.ts",
"utilities.ts",
"binder.ts",
"checker.ts",
"factory.ts",
"visitor.ts",
"transformers/destructuring.ts",
"transformers/ts.ts",
"transformers/jsx.ts",
"transformers/esnext.ts",
"transformers/es2017.ts",
"transformers/es2016.ts",
"transformers/es2015.ts",
"transformers/generators.ts",
"transformers/es5.ts",
"transformers/module/es2015.ts",
"transformers/module/system.ts",
"transformers/module/module.ts",
"transformer.ts",
"sourcemap.ts",
"comments.ts",
"declarationEmitter.ts",
"emitter.ts",
"program.ts",
"commandLineParser.ts",
"tsc.ts",
"diagnosticInformationMap.generated.ts"
].map(function (f) {
return path.join(compilerDirectory, f);
});
var servicesSources = [
"core.ts",
"performance.ts",
"sys.ts",
"types.ts",
"scanner.ts",
"parser.ts",
"utilities.ts",
"binder.ts",
"checker.ts",
"factory.ts",
"visitor.ts",
"transformers/destructuring.ts",
"transformers/ts.ts",
"transformers/jsx.ts",
"transformers/esnext.ts",
"transformers/es2017.ts",
"transformers/es2016.ts",
"transformers/es2015.ts",
"transformers/generators.ts",
"transformers/es5.ts",
"transformers/module/es2015.ts",
"transformers/module/system.ts",
"transformers/module/module.ts",
"transformer.ts",
"sourcemap.ts",
"comments.ts",
"declarationEmitter.ts",
"emitter.ts",
"program.ts",
"commandLineParser.ts",
"diagnosticInformationMap.generated.ts"
].map(function (f) {
return path.join(compilerDirectory, f);
}).concat([
"types.ts",
"utilities.ts",
"breakpoints.ts",
"classifier.ts",
"completions.ts",
"documentHighlights.ts",
"documentRegistry.ts",
"findAllReferences.ts",
"goToDefinition.ts",
"goToImplementation.ts",
"jsDoc.ts",
"jsTyping.ts",
"navigateTo.ts",
"navigationBar.ts",
"outliningElementsCollector.ts",
"patternMatcher.ts",
"preProcess.ts",
"rename.ts",
"services.ts",
"shims.ts",
"signatureHelp.ts",
"symbolDisplay.ts",
"transpile.ts",
// Formatting
"formatting/formatting.ts",
"formatting/formattingContext.ts",
"formatting/formattingRequestKind.ts",
"formatting/formattingScanner.ts",
"formatting/references.ts",
"formatting/rule.ts",
"formatting/ruleAction.ts",
"formatting/ruleDescriptor.ts",
"formatting/ruleFlag.ts",
"formatting/ruleOperation.ts",
"formatting/ruleOperationContext.ts",
"formatting/rules.ts",
"formatting/rulesMap.ts",
"formatting/rulesProvider.ts",
"formatting/smartIndenter.ts",
"formatting/tokenRange.ts",
// CodeFixes
"codeFixProvider.ts",
"codefixes/fixes.ts",
"codefixes/fixExtendsInterfaceBecomesImplements.ts",
"codefixes/fixClassIncorrectlyImplementsInterface.ts",
"codefixes/fixClassDoesntImplementInheritedAbstractMember.ts",
"codefixes/fixClassSuperMustPrecedeThisAccess.ts",
"codefixes/fixConstructorForDerivedNeedSuperCall.ts",
"codefixes/helpers.ts",
"codefixes/importFixes.ts",
"codefixes/unusedIdentifierFixes.ts"
].map(function (f) {
return path.join(servicesDirectory, f);
}));
var baseServerCoreSources = [
"builder.ts",
"editorServices.ts",
"lsHost.ts",
"project.ts",
"protocol.ts",
"scriptInfo.ts",
"scriptVersionCache.ts",
"session.ts",
"shared.ts",
"types.ts",
"typingsCache.ts",
"utilities.ts",
].map(function (f) {
return path.join(serverDirectory, f);
});
var serverCoreSources = [
"server.ts"
].map(function (f) {
return path.join(serverDirectory, f);
}).concat(baseServerCoreSources);
var cancellationTokenSources = [
"cancellationToken.ts"
].map(function (f) {
return path.join(cancellationTokenDirectory, f);
});
var typingsInstallerSources = [
"../types.ts",
"../shared.ts",
"typingsInstaller.ts",
"nodeTypingsInstaller.ts"
].map(function (f) {
return path.join(typingsInstallerDirectory, f);
});
var serverSources = serverCoreSources.concat(servicesSources);
var languageServiceLibrarySources = baseServerCoreSources.concat(servicesSources);
var compilerSources = filesFromConfig("./src/compiler/tsconfig.json");
var servicesSources = filesFromConfig("./src/services/tsconfig.json");
var cancellationTokenSources = filesFromConfig(path.join(serverDirectory, "cancellationToken/tsconfig.json"));
var typingsInstallerSources = filesFromConfig(path.join(serverDirectory, "typingsInstaller/tsconfig.json"));
var serverSources = filesFromConfig(path.join(serverDirectory, "tsconfig.json"))
var languageServiceLibrarySources = filesFromConfig(path.join(serverDirectory, "tsconfig.library.json"));
var harnessCoreSources = [
"harness.ts",
@@ -1239,13 +1098,16 @@ var lintTargets = compilerSources
.concat(harnessSources)
// Other harness sources
.concat(["instrumenter.ts"].map(function (f) { return path.join(harnessDirectory, f) }))
.concat(serverCoreSources)
.concat(serverSources)
.concat(tslintRulesFiles)
.concat(servicesSources)
.concat(typingsInstallerSources)
.concat(cancellationTokenSources)
.concat(["Gulpfile.ts"])
.concat([nodeServerInFile, perftscPath, "tests/perfsys.ts", webhostPath]);
.concat([nodeServerInFile, perftscPath, "tests/perfsys.ts", webhostPath])
.map(function (p) { return path.resolve(p) });
// keep only unique items
lintTargets = Array.from(new Set(lintTargets));
function sendNextFile(files, child, callback, failures) {
var file = files.pop();
+72 -32
View File
@@ -315,7 +315,6 @@ namespace ts {
"object": TypeFacts.TypeofEQObject,
"function": TypeFacts.TypeofEQFunction
});
const typeofNEFacts = createMapFromTemplate({
"string": TypeFacts.TypeofNEString,
"number": TypeFacts.TypeofNENumber,
@@ -325,7 +324,6 @@ namespace ts {
"object": TypeFacts.TypeofNEObject,
"function": TypeFacts.TypeofNEFunction
});
const typeofTypesByName = createMapFromTemplate<Type>({
"string": stringType,
"number": numberType,
@@ -333,6 +331,7 @@ namespace ts {
"symbol": esSymbolType,
"undefined": undefinedType
});
const typeofType = createTypeofType();
let jsxElementType: Type;
let _jsxNamespace: string;
@@ -630,7 +629,7 @@ namespace ts {
}
// declaration is after usage
// can be legal if usage is deferred (i.e. inside function or in initializer of instance property)
if (isUsedInFunctionOrNonStaticProperty(usage)) {
if (isUsedInFunctionOrInstanceProperty(usage)) {
return true;
}
const sourceFiles = host.getSourceFiles();
@@ -657,10 +656,12 @@ namespace ts {
}
// declaration is after usage
// can be legal if usage is deferred (i.e. inside function or in initializer of instance property)
// declaration is after usage, but it can still be legal if usage is deferred:
// 1. inside a function
// 2. inside an instance property initializer, a reference to a non-instance property
const container = getEnclosingBlockScopeContainer(declaration);
return isUsedInFunctionOrNonStaticProperty(usage, container);
const isInstanceProperty = declaration.kind === SyntaxKind.PropertyDeclaration && !(getModifierFlags(declaration) & ModifierFlags.Static);
return isUsedInFunctionOrInstanceProperty(usage, isInstanceProperty, container);
function isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration: VariableDeclaration, usage: Node): boolean {
const container = getEnclosingBlockScopeContainer(declaration);
@@ -689,7 +690,7 @@ namespace ts {
return false;
}
function isUsedInFunctionOrNonStaticProperty(usage: Node, container?: Node): boolean {
function isUsedInFunctionOrInstanceProperty(usage: Node, isDeclarationInstanceProperty?: boolean, container?: Node): boolean {
let current = usage;
while (current) {
if (current === container) {
@@ -700,13 +701,13 @@ namespace ts {
return true;
}
const initializerOfNonStaticProperty = current.parent &&
const initializerOfInstanceProperty = current.parent &&
current.parent.kind === SyntaxKind.PropertyDeclaration &&
(getModifierFlags(current.parent) & ModifierFlags.Static) === 0 &&
(<PropertyDeclaration>current.parent).initializer === current;
if (initializerOfNonStaticProperty) {
return true;
if (initializerOfInstanceProperty) {
return !isDeclarationInstanceProperty;
}
current = current.parent;
@@ -975,10 +976,10 @@ namespace ts {
// interface bar {}
// }
// const foo/*1*/: foo/*2*/.bar;
// The foo at /*1*/ and /*2*/ will share same symbol with two meaning
// block - scope variable and namespace module. However, only when we
// The foo at /*1*/ and /*2*/ will share same symbol with two meanings:
// block-scoped variable and namespace module. However, only when we
// try to resolve name in /*1*/ which is used in variable position,
// we want to check for block- scoped
// we want to check for block-scoped
if (meaning & SymbolFlags.BlockScopedVariable) {
const exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result);
if (exportOrLocalSymbol.flags & SymbolFlags.BlockScopedVariable) {
@@ -1002,7 +1003,7 @@ namespace ts {
return false;
}
const container = getThisContainer(errorLocation, /* includeArrowFunctions */ true);
const container = getThisContainer(errorLocation, /*includeArrowFunctions*/ true);
let location = container;
while (location) {
if (isClassLike(location.parent)) {
@@ -1714,6 +1715,10 @@ namespace ts {
return type;
}
function createTypeofType() {
return getUnionType(convertToArray(typeofEQFacts.keys(), s => getLiteralTypeForText(TypeFlags.StringLiteral, s)));
}
// A reserved member name starts with two underscores, but the third character cannot be an underscore
// or the @ symbol. A third underscore indicates an escaped form of an identifer that started
// with at least two underscores. The @ character indicates that the name is denoted by a well known ES
@@ -3243,7 +3248,7 @@ namespace ts {
type;
}
function getTypeForVariableLikeDeclarationFromJSDocComment(declaration: VariableLikeDeclaration) {
function getTypeForDeclarationFromJSDocComment(declaration: Node ) {
const jsdocType = getJSDocType(declaration);
if (jsdocType) {
return getTypeFromTypeNode(jsdocType);
@@ -3271,7 +3276,7 @@ namespace ts {
// If this is a variable in a JavaScript file, then use the JSDoc type (if it has
// one as its type), otherwise fallback to the below standard TS codepaths to
// try to figure it out.
const type = getTypeForVariableLikeDeclarationFromJSDocComment(declaration);
const type = getTypeForDeclarationFromJSDocComment(declaration);
if (type && type !== unknownType) {
return type;
}
@@ -3367,6 +3372,27 @@ namespace ts {
return undefined;
}
// Return the inferred type for a variable, parameter, or property declaration
function getTypeForJSSpecialPropertyDeclaration(declaration: Declaration): Type {
const expression = declaration.kind === SyntaxKind.BinaryExpression ? <BinaryExpression>declaration :
declaration.kind === SyntaxKind.PropertyAccessExpression ? <BinaryExpression>getAncestor(declaration, SyntaxKind.BinaryExpression) :
undefined;
if (!expression) {
return unknownType;
}
if (expression.flags & NodeFlags.JavaScriptFile) {
// If there is a JSDoc type, use it
const type = getTypeForDeclarationFromJSDocComment(expression.parent);
if (type && type !== unknownType) {
return getWidenedType(type);
}
}
return getWidenedLiteralType(checkExpressionCached(expression.right));
}
// Return the type implied by a binding pattern element. This is the type of the initializer of the element if
// one is present. Otherwise, if the element is itself a binding pattern, it is the type implied by the binding
// pattern. Otherwise, it is the type any.
@@ -3521,18 +3547,7 @@ namespace ts {
// * className.prototype.method = expr
if (declaration.kind === SyntaxKind.BinaryExpression ||
declaration.kind === SyntaxKind.PropertyAccessExpression && declaration.parent.kind === SyntaxKind.BinaryExpression) {
// Use JS Doc type if present on parent expression statement
if (declaration.flags & NodeFlags.JavaScriptFile) {
const jsdocType = getJSDocType(declaration.parent);
if (jsdocType) {
return links.type = getTypeFromTypeNode(jsdocType);
}
}
const declaredTypes = map(symbol.declarations,
decl => decl.kind === SyntaxKind.BinaryExpression ?
checkExpressionCached((<BinaryExpression>decl).right) :
checkExpressionCached((<BinaryExpression>decl.parent).right));
type = getUnionType(declaredTypes, /*subtypeReduction*/ true);
type = getWidenedType(getUnionType(map(symbol.declarations, getTypeForJSSpecialPropertyDeclaration), /*subtypeReduction*/ true));
}
else {
type = getWidenedTypeForVariableLikeDeclaration(<VariableLikeDeclaration>declaration, /*reportErrors*/ true);
@@ -3575,7 +3590,7 @@ namespace ts {
const setter = <AccessorDeclaration>getDeclarationOfKind(symbol, SyntaxKind.SetAccessor);
if (getter && getter.flags & NodeFlags.JavaScriptFile) {
const jsDocType = getTypeForVariableLikeDeclarationFromJSDocComment(getter);
const jsDocType = getTypeForDeclarationFromJSDocComment(getter);
if (jsDocType) {
return links.type = jsDocType;
}
@@ -5223,6 +5238,7 @@ namespace ts {
let hasThisParameter: boolean;
const iife = getImmediatelyInvokedFunctionExpression(declaration);
const isJSConstructSignature = isJSDocConstructSignature(declaration);
const isUntypedSignatureInJSFile = !iife && !isJSConstructSignature && isInJavaScriptFile(declaration) && !hasJSDocParameterTags(declaration);
// If this is a JSDoc construct signature, then skip the first parameter in the
// parameter list. The first parameter represents the return type of the construct
@@ -5251,7 +5267,8 @@ namespace ts {
// Record a new minimum argument count if this is not an optional parameter
const isOptionalParameter = param.initializer || param.questionToken || param.dotDotDotToken ||
iife && parameters.length > iife.arguments.length && !param.type ||
isJSDocOptionalParameter(param);
isJSDocOptionalParameter(param) ||
isUntypedSignatureInJSFile;
if (!isOptionalParameter) {
minArgumentCount = parameters.length;
}
@@ -9521,11 +9538,19 @@ namespace ts {
}
function getAssignedTypeOfBinaryExpression(node: BinaryExpression): Type {
return node.parent.kind === SyntaxKind.ArrayLiteralExpression || node.parent.kind === SyntaxKind.PropertyAssignment ?
const isDestructuringDefaultAssignment =
node.parent.kind === SyntaxKind.ArrayLiteralExpression && isDestructuringAssignmentTarget(node.parent) ||
node.parent.kind === SyntaxKind.PropertyAssignment && isDestructuringAssignmentTarget(node.parent.parent);
return isDestructuringDefaultAssignment ?
getTypeWithDefault(getAssignedType(node), node.right) :
getTypeOfExpression(node.right);
}
function isDestructuringAssignmentTarget(parent: Node) {
return parent.parent.kind === SyntaxKind.BinaryExpression && (parent.parent as BinaryExpression).left === parent ||
parent.parent.kind === SyntaxKind.ForOfStatement && (parent.parent as ForOfStatement).initializer === parent;
}
function getAssignedTypeOfArrayLiteralElement(node: ArrayLiteralExpression, element: Expression): Type {
return getTypeOfDestructuredArrayElement(getAssignedType(node), indexOf(node.elements, element));
}
@@ -12599,6 +12624,16 @@ namespace ts {
}
}
function isInPropertyInitializer(node: Node): boolean {
while (node) {
if (node.parent && node.parent.kind === SyntaxKind.PropertyDeclaration && (node.parent as PropertyDeclaration).initializer === node) {
return true;
}
node = node.parent;
}
return false;
}
function checkPropertyAccessExpressionOrQualifiedName(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, right: Identifier) {
const type = checkNonNullExpression(left);
if (isTypeAny(type) || type === silentNeverType) {
@@ -12621,6 +12656,11 @@ namespace ts {
}
return unknownType;
}
if (prop.valueDeclaration &&
isInPropertyInitializer(node) &&
!isBlockScopedNameDeclaredBeforeUse(prop.valueDeclaration, right)) {
error(right, Diagnostics.Block_scoped_variable_0_used_before_its_declaration, right.text);
}
markPropertyAsReferenced(prop);
@@ -14682,7 +14722,7 @@ namespace ts {
function checkTypeOfExpression(node: TypeOfExpression): Type {
checkExpression(node.expression);
return stringType;
return typeofType;
}
function checkVoidExpression(node: VoidExpression): Type {
+10
View File
@@ -9,6 +9,7 @@ namespace ts {
emitNodeWithComments(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void;
emitBodyWithDetachedComments(node: Node, detachedRange: TextRange, emitCallback: (node: Node) => void): void;
emitTrailingCommentsOfPosition(pos: number): void;
emitLeadingCommentsOfPosition(pos: number): void;
}
export function createCommentWriter(printerOptions: PrinterOptions, emitPos: ((pos: number) => void) | undefined): CommentWriter {
@@ -32,6 +33,7 @@ namespace ts {
emitNodeWithComments,
emitBodyWithDetachedComments,
emitTrailingCommentsOfPosition,
emitLeadingCommentsOfPosition,
};
function emitNodeWithComments(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) {
@@ -210,6 +212,14 @@ namespace ts {
}
}
function emitLeadingCommentsOfPosition(pos: number) {
if (disabled || pos === -1) {
return;
}
emitLeadingComments(pos, /*isEmittedNode*/ true);
}
function emitTrailingComments(pos: number) {
forEachTrailingCommentToEmit(pos, emitTrailingComment);
}
+8
View File
@@ -895,6 +895,14 @@ namespace ts {
return result;
}
export function convertToArray<T, U>(iterator: Iterator<T>, f: (value: T) => U) {
const result: U[] = [];
for (let { value, done } = iterator.next(); !done; { value, done } = iterator.next()) {
result.push(f(value));
}
return result;
}
/**
* Calls `callback` for each entry in the map, returning the first truthy result.
* Use `map.forEach` instead for normal iteration.
+36 -11
View File
@@ -1,4 +1,4 @@
/// <reference path="checker.ts" />
/// <reference path="checker.ts" />
/// <reference path="transformer.ts" />
/// <reference path="declarationEmitter.ts" />
/// <reference path="sourcemap.ts" />
@@ -211,6 +211,7 @@ namespace ts {
emitNodeWithComments,
emitBodyWithDetachedComments,
emitTrailingCommentsOfPosition,
emitLeadingCommentsOfPosition,
} = comments;
let currentSourceFile: SourceFile;
@@ -1346,6 +1347,10 @@ namespace ts {
else {
writeToken(SyntaxKind.OpenBraceToken, node.pos, /*contextNode*/ node);
emitBlockStatements(node);
// We have to call emitLeadingComments explicitly here because otherwise leading comments of the close brace token will not be emitted
increaseIndent();
emitLeadingCommentsOfPosition(node.statements.end);
decreaseIndent();
writeToken(SyntaxKind.CloseBraceToken, node.statements.end, /*contextNode*/ node);
}
}
@@ -2229,6 +2234,15 @@ namespace ts {
// Write the delimiter if this is not the first node.
if (previousSibling) {
// i.e
// function commentedParameters(
// /* Parameter a */
// a
// /* End of parameter a */ -> this comment isn't considered to be trailing comment of parameter "a" due to newline
// ,
if (delimiter && previousSibling.end !== parentNode.end) {
emitLeadingCommentsOfPosition(previousSibling.end);
}
write(delimiter);
// Write either a line terminator or whitespace to separate the elements.
@@ -2275,6 +2289,17 @@ namespace ts {
write(",");
}
// Emit any trailing comment of the last element in the list
// i.e
// var array = [...
// 2
// /* end of element 2 */
// ];
if (previousSibling && delimiter && previousSibling.end !== parentNode.end) {
emitLeadingCommentsOfPosition(previousSibling.end);
}
// Decrease the indent, if requested.
if (format & ListFormat.Indented) {
decreaseIndent();
@@ -2566,7 +2591,7 @@ namespace ts {
// Node names generate unique names based on their original node
// and are cached based on that node's id.
const node = getNodeForGeneratedName(name);
return generateNameCached(node, getTextOfNode);
return generateNameCached(node);
}
else {
// Auto, Loop, and Unique names are cached based on their unique
@@ -2576,9 +2601,9 @@ namespace ts {
}
}
function generateNameCached(node: Node, getTextOfNode: (node: Node, includeTrivia?: boolean) => string) {
function generateNameCached(node: Node) {
const nodeId = getNodeId(node);
return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = unescapeIdentifier(generateNameForNode(node, getTextOfNode)));
return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = unescapeIdentifier(generateNameForNode(node)));
}
/**
@@ -2660,7 +2685,7 @@ namespace ts {
/**
* Generates a unique name for a ModuleDeclaration or EnumDeclaration.
*/
function generateNameForModuleOrEnum(node: ModuleDeclaration | EnumDeclaration, getTextOfNode: (node: Node, includeTrivia?: boolean) => string) {
function generateNameForModuleOrEnum(node: ModuleDeclaration | EnumDeclaration) {
const name = getTextOfNode(node.name);
// Use module/enum name itself if it is unique, otherwise make a unique variation
return isUniqueLocalName(name, node) ? name : makeUniqueName(name);
@@ -2690,9 +2715,9 @@ namespace ts {
return makeUniqueName("class");
}
function generateNameForMethodOrAccessor(node: MethodDeclaration | AccessorDeclaration, getTextOfNode: (node: Node, includeTrivia?: boolean) => string) {
function generateNameForMethodOrAccessor(node: MethodDeclaration | AccessorDeclaration) {
if (isIdentifier(node.name)) {
return generateNameCached(node.name, getTextOfNode);
return generateNameCached(node.name);
}
return makeTempVariableName(TempFlags.Auto);
}
@@ -2700,13 +2725,13 @@ namespace ts {
/**
* Generates a unique name from a node.
*/
function generateNameForNode(node: Node, getTextOfNode: (node: Node, includeTrivia?: boolean) => string): string {
function generateNameForNode(node: Node): string {
switch (node.kind) {
case SyntaxKind.Identifier:
return makeUniqueName(getTextOfNode(node));
case SyntaxKind.ModuleDeclaration:
case SyntaxKind.EnumDeclaration:
return generateNameForModuleOrEnum(<ModuleDeclaration | EnumDeclaration>node, getTextOfNode);
return generateNameForModuleOrEnum(<ModuleDeclaration | EnumDeclaration>node);
case SyntaxKind.ImportDeclaration:
case SyntaxKind.ExportDeclaration:
return generateNameForImportOrExportDeclaration(<ImportDeclaration | ExportDeclaration>node);
@@ -2719,7 +2744,7 @@ namespace ts {
case SyntaxKind.MethodDeclaration:
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
return generateNameForMethodOrAccessor(<MethodDeclaration | AccessorDeclaration>node, getTextOfNode);
return generateNameForMethodOrAccessor(<MethodDeclaration | AccessorDeclaration>node);
default:
return makeTempVariableName(TempFlags.Auto);
}
@@ -2735,7 +2760,7 @@ namespace ts {
case GeneratedIdentifierKind.Loop:
return makeTempVariableName(TempFlags._i);
case GeneratedIdentifierKind.Unique:
return makeUniqueName(name.text);
return makeUniqueName(unescapeIdentifier(name.text));
}
Debug.fail("Unsupported GeneratedIdentifierKind.");
+1307 -1108
View File
File diff suppressed because it is too large. Load diff
+3 -6
View File
@@ -1152,13 +1152,10 @@ namespace ts {
&& (options.isolatedModules || isExternalModuleFile)
&& !file.isDeclarationFile) {
// synthesize 'import "tslib"' declaration
const externalHelpersModuleReference = <StringLiteral>createSynthesizedNode(SyntaxKind.StringLiteral);
externalHelpersModuleReference.text = externalHelpersModuleNameText;
const importDecl = createSynthesizedNode(SyntaxKind.ImportDeclaration);
importDecl.parent = file;
const externalHelpersModuleReference = createLiteral(externalHelpersModuleNameText);
const importDecl = createImportDeclaration(undefined, undefined, undefined);
externalHelpersModuleReference.parent = importDecl;
importDecl.parent = file;
imports = [externalHelpersModuleReference];
}
+8 -1
View File
@@ -485,7 +485,10 @@ namespace ts {
// Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows
// (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643)
let options: any;
if (!directoryExists(directoryName)) {
if (!directoryExists(directoryName) || (isUNCPath(directoryName) && process.platform === "win32")) {
// do nothing if either
// - target folder does not exist
// - this is UNC path on Windows (https://github.com/Microsoft/TypeScript/issues/13874)
return noOpFileWatcher;
}
@@ -509,6 +512,10 @@ namespace ts {
};
}
);
function isUNCPath(s: string): boolean {
return s.length > 2 && s.charCodeAt(0) === CharacterCodes.slash && s.charCodeAt(1) === CharacterCodes.slash;
}
},
resolvePath: function(path: string): string {
return _path.resolve(path);
+18 -5
View File
@@ -114,7 +114,10 @@ namespace ts {
Debug.assertNode(target, createAssignmentCallback ? isIdentifier : isExpression);
const expression = createAssignmentCallback
? createAssignmentCallback(<Identifier>target, value, location)
: createAssignment(visitNode(<Expression>target, visitor, isExpression), value, location);
: setTextRange(
createAssignment(visitNode(<Expression>target, visitor, isExpression), value),
location
);
expression.original = original;
emitExpression(expression);
}
@@ -177,9 +180,10 @@ namespace ts {
const variable = createVariableDeclaration(
name,
/*type*/ undefined,
pendingExpressions ? inlineExpressions(append(pendingExpressions, value)) : value,
location);
pendingExpressions ? inlineExpressions(append(pendingExpressions, value)) : value
);
variable.original = original;
setTextRange(variable, location);
if (isIdentifier(name)) {
setEmitFlags(variable, EmitFlags.NoNestedSourceMaps);
}
@@ -435,7 +439,7 @@ namespace ts {
const temp = createTempVariable(/*recordTempVariable*/ undefined);
if (flattenContext.hoistTempVariables) {
flattenContext.context.hoistVariableDeclaration(temp);
flattenContext.emitExpression(createAssignment(temp, value, location));
flattenContext.emitExpression(setTextRange(createAssignment(temp, value), location));
}
else {
flattenContext.emitBindingOrAssignment(temp, value, location, /*original*/ undefined);
@@ -511,6 +515,15 @@ namespace ts {
}
}
}
return createCall(getHelperName("__rest"), undefined, [value, createArrayLiteral(propertyNames, location)]);
return createCall(
getHelperName("__rest"),
undefined,
[
value,
setTextRange(
createArrayLiteral(propertyNames),
location
)
]);
}
}
+231 -189
View File
@@ -516,7 +516,7 @@ namespace ts {
exitSubtree(ancestorFacts, HierarchyFacts.None, HierarchyFacts.None);
return updateSourceFileNode(
node,
createNodeArray(statements, node.statements)
setTextRange(createNodeArray(statements), node.statements)
);
}
@@ -673,9 +673,10 @@ namespace ts {
setOriginalNode(variable, node);
const statements: Statement[] = [];
const statement = createVariableStatement(/*modifiers*/ undefined, createVariableDeclarationList([variable]), /*location*/ node);
const statement = createVariableStatement(/*modifiers*/ undefined, createVariableDeclarationList([variable]));
setOriginalNode(statement, node);
setTextRange(statement, node);
startOnNewLine(statement);
statements.push(statement);
@@ -820,7 +821,7 @@ namespace ts {
addRange(statements, endLexicalEnvironment());
const block = createBlock(createNodeArray(statements, /*location*/ node.members), /*location*/ undefined, /*multiLine*/ true);
const block = createBlock(setTextRange(createNodeArray(statements), /*location*/ node.members), /*multiLine*/ true);
setEmitFlags(block, EmitFlags.NoComments);
return block;
}
@@ -835,8 +836,10 @@ namespace ts {
function addExtendsHelperIfNeeded(statements: Statement[], node: ClassExpression | ClassDeclaration, extendsClauseElement: ExpressionWithTypeArguments): void {
if (extendsClauseElement) {
statements.push(
createStatement(
createExtendsHelper(context, getLocalName(node)),
setTextRange(
createStatement(
createExtendsHelper(context, getLocalName(node))
),
/*location*/ extendsClauseElement
)
);
@@ -856,19 +859,18 @@ namespace ts {
const ancestorFacts = enterSubtree(HierarchyFacts.ConstructorExcludes, HierarchyFacts.ConstructorIncludes);
const constructor = getFirstConstructorWithBody(node);
const hasSynthesizedSuper = hasSynthesizedDefaultSuperCall(constructor, extendsClauseElement !== undefined);
const constructorFunction =
createFunctionDeclaration(
/*decorators*/ undefined,
/*modifiers*/ undefined,
/*asteriskToken*/ undefined,
getDeclarationName(node),
/*typeParameters*/ undefined,
transformConstructorParameters(constructor, hasSynthesizedSuper),
/*type*/ undefined,
transformConstructorBody(constructor, node, extendsClauseElement, hasSynthesizedSuper),
/*location*/ constructor || node
);
const constructorFunction = createFunctionDeclaration(
/*decorators*/ undefined,
/*modifiers*/ undefined,
/*asteriskToken*/ undefined,
getDeclarationName(node),
/*typeParameters*/ undefined,
transformConstructorParameters(constructor, hasSynthesizedSuper),
/*type*/ undefined,
transformConstructorBody(constructor, node, extendsClauseElement, hasSynthesizedSuper)
);
setTextRange(constructorFunction, constructor || node);
if (extendsClauseElement) {
setEmitFlags(constructorFunction, EmitFlags.CapturesThis);
}
@@ -964,14 +966,16 @@ namespace ts {
}
const block = createBlock(
createNodeArray(
statements,
setTextRange(
createNodeArray(
statements
),
/*location*/ constructor ? constructor.body.statements : node.members
),
/*location*/ constructor ? constructor.body : node,
/*multiLine*/ true
);
setTextRange(block, constructor ? constructor.body : node);
if (!constructor) {
setEmitFlags(block, EmitFlags.NoComments);
}
@@ -1141,14 +1145,16 @@ namespace ts {
// Binding patterns are converted into a generated name and are
// evaluated inside the function body.
return setOriginalNode(
createParameter(
/*decorators*/ undefined,
/*modifiers*/ undefined,
/*dotDotDotToken*/ undefined,
getGeneratedNameForNode(node),
/*questionToken*/ undefined,
/*type*/ undefined,
/*initializer*/ undefined,
setTextRange(
createParameter(
/*decorators*/ undefined,
/*modifiers*/ undefined,
/*dotDotDotToken*/ undefined,
getGeneratedNameForNode(node),
/*questionToken*/ undefined,
/*type*/ undefined,
/*initializer*/ undefined
),
/*location*/ node
),
/*original*/ node
@@ -1157,14 +1163,16 @@ namespace ts {
else if (node.initializer) {
// Initializers are elided
return setOriginalNode(
createParameter(
/*decorators*/ undefined,
/*modifiers*/ undefined,
/*dotDotDotToken*/ undefined,
node.name,
/*questionToken*/ undefined,
/*type*/ undefined,
/*initializer*/ undefined,
setTextRange(
createParameter(
/*decorators*/ undefined,
/*modifiers*/ undefined,
/*dotDotDotToken*/ undefined,
node.name,
/*questionToken*/ undefined,
/*type*/ undefined,
/*initializer*/ undefined
),
/*location*/ node
),
/*original*/ node
@@ -1276,21 +1284,25 @@ namespace ts {
const statement = createIf(
createTypeCheck(getSynthesizedClone(name), "undefined"),
setEmitFlags(
createBlock([
createStatement(
createAssignment(
setEmitFlags(getMutableClone(name), EmitFlags.NoSourceMap),
setEmitFlags(initializer, EmitFlags.NoSourceMap | getEmitFlags(initializer)),
/*location*/ parameter
setTextRange(
createBlock([
createStatement(
setTextRange(
createAssignment(
setEmitFlags(getMutableClone(name), EmitFlags.NoSourceMap),
setEmitFlags(initializer, EmitFlags.NoSourceMap | getEmitFlags(initializer))
),
parameter
)
)
)
], /*location*/ parameter),
]),
parameter
),
EmitFlags.SingleLine | EmitFlags.NoTrailingSourceMap | EmitFlags.NoTokenSourceMaps
),
/*elseStatement*/ undefined,
/*location*/ parameter
)
);
statement.startsOnNewLine = true;
setTextRange(statement, parameter);
setEmitFlags(statement, EmitFlags.NoTokenSourceMaps | EmitFlags.NoTrailingSourceMap | EmitFlags.CustomPrologue);
statements.push(statement);
}
@@ -1334,15 +1346,17 @@ namespace ts {
// var param = [];
statements.push(
setEmitFlags(
createVariableStatement(
/*modifiers*/ undefined,
createVariableDeclarationList([
createVariableDeclaration(
declarationName,
/*type*/ undefined,
createArrayLiteral([])
)
]),
setTextRange(
createVariableStatement(
/*modifiers*/ undefined,
createVariableDeclarationList([
createVariableDeclaration(
declarationName,
/*type*/ undefined,
createArrayLiteral([])
)
])
),
/*location*/ parameter
),
EmitFlags.CustomPrologue
@@ -1353,26 +1367,33 @@ namespace ts {
// param[_i - restIndex] = arguments[_i];
// }
const forStatement = createFor(
createVariableDeclarationList([
createVariableDeclaration(temp, /*type*/ undefined, createLiteral(restIndex))
], /*location*/ parameter),
createLessThan(
temp,
createPropertyAccess(createIdentifier("arguments"), "length"),
/*location*/ parameter
setTextRange(
createVariableDeclarationList([
createVariableDeclaration(temp, /*type*/ undefined, createLiteral(restIndex))
]),
parameter
),
createPostfixIncrement(temp, /*location*/ parameter),
setTextRange(
createLessThan(
temp,
createPropertyAccess(createIdentifier("arguments"), "length")
),
parameter
),
setTextRange(createPostfixIncrement(temp), parameter),
createBlock([
startOnNewLine(
createStatement(
createAssignment(
createElementAccess(
expressionName,
restIndex === 0
? temp
: createSubtract(temp, createLiteral(restIndex))
),
createElementAccess(createIdentifier("arguments"), temp)
setTextRange(
createStatement(
createAssignment(
createElementAccess(
expressionName,
restIndex === 0
? temp
: createSubtract(temp, createLiteral(restIndex))
),
createElementAccess(createIdentifier("arguments"), temp)
)
),
/*location*/ parameter
)
@@ -1407,11 +1428,10 @@ namespace ts {
/*type*/ undefined,
initializer
)
]),
originalStatement
])
);
setEmitFlags(captureThisStatement, EmitFlags.NoComments | EmitFlags.CustomPrologue);
setTextRange(captureThisStatement, originalStatement);
setSourceMapRange(captureThisStatement, node);
statements.push(captureThisStatement);
}
@@ -1531,7 +1551,7 @@ namespace ts {
* @param member The SemicolonClassElement node.
*/
function transformSemicolonClassElementToStatement(member: SemicolonClassElement) {
return createEmptyStatement(/*location*/ member);
return setTextRange(createEmptyStatement(), member);
}
/**
@@ -1549,8 +1569,10 @@ namespace ts {
setEmitFlags(memberFunction, EmitFlags.NoComments);
setSourceMapRange(memberFunction, sourceMapRange);
const statement = createStatement(
createAssignment(memberName, memberFunction),
const statement = setTextRange(
createStatement(
createAssignment(memberName, memberFunction)
),
/*location*/ member
);
@@ -1573,15 +1595,12 @@ namespace ts {
* @param accessors The set of related get/set accessors.
*/
function transformAccessorsToStatement(receiver: LeftHandSideExpression, accessors: AllAccessorDeclarations, container: Node): Statement {
const statement = createStatement(
transformAccessorsToExpression(receiver, accessors, container, /*startsOnNewLine*/ false),
/*location*/ getSourceMapRange(accessors.firstAccessor)
);
const statement = createStatement(transformAccessorsToExpression(receiver, accessors, container, /*startsOnNewLine*/ false));
// The location for the statement is used to emit source maps only.
// No comments should be emitted for this statement to align with the
// old emitter.
setEmitFlags(statement, EmitFlags.NoComments);
setSourceMapRange(statement, getSourceMapRange(accessors.firstAccessor));
return statement;
}
@@ -1624,8 +1643,8 @@ namespace ts {
}
properties.push(
createPropertyAssignment("enumerable", createLiteral(true)),
createPropertyAssignment("configurable", createLiteral(true))
createPropertyAssignment("enumerable", createTrue()),
createPropertyAssignment("configurable", createTrue())
);
const call = createCall(
@@ -1634,7 +1653,7 @@ namespace ts {
[
target,
propertyName,
createObjectLiteral(properties, /*location*/ undefined, /*multiLine*/ true)
createObjectLiteral(properties, /*multiLine*/ true)
]
);
if (startsOnNewLine) {
@@ -1664,9 +1683,9 @@ namespace ts {
/*typeParameters*/ undefined,
visitParameterList(node.parameters, visitor, context),
/*type*/ undefined,
transformFunctionBody(node),
node
transformFunctionBody(node)
);
setTextRange(func, node);
setOriginalNode(func, node);
setEmitFlags(func, EmitFlags.CapturesThis);
exitSubtree(ancestorFacts, HierarchyFacts.None, HierarchyFacts.None);
@@ -1762,14 +1781,16 @@ namespace ts {
exitSubtree(ancestorFacts, HierarchyFacts.PropagateNewTargetMask, HierarchyFacts.None);
convertedLoopState = savedConvertedLoopState;
return setOriginalNode(
createFunctionExpression(
/*modifiers*/ undefined,
node.asteriskToken,
name,
/*typeParameters*/ undefined,
parameters,
/*type*/ undefined,
body,
setTextRange(
createFunctionExpression(
/*modifiers*/ undefined,
node.asteriskToken,
name,
/*typeParameters*/ undefined,
parameters,
/*type*/ undefined,
body
),
location
),
/*original*/ node
@@ -1836,7 +1857,8 @@ namespace ts {
}
const expression = visitNode(body, visitor, isExpression);
const returnStatement = createReturn(expression, /*location*/ body);
const returnStatement = createReturn(expression);
setTextRange(returnStatement, body);
setEmitFlags(returnStatement, EmitFlags.NoTokenSourceMaps | EmitFlags.NoTrailingSourceMap | EmitFlags.NoTrailingComments);
statements.push(returnStatement);
@@ -1855,7 +1877,8 @@ namespace ts {
multiLine = true;
}
const block = createBlock(createNodeArray(statements, statementsLocation), node.body, multiLine);
const block = createBlock(setTextRange(createNodeArray(statements), statementsLocation), multiLine);
setTextRange(block, node.body);
if (!multiLine && singleLine) {
setEmitFlags(block, EmitFlags.SingleLine);
}
@@ -1872,8 +1895,10 @@ namespace ts {
const updated = visitFunctionBody(node.body, functionBodyVisitor, context);
return updateBlock(
updated,
createNodeArray(
prependCaptureNewTargetIfNeeded(updated.statements, node, /*copyOnWrite*/ true),
setTextRange(
createNodeArray(
prependCaptureNewTargetIfNeeded(updated.statements, node, /*copyOnWrite*/ true)
),
/*location*/ updated.statements
)
);
@@ -1977,8 +2002,7 @@ namespace ts {
}
}
if (assignments) {
// TODO(rbuckton): use inlineExpressions.
updated = createStatement(reduceLeft(assignments, (acc, v) => createBinary(v, SyntaxKind.CommaToken, acc)), node);
updated = setTextRange(createStatement(reduceLeft(assignments, (acc, v) => createBinary(v, SyntaxKind.CommaToken, acc))), node);
}
else {
// none of declarations has initializer - the entire variable statement can be deleted
@@ -2008,8 +2032,9 @@ namespace ts {
? visitVariableDeclarationInLetDeclarationList
: visitVariableDeclaration));
const declarationList = createVariableDeclarationList(declarations, /*location*/ node);
const declarationList = createVariableDeclarationList(declarations);
setOriginalNode(declarationList, node);
setTextRange(declarationList, node);
setCommentRange(declarationList, node);
if (node.transformFlags & TransformFlags.ContainsBindingPattern
@@ -2234,7 +2259,7 @@ namespace ts {
boundValue
);
const declarationList = createVariableDeclarationList(declarations, /*location*/ node.initializer);
const declarationList = setTextRange(createVariableDeclarationList(declarations), node.initializer);
setOriginalNode(declarationList, node.initializer);
// Adjust the source map range for the first declaration to align with the old
@@ -2254,22 +2279,24 @@ namespace ts {
// The following call does not include the initializer, so we have
// to emit it separately.
statements.push(
createVariableStatement(
/*modifiers*/ undefined,
setOriginalNode(
createVariableDeclarationList(
[
createVariableDeclaration(
firstOriginalDeclaration ? firstOriginalDeclaration.name : createTempVariable(/*recordTempVariable*/ undefined),
/*type*/ undefined,
boundValue
)
],
/*location*/ moveRangePos(node.initializer, -1)
),
node.initializer
setTextRange(
createVariableStatement(
/*modifiers*/ undefined,
setOriginalNode(
setTextRange(
createVariableDeclarationList([
createVariableDeclaration(
firstOriginalDeclaration ? firstOriginalDeclaration.name : createTempVariable(/*recordTempVariable*/ undefined),
/*type*/ undefined,
boundValue
)
]),
moveRangePos(node.initializer, -1)
),
node.initializer
)
),
/*location*/ moveRangeEnd(node.initializer, -1)
moveRangeEnd(node.initializer, -1)
)
);
}
@@ -2284,7 +2311,7 @@ namespace ts {
}
else {
assignment.end = node.initializer.end;
statements.push(createStatement(visitNode(assignment, visitor, isExpression), /*location*/ moveRangeEnd(node.initializer, -1)));
statements.push(setTextRange(createStatement(visitNode(assignment, visitor, isExpression)), moveRangeEnd(node.initializer, -1)));
}
}
@@ -2308,10 +2335,12 @@ namespace ts {
// The old emitter does not emit source maps for the block.
// We add the location to preserve comments.
return setEmitFlags(
createBlock(
createNodeArray(statements, /*location*/ statementsLocation),
/*location*/ bodyLocation,
/*multiLine*/ true
setTextRange(
createBlock(
setTextRange(createNodeArray(statements), statementsLocation),
/*multiLine*/ true
),
bodyLocation,
),
EmitFlags.NoSourceMap | EmitFlags.NoTokenSourceMaps
);
@@ -2352,30 +2381,38 @@ namespace ts {
// The old emitter does not emit source maps for the expression
setEmitFlags(expression, EmitFlags.NoSourceMap | getEmitFlags(expression));
const forStatement = createFor(
/*initializer*/ setEmitFlags(
createVariableDeclarationList([
createVariableDeclaration(counter, /*type*/ undefined, createLiteral(0), /*location*/ moveRangePos(node.expression, -1)),
createVariableDeclaration(rhsReference, /*type*/ undefined, expression, /*location*/ node.expression)
], /*location*/ node.expression),
EmitFlags.NoHoisting
),
/*condition*/ createLessThan(
counter,
createPropertyAccess(rhsReference, "length"),
/*location*/ node.expression
),
/*incrementor*/ createPostfixIncrement(counter, /*location*/ node.expression),
/*statement*/ convertForOfStatementHead(
node,
createElementAccess(rhsReference, counter),
convertedLoopBodyStatements
const forStatement = setTextRange(
createFor(
/*initializer*/ setEmitFlags(
setTextRange(
createVariableDeclarationList([
setTextRange(createVariableDeclaration(counter, /*type*/ undefined, createLiteral(0)), moveRangePos(node.expression, -1)),
setTextRange(createVariableDeclaration(rhsReference, /*type*/ undefined, expression), node.expression)
]),
node.expression
),
EmitFlags.NoHoisting
),
/*condition*/ setTextRange(
createLessThan(
counter,
createPropertyAccess(rhsReference, "length")
),
node.expression
),
/*incrementor*/ setTextRange(createPostfixIncrement(counter), node.expression),
/*statement*/ convertForOfStatementHead(
node,
createElementAccess(rhsReference, counter),
convertedLoopBodyStatements
)
),
/*location*/ node
);
// Disable trailing source maps for the OpenParenToken to align source map emit with the old emitter.
setEmitFlags(forStatement, EmitFlags.NoTokenTrailingSourceMaps);
setTextRange(forStatement, node);
return restoreEnclosingLabel(forStatement, outermostLabeledStatement, convertedLoopState && resetLabel);
}
@@ -2393,20 +2430,25 @@ namespace ts {
hoistVariableDeclaration(returnMethod);
const forStatement = setEmitFlags(
createFor(
/*initializer*/ setEmitFlags(
createVariableDeclarationList([
createVariableDeclaration(iterator, /*type*/ undefined, values, /*location*/ node.expression),
createVariableDeclaration(result, /*type*/ undefined, next)
], /*location*/ node.expression),
EmitFlags.NoHoisting
),
/*condition*/ createLogicalNot(createPropertyAccess(result, "done")),
/*incrementor*/ createAssignment(result, next),
/*statement*/ convertForOfStatementHead(
node,
createPropertyAccess(result, "value"),
convertedLoopBodyStatements
setTextRange(
createFor(
/*initializer*/ setEmitFlags(
setTextRange(
createVariableDeclarationList([
setTextRange(createVariableDeclaration(iterator, /*type*/ undefined, values), node.expression),
createVariableDeclaration(result, /*type*/ undefined, next)
]),
node.expression
),
EmitFlags.NoHoisting
),
/*condition*/ createLogicalNot(createPropertyAccess(result, "done")),
/*incrementor*/ createAssignment(result, next),
/*statement*/ convertForOfStatementHead(
node,
createPropertyAccess(result, "value"),
convertedLoopBodyStatements
)
),
/*location*/ node
),
@@ -2421,7 +2463,7 @@ namespace ts {
convertedLoopState && resetLabel
)
]),
createCatchClause(catchVariable,
createCatchClause(createVariableDeclaration(catchVariable),
setEmitFlags(
createBlock([
createStatement(
@@ -2522,7 +2564,6 @@ namespace ts {
setEmitFlags(
createObjectLiteral(
visitNodes(properties, visitor, isObjectLiteralElementLike, 0, numInitialProperties),
/*location*/ undefined,
node.multiLine
),
EmitFlags.Indented
@@ -2650,14 +2691,14 @@ namespace ts {
copyOutParameters(loopOutParameters, CopyDirection.ToOutParameter, statements);
}
addRange(statements, lexicalEnvironment)
loopBody = createBlock(statements, /*location*/ undefined, /*multiline*/ true);
loopBody = createBlock(statements, /*multiline*/ true);
}
if (isBlock(loopBody)) {
loopBody.multiLine = true;
}
else {
loopBody = createBlock([loopBody], /*location*/ undefined, /*multiline*/ true);
loopBody = createBlock([loopBody], /*multiline*/ true);
}
const isAsyncBlockContainingAwait =
@@ -2792,12 +2833,7 @@ namespace ts {
// visit childnodes to transform initializer/condition/incrementor parts
clone = visitEachChild(clone, visitor, context);
// set loop statement
clone.statement = createBlock(
convertedLoopBodyStatements,
/*location*/ undefined,
/*multiline*/ true
);
clone.statement = createBlock(convertedLoopBodyStatements, /*multiline*/ true);
// reset and re-aggregate the transform flags
clone.transformFlags = 0;
aggregateTransformFlags(clone);
@@ -2946,7 +2982,7 @@ namespace ts {
else {
loopParameters.push(createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, name));
if (resolver.getNodeCheckFlags(decl) & NodeCheckFlags.NeedsLoopOutParameter) {
const outParamName = createUniqueName("out_" + name.text);
const outParamName = createUniqueName("out_" + unescapeIdentifier(name.text));
loopOutParameters.push({ originalName: name, outParamName });
}
}
@@ -3008,9 +3044,9 @@ namespace ts {
receiver,
visitNode(property.name, visitor, isPropertyName)
),
visitNode(property.initializer, visitor, isExpression),
/*location*/ property
visitNode(property.initializer, visitor, isExpression)
);
setTextRange(expression, property);
if (startsOnNewLine) {
expression.startsOnNewLine = true;
}
@@ -3030,9 +3066,9 @@ namespace ts {
receiver,
visitNode(property.name, visitor, isPropertyName)
),
getSynthesizedClone(property.name),
/*location*/ property
getSynthesizedClone(property.name)
);
setTextRange(expression, property);
if (startsOnNewLine) {
expression.startsOnNewLine = true;
}
@@ -3053,9 +3089,9 @@ namespace ts {
receiver,
visitNode(method.name, visitor, isPropertyName)
),
transformFunctionLikeToExpression(method, /*location*/ method, /*name*/ undefined, container),
/*location*/ method
transformFunctionLikeToExpression(method, /*location*/ method, /*name*/ undefined, container)
);
setTextRange(expression, method);
if (startsOnNewLine) {
expression.startsOnNewLine = true;
}
@@ -3068,7 +3104,8 @@ namespace ts {
let updated: CatchClause;
if (isBindingPattern(node.variableDeclaration.name)) {
const temp = createTempVariable(undefined);
const newVariableDeclaration = createVariableDeclaration(temp, undefined, undefined, node.variableDeclaration);
const newVariableDeclaration = createVariableDeclaration(temp);
setTextRange(newVariableDeclaration, node.variableDeclaration);
const vars = flattenDestructuringBinding(
node.variableDeclaration,
visitor,
@@ -3076,8 +3113,9 @@ namespace ts {
FlattenLevel.All,
temp
);
const list = createVariableDeclarationList(vars, /*location*/ node.variableDeclaration, /*flags*/ node.variableDeclaration.flags);
const destructure = createVariableStatement(undefined, list);
const list = createVariableDeclarationList(vars);
setTextRange(list, node.variableDeclaration);
const destructure = createVariableStatement(/*modifiers*/ undefined, list);
updated = updateCatchClause(node, newVariableDeclaration, addStatementToStartOfBlock(node.block, destructure));
}
else {
@@ -3106,9 +3144,11 @@ namespace ts {
Debug.assert(!isComputedPropertyName(node.name));
const functionExpression = transformFunctionLikeToExpression(node, /*location*/ moveRangePos(node, -1), /*name*/ undefined, /*container*/ undefined);
setEmitFlags(functionExpression, EmitFlags.NoLeadingComments | getEmitFlags(functionExpression));
return createPropertyAssignment(
node.name,
functionExpression,
return setTextRange(
createPropertyAssignment(
node.name,
functionExpression
),
/*location*/ node
);
}
@@ -3135,9 +3175,11 @@ namespace ts {
* @param node A ShorthandPropertyAssignment node.
*/
function visitShorthandPropertyAssignment(node: ShorthandPropertyAssignment): ObjectLiteralElementLike {
return createPropertyAssignment(
node.name,
getSynthesizedClone(node.name),
return setTextRange(
createPropertyAssignment(
node.name,
getSynthesizedClone(node.name)
),
/*location*/ node
);
}
@@ -3345,8 +3387,7 @@ namespace ts {
function visitSpanOfNonSpreads(chunk: Expression[], multiLine: boolean, hasTrailingComma: boolean): VisitResult<Expression> {
return createArrayLiteral(
visitNodes(createNodeArray(chunk, /*location*/ undefined, hasTrailingComma), visitor, isExpression),
/*location*/ undefined,
visitNodes(createNodeArray(chunk, hasTrailingComma), visitor, isExpression),
multiLine
);
}
@@ -3370,7 +3411,7 @@ namespace ts {
* @param node A template literal.
*/
function visitTemplateLiteral(node: LiteralExpression): LeftHandSideExpression {
return createLiteral(node.text, /*location*/ node);
return setTextRange(createLiteral(node.text), node);
}
/**
@@ -3438,7 +3479,7 @@ namespace ts {
// ES6 Spec 11.8.6.1 - Static Semantics of TV's and TRV's
// <CR><LF> and <CR> LineTerminatorSequences are normalized to <LF> for both TV and TRV.
text = text.replace(/\r\n?/g, "\n");
return createLiteral(text, /*location*/ node);
return setTextRange(createLiteral(text), node);
}
/**
@@ -3462,7 +3503,8 @@ namespace ts {
// "abc" + (1 << 2) + ""
const expression = reduceLeft(expressions, createAdd);
if (nodeIsSynthesized(expression)) {
setTextRange(expression, node);
expression.pos = node.pos;
expression.end = node.end;
}
return expression;
@@ -3700,7 +3742,7 @@ namespace ts {
function substituteThisKeyword(node: PrimaryExpression): PrimaryExpression {
if (enabledSubstitutions & ES2015SubstitutionFlags.CapturedThis
&& hierarchyFacts & HierarchyFacts.CapturesThis) {
return createIdentifier("_this", /*location*/ node);
return setTextRange(createIdentifier("_this"), node);
}
return node;
}
+31 -17
View File
@@ -48,29 +48,37 @@ namespace ts {
// Transforms `a[x] **= b` into `(_a = a)[_x = x] = Math.pow(_a[_x], b)`
const expressionTemp = createTempVariable(hoistVariableDeclaration);
const argumentExpressionTemp = createTempVariable(hoistVariableDeclaration);
target = createElementAccess(
createAssignment(expressionTemp, left.expression, /*location*/ left.expression),
createAssignment(argumentExpressionTemp, left.argumentExpression, /*location*/ left.argumentExpression),
/*location*/ left
target = setTextRange(
createElementAccess(
setTextRange(createAssignment(expressionTemp, left.expression), left.expression),
setTextRange(createAssignment(argumentExpressionTemp, left.argumentExpression), left.argumentExpression)
),
left
);
value = createElementAccess(
expressionTemp,
argumentExpressionTemp,
/*location*/ left
value = setTextRange(
createElementAccess(
expressionTemp,
argumentExpressionTemp
),
left
);
}
else if (isPropertyAccessExpression(left)) {
// Transforms `a.x **= b` into `(_a = a).x = Math.pow(_a.x, b)`
const expressionTemp = createTempVariable(hoistVariableDeclaration);
target = createPropertyAccess(
createAssignment(expressionTemp, left.expression, /*location*/ left.expression),
left.name,
/*location*/ left
target = setTextRange(
createPropertyAccess(
setTextRange(createAssignment(expressionTemp, left.expression), left.expression),
left.name
),
left
);
value = createPropertyAccess(
expressionTemp,
left.name,
/*location*/ left
value = setTextRange(
createPropertyAccess(
expressionTemp,
left.name
),
left
);
}
else {
@@ -78,7 +86,13 @@ namespace ts {
target = left;
value = left;
}
return createAssignment(target, createMathPow(value, right, /*location*/ node), /*location*/ node);
return setTextRange(
createAssignment(
target,
createMathPow(value, right, /*location*/ node)
),
node
);
}
function visitExponentiationExpression(node: BinaryExpression) {
+24 -17
View File
@@ -99,10 +99,12 @@ namespace ts {
*/
function visitAwaitExpression(node: AwaitExpression): Expression {
return setOriginalNode(
createYield(
/*asteriskToken*/ undefined,
visitNode(node.expression, visitor, isExpression),
/*location*/ node
setTextRange(
createYield(
/*asteriskToken*/ undefined,
visitNode(node.expression, visitor, isExpression)
),
node
),
node
);
@@ -233,7 +235,8 @@ namespace ts {
addRange(statements, endLexicalEnvironment());
const block = createBlock(statements, /*location*/ node.body, /*multiLine*/ true);
const block = createBlock(statements, /*multiLine*/ true);
setTextRange(block, node.body);
// Minor optimization, emit `_super` helper to capture `super` access in an arrow.
// This step isn't needed if we eventually transform this to ES5.
@@ -261,7 +264,7 @@ namespace ts {
const declarations = endLexicalEnvironment();
if (some(declarations)) {
const block = convertToFunctionBody(expression);
return updateBlock(block, createNodeArray(concatenate(block.statements, declarations), block.statements));
return updateBlock(block, setTextRange(createNodeArray(concatenate(block.statements, declarations)), block.statements));
}
return expression;
@@ -276,7 +279,7 @@ namespace ts {
startLexicalEnvironment();
const visited = convertToFunctionBody(visitNode(body, visitor, isConciseBody));
const declarations = endLexicalEnvironment();
return updateBlock(visited, createNodeArray(concatenate(visited.statements, declarations), visited.statements));
return updateBlock(visited, setTextRange(createNodeArray(concatenate(visited.statements, declarations)), visited.statements));
}
}
@@ -411,21 +414,25 @@ namespace ts {
function createSuperAccessInAsyncMethod(argumentExpression: Expression, location: TextRange): LeftHandSideExpression {
if (enclosingSuperContainerFlags & NodeCheckFlags.AsyncMethodWithSuperBinding) {
return createPropertyAccess(
return setTextRange(
createPropertyAccess(
createCall(
createIdentifier("_super"),
/*typeArguments*/ undefined,
[argumentExpression]
),
"value"
),
location
);
}
else {
return setTextRange(
createCall(
createIdentifier("_super"),
/*typeArguments*/ undefined,
[argumentExpression]
),
"value",
location
);
}
else {
return createCall(
createIdentifier("_super"),
/*typeArguments*/ undefined,
[argumentExpression],
location
);
}
+2 -2
View File
@@ -87,7 +87,7 @@ namespace ts {
function substitutePropertyAccessExpression(node: PropertyAccessExpression): Expression {
const literalName = trySubstituteReservedName(node.name);
if (literalName) {
return createElementAccess(node.expression, literalName, /*location*/ node);
return setTextRange(createElementAccess(node.expression, literalName), node);
}
return node;
}
@@ -113,7 +113,7 @@ namespace ts {
function trySubstituteReservedName(name: Identifier) {
const token = name.originalKeywordKind || (nodeIsSynthesized(name) ? stringToToken(name.text) : undefined);
if (token >= SyntaxKind.FirstReservedWord && token <= SyntaxKind.LastReservedWord) {
return createLiteral(name, /*location*/ name);
return setTextRange(createLiteral(name), name);
}
return undefined;
}
+69 -47
View File
@@ -110,9 +110,11 @@ namespace ts {
if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) {
const expression = visitNode(node.expression, visitor, isExpression);
return setOriginalNode(
createYield(
/*asteriskToken*/ undefined,
createArrayLiteral([createLiteral("await"), expression]),
setTextRange(
createYield(
/*asteriskToken*/ undefined,
createArrayLiteral([createLiteral("await"), expression])
),
/*location*/ node
),
node
@@ -294,18 +296,22 @@ namespace ts {
return updateForOf(
node,
node.awaitModifier,
createVariableDeclarationList(
[
createVariableDeclaration(temp, /*type*/ undefined, /*initializer*/ undefined, node.initializer)
],
node.initializer,
NodeFlags.Let
setTextRange(
createVariableDeclarationList(
[
setTextRange(createVariableDeclaration(temp), node.initializer)
],
NodeFlags.Let
),
node.initializer
),
node.expression,
createBlock(
createNodeArray(statements, statementsLocation),
bodyLocation,
/*multiLine*/ true
setTextRange(
createBlock(
setTextRange(createNodeArray(statements), statementsLocation),
/*multiLine*/ true
),
bodyLocation
)
);
}
@@ -329,10 +335,12 @@ namespace ts {
}
return setEmitFlags(
createBlock(
createNodeArray(statements, statementsLocation),
bodyLocation,
/*multiLine*/ true
setTextRange(
createBlock(
setTextRange(createNodeArray(statements), statementsLocation),
/*multiLine*/ true
),
bodyLocation
),
EmitFlags.NoSourceMap | EmitFlags.NoTokenSourceMaps
);
@@ -358,17 +366,22 @@ namespace ts {
hoistVariableDeclaration(returnMethod);
const forStatement = setEmitFlags(
createFor(
/*initializer*/ setEmitFlags(
createVariableDeclarationList([
createVariableDeclaration(iterator, /*type*/ undefined, values, node.expression),
createVariableDeclaration(result, /*type*/ undefined, next)
], /*location*/ node.expression),
EmitFlags.NoHoisting
setTextRange(
createFor(
/*initializer*/ setEmitFlags(
setTextRange(
createVariableDeclarationList([
setTextRange(createVariableDeclaration(iterator, /*type*/ undefined, values), node.expression),
createVariableDeclaration(result, /*type*/ undefined, next)
]),
node.expression
),
EmitFlags.NoHoisting
),
/*condition*/ createLogicalNot(createPropertyAccess(result, "done")),
/*incrementor*/ createAssignment(result, next),
/*statement*/ convertForOfStatementHead(node, createPropertyAccess(result, "value"))
),
/*condition*/ createLogicalNot(createPropertyAccess(result, "done")),
/*incrementor*/ createAssignment(result, next),
/*statement*/ convertForOfStatementHead(node, createPropertyAccess(result, "value")),
/*location*/ node
),
EmitFlags.NoTokenTrailingSourceMaps
@@ -381,7 +394,8 @@ namespace ts {
outermostLabeledStatement
)
]),
createCatchClause(catchVariable,
createCatchClause(
createVariableDeclaration(catchVariable),
setEmitFlags(
createBlock([
createStatement(
@@ -647,7 +661,7 @@ namespace ts {
const trailingStatements = endLexicalEnvironment();
if (some(leadingStatements) || some(trailingStatements)) {
const block = convertToFunctionBody(body, /*multiLine*/ true);
return updateBlock(block, createNodeArray(concatenate(concatenate(leadingStatements, block.statements), trailingStatements), block.statements));
return updateBlock(block, setTextRange(createNodeArray(concatenate(concatenate(leadingStatements, block.statements), trailingStatements)), block.statements));
}
return body;
}
@@ -798,21 +812,25 @@ namespace ts {
function createSuperAccessInAsyncMethod(argumentExpression: Expression, location: TextRange): LeftHandSideExpression {
if (enclosingSuperContainerFlags & NodeCheckFlags.AsyncMethodWithSuperBinding) {
return createPropertyAccess(
return setTextRange(
createPropertyAccess(
createCall(
createIdentifier("_super"),
/*typeArguments*/ undefined,
[argumentExpression]
),
"value"
),
location
);
}
else {
return setTextRange(
createCall(
createIdentifier("_super"),
/*typeArguments*/ undefined,
[argumentExpression]
),
"value",
location
);
}
else {
return createCall(
createIdentifier("_super"),
/*typeArguments*/ undefined,
[argumentExpression],
location
);
}
@@ -898,10 +916,12 @@ namespace ts {
function createAsyncDelegatorHelper(context: TransformationContext, expression: Expression, location?: TextRange) {
context.requestEmitHelper(asyncDelegator);
return createCall(
getHelperName("__asyncDelegator"),
/*typeArguments*/ undefined,
[expression],
return setTextRange(
createCall(
getHelperName("__asyncDelegator"),
/*typeArguments*/ undefined,
[expression]
),
location
);
}
@@ -919,10 +939,12 @@ namespace ts {
function createAsyncValuesHelper(context: TransformationContext, expression: Expression, location?: TextRange) {
context.requestEmitHelper(asyncValues);
return createCall(
getHelperName("__asyncValues"),
/*typeArguments*/ undefined,
[expression],
return setTextRange(
createCall(
getHelperName("__asyncValues"),
/*typeArguments*/ undefined,
[expression]
),
location
);
}
+126 -90
View File
@@ -450,15 +450,17 @@ namespace ts {
// Currently, we only support generators that were originally async functions.
if (node.asteriskToken) {
node = setOriginalNode(
createFunctionDeclaration(
/*decorators*/ undefined,
node.modifiers,
/*asteriskToken*/ undefined,
node.name,
/*typeParameters*/ undefined,
visitParameterList(node.parameters, visitor, context),
/*type*/ undefined,
transformGeneratorFunctionBody(node.body),
setTextRange(
createFunctionDeclaration(
/*decorators*/ undefined,
node.modifiers,
/*asteriskToken*/ undefined,
node.name,
/*typeParameters*/ undefined,
visitParameterList(node.parameters, visitor, context),
/*type*/ undefined,
transformGeneratorFunctionBody(node.body)
),
/*location*/ node
),
node
@@ -498,14 +500,16 @@ namespace ts {
// Currently, we only support generators that were originally async functions.
if (node.asteriskToken) {
node = setOriginalNode(
createFunctionExpression(
/*modifiers*/ undefined,
/*asteriskToken*/ undefined,
node.name,
/*typeParameters*/ undefined,
visitParameterList(node.parameters, visitor, context),
/*type*/ undefined,
transformGeneratorFunctionBody(node.body),
setTextRange(
createFunctionExpression(
/*modifiers*/ undefined,
/*asteriskToken*/ undefined,
node.name,
/*typeParameters*/ undefined,
visitParameterList(node.parameters, visitor, context),
/*type*/ undefined,
transformGeneratorFunctionBody(node.body)
),
/*location*/ node
),
node
@@ -606,7 +610,7 @@ namespace ts {
operationLocations = savedOperationLocations;
state = savedState;
return createBlock(statements, /*location*/ body, body.multiLine);
return setTextRange(createBlock(statements, body.multiLine), body);
}
/**
@@ -739,14 +743,17 @@ namespace ts {
const operator = node.operatorToken.kind;
if (isCompoundAssignment(operator)) {
return createBinary(
target,
SyntaxKind.EqualsToken,
createBinary(
cacheExpression(target),
getOperatorForCompoundAssignment(operator),
visitNode(right, visitor, isExpression),
node
return setTextRange(
createAssignment(
target,
setTextRange(
createBinary(
cacheExpression(target),
getOperatorForCompoundAssignment(operator),
visitNode(right, visitor, isExpression)
),
node
)
),
node
);
@@ -987,8 +994,11 @@ namespace ts {
const expressions = reduceLeft(elements, reduceElement, <Expression[]>[], numInitialElements);
return temp
? createArrayConcat(temp, [createArrayLiteral(expressions, /*location*/ undefined, multiLine)])
: createArrayLiteral(leadingElement ? [leadingElement, ...expressions] : expressions, location, multiLine);
? createArrayConcat(temp, [createArrayLiteral(expressions, multiLine)])
: setTextRange(
createArrayLiteral(leadingElement ? [leadingElement, ...expressions] : expressions, multiLine),
location
);
function reduceElement(expressions: Expression[], element: Expression) {
if (containsYield(element) && expressions.length > 0) {
@@ -1002,11 +1012,10 @@ namespace ts {
hasAssignedTemp
? createArrayConcat(
temp,
[createArrayLiteral(expressions, /*location*/ undefined, multiLine)]
[createArrayLiteral(expressions, multiLine)]
)
: createArrayLiteral(
leadingElement ? [leadingElement, ...expressions] : expressions,
/*location*/ undefined,
multiLine
)
);
@@ -1046,7 +1055,6 @@ namespace ts {
emitAssignment(temp,
createObjectLiteral(
visitNodes(properties, visitor, isObjectLiteralElementLike, 0, numInitialProperties),
/*location*/ undefined,
multiLine
)
);
@@ -1142,18 +1150,20 @@ namespace ts {
const { target, thisArg } = createCallBinding(createPropertyAccess(node.expression, "bind"), hoistVariableDeclaration);
return setOriginalNode(
createNew(
createFunctionApply(
cacheExpression(visitNode(target, visitor, isExpression)),
thisArg,
visitElements(
node.arguments,
/*leadingElement*/ createVoidZero()
)
setTextRange(
createNew(
createFunctionApply(
cacheExpression(visitNode(target, visitor, isExpression)),
thisArg,
visitElements(
node.arguments,
/*leadingElement*/ createVoidZero()
)
),
/*typeArguments*/ undefined,
[]
),
/*typeArguments*/ undefined,
[],
/*location*/ node
node
),
node
);
@@ -1426,9 +1436,11 @@ namespace ts {
}
else {
emitStatement(
createStatement(
visitNode(initializer, visitor, isExpression),
/*location*/ initializer
setTextRange(
createStatement(
visitNode(initializer, visitor, isExpression)
),
initializer
)
);
}
@@ -1444,9 +1456,11 @@ namespace ts {
markLabel(incrementLabel);
if (node.incrementor) {
emitStatement(
createStatement(
visitNode(node.incrementor, visitor, isExpression),
/*location*/ node.incrementor
setTextRange(
createStatement(
visitNode(node.incrementor, visitor, isExpression)
),
node.incrementor
)
);
}
@@ -2420,11 +2434,13 @@ namespace ts {
*/
function createInlineBreak(label: Label, location?: TextRange): ReturnStatement {
Debug.assert(label > 0, `Invalid label: ${label}`);
return createReturn(
createArrayLiteral([
createInstruction(Instruction.Break),
createLabel(label)
]),
return setTextRange(
createReturn(
createArrayLiteral([
createInstruction(Instruction.Break),
createLabel(label)
])
),
location
);
}
@@ -2436,10 +2452,12 @@ namespace ts {
* @param location An optional source map location for the statement.
*/
function createInlineReturn(expression?: Expression, location?: TextRange): ReturnStatement {
return createReturn(
createArrayLiteral(expression
? [createInstruction(Instruction.Return), expression]
: [createInstruction(Instruction.Return)]
return setTextRange(
createReturn(
createArrayLiteral(expression
? [createInstruction(Instruction.Return), expression]
: [createInstruction(Instruction.Return)]
)
),
location
);
@@ -2449,7 +2467,14 @@ namespace ts {
* Creates an expression that can be used to resume from a Yield operation.
*/
function createGeneratorResume(location?: TextRange): LeftHandSideExpression {
return createCall(createPropertyAccess(state, "sent"), /*typeArguments*/ undefined, [], location);
return setTextRange(
createCall(
createPropertyAccess(state, "sent"),
/*typeArguments*/ undefined,
[]
),
location
);
}
/**
@@ -2617,7 +2642,6 @@ namespace ts {
/*type*/ undefined,
createBlock(
buildResult,
/*location*/ undefined,
/*multiLine*/ buildResult.length > 0
)
),
@@ -2947,7 +2971,7 @@ namespace ts {
* @param operationLocation The source map location for the operation.
*/
function writeAssign(left: Expression, right: Expression, operationLocation: TextRange): void {
writeStatement(createStatement(createAssignment(left, right), operationLocation));
writeStatement(setTextRange(createStatement(createAssignment(left, right)), operationLocation));
}
/**
@@ -2959,7 +2983,7 @@ namespace ts {
function writeThrow(expression: Expression, operationLocation: TextRange): void {
lastOperationWasAbrupt = true;
lastOperationWasCompletion = true;
writeStatement(createThrow(expression, operationLocation));
writeStatement(setTextRange(createThrow(expression), operationLocation));
}
/**
@@ -2973,10 +2997,12 @@ namespace ts {
lastOperationWasCompletion = true;
writeStatement(
setEmitFlags(
createReturn(
createArrayLiteral(expression
? [createInstruction(Instruction.Return), expression]
: [createInstruction(Instruction.Return)]
setTextRange(
createReturn(
createArrayLiteral(expression
? [createInstruction(Instruction.Return), expression]
: [createInstruction(Instruction.Return)]
)
),
operationLocation
),
@@ -2995,11 +3021,13 @@ namespace ts {
lastOperationWasAbrupt = true;
writeStatement(
setEmitFlags(
createReturn(
createArrayLiteral([
createInstruction(Instruction.Break),
createLabel(label)
]),
setTextRange(
createReturn(
createArrayLiteral([
createInstruction(Instruction.Break),
createLabel(label)
])
),
operationLocation
),
EmitFlags.NoTokenSourceMaps
@@ -3020,11 +3048,13 @@ namespace ts {
createIf(
condition,
setEmitFlags(
createReturn(
createArrayLiteral([
createInstruction(Instruction.Break),
createLabel(label)
]),
setTextRange(
createReturn(
createArrayLiteral([
createInstruction(Instruction.Break),
createLabel(label)
])
),
operationLocation
),
EmitFlags.NoTokenSourceMaps
@@ -3048,11 +3078,13 @@ namespace ts {
createIf(
createLogicalNot(condition),
setEmitFlags(
createReturn(
createArrayLiteral([
createInstruction(Instruction.Break),
createLabel(label)
]),
setTextRange(
createReturn(
createArrayLiteral([
createInstruction(Instruction.Break),
createLabel(label)
])
),
operationLocation
),
EmitFlags.NoTokenSourceMaps
@@ -3073,11 +3105,13 @@ namespace ts {
lastOperationWasAbrupt = true;
writeStatement(
setEmitFlags(
createReturn(
createArrayLiteral(
expression
? [createInstruction(Instruction.Yield), expression]
: [createInstruction(Instruction.Yield)]
setTextRange(
createReturn(
createArrayLiteral(
expression
? [createInstruction(Instruction.Yield), expression]
: [createInstruction(Instruction.Yield)]
)
),
operationLocation
),
@@ -3096,11 +3130,13 @@ namespace ts {
lastOperationWasAbrupt = true;
writeStatement(
setEmitFlags(
createReturn(
createArrayLiteral([
createInstruction(Instruction.YieldStar),
expression
]),
setTextRange(
createReturn(
createArrayLiteral([
createInstruction(Instruction.YieldStar),
expression
])
),
operationLocation
),
EmitFlags.NoTokenSourceMaps
+3 -3
View File
@@ -138,15 +138,15 @@ namespace ts {
function transformJsxAttributeInitializer(node: StringLiteral | JsxExpression) {
if (node === undefined) {
return createLiteral(true);
return createTrue();
}
else if (node.kind === SyntaxKind.StringLiteral) {
const decoded = tryDecodeEntities((<StringLiteral>node).text);
return decoded ? createLiteral(decoded, /*location*/ node) : node;
return decoded ? setTextRange(createLiteral(decoded), node) : node;
}
else if (node.kind === SyntaxKind.JsxExpression) {
if (node.expression === undefined) {
return createLiteral(true);
return createTrue();
}
return visitJsxExpression(<JsxExpression>node);
}
+1 -1
View File
@@ -37,7 +37,7 @@ namespace ts {
addRange(statements, visitNodes(node.statements, visitor, isStatement, statementOffset));
return updateSourceFileNode(
node,
createNodeArray(statements, node.statements));
setTextRange(createNodeArray(statements), node.statements));
}
else {
return visitEachChild(node, visitor, context);
+240 -210
View File
@@ -89,7 +89,7 @@ namespace ts {
addExportEqualsIfNeeded(statements, /*emitAsReturn*/ false);
addRange(statements, endLexicalEnvironment());
const updated = updateSourceFileNode(node, createNodeArray(statements, node.statements));
const updated = updateSourceFileNode(node, setTextRange(createNodeArray(statements), node.statements));
if (currentModuleInfo.hasExportStarsToExportValues) {
// If we have any `export * from ...` declarations
// we need to inform the emitter to add the __export helper.
@@ -134,47 +134,49 @@ namespace ts {
// Create an updated SourceFile:
//
// define(moduleName?, ["module1", "module2"], function ...
return updateSourceFileNode(node, createNodeArray(
[
createStatement(
createCall(
define,
/*typeArguments*/ undefined,
[
// Add the module name (if provided).
...(moduleName ? [moduleName] : []),
return updateSourceFileNode(node,
setTextRange(
createNodeArray([
createStatement(
createCall(
define,
/*typeArguments*/ undefined,
[
// Add the module name (if provided).
...(moduleName ? [moduleName] : []),
// Add the dependency array argument:
//
// ["require", "exports", module1", "module2", ...]
createArrayLiteral([
createLiteral("require"),
createLiteral("exports"),
...aliasedModuleNames,
...unaliasedModuleNames
]),
// Add the dependency array argument:
//
// ["require", "exports", module1", "module2", ...]
createArrayLiteral([
createLiteral("require"),
createLiteral("exports"),
...aliasedModuleNames,
...unaliasedModuleNames
]),
// Add the module body function argument:
//
// function (require, exports, module1, module2) ...
createFunctionExpression(
/*modifiers*/ undefined,
/*asteriskToken*/ undefined,
/*name*/ undefined,
/*typeParameters*/ undefined,
[
createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "require"),
createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "exports"),
...importAliasNames
],
/*type*/ undefined,
transformAsynchronousModuleBody(node)
)
]
// Add the module body function argument:
//
// function (require, exports, module1, module2) ...
createFunctionExpression(
/*modifiers*/ undefined,
/*asteriskToken*/ undefined,
/*name*/ undefined,
/*typeParameters*/ undefined,
[
createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "require"),
createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "exports"),
...importAliasNames
],
/*type*/ undefined,
transformAsynchronousModuleBody(node)
)
]
)
)
)
],
/*location*/ node.statements)
]),
/*location*/ node.statements
)
);
}
@@ -192,74 +194,76 @@ namespace ts {
/*typeParameters*/ undefined,
[createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "factory")],
/*type*/ undefined,
createBlock(
[
createIf(
createLogicalAnd(
createTypeCheck(createIdentifier("module"), "object"),
createTypeCheck(createPropertyAccess(createIdentifier("module"), "exports"), "object")
),
createBlock([
createVariableStatement(
/*modifiers*/ undefined,
[
createVariableDeclaration(
"v",
/*type*/ undefined,
setTextRange(
createBlock(
[
createIf(
createLogicalAnd(
createTypeCheck(createIdentifier("module"), "object"),
createTypeCheck(createPropertyAccess(createIdentifier("module"), "exports"), "object")
),
createBlock([
createVariableStatement(
/*modifiers*/ undefined,
[
createVariableDeclaration(
"v",
/*type*/ undefined,
createCall(
createIdentifier("factory"),
/*typeArguments*/ undefined,
[
createIdentifier("require"),
createIdentifier("exports")
]
)
)
]
),
setEmitFlags(
createIf(
createStrictInequality(
createIdentifier("v"),
createIdentifier("undefined")
),
createStatement(
createAssignment(
createPropertyAccess(createIdentifier("module"), "exports"),
createIdentifier("v")
)
)
),
EmitFlags.SingleLine
)
]),
createIf(
createLogicalAnd(
createTypeCheck(createIdentifier("define"), "function"),
createPropertyAccess(createIdentifier("define"), "amd")
),
createBlock([
createStatement(
createCall(
createIdentifier("factory"),
createIdentifier("define"),
/*typeArguments*/ undefined,
[
createIdentifier("require"),
createIdentifier("exports")
createArrayLiteral([
createLiteral("require"),
createLiteral("exports"),
...aliasedModuleNames,
...unaliasedModuleNames
]),
createIdentifier("factory")
]
)
)
]
),
setEmitFlags(
createIf(
createStrictInequality(
createIdentifier("v"),
createIdentifier("undefined")
),
createStatement(
createAssignment(
createPropertyAccess(createIdentifier("module"), "exports"),
createIdentifier("v")
)
)
),
EmitFlags.SingleLine
])
)
]),
createIf(
createLogicalAnd(
createTypeCheck(createIdentifier("define"), "function"),
createPropertyAccess(createIdentifier("define"), "amd")
),
createBlock([
createStatement(
createCall(
createIdentifier("define"),
/*typeArguments*/ undefined,
[
createArrayLiteral([
createLiteral("require"),
createLiteral("exports"),
...aliasedModuleNames,
...unaliasedModuleNames
]),
createIdentifier("factory")
]
)
)
])
)
)
],
/*location*/ undefined,
/*multiLine*/ true
],
/*multiLine*/ true
),
/*location*/ undefined
)
);
@@ -277,8 +281,8 @@ namespace ts {
return updateSourceFileNode(
node,
createNodeArray(
[
setTextRange(
createNodeArray([
createStatement(
createCall(
umdHeader,
@@ -303,7 +307,7 @@ namespace ts {
]
)
)
],
]),
/*location*/ node.statements
)
);
@@ -381,7 +385,7 @@ namespace ts {
// and merge any new lexical declarations.
addRange(statements, endLexicalEnvironment());
const body = createBlock(statements, /*location*/ undefined, /*multiLine*/ true);
const body = createBlock(statements, /*multiLine*/ true);
if (currentModuleInfo.hasExportStarsToExportValues) {
// If we have any `export * from ...` declarations
// we need to inform the emitter to add the __export helper.
@@ -402,11 +406,8 @@ namespace ts {
function addExportEqualsIfNeeded(statements: Statement[], emitAsReturn: boolean) {
if (currentModuleInfo.exportEquals) {
if (emitAsReturn) {
const statement = createReturn(
currentModuleInfo.exportEquals.expression,
/*location*/ currentModuleInfo.exportEquals
);
const statement = createReturn(currentModuleInfo.exportEquals.expression);
setTextRange(statement, currentModuleInfo.exportEquals);
setEmitFlags(statement, EmitFlags.NoTokenSourceMaps | EmitFlags.NoComments);
statements.push(statement);
}
@@ -418,10 +419,10 @@ namespace ts {
"exports"
),
currentModuleInfo.exportEquals.expression
),
/*location*/ currentModuleInfo.exportEquals
)
);
setTextRange(statement, currentModuleInfo.exportEquals);
setEmitFlags(statement, EmitFlags.NoComments);
statements.push(statement);
}
@@ -484,7 +485,7 @@ namespace ts {
if (moduleKind !== ModuleKind.AMD) {
if (!node.importClause) {
// import "mod";
return createStatement(createRequireCall(node), /*location*/ node);
return setTextRange(createStatement(createRequireCall(node)), node);
}
else {
const variables: VariableDeclaration[] = [];
@@ -523,12 +524,13 @@ namespace ts {
}
statements = append(statements,
createVariableStatement(
/*modifiers*/ undefined,
createVariableDeclarationList(
variables,
/*location*/ undefined,
languageVersion >= ScriptTarget.ES2015 ? NodeFlags.Const : NodeFlags.None
setTextRange(
createVariableStatement(
/*modifiers*/ undefined,
createVariableDeclarationList(
variables,
languageVersion >= ScriptTarget.ES2015 ? NodeFlags.Const : NodeFlags.None
)
),
/*location*/ node
)
@@ -542,14 +544,15 @@ namespace ts {
/*modifiers*/ undefined,
createVariableDeclarationList(
[
createVariableDeclaration(
getSynthesizedClone(namespaceDeclaration.name),
/*type*/ undefined,
getGeneratedNameForNode(node),
setTextRange(
createVariableDeclaration(
getSynthesizedClone(namespaceDeclaration.name),
/*type*/ undefined,
getGeneratedNameForNode(node)
),
/*location*/ node
)
],
/*location*/ undefined,
languageVersion >= ScriptTarget.ES2015 ? NodeFlags.Const : NodeFlags.None
)
)
@@ -595,31 +598,34 @@ namespace ts {
if (moduleKind !== ModuleKind.AMD) {
if (hasModifier(node, ModifierFlags.Export)) {
statements = append(statements,
createStatement(
createExportExpression(
node.name,
createRequireCall(node)
setTextRange(
createStatement(
createExportExpression(
node.name,
createRequireCall(node)
)
),
/*location*/ node
node
)
);
}
else {
statements = append(statements,
createVariableStatement(
/*modifiers*/ undefined,
createVariableDeclarationList(
[
createVariableDeclaration(
getSynthesizedClone(node.name),
/*type*/ undefined,
createRequireCall(node)
)
],
/*location*/ undefined,
/*flags*/ languageVersion >= ScriptTarget.ES2015 ? NodeFlags.Const : NodeFlags.None
setTextRange(
createVariableStatement(
/*modifiers*/ undefined,
createVariableDeclarationList(
[
createVariableDeclaration(
getSynthesizedClone(node.name),
/*type*/ undefined,
createRequireCall(node)
)
],
/*flags*/ languageVersion >= ScriptTarget.ES2015 ? NodeFlags.Const : NodeFlags.None
)
),
/*location*/ node
node
)
);
}
@@ -627,9 +633,11 @@ namespace ts {
else {
if (hasModifier(node, ModifierFlags.Export)) {
statements = append(statements,
createStatement(
createExportExpression(getExportName(node), getLocalName(node)),
/*location*/ node
setTextRange(
createStatement(
createExportExpression(getExportName(node), getLocalName(node))
),
node
)
);
}
@@ -665,15 +673,17 @@ namespace ts {
// export { x, y } from "mod";
if (moduleKind !== ModuleKind.AMD) {
statements.push(
createVariableStatement(
/*modifiers*/ undefined,
createVariableDeclarationList([
createVariableDeclaration(
generatedName,
/*type*/ undefined,
createRequireCall(node)
)
]),
setTextRange(
createVariableStatement(
/*modifiers*/ undefined,
createVariableDeclarationList([
createVariableDeclaration(
generatedName,
/*type*/ undefined,
createRequireCall(node)
)
])
),
/*location*/ node
)
);
@@ -684,9 +694,11 @@ namespace ts {
specifier.propertyName || specifier.name
);
statements.push(
createStatement(
createExportExpression(getExportName(specifier), exportedValue),
/*location*/ specifier
setTextRange(
createStatement(
createExportExpression(getExportName(specifier), exportedValue)
),
specifier
)
);
}
@@ -695,17 +707,19 @@ namespace ts {
}
else {
// export * from "mod";
return createStatement(
createCall(
createIdentifier("__export"),
/*typeArguments*/ undefined,
[
moduleKind !== ModuleKind.AMD
? createRequireCall(node)
: generatedName
]
return setTextRange(
createStatement(
createCall(
createIdentifier("__export"),
/*typeArguments*/ undefined,
[
moduleKind !== ModuleKind.AMD
? createRequireCall(node)
: generatedName
]
)
),
/*location*/ node
node
);
}
}
@@ -744,15 +758,17 @@ namespace ts {
if (hasModifier(node, ModifierFlags.Export)) {
statements = append(statements,
setOriginalNode(
createFunctionDeclaration(
/*decorators*/ undefined,
visitNodes(node.modifiers, modifierVisitor, isModifier),
node.asteriskToken,
getDeclarationName(node, /*allowComments*/ true, /*allowSourceMaps*/ true),
/*typeParameters*/ undefined,
node.parameters,
/*type*/ undefined,
node.body,
setTextRange(
createFunctionDeclaration(
/*decorators*/ undefined,
visitNodes(node.modifiers, modifierVisitor, isModifier),
node.asteriskToken,
getDeclarationName(node, /*allowComments*/ true, /*allowSourceMaps*/ true),
/*typeParameters*/ undefined,
node.parameters,
/*type*/ undefined,
node.body
),
/*location*/ node
),
/*original*/ node
@@ -785,16 +801,18 @@ namespace ts {
if (hasModifier(node, ModifierFlags.Export)) {
statements = append(statements,
setOriginalNode(
createClassDeclaration(
/*decorators*/ undefined,
visitNodes(node.modifiers, modifierVisitor, isModifier),
getDeclarationName(node, /*allowComments*/ true, /*allowSourceMaps*/ true),
/*typeParameters*/ undefined,
node.heritageClauses,
node.members,
/*location*/ node
setTextRange(
createClassDeclaration(
/*decorators*/ undefined,
visitNodes(node.modifiers, modifierVisitor, isModifier),
getDeclarationName(node, /*allowComments*/ true, /*allowSourceMaps*/ true),
/*typeParameters*/ undefined,
node.heritageClauses,
node.members
),
node
),
/*original*/ node
node
)
);
}
@@ -846,7 +864,7 @@ namespace ts {
}
if (expressions) {
statements = append(statements, createStatement(inlineExpressions(expressions), /*location*/ node));
statements = append(statements, setTextRange(createStatement(inlineExpressions(expressions)), node));
}
}
else {
@@ -883,9 +901,11 @@ namespace ts {
}
else {
return createAssignment(
createPropertyAccess(
createIdentifier("exports"),
node.name,
setTextRange(
createPropertyAccess(
createIdentifier("exports"),
node.name
),
/*location*/ node.name
),
node.initializer
@@ -1118,7 +1138,7 @@ namespace ts {
createStatement(
createExportExpression(
createIdentifier("__esModule"),
createLiteral(true)
createTrue()
)
)
);
@@ -1133,7 +1153,7 @@ namespace ts {
createIdentifier("exports"),
createLiteral("__esModule"),
createObjectLiteral([
createPropertyAssignment("value", createLiteral(true))
createPropertyAssignment("value", createTrue())
])
]
)
@@ -1156,7 +1176,7 @@ namespace ts {
* @param allowComments An optional value indicating whether to emit comments for the statement.
*/
function createExportStatement(name: Identifier, value: Expression, location?: TextRange, allowComments?: boolean) {
const statement = createStatement(createExportExpression(name, value), location);
const statement = setTextRange(createStatement(createExportExpression(name, value)), location);
startOnNewLine(statement);
if (!allowComments) {
setEmitFlags(statement, EmitFlags.NoComments);
@@ -1173,12 +1193,14 @@ namespace ts {
* @param location The location to use for source maps and comments for the export.
*/
function createExportExpression(name: Identifier, value: Expression, location?: TextRange) {
return createAssignment(
createPropertyAccess(
createIdentifier("exports"),
getSynthesizedClone(name)
return setTextRange(
createAssignment(
createPropertyAccess(
createIdentifier("exports"),
getSynthesizedClone(name)
),
value
),
value,
location
);
}
@@ -1271,9 +1293,9 @@ namespace ts {
// destructuring assignment
if (node.objectAssignmentInitializer) {
const initializer = createAssignment(exportedOrImportedName, node.objectAssignmentInitializer);
return createPropertyAssignment(name, initializer, /*location*/ node);
return setTextRange(createPropertyAssignment(name, initializer), node);
}
return createPropertyAssignment(name, exportedOrImportedName, /*location*/ node);
return setTextRange(createPropertyAssignment(name, exportedOrImportedName), node);
}
return node;
}
@@ -1316,9 +1338,11 @@ namespace ts {
if (!isGeneratedIdentifier(node) && !isLocalName(node)) {
const exportContainer = resolver.getReferencedExportContainer(node, isExportName(node));
if (exportContainer && exportContainer.kind === SyntaxKind.SourceFile) {
return createPropertyAccess(
createIdentifier("exports"),
getSynthesizedClone(node),
return setTextRange(
createPropertyAccess(
createIdentifier("exports"),
getSynthesizedClone(node)
),
/*location*/ node
);
}
@@ -1326,17 +1350,21 @@ namespace ts {
const importDeclaration = resolver.getReferencedImportDeclaration(node);
if (importDeclaration) {
if (isImportClause(importDeclaration)) {
return createPropertyAccess(
getGeneratedNameForNode(importDeclaration.parent),
createIdentifier("default"),
return setTextRange(
createPropertyAccess(
getGeneratedNameForNode(importDeclaration.parent),
createIdentifier("default")
),
/*location*/ node
);
}
else if (isImportSpecifier(importDeclaration)) {
const name = importDeclaration.propertyName || importDeclaration.name;
return createPropertyAccess(
getGeneratedNameForNode(importDeclaration.parent.parent.parent),
getSynthesizedClone(name),
return setTextRange(
createPropertyAccess(
getGeneratedNameForNode(importDeclaration.parent.parent.parent),
getSynthesizedClone(name)
),
/*location*/ node
);
}
@@ -1404,10 +1432,12 @@ namespace ts {
const exportedNames = getExports(node.operand);
if (exportedNames) {
let expression: Expression = node.kind === SyntaxKind.PostfixUnaryExpression
? createBinary(
node.operand,
createToken(node.operator === SyntaxKind.PlusPlusToken ? SyntaxKind.PlusEqualsToken : SyntaxKind.MinusEqualsToken),
createLiteral(1),
? setTextRange(
createBinary(
node.operand,
createToken(node.operator === SyntaxKind.PlusPlusToken ? SyntaxKind.PlusEqualsToken : SyntaxKind.MinusEqualsToken),
createLiteral(1)
),
/*location*/ node)
: node;
for (const exportName of exportedNames) {
+72 -69
View File
@@ -106,17 +106,20 @@ namespace ts {
const updated = setEmitFlags(
updateSourceFileNode(
node,
createNodeArray([
createStatement(
createCall(
createPropertyAccess(createIdentifier("System"), "register"),
/*typeArguments*/ undefined,
moduleName
? [moduleName, dependencies, moduleBodyFunction]
: [dependencies, moduleBodyFunction]
setTextRange(
createNodeArray([
createStatement(
createCall(
createPropertyAccess(createIdentifier("System"), "register"),
/*typeArguments*/ undefined,
moduleName
? [moduleName, dependencies, moduleBodyFunction]
: [dependencies, moduleBodyFunction]
)
)
)
], node.statements)
]),
node.statements
)
), EmitFlags.NoTrailingComments);
if (!(compilerOptions.outFile || compilerOptions.out)) {
@@ -260,35 +263,26 @@ namespace ts {
addRange(statements, endLexicalEnvironment());
const exportStarFunction = addExportStarIfNeeded(statements);
statements.push(
createReturn(
setMultiLine(
createObjectLiteral([
createPropertyAssignment("setters",
createSettersArray(exportStarFunction, dependencyGroups)
),
createPropertyAssignment("execute",
createFunctionExpression(
/*modifiers*/ undefined,
/*asteriskToken*/ undefined,
/*name*/ undefined,
/*typeParameters*/ undefined,
/*parameters*/ [],
/*type*/ undefined,
createBlock(
executeStatements,
/*location*/ undefined,
/*multiLine*/ true
)
)
)
]),
/*multiLine*/ true
const moduleObject = createObjectLiteral([
createPropertyAssignment("setters",
createSettersArray(exportStarFunction, dependencyGroups)
),
createPropertyAssignment("execute",
createFunctionExpression(
/*modifiers*/ undefined,
/*asteriskToken*/ undefined,
/*name*/ undefined,
/*typeParameters*/ undefined,
/*parameters*/ [],
/*type*/ undefined,
createBlock(executeStatements, /*multiLine*/ true)
)
)
);
]);
return createBlock(statements, /*location*/ undefined, /*multiLine*/ true);
moduleObject.multiLine = true;
statements.push(createReturn(moduleObject));
return createBlock(statements, /*multiLine*/ true);
}
/**
@@ -337,7 +331,7 @@ namespace ts {
exportedNames.push(
createPropertyAssignment(
createLiteral(exportedLocalName),
createLiteral(true)
createTrue()
)
);
}
@@ -359,7 +353,7 @@ namespace ts {
exportedNames.push(
createPropertyAssignment(
createLiteral((element.name || element.propertyName).text),
createLiteral(true)
createTrue()
)
);
}
@@ -373,7 +367,7 @@ namespace ts {
createVariableDeclaration(
exportedNamesStorageRef,
/*type*/ undefined,
createObjectLiteral(exportedNames, /*location*/ undefined, /*multiline*/ true)
createObjectLiteral(exportedNames, /*multiline*/ true)
)
])
)
@@ -456,9 +450,7 @@ namespace ts {
[exports]
)
)
],
/*location*/ undefined,
/*multiline*/ true)
], /*multiline*/ true)
);
}
@@ -525,7 +517,7 @@ namespace ts {
createCall(
exportFunction,
/*typeArguments*/ undefined,
[createObjectLiteral(properties, /*location*/ undefined, /*multiline*/ true)]
[createObjectLiteral(properties, /*multiline*/ true)]
)
)
);
@@ -558,12 +550,12 @@ namespace ts {
/*typeParameters*/ undefined,
[createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, parameterName)],
/*type*/ undefined,
createBlock(statements, /*location*/ undefined, /*multiLine*/ true)
createBlock(statements, /*multiLine*/ true)
)
);
}
return createArrayLiteral(setters, /*location*/ undefined, /*multiLine*/ true);
return createArrayLiteral(setters, /*multiLine*/ true);
}
//
@@ -714,19 +706,23 @@ namespace ts {
// Rewrite the class declaration into an assignment of a class expression.
statements = append(statements,
createStatement(
createAssignment(
name,
createClassExpression(
/*modifiers*/ undefined,
node.name,
/*typeParameters*/ undefined,
visitNodes(node.heritageClauses, destructuringVisitor, isHeritageClause),
visitNodes(node.members, destructuringVisitor, isClassElement),
/*location*/ node
setTextRange(
createStatement(
createAssignment(
name,
setTextRange(
createClassExpression(
/*modifiers*/ undefined,
node.name,
/*typeParameters*/ undefined,
visitNodes(node.heritageClauses, destructuringVisitor, isHeritageClause),
visitNodes(node.members, destructuringVisitor, isClassElement)
),
node
)
)
),
/*location*/ node
node
)
);
@@ -767,7 +763,7 @@ namespace ts {
let statements: Statement[];
if (expressions) {
statements = append(statements, createStatement(inlineExpressions(expressions), /*location*/ node));
statements = append(statements, setTextRange(createStatement(inlineExpressions(expressions)), node));
}
if (isMarkedDeclaration) {
@@ -865,8 +861,8 @@ namespace ts {
function createVariableAssignment(name: Identifier, value: Expression, location: TextRange, isExportedDeclaration: boolean) {
hoistVariableDeclaration(getSynthesizedClone(name));
return isExportedDeclaration
? createExportExpression(name, preventSubstitution(createAssignment(name, value, location)))
: preventSubstitution(createAssignment(name, value, location));
? createExportExpression(name, preventSubstitution(setTextRange(createAssignment(name, value), location)))
: preventSubstitution(setTextRange(createAssignment(name, value), location));
}
/**
@@ -1645,16 +1641,20 @@ namespace ts {
const importDeclaration = resolver.getReferencedImportDeclaration(node);
if (importDeclaration) {
if (isImportClause(importDeclaration)) {
return createPropertyAccess(
getGeneratedNameForNode(importDeclaration.parent),
createIdentifier("default"),
return setTextRange(
createPropertyAccess(
getGeneratedNameForNode(importDeclaration.parent),
createIdentifier("default")
),
/*location*/ node
);
}
else if (isImportSpecifier(importDeclaration)) {
return createPropertyAccess(
getGeneratedNameForNode(importDeclaration.parent.parent.parent),
getSynthesizedClone(importDeclaration.propertyName || importDeclaration.name),
return setTextRange(
createPropertyAccess(
getGeneratedNameForNode(importDeclaration.parent.parent.parent),
getSynthesizedClone(importDeclaration.propertyName || importDeclaration.name)
),
/*location*/ node
);
}
@@ -1721,10 +1721,13 @@ namespace ts {
const exportedNames = getExports(node.operand);
if (exportedNames) {
let expression: Expression = node.kind === SyntaxKind.PostfixUnaryExpression
? createPrefix(
node.operator,
node.operand,
/*location*/ node)
? setTextRange(
createPrefix(
node.operator,
node.operand
),
node
)
: node;
for (const exportName of exportedNames) {
+149 -114
View File
@@ -588,17 +588,17 @@ namespace ts {
name,
/*typeParameters*/ undefined,
visitNodes(node.heritageClauses, visitor, isHeritageClause),
transformClassMembers(node, hasExtendsClause),
node);
let emitFlags = getEmitFlags(node);
transformClassMembers(node, hasExtendsClause)
);
// To better align with the old emitter, we should not emit a trailing source map
// entry if the class has static properties.
let emitFlags = getEmitFlags(node);
if (hasStaticProperties) {
emitFlags |= EmitFlags.NoTrailingSourceMap;
}
setTextRange(classDeclaration, node);
setOriginalNode(classDeclaration, node);
setEmitFlags(classDeclaration, emitFlags);
return classDeclaration;
@@ -709,13 +709,24 @@ namespace ts {
// }
const heritageClauses = visitNodes(node.heritageClauses, visitor, isHeritageClause);
const members = transformClassMembers(node, hasExtendsClause);
const classExpression = createClassExpression(/*modifiers*/ undefined, name, /*typeParameters*/ undefined, heritageClauses, members, location);
const classExpression = createClassExpression(/*modifiers*/ undefined, name, /*typeParameters*/ undefined, heritageClauses, members);
setOriginalNode(classExpression, node);
setTextRange(classExpression, location);
// let ${name} = ${classExpression} where name is either declaredName if the class doesn't contain self-reference
// or decoratedClassAlias if the class contain self-reference.
const statement = createLetStatement(declName, classAlias ? createAssignment(classAlias, classExpression) : classExpression, location);
const statement = createVariableStatement(
/*modifiers*/ undefined,
createVariableDeclarationList([
createVariableDeclaration(
declName,
/*type*/ undefined,
classAlias ? createAssignment(classAlias, classExpression) : classExpression
)
], NodeFlags.Let)
);
setOriginalNode(statement, node);
setTextRange(statement, location);
setCommentRange(statement, node);
return statement;
}
@@ -734,18 +745,17 @@ namespace ts {
const heritageClauses = visitNodes(node.heritageClauses, visitor, isHeritageClause);
const members = transformClassMembers(node, some(heritageClauses, c => c.token === SyntaxKind.ExtendsKeyword));
const classExpression = setOriginalNode(
createClassExpression(
/*modifiers*/ undefined,
node.name,
/*typeParameters*/ undefined,
heritageClauses,
members,
/*location*/ node
),
node
const classExpression = createClassExpression(
/*modifiers*/ undefined,
node.name,
/*typeParameters*/ undefined,
heritageClauses,
members
);
setOriginalNode(classExpression, node);
setTextRange(classExpression, node);
if (staticProperties.length > 0) {
const expressions: Expression[] = [];
const temp = createTempVariable(hoistVariableDeclaration);
@@ -781,7 +791,7 @@ namespace ts {
}
addRange(members, visitNodes(node.members, classElementVisitor, isClassElement));
return createNodeArray(members, /*location*/ node.members);
return setTextRange(createNodeArray(members), /*location*/ node.members);
}
/**
@@ -812,12 +822,14 @@ namespace ts {
// }
return startOnNewLine(
setOriginalNode(
createConstructor(
/*decorators*/ undefined,
/*modifiers*/ undefined,
parameters,
body,
/*location*/ constructor || node
setTextRange(
createConstructor(
/*decorators*/ undefined,
/*modifiers*/ undefined,
parameters,
body
),
constructor || node
),
constructor
)
@@ -919,13 +931,15 @@ namespace ts {
// End the lexical environment.
statements = mergeLexicalEnvironment(statements, endLexicalEnvironment());
return createBlock(
createNodeArray(
statements,
/*location*/ constructor ? constructor.body.statements : node.members
return setTextRange(
createBlock(
setTextRange(
createNodeArray(statements),
/*location*/ constructor ? constructor.body.statements : node.members
),
/*multiLine*/ true
),
/*location*/ constructor ? constructor.body : /*location*/ undefined,
/*multiLine*/ true
/*location*/ constructor ? constructor.body : undefined
);
}
@@ -991,16 +1005,20 @@ namespace ts {
setEmitFlags(localName, EmitFlags.NoComments);
return startOnNewLine(
createStatement(
createAssignment(
createPropertyAccess(
createThis(),
propertyName,
/*location*/ node.name
),
localName
setTextRange(
createStatement(
createAssignment(
setTextRange(
createPropertyAccess(
createThis(),
propertyName
),
node.name
),
localName
)
),
/*location*/ moveRangePos(node, -1)
moveRangePos(node, -1)
)
);
}
@@ -1504,7 +1522,7 @@ namespace ts {
(properties || (properties = [])).push(createPropertyAssignment("returnType", createArrowFunction(/*modifiers*/ undefined, /*typeParameters*/ undefined, [], /*type*/ undefined, createToken(SyntaxKind.EqualsGreaterThanToken), serializeReturnTypeOfNode(node))));
}
if (properties) {
decoratorExpressions.push(createMetadataHelper(context, "design:typeinfo", createObjectLiteral(properties, /*location*/ undefined, /*multiLine*/ true)));
decoratorExpressions.push(createMetadataHelper(context, "design:typeinfo", createObjectLiteral(properties, /*multiLine*/ true)));
}
}
}
@@ -1939,10 +1957,7 @@ namespace ts {
expression = createAssignment(generatedName, expression);
}
return setOriginalNode(
createComputedPropertyName(expression, /*location*/ name),
name
);
return updateComputedPropertyName(name, expression);
}
else {
return name;
@@ -1961,9 +1976,11 @@ namespace ts {
function visitHeritageClause(node: HeritageClause): HeritageClause {
if (node.token === SyntaxKind.ExtendsKeyword) {
const types = visitNodes(node.types, visitor, isExpressionWithTypeArguments, 0, 1);
return createHeritageClause(
SyntaxKind.ExtendsKeyword,
types,
return setTextRange(
createHeritageClause(
SyntaxKind.ExtendsKeyword,
types
),
node
);
}
@@ -1980,11 +1997,10 @@ namespace ts {
* @param node The ExpressionWithTypeArguments to transform.
*/
function visitExpressionWithTypeArguments(node: ExpressionWithTypeArguments): ExpressionWithTypeArguments {
const expression = visitNode(node.expression, visitor, isLeftHandSideExpression);
return createExpressionWithTypeArguments(
return updateExpressionWithTypeArguments(
node,
/*typeArguments*/ undefined,
expression,
node
visitNode(node.expression, visitor, isLeftHandSideExpression)
);
}
@@ -2214,13 +2230,13 @@ namespace ts {
visitNode(node.name, visitor, isBindingName),
/*questionToken*/ undefined,
/*type*/ undefined,
visitNode(node.initializer, visitor, isExpression),
/*location*/ moveRangePastModifiers(node)
visitNode(node.initializer, visitor, isExpression)
);
// While we emit the source map for the node after skipping decorators and modifiers,
// we need to emit the comments for the original range.
setOriginalNode(parameter, node);
setTextRange(parameter, moveRangePastModifiers(node));
setCommentRange(parameter, node);
setSourceMapRange(parameter, moveRangePastModifiers(node));
setEmitFlags(parameter.name, EmitFlags.NoTrailingSourceMap);
@@ -2242,11 +2258,13 @@ namespace ts {
return undefined;
}
return createStatement(
inlineExpressions(
map(variables, transformInitializedVariable)
return setTextRange(
createStatement(
inlineExpressions(
map(variables, transformInitializedVariable)
)
),
/*location*/ node
node
);
}
else {
@@ -2267,9 +2285,11 @@ namespace ts {
);
}
else {
return createAssignment(
getNamespaceMemberNameWithSourceMapsAndWithoutComments(name),
visitNode(node.initializer, visitor, isExpression),
return setTextRange(
createAssignment(
getNamespaceMemberNameWithSourceMapsAndWithoutComments(name),
visitNode(node.initializer, visitor, isExpression)
),
/*location*/ node
);
}
@@ -2427,11 +2447,11 @@ namespace ts {
),
/*typeArguments*/ undefined,
[moduleArg]
),
/*location*/ node
)
);
setOriginalNode(enumStatement, node);
setTextRange(enumStatement, node);
setEmitFlags(enumStatement, emitFlags);
statements.push(enumStatement);
@@ -2457,8 +2477,7 @@ namespace ts {
currentNamespaceContainerName = savedCurrentNamespaceLocalName;
return createBlock(
createNodeArray(statements, /*location*/ node.members),
/*location*/ undefined,
setTextRange(createNodeArray(statements), /*location*/ node.members),
/*multiLine*/ true
);
}
@@ -2473,22 +2492,26 @@ namespace ts {
// we pass false as 'generateNameForComputedPropertyName' for a backward compatibility purposes
// old emitter always generate 'expression' part of the name as-is.
const name = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ false);
return createStatement(
createAssignment(
createElementAccess(
currentNamespaceContainerName,
return setTextRange(
createStatement(
setTextRange(
createAssignment(
createElementAccess(
currentNamespaceContainerName,
name
createAssignment(
createElementAccess(
currentNamespaceContainerName,
name
),
transformEnumMemberDeclarationValue(member)
)
),
transformEnumMemberDeclarationValue(member)
)
),
name,
/*location*/ member
name
),
member
)
),
/*location*/ member
member
);
}
@@ -2706,11 +2729,11 @@ namespace ts {
),
/*typeArguments*/ undefined,
[moduleArg]
),
/*location*/ node
)
);
setOriginalNode(moduleStatement, node);
setTextRange(moduleStatement, node);
setEmitFlags(moduleStatement, emitFlags);
statements.push(moduleStatement);
@@ -2765,13 +2788,13 @@ namespace ts {
currentScopeFirstDeclarationsOfName = savedCurrentScopeFirstDeclarationsOfName;
const block = createBlock(
createNodeArray(
statements,
setTextRange(
createNodeArray(statements),
/*location*/ statementsLocation
),
/*location*/ blockLocation,
/*multiLine*/ true
);
setTextRange(block, blockLocation);
// namespace hello.hi.world {
// function foo() {}
@@ -2971,18 +2994,20 @@ namespace ts {
// export var ${name} = ${moduleReference};
// var ${name} = ${moduleReference};
return setOriginalNode(
createVariableStatement(
visitNodes(node.modifiers, modifierVisitor, isModifier),
createVariableDeclarationList([
setOriginalNode(
createVariableDeclaration(
node.name,
/*type*/ undefined,
moduleReference
),
node
)
]),
setTextRange(
createVariableStatement(
visitNodes(node.modifiers, modifierVisitor, isModifier),
createVariableDeclarationList([
setOriginalNode(
createVariableDeclaration(
node.name,
/*type*/ undefined,
moduleReference
),
node
)
])
),
node
),
node
@@ -3043,7 +3068,7 @@ namespace ts {
* Creates a statement for the provided expression. This is used in calls to `map`.
*/
function expressionToStatement(expression: Expression) {
return createStatement(expression, /*location*/ undefined);
return createStatement(expression);
}
function addExportMemberAssignment(statements: Statement[], node: ClassDeclaration | FunctionDeclaration) {
@@ -3059,17 +3084,19 @@ namespace ts {
}
function createNamespaceExport(exportName: Identifier, exportValue: Expression, location?: TextRange) {
return createStatement(
createAssignment(
getNamespaceMemberName(currentNamespaceContainerName, exportName, /*allowComments*/ false, /*allowSourceMaps*/ true),
exportValue
return setTextRange(
createStatement(
createAssignment(
getNamespaceMemberName(currentNamespaceContainerName, exportName, /*allowComments*/ false, /*allowSourceMaps*/ true),
exportValue
)
),
location
);
}
function createNamespaceExportExpression(exportName: Identifier, exportValue: Expression, location?: TextRange) {
return createAssignment(getNamespaceMemberNameWithSourceMapsAndWithoutComments(exportName), exportValue, location);
return setTextRange(createAssignment(getNamespaceMemberNameWithSourceMapsAndWithoutComments(exportName), exportValue), location);
}
function getNamespaceMemberNameWithSourceMapsAndWithoutComments(name: Identifier) {
@@ -3101,7 +3128,7 @@ namespace ts {
function getClassAliasIfNeeded(node: ClassDeclaration) {
if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.ClassWithConstructorReference) {
enableSubstitutionForClassAliases();
const classAlias = createUniqueName(node.name && !isGeneratedIdentifier(node.name) ? node.name.text : "default");
const classAlias = createUniqueName(node.name && !isGeneratedIdentifier(node.name) ? unescapeIdentifier(node.name.text) : "default");
classAliases[getOriginalNodeId(node)] = classAlias;
hoistVariableDeclaration(classAlias);
return classAlias;
@@ -3216,9 +3243,9 @@ namespace ts {
// destructuring assignment
if (node.objectAssignmentInitializer) {
const initializer = createAssignment(exportedName, node.objectAssignmentInitializer);
return createPropertyAssignment(name, initializer, /*location*/ node);
return setTextRange(createPropertyAssignment(name, initializer), node);
}
return createPropertyAssignment(name, exportedName, /*location*/ node);
return setTextRange(createPropertyAssignment(name, exportedName), node);
}
}
return node;
@@ -3278,7 +3305,10 @@ namespace ts {
(applicableSubstitutions & TypeScriptSubstitutionFlags.NamespaceExports && container.kind === SyntaxKind.ModuleDeclaration) ||
(applicableSubstitutions & TypeScriptSubstitutionFlags.NonQualifiedEnumMembers && container.kind === SyntaxKind.EnumDeclaration);
if (substitute) {
return createPropertyAccess(getGeneratedNameForNode(container), node, /*location*/ node);
return setTextRange(
createPropertyAccess(getGeneratedNameForNode(container), node),
/*location*/ node
);
}
}
}
@@ -3327,7 +3357,7 @@ namespace ts {
function createDecorateHelper(context: TransformationContext, decoratorExpressions: Expression[], target: Expression, memberName?: Expression, descriptor?: Expression, location?: TextRange) {
const argumentsArray: Expression[] = [];
argumentsArray.push(createArrayLiteral(decoratorExpressions, /*location*/ undefined, /*multiLine*/ true));
argumentsArray.push(createArrayLiteral(decoratorExpressions, /*multiLine*/ true));
argumentsArray.push(target);
if (memberName) {
argumentsArray.push(memberName);
@@ -3337,11 +3367,14 @@ namespace ts {
}
context.requestEmitHelper(decorateHelper);
return createCall(
getHelperName("__decorate"),
/*typeArguments*/ undefined,
argumentsArray,
location);
return setTextRange(
createCall(
getHelperName("__decorate"),
/*typeArguments*/ undefined,
argumentsArray
),
location
);
}
const decorateHelper: EmitHelper = {
@@ -3381,13 +3414,15 @@ namespace ts {
function createParamHelper(context: TransformationContext, expression: Expression, parameterOffset: number, location?: TextRange) {
context.requestEmitHelper(paramHelper);
return createCall(
getHelperName("__param"),
/*typeArguments*/ undefined,
[
createLiteral(parameterOffset),
expression
],
return setTextRange(
createCall(
getHelperName("__param"),
/*typeArguments*/ undefined,
[
createLiteral(parameterOffset),
expression
]
),
location
);
}
+10 -10
View File
@@ -965,8 +965,7 @@
}
// Represents an expression that is elided as part of a transformation to emit comments on a
// not-emitted node. The 'expression' property of a NotEmittedExpression should be emitted.
// @internal
// not-emitted node. The 'expression' property of a PartiallyEmittedExpression should be emitted.
export interface PartiallyEmittedExpression extends LeftHandSideExpression {
kind: SyntaxKind.PartiallyEmittedExpression;
expression: Expression;
@@ -1545,7 +1544,6 @@
// Represents a statement that is elided as part of a transformation to emit comments on a
// not-emitted node.
// @internal
export interface NotEmittedStatement extends Statement {
kind: SyntaxKind.NotEmittedStatement;
}
@@ -1781,24 +1779,28 @@
members: NodeArray<EnumMember>;
}
export type ModuleBody = ModuleBlock | ModuleDeclaration;
export type ModuleName = Identifier | StringLiteral;
export type ModuleBody = NamespaceBody | JSDocNamespaceBody;
export interface ModuleDeclaration extends DeclarationStatement {
kind: SyntaxKind.ModuleDeclaration;
name: Identifier | StringLiteral;
body?: ModuleBlock | NamespaceDeclaration | JSDocNamespaceDeclaration | Identifier;
body?: ModuleBody | JSDocNamespaceDeclaration | Identifier;
}
export type NamespaceBody = ModuleBlock | NamespaceDeclaration;
export interface NamespaceDeclaration extends ModuleDeclaration {
name: Identifier;
body: ModuleBlock | NamespaceDeclaration;
body: NamespaceBody;
}
export type JSDocNamespaceBody = Identifier | JSDocNamespaceDeclaration;
export interface JSDocNamespaceDeclaration extends ModuleDeclaration {
name: Identifier;
body: JSDocNamespaceDeclaration | Identifier;
body: JSDocNamespaceBody;
}
export interface ModuleBlock extends Node, Statement {
@@ -3748,7 +3750,6 @@
helpers?: EmitHelper[]; // Emit helpers for the node
}
/* @internal */
export const enum EmitFlags {
SingleLine = 1 << 0, // The contents of this node should be emitted on a single line.
AdviseOnEmitNode = 1 << 1, // The printer should invoke the onEmitNode callback when printing this node.
@@ -3777,7 +3778,6 @@
HasEndOfDeclarationMarker = 1 << 21, // Declaration has an associated NotEmittedStatement to mark the end of the declaration
}
/* @internal */
export interface EmitHelper {
readonly name: string; // A unique name for this helper.
readonly scoped: boolean; // Indicates whether ther helper MUST be emitted in the current scope.
+77 -51
View File
@@ -1518,6 +1518,11 @@ namespace ts {
return map(getJSDocs(node), doc => doc.comment);
}
export function hasJSDocParameterTags(node: FunctionLikeDeclaration | SignatureDeclaration) {
const parameterTags = getJSDocTags(node, SyntaxKind.JSDocParameterTag);
return parameterTags && parameterTags.length > 0;
}
function getJSDocTags(node: Node, kind: SyntaxKind): JSDocTag[] {
const docs = getJSDocs(node);
if (docs) {
@@ -2085,57 +2090,6 @@ namespace ts {
|| positionIsSynthesized(node.end);
}
export function getOriginalNode(node: Node): Node;
export function getOriginalNode<T extends Node>(node: Node, nodeTest: (node: Node) => node is T): T;
export function getOriginalNode(node: Node, nodeTest?: (node: Node) => boolean): Node {
if (node) {
while (node.original !== undefined) {
node = node.original;
}
}
return !nodeTest || nodeTest(node) ? node : undefined;
}
/**
* Gets a value indicating whether a node originated in the parse tree.
*
* @param node The node to test.
*/
export function isParseTreeNode(node: Node): boolean {
return (node.flags & NodeFlags.Synthesized) === 0;
}
/**
* Gets the original parse tree node for a node.
*
* @param node The original node.
* @returns The original parse tree node if found; otherwise, undefined.
*/
export function getParseTreeNode(node: Node): Node;
/**
* Gets the original parse tree node for a node.
*
* @param node The original node.
* @param nodeTest A callback used to ensure the correct type of parse tree node is returned.
* @returns The original parse tree node if found; otherwise, undefined.
*/
export function getParseTreeNode<T extends Node>(node: Node, nodeTest?: (node: Node) => node is T): T;
export function getParseTreeNode(node: Node, nodeTest?: (node: Node) => boolean): Node {
if (isParseTreeNode(node)) {
return node;
}
node = getOriginalNode(node);
if (isParseTreeNode(node) && (!nodeTest || nodeTest(node))) {
return node;
}
return undefined;
}
export function getOriginalSourceFileOrBundle(sourceFileOrBundle: SourceFile | Bundle) {
if (sourceFileOrBundle.kind === SyntaxKind.Bundle) {
return updateBundle(sourceFileOrBundle, sameMap(sourceFileOrBundle.sourceFiles, getOriginalSourceFile));
@@ -3374,6 +3328,14 @@ namespace ts {
}
}
export function getRangePos(range: TextRange | undefined) {
return range ? range.pos : -1;
}
export function getRangeEnd(range: TextRange | undefined) {
return range ? range.end : -1;
}
/**
* Increases (or decreases) a position by the provided amount.
*
@@ -3973,6 +3935,19 @@ namespace ts {
export function isModuleBody(node: Node): node is ModuleBody {
const kind = node.kind;
return kind === SyntaxKind.ModuleBlock
|| kind === SyntaxKind.ModuleDeclaration
|| kind === SyntaxKind.Identifier;
}
export function isNamespaceBody(node: Node): node is NamespaceBody {
const kind = node.kind;
return kind === SyntaxKind.ModuleBlock
|| kind === SyntaxKind.ModuleDeclaration;
}
export function isJSDocNamespaceBody(node: Node): node is JSDocNamespaceBody {
const kind = node.kind;
return kind === SyntaxKind.Identifier
|| kind === SyntaxKind.ModuleDeclaration;
}
@@ -4564,4 +4539,55 @@ namespace ts {
return true;
}
}
export function getOriginalNode(node: Node): Node;
export function getOriginalNode<T extends Node>(node: Node, nodeTest: (node: Node) => node is T): T;
export function getOriginalNode(node: Node, nodeTest?: (node: Node) => boolean): Node {
if (node) {
while (node.original !== undefined) {
node = node.original;
}
}
return !nodeTest || nodeTest(node) ? node : undefined;
}
/**
* Gets a value indicating whether a node originated in the parse tree.
*
* @param node The node to test.
*/
export function isParseTreeNode(node: Node): boolean {
return (node.flags & NodeFlags.Synthesized) === 0;
}
/**
* Gets the original parse tree node for a node.
*
* @param node The original node.
* @returns The original parse tree node if found; otherwise, undefined.
*/
export function getParseTreeNode(node: Node): Node;
/**
* Gets the original parse tree node for a node.
*
* @param node The original node.
* @param nodeTest A callback used to ensure the correct type of parse tree node is returned.
* @returns The original parse tree node if found; otherwise, undefined.
*/
export function getParseTreeNode<T extends Node>(node: Node, nodeTest?: (node: Node) => node is T): T;
export function getParseTreeNode(node: Node, nodeTest?: (node: Node) => boolean): Node {
if (isParseTreeNode(node)) {
return node;
}
node = getOriginalNode(node);
if (isParseTreeNode(node) && (!nodeTest || nodeTest(node))) {
return node;
}
return undefined;
}
}
+136 -159
View File
@@ -6,97 +6,6 @@
namespace ts {
export type VisitResult<T extends Node> = T[] | T | undefined;
/**
* Describes an edge of a Node, used when traversing a syntax tree.
*/
interface NodeEdge {
/** The property name for the edge. */
name: string;
/** Indicates that the result is optional. */
optional?: boolean;
/** A callback used to test whether a node is valid. */
test?: (node: Node) => node is Node;
/** A callback used to lift a NodeArrayNode into a valid node. */
lift?: (nodes: NodeArray<Node>) => Node;
/** A callback used to parenthesize a node to preserve the intended order of operations. */
parenthesize?: (value: Node, parentNode: Node) => Node;
};
/**
* Describes the shape of a Node.
*/
type NodeTraversalPath = NodeEdge[];
/**
* This map contains information about the shape of each Node in "types.ts" pertaining to how
* each node should be traversed during a transformation.
*
* Each edge corresponds to a property in a Node subtype that should be traversed when visiting
* each child. The properties are assigned in the order in which traversal should occur.
*
* We only add entries for nodes that do not have a create/update pair defined in factory.ts
*
* NOTE: This needs to be kept up to date with changes to nodes in "types.ts". Currently, this
* map is not comprehensive. Only node edges relevant to tree transformation are
* currently defined. We may extend this to be more comprehensive, and eventually
* supplant the existing `forEachChild` implementation if performance is not
* significantly impacted.
*/
function getNodeEdgeTraversal(kind: SyntaxKind): NodeTraversalPath {
switch (kind) {
case SyntaxKind.QualifiedName: return [
{ name: "left", test: isEntityName },
{ name: "right", test: isIdentifier }
];
case SyntaxKind.Decorator: return [
{ name: "expression", test: isLeftHandSideExpression }
];
case SyntaxKind.TypeAssertionExpression: return [
{ name: "type", test: isTypeNode },
{ name: "expression", test: isUnaryExpression }
];
case SyntaxKind.AsExpression: return [
{ name: "expression", test: isExpression },
{ name: "type", test: isTypeNode }
];
case SyntaxKind.NonNullExpression: return [
{ name: "expression", test: isLeftHandSideExpression }
];
case SyntaxKind.EnumDeclaration: return [
{ name: "decorators", test: isDecorator },
{ name: "modifiers", test: isModifier },
{ name: "name", test: isIdentifier },
{ name: "members", test: isEnumMember }
];
case SyntaxKind.ModuleDeclaration: return [
{ name: "decorators", test: isDecorator },
{ name: "modifiers", test: isModifier },
{ name: "name", test: isModuleName },
{ name: "body", test: isModuleBody }
];
case SyntaxKind.ModuleBlock: return [
{ name: "statements", test: isStatement }
];
case SyntaxKind.ImportEqualsDeclaration: return [
{ name: "decorators", test: isDecorator },
{ name: "modifiers", test: isModifier },
{ name: "name", test: isIdentifier },
{ name: "moduleReference", test: isModuleReference }
];
case SyntaxKind.ExternalModuleReference: return [
{ name: "expression", test: isExpression, optional: true }
];
case SyntaxKind.EnumMember: return [
{ name: "name", test: isPropertyName },
{ name: "initializer", test: isExpression, optional: true, parenthesize: parenthesizeExpressionForList }
];
}
}
function reduceNode<T>(node: Node, f: (memo: T, node: Node) => T, initial: T) {
return node ? f(initial, node) : initial;
}
@@ -107,8 +16,7 @@ namespace ts {
/**
* Similar to `reduceLeft`, performs a reduction against each child of a node.
* NOTE: Unlike `forEachChild`, this does *not* visit every node. Only nodes added to the
* `nodeEdgeTraversalMap` above will be visited.
* NOTE: Unlike `forEachChild`, this does *not* visit every node.
*
* @param node The node containing the children to reduce.
* @param initial The initial value to supply to the reduction.
@@ -145,6 +53,11 @@ namespace ts {
break;
// Names
case SyntaxKind.QualifiedName:
result = reduceNode((<QualifiedName>node).left, cbNode, result);
result = reduceNode((<QualifiedName>node).right, cbNode, result);
break;
case SyntaxKind.ComputedPropertyName:
result = reduceNode((<ComputedPropertyName>node).expression, cbNode, result);
break;
@@ -252,6 +165,11 @@ namespace ts {
result = reduceNode((<TaggedTemplateExpression>node).template, cbNode, result);
break;
case SyntaxKind.TypeAssertionExpression:
result = reduceNode((<TypeAssertion>node).type, cbNode, result);
result = reduceNode((<TypeAssertion>node).expression, cbNode, result);
break;
case SyntaxKind.FunctionExpression:
result = reduceNodes((<FunctionExpression>node).modifiers, cbNodes, result);
result = reduceNode((<FunctionExpression>node).name, cbNode, result);
@@ -314,6 +232,15 @@ namespace ts {
result = reduceNodes((<ExpressionWithTypeArguments>node).typeArguments, cbNodes, result);
break;
case SyntaxKind.AsExpression:
result = reduceNode((<AsExpression>node).expression, cbNode, result);
result = reduceNode((<AsExpression>node).type, cbNode, result);
break;
case SyntaxKind.NonNullExpression:
result = reduceNode((<NonNullExpression>node).expression, cbNode, result);
break;
// Misc
case SyntaxKind.TemplateSpan:
result = reduceNode((<TemplateSpan>node).expression, cbNode, result);
@@ -415,10 +342,35 @@ namespace ts {
result = reduceNodes((<ClassDeclaration>node).members, cbNodes, result);
break;
case SyntaxKind.EnumDeclaration:
result = reduceNodes((<EnumDeclaration>node).decorators, cbNodes, result);
result = reduceNodes((<EnumDeclaration>node).modifiers, cbNodes, result);
result = reduceNode((<EnumDeclaration>node).name, cbNode, result);
result = reduceNodes((<EnumDeclaration>node).members, cbNodes, result);
break;
case SyntaxKind.ModuleDeclaration:
result = reduceNodes((<ModuleDeclaration>node).decorators, cbNodes, result);
result = reduceNodes((<ModuleDeclaration>node).modifiers, cbNodes, result);
result = reduceNode((<ModuleDeclaration>node).name, cbNode, result);
result = reduceNode((<ModuleDeclaration>node).body, cbNode, result);
break;
case SyntaxKind.ModuleBlock:
result = reduceNodes((<ModuleBlock>node).statements, cbNodes, result);
break;
case SyntaxKind.CaseBlock:
result = reduceNodes((<CaseBlock>node).clauses, cbNodes, result);
break;
case SyntaxKind.ImportEqualsDeclaration:
result = reduceNodes((<ImportEqualsDeclaration>node).decorators, cbNodes, result);
result = reduceNodes((<ImportEqualsDeclaration>node).modifiers, cbNodes, result);
result = reduceNode((<ImportEqualsDeclaration>node).name, cbNode, result);
result = reduceNode((<ImportEqualsDeclaration>node).moduleReference, cbNode, result);
break;
case SyntaxKind.ImportDeclaration:
result = reduceNodes((<ImportDeclaration>node).decorators, cbNodes, result);
result = reduceNodes((<ImportDeclaration>node).modifiers, cbNodes, result);
@@ -459,6 +411,11 @@ namespace ts {
result = reduceNode((<ExportDeclaration>node).moduleSpecifier, cbNode, result);
break;
// Module references
case SyntaxKind.ExternalModuleReference:
result = reduceNode((<ExternalModuleReference>node).expression, cbNode, result);
break;
// JSX
case SyntaxKind.JsxElement:
result = reduceNode((<JsxElement>node).openingElement, cbNode, result);
@@ -519,30 +476,25 @@ namespace ts {
break;
case SyntaxKind.SpreadAssignment:
result = reduceNode((node as SpreadAssignment).expression, cbNode, result);
result = reduceNode((<SpreadAssignment>node).expression, cbNode, result);
break;
// Enum
case SyntaxKind.EnumMember:
result = reduceNode((<EnumMember>node).name, cbNode, result);
result = reduceNode((<EnumMember>node).initializer, cbNode, result);
// Top-level nodes
case SyntaxKind.SourceFile:
result = reduceNodes((<SourceFile>node).statements, cbNodes, result);
break;
// Transformation nodes
case SyntaxKind.PartiallyEmittedExpression:
result = reduceNode((<PartiallyEmittedExpression>node).expression, cbNode, result);
break;
default:
const edgeTraversalPath = getNodeEdgeTraversal(kind);
if (edgeTraversalPath) {
for (const edge of edgeTraversalPath) {
const value = (<MapLike<any>>node)[edge.name];
if (value !== undefined) {
result = isArray(value)
? reduceNodes(<NodeArray<Node>>value, cbNodes, result)
: cbNode(result, <Node>value);
}
}
}
break;
}
@@ -556,11 +508,9 @@ namespace ts {
* @param visitor The callback used to visit the Node.
* @param test A callback to execute to verify the Node is valid.
* @param optional An optional value indicating whether the Node is itself optional.
* @param lift An optional callback to execute to lift a NodeArrayNode into a valid Node.
* @param lift An optional callback to execute to lift a NodeArray into a valid Node.
*/
export function visitNode<T extends Node>(node: T, visitor: (node: Node) => VisitResult<Node>, test: (node: Node) => boolean, optional?: boolean, lift?: (node: NodeArray<Node>) => T): T;
export function visitNode<T extends Node>(node: T, visitor: (node: Node) => VisitResult<Node>, test: (node: Node) => boolean, optional: boolean, lift: (node: NodeArray<Node>) => T, parenthesize: (node: Node, parentNode: Node) => Node, parentNode: Node): T;
export function visitNode(node: Node, visitor: (node: Node) => VisitResult<Node>, test: (node: Node) => boolean, optional?: boolean, lift?: (node: Node[]) => Node, parenthesize?: (node: Node, parentNode: Node) => Node, parentNode?: Node): Node {
export function visitNode<T extends Node>(node: T, visitor: (node: Node) => VisitResult<Node>, test: (node: Node) => boolean, optional?: boolean, lift?: (node: NodeArray<Node>) => T): T {
if (node === undefined || visitor === undefined) {
return node;
}
@@ -586,13 +536,9 @@ namespace ts {
visitedNode = visited;
}
if (parenthesize !== undefined) {
visitedNode = parenthesize(visitedNode, parentNode);
}
Debug.assertNode(visitedNode, test);
aggregateTransformFlags(visitedNode);
return visitedNode;
return <T>visitedNode;
}
/**
@@ -604,14 +550,12 @@ namespace ts {
* @param start An optional value indicating the starting offset at which to start visiting.
* @param count An optional value indicating the maximum number of nodes to visit.
*/
export function visitNodes<T extends Node>(nodes: NodeArray<T>, visitor: (node: Node) => VisitResult<Node>, test: (node: Node) => boolean, start?: number, count?: number): NodeArray<T>;
export function visitNodes<T extends Node>(nodes: NodeArray<T>, visitor: (node: Node) => VisitResult<Node>, test: (node: Node) => boolean, start: number, count: number, parenthesize: (node: Node, parentNode: Node) => Node, parentNode: Node): NodeArray<T>;
export function visitNodes(nodes: NodeArray<Node>, visitor: (node: Node) => VisitResult<Node>, test: (node: Node) => boolean, start?: number, count?: number, parenthesize?: (node: Node, parentNode: Node) => Node, parentNode?: Node): NodeArray<Node> {
export function visitNodes<T extends Node>(nodes: NodeArray<T>, visitor: (node: Node) => VisitResult<Node>, test: (node: Node) => boolean, start?: number, count?: number): NodeArray<T> {
if (nodes === undefined) {
return undefined;
}
let updated: NodeArray<Node>;
let updated: NodeArray<T>;
// Ensure start and count have valid values
const length = nodes.length;
@@ -627,8 +571,7 @@ namespace ts {
// If we are not visiting all of the original nodes, we must always create a new array.
// Since this is a fragment of a node array, we do not copy over the previous location
// and will only copy over `hasTrailingComma` if we are including the last element.
updated = createNodeArray<Node>([], /*location*/ undefined,
/*hasTrailingComma*/ nodes.hasTrailingComma && start + count === length);
updated = createNodeArray<T>([], /*hasTrailingComma*/ nodes.hasTrailingComma && start + count === length);
}
// Visit each original node.
@@ -639,26 +582,21 @@ namespace ts {
if (updated !== undefined || visited === undefined || visited !== node) {
if (updated === undefined) {
// Ensure we have a copy of `nodes`, up to the current index.
updated = createNodeArray(nodes.slice(0, i), /*location*/ nodes, nodes.hasTrailingComma);
updated = createNodeArray(nodes.slice(0, i), nodes.hasTrailingComma);
setTextRange(updated, nodes);
}
if (visited) {
if (isArray(visited)) {
for (let visitedNode of visited) {
visitedNode = parenthesize
? parenthesize(visitedNode, parentNode)
: visitedNode;
for (const visitedNode of visited) {
Debug.assertNode(visitedNode, test);
aggregateTransformFlags(visitedNode);
updated.push(visitedNode);
updated.push(<T>visitedNode);
}
}
else {
const visitedNode = parenthesize
? parenthesize(visited, parentNode)
: visited;
Debug.assertNode(visitedNode, test);
aggregateTransformFlags(visitedNode);
updated.push(visitedNode);
Debug.assertNode(visited, test);
aggregateTransformFlags(visited);
updated.push(<T>visited);
}
}
}
@@ -675,10 +613,10 @@ namespace ts {
context.startLexicalEnvironment();
statements = visitNodes(statements, visitor, isStatement, start);
if (ensureUseStrict && !startsWithUseStrict(statements)) {
statements = createNodeArray([createStatement(createLiteral("use strict")), ...statements], statements);
statements = setTextRange(createNodeArray([createStatement(createLiteral("use strict")), ...statements]), statements);
}
const declarations = context.endLexicalEnvironment();
return createNodeArray(concatenate(statements, declarations), statements);
return setTextRange(createNodeArray(concatenate(statements, declarations)), statements);
}
/**
@@ -747,6 +685,11 @@ namespace ts {
return node;
// Names
case SyntaxKind.QualifiedName:
return updateQualifiedName(<QualifiedName>node,
visitNode((<QualifiedName>node).left, visitor, isEntityName),
visitNode((<QualifiedName>node).right, visitor, isIdentifier));
case SyntaxKind.ComputedPropertyName:
return updateComputedPropertyName(<ComputedPropertyName>node,
visitNode((<ComputedPropertyName>node).expression, visitor, isExpression));
@@ -761,6 +704,10 @@ namespace ts {
visitNode((<ParameterDeclaration>node).type, visitor, isTypeNode, /*optional*/ true),
visitNode((<ParameterDeclaration>node).initializer, visitor, isExpression, /*optional*/ true));
case SyntaxKind.Decorator:
return updateDecorator(<Decorator>node,
visitNode((<Decorator>node).expression, visitor, isExpression));
// Type member
case SyntaxKind.PropertyDeclaration:
return updateProperty(<PropertyDeclaration>node,
@@ -857,6 +804,11 @@ namespace ts {
visitNode((<TaggedTemplateExpression>node).tag, visitor, isExpression),
visitNode((<TaggedTemplateExpression>node).template, visitor, isTemplateLiteral));
case SyntaxKind.TypeAssertionExpression:
return updateTypeAssertion(<TypeAssertion>node,
visitNode((<TypeAssertion>node).type, visitor, isTypeNode),
visitNode((<TypeAssertion>node).expression, visitor, isExpression));
case SyntaxKind.ParenthesizedExpression:
return updateParen(<ParenthesizedExpression>node,
visitNode((<ParenthesizedExpression>node).expression, visitor, isExpression));
@@ -940,6 +892,15 @@ namespace ts {
visitNodes((<ExpressionWithTypeArguments>node).typeArguments, visitor, isTypeNode),
visitNode((<ExpressionWithTypeArguments>node).expression, visitor, isExpression));
case SyntaxKind.AsExpression:
return updateAsExpression(<AsExpression>node,
visitNode((<AsExpression>node).expression, visitor, isExpression),
visitNode((<AsExpression>node).type, visitor, isTypeNode));
case SyntaxKind.NonNullExpression:
return updateNonNullExpression(<NonNullExpression>node,
visitNode((<NonNullExpression>node).expression, visitor, isExpression));
// Misc
case SyntaxKind.TemplateSpan:
return updateTemplateSpan(<TemplateSpan>node,
@@ -1063,10 +1024,35 @@ namespace ts {
visitNodes((<ClassDeclaration>node).heritageClauses, visitor, isHeritageClause),
visitNodes((<ClassDeclaration>node).members, visitor, isClassElement));
case SyntaxKind.EnumDeclaration:
return updateEnumDeclaration(<EnumDeclaration>node,
visitNodes((<EnumDeclaration>node).decorators, visitor, isDecorator),
visitNodes((<EnumDeclaration>node).modifiers, visitor, isModifier),
visitNode((<EnumDeclaration>node).name, visitor, isIdentifier),
visitNodes((<EnumDeclaration>node).members, visitor, isEnumMember));
case SyntaxKind.ModuleDeclaration:
return updateModuleDeclaration(<ModuleDeclaration>node,
visitNodes((<ModuleDeclaration>node).decorators, visitor, isDecorator),
visitNodes((<ModuleDeclaration>node).modifiers, visitor, isModifier),
visitNode((<ModuleDeclaration>node).name, visitor, isIdentifier),
visitNode((<ModuleDeclaration>node).body, visitor, isModuleBody));
case SyntaxKind.ModuleBlock:
return updateModuleBlock(<ModuleBlock>node,
visitNodes((<ModuleBlock>node).statements, visitor, isStatement));
case SyntaxKind.CaseBlock:
return updateCaseBlock(<CaseBlock>node,
visitNodes((<CaseBlock>node).clauses, visitor, isCaseOrDefaultClause));
case SyntaxKind.ImportEqualsDeclaration:
return updateImportEqualsDeclaration(<ImportEqualsDeclaration>node,
visitNodes((<ImportEqualsDeclaration>node).decorators, visitor, isDecorator),
visitNodes((<ImportEqualsDeclaration>node).modifiers, visitor, isModifier),
visitNode((<ImportEqualsDeclaration>node).name, visitor, isIdentifier),
visitNode((<ImportEqualsDeclaration>node).moduleReference, visitor, isModuleReference));
case SyntaxKind.ImportDeclaration:
return updateImportDeclaration(<ImportDeclaration>node,
visitNodes((<ImportDeclaration>node).decorators, visitor, isDecorator),
@@ -1114,6 +1100,11 @@ namespace ts {
visitNode((<ExportSpecifier>node).propertyName, visitor, isIdentifier, /*optional*/ true),
visitNode((<ExportSpecifier>node).name, visitor, isIdentifier));
// Module references
case SyntaxKind.ExternalModuleReference:
return updateExternalModuleReference(<ExternalModuleReference>node,
visitNode((<ExternalModuleReference>node).expression, visitor, isExpression));
// JSX
case SyntaxKind.JsxElement:
return updateJsxElement(<JsxElement>node,
@@ -1179,10 +1170,16 @@ namespace ts {
visitNode((<ShorthandPropertyAssignment>node).objectAssignmentInitializer, visitor, isExpression));
case SyntaxKind.SpreadAssignment:
return updateSpreadAssignment(node as SpreadAssignment,
visitNode((node as SpreadAssignment).expression, visitor, isExpression));
return updateSpreadAssignment(<SpreadAssignment>node,
visitNode((<SpreadAssignment>node).expression, visitor, isExpression));
// Top-level nodes
// Enum
case SyntaxKind.EnumMember:
return updateEnumMember(<EnumMember>node,
visitNode((<EnumMember>node).name, visitor, isPropertyName),
visitNode((<EnumMember>node).initializer, visitor, isExpression, /*optional*/ true));
// Top-level nodes
case SyntaxKind.SourceFile:
return updateSourceFileNode(<SourceFile>node,
visitLexicalEnvironment((<SourceFile>node).statements, visitor, context));
@@ -1193,27 +1190,7 @@ namespace ts {
visitNode((<PartiallyEmittedExpression>node).expression, visitor, isExpression));
default:
let updated: Node & MapLike<any>;
const edgeTraversalPath = getNodeEdgeTraversal(kind);
if (edgeTraversalPath) {
for (const edge of edgeTraversalPath) {
const value = <Node | NodeArray<Node>>(<Node & MapLike<any>>node)[edge.name];
if (value !== undefined) {
const visited = isArray(value)
? visitNodes(value, visitor, edge.test, 0, value.length, edge.parenthesize, node)
: visitNode(value, visitor, edge.test, edge.optional, edge.lift, edge.parenthesize, node);
if (updated !== undefined || visited !== value) {
if (updated === undefined) {
updated = getMutableClone(node);
}
if (visited !== value) {
updated[edge.name] = visited;
}
}
}
}
}
return updated ? updateNode(updated, node) : node;
return node;
}
}
@@ -1232,7 +1209,7 @@ namespace ts {
}
return isNodeArray(statements)
? createNodeArray(concatenate(statements, declarations), statements)
? setTextRange(createNodeArray(concatenate(statements, declarations)), statements)
: addRange(statements, declarations);
}
+93 -30
View File
@@ -183,7 +183,7 @@ namespace FourSlash {
// The current caret position in the active file
public currentCaretPosition = 0;
public lastKnownMarker: string = "";
public lastKnownMarker = "";
// The file that's currently 'opened'
public activeFile: FourSlashFile;
@@ -452,7 +452,8 @@ namespace FourSlash {
}
private messageAtLastKnownMarker(message: string) {
return "Marker: " + this.lastKnownMarker + "\n" + message;
const locationDescription = this.lastKnownMarker ? this.lastKnownMarker : this.getLineColStringAtPosition(this.currentCaretPosition);
return `At ${locationDescription}: ${message}`;
}
private assertionMessageAtLastKnownMarker(msg: string) {
@@ -562,7 +563,7 @@ namespace FourSlash {
}
public verifyGoToDefinitionIs(endMarker: string | string[]) {
this.verifyGoToXWorker(endMarker instanceof Array ? endMarker : [endMarker], () => this.getGoToDefinition());
this.verifyGoToXWorker(toArray(endMarker), () => this.getGoToDefinition());
}
public verifyGoToDefinition(arg0: any, endMarkerNames?: string | string[]) {
@@ -582,7 +583,7 @@ namespace FourSlash {
if (endMarkerNames) {
this.verifyGoToXPlain(arg0, endMarkerNames, getDefs);
}
else if (arg0 instanceof Array) {
else if (ts.isArray(arg0)) {
const pairs: [string | string[], string | string[]][] = arg0;
for (const [start, end] of pairs) {
this.verifyGoToXPlain(start, end, getDefs);
@@ -599,13 +600,8 @@ namespace FourSlash {
}
private verifyGoToXPlain(startMarkerNames: string | string[], endMarkerNames: string | string[], getDefs: () => ts.DefinitionInfo[] | undefined) {
if (startMarkerNames instanceof Array) {
for (const start of startMarkerNames) {
this.verifyGoToXSingle(start, endMarkerNames, getDefs);
}
}
else {
this.verifyGoToXSingle(startMarkerNames, endMarkerNames, getDefs);
for (const start of toArray(startMarkerNames)) {
this.verifyGoToXSingle(start, endMarkerNames, getDefs);
}
}
@@ -617,7 +613,7 @@ namespace FourSlash {
private verifyGoToXSingle(startMarkerName: string, endMarkerNames: string | string[], getDefs: () => ts.DefinitionInfo[] | undefined) {
this.goToMarker(startMarkerName);
this.verifyGoToXWorker(endMarkerNames instanceof Array ? endMarkerNames : [endMarkerNames], getDefs);
this.verifyGoToXWorker(toArray(endMarkerNames), getDefs);
}
private verifyGoToXWorker(endMarkers: string[], getDefs: () => ts.DefinitionInfo[] | undefined) {
@@ -899,8 +895,74 @@ namespace FourSlash {
}
}
public verifyRangesWithSameTextReferenceEachOther() {
this.rangesByText().forEach(ranges => this.verifyRangesReferenceEachOther(ranges));
public verifyReferenceGroups(startRanges: Range | Range[], parts: Array<{ definition: string, ranges: Range[] }>): void {
interface ReferenceJson { definition: string; ranges: ts.ReferenceEntry[]; }
type ReferencesJson = ReferenceJson[];
const fullExpected = parts.map<ReferenceJson>(({ definition, ranges }) => ({ definition, ranges: ranges.map(rangeToReferenceEntry) }));
for (const startRange of toArray(startRanges)) {
this.goToRangeStart(startRange);
const fullActual = this.findReferencesAtCaret().map<ReferenceJson>(({ definition, references }) => ({
definition: definition.displayParts.map(d => d.text).join(""),
ranges: references
}));
this.assertObjectsEqual<ReferencesJson>(fullActual, fullExpected);
}
function rangeToReferenceEntry(r: Range) {
let { isWriteAccess, isDefinition } = (r.marker && r.marker.data) || { isWriteAccess: false, isDefinition: false };
isWriteAccess = !!isWriteAccess; isDefinition = !!isDefinition;
return { fileName: r.fileName, textSpan: { start: r.start, length: r.end - r.start }, isWriteAccess, isDefinition }
}
}
public verifyNoReferences(markerNameOrRange?: string | Range) {
if (markerNameOrRange) {
if (typeof markerNameOrRange === "string") {
this.goToMarker(markerNameOrRange);
}
else {
this.goToRangeStart(markerNameOrRange);
}
}
const refs = this.getReferencesAtCaret();
if (refs && refs.length) {
console.log(refs);
this.raiseError("Expected getReferences to fail");
}
}
public verifySingleReferenceGroup(definition: string, ranges?: Range[]) {
ranges = ranges || this.getRanges();
this.verifyReferenceGroups(ranges, [{ definition, ranges }]);
}
private assertObjectsEqual<T>(fullActual: T, fullExpected: T, msgPrefix = ""): void {
const recur = <U>(actual: U, expected: U, path: string) => {
const fail = (msg: string) => {
console.log("Expected:", stringify(fullExpected));
console.log("Actual: ", stringify(fullActual));
this.raiseError(`${msgPrefix}At ${path}: ${msg}`);
};
for (const key in actual) if (ts.hasProperty(actual as any, key)) {
const ak = actual[key], ek = expected[key];
if (typeof ak === "object" && typeof ek === "object") {
recur(ak, ek, path ? path + "." + key : key);
}
else if (ak !== ek) {
fail(`Expected '${key}' to be '${ek}', got '${ak}'`);
}
}
for (const key in expected) if (ts.hasProperty(expected as any, key)) {
if (!ts.hasProperty(actual as any, key)) {
fail(`${msgPrefix}Missing property '${key}'`);
}
}
};
recur(fullActual, fullExpected, "");
}
public verifyDisplayPartsOfReferencedSymbol(expected: ts.SymbolDisplayPart[]) {
@@ -974,7 +1036,7 @@ namespace FourSlash {
public verifyQuickInfos(namesAndTexts: { [name: string]: string | [string, string] }) {
for (const name in namesAndTexts) if (ts.hasProperty(namesAndTexts, name)) {
const text = namesAndTexts[name];
if (text instanceof Array) {
if (ts.isArray(text)) {
assert(text.length === 2);
const [expectedText, expectedDocumentation] = text;
this.verifyQuickInfoAt(name, expectedText, expectedDocumentation);
@@ -1411,13 +1473,6 @@ namespace FourSlash {
Harness.IO.log(membersString);
}
public printReferences() {
const references = this.getReferencesAtCaret();
ts.forEach(references, entry => {
Harness.IO.log(stringify(entry));
});
}
public printContext() {
ts.forEach(this.languageServiceAdapterHost.getFilenames(), Harness.IO.log);
}
@@ -3082,6 +3137,10 @@ ${code}
}
return ts.arrayFrom(set.keys());
}
function toArray<T>(x: T | T[]): T[] {
return ts.isArray(x) ? x : [x];
}
}
namespace FourSlashInterface {
@@ -3346,6 +3405,18 @@ namespace FourSlashInterface {
this.state.verifyReferencesOf(start, references);
}
public referenceGroups(startRanges: FourSlash.Range[], parts: Array<{ definition: string, ranges: FourSlash.Range[] }>) {
this.state.verifyReferenceGroups(startRanges, parts);
}
public noReferences(markerNameOrRange?: string | FourSlash.Range) {
this.state.verifyNoReferences(markerNameOrRange);
}
public singleReferenceGroup(definition: string, ranges?: FourSlash.Range[]) {
this.state.verifySingleReferenceGroup(definition, ranges);
}
public rangesReferenceEachOther(ranges?: FourSlash.Range[]) {
this.state.verifyRangesReferenceEachOther(ranges);
}
@@ -3354,10 +3425,6 @@ namespace FourSlashInterface {
this.state.verifyDisplayPartsOfReferencedSymbol(expected);
}
public rangesWithSameTextReferenceEachOther() {
this.state.verifyRangesWithSameTextReferenceEachOther();
}
public currentParameterHelpArgumentNameIs(name: string) {
this.state.verifyCurrentParameterHelpName(name);
}
@@ -3660,10 +3727,6 @@ namespace FourSlashInterface {
this.state.printNavigationBar();
}
public printReferences() {
this.state.printReferences();
}
public printContext() {
this.state.printContext();
}
+2 -2
View File
@@ -5,7 +5,7 @@
namespace Harness.LanguageService {
export class ScriptInfo {
public version: number = 1;
public version = 1;
public editRanges: { length: number; textChangeRange: ts.TextChangeRange; }[] = [];
private lineMap: number[] = undefined;
@@ -594,7 +594,7 @@ namespace Harness.LanguageService {
class SessionServerHost implements ts.server.ServerHost, ts.server.Logger {
args: string[] = [];
newLine: string;
useCaseSensitiveFileNames: boolean = false;
useCaseSensitiveFileNames = false;
constructor(private host: NativeLanguageServiceHost) {
this.newLine = this.host.getNewLine();
+49 -1
View File
@@ -3031,6 +3031,54 @@ namespace ts.projectSystem {
});
});
describe("emit with outFile or out setting", () => {
function test(opts: CompilerOptions, expectedUsesOutFile: boolean) {
const f1 = {
path: "/a/a.ts",
content: "let x = 1"
};
const f2 = {
path: "/a/b.ts",
content: "let y = 1"
};
const config = {
path: "/a/tsconfig.json",
content: JSON.stringify({
compilerOptions: opts,
compileOnSave: true
})
};
const host = createServerHost([f1, f2, config]);
const session = createSession(host);
session.executeCommand(<protocol.OpenRequest>{
seq: 1,
type: "request",
command: "open",
arguments: { file: f1.path }
});
checkNumberOfProjects(session.getProjectService(), { configuredProjects: 1 });
const { response } = session.executeCommand(<protocol.CompileOnSaveAffectedFileListRequest>{
seq: 2,
type: "request",
command: "compileOnSaveAffectedFileList",
arguments: { file: f1.path }
});
assert.equal((<protocol.CompileOnSaveAffectedFileListSingleProject[]>response).length, 1, "expected output for 1 project");
assert.equal((<protocol.CompileOnSaveAffectedFileListSingleProject[]>response)[0].fileNames.length, 2, "expected output for 1 project");
assert.equal((<protocol.CompileOnSaveAffectedFileListSingleProject[]>response)[0].projectUsesOutFile, expectedUsesOutFile, "usesOutFile");
}
it ("projectUsesOutFile should not be returned if not set", () => {
test({}, /*expectedUsesOutFile*/ false);
});
it ("projectUsesOutFile should be true if outFile is set", () => {
test({ outFile: "/a/out.js" }, /*expectedUsesOutFile*/ true);
});
it ("projectUsesOutFile should be true if out is set", () => {
test({ out: "/a/out.js" }, /*expectedUsesOutFile*/ true);
});
});
describe("import helpers", () => {
it("should not crash in tsserver", () => {
const f1 = {
@@ -3067,7 +3115,7 @@ namespace ts.projectSystem {
let options = project.getCompilerOptions();
assert.isTrue(options.maxNodeModuleJsDepth === 2);
// Assert the option sticks
// Assert the option sticks
projectService.setCompilerOptionsForInferredProjects({ target: ScriptTarget.ES2016 });
project = projectService.inferredProjects[0];
options = project.getCompilerOptions();
+39
View File
@@ -46,6 +46,45 @@ namespace ts.projectSystem {
import typingsName = server.typingsInstaller.typingsName;
describe("local module", () => {
it("should not be picked up", () => {
const f1 = {
path: "/a/app.js",
content: "const c = require('./config');"
};
const f2 = {
path: "/a/config.js",
content: "export let x = 1"
};
const typesCache = "/cache"
const typesConfig = {
path: typesCache + "/node_modules/@types/config/index.d.ts",
content: "export let y: number;"
};
const config = {
path: "/a/jsconfig.json",
content: JSON.stringify({
compilerOptions: { moduleResolution: "commonjs" },
typeAcquisition: { enable: true }
})
};
const host = createServerHost([f1, f2, config, typesConfig]);
const installer = new (class extends Installer {
constructor() {
super(host, { typesRegistry: createTypesRegistry("config"), globalTypingsCacheLocation: typesCache });
}
installWorker(_requestId: number, _args: string[], _cwd: string, _cb: server.typingsInstaller.RequestCompletedAction) {
assert(false, "should not be called")
}
})();
const service = createProjectService(host, { typingsInstaller: installer });
service.openClientFile(f1.path);
service.checkNumberOfProjects({ configuredProjects: 1 });
checkProjectActualFiles(service.configuredProjects[0], [f1.path, f2.path]);
installer.installAll(0);
});
});
describe("typingsInstaller", () => {
it("configured projects (typings installed) 1", () => {
const file1 = {
+1564 -365
View File
File diff suppressed because it is too large. Load diff
+636 -161
View File
File diff suppressed because it is too large. Load diff
@@ -1,7 +1,7 @@
/// <reference types="node" />
// TODO: extract services types
// TODO: extract services types
interface HostCancellationToken {
isCancellationRequested(): boolean;
}
+1 -1
View File
@@ -28,7 +28,7 @@ namespace ts.server {
: undefined;
const primaryResult = resolveModuleName(moduleName, containingFile, compilerOptions, host);
// return result immediately only if it is .ts, .tsx or .d.ts
if (!(primaryResult.resolvedModule && extensionIsTypeScript(primaryResult.resolvedModule.extension)) && globalCache !== undefined) {
if (moduleHasNonRelativeName(moduleName) && !(primaryResult.resolvedModule && extensionIsTypeScript(primaryResult.resolvedModule.extension)) && globalCache !== undefined) {
// otherwise try to load typings from @types
// create different collection of failed lookup locations for second pass
+5
View File
@@ -1239,6 +1239,11 @@ namespace ts.server.protocol {
* List of files names that should be recompiled
*/
fileNames: string[];
/**
* true if project uses outFile or out compiler option
*/
projectUsesOutFile: boolean;
}
/**
+2 -1
View File
@@ -1040,7 +1040,8 @@ namespace ts.server {
if (project.compileOnSaveEnabled && project.languageServiceEnabled) {
result.push({
projectFileName: project.getProjectName(),
fileNames: project.getCompileOnSaveAffectedFileList(info)
fileNames: project.getCompileOnSaveAffectedFileList(info),
projectUsesOutFile: !!project.getCompilerOptions().outFile || !!project.getCompilerOptions().out
});
}
}
+1
View File
@@ -115,6 +115,7 @@ namespace ts.codefix {
registerCodeFix({
errorCodes: [
Diagnostics.Cannot_find_name_0.code,
Diagnostics.Cannot_find_namespace_0.code,
Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code
],
getCodeActions: (context: CodeFixContext) => {
+34 -18
View File
@@ -25,7 +25,7 @@ namespace ts.codefix {
const forStatement = <ForStatement>token.parent.parent.parent;
const forInitializer = <VariableDeclarationList>forStatement.initializer;
if (forInitializer.declarations.length === 1) {
return createCodeFix("", forInitializer.pos, forInitializer.end - forInitializer.pos);
return createCodeFixToRemoveNode(forInitializer);
}
else {
return removeSingleItem(forInitializer.declarations, token);
@@ -35,7 +35,7 @@ namespace ts.codefix {
const forOfStatement = <ForOfStatement>token.parent.parent.parent;
if (forOfStatement.initializer.kind === SyntaxKind.VariableDeclarationList) {
const forOfInitializer = <VariableDeclarationList>forOfStatement.initializer;
return createCodeFix("{}", forOfInitializer.declarations[0].pos, forOfInitializer.declarations[0].end - forOfInitializer.declarations[0].pos);
return createCodeFix("{}", forOfInitializer.declarations[0].getStart(), forOfInitializer.declarations[0].getWidth());
}
break;
@@ -47,12 +47,12 @@ namespace ts.codefix {
case SyntaxKind.CatchClause:
const catchClause = <CatchClause>token.parent.parent;
const parameter = catchClause.variableDeclaration.getChildren()[0];
return createCodeFix("", parameter.pos, parameter.end - parameter.pos);
return createCodeFixToRemoveNode(parameter);
default:
const variableStatement = <VariableStatement>token.parent.parent.parent;
if (variableStatement.declarationList.declarations.length === 1) {
return createCodeFix("", variableStatement.pos, variableStatement.end - variableStatement.pos);
return createCodeFixToRemoveNode(variableStatement);
}
else {
const declarations = variableStatement.declarationList.declarations;
@@ -72,7 +72,7 @@ namespace ts.codefix {
case ts.SyntaxKind.Parameter:
const functionDeclaration = <FunctionDeclaration>token.parent.parent;
if (functionDeclaration.parameters.length === 1) {
return createCodeFix("", token.parent.pos, token.parent.end - token.parent.pos);
return createCodeFixToRemoveNode(token.parent);
}
else {
return removeSingleItem(functionDeclaration.parameters, token);
@@ -81,36 +81,43 @@ namespace ts.codefix {
// handle case where 'import a = A;'
case SyntaxKind.ImportEqualsDeclaration:
const importEquals = findImportDeclaration(token);
return createCodeFix("", importEquals.pos, importEquals.end - importEquals.pos);
return createCodeFixToRemoveNode(importEquals);
case SyntaxKind.ImportSpecifier:
const namedImports = <NamedImports>token.parent.parent;
if (namedImports.elements.length === 1) {
// Only 1 import and it is unused. So the entire declaration should be removed.
const importSpec = findImportDeclaration(token);
return createCodeFix("", importSpec.pos, importSpec.end - importSpec.pos);
return createCodeFixToRemoveNode(importSpec);
}
else {
return removeSingleItem(namedImports.elements, token);
}
// handle case where "import d, * as ns from './file'"
// handle case where "import d, * as ns from './file'"
// or "'import {a, b as ns} from './file'"
case SyntaxKind.ImportClause: // this covers both 'import |d|' and 'import |d,| *'
case SyntaxKind.ImportClause: // this covers both 'import |d|' and 'import |d,| *'
const importClause = <ImportClause>token.parent;
if (!importClause.namedBindings) { // |import d from './file'| or |import * as ns from './file'|
const importDecl = findImportDeclaration(importClause);
return createCodeFix("", importDecl.pos, importDecl.end - importDecl.pos);
return createCodeFixToRemoveNode(importDecl);
}
else { // import |d,| * as ns from './file'
return createCodeFix("", importClause.name.pos, importClause.namedBindings.pos - importClause.name.pos);
else {
// import |d,| * as ns from './file'
const start = importClause.name.getStart();
let end = findFirstNonSpaceCharPosStarting(importClause.name.end);
if (sourceFile.text.charCodeAt(end) === CharacterCodes.comma) {
end = findFirstNonSpaceCharPosStarting(end + 1);
}
return createCodeFix("", start, end - start);
}
case SyntaxKind.NamespaceImport:
const namespaceImport = <NamespaceImport>token.parent;
if (namespaceImport.name == token && !(<ImportClause>namespaceImport.parent).name) {
const importDecl = findImportDeclaration(namespaceImport);
return createCodeFix("", importDecl.pos, importDecl.end - importDecl.pos);
return createCodeFixToRemoveNode(importDecl);
}
else {
const start = (<ImportClause>namespaceImport.parent).name.end;
@@ -120,16 +127,14 @@ namespace ts.codefix {
break;
case SyntaxKind.PropertyDeclaration:
return createCodeFix("", token.parent.pos, token.parent.end - token.parent.pos);
case SyntaxKind.NamespaceImport:
return createCodeFix("", token.parent.pos, token.parent.end - token.parent.pos);
return createCodeFixToRemoveNode(token.parent);
}
if (isDeclarationName(token)) {
return createCodeFix("", token.parent.pos, token.parent.end - token.parent.pos);
return createCodeFixToRemoveNode(token.parent);
}
else if (isLiteralComputedPropertyDeclarationName(token)) {
return createCodeFix("", token.parent.parent.pos, token.parent.parent.end - token.parent.parent.pos);
return createCodeFixToRemoveNode(token.parent.parent);
}
else {
return undefined;
@@ -144,6 +149,17 @@ namespace ts.codefix {
return importDecl;
}
function createCodeFixToRemoveNode(node: Node) {
return createCodeFix("", node.getStart(), node.getWidth());
}
function findFirstNonSpaceCharPosStarting(start: number) {
while (isWhiteSpace(sourceFile.text.charCodeAt(start))) {
start += 1;
}
return start;
}
function createCodeFix(newText: string, start: number, length: number): CodeAction[] {
return [{
description: formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Remove_declaration_for_Colon_0), { 0: token.getText() }),
+4 -15
View File
@@ -5,6 +5,10 @@ namespace ts.FindAllReferences {
return getReferencedSymbolsForNode(typeChecker, cancellationToken, node, sourceFiles, findInStrings, findInComments, isForRename);
}
export function convertReferences(referenceSymbols: ReferencedSymbol[]): ReferenceEntry[] {
return referenceSymbols && flatMap(referenceSymbols, r => r.references);
}
export function getReferencedSymbolsForNode(typeChecker: TypeChecker, cancellationToken: CancellationToken, node: Node, sourceFiles: SourceFile[], findInStrings?: boolean, findInComments?: boolean, isForRename?: boolean, implementations?: boolean): ReferencedSymbol[] | undefined {
if (!implementations) {
const special = getReferencedSymbolsSpecial(node, sourceFiles, typeChecker, cancellationToken);
@@ -411,7 +415,6 @@ namespace ts.FindAllReferences {
textSpan: createTextSpan(0, 1),
displayParts: [{ text: name, kind: ScriptElementKind.keyword }]
}
const references: ReferenceEntry[] = [];
for (const sourceFile of sourceFiles) {
cancellationToken.throwIfCancellationRequested();
@@ -1316,20 +1319,6 @@ namespace ts.FindAllReferences {
return meaning;
}
export function convertReferences(referenceSymbols: ReferencedSymbol[]): ReferenceEntry[] {
if (!referenceSymbols) {
return undefined;
}
const referenceEntries: ReferenceEntry[] = [];
for (const referenceSymbol of referenceSymbols) {
addRange(referenceEntries, referenceSymbol.references);
}
return referenceEntries;
}
function isImplementation(node: Node): boolean {
if (!node) {
return false;
+1 -6
View File
@@ -1415,7 +1415,6 @@ namespace ts {
function findReferences(fileName: string, position: number): ReferencedSymbol[] {
const referencedSymbols = findReferencedSymbols(fileName, position, /*findInStrings*/ false, /*findInComments*/ false, /*isForRename*/false);
// Only include referenced symbols that have a valid definition.
return filter(referencedSymbols, rs => !!rs.definition);
}
@@ -2015,9 +2014,5 @@ namespace ts {
throw new Error("getDefaultLibFilePath is only supported when consumed as a node module. ");
}
function initializeServices() {
objectAllocator = getServicesObjectAllocator();
}
initializeServices();
objectAllocator = getServicesObjectAllocator();
}
@@ -12,7 +12,7 @@ function f1(x: Color | string) {
if (typeof x === "number") {
>typeof x === "number" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | Color
>"number" : "number"
@@ -41,7 +41,7 @@ function f2(x: Color | string | string[]) {
if (typeof x === "object") {
>typeof x === "object" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | Color | string[]
>"object" : "object"
@@ -54,7 +54,7 @@ function f2(x: Color | string | string[]) {
}
if (typeof x === "number") {
>typeof x === "number" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | Color | string[]
>"number" : "number"
@@ -76,7 +76,7 @@ function f2(x: Color | string | string[]) {
}
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | Color | string[]
>"string" : "string"
@@ -26,5 +26,6 @@ define(["require", "exports"], function (require, exports) {
define(["require", "exports", "./foo_0"], function (require, exports, foo) {
"use strict";
if (foo.E1.A === 0) {
// Should cause runtime import - interesting optimization possibility, as gets inlined to 0.
}
});
@@ -4,7 +4,7 @@ function f() {
return typeof class {} === "function";
>typeof class {} === "function" : boolean
>typeof class {} : string
>typeof class {} : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>class {} : typeof (Anonymous class)
>"function" : "function"
}
+1
View File
@@ -17,6 +17,7 @@ var C = (function () {
}
C.prototype.P = function (ii, j, k) {
for (var i = 0; i < arguments.length; i++) {
// WScript.Echo("param: " + arguments[i]);
}
};
return C;
@@ -83,7 +83,9 @@ f(// comment 1
// comment 2
function () {
// comment 4
});
}
// comment 5
);
// body is not a block
f(function (_) { return 1 +
2; });
@@ -0,0 +1,21 @@
//// [assignmentNestedInLiterals.ts]
var target, x, y;
target = [x = 1, y = x];
var aegis, a, b;
aegis = { x: a = 1, y: b = a };
var kowloona, c, d;
for (kowloona of [c = 1, d = c]) {
}
//// [assignmentNestedInLiterals.js]
var target, x, y;
target = [x = 1, y = x];
var aegis, a, b;
aegis = { x: a = 1, y: b = a };
var kowloona, c, d;
for (var _i = 0, _a = [c = 1, d = c]; _i < _a.length; _i++) {
kowloona = _a[_i];
}
@@ -0,0 +1,37 @@
=== tests/cases/compiler/assignmentNestedInLiterals.ts ===
var target, x, y;
>target : Symbol(target, Decl(assignmentNestedInLiterals.ts, 0, 3))
>x : Symbol(x, Decl(assignmentNestedInLiterals.ts, 0, 11))
>y : Symbol(y, Decl(assignmentNestedInLiterals.ts, 0, 14))
target = [x = 1, y = x];
>target : Symbol(target, Decl(assignmentNestedInLiterals.ts, 0, 3))
>x : Symbol(x, Decl(assignmentNestedInLiterals.ts, 0, 11))
>y : Symbol(y, Decl(assignmentNestedInLiterals.ts, 0, 14))
>x : Symbol(x, Decl(assignmentNestedInLiterals.ts, 0, 11))
var aegis, a, b;
>aegis : Symbol(aegis, Decl(assignmentNestedInLiterals.ts, 3, 3))
>a : Symbol(a, Decl(assignmentNestedInLiterals.ts, 3, 10))
>b : Symbol(b, Decl(assignmentNestedInLiterals.ts, 3, 13))
aegis = { x: a = 1, y: b = a };
>aegis : Symbol(aegis, Decl(assignmentNestedInLiterals.ts, 3, 3))
>x : Symbol(x, Decl(assignmentNestedInLiterals.ts, 4, 9))
>a : Symbol(a, Decl(assignmentNestedInLiterals.ts, 3, 10))
>y : Symbol(y, Decl(assignmentNestedInLiterals.ts, 4, 19))
>b : Symbol(b, Decl(assignmentNestedInLiterals.ts, 3, 13))
>a : Symbol(a, Decl(assignmentNestedInLiterals.ts, 3, 10))
var kowloona, c, d;
>kowloona : Symbol(kowloona, Decl(assignmentNestedInLiterals.ts, 6, 3))
>c : Symbol(c, Decl(assignmentNestedInLiterals.ts, 6, 13))
>d : Symbol(d, Decl(assignmentNestedInLiterals.ts, 6, 16))
for (kowloona of [c = 1, d = c]) {
>kowloona : Symbol(kowloona, Decl(assignmentNestedInLiterals.ts, 6, 3))
>c : Symbol(c, Decl(assignmentNestedInLiterals.ts, 6, 13))
>d : Symbol(d, Decl(assignmentNestedInLiterals.ts, 6, 16))
>c : Symbol(c, Decl(assignmentNestedInLiterals.ts, 6, 13))
}
@@ -0,0 +1,51 @@
=== tests/cases/compiler/assignmentNestedInLiterals.ts ===
var target, x, y;
>target : any
>x : any
>y : any
target = [x = 1, y = x];
>target = [x = 1, y = x] : number[]
>target : any
>[x = 1, y = x] : number[]
>x = 1 : 1
>x : any
>1 : 1
>y = x : number
>y : any
>x : number
var aegis, a, b;
>aegis : any
>a : any
>b : any
aegis = { x: a = 1, y: b = a };
>aegis = { x: a = 1, y: b = a } : { x: number; y: number; }
>aegis : any
>{ x: a = 1, y: b = a } : { x: number; y: number; }
>x : number
>a = 1 : 1
>a : any
>1 : 1
>y : number
>b = a : number
>b : any
>a : number
var kowloona, c, d;
>kowloona : any
>c : any
>d : any
for (kowloona of [c = 1, d = c]) {
>kowloona : any
>[c = 1, d = c] : number[]
>c = 1 : 1
>c : any
>1 : 1
>d = c : number
>d : any
>c : number
}
@@ -103,17 +103,17 @@ var r6 = foo6(1);
>1 : 1
function foo7(x) {
>foo7 : (x: any) => string
>foo7 : (x: any) => "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : any
return typeof x;
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : any
}
var r7 = foo7(1);
>r7 : string
>foo7(1) : string
>foo7 : (x: any) => string
>r7 : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>foo7(1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>foo7 : (x: any) => "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>1 : 1
// object types
@@ -0,0 +1,52 @@
//// [capturedLetConstInLoop13.ts]
class Main {
constructor() {
this.register("a", "b", "c");
}
private register(...names: string[]): void {
for (let name of names) {
this.bar({
[name + ".a"]: () => { this.foo(name); },
});
}
}
private bar(a: any): void { }
private foo(name: string): void { }
}
new Main();
//// [capturedLetConstInLoop13.js]
var Main = (function () {
function Main() {
this.register("a", "b", "c");
}
Main.prototype.register = function () {
var _this = this;
var names = [];
for (var _i = 0; _i < arguments.length; _i++) {
names[_i] = arguments[_i];
}
var _loop_1 = function (name) {
this_1.bar((_a = {},
_a[name + ".a"] = function () { _this.foo(name); },
_a));
var _a;
};
var this_1 = this;
for (var _a = 0, names_1 = names; _a < names_1.length; _a++) {
var name = names_1[_a];
_loop_1(name);
}
};
Main.prototype.bar = function (a) { };
Main.prototype.foo = function (name) { };
return Main;
}());
new Main();
@@ -0,0 +1,48 @@
=== tests/cases/compiler/capturedLetConstInLoop13.ts ===
class Main {
>Main : Symbol(Main, Decl(capturedLetConstInLoop13.ts, 0, 0))
constructor() {
this.register("a", "b", "c");
>this.register : Symbol(Main.register, Decl(capturedLetConstInLoop13.ts, 4, 5))
>this : Symbol(Main, Decl(capturedLetConstInLoop13.ts, 0, 0))
>register : Symbol(Main.register, Decl(capturedLetConstInLoop13.ts, 4, 5))
}
private register(...names: string[]): void {
>register : Symbol(Main.register, Decl(capturedLetConstInLoop13.ts, 4, 5))
>names : Symbol(names, Decl(capturedLetConstInLoop13.ts, 6, 21))
for (let name of names) {
>name : Symbol(name, Decl(capturedLetConstInLoop13.ts, 7, 16))
>names : Symbol(names, Decl(capturedLetConstInLoop13.ts, 6, 21))
this.bar({
>this.bar : Symbol(Main.bar, Decl(capturedLetConstInLoop13.ts, 13, 5))
>this : Symbol(Main, Decl(capturedLetConstInLoop13.ts, 0, 0))
>bar : Symbol(Main.bar, Decl(capturedLetConstInLoop13.ts, 13, 5))
[name + ".a"]: () => { this.foo(name); },
>name : Symbol(name, Decl(capturedLetConstInLoop13.ts, 7, 16))
>this.foo : Symbol(Main.foo, Decl(capturedLetConstInLoop13.ts, 15, 33))
>this : Symbol(Main, Decl(capturedLetConstInLoop13.ts, 0, 0))
>foo : Symbol(Main.foo, Decl(capturedLetConstInLoop13.ts, 15, 33))
>name : Symbol(name, Decl(capturedLetConstInLoop13.ts, 7, 16))
});
}
}
private bar(a: any): void { }
>bar : Symbol(Main.bar, Decl(capturedLetConstInLoop13.ts, 13, 5))
>a : Symbol(a, Decl(capturedLetConstInLoop13.ts, 15, 16))
private foo(name: string): void { }
>foo : Symbol(Main.foo, Decl(capturedLetConstInLoop13.ts, 15, 33))
>name : Symbol(name, Decl(capturedLetConstInLoop13.ts, 17, 16))
}
new Main();
>Main : Symbol(Main, Decl(capturedLetConstInLoop13.ts, 0, 0))
@@ -0,0 +1,59 @@
=== tests/cases/compiler/capturedLetConstInLoop13.ts ===
class Main {
>Main : Main
constructor() {
this.register("a", "b", "c");
>this.register("a", "b", "c") : void
>this.register : (...names: string[]) => void
>this : this
>register : (...names: string[]) => void
>"a" : "a"
>"b" : "b"
>"c" : "c"
}
private register(...names: string[]): void {
>register : (...names: string[]) => void
>names : string[]
for (let name of names) {
>name : string
>names : string[]
this.bar({
>this.bar({ [name + ".a"]: () => { this.foo(name); }, }) : void
>this.bar : (a: any) => void
>this : this
>bar : (a: any) => void
>{ [name + ".a"]: () => { this.foo(name); }, } : { [x: string]: () => void; }
[name + ".a"]: () => { this.foo(name); },
>name + ".a" : string
>name : string
>".a" : ".a"
>() => { this.foo(name); } : () => void
>this.foo(name) : void
>this.foo : (name: string) => void
>this : this
>foo : (name: string) => void
>name : string
});
}
}
private bar(a: any): void { }
>bar : (a: any) => void
>a : any
private foo(name: string): void { }
>foo : (name: string) => void
>name : string
}
new Main();
>new Main() : Main
>Main : typeof Main
@@ -182,7 +182,7 @@ declare var A;
>(<any>typeof A).x : any
>(<any>typeof A) : any
><any>typeof A : any
>typeof A : string
>typeof A : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>A : any
>x : any
+2 -2
View File
@@ -8,7 +8,7 @@ async function f() {
>0 : 0
typeof await 0;
>typeof await 0 : string
>typeof await 0 : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>await 0 : 0
>0 : 0
@@ -21,7 +21,7 @@ async function f() {
>await void <string> typeof <number> void await 0 : undefined
>void <string> typeof <number> void await 0 : undefined
><string> typeof <number> void await 0 : string
>typeof <number> void await 0 : string
>typeof <number> void await 0 : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
><number> void await 0 : number
>void await 0 : undefined
>await 0 : 0
@@ -5,7 +5,7 @@ var x: StringTree;
if (typeof x !== "string") {
>typeof x !== "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : StringTree
>"string" : "string"
@@ -0,0 +1,24 @@
//// [commentLeadingCloseBrace.ts]
declare function commentedParameters(...args): any;
function ifelse() {
if (commentedParameters(1, 2)) {
/*comment1*/
commentedParameters(3, 4);
/*comment2*/
} else {
commentedParameters(5, 6);
}
}
//// [commentLeadingCloseBrace.js]
function ifelse() {
if (commentedParameters(1, 2)) {
/*comment1*/
commentedParameters(3, 4);
/*comment2*/
}
else {
commentedParameters(5, 6);
}
}
@@ -0,0 +1,21 @@
=== tests/cases/compiler/commentLeadingCloseBrace.ts ===
declare function commentedParameters(...args): any;
>commentedParameters : Symbol(commentedParameters, Decl(commentLeadingCloseBrace.ts, 0, 0))
>args : Symbol(args, Decl(commentLeadingCloseBrace.ts, 0, 37))
function ifelse() {
>ifelse : Symbol(ifelse, Decl(commentLeadingCloseBrace.ts, 0, 51))
if (commentedParameters(1, 2)) {
>commentedParameters : Symbol(commentedParameters, Decl(commentLeadingCloseBrace.ts, 0, 0))
/*comment1*/
commentedParameters(3, 4);
>commentedParameters : Symbol(commentedParameters, Decl(commentLeadingCloseBrace.ts, 0, 0))
/*comment2*/
} else {
commentedParameters(5, 6);
>commentedParameters : Symbol(commentedParameters, Decl(commentLeadingCloseBrace.ts, 0, 0))
}
}
@@ -0,0 +1,30 @@
=== tests/cases/compiler/commentLeadingCloseBrace.ts ===
declare function commentedParameters(...args): any;
>commentedParameters : (...args: any[]) => any
>args : any[]
function ifelse() {
>ifelse : () => void
if (commentedParameters(1, 2)) {
>commentedParameters(1, 2) : any
>commentedParameters : (...args: any[]) => any
>1 : 1
>2 : 2
/*comment1*/
commentedParameters(3, 4);
>commentedParameters(3, 4) : any
>commentedParameters : (...args: any[]) => any
>3 : 3
>4 : 4
/*comment2*/
} else {
commentedParameters(5, 6);
>commentedParameters(5, 6) : any
>commentedParameters : (...args: any[]) => any
>5 : 5
>6 : 6
}
}
@@ -0,0 +1,17 @@
//// [commentOnArrayElement1.ts]
var array = [
/* element 1*/
1
/* end of element 1 */,
2
/* end of element 2 */
];
//// [commentOnArrayElement1.js]
var array = [
/* element 1*/
1
/* end of element 1 */ ,
2
/* end of element 2 */
];
@@ -0,0 +1,10 @@
=== tests/cases/compiler/commentOnArrayElement1.ts ===
var array = [
>array : Symbol(array, Decl(commentOnArrayElement1.ts, 0, 3))
/* element 1*/
1
/* end of element 1 */,
2
/* end of element 2 */
];
@@ -0,0 +1,15 @@
=== tests/cases/compiler/commentOnArrayElement1.ts ===
var array = [
>array : number[]
>[ /* element 1*/ 1 /* end of element 1 */, 2 /* end of element 2 */] : number[]
/* element 1*/
1
>1 : 1
/* end of element 1 */,
2
>2 : 2
/* end of element 2 */
];
@@ -0,0 +1,15 @@
//// [commentOnArrayElement2.ts]
var array = [
/* element 1*/
1 /* end of element 1 */,
2
/* end of element 2 */
];
//// [commentOnArrayElement2.js]
var array = [
/* element 1*/
1 /* end of element 1 */,
2
/* end of element 2 */
];
@@ -0,0 +1,9 @@
=== tests/cases/compiler/commentOnArrayElement2.ts ===
var array = [
>array : Symbol(array, Decl(commentOnArrayElement2.ts, 0, 3))
/* element 1*/
1 /* end of element 1 */,
2
/* end of element 2 */
];
@@ -0,0 +1,14 @@
=== tests/cases/compiler/commentOnArrayElement2.ts ===
var array = [
>array : number[]
>[ /* element 1*/ 1 /* end of element 1 */, 2 /* end of element 2 */] : number[]
/* element 1*/
1 /* end of element 1 */,
>1 : 1
2
>2 : 2
/* end of element 2 */
];
@@ -0,0 +1,19 @@
//// [commentOnArrayElement3.ts]
var array = [
/* element 1*/
1
/* end of element 1 */,
2
/* end of element 2 */, ,
/* extra comment */
];
//// [commentOnArrayElement3.js]
var array = [
/* element 1*/
1
/* end of element 1 */ ,
2
/* end of element 2 */ ,
,
];
@@ -0,0 +1,11 @@
=== tests/cases/compiler/commentOnArrayElement3.ts ===
var array = [
>array : Symbol(array, Decl(commentOnArrayElement3.ts, 0, 3))
/* element 1*/
1
/* end of element 1 */,
2
/* end of element 2 */, ,
/* extra comment */
];
@@ -0,0 +1,18 @@
=== tests/cases/compiler/commentOnArrayElement3.ts ===
var array = [
>array : number[]
>[ /* element 1*/ 1 /* end of element 1 */, 2 /* end of element 2 */, , /* extra comment */] : number[]
/* element 1*/
1
>1 : 1
/* end of element 1 */,
2
>2 : 2
/* end of element 2 */, ,
> : undefined
/* extra comment */
];
@@ -0,0 +1,20 @@
//// [commentOnParameter1.ts]
function commentedParameters(
/* Parameter a */
a
/* End of parameter a */
/* Parameter b */
,
b
/* End of parameter b */
){}
//// [commentOnParameter1.js]
function commentedParameters(
/* Parameter a */
a
/* End of parameter a */
/* Parameter b */
, b
/* End of parameter b */
) { }
@@ -0,0 +1,16 @@
=== tests/cases/compiler/commentOnParameter1.ts ===
function commentedParameters(
>commentedParameters : Symbol(commentedParameters, Decl(commentOnParameter1.ts, 0, 0))
/* Parameter a */
a
>a : Symbol(a, Decl(commentOnParameter1.ts, 0, 29))
/* End of parameter a */
/* Parameter b */
,
b
>b : Symbol(b, Decl(commentOnParameter1.ts, 5, 1))
/* End of parameter b */
){}
@@ -0,0 +1,16 @@
=== tests/cases/compiler/commentOnParameter1.ts ===
function commentedParameters(
>commentedParameters : (a: any, b: any) => void
/* Parameter a */
a
>a : any
/* End of parameter a */
/* Parameter b */
,
b
>b : any
/* End of parameter b */
){}
@@ -0,0 +1,18 @@
//// [commentOnParameter2.ts]
function commentedParameters(
/* Parameter a */
a /* End of parameter a */
/* Parameter b */
,
b
/* End of parameter b */
){}
//// [commentOnParameter2.js]
function commentedParameters(
/* Parameter a */
a /* End of parameter a */
/* Parameter b */
, b
/* End of parameter b */
) { }
@@ -0,0 +1,15 @@
=== tests/cases/compiler/commentOnParameter2.ts ===
function commentedParameters(
>commentedParameters : Symbol(commentedParameters, Decl(commentOnParameter2.ts, 0, 0))
/* Parameter a */
a /* End of parameter a */
>a : Symbol(a, Decl(commentOnParameter2.ts, 0, 29))
/* Parameter b */
,
b
>b : Symbol(b, Decl(commentOnParameter2.ts, 4, 1))
/* End of parameter b */
){}
@@ -0,0 +1,15 @@
=== tests/cases/compiler/commentOnParameter2.ts ===
function commentedParameters(
>commentedParameters : (a: any, b: any) => void
/* Parameter a */
a /* End of parameter a */
>a : any
/* Parameter b */
,
b
>b : any
/* End of parameter b */
){}
@@ -0,0 +1,9 @@
//// [commentOnParameter3.ts]
function commentedParameters(
a /* parameter a */,
b /* parameter b */,
/* extra comment */
) { }
//// [commentOnParameter3.js]
function commentedParameters(a /* parameter a */, b /* parameter b */) { }
@@ -0,0 +1,12 @@
=== tests/cases/compiler/commentOnParameter3.ts ===
function commentedParameters(
>commentedParameters : Symbol(commentedParameters, Decl(commentOnParameter3.ts, 0, 0))
a /* parameter a */,
>a : Symbol(a, Decl(commentOnParameter3.ts, 0, 29))
b /* parameter b */,
>b : Symbol(b, Decl(commentOnParameter3.ts, 1, 20))
/* extra comment */
) { }
@@ -0,0 +1,12 @@
=== tests/cases/compiler/commentOnParameter3.ts ===
function commentedParameters(
>commentedParameters : (a: any, b: any) => void
a /* parameter a */,
>a : any
b /* parameter b */,
>b : any
/* extra comment */
) { }
@@ -27,4 +27,5 @@ exports.C1 = C1;
"use strict";
var foo = require("./foo_0");
if (foo.C1.s1) {
// Should cause runtime import
}
@@ -120,7 +120,7 @@ true ? exprString1 : exprBoolean1; // union
typeof "123" == "string" ? exprBoolean1 : exprBoolean2;
>typeof "123" == "string" ? exprBoolean1 : exprBoolean2 : boolean
>typeof "123" == "string" : boolean
>typeof "123" : string
>typeof "123" : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>"123" : "123"
>"string" : "string"
>exprBoolean1 : boolean
@@ -262,7 +262,7 @@ var resultIsBoolean3 = typeof "123" == "string" ? exprBoolean1 : exprBoolean2;
>resultIsBoolean3 : boolean
>typeof "123" == "string" ? exprBoolean1 : exprBoolean2 : boolean
>typeof "123" == "string" : boolean
>typeof "123" : string
>typeof "123" : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>"123" : "123"
>"string" : "string"
>exprBoolean1 : boolean
@@ -299,7 +299,7 @@ var resultIsStringOrBoolean4 = typeof "123" === "string" ? exprString1 : exprBoo
>resultIsStringOrBoolean4 : string | boolean
>typeof "123" === "string" ? exprString1 : exprBoolean1 : string | boolean
>typeof "123" === "string" : boolean
>typeof "123" : string
>typeof "123" : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>"123" : "123"
>"string" : "string"
>exprString1 : string
@@ -123,7 +123,7 @@ var array = ["1", "2", "3"];
typeof condString ? exprAny1 : exprAny2;
>typeof condString ? exprAny1 : exprAny2 : any
>typeof condString : string
>typeof condString : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>condString : string
>exprAny1 : any
>exprAny2 : any
@@ -254,7 +254,7 @@ var resultIsStringOrBoolean2 = "hello" ? exprString1 : exprBoolean1; // union
var resultIsAny3 = typeof condString ? exprAny1 : exprAny2;
>resultIsAny3 : any
>typeof condString ? exprAny1 : exprAny2 : any
>typeof condString : string
>typeof condString : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>condString : string
>exprAny1 : any
>exprAny2 : any
@@ -297,7 +297,7 @@ var resultIsObject3 = array[1] ? exprIsObject1 : exprIsObject2;
var resultIsStringOrBoolean3 = typeof condString ? exprString1 : exprBoolean1; // union
>resultIsStringOrBoolean3 : string | boolean
>typeof condString ? exprString1 : exprBoolean1 : string | boolean
>typeof condString : string
>typeof condString : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>condString : string
>exprString1 : string
>exprBoolean1 : boolean
@@ -12,7 +12,7 @@ function f1() {
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | number
>"string" : "string"
@@ -35,7 +35,7 @@ function f2() {
if (typeof x !== "string") {
>typeof x !== "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | number
>"string" : "string"
@@ -59,7 +59,7 @@ function f3() {
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | number
>"string" : "string"
@@ -82,7 +82,7 @@ function f4() {
if (typeof x !== "string") {
>typeof x !== "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | number
>"string" : "string"
@@ -106,7 +106,7 @@ function f5() {
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | number
>"string" : "string"
@@ -17,7 +17,7 @@ function f(x: string | number | boolean) {
>y : string | number | boolean
>"" : ""
>typeof x === "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | number | boolean
>"string" : "string"
@@ -36,7 +36,7 @@ function f(x: string | number | boolean) {
>z : string | number | boolean
>1 : 1
>typeof x === "number" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : number | boolean
>"number" : "number"
@@ -66,7 +66,7 @@ function c() {
if (typeof x === "string") continue;
>typeof x === "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | number
>"string" : "string"
@@ -82,7 +82,7 @@ function d() {
>x : string | number | boolean
>"" : ""
>typeof x === "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | number
>"string" : "string"
>x = 5 : 5
@@ -107,7 +107,7 @@ function e() {
>"" : ""
>0 : 0
>typeof x !== "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : number | true
>"string" : "string"
>x = "" || true : true
@@ -128,7 +128,7 @@ function f() {
for (; typeof x !== "string";) {
>typeof x !== "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | number | boolean
>"string" : "string"
@@ -137,7 +137,7 @@ function f() {
if (typeof x === "number") break;
>typeof x === "number" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : number | boolean
>"number" : "number"
@@ -13,7 +13,7 @@ function f1() {
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | number
>"string" : "string"
@@ -41,7 +41,7 @@ function f2() {
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | number
>"string" : "string"
@@ -73,7 +73,7 @@ function f3() {
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | number
>"string" : "string"
@@ -100,7 +100,7 @@ function c<T>(data: string | T): T {
if (typeof data === 'string') {
>typeof data === 'string' : boolean
>typeof data : string
>typeof data : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>data : string | T
>'string' : "string"
@@ -124,7 +124,7 @@ function d<T extends string>(data: string | T): never {
if (typeof data === 'string') {
>typeof data === 'string' : boolean
>typeof data : string
>typeof data : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>data : string | T
>'string' : "string"
@@ -69,7 +69,7 @@ function c() {
if (typeof x === "string") continue;
>typeof x === "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | number
>"string" : "string"
@@ -16,7 +16,7 @@ function foo1() {
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | number
>"string" : "string"
@@ -49,7 +49,7 @@ function foo2() {
if (typeof x === "number") {
>typeof x === "number" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | number
>"number" : "number"
@@ -7,7 +7,7 @@ export function f(x: any): x is number {
return typeof x === "number";
>typeof x === "number" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : any
>"number" : "number"
}
@@ -30,7 +30,7 @@ function f1(x: Foo | Bar | string) {
if (typeof x !== 'string') {
>typeof x !== 'string' : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | Foo | Bar
>'string' : "string"
@@ -58,7 +58,7 @@ function f2(x: Foo | Bar | string | undefined) {
if (typeof x === "object") {
>typeof x === "object" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | Foo | Bar | undefined
>"object" : "object"
@@ -89,7 +89,7 @@ function f3(x: Foo | Bar | string | null) {
>x && typeof x !== "string" : boolean | "" | null
>x : string | Foo | Bar | null
>typeof x !== "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | Foo | Bar
>"string" : "string"
@@ -120,7 +120,7 @@ function f4(x: Foo | Bar | string | number | null) {
>x && typeof x === "object" : boolean | "" | 0 | null
>x : string | number | Foo | Bar | null
>typeof x === "object" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : string | number | Foo | Bar
>"object" : "object"
@@ -391,6 +391,7 @@ var TestRunner = (function () {
}
}
if (testResult === false) {
//console.log(e.message);
}
}
if ((testcase.errorMessageRegEx !== undefined) && !exception) {
@@ -64,7 +64,7 @@ var s;
`${typeof (t1 ** t2 ** t1) } world`;
>`${typeof (t1 ** t2 ** t1) } world` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -162,14 +162,14 @@ var s;
`${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}`;
>`${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
>t2 ** t1 : number
>t2 : number
>t1 : number
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -223,7 +223,7 @@ var s;
`hello ${typeof (t1 ** t2 ** t1)}`;
>`hello ${typeof (t1 ** t2 ** t1)}` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -64,7 +64,7 @@ var s;
`${typeof (t1 ** t2 ** t1) } world`;
>`${typeof (t1 ** t2 ** t1) } world` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -162,14 +162,14 @@ var s;
`${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}`;
>`${typeof (t1 ** t2 ** t1)} hello world ${typeof (t1 ** t2 ** t1)}` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
>t2 ** t1 : number
>t2 : number
>t1 : number
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -223,7 +223,7 @@ var s;
`hello ${typeof (t1 ** t2 ** t1)}`;
>`hello ${typeof (t1 ** t2 ** t1)}` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -54,7 +54,7 @@ var s;
`${typeof (t1 ** t2 ** t1) }`;
>`${typeof (t1 ** t2 ** t1) }` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -66,7 +66,7 @@ var s;
>`${1 + typeof (t1 ** t2 ** t1) }` : string
>1 + typeof (t1 ** t2 ** t1) : string
>1 : 1
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -141,14 +141,14 @@ var s;
`${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}`;
>`${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
>t2 ** t1 : number
>t2 : number
>t1 : number
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -223,14 +223,14 @@ var s;
`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
>`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
>t2 ** t1 : number
>t2 : number
>t1 : number
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -54,7 +54,7 @@ var s;
`${typeof (t1 ** t2 ** t1) }`;
>`${typeof (t1 ** t2 ** t1) }` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -66,7 +66,7 @@ var s;
>`${1 + typeof (t1 ** t2 ** t1) }` : string
>1 + typeof (t1 ** t2 ** t1) : string
>1 : 1
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -141,14 +141,14 @@ var s;
`${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}`;
>`${typeof (t1 ** t2 ** t1)}${typeof (t1 ** t2 ** t1)}` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
>t2 ** t1 : number
>t2 : number
>t1 : number
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -223,14 +223,14 @@ var s;
`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
>`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
>t2 ** t1 : number
>t2 : number
>t1 : number
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -54,7 +54,7 @@ var s;
`hello ${typeof (t1 ** t2 ** t1) }`;
>`hello ${typeof (t1 ** t2 ** t1) }` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -66,7 +66,7 @@ var s;
>`hello ${1 + typeof (t1 ** t2 ** t1) }` : string
>1 + typeof (t1 ** t2 ** t1) : string
>1 : 1
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -141,14 +141,14 @@ var s;
`hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }`;
>`hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
>t2 ** t1 : number
>t2 : number
>t1 : number
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -223,14 +223,14 @@ var s;
`hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
>`hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
>t2 ** t1 : number
>t2 : number
>t1 : number
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -54,7 +54,7 @@ var s;
`hello ${typeof (t1 ** t2 ** t1) }`;
>`hello ${typeof (t1 ** t2 ** t1) }` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -66,7 +66,7 @@ var s;
>`hello ${1 + typeof (t1 ** t2 ** t1) }` : string
>1 + typeof (t1 ** t2 ** t1) : string
>1 : 1
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -141,14 +141,14 @@ var s;
`hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }`;
>`hello ${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) }` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
>t2 ** t1 : number
>t2 : number
>t1 : number
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -223,14 +223,14 @@ var s;
`hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }`;
>`hello ${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1) }` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
>t2 ** t1 : number
>t2 : number
>t1 : number
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -54,7 +54,7 @@ var s;
`${typeof (t1 ** t2 ** t1) } world`;
>`${typeof (t1 ** t2 ** t1) } world` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -66,7 +66,7 @@ var s;
>`${1 + typeof (t1 ** t2 ** t1) } world` : string
>1 + typeof (t1 ** t2 ** t1) : string
>1 : 1
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -141,14 +141,14 @@ var s;
`${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world`;
>`${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
>t2 ** t1 : number
>t2 : number
>t1 : number
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -223,14 +223,14 @@ var s;
`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!`;
>`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
>t2 ** t1 : number
>t2 : number
>t1 : number
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -54,7 +54,7 @@ var s;
`${typeof (t1 ** t2 ** t1) } world`;
>`${typeof (t1 ** t2 ** t1) } world` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -66,7 +66,7 @@ var s;
>`${1 + typeof (t1 ** t2 ** t1) } world` : string
>1 + typeof (t1 ** t2 ** t1) : string
>1 : 1
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -141,14 +141,14 @@ var s;
`${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world`;
>`${typeof (t1 ** t2 ** t1) }${typeof (t1 ** t2 ** t1) } world` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
>t2 ** t1 : number
>t2 : number
>t1 : number
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -223,14 +223,14 @@ var s;
`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!`;
>`${typeof (t1 ** t2 ** t1) } hello world ${typeof (t1 ** t2 ** t1)} !!` : string
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
>t2 ** t1 : number
>t2 : number
>t1 : number
>typeof (t1 ** t2 ** t1) : string
>typeof (t1 ** t2 ** t1) : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>(t1 ** t2 ** t1) : number
>t1 ** t2 ** t1 : number
>t1 : number
@@ -0,0 +1,27 @@
tests/cases/compiler/forwardRefInClassProperties.ts(3,15): error TS2448: Block-scoped variable '_a' used before its declaration.
tests/cases/compiler/forwardRefInClassProperties.ts(6,22): error TS2448: Block-scoped variable '_A' used before its declaration.
tests/cases/compiler/forwardRefInClassProperties.ts(11,17): error TS2448: Block-scoped variable 'b' used before its declaration.
==== tests/cases/compiler/forwardRefInClassProperties.ts (3 errors) ====
class Test
{
_b = this._a; // undefined, no error/warning
~~
!!! error TS2448: Block-scoped variable '_a' used before its declaration.
_a = 3;
static _B = Test._A; // undefined, no error/warning
~~
!!! error TS2448: Block-scoped variable '_A' used before its declaration.
static _A = 3;
method()
{
let a = b; // Block-scoped variable 'b' used before its declaration
~
!!! error TS2448: Block-scoped variable 'b' used before its declaration.
let b = 3;
}
}
@@ -0,0 +1,31 @@
//// [forwardRefInClassProperties.ts]
class Test
{
_b = this._a; // undefined, no error/warning
_a = 3;
static _B = Test._A; // undefined, no error/warning
static _A = 3;
method()
{
let a = b; // Block-scoped variable 'b' used before its declaration
let b = 3;
}
}
//// [forwardRefInClassProperties.js]
var Test = (function () {
function Test() {
this._b = this._a; // undefined, no error/warning
this._a = 3;
}
Test.prototype.method = function () {
var a = b; // Block-scoped variable 'b' used before its declaration
var b = 3;
};
return Test;
}());
Test._B = Test._A; // undefined, no error/warning
Test._A = 3;
@@ -5,7 +5,7 @@ var x: StringTree;
if (typeof x !== "string") {
>typeof x !== "string" : boolean
>typeof x : string
>typeof x : "string" | "number" | "boolean" | "symbol" | "undefined" | "object" | "function"
>x : StringTree
>"string" : "string"
@@ -227,9 +227,9 @@ function getValueAsString(value: IntersectionFail): string {
if (value.kind === 'int') {
>value.kind === 'int' : boolean
>value.kind : "int" | "string"
>value.kind : "string" | "int"
>value : IntersectionFail
>kind : "int" | "string"
>kind : "string" | "int"
>'int' : "int"
return '' + value.num;
@@ -0,0 +1,17 @@
tests/cases/compiler/bar.ts(2,1): error TS2322: Type '"string"' is not assignable to type 'number'.
==== tests/cases/compiler/foo.js (0 errors) ====
class C {
constructor () {
this.p = 0;
}
}
==== tests/cases/compiler/bar.ts (1 errors) ====
(new C()).p = "string";
~~~~~~~~~~~
!!! error TS2322: Type '"string"' is not assignable to type 'number'.
Loaded 100 of 356 files, more files were not shown because too many files have changed in this diff. Show more