From fafd497124a0b3de55b29c3d3151060de229e6a1 Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Thu, 13 Aug 2015 14:30:29 -0700 Subject: [PATCH] Fix #4274: When collecting linked aliases use SymbolFlags.Alias to capture local aliases as well --- src/compiler/checker.ts | 7 ++-- src/services/formatting/rules.ts | 2 ++ .../declarationEmit_exportAssignment.js | 30 ++++++++++++++++ .../declarationEmit_exportAssignment.symbols | 18 ++++++++++ .../declarationEmit_exportAssignment.types | 18 ++++++++++ .../declarationEmit_exportDeclaration.js | 35 +++++++++++++++++++ .../declarationEmit_exportDeclaration.symbols | 27 ++++++++++++++ .../declarationEmit_exportDeclaration.types | 28 +++++++++++++++ .../declarationEmit_exportAssignment.ts | 12 +++++++ .../declarationEmit_exportDeclaration.ts | 15 ++++++++ tests/cases/fourslash/genericsFormatting.ts | 15 +++++++- 11 files changed, 204 insertions(+), 3 deletions(-) create mode 100644 tests/baselines/reference/declarationEmit_exportAssignment.js create mode 100644 tests/baselines/reference/declarationEmit_exportAssignment.symbols create mode 100644 tests/baselines/reference/declarationEmit_exportAssignment.types create mode 100644 tests/baselines/reference/declarationEmit_exportDeclaration.js create mode 100644 tests/baselines/reference/declarationEmit_exportDeclaration.symbols create mode 100644 tests/baselines/reference/declarationEmit_exportDeclaration.types create mode 100644 tests/cases/compiler/declarationEmit_exportAssignment.ts create mode 100644 tests/cases/compiler/declarationEmit_exportDeclaration.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 9babfdec33..cb69c3f6af 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -2175,10 +2175,13 @@ namespace ts { function collectLinkedAliases(node: Identifier): Node[] { let exportSymbol: Symbol; if (node.parent && node.parent.kind === SyntaxKind.ExportAssignment) { - exportSymbol = resolveName(node.parent, node.text, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace, Diagnostics.Cannot_find_name_0, node); + exportSymbol = resolveName(node.parent, node.text, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias, Diagnostics.Cannot_find_name_0, node); } else if (node.parent.kind === SyntaxKind.ExportSpecifier) { - exportSymbol = getTargetOfExportSpecifier(node.parent); + let exportSpecifier = node.parent; + exportSymbol = (exportSpecifier.parent.parent).moduleSpecifier ? + getExternalModuleMember(exportSpecifier.parent.parent, exportSpecifier) : + resolveEntityName(exportSpecifier.propertyName || exportSpecifier.name, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias); } let result: Node[] = []; if (exportSymbol) { diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts index 497c511440..a5e37bf690 100644 --- a/src/services/formatting/rules.ts +++ b/src/services/formatting/rules.ts @@ -715,6 +715,7 @@ namespace ts.formatting { case SyntaxKind.TypeReference: case SyntaxKind.TypeAssertionExpression: case SyntaxKind.ClassDeclaration: + case SyntaxKind.ClassExpression: case SyntaxKind.InterfaceDeclaration: case SyntaxKind.FunctionDeclaration: case SyntaxKind.FunctionExpression: @@ -725,6 +726,7 @@ namespace ts.formatting { case SyntaxKind.ConstructSignature: case SyntaxKind.CallExpression: case SyntaxKind.NewExpression: + case SyntaxKind.ExpressionWithTypeArguments: return true; default: return false; diff --git a/tests/baselines/reference/declarationEmit_exportAssignment.js b/tests/baselines/reference/declarationEmit_exportAssignment.js new file mode 100644 index 0000000000..54f3eb5fd0 --- /dev/null +++ b/tests/baselines/reference/declarationEmit_exportAssignment.js @@ -0,0 +1,30 @@ +//// [tests/cases/compiler/declarationEmit_exportAssignment.ts] //// + +//// [utils.ts] + +export function foo() { } +export function bar() { } +export interface Buzz { } + +//// [index.ts] +import {foo} from "utils"; +export = foo; + +//// [utils.js] +function foo() { } +exports.foo = foo; +function bar() { } +exports.bar = bar; +//// [index.js] +var utils_1 = require("utils"); +module.exports = utils_1.foo; + + +//// [utils.d.ts] +export declare function foo(): void; +export declare function bar(): void; +export interface Buzz { +} +//// [index.d.ts] +import { foo } from "utils"; +export = foo; diff --git a/tests/baselines/reference/declarationEmit_exportAssignment.symbols b/tests/baselines/reference/declarationEmit_exportAssignment.symbols new file mode 100644 index 0000000000..b443ba6e79 --- /dev/null +++ b/tests/baselines/reference/declarationEmit_exportAssignment.symbols @@ -0,0 +1,18 @@ +=== tests/cases/compiler/utils.ts === + +export function foo() { } +>foo : Symbol(foo, Decl(utils.ts, 0, 0)) + +export function bar() { } +>bar : Symbol(bar, Decl(utils.ts, 1, 25)) + +export interface Buzz { } +>Buzz : Symbol(Buzz, Decl(utils.ts, 2, 25)) + +=== tests/cases/compiler/index.ts === +import {foo} from "utils"; +>foo : Symbol(foo, Decl(index.ts, 0, 8)) + +export = foo; +>foo : Symbol(foo, Decl(index.ts, 0, 8)) + diff --git a/tests/baselines/reference/declarationEmit_exportAssignment.types b/tests/baselines/reference/declarationEmit_exportAssignment.types new file mode 100644 index 0000000000..81c56da432 --- /dev/null +++ b/tests/baselines/reference/declarationEmit_exportAssignment.types @@ -0,0 +1,18 @@ +=== tests/cases/compiler/utils.ts === + +export function foo() { } +>foo : () => void + +export function bar() { } +>bar : () => void + +export interface Buzz { } +>Buzz : Buzz + +=== tests/cases/compiler/index.ts === +import {foo} from "utils"; +>foo : () => void + +export = foo; +>foo : () => void + diff --git a/tests/baselines/reference/declarationEmit_exportDeclaration.js b/tests/baselines/reference/declarationEmit_exportDeclaration.js new file mode 100644 index 0000000000..f05639dc18 --- /dev/null +++ b/tests/baselines/reference/declarationEmit_exportDeclaration.js @@ -0,0 +1,35 @@ +//// [tests/cases/compiler/declarationEmit_exportDeclaration.ts] //// + +//// [utils.ts] + +export function foo() { } +export function bar() { } +export interface Buzz { } + +//// [index.ts] +import {foo, bar, Buzz} from "utils"; + +foo(); +let obj: Buzz; +export {bar}; + +//// [utils.js] +function foo() { } +exports.foo = foo; +function bar() { } +exports.bar = bar; +//// [index.js] +var utils_1 = require("utils"); +exports.bar = utils_1.bar; +utils_1.foo(); +var obj; + + +//// [utils.d.ts] +export declare function foo(): void; +export declare function bar(): void; +export interface Buzz { +} +//// [index.d.ts] +import { bar } from "utils"; +export { bar }; diff --git a/tests/baselines/reference/declarationEmit_exportDeclaration.symbols b/tests/baselines/reference/declarationEmit_exportDeclaration.symbols new file mode 100644 index 0000000000..5cd8c5fee9 --- /dev/null +++ b/tests/baselines/reference/declarationEmit_exportDeclaration.symbols @@ -0,0 +1,27 @@ +=== tests/cases/compiler/utils.ts === + +export function foo() { } +>foo : Symbol(foo, Decl(utils.ts, 0, 0)) + +export function bar() { } +>bar : Symbol(bar, Decl(utils.ts, 1, 25)) + +export interface Buzz { } +>Buzz : Symbol(Buzz, Decl(utils.ts, 2, 25)) + +=== tests/cases/compiler/index.ts === +import {foo, bar, Buzz} from "utils"; +>foo : Symbol(foo, Decl(index.ts, 0, 8)) +>bar : Symbol(bar, Decl(index.ts, 0, 12)) +>Buzz : Symbol(Buzz, Decl(index.ts, 0, 17)) + +foo(); +>foo : Symbol(foo, Decl(index.ts, 0, 8)) + +let obj: Buzz; +>obj : Symbol(obj, Decl(index.ts, 3, 3)) +>Buzz : Symbol(Buzz, Decl(index.ts, 0, 17)) + +export {bar}; +>bar : Symbol(bar, Decl(index.ts, 4, 8)) + diff --git a/tests/baselines/reference/declarationEmit_exportDeclaration.types b/tests/baselines/reference/declarationEmit_exportDeclaration.types new file mode 100644 index 0000000000..058ee863c6 --- /dev/null +++ b/tests/baselines/reference/declarationEmit_exportDeclaration.types @@ -0,0 +1,28 @@ +=== tests/cases/compiler/utils.ts === + +export function foo() { } +>foo : () => void + +export function bar() { } +>bar : () => void + +export interface Buzz { } +>Buzz : Buzz + +=== tests/cases/compiler/index.ts === +import {foo, bar, Buzz} from "utils"; +>foo : () => void +>bar : () => void +>Buzz : any + +foo(); +>foo() : void +>foo : () => void + +let obj: Buzz; +>obj : Buzz +>Buzz : Buzz + +export {bar}; +>bar : () => void + diff --git a/tests/cases/compiler/declarationEmit_exportAssignment.ts b/tests/cases/compiler/declarationEmit_exportAssignment.ts new file mode 100644 index 0000000000..166f4abe8e --- /dev/null +++ b/tests/cases/compiler/declarationEmit_exportAssignment.ts @@ -0,0 +1,12 @@ +// @target: es5 +// @module: commonjs +// @declaration: true + +// @filename: utils.ts +export function foo() { } +export function bar() { } +export interface Buzz { } + +// @filename: index.ts +import {foo} from "utils"; +export = foo; \ No newline at end of file diff --git a/tests/cases/compiler/declarationEmit_exportDeclaration.ts b/tests/cases/compiler/declarationEmit_exportDeclaration.ts new file mode 100644 index 0000000000..a9e0bda761 --- /dev/null +++ b/tests/cases/compiler/declarationEmit_exportDeclaration.ts @@ -0,0 +1,15 @@ +// @target: es5 +// @module: commonjs +// @declaration: true + +// @filename: utils.ts +export function foo() { } +export function bar() { } +export interface Buzz { } + +// @filename: index.ts +import {foo, bar, Buzz} from "utils"; + +foo(); +let obj: Buzz; +export {bar}; \ No newline at end of file diff --git a/tests/cases/fourslash/genericsFormatting.ts b/tests/cases/fourslash/genericsFormatting.ts index b8ef27fa8f..f5e44522a8 100644 --- a/tests/cases/fourslash/genericsFormatting.ts +++ b/tests/cases/fourslash/genericsFormatting.ts @@ -14,6 +14,13 @@ //// ////foo()(); ////(a + b)(); +//// +////function bar() { +/////*inClassExpression*/ return class < T2 > { +//// } +////} +/////*expressionWithTypeArguments*/class A < T > extends bar < T >( ) < T > { +////} format.document(); @@ -33,4 +40,10 @@ goTo.marker("inNewSignature"); verify.currentLineContentIs(" new (a: T);"); goTo.marker("inOptionalMethodSignature"); -verify.currentLineContentIs(" op?(a: T, b: M);"); \ No newline at end of file +verify.currentLineContentIs(" op?(a: T, b: M);"); + +goTo.marker("inClassExpression"); +verify.currentLineContentIs(" return class {"); + +goTo.marker("expressionWithTypeArguments"); +verify.currentLineContentIs("class A extends bar() {"); \ No newline at end of file