Merge pull request #48 from CheekyGhost-Labs/develop

Merging develop for 4.1.0 minor release

Author: mobrien-ghost

README.md

@@ -189,7 +189,49 @@ syntaxTree.functions[0].typealiases[0].name // SampleAlias
 syntaxTree.functions[0].typealiases[0].initializedType.type // .simple("String")
 ```
 
+### Modifier Conveniences
+
+Where applicable, types will conform to the `ModifierAssessing` protocol, which lets you assess what modifiers are present based on a `SwiftSyntax.Keyword` type. This is also available on any `Collection` where the element type is `Modifier`
+
+```swift
+// Assess if the instnace has `private(set)` and is `public`
+conformingInstance.containsModifierWithKeyword(.private, withDetail: "set")
+conformingInstance.containsModifierWithKeyword(.public)
+// or on a collection of modifiers
+variable.modifiers.containsKeyword(.private, withDetail: "set")
+```
+
+some common scenarios are available as direct getters:
+
+```swift
+conformingInstance.isPrivate
+conformingInstance.isPublic
+conformingInstance.isOpen
+// etc
+variable.isPrivateSetter
+variable.isFilePrivateSetter
+initializer.isConvenience
+initializer.isRequired
+// etc
+```
+
+Conforming types are:
+
+- `Actor`
+- `Class`
+- `Enumeration`
+- `Extension`
+- `Function`
+- `ProtocolDecl`
+- `Structure`
+- `Subscript`
+- `Typealias`
+- `Variable`
+- `Initializer`
+- Any collection where the type is `Modifier`
+
 ### Source Locations and Bounds:
+
 `Declaration` types can can also be sent to the `SyntaxTree` to extract source location and content:
 
 ```swift
@@ -294,7 +336,7 @@ Currently, SyntaxSparrow supports Swift Package Manager (SPM).
 To add SyntaxSparrow to your project, add the following line to your dependencies in your Package.swift file:
 
 ```swift
-.package(url: "https://github.com/CheekyGhost-Labs/SyntaxSparrow", from: "4.0.0")
+.package(url: "https://github.com/CheekyGhost-Labs/SyntaxSparrow", from: "4.1.0")
 ```
 
 Then, add SyntaxSparrow as a dependency for your target:

Sources/SyntaxSparrow/Internal/Resolvers/Declaration/VariableSemanticsResolver.swift

@@ -97,6 +97,21 @@ struct VariableSemanticsResolver: SemanticsResolving {
         return typeNode.type.resolveIsSyntaxOptional()
     }
 
+    func resolveIsComputed() -> Bool {
+        // If there is a value assigned - return false
+        guard node.initializer == nil else { return false}
+        // If there is a setter accessor - return false
+        let hasSetter = resolveHasSetter()
+        guard !hasSetter else { return false }
+        // If getter accessor exists - return true
+        let accessors = resolveAccessors()
+        if accessors.contains(where: { $0.kind == .get }) {
+            return true
+        }
+        // Otherwise check if there is a code block
+        return node.accessorBlock != nil
+    }
+
     func resolveHasSetter() -> Bool {
         // Resolver accessors for assessment
         let accessors = resolveAccessors()

Sources/SyntaxSparrow/Public/Extensions/Collection+Modifiers.swift

@@ -0,0 +1,30 @@
+//
+//  File.swift
+//  
+//
+//  Created by Michael O'Brien on 9/5/2024.
+//
+
+import Foundation
+import SwiftSyntax
+
+public extension Collection where Element == Modifier {
+    
+    /// Will return true when the collection contains a ``Modifier`` whose ``Modifier/name`` matches the given keyword.
+    ///
+    /// You can also provide a detail to assess. For example
+    /// ```swift
+    /// private(set) public var name: String = "foo"
+    /// ```
+    /// the following would return `true`:
+    /// ```swift
+    /// collection.containsKeyword(.private, withDetail: "set")
+    /// ```
+    /// - Parameters:
+    ///   - keyword: The keyword to search for
+    ///   - detail: Optional detail assigned to the modifier.
+    /// - Returns: Bool
+    func containsKeyword(_ keyword: Keyword, withDetail detail: String? = nil) -> Bool {
+        contains(where: { $0.node.name.tokenKind == .keyword(keyword) && $0.detail == detail })
+    }
+}

Sources/SyntaxSparrow/Public/Extensions/Collection+Parameters.swift

@@ -19,14 +19,7 @@ public extension Collection where Element == Parameter {
     /// - Parameter includeParenthesis: Bool whether to wrap the result in parenthesis. Defaults to `true`.
     /// - Returns: `String`
     func signatureInputString(includeParenthesis: Bool = true) -> String {
-        let components: [String] = map { param in
-            var base = param.description
-            base = base.replacingOccurrences(of: ",", with: "")
-            base = base.replacingOccurrences(of: " :", with: ":")
-            base = base.trimmingCharacters(in: .whitespacesAndNewlines)
-            return base
-        }
-        let joined = components.joined(separator: ", ")
+        let joined = map(\.description).joined(separator: ", ")
         if includeParenthesis {
             return "(\(joined))"
         }

Sources/SyntaxSparrow/Public/Protocols/ModifierAssessing.swift

@@ -0,0 +1,166 @@
+//
+//  ModifierAssessing.swift
+//
+//
+//  Created by Michael O'Brien on 9/5/2024.
+//
+
+import Foundation
+import SwiftSyntax
+
+/// ``ModifierAssessing`` conforming instances provide convenience assessments of an expected array of ``Modifier`` instances.
+public protocol ModifierAssessing {
+
+    /// Array of modifiers found in the declaration.
+    /// - See: ``SyntaxSparrow/Modifier``
+    var modifiers: [Modifier] { get }
+
+    /// Returns `true` when the `public` keyword is within the collection.
+    ///
+    /// For example:
+    /// ```swift
+    /// public var name: String = ""
+    /// public func executeOrder66() {}
+    /// public enum SomeType {}
+    /// ```
+    var isPublic: Bool { get }
+
+    /// Returns `true` when the `public`, `open`, `private`, and `fileprivate` keywords are not contained in the collection.
+    ///
+    /// **Note: ** Will also assess whether the internal keyword is explicitly present.
+    ///
+    /// For example:
+    /// ```swift
+    /// var name: String = ""
+    /// func executeOrder66() {}
+    /// enum SomeType {}
+    /// ```
+    var isInternal: Bool { get }
+
+    /// Returns `true` when the `open` keyword is within the collection.
+    ///
+    /// For example:
+    /// ```swift
+    /// open var name: String = ""
+    /// open func executeOrder66() {}
+    /// open class SomeType {}
+    /// ```
+    var isOpen: Bool { get }
+
+    /// Returns `true` when the `private` keyword is within the collection with no detail assigned.
+    ///
+    /// For example:
+    /// ```swift
+    /// private var name: String = ""
+    /// private func executeOrder66() {}
+    /// private class SomeType {}
+    /// ```
+    var isPrivate: Bool { get }
+
+    /// Returns `true` when the `filePrivate` keyword is within the collection with no detail assigned.
+    ///
+    /// For example:
+    /// ```swift
+    /// fileprivate var name: String = ""
+    /// fileprivate func executeOrder66() {}
+    /// fileprivate class SomeType {}
+    /// ```
+    var isFilePrivate: Bool { get }
+
+    /// Returns `true` when the `private` keyword is within the collection with no detail assigned.
+    ///
+    /// For example:
+    /// ```swift
+    /// final var name: String = ""
+    /// final func executeOrder66() {}
+    /// final class SomeType {}
+    /// ```
+    var isFinal: Bool { get }
+
+    /// Will return true when the ``ModifierAssessing/modifiers`` collection contains a modifier whose ``Modifier/name`` matches the given keyword.
+    ///
+    /// You can also provide a detail to assess. For example
+    /// ```swift
+    /// private(set) public var name: String = "foo"
+    /// ```
+    /// the following would return `true`:
+    /// ```swift
+    /// collection.containsKeyword(.private, withDetail: "set")
+    /// ```
+    /// - Parameters:
+    ///   - keyword: The keyword to search for
+    ///   - detail: Optional detail assigned to the modifier.
+    /// - Returns: Bool
+    func containsModifierWithKeyword(_ keyword: Keyword, withDetail detail: String?) -> Bool
+}
+
+extension ModifierAssessing {
+
+    public var isPublic: Bool { containsModifierWithKeyword(.public) }
+
+    public var isOpen: Bool { containsModifierWithKeyword(.open) }
+
+    public var isPrivate: Bool { containsModifierWithKeyword(.private) }
+
+    public var isFilePrivate: Bool { containsModifierWithKeyword(.fileprivate) }
+
+    public var isFinal: Bool { containsModifierWithKeyword(.final) }
+
+    public var isInternal: Bool {
+        (!isPublic && !isOpen && !isPrivate && !isFilePrivate) || containsModifierWithKeyword(.internal)
+    }
+
+    public func containsModifierWithKeyword(_ keyword: Keyword, withDetail detail: String? = nil) -> Bool {
+        modifiers.lazy.containsKeyword(keyword, withDetail: detail)
+    }
+}
+
+// MARK: - Conformance
+
+extension Actor: ModifierAssessing {}
+extension Class: ModifierAssessing {}
+extension Enumeration: ModifierAssessing {}
+extension Extension: ModifierAssessing {}
+extension Function: ModifierAssessing {}
+extension ProtocolDecl: ModifierAssessing {}
+extension Structure: ModifierAssessing {}
+extension Subscript: ModifierAssessing {}
+extension Typealias: ModifierAssessing {}
+
+extension Variable: ModifierAssessing {
+
+    /// Returns `true` when the `private` keyword is within the modifier collection with the `set` detail assigned.
+    ///
+    /// For example:
+    /// ```swift
+    /// private(set) var name: String = ""
+    /// ```
+    public var isPrivateSetter: Bool { containsModifierWithKeyword(.private, withDetail: "set") }
+
+    /// Returns `true` when the `fileprivate` keyword is within the modifier collection with the `set` detail assigned.
+    ///
+    /// For example:
+    /// ```swift
+    /// private(set) var name: String = ""
+    /// ```
+    public var isFilePrivateSetter: Bool { containsModifierWithKeyword(.fileprivate, withDetail: "set") }
+}
+
+extension Initializer: ModifierAssessing {
+
+    /// Returns `true` when the `required` keyword is within the modifier collection.
+    ///
+    /// For example:
+    /// ```swift
+    /// required init(name: String) {}
+    /// ```
+    public var isRequired: Bool { containsModifierWithKeyword(.required) }
+
+    /// Returns `true` when the `convenience` keyword is within the modifier collection.
+    ///
+    /// For example:
+    /// ```swift
+    /// convenience init(name: String) {}
+    /// ```
+    public var isConvenience: Bool { containsModifierWithKeyword(.convenience) }
+}

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

@@ -29,19 +29,19 @@ public struct Closure: DeclarationComponent {
     // MARK: - Properties
 
     /// Will return the closure input element from the input `typeAnnotation` for the closure.
-    /// **Note:** This will **always** resolve to ``EntityType/tuple`` with one or more parameters
-    /// or ``EntityType/tuple`` if there are no inputs. i.e
+    /// **Note:** This will **always** resolve to ``EntityType/tuple(_:)`` with one or more parameters
+    /// or ``EntityType/tuple(_:)`` if there are no inputs. i.e
     /// ```swift
     /// - ((name: inout String, age: Int) -> Void
     /// - (inout String, Int) -> Void
     /// - (String) -> Void
     /// - () -> Void
     /// ```
     /// will result in:
-    /// - ``EntityType/tuple`` with a single tuple element. The single tuple element will have the `name: inout String` and `age: Int` elements
-    /// - ``EntityType/tuple`` with two elements. The inout `String` and the `Int`
-    /// - ``EntityType/tuple`` with a single element. The `String`
-    /// - ``EntityType/void``.
+    /// - ``EntityType/tuple(_:)`` with a single tuple element. The single tuple element will have the `name: inout String` and `age: Int` elements
+    /// - ``EntityType/tuple(_:)`` with two elements. The inout `String` and the `Int`
+    /// - ``EntityType/tuple(_:)`` with a single element. The `String`
+    /// - ``EntityType/void(_:_:)``.
     public var input: EntityType { resolver.resolveInput() }
 
     /// Will return the input string for the closure. Returns an empty string if no result is found.

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

@@ -51,6 +51,21 @@ public struct Function: Declaration, SyntaxChildCollecting {
         ///
         /// **Note:** Value will be `false` when the `output` is `nil`
         public let outputIsOptional: Bool
+        
+        /// Will return the raw function return type.
+        ///
+        /// This can be used when a more accurate string description is needed for the ``Function/Signature/output`` property loses some info.
+        /// For example:
+        /// ```swift
+        /// func example() -> (any SomeProtocol)?
+        /// ```
+        /// in the above:
+        /// - `output` will be `.simple("any SomeProtocol")`
+        /// - `outputIsOptional` will be `true`
+        /// - The `rawOutputType` will be `"(any SomeProtocol)?"`
+        public var rawOutputType: String? {
+            node.returnClause?.type.description
+        }
 
         /// The `throws` or `rethrows` keyword, if any.
         /// Indicates whether the function can throw an error.
@@ -170,6 +185,25 @@ public struct Function: Declaration, SyntaxChildCollecting {
     /// `Operator.Kind` assigned when the `isOperator` is `true`.
     public var operatorKind: Operator.Kind? { resolver.resolveOperatorKind() }
 
+    /// Returns `true` when the ``Function/Signature/effectSpecifiers`` has the `throw` keyword.
+    ///
+    /// For example, the following would return `true`:
+    /// ```swift
+    /// func example() throws
+    /// ```
+    public var isThrowing: Bool {
+        return signature.effectSpecifiers?.throwsSpecifier != nil
+    }
+
+    /// Returns `true` when the ``Function/Signature/effectSpecifiers`` has the `throw` keyword.
+    ///
+    /// For example, the following would return `true`:
+    /// ```swift
+    /// func example() async
+    /// ```
+    public var isAsync: Bool {
+        return signature.effectSpecifiers?.asyncSpecifier != nil
+    }
     // MARK: - Properties: Resolving
 
     private(set) var resolver: FunctionSemanticsResolver