maxmustermann/TypeScript
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Merge branch 'transforms' into moduleNameInOutput

Browse source
This commit is contained in:
Mohamed Hegazy 2016-04-13 13:20:08 -07:00
parent cf859be9da 9d73220c2e
commit 5f66c8766e
20 changed files with 392 additions and 290 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
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/*

26
Jakefile.js
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]);
}

129
src/compiler/checker.ts
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 {

4
src/compiler/commandLineParser.ts
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);

31
src/compiler/emitter.ts
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:

6
src/compiler/printer.ts
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(";");
}

12
src/compiler/transformers/destructuring.ts
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);
}
}
}
}

24
src/compiler/transformers/es6.ts
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);
}
}

70
src/compiler/transformers/module/module.ts
View file

@ -461,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;
@ -714,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
);
}
}
}

6
src/compiler/transformers/module/system.ts
View file

@ -575,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
@ -1017,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);
}

95
src/compiler/transformers/ts.ts
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;
@ -1380,7 +1388,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)));
}
@ -1614,11 +1621,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(
@ -1634,7 +1639,7 @@ namespace ts {
);
case TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue:
return serializeEntityNameAsExpression(typeName, /*useFallback*/ false);
return serializeEntityNameAsExpression(node.typeName, /*useFallback*/ false);
case TypeReferenceSerializationKind.VoidType:
return createVoidZero();
@ -1675,17 +1680,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);
@ -2644,9 +2652,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;
}
}
@ -2738,41 +2746,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 {
@ -2900,7 +2919,7 @@ namespace ts {
function getSuperContainerAsyncMethodFlags() {
return currentSuperContainer !== undefined
&& resolver.getNodeCheckFlags(getOriginalNode(currentSuperContainer)) & (NodeCheckFlags.AsyncMethodWithSuper | NodeCheckFlags.AsyncMethodWithSuperBinding);
&& resolver.getNodeCheckFlags(currentSuperContainer) & (NodeCheckFlags.AsyncMethodWithSuper | NodeCheckFlags.AsyncMethodWithSuperBinding);
}
}
}
}

7
src/compiler/types.ts
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` */

48
src/compiler/utilities.ts
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;
}

178
src/compiler/visitor.ts
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]: [

4
tests/baselines/reference/emptyAssignmentPatterns02_ES5.js
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]

18
tests/baselines/reference/es5ModuleInternalNamedImports.errors.txt
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'.

5
tests/baselines/reference/es5ModuleInternalNamedImports.js
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 = {}));
});

7
tests/baselines/reference/es6ModuleInternalNamedImports.js
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 = {}));

7
tests/baselines/reference/es6ModuleInternalNamedImports2.js
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 = {}));

4
tests/cases/compiler/es5ModuleInternalNamedImports.ts
View file

@ -30,4 +30,8 @@ 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";