Address code-review nitpicks

Author: Brennanium

Generator/Sources/Internal/Templates/MockTemplate.swift

@@ -16,7 +16,8 @@ extension Templates {
 extension {{ container.parentFullyQualifiedName }} {
 {% endif %}
 {% if container.hasPrimaryAssociatedTypes %}
-@available(iOS 16.0.0, macOS 13.0.0, watchOS 9.0, tvOS 16, *) // runtime support for constrained protocols with primary associated types
+// runtime support for constrained protocols with primary associated types
+@available(iOS 16, macOS 13, watchOS 9, tvOS 16, *)
 {% endif %}
 {{ container.accessibility|withSpace }}class {{ container.mockName }}{{ container.genericParameters }}:{% if container.isNSObjectProtocol %} NSObject,{% endif %} {{ container.name }}{% if container.isImplementation %}{{ container.genericArguments }}{% endif %},{% if container.isImplementation %} Cuckoo.ClassMock{% else %} Cuckoo.ProtocolMock{% endif %}, @unchecked Sendable {
     {% if container.isGeneric and not container.isImplementation and not container.hasOnlyPrimaryAssociatedTypes %}

Generator/Sources/Internal/Tokens/Capabilities/HasGenerics.swift

@@ -31,15 +31,17 @@ extension HasGenerics {
     }
 
     func genericsSerialize() -> GeneratorContext {
-        var genericProtocolIdentity: String?
-        var genericPrimaryAssociatedTypeArguments: String?
-        
-        if let protocolDeclaration = asProtocol {
-            genericProtocolIdentity = genericParameters.map { "\(Templates.staticGenericParameter).\($0.name) == \($0.name)" }.joined(separator: ", ")
-            if !protocolDeclaration.primaryAssociatedTypes.isEmpty {
-                let arguments = protocolDeclaration.primaryAssociatedTypes.map { $0.name }.joined(separator: ", ")
-                genericPrimaryAssociatedTypeArguments = "<\(arguments)>"
-            }
+        let genericProtocolIdentity = isProtocol
+            ? genericParameters
+                .map { "\(Templates.staticGenericParameter).\($0.name) == \($0.name)" }
+                .joined(separator: ", ")
+            : nil
+        let genericPrimaryAssociatedTypeArguments: String?
+        if let protocolDeclaration = asProtocol, hasPrimaryAssociatedTypes {
+            let arguments = protocolDeclaration.primaryAssociatedTypes.map { $0.name }.joined(separator: ", ")
+            genericPrimaryAssociatedTypeArguments = "<\(arguments)>"
+        } else {
+            genericPrimaryAssociatedTypeArguments = nil
         }
 
         return [

Generator/Sources/Internal/Tokens/ComplexType.swift

@@ -244,16 +244,16 @@ extension ComplexType {
 
     func replaceType(named typeName: String, with replacement: String) -> ComplexType? {
         switch self {
-        case .attributed(attributes: let attributes, baseType: let baseType):
+        case .attributed(let attributes, let baseType):
             return baseType.replaceType(named: typeName, with: replacement)
                 .map { ComplexType.attributed(attributes: attributes, baseType: $0) }
-        case .optional(wrappedType: let wrappedType, isImplicit: let isImplicit):
+        case .optional(let wrappedType, let isImplicit):
             return wrappedType.replaceType(named: typeName, with: replacement)
                 .map { ComplexType.optional(wrappedType: $0, isImplicit: isImplicit) }
-        case .array(elementType: let elementType):
+        case .array(let elementType):
             return elementType.replaceType(named: typeName, with: replacement)
                 .map { ComplexType.array(elementType: $0) }
-        case .dictionary(keyType: let keyType, valueType: let valueType):
+        case .dictionary(let keyType, let valueType):
             let newKey = keyType.replaceType(named: typeName, with: replacement)
             let newValue = valueType.replaceType(named: typeName, with: replacement)
             if newKey == nil && newValue == nil { return nil }
@@ -294,13 +294,13 @@ extension ComplexType {
 
     func containsType(named typeName: String) -> Bool {
         switch self {
-        case .attributed(attributes: _, baseType: let baseType):
+        case .attributed(_, let baseType):
             baseType.containsType(named: typeName)
-        case .optional(wrappedType: let wrappedType, isImplicit: _):
+        case .optional(let wrappedType, _):
             wrappedType.containsType(named: typeName)
-        case .array(elementType: let elementType):
+        case .array(let elementType):
             elementType.containsType(named: typeName)
-        case .dictionary(keyType: let keyType, valueType: let valueType):
+        case .dictionary(let keyType, let valueType):
             keyType.containsType(named: typeName) || valueType.containsType(named: typeName)
         case .closure(let closure):
             (closure.parameters.map(\.type) + [closure.returnType]).contains(where: { $0.containsType(named: typeName)})

Generator/Sources/Internal/Tokens/Method.swift

@@ -74,20 +74,21 @@ extension Method {
             .map(\.call)
             .joined(separator: ", ")
 
-        var staticGenericCall = "(\(call))"
-            
+        let staticGenericCall: String
         if let parent = parent.asProtocol, !parent.nonPrimaryAssociatedTypes.isEmpty {
             let nonPrimary = parent.nonPrimaryAssociatedTypes.map(\.name)
 
             let staticGenericCallableParameters = signature.parameters
                 .map { $0.callAndCastTypes(named: nonPrimary, as: { Templates.staticGenericParameter + ".\($0)" }) }
                 .joined(separator: ", ")
 
-            staticGenericCall = "(\(staticGenericCallableParameters))"
-            
-            if let returnType, returnType.containsTypes(named: nonPrimary) {
-                staticGenericCall = staticGenericCall.forceCast(as: returnType)
+            staticGenericCall = if let returnType, returnType.containsTypes(named: nonPrimary) {
+                "(\(staticGenericCallableParameters))".forceCast(as: returnType)
+            } else {
+                "(\(staticGenericCallableParameters))"
             }
+        } else {
+            staticGenericCall = "(\(call))"
         }
 
         let stubFunctionPrefix = parent.isClass ? "Class" : "Protocol"