Add 'as'/'is' enum case accessor code actions

Replaces the single accessor refactoring with two: "Generate 'as' accessors for enum cases" adds an `as<Case>` property for each case with associated values, and "Generate 'is' accessors for enum cases" adds an `is<Case>` Boolean for every case. Resolves #2522.

Author: ayush-that

Sources/SwiftSyntaxCodeActions/CMakeLists.txt

@@ -6,6 +6,7 @@ add_library(SwiftSyntaxCodeActions STATIC
   ConvertIntegerLiteral.swift
   ConvertJSONToCodableStruct.swift
   ConvertStringConcatenationToStringInterpolation.swift
+  GenerateEnumCaseAccessors.swift
   IndentationRemover.swift
   PackageManifestEdits.swift
   SyntaxCodeActionProvider.swift

Sources/SwiftSyntaxCodeActions/GenerateEnumCaseAccessors.swift

@@ -0,0 +1,215 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2026 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftBasicFormat
+import SwiftRefactor
+import SwiftSyntax
+
+/// Syntactic code action that adds an `as<Case>` computed property for every
+/// enum case with associated values, returning the value(s) as an optional.
+struct GenerateEnumCaseAsAccessors: EditRefactoringProvider {
+  static func textRefactor(syntax: EnumDeclSyntax, in context: Void) throws -> [SourceEdit] {
+    var usedNames = existingMemberNames(in: syntax)
+    let indentation = accessorIndentation(for: syntax)
+
+    var accessors: [String] = []
+    for element in enumCaseElements(of: syntax) {
+      guard let parameters = element.parameterClause?.parameters, !parameters.isEmpty else {
+        continue
+      }
+      let name = "as\(capitalizedCaseName(of: element))"
+      guard !usedNames.contains(name) else { continue }
+      usedNames.insert(name)
+      accessors.append(
+        makeAsAccessor(
+          name: name,
+          casePattern: element.name.text,
+          parameters: Array(parameters),
+          indentation: indentation
+        )
+      )
+    }
+
+    return try sourceEdits(insertingAccessors: accessors, into: syntax)
+  }
+
+  private static func makeAsAccessor(
+    name: String,
+    casePattern: String,
+    parameters: [EnumCaseParameterSyntax],
+    indentation: (member: String, body: String)
+  ) -> String {
+    let bindings = parameters.enumerated().map { index, parameter -> String in
+      if let label = parameter.firstName, label.text != "_" {
+        return label.text
+      }
+      return parameters.count == 1 ? "value" : "value\(index + 1)"
+    }
+    let types = parameters.map { $0.type.trimmedDescription }
+    let returnType: String
+    if parameters.count == 1 {
+      returnType = needsParenthesesBeforeOptional(parameters[0].type) ? "(\(types[0]))?" : "\(types[0])?"
+    } else {
+      returnType = "(\(types.joined(separator: ", ")))?"
+    }
+    let boundValues = bindings.joined(separator: ", ")
+    let returnValue = bindings.count == 1 ? bindings[0] : "(\(boundValues))"
+    return """
+      \(indentation.member)var \(name): \(returnType) {
+      \(indentation.body)if case let .\(casePattern)(\(boundValues)) = self { return \(returnValue) }
+      \(indentation.body)return nil
+      \(indentation.member)}
+      """
+  }
+}
+
+extension GenerateEnumCaseAsAccessors: SyntaxRefactoringCodeActionProvider {
+  static let title: String = "Generate 'as' accessors for enum cases"
+
+  static func nodeToRefactor(in scope: SyntaxCodeActionScope) -> EnumDeclSyntax? {
+    return scope.innermostNodeContainingRange?.findParentOfSelf(
+      ofType: EnumDeclSyntax.self,
+      stoppingIf: { $0.is(CodeBlockSyntax.self) }
+    )
+  }
+}
+
+/// Syntactic code action that adds an `is<Case>` Boolean computed property for
+/// every enum case.
+struct GenerateEnumCaseIsAccessors: EditRefactoringProvider {
+  static func textRefactor(syntax: EnumDeclSyntax, in context: Void) throws -> [SourceEdit] {
+    var usedNames = existingMemberNames(in: syntax)
+    let indentation = accessorIndentation(for: syntax)
+
+    var accessors: [String] = []
+    for element in enumCaseElements(of: syntax) {
+      let name = "is\(capitalizedCaseName(of: element))"
+      guard !usedNames.contains(name) else { continue }
+      usedNames.insert(name)
+      accessors.append(
+        makeIsAccessor(name: name, casePattern: element.name.text, indentation: indentation)
+      )
+    }
+
+    return try sourceEdits(insertingAccessors: accessors, into: syntax)
+  }
+
+  private static func makeIsAccessor(
+    name: String,
+    casePattern: String,
+    indentation: (member: String, body: String)
+  ) -> String {
+    return """
+      \(indentation.member)var \(name): Bool {
+      \(indentation.body)if case .\(casePattern) = self { return true }
+      \(indentation.body)return false
+      \(indentation.member)}
+      """
+  }
+}
+
+extension GenerateEnumCaseIsAccessors: SyntaxRefactoringCodeActionProvider {
+  static let title: String = "Generate 'is' accessors for enum cases"
+
+  static func nodeToRefactor(in scope: SyntaxCodeActionScope) -> EnumDeclSyntax? {
+    return scope.innermostNodeContainingRange?.findParentOfSelf(
+      ofType: EnumDeclSyntax.self,
+      stoppingIf: { $0.is(CodeBlockSyntax.self) }
+    )
+  }
+}
+
+// MARK: - Shared helpers
+
+private func enumCaseElements(of enumDecl: EnumDeclSyntax) -> [EnumCaseElementSyntax] {
+  enumDecl.memberBlock.members.flatMap { member -> [EnumCaseElementSyntax] in
+    guard let caseDecl = member.decl.as(EnumCaseDeclSyntax.self) else { return [] }
+    return Array(caseDecl.elements)
+  }
+}
+
+/// The `as`/`is` accessor name for a case, with the leading character upper-cased.
+private func capitalizedCaseName(of element: EnumCaseElementSyntax) -> String {
+  let caseName = element.name.identifier?.name ?? element.name.text
+  return caseName.prefix(1).uppercased() + caseName.dropFirst()
+}
+
+/// Whether `type` must be parenthesized to be made optional. Types that the postfix `?` already
+/// binds to are returned as-is; anything else (function, composition, `any`, attributed, … types)
+/// is parenthesized so e.g. `(Int) -> Void` becomes `((Int) -> Void)?` rather than `(Int) -> Void?`.
+private func needsParenthesesBeforeOptional(_ type: TypeSyntax) -> Bool {
+  switch type.as(TypeSyntaxEnum.self) {
+  case .identifierType, .memberType, .arrayType, .dictionaryType, .optionalType,
+    .implicitlyUnwrappedOptionalType, .tupleType, .metatypeType:
+    return false
+  default:
+    return true
+  }
+}
+
+/// The indentation for generated members and their bodies, derived from the
+/// enclosing enum's indentation and the file's inferred indentation width.
+private func accessorIndentation(for enumDecl: EnumDeclSyntax) -> (member: String, body: String) {
+  let base = enumDecl.firstToken(viewMode: .sourceAccurate)?.indentationOfLine ?? []
+  let step = BasicFormat.inferIndentation(of: enumDecl.root) ?? .spaces(4)
+  let member = base + step
+  return (member: member.description, body: (member + step).description)
+}
+
+/// Names of all identifier-declaring members, so generated accessors never collide with an existing one.
+private func existingMemberNames(in enumDecl: EnumDeclSyntax) -> Set<String> {
+  func canonicalName(_ token: TokenSyntax) -> String {
+    token.identifier?.name ?? token.text
+  }
+
+  var names: Set<String> = []
+  for member in enumDecl.memberBlock.members {
+    switch member.decl.as(DeclSyntaxEnum.self) {
+    case .enumCaseDecl(let caseDecl):
+      for element in caseDecl.elements {
+        names.insert(canonicalName(element.name))
+      }
+    case .variableDecl(let variable):
+      for binding in variable.bindings {
+        if let pattern = binding.pattern.as(IdentifierPatternSyntax.self) {
+          names.insert(canonicalName(pattern.identifier))
+        }
+      }
+    case .functionDecl(let function):
+      names.insert(canonicalName(function.name))
+    case .typeAliasDecl(let typeAlias):
+      names.insert(canonicalName(typeAlias.name))
+    case .structDecl(let structDecl):
+      names.insert(canonicalName(structDecl.name))
+    case .classDecl(let classDecl):
+      names.insert(canonicalName(classDecl.name))
+    case .enumDecl(let nestedEnum):
+      names.insert(canonicalName(nestedEnum.name))
+    case .actorDecl(let actorDecl):
+      names.insert(canonicalName(actorDecl.name))
+    default:
+      break
+    }
+  }
+  return names
+}
+
+private func sourceEdits(insertingAccessors accessors: [String], into enumDecl: EnumDeclSyntax) throws -> [SourceEdit] {
+  guard !accessors.isEmpty else {
+    throw RefactoringNotApplicableError("No accessors to generate")
+  }
+  // Insert before the closing brace's leading trivia so the brace keeps its own
+  // newline and indentation (correct for both top-level and nested enums).
+  let insertion = "\n\n" + accessors.joined(separator: "\n\n")
+  let position = enumDecl.memberBlock.rightBrace.position
+  return [SourceEdit(range: position..<position, replacement: insertion)]
+}

Sources/SwiftSyntaxCodeActions/SyntaxCodeActions.swift

@@ -27,6 +27,8 @@ package let allSyntaxCodeActions: [any SyntaxCodeActionProvider.Type] = {
     ConvertStringConcatenationToStringInterpolation.self,
     ConvertZeroParameterFunctionToComputedProperty.self,
     FormatRawStringLiteral.self,
+    GenerateEnumCaseAsAccessors.self,
+    GenerateEnumCaseIsAccessors.self,
     MigrateToNewIfLetSyntax.self,
     OpaqueParameterToGeneric.self,
     RemoveRedundantParentheses.self,