From 56fc112d8dcfe53327af4d347b7351dd0a7884c5 Mon Sep 17 00:00:00 2001 From: Justin Bay Date: Wed, 25 Oct 2017 20:50:11 -0400 Subject: [PATCH] add more information to quickinfo for imported symbols --- .gitignore | 1 + src/services/symbolDisplay.ts | 66 +- ...foDisplayPartsInternalModuleAlias.baseline | 722 ++++++++++++++++++ .../fourslash/ambientShorthandFindAllRefs.ts | 4 +- .../ambientShorthandGotoDefinition.ts | 8 +- .../fourslash/completionListOnAliases.ts | 2 +- ...mpletionsImport_named_didNotExistBefore.ts | 2 +- .../fourslash/completionsImport_ofAlias.ts | 2 +- .../fourslash/duplicatePackageServices.ts | 4 +- tests/cases/fourslash/exportEqualTypes.ts | 2 +- .../externalModuleWithExportAssignment.ts | 18 +- .../findAllReferencesOfConstructor.ts | 4 +- .../fourslash/findAllRefsClassExpression2.ts | 2 +- .../fourslash/findAllRefsExportAsNamespace.ts | 2 +- .../findAllRefsExportConstEqualToClass.ts | 2 +- .../fourslash/findAllRefsForDefaultExport.ts | 4 +- .../findAllRefsForDefaultExport04.ts | 10 +- .../findAllRefsForDefaultExport_reExport.ts | 12 +- ...t_reExport_allowSyntheticDefaultImports.ts | 12 +- .../findAllRefsImportStarOfExportEquals.ts | 16 +- .../fourslash/findAllRefsOnImportAliases.ts | 4 +- .../fourslash/findAllRefsOnImportAliases2.ts | 4 +- .../fourslash/findAllRefsReExportLocal.ts | 6 +- ...findAllRefsReExportRightNameWrongSymbol.ts | 6 +- .../fourslash/findAllRefsReExportStar.ts | 2 +- tests/cases/fourslash/findAllRefsReExports.ts | 14 +- .../cases/fourslash/findAllRefsReExports2.ts | 2 +- .../findAllRefsRenameImportWithSameName.ts | 2 +- .../fourslash/findReferencesJSXTagName.ts | 2 +- .../getOccurrencesIsDefinitionOfExport.ts | 2 +- ...mergedDeclarationsWithExportAssignment1.ts | 6 +- ...uickInfoDisplayPartsInternalModuleAlias.ts | 31 +- .../cases/fourslash/quickInfoImportedTypes.ts | 34 + ...uickInfoImportedTypesWithMergedMeanings.ts | 28 + tests/cases/fourslash/quickInfoMeaning.ts | 4 +- .../fourslash/quickInfoOnInternalAliases.ts | 8 +- .../cases/fourslash/referencesForAmbients.ts | 2 +- .../cases/fourslash/referencesForGlobals5.ts | 2 +- .../referencesForMergedDeclarations2.ts | 6 +- tests/cases/fourslash/renameDefaultImport.ts | 2 +- .../renameDefaultImportDifferentName.ts | 2 +- .../renameImportAndExportInDiffFiles.ts | 2 +- .../fourslash/renameImportOfExportEquals.ts | 4 +- .../fourslash/renameImportOfExportEquals2.ts | 6 +- .../cases/fourslash/renameImportOfReExport.ts | 4 +- .../fourslash/renameImportOfReExport2.ts | 4 +- .../fourslash/transitiveExportImports.ts | 2 +- .../fourslash/transitiveExportImports2.ts | 4 +- .../fourslash/transitiveExportImports3.ts | 6 +- 49 files changed, 958 insertions(+), 138 deletions(-) create mode 100644 tests/baselines/reference/quickInfoDisplayPartsInternalModuleAlias.baseline create mode 100644 tests/cases/fourslash/quickInfoImportedTypes.ts create mode 100644 tests/cases/fourslash/quickInfoImportedTypesWithMergedMeanings.ts diff --git a/.gitignore b/.gitignore index 19d96d0b04..5125de360b 100644 --- a/.gitignore +++ b/.gitignore @@ -58,6 +58,7 @@ internal/ !tests/baselines/reference/project/nodeModules*/**/* .idea yarn.lock +yarn-error.log .parallelperf.* tests/cases/user/*/package-lock.json tests/cases/user/*/node_modules/ diff --git a/src/services/symbolDisplay.ts b/src/services/symbolDisplay.ts index caf38306be..600a269e2c 100644 --- a/src/services/symbolDisplay.ts +++ b/src/services/symbolDisplay.ts @@ -105,7 +105,7 @@ namespace ts.SymbolDisplay { // TODO(drosen): Currently completion entry details passes the SemanticMeaning.All instead of using semanticMeaning of location export function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker: TypeChecker, symbol: Symbol, sourceFile: SourceFile, enclosingDeclaration: Node, - location: Node, semanticMeaning = getMeaningFromLocation(location)): SymbolDisplayPartsDocumentationAndSymbolKind { + location: Node, semanticMeaning = getMeaningFromLocation(location), alias?: Symbol): SymbolDisplayPartsDocumentationAndSymbolKind { const displayParts: SymbolDisplayPart[] = []; let documentation: SymbolDisplayPart[]; @@ -115,6 +115,7 @@ namespace ts.SymbolDisplay { let hasAddedSymbolInfo: boolean; const isThisExpression = location.kind === SyntaxKind.ThisKeyword && isExpression(location); let type: Type; + let documentationFromAlias: SymbolDisplayPart[]; // Class at constructor site need to be shown as constructor apart from property,method, vars if (symbolKind !== ScriptElementKind.unknown || symbolFlags & SymbolFlags.Class || symbolFlags & SymbolFlags.Alias) { @@ -243,6 +244,7 @@ namespace ts.SymbolDisplay { } } if (symbolFlags & SymbolFlags.Class && !hasAddedSymbolInfo && !isThisExpression) { + addAliasPrefixIfNecessary(); if (getDeclarationOfKind(symbol, SyntaxKind.ClassExpression)) { // Special case for class expressions because we would like to indicate that // the class name is local to the class body (similar to function expression) @@ -258,14 +260,14 @@ namespace ts.SymbolDisplay { writeTypeParametersOfSymbol(symbol, sourceFile); } if ((symbolFlags & SymbolFlags.Interface) && (semanticMeaning & SemanticMeaning.Type)) { - addNewLineIfDisplayPartsExist(); + prefixNextMeaning(); displayParts.push(keywordPart(SyntaxKind.InterfaceKeyword)); displayParts.push(spacePart()); addFullSymbolName(symbol); writeTypeParametersOfSymbol(symbol, sourceFile); } if (symbolFlags & SymbolFlags.TypeAlias) { - addNewLineIfDisplayPartsExist(); + prefixNextMeaning(); displayParts.push(keywordPart(SyntaxKind.TypeKeyword)); displayParts.push(spacePart()); addFullSymbolName(symbol); @@ -276,7 +278,7 @@ namespace ts.SymbolDisplay { addRange(displayParts, typeToDisplayParts(typeChecker, typeChecker.getDeclaredTypeOfSymbol(symbol), enclosingDeclaration, TypeFormatFlags.InTypeAlias)); } if (symbolFlags & SymbolFlags.Enum) { - addNewLineIfDisplayPartsExist(); + prefixNextMeaning(); if (forEach(symbol.declarations, isConstEnumDeclaration)) { displayParts.push(keywordPart(SyntaxKind.ConstKeyword)); displayParts.push(spacePart()); @@ -286,7 +288,7 @@ namespace ts.SymbolDisplay { addFullSymbolName(symbol); } if (symbolFlags & SymbolFlags.Module) { - addNewLineIfDisplayPartsExist(); + prefixNextMeaning(); const declaration = getDeclarationOfKind(symbol, SyntaxKind.ModuleDeclaration); const isNamespace = declaration && declaration.name && declaration.name.kind === SyntaxKind.Identifier; displayParts.push(keywordPart(isNamespace ? SyntaxKind.NamespaceKeyword : SyntaxKind.ModuleKeyword)); @@ -294,7 +296,7 @@ namespace ts.SymbolDisplay { addFullSymbolName(symbol); } if ((symbolFlags & SymbolFlags.TypeParameter) && (semanticMeaning & SemanticMeaning.Type)) { - addNewLineIfDisplayPartsExist(); + prefixNextMeaning(); displayParts.push(punctuationPart(SyntaxKind.OpenParenToken)); displayParts.push(textPart("type parameter")); displayParts.push(punctuationPart(SyntaxKind.CloseParenToken)); @@ -354,7 +356,32 @@ namespace ts.SymbolDisplay { } } if (symbolFlags & SymbolFlags.Alias) { - addNewLineIfDisplayPartsExist(); + prefixNextMeaning(); + if (!hasAddedSymbolInfo) { + const resolvedSymbol = typeChecker.getAliasedSymbol(symbol); + if (resolvedSymbol !== symbol && resolvedSymbol.declarations && resolvedSymbol.declarations.length > 0) { + const resolvedNode = resolvedSymbol.declarations[0]; + const declarationName = ts.getNameOfDeclaration(resolvedNode); + if (declarationName) { + const isExternalModuleDeclaration = + ts.isModuleWithStringLiteralName(resolvedNode) && + ts.hasModifier(resolvedNode, ModifierFlags.Ambient); + const shouldUseAliasName = symbol.name !== "default" && !isExternalModuleDeclaration; + const resolvedInfo = getSymbolDisplayPartsDocumentationAndSymbolKind( + typeChecker, + resolvedSymbol, + ts.getSourceFileOfNode(resolvedNode), + resolvedNode, + declarationName, + semanticMeaning, + shouldUseAliasName ? symbol : resolvedSymbol); + displayParts.push(...resolvedInfo.displayParts); + displayParts.push(lineBreakPart()); + documentationFromAlias = resolvedInfo.documentation; + } + } + } + switch (symbol.declarations[0].kind) { case SyntaxKind.NamespaceExportDeclaration: displayParts.push(keywordPart(SyntaxKind.ExportKeyword)); @@ -400,7 +427,7 @@ namespace ts.SymbolDisplay { if (symbolKind !== ScriptElementKind.unknown) { if (type) { if (isThisExpression) { - addNewLineIfDisplayPartsExist(); + prefixNextMeaning(); displayParts.push(keywordPart(SyntaxKind.ThisKeyword)); } else { @@ -472,12 +499,24 @@ namespace ts.SymbolDisplay { } } + if (documentation.length === 0 && documentationFromAlias) { + documentation = documentationFromAlias; + } + return { displayParts, documentation, symbolKind, tags }; - function addNewLineIfDisplayPartsExist() { + function prefixNextMeaning() { if (displayParts.length) { displayParts.push(lineBreakPart()); } + addAliasPrefixIfNecessary(); + } + + function addAliasPrefixIfNecessary() { + if (alias) { + pushTypePart(ScriptElementKind.alias); + displayParts.push(spacePart()); + } } function addInPrefix() { @@ -486,14 +525,17 @@ namespace ts.SymbolDisplay { displayParts.push(spacePart()); } - function addFullSymbolName(symbol: Symbol, enclosingDeclaration?: Node) { - const fullSymbolDisplayParts = symbolToDisplayParts(typeChecker, symbol, enclosingDeclaration || sourceFile, /*meaning*/ undefined, + function addFullSymbolName(symbolToDisplay: Symbol, enclosingDeclaration?: Node) { + if (alias && symbolToDisplay === symbol) { + symbolToDisplay = alias; + } + const fullSymbolDisplayParts = symbolToDisplayParts(typeChecker, symbolToDisplay, enclosingDeclaration || sourceFile, /*meaning*/ undefined, SymbolFormatFlags.WriteTypeParametersOrArguments | SymbolFormatFlags.UseOnlyExternalAliasing); addRange(displayParts, fullSymbolDisplayParts); } function addPrefixForAnyFunctionOrVar(symbol: Symbol, symbolKind: string) { - addNewLineIfDisplayPartsExist(); + prefixNextMeaning(); if (symbolKind) { pushTypePart(symbolKind); if (symbol && !some(symbol.declarations, d => isArrowFunction(d) || (isFunctionExpression(d) || isClassExpression(d)) && !d.name)) { diff --git a/tests/baselines/reference/quickInfoDisplayPartsInternalModuleAlias.baseline b/tests/baselines/reference/quickInfoDisplayPartsInternalModuleAlias.baseline new file mode 100644 index 0000000000..c476abad35 --- /dev/null +++ b/tests/baselines/reference/quickInfoDisplayPartsInternalModuleAlias.baseline @@ -0,0 +1,722 @@ +[ + { + "marker": { + "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInternalModuleAlias.ts", + "position": 66 + }, + "quickInfo": { + "kind": "alias", + "kindModifiers": "", + "textSpan": { + "start": 66, + "length": 2 + }, + "displayParts": [ + { + "text": "(", + "kind": "punctuation" + }, + { + "text": "alias", + "kind": "text" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "namespace", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "a1", + "kind": "aliasName" + }, + { + "text": "\n", + "kind": "lineBreak" + }, + { + "text": "import", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "a1", + "kind": "aliasName" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "=", + "kind": "operator" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "m", + "kind": "moduleName" + } + ], + "documentation": [], + "tags": [] + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInternalModuleAlias.ts", + "position": 82 + }, + "quickInfo": { + "kind": "alias", + "kindModifiers": "", + "textSpan": { + "start": 82, + "length": 2 + }, + "displayParts": [ + { + "text": "(", + "kind": "punctuation" + }, + { + "text": "alias", + "kind": "text" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "namespace", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "a1", + "kind": "aliasName" + }, + { + "text": "\n", + "kind": "lineBreak" + }, + { + "text": "import", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "a1", + "kind": "aliasName" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "=", + "kind": "operator" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "m", + "kind": "moduleName" + } + ], + "documentation": [], + "tags": [] + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInternalModuleAlias.ts", + "position": 104 + }, + "quickInfo": { + "kind": "alias", + "kindModifiers": "", + "textSpan": { + "start": 104, + "length": 2 + }, + "displayParts": [ + { + "text": "(", + "kind": "punctuation" + }, + { + "text": "alias", + "kind": "text" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "namespace", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "a2", + "kind": "aliasName" + }, + { + "text": "\n", + "kind": "lineBreak" + }, + { + "text": "import", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "a2", + "kind": "aliasName" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "=", + "kind": "operator" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "m", + "kind": "moduleName" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "m1", + "kind": "moduleName" + } + ], + "documentation": [], + "tags": [] + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInternalModuleAlias.ts", + "position": 123 + }, + "quickInfo": { + "kind": "alias", + "kindModifiers": "", + "textSpan": { + "start": 123, + "length": 2 + }, + "displayParts": [ + { + "text": "(", + "kind": "punctuation" + }, + { + "text": "alias", + "kind": "text" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "namespace", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "a2", + "kind": "aliasName" + }, + { + "text": "\n", + "kind": "lineBreak" + }, + { + "text": "import", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "a2", + "kind": "aliasName" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "=", + "kind": "operator" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "m", + "kind": "moduleName" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "m1", + "kind": "moduleName" + } + ], + "documentation": [], + "tags": [] + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInternalModuleAlias.ts", + "position": 149 + }, + "quickInfo": { + "kind": "alias", + "kindModifiers": "export", + "textSpan": { + "start": 149, + "length": 2 + }, + "displayParts": [ + { + "text": "(", + "kind": "punctuation" + }, + { + "text": "alias", + "kind": "text" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "namespace", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "m2", + "kind": "moduleName" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "a3", + "kind": "aliasName" + }, + { + "text": "\n", + "kind": "lineBreak" + }, + { + "text": "import", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "m2", + "kind": "moduleName" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "a3", + "kind": "aliasName" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "=", + "kind": "operator" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "m", + "kind": "moduleName" + } + ], + "documentation": [], + "tags": [] + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInternalModuleAlias.ts", + "position": 165 + }, + "quickInfo": { + "kind": "alias", + "kindModifiers": "export", + "textSpan": { + "start": 165, + "length": 2 + }, + "displayParts": [ + { + "text": "(", + "kind": "punctuation" + }, + { + "text": "alias", + "kind": "text" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "namespace", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "m2", + "kind": "moduleName" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "a3", + "kind": "aliasName" + }, + { + "text": "\n", + "kind": "lineBreak" + }, + { + "text": "import", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "m2", + "kind": "moduleName" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "a3", + "kind": "aliasName" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "=", + "kind": "operator" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "m", + "kind": "moduleName" + } + ], + "documentation": [], + "tags": [] + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInternalModuleAlias.ts", + "position": 194 + }, + "quickInfo": { + "kind": "alias", + "kindModifiers": "export", + "textSpan": { + "start": 194, + "length": 2 + }, + "displayParts": [ + { + "text": "(", + "kind": "punctuation" + }, + { + "text": "alias", + "kind": "text" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "namespace", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "m2", + "kind": "moduleName" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "a4", + "kind": "aliasName" + }, + { + "text": "\n", + "kind": "lineBreak" + }, + { + "text": "import", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "m2", + "kind": "moduleName" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "a4", + "kind": "aliasName" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "=", + "kind": "operator" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "m", + "kind": "moduleName" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "m1", + "kind": "moduleName" + } + ], + "documentation": [], + "tags": [] + } + }, + { + "marker": { + "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInternalModuleAlias.ts", + "position": 213 + }, + "quickInfo": { + "kind": "alias", + "kindModifiers": "export", + "textSpan": { + "start": 213, + "length": 2 + }, + "displayParts": [ + { + "text": "(", + "kind": "punctuation" + }, + { + "text": "alias", + "kind": "text" + }, + { + "text": ")", + "kind": "punctuation" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "namespace", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "m2", + "kind": "moduleName" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "a4", + "kind": "aliasName" + }, + { + "text": "\n", + "kind": "lineBreak" + }, + { + "text": "import", + "kind": "keyword" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "m2", + "kind": "moduleName" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "a4", + "kind": "aliasName" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "=", + "kind": "operator" + }, + { + "text": " ", + "kind": "space" + }, + { + "text": "m", + "kind": "moduleName" + }, + { + "text": ".", + "kind": "punctuation" + }, + { + "text": "m1", + "kind": "moduleName" + } + ], + "documentation": [], + "tags": [] + } + } +] \ No newline at end of file diff --git a/tests/cases/fourslash/ambientShorthandFindAllRefs.ts b/tests/cases/fourslash/ambientShorthandFindAllRefs.ts index 3f325a546c..14918f4a44 100644 --- a/tests/cases/fourslash/ambientShorthandFindAllRefs.ts +++ b/tests/cases/fourslash/ambientShorthandFindAllRefs.ts @@ -12,5 +12,5 @@ const ranges = test.ranges(); const [r0, r1] = ranges; // TODO: Want these to be in the same group, but that would require creating a symbol for `x`. -verify.singleReferenceGroup("import x", [r0]); -verify.singleReferenceGroup("import x", [r1]); \ No newline at end of file +verify.singleReferenceGroup("(alias) module \"jquery\"\nimport x", [r0]); +verify.singleReferenceGroup("(alias) module \"jquery\"\nimport x", [r1]); \ No newline at end of file diff --git a/tests/cases/fourslash/ambientShorthandGotoDefinition.ts b/tests/cases/fourslash/ambientShorthandGotoDefinition.ts index f0e717999c..6530a0e0c9 100644 --- a/tests/cases/fourslash/ambientShorthandGotoDefinition.ts +++ b/tests/cases/fourslash/ambientShorthandGotoDefinition.ts @@ -10,22 +10,22 @@ ////import [|/*importBang*/bang|] = require("jquery"); ////[|foo/*useFoo*/|]([|bar/*useBar*/|], [|baz/*useBaz*/|], [|bang/*useBang*/|]); -verify.quickInfoAt("useFoo", "import foo"); +verify.quickInfoAt("useFoo", "(alias) module \"jquery\"\nimport foo"); verify.goToDefinition({ useFoo: "module", importFoo: "module" }); -verify.quickInfoAt("useBar", "import bar"); +verify.quickInfoAt("useBar", "(alias) module \"jquery\"\nimport bar"); verify.goToDefinition("useBar", "module"); -verify.quickInfoAt("useBaz", "import baz"); +verify.quickInfoAt("useBaz", "(alias) module \"jquery\"\nimport baz"); verify.goToDefinition({ useBaz: "importBaz", importBaz: "module" }); -verify.quickInfoAt("useBang", "import bang = require(\"jquery\")"); +verify.quickInfoAt("useBang", "(alias) module \"jquery\"\nimport bang = require(\"jquery\")"); verify.goToDefinition({ useBang: "module", importBang: "module" diff --git a/tests/cases/fourslash/completionListOnAliases.ts b/tests/cases/fourslash/completionListOnAliases.ts index c15e5284c0..0c5b7adcd5 100644 --- a/tests/cases/fourslash/completionListOnAliases.ts +++ b/tests/cases/fourslash/completionListOnAliases.ts @@ -9,7 +9,7 @@ ////} goTo.marker("1"); -verify.completionListContains("x", "import x = M", undefined); +verify.completionListContains("x", "(alias) namespace x\nimport x = M", undefined); goTo.marker("2"); verify.completionListContains("value"); diff --git a/tests/cases/fourslash/completionsImport_named_didNotExistBefore.ts b/tests/cases/fourslash/completionsImport_named_didNotExistBefore.ts index c793a5f06a..a69c0ab19c 100644 --- a/tests/cases/fourslash/completionsImport_named_didNotExistBefore.ts +++ b/tests/cases/fourslash/completionsImport_named_didNotExistBefore.ts @@ -11,7 +11,7 @@ goTo.marker(""); const options = { includeExternalModuleExports: true, sourceDisplay: undefined }; verify.completionListContains({ name: "Test1", source: "/a" }, "function Test1(): void", "", "function", /*spanIndex*/ undefined, /*hasAction*/ true, { ...options, sourceDisplay: "./a" }); -verify.completionListContains("Test2", "import Test2", "", "alias", /*spanIndex*/ undefined, /*hasAction*/ undefined, options); +verify.completionListContains("Test2", "(alias) function Test2(): void\nimport Test2", "", "alias", /*spanIndex*/ undefined, /*hasAction*/ undefined, options); verify.not.completionListContains({ name: "Test2", source: "/a" }, undefined, undefined, undefined, undefined, undefined, options); verify.applyCodeActionFromCompletion("", { diff --git a/tests/cases/fourslash/completionsImport_ofAlias.ts b/tests/cases/fourslash/completionsImport_ofAlias.ts index a693065b93..5808e6c9f1 100644 --- a/tests/cases/fourslash/completionsImport_ofAlias.ts +++ b/tests/cases/fourslash/completionsImport_ofAlias.ts @@ -21,7 +21,7 @@ goTo.marker(""); const options = { includeExternalModuleExports: true, sourceDisplay: "./a" }; // TODO: https://github.com/Microsoft/TypeScript/issues/14003 //TODO: verify that there's only one! -verify.completionListContains({ name: "foo", source: "/a" }, "import foo", "", "alias", /*spanIndex*/ undefined, /*hasAction*/ true, options); +verify.completionListContains({ name: "foo", source: "/a" }, "(alias) const foo: 0\nimport foo", "", "alias", /*spanIndex*/ undefined, /*hasAction*/ true, options); verify.not.completionListContains({ name: "foo", source: "/a_reexport" }, undefined, undefined, undefined, undefined, undefined, options); verify.not.completionListContains({ name: "foo", source: "/a_reexport_2" }, undefined, undefined, undefined, undefined, undefined, options); diff --git a/tests/cases/fourslash/duplicatePackageServices.ts b/tests/cases/fourslash/duplicatePackageServices.ts index c84c43cdd9..48dfdf8aa8 100644 --- a/tests/cases/fourslash/duplicatePackageServices.ts +++ b/tests/cases/fourslash/duplicatePackageServices.ts @@ -36,9 +36,9 @@ verify.goToDefinition("useAX", "defAX"); verify.goToDefinition("useBX", "defAX"); const [r0, r1, r2, r3, r4, r5] = test.ranges(); -const aImport = { definition: "import X", ranges: [r0, r1] }; +const aImport = { definition: "(alias) class X\nimport X", ranges: [r0, r1] }; const def = { definition: "class X", ranges: [r2] }; -const bImport = { definition: "import X", ranges: [r3, r4] }; +const bImport = { definition: "(alias) class X\nimport X", ranges: [r3, r4] }; verify.referenceGroups([r0, r1], [aImport, def, bImport]); verify.referenceGroups([r2], [def, aImport, bImport]); verify.referenceGroups([r3, r4], [bImport, def, aImport]); diff --git a/tests/cases/fourslash/exportEqualTypes.ts b/tests/cases/fourslash/exportEqualTypes.ts index f130d21103..cb1e2ec90a 100644 --- a/tests/cases/fourslash/exportEqualTypes.ts +++ b/tests/cases/fourslash/exportEqualTypes.ts @@ -15,7 +15,7 @@ ////var /*3*/r2 = t./*4*/foo; // t should have 'foo' in dropdown list and be of type 'string' verify.quickInfos({ - 1: "import test = require('./exportEqualTypes_file0')", + 1: "(alias) interface test\nimport test = require('./exportEqualTypes_file0')", 2: "var r1: Date", 3: "var r2: string" }); diff --git a/tests/cases/fourslash/externalModuleWithExportAssignment.ts b/tests/cases/fourslash/externalModuleWithExportAssignment.ts index 5b39262369..e35a89f1d7 100644 --- a/tests/cases/fourslash/externalModuleWithExportAssignment.ts +++ b/tests/cases/fourslash/externalModuleWithExportAssignment.ts @@ -29,8 +29,22 @@ ////var v1: a1./*15*/connectExport; goTo.file("externalModuleWithExportAssignment_file1.ts"); -verify.quickInfoAt("1", 'import a1 = require("./externalModuleWithExportAssignment_file0")'); -verify.quickInfoAt("2", "var a: {\n (): a1.connectExport;\n test1: a1.connectModule;\n test2(): a1.connectModule;\n}", undefined); +verify.quickInfoAt("1", [ + "(alias) namespace a1", + "(alias) var a1: {", + " (): connectExport;", + " test1: connectModule;", + " test2(): connectModule;", + "}", + 'import a1 = require("./externalModuleWithExportAssignment_file0")' +].join("\n")); +verify.quickInfoAt("2", [ + "var a: {", + " (): a1.connectExport;", + " test1: a1.connectModule;", + " test2(): a1.connectModule;", + "}" +].join("\n"), undefined); goTo.marker('3'); verify.quickInfoIs("(property) test1: a1.connectModule\n(res: any, req: any, next: any) => void", undefined); diff --git a/tests/cases/fourslash/findAllReferencesOfConstructor.ts b/tests/cases/fourslash/findAllReferencesOfConstructor.ts index 37f0264c81..d177907b97 100644 --- a/tests/cases/fourslash/findAllReferencesOfConstructor.ts +++ b/tests/cases/fourslash/findAllReferencesOfConstructor.ts @@ -48,7 +48,7 @@ verify.referenceGroups(a1, defs("constructor C(): C (+1 overload)")); function defs(definition: string) { return [ { definition, ranges: [a0, a1, a2, a3, d0, d1, a4] }, - { definition: "import C", ranges: [b0] }, - { definition: "import C", ranges: [c0] } + { definition: "(alias) class C\nimport C", ranges: [b0] }, + { definition: "(alias) class C\nimport C", ranges: [c0] } ] } diff --git a/tests/cases/fourslash/findAllRefsClassExpression2.ts b/tests/cases/fourslash/findAllRefsClassExpression2.ts index ce2fc8bbf3..b9d2267c51 100644 --- a/tests/cases/fourslash/findAllRefsClassExpression2.ts +++ b/tests/cases/fourslash/findAllRefsClassExpression2.ts @@ -11,6 +11,6 @@ const [r0, r1, r2] = test.ranges(); const defs = { definition: "(property) A: typeof (Anonymous class)", ranges: [r0] }; -const imports = { definition: "import A", ranges: [r1, r2] }; +const imports = { definition: "(alias) (property) A: typeof (Anonymous class)\nimport A", ranges: [r1, r2] }; verify.referenceGroups([r0], [defs, imports]); verify.referenceGroups([r1, r2], [imports, defs]); diff --git a/tests/cases/fourslash/findAllRefsExportAsNamespace.ts b/tests/cases/fourslash/findAllRefsExportAsNamespace.ts index e6b29fce47..f6149f17d9 100644 --- a/tests/cases/fourslash/findAllRefsExportAsNamespace.ts +++ b/tests/cases/fourslash/findAllRefsExportAsNamespace.ts @@ -18,7 +18,7 @@ const ranges = test.ranges(); const [r0, r1, r2] = ranges; const globals = { definition: "function f(): void", ranges: [r0, r2] }; -const imports = { definition: "import f", ranges: [r1] }; +const imports = { definition: "(alias) function f(): void\nimport f", ranges: [r1] }; verify.referenceGroups([r0, r2], [globals, imports]); verify.referenceGroups(r1, [imports, globals]); diff --git a/tests/cases/fourslash/findAllRefsExportConstEqualToClass.ts b/tests/cases/fourslash/findAllRefsExportConstEqualToClass.ts index a5e9bd1cd7..6be7ea0bdb 100644 --- a/tests/cases/fourslash/findAllRefsExportConstEqualToClass.ts +++ b/tests/cases/fourslash/findAllRefsExportConstEqualToClass.ts @@ -12,6 +12,6 @@ const [C0, D0, C1, D1] = test.ranges(); verify.singleReferenceGroup("class C", [C0, C1]); const d0Group = { definition: "const D: typeof C", ranges: [D0] }; -const d1Group = { definition: "import D", ranges: [D1] }; +const d1Group = { definition: "(alias) const D: typeof C\nimport D", ranges: [D1] }; verify.referenceGroups(D0, [d0Group, d1Group]); verify.referenceGroups(D1, [d1Group, d0Group]); diff --git a/tests/cases/fourslash/findAllRefsForDefaultExport.ts b/tests/cases/fourslash/findAllRefsForDefaultExport.ts index 414b250339..1fe48cd78a 100644 --- a/tests/cases/fourslash/findAllRefsForDefaultExport.ts +++ b/tests/cases/fourslash/findAllRefsForDefaultExport.ts @@ -14,9 +14,9 @@ const ranges = test.ranges(); const [r0, r1, r2] = ranges; verify.referenceGroups(r0, [ { definition: "function f(): void", ranges: [r0] }, - { definition: "import g", ranges: [r1, r2] } + { definition: "(alias) function g(): void\nimport g", ranges: [r1, r2] } ]); -verify.referenceGroups(r1, [{ definition: "import g", ranges: [r1, r2] }]); +verify.referenceGroups(r1, [{ definition: "(alias) function g(): void\nimport g", ranges: [r1, r2] }]); verify.referenceGroups(r2, [{ definition: "(alias) g(): void\nimport g", ranges: [r1, r2] }]); verify.goToDefinition("ref", "def"); diff --git a/tests/cases/fourslash/findAllRefsForDefaultExport04.ts b/tests/cases/fourslash/findAllRefsForDefaultExport04.ts index 093910d1cb..279f2bd1e8 100644 --- a/tests/cases/fourslash/findAllRefsForDefaultExport04.ts +++ b/tests/cases/fourslash/findAllRefsForDefaultExport04.ts @@ -11,13 +11,13 @@ const [r0, r1, r2, r3, r4] = test.ranges(); verify.referenceGroups([r0, r2], [ { definition: "const a: 0", ranges: [r0, r2] }, - { definition: "import a", ranges: [r3, r4] } + { definition: "(alias) const a: 0\nimport a", ranges: [r3, r4] } ]); verify.referenceGroups(r1, [ - { definition: "export default a", ranges: [r1] }, - { definition: "import a", ranges: [r3, r4] }, + { definition: "(alias) const a: 0\nexport default a", ranges: [r1] }, + { definition: "(alias) const a: 0\nimport a", ranges: [r3, r4] }, ]); verify.referenceGroups([r3, r4], [ - { definition: "import a", ranges: [r3, r4] }, - { definition: "export default a", ranges: [r1] }, + { definition: "(alias) const a: 0\nimport a", ranges: [r3, r4] }, + { definition: "(alias) const a: 0\nexport default a", ranges: [r1] }, ]); diff --git a/tests/cases/fourslash/findAllRefsForDefaultExport_reExport.ts b/tests/cases/fourslash/findAllRefsForDefaultExport_reExport.ts index 4c2427639f..2154087d81 100644 --- a/tests/cases/fourslash/findAllRefsForDefaultExport_reExport.ts +++ b/tests/cases/fourslash/findAllRefsForDefaultExport_reExport.ts @@ -13,16 +13,16 @@ const [r0, r1, r2, r3] = test.ranges(); verify.referenceGroups([r0, r1], [ { definition: "const foo: 1", ranges: [r0, r1] }, - { definition: "import default", ranges: [r2], }, - { definition: "import fooDefault", ranges: [r3] }, + { definition: "(alias) const foo: 1\nimport default", ranges: [r2], }, + { definition: "(alias) const fooDefault: 1\nimport fooDefault", ranges: [r3] }, ]); verify.referenceGroups(r2, [ - { definition: "import default", ranges: [r2] }, - { definition: "import fooDefault", ranges: [r3] }, + { definition: "(alias) const foo: 1\nimport default", ranges: [r2] }, + { definition: "(alias) const fooDefault: 1\nimport fooDefault", ranges: [r3] }, { definition: "const foo: 1", ranges: [r0, r1] }, ]); verify.referenceGroups(r3, [ - { definition: "import fooDefault", ranges: [r3] }, - { definition: "import default", ranges: [r2] }, + { definition: "(alias) const fooDefault: 1\nimport fooDefault", ranges: [r3] }, + { definition: "(alias) const foo: 1\nimport default", ranges: [r2] }, { definition: "const foo: 1", ranges: [r0, r1] }, ]); diff --git a/tests/cases/fourslash/findAllRefsForDefaultExport_reExport_allowSyntheticDefaultImports.ts b/tests/cases/fourslash/findAllRefsForDefaultExport_reExport_allowSyntheticDefaultImports.ts index 26a05f2e12..41377a41ac 100644 --- a/tests/cases/fourslash/findAllRefsForDefaultExport_reExport_allowSyntheticDefaultImports.ts +++ b/tests/cases/fourslash/findAllRefsForDefaultExport_reExport_allowSyntheticDefaultImports.ts @@ -17,16 +17,16 @@ verify.noErrors(); const [r0, r1, r2, r3] = test.ranges(); verify.referenceGroups([r0, r1], [ { definition: "const foo: 1", ranges: [r0, r1] }, - { definition: "import default", ranges: [r2], }, - { definition: "import fooDefault", ranges: [r3] }, + { definition: "(alias) const foo: 1\nimport default", ranges: [r2], }, + { definition: "(alias) const fooDefault: 1\nimport fooDefault", ranges: [r3] }, ]); verify.referenceGroups(r2, [ - { definition: "import default", ranges: [r2] }, - { definition: "import fooDefault", ranges: [r3] }, + { definition: "(alias) const foo: 1\nimport default", ranges: [r2] }, + { definition: "(alias) const fooDefault: 1\nimport fooDefault", ranges: [r3] }, { definition: "const foo: 1", ranges: [r0, r1] }, ]); verify.referenceGroups(r3, [ - { definition: "import fooDefault", ranges: [r3] }, - { definition: "import default", ranges: [r2] }, + { definition: "(alias) const fooDefault: 1\nimport fooDefault", ranges: [r3] }, + { definition: "(alias) const foo: 1\nimport default", ranges: [r2] }, { definition: "const foo: 1", ranges: [r0, r1] }, ]); diff --git a/tests/cases/fourslash/findAllRefsImportStarOfExportEquals.ts b/tests/cases/fourslash/findAllRefsImportStarOfExportEquals.ts index c57f4a67fd..c1d3bd8c7f 100644 --- a/tests/cases/fourslash/findAllRefsImportStarOfExportEquals.ts +++ b/tests/cases/fourslash/findAllRefsImportStarOfExportEquals.ts @@ -28,31 +28,31 @@ const cRanges = [c0, c1, c2]; verify.referenceGroups(a0, [ { definition: "function a(): void\nnamespace a", ranges: aRanges }, - { definition: "import b", ranges: bRanges }, - { definition: "import a", ranges: cRanges } + { definition: "(alias) function b(): void\n(alias) namespace b\nimport b", ranges: bRanges }, + { definition: "(alias) function a(): void\n(alias) namespace a\nimport a", ranges: cRanges } ]); verify.referenceGroups([a1, a2], [ { definition: "namespace a\nfunction a(): void", ranges: aRanges }, - { definition: "import b", ranges: bRanges }, - { definition: "import a", ranges: cRanges } + { definition: "(alias) function b(): void\n(alias) namespace b\nimport b", ranges: bRanges }, + { definition: "(alias) function a(): void\n(alias) namespace a\nimport a", ranges: cRanges } ]); verify.referenceGroups([b0, b0], [ - { definition: "import b", ranges: bRanges } + { definition: "(alias) function b(): void\n(alias) namespace b\nimport b", ranges: bRanges } ]); verify.referenceGroups(b1, [ { definition: "(alias) b(): void\nimport b", ranges: bRanges } ]); verify.referenceGroups([c0, c2], [ - { definition: "import a", ranges: cRanges }, + { definition: "(alias) function a(): void\n(alias) namespace a\nimport a", ranges: cRanges }, { definition: "namespace a\nfunction a(): void", ranges: aRanges }, - { definition: "import b", ranges: bRanges } + { definition: "(alias) function b(): void\n(alias) namespace b\nimport b", ranges: bRanges } ]); verify.referenceGroups(c1, [ { definition: "(alias) a(): void\nimport a", ranges: cRanges }, { definition: "namespace a\nfunction a(): void", ranges: aRanges }, - { definition: "import b", ranges: bRanges } + { definition: "(alias) function b(): void\n(alias) namespace b\nimport b", ranges: bRanges } ]); verify.renameLocations(aRanges, aRanges.concat(cRanges)); diff --git a/tests/cases/fourslash/findAllRefsOnImportAliases.ts b/tests/cases/fourslash/findAllRefsOnImportAliases.ts index 98509ad693..cb5dc08215 100644 --- a/tests/cases/fourslash/findAllRefsOnImportAliases.ts +++ b/tests/cases/fourslash/findAllRefsOnImportAliases.ts @@ -15,8 +15,8 @@ const ranges = test.ranges(); const [r0, r1, r2, r3] = ranges; const classes = { definition: "class Class", ranges: [r0] }; -const imports = { definition: "import Class", ranges: [r1, r2] }; -const reExports = { definition: "import Class", ranges: [r3] }; +const imports = { definition: "(alias) class Class\nimport Class", ranges: [r1, r2] }; +const reExports = { definition: "(alias) class Class\nimport Class", ranges: [r3] }; verify.referenceGroups(r0, [classes, imports, reExports]); verify.referenceGroups(r1, [imports, classes, reExports]); verify.referenceGroups(r2, [ diff --git a/tests/cases/fourslash/findAllRefsOnImportAliases2.ts b/tests/cases/fourslash/findAllRefsOnImportAliases2.ts index 64f44018d0..74b099ea76 100644 --- a/tests/cases/fourslash/findAllRefsOnImportAliases2.ts +++ b/tests/cases/fourslash/findAllRefsOnImportAliases2.ts @@ -17,8 +17,8 @@ const c2Ranges = ranges.get("C2"); const [c2_0, c2_1] = c2Ranges; const c3Ranges = ranges.get("C3"); const classes = { definition: "class Class", ranges: classRanges }; -const c2s = { definition: "import C2", ranges: c2Ranges }; -const c3s = { definition: "import C3", ranges: c3Ranges }; +const c2s = { definition: "(alias) class C2\nimport C2", ranges: c2Ranges }; +const c3s = { definition: "(alias) class C3\nimport C3", ranges: c3Ranges }; verify.referenceGroups(classRanges, [classes, c2s, c3s]); diff --git a/tests/cases/fourslash/findAllRefsReExportLocal.ts b/tests/cases/fourslash/findAllRefsReExportLocal.ts index 3e5890e631..f57cc8480f 100644 --- a/tests/cases/fourslash/findAllRefsReExportLocal.ts +++ b/tests/cases/fourslash/findAllRefsReExportLocal.ts @@ -18,9 +18,9 @@ const axRanges = [ax0, ax1, ax2]; const bxRanges = [bx0, bx1]; const byRanges = [by0, by1]; const axGroup = { definition: "var x: any", ranges: axRanges }; -const bxGroup = { definition: "import x", ranges: bxRanges }; -const ayGroup = { definition: "import y", ranges: [ay] } -const byGroup = { definition: "import y", ranges: byRanges } +const bxGroup = { definition: "(alias) var x: any\nimport x", ranges: bxRanges }; +const ayGroup = { definition: "(alias) var y: any\nimport y", ranges: [ay] } +const byGroup = { definition: "(alias) var y: any\nimport y", ranges: byRanges } verify.referenceGroups(axRanges, [axGroup, bxGroup, ayGroup, byGroup]); verify.referenceGroups(bxRanges, [bxGroup, axGroup, ayGroup, byGroup]); diff --git a/tests/cases/fourslash/findAllRefsReExportRightNameWrongSymbol.ts b/tests/cases/fourslash/findAllRefsReExportRightNameWrongSymbol.ts index c9d42e53d4..12305381fe 100644 --- a/tests/cases/fourslash/findAllRefsReExportRightNameWrongSymbol.ts +++ b/tests/cases/fourslash/findAllRefsReExportRightNameWrongSymbol.ts @@ -19,13 +19,13 @@ const [a, b, cFromB, cFromA, cUse, d] = test.ranges(); const cFromARanges = [cFromA, cUse]; const aGroup = { definition: "const x: 0", ranges: [a] }; -const cFromAGroup = { definition: "import x", ranges: cFromARanges }; +const cFromAGroup = { definition: "(alias) const x: 0\nimport x", ranges: cFromARanges }; verify.referenceGroups(a, [aGroup, cFromAGroup]); const bGroup = { definition: "const x: 0", ranges: [b] }; -const cFromBGroup = { definition: "import x", ranges: [cFromB] }; -const dGroup = { definition: "import x", ranges: [d] }; +const cFromBGroup = { definition: "(alias) const x: 0\nimport x", ranges: [cFromB] }; +const dGroup = { definition: "(alias) const x: 0\nimport x", ranges: [d] }; verify.referenceGroups(b, [bGroup, cFromBGroup, dGroup]); verify.referenceGroups(cFromB, [cFromBGroup, dGroup, bGroup]); diff --git a/tests/cases/fourslash/findAllRefsReExportStar.ts b/tests/cases/fourslash/findAllRefsReExportStar.ts index 86901cfadf..a82f91cc5b 100644 --- a/tests/cases/fourslash/findAllRefsReExportStar.ts +++ b/tests/cases/fourslash/findAllRefsReExportStar.ts @@ -13,6 +13,6 @@ verify.noErrors(); const ranges = test.ranges(); const [r0, r1] = ranges; const a = { definition: "function foo(): void", ranges: [r0] }; -const c = { definition: "import foo", ranges: [r1] }; +const c = { definition: "(alias) function foo(): void\nimport foo", ranges: [r1] }; verify.referenceGroups(r0, [a, c]); verify.referenceGroups(r1, [c, a]); diff --git a/tests/cases/fourslash/findAllRefsReExports.ts b/tests/cases/fourslash/findAllRefsReExports.ts index e993686760..9c0e3b26bf 100644 --- a/tests/cases/fourslash/findAllRefsReExports.ts +++ b/tests/cases/fourslash/findAllRefsReExports.ts @@ -22,13 +22,13 @@ verify.noErrors(); const [foo0, foo1, bar0, foo2, defaultC, defaultD, bar1, baz0, defaultE, bang0, boom0, bar2, baz1, bang1, boom1] = test.ranges(); const a = { definition: "function foo(): void", ranges: [foo0, foo1, foo2] }; -const b = { definition: "import bar", ranges: [bar0] }; -const c = { definition: "import default", ranges: [defaultC, defaultE] }; -const d = { definition: "import default", ranges: [defaultD] }; -const eBar = { definition: "import bar", ranges: [bar1, bar2] }; -const eBaz = { definition: "import baz", ranges: [baz0, baz1] }; -const eBang = { definition: "import bang", ranges: [bang0, bang1] }; -const eBoom = { definition: "import boom", ranges: [boom0, boom1] }; +const b = { definition: "(alias) function bar(): void\nimport bar", ranges: [bar0] }; +const c = { definition: "(alias) function foo(): void\nimport default", ranges: [defaultC, defaultE] }; +const d = { definition: "(alias) function foo(): void\nimport default", ranges: [defaultD] }; +const eBar = { definition: "(alias) function bar(): void\nimport bar", ranges: [bar1, bar2] }; +const eBaz = { definition: "(alias) function baz(): void\nimport baz", ranges: [baz0, baz1] }; +const eBang = { definition: "(alias) function bang(): void\nimport bang", ranges: [bang0, bang1] }; +const eBoom = { definition: "(alias) function boom(): void\nimport boom", ranges: [boom0, boom1] }; verify.referenceGroups([foo0, foo1, foo2], [a, b, eBar, c, d, eBoom, eBaz, eBang]); diff --git a/tests/cases/fourslash/findAllRefsReExports2.ts b/tests/cases/fourslash/findAllRefsReExports2.ts index 5dfdc8aebb..31aa07fa29 100644 --- a/tests/cases/fourslash/findAllRefsReExports2.ts +++ b/tests/cases/fourslash/findAllRefsReExports2.ts @@ -10,5 +10,5 @@ verify.noErrors(); const [r0, r1, r2] = test.ranges(); verify.referenceGroups(r0, [ { definition: "function foo(): void", ranges: [r0, r1] }, - { definition: "import oof", ranges: [r2] } + { definition: "(alias) function oof(): void\nimport oof", ranges: [r2] } ]); diff --git a/tests/cases/fourslash/findAllRefsRenameImportWithSameName.ts b/tests/cases/fourslash/findAllRefsRenameImportWithSameName.ts index 5a5db1496a..62b1c19c5e 100644 --- a/tests/cases/fourslash/findAllRefsRenameImportWithSameName.ts +++ b/tests/cases/fourslash/findAllRefsRenameImportWithSameName.ts @@ -12,7 +12,7 @@ const [r0, r1, r2, r3] = test.ranges(); const aRanges = [r0, r1]; const bRanges = [r2, r3]; const aGroup = { definition: "const x: 0", ranges: aRanges }; -const bGroup = { definition: "import x", ranges: bRanges }; +const bGroup = { definition: "(alias) const x: 0\nimport x", ranges: bRanges }; verify.referenceGroups(aRanges, [aGroup, bGroup]); verify.referenceGroups(bRanges, [bGroup]); diff --git a/tests/cases/fourslash/findReferencesJSXTagName.ts b/tests/cases/fourslash/findReferencesJSXTagName.ts index 39031051f1..8547ad8b33 100644 --- a/tests/cases/fourslash/findReferencesJSXTagName.ts +++ b/tests/cases/fourslash/findReferencesJSXTagName.ts @@ -12,7 +12,7 @@ ////
; const [r0, r1, r2] = test.ranges(); -const imports = { definition: "import SubmissionComp", ranges: [r0, r1] }; +const imports = { definition: "(alias) const SubmissionComp: (submission: any) => any\nimport SubmissionComp", ranges: [r0, r1] }; const def = { definition: "const SubmissionComp: (submission: any) => any", ranges: [r2] }; verify.referenceGroups([r0, r1], [imports, def]); verify.referenceGroups(r2, [def, imports]); diff --git a/tests/cases/fourslash/getOccurrencesIsDefinitionOfExport.ts b/tests/cases/fourslash/getOccurrencesIsDefinitionOfExport.ts index 4268e5d180..e31bc46eae 100644 --- a/tests/cases/fourslash/getOccurrencesIsDefinitionOfExport.ts +++ b/tests/cases/fourslash/getOccurrencesIsDefinitionOfExport.ts @@ -8,6 +8,6 @@ const ranges = test.ranges(); const [r0, r1, r2] = ranges; const defs = { definition: "var x: number", ranges: [r0] }; -const imports = { definition: "import x", ranges: [r1, r2] }; +const imports = { definition: "(alias) var x: number\nimport x", ranges: [r1, r2] }; verify.referenceGroups(r0, [defs, imports]); verify.referenceGroups([r1, r2], [imports, defs]); diff --git a/tests/cases/fourslash/mergedDeclarationsWithExportAssignment1.ts b/tests/cases/fourslash/mergedDeclarationsWithExportAssignment1.ts index fd9a2e34b4..f6a159f7ee 100644 --- a/tests/cases/fourslash/mergedDeclarationsWithExportAssignment1.ts +++ b/tests/cases/fourslash/mergedDeclarationsWithExportAssignment1.ts @@ -15,7 +15,11 @@ ////var /*3*/z = new /*2*/Foo(); ////var /*5*/r2 = Foo./*4*/x; -verify.quickInfoAt("1", "import Foo = require('./mergedDeclarationsWithExportAssignment1_file0')"); +verify.quickInfoAt("1", [ + "(alias) class Foo", + "(alias) namespace Foo", + "import Foo = require('./mergedDeclarationsWithExportAssignment1_file0')" +].join("\n")); goTo.marker('2'); verify.completionListContains('Foo'); diff --git a/tests/cases/fourslash/quickInfoDisplayPartsInternalModuleAlias.ts b/tests/cases/fourslash/quickInfoDisplayPartsInternalModuleAlias.ts index 78c22b09da..9fcedc9410 100644 --- a/tests/cases/fourslash/quickInfoDisplayPartsInternalModuleAlias.ts +++ b/tests/cases/fourslash/quickInfoDisplayPartsInternalModuleAlias.ts @@ -15,33 +15,4 @@ //// new /*8*/a4.c(); ////} -var marker = 0; -function goToMarker() { - marker++; - goTo.marker(marker.toString()); -} - -function verifyImport(name: string, assigningDisplay:ts.SymbolDisplayPart[], optionalParentName?: string) { - goToMarker(); - var moduleNameDisplay = [{ text: name, kind: "aliasName" }]; - if (optionalParentName) { - moduleNameDisplay = [{ text: optionalParentName, kind: "moduleName" }, { text: ".", kind: "punctuation" }].concat(moduleNameDisplay); - } - verify.verifyQuickInfoDisplayParts("alias", optionalParentName ? "export" : "", { start: test.markerByName(marker.toString()).position, length: name.length }, - [{ text: "import", kind: "keyword" }, { text: " ", kind: "space" }].concat(moduleNameDisplay).concat( - { text: " ", kind: "space" }, { text: "=", kind: "operator" }, { text: " ", kind: "space" }).concat(assigningDisplay), - [], []); -} - -var moduleMDisplay = [{ text: "m", kind: "moduleName" }]; -var moduleMDotM1Display = moduleMDisplay.concat({ text: ".", kind: "punctuation" }, { text: "m1", kind: "moduleName" }); - -verifyImport("a1", moduleMDisplay); -verifyImport("a1", moduleMDisplay); -verifyImport("a2", moduleMDotM1Display); -verifyImport("a2", moduleMDotM1Display); - -verifyImport("a3", moduleMDisplay, "m2"); -verifyImport("a3", moduleMDisplay, "m2"); -verifyImport("a4", moduleMDotM1Display, "m2"); -verifyImport("a4", moduleMDotM1Display, "m2"); \ No newline at end of file +verify.baselineQuickInfo(); diff --git a/tests/cases/fourslash/quickInfoImportedTypes.ts b/tests/cases/fourslash/quickInfoImportedTypes.ts new file mode 100644 index 0000000000..52da97ada9 --- /dev/null +++ b/tests/cases/fourslash/quickInfoImportedTypes.ts @@ -0,0 +1,34 @@ +/// + +// @Filename: quickInfoImportedTypes.ts +//// /** This is an interface */ +//// export interface Foo { +//// a?: number; +//// } +//// /** One or two */ +//// export type Bar = 1 | 2 +//// /** This is a class */ +//// export class Baz { +//// public x: T = {} as T +//// } + +// @Filename: two.ts +//// import { Foo, Bar, Baz } from './quickInfoImportedTypes'; +//// let x: Foo/*1*/; +//// let y: Bar/*2*/; +//// let z: Baz/*3*/; + +verify.quickInfoAt("1", [ + "(alias) interface Foo", + "import Foo", +].join("\n"), "This is an interface "); + +verify.quickInfoAt("2", [ + "(alias) type Bar = 1 | 2", + "import Bar", +].join("\n"), "One or two "); + +verify.quickInfoAt("3", [ + "(alias) class Baz", + "import Baz", +].join("\n"), "This is a class "); diff --git a/tests/cases/fourslash/quickInfoImportedTypesWithMergedMeanings.ts b/tests/cases/fourslash/quickInfoImportedTypesWithMergedMeanings.ts new file mode 100644 index 0000000000..9e7efc5276 --- /dev/null +++ b/tests/cases/fourslash/quickInfoImportedTypesWithMergedMeanings.ts @@ -0,0 +1,28 @@ +/// + +// @Filename: quickInfoImportedTypesWithMergedMeanings.ts +//// export namespace Original { } +//// export type Original = () => T; +//// /** some docs */ +//// export function Original() { } + +// @Filename: transient.ts +//// export { Original/*1*/ } from './quickInfoImportedTypesWithMergedMeanings'; + +// @Filename: importer.ts +//// import { Original as Alias } from './quickInfoImportedTypesWithMergedMeanings'; +//// Alias/*2*/; + +verify.quickInfoAt("1", [ + "(alias) type Original = () => T", + "(alias) namespace Original", + "(alias) function Original(): void", + "import Original", +].join("\n"), "some docs "); + +verify.quickInfoAt("2", [ + "(alias) type Alias = () => T", + "(alias) namespace Alias", + "(alias) function Alias(): void", + "import Alias", +].join("\n"), "some docs "); diff --git a/tests/cases/fourslash/quickInfoMeaning.ts b/tests/cases/fourslash/quickInfoMeaning.ts index 2c7aa5a0cc..f50675ba39 100644 --- a/tests/cases/fourslash/quickInfoMeaning.ts +++ b/tests/cases/fourslash/quickInfoMeaning.ts @@ -29,7 +29,7 @@ verify.quickInfoIs("const foo: number"); verify.goToDefinitionIs("foo_value_declaration"); goTo.marker("foo_type"); -verify.quickInfoIs("import foo = require(\"foo_module\")"); +verify.quickInfoIs("(alias) interface foo\nimport foo = require(\"foo_module\")"); verify.goToDefinitionIs("foo_type_declaration"); @@ -54,7 +54,7 @@ verify.navigationItemsListContains("bar", "alias", "bar", "exact"); verify.navigationItemsListContains("bar", "interface", "bar", "exact"); goTo.marker("bar_value"); -verify.quickInfoIs("import bar = require(\"bar_module\")"); +verify.quickInfoIs("(alias) const bar: number\nimport bar = require(\"bar_module\")"); verify.goToDefinitionIs("bar_value_declaration"); goTo.marker("bar_type"); diff --git a/tests/cases/fourslash/quickInfoOnInternalAliases.ts b/tests/cases/fourslash/quickInfoOnInternalAliases.ts index 8d334ef4a6..f22b61ae86 100644 --- a/tests/cases/fourslash/quickInfoOnInternalAliases.ts +++ b/tests/cases/fourslash/quickInfoOnInternalAliases.ts @@ -21,16 +21,16 @@ verify.quickInfos({ 1: ["class m1.m2.c", "class comment;"], - 2: ["import internalAlias = m1.m2.c", "This is on import declaration"], + 2: ["(alias) class internalAlias\nimport internalAlias = m1.m2.c", "This is on import declaration"], 3: ["class m1.m2.c", "class comment;"], 4: "var newVar: internalAlias", 5: "(alias) new internalAlias(): internalAlias\nimport internalAlias = m1.m2.c", 6: "var anotherAliasVar: typeof internalAlias", - 7: ["import internalAlias = m1.m2.c", "This is on import declaration"], - 8: "import internalFoo = m1.foo", + 7: ["(alias) class internalAlias\nimport internalAlias = m1.m2.c", "This is on import declaration"], + 8: "(alias) function internalFoo(): void\nimport internalFoo = m1.foo", 9: "function m1.foo(): void", 10: "var callVar: void", 11: "(alias) internalFoo(): void\nimport internalFoo = m1.foo", 12: "var anotherAliasFoo: () => void", - 13: "import internalFoo = m1.foo" + 13: "(alias) function internalFoo(): void\nimport internalFoo = m1.foo" }); diff --git a/tests/cases/fourslash/referencesForAmbients.ts b/tests/cases/fourslash/referencesForAmbients.ts index 2397738581..02001d2ffd 100644 --- a/tests/cases/fourslash/referencesForAmbients.ts +++ b/tests/cases/fourslash/referencesForAmbients.ts @@ -17,5 +17,5 @@ const [moduleFoo0, f0, moduleBar0, foo0, moduleFoo1, foo1, f1, moduleBar1, foo2] = test.ranges(); verify.singleReferenceGroup('module "foo"', [moduleFoo1, moduleFoo0]); verify.singleReferenceGroup('module "bar"', [moduleBar1, moduleBar0]); -verify.singleReferenceGroup('import foo = require("foo")', [foo0, foo1, foo2]); +verify.singleReferenceGroup('(alias) module "foo"\nimport foo = require("foo")', [foo0, foo1, foo2]); verify.singleReferenceGroup("var f: number", [f0, f1]); diff --git a/tests/cases/fourslash/referencesForGlobals5.ts b/tests/cases/fourslash/referencesForGlobals5.ts index d7dd930474..0d205b4b9b 100644 --- a/tests/cases/fourslash/referencesForGlobals5.ts +++ b/tests/cases/fourslash/referencesForGlobals5.ts @@ -12,4 +12,4 @@ // @Filename: referencesForGlobals_2.ts ////var m = [|globalAlias|]; -verify.singleReferenceGroup("import globalAlias = globalModule"); +verify.singleReferenceGroup("(alias) namespace globalAlias\nimport globalAlias = globalModule"); diff --git a/tests/cases/fourslash/referencesForMergedDeclarations2.ts b/tests/cases/fourslash/referencesForMergedDeclarations2.ts index 5cf9234511..ba61d4c906 100644 --- a/tests/cases/fourslash/referencesForMergedDeclarations2.ts +++ b/tests/cases/fourslash/referencesForMergedDeclarations2.ts @@ -11,4 +11,8 @@ ////var a: [|alias|].Bar; // namespace ////[|alias|].call(this); // value -verify.singleReferenceGroup("import alias = ATest"); +verify.singleReferenceGroup([ + "(alias) namespace alias", + "(alias) function alias(): void", + "import alias = ATest" +].join("\n")); diff --git a/tests/cases/fourslash/renameDefaultImport.ts b/tests/cases/fourslash/renameDefaultImport.ts index 086a05f6b9..3cf0c8b088 100644 --- a/tests/cases/fourslash/renameDefaultImport.ts +++ b/tests/cases/fourslash/renameDefaultImport.ts @@ -18,7 +18,7 @@ const ranges = test.ranges(); const [C, B0, B1] = ranges; const classes = { definition: "class B", ranges: [C] }; -const imports = { definition: "import B", ranges: [B0, B1] }; +const imports = { definition: "(alias) class B\nimport B", ranges: [B0, B1] }; verify.referenceGroups(C, [classes, imports]); verify.referenceGroups(B0, [imports, classes]); verify.referenceGroups(B1, [ diff --git a/tests/cases/fourslash/renameDefaultImportDifferentName.ts b/tests/cases/fourslash/renameDefaultImportDifferentName.ts index ac44c26c44..75f80257e0 100644 --- a/tests/cases/fourslash/renameDefaultImportDifferentName.ts +++ b/tests/cases/fourslash/renameDefaultImportDifferentName.ts @@ -18,7 +18,7 @@ const ranges = test.ranges(); const [C, B0, B1] = ranges; const bRanges = [B0, B1]; const classes = { definition: "class C", ranges: [C] }; -const imports = { definition: "import B", ranges: [B0, B1] }; +const imports = { definition: "(alias) class B\nimport B", ranges: [B0, B1] }; verify.referenceGroups(C, [classes, imports]); verify.referenceGroups(B0, [imports]); verify.referenceGroups(B1, [{ definition: "(alias) new B(): B\nimport B", ranges: bRanges }]); diff --git a/tests/cases/fourslash/renameImportAndExportInDiffFiles.ts b/tests/cases/fourslash/renameImportAndExportInDiffFiles.ts index 30feb0760e..a961ebf241 100644 --- a/tests/cases/fourslash/renameImportAndExportInDiffFiles.ts +++ b/tests/cases/fourslash/renameImportAndExportInDiffFiles.ts @@ -10,7 +10,7 @@ const ranges = test.ranges(); const [r0, r1, r2] = ranges; const vars = { definition: "var a: any", ranges: [r0] }; -const imports = { definition: "import a", ranges: [r1, r2] }; +const imports = { definition: "(alias) var a: any\nimport a", ranges: [r1, r2] }; verify.referenceGroups(r0, [vars, imports]); verify.referenceGroups(r1, [imports, vars]); verify.referenceGroups(r2, [imports, vars]); diff --git a/tests/cases/fourslash/renameImportOfExportEquals.ts b/tests/cases/fourslash/renameImportOfExportEquals.ts index 12cd86df64..65c65a6240 100644 --- a/tests/cases/fourslash/renameImportOfExportEquals.ts +++ b/tests/cases/fourslash/renameImportOfExportEquals.ts @@ -22,8 +22,8 @@ const bRanges = [b0, b1]; const xRanges = [x0, x1]; const nGroup = { definition: "namespace N", ranges: nRanges }; -const aGroup = { definition: "import N", ranges: aRanges }; -const bGroup = { definition: "import N", ranges: [b0, b1] }; +const aGroup = { definition: "(alias) namespace N\nimport N", ranges: aRanges }; +const bGroup = { definition: "(alias) namespace N\nimport N", ranges: [b0, b1] }; verify.referenceGroups(nRanges, [nGroup, aGroup, bGroup]); verify.referenceGroups([a0, a1], [aGroup, nGroup, bGroup]); diff --git a/tests/cases/fourslash/renameImportOfExportEquals2.ts b/tests/cases/fourslash/renameImportOfExportEquals2.ts index 8ac00b8c01..83ff1794bd 100644 --- a/tests/cases/fourslash/renameImportOfExportEquals2.ts +++ b/tests/cases/fourslash/renameImportOfExportEquals2.ts @@ -24,9 +24,9 @@ const pRanges = [P0, P1]; const qRanges = [Q0, Q1]; const ns = { definition: "namespace N", ranges: nRanges }; -const os = { definition: "import O", ranges: oRanges }; -const ps = { definition: "import P", ranges: pRanges }; -const qs = { definition: "import Q", ranges: qRanges }; +const os = { definition: "(alias) namespace O\nimport O", ranges: oRanges }; +const ps = { definition: "(alias) namespace P\nimport P", ranges: pRanges }; +const qs = { definition: "(alias) namespace Q\nimport Q", ranges: qRanges }; verify.referenceGroups(nRanges, [ns, os, ps, qs]); verify.referenceGroups(oRanges, [os, ps, qs]); diff --git a/tests/cases/fourslash/renameImportOfReExport.ts b/tests/cases/fourslash/renameImportOfReExport.ts index 3f8250b4d7..6afb953ad5 100644 --- a/tests/cases/fourslash/renameImportOfReExport.ts +++ b/tests/cases/fourslash/renameImportOfReExport.ts @@ -20,8 +20,8 @@ const ranges = test.ranges(); const [r0, r1, r2, r3] = ranges; const importRanges = [r2, r3]; const classes = { definition: "class C", ranges: [r0] }; -const bs = { definition: "import C", ranges: [r1] }; -const imports = { definition: "import C", ranges: importRanges }; +const bs = { definition: "(alias) class C\nimport C", ranges: [r1] }; +const imports = { definition: "(alias) class C\nimport C", ranges: importRanges }; verify.referenceGroups(r0, [classes, bs, imports]); verify.referenceGroups(r1, [bs, imports, classes]); verify.referenceGroups(importRanges, [imports, bs, classes]); diff --git a/tests/cases/fourslash/renameImportOfReExport2.ts b/tests/cases/fourslash/renameImportOfReExport2.ts index ac61200b2f..bcaa0e41c8 100644 --- a/tests/cases/fourslash/renameImportOfReExport2.ts +++ b/tests/cases/fourslash/renameImportOfReExport2.ts @@ -18,8 +18,8 @@ const cRanges = ranges.get("C"); const [d0, d1, d2] = ranges.get("D"); const classes = { definition: "class C", ranges: cRanges }; -const bImports = { definition: "import D", ranges: [d0] }; -const cImports = { definition: "import D", ranges: [d1, d2] }; +const bImports = { definition: "(alias) class D\nimport D", ranges: [d0] }; +const cImports = { definition: "(alias) class D\nimport D", ranges: [d1, d2] }; verify.referenceGroups(cRanges, [classes, bImports, cImports]); verify.referenceGroups(d0, [bImports, cImports]); diff --git a/tests/cases/fourslash/transitiveExportImports.ts b/tests/cases/fourslash/transitiveExportImports.ts index 093121c1d9..68cca0c407 100644 --- a/tests/cases/fourslash/transitiveExportImports.ts +++ b/tests/cases/fourslash/transitiveExportImports.ts @@ -21,7 +21,7 @@ const aRanges = [a0, a1]; const bRanges = [b0, c2]; const cRanges = [c0, c1]; -const bGroup = { definition: "import b = require('./a')", ranges: bRanges } +const bGroup = { definition: "(alias) class b\nimport b = require('./a')", ranges: bRanges } verify.referenceGroups(aRanges, [ { definition: "class A", ranges: aRanges }, diff --git a/tests/cases/fourslash/transitiveExportImports2.ts b/tests/cases/fourslash/transitiveExportImports2.ts index 397bbf44a3..73e1e828b0 100644 --- a/tests/cases/fourslash/transitiveExportImports2.ts +++ b/tests/cases/fourslash/transitiveExportImports2.ts @@ -20,8 +20,8 @@ const bRanges = [B0, B1]; const cRanges = [B2]; const aGroup = { definition: "namespace A", ranges: aRanges }; -const bGroup = { definition: "import B = A", ranges: bRanges }; -const cGroup = { definition: "import B", ranges: cRanges }; +const bGroup = { definition: "(alias) namespace B\nimport B = A", ranges: bRanges }; +const cGroup = { definition: "(alias) namespace B\nimport B", ranges: cRanges }; verify.referenceGroups(aRanges, [aGroup, bGroup, cGroup]); verify.referenceGroups(bRanges, [bGroup, cGroup]); diff --git a/tests/cases/fourslash/transitiveExportImports3.ts b/tests/cases/fourslash/transitiveExportImports3.ts index 638fa85df8..abb7b2a298 100644 --- a/tests/cases/fourslash/transitiveExportImports3.ts +++ b/tests/cases/fourslash/transitiveExportImports3.ts @@ -13,9 +13,9 @@ verify.noErrors(); const [f0, f1, g0, f2, g1] = test.ranges(); const af = { definition: "function f(): void", ranges: [f0, f1] }; -const g0Group = { definition: "import g", ranges: [g0] }; -const g1Group = { definition: "import g", ranges: [g1] }; -const bf = { definition: "import f", ranges: [f2] }; +const g0Group = { definition: "(alias) function g(): void\nimport g", ranges: [g0] }; +const g1Group = { definition: "(alias) function g(): void\nimport g", ranges: [g1] }; +const bf = { definition: "(alias) function f(): void\nimport f", ranges: [f2] }; verify.referenceGroups([f0, f1], [af, g0Group, g1Group, bf]); verify.referenceGroups(g0, [g0Group, g1Group]);