Add a CompileTest for "multi module" generation.

- Add basic infrastructure to have Compile Tests.

- Add a specific MultiModule CompileTest.
  - This ensure that with `import public` is properly handle and the generated
    code compiles even when a needed type is coming from a public import.
  - So the any relevant code changes are more visible, check the the generated
    code so the diffs for an changes related to the test will be easily
    reviewed.
  - The SPM plugin doesn't support multi module generation
    (apple#1450), which is also why the
    code needs to be checked in, otherwise, it might simplify the tests.

Note: The whole concept of CompileTests doesn't have to be a set up as distinct
Swift Packages, but if we put the required targets in the main Package.swift,
all projects using swift-protobuf would end up having the "overhead" of those
test only targets, so I've errored on the side of a distinct package to make
sure there is no impact of these tests on the folks using swift-protobuf.

.github/workflows/build.yml

@@ -102,6 +102,9 @@ jobs:
     - name: Test SPM plugin
       working-directory: main
       run: make test-spm-plugin PROTOC=../protobuf/cmake_build/protoc
+    - name: Compilation Tests
+      working-directory: main
+      run: make compile-tests PROTOC=../protobuf/cmake_build/protoc
 
   sanitizer_testing:
     runs-on: ubuntu-latest

.gitignore

@@ -9,6 +9,8 @@ xcbaselines
 /docs
 /build
 mined_words.txt
+/CompileTests/MultiModule/.build
+/CompileTests/MultiModule/.swiftpm
 /*DescriptorTestData.bin
 /Package.resolved
 

CompileTests/MultiModule/Package.swift

@@ -0,0 +1,40 @@
+// swift-tools-version: 5.6
+
+import PackageDescription
+
+let package = Package(
+    name: "CompileTests",
+    dependencies: [
+        .package(name: "swift-protobuf", path: "../..")
+    ],
+    targets: [
+        .testTarget(
+            name: "Test1",
+            dependencies: ["ImportsAPublicly"]
+        ),
+        .testTarget(
+            name: "Test2",
+            dependencies: ["ImportsImportsAPublicly"]
+        ),
+        .target(
+            name: "ModuleA",
+            dependencies: [
+                .product(name: "SwiftProtobuf", package: "swift-protobuf"),
+            ]
+        ),
+        .target(
+            name: "ImportsAPublicly",
+            dependencies: [
+                .product(name: "SwiftProtobuf", package: "swift-protobuf"),
+                .target(name: "ModuleA"),
+            ]
+        ),
+        .target(
+            name: "ImportsImportsAPublicly",
+            dependencies: [
+                .product(name: "SwiftProtobuf", package: "swift-protobuf"),
+                .target(name: "ImportsAPublicly"),
+            ]
+        ),
+    ]
+)

CompileTests/MultiModule/README.md

@@ -0,0 +1,7 @@
+# CompileTests/MultiModule
+
+This is a test case that uses sources generated into multiple modules and
+ensures the generated code compiles with the cross modules references.
+
+This can't use the SwiftPM Plugin as that currently doesn't have support for the
+module mappings.

CompileTests/MultiModule/Sources/ImportsAPublicly/imports_a_publicly.pb.swift

@@ -0,0 +1,98 @@
+// DO NOT EDIT.
+// swift-format-ignore-file
+//
+// Generated by the Swift generator plugin for the protocol buffer compiler.
+// Source: Sources/ImportsAPublicly/imports_a_publicly.proto
+//
+// For information on using the generated types, please see the documentation:
+//   https://github.com/apple/swift-protobuf/
+
+import Foundation
+import SwiftProtobuf
+
+import ModuleA
+
+// If the compiler emits an error on this type, it is because this file
+// was generated by a version of the `protoc` Swift plug-in that is
+// incompatible with the version of SwiftProtobuf to which you are linking.
+// Please ensure that you are building against the same version of the API
+// that was used to generate this file.
+fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
+  struct _3: SwiftProtobuf.ProtobufAPIVersion_3 {}
+  typealias Version = _3
+}
+
+public struct ImportsAPublicly: Sendable {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  public var a: ModuleA.A {
+    get {return _a ?? ModuleA.A()}
+    set {_a = newValue}
+  }
+  /// Returns true if `a` has been explicitly set.
+  public var hasA: Bool {return self._a != nil}
+  /// Clears the value of `a`. Subsequent reads from it will return its default value.
+  public mutating func clearA() {self._a = nil}
+
+  public var e: ModuleA.E {
+    get {return _e ?? .unset}
+    set {_e = newValue}
+  }
+  /// Returns true if `e` has been explicitly set.
+  public var hasE: Bool {return self._e != nil}
+  /// Clears the value of `e`. Subsequent reads from it will return its default value.
+  public mutating func clearE() {self._e = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _a: ModuleA.A? = nil
+  fileprivate var _e: ModuleA.E? = nil
+}
+
+// MARK: - Code below here is support for the SwiftProtobuf runtime.
+
+extension ImportsAPublicly: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "ImportsAPublicly"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    11: .same(proto: "a"),
+    12: .same(proto: "e"),
+  ]
+
+  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 11: try { try decoder.decodeSingularMessageField(value: &self._a) }()
+      case 12: try { try decoder.decodeSingularEnumField(value: &self._e) }()
+      default: break
+      }
+    }
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._a {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 11)
+    } }()
+    try { if let v = self._e {
+      try visitor.visitSingularEnumField(value: v, fieldNumber: 12)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: ImportsAPublicly, rhs: ImportsAPublicly) -> Bool {
+    if lhs._a != rhs._a {return false}
+    if lhs._e != rhs._e {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}

CompileTests/MultiModule/Sources/ImportsImportsAPublicly/imports_imports_a_publicly.pb.swift

@@ -0,0 +1,99 @@
+// DO NOT EDIT.
+// swift-format-ignore-file
+//
+// Generated by the Swift generator plugin for the protocol buffer compiler.
+// Source: Sources/ImportsImportsAPublicly/imports_imports_a_publicly.proto
+//
+// For information on using the generated types, please see the documentation:
+//   https://github.com/apple/swift-protobuf/
+
+import Foundation
+import SwiftProtobuf
+
+import ImportsAPublicly
+import ModuleA
+
+// If the compiler emits an error on this type, it is because this file
+// was generated by a version of the `protoc` Swift plug-in that is
+// incompatible with the version of SwiftProtobuf to which you are linking.
+// Please ensure that you are building against the same version of the API
+// that was used to generate this file.
+fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
+  struct _3: SwiftProtobuf.ProtobufAPIVersion_3 {}
+  typealias Version = _3
+}
+
+public struct ImportsImportsAPublicly: Sendable {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  public var a: ModuleA.A {
+    get {return _a ?? ModuleA.A()}
+    set {_a = newValue}
+  }
+  /// Returns true if `a` has been explicitly set.
+  public var hasA: Bool {return self._a != nil}
+  /// Clears the value of `a`. Subsequent reads from it will return its default value.
+  public mutating func clearA() {self._a = nil}
+
+  public var e: ModuleA.E {
+    get {return _e ?? .unset}
+    set {_e = newValue}
+  }
+  /// Returns true if `e` has been explicitly set.
+  public var hasE: Bool {return self._e != nil}
+  /// Clears the value of `e`. Subsequent reads from it will return its default value.
+  public mutating func clearE() {self._e = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _a: ModuleA.A? = nil
+  fileprivate var _e: ModuleA.E? = nil
+}
+
+// MARK: - Code below here is support for the SwiftProtobuf runtime.
+
+extension ImportsImportsAPublicly: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "ImportsImportsAPublicly"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    21: .same(proto: "a"),
+    22: .same(proto: "e"),
+  ]
+
+  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 21: try { try decoder.decodeSingularMessageField(value: &self._a) }()
+      case 22: try { try decoder.decodeSingularEnumField(value: &self._e) }()
+      default: break
+      }
+    }
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._a {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 21)
+    } }()
+    try { if let v = self._e {
+      try visitor.visitSingularEnumField(value: v, fieldNumber: 22)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: ImportsImportsAPublicly, rhs: ImportsImportsAPublicly) -> Bool {
+    if lhs._a != rhs._a {return false}
+    if lhs._e != rhs._e {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}

CompileTests/MultiModule/Sources/ModuleA/a.pb.swift

@@ -0,0 +1,117 @@
+// DO NOT EDIT.
+// swift-format-ignore-file
+//
+// Generated by the Swift generator plugin for the protocol buffer compiler.
+// Source: Sources/ModuleA/a.proto
+//
+// For information on using the generated types, please see the documentation:
+//   https://github.com/apple/swift-protobuf/
+
+import Foundation
+import SwiftProtobuf
+
+// If the compiler emits an error on this type, it is because this file
+// was generated by a version of the `protoc` Swift plug-in that is
+// incompatible with the version of SwiftProtobuf to which you are linking.
+// Please ensure that you are building against the same version of the API
+// that was used to generate this file.
+fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
+  struct _3: SwiftProtobuf.ProtobufAPIVersion_3 {}
+  typealias Version = _3
+}
+
+public enum E: SwiftProtobuf.Enum {
+  public typealias RawValue = Int
+  case unset // = 0
+  case a // = 1
+  case b // = 2
+
+  public init() {
+    self = .unset
+  }
+
+  public init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .unset
+    case 1: self = .a
+    case 2: self = .b
+    default: return nil
+    }
+  }
+
+  public var rawValue: Int {
+    switch self {
+    case .unset: return 0
+    case .a: return 1
+    case .b: return 2
+    }
+  }
+
+}
+
+public struct A: Sendable {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  public var e: E {
+    get {return _e ?? .unset}
+    set {_e = newValue}
+  }
+  /// Returns true if `e` has been explicitly set.
+  public var hasE: Bool {return self._e != nil}
+  /// Clears the value of `e`. Subsequent reads from it will return its default value.
+  public mutating func clearE() {self._e = nil}
+
+  public var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  public init() {}
+
+  fileprivate var _e: E? = nil
+}
+
+// MARK: - Code below here is support for the SwiftProtobuf runtime.
+
+extension E: SwiftProtobuf._ProtoNameProviding {
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "E_UNSET"),
+    1: .same(proto: "E_A"),
+    2: .same(proto: "E_B"),
+  ]
+}
+
+extension A: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  public static let protoMessageName: String = "A"
+  public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "e"),
+  ]
+
+  public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularEnumField(value: &self._e) }()
+      default: break
+      }
+    }
+  }
+
+  public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._e {
+      try visitor.visitSingularEnumField(value: v, fieldNumber: 1)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  public static func ==(lhs: A, rhs: A) -> Bool {
+    if lhs._e != rhs._e {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}