-

Author: NSFatalError

Sources/PrincipleMacros/Parameters/ParameterExtractor.swift

@@ -165,13 +165,15 @@ extension ParameterExtractor {
             return .nonisolated(trimmedModifer: isolation)
         }
 
-        if let memberAccessExpression = MemberAccessExprSyntax(expression),
-           let explicitType = memberAccessExpression.base?.inferredType,
-           memberAccessExpression.referencesBaseType {
-            return .isolated(standardizedType: explicitType.standardized)
+        guard let memberAccessExpression = MemberAccessExprSyntax(expression),
+              let globalActorType = memberAccessExpression.baseTypeReference
+        else {
+            throw ParameterExtractionError.unexpectedSyntaxType
         }
 
-        throw ParameterExtractionError.unexpectedSyntaxType
+        return .isolated(
+            standardizedType: globalActorType.standardized
+        )
     }
 
     public func requiredGlobalActorIsolation(
@@ -183,3 +185,31 @@ extension ParameterExtractor {
         return isolation
     }
 }
+
+extension ParameterExtractor {
+
+    public func type(
+        withLabel label: TokenSyntax?
+    ) throws -> TypeSyntax? {
+        guard let expression = expression(withLabel: label) else {
+            return nil
+        }
+
+        guard let memberAccessExpression = MemberAccessExprSyntax(expression),
+              let type = memberAccessExpression.baseTypeReference
+        else {
+            throw ParameterExtractionError.unexpectedSyntaxType
+        }
+
+        return type
+    }
+
+    public func requiredType(
+        withLabel label: TokenSyntax?
+    ) throws -> TypeSyntax {
+        guard let type = try type(withLabel: label) else {
+            throw ParameterExtractionError.missingRequirement
+        }
+        return type
+    }
+}

Sources/PrincipleMacros/Syntax/Extensions/ExprSyntax.swift

@@ -66,10 +66,10 @@ extension StringLiteralExprSyntax {
 extension OptionalChainingExprSyntax {
 
     public var inferredType: TypeSyntax? {
-        guard let inferredWrappedType else {
-            return nil
+        if let inferredWrappedType {
+            return "Optional<\(inferredWrappedType)>"
         }
-        return "Optional<\(inferredWrappedType)>"
+        return nil
     }
 
     public var inferredWrappedType: TypeSyntax? {
@@ -80,10 +80,10 @@ extension OptionalChainingExprSyntax {
 extension ArrayExprSyntax {
 
     public var inferredType: TypeSyntax? {
-        guard let inferredElementType else {
-            return nil
+        if let inferredElementType {
+            return "Array<\(inferredElementType)>"
         }
-        return "Array<\(inferredElementType)>"
+        return nil
     }
 
     public var inferredElementType: TypeSyntax? {
@@ -94,10 +94,10 @@ extension ArrayExprSyntax {
 extension DictionaryExprSyntax {
 
     public var inferredType: TypeSyntax? {
-        guard let inferredKeyType, let inferredValueType else {
-            return nil
+        if let inferredKeyType, let inferredValueType {
+            return "Dictionary<\(inferredKeyType), \(inferredValueType)>"
         }
-        return "Dictionary<\(inferredKeyType), \(inferredValueType)>"
+        return nil
     }
 
     public var inferredKeyType: TypeSyntax? {
@@ -129,10 +129,10 @@ extension FunctionCallExprSyntax {
 extension GenericSpecializationExprSyntax {
 
     public var inferredType: TypeSyntax? {
-        guard let inferredType = expression.inferredType else {
-            return nil
+        if let inferredType = expression.inferredType {
+            return "\(inferredType)\(genericArgumentClause.standardized)"
         }
-        return "\(inferredType)\(genericArgumentClause.standardized)"
+        return nil
     }
 }
 
@@ -148,8 +148,11 @@ extension MemberAccessExprSyntax {
         return first
     }
 
-    public var referencesBaseType: Bool {
-        declName.baseName.tokenKind == .keyword(.self)
+    public var baseTypeReference: TypeSyntax? {
+        if let base, declName.baseName.tokenKind == .keyword(.self) {
+            return "\(base.trimmed)"
+        }
+        return nil
     }
 }
 

Sources/PrincipleMacros/Syntax/Extensions/IfConfigDeclSyntax+Availability.swift

@@ -34,7 +34,7 @@ extension IfConfigDeclSyntax {
 
 extension IfConfigClauseSyntax {
 
-    var availability: Self? {
+    public var availability: Self? {
         if let availability = elements?.availability {
             with(\.elements, availability)
         } else {

Tests/PrincipleMacrosTests/Parameters/ParameterExtractorTests.swift

@@ -143,3 +143,26 @@ extension ParameterExtractorTests {
         }
     }
 }
+
+extension ParameterExtractorTests {
+
+    @Test(
+        arguments: [
+            "MyType",
+            "SomeType.MyType"
+        ]
+    )
+    func typeExtraction(_ type: String) throws {
+        let extractor = try makeExtractor(from: "#MyMacro(type: \(raw: type).self)")
+        let extracted = try extractor.type(withLabel: "type")
+        #expect(extracted?.trimmedDescription == type)
+    }
+
+    @Test
+    func unexpectedSyntaxWhenPerformingTypeExtraction() throws {
+        let extractor = try makeExtractor(from: #"#MyMacro(type: MainActor.Type)"#)
+        #expect(throws: ParameterExtractionError.unexpectedSyntaxType) {
+            try extractor.type(withLabel: "type")
+        }
+    }
+}

Tests/PrincipleMacrosTests/Syntax/Extensions/ClassDeclSyntaxTests.swift

@@ -12,7 +12,7 @@ import Testing
 internal struct ClassDeclSyntaxTests {
 
     @Test
-    func withoutInheritenceClause() throws {
+    func withoutInheritanceClause() throws {
         let decl: DeclSyntax = "class MyClass {}"
         let classDecl = try #require(decl.as(ClassDeclSyntax.self))
         let inferredSuperclass = classDecl.inferredSuperclass()