Merge pull request #4 from gojekfarm/task/update-swiftprotobuf-version

Task/update swiftprotobuf version

Author: AbhijeetMallick

Sources/protoc-gen-swift/Docs.docc/spm-plugin.md

@@ -22,30 +22,18 @@ There are multiple ways to do this. Some of the easiest are:
 1. If you are on macOS, installing it via `brew install protobuf`
 2. Download the binary from [Google's github repository](https://github.com/protocolbuffers/protobuf).
 
-### Adding the proto files to your target
-
-Next, you need to add the `.proto` files for which you want to generate your Swift types to your target's
-source directory. You should also commit these files to your git repository since the generated types
-are now generated on demand.
-
-> Note: imports on your `.proto` files will have to include the relative path from the target source to the `.proto` file you wish to import.
-
 ### Adding the plugin to your manifest
 
-After adding the `.proto` files you can now add the plugin to the target inside your `Package.swift` manifest.
 First, you need to add a dependency on `swift-protobuf`. Afterwards, you can declare the usage of the plugin
 for your target. Here is an example snippet of a `Package.swift` manifest:
 
-> Note: imports on your `.proto` files will have to include the relative path from the target source to the `.proto` file you wish to import. 
-> Files **must** be contained within the target source directory.
-
 ```swift
 let package = Package(
   name: "YourPackage",
   products: [...],
   dependencies: [
     ...
-    .package(url: "https://github.com/apple/swift-protobuf", from: "1.29.0.1"),
+    .package(url: "https://github.com/apple/swift-protobuf", from: "2.0.0"),
     ...
   ],
   targets: [
@@ -63,9 +51,25 @@ let package = Package(
 
 ### Configuring the plugin
 
-Lastly, after you have added the `.proto` files and modified your `Package.swift` manifest, you can now
-configure the plugin to invoke the `protoc` compiler. This is done by adding a `swift-protobuf-config.json`
-to the root of your target's source folder. An example configuration file looks like this:
+Configuring the plugin is done by adding a `swift-protobuf-config.json` file anywhere in your target's sources.
+Before you start configuring the plugin, you need to add the `.proto` files to your sources. You should also commit these
+files to your git repository since the generated types are now generated on demand.
+It's also important to note that the proto files in your configuration should be in
+the same directory as the config file. Let's see an example to have a better understanding.
+
+Here's an example file structure that looks like this:
+
+```text
+Sources
+├── main.swift
+├── ProtoBuf
+    ├── swift-protobuf-config.json
+    ├── foo.proto
+    └── Bar
+        └── Bar.proto
+```
+
+So, the configuration file would look something like this:
 
 ```json
 {
@@ -79,7 +83,7 @@ to the root of your target's source folder. An example configuration file looks
         },
         {
             "protoFiles": [
-                "Bar.proto"
+                "Bar/Bar.proto"
             ],
             "visibility": "public",
             "fileNaming": "pathToUnderscores"
@@ -88,24 +92,25 @@ to the root of your target's source folder. An example configuration file looks
 }
 
 ```
+As you can see in the above configuration, the paths are relative with respect to the `ProtoBuf` folder and not the root folder.
+If you add a file in the `Sources` folder, the plugin would be unable to access it as the path is computed relative to
+the `swift-protobuf-config.json` file.
 
-> Note: paths to your `.proto` files will have to include the relative path from the target source to the `.proto` file location.
-> Files **must** be contained within the target source directory.
+> Note: paths to your `.proto` files will have to include the relative path from the config file directory to the `.proto` file location.
+> Files **must** be contained within the same directory as the config file.
 
 In the above configuration, you declared two invocations to the `protoc` compiler. The first invocation
 is generating Swift types for the `Foo.proto` file with `internal` visibility. The second invocation
 is generating Swift types for the `Bar.proto` file with the `public` visibility. Furthermore, the second
 invocation is using the `pathToUnderscores` file naming option. This option can be used to solve
 problems where a single target contains two or more proto files with the same name.
 
-> Note: paths to your `.proto` files will have to include the relative path from the target source to the `.proto` file location. 
-
 ### Defining the path to the protoc binary
 
-The plugin needs to be able to invoke the `protoc` binary to generate the Swift types. There are several ways to achieve this. 
+The plugin needs to be able to invoke the `protoc` binary to generate the Swift types. There are several ways to achieve this.
 
-First, by default, the package manager looks into the `$PATH` to find binaries named `protoc`. 
-This works immediately if you use `swift build` to build your package and `protoc` is installed 
+First, by default, the package manager looks into the `$PATH` to find binaries named `protoc`.
+This works immediately if you use `swift build` to build your package and `protoc` is installed
 in the `$PATH` (`brew` is adding it to your `$PATH` automatically).
 However, this doesn't work if you want to compile from Xcode since Xcode is not passed the `$PATH`.
 
@@ -135,7 +140,15 @@ env PROTOC_PATH=/opt/homebrew/bin/protoc xcodebuild <Here goes your command>
 }
 ```
 
-> Warning: The configuration file option only solves the problem for leaf packages that are using the Swift package manager
-plugin since there you can point the package manager to the right binary. The environment variable
-does solve the problem for transitive packages as well; however, it requires your users to set
-the variable now. In general we advise against adopting the plugin as a non-leaf package!
+### Known Issues
+
+- The configuration file _must not_ be excluded from the list of sources for the
+  target in the package manifest (that is, it should not be present in the
+  `exclude` argument for the target). The build system does not have access to
+  the file if it is excluded, however, `swift build` will result in a warning
+  that the file should be excluded.
+- The plugin should only be used for leaf packages. The configuration file option
+  only solves the problem for leaf packages that are using the Swift package
+  manager plugin since there you can point the package manager to the right
+  binary. The environment variable does solve the problem for transitive
+  packages as well; however, it requires your users to set the variable now.

Sources/protoc-gen-swift/FileGenerator.swift

@@ -15,9 +15,8 @@
 ///
 // -----------------------------------------------------------------------------
 import Foundation
-import SwiftProtobufPluginLibrary
 import SwiftProtobuf
-
+import SwiftProtobufPluginLibrary
 
 class FileGenerator {
     private let fileDescriptor: FileDescriptor
@@ -39,104 +38,140 @@ class FileGenerator {
         }
     }
 
-    init(fileDescriptor: FileDescriptor,
-         generatorOptions: GeneratorOptions) {
+    init(
+        fileDescriptor: FileDescriptor,
+        generatorOptions: GeneratorOptions
+    ) {
         self.fileDescriptor = fileDescriptor
         self.generatorOptions = generatorOptions
-        namer = SwiftProtobufNamer(currentFile: fileDescriptor,
-                                   protoFileToModuleMappings: generatorOptions.protoToModuleMappings)
+        namer = SwiftProtobufNamer(
+            currentFile: fileDescriptor,
+            protoFileToModuleMappings: generatorOptions.protoToModuleMappings
+        )
     }
 
     /// Generate, if `errorString` gets filled in, then report error instead of using
     /// what written into `printer`.
     func generateOutputFile(printer p: inout CodePrinter, errorString: inout String?) {
-        guard fileDescriptor.options.swiftPrefix.isEmpty ||
-            isValidSwiftIdentifier(fileDescriptor.options.swiftPrefix,
-                                   allowQuoted: false) else {
-          errorString = "\(fileDescriptor.name) has an 'swift_prefix' that isn't a valid Swift identifier (\(fileDescriptor.options.swiftPrefix))."
-          return
+        guard
+            fileDescriptor.options.swiftPrefix.isEmpty
+                || isValidSwiftIdentifier(
+                    fileDescriptor.options.swiftPrefix,
+                    allowQuoted: false
+                )
+        else {
+            errorString =
+                "\(fileDescriptor.name) has an 'swift_prefix' that isn't a valid Swift identifier (\(fileDescriptor.options.swiftPrefix))."
+            return
         }
-        p.print("""
+        p.print(
+            """
             // DO NOT EDIT.
             // swift-format-ignore-file
+            // swiftlint:disable all
             //
             // Generated by the Swift generator plugin for the protocol buffer compiler.
             // Source: \(fileDescriptor.name)
             //
             // For information on using the generated types, please see the documentation:
             //   https://github.com/apple/swift-protobuf/
 
-            """)
+            """
+        )
 
         // Attempt to bring over the comments at the top of the .proto file as
         // they likely contain copyrights/preamble/etc.
         //
         // The C++ FileDescriptor::GetSourceLocation(), says the location for
         // the file is an empty path. That never seems to have comments on it.
         // https://github.com/protocolbuffers/protobuf/issues/2249 opened to
-        // figure out the right way to do this since the syntax entry is
-        // optional.
-        var comments = String()
+        // figure out the right way to do this but going forward best bet seems
+        // to be to look for the "edition" or the "syntax" decl.
+        let editionPath = IndexPath(index: Google_Protobuf_FileDescriptorProto.FieldNumbers.edition)
         let syntaxPath = IndexPath(index: Google_Protobuf_FileDescriptorProto.FieldNumbers.syntax)
-        if let syntaxLocation = fileDescriptor.sourceCodeInfoLocation(path: syntaxPath) {
-          comments = syntaxLocation.asSourceComment(commentPrefix: "///",
-                                                    leadingDetachedPrefix: "//")
-          // If the was a leading or tailing comment it won't have a blank
-          // line, after it, so ensure there is one.
-          if !comments.isEmpty && !comments.hasSuffix("\n\n") {
-            comments.append("\n")
-          }
+        var commentLocation: Google_Protobuf_SourceCodeInfo.Location? = nil
+        if self.generatorOptions.experimentalStripNonfunctionalCodegen {
+            // Comments are inherently non-functional, and may change subtly on
+            // transformations.
+        } else if let location = fileDescriptor.sourceCodeInfoLocation(path: editionPath) {
+            commentLocation = location
+        } else if let location = fileDescriptor.sourceCodeInfoLocation(path: syntaxPath) {
+            commentLocation = location
+        }
+        if let commentLocation = commentLocation {
+            let comments = commentLocation.asSourceComment(
+                commentPrefix: "///",
+                leadingDetachedPrefix: "//"
+            )
+            if !comments.isEmpty {
+                // If the was a leading or tailing comment it won't have a blank
+                // line, after it, so ensure there is one.
+                p.print(comments, newlines: !comments.hasSuffix("\n\n"))
+            }
         }
 
-        p.print("\(comments)import Foundation")
+        let fileDefinesTypes =
+            !fileDescriptor.enums.isEmpty || !fileDescriptor.messages.isEmpty || !fileDescriptor.extensions.isEmpty
 
-        if self.generatorOptions.implementationOnlyImports,
-           self.generatorOptions.visibility == .public {
-            errorString = """
-                Cannot use @_implementationOnly imports when the proto visibility is public.
-                Either change the visibility to internal, or disable @_implementationOnly imports.
-            """
-            return
+        var hasImports = false
+        if fileDescriptor.needsFoundationImport {
+            p.print("\(generatorOptions.importDirective.snippet) Foundation")
+            hasImports = true
         }
 
-        // Import all other imports as @_implementationOnly if the visiblity is
-        // internal and the option is set, to avoid exposing internal types to users.
-        let visibilityAnnotation: String = {
-            if self.generatorOptions.implementationOnlyImports,
-               self.generatorOptions.visibility == .internal {
-                return "@_implementationOnly "
-            } else {
-                return ""
+        if fileDescriptor.isBundledProto {
+            p.print(
+                "// 'import \(namer.swiftProtobufModuleName)' suppressed, this proto file is meant to be bundled in the runtime."
+            )
+            hasImports = true
+        } else if fileDefinesTypes {
+            p.print("\(generatorOptions.importDirective.snippet) \(namer.swiftProtobufModuleName)")
+            hasImports = true
+        }
+
+        let neededImports = fileDescriptor.computeImports(
+            namer: namer,
+            directive: generatorOptions.importDirective,
+            reexportPublicImports: generatorOptions.visibility != .internal
+        )
+        if !neededImports.isEmpty {
+            if hasImports {
+                p.print()
             }
-        }()
-        if !fileDescriptor.isBundledProto {
-            // The well known types ship with the runtime, everything else needs
-            // to import the runtime.
-            p.print("\(visibilityAnnotation)import \(namer.swiftProtobufModuleName)")
+            p.print(neededImports)
+            hasImports = true
         }
-        if let neededImports = generatorOptions.protoToModuleMappings.neededModules(forFile: fileDescriptor) {
-            p.print()
-            for i in neededImports {
-                p.print("\(visibilityAnnotation)import \(i)")
+
+        // If there is nothing to generate, then just record that and be done (usually means
+        // there just was one or more services).
+        guard fileDefinesTypes else {
+            if hasImports {
+                p.print()
             }
+            p.print("// This file contained no messages, enums, or extensions.")
+            return
         }
 
         let extensionSet =
-            ExtensionSetGenerator(fileDescriptor: fileDescriptor,
-                                  generatorOptions: generatorOptions,
-                                  namer: namer)
+            ExtensionSetGenerator(
+                fileDescriptor: fileDescriptor,
+                generatorOptions: generatorOptions,
+                namer: namer
+            )
 
         extensionSet.add(extensionFields: fileDescriptor.extensions)
 
         let enums = fileDescriptor.enums.map {
-            return EnumGenerator(descriptor: $0, generatorOptions: generatorOptions, namer: namer)
+            EnumGenerator(descriptor: $0, generatorOptions: generatorOptions, namer: namer)
         }
 
         let messages = fileDescriptor.messages.map {
-          return MessageGenerator(descriptor: $0,
-                                  generatorOptions: generatorOptions,
-                                  namer: namer,
-                                  extensionSet: extensionSet)
+            MessageGenerator(
+                descriptor: $0,
+                generatorOptions: generatorOptions,
+                namer: namer,
+                extensionSet: extensionSet
+            )
         }
 
         for e in enums {
@@ -147,23 +182,13 @@ class FileGenerator {
             m.generateMainStruct(printer: &p, parent: nil, errorString: &errorString)
         }
 
-        var sendablePrinter = CodePrinter(p)
-        for m in messages {
-            m.generateSendable(printer: &sendablePrinter)
-        }
-
-        if !sendablePrinter.isEmpty {
-            p.print("", "#if swift(>=5.5) && canImport(_Concurrency)")
-            p.append(sendablePrinter)
-            p.print("#endif  // swift(>=5.5) && canImport(_Concurrency)")
-        }
-
         if !extensionSet.isEmpty {
             let pathParts = splitPath(pathname: fileDescriptor.name)
             let filename = pathParts.base + pathParts.suffix
             p.print(
                 "",
-                "// MARK: - Extension support defined in \(filename).")
+                "// MARK: - Extension support defined in \(filename)."
+            )
 
             // Generate the Swift Extensions on the Messages that provide the api
             // for using the protobuf extension.
@@ -185,11 +210,13 @@ class FileGenerator {
         if needsProtoPackage || !enums.isEmpty || !messages.isEmpty {
             p.print(
                 "",
-                "// MARK: - Code below here is support for the SwiftProtobuf runtime.")
+                "// MARK: - Code below here is support for the SwiftProtobuf runtime."
+            )
             if needsProtoPackage {
                 p.print(
                     "",
-                    "fileprivate let _protobuf_package = \"\(protoPackage)\"")
+                    "fileprivate let _protobuf_package = \"\(protoPackage)\""
+                )
             }
             for e in enums {
                 e.generateRuntimeSupport(printer: &p)