WIP

microsoft · gabritto · Dec 2, 2022 · Sep 23, 2022 · Sep 23, 2022 · Sep 7, 2022
commit d46c0d254d6093e3375bfee8d1a80aecafd1d23a
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -22449,35 +22449,7 @@ namespace ts {
          * @param text a valid bigint string excluding a trailing `n`, but including a possible prefix `-`. Use `isValidBigIntString(text, roundTripOnly)` before calling this function.
          */
         function parseBigIntLiteralType(text: string) {
-            const negative = text.startsWith("-");
-            const base10Value = parsePseudoBigInt(`${negative ? text.slice(1) : text}n`);
-            return getBigIntLiteralType({ negative, base10Value });
-        }
-
-        /**
-         * Tests whether the provided string can be parsed as a bigint.
-         * @param s The string to test.
-         * @param roundTripOnly Indicates the resulting bigint matches the input when converted back to a string.
-         */
-        function isValidBigIntString(s: string, roundTripOnly: boolean): boolean {
-            if (s === "") return false;
-            const scanner = createScanner(ScriptTarget.ESNext, /*skipTrivia*/ false);
-            let success = true;
-            scanner.setOnError(() => success = false);
-            scanner.setText(s + "n");
-            let result = scanner.scan();
-            const negative = result === SyntaxKind.MinusToken;
-            if (negative) {
-                result = scanner.scan();
-            }
-            const flags = scanner.getTokenFlags();
-            // validate that
-            // * scanning proceeded without error
-            // * a bigint can be scanned, and that when it is scanned, it is
-            // * the full length of the input string (so the scanner is one character beyond the augmented input length)
-            // * it does not contain a numeric seperator (the `BigInt` constructor does not accept a numeric seperator in its input)
-            return success && result === SyntaxKind.BigIntLiteral && scanner.getTextPos() === (s.length + 1) && !(flags & TokenFlags.ContainsSeparator)
-                && (!roundTripOnly || s === pseudoBigIntToString({ negative, base10Value: parsePseudoBigInt(scanner.getTokenValue()) }));
+            return getBigIntLiteralType(parseValidBigInt(text));
         }
 
         function isMemberOfStringMapping(source: Type, target: Type): boolean {

diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -7313,6 +7313,48 @@ namespace ts {
         return (negative && base10Value !== "0" ? "-" : "") + base10Value;
     }
 
+    export function parseBigInt(text: string): PseudoBigInt | undefined {
+        if (!isValidBigIntString(text, /*roundTripOnly*/ false)) {
+            return undefined;
+        }
+        return parseValidBigInt(text);
+    }
+
+    /**
+     *  @param text a valid bigint string excluding a trailing `n`, but including a possible prefix `-`. Use `isValidBigIntString(text, roundTripOnly)` before calling this function.
+     */
+    export function parseValidBigInt(text: string): PseudoBigInt {
+        const negative = text.startsWith("-");
+        const base10Value = parsePseudoBigInt(`${negative ? text.slice(1) : text}n`);
+        return { negative, base10Value };
+    }
+
+    /**
+     * Tests whether the provided string can be parsed as a bigint.
+     * @param s The string to test.
+     * @param roundTripOnly Indicates the resulting bigint matches the input when converted back to a string.
+     */
+    export function isValidBigIntString(s: string, roundTripOnly: boolean): boolean {
+        if (s === "") return false;
+        const scanner = createScanner(ScriptTarget.ESNext, /*skipTrivia*/ false);
+        let success = true;
+        scanner.setOnError(() => success = false);
+        scanner.setText(s + "n");
+        let result = scanner.scan();
+        const negative = result === SyntaxKind.MinusToken;
+        if (negative) {
+            result = scanner.scan();
+        }
+        const flags = scanner.getTokenFlags();
+        // validate that
+        // * scanning proceeded without error
+        // * a bigint can be scanned, and that when it is scanned, it is
+        // * the full length of the input string (so the scanner is one character beyond the augmented input length)
+        // * it does not contain a numeric seperator (the `BigInt` constructor does not accept a numeric seperator in its input)
+        return success && result === SyntaxKind.BigIntLiteral && scanner.getTextPos() === (s.length + 1) && !(flags & TokenFlags.ContainsSeparator)
+            && (!roundTripOnly || s === pseudoBigIntToString({ negative, base10Value: parsePseudoBigInt(scanner.getTokenValue()) }));
+    }
+
     export function isValidTypeOnlyAliasUseSite(useSite: Node): boolean {
         return !!(useSite.flags & NodeFlags.Ambient)
             || isPartOfTypeQuery(useSite)

diff --git a/src/services/completions.ts b/src/services/completions.ts
@@ -567,7 +567,7 @@ namespace ts.Completions {
             getJSCompletionEntries(sourceFile, location.pos, uniqueNames, getEmitScriptTarget(compilerOptions), entries);
         }
 
-        // >> TODO: prototype remaining cases here
+        // >> TODO: trigger on semi-completed case-keyword
         if (contextToken && isCaseKeyword(contextToken) && preferences.includeCompletionsWithInsertText) {
             const cases = getExhaustiveCaseSnippets(contextToken, sourceFile, preferences, compilerOptions, host, program, formatContext);
             if (cases) {
@@ -624,7 +624,11 @@ namespace ts.Completions {
                 // const existingSymbols = new Map<SymbolId, true>();
                 // const existingLiterals: (number | string | PseudoBigInt)[] = [];
                 // existingLiterals;
-                const existingValues: (string | number | PseudoBigInt)[] = [];
+                // const existingValues: (string | number | PseudoBigInt)[] = [];
+                const existingStrings = new Set<string>();
+                const existingNumbers = new Set<number>();
+                const existingBigInts = new Set<string>();
+                const existingBools = new Set<boolean>();
 
                 for (const clause of clauses) {
                     if (isDefaultClause(clause)) {
@@ -633,91 +637,93 @@ namespace ts.Completions {
                     if (isLiteralExpression(clause.expression)) {
                         const expression = clause.expression;
                         switch (expression.kind) {
+                            case SyntaxKind.NoSubstitutionTemplateLiteral:
                             case SyntaxKind.StringLiteral:
-                                existingValues.push(expression.text);
-                                continue;
+                                existingStrings.add(expression.text);
+                                break;
                             case SyntaxKind.NumericLiteral:
-                                existingValues.push(parseInt(expression.text)); // ??
-                                continue;
+                                existingNumbers.add(parseInt(expression.text)); // >> do we need to parse it??
+                                break;
                             case SyntaxKind.BigIntLiteral:
-                            case SyntaxKind.NoSubstitutionTemplateLiteral:
-                                continue;
-                            default:
-                                return undefined;
+                                const parsedBigInt = parseBigInt(endsWith(expression.text, "n") ? expression.text.slice(0, -1) : expression.text);
+                                if (parsedBigInt) {
+                                    existingBigInts.add(pseudoBigIntToString(parsedBigInt)); // >> does it work? answer: no
+                                }
+                                break;
+                            case SyntaxKind.TrueKeyword:
+                                existingBools.add(true);
+                                break;
+                            case SyntaxKind.FalseKeyword:
+                                existingBools.add(false);
+                                break;
                         }
                     }
-                    else {
+                    else if (checker.getSymbolAtLocation(clause.expression)) {
                         const symbol = checker.getSymbolAtLocation(clause.expression);
                         if (symbol && symbol.valueDeclaration && isEnumMember(symbol.valueDeclaration)) {
                             // TODO: check that it's an enum member symbol
                             const enumValue = checker.getConstantValue(symbol.valueDeclaration);
-                            if (enumValue) {
-                                existingValues.push(enumValue);
-                            }
-                            else {
-                                return undefined
+                            if (enumValue !== undefined) {
+                                switch (typeof enumValue) {
+                                    case "string":
+                                        existingStrings.add(enumValue);
+                                        break;
+                                    case "number":
+                                        existingNumbers.add(enumValue);
+                                }
                             }
                         }
                     }
-                    return undefined; // We couldn't recognize all existing case clauses, so fail.
                 }
 
-
                 const importAdder = codefix.createImportAdder(sourceFile, program, preferences, host);
                 const elements: Expression[] = [];
                 for (const type of switchType.types as LiteralType[]) {
                     if (type.flags & TypeFlags.EnumLiteral) {
                         Debug.assert(type.symbol, "TODO: should this hold always?");
                         Debug.assert(type.symbol.parent, "TODO: should this hold always too?");
-                        // if (existingSymbols.has(getSymbolId(type.symbol))) {
-                        //     continue;
-                        // }
+                        // >> TODO: see if we need to filter enum by their constant vals
                         const target = getEmitScriptTarget(options);
                         // >> TODO: figure out if need an import action
+                        // >> TODO: fix issue when qualified import
                         const typeNode = codefix.typeToAutoImportableTypeNode(checker, importAdder, type, caseClause.parent, target);
-                        if (typeNode) {
-                            const typeNodeText = printer.printSnippetList(
-                                ListFormat.None,
-                                factory.createNodeArray([typeNode]),
-                                sourceFile);
-                            typeNodeText;
-
-                            const expr = foo(typeNode, target);
-                            if (expr) {
-                                elements.push(expr);
-                            }
+                        if (!typeNode) {
+                            return undefined;
                         }
+                        const typeNodeText = printer.printSnippetList(
+                            ListFormat.None,
+                            factory.createNodeArray([typeNode]),
+                            sourceFile);
+                        typeNodeText;
+
+                        const expr = foo(typeNode, target);
+                        if (!expr) {
+                            return undefined;
+                        }
+                        elements.push(expr);
                         // >> TODO: what if expression has import node?
                         // const expr = checker.symbolToExpression(type.symbol, SymbolFlags.EnumMember, caseClause.parent, /*flags*/ undefined);
                         // if (expr) {
                         //     return expr;
                         // }
                     // }
-                    }
+                    } // >> TODO: else if boolean???
                     else {
                         // const text = completionNameForLiteral(sourceFile, preferences, type.value);
+                        // >> TODO: filter by existing
                         const literal: Expression = typeof type.value === "object"
                             ? factory.createBigIntLiteral(type.value)
                             : typeof type.value === "number"
                                 ? factory.createNumericLiteral(type.value)
                                 : factory.createStringLiteral(type.value);
                         elements.push(literal);
                     }
-                    return undefined;
                 }
 
                 if (elements.length === 0) {
                     return undefined;
                 }
 
-                // const existingClauses = new Set(mapDefined(caseClause.parent.clauses, clause => {
-                //     if (isDefaultClause(clause)) {
-                //         return undefined;
-                //     }
-                //     return clause.expression.getText();
-                // }));
-
-                // elements = filter(elements, element => !existingClauses.has(element[0]));
                 const newClauses = mapDefined(elements, element => {
                     return factory.createCaseClause(element, []);
                 });
@@ -736,9 +742,9 @@ namespace ts.Completions {
                 return {
                     entry: {
                         name: `${firstClause} ...`, // >> TODO: what should this be?
-                        isRecommended: true, // >> I assume that is ok because if there's another recommended, it will be sorted after this one
+                        // isRecommended: true, // >> I assume that is ok because if there's another recommended, it will be sorted after this one
                         kind: ScriptElementKind.unknown, // >> TODO: what should this be?
-                        sortText: SortText.LocalDeclarationPriority,
+                        sortText: SortText.LocalDeclarationPriority, // >> TODO: sort *right after* case keyword
                         insertText,
                         replacementSpan: getReplacementSpanForContextToken(contextToken),
                         hasAction: importAdder.hasFixes() || undefined,

diff --git a/tests/cases/fourslash/fullCaseCompletions3.ts b/tests/cases/fourslash/fullCaseCompletions3.ts
@@ -12,6 +12,7 @@
 ////     case E.A:
 ////     case 1:
 ////     case 1n:
+////     case 0x1n:
 ////     case "1":
 ////     case `1`:
 ////     case `1${u}`:
@@ -41,6 +42,7 @@ verify.completions(
     },
 );
 
+
 // verify.applyCodeActionFromCompletion("1", {
 //     name: "case E.A: ...",
 //     source: "SwitchCases/",