Adding existential and opaque support to EntityType

Author: mobrien-ghost

Sources/SyntaxSparrow/Internal/Extensions/EntityType+Parsing.swift

@@ -28,6 +28,25 @@ extension EntityType {
         }
     }
 
+
+    var isExistential: Bool {
+        switch self {
+        case .existential:
+            return true
+        default:
+            return false
+        }
+    }
+
+    var isOpaque: Bool {
+        switch self {
+        case .opaque:
+            return true
+        default:
+            return false
+        }
+    }
+
     var isVoid: Bool {
         switch self {
         case .void:
@@ -107,6 +126,16 @@ extension EntityType {
             return parseType(attributedType.baseType)
         }
 
+        // Some or Any (Opaque/Existential)
+        if let someOrAny = typeSyntax.as(SomeOrAnyTypeSyntax.self) {
+            let resolvedType = parseType(someOrAny.constraint)
+            if someOrAny.someOrAnySpecifier.tokenKind == .keyword(.any) {
+                return .existential(resolvedType)
+            } else {
+                return .opaque(resolvedType)
+            }
+        }
+
         // Fallback
         if !typeSyntax.description.trimmed.isEmpty {
             let typeString = resolveSimpleTypeString(from: typeSyntax)

Sources/SyntaxSparrow/Public/Semantics/Components/EntityType.swift

@@ -13,7 +13,7 @@ import SwiftSyntax
 /// By default a ``SyntaxSparrow/EntityType/simple(_:)`` type will be used with a string representation of the declared type.
 /// Initial support for some complex types, such as closures, tuples, and results is provided.
 /// As support for more complex types are added they will be added as a dedicated enumeration case to the `EntityType`
-public enum EntityType: Equatable, Hashable, CustomStringConvertible {
+public indirect enum EntityType: Equatable, Hashable, CustomStringConvertible {
     /// A `simple` type refers to a standard swift type can't does not have any nested or related syntax.
     /// **Note:** This is also used for any unsupported syntax types. i.e `CVarArg` is not currently supported so it will use the
     /// `.simple("CVarArg...")`
@@ -102,6 +102,39 @@ public enum EntityType: Equatable, Hashable, CustomStringConvertible {
     /// - The third function would have a parameter with the type `.closure(Closure)` where the closure input and output are both `.void`
     case void(_ raw: String, _ isOptional: Bool)
 
+    /// An `existential` type is used when a parameter's type uses the `any` keyword to represent an existential type.
+    ///
+    /// Existential types allow for runtime polymorphism by erasing the concrete type behind a protocol constraint.
+    ///
+    /// For example,
+    /// ```swift
+    /// func example(handler: any Sendable) { ... }
+    /// func example(items: [any Codable]) { ... }
+    /// ```
+    /// would have types of `.existential(.simple("Sendable"))` and `.array(ArrayDecl)` where the array's `elementType`
+    /// is `.existential(.simple("Codable"))` respectively.
+    ///
+    /// **Note:** The `any` keyword was introduced in Swift 5.7 to explicitly denote existential types, making the distinction
+    /// between existential and opaque types clear in the type system.
+    case existential(_ type: EntityType)
+
+    /// An `opaque` type is used when a parameter's type uses the `some` keyword to represent an opaque type.
+    ///
+    /// Opaque types provide compile-time polymorphism by hiding the concrete type behind a protocol constraint while
+    /// preserving type identity. Unlike existential types, opaque types guarantee the same underlying concrete type
+    /// is used consistently.
+    ///
+    /// For example,
+    /// ```swift
+    /// func example() -> some View { ... }
+    /// func example(handler: some Sendable) { ... }
+    /// ```
+    /// would have return/parameter types of `.opaque(.simple("View"))` and `.opaque(.simple("Sendable"))` respectively.
+    ///
+    /// **Note:** Opaque types are commonly used with SwiftUI's `View` protocol and were introduced in Swift 5.1,
+    /// with the `some` keyword extended to parameter position in Swift 5.7.
+    case opaque(_ type: EntityType)
+
     /// An `empty` type refers to a when a parameter or property is partially declared and does not have a type defined.
     ///
     /// **Note:** This is not best practice, but as the parser can iterate over these declarations, it avoids having an optional type to work with.
@@ -128,6 +161,10 @@ public enum EntityType: Equatable, Hashable, CustomStringConvertible {
         case let .void(rawType, isOptional):
             if rawType.hasSuffix("?") { return rawType }
             return "\(rawType)\(isOptional ? "?" : "")"
+        case let .existential(wrapped):
+            return wrapped.description
+        case let .opaque(wrapped):
+            return wrapped.description
         case .empty:
             return ""
         }

Sources/SyntaxSparrow/Public/Semantics/Components/Parameter.swift

@@ -134,6 +134,72 @@ public struct Parameter: Equatable, Hashable, CustomStringConvertible {
     /// - Both parameter arguments in the tuple will have `isLabelOmitted` as `false`
     public var isLabelOmitted: Bool { name == "_" }
 
+    /// A Boolean value indicating whether the variable's type is an existential type (prefixed with `any`).
+    ///
+    /// Existential types allow for runtime polymorphism by type-erasing the concrete implementation
+    /// behind a protocol constraint. This property returns `true` when the variable is declared with
+    /// the `any` keyword.
+    ///
+    /// For example:
+    /// ```swift
+    /// var handler: any Sendable  // isExistential = true
+    /// var items: [any Codable]   // isExistential = false (the variable is an array, but contains existential elements)
+    /// var name: String           // isExistential = false
+    /// ```
+    ///
+    /// **Note:** This property only checks if the top-level type is existential. For nested existential
+    /// types (such as array elements), you need to inspect the ``type`` property directly.
+    public var isExistential: Bool {
+        type.isExistential
+    }
+
+    /// A Boolean value indicating whether the variable's type is an opaque type (prefixed with `some`).
+    ///
+    /// Opaque types provide compile-time polymorphism by hiding the concrete type behind a protocol
+    /// constraint while preserving type identity. This property returns `true` when the variable is
+    /// declared with the `some` keyword.
+    ///
+    /// For example:
+    /// ```swift
+    /// var view: some View        // isOpaque = true
+    /// var items: [some Sendable] // isOpaque = false (the variable is an array, but contains opaque elements)
+    /// var name: String           // isOpaque = false
+    /// ```
+    ///
+    /// **Note:** This property only checks if the top-level type is opaque. For nested opaque types
+    /// (such as array elements), you need to inspect the ``type`` property directly.
+    public var isOpaque: Bool {
+        type.isOpaque
+    }
+
+    /// Returns the existential or opaque type keyword used in the variable's type declaration, if present.
+    ///
+    /// This property returns `"any"` for existential types, `"some"` for opaque types, or `nil` if the
+    /// variable's type is neither existential nor opaque.
+    ///
+    /// For example:
+    /// ```swift
+    /// var handler: any Sendable     // someOrAnyKeyword = "any"
+    /// var view: some View           // someOrAnyKeyword = "some"
+    /// var name: String              // someOrAnyKeyword = nil
+    /// var items: [any Codable]      // someOrAnyKeyword = nil (top-level type is array)
+    /// ```
+    ///
+    /// **Note:** This property only checks the top-level type. For nested existential or opaque types
+    /// (such as `[any Codable]` or `(some View) -> Void`), this returns `nil` because the variable's
+    /// direct type is the collection or closure, not the existential/opaque type itself.
+    ///
+    /// - Returns: `"any"` if the type is existential, `"some"` if the type is opaque, or `nil` otherwise.
+    public var someOrAnyKeyword: String? {
+        if isExistential {
+            return "any"
+        } else if isOpaque {
+            return "some"
+        } else {
+            return nil
+        }
+    }
+
     // MARK: - Properties: Resolving
 
     private(set) var resolver: any ParameterNodeSemanticsResolving

Sources/SyntaxSparrow/Public/Semantics/Declarations/Variable.swift

@@ -164,6 +164,72 @@ public struct Variable: Declaration {
         return accessors.contains(where: { $0.kind == .get && $0.effectSpecifiers?.asyncSpecifier != nil })
     }
 
+    /// A Boolean value indicating whether the variable's type is an existential type (prefixed with `any`).
+    ///
+    /// Existential types allow for runtime polymorphism by type-erasing the concrete implementation
+    /// behind a protocol constraint. This property returns `true` when the variable is declared with
+    /// the `any` keyword.
+    ///
+    /// For example:
+    /// ```swift
+    /// var handler: any Sendable  // isExistential = true
+    /// var items: [any Codable]   // isExistential = false (the variable is an array, but contains existential elements)
+    /// var name: String           // isExistential = false
+    /// ```
+    ///
+    /// **Note:** This property only checks if the top-level type is existential. For nested existential
+    /// types (such as array elements), you need to inspect the ``type`` property directly.
+    public var isExistential: Bool {
+        type.isExistential
+    }
+
+    /// A Boolean value indicating whether the variable's type is an opaque type (prefixed with `some`).
+    ///
+    /// Opaque types provide compile-time polymorphism by hiding the concrete type behind a protocol
+    /// constraint while preserving type identity. This property returns `true` when the variable is
+    /// declared with the `some` keyword.
+    ///
+    /// For example:
+    /// ```swift
+    /// var view: some View        // isOpaque = true
+    /// var items: [some Sendable] // isOpaque = false (the variable is an array, but contains opaque elements)
+    /// var name: String           // isOpaque = false
+    /// ```
+    ///
+    /// **Note:** This property only checks if the top-level type is opaque. For nested opaque types
+    /// (such as array elements), you need to inspect the ``type`` property directly.
+    public var isOpaque: Bool {
+        type.isOpaque
+    }
+
+    /// Returns the existential or opaque type keyword used in the variable's type declaration, if present.
+    ///
+    /// This property returns `"any"` for existential types, `"some"` for opaque types, or `nil` if the
+    /// variable's type is neither existential nor opaque.
+    ///
+    /// For example:
+    /// ```swift
+    /// var handler: any Sendable     // someOrAnyKeyword = "any"
+    /// var view: some View           // someOrAnyKeyword = "some"
+    /// var name: String              // someOrAnyKeyword = nil
+    /// var items: [any Codable]      // someOrAnyKeyword = nil (top-level type is array)
+    /// ```
+    ///
+    /// **Note:** This property only checks the top-level type. For nested existential or opaque types
+    /// (such as `[any Codable]` or `(some View) -> Void`), this returns `nil` because the variable's
+    /// direct type is the collection or closure, not the existential/opaque type itself.
+    ///
+    /// - Returns: `"any"` if the type is existential, `"some"` if the type is opaque, or `nil` otherwise.
+    public var someOrAnyKeyword: String? {
+        if isExistential {
+            return "any"
+        } else if isOpaque {
+            return "some"
+        } else {
+            return nil
+        }
+    }
+
     // MARK: - Properties: DeclarationCollecting
 
     private(set) var resolver: VariableSemanticsResolver