Add support for targets with mixed language sources

Fixtures/MixedTargets/DummyTargets/Package.swift

@@ -0,0 +1,51 @@
+// swift-tools-version: 999.0
+// FIXME(ncooke3): Update above version with the next version of SwiftPM.
+
+import PackageDescription
+
+// This package vends targets to aid in testing the MixedTargetsWithObjC package.
+let package = Package(
+    name: "DummyTargets",
+    dependencies: [
+         .package(path: "../MixedTargetsWithObjC")
+    ],
+    targets: [
+        .executableTarget(
+            name: "ClangExecutableDependsOnDynamicallyLinkedMixedTarget", 
+            dependencies: [
+                .product(
+                    name: "DynamicallyLinkedBasicMixedTarget", 
+                    package: "MixedTargetsWithObjC"
+                )
+            ]
+         ),
+         .executableTarget(
+             name: "ClangExecutableDependsOnStaticallyLinkedMixedTarget",
+             dependencies: [
+                .product(
+                    name: "StaticallyLinkedBasicMixedTarget", 
+                    package: "MixedTargetsWithObjC"
+                )
+            ]
+         ),
+         .executableTarget(
+             name: "SwiftExecutableDependsOnDynamicallyLinkedMixedTarget",
+             dependencies: [
+                .product(
+                    name: "DynamicallyLinkedBasicMixedTarget", 
+                    package: "MixedTargetsWithObjC"
+                )
+             ]
+         ),
+         .executableTarget(
+             name: "SwiftExecutableDependsOnStaticallyLinkedMixedTarget",
+             dependencies: [
+                .product(
+                    name: "StaticallyLinkedBasicMixedTarget", 
+                    package: "MixedTargetsWithObjC"
+                )
+             ]
+         )
+
+    ]
+)

Fixtures/MixedTargets/DummyTargets/Sources/ClangExecutableDependsOnDynamicallyLinkedMixedTarget/main.m

@@ -0,0 +1,14 @@
+#import <Foundation/Foundation.h>
+
+@import BasicMixedTarget;
+
+int main(int argc, const char *argv[]) {
+  @autoreleasepool {
+    // Ensure that the module is actually loaded.
+        Engine *engine = [[Engine alloc] init];
+        OldCar *oldCar = [[OldCar alloc] init];
+
+        printf("Hello, world!\n");
+  }
+  return 0;
+}

Fixtures/MixedTargets/DummyTargets/Sources/ClangExecutableDependsOnStaticallyLinkedMixedTarget/main.m

@@ -0,0 +1,14 @@
+#import <Foundation/Foundation.h>
+
+@import BasicMixedTarget;
+
+int main(int argc, const char * argv[]) {
+    @autoreleasepool {
+        // Ensure that the module is actually loaded.
+        Engine *engine = [[Engine alloc] init];
+        OldCar *oldCar = [[OldCar alloc] init];
+
+        printf("Hello, world!\n");
+    }
+    return 0;
+}

Fixtures/MixedTargets/DummyTargets/Sources/SwiftExecutableDependsOnDynamicallyLinkedMixedTarget/main.swift

@@ -0,0 +1,7 @@
+import BasicMixedTarget
+
+// Ensure that the module is actually loaded.
+let _  = NewCar()
+let _  = OldCar()
+
+print("Hello, world!")

Fixtures/MixedTargets/DummyTargets/Sources/SwiftExecutableDependsOnStaticallyLinkedMixedTarget/main.swift

@@ -0,0 +1,7 @@
+import BasicMixedTarget
+
+// Ensure that the module is actually loaded.
+let _  = NewCar()
+let _  = OldCar()
+
+print("Hello, world!")

Fixtures/MixedTargets/MixedTargetsWithCXX_InteropDisabled/Package.swift

@@ -0,0 +1,32 @@
+// swift-tools-version: 999.0
+// FIXME(ncooke3): Update above version with the next version of SwiftPM.
+
+// NOTE: This is package is intended to build on all platforms (macOS, Linux, and Windows).
+
+import PackageDescription
+
+let package = Package(
+    name: "MixedTargetsWithCXX_InteropDisabled",
+    products: [
+        .library(
+            name: "MixedTarget",
+            targets: ["MixedTarget"]
+        ),
+        .library(
+            name: "StaticallyLinkedMixedTarget",
+            type: .static,
+            targets: ["MixedTarget"]
+        ),
+        .library(
+            name: "DynamicallyLinkedMixedTarget",
+            type: .dynamic,
+            targets: ["MixedTarget"]
+        )
+    ],
+    dependencies: [],
+    targets: [
+        .target(
+          name: "MixedTarget"
+        )
+    ]
+)

Fixtures/MixedTargets/MixedTargetsWithCXX_InteropDisabled/Sources/MixedTarget/CxxCountdown.cpp

@@ -0,0 +1,23 @@
+#include "CxxCountdown.hpp"
+
+#include <iostream>
+
+#include "MixedTarget-Swift.h"
+#include <MixedTarget-Swift.h>
+
+CxxCountdown::CxxCountdown(bool printCount) : printCount(printCount) {}
+
+void CxxCountdown::countdown(int x )const {
+    if (x < 0)
+      std::cout << "[c++] Cannot count down from a negative number.\n";
+      return;
+
+    if (printCount)
+      std::cout << "[c++] T-minus " << x << "... \n";
+
+    if (x == 0)
+      std::cout << "[c++] We have liftoff!";
+      return;
+
+    CxxCountdown::countdown(x - 1);
+}

Fixtures/MixedTargets/MixedTargetsWithCXX_InteropDisabled/Sources/MixedTarget/SwiftCountdown.swift

@@ -0,0 +1,27 @@
+import Foundation
+
+public struct SwiftCountdown {
+    private let printCount: Bool
+
+    public init(printCount: Bool) {
+      self.printCount = printCount
+    }
+
+    public func countdown(x: Int) {
+      if x < 0 {
+        print("[swift] Cannot count down from a negative number.")
+        return
+      }
+
+      if printCount {
+        print("[swift] T-minus \(x)...")
+      }
+
+      if x == 0 {
+        print("[swift] We have liftoff!")
+        return
+      }
+
+      countdown(x: x - 1)
+    }
+}

Fixtures/MixedTargets/MixedTargetsWithCXX_InteropDisabled/Sources/MixedTarget/include/CxxCountdown.hpp

@@ -0,0 +1,10 @@
+#ifdef __cplusplus
+class CxxCountdown
+{
+public:
+    CxxCountdown(bool printCount);
+    void countdown(int x) const;
+private:
+    bool printCount;
+};
+#endif  // __cplusplus

Fixtures/MixedTargets/MixedTargetsWithCXX_InteropEnabled/Package.swift

@@ -0,0 +1,37 @@
+// swift-tools-version: 999.0
+// FIXME(ncooke3): Update above version with the next version of SwiftPM.
+
+// NOTE: This is package is intended to build on all platforms (macOS, Linux, and Windows).
+
+import PackageDescription
+
+let package = Package(
+    name: "MixedTargetsWithCXX_InteropEnabled",
+    products: [
+        .library(
+            name: "MixedTarget",
+            targets: ["MixedTarget"]
+        ),
+        .library(
+            name: "StaticallyLinkedMixedTarget",
+            type: .static,
+            targets: ["MixedTarget"]
+        ),
+        .library(
+            name: "DynamicallyLinkedMixedTarget",
+            type: .dynamic,
+            targets: ["MixedTarget"]
+        )
+    ],
+    dependencies: [],
+    targets: [
+        .target(
+          name: "MixedTarget",
+          swiftSettings: [.interoperabilityMode(.Cxx)]
+        )
+    ],
+    // TODO(ncooke3): Is the below note behavior that we want to be intended?
+    // This is needed for targets with that have
+    // `swiftSettings: [.interoperabilityMode(.Cxx)]` set.
+    cxxLanguageStandard: .cxx11
+)

Fixtures/MixedTargets/MixedTargetsWithCXX_InteropEnabled/Sources/MixedTarget/CxxCountdown.cpp

@@ -0,0 +1,24 @@
+#include "CxxCountdown.hpp"
+
+#include <iostream>
+
+#include "MixedTarget-Swift.h"
+#include <MixedTarget-Swift.h>
+
+CxxCountdown::CxxCountdown(bool printCount) : printCount(printCount) {}
+
+void CxxCountdown::countdown(int x )const {
+    if (x < 0)
+      std::cout << "[c++] Cannot count down from a negative number.\n";
+      return;
+
+    if (printCount)
+      std::cout << "[c++] T-minus " << x << "... \n";
+
+    if (x == 0)
+      std::cout << "[c++] We have liftoff!";
+      return;
+
+    auto swiftCountdown = MixedTarget::SwiftCountdown::init(printCount);
+    swiftCountdown.countdown(x - 1);
+}

Fixtures/MixedTargets/MixedTargetsWithCXX_InteropEnabled/Sources/MixedTarget/SwiftCountdown.swift

@@ -0,0 +1,28 @@
+import Foundation
+
+public struct SwiftCountdown {
+    private let printCount: Bool
+
+    public init(printCount: Bool) {
+      self.printCount = printCount
+    }
+
+    public func countdown(x: Int) {
+      if x < 0 {
+        print("[swift] Cannot count down from a negative number.")
+        return
+      }
+
+      if printCount {
+        print("[swift] T-minus \(x)...")
+      }
+
+      if x == 0 {
+        print("[swift] We have liftoff!")
+        return
+      }
+
+      let cxxCountdown = CxxCountdown(printCount)
+      cxxCountdown.countdown(Int32(x) - 1)
+    }
+}

Fixtures/MixedTargets/MixedTargetsWithCXX_InteropEnabled/Sources/MixedTarget/include/CxxCountdown.hpp

@@ -0,0 +1,8 @@
+class CxxCountdown
+{
+public:
+    CxxCountdown(bool printCount);
+    void countdown(int x) const;
+private:
+    bool printCount;
+};

Fixtures/MixedTargets/MixedTargetsWithObjC/MixedTargetWithCustomPaths/Sources/Driver.m

@@ -0,0 +1,9 @@
+#import <Foundation/Foundation.h>
+
+// All three import statements should be supported.
+#import "Driver.h"
+#import "Public/Driver.h"
+#import "MixedTargetWithCustomPaths/Sources/Public/Driver.h"
+
+@implementation Driver
+@end

Fixtures/MixedTargets/MixedTargetsWithObjC/MixedTargetWithCustomPaths/Sources/Engine.swift

@@ -0,0 +1,4 @@
+import Foundation
+
+// This type is Objective-C compatible and used in `OldCar`.
+@objc public class Engine: NSObject {}

Fixtures/MixedTargets/MixedTargetsWithObjC/MixedTargetWithCustomPaths/Sources/NewCar.swift

@@ -0,0 +1,10 @@
+import Foundation
+
+public class NewCar {
+    // `Engine` is defined in Swift.
+    var engine: Engine? = nil
+    // The following types are defined in Objective-C.
+    var driver: Driver? = nil
+
+    public init() {}
+}

Fixtures/MixedTargets/MixedTargetsWithObjC/MixedTargetWithCustomPaths/Sources/OldCar.m

@@ -0,0 +1,22 @@
+#import <Foundation/Foundation.h>
+
+// The below import statements should be supported.
+#import "MixedTargetWithCustomPaths/Sources/Public/OldCar.h"
+#import "OldCar.h"
+#import "Public/OldCar.h"
+#import <OldCar.h>
+#import <Public/OldCar.h>
+
+// Import the Swift part of the module.
+#import "MixedTargetWithCustomPaths-Swift.h"
+
+// Both import statements should be supported.
+#import "MixedTargetWithCustomPaths/Sources/Transmission.h"
+#import "Transmission.h"
+
+@interface OldCar ()
+@property(nonatomic) Transmission *transmission;
+@end
+
+@implementation OldCar
+@end

Fixtures/MixedTargets/MixedTargetsWithObjC/MixedTargetWithCustomPaths/Sources/Public/Driver.h

@@ -0,0 +1,6 @@
+#import <Foundation/Foundation.h>
+
+// This type is Swift compatible and used in `NewCar`.
+@interface Driver : NSObject
+@property(nonnull) NSString* name;
+@end

Fixtures/MixedTargets/MixedTargetsWithObjC/MixedTargetWithCustomPaths/Sources/Public/OldCar.h

@@ -0,0 +1,14 @@
+#import <Foundation/Foundation.h>
+
+#import "Driver.h"
+
+// The `Engine` type is declared in the Swift part of the module. Such types
+// must be forward declared in headers.
+@class Engine;
+
+@interface OldCar : NSObject
+// `Engine` is defined in Swift.
+@property(nullable) Engine *engine;
+// `Driver` is defined in Objective-C.
+@property(nullable) Driver *driver;
+@end

Fixtures/MixedTargets/MixedTargetsWithObjC/MixedTargetWithCustomPaths/Sources/Transmission.h

@@ -0,0 +1,10 @@
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, TransmissionKind) {
+  TransmissionKindManual,
+  TransmissionKindAutomatic
+};
+
+@interface Transmission : NSObject
+@property (nonatomic, readonly, assign) TransmissionKind transmissionKind;
+@end

Fixtures/MixedTargets/MixedTargetsWithObjC/MixedTargetWithCustomPaths/Sources/Transmission.m

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+
+// Both import statements should be supported.
+#import "Transmission.h"
+#import "MixedTargetWithCustomPaths/Sources/Transmission.h"
+
+@implementation Transmission
+@end