Merge branch 'develop'

Author: helje5

Package.swift

@@ -5,16 +5,12 @@ import CompilerPluginSupport
 let package = Package(
   name: "ManagedModels",
 
-  // For now :-)
-  // macOS v13 needed to build the macro on macOS 13! (for iOS)
-  platforms: [ .macOS(.v11), .iOS(.v14), .tvOS(.v15), .watchOS(.v8) ],
+  platforms: [ .macOS(.v11), .iOS(.v13), .tvOS(.v13), .watchOS(.v6) ],
   products: [
     .library(name: "ManagedModels", targets: [ "ManagedModels" ])
   ],
   dependencies: [
-    // Depend on the latest Swift 5.9 prerelease of SwiftSyntax
-    .package(url: "https://github.com/apple/swift-syntax.git", 
-             from: "509.0.0-swift-5.9-DEVELOPMENT-SNAPSHOT-2023-04-25-b"),
+    .package(url: "https://github.com/apple/swift-syntax.git", from: "509.0.0")
   ],
   targets: [
     .target(name: "ManagedModels", dependencies: [ "ManagedModelMacros" ]),
@@ -27,13 +23,11 @@ let package = Package(
       ]
     ),
 
-    // A test target used to develop the macro implementation.
     .testTarget(
       name: "ManagedModelTests",
       dependencies: [ "ManagedModels" ]
     ),
 
-    // A test target used to develop the macro implementation.
     .testTarget(
       name: "ManagedModelMacrosTests",
       dependencies: [

Sources/ManagedModelMacros/ModelMacro/ModelMacro.swift

@@ -4,14 +4,4 @@
 //
 
 public enum ModelMacro {
-  /*
-   @attached(member, ...)
-   @attached(memberAttribute)
-   @attached(extension, conformances: // the protocols we add automagically
-     PersistentModel
-   )
-   
-   Note: @Model does not support `originalName`/`renamingIdentifier`?
-         We could. Some for that versionHash thing.
-   */
 }

Sources/ManagedModelMacros/ModelMacro/ModelMembers.swift

@@ -49,15 +49,10 @@ extension ModelMacro: MemberMacro { // @attached(member, names:...)
       initializers: findInitializers(in: classDecl)
     )
 
-    let needsFR : Bool = {
-      guard let f = classDecl
-        .findFunctionWithName("fetchRequest", isStatic: true) else
-      {
-        return true
-      }
-      return f.parameterCount != 0
-    }()
-    if needsFR {
+    if classDecl.findFunctionWithName("fetchRequest", isStaticOrClass: true,
+                                      numberOfParametersWithoutDefaults: 0)
+       == nil
+    {
       let modelClassName = modelClassName.text
       newMembers.append(
         """
@@ -78,13 +73,9 @@ extension ModelMacro: MemberMacro { // @attached(member, names:...)
     )
     newMembers.append(DeclSyntax(metadata))
 
-    let needsEntity : Bool = {
-      guard let f = classDecl.findFunctionWithName("entity", isStatic: true) else {
-        return true
-      }
-      return f.parameterCount != 0
-    }()
-    if needsEntity {
+    if classDecl.findFunctionWithName("entity", isStaticOrClass: true,
+                                      parameterCount: 0) == nil
+    {
       newMembers.append(
         """
         /// Returns the `NSEntityDescription` associated w/ the `PersistentModel`.

Sources/ManagedModelMacros/Models/ModelInitializers.swift

@@ -13,14 +13,18 @@ struct ModelInitializer {
 
   /// Just the keyword parts of the selector, empty for wildcard.
   let parameterKeywords : [ String ]
+  
+  let numberOfParametersWithoutDefaults : Int
 }
 
 extension Collection where Element == ModelInitializer {
 
+  /// Either has a plain `init()` or an init that has all parameters w/ a
+  /// default (e.g. `init(title: String = "")`) which can be called w/o
+  /// specifying parameters.
   var hasNoArgumentInitializer: Bool {
-    // TBD: should also check for default arguments!!
     guard !self.isEmpty else { return false }
-    return self.contains(where: { $0.parameterKeywords.isEmpty })
+    return self.contains(where: { $0.numberOfParametersWithoutDefaults == 0 })
   }
 
   var hasDesignatedInitializers: Bool {
@@ -54,17 +58,23 @@ extension ModelMacro {
         continue
       }
 
+      var numberOfParametersWithoutDefaults = 0
       var keywords = [ String ]()
       for parameter : FunctionParameterSyntax
             in initDecl.signature.parameterClause.parameters
       {
         if parameter.firstName.tokenKind == .wildcard { keywords.append("") }
         else { keywords.append(parameter.firstName.trimmedDescription) }
+        
+        if parameter.defaultValue == nil {
+          numberOfParametersWithoutDefaults += 1
+        }
       }
 
       initializers.append(ModelInitializer(
         isConvenience: initDecl.isConvenience,
-        parameterKeywords: keywords
+        parameterKeywords: keywords,
+        numberOfParametersWithoutDefaults: numberOfParametersWithoutDefaults
       ))
     }
     return initializers

Sources/ManagedModelMacros/Utilities/ClassDeclSyntax+Extras.swift

@@ -0,0 +1,69 @@
+//
+//  Created by Helge Heß.
+//  Copyright © 2023 ZeeZide GmbH.
+//
+
+import SwiftSyntax
+
+extension ClassDeclSyntax {
+  
+  var isPublicOrOpen : Bool { modifiers.containsPublicOrOpen }
+  
+  var publicOrOpenModifier : DeclModifierListSyntax.Element? {
+    modifiers.publicOrOpenModifier
+  }
+}
+
+extension ClassDeclSyntax {
+  
+  var inheritedTypeNames : Set<String> {
+    // The protocol types in like (as a workaround for protocols below)
+    //   `class Model: Codable, CustomStringConvertible`
+    var inheritedTypeNames = Set<String>()
+    if let inheritedTypes = inheritanceClause?.inheritedTypes {
+      for type : InheritedTypeSyntax in inheritedTypes {
+        let typeSyntax : TypeSyntax = type.type
+        if let id = typeSyntax.as(IdentifierTypeSyntax.self) {
+          inheritedTypeNames.insert(id.name.trimmed.text)
+        }
+      }
+    }
+    return inheritedTypeNames
+  }
+}
+
+extension ClassDeclSyntax {
+
+  func findFunctionWithName(_ name: String, isStaticOrClass: Bool,
+                            parameterCount: Int? = nil,
+                            numberOfParametersWithoutDefaults: Int? = nil)
+       -> FunctionDeclSyntax?
+  {
+    for member : MemberBlockItemSyntax in memberBlock.members {
+      guard let funcDecl = member.decl.as(FunctionDeclSyntax.self) else {
+        continue
+      }
+      let hasStatic = funcDecl.modifiers.containsStaticOrClass
+      guard hasStatic == isStaticOrClass else { continue }
+
+      if let parameterCount {
+        guard parameterCount == funcDecl.parameterCount else { continue }
+      }
+      if let numberOfParametersWithoutDefaults {
+        guard numberOfParametersWithoutDefaults ==
+                funcDecl.numberOfParametersWithoutDefaults else { continue }
+      }
+
+      // filter out operators and different names
+      guard case .identifier(let idName) = funcDecl.name.tokenKind,
+            idName == name else
+      {
+        continue
+      }
+      
+      // Found it
+      return funcDecl
+    }
+    return nil
+  }
+}

Sources/ManagedModelMacros/Utilities/DeclHelpers.swift

@@ -7,109 +7,40 @@ import SwiftSyntax
 
 extension VariableDeclSyntax {
 
-  var isStaticOrClass : Bool {
-    modifiers.contains {
-      switch $0.name.tokenKind {
-        case .keyword(.static) : return true
-        case .keyword(.class)  : return true
-        default: return false
-      }
-    }
-  }
-  
-  var isPublicOrOpen : Bool { modifiers.containsPublicOrOpen }
+  var isStaticOrClass : Bool { modifiers.containsStaticOrClass }
+  var isPublicOrOpen  : Bool { modifiers.containsPublicOrOpen  }
 }
 
 extension InitializerDeclSyntax {
-  var isConvenience : Bool { modifiers.convenienceModifier != nil }
-}
-
-extension FunctionDeclSyntax {
 
-  var parameterCount : Int {
-    signature.parameterClause.parameters.count
+  var isConvenience : Bool {
+    modifiers.contains { $0.name.tokenKind == .keyword(.convenience) }
   }
-}
-
-extension ClassDeclSyntax {
 
-  var isPublicOrOpen : Bool { modifiers.containsPublicOrOpen }
-  var publicOrOpenModifier : DeclModifierListSyntax.Element? {
-    modifiers.publicOrOpenModifier
-  }
+  var parameterCount : Int { signature.parameterClause.parameters.count }
 
-  var inheritedTypeNames : Set<String> {
-    // The protocol types in like (as a workaround for protocols below)
-    //   `class Model: Codable, CustomStringConvertible`
-    var inheritedTypeNames = Set<String>()
-    if let inheritedTypes = inheritanceClause?.inheritedTypes {
-      for type : InheritedTypeSyntax in inheritedTypes {
-        let typeSyntax : TypeSyntax = type.type
-        if let id = typeSyntax.as(IdentifierTypeSyntax.self) {
-          inheritedTypeNames.insert(id.name.trimmed.text)
-        }
-      }
-    }
-    return inheritedTypeNames
-  }
-  
-  func findFunctionWithName(_ name: String, isStatic: Bool)
-       -> FunctionDeclSyntax?
-  {
-    for member : MemberBlockItemSyntax in memberBlock.members {
-      guard let funcDecl = member.decl.as(FunctionDeclSyntax.self) else {
-        continue
-      }
-      let hasStatic = funcDecl.modifiers.contains(.static)
-      guard hasStatic == isStatic else { continue }
-
-      switch funcDecl.name.tokenKind {
-        case .identifier(_):
-          return funcDecl
-        default: // operator
-          return nil
-      }
-    }
-    return nil
+  var numberOfParametersWithoutDefaults : Int {
+    signature.parameterClause.parameters.numberOfParametersWithoutDefaults
   }
 }
 
-extension DeclModifierListSyntax {
+extension FunctionDeclSyntax {
 
-  var modifiers : Set<Keyword> {
-    var modifiers = Set<Keyword>()
-    for modifier in self {
-      guard case .keyword(let keyword) = modifier.name.tokenKind else {
-        continue
-      }
-      modifiers.insert(keyword)
-    }
-    return modifiers
-  }
+  var parameterCount : Int { signature.parameterClause.parameters.count }
 
-  func contains(_ keyword: Keyword) -> Bool {
-    for modifier in self {
-      guard case .keyword(let keywordMember) = modifier.name.tokenKind else {
-        continue
-      }
-      if keyword == keywordMember { return true }
-    }
-    return false
+  var numberOfParametersWithoutDefaults : Int {
+    signature.parameterClause.parameters.numberOfParametersWithoutDefaults
   }
+}
+
+extension FunctionParameterListSyntax {
 
-  var publicOrOpenModifier : Element? {
-    self.first {
-      switch $0.name.tokenKind {
-        case .keyword(.public) : return true
-        case .keyword(.open)   : return true
-        default: return false
-      }
+  var numberOfParametersWithoutDefaults : Int {
+    var count = 0
+    for parameter : FunctionParameterSyntax in self {
+      guard parameter.defaultValue == nil else { continue }
+      count += 1
     }
+    return count
   }
-
-  var convenienceModifier : Element? {
-    self.first { $0.name.tokenKind == .keyword(.convenience) }
-  }
-
-  var containsPublicOrOpen : Bool { publicOrOpenModifier != nil }
 }

Sources/ManagedModelMacros/Utilities/DeclModifierListSyntax+Extras.swift

@@ -0,0 +1,52 @@
+//
+//  Created by Helge Heß.
+//  Copyright © 2023 ZeeZide GmbH.
+//
+
+import SwiftSyntax
+
+extension DeclModifierListSyntax {
+  
+  var modifiers : Set<Keyword> {
+    var modifiers = Set<Keyword>()
+    for modifier in self {
+      guard case .keyword(let keyword) = modifier.name.tokenKind else {
+        continue
+      }
+      modifiers.insert(keyword)
+    }
+    return modifiers
+  }
+  
+  func contains(_ keyword: Keyword) -> Bool {
+    for modifier in self {
+      guard case .keyword(let keywordMember) = modifier.name.tokenKind else {
+        continue
+      }
+      if keyword == keywordMember { return true }
+    }
+    return false
+  }
+  
+  var publicOrOpenModifier : Element? {
+    self.first {
+      switch $0.name.tokenKind {
+        case .keyword(.public) : return true
+        case .keyword(.open)   : return true
+        default: return false
+      }
+    }
+  }
+    
+  var containsPublicOrOpen : Bool { publicOrOpenModifier != nil }
+  
+  var containsStaticOrClass : Bool {
+    contains {
+      switch $0.name.tokenKind {
+        case .keyword(.static) : return true
+        case .keyword(.class)  : return true
+        default: return false
+      }
+    }
+  }
+}