Fixed crash in switch completions related to parenthesized expressions (#52881)

Author: Andarist

src/services/stringCompletions.ts

@@ -431,7 +431,7 @@ function getStringLiteralCompletionEntries(sourceFile: SourceFile, node: StringL
             //      export * from "/*completion position*/";
             return { kind: StringLiteralCompletionKind.Paths, paths: getStringLiteralCompletionsFromModuleNames(sourceFile, node, compilerOptions, host, typeChecker, preferences) };
         case SyntaxKind.CaseClause:
-            const tracker = newCaseClauseTracker(typeChecker, (node.parent as CaseClause).parent.clauses);
+            const tracker = newCaseClauseTracker(typeChecker, (parent as CaseClause).parent.clauses);
             const literals = fromContextualType().types.filter(literal => !tracker.hasValue(literal.value));
             return { kind: StringLiteralCompletionKind.Types, types: literals, isNewIdentifier: false };
         default:

src/services/utilities.ts

@@ -312,6 +312,7 @@ import {
     singleOrUndefined,
     skipAlias,
     skipOuterExpressions,
+    skipParentheses,
     some,
     SortKind,
     SourceFile,
@@ -360,6 +361,7 @@ import {
     VariableDeclaration,
     visitEachChild,
     VoidExpression,
+    walkUpParenthesizedExpressions,
     YieldExpression,
 } from "./_namespaces/ts";
 
@@ -3298,7 +3300,7 @@ export function needsParentheses(expression: Expression): boolean {
 
 /** @internal */
 export function getContextualTypeFromParent(node: Expression, checker: TypeChecker, contextFlags?: ContextFlags): Type | undefined {
-    const { parent } = node;
+    const parent = walkUpParenthesizedExpressions(node.parent);
     switch (parent.kind) {
         case SyntaxKind.NewExpression:
             return checker.getContextualType(parent as NewExpression, contextFlags);
@@ -3309,7 +3311,7 @@ export function getContextualTypeFromParent(node: Expression, checker: TypeCheck
                 : checker.getContextualType(node, contextFlags);
         }
         case SyntaxKind.CaseClause:
-            return (parent as CaseClause).expression === node ? getSwitchedType(parent as CaseClause, checker) : undefined;
+            return getSwitchedType(parent as CaseClause, checker);
         default:
             return checker.getContextualType(node, contextFlags);
     }
@@ -4098,8 +4100,8 @@ export function newCaseClauseTracker(checker: TypeChecker, clauses: readonly (Ca
 
     for (const clause of clauses) {
         if (!isDefaultClause(clause)) {
-            if (isLiteralExpression(clause.expression)) {
-                const expression = clause.expression;
+            const expression = skipParentheses(clause.expression);
+            if (isLiteralExpression(expression)) {
                 switch (expression.kind) {
                     case SyntaxKind.NoSubstitutionTemplateLiteral:
                     case SyntaxKind.StringLiteral:

tests/cases/fourslash/switchCompletions.ts

@@ -19,6 +19,12 @@
 ////         return 1;
 ////     case '/*3*/'
 //// }
+////
+//// // repro from #52874
+//// declare let x: "foo" | "bar";
+//// switch (x) {
+////     case ('/*4*/')
+//// }
 
 verify.completions(
     {
@@ -38,5 +44,10 @@ verify.completions(
         isNewIdentifierLocation: false,
         includes: ["foo", "baz"],
         excludes: "bar",
+    },
+    {
+        marker: "4",
+        isNewIdentifierLocation: false,
+        includes: ["foo", "bar"],
     }
 );