Added superclass inference

Sources/PrincipleMacros/Diagnostics/DiagnosticsError.swift

@@ -0,0 +1,21 @@
+//
+//  DiagnosticsError.swift
+//  PrincipleMacros
+//
+//  Created by Kamil Strzelecki on 21/11/2025.
+//  Copyright © 2025 Kamil Strzelecki. All rights reserved.
+//
+
+import SwiftSyntaxMacros
+
+extension DiagnosticsError {
+
+    public init(
+        node: some SyntaxProtocol,
+        message: String
+    ) {
+        let message = MacroExpansionErrorMessage(message)
+        let diagnostic = Diagnostic(node: node, message: message)
+        self.init(diagnostics: [diagnostic])
+    }
+}

Sources/PrincipleMacros/Parsers/Common/Parser.swift

@@ -13,12 +13,44 @@ public protocol Parser {
     associatedtype ResultsCollection: ParserResultsCollection
 
     static func parse(
-        declaration: some DeclSyntaxProtocol,
-        in context: some MacroExpansionContext
-    ) -> ResultsCollection
+        declaration: some DeclSyntaxProtocol
+    ) throws -> ResultsCollection
+}
 
-    static func parse(
-        memberBlock: MemberBlockSyntax,
-        in context: some MacroExpansionContext
-    ) -> ResultsCollection
+extension Parser {
+
+    public static func parse(
+        ifConfig: IfConfigDeclSyntax
+    ) throws -> ResultsCollection {
+        try ResultsCollection(
+            ifConfig.clauses.flatMap { clause in
+                switch clause.elements {
+                case let .decls(members):
+                    try parse(members: members)
+                default:
+                    ResultsCollection()
+                }
+            }
+        )
+    }
+
+    public static func parse(
+        members: MemberBlockItemListSyntax
+    ) throws -> ResultsCollection {
+        try ResultsCollection(
+            members.flatMap { member in
+                if let ifConfig = member.decl.as(IfConfigDeclSyntax.self) {
+                    try parse(ifConfig: ifConfig)
+                } else {
+                    try parse(declaration: member.decl)
+                }
+            }
+        )
+    }
+
+    public static func parse(
+        memberBlock: MemberBlockSyntax
+    ) throws -> ResultsCollection {
+        try parse(members: memberBlock.members)
+    }
 }

Sources/PrincipleMacros/Parsers/Common/ParserResultsCollection.swift

@@ -12,6 +12,8 @@ where Element: ParserResult {
     associatedtype Element
 
     var all: [Element] { get }
+
+    init(_ all: [Element])
 }
 
 extension ParserResultsCollection {
@@ -24,6 +26,10 @@ extension ParserResultsCollection {
         all.endIndex
     }
 
+    public init() {
+        self.init([])
+    }
+
     public subscript(position: Int) -> Element {
         all[position]
     }

Sources/PrincipleMacros/Parsers/EnumCases/EnumCasesList.swift

@@ -8,11 +8,11 @@
 
 import SwiftSyntaxMacros
 
-public struct EnumCasesList: _ParserResultsCollection {
+public struct EnumCasesList: ParserResultsCollection {
 
     public let all: [EnumCase]
 
-    init(_ all: [EnumCase]) {
+    public init(_ all: [EnumCase]) {
         self.all = all
     }
 }

Sources/PrincipleMacros/Parsers/EnumCases/EnumCasesParser.swift

@@ -8,11 +8,10 @@
 
 import SwiftSyntaxMacros
 
-public enum EnumCasesParser: _Parser {
+public enum EnumCasesParser: Parser {
 
     public static func parse(
-        declaration: some DeclSyntaxProtocol,
-        in _: some MacroExpansionContext
+        declaration: some DeclSyntaxProtocol
     ) -> EnumCasesList {
         guard let declaration = EnumCaseDeclSyntax(declaration) else {
             return .init()

Sources/PrincipleMacros/Parsers/Properties/PropertiesList.swift

@@ -8,11 +8,11 @@
 
 import SwiftSyntaxMacros
 
-public struct PropertiesList: _ParserResultsCollection {
+public struct PropertiesList: ParserResultsCollection {
 
     public let all: [Property]
 
-    init(_ all: [Property]) {
+    public init(_ all: [Property]) {
         self.all = all
     }
 }

Sources/PrincipleMacros/Parsers/Properties/PropertiesParser.swift

@@ -8,32 +8,29 @@
 
 import SwiftSyntaxMacros
 
-public enum PropertiesParser: _Parser {
+public enum PropertiesParser: Parser {
 
     public static func parse(
-        declaration: some DeclSyntaxProtocol,
-        in context: some MacroExpansionContext
-    ) -> PropertiesList {
+        declaration: some DeclSyntaxProtocol
+    ) throws -> PropertiesList {
         guard let declaration = VariableDeclSyntax(declaration) else {
             return .init()
         }
 
-        return PropertiesList(
+        return try PropertiesList(
             declaration.bindings.compactMap { binding -> Property? in
                 guard let name = binding.name else {
-                    context.diagnose(
+                    throw DiagnosticsError(
                         node: declaration,
-                        errorMessage: "Property cannot be parsed"
+                        message: "Property cannot be parsed"
                     )
-                    return nil
                 }
 
                 guard let inferredType = binding.inferredType else {
-                    context.diagnose(
+                    throw DiagnosticsError(
                         node: declaration,
-                        errorMessage: "Type of property cannot be inferred - provide it explicitly"
+                        message: "Type of property cannot be inferred - provide it explicitly"
                     )
-                    return nil
                 }
 
                 return Property(

Sources/PrincipleMacros/Syntax/Concepts/GlobalActorIsolation.swift

@@ -32,10 +32,10 @@ public enum GlobalActorIsolation {
     }
 
     public var standardizedIsolationAttribute: AttributeSyntax? {
-        guard let standardizedIsolationType else {
-            return nil
+        if let standardizedIsolationType {
+            return AttributeSyntax(attributeName: standardizedIsolationType)
         }
-        return AttributeSyntax(attributeName: standardizedIsolationType)
+        return nil
     }
 }
 

Sources/PrincipleMacros/Syntax/Extensions/ClassDeclSyntax.swift

@@ -0,0 +1,56 @@
+//
+//  ClassDeclSyntax.swift
+//  PrincipleMacros
+//
+//  Created by Kamil Strzelecki on 21/11/2025.
+//  Copyright © 2025 Kamil Strzelecki. All rights reserved.
+//
+
+import SwiftSyntaxMacros
+
+extension ClassDeclSyntax {
+
+    public func inferredSuperclass() -> TypeSyntax? {
+        let superclassFinder = SuperclassFinder(for: self)
+        return superclassFinder.find()?.trimmed
+    }
+}
+
+extension ClassDeclSyntax {
+
+    private final class SuperclassFinder: SyntaxVisitor {
+
+        private let classDecl: ClassDeclSyntax
+        private var didFind = false
+
+        init(for classDecl: ClassDeclSyntax) {
+            self.classDecl = classDecl
+            super.init(viewMode: .sourceAccurate)
+        }
+
+        func find() -> TypeSyntax? {
+            guard let inheritanceClause = classDecl.inheritanceClause,
+                  let firstInheritedType = inheritanceClause.inheritedTypes.first?.type
+            else {
+                return nil
+            }
+
+            walk(classDecl)
+            return didFind ? firstInheritedType : nil
+        }
+
+        override func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {
+            node == classDecl ? .visitChildren : .skipChildren
+        }
+
+        override func visit(_ node: DeclModifierSyntax) -> SyntaxVisitorContinueKind {
+            didFind = didFind || node.overrideSpecifier != nil
+            return .visitChildren
+        }
+
+        override func visit(_: SuperExprSyntax) -> SyntaxVisitorContinueKind {
+            didFind = true
+            return .visitChildren
+        }
+    }
+}

Sources/PrincipleMacros/Syntax/Extensions/ExprSyntax.swift

@@ -66,10 +66,14 @@ extension StringLiteralExprSyntax {
 extension OptionalChainingExprSyntax {
 
     public var inferredType: TypeSyntax? {
-        guard let inferredType = expression.inferredType else {
+        guard let inferredWrappedType else {
             return nil
         }
-        return "Optional<\(inferredType)>"
+        return "Optional<\(inferredWrappedType)>"
+    }
+
+    public var inferredWrappedType: TypeSyntax? {
+        expression.inferredType
     }
 }
 
@@ -134,10 +138,6 @@ extension GenericSpecializationExprSyntax {
 
 extension MemberAccessExprSyntax {
 
-    public var referencesBaseType: Bool {
-        declName.baseName.tokenKind == .keyword(.self)
-    }
-
     public var inferredType: TypeSyntax? {
         guard let first = base?.inferredType else {
             return nil
@@ -147,6 +147,10 @@ extension MemberAccessExprSyntax {
         }
         return first
     }
+
+    public var referencesBaseType: Bool {
+        declName.baseName.tokenKind == .keyword(.self)
+    }
 }
 
 extension DeclReferenceExprSyntax {