[CodeGenLib] SourceGenerator public API

Motivation:

The SourceGenerator is responsible for transforming the CodeGenerationRequest input into a SourceFile object.

Modifications:

- created the public SourceGenerator struct that contains a Configuration struct (visibility level + indentation)
and the `generate()` function.
- the `generate()` function translates the input object into a StructuredSwiftRepresentation oject, then renders the
latter into a SourceFile object.
- modified tests to include Visibility.

Result:

The user can now generate a SourceFile that contains generated code, using a CodeGenerationRequest object and the SourceGenerator API.

Author: stefanadranca

Sources/GRPCCodeGen/Internal/Renderer/TextBasedRenderer.swift

@@ -40,14 +40,18 @@ final class StringCodeWriter {
   /// The current nesting level.
   private var level: Int
 
+  /// The indentation for each level as the number of spaces.
+  internal let indentation: Int
+
   /// Whether the next call to `writeLine` will continue writing to the last
   /// stored line. Otherwise a new line is appended.
   private var nextWriteAppendsToLastLine: Bool = false
 
   /// Creates a new empty writer.
-  init() {
+  init(indentation: Int) {
     self.level = 0
     self.lines = []
+    self.indentation = indentation
   }
 
   /// Concatenates the stored lines of code into a single string.
@@ -67,7 +71,7 @@ final class StringCodeWriter {
       let existingLine = lines.removeLast()
       newLine = existingLine + line
     } else {
-      let indentation = Array(repeating: " ", count: 4 * level).joined()
+      let indentation = Array(repeating: " ", count: self.indentation * level).joined()
       newLine = indentation + line
     }
     lines.append(newLine)
@@ -119,7 +123,11 @@ struct TextBasedRenderer: RendererProtocol {
   private let writer: StringCodeWriter
 
   /// Creates a new empty renderer.
-  static var `default`: TextBasedRenderer { .init(writer: StringCodeWriter()) }
+  static var `default`: TextBasedRenderer { .init(indentation: 4) }
+
+  init(indentation: Int) {
+    self.writer = StringCodeWriter(indentation: indentation)
+  }
 
   // MARK: - Internals
 

Sources/GRPCCodeGen/Internal/StructuredSwiftRepresentation.swift

@@ -344,7 +344,7 @@ struct WhereClause: Equatable, Codable {
 struct ExtensionDescription: Equatable, Codable {
 
   /// An access modifier.
-  var accessModifier: AccessModifier?
+  var accessModifier: AccessModifier? = nil
 
   /// The name of the extended type.
   ///
@@ -694,6 +694,7 @@ struct ClosureSignatureDescription: Equatable, Codable {
   /// The ``@escaping`` attribute.
   var escaping: Bool = false
 }
+
 /// A description of the associated value of an enum case.
 ///
 /// For example, in `case foo(bar: String)`, the associated value
@@ -1385,7 +1386,7 @@ extension Declaration {
   ///   extended type.
   /// - Returns: An extension declaration.
   static func `extension`(
-    accessModifier: AccessModifier?,
+    accessModifier: AccessModifier? = nil,
     onType: String,
     conformances: [String] = [],
     whereClause: WhereClause? = nil,

Sources/GRPCCodeGen/Internal/Translator/ClientCodeTranslator.swift

@@ -42,12 +42,12 @@
 ///       body
 ///     )
 /// }
-/// struct foo_BarClient: foo.Bar.ClientProtocol {
-///   let client: GRPCCore.GRPCClient
-///   init(client: GRPCCore.GRPCClient) {
+/// public struct foo_BarClient: foo.Bar.ClientProtocol {
+///   private let client: GRPCCore.GRPCClient
+///   public init(client: GRPCCore.GRPCClient) {
 ///     self.client = client
 ///   }
-///   func methodA<R: Sendable>(
+///   public func methodA<R: Sendable>(
 ///     request: ClientRequest.Stream<namespaceA.ServiceA.Methods.methodA.Input>,
 ///     serializer: some MessageSerializer<namespaceA.ServiceA.Methods.methodA.Input>,
 ///     deserializer: some MessageDeserializer<namespaceA.ServiceA.Methods.methodA.Output>,
@@ -64,6 +64,12 @@
 /// }
 ///```
 struct ClientCodeTranslator: SpecializedTranslator {
+  var accessLevel: SourceGenerator.Configuration.AccessLevel
+
+  init(accessLevel: SourceGenerator.Configuration.AccessLevel) {
+    self.accessLevel = accessLevel
+  }
+
   func translate(from codeGenerationRequest: CodeGenerationRequest) throws -> [CodeBlock] {
     var codeBlocks = [CodeBlock]()
 
@@ -108,6 +114,7 @@ extension ClientCodeTranslator {
 
     let clientProtocol = Declaration.protocol(
       ProtocolDescription(
+        accessModifier: self.accessModifier,
         name: "\(service.namespacedPrefix)ClientProtocol",
         conformances: ["Sendable"],
         members: methods
@@ -125,7 +132,8 @@ extension ClientCodeTranslator {
         for: $0,
         in: service,
         from: codeGenerationRequest,
-        generateSerializerDeserializer: true
+        generateSerializerDeserializer: true,
+        accessModifier: self.accessModifier
       )
     }
     let clientProtocolExtension = Declaration.extension(
@@ -141,7 +149,8 @@ extension ClientCodeTranslator {
     for method: CodeGenerationRequest.ServiceDescriptor.MethodDescriptor,
     in service: CodeGenerationRequest.ServiceDescriptor,
     from codeGenerationRequest: CodeGenerationRequest,
-    generateSerializerDeserializer: Bool
+    generateSerializerDeserializer: Bool,
+    accessModifier: AccessModifier? = nil
   ) -> Declaration {
     let methodParameters = self.makeParameters(
       for: method,
@@ -150,6 +159,7 @@ extension ClientCodeTranslator {
       generateSerializerDeserializer: generateSerializerDeserializer
     )
     let functionSignature = FunctionSignatureDescription(
+      accessModifier: accessModifier,
       kind: .function(
         name: method.name,
         isStatic: false
@@ -303,6 +313,7 @@ extension ClientCodeTranslator {
     in codeGenerationRequest: CodeGenerationRequest
   ) -> Declaration {
     let clientProperty = Declaration.variable(
+      accessModifier: .private,
       kind: .let,
       left: "client",
       type: .member(["GRPCCore", "GRPCClient"])
@@ -317,6 +328,7 @@ extension ClientCodeTranslator {
 
     return .struct(
       StructDescription(
+        accessModifier: self.accessModifier,
         name: "\(service.namespacedPrefix)Client",
         conformances: ["\(service.namespacedTypealiasPrefix).ClientProtocol"],
         members: [clientProperty, initializer] + methods
@@ -333,6 +345,7 @@ extension ClientCodeTranslator {
     )
     return .function(
       signature: .init(
+        accessModifier: self.accessModifier,
         kind: .initializer,
         parameters: [.init(label: "client", type: .member(["GRPCCore", "GRPCClient"]))]
       ),
@@ -394,6 +407,7 @@ extension ClientCodeTranslator {
     )
 
     return .function(
+      accessModifier: self.accessModifier,
       kind: .function(
         name: "\(method.name)",
         isStatic: false

Sources/GRPCCodeGen/Internal/Translator/IDLToStructuredSwiftTranslator.swift

@@ -14,14 +14,23 @@
  * limitations under the License.
  */
 
+/// Creates a representation for the server and client code, as well as for the enums containing useful type aliases and properties.
+/// The representation is generated based on the ``CodeGenerationRequest`` object and user specifications,
+/// using types from ``StructuredSwiftRepresentation``.
 struct IDLToStructuredSwiftTranslator: Translator {
   func translate(
     codeGenerationRequest: CodeGenerationRequest,
+    accessLevel: SourceGenerator.Configuration.AccessLevel,
     client: Bool,
     server: Bool
   ) throws -> StructuredSwiftRepresentation {
     try self.validateInput(codeGenerationRequest)
-    let typealiasTranslator = TypealiasTranslator(client: client, server: server)
+    let typealiasTranslator = TypealiasTranslator(
+      client: client,
+      server: server,
+      accessLevel: accessLevel
+    )
+
     let topComment = Comment.doc(codeGenerationRequest.leadingTrivia)
     let imports = try codeGenerationRequest.dependencies.reduce(
       into: [ImportDescription(moduleName: "GRPCCore")]
@@ -35,14 +44,14 @@ struct IDLToStructuredSwiftTranslator: Translator {
     )
 
     if server {
-      let serverCodeTranslator = ServerCodeTranslator()
+      let serverCodeTranslator = ServerCodeTranslator(accessLevel: accessLevel)
       codeBlocks.append(
         contentsOf: try serverCodeTranslator.translate(from: codeGenerationRequest)
       )
     }
 
     if client {
-      let clientCodeTranslator = ClientCodeTranslator()
+      let clientCodeTranslator = ClientCodeTranslator(accessLevel: accessLevel)
       codeBlocks.append(
         contentsOf: try clientCodeTranslator.translate(from: codeGenerationRequest)
       )

Sources/GRPCCodeGen/Internal/Translator/ServerCodeTranslator.swift

@@ -54,6 +54,12 @@
 /// }
 ///```
 struct ServerCodeTranslator: SpecializedTranslator {
+  var accessLevel: SourceGenerator.Configuration.AccessLevel
+
+  init(accessLevel: SourceGenerator.Configuration.AccessLevel) {
+    self.accessLevel = accessLevel
+  }
+
   func translate(from codeGenerationRequest: CodeGenerationRequest) throws -> [CodeBlock] {
     var codeBlocks = [CodeBlock]()
     for service in codeGenerationRequest.services {
@@ -112,6 +118,7 @@ extension ServerCodeTranslator {
 
     let streamingProtocol = Declaration.protocol(
       .init(
+        accessModifier: self.accessModifier,
         name: self.protocolName(service: service, streaming: true),
         conformances: ["GRPCCore.RegistrableRPCService"],
         members: methods
@@ -123,9 +130,11 @@ extension ServerCodeTranslator {
 
   private func makeStreamingMethodSignature(
     for method: CodeGenerationRequest.ServiceDescriptor.MethodDescriptor,
-    in service: CodeGenerationRequest.ServiceDescriptor
+    in service: CodeGenerationRequest.ServiceDescriptor,
+    accessModifier: AccessModifier? = nil
   ) -> FunctionSignatureDescription {
     return FunctionSignatureDescription(
+      accessModifier: accessModifier,
       kind: .function(name: method.name),
       parameters: [
         .init(
@@ -157,7 +166,6 @@ extension ServerCodeTranslator {
     let streamingProtocol = self.protocolNameTypealias(service: service, streaming: true)
     let registerRPCMethod = self.makeRegisterRPCsMethod(for: service, in: codeGenerationRequest)
     return .extension(
-      accessModifier: .public,
       onType: streamingProtocol,
       declarations: [registerRPCMethod]
     )
@@ -168,7 +176,8 @@ extension ServerCodeTranslator {
     in codeGenerationRequest: CodeGenerationRequest
   ) -> Declaration {
     let registerRPCsSignature = FunctionSignatureDescription(
-      kind: .function(name: "registerRPCs"),
+      accessModifier: self.accessModifier,
+      kind: .function(name: "registerMethods"),
       parameters: [
         .init(
           label: "with",
@@ -280,14 +289,20 @@ extension ServerCodeTranslator {
     return .commentable(
       .doc(service.documentation),
       .protocol(
-        ProtocolDescription(name: protocolName, conformances: [streamingProtocol], members: methods)
+        ProtocolDescription(
+          accessModifier: self.accessModifier,
+          name: protocolName,
+          conformances: [streamingProtocol],
+          members: methods
+        )
       )
     )
   }
 
   private func makeServiceProtocolMethod(
     for method: CodeGenerationRequest.ServiceDescriptor.MethodDescriptor,
-    in service: CodeGenerationRequest.ServiceDescriptor
+    in service: CodeGenerationRequest.ServiceDescriptor,
+    accessModifier: AccessModifier? = nil
   ) -> Declaration {
     let inputStreaming = method.isInputStreaming ? "Stream" : "Single"
     let outputStreaming = method.isOutputStreaming ? "Stream" : "Single"
@@ -304,6 +319,7 @@ extension ServerCodeTranslator {
     )
 
     let functionSignature = FunctionSignatureDescription(
+      accessModifier: accessModifier,
       kind: .function(name: method.name),
       parameters: [
         .init(
@@ -338,7 +354,10 @@ extension ServerCodeTranslator {
     }
 
     let protocolName = self.protocolNameTypealias(service: service, streaming: false)
-    return .extension(accessModifier: .public, onType: protocolName, declarations: methods)
+    return .extension(
+      onType: protocolName,
+      declarations: methods
+    )
   }
 
   private func makeServiceProtocolExtensionMethod(
@@ -354,7 +373,11 @@ extension ServerCodeTranslator {
     let returnStatement = CodeBlock(item: .expression(self.makeReturnStatement(for: method)))
 
     return .function(
-      signature: self.makeStreamingMethodSignature(for: method, in: service),
+      signature: self.makeStreamingMethodSignature(
+        for: method,
+        in: service,
+        accessModifier: self.accessModifier
+      ),
       body: [response, returnStatement]
     )
   }

Sources/GRPCCodeGen/Internal/Translator/SpecializedTranslator.swift

@@ -17,6 +17,10 @@
 /// Represents one responsibility of the ``Translator``: either the type aliases translation,
 /// the server code translation or the client code translation.
 protocol SpecializedTranslator {
+
+  /// The ``SourceGenerator.Configuration.AccessLevel`` object used to represent the visibility level used in the generated code.
+  var accessLevel: SourceGenerator.Configuration.AccessLevel { get }
+
   /// Generates an array of ``CodeBlock`` elements that will be part of the ``StructuredSwiftRepresentation`` object
   /// created by the ``Translator``.
   ///
@@ -27,3 +31,19 @@ protocol SpecializedTranslator {
   /// - SeeAlso: ``CodeGenerationRequest``, ``Translator``,  ``CodeBlock``.
   func translate(from codeGenerationRequest: CodeGenerationRequest) throws -> [CodeBlock]
 }
+
+extension SpecializedTranslator {
+  /// The access modifier that corresponds with the access level from ``SourceGenerator.Configuration``.
+  internal var accessModifier: AccessModifier {
+    get {
+      switch accessLevel.level {
+      case .internal:
+        return AccessModifier.internal
+      case .package:
+        return AccessModifier.package
+      case .public:
+        return AccessModifier.public
+      }
+    }
+  }
+}

Sources/GRPCCodeGen/Internal/Translator/Translator.swift

@@ -21,12 +21,14 @@ protocol Translator {
   /// Translates the provided ``CodeGenerationRequest`` object, into Swift code representation.
   /// - Parameters:
   ///   - codeGenerationRequest: The IDL described RPCs representation.
+  ///   - accessLevel: The access level that will restrict the protocols, extensions and methods in the generated code.
   ///   - client: Whether or not client code should be generated from the IDL described RPCs representation.
   ///   - server: Whether or not server code should be generated from the IDL described RPCs representation.
   /// - Returns: A structured Swift representation of the generated code.
   /// - Throws: An error if there are issues translating the codeGenerationRequest.
   func translate(
     codeGenerationRequest: CodeGenerationRequest,
+    accessLevel: SourceGenerator.Configuration.AccessLevel,
     client: Bool,
     server: Bool
   ) throws -> StructuredSwiftRepresentation