Microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2025-11-18 17:21:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/transforms' into fixLocationOfSuperCall

Browse Source
This commit is contained in:
Vladimir Matveev
2016-04-13 14:03:36 -07:00
parent 83334fac18 012d1118a5
commit 936ee66f7d
181 changed files with 991 additions and 812 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitignore
+1
View File
@@ -7,6 +7,7 @@ tests/cases/perf/*
test-args.txt
~*.docx
tests/baselines/local/*
tests/baselines/local.old/*
tests/services/baselines/local/*
tests/baselines/prototyping/local/*
tests/baselines/rwc/*
Jakefile.js
+20 -6
View File
@@ -309,7 +309,7 @@ function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, opts
options += " --stripInternal";
}
if (useBuiltCompiler && !/^(no?|f(alse)?|0|-)$/i.test(process.env.USE_TRANSFORMS)) {
if (useBuiltCompiler && !environmentVariableIsDisabled("USE_TRANSFORMS")) {
console.warn("\u001b[93mwarning: 'USE_TRANSFORMS' environment variable is not set to 'false'. Experimental transforms will be enabled by default.\u001b[0m");
}
@@ -826,14 +826,17 @@ function runTestsAndWriteOutput(file) {
});
}
function runConsoleTests(defaultReporter, defaultSubsets) {
cleanTestDirs();
function runConsoleTests(defaultReporter, defaultSubsets, dirty) {
if (!dirty) {
cleanTestDirs();
}
var debug = process.env.debug || process.env.d;
tests = process.env.test || process.env.tests || process.env.t;
var light = process.env.light || false;
var stackTraceLimit = process.env.stackTraceLimit || 1;
var testConfigFile = 'test.config';
if(fs.existsSync(testConfigFile)) {
if (fs.existsSync(testConfigFile)) {
fs.unlinkSync(testConfigFile);
}
@@ -866,7 +869,7 @@ function runConsoleTests(defaultReporter, defaultSubsets) {
console.log(cmd);
exec(cmd, function () {
deleteTemporaryProjectOutput();
if (i === 0) {
if (i === 0 && !dirty) {
var lint = jake.Task['lint'];
lint.addListener('complete', function () {
complete();
@@ -894,6 +897,9 @@ task("runtests", ["build-rules", "tests", builtLocalDirectory], function() {
task("runtests-file", ["build-rules", "tests", builtLocalDirectory], function () {
runTestsAndWriteOutput("tests/baselines/local/testresults.tap");
}, { async: true });
task("runtests-dirty", ["build-rules", "tests", builtLocalDirectory], function () {
runConsoleTests("mocha-fivemat-progress-reporter", [], /*dirty*/ true);
}, { async: true });
desc("Generates code coverage data via instanbul");
task("generate-code-coverage", ["tests", builtLocalDirectory], function () {
@@ -1258,4 +1264,12 @@ ProgressBar.prototype = {
this._lastProgress = progress;
this.visible = true;
}
};
};
function environmentVariableIsEnabled(name) {
return /^(y(es)?|t(rue)?|on|enabled?|1|\+)$/.test(process.env[name]);
}
function environmentVariableIsDisabled(name) {
return /^(no?|f(alse)?|off|disabled?|0|-)$/.test(process.env[name]);
}
src/compiler/checker.ts
+90 -39
View File
@@ -1118,7 +1118,7 @@ namespace ts {
}
// Resolves a qualified name and any involved aliases
function resolveEntityName(name: EntityName | Expression, meaning: SymbolFlags, ignoreErrors?: boolean): Symbol {
function resolveEntityName(name: EntityName | Expression, meaning: SymbolFlags, ignoreErrors?: boolean, location?: Node): Symbol {
if (nodeIsMissing(name)) {
return undefined;
}
@@ -1127,7 +1127,7 @@ namespace ts {
if (name.kind === SyntaxKind.Identifier) {
const message = meaning === SymbolFlags.Namespace ? Diagnostics.Cannot_find_namespace_0 : Diagnostics.Cannot_find_name_0;
symbol = resolveName(name, (<Identifier>name).text, meaning, ignoreErrors ? undefined : message, <Identifier>name);
symbol = resolveName(location || name, (<Identifier>name).text, meaning, ignoreErrors ? undefined : message, <Identifier>name);
if (!symbol) {
return undefined;
}
@@ -1136,7 +1136,7 @@ namespace ts {
const left = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).left : (<PropertyAccessExpression>name).expression;
const right = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).right : (<PropertyAccessExpression>name).name;
const namespace = resolveEntityName(left, SymbolFlags.Namespace, ignoreErrors);
const namespace = resolveEntityName(left, SymbolFlags.Namespace, ignoreErrors, location);
if (!namespace || namespace === unknownSymbol || nodeIsMissing(right)) {
return undefined;
}
@@ -16042,7 +16042,14 @@ namespace ts {
// Emitter support
function isArgumentsLocalBinding(node: Identifier): boolean {
return getReferencedValueSymbol(node) === argumentsSymbol;
if (!isGeneratedIdentifier(node)) {
node = getSourceTreeNodeOfType(node, isIdentifier);
if (node) {
return getReferencedValueSymbol(node) === argumentsSymbol;
}
}
return false;
}
function moduleExportsSomeValue(moduleReferenceExpression: Expression): boolean {
@@ -16077,37 +16084,49 @@ namespace ts {
// When resolved as an expression identifier, if the given node references an exported entity, return the declaration
// node of the exported entity's container. Otherwise, return undefined.
function getReferencedExportContainer(node: Identifier, prefixLocals?: boolean): SourceFile | ModuleDeclaration | EnumDeclaration {
let symbol = getReferencedValueSymbol(node);
if (symbol) {
if (symbol.flags & SymbolFlags.ExportValue) {
// If we reference an exported entity within the same module declaration, then whether
// we prefix depends on the kind of entity. SymbolFlags.ExportHasLocal encompasses all the
// kinds that we do NOT prefix.
const exportSymbol = getMergedSymbol(symbol.exportSymbol);
if (exportSymbol.flags & SymbolFlags.ExportHasLocal && !prefixLocals) {
return undefined;
node = getSourceTreeNodeOfType(node, isIdentifier);
if (node) {
let symbol = getReferencedValueSymbol(node);
if (symbol) {
if (symbol.flags & SymbolFlags.ExportValue) {
// If we reference an exported entity within the same module declaration, then whether
// we prefix depends on the kind of entity. SymbolFlags.ExportHasLocal encompasses all the
// kinds that we do NOT prefix.
const exportSymbol = getMergedSymbol(symbol.exportSymbol);
if (exportSymbol.flags & SymbolFlags.ExportHasLocal && !prefixLocals) {
return undefined;
}
symbol = exportSymbol;
}
symbol = exportSymbol;
}
const parentSymbol = getParentOfSymbol(symbol);
if (parentSymbol) {
if (parentSymbol.flags & SymbolFlags.ValueModule && parentSymbol.valueDeclaration.kind === SyntaxKind.SourceFile) {
return <SourceFile>parentSymbol.valueDeclaration;
}
for (let n = node.parent; n; n = n.parent) {
if ((n.kind === SyntaxKind.ModuleDeclaration || n.kind === SyntaxKind.EnumDeclaration) && getSymbolOfNode(n) === parentSymbol) {
return <ModuleDeclaration | EnumDeclaration>n;
const parentSymbol = getParentOfSymbol(symbol);
if (parentSymbol) {
if (parentSymbol.flags & SymbolFlags.ValueModule && parentSymbol.valueDeclaration.kind === SyntaxKind.SourceFile) {
return <SourceFile>parentSymbol.valueDeclaration;
}
for (let n = node.parent; n; n = n.parent) {
if ((n.kind === SyntaxKind.ModuleDeclaration || n.kind === SyntaxKind.EnumDeclaration) && getSymbolOfNode(n) === parentSymbol) {
return <ModuleDeclaration | EnumDeclaration>n;
}
}
}
}
}
return undefined;
}
// When resolved as an expression identifier, if the given node references an import, return the declaration of
// that import. Otherwise, return undefined.
function getReferencedImportDeclaration(node: Identifier): Declaration {
const symbol = getReferencedValueSymbol(node);
return symbol && symbol.flags & SymbolFlags.Alias ? getDeclarationOfAliasSymbol(symbol) : undefined;
node = getSourceTreeNodeOfType(node, isIdentifier);
if (node) {
const symbol = getReferencedValueSymbol(node);
if (symbol && symbol.flags & SymbolFlags.Alias) {
return getDeclarationOfAliasSymbol(symbol);
}
}
return undefined;
}
function isSymbolOfDeclarationWithCollidingName(symbol: Symbol): boolean {
@@ -16157,35 +16176,57 @@ namespace ts {
// a name that either hides an existing name or might hide it when compiled downlevel,
// return the declaration of that entity. Otherwise, return undefined.
function getReferencedDeclarationWithCollidingName(node: Identifier): Declaration {
const symbol = getReferencedValueSymbol(node);
return symbol && isSymbolOfDeclarationWithCollidingName(symbol) ? symbol.valueDeclaration : undefined;
if (!isGeneratedIdentifier(node)) {
node = getSourceTreeNodeOfType(node, isIdentifier);
if (node) {
const symbol = getReferencedValueSymbol(node);
if (symbol && isSymbolOfDeclarationWithCollidingName(symbol)) {
return symbol.valueDeclaration;
}
}
}
return undefined;
}
// Return true if the given node is a declaration of a nested block scoped entity with a name that either hides an
// existing name or might hide a name when compiled downlevel
function isDeclarationWithCollidingName(node: Declaration): boolean {
return isSymbolOfDeclarationWithCollidingName(getSymbolOfNode(node));
node = getSourceTreeNodeOfType(node, isDeclaration);
if (node) {
const symbol = getSymbolOfNode(node);
if (symbol) {
return isSymbolOfDeclarationWithCollidingName(symbol);
}
}
return false;
}
function isValueAliasDeclaration(node: Node): boolean {
node = getSourceTreeNode(node);
switch (node.kind) {
case SyntaxKind.ImportEqualsDeclaration:
case SyntaxKind.ImportClause:
case SyntaxKind.NamespaceImport:
case SyntaxKind.ImportSpecifier:
case SyntaxKind.ExportSpecifier:
return isAliasResolvedToValue(getSymbolOfNode(node));
return isAliasResolvedToValue(getSymbolOfNode(node) || unknownSymbol);
case SyntaxKind.ExportDeclaration:
const exportClause = (<ExportDeclaration>node).exportClause;
return exportClause && forEach(exportClause.elements, isValueAliasDeclaration);
case SyntaxKind.ExportAssignment:
return (<ExportAssignment>node).expression && (<ExportAssignment>node).expression.kind === SyntaxKind.Identifier ? isAliasResolvedToValue(getSymbolOfNode(node)) : true;
return (<ExportAssignment>node).expression
&& (<ExportAssignment>node).expression.kind === SyntaxKind.Identifier
? isAliasResolvedToValue(getSymbolOfNode(node) || unknownSymbol)
: true;
}
return false;
}
function isTopLevelValueImportEqualsWithEntityName(node: ImportEqualsDeclaration): boolean {
if (node.parent.kind !== SyntaxKind.SourceFile || !isInternalModuleImportEqualsDeclaration(node)) {
node = getSourceTreeNodeOfType(node, isImportEqualsDeclaration);
if (node === undefined || node.parent.kind !== SyntaxKind.SourceFile || !isInternalModuleImportEqualsDeclaration(node)) {
// parent is not source file or it is not reference to internal module
return false;
}
@@ -16212,9 +16253,10 @@ namespace ts {
}
function isReferencedAliasDeclaration(node: Node, checkChildren?: boolean): boolean {
node = getSourceTreeNode(node);
if (isAliasSymbolDeclaration(node)) {
const symbol = getSymbolOfNode(node);
if (getSymbolLinks(symbol).referenced) {
if (symbol && getSymbolLinks(symbol).referenced) {
return true;
}
}
@@ -16247,7 +16289,8 @@ namespace ts {
}
function getNodeCheckFlags(node: Node): NodeCheckFlags {
return getNodeLinks(node).flags;
node = getSourceTreeNode(node);
return node ? getNodeLinks(node).flags : undefined;
}
function getEnumMemberValue(node: EnumMember): number {
@@ -16275,16 +16318,16 @@ namespace ts {
return type.flags & TypeFlags.ObjectType && getSignaturesOfType(type, SignatureKind.Call).length > 0;
}
function getTypeReferenceSerializationKind(typeName: EntityName): TypeReferenceSerializationKind {
function getTypeReferenceSerializationKind(typeName: EntityName, location?: Node): TypeReferenceSerializationKind {
// Resolve the symbol as a value to ensure the type can be reached at runtime during emit.
const valueSymbol = resolveEntityName(typeName, SymbolFlags.Value, /*ignoreErrors*/ true);
const valueSymbol = resolveEntityName(typeName, SymbolFlags.Value, /*ignoreErrors*/ true, location);
const constructorType = valueSymbol ? getTypeOfSymbol(valueSymbol) : undefined;
if (constructorType && isConstructorType(constructorType)) {
return TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue;
}
// Resolve the symbol as a type so that we can provide a more useful hint for the type serializer.
const typeSymbol = resolveEntityName(typeName, SymbolFlags.Type, /*ignoreErrors*/ true);
const typeSymbol = resolveEntityName(typeName, SymbolFlags.Type, /*ignoreErrors*/ true, location);
// We might not be able to resolve type symbol so use unknown type in that case (eg error case)
if (!typeSymbol) {
return TypeReferenceSerializationKind.ObjectType;
@@ -16363,9 +16406,17 @@ namespace ts {
}
function getReferencedValueDeclaration(reference: Identifier): Declaration {
Debug.assert(!nodeIsSynthesized(reference));
const symbol = getReferencedValueSymbol(reference);
return symbol && getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration;
if (!isGeneratedIdentifier(reference)) {
reference = getSourceTreeNodeOfType(reference, isIdentifier);
if (reference) {
const symbol = getReferencedValueSymbol(reference);
if (symbol) {
return getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration;
}
}
}
return undefined;
}
function createResolver(): EmitResolver {
src/compiler/commandLineParser.ts
+2 -2
View File
@@ -474,7 +474,7 @@ namespace ts {
}
function parseCustomTypeOption(opt: CommandLineOptionOfCustomType, value: string) {
const key = (value || "").trim().toLowerCase();
const key = (value || "").toLowerCase();
const map = opt.type;
if (hasProperty(map, key)) {
return map[key];
@@ -485,7 +485,7 @@ namespace ts {
}
function parseListTypeOption(opt: CommandLineOptionOfListType, value: string): (string | number)[] {
const values = (value || "").trim().split(",");
const values = (value || "").split(",");
switch (opt.element.type) {
case "number":
return ts.map(values, parseInt);
src/compiler/emitter.ts
+19 -12
View File
@@ -2240,41 +2240,49 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
emit(node.right);
}
function emitQualifiedNameAsExpression(node: QualifiedName, useFallback: boolean) {
function emitQualifiedNameAsExpression(node: QualifiedName, useFallback: boolean, location?: Node) {
if (node.left.kind === SyntaxKind.Identifier) {
emitEntityNameAsExpression(node.left, useFallback);
emitEntityNameAsExpression(node.left, useFallback, location);
}
else if (useFallback) {
const temp = createAndRecordTempVariable(TempFlags.Auto);
write("(");
emitNodeWithoutSourceMap(temp);
write(" = ");
emitEntityNameAsExpression(node.left, /*useFallback*/ true);
emitEntityNameAsExpression(node.left, /*useFallback*/ true, location);
write(") && ");
emitNodeWithoutSourceMap(temp);
}
else {
emitEntityNameAsExpression(node.left, /*useFallback*/ false);
emitEntityNameAsExpression(node.left, /*useFallback*/ false, location);
}
write(".");
emit(node.right);
}
function emitEntityNameAsExpression(node: EntityName | Expression, useFallback: boolean) {
function emitEntityNameAsExpression(node: EntityName | Expression, useFallback: boolean, location?: Node) {
switch (node.kind) {
case SyntaxKind.Identifier:
let name = <Identifier>node;
if (location) {
// to resolve the expression to the correct container, create a shallow
// clone of `node` with a new parent.
name = clone(name);
name.parent = location;
}
if (useFallback) {
write("typeof ");
emitExpressionIdentifier(<Identifier>node);
emitExpressionIdentifier(name);
write(" !== 'undefined' && ");
}
emitExpressionIdentifier(<Identifier>node);
emitExpressionIdentifier(name);
break;
case SyntaxKind.QualifiedName:
emitQualifiedNameAsExpression(<QualifiedName>node, useFallback);
emitQualifiedNameAsExpression(<QualifiedName>node, useFallback, location);
break;
default:
@@ -5943,22 +5951,21 @@ const _super = (function (geti, seti) {
}
// Clone the type name and parent it to a location outside of the current declaration.
const typeName = cloneEntityName(node.typeName, location);
const result = resolver.getTypeReferenceSerializationKind(typeName);
const result = resolver.getTypeReferenceSerializationKind(node.typeName, location);
switch (result) {
case TypeReferenceSerializationKind.Unknown:
let temp = createAndRecordTempVariable(TempFlags.Auto);
write("(typeof (");
emitNodeWithoutSourceMap(temp);
write(" = ");
emitEntityNameAsExpression(typeName, /*useFallback*/ true);
emitEntityNameAsExpression(node.typeName, /*useFallback*/ true, location);
write(") === 'function' && ");
emitNodeWithoutSourceMap(temp);
write(") || Object");
break;
case TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue:
emitEntityNameAsExpression(typeName, /*useFallback*/ false);
emitEntityNameAsExpression(node.typeName, /*useFallback*/ false, location);
break;
case TypeReferenceSerializationKind.VoidType:
src/compiler/factory.ts
+71
View File
@@ -1707,4 +1707,75 @@ namespace ts {
nodes.hasTrailingComma = hasTrailingComma;
return nodes;
}
/**
* Get the name of that target module from an import or export declaration
*/
export function getLocalNameForExternalImport(node: ImportDeclaration | ExportDeclaration | ImportEqualsDeclaration, sourceFile: SourceFile): Identifier {
const namespaceDeclaration = getNamespaceDeclarationNode(node);
if (namespaceDeclaration && !isDefaultImport(node)) {
return createIdentifier(getSourceTextOfNodeFromSourceFile(sourceFile, namespaceDeclaration.name));
}
if (node.kind === SyntaxKind.ImportDeclaration && (<ImportDeclaration>node).importClause) {
return getGeneratedNameForNode(node);
}
if (node.kind === SyntaxKind.ExportDeclaration && (<ExportDeclaration>node).moduleSpecifier) {
return getGeneratedNameForNode(node);
}
return undefined;
}
/**
* Get the name of a target module from an import/export declaration as should be written in the emitted output.
* The emitted output name can be different from the input if:
* 1. The module has a /// <amd-module name="<new name>" />
* 2. --out or --outFile is used, making the name relative to the rootDir
* 3- The containing SourceFile has an entry in renamedDependencies for the import as requested by some module loaders (e.g. System).
* Otherwise, a new StringLiteral node representing the module name will be returned.
*/
export function getExternalModuleNameLiteral(importNode: ImportDeclaration | ExportDeclaration | ImportEqualsDeclaration, sourceFile: SourceFile, host: EmitHost, resolver: EmitResolver, compilerOptions: CompilerOptions) {
const moduleName = getExternalModuleName(importNode);
if (moduleName.kind === SyntaxKind.StringLiteral) {
return tryGetModuleNameFromDeclaration(importNode, host, resolver, compilerOptions)
|| tryRenameExternalModule(<StringLiteral>moduleName, sourceFile)
|| getSynthesizedClone(<StringLiteral>moduleName);
}
return undefined;
}
/**
* Some bundlers (SystemJS builder) sometimes want to rename dependencies.
* Here we check if alternative name was provided for a given moduleName and return it if possible.
*/
function tryRenameExternalModule(moduleName: LiteralExpression, sourceFile: SourceFile) {
if (sourceFile.renamedDependencies && hasProperty(sourceFile.renamedDependencies, moduleName.text)) {
return createLiteral(sourceFile.renamedDependencies[moduleName.text]);
}
return undefined;
}
/**
* Get the name of a module as should be written in the emitted output.
* The emitted output name can be different from the input if:
* 1. The module has a /// <amd-module name="<new name>" />
* 2. --out or --outFile is used, making the name relative to the rootDir
* Otherwise, a new StringLiteral node representing the module name will be returned.
*/
export function tryGetModuleNameFromFile(file: SourceFile, host: EmitHost, options: CompilerOptions): StringLiteral {
if (!file) {
return undefined;
}
if (file.moduleName) {
return createLiteral(file.moduleName);
}
if (!isDeclarationFile(file) && (options.out || options.outFile)) {
return createLiteral(getExternalModuleNameFromPath(host, file.fileName));
}
return undefined;
}
function tryGetModuleNameFromDeclaration(declaration: ImportEqualsDeclaration | ImportDeclaration | ExportDeclaration, host: EmitHost, resolver: EmitResolver, compilerOptions: CompilerOptions) {
return tryGetModuleNameFromFile(resolver.getExternalModuleFileFromDeclaration(declaration), host, compilerOptions);
}
}
src/compiler/printer.ts
+4 -2
View File
@@ -1643,8 +1643,10 @@ const _super = (function (geti, seti) {
function emitImportDeclaration(node: ImportDeclaration) {
emitModifiers(node, node.modifiers);
write("import ");
emit(node.importClause);
write(" from ");
if (node.importClause) {
emit(node.importClause);
write(" from ");
}
emitExpression(node.moduleSpecifier);
write(";");
}
src/compiler/transformer.ts
+1
View File
@@ -68,6 +68,7 @@ namespace ts {
const context: TransformationContext = {
getCompilerOptions: () => host.getCompilerOptions(),
getEmitResolver: () => resolver,
getEmitHost: () => host,
getNodeEmitFlags,
setNodeEmitFlags,
hoistVariableDeclaration,
src/compiler/transformers/destructuring.ts
+9 -3
View File
@@ -17,10 +17,16 @@ namespace ts {
node: BinaryExpression,
needsValue: boolean,
recordTempVariable: (node: Identifier) => void,
visitor?: (node: Node) => VisitResult<Node>) {
visitor?: (node: Node) => VisitResult<Node>): Expression {
if (isEmptyObjectLiteralOrArrayLiteral(node.left)) {
return node.right;
const right = node.right;
if (isDestructuringAssignment(right)) {
return flattenDestructuringAssignment(context, right, needsValue, recordTempVariable, visitor);
}
else {
return node.right;
}
}
let location: TextRange = node;
@@ -401,4 +407,4 @@ namespace ts {
return emitTempVariableAssignment(value, location);
}
}
}
}
src/compiler/transformers/es6.ts
+9 -15
View File
@@ -467,7 +467,7 @@ namespace ts {
if (isGeneratedIdentifier(node)) {
return node;
}
if (node.text !== "arguments" && !resolver.isArgumentsLocalBinding(<Identifier>getOriginalNode(node))) {
if (node.text !== "arguments" && !resolver.isArgumentsLocalBinding(node)) {
return node;
}
return convertedLoopState.argumentsName || (convertedLoopState.argumentsName = createUniqueName("arguments"));
@@ -1426,10 +1426,7 @@ namespace ts {
// * Why loop initializer is excluded?
// - Since we've introduced a fresh name it already will be undefined.
const original = getOriginalNode(node);
Debug.assert(isVariableDeclaration(original));
const flags = resolver.getNodeCheckFlags(original);
const flags = resolver.getNodeCheckFlags(node);
const isCapturedInFunction = flags & NodeCheckFlags.CapturedBlockScopedBinding;
const isDeclaredInLoop = flags & NodeCheckFlags.BlockScopedBindingInLoop;
const emittedAsTopLevel =
@@ -1443,7 +1440,7 @@ namespace ts {
!emittedAsTopLevel
&& enclosingBlockScopeContainer.kind !== SyntaxKind.ForInStatement
&& enclosingBlockScopeContainer.kind !== SyntaxKind.ForOfStatement
&& (!resolver.isDeclarationWithCollidingName(<Declaration>original)
&& (!resolver.isDeclarationWithCollidingName(node)
|| (isDeclaredInLoop
&& !isCapturedInFunction
&& !isIterationStatement(enclosingBlockScopeContainer, /*lookInLabeledStatements*/ false)));
@@ -1721,7 +1718,7 @@ namespace ts {
}
function shouldConvertIterationStatementBody(node: IterationStatement): boolean {
return (resolver.getNodeCheckFlags(getOriginalNode(node)) & NodeCheckFlags.LoopWithCapturedBlockScopedBinding) !== 0;
return (resolver.getNodeCheckFlags(node) & NodeCheckFlags.LoopWithCapturedBlockScopedBinding) !== 0;
}
/**
@@ -2614,8 +2611,8 @@ namespace ts {
// Only substitute the identifier if we have enabled substitutions for block-scoped
// bindings.
if (enabledSubstitutions & ES6SubstitutionFlags.BlockScopedBindings) {
const original = getOriginalNode(node);
if (isIdentifier(original) && !nodeIsSynthesized(original) && original.parent && isNameOfDeclarationWithCollidingName(original)) {
const original = getSourceTreeNodeOfType(node, isIdentifier);
if (original && isNameOfDeclarationWithCollidingName(original)) {
return getGeneratedNameForNode(original);
}
}
@@ -2668,12 +2665,9 @@ namespace ts {
*/
function substituteExpressionIdentifier(node: Identifier): Identifier {
if (enabledSubstitutions & ES6SubstitutionFlags.BlockScopedBindings) {
const original = getOriginalNode(node);
if (isIdentifier(original)) {
const declaration = resolver.getReferencedDeclarationWithCollidingName(original);
if (declaration) {
return getGeneratedNameForNode(declaration.name);
}
const declaration = resolver.getReferencedDeclarationWithCollidingName(node);
if (declaration) {
return getGeneratedNameForNode(declaration.name);
}
}
src/compiler/transformers/module/module.ts
+38 -75
View File
@@ -21,6 +21,7 @@ namespace ts {
const compilerOptions = context.getCompilerOptions();
const resolver = context.getEmitResolver();
const host = context.getEmitHost();
const languageVersion = getEmitScriptTarget(compilerOptions);
const moduleKind = getEmitModuleKind(compilerOptions);
const previousExpressionSubstitution = context.expressionSubstitution;
@@ -91,7 +92,7 @@ namespace ts {
*/
function transformAMDModule(node: SourceFile) {
const define = createIdentifier("define");
const moduleName = node.moduleName ? createLiteral(node.moduleName) : undefined;
const moduleName = tryGetModuleNameFromFile(node, host, compilerOptions);
return transformAsynchronousModule(node, define, moduleName, /*includeNonAmdDependencies*/ true);
}
@@ -460,8 +461,7 @@ namespace ts {
function visitExportAssignment(node: ExportAssignment): VisitResult<Statement> {
if (!node.isExportEquals) {
const original = getOriginalNode(node);
if (nodeIsSynthesized(original) || resolver.isValueAliasDeclaration(original)) {
if (nodeIsSynthesized(node) || resolver.isValueAliasDeclaration(node)) {
const statements: Statement[] = [];
addExportDefault(statements, node.expression, /*location*/ node);
return statements;
@@ -713,46 +713,43 @@ namespace ts {
}
function substituteExpressionIdentifier(node: Identifier): Expression {
const original = getOriginalNode(node);
if (isIdentifier(original)) {
const container = resolver.getReferencedExportContainer(original, (getNodeEmitFlags(node) & NodeEmitFlags.PrefixExportedLocal) !== 0);
if (container) {
if (container.kind === SyntaxKind.SourceFile) {
return createPropertyAccess(
createIdentifier("exports"),
getSynthesizedClone(node),
/*location*/ node
);
}
const container = resolver.getReferencedExportContainer(node, (getNodeEmitFlags(node) & NodeEmitFlags.ExportName) !== 0);
if (container) {
if (container.kind === SyntaxKind.SourceFile) {
return createPropertyAccess(
createIdentifier("exports"),
getSynthesizedClone(node),
/*location*/ node
);
}
else {
const declaration = resolver.getReferencedImportDeclaration(node.parent ? node : original);
if (declaration) {
if (declaration.kind === SyntaxKind.ImportClause) {
if (languageVersion >= ScriptTarget.ES5) {
return createPropertyAccess(
getGeneratedNameForNode(declaration.parent),
createIdentifier("default"),
/*location*/ node
);
}
else {
return createElementAccess(
getGeneratedNameForNode(declaration.parent),
createLiteral("default"),
/*location*/ node
);
}
}
else if (declaration.kind === SyntaxKind.ImportSpecifier) {
const name = (<ImportSpecifier>declaration).propertyName
|| (<ImportSpecifier>declaration).name;
}
else {
const declaration = resolver.getReferencedImportDeclaration(node);
if (declaration) {
if (declaration.kind === SyntaxKind.ImportClause) {
if (languageVersion >= ScriptTarget.ES5) {
return createPropertyAccess(
getGeneratedNameForNode(declaration.parent.parent.parent),
getSynthesizedClone(name),
getGeneratedNameForNode(declaration.parent),
createIdentifier("default"),
/*location*/ node
);
}
else {
return createElementAccess(
getGeneratedNameForNode(declaration.parent),
createLiteral("default"),
/*location*/ node
);
}
}
else if (declaration.kind === SyntaxKind.ImportSpecifier) {
const name = (<ImportSpecifier>declaration).propertyName
|| (<ImportSpecifier>declaration).name;
return createPropertyAccess(
getGeneratedNameForNode(declaration.parent.parent.parent),
getSynthesizedClone(name),
/*location*/ node
);
}
}
}
@@ -768,42 +765,8 @@ namespace ts {
);
}
function getExternalModuleNameLiteral(importNode: ImportDeclaration | ExportDeclaration | ImportEqualsDeclaration) {
const moduleName = getExternalModuleName(importNode);
if (moduleName.kind === SyntaxKind.StringLiteral) {
return tryRenameExternalModule(<StringLiteral>moduleName)
|| createLiteral(<StringLiteral>moduleName);
}
return undefined;
}
/**
* Some bundlers (SystemJS builder) sometimes want to rename dependencies.
* Here we check if alternative name was provided for a given moduleName and return it if possible.
*/
function tryRenameExternalModule(moduleName: LiteralExpression) {
if (currentSourceFile.renamedDependencies && hasProperty(currentSourceFile.renamedDependencies, moduleName.text)) {
return createLiteral(currentSourceFile.renamedDependencies[moduleName.text]);
}
return undefined;
}
function getLocalNameForExternalImport(node: ImportDeclaration | ExportDeclaration | ImportEqualsDeclaration): Identifier {
const namespaceDeclaration = getNamespaceDeclarationNode(node);
if (namespaceDeclaration && !isDefaultImport(node)) {
return createIdentifier(getSourceTextOfNodeFromSourceFile(currentSourceFile, namespaceDeclaration.name));
}
if (node.kind === SyntaxKind.ImportDeclaration && (<ImportDeclaration>node).importClause) {
return getGeneratedNameForNode(node);
}
if (node.kind === SyntaxKind.ExportDeclaration && (<ExportDeclaration>node).moduleSpecifier) {
return getGeneratedNameForNode(node);
}
}
function createRequireCall(importNode: ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration) {
const moduleName = getExternalModuleNameLiteral(importNode);
const moduleName = getExternalModuleNameLiteral(importNode, currentSourceFile, host, resolver, compilerOptions);
const args: Expression[] = [];
if (isDefined(moduleName)) {
args.push(moduleName);
@@ -862,10 +825,10 @@ namespace ts {
for (const importNode of externalImports) {
// Find the name of the external module
const externalModuleName = getExternalModuleNameLiteral(importNode);
const externalModuleName = getExternalModuleNameLiteral(importNode, currentSourceFile, host, resolver, compilerOptions);
// Find the name of the module alias, if there is one
const importAliasName = getLocalNameForExternalImport(importNode);
const importAliasName = getLocalNameForExternalImport(importNode, currentSourceFile);
if (includeNonAmdDependencies && importAliasName) {
aliasedModuleNames.push(externalModuleName);
importAliasNames.push(createParameter(importAliasName));
src/compiler/transformers/module/system.ts
+11 -46
View File
@@ -20,6 +20,7 @@ namespace ts {
const compilerOptions = context.getCompilerOptions();
const resolver = context.getEmitResolver();
const host = context.getEmitHost();
const languageVersion = getEmitScriptTarget(compilerOptions);
const previousExpressionSubstitution = context.expressionSubstitution;
context.enableExpressionSubstitution(SyntaxKind.Identifier);
@@ -106,6 +107,7 @@ namespace ts {
// Add the body of the module.
addSystemModuleBody(statements, node, dependencyGroups);
const moduleName = tryGetModuleNameFromFile(node, host, compilerOptions);
const dependencies = createArrayLiteral(map(dependencyGroups, getNameOfDependencyGroup));
const body = createFunctionExpression(
/*asteriskToken*/ undefined,
@@ -127,8 +129,8 @@ namespace ts {
createStatement(
createCall(
createPropertyAccess(createIdentifier("System"), "register"),
node.moduleName
? [createLiteral(node.moduleName), dependencies, body]
moduleName
? [moduleName, dependencies, body]
: [dependencies, body]
)
)
@@ -341,11 +343,11 @@ namespace ts {
const setters: Expression[] = [];
for (const group of dependencyGroups) {
// derive a unique name for parameter from the first named entry in the group
const localName = forEach(group.externalImports, getLocalNameForExternalImport);
const localName = forEach(group.externalImports, i => getLocalNameForExternalImport(i, currentSourceFile));
const parameterName = localName ? getGeneratedNameForNode(localName) : createUniqueName("");
const statements: Statement[] = [];
for (const entry of group.externalImports) {
const importVariableName = getLocalNameForExternalImport(entry);
const importVariableName = getLocalNameForExternalImport(entry, currentSourceFile);
switch (entry.kind) {
case SyntaxKind.ImportDeclaration:
if (!(<ImportDeclaration>entry).importClause) {
@@ -534,7 +536,7 @@ namespace ts {
function visitImportDeclaration(node: ImportDeclaration): Node {
if (node.importClause && contains(externalImports, node)) {
hoistVariableDeclaration(getLocalNameForExternalImport(node));
hoistVariableDeclaration(getLocalNameForExternalImport(node, currentSourceFile));
}
return undefined;
@@ -542,7 +544,7 @@ namespace ts {
function visitImportEqualsDeclaration(node: ImportEqualsDeclaration): Node {
if (contains(externalImports, node)) {
hoistVariableDeclaration(getLocalNameForExternalImport(node));
hoistVariableDeclaration(getLocalNameForExternalImport(node, currentSourceFile));
}
// NOTE(rbuckton): Do we support export import = require('') in System?
@@ -573,8 +575,7 @@ namespace ts {
function visitExportAssignment(node: ExportAssignment): Statement {
if (!node.isExportEquals) {
const original = getOriginalNode(node);
if (nodeIsSynthesized(original) || resolver.isValueAliasDeclaration(original)) {
if (nodeIsSynthesized(node) || resolver.isValueAliasDeclaration(node)) {
return createExportStatement(
createLiteral("default"),
node.expression
@@ -1015,8 +1016,7 @@ namespace ts {
const left = node.left;
switch (left.kind) {
case SyntaxKind.Identifier:
const originalNode = getOriginalNode(left);
const exportDeclaration = resolver.getReferencedExportContainer(<Identifier>originalNode);
const exportDeclaration = resolver.getReferencedExportContainer(<Identifier>left);
if (exportDeclaration) {
return createExportExpression(<Identifier>left, node);
}
@@ -1152,41 +1152,6 @@ namespace ts {
return node;
}
function getExternalModuleNameLiteral(importNode: ImportDeclaration | ExportDeclaration | ImportEqualsDeclaration) {
const moduleName = getExternalModuleName(importNode);
if (moduleName.kind === SyntaxKind.StringLiteral) {
return tryRenameExternalModule(<StringLiteral>moduleName)
|| getSynthesizedClone(<StringLiteral>moduleName);
}
return undefined;
}
/**
* Some bundlers (SystemJS builder) sometimes want to rename dependencies.
* Here we check if alternative name was provided for a given moduleName and return it if possible.
*/
function tryRenameExternalModule(moduleName: LiteralExpression) {
if (currentSourceFile.renamedDependencies && hasProperty(currentSourceFile.renamedDependencies, moduleName.text)) {
return createLiteral(currentSourceFile.renamedDependencies[moduleName.text]);
}
return undefined;
}
function getLocalNameForExternalImport(node: ImportDeclaration | ExportDeclaration | ImportEqualsDeclaration): Identifier {
const namespaceDeclaration = getNamespaceDeclarationNode(node);
if (namespaceDeclaration && !isDefaultImport(node)) {
return createIdentifier(getSourceTextOfNodeFromSourceFile(currentSourceFile, namespaceDeclaration.name));
}
if (node.kind === SyntaxKind.ImportDeclaration && (<ImportDeclaration>node).importClause) {
return getGeneratedNameForNode(node);
}
if (node.kind === SyntaxKind.ExportDeclaration && (<ExportDeclaration>node).moduleSpecifier) {
return getGeneratedNameForNode(node);
}
}
/**
* Gets a name to use for a DeclarationStatement.
* @param node The declaration statement.
@@ -1316,7 +1281,7 @@ namespace ts {
const dependencyGroups: DependencyGroup[] = [];
for (let i = 0; i < externalImports.length; i++) {
const externalImport = externalImports[i];
const externalModuleName = getExternalModuleNameLiteral(externalImport);
const externalModuleName = getExternalModuleNameLiteral(externalImport, currentSourceFile, host, resolver, compilerOptions);
const text = externalModuleName.text;
if (hasProperty(groupIndices, text)) {
// deduplicate/group entries in dependency list by the dependency name
src/compiler/transformers/ts.ts
+66 -42
View File
@@ -157,7 +157,15 @@ namespace ts {
* @param node The node to visit.
*/
function namespaceElementVisitorWorker(node: Node): VisitResult<Node> {
if (node.transformFlags & TransformFlags.TypeScript || hasModifier(node, ModifierFlags.Export)) {
if (node.kind === SyntaxKind.ExportDeclaration ||
node.kind === SyntaxKind.ImportDeclaration ||
node.kind === SyntaxKind.ImportClause ||
(node.kind === SyntaxKind.ImportEqualsDeclaration &&
(<ImportEqualsDeclaration>node).moduleReference.kind === SyntaxKind.ExternalModuleReference)) {
// do not emit ES6 imports and exports since they are illegal inside a namespace
return undefined;
}
else if (node.transformFlags & TransformFlags.TypeScript || hasModifier(node, ModifierFlags.Export)) {
// This node is explicitly marked as TypeScript, or is exported at the namespace
// level, so we should transform the node.
return visitTypeScript(node);
@@ -596,7 +604,7 @@ namespace ts {
// Record an alias to avoid class double-binding.
let decoratedClassAlias: Identifier;
if (resolver.getNodeCheckFlags(getOriginalNode(node)) & NodeCheckFlags.DecoratedClassWithSelfReference) {
if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.DecoratedClassWithSelfReference) {
enableExpressionSubstitutionForDecoratedClasses();
decoratedClassAlias = createUniqueName(node.name && !isGeneratedIdentifier(node.name) ? node.name.text : "default");
decoratedClassAliases[getOriginalNodeId(node)] = decoratedClassAlias;
@@ -1282,7 +1290,7 @@ namespace ts {
//
const prefix = getClassMemberPrefix(node, member);
const memberName = getExpressionForPropertyName(member);
const memberName = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ true);
const descriptor = languageVersion > ScriptTarget.ES3
? member.kind === SyntaxKind.PropertyDeclaration
// We emit `void 0` here to indicate to `__decorate` that it can invoke `Object.defineProperty` directly, but that it
@@ -1394,7 +1402,6 @@ namespace ts {
function addOldTypeMetadata(node: Declaration, decoratorExpressions: Expression[]) {
if (compilerOptions.emitDecoratorMetadata) {
let properties: ObjectLiteralElement[];
if (shouldAddTypeMetadata(node)) {
decoratorExpressions.push(createMetadataHelper("design:type", serializeTypeOfNode(node)));
}
@@ -1628,11 +1635,9 @@ namespace ts {
* @param node The type reference node.
*/
function serializeTypeReferenceNode(node: TypeReferenceNode) {
// Clone the type name and parent it to a location outside of the current declaration.
const typeName = cloneEntityName(node.typeName, currentScope);
switch (resolver.getTypeReferenceSerializationKind(typeName)) {
switch (resolver.getTypeReferenceSerializationKind(node.typeName, currentScope)) {
case TypeReferenceSerializationKind.Unknown:
const serialized = serializeEntityNameAsExpression(typeName, /*useFallback*/ true);
const serialized = serializeEntityNameAsExpression(node.typeName, /*useFallback*/ true);
const temp = createTempVariable(hoistVariableDeclaration);
return createLogicalOr(
createLogicalAnd(
@@ -1648,7 +1653,7 @@ namespace ts {
);
case TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue:
return serializeEntityNameAsExpression(typeName, /*useFallback*/ false);
return serializeEntityNameAsExpression(node.typeName, /*useFallback*/ false);
case TypeReferenceSerializationKind.VoidType:
return createVoidZero();
@@ -1689,17 +1694,20 @@ namespace ts {
function serializeEntityNameAsExpression(node: EntityName, useFallback: boolean): Expression {
switch (node.kind) {
case SyntaxKind.Identifier:
const name = getMutableClone(<Identifier>node);
name.original = undefined;
name.parent = currentScope;
if (useFallback) {
return createLogicalAnd(
createStrictInequality(
createTypeOf(<Identifier>node),
createTypeOf(name),
createLiteral("undefined")
),
<Identifier>node
name
);
}
return <Identifier>node;
return name;
case SyntaxKind.QualifiedName:
return serializeQualifiedNameAsExpression(<QualifiedName>node, useFallback);
@@ -1756,10 +1764,12 @@ namespace ts {
*
* @param member The member whose name should be converted into an expression.
*/
function getExpressionForPropertyName(member: ClassElement | EnumMember): Expression {
function getExpressionForPropertyName(member: ClassElement | EnumMember, generateNameForComputedPropertyName: boolean): Expression {
const name = member.name;
if (isComputedPropertyName(name)) {
return getGeneratedNameForNode(name);
return generateNameForComputedPropertyName
? getGeneratedNameForNode(name)
: (<ComputedPropertyName>name).expression;
}
else if (isIdentifier(name)) {
return createLiteral(name.text);
@@ -2343,7 +2353,10 @@ namespace ts {
* @param member The enum member node.
*/
function transformEnumMember(member: EnumMember): Statement {
const name = getExpressionForPropertyName(member);
// enums don't support computed properties
// 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(
@@ -2658,9 +2671,9 @@ namespace ts {
return getNamespaceMemberName(name);
}
else {
// We set the "PrefixExportedLocal" flag to indicate to any module transformer
// We set the "ExportName" flag to indicate to any module transformer
// downstream that any `exports.` prefix should be added.
setNodeEmitFlags(name, getNodeEmitFlags(name) | NodeEmitFlags.PrefixExportedLocal);
setNodeEmitFlags(name, getNodeEmitFlags(name) | NodeEmitFlags.ExportName);
return name;
}
}
@@ -2752,41 +2765,52 @@ namespace ts {
}
function substituteExpressionIdentifier(node: Identifier): Expression {
return trySubstituteDecoratedClassName(node)
|| trySubstituteNamespaceExportedName(node)
|| node;
}
function trySubstituteDecoratedClassName(node: Identifier): Expression {
if (enabledSubstitutions & TypeScriptSubstitutionFlags.DecoratedClasses) {
const original = getOriginalNode(node);
if (isIdentifier(original)) {
if (resolver.getNodeCheckFlags(original) & NodeCheckFlags.SelfReferenceInDecoratedClass) {
// Due to the emit for class decorators, any reference to the class from inside of the class body
// must instead be rewritten to point to a temporary variable to avoid issues with the double-bind
// behavior of class names in ES6.
const declaration = resolver.getReferencedValueDeclaration(original);
if (declaration) {
const classAlias = currentDecoratedClassAliases[getNodeId(declaration)];
if (classAlias) {
return getRelocatedClone(classAlias, /*location*/ node);
}
if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.SelfReferenceInDecoratedClass) {
// Due to the emit for class decorators, any reference to the class from inside of the class body
// must instead be rewritten to point to a temporary variable to avoid issues with the double-bind
// behavior of class names in ES6.
const declaration = resolver.getReferencedValueDeclaration(node);
if (declaration) {
const classAlias = currentDecoratedClassAliases[getNodeId(declaration)];
if (classAlias) {
return getRelocatedClone(classAlias, /*location*/ node);
}
}
}
}
return undefined;
}
function trySubstituteNamespaceExportedName(node: Identifier): Expression {
if (enabledSubstitutions & applicableSubstitutions) {
// If this is explicitly a local name, do not substitute.
if (getNodeEmitFlags(node) & NodeEmitFlags.LocalName) {
return node;
}
// If we are nested within a namespace declaration, we may need to qualifiy
// an identifier that is exported from a merged namespace.
const original = getOriginalNode(node);
if (isIdentifier(original) && original.parent) {
const container = resolver.getReferencedExportContainer(original);
if (container) {
const substitute =
(applicableSubstitutions & TypeScriptSubstitutionFlags.NamespaceExports && container.kind === SyntaxKind.ModuleDeclaration) ||
(applicableSubstitutions & TypeScriptSubstitutionFlags.NonQualifiedEnumMembers && container.kind === SyntaxKind.EnumDeclaration);
if (substitute) {
return createPropertyAccess(getGeneratedNameForNode(container), node, /*location*/ node);
}
const original = getSourceTreeNodeOfType(node, isIdentifier);
const container = resolver.getReferencedExportContainer(original, /*prefixLocals*/ false);
if (container && original !== container.name) {
const substitute =
(applicableSubstitutions & TypeScriptSubstitutionFlags.NamespaceExports && container.kind === SyntaxKind.ModuleDeclaration) ||
(applicableSubstitutions & TypeScriptSubstitutionFlags.NonQualifiedEnumMembers && container.kind === SyntaxKind.EnumDeclaration);
if (substitute) {
return createPropertyAccess(getGeneratedNameForNode(container), node, /*location*/ node);
}
}
}
return node;
return undefined;
}
function substituteCallExpression(node: CallExpression): Expression {
@@ -2914,7 +2938,7 @@ namespace ts {
function getSuperContainerAsyncMethodFlags() {
return currentSuperContainer !== undefined
&& resolver.getNodeCheckFlags(getOriginalNode(currentSuperContainer)) & (NodeCheckFlags.AsyncMethodWithSuper | NodeCheckFlags.AsyncMethodWithSuperBinding);
&& resolver.getNodeCheckFlags(currentSuperContainer) & (NodeCheckFlags.AsyncMethodWithSuper | NodeCheckFlags.AsyncMethodWithSuperBinding);
}
}
}
}
src/compiler/types.ts
+5 -3
View File
@@ -1963,7 +1963,7 @@ namespace ts {
// Returns the constant value this property access resolves to, or 'undefined' for a non-constant
getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
getReferencedValueDeclaration(reference: Identifier): Declaration;
getTypeReferenceSerializationKind(typeName: EntityName): TypeReferenceSerializationKind;
getTypeReferenceSerializationKind(typeName: EntityName, location?: Node): TypeReferenceSerializationKind;
isOptionalParameter(node: ParameterDeclaration): boolean;
moduleExportsSomeValue(moduleReferenceExpression: Expression): boolean;
isArgumentsLocalBinding(node: Identifier): boolean;
@@ -2875,8 +2875,9 @@ namespace ts {
NoSourceMap = 1 << 10, // Do not emit a source map location for this node.
NoNestedSourceMaps = 1 << 11, // Do not emit source map locations for children of this node.
NoComments = 1 << 12, // Do not emit comments for this node.
PrefixExportedLocal = 1 << 13, // Ensure an export prefix is added for an identifier that points to an exported declaration with a local name (see SymbolFlags.ExportHasLocal).
Indented = 1 << 14, // Adds an explicit extra indentation level for class and function bodies when printing (used to match old emitter).
ExportName = 1 << 13, // Ensure an export prefix is added for an identifier that points to an exported declaration with a local name (see SymbolFlags.ExportHasLocal).
LocalName = 1 << 14, // Ensure an export prefix is not added for an identifier that points to an exported declaration.
Indented = 1 << 15, // Adds an explicit extra indentation level for class and function bodies when printing (used to match old emitter).
}
/** Additional context provided to `visitEachChild` */
@@ -2892,6 +2893,7 @@ namespace ts {
export interface TransformationContext extends LexicalEnvironment {
getCompilerOptions(): CompilerOptions;
getEmitResolver(): EmitResolver;
getEmitHost(): EmitHost;
getNodeEmitFlags(node: Node): NodeEmitFlags;
setNodeEmitFlags<T extends Node>(node: T, flags: NodeEmitFlags): T;
hoistFunctionDeclaration(node: FunctionDeclaration): void;
src/compiler/utilities.ts
+26 -22
View File
@@ -1711,24 +1711,6 @@ namespace ts {
|| kind === SyntaxKind.SourceFile;
}
/**
* Creates a deep clone of an EntityName, with new parent pointers.
* @param node The EntityName to clone.
* @param parent The parent for the cloned node.
*/
export function cloneEntityName(node: EntityName, parent?: Node): EntityName {
const clone = getMutableClone(node);
clone.parent = parent;
if (isQualifiedName(clone)) {
const { left, right } = clone;
clone.left = cloneEntityName(left, clone);
clone.right = getMutableClone(right);
clone.right.parent = clone;
}
return clone;
}
export function nodeIsSynthesized(node: TextRange): boolean {
return positionIsSynthesized(node.pos)
|| positionIsSynthesized(node.end);
@@ -1741,13 +1723,31 @@ namespace ts {
}
export function getOriginalNode(node: Node): Node {
while (node.original !== undefined) {
node = node.original;
if (node) {
while (node.original !== undefined) {
node = node.original;
}
}
return node;
}
export function getSourceTreeNode(node: Node): Node {
node = getOriginalNode(node);
if (node) {
if (node.parent || node.kind === SyntaxKind.SourceFile) {
return node;
}
}
return undefined;
}
export function getSourceTreeNodeOfType<T extends Node>(node: T, nodeTest: (node: Node) => node is T): T {
const source = getSourceTreeNode(node);
return source && nodeTest(source) ? source : undefined;
}
export function getOriginalNodeId(node: Node) {
node = getOriginalNode(node);
return node ? getNodeId(node) : 0;
@@ -2999,7 +2999,7 @@ namespace ts {
break;
case SyntaxKind.ImportEqualsDeclaration:
if ((<ImportEqualsDeclaration>node).moduleReference.kind === SyntaxKind.ExternalModuleReference && resolver.isReferencedAliasDeclaration(getOriginalNode(node))) {
if ((<ImportEqualsDeclaration>node).moduleReference.kind === SyntaxKind.ExternalModuleReference && resolver.isReferencedAliasDeclaration(node)) {
// import x = require("mod") where x is referenced
externalImports.push(<ImportEqualsDeclaration>node);
}
@@ -3014,7 +3014,7 @@ namespace ts {
hasExportStarsToExportValues = true;
}
}
else if (resolver.isValueAliasDeclaration(getOriginalNode(node))) {
else if (resolver.isValueAliasDeclaration(node)) {
// export { x, y } from "mod" where at least one export is a value symbol
externalImports.push(<ExportDeclaration>node);
}
@@ -3416,6 +3416,10 @@ namespace ts {
|| kind === SyntaxKind.ModuleDeclaration;
}
export function isImportEqualsDeclaration(node: Node): node is ImportEqualsDeclaration {
return node.kind === SyntaxKind.ImportEqualsDeclaration;
}
export function isImportClause(node: Node): node is ImportClause {
return node.kind === SyntaxKind.ImportClause;
}
src/compiler/visitor.ts
+89 -89
View File
@@ -46,27 +46,27 @@ namespace ts {
const nodeEdgeTraversalMap: Map<NodeTraversalPath> = {
[SyntaxKind.QualifiedName]: [
{ name: "left", test: isEntityName },
{ name: "right", test: isIdentifier },
{ name: "right", test: isIdentifier }
],
[SyntaxKind.ComputedPropertyName]: [
{ name: "expression", test: isExpression },
{ name: "expression", test: isExpression }
],
[SyntaxKind.Parameter]: [
{ name: "decorators", test: isDecorator },
{ name: "modifiers", test: isModifier },
{ name: "name", test: isBindingName },
{ name: "type", test: isTypeNode, optional: true },
{ name: "initializer", test: isExpression, optional: true, parenthesize: parenthesizeExpressionForList },
{ name: "initializer", test: isExpression, optional: true, parenthesize: parenthesizeExpressionForList }
],
[SyntaxKind.Decorator]: [
{ name: "expression", test: isLeftHandSideExpression },
{ name: "expression", test: isLeftHandSideExpression }
],
[SyntaxKind.PropertyDeclaration]: [
{ name: "decorators", test: isDecorator },
{ name: "modifiers", test: isModifier },
{ name: "name", test: isPropertyName },
{ name: "type", test: isTypeNode, optional: true },
{ name: "initializer", test: isExpression, optional: true },
{ name: "initializer", test: isExpression, optional: true }
],
[SyntaxKind.MethodDeclaration]: [
{ name: "decorators", test: isDecorator },
@@ -75,7 +75,7 @@ namespace ts {
{ name: "typeParameters", test: isTypeParameter },
{ name: "parameters", test: isParameter },
{ name: "type", test: isTypeNode, optional: true },
{ name: "body", test: isBlock, optional: true },
{ name: "body", test: isBlock, optional: true }
],
[SyntaxKind.Constructor]: [
{ name: "decorators", test: isDecorator },
@@ -83,7 +83,7 @@ namespace ts {
{ name: "typeParameters", test: isTypeParameter },
{ name: "parameters", test: isParameter },
{ name: "type", test: isTypeNode, optional: true },
{ name: "body", test: isBlock, optional: true },
{ name: "body", test: isBlock, optional: true }
],
[SyntaxKind.GetAccessor]: [
{ name: "decorators", test: isDecorator },
@@ -92,7 +92,7 @@ namespace ts {
{ name: "typeParameters", test: isTypeParameter },
{ name: "parameters", test: isParameter },
{ name: "type", test: isTypeNode, optional: true },
{ name: "body", test: isBlock, optional: true },
{ name: "body", test: isBlock, optional: true }
],
[SyntaxKind.SetAccessor]: [
{ name: "decorators", test: isDecorator },
@@ -101,53 +101,53 @@ namespace ts {
{ name: "typeParameters", test: isTypeParameter },
{ name: "parameters", test: isParameter },
{ name: "type", test: isTypeNode, optional: true },
{ name: "body", test: isBlock, optional: true },
{ name: "body", test: isBlock, optional: true }
],
[SyntaxKind.ObjectBindingPattern]: [
{ name: "elements", test: isBindingElement },
{ name: "elements", test: isBindingElement }
],
[SyntaxKind.ArrayBindingPattern]: [
{ name: "elements", test: isBindingElement },
{ name: "elements", test: isBindingElement }
],
[SyntaxKind.BindingElement]: [
{ name: "propertyName", test: isPropertyName, optional: true },
{ name: "name", test: isBindingName },
{ name: "initializer", test: isExpression, optional: true, parenthesize: parenthesizeExpressionForList },
{ name: "initializer", test: isExpression, optional: true, parenthesize: parenthesizeExpressionForList }
],
[SyntaxKind.ArrayLiteralExpression]: [
{ name: "elements", test: isExpression, parenthesize: parenthesizeExpressionForList },
{ name: "elements", test: isExpression, parenthesize: parenthesizeExpressionForList }
],
[SyntaxKind.ObjectLiteralExpression]: [
{ name: "properties", test: isObjectLiteralElement },
{ name: "properties", test: isObjectLiteralElement }
],
[SyntaxKind.PropertyAccessExpression]: [
{ name: "expression", test: isLeftHandSideExpression, parenthesize: parenthesizeForAccess },
{ name: "name", test: isIdentifier },
{ name: "name", test: isIdentifier }
],
[SyntaxKind.ElementAccessExpression]: [
{ name: "expression", test: isLeftHandSideExpression, parenthesize: parenthesizeForAccess },
{ name: "argumentExpression", test: isExpression },
{ name: "argumentExpression", test: isExpression }
],
[SyntaxKind.CallExpression]: [
{ name: "expression", test: isLeftHandSideExpression, parenthesize: parenthesizeForAccess },
{ name: "typeArguments", test: isTypeNode },
{ name: "arguments", test: isExpression, parenthesize: parenthesizeExpressionForList },
{ name: "arguments", test: isExpression, parenthesize: parenthesizeExpressionForList }
],
[SyntaxKind.NewExpression]: [
{ name: "expression", test: isLeftHandSideExpression, parenthesize: parenthesizeForNew },
{ name: "typeArguments", test: isTypeNode },
{ name: "arguments", test: isExpression, parenthesize: parenthesizeExpressionForList },
{ name: "arguments", test: isExpression, parenthesize: parenthesizeExpressionForList }
],
[SyntaxKind.TaggedTemplateExpression]: [
{ name: "tag", test: isLeftHandSideExpression, parenthesize: parenthesizeForAccess },
{ name: "template", test: isTemplate },
{ name: "template", test: isTemplate }
],
[SyntaxKind.TypeAssertionExpression]: [
{ name: "type", test: isTypeNode },
{ name: "expression", test: isUnaryExpression },
{ name: "expression", test: isUnaryExpression }
],
[SyntaxKind.ParenthesizedExpression]: [
{ name: "expression", test: isExpression },
{ name: "expression", test: isExpression }
],
[SyntaxKind.FunctionExpression]: [
{ name: "decorators", test: isDecorator },
@@ -156,7 +156,7 @@ namespace ts {
{ name: "typeParameters", test: isTypeParameter },
{ name: "parameters", test: isParameter },
{ name: "type", test: isTypeNode, optional: true },
{ name: "body", test: isBlock, optional: true },
{ name: "body", test: isBlock, optional: true }
],
[SyntaxKind.ArrowFunction]: [
{ name: "decorators", test: isDecorator },
@@ -164,44 +164,44 @@ namespace ts {
{ name: "typeParameters", test: isTypeParameter },
{ name: "parameters", test: isParameter },
{ name: "type", test: isTypeNode, optional: true },
{ name: "body", test: isConciseBody, lift: liftToBlock, parenthesize: parenthesizeConciseBody },
{ name: "body", test: isConciseBody, lift: liftToBlock, parenthesize: parenthesizeConciseBody }
],
[SyntaxKind.DeleteExpression]: [
{ name: "expression", test: isUnaryExpression, parenthesize: parenthesizePrefixOperand },
{ name: "expression", test: isUnaryExpression, parenthesize: parenthesizePrefixOperand }
],
[SyntaxKind.TypeOfExpression]: [
{ name: "expression", test: isUnaryExpression, parenthesize: parenthesizePrefixOperand },
{ name: "expression", test: isUnaryExpression, parenthesize: parenthesizePrefixOperand }
],
[SyntaxKind.VoidExpression]: [
{ name: "expression", test: isUnaryExpression, parenthesize: parenthesizePrefixOperand },
{ name: "expression", test: isUnaryExpression, parenthesize: parenthesizePrefixOperand }
],
[SyntaxKind.AwaitExpression]: [
{ name: "expression", test: isUnaryExpression, parenthesize: parenthesizePrefixOperand },
{ name: "expression", test: isUnaryExpression, parenthesize: parenthesizePrefixOperand }
],
[SyntaxKind.PrefixUnaryExpression]: [
{ name: "operand", test: isUnaryExpression, parenthesize: parenthesizePrefixOperand },
{ name: "operand", test: isUnaryExpression, parenthesize: parenthesizePrefixOperand }
],
[SyntaxKind.PostfixUnaryExpression]: [
{ name: "operand", test: isLeftHandSideExpression, parenthesize: parenthesizePostfixOperand },
{ name: "operand", test: isLeftHandSideExpression, parenthesize: parenthesizePostfixOperand }
],
[SyntaxKind.BinaryExpression]: [
{ name: "left", test: isExpression, parenthesize: (node: Expression, parent: BinaryExpression) => parenthesizeBinaryOperand(getOperator(parent), node, true, /*leftOperand*/ undefined) },
{ name: "right", test: isExpression, parenthesize: (node: Expression, parent: BinaryExpression) => parenthesizeBinaryOperand(getOperator(parent), node, false, parent.left) },
{ name: "right", test: isExpression, parenthesize: (node: Expression, parent: BinaryExpression) => parenthesizeBinaryOperand(getOperator(parent), node, false, parent.left) }
],
[SyntaxKind.ConditionalExpression]: [
{ name: "condition", test: isExpression },
{ name: "whenTrue", test: isExpression },
{ name: "whenFalse", test: isExpression },
{ name: "whenFalse", test: isExpression }
],
[SyntaxKind.TemplateExpression]: [
{ name: "head", test: isTemplateLiteralFragment },
{ name: "templateSpans", test: isTemplateSpan },
{ name: "templateSpans", test: isTemplateSpan }
],
[SyntaxKind.YieldExpression]: [
{ name: "expression", test: isExpression, optional: true },
{ name: "expression", test: isExpression, optional: true }
],
[SyntaxKind.SpreadElementExpression]: [
{ name: "expression", test: isExpression, parenthesize: parenthesizeExpressionForList },
{ name: "expression", test: isExpression, parenthesize: parenthesizeExpressionForList }
],
[SyntaxKind.ClassExpression]: [
{ name: "decorators", test: isDecorator },
@@ -209,96 +209,96 @@ namespace ts {
{ name: "name", test: isIdentifier, optional: true },
{ name: "typeParameters", test: isTypeParameter },
{ name: "heritageClauses", test: isHeritageClause },
{ name: "members", test: isClassElement },
{ name: "members", test: isClassElement }
],
[SyntaxKind.ExpressionWithTypeArguments]: [
{ name: "expression", test: isLeftHandSideExpression, parenthesize: parenthesizeForAccess },
{ name: "typeArguments", test: isTypeNode },
{ name: "typeArguments", test: isTypeNode }
],
[SyntaxKind.AsExpression]: [
{ name: "expression", test: isExpression },
{ name: "type", test: isTypeNode },
{ name: "type", test: isTypeNode }
],
[SyntaxKind.TemplateSpan]: [
{ name: "expression", test: isExpression },
{ name: "literal", test: isTemplateLiteralFragment },
{ name: "literal", test: isTemplateLiteralFragment }
],
[SyntaxKind.Block]: [
{ name: "statements", test: isStatement },
{ name: "statements", test: isStatement }
],
[SyntaxKind.VariableStatement]: [
{ name: "decorators", test: isDecorator },
{ name: "modifiers", test: isModifier },
{ name: "declarationList", test: isVariableDeclarationList },
{ name: "declarationList", test: isVariableDeclarationList }
],
[SyntaxKind.ExpressionStatement]: [
{ name: "expression", test: isExpression, parenthesize: parenthesizeExpressionForExpressionStatement },
{ name: "expression", test: isExpression, parenthesize: parenthesizeExpressionForExpressionStatement }
],
[SyntaxKind.IfStatement]: [
{ name: "expression", test: isExpression },
{ name: "thenStatement", test: isStatement, lift: liftToBlock },
{ name: "elseStatement", test: isStatement, lift: liftToBlock, optional: true },
{ name: "elseStatement", test: isStatement, lift: liftToBlock, optional: true }
],
[SyntaxKind.DoStatement]: [
{ name: "statement", test: isStatement, lift: liftToBlock },
{ name: "expression", test: isExpression },
{ name: "expression", test: isExpression }
],
[SyntaxKind.WhileStatement]: [
{ name: "expression", test: isExpression },
{ name: "statement", test: isStatement, lift: liftToBlock },
{ name: "statement", test: isStatement, lift: liftToBlock }
],
[SyntaxKind.ForStatement]: [
{ name: "initializer", test: isForInitializer, optional: true },
{ name: "condition", test: isExpression, optional: true },
{ name: "incrementor", test: isExpression, optional: true },
{ name: "statement", test: isStatement, lift: liftToBlock },
{ name: "statement", test: isStatement, lift: liftToBlock }
],
[SyntaxKind.ForInStatement]: [
{ name: "initializer", test: isForInitializer },
{ name: "expression", test: isExpression },
{ name: "statement", test: isStatement, lift: liftToBlock },
{ name: "statement", test: isStatement, lift: liftToBlock }
],
[SyntaxKind.ForOfStatement]: [
{ name: "initializer", test: isForInitializer },
{ name: "expression", test: isExpression },
{ name: "statement", test: isStatement, lift: liftToBlock },
{ name: "statement", test: isStatement, lift: liftToBlock }
],
[SyntaxKind.ContinueStatement]: [
{ name: "label", test: isIdentifier, optional: true },
{ name: "label", test: isIdentifier, optional: true }
],
[SyntaxKind.BreakStatement]: [
{ name: "label", test: isIdentifier, optional: true },
{ name: "label", test: isIdentifier, optional: true }
],
[SyntaxKind.ReturnStatement]: [
{ name: "expression", test: isExpression, optional: true },
{ name: "expression", test: isExpression, optional: true }
],
[SyntaxKind.WithStatement]: [
{ name: "expression", test: isExpression },
{ name: "statement", test: isStatement, lift: liftToBlock },
{ name: "statement", test: isStatement, lift: liftToBlock }
],
[SyntaxKind.SwitchStatement]: [
{ name: "expression", test: isExpression },
{ name: "caseBlock", test: isCaseBlock },
{ name: "caseBlock", test: isCaseBlock }
],
[SyntaxKind.LabeledStatement]: [
{ name: "label", test: isIdentifier },
{ name: "statement", test: isStatement, lift: liftToBlock },
{ name: "statement", test: isStatement, lift: liftToBlock }
],
[SyntaxKind.ThrowStatement]: [
{ name: "expression", test: isExpression },
{ name: "expression", test: isExpression }
],
[SyntaxKind.TryStatement]: [
{ name: "tryBlock", test: isBlock },
{ name: "catchClause", test: isCatchClause, optional: true },
{ name: "finallyBlock", test: isBlock, optional: true },
{ name: "finallyBlock", test: isBlock, optional: true }
],
[SyntaxKind.VariableDeclaration]: [
{ name: "name", test: isBindingName },
{ name: "type", test: isTypeNode, optional: true },
{ name: "initializer", test: isExpression, optional: true, parenthesize: parenthesizeExpressionForList },
{ name: "initializer", test: isExpression, optional: true, parenthesize: parenthesizeExpressionForList }
],
[SyntaxKind.VariableDeclarationList]: [
{ name: "declarations", test: isVariableDeclaration },
{ name: "declarations", test: isVariableDeclaration }
],
[SyntaxKind.FunctionDeclaration]: [
{ name: "decorators", test: isDecorator },
@@ -307,7 +307,7 @@ namespace ts {
{ name: "typeParameters", test: isTypeParameter },
{ name: "parameters", test: isParameter },
{ name: "type", test: isTypeNode, optional: true },
{ name: "body", test: isBlock, optional: true },
{ name: "body", test: isBlock, optional: true }
],
[SyntaxKind.ClassDeclaration]: [
{ name: "decorators", test: isDecorator },
@@ -315,127 +315,127 @@ namespace ts {
{ name: "name", test: isIdentifier, optional: true },
{ name: "typeParameters", test: isTypeParameter },
{ name: "heritageClauses", test: isHeritageClause },
{ name: "members", test: isClassElement },
{ name: "members", test: isClassElement }
],
[SyntaxKind.EnumDeclaration]: [
{ name: "decorators", test: isDecorator },
{ name: "modifiers", test: isModifier },
{ name: "name", test: isIdentifier },
{ name: "members", test: isEnumMember },
{ name: "members", test: isEnumMember }
],
[SyntaxKind.ModuleDeclaration]: [
{ name: "decorators", test: isDecorator },
{ name: "modifiers", test: isModifier },
{ name: "name", test: isModuleName },
{ name: "body", test: isModuleBody },
{ name: "body", test: isModuleBody }
],
[SyntaxKind.ModuleBlock]: [
{ name: "statements", test: isStatement },
{ name: "statements", test: isStatement }
],
[SyntaxKind.CaseBlock]: [
{ name: "clauses", test: isCaseOrDefaultClause },
{ name: "clauses", test: isCaseOrDefaultClause }
],
[SyntaxKind.ImportEqualsDeclaration]: [
{ name: "decorators", test: isDecorator },
{ name: "modifiers", test: isModifier },
{ name: "name", test: isIdentifier },
{ name: "moduleReference", test: isModuleReference },
{ name: "moduleReference", test: isModuleReference }
],
[SyntaxKind.ImportDeclaration]: [
{ name: "decorators", test: isDecorator },
{ name: "modifiers", test: isModifier },
{ name: "importClause", test: isImportClause, optional: true },
{ name: "moduleSpecifier", test: isExpression },
{ name: "moduleSpecifier", test: isExpression }
],
[SyntaxKind.ImportClause]: [
{ name: "name", test: isIdentifier, optional: true },
{ name: "namedBindings", test: isNamedImportBindings, optional: true },
{ name: "namedBindings", test: isNamedImportBindings, optional: true }
],
[SyntaxKind.NamespaceImport]: [
{ name: "name", test: isIdentifier },
{ name: "name", test: isIdentifier }
],
[SyntaxKind.NamedImports]: [
{ name: "elements", test: isImportSpecifier },
{ name: "elements", test: isImportSpecifier }
],
[SyntaxKind.ImportSpecifier]: [
{ name: "propertyName", test: isIdentifier, optional: true },
{ name: "name", test: isIdentifier },
{ name: "name", test: isIdentifier }
],
[SyntaxKind.ExportAssignment]: [
{ name: "decorators", test: isDecorator },
{ name: "modifiers", test: isModifier },
{ name: "expression", test: isExpression },
{ name: "expression", test: isExpression }
],
[SyntaxKind.ExportDeclaration]: [
{ name: "decorators", test: isDecorator },
{ name: "modifiers", test: isModifier },
{ name: "exportClause", test: isNamedExports, optional: true },
{ name: "moduleSpecifier", test: isExpression, optional: true },
{ name: "moduleSpecifier", test: isExpression, optional: true }
],
[SyntaxKind.NamedExports]: [
{ name: "elements", test: isExportSpecifier },
{ name: "elements", test: isExportSpecifier }
],
[SyntaxKind.ExportSpecifier]: [
{ name: "propertyName", test: isIdentifier, optional: true },
{ name: "name", test: isIdentifier },
{ name: "name", test: isIdentifier }
],
[SyntaxKind.ExternalModuleReference]: [
{ name: "expression", test: isExpression, optional: true },
{ name: "expression", test: isExpression, optional: true }
],
[SyntaxKind.JsxElement]: [
{ name: "openingElement", test: isJsxOpeningElement },
{ name: "children", test: isJsxChild },
{ name: "closingElement", test: isJsxClosingElement },
{ name: "closingElement", test: isJsxClosingElement }
],
[SyntaxKind.JsxSelfClosingElement]: [
{ name: "tagName", test: isEntityName },
{ name: "attributes", test: isJsxAttributeLike },
{ name: "attributes", test: isJsxAttributeLike }
],
[SyntaxKind.JsxOpeningElement]: [
{ name: "tagName", test: isEntityName },
{ name: "attributes", test: isJsxAttributeLike },
{ name: "attributes", test: isJsxAttributeLike }
],
[SyntaxKind.JsxClosingElement]: [
{ name: "tagName", test: isEntityName },
{ name: "tagName", test: isEntityName }
],
[SyntaxKind.JsxAttribute]: [
{ name: "name", test: isIdentifier },
{ name: "initializer", test: isStringLiteralOrJsxExpression, optional: true },
{ name: "initializer", test: isStringLiteralOrJsxExpression, optional: true }
],
[SyntaxKind.JsxSpreadAttribute]: [
{ name: "expression", test: isExpression },
{ name: "expression", test: isExpression }
],
[SyntaxKind.JsxExpression]: [
{ name: "expression", test: isExpression, optional: true },
{ name: "expression", test: isExpression, optional: true }
],
[SyntaxKind.CaseClause]: [
{ name: "expression", test: isExpression, parenthesize: parenthesizeExpressionForList },
{ name: "statements", test: isStatement },
{ name: "statements", test: isStatement }
],
[SyntaxKind.DefaultClause]: [
{ name: "statements", test: isStatement },
{ name: "statements", test: isStatement }
],
[SyntaxKind.HeritageClause]: [
{ name: "types", test: isExpressionWithTypeArguments },
{ name: "types", test: isExpressionWithTypeArguments }
],
[SyntaxKind.CatchClause]: [
{ name: "variableDeclaration", test: isVariableDeclaration },
{ name: "block", test: isBlock },
{ name: "block", test: isBlock }
],
[SyntaxKind.PropertyAssignment]: [
{ name: "name", test: isPropertyName },
{ name: "initializer", test: isExpression, parenthesize: parenthesizeExpressionForList },
{ name: "initializer", test: isExpression, parenthesize: parenthesizeExpressionForList }
],
[SyntaxKind.ShorthandPropertyAssignment]: [
{ name: "name", test: isIdentifier },
{ name: "objectAssignmentInitializer", test: isExpression, optional: true },
{ name: "objectAssignmentInitializer", test: isExpression, optional: true }
],
[SyntaxKind.EnumMember]: [
{ name: "name", test: isPropertyName },
{ name: "initializer", test: isExpression, optional: true, parenthesize: parenthesizeExpressionForList },
{ name: "initializer", test: isExpression, optional: true, parenthesize: parenthesizeExpressionForList }
],
[SyntaxKind.SourceFile]: [
{ name: "statements", test: isStatement },
{ name: "statements", test: isStatement }
],
[SyntaxKind.NotEmittedStatement]: [],
[SyntaxKind.PartiallyEmittedExpression]: [
tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.js
+4 -4
View File
@@ -33,8 +33,8 @@ var Point = (function () {
}());
var Point;
(function (Point) {
function Origin() { return null; }
Point.Origin = Origin; //expected duplicate identifier error
function Origin() { return null; } //expected duplicate identifier error
Point.Origin = Origin;
})(Point || (Point = {}));
var A;
(function (A) {
@@ -49,7 +49,7 @@ var A;
A.Point = Point;
var Point;
(function (Point) {
function Origin() { return ""; }
Point.Origin = Origin; //expected duplicate identifier error
function Origin() { return ""; } //expected duplicate identifier error
Point.Origin = Origin;
})(Point = A.Point || (A.Point = {}));
})(A || (A = {}));
tests/baselines/reference/ambientDeclarationsExternal.js
+1 -1
View File
@@ -29,6 +29,6 @@ var n: number;
//// [consumer.js]
"use strict";
// Ambient external module members are always exported with or without export keyword when module lacks export assignment
var imp3 = require('equ2');
var imp3 = require("equ2");
var n = imp3.x;
var n;
tests/baselines/reference/ambientExternalModuleWithInternalImportDeclaration.js
+1 -1
View File
@@ -20,7 +20,7 @@ var c = new A();
//// [ambientExternalModuleWithInternalImportDeclaration_0.js]
//// [ambientExternalModuleWithInternalImportDeclaration_1.js]
define(["require", "exports", 'M'], function (require, exports, A) {
define(["require", "exports", "M"], function (require, exports, A) {
"use strict";
var c = new A();
});
tests/baselines/reference/ambientExternalModuleWithoutInternalImportDeclaration.js
+1 -1
View File
@@ -19,7 +19,7 @@ var c = new A();
//// [ambientExternalModuleWithoutInternalImportDeclaration_0.js]
//// [ambientExternalModuleWithoutInternalImportDeclaration_1.js]
define(["require", "exports", 'M'], function (require, exports, A) {
define(["require", "exports", "M"], function (require, exports, A) {
"use strict";
var c = new A();
});
tests/baselines/reference/amdImportNotAsPrimaryExpression.js
+1 -1
View File
@@ -40,8 +40,8 @@ define(["require", "exports"], function (require, exports) {
}
return C1;
}());
C1.s1 = true;
exports.C1 = C1;
C1.s1 = true;
(function (E1) {
E1[E1["A"] = 0] = "A";
E1[E1["B"] = 1] = "B";
tests/baselines/reference/arrowFunctionWithObjectLiteralBody1.js
+1 -1
View File
@@ -2,4 +2,4 @@
var v = a => <any>{}
//// [arrowFunctionWithObjectLiteralBody1.js]
var v = function (a) { return {}; };
var v = function (a) { return ({}); };
tests/baselines/reference/arrowFunctionWithObjectLiteralBody2.js
+1 -1
View File
@@ -2,4 +2,4 @@
var v = a => <any><any>{}
//// [arrowFunctionWithObjectLiteralBody2.js]
var v = function (a) { return {}; };
var v = function (a) { return ({}); };
tests/baselines/reference/asOperator4.js
+1 -1
View File
@@ -18,7 +18,7 @@ function foo() { }
exports.foo = foo;
//// [bar.js]
"use strict";
var foo_1 = require('./foo');
var foo_1 = require("./foo");
// These should emit identically
foo_1.foo;
foo_1.foo;
tests/baselines/reference/assignmentLHSIsValue.js
+1 -1
View File
@@ -113,7 +113,7 @@ false = value;
}
value;
// array literals
'' = value[0], '' = value[1];
"" = value[0], "" = value[1];
// super
var Derived = (function (_super) {
__extends(Derived, _super);
tests/baselines/reference/bind1.js
+2 -2
View File
@@ -12,6 +12,6 @@ var M;
function C() {
}
return C;
}());
M.C = C; // this should be an unresolved symbol I error
}()); // this should be an unresolved symbol I error
M.C = C;
})(M || (M = {}));
tests/baselines/reference/callSignaturesWithParameterInitializers2.js
+2 -1
View File
@@ -48,7 +48,8 @@ var b = {
foo: function (x) {
if (x === void 0) { x = 1; }
},
foo: function (x) {
foo: // error
function (x) {
if (x === void 0) { x = 1; }
}
};
tests/baselines/reference/capturedLetConstInLoop1.js
+22 -22
View File
@@ -114,15 +114,15 @@ for (const y = 0; y < 1;) {
}
//// [capturedLetConstInLoop1.js]
//==== let
var _loop_1 = function(x) {
var _loop_1 = function (x) {
(function () { return x; });
(function () { return x; });
};
//==== let
for (var x in {}) {
_loop_1(x);
}
var _loop_2 = function(x) {
var _loop_2 = function (x) {
(function () { return x; });
(function () { return x; });
};
@@ -130,14 +130,14 @@ for (var _i = 0, _a = []; _i < _a.length; _i++) {
var x = _a[_i];
_loop_2(x);
}
var _loop_3 = function(x) {
var _loop_3 = function (x) {
(function () { return x; });
(function () { return x; });
};
for (var x = 0; x < 1; ++x) {
_loop_3(x);
}
var _loop_4 = function() {
var _loop_4 = function () {
var x;
(function () { return x; });
(function () { return x; });
@@ -145,7 +145,7 @@ var _loop_4 = function() {
while (1 === 1) {
_loop_4();
}
var _loop_5 = function() {
var _loop_5 = function () {
var x;
(function () { return x; });
(function () { return x; });
@@ -153,7 +153,7 @@ var _loop_5 = function() {
do {
_loop_5();
} while (1 === 1);
var _loop_6 = function(y) {
var _loop_6 = function (y) {
var x = 1;
(function () { return x; });
(function () { return x; });
@@ -161,14 +161,14 @@ var _loop_6 = function(y) {
for (var y = 0; y < 1; ++y) {
_loop_6(y);
}
var _loop_7 = function(x, y) {
var _loop_7 = function (x, y) {
(function () { return x + y; });
(function () { return x + y; });
};
for (var x = 0, y = 1; x < 1; ++x) {
_loop_7(x, y);
}
var _loop_8 = function() {
var _loop_8 = function () {
var x, y;
(function () { return x + y; });
(function () { return x + y; });
@@ -176,7 +176,7 @@ var _loop_8 = function() {
while (1 === 1) {
_loop_8();
}
var _loop_9 = function() {
var _loop_9 = function () {
var x, y;
(function () { return x + y; });
(function () { return x + y; });
@@ -184,7 +184,7 @@ var _loop_9 = function() {
do {
_loop_9();
} while (1 === 1);
var _loop_10 = function(y) {
var _loop_10 = function (y) {
var x = 1;
(function () { return x + y; });
(function () { return x + y; });
@@ -192,15 +192,15 @@ var _loop_10 = function(y) {
for (var y = 0; y < 1; ++y) {
_loop_10(y);
}
//=========const
var _loop_11 = function(x) {
var _loop_11 = function (x) {
(function () { return x; });
(function () { return x; });
};
//=========const
for (var x in {}) {
_loop_11(x);
}
var _loop_12 = function(x) {
var _loop_12 = function (x) {
(function () { return x; });
(function () { return x; });
};
@@ -208,14 +208,14 @@ for (var _b = 0, _c = []; _b < _c.length; _b++) {
var x = _c[_b];
_loop_12(x);
}
var _loop_13 = function(x) {
var _loop_13 = function (x) {
(function () { return x; });
(function () { return x; });
};
for (var x = 0; x < 1;) {
_loop_13(x);
}
var _loop_14 = function() {
var _loop_14 = function () {
var x = 1;
(function () { return x; });
(function () { return x; });
@@ -223,7 +223,7 @@ var _loop_14 = function() {
while (1 === 1) {
_loop_14();
}
var _loop_15 = function() {
var _loop_15 = function () {
var x = 1;
(function () { return x; });
(function () { return x; });
@@ -231,7 +231,7 @@ var _loop_15 = function() {
do {
_loop_15();
} while (1 === 1);
var _loop_16 = function(y) {
var _loop_16 = function (y) {
var x = 1;
(function () { return x; });
(function () { return x; });
@@ -239,14 +239,14 @@ var _loop_16 = function(y) {
for (var y = 0; y < 1;) {
_loop_16(y);
}
var _loop_17 = function(x, y) {
var _loop_17 = function (x, y) {
(function () { return x + y; });
(function () { return x + y; });
};
for (var x = 0, y = 1; x < 1;) {
_loop_17(x, y);
}
var _loop_18 = function() {
var _loop_18 = function () {
var x = 1, y = 1;
(function () { return x + y; });
(function () { return x + y; });
@@ -254,7 +254,7 @@ var _loop_18 = function() {
while (1 === 1) {
_loop_18();
}
var _loop_19 = function() {
var _loop_19 = function () {
var x = 1, y = 1;
(function () { return x + y; });
(function () { return x + y; });
@@ -262,7 +262,7 @@ var _loop_19 = function() {
do {
_loop_19();
} while (1 === 1);
var _loop_20 = function(y) {
var _loop_20 = function (y) {
var x = 1;
(function () { return x + y; });
(function () { return x + y; });
tests/baselines/reference/capturedLetConstInLoop6.js
+62 -42
View File
@@ -239,8 +239,7 @@ for (const y = 0; y < 1;) {
//// [capturedLetConstInLoop6.js]
// ====let
var _loop_1 = function(x) {
var _loop_1 = function (x) {
(function () { return x; });
(function () { return x; });
if (x == 1) {
@@ -250,12 +249,14 @@ var _loop_1 = function(x) {
return "continue";
}
};
// ====let
for (var _i = 0, _a = []; _i < _a.length; _i++) {
var x = _a[_i];
var state_1 = _loop_1(x);
if (state_1 === "break") break;
if (state_1 === "break")
break;
}
var _loop_2 = function(x) {
var _loop_2 = function (x) {
(function () { return x; });
(function () { return x; });
if (x == "1") {
@@ -267,9 +268,10 @@ var _loop_2 = function(x) {
};
for (var x in []) {
var state_2 = _loop_2(x);
if (state_2 === "break") break;
if (state_2 === "break")
break;
}
var _loop_3 = function(x) {
var _loop_3 = function (x) {
(function () { return x; });
(function () { return x; });
if (x == 1) {
@@ -281,9 +283,10 @@ var _loop_3 = function(x) {
};
for (var x = 0; x < 1; ++x) {
var state_3 = _loop_3(x);
if (state_3 === "break") break;
if (state_3 === "break")
break;
}
var _loop_4 = function() {
var _loop_4 = function () {
var x;
(function () { return x; });
(function () { return x; });
@@ -296,9 +299,10 @@ var _loop_4 = function() {
};
while (1 === 1) {
var state_4 = _loop_4();
if (state_4 === "break") break;
if (state_4 === "break")
break;
}
var _loop_5 = function() {
var _loop_5 = function () {
var x;
(function () { return x; });
(function () { return x; });
@@ -311,9 +315,10 @@ var _loop_5 = function() {
};
do {
var state_5 = _loop_5();
if (state_5 === "break") break;
if (state_5 === "break")
break;
} while (1 === 1);
var _loop_6 = function(y) {
var _loop_6 = function (y) {
var x = 1;
(function () { return x; });
(function () { return x; });
@@ -326,9 +331,10 @@ var _loop_6 = function(y) {
};
for (var y = 0; y < 1; ++y) {
var state_6 = _loop_6(y);
if (state_6 === "break") break;
if (state_6 === "break")
break;
}
var _loop_7 = function(x, y) {
var _loop_7 = function (x, y) {
(function () { return x + y; });
(function () { return x + y; });
if (x == 1) {
@@ -340,9 +346,10 @@ var _loop_7 = function(x, y) {
};
for (var x = 0, y = 1; x < 1; ++x) {
var state_7 = _loop_7(x, y);
if (state_7 === "break") break;
if (state_7 === "break")
break;
}
var _loop_8 = function() {
var _loop_8 = function () {
var x, y;
(function () { return x + y; });
(function () { return x + y; });
@@ -355,9 +362,10 @@ var _loop_8 = function() {
};
while (1 === 1) {
var state_8 = _loop_8();
if (state_8 === "break") break;
if (state_8 === "break")
break;
}
var _loop_9 = function() {
var _loop_9 = function () {
var x, y;
(function () { return x + y; });
(function () { return x + y; });
@@ -370,9 +378,10 @@ var _loop_9 = function() {
};
do {
var state_9 = _loop_9();
if (state_9 === "break") break;
if (state_9 === "break")
break;
} while (1 === 1);
var _loop_10 = function(y) {
var _loop_10 = function (y) {
var x = 1;
(function () { return x + y; });
(function () { return x + y; });
@@ -385,10 +394,10 @@ var _loop_10 = function(y) {
};
for (var y = 0; y < 1; ++y) {
var state_10 = _loop_10(y);
if (state_10 === "break") break;
if (state_10 === "break")
break;
}
// ====const
var _loop_11 = function(x) {
var _loop_11 = function (x) {
(function () { return x; });
(function () { return x; });
if (x == 1) {
@@ -398,12 +407,14 @@ var _loop_11 = function(x) {
return "continue";
}
};
// ====const
for (var _b = 0, _c = []; _b < _c.length; _b++) {
var x = _c[_b];
var state_11 = _loop_11(x);
if (state_11 === "break") break;
if (state_11 === "break")
break;
}
var _loop_12 = function(x) {
var _loop_12 = function (x) {
(function () { return x; });
(function () { return x; });
if (x == "1") {
@@ -415,9 +426,10 @@ var _loop_12 = function(x) {
};
for (var x in []) {
var state_12 = _loop_12(x);
if (state_12 === "break") break;
if (state_12 === "break")
break;
}
var _loop_13 = function(x) {
var _loop_13 = function (x) {
(function () { return x; });
(function () { return x; });
if (x == 1) {
@@ -429,9 +441,10 @@ var _loop_13 = function(x) {
};
for (var x = 0; x < 1;) {
var state_13 = _loop_13(x);
if (state_13 === "break") break;
if (state_13 === "break")
break;
}
var _loop_14 = function() {
var _loop_14 = function () {
var x = 1;
(function () { return x; });
(function () { return x; });
@@ -444,9 +457,10 @@ var _loop_14 = function() {
};
while (1 === 1) {
var state_14 = _loop_14();
if (state_14 === "break") break;
if (state_14 === "break")
break;
}
var _loop_15 = function() {
var _loop_15 = function () {
var x = 1;
(function () { return x; });
(function () { return x; });
@@ -459,9 +473,10 @@ var _loop_15 = function() {
};
do {
var state_15 = _loop_15();
if (state_15 === "break") break;
if (state_15 === "break")
break;
} while (1 === 1);
var _loop_16 = function(y) {
var _loop_16 = function (y) {
var x = 1;
(function () { return x; });
(function () { return x; });
@@ -474,9 +489,10 @@ var _loop_16 = function(y) {
};
for (var y = 0; y < 1;) {
var state_16 = _loop_16(y);
if (state_16 === "break") break;
if (state_16 === "break")
break;
}
var _loop_17 = function(x, y) {
var _loop_17 = function (x, y) {
(function () { return x + y; });
(function () { return x + y; });
if (x == 1) {
@@ -488,9 +504,10 @@ var _loop_17 = function(x, y) {
};
for (var x = 0, y = 1; x < 1;) {
var state_17 = _loop_17(x, y);
if (state_17 === "break") break;
if (state_17 === "break")
break;
}
var _loop_18 = function() {
var _loop_18 = function () {
var x = 1, y = 1;
(function () { return x + y; });
(function () { return x + y; });
@@ -503,9 +520,10 @@ var _loop_18 = function() {
};
while (1 === 1) {
var state_18 = _loop_18();
if (state_18 === "break") break;
if (state_18 === "break")
break;
}
var _loop_19 = function() {
var _loop_19 = function () {
var x = 1, y = 1;
(function () { return x + y; });
(function () { return x + y; });
@@ -518,9 +536,10 @@ var _loop_19 = function() {
};
do {
var state_19 = _loop_19();
if (state_19 === "break") break;
if (state_19 === "break")
break;
} while (1 === 1);
var _loop_20 = function(y) {
var _loop_20 = function (y) {
var x = 1;
(function () { return x + y; });
(function () { return x + y; });
@@ -533,5 +552,6 @@ var _loop_20 = function(y) {
};
for (var y = 0; y < 1;) {
var state_20 = _loop_20(y);
if (state_20 === "break") break;
if (state_20 === "break")
break;
}
tests/baselines/reference/capturedLetConstInLoop7.js
+82 -62
View File
@@ -376,8 +376,7 @@ for (const y = 0; y < 1;) {
}
//// [capturedLetConstInLoop7.js]
//===let
var _loop_1 = function(x) {
var _loop_1 = function (x) {
(function () { return x; });
(function () { return x; });
if (x == 1) {
@@ -393,16 +392,18 @@ var _loop_1 = function(x) {
return "continue-l0";
}
};
//===let
l0: for (var _i = 0, _a = []; _i < _a.length; _i++) {
var x = _a[_i];
var state_1 = _loop_1(x);
if (state_1 === "break") break;
switch(state_1) {
if (state_1 === "break")
break;
switch (state_1) {
case "break-l0": break l0;
case "continue-l0": continue l0;
}
}
var _loop_2 = function(x) {
var _loop_2 = function (x) {
(function () { return x; });
(function () { return x; });
if (x == "1") {
@@ -420,13 +421,14 @@ var _loop_2 = function(x) {
};
l00: for (var x in []) {
var state_2 = _loop_2(x);
if (state_2 === "break") break;
switch(state_2) {
if (state_2 === "break")
break;
switch (state_2) {
case "break-l00": break l00;
case "continue-l00": continue l00;
}
}
var _loop_3 = function(x) {
var _loop_3 = function (x) {
(function () { return x; });
(function () { return x; });
if (x == 1) {
@@ -444,13 +446,14 @@ var _loop_3 = function(x) {
};
l1: for (var x = 0; x < 1; ++x) {
var state_3 = _loop_3(x);
if (state_3 === "break") break;
switch(state_3) {
if (state_3 === "break")
break;
switch (state_3) {
case "break-l1": break l1;
case "continue-l1": continue l1;
}
}
var _loop_4 = function() {
var _loop_4 = function () {
var x;
(function () { return x; });
(function () { return x; });
@@ -469,13 +472,14 @@ var _loop_4 = function() {
};
l2: while (1 === 1) {
var state_4 = _loop_4();
if (state_4 === "break") break;
switch(state_4) {
if (state_4 === "break")
break;
switch (state_4) {
case "break-l2": break l2;
case "continue-l2": continue l2;
}
}
var _loop_5 = function() {
var _loop_5 = function () {
var x;
(function () { return x; });
(function () { return x; });
@@ -494,13 +498,14 @@ var _loop_5 = function() {
};
l3: do {
var state_5 = _loop_5();
if (state_5 === "break") break;
switch(state_5) {
if (state_5 === "break")
break;
switch (state_5) {
case "break-l3": break l3;
case "continue-l3": continue l3;
}
} while (1 === 1);
var _loop_6 = function(y) {
var _loop_6 = function (y) {
var x = 1;
(function () { return x; });
(function () { return x; });
@@ -519,13 +524,14 @@ var _loop_6 = function(y) {
};
l4: for (var y = 0; y < 1; ++y) {
var state_6 = _loop_6(y);
if (state_6 === "break") break;
switch(state_6) {
if (state_6 === "break")
break;
switch (state_6) {
case "break-l4": break l4;
case "continue-l4": continue l4;
}
}
var _loop_7 = function(x, y) {
var _loop_7 = function (x, y) {
(function () { return x + y; });
(function () { return x + y; });
if (x == 1) {
@@ -543,13 +549,14 @@ var _loop_7 = function(x, y) {
};
l5: for (var x = 0, y = 1; x < 1; ++x) {
var state_7 = _loop_7(x, y);
if (state_7 === "break") break;
switch(state_7) {
if (state_7 === "break")
break;
switch (state_7) {
case "break-l5": break l5;
case "continue-l5": continue l5;
}
}
var _loop_8 = function() {
var _loop_8 = function () {
var x, y;
(function () { return x + y; });
(function () { return x + y; });
@@ -568,13 +575,14 @@ var _loop_8 = function() {
};
l6: while (1 === 1) {
var state_8 = _loop_8();
if (state_8 === "break") break;
switch(state_8) {
if (state_8 === "break")
break;
switch (state_8) {
case "break-l6": break l6;
case "continue-l6": continue l6;
}
}
var _loop_9 = function() {
var _loop_9 = function () {
var x, y;
(function () { return x + y; });
(function () { return x + y; });
@@ -593,13 +601,14 @@ var _loop_9 = function() {
};
l7: do {
var state_9 = _loop_9();
if (state_9 === "break") break;
switch(state_9) {
if (state_9 === "break")
break;
switch (state_9) {
case "break-l7": break l7;
case "continue-l7": continue l7;
}
} while (1 === 1);
var _loop_10 = function(y) {
var _loop_10 = function (y) {
var x = 1;
(function () { return x + y; });
(function () { return x + y; });
@@ -618,14 +627,14 @@ var _loop_10 = function(y) {
};
l8: for (var y = 0; y < 1; ++y) {
var state_10 = _loop_10(y);
if (state_10 === "break") break;
switch(state_10) {
if (state_10 === "break")
break;
switch (state_10) {
case "break-l8": break l8;
case "continue-l8": continue l8;
}
}
//===const
var _loop_11 = function(x) {
var _loop_11 = function (x) {
(function () { return x; });
(function () { return x; });
if (x == 1) {
@@ -641,16 +650,18 @@ var _loop_11 = function(x) {
return "continue-l0_c";
}
};
//===const
l0_c: for (var _b = 0, _c = []; _b < _c.length; _b++) {
var x = _c[_b];
var state_11 = _loop_11(x);
if (state_11 === "break") break;
switch(state_11) {
if (state_11 === "break")
break;
switch (state_11) {
case "break-l0_c": break l0_c;
case "continue-l0_c": continue l0_c;
}
}
var _loop_12 = function(x) {
var _loop_12 = function (x) {
(function () { return x; });
(function () { return x; });
if (x == "1") {
@@ -668,13 +679,14 @@ var _loop_12 = function(x) {
};
l00_c: for (var x in []) {
var state_12 = _loop_12(x);
if (state_12 === "break") break;
switch(state_12) {
if (state_12 === "break")
break;
switch (state_12) {
case "break-l00_c": break l00_c;
case "continue-l00_c": continue l00_c;
}
}
var _loop_13 = function(x) {
var _loop_13 = function (x) {
(function () { return x; });
(function () { return x; });
if (x == 1) {
@@ -692,13 +704,14 @@ var _loop_13 = function(x) {
};
l1_c: for (var x = 0; x < 1;) {
var state_13 = _loop_13(x);
if (state_13 === "break") break;
switch(state_13) {
if (state_13 === "break")
break;
switch (state_13) {
case "break-l1_c": break l1_c;
case "continue-l1_c": continue l1_c;
}
}
var _loop_14 = function() {
var _loop_14 = function () {
var x = 1;
(function () { return x; });
(function () { return x; });
@@ -717,13 +730,14 @@ var _loop_14 = function() {
};
l2_c: while (1 === 1) {
var state_14 = _loop_14();
if (state_14 === "break") break;
switch(state_14) {
if (state_14 === "break")
break;
switch (state_14) {
case "break-l2_c": break l2_c;
case "continue-l2_c": continue l2_c;
}
}
var _loop_15 = function() {
var _loop_15 = function () {
var x = 1;
(function () { return x; });
(function () { return x; });
@@ -742,13 +756,14 @@ var _loop_15 = function() {
};
l3_c: do {
var state_15 = _loop_15();
if (state_15 === "break") break;
switch(state_15) {
if (state_15 === "break")
break;
switch (state_15) {
case "break-l3_c": break l3_c;
case "continue-l3_c": continue l3_c;
}
} while (1 === 1);
var _loop_16 = function(y) {
var _loop_16 = function (y) {
var x = 1;
(function () { return x; });
(function () { return x; });
@@ -767,13 +782,14 @@ var _loop_16 = function(y) {
};
l4_c: for (var y = 0; y < 1;) {
var state_16 = _loop_16(y);
if (state_16 === "break") break;
switch(state_16) {
if (state_16 === "break")
break;
switch (state_16) {
case "break-l4_c": break l4_c;
case "continue-l4_c": continue l4_c;
}
}
var _loop_17 = function(x, y) {
var _loop_17 = function (x, y) {
(function () { return x + y; });
(function () { return x + y; });
if (x == 1) {
@@ -791,13 +807,14 @@ var _loop_17 = function(x, y) {
};
l5_c: for (var x = 0, y = 1; x < 1;) {
var state_17 = _loop_17(x, y);
if (state_17 === "break") break;
switch(state_17) {
if (state_17 === "break")
break;
switch (state_17) {
case "break-l5_c": break l5_c;
case "continue-l5_c": continue l5_c;
}
}
var _loop_18 = function() {
var _loop_18 = function () {
var x = 1, y = 1;
(function () { return x + y; });
(function () { return x + y; });
@@ -816,13 +833,14 @@ var _loop_18 = function() {
};
l6_c: while (1 === 1) {
var state_18 = _loop_18();
if (state_18 === "break") break;
switch(state_18) {
if (state_18 === "break")
break;
switch (state_18) {
case "break-l6_c": break l6_c;
case "continue-l6_c": continue l6_c;
}
}
var _loop_19 = function() {
var _loop_19 = function () {
var x = 1, y = 1;
(function () { return x + y; });
(function () { return x + y; });
@@ -841,13 +859,14 @@ var _loop_19 = function() {
};
l7_c: do {
var state_19 = _loop_19();
if (state_19 === "break") break;
switch(state_19) {
if (state_19 === "break")
break;
switch (state_19) {
case "break-l7_c": break l7_c;
case "continue-l7_c": continue l7_c;
}
} while (1 === 1);
var _loop_20 = function(y) {
var _loop_20 = function (y) {
var x = 1;
(function () { return x + y; });
(function () { return x + y; });
@@ -866,8 +885,9 @@ var _loop_20 = function(y) {
};
l8_c: for (var y = 0; y < 1;) {
var state_20 = _loop_20(y);
if (state_20 === "break") break;
switch(state_20) {
if (state_20 === "break")
break;
switch (state_20) {
case "break-l8_c": break l8_c;
case "continue-l8_c": continue l8_c;
}
tests/baselines/reference/castExpressionParentheses.js
+1 -1
View File
@@ -53,7 +53,7 @@ new (<any>A());
//// [castExpressionParentheses.js]
// parentheses should be omitted
// literals
{ a: 0 };
({ a: 0 });
[1, 3,];
"string";
23.0;
tests/baselines/reference/chainedImportAlias.js
+1 -1
View File
@@ -20,6 +20,6 @@ var m;
})(m = exports.m || (exports.m = {}));
//// [chainedImportAlias_file1.js]
"use strict";
var x = require('./chainedImportAlias_file0');
var x = require("./chainedImportAlias_file0");
var y = x;
y.m.foo();
tests/baselines/reference/circularReference.js
+2 -2
View File
@@ -35,7 +35,7 @@ export module M1 {
//// [foo1.js]
"use strict";
var foo2 = require('./foo2');
var foo2 = require("./foo2");
var M1;
(function (M1) {
var C1 = (function () {
@@ -50,7 +50,7 @@ var M1;
})(M1 = exports.M1 || (exports.M1 = {}));
//// [foo2.js]
"use strict";
var foo1 = require('./foo1');
var foo1 = require("./foo1");
var M1;
(function (M1) {
var C1 = (function () {
tests/baselines/reference/classExtendsAcrossFiles.js
+2 -2
View File
@@ -26,7 +26,7 @@ var __extends = (this && this.__extends) || function (d, b) {
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var a_1 = require('./a');
var a_1 = require("./a");
exports.b = {
f: function () {
var A = (function () {
@@ -51,7 +51,7 @@ var __extends = (this && this.__extends) || function (d, b) {
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var b_1 = require('./b');
var b_1 = require("./b");
exports.a = {
f: function () {
var A = (function () {
tests/baselines/reference/collisionExportsRequireAndAlias.js
+1 -1
View File
@@ -32,7 +32,7 @@ define(["require", "exports"], function (require, exports) {
exports.bar2 = bar2;
});
//// [collisionExportsRequireAndAlias_file2.js]
define(["require", "exports", 'collisionExportsRequireAndAlias_file1', 'collisionExportsRequireAndAlias_file3333'], function (require, exports, require, exports) {
define(["require", "exports", "collisionExportsRequireAndAlias_file1", "collisionExportsRequireAndAlias_file3333"], function (require, exports, require, exports) {
"use strict";
function foo() {
require.bar();
tests/baselines/reference/commentsFunction.js
+1 -1
View File
@@ -84,7 +84,7 @@ function blah(a /* multiline trailing comment
function blah2(a /* single line multiple trailing comments */ /* second */) {
}
function blah3(a // trailing commen single line
) {
) {
}
lambdaFoo = function (a, b) { return a * b; }; // This is trailing comment
/*leading comment*/ (function () { return 0; }); // Needs to be wrapped in parens to be a valid expression (not declaration)
tests/baselines/reference/commonJSImportAsPrimaryExpression.js
+1 -1
View File
@@ -21,8 +21,8 @@ var C1 = (function () {
}
return C1;
}());
C1.s1 = true;
exports.C1 = C1;
C1.s1 = true;
//// [foo_1.js]
"use strict";
var foo = require("./foo_0");
tests/baselines/reference/commonJSImportNotAsPrimaryExpression.js
+1 -1
View File
@@ -39,8 +39,8 @@ var C1 = (function () {
}
return C1;
}());
C1.s1 = true;
exports.C1 = C1;
C1.s1 = true;
(function (E1) {
E1[E1["A"] = 0] = "A";
E1[E1["B"] = 1] = "B";
tests/baselines/reference/commonjsSafeImport.js
+1 -1
View File
@@ -16,7 +16,7 @@ function Foo() { }
exports.Foo = Foo;
//// [main.js]
"use strict";
var _10_lib_1 = require('./10_lib');
var _10_lib_1 = require("./10_lib");
_10_lib_1.Foo();
tests/baselines/reference/computedPropertyNames11_ES5.js
+10
View File
@@ -46,6 +46,16 @@ var v = (_a = {},
enumerable: true,
configurable: true
}),
Object.defineProperty(_a, "", {
set: function (v) { },
enumerable: true,
configurable: true
}),
Object.defineProperty(_a, 0, {
get: function () { return 0; },
enumerable: true,
configurable: true
}),
Object.defineProperty(_a, a, {
set: function (v) { },
enumerable: true,
tests/baselines/reference/constDeclarations-access5.js
+1 -1
View File
@@ -54,7 +54,7 @@ define(["require", "exports"], function (require, exports) {
exports.x = 0;
});
//// [constDeclarations_access_2.js]
define(["require", "exports", 'constDeclarations_access_1'], function (require, exports, m) {
define(["require", "exports", "constDeclarations_access_1"], function (require, exports, m) {
"use strict";
// Errors
m.x = 1;
tests/baselines/reference/constructorArgsErrors1.js
+1 -1
View File
@@ -6,7 +6,7 @@ class foo {
//// [constructorArgsErrors1.js]
var foo = (function () {
function foo(a) {
function foo(static a) {
}
return foo;
}());
tests/baselines/reference/constructorArgsErrors5.js
+1 -1
View File
@@ -7,7 +7,7 @@ class foo {
//// [constructorArgsErrors5.js]
var foo = (function () {
function foo(a) {
function foo(export a) {
}
return foo;
}());
tests/baselines/reference/contextuallyTypedClassExpressionMethodDeclaration01.js
+4 -4
View File
@@ -61,7 +61,7 @@ function getFoo1() {
}());
}
function getFoo2() {
return (_a = (function () {
return _a = (function () {
function class_2() {
}
return class_2;
@@ -72,11 +72,11 @@ function getFoo2() {
_a.method2 = function (arg) {
arg.strProp = "hello";
},
_a);
_a;
var _a;
}
function getFoo3() {
return (_a = (function () {
return _a = (function () {
function class_3() {
}
return class_3;
@@ -87,6 +87,6 @@ function getFoo3() {
_a.method2 = function (arg) {
arg.strProp = "hello";
},
_a);
_a;
var _a;
}
tests/baselines/reference/declFileForExportedImport.js
+1 -1
View File
@@ -16,7 +16,7 @@ var z = b.x;
//// [declFileForExportedImport_1.js]
"use strict";
///<reference path='declFileForExportedImport_0.ts'/>
exports.a = require('./declFileForExportedImport_0');
exports.a = require("./declFileForExportedImport_0");
var y = exports.a.x;
exports.b = exports.a;
var z = exports.b.x;
tests/baselines/reference/declarationEmit_inferedDefaultExportType.js
+1
View File
@@ -10,6 +10,7 @@ export default {
//// [declarationEmit_inferedDefaultExportType.js]
"use strict";
exports.__esModule = true;
// test.ts
exports["default"] = {
foo: [],
bar: undefined,
tests/baselines/reference/declarationEmit_invalidExport.js
+1 -1
View File
@@ -10,5 +10,5 @@ export type MyClass = typeof myClass;
//// [declarationEmit_invalidExport.js]
"use strict";
if (false) {
exports.myClass = 0;
export var myClass = 0;
}
tests/baselines/reference/declarationEmit_nameConflicts.js
+1 -1
View File
@@ -63,7 +63,7 @@ var f;
module.exports = f;
//// [declarationEmit_nameConflicts_0.js]
"use strict";
var im = require('./declarationEmit_nameConflicts_1');
var im = require("./declarationEmit_nameConflicts_1");
var M;
(function (M) {
function f() { }
tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.js
+11 -11
View File
@@ -13,19 +13,19 @@ var decorator: ClassDecorator;
export default class {}
//// [a.js]
System.register([], function(exports_1, context_1) {
System.register([], function (exports_1, context_1) {
"use strict";
var __moduleName = context_1 && context_1.id;
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __moduleName = context_1 && context_1.id;
var decorator, Foo;
return {
setters:[],
execute: function() {
setters: [],
execute: function () {
Foo = class Foo {
};
Foo = __decorate([
@@ -33,22 +33,22 @@ System.register([], function(exports_1, context_1) {
], Foo);
exports_1("default", Foo);
}
}
};
});
//// [b.js]
System.register([], function(exports_1, context_1) {
System.register([], function (exports_1, context_1) {
"use strict";
var __moduleName = context_1 && context_1.id;
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var decorator, default_1;
var __moduleName = context_1 && context_1.id;
var decorator, default_1_1;
return {
setters:[],
execute: function() {
setters: [],
execute: function () {
default_1 = class {
};
default_1 = __decorate([
@@ -56,5 +56,5 @@ System.register([], function(exports_1, context_1) {
], default_1);
exports_1("default", default_1);
}
}
};
});
tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.js
+1 -1
View File
@@ -33,7 +33,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var a_1 = require('./a');
var a_1 = require("./a");
function filter(handler) {
return function (target, propertyKey) {
// ...
tests/baselines/reference/decoratorMetadataOnInferredType.js
+4 -4
View File
@@ -33,8 +33,8 @@ var B = (function () {
}
return B;
}());
__decorate([
decorator,
__metadata('design:type', Object)
], B.prototype, "x", void 0);
exports.B = B;
__decorate([
decorator,
__metadata("design:type", Object)
], B.prototype, "x", void 0);
tests/baselines/reference/decoratorMetadataWithConstructorType.js
+4 -4
View File
@@ -33,8 +33,8 @@ var B = (function () {
}
return B;
}());
__decorate([
decorator,
__metadata('design:type', A)
], B.prototype, "x", void 0);
exports.B = B;
__decorate([
decorator,
__metadata("design:type", A)
], B.prototype, "x", void 0);
tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision.js
+3 -3
View File
@@ -35,7 +35,7 @@ var db = (function () {
exports.db = db;
//// [service.js]
"use strict";
var db_1 = require('./db');
var db_1 = require("./db");
function someDecorator(target) {
return target;
}
@@ -47,7 +47,7 @@ var MyClass = (function () {
return MyClass;
}());
MyClass = __decorate([
someDecorator,
__metadata('design:paramtypes', [db_1.db])
someDecorator,
__metadata("design:paramtypes", [db_1.db])
], MyClass);
exports.MyClass = MyClass;
tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision2.js
+3 -3
View File
@@ -35,7 +35,7 @@ var db = (function () {
exports.db = db;
//// [service.js]
"use strict";
var db_1 = require('./db');
var db_1 = require("./db");
function someDecorator(target) {
return target;
}
@@ -47,7 +47,7 @@ var MyClass = (function () {
return MyClass;
}());
MyClass = __decorate([
someDecorator,
__metadata('design:paramtypes', [db_1.db])
someDecorator,
__metadata("design:paramtypes", [db_1.db])
], MyClass);
exports.MyClass = MyClass;
tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision3.js
+3 -3
View File
@@ -35,7 +35,7 @@ var db = (function () {
exports.db = db;
//// [service.js]
"use strict";
var db = require('./db');
var db = require("./db");
function someDecorator(target) {
return target;
}
@@ -47,7 +47,7 @@ var MyClass = (function () {
return MyClass;
}());
MyClass = __decorate([
someDecorator,
__metadata('design:paramtypes', [db.db])
someDecorator,
__metadata("design:paramtypes", [db.db])
], MyClass);
exports.MyClass = MyClass;
tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision4.js
+3 -3
View File
@@ -35,7 +35,7 @@ var db = (function () {
exports.db = db;
//// [service.js]
"use strict";
var db_1 = require('./db'); // error no default export
var db_1 = require("./db"); // error no default export
function someDecorator(target) {
return target;
}
@@ -47,7 +47,7 @@ var MyClass = (function () {
return MyClass;
}());
MyClass = __decorate([
someDecorator,
__metadata('design:paramtypes', [Object])
someDecorator,
__metadata("design:paramtypes", [Object])
], MyClass);
exports.MyClass = MyClass;
tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision5.js
+3 -3
View File
@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
exports.default = db;
//// [service.js]
"use strict";
var db_1 = require('./db');
var db_1 = require("./db");
function someDecorator(target) {
return target;
}
@@ -48,7 +48,7 @@ var MyClass = (function () {
return MyClass;
}());
MyClass = __decorate([
someDecorator,
__metadata('design:paramtypes', [db_1.default])
someDecorator,
__metadata("design:paramtypes", [db_1.default])
], MyClass);
exports.MyClass = MyClass;
tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision6.js
+3 -3
View File
@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
exports.default = db;
//// [service.js]
"use strict";
var db_1 = require('./db');
var db_1 = require("./db");
function someDecorator(target) {
return target;
}
@@ -48,7 +48,7 @@ var MyClass = (function () {
return MyClass;
}());
MyClass = __decorate([
someDecorator,
__metadata('design:paramtypes', [db_1.default])
someDecorator,
__metadata("design:paramtypes", [db_1.default])
], MyClass);
exports.MyClass = MyClass;
tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision7.js
+3 -3
View File
@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
exports.default = db;
//// [service.js]
"use strict";
var db_1 = require('./db');
var db_1 = require("./db");
function someDecorator(target) {
return target;
}
@@ -48,7 +48,7 @@ var MyClass = (function () {
return MyClass;
}());
MyClass = __decorate([
someDecorator,
__metadata('design:paramtypes', [Object])
someDecorator,
__metadata("design:paramtypes", [Object])
], MyClass);
exports.MyClass = MyClass;
tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision8.js
+3 -3
View File
@@ -35,7 +35,7 @@ var db = (function () {
exports.db = db;
//// [service.js]
"use strict";
var database = require('./db');
var database = require("./db");
function someDecorator(target) {
return target;
}
@@ -47,7 +47,7 @@ var MyClass = (function () {
return MyClass;
}());
MyClass = __decorate([
someDecorator,
__metadata('design:paramtypes', [database.db])
someDecorator,
__metadata("design:paramtypes", [database.db])
], MyClass);
exports.MyClass = MyClass;
tests/baselines/reference/dependencyViaImportAlias.js
+1 -1
View File
@@ -21,7 +21,7 @@ define(["require", "exports"], function (require, exports) {
exports.A = A;
});
//// [B.js]
define(["require", "exports", 'A'], function (require, exports, a) {
define(["require", "exports", "A"], function (require, exports, a) {
"use strict";
var A = a.A;
return A;
tests/baselines/reference/destructuringParameterDeclaration6.js
+7
View File
@@ -32,10 +32,17 @@ function a(_a) {
function a1(_a) {
var public = _a.public;
}
function a4(_a) { }
while (, )
for (, public; ; )
;
{ }
function a5() {
var = [];
for (var _i = 0; _i < arguments.length; _i++) {
[_i - 0] = arguments[_i];
}
}
while () { }
function a6() {
var public = [];
tests/baselines/reference/duplicateIdentifiersAcrossContainerBoundaries.js
+4 -4
View File
@@ -73,8 +73,8 @@ var M;
function f() {
}
return f;
}());
M.f = f; // error
}()); // error
M.f = f;
})(M || (M = {}));
var M;
(function (M) {
@@ -86,8 +86,8 @@ var M;
function g() {
}
return g;
}());
M.g = g; // no error
}()); // no error
M.g = g;
})(M || (M = {}));
var M;
(function (M) {
tests/baselines/reference/duplicateSymbolsExportMatching.js
+2 -2
View File
@@ -92,8 +92,8 @@ define(["require", "exports"], function (require, exports) {
(function (F) {
var t;
})(F || (F = {}));
function F() { }
M.F = F; // Only one error for duplicate identifier (don't consider visibility)
function F() { } // Only one error for duplicate identifier (don't consider visibility)
M.F = F;
})(M || (M = {}));
var M;
(function (M) {
tests/baselines/reference/elidingImportNames.js
+2 -2
View File
@@ -23,8 +23,8 @@ exports.main = 10;
exports.main = 10;
//// [elidingImportNames_test.js]
"use strict";
var a = require('./elidingImportNames_main'); // alias used in typeof
var a = require("./elidingImportNames_main"); // alias used in typeof
var b = a;
var x;
var a2 = require('./elidingImportNames_main1'); // alias not used in typeof
var a2 = require("./elidingImportNames_main1"); // alias not used in typeof
var b2 = a2;
tests/baselines/reference/emitArrowFunctionWhenUsingArguments01_ES6.js
+4 -4
View File
@@ -41,9 +41,9 @@ var b = function () {
};
};
function baz() {
(() => {
() => {
var arg = arguments[0];
});
};
}
function foo(inputFunc) { }
foo(() => {
@@ -52,8 +52,8 @@ foo(() => {
function bar() {
var arg = arguments[0]; // no error
}
(() => {
() => {
function foo() {
var arg = arguments[0]; // no error
}
});
};
tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS2.js
+7 -7
View File
@@ -17,10 +17,10 @@ function foo() {
globalCounter += 1;
return { 0: 2 };
}
(_a = foo(), _a[0] = Math.pow(_a[0], foo()[0]));
var result_foo1 = (_b = foo(), _b[0] = Math.pow(_b[0], foo()[0]));
(_c = foo(), _c[0] = Math.pow(_c[0], (_d = foo(), _d[0] = Math.pow(_d[0], 2))));
var result_foo2 = (_e = foo(), _e[0] = Math.pow(_e[0], (_f = foo(), _f[0] = Math.pow(_f[0], 2))));
(_g = foo(), _g[0] = Math.pow(_g[0], Math.pow(foo()[0], 2)));
var result_foo3 = (_h = foo(), _h[0] = Math.pow(_h[0], Math.pow(foo()[0], 2)));
var _a, _b, _c, _d, _e, _f, _g, _h;
(_a = foo())[_b = 0] = Math.pow(_a[_b], foo()[0]);
var result_foo1 = (_c = foo())[_d = 0] = Math.pow(_c[_d], foo()[0]);
(_e = foo())[_f = 0] = Math.pow(_e[_f], (_g = foo())[_h = 0] = Math.pow(_g[_h], 2));
var result_foo2 = (_j = foo())[_k = 0] = Math.pow(_j[_k], (_l = foo())[_m = 0] = Math.pow(_l[_m], 2));
(_o = foo())[_p = 0] = Math.pow(_o[_p], Math.pow(foo()[0], 2));
var result_foo3 = (_q = foo())[_r = 0] = Math.pow(_q[_r], Math.pow(foo()[0], 2));
var _a, _b, _c, _d, _g, _h, _e, _f, _l, _m, _j, _k, _o, _p, _q, _r;
tests/baselines/reference/emitCompoundExponentiationAssignmentWithIndexingOnLHS3.js
+4 -4
View File
@@ -23,7 +23,7 @@ var object = {
this._0 = x;
},
};
(_a = object, _a[0] = Math.pow(_a[0], object[0]));
(_b = object, _b[0] = Math.pow(_b[0], (_c = object, _c[0] = Math.pow(_c[0], 2))));
(_d = object, _d[0] = Math.pow(_d[0], Math.pow(object[0], 2)));
var _a, _b, _c, _d;
(_a = object)[_b = 0] = Math.pow(_a[_b], object[0]);
(_c = object)[_d = 0] = Math.pow(_c[_d], (_e = object)[_f = 0] = Math.pow(_e[_f], 2));
(_g = object)[_h = 0] = Math.pow(_g[_h], Math.pow(object[0], 2));
var _a, _b, _e, _f, _c, _d, _g, _h;
tests/baselines/reference/emitRestParametersMethodES6.js
+2 -4
View File
@@ -16,14 +16,12 @@ class D {
//// [emitRestParametersMethodES6.js]
class C {
constructor(name, ...rest) {
}
constructor(name, ...rest) { }
bar(...rest) { }
foo(x, ...rest) { }
}
class D {
constructor(...rest) {
}
constructor(...rest) { }
bar(...rest) { }
foo(x, ...rest) { }
}
tests/baselines/reference/emptyAssignmentPatterns02_ES5.js
+2 -2
View File
@@ -9,8 +9,8 @@ let x, y, z, a1, a2, a3;
//// [emptyAssignmentPatterns02_ES5.js]
var a;
var x, y, z, a1, a2, a3;
((x = a.x, y = a.y, z = a.z, a));
((a1 = a[0], a2 = a[1], a3 = a[2], a));
(x = a.x, y = a.y, z = a.z, a);
(a1 = a[0], a2 = a[1], a3 = a[2], a);
//// [emptyAssignmentPatterns02_ES5.d.ts]
tests/baselines/reference/emptyAssignmentPatterns03_ES5.js
+2 -2
View File
@@ -7,8 +7,8 @@ var a: any;
//// [emptyAssignmentPatterns03_ES5.js]
var a;
(a);
(a);
({} = a);
([] = a);
//// [emptyAssignmentPatterns03_ES5.d.ts]
tests/baselines/reference/emptyAssignmentPatterns04_ES5.js
+2 -2
View File
@@ -9,8 +9,8 @@ let x, y, z, a1, a2, a3;
//// [emptyAssignmentPatterns04_ES5.js]
var a;
var x, y, z, a1, a2, a3;
(_a = a, x = _a.x, y = _a.y, z = _a.z, _a);
(_b = a, a1 = _b[0], a2 = _b[1], a3 = _b[2], _b);
(_a = {} = a, x = _a.x, y = _a.y, z = _a.z, _a);
(_b = [] = a, a1 = _b[0], a2 = _b[1], a3 = _b[2], _b);
var _a, _b;
tests/baselines/reference/enumFromExternalModule.js
+1 -1
View File
@@ -19,5 +19,5 @@ var Mode = exports.Mode;
//// [enumFromExternalModule_1.js]
"use strict";
///<reference path='enumFromExternalModule_0.ts'/>
var f = require('./enumFromExternalModule_0');
var f = require("./enumFromExternalModule_0");
var x = f.Mode.Open;
tests/baselines/reference/enumIdentifierLiterals.js
+4 -4
View File
@@ -10,9 +10,9 @@ enum Nums {
//// [enumIdentifierLiterals.js]
var Nums;
(function (Nums) {
Nums[Nums["1"] = 0] = "1";
Nums[Nums["1.1"] = 1] = "1.1";
Nums[Nums["1.2"] = 2] = "1.2";
Nums[Nums[1] = 0] = 1;
Nums[Nums[1.1] = 1] = 1.1;
Nums[Nums[1.2] = 2] = 1.2;
Nums[Nums["13e-1"] = 3] = "13e-1";
Nums[Nums["61453"] = 4] = "61453";
Nums[Nums[61453] = 4] = 61453;
})(Nums || (Nums = {}));
tests/baselines/reference/es5ModuleInternalNamedImports.errors.txt
+17 -1
View File
@@ -6,9 +6,13 @@ tests/cases/compiler/es5ModuleInternalNamedImports.ts(27,5): error TS1194: Expor
tests/cases/compiler/es5ModuleInternalNamedImports.ts(28,5): error TS1194: Export declarations are not permitted in a namespace.
tests/cases/compiler/es5ModuleInternalNamedImports.ts(29,5): error TS1194: Export declarations are not permitted in a namespace.
tests/cases/compiler/es5ModuleInternalNamedImports.ts(30,5): error TS1194: Export declarations are not permitted in a namespace.
tests/cases/compiler/es5ModuleInternalNamedImports.ts(31,25): error TS1147: Import declarations in a namespace cannot reference a module.
tests/cases/compiler/es5ModuleInternalNamedImports.ts(32,20): error TS1147: Import declarations in a namespace cannot reference a module.
tests/cases/compiler/es5ModuleInternalNamedImports.ts(33,32): error TS1147: Import declarations in a namespace cannot reference a module.
tests/cases/compiler/es5ModuleInternalNamedImports.ts(35,16): error TS2307: Cannot find module 'M3'.
==== tests/cases/compiler/es5ModuleInternalNamedImports.ts (8 errors) ====
==== tests/cases/compiler/es5ModuleInternalNamedImports.ts (12 errors) ====
export module M {
// variable
@@ -55,5 +59,17 @@ tests/cases/compiler/es5ModuleInternalNamedImports.ts(30,5): error TS1194: Expor
export {M_A as a};
~~~~~~~~~~~~~~~~~~
!!! error TS1194: Export declarations are not permitted in a namespace.
import * as M2 from "M2";
~~~~
!!! error TS1147: Import declarations in a namespace cannot reference a module.
import M4 from "M4";
~~~~
!!! error TS1147: Import declarations in a namespace cannot reference a module.
export import M5 = require("M5");
~~~~
!!! error TS1147: Import declarations in a namespace cannot reference a module.
}
import M3 from "M3";
~~~~
!!! error TS2307: Cannot find module 'M3'.
tests/baselines/reference/es5ModuleInternalNamedImports.js
+4 -1
View File
@@ -29,7 +29,11 @@ export module M {
export {M_F as f};
export {M_E as e};
export {M_A as a};
import * as M2 from "M2";
import M4 from "M4";
export import M5 = require("M5");
}
import M3 from "M3";
//// [es5ModuleInternalNamedImports.js]
@@ -60,6 +64,5 @@ define(["require", "exports"], function (require, exports) {
var M_E = M.M_E;
// alias
M.M_A = M_M;
// Reexports
})(M = exports.M || (exports.M = {}));
});
tests/baselines/reference/es6ModuleInternalNamedImports.js
-7
View File
@@ -55,11 +55,4 @@ export var M;
var M_E = M.M_E;
// alias
M.M_A = M_M;
// Reexports
export { M_V as v };
export { M_C as c };
export { M_M as m };
export { M_F as f };
export { M_E as e };
export { M_A as a };
})(M || (M = {}));
tests/baselines/reference/es6ModuleInternalNamedImports2.js
-7
View File
@@ -59,11 +59,4 @@ export var M;
M.M_A = M_M;
})(M || (M = {}));
(function (M) {
// Reexports
export { M_V as v };
export { M_C as c };
export { M_M as m };
export { M_F as f };
export { M_E as e };
export { M_A as a };
})(M || (M = {}));
tests/baselines/reference/exportAssignDottedName.js
+1 -1
View File
@@ -18,5 +18,5 @@ function x() {
exports.x = x;
//// [foo2.js]
"use strict";
var foo1 = require('./foo1');
var foo1 = require("./foo1");
module.exports = foo1.x;
tests/baselines/reference/exportAssignImportedIdentifier.js
+2 -2
View File
@@ -22,10 +22,10 @@ function x() {
exports.x = x;
//// [foo2.js]
"use strict";
var foo1 = require('./foo1');
var foo1 = require("./foo1");
var x = foo1.x;
module.exports = x;
//// [foo3.js]
"use strict";
var foo2 = require('./foo2');
var foo2 = require("./foo2");
var x = foo2(); // should be boolean
tests/baselines/reference/exportAssignTypes.js
+7 -7
View File
@@ -85,17 +85,17 @@ function x(a) {
module.exports = x;
//// [consumer.js]
"use strict";
var iString = require('./expString');
var iString = require("./expString");
var v1 = iString;
var iNumber = require('./expNumber');
var iNumber = require("./expNumber");
var v2 = iNumber;
var iBoolean = require('./expBoolean');
var iBoolean = require("./expBoolean");
var v3 = iBoolean;
var iArray = require('./expArray');
var iArray = require("./expArray");
var v4 = iArray;
var iObject = require('./expObject');
var iObject = require("./expObject");
var v5 = iObject;
var iAny = require('./expAny');
var iAny = require("./expAny");
var v6 = iAny;
var iGeneric = require('./expGeneric');
var iGeneric = require("./expGeneric");
var v7 = iGeneric;
tests/baselines/reference/exportAssignmentCircularModules.js
+1 -1
View File
@@ -32,7 +32,7 @@ define(["require", "exports", "./foo_2"], function (require, exports, foo2) {
return Foo;
});
//// [foo_0.js]
define(["require", "exports", './foo_1'], function (require, exports, foo1) {
define(["require", "exports", "./foo_1"], function (require, exports, foo1) {
"use strict";
var Foo;
(function (Foo) {
tests/baselines/reference/exportDeclarationInInternalModule.js
+1 -1
View File
@@ -53,7 +53,7 @@ var Bbb;
return SomeType;
}());
Bbb.SomeType = SomeType;
// this line causes the nullref
export * from Aaa; // this line causes the nullref
})(Bbb || (Bbb = {}));
var a;
tests/baselines/reference/exportDeclaredModule.js
+1 -1
View File
@@ -17,5 +17,5 @@ var x: number = foo1.b();
module.exports = M1;
//// [foo2.js]
"use strict";
var foo1 = require('./foo1');
var foo1 = require("./foo1");
var x = foo1.b();
tests/baselines/reference/exportEqualCallable.js
+1 -1
View File
@@ -20,7 +20,7 @@ define(["require", "exports"], function (require, exports) {
return server;
});
//// [exportEqualCallable_1.js]
define(["require", "exports", 'exportEqualCallable_0'], function (require, exports, connect) {
define(["require", "exports", "exportEqualCallable_0"], function (require, exports, connect) {
"use strict";
connect();
});
tests/baselines/reference/exportEqualErrorType.js
+1 -1
View File
@@ -28,7 +28,7 @@ define(["require", "exports"], function (require, exports) {
return server;
});
//// [exportEqualErrorType_1.js]
define(["require", "exports", 'exportEqualErrorType_0'], function (require, exports, connect) {
define(["require", "exports", "exportEqualErrorType_0"], function (require, exports, connect) {
"use strict";
connect().use(connect.static('foo')); // Error 1 The property 'static' does not exist on value of type ''.
});
tests/baselines/reference/exportEqualMemberMissing.js
+1 -1
View File
@@ -28,5 +28,5 @@ module.exports = server;
//// [exportEqualMemberMissing_1.js]
"use strict";
///<reference path='exportEqualMemberMissing_0.ts'/>
var connect = require('./exportEqualMemberMissing_0');
var connect = require("./exportEqualMemberMissing_0");
connect().use(connect.static('foo')); // Error 1 The property 'static' does not exist on value of type ''.
tests/baselines/reference/exportImport.js
+2 -2
View File
@@ -27,12 +27,12 @@ define(["require", "exports"], function (require, exports) {
return Widget1;
});
//// [exporter.js]
define(["require", "exports", './w1'], function (require, exports, w) {
define(["require", "exports", "./w1"], function (require, exports, w) {
"use strict";
exports.w = w;
});
//// [consumer.js]
define(["require", "exports", './exporter'], function (require, exports, e) {
define(["require", "exports", "./exporter"], function (require, exports, e) {
"use strict";
function w() {
return new e.w();
tests/baselines/reference/exportImportMultipleFiles.js
+1 -1
View File
@@ -25,7 +25,7 @@ define(["require", "exports", "exportImportMultipleFiles_math"], function (requi
exports.math.add(3, 4); // OK
});
//// [exportImportMultipleFiles_userCode.js]
define(["require", "exports", './exportImportMultipleFiles_library'], function (require, exports, lib) {
define(["require", "exports", "./exportImportMultipleFiles_library"], function (require, exports, lib) {
"use strict";
lib.math.add(3, 4); // Shouldnt be error
});
tests/baselines/reference/exportStarForValues10.js
+17 -15
View File
@@ -13,46 +13,48 @@ export * from "file1";
var x = 1;
//// [file0.js]
System.register([], function(exports_1, context_1) {
System.register([], function (exports_1, context_1) {
"use strict";
var __moduleName = context_1 && context_1.id;
var v;
return {
setters:[],
execute: function() {
setters: [],
execute: function () {
exports_1("v", v = 1);
}
}
};
});
//// [file1.js]
System.register([], function(exports_1, context_1) {
System.register([], function (exports_1, context_1) {
"use strict";
var __moduleName = context_1 && context_1.id;
return {
setters:[],
execute: function() {
setters: [],
execute: function () {
}
}
};
});
//// [file2.js]
System.register(["file0"], function(exports_1, context_1) {
System.register(["file0"], function (exports_1, context_1) {
"use strict";
var __moduleName = context_1 && context_1.id;
var x;
function exportStar_1(m) {
var exports = {};
for(var n in m) {
if (n !== "default") exports[n] = m[n];
for (var n in m) {
if (n !== "default")
exports[n] = m[n];
}
exports_1(exports);
}
return {
setters:[
setters: [
function (file0_1_1) {
exportStar_1(file0_1_1);
}],
execute: function() {
}
],
execute: function () {
x = 1;
}
}
};
});
tests/baselines/reference/exportStarForValues6.js
+8 -8
View File
@@ -9,24 +9,24 @@ export * from "file1"
export var x = 1;
//// [file1.js]
System.register([], function(exports_1, context_1) {
System.register([], function (exports_1, context_1) {
"use strict";
var __moduleName = context_1 && context_1.id;
return {
setters:[],
execute: function() {
setters: [],
execute: function () {
}
}
};
});
//// [file2.js]
System.register([], function(exports_1, context_1) {
System.register([], function (exports_1, context_1) {
"use strict";
var __moduleName = context_1 && context_1.id;
var x;
return {
setters:[],
execute: function() {
setters: [],
execute: function () {
exports_1("x", x = 1);
}
}
};
});
tests/baselines/reference/exportStarForValuesInSystem.js
+8 -8
View File
@@ -9,24 +9,24 @@ export * from "file1"
var x = 1;
//// [file1.js]
System.register([], function(exports_1, context_1) {
System.register([], function (exports_1, context_1) {
"use strict";
var __moduleName = context_1 && context_1.id;
return {
setters:[],
execute: function() {
setters: [],
execute: function () {
}
}
};
});
//// [file2.js]
System.register([], function(exports_1, context_1) {
System.register([], function (exports_1, context_1) {
"use strict";
var __moduleName = context_1 && context_1.id;
var x;
return {
setters:[],
execute: function() {
setters: [],
execute: function () {
x = 1;
}
}
};
});
tests/baselines/reference/extendClassExpressionFromModule.js
+1 -1
View File
@@ -26,7 +26,7 @@ var __extends = (this && this.__extends) || function (d, b) {
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var foo1 = require('./foo1');
var foo1 = require("./foo1");
var x = foo1;
var y = (function (_super) {
__extends(y, _super);
tests/baselines/reference/externalModuleAssignToVar.js
+1 -1
View File
@@ -57,7 +57,7 @@ define(["require", "exports"], function (require, exports) {
return D;
});
//// [externalModuleAssignToVar_core.js]
define(["require", "exports", 'externalModuleAssignToVar_core_require', 'externalModuleAssignToVar_core_require2', 'externalModuleAssignToVar_ext'], function (require, exports, ext, ext2, ext3) {
define(["require", "exports", "externalModuleAssignToVar_core_require", "externalModuleAssignToVar_core_require2", "externalModuleAssignToVar_ext"], function (require, exports, ext, ext2, ext3) {
"use strict";
var y1 = ext;
y1 = ext; // ok
tests/baselines/reference/externalModuleExportingGenericClass.js
+1 -1
View File
@@ -25,7 +25,7 @@ var C = (function () {
module.exports = C;
//// [externalModuleExportingGenericClass_file1.js]
"use strict";
var a = require('./externalModuleExportingGenericClass_file0');
var a = require("./externalModuleExportingGenericClass_file0");
var v; // this should report error
var v2 = (new a()).foo;
var v3 = (new a()).foo;
tests/baselines/reference/externalModuleImmutableBindings.js
+1 -1
View File
@@ -57,7 +57,7 @@ exports.x = 1;
//// [f2.js]
"use strict";
// all mutations below are illegal and should be fixed
var stuff = require('./f1');
var stuff = require("./f1");
var n = 'baz';
stuff.x = 0;
stuff['x'] = 1;
tests/baselines/reference/externalModuleReferenceOfImportDeclarationWithExportModifier.js
+1 -1
View File
@@ -16,7 +16,7 @@ define(["require", "exports"], function (require, exports) {
;
});
//// [externalModuleReferenceOfImportDeclarationWithExportModifier_1.js]
define(["require", "exports", 'externalModuleReferenceOfImportDeclarationWithExportModifier_0'], function (require, exports, file1) {
define(["require", "exports", "externalModuleReferenceOfImportDeclarationWithExportModifier_0"], function (require, exports, file1) {
"use strict";
exports.file1 = file1;
exports.file1.foo();
tests/baselines/reference/externalModuleRefernceResolutionOrderInImportDeclaration.js
+1 -1
View File
@@ -26,6 +26,6 @@ exports.foo = foo;
//// [externalModuleRefernceResolutionOrderInImportDeclaration_file3.js]
"use strict";
///<reference path='externalModuleRefernceResolutionOrderInImportDeclaration_file2.ts'/>
var file1 = require('./externalModuleRefernceResolutionOrderInImportDeclaration_file1');
var file1 = require("./externalModuleRefernceResolutionOrderInImportDeclaration_file1");
file1.foo();
file1.bar();
tests/baselines/reference/externalModuleResolution.js
+1 -1
View File
@@ -25,5 +25,5 @@ var M2;
module.exports = M2;
//// [consumer.js]
"use strict";
var x = require('./foo');
var x = require("./foo");
x.Y; // .ts should be picked
tests/baselines/reference/externalModuleResolution2.js
+1 -1
View File
@@ -26,5 +26,5 @@ var M2;
module.exports = M2;
//// [consumer.js]
"use strict";
var x = require('./foo');
var x = require("./foo");
x.X; // .ts should be picked

Some files were not shown because too many files have changed in this diff Show More