Use nested protocols

Motivation:

The minimum Swift version we require supports protocols being declared
within another type. This means that all protocols and types we generate
for a service can be declared within the enum namespace for that service
and we can remove the typealiases.

Modifications:

- Declare generated protocols within their enum namespace
- Inline generated service descriptors

Result:

Simpler generated code

Author: glbrntt

Sources/GRPCCodeGen/Internal/StructuredSwift+ServiceMetadata.swift

@@ -43,12 +43,12 @@ extension TypealiasDescription {
 extension VariableDescription {
   /// ```
   /// static let descriptor = GRPCCore.MethodDescriptor(
-  ///   service: <serviceNamespace>.descriptor.fullyQualifiedService,
+  ///   service: GRPCCore.ServiceDescriptor(fullyQualifiedServiceName: "<literalFullyQualifiedService>"),
   ///   method: "<literalMethodName>"
   /// ```
   package static func methodDescriptor(
     accessModifier: AccessModifier? = nil,
-    serviceNamespace: String,
+    literalFullyQualifiedService: String,
     literalMethodName: String
   ) -> Self {
     return VariableDescription(
@@ -62,9 +62,11 @@ extension VariableDescription {
           arguments: [
             FunctionArgumentDescription(
               label: "service",
-              expression: .identifierType(
-                .member([serviceNamespace, "descriptor"])
-              ).dot("fullyQualifiedService")
+              expression: .functionCall(
+                .serviceDescriptor(
+                  literalFullyQualifiedService: literalFullyQualifiedService
+                )
+              )
             ),
             FunctionArgumentDescription(
               label: "method",
@@ -77,18 +79,34 @@ extension VariableDescription {
   }
 
   /// ```
-  /// static let descriptor = GRPCCore.ServiceDescriptor.<namespacedProperty>
+  /// static let descriptor = GRPCCore.ServiceDescriptor(package: "...", service: "...")
   /// ```
   package static func serviceDescriptor(
     accessModifier: AccessModifier? = nil,
-    namespacedProperty: String
+    literalFullyQualifiedService name: String
   ) -> Self {
     return VariableDescription(
       accessModifier: accessModifier,
       isStatic: true,
       kind: .let,
       left: .identifierPattern("descriptor"),
-      right: .identifier(.type(.serviceDescriptor)).dot(namespacedProperty)
+      right: .functionCall(.serviceDescriptor(literalFullyQualifiedService: name))
+    )
+  }
+}
+
+extension FunctionCallDescription {
+  package static func serviceDescriptor(
+    literalFullyQualifiedService: String
+  ) -> Self {
+    FunctionCallDescription(
+      calledExpression: .identifier(.type(.serviceDescriptor)),
+      arguments: [
+        FunctionArgumentDescription(
+          label: "fullyQualifiedService",
+          expression: .literal(literalFullyQualifiedService)
+        )
+      ]
     )
   }
 }
@@ -97,16 +115,14 @@ extension ExtensionDescription {
   /// ```
   /// extension GRPCCore.ServiceDescriptor {
   ///   static let <PropertyName> = Self(
-  ///     package: "<LiteralNamespaceName>",
-  ///     service: "<LiteralServiceName>"
+  ///     fullyQualifiedService: <LiteralFullyQualifiedService>
   ///   )
   /// }
   /// ```
   package static func serviceDescriptor(
     accessModifier: AccessModifier? = nil,
     propertyName: String,
-    literalNamespace: String,
-    literalService: String
+    literalFullyQualifiedService: String
   ) -> ExtensionDescription {
     return ExtensionDescription(
       onType: "GRPCCore.ServiceDescriptor",
@@ -117,17 +133,7 @@ extension ExtensionDescription {
           kind: .let,
           left: .identifier(.pattern(propertyName)),
           right: .functionCall(
-            calledExpression: .identifierType(.member("Self")),
-            arguments: [
-              FunctionArgumentDescription(
-                label: "package",
-                expression: .literal(literalNamespace)
-              ),
-              FunctionArgumentDescription(
-                label: "service",
-                expression: .literal(literalService)
-              ),
-            ]
+            .serviceDescriptor(literalFullyQualifiedService: literalFullyQualifiedService)
           )
         )
       ]
@@ -169,7 +175,7 @@ extension EnumDescription {
     accessModifier: AccessModifier? = nil,
     name: String,
     literalMethod: String,
-    serviceNamespace: String,
+    literalFullyQualifiedService: String,
     inputType: String,
     outputType: String
   ) -> Self {
@@ -182,7 +188,7 @@ extension EnumDescription {
         .variable(
           .methodDescriptor(
             accessModifier: accessModifier,
-            serviceNamespace: serviceNamespace,
+            literalFullyQualifiedService: literalFullyQualifiedService,
             literalMethodName: literalMethod
           )
         ),
@@ -209,7 +215,7 @@ extension EnumDescription {
   /// ```
   package static func methodsNamespace(
     accessModifier: AccessModifier? = nil,
-    serviceNamespace: String,
+    literalFullyQualifiedService: String,
     methods: [MethodDescriptor]
   ) -> EnumDescription {
     var description = EnumDescription(accessModifier: accessModifier, name: "Method")
@@ -221,7 +227,7 @@ extension EnumDescription {
           accessModifier: accessModifier,
           name: method.name.base,
           literalMethod: method.name.base,
-          serviceNamespace: serviceNamespace,
+          literalFullyQualifiedService: literalFullyQualifiedService,
           inputType: method.inputType,
           outputType: method.outputType
         )
@@ -245,57 +251,31 @@ extension EnumDescription {
   ///   enum Method {
   ///     ...
   ///   }
-  ///   @available(...)
-  ///   typealias StreamingServiceProtocol = ...
-  ///   @available(...)
-  ///   typealias ServiceProtocol = ...
-  ///   ...
   /// }
   /// ```
   package static func serviceNamespace(
     accessModifier: AccessModifier? = nil,
     name: String,
-    serviceDescriptorProperty: String,
-    client: Bool,
-    server: Bool,
+    literalFullyQualifiedService: String,
     methods: [MethodDescriptor]
   ) -> EnumDescription {
     var description = EnumDescription(accessModifier: accessModifier, name: name)
 
-    // static let descriptor = GRPCCore.ServiceDescriptor.<namespacedServicePropertyName>
+    // static let descriptor = GRPCCore.ServiceDescriptor(fullyQualifiedService: "...")
     let descriptor = VariableDescription.serviceDescriptor(
       accessModifier: accessModifier,
-      namespacedProperty: serviceDescriptorProperty
+      literalFullyQualifiedService: literalFullyQualifiedService
     )
     description.members.append(.variable(descriptor))
 
     // enum Method { ... }
     let methodsNamespace: EnumDescription = .methodsNamespace(
       accessModifier: accessModifier,
-      serviceNamespace: name,
+      literalFullyQualifiedService: literalFullyQualifiedService,
       methods: methods
     )
     description.members.append(.enum(methodsNamespace))
 
-    // Typealiases for the various protocols.
-    var typealiasNames: [String] = []
-    if server {
-      typealiasNames.append("StreamingServiceProtocol")
-      typealiasNames.append("ServiceProtocol")
-    }
-    if client {
-      typealiasNames.append("ClientProtocol")
-      typealiasNames.append("Client")
-    }
-    let typealiases: [Declaration] = typealiasNames.map { alias in
-      .typealias(
-        accessModifier: accessModifier,
-        name: alias,
-        existingType: .member(name + "_" + alias)
-      )
-    }
-    description.members.append(contentsOf: typealiases)
-
     return description
   }
 }
@@ -312,27 +292,22 @@ extension [CodeBlock] {
   /// ```
   package static func serviceMetadata(
     accessModifier: AccessModifier? = nil,
-    service: ServiceDescriptor,
-    client: Bool,
-    server: Bool
+    service: ServiceDescriptor
   ) -> Self {
     var blocks: [CodeBlock] = []
 
     let serviceNamespace: EnumDescription = .serviceNamespace(
       accessModifier: accessModifier,
       name: service.namespacedGeneratedName,
-      serviceDescriptorProperty: service.namespacedServicePropertyName,
-      client: client,
-      server: server,
+      literalFullyQualifiedService: service.fullyQualifiedName,
       methods: service.methods
     )
     blocks.append(CodeBlock(item: .declaration(.enum(serviceNamespace))))
 
     let descriptorExtension: ExtensionDescription = .serviceDescriptor(
       accessModifier: accessModifier,
       propertyName: service.namespacedServicePropertyName,
-      literalNamespace: service.namespace.base,
-      literalService: service.name.base
+      literalFullyQualifiedService: service.fullyQualifiedName
     )
     blocks.append(CodeBlock(item: .declaration(.extension(descriptorExtension))))
 

Sources/GRPCCodeGen/Internal/Translator/ClientCodeTranslator.swift

@@ -86,25 +86,41 @@ struct ClientCodeTranslator {
   ) -> [CodeBlock] {
     var blocks = [CodeBlock]()
 
-    let protocolName = "\(service.namespacedGeneratedName)_ClientProtocol"
-    let protocolTypealias = "\(service.namespacedGeneratedName).ClientProtocol"
-    let structName = "\(service.namespacedGeneratedName)_Client"
+    let `extension` = ExtensionDescription(
+      onType: service.namespacedGeneratedName,
+      declarations: [
+        // protocol ClientProtocol { ... }
+        .commentable(
+          .preFormatted(service.documentation),
+          .protocol(
+            .clientProtocol(
+              accessLevel: accessModifier,
+              name: "ClientProtocol",
+              methods: service.methods
+            )
+          )
+        ),
 
-    let clientProtocol: ProtocolDescription = .clientProtocol(
-      accessLevel: accessModifier,
-      name: protocolName,
-      methods: service.methods
-    )
-    blocks.append(
-      CodeBlock(
-        comment: .preFormatted(service.documentation),
-        item: .declaration(.protocol(clientProtocol))
-      )
+        // struct Client: ClientProtocol { ... }
+        .commentable(
+          .preFormatted(service.documentation),
+          .struct(
+            .client(
+              accessLevel: accessModifier,
+              name: "Client",
+              serviceEnum: service.namespacedGeneratedName,
+              clientProtocol: "ClientProtocol",
+              methods: service.methods
+            )
+          )
+        ),
+      ]
     )
+    blocks.append(.declaration(.extension(`extension`)))
 
     let extensionWithDefaults: ExtensionDescription = .clientMethodSignatureWithDefaults(
       accessLevel: accessModifier,
-      name: protocolTypealias,
+      name: "\(service.namespacedGeneratedName).ClientProtocol",
       methods: service.methods,
       serializer: serializer,
       deserializer: deserializer
@@ -115,27 +131,13 @@ struct ClientCodeTranslator {
 
     let extensionWithExplodedAPI: ExtensionDescription = .explodedClientMethods(
       accessLevel: accessModifier,
-      on: protocolTypealias,
+      on: "\(service.namespacedGeneratedName).ClientProtocol",
       methods: service.methods
     )
     blocks.append(
       CodeBlock(item: .declaration(.extension(extensionWithExplodedAPI)))
     )
 
-    let clientStruct: StructDescription = .client(
-      accessLevel: accessModifier,
-      name: structName,
-      serviceEnum: service.namespacedGeneratedName,
-      clientProtocol: protocolTypealias,
-      methods: service.methods
-    )
-    blocks.append(
-      CodeBlock(
-        comment: .preFormatted(service.documentation),
-        item: .declaration(.struct(clientStruct))
-      )
-    )
-
     return blocks
   }
 }

Sources/GRPCCodeGen/Internal/Translator/IDLToStructuredSwiftTranslator.swift

@@ -40,9 +40,7 @@ struct IDLToStructuredSwiftTranslator: Translator {
 
       let metadata = metadataTranslator.translate(
         accessModifier: accessModifier,
-        service: service,
-        client: client,
-        server: server
+        service: service
       )
       codeBlocks.append(contentsOf: metadata)
 

Sources/GRPCCodeGen/Internal/Translator/MetadataTranslator.swift

@@ -19,15 +19,8 @@ struct MetadataTranslator {
 
   func translate(
     accessModifier: AccessModifier,
-    service: ServiceDescriptor,
-    client: Bool,
-    server: Bool
+    service: ServiceDescriptor
   ) -> [CodeBlock] {
-    .serviceMetadata(
-      accessModifier: accessModifier,
-      service: service,
-      client: client,
-      server: server
-    )
+    .serviceMetadata(accessModifier: accessModifier, service: service)
   }
 }