Exhaustive case completion for switch statements

src/compiler/checker.ts

@@ -18,7 +18,7 @@ import {
     createDiagnosticForFileFromMessageChain, createDiagnosticForNode, createDiagnosticForNodeArray,
     createDiagnosticForNodeFromMessageChain, createDiagnosticMessageChainFromDiagnostic, createEmptyExports,
     createFileDiagnostic, createGetCanonicalFileName, createGetSymbolWalker, createPrinter,
-    createPropertyNameNodeForIdentifierOrLiteral, createScanner, createSymbolTable, createTextWriter,
+    createPropertyNameNodeForIdentifierOrLiteral, createSymbolTable, createTextWriter,
     createUnderscoreEscapedMultiMap, Debug, Declaration, DeclarationName, declarationNameToString, DeclarationStatement,
     DeclarationWithTypeParameterChildren, DeclarationWithTypeParameters, Decorator, deduplicate, DefaultClause,
     defaultMaximumTruncationLength, DeferredTypeReference, DeleteExpression, Diagnostic, DiagnosticCategory,
@@ -101,7 +101,7 @@ import {
     isFunctionExpressionOrArrowFunction, isFunctionLike, isFunctionLikeDeclaration,
     isFunctionLikeOrClassStaticBlockDeclaration, isFunctionOrModuleBlock, isFunctionTypeNode, isGeneratedIdentifier,
     isGetAccessor, isGetAccessorDeclaration, isGetOrSetAccessorDeclaration, isGlobalScopeAugmentation, isHeritageClause,
-    isIdentifier, isIdentifierStart, isIdentifierText, isIdentifierTypePredicate, isIdentifierTypeReference,
+    isIdentifier, isIdentifierText, isIdentifierTypePredicate, isIdentifierTypeReference,
     isIfStatement, isImportCall, isImportClause, isImportDeclaration, isImportEqualsDeclaration, isImportKeyword,
     isImportOrExportSpecifier, isImportSpecifier, isImportTypeNode, isIndexedAccessTypeNode, isInExpressionContext,
     isInfinityOrNaNString, isInJSDoc, isInJSFile, isInJsonFile, isInterfaceDeclaration,
@@ -195,7 +195,7 @@ import {
     usingSingleLineStringWriter, VariableDeclaration, VariableDeclarationList, VariableLikeDeclaration,
     VariableStatement, VarianceFlags, visitEachChild, visitNode, visitNodes, Visitor, VisitResult, VoidExpression,
     walkUpBindingElementsAndPatterns, walkUpParenthesizedExpressions, walkUpParenthesizedTypes,
-    walkUpParenthesizedTypesAndGetParentAndChild, WhileStatement, WideningContext, WithStatement, YieldExpression, ResolutionMode,
+    walkUpParenthesizedTypesAndGetParentAndChild, WhileStatement, WideningContext, WithStatement, YieldExpression, ResolutionMode, canUsePropertyAccess, parseValidBigInt, isValidBigIntString,
 } from "./_namespaces/ts";
 import * as performance from "./_namespaces/ts.performance";
 import * as moduleSpecifiers from "./_namespaces/ts.moduleSpecifiers";
@@ -6881,10 +6881,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 if (isSingleOrDoubleQuote(firstChar) && some(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
                     return factory.createStringLiteral(getSpecifierForModuleSymbol(symbol, context));
                 }
-                const canUsePropertyAccess = firstChar === CharacterCodes.hash ?
-                    symbolName.length > 1 && isIdentifierStart(symbolName.charCodeAt(1), languageVersion) :
-                    isIdentifierStart(firstChar, languageVersion);
-                if (index === 0 || canUsePropertyAccess) {
+                if (index === 0 || canUsePropertyAccess(symbolName, languageVersion)) {
                     const identifier = setEmitFlags(factory.createIdentifier(symbolName, typeParameterNodes), EmitFlags.NoAsciiEscaping);
                     identifier.symbol = symbol;
 
@@ -22698,35 +22695,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
      * @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 {

src/compiler/utilities.ts

@@ -90,7 +90,7 @@ import {
     TypePredicate, TypePredicateKind, TypeReferenceNode, unescapeLeadingUnderscores, UnionOrIntersectionTypeNode,
     ValidImportTypeNode, VariableDeclaration, VariableDeclarationInitializedTo, VariableDeclarationList,
     VariableLikeDeclaration, VariableStatement, version, WhileStatement, WithStatement, WriteFileCallback,
-    WriteFileCallbackData, YieldExpression, ResolutionMode,
+    WriteFileCallbackData, YieldExpression, ResolutionMode, isIdentifierStart,
 } from "./_namespaces/ts";
 
 /** @internal */
@@ -8129,6 +8129,51 @@ export function pseudoBigIntToString({negative, base10Value}: PseudoBigInt): str
     return (negative && base10Value !== "0" ? "-" : "") + base10Value;
 }
 
+/** @internal */
+export function parseBigInt(text: string): PseudoBigInt | undefined {
+    if (!isValidBigIntString(text, /*roundTripOnly*/ false)) {
+        return undefined;
+    }
+    return parseValidBigInt(text);
+}
+
+/**
+ * @internal
+ * @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 };
+}
+
+/**
+ * @internal
+ * 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()) }));
+}
+
 /** @internal */
 export function isValidTypeOnlyAliasUseSite(useSite: Node): boolean {
     return !!(useSite.flags & NodeFlags.Ambient)
@@ -8636,4 +8681,13 @@ export function isOptionalJSDocPropertyLikeTag(node: Node): node is JSDocPropert
     }
     const { isBracketed, typeExpression } = node;
     return isBracketed || !!typeExpression && typeExpression.type.kind === SyntaxKind.JSDocOptionalType;
+
+}
+
+/** @internal */
+export function canUsePropertyAccess(name: string, languageVersion: ScriptTarget): boolean {
+    const firstChar = name.charCodeAt(0);
+    return firstChar === CharacterCodes.hash ?
+        name.length > 1 && isIdentifierStart(name.charCodeAt(1), languageVersion) :
+        isIdentifierStart(firstChar, languageVersion);
 }