Completion list in the type expression should show types

sheetalkamat · sheetalkamat · commit 5eca96c4d219 · 2017-06-14T10:57:23.000-07:00
diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
@@ -814,8 +814,8 @@ namespace FourSlash {
 
             function filterByTextOrDocumentation(entry: ts.CompletionEntry) {
                 const details = that.getCompletionEntryDetails(entry.name);
-                const documentation = ts.displayPartsToString(details.documentation);
-                const text = ts.displayPartsToString(details.displayParts);
+                const documentation = details && ts.displayPartsToString(details.documentation);
+                const text = details && ts.displayPartsToString(details.displayParts);
 
                 // If any of the expected values are undefined, assume that users don't
                 // care about them.
@@ -852,6 +852,9 @@ namespace FourSlash {
                     if (expectedKind) {
                         error += "Expected kind: " + expectedKind + " to equal: " + filterCompletions[0].kind + ".";
                     }
+                    else {
+                        error += "kind: " + filterCompletions[0].kind + ".";
+                    }
                     if (replacementSpan) {
                         const spanText = filterCompletions[0].replacementSpan ? stringify(filterCompletions[0].replacementSpan) : undefined;
                         error += "Expected replacement span: " + stringify(replacementSpan) + " to equal: " + spanText + ".";
diff --git a/src/services/completions.ts b/src/services/completions.ts
@@ -366,16 +366,16 @@ namespace ts.Completions {
         let request: Request | undefined;
 
         let start = timestamp();
-        const currentToken = getTokenAtPosition(sourceFile, position, /*includeJsDocComment*/ false);
+        let currentToken = getTokenAtPosition(sourceFile, position, /*includeJsDocComment*/ false);
         // We will check for jsdoc comments with insideComment and getJsDocTagAtPosition. (TODO: that seems rather inefficient to check the same thing so many times.)
-
         log("getCompletionData: Get current token: " + (timestamp() - start));
 
         start = timestamp();
         // Completion not allowed inside comments, bail out if this is the case
         const insideComment = isInComment(sourceFile, position, currentToken);
         log("getCompletionData: Is inside comment: " + (timestamp() - start));
 
+        let insideJsDocTagTypeExpression = false;
         if (insideComment) {
             if (hasDocComment(sourceFile, position)) {
                 if (sourceFile.text.charCodeAt(position - 1) === CharacterCodes.at) {
@@ -410,33 +410,31 @@ namespace ts.Completions {
             // Completion should work inside certain JsDoc tags. For example:
             //     /** @type {number | string} */
             // Completion should work in the brackets
-            let insideJsDocTagExpression = false;
             const tag = getJsDocTagAtPosition(currentToken, position);
             if (tag) {
                 if (tag.tagName.pos <= position && position <= tag.tagName.end) {
                     request = { kind: "JsDocTagName" };
                 }
-
-                switch (tag.kind) {
-                    case SyntaxKind.JSDocTypeTag:
-                    case SyntaxKind.JSDocParameterTag:
-                    case SyntaxKind.JSDocReturnTag:
-                        const tagWithExpression = <JSDocTypeTag | JSDocParameterTag | JSDocReturnTag>tag;
-                        if (tagWithExpression.typeExpression && tagWithExpression.typeExpression.pos < position && position < tagWithExpression.typeExpression.end) {
-                            insideJsDocTagExpression = true;
-                        }
-                        else if (isJSDocParameterTag(tag) && (nodeIsMissing(tag.name) || tag.name.pos <= position && position <= tag.name.end)) {
-                            request = { kind: "JsDocParameterName", tag };
-                        }
-                        break;
+                if (isTagWithTypeExpression(tag) && tag.typeExpression) {
+                    currentToken = getTokenAtPosition(sourceFile, position, /*includeJsDocComment*/ true);
+                    if (!currentToken ||
+                        (!isDeclarationName(currentToken) &&
+                            (currentToken.parent.kind !== SyntaxKind.JSDocPropertyTag ||
+                                (<JSDocPropertyTag>currentToken.parent).name !== currentToken))) {
+                        // Use as type location if inside tag's type expression
+                        insideJsDocTagTypeExpression = isCurrentlyEditingNode(tag.typeExpression);
+                    }
+                }
+                if (isJSDocParameterTag(tag) && (nodeIsMissing(tag.name) || tag.name.pos <= position && position <= tag.name.end)) {
+                    request = { kind: "JsDocParameterName", tag };
                 }
             }
 
             if (request) {
                 return { symbols: undefined, isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, location: undefined, isRightOfDot: false, request, hasFilteredClassMemberKeywords: false };
             }
 
-            if (!insideJsDocTagExpression) {
+            if (!insideJsDocTagTypeExpression) {
                 // Proceed if the current position is in jsDoc tag expression; otherwise it is a normal
                 // comment or the plain text part of a jsDoc comment, so no completion should be available
                 log("Returning an empty list because completion was inside a regular comment or plain text part of a JsDoc comment.");
@@ -445,7 +443,7 @@ namespace ts.Completions {
         }
 
         start = timestamp();
-        const previousToken = findPrecedingToken(position, sourceFile, /*startNode*/ undefined, /*includeJsDoc*/ true);
+        const previousToken = findPrecedingToken(position, sourceFile, /*startNode*/ undefined, insideJsDocTagTypeExpression);
         log("getCompletionData: Get previous token 1: " + (timestamp() - start));
 
         // The decision to provide completion depends on the contextToken, which is determined through the previousToken.
@@ -456,7 +454,7 @@ namespace ts.Completions {
         // Skip this partial identifier and adjust the contextToken to the token that precedes it.
         if (contextToken && position <= contextToken.end && isWord(contextToken.kind)) {
             const start = timestamp();
-            contextToken = findPrecedingToken(contextToken.getFullStart(), sourceFile, /*startNode*/ undefined, /*includeJsDoc*/ true);
+            contextToken = findPrecedingToken(contextToken.getFullStart(), sourceFile, /*startNode*/ undefined, insideJsDocTagTypeExpression);
             log("getCompletionData: Get previous token 2: " + (timestamp() - start));
         }
 
@@ -468,7 +466,7 @@ namespace ts.Completions {
         let isRightOfOpenTag = false;
         let isStartingCloseTag = false;
 
-        let location = getTouchingPropertyName(sourceFile, position, /*includeJsDocComment*/ false); // TODO: GH#15853
+        let location = getTouchingPropertyName(sourceFile, position, insideJsDocTagTypeExpression); // TODO: GH#15853
         if (contextToken) {
             // Bail out if this is a known invalid completion location
             if (isCompletionListBlocker(contextToken)) {
@@ -572,14 +570,28 @@ namespace ts.Completions {
 
         return { symbols, isGlobalCompletion, isMemberCompletion, isNewIdentifierLocation, location, isRightOfDot: (isRightOfDot || isRightOfOpenTag), request, hasFilteredClassMemberKeywords };
 
+        type JSDocTagWithTypeExpression = JSDocAugmentsTag | JSDocParameterTag | JSDocPropertyTag | JSDocReturnTag | JSDocTypeTag | JSDocTypedefTag;
+
+        function isTagWithTypeExpression(tag: JSDocTag): tag is JSDocTagWithTypeExpression {
+            switch (tag.kind) {
+                case SyntaxKind.JSDocAugmentsTag:
+                case SyntaxKind.JSDocParameterTag:
+                case SyntaxKind.JSDocPropertyTag:
+                case SyntaxKind.JSDocReturnTag:
+                case SyntaxKind.JSDocTypeTag:
+                case SyntaxKind.JSDocTypedefTag:
+                    return true;
+            }
+        }
+
         function getTypeScriptMemberSymbols(): void {
             // Right of dot member completion list
             isGlobalCompletion = false;
             isMemberCompletion = true;
             isNewIdentifierLocation = false;
 
             // Since this is qualified name check its a type node location
-            const isTypeLocation = isPartOfTypeNode(node.parent);
+            const isTypeLocation = isPartOfTypeNode(node.parent) || insideJsDocTagTypeExpression;
             const isRhsOfImportDeclaration = isInRightSideOfInternalImportEqualsDeclaration(node);
             if (node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName || node.kind === SyntaxKind.PropertyAccessExpression) {
                 let symbol = typeChecker.getSymbolAtLocation(node);
@@ -741,8 +753,9 @@ namespace ts.Completions {
                         return !!(symbol.flags & SymbolFlags.Namespace);
                     }
 
-                    if (!isContextTokenValueLocation(contextToken) &&
-                        (isPartOfTypeNode(location) || isContextTokenTypeLocation(contextToken))) {
+                    if (insideJsDocTagTypeExpression ||
+                        (!isContextTokenValueLocation(contextToken) &&
+                            (isPartOfTypeNode(location) || isContextTokenTypeLocation(contextToken)))) {
                         // Its a type, but you can reach it by namespace.type as well
                         return symbolCanbeReferencedAtTypeLocation(symbol);
                     }
@@ -789,14 +802,16 @@ namespace ts.Completions {
                 symbol = typeChecker.getAliasedSymbol(symbol);
             }
 
+            if (symbol.flags & SymbolFlags.Type) {
+                return true;
+            }
+
             if (symbol.flags & (SymbolFlags.ValueModule | SymbolFlags.NamespaceModule)) {
                 const exportedSymbols = typeChecker.getExportsOfModule(symbol);
                 // If the exported symbols contains type,
                 // symbol can be referenced at locations where type is allowed
                 return forEach(exportedSymbols, symbolCanbeReferencedAtTypeLocation);
             }
-
-            return !!(symbol.flags & (SymbolFlags.NamespaceModule | SymbolFlags.Type));
         }
 
         /**
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
@@ -745,7 +745,7 @@ namespace ts {
                 // NOTE: JsxText is a weird kind of node that can contain only whitespaces (since they are not counted as trivia).
                 // if this is the case - then we should assume that token in question is located in previous child.
                 if (position < child.end && (nodeHasTokens(child) || child.kind === SyntaxKind.JsxText)) {
-                    const start = (includeJsDoc && child.jsDoc ? child.jsDoc[0] : child).getStart(sourceFile);
+                    const start = child.getStart(sourceFile, includeJsDoc);
                     const lookInPreviousChild =
                         (start >= position) || // cursor in the leading trivia
                         (child.kind === SyntaxKind.JsxText && start === child.end); // whitespace only JsxText
diff --git a/tests/cases/fourslash/jsFileJsdocTypedefTagTypeExpressionCompletion.ts b/tests/cases/fourslash/jsFileJsdocTypedefTagTypeExpressionCompletion.ts
@@ -0,0 +1,70 @@
+/// <reference path="fourslash.ts"/>
+
+// @allowNonTsExtensions: true
+// @Filename: jsFileJsdocTypedefTagTypeExpressionCompletion_typedef.js
+
+//// /**
+////  * @typedef {/*1*/string | /*2*/number} T.NumberLike
+////  * @typedef {{/*propertyName*/age: /*3*/number}} T.People
+////  * @typedef {string | number} T.O.Q.NumberLike
+////  * @type {/*4*/T./*1TypeMember*/NumberLike}
+////  */
+//// var x;
+//// /** @type {/*5*/T./*2TypeMember*/O.Q.NumberLike} */
+//// var x1; 
+//// /** @type {/*6*/T./*3TypeMember*/People} */
+//// var x1;
+//// /*globalValue*/
+
+interface VeriferCompletionsInJsDoc {
+    verifyType(symbol: string, kind: string): void;
+    verifyValue(symbol: string, kind: string): void;
+    verifyTypeMember(symbol: string, kind: string): void;
+}
+
+function verifyCompletionsInJsDocType(marker: string, { verifyType, verifyValue, verifyTypeMember }: VeriferCompletionsInJsDoc) {
+    goTo.marker(marker);
+
+    verifyType("T", "module");
+
+    // TODO: May be filter keywords based on context
+    //verifyType("string", "keyword");
+    //verifyType("number", "keyword");
+
+    verifyValue("x", "var");
+    verifyValue("x1", "var");
+
+    verifyTypeMember("NumberLike", "type");
+    verifyTypeMember("People", "type");
+    verifyTypeMember("O", "module");
+}
+
+function verifySymbolPresentWithKind(symbol: string, kind: string) {
+    return verify.completionListContains(symbol, /*text*/ undefined, /*documentation*/ undefined, kind);
+}
+
+function verifySymbolPresentWithWarning(symbol: string) {
+    return verifySymbolPresentWithKind(symbol, "warning");
+}
+
+for (let i = 1; i <= 6; i++) {
+    verifyCompletionsInJsDocType(i.toString(), {
+        verifyType: verifySymbolPresentWithKind,
+        verifyValue: verifySymbolPresentWithWarning,
+        verifyTypeMember: verifySymbolPresentWithWarning,
+    });
+}
+verifyCompletionsInJsDocType("globalValue", {
+    verifyType: verifySymbolPresentWithWarning,
+    verifyValue: verifySymbolPresentWithKind,
+    verifyTypeMember: verifySymbolPresentWithWarning,
+});
+for (let i = 1; i <= 3; i++) {
+    verifyCompletionsInJsDocType(i.toString() + "TypeMember", {
+        verifyType: verifySymbolPresentWithWarning,
+        verifyValue: verifySymbolPresentWithWarning,
+        verifyTypeMember: verifySymbolPresentWithKind,
+    });
+}
+goTo.marker("propertyName");
+verify.completionListIsEmpty();
diff --git a/tests/cases/fourslash/jsFileJsdocTypedefTagTypeExpressionCompletion2.ts b/tests/cases/fourslash/jsFileJsdocTypedefTagTypeExpressionCompletion2.ts
@@ -0,0 +1,65 @@
+/// <reference path="fourslash.ts"/>
+
+// @allowNonTsExtensions: true
+// @Filename: jsFileJsdocTypedefTagTypeExpressionCompletion2_typedef.js
+
+//// class Foo {
+////     constructor(value: number) { this.property1 = "hello"; }
+////     static method1() {}
+////     method3() { return 3; }
+////     /**
+////      * @param {string} foo A value.
+////      * @returns {number} Another value
+////      * @mytag 
+////      */
+////     method4(foo) { return 3; }
+//// }
+//// /**
+////  * @type { /*type*/Foo }
+////  */
+////var x;
+/////*globalValue*/
+////x./*valueMember*/
+
+interface VeriferCompletionsInJsDoc {
+    verifyValueOrType(symbol: string, kind: string): void;
+    verifyValue(symbol: string, kind: string): void;
+    verifyValueMember(symbol: string, kind: string): void;
+}
+
+function verifyCompletionsInJsDocType(marker: string, { verifyValueOrType, verifyValue, verifyValueMember }: VeriferCompletionsInJsDoc) {
+    goTo.marker(marker);
+
+    verifyValueOrType("Foo", "class");
+
+    verifyValue("x", "var");
+
+    verifyValueMember("property1", "property");
+    verifyValueMember("method3", "method");
+    verifyValueMember("method4", "method");
+    verifyValueMember("foo", "warning");
+}
+
+function verifySymbolPresentWithKind(symbol: string, kind: string) {
+    return verify.completionListContains(symbol, /*text*/ undefined, /*documentation*/ undefined, kind);
+}
+
+function verifySymbolPresentWithWarning(symbol: string) {
+    return verifySymbolPresentWithKind(symbol, "warning");
+}
+
+verifyCompletionsInJsDocType("type", {
+    verifyValueOrType: verifySymbolPresentWithKind,
+    verifyValue: verifySymbolPresentWithWarning,
+    verifyValueMember: verifySymbolPresentWithWarning,
+});
+verifyCompletionsInJsDocType("globalValue", {
+    verifyValueOrType: verifySymbolPresentWithKind,
+    verifyValue: verifySymbolPresentWithKind,
+    verifyValueMember: verifySymbolPresentWithWarning,
+});
+verifyCompletionsInJsDocType("valueMember", {
+    verifyValueOrType: verifySymbolPresentWithWarning,
+    verifyValue: verifySymbolPresentWithWarning,
+    verifyValueMember: verifySymbolPresentWithKind,
+});
diff --git a/tests/cases/fourslash/jsFileJsdocTypedefTagTypeExpressionCompletion3.ts b/tests/cases/fourslash/jsFileJsdocTypedefTagTypeExpressionCompletion3.ts
diff --git a/tests/cases/fourslash/jsdocTypedefTagTypeExpressionCompletion.ts b/tests/cases/fourslash/jsdocTypedefTagTypeExpressionCompletion.ts
