Merge pull request microsoft#8789 from Microsoft/getSymbolAtAliasLocation

sheetalkamat · sheetalkamat · commit 35156527a352 · 2016-05-27T09:27:23.000-07:00
Do not resolve alias when getting symbol of import equal's right hand side
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -1180,11 +1180,7 @@ namespace ts {
         }
 
         // This function is only for imports with entity names
-        function getSymbolOfPartOfRightHandSideOfImportEquals(entityName: EntityName, importDeclaration?: ImportEqualsDeclaration): Symbol {
-            if (!importDeclaration) {
-                importDeclaration = <ImportEqualsDeclaration>getAncestor(entityName, SyntaxKind.ImportEqualsDeclaration);
-                Debug.assert(importDeclaration !== undefined);
-            }
+        function getSymbolOfPartOfRightHandSideOfImportEquals(entityName: EntityName, importDeclaration: ImportEqualsDeclaration, dontResolveAlias?: boolean): Symbol {
             // There are three things we might try to look for. In the following examples,
             // the search term is enclosed in |...|:
             //
@@ -1196,13 +1192,13 @@ namespace ts {
             }
             // Check for case 1 and 3 in the above example
             if (entityName.kind === SyntaxKind.Identifier || entityName.parent.kind === SyntaxKind.QualifiedName) {
-                return resolveEntityName(entityName, SymbolFlags.Namespace);
+                return resolveEntityName(entityName, SymbolFlags.Namespace, /*ignoreErrors*/ false, dontResolveAlias);
             }
             else {
                 // Case 2 in above example
                 // entityName.kind could be a QualifiedName or a Missing identifier
                 Debug.assert(entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration);
-                return resolveEntityName(entityName, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace);
+                return resolveEntityName(entityName, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace, /*ignoreErrors*/ false, dontResolveAlias);
             }
         }
 
@@ -1211,7 +1207,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, dontResolveAlias?: boolean): Symbol {
             if (nodeIsMissing(name)) {
                 return undefined;
             }
@@ -1245,7 +1241,7 @@ namespace ts {
                 Debug.fail("Unknown entity name kind.");
             }
             Debug.assert((symbol.flags & SymbolFlags.Instantiated) === 0, "Should never get an instantiated symbol here.");
-            return symbol.flags & meaning ? symbol : resolveAlias(symbol);
+            return (symbol.flags & meaning) || dontResolveAlias ? symbol : resolveAlias(symbol);
         }
 
         function resolveExternalModuleName(location: Node, moduleReferenceExpression: Expression): Symbol {
@@ -16803,7 +16799,9 @@ namespace ts {
             if (entityName.kind !== SyntaxKind.PropertyAccessExpression) {
                 if (isInRightSideOfImportOrExportAssignment(<EntityName>entityName)) {
                     // Since we already checked for ExportAssignment, this really could only be an Import
-                    return getSymbolOfPartOfRightHandSideOfImportEquals(<EntityName>entityName);
+                    const importEqualsDeclaration = <ImportEqualsDeclaration>getAncestor(entityName, SyntaxKind.ImportEqualsDeclaration);
+                    Debug.assert(importEqualsDeclaration !== undefined);
+                    return getSymbolOfPartOfRightHandSideOfImportEquals(<EntityName>entityName, importEqualsDeclaration, /*dontResolveAlias*/ true);
                 }
             }
 
@@ -16899,9 +16897,7 @@ namespace ts {
 
             if (node.kind === SyntaxKind.Identifier) {
                 if (isInRightSideOfImportOrExportAssignment(<Identifier>node)) {
-                    return node.parent.kind === SyntaxKind.ExportAssignment
-                        ? getSymbolOfEntityNameOrPropertyAccessExpression(<Identifier>node)
-                        : getSymbolOfPartOfRightHandSideOfImportEquals(<Identifier>node);
+                    return getSymbolOfEntityNameOrPropertyAccessExpression(<Identifier>node);
                 }
                 else if (node.parent.kind === SyntaxKind.BindingElement &&
                     node.parent.parent.kind === SyntaxKind.ObjectBindingPattern &&
diff --git a/tests/baselines/reference/acceptableAlias1.symbols b/tests/baselines/reference/acceptableAlias1.symbols
@@ -13,5 +13,5 @@ module M {
 import r = M.X;
 >r : Symbol(r, Decl(acceptableAlias1.ts, 4, 1))
 >M : Symbol(M, Decl(acceptableAlias1.ts, 0, 0))
->X : Symbol(r, Decl(acceptableAlias1.ts, 0, 10))
+>X : Symbol(M.X, Decl(acceptableAlias1.ts, 2, 5))
 
diff --git a/tests/baselines/reference/amdImportNotAsPrimaryExpression.symbols b/tests/baselines/reference/amdImportNotAsPrimaryExpression.symbols
@@ -5,7 +5,7 @@ import foo = require("./foo_0");
 // None of the below should cause a runtime dependency on foo_0
 import f = foo.M1;
 >f : Symbol(f, Decl(foo_1.ts, 0, 32))
->foo : Symbol(foo, Decl(foo_0.ts, 0, 0))
+>foo : Symbol(foo, Decl(foo_1.ts, 0, 0))
 >M1 : Symbol(foo.M1, Decl(foo_0.ts, 8, 1))
 
 var i: f.I2;
diff --git a/tests/baselines/reference/chainedImportAlias.symbols b/tests/baselines/reference/chainedImportAlias.symbols
@@ -4,7 +4,7 @@ import x = require('./chainedImportAlias_file0');
 
 import y = x;
 >y : Symbol(y, Decl(chainedImportAlias_file1.ts, 0, 49))
->x : Symbol(x, Decl(chainedImportAlias_file0.ts, 0, 0))
+>x : Symbol(x, Decl(chainedImportAlias_file1.ts, 0, 0))
 
 y.m.foo();
 >y.m.foo : Symbol(x.m.foo, Decl(chainedImportAlias_file0.ts, 0, 17))
diff --git a/tests/baselines/reference/commonJSImportNotAsPrimaryExpression.symbols b/tests/baselines/reference/commonJSImportNotAsPrimaryExpression.symbols
@@ -5,7 +5,7 @@ import foo = require("./foo_0");
 // None of the below should cause a runtime dependency on foo_0
 import f = foo.M1;
 >f : Symbol(f, Decl(foo_1.ts, 0, 32))
->foo : Symbol(foo, Decl(foo_0.ts, 0, 0))
+>foo : Symbol(foo, Decl(foo_1.ts, 0, 0))
 >M1 : Symbol(foo.M1, Decl(foo_0.ts, 8, 1))
 
 var i: f.I2;
diff --git a/tests/baselines/reference/declFileForExportedImport.symbols b/tests/baselines/reference/declFileForExportedImport.symbols
@@ -11,7 +11,7 @@ var y = a.x;
 
 export import b = a;
 >b : Symbol(b, Decl(declFileForExportedImport_1.ts, 2, 12))
->a : Symbol(a, Decl(declFileForExportedImport_0.ts, 0, 0))
+>a : Symbol(a, Decl(declFileForExportedImport_1.ts, 0, 0))
 
 var z = b.x;
 >z : Symbol(z, Decl(declFileForExportedImport_1.ts, 5, 3))
diff --git a/tests/baselines/reference/declFileImportChainInExportAssignment.symbols b/tests/baselines/reference/declFileImportChainInExportAssignment.symbols
@@ -17,7 +17,7 @@ import a = m.c;
 
 import b = a;
 >b : Symbol(b, Decl(declFileImportChainInExportAssignment.ts, 6, 15))
->a : Symbol(a, Decl(declFileImportChainInExportAssignment.ts, 0, 10))
+>a : Symbol(a, Decl(declFileImportChainInExportAssignment.ts, 5, 1))
 
 export = b;
 >b : Symbol(b, Decl(declFileImportChainInExportAssignment.ts, 6, 15))
diff --git a/tests/baselines/reference/declarationEmit_nameConflicts.symbols b/tests/baselines/reference/declarationEmit_nameConflicts.symbols
@@ -37,7 +37,7 @@ export module M {
 
     export import d = im;
 >d : Symbol(d, Decl(declarationEmit_nameConflicts_0.ts, 11, 24))
->im : Symbol(d, Decl(declarationEmit_nameConflicts_1.ts, 0, 0))
+>im : Symbol(im, Decl(declarationEmit_nameConflicts_0.ts, 0, 0))
 }
 
 export module M.P {
diff --git a/tests/baselines/reference/dependencyViaImportAlias.symbols b/tests/baselines/reference/dependencyViaImportAlias.symbols
@@ -4,7 +4,7 @@ import a = require('A');
 
 import A = a.A;
 >A : Symbol(A, Decl(B.ts, 0, 24))
->a : Symbol(a, Decl(A.ts, 0, 0))
+>a : Symbol(a, Decl(B.ts, 0, 0))
 >A : Symbol(a.A, Decl(A.ts, 0, 0))
 
 export = A;
diff --git a/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.symbols b/tests/baselines/reference/es6ImportNamedImportInIndirectExportAssignment.symbols
@@ -14,7 +14,7 @@ import { a } from "./es6ImportNamedImportInIndirectExportAssignment_0";
 
 import x = a;
 >x : Symbol(x, Decl(es6ImportNamedImportInIndirectExportAssignment_1.ts, 0, 71))
->a : Symbol(a, Decl(es6ImportNamedImportInIndirectExportAssignment_0.ts, 0, 0))
+>a : Symbol(a, Decl(es6ImportNamedImportInIndirectExportAssignment_1.ts, 0, 8))
 
 export = x;
 >x : Symbol(x, Decl(es6ImportNamedImportInIndirectExportAssignment_1.ts, 0, 71))
diff --git a/tests/baselines/reference/externalModuleReferenceDoubleUnderscore1.symbols b/tests/baselines/reference/externalModuleReferenceDoubleUnderscore1.symbols
@@ -5,7 +5,7 @@ declare module 'timezonecomplete' {
 
     export import TimeUnit = basics.TimeUnit;
 >TimeUnit : Symbol(TimeUnit, Decl(externalModuleReferenceDoubleUnderscore1.ts, 1, 57))
->basics : Symbol(basics, Decl(externalModuleReferenceDoubleUnderscore1.ts, 3, 1))
+>basics : Symbol(basics, Decl(externalModuleReferenceDoubleUnderscore1.ts, 0, 35))
 >TimeUnit : Symbol(basics.TimeUnit, Decl(externalModuleReferenceDoubleUnderscore1.ts, 5, 44))
 }
 
diff --git a/tests/baselines/reference/importAliasAnExternalModuleInsideAnInternalModule.symbols b/tests/baselines/reference/importAliasAnExternalModuleInsideAnInternalModule.symbols
@@ -8,7 +8,7 @@ module m_private {
     //import r2 = require('m'); // would be error
     export import C = r; // no error
 >C : Symbol(C, Decl(importAliasAnExternalModuleInsideAnInternalModule_file1.ts, 1, 18))
->r : Symbol(C, Decl(importAliasAnExternalModuleInsideAnInternalModule_file0.ts, 0, 0))
+>r : Symbol(r, Decl(importAliasAnExternalModuleInsideAnInternalModule_file1.ts, 0, 0))
 
     C.m.foo();
 >C.m.foo : Symbol(C.m.foo, Decl(importAliasAnExternalModuleInsideAnInternalModule_file0.ts, 0, 17))
diff --git a/tests/baselines/reference/import_reference-exported-alias.symbols b/tests/baselines/reference/import_reference-exported-alias.symbols
@@ -4,12 +4,12 @@ import appJs = require("file1");
 
 import Services = appJs.Services;
 >Services : Symbol(Services, Decl(file2.ts, 0, 32))
->appJs : Symbol(appJs, Decl(file1.ts, 0, 0))
+>appJs : Symbol(appJs, Decl(file2.ts, 0, 0))
 >Services : Symbol(appJs.Services, Decl(file1.ts, 0, 12))
 
 import UserServices = Services.UserServices;
 >UserServices : Symbol(UserServices, Decl(file2.ts, 1, 33))
->Services : Symbol(appJs.Services, Decl(file1.ts, 0, 12))
+>Services : Symbol(Services, Decl(file2.ts, 0, 32))
 >UserServices : Symbol(Services.UserServices, Decl(file1.ts, 1, 28))
 
 var x = new UserServices().getUserName();
diff --git a/tests/baselines/reference/import_reference-to-type-alias.symbols b/tests/baselines/reference/import_reference-to-type-alias.symbols
@@ -4,7 +4,7 @@ import appJs = require("file1");
 
 import Services = appJs.App.Services;
 >Services : Symbol(Services, Decl(file2.ts, 0, 32))
->appJs : Symbol(appJs, Decl(file1.ts, 0, 0))
+>appJs : Symbol(appJs, Decl(file2.ts, 0, 0))
 >App : Symbol(appJs.App, Decl(file1.ts, 0, 0))
 >Services : Symbol(Services, Decl(file1.ts, 0, 19))
 
diff --git a/tests/baselines/reference/importedAliasesInTypePositions.symbols b/tests/baselines/reference/importedAliasesInTypePositions.symbols
@@ -4,7 +4,7 @@ import RT_ALIAS = require("file1");
 
 import ReferredTo = RT_ALIAS.elaborate.nested.mod.name.ReferredTo;
 >ReferredTo : Symbol(ReferredTo, Decl(file2.ts, 0, 35))
->RT_ALIAS : Symbol(RT_ALIAS, Decl(file1.ts, 0, 0))
+>RT_ALIAS : Symbol(RT_ALIAS, Decl(file2.ts, 0, 0))
 >elaborate : Symbol(RT_ALIAS.elaborate, Decl(file1.ts, 0, 0))
 >nested : Symbol(RT_ALIAS.elaborate.nested, Decl(file1.ts, 0, 24))
 >mod : Symbol(RT_ALIAS.elaborate.nested.mod, Decl(file1.ts, 0, 31))
diff --git a/tests/baselines/reference/tsxPreserveEmit1.symbols b/tests/baselines/reference/tsxPreserveEmit1.symbols
@@ -8,7 +8,7 @@ import ReactRouter = require('react-router');
 
 import Route = ReactRouter.Route;
 >Route : Symbol(Route, Decl(test.tsx, 2, 45))
->ReactRouter : Symbol(ReactRouter, Decl(react.d.ts, 4, 1))
+>ReactRouter : Symbol(ReactRouter, Decl(test.tsx, 1, 32))
 >Route : Symbol(ReactRouter.Route, Decl(react.d.ts, 7, 4))
 
 var routes1 = <Route />;
diff --git a/tests/cases/fourslash/renameAlias.ts b/tests/cases/fourslash/renameAlias.ts
@@ -0,0 +1,11 @@
+/// <reference path='fourslash.ts'/>
+
+////module SomeModule { export class SomeClass { } }
+////import [|M|] = SomeModule;
+////import C = [|M|].SomeClass;
+
+let ranges = test.ranges()
+for (let range of ranges) {
+    goTo.position(range.start);
+    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
+}
diff --git a/tests/cases/fourslash/renameAlias2.ts b/tests/cases/fourslash/renameAlias2.ts
@@ -0,0 +1,11 @@
+/// <reference path='fourslash.ts'/>
+
+////module [|SomeModule|] { export class SomeClass { } }
+////import M = [|SomeModule|];
+////import C = M.SomeClass;
+
+let ranges = test.ranges()
+for (let range of ranges) {
+    goTo.position(range.start);
+    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
+}
diff --git a/tests/cases/fourslash/renameAlias3.ts b/tests/cases/fourslash/renameAlias3.ts
@@ -0,0 +1,11 @@
+/// <reference path='fourslash.ts'/>
+
+////module SomeModule { export class [|SomeClass|] { } }
+////import M = SomeModule;
+////import C = M.[|SomeClass|];
+
+let ranges = test.ranges()
+for (let range of ranges) {
+    goTo.position(range.start);
+    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
+}
diff --git a/tests/cases/fourslash/renameAliasExternalModule.ts b/tests/cases/fourslash/renameAliasExternalModule.ts
@@ -0,0 +1,16 @@
+/// <reference path='fourslash.ts'/>
+
+// @Filename: a.ts
+////module SomeModule { export class SomeClass { } }
+////export = SomeModule;
+
+// @Filename: b.ts
+////import [|M|] = require("./a");
+////import C = [|M|].SomeClass;
+
+let ranges = test.ranges()
+for (let range of ranges) {
+    goTo.file(range.fileName);
+    goTo.position(range.start);
+    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
+}
diff --git a/tests/cases/fourslash/renameAliasExternalModule2.ts b/tests/cases/fourslash/renameAliasExternalModule2.ts
@@ -0,0 +1,16 @@
+/// <reference path='fourslash.ts'/>
+
+// @Filename: a.ts
+////module [|SomeModule|] { export class SomeClass { } }
+////export = [|SomeModule|];
+
+// @Filename: b.ts
+////import M = require("./a");
+////import C = M.SomeClass;
+
+let ranges = test.ranges()
+for (let range of ranges) {
+    goTo.file(range.fileName);
+    goTo.position(range.start);
+    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
+}
diff --git a/tests/cases/fourslash/renameAliasExternalModule3.ts b/tests/cases/fourslash/renameAliasExternalModule3.ts
@@ -0,0 +1,16 @@
+/// <reference path='fourslash.ts'/>
+
+// @Filename: a.ts
+////module SomeModule { export class [|SomeClass|] { } }
+////export = SomeModule;
+
+// @Filename: b.ts
+////import M = require("./a");
+////import C = M.[|SomeClass|];
+
+let ranges = test.ranges()
+for (let range of ranges) {
+    goTo.file(range.fileName);
+    goTo.position(range.start);
+    verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false);
+}

Original file line number	Diff line number	Diff line change
`@@ -1180,11 +1180,7 @@ namespace ts {`
`1180`	`1180`	`}`
`1181`	`1181`
`1182`	`1182`	`// This function is only for imports with entity names`
`1183`		`- function getSymbolOfPartOfRightHandSideOfImportEquals(entityName: EntityName, importDeclaration?: ImportEqualsDeclaration): Symbol {`
`1184`		`- if (!importDeclaration) {`
`1185`		`- importDeclaration = <ImportEqualsDeclaration>getAncestor(entityName, SyntaxKind.ImportEqualsDeclaration);`
`1186`		`- Debug.assert(importDeclaration !== undefined);`
`1187`		`- }`
	`1183`	`+ function getSymbolOfPartOfRightHandSideOfImportEquals(entityName: EntityName, importDeclaration: ImportEqualsDeclaration, dontResolveAlias?: boolean): Symbol {`
`1188`	`1184`	`// There are three things we might try to look for. In the following examples,`
`1189`	`1185`	`// the search term is enclosed in \|...\|:`
`1190`	`1186`	`//`
`@@ -1196,13 +1192,13 @@ namespace ts {`
`1196`	`1192`	`}`
`1197`	`1193`	`// Check for case 1 and 3 in the above example`
`1198`	`1194`	`if (entityName.kind === SyntaxKind.Identifier \|\| entityName.parent.kind === SyntaxKind.QualifiedName) {`
`1199`		`- return resolveEntityName(entityName, SymbolFlags.Namespace);`
	`1195`	`+ return resolveEntityName(entityName, SymbolFlags.Namespace, /ignoreErrors/ false, dontResolveAlias);`
`1200`	`1196`	`}`
`1201`	`1197`	`else {`
`1202`	`1198`	`// Case 2 in above example`
`1203`	`1199`	`// entityName.kind could be a QualifiedName or a Missing identifier`
`1204`	`1200`	`Debug.assert(entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration);`
`1205`		`- return resolveEntityName(entityName, SymbolFlags.Value \| SymbolFlags.Type \| SymbolFlags.Namespace);`
	`1201`	`+ return resolveEntityName(entityName, SymbolFlags.Value \| SymbolFlags.Type \| SymbolFlags.Namespace, /ignoreErrors/ false, dontResolveAlias);`
`1206`	`1202`	`}`
`1207`	`1203`	`}`
`1208`	`1204`
`@@ -1211,7 +1207,7 @@ namespace ts {`
`1211`	`1207`	`}`
`1212`	`1208`
`1213`	`1209`	`// Resolves a qualified name and any involved aliases`
`1214`		`- function resolveEntityName(name: EntityName \| Expression, meaning: SymbolFlags, ignoreErrors?: boolean): Symbol {`
	`1210`	`+ function resolveEntityName(name: EntityName \| Expression, meaning: SymbolFlags, ignoreErrors?: boolean, dontResolveAlias?: boolean): Symbol {`
`1215`	`1211`	`if (nodeIsMissing(name)) {`
`1216`	`1212`	`return undefined;`
`1217`	`1213`	`}`
`@@ -1245,7 +1241,7 @@ namespace ts {`
`1245`	`1241`	`Debug.fail("Unknown entity name kind.");`
`1246`	`1242`	`}`
`1247`	`1243`	`Debug.assert((symbol.flags & SymbolFlags.Instantiated) === 0, "Should never get an instantiated symbol here.");`
`1248`		`- return symbol.flags & meaning ? symbol : resolveAlias(symbol);`
	`1244`	`+ return (symbol.flags & meaning) \|\| dontResolveAlias ? symbol : resolveAlias(symbol);`
`1249`	`1245`	`}`
`1250`	`1246`
`1251`	`1247`	`function resolveExternalModuleName(location: Node, moduleReferenceExpression: Expression): Symbol {`
`@@ -16803,7 +16799,9 @@ namespace ts {`
`16803`	`16799`	`if (entityName.kind !== SyntaxKind.PropertyAccessExpression) {`
`16804`	`16800`	`if (isInRightSideOfImportOrExportAssignment(<EntityName>entityName)) {`
`16805`	`16801`	`// Since we already checked for ExportAssignment, this really could only be an Import`
`16806`		`- return getSymbolOfPartOfRightHandSideOfImportEquals(<EntityName>entityName);`
	`16802`	`+ const importEqualsDeclaration = <ImportEqualsDeclaration>getAncestor(entityName, SyntaxKind.ImportEqualsDeclaration);`
	`16803`	`+ Debug.assert(importEqualsDeclaration !== undefined);`
	`16804`	`+ return getSymbolOfPartOfRightHandSideOfImportEquals(<EntityName>entityName, importEqualsDeclaration, /dontResolveAlias/ true);`
`16807`	`16805`	`}`
`16808`	`16806`	`}`
`16809`	`16807`
`@@ -16899,9 +16897,7 @@ namespace ts {`
`16899`	`16897`
`16900`	`16898`	`if (node.kind === SyntaxKind.Identifier) {`
`16901`	`16899`	`if (isInRightSideOfImportOrExportAssignment(<Identifier>node)) {`
`16902`		`- return node.parent.kind === SyntaxKind.ExportAssignment`
`16903`		`- ? getSymbolOfEntityNameOrPropertyAccessExpression(<Identifier>node)`
`16904`		`- : getSymbolOfPartOfRightHandSideOfImportEquals(<Identifier>node);`
	`16900`	`+ return getSymbolOfEntityNameOrPropertyAccessExpression(<Identifier>node);`
`16905`	`16901`	`}`
`16906`	`16902`	`else if (node.parent.kind === SyntaxKind.BindingElement &&`
`16907`	`16903`	`node.parent.parent.kind === SyntaxKind.ObjectBindingPattern &&`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ export module M {`
`37`	`37`
`38`	`38`	`export import d = im;`
`39`	`39`	`>d : Symbol(d, Decl(declarationEmit_nameConflicts_0.ts, 11, 24))`
`40`		`->im : Symbol(d, Decl(declarationEmit_nameConflicts_1.ts, 0, 0))`
	`40`	`+>im : Symbol(im, Decl(declarationEmit_nameConflicts_0.ts, 0, 0))`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`export module M.P {`