Move the plugin over to the new helpers.

Author: thomasvl

Sources/protoc-gen-swift/GenerationError.swift

@@ -15,4 +15,19 @@ enum GenerationError: Error {
   case invalidParameterValue(name: String, value: String)
   /// Raised to wrap another error but provide a context message.
   case wrappedError(message: String, error: Error)
+  /// Raised with an specific message
+  case message(message: String)
+
+  var description: String {
+    switch self {
+    case .unknownParameter(let name):
+      return "Unknown generation parameter '\(name)'"
+    case .invalidParameterValue(let name, let value):
+      return "Unknown value for generation parameter '\(name)': '\(value)'"
+    case .wrappedError(let message, let error):
+      return "\(message): \(error)"
+    case .message(let message):
+      return message
+    }
+  }
 }

Sources/protoc-gen-swift/GeneratorOptions.swift

@@ -57,14 +57,14 @@ class GeneratorOptions {
   /// A string snippet to insert for the visibility
   let visibilitySourceSnippet: String
 
-  init(parameter: String?) throws {
+  init(parameter: CodeGeneratorParameter) throws {
     var outputNaming: OutputNaming = .fullPath
     var moduleMapPath: String?
     var visibility: Visibility = .internal
     var swiftProtobufModuleName: String? = nil
     var implementationOnlyImports: Bool = false
 
-    for pair in parseParameter(string:parameter) {
+    for pair in parameter.parsedPairs {
       switch pair.key {
       case "FileNaming":
         if let naming = OutputNaming(flag: pair.value) {

Sources/protoc-gen-swift/StringUtils.swift

@@ -35,28 +35,6 @@ func splitPath(pathname: String) -> (dir:String, base:String, suffix:String) {
   return (dir: dir, base: base, suffix: suffix)
 }
 
-func partition(string: String, atFirstOccurrenceOf substring: String) -> (String, String) {
-  guard let index = string.range(of: substring)?.lowerBound else {
-    return (string, "")
-  }
-  return (String(string[..<index]),
-          String(string[string.index(after: index)...]))
-}
-
-func parseParameter(string: String?) -> [(key:String, value:String)] {
-  guard let string = string, !string.isEmpty else {
-    return []
-  }
-  let parts = string.components(separatedBy: ",")
-  let asPairs = parts.map { partition(string: $0, atFirstOccurrenceOf: "=") }
-  let result = asPairs.map { (key:trimWhitespace($0), value:trimWhitespace($1)) }
-  return result
-}
-
-func trimWhitespace(_ s: String) -> String {
-  return s.trimmingCharacters(in: .whitespacesAndNewlines)
-}
-
 /// The protoc parser emits byte literals using an escaped C convention.
 /// Fortunately, it uses only a limited subset of the C escapse:
 ///  \n\r\t\\\'\" and three-digit octal escapes but nothing else.

Sources/protoc-gen-swift/main.swift

@@ -23,16 +23,7 @@ import Foundation
 import SwiftProtobuf
 import SwiftProtobufPluginLibrary
 
-extension Google_Protobuf_Compiler_Version {
-  fileprivate var versionString: String {
-    if !suffix.isEmpty {
-      return "\(major).\(minor).\(patch).\(suffix)"
-    }
-    return "\(major).\(minor).\(patch)"
-  }
-}
-
-struct GeneratorPlugin {
+struct GeneratorPlugin: CodeGenerator {
   private enum Mode {
     case showHelp
     case showVersion
@@ -154,7 +145,7 @@ struct GeneratorPlugin {
     }
 
     auditProtoCVersion(request: request)
-    let response = generate(request: request)
+    let response = generateCode(request: request, generator: self)
     guard sendReply(response: response) else { return 1 }
     return 0
   }
@@ -182,7 +173,7 @@ struct GeneratorPlugin {
         continue
       }
 
-      let response = generate(request: request)
+      let response = generateCode(request: request, generator: self)
       if response.hasError {
         Stderr.print("Error while generating from \(p) - \(response.error)")
         result = 1
@@ -198,47 +189,32 @@ struct GeneratorPlugin {
     return result
   }
 
-  private func generate(
-    request: Google_Protobuf_Compiler_CodeGeneratorRequest
-  ) -> Google_Protobuf_Compiler_CodeGeneratorResponse {
-    let options: GeneratorOptions
-    do {
-      options = try GeneratorOptions(parameter: request.parameter)
-    } catch GenerationError.unknownParameter(let name) {
-      return Google_Protobuf_Compiler_CodeGeneratorResponse(
-        error: "Unknown generation parameter '\(name)'")
-    } catch GenerationError.invalidParameterValue(let name, let value) {
-      return Google_Protobuf_Compiler_CodeGeneratorResponse(
-        error: "Unknown value for generation parameter '\(name)': '\(value)'")
-    } catch GenerationError.wrappedError(let message, let e) {
-      return Google_Protobuf_Compiler_CodeGeneratorResponse(error: "\(message): \(e)")
-    } catch let e {
-      return Google_Protobuf_Compiler_CodeGeneratorResponse(
-        error: "Internal Error parsing request options: \(e)")
-    }
-
-    let descriptorSet = DescriptorSet(protos: request.protoFile)
+  func generate(
+    files: [SwiftProtobufPluginLibrary.FileDescriptor],
+    parameter: CodeGeneratorParameter,
+    protoCompilerContext: SwiftProtobufPluginLibrary.ProtoCompilerContext,
+    generatorOutputs: SwiftProtobufPluginLibrary.GeneratorOutputs
+  ) throws {
+    let options = try GeneratorOptions(parameter: parameter)
 
     var errorString: String? = nil
-    var responseFiles: [Google_Protobuf_Compiler_CodeGeneratorResponse.File] = []
-    for name in request.fileToGenerate {
-      let fileDescriptor = descriptorSet.fileDescriptor(named: name)!
+    for fileDescriptor in files {
       let fileGenerator = FileGenerator(fileDescriptor: fileDescriptor, generatorOptions: options)
       var printer = CodePrinter(addNewlines: true)
       fileGenerator.generateOutputFile(printer: &printer, errorString: &errorString)
       if let errorString = errorString {
         // If generating multiple files, scope the message with the file that triggered it.
-        let fullError = request.fileToGenerate.count > 1 ? "\(name): \(errorString)" : errorString
-        return Google_Protobuf_Compiler_CodeGeneratorResponse(error: fullError)
+        let fullError = files.count > 1 ? "\(fileDescriptor.name): \(errorString)" : errorString
+        throw GenerationError.message(message: fullError)
       }
-      responseFiles.append(
-        Google_Protobuf_Compiler_CodeGeneratorResponse.File(name: fileGenerator.outputFilename,
-                                                            content: printer.content))
+      try generatorOutputs.add(fileName: fileGenerator.outputFilename, contents: printer.content)
     }
-    return Google_Protobuf_Compiler_CodeGeneratorResponse(files: responseFiles,
-                                                          supportedFeatures: [.proto3Optional])
   }
 
+  var supportedFeatures: [SwiftProtobufPluginLibrary.Google_Protobuf_Compiler_CodeGeneratorResponse.Feature] = [
+    .proto3Optional,
+  ]
+
   private func auditProtoCVersion(request: Google_Protobuf_Compiler_CodeGeneratorRequest) {
     guard request.hasCompilerVersion else {
       Stderr.print("WARNING: unknown version of protoc, use 3.2.x or later to ensure JSON support is correct.")