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,
+    walkUpParenthesizedTypesAndGetParentAndChild, WhileStatement, WideningContext, WithStatement, YieldExpression, 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/factory/nodeTests.ts

@@ -85,7 +85,7 @@ export function isDotDotDotToken(node: Node): node is DotDotDotToken {
     return node.kind === SyntaxKind.DotDotDotToken;
 }
 
-/** @internal */
+/** @internal*/
 export function isCommaToken(node: Node): node is Token<SyntaxKind.CommaToken> {
     return node.kind === SyntaxKind.CommaToken;
 }

src/compiler/types.ts

@@ -1331,6 +1331,7 @@ export interface KeywordToken<TKind extends KeywordSyntaxKind> extends Token<TKi
 export type AssertsKeyword = KeywordToken<SyntaxKind.AssertsKeyword>;
 export type AssertKeyword = KeywordToken<SyntaxKind.AssertKeyword>;
 export type AwaitKeyword = KeywordToken<SyntaxKind.AwaitKeyword>;
+export type CaseKeyword = KeywordToken<SyntaxKind.CaseKeyword>;
 
 /** @deprecated Use `AwaitKeyword` instead. */
 export type AwaitKeywordToken = AwaitKeyword;
@@ -7853,12 +7854,12 @@ export interface NodeFactory {
     // Signature elements
     //
 
-    createTypeParameterDeclaration(modifiers: readonly Modifier[] | undefined, name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration;
-    updateTypeParameterDeclaration(node: TypeParameterDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration;
-    createParameterDeclaration(modifiers: readonly ModifierLike[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): ParameterDeclaration;
-    updateParameterDeclaration(node: ParameterDeclaration, modifiers: readonly ModifierLike[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): ParameterDeclaration;
-    createDecorator(expression: Expression): Decorator;
-    updateDecorator(node: Decorator, expression: Expression): Decorator;
+        createTypeParameterDeclaration(modifiers: readonly Modifier[] | undefined, name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration;
+        updateTypeParameterDeclaration(node: TypeParameterDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration;
+        createParameterDeclaration(modifiers: readonly ModifierLike[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): ParameterDeclaration;
+        updateParameterDeclaration(node: ParameterDeclaration, modifiers: readonly ModifierLike[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): ParameterDeclaration;
+        createDecorator(expression: Expression): Decorator;
+        updateDecorator(node: Decorator, expression: Expression): Decorator;
 
     //
     // Type Elements

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,
+    WriteFileCallbackData, YieldExpression, 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);
 }