Merge remote-tracking branch 'origin/main' into rebranch

swift-ci · swift-ci · commit 3b702bf6e4cb · 2021-09-24T11:54:10.000-07:00
diff --git a/include/swift/Basic/LangOptions.h b/include/swift/Basic/LangOptions.h
@@ -670,6 +670,10 @@ namespace swift {
   /// Options for controlling the behavior of the Clang importer.
   class ClangImporterOptions final {
   public:
+    /// The path to the Clang compiler executable.
+    /// Used to detect the default include paths.
+    std::string clangPath = "clang";
+
     /// The module cache path which the Clang importer should use.
     std::string ModuleCachePath;
 
diff --git a/lib/ClangImporter/ClangImporter.cpp b/lib/ClangImporter/ClangImporter.cpp
@@ -964,7 +964,7 @@ ClangImporter::getClangArguments(ASTContext &ctx) {
   std::vector<std::string> invocationArgStrs;
   // Clang expects this to be like an actual command line. So we need to pass in
   // "clang" for argv[0]
-  invocationArgStrs.push_back("clang");
+  invocationArgStrs.push_back(ctx.ClangImporterOpts.clangPath);
   switch (ctx.ClangImporterOpts.Mode) {
   case ClangImporterOptions::Modes::Normal:
   case ClangImporterOptions::Modes::PrecompiledModule:
diff --git a/lib/ClangImporter/ImportType.cpp b/lib/ClangImporter/ImportType.cpp
@@ -1918,6 +1918,7 @@ ParameterList *ClangImporter::Implementation::importFunctionParameterList(
     // Import the parameter type into Swift.
     Type swiftParamTy;
     bool isParamTypeImplicitlyUnwrapped = false;
+    bool isInOut = false;
 
     auto referenceType = dyn_cast<clang::ReferenceType>(paramTy);
     if (referenceType &&
@@ -1937,6 +1938,10 @@ ParameterList *ClangImporter::Implementation::importFunctionParameterList(
       swiftParamTy =
           findGenericTypeInGenericDecls(templateParamType, genericParams);
     } else {
+      if (auto refType = dyn_cast<clang::ReferenceType>(paramTy)) {
+        paramTy = refType->getPointeeType();
+        isInOut = true;
+      }
       auto importedType = importType(paramTy, importKind, allowNSUIntegerAsInt,
                                      Bridgeability::Full, OptionalityOfParam);
       if (!importedType)
@@ -1968,7 +1973,8 @@ ParameterList *ClangImporter::Implementation::importFunctionParameterList(
         param, AccessLevel::Private, SourceLoc(), SourceLoc(), name,
         importSourceLoc(param->getLocation()), bodyName,
         ImportedHeaderUnit);
-    paramInfo->setSpecifier(ParamSpecifier::Default);
+    paramInfo->setSpecifier(isInOut ? ParamSpecifier::InOut
+                                    : ParamSpecifier::Default);
     paramInfo->setInterfaceType(swiftParamTy);
     recordImplicitUnwrapForDecl(paramInfo, isParamTypeImplicitlyUnwrapped);
     recordUnsafeConcurrencyForDecl(
diff --git a/lib/Driver/ToolChains.cpp b/lib/Driver/ToolChains.cpp
@@ -264,6 +264,7 @@ void ToolChain::addCommonFrontendArgs(const OutputInfo &OI,
   inputArgs.AddLastArg(arguments, options::OPT_swift_version);
   inputArgs.AddLastArg(arguments, options::OPT_enforce_exclusivity_EQ);
   inputArgs.AddLastArg(arguments, options::OPT_stats_output_dir);
+  inputArgs.AddLastArg(arguments, options::OPT_tools_directory);
   inputArgs.AddLastArg(arguments, options::OPT_trace_stats_events);
   inputArgs.AddLastArg(arguments, options::OPT_profile_stats_events);
   inputArgs.AddLastArg(arguments, options::OPT_profile_stats_entities);
diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp
@@ -68,6 +68,11 @@ void CompilerInvocation::setMainExecutablePath(StringRef Path) {
       Path, FrontendOpts.UseSharedResourceFolder, LibPath);
   setRuntimeResourcePath(LibPath.str());
 
+  llvm::SmallString<128> clangPath(Path);
+  llvm::sys::path::remove_filename(clangPath);
+  llvm::sys::path::append(clangPath, "clang");
+  ClangImporterOpts.clangPath = std::string(clangPath);
+
   llvm::SmallString<128> DiagnosticDocsPath(Path);
   llvm::sys::path::remove_filename(DiagnosticDocsPath); // Remove /swift
   llvm::sys::path::remove_filename(DiagnosticDocsPath); // Remove /bin
@@ -990,6 +995,18 @@ static bool ParseClangImporterArgs(ClangImporterOptions &Opts,
                                    StringRef workingDirectory) {
   using namespace options;
 
+  if (const Arg *a = Args.getLastArg(OPT_tools_directory)) {
+    // If a custom tools directory is specified, try to find Clang there.
+    // This is useful when the Swift executable is located in a different
+    // directory than the Clang/LLVM executables, for example, when building
+    // the Swift project itself.
+    llvm::SmallString<128> clangPath(a->getValue());
+    llvm::sys::path::append(clangPath, "clang");
+    if (llvm::sys::fs::exists(clangPath)) {
+      Opts.clangPath = std::string(clangPath);
+    }
+  }
+
   if (const Arg *A = Args.getLastArg(OPT_module_cache_path)) {
     Opts.ModuleCachePath = A->getValue();
   }
diff --git a/lib/SIL/IR/Bridging.cpp b/lib/SIL/IR/Bridging.cpp
@@ -42,8 +42,7 @@ TypeConverter::getBridgedParam(SILFunctionTypeRepresentation rep,
                                AbstractionPattern pattern,
                                AnyFunctionType::Param param,
                                Bridgeability bridging) {
-  assert(!param.getParameterFlags().isInOut() &&
-         !param.getParameterFlags().isVariadic());
+  assert(!param.getParameterFlags().isVariadic());
 
   auto bridged = getLoweredBridgedType(pattern, param.getPlainType(), bridging,
                                        rep, TypeConverter::ForArgument);
diff --git a/stdlib/cmake/modules/SwiftSource.cmake b/stdlib/cmake/modules/SwiftSource.cmake
@@ -407,6 +407,10 @@ function(_compile_swift_files
   compute_library_subdir(library_subdir
     "${library_subdir_sdk}" "${SWIFTFILE_ARCHITECTURE}")
 
+  if(NOT "${SWIFT_NATIVE_CLANG_TOOLS_PATH}" STREQUAL "")
+    list(APPEND swift_flags "-tools-directory" "${SWIFT_NATIVE_CLANG_TOOLS_PATH}")
+  endif()
+
   # If we have a custom module cache path, use it.
   if (SWIFT_MODULE_CACHE_PATH)
     list(APPEND swift_flags "-module-cache-path" "${SWIFT_MODULE_CACHE_PATH}")
diff --git a/test/Interop/Cxx/reference/reference-irgen.swift b/test/Interop/Cxx/reference/reference-irgen.swift
@@ -32,39 +32,31 @@ public func getConstCxxRvalueRef() -> UnsafePointer<CInt> {
 
 public func setCxxRef() {
   var val: CInt = 21
-  withUnsafeMutablePointer(to: &val) {
-    setStaticIntRef($0)
-  }
+  setStaticIntRef(&val)
 }
 
 // CHECK: define {{(protected |dllexport )?}}swiftcc void @"$s4main9setCxxRefyyF"()
 // CHECK: call void @{{_Z15setStaticIntRefRi|"\?setStaticIntRef@@YAXAEAH@Z"}}(i32* {{nonnull %val|%2}})
 
 public func setCxxConstRef() {
   var val: CInt = 21
-  withUnsafePointer(to: &val) {
-    setConstStaticIntRef($0)
-  }
+  setConstStaticIntRef(&val)
 }
 
 // CHECK: define {{(protected |dllexport )?}}swiftcc void @"$s4main14setCxxConstRefyyF"()
 // CHECK: call void @{{_Z20setConstStaticIntRefRKi|"\?setConstStaticIntRef@@YAXAEBH@Z"}}(i32* {{nonnull %val|%2}})
 
 public func setCxxRvalueRef() {
   var val: CInt = 21
-  withUnsafeMutablePointer(to: &val) {
-    setStaticIntRvalueRef($0)
-  }
+  setStaticIntRvalueRef(&val)
 }
 
 // CHECK: define {{(protected |dllexport )?}}swiftcc void @"$s4main15setCxxRvalueRefyyF"()
 // CHECK: call void @{{_Z21setStaticIntRvalueRefOi|"\?setStaticIntRvalueRef@@YAX\$\$QEAH@Z"}}(i32* {{nonnull %val|%2}})
 
 public func setCxxConstRvalueRef() {
   var val: CInt = 21
-  withUnsafePointer(to: &val) {
-    setConstStaticIntRvalueRef($0)
-  }
+  setConstStaticIntRvalueRef(&val)
 }
 
 // CHECK: define {{(protected |dllexport )?}}swiftcc void @"$s4main20setCxxConstRvalueRefyyF"()
diff --git a/test/Interop/Cxx/reference/reference-module-interface.swift b/test/Interop/Cxx/reference/reference-module-interface.swift
@@ -6,10 +6,10 @@
 // CHECK: func getConstStaticIntRef() -> UnsafePointer<Int32>
 // CHECK: func getConstStaticIntRvalueRef() -> UnsafePointer<Int32>
 // CHECK: func setStaticInt(_: Int32)
-// CHECK: func setStaticIntRef(_: UnsafeMutablePointer<Int32>)
-// CHECK: func setStaticIntRvalueRef(_: UnsafeMutablePointer<Int32>)
-// CHECK: func setConstStaticIntRef(_: UnsafePointer<Int32>)
-// CHECK: func setConstStaticIntRvalueRef(_: UnsafePointer<Int32>)
+// CHECK: func setStaticIntRef(_: inout Int32)
+// CHECK: func setStaticIntRvalueRef(_: inout Int32)
+// CHECK: func setConstStaticIntRef(_: inout Int32)
+// CHECK: func setConstStaticIntRvalueRef(_: inout Int32)
 // CHECK: func getFuncRef() -> @convention(c) () -> Int32
 // CHECK: func getFuncRvalueRef() -> @convention(c) () -> Int32
 
diff --git a/test/Interop/Cxx/reference/reference-silgen.swift b/test/Interop/Cxx/reference/reference-silgen.swift
@@ -36,48 +36,36 @@ func getConstCxxRvalueRef() -> UnsafePointer<CInt> {
 
 func setCxxRef() {
   var val: CInt = 21
-  withUnsafeMutablePointer(to: &val) {
-    setStaticIntRef($0)
-  }
+  setStaticIntRef(&val)
 }
 
-// CHECK: // closure #1 in setCxxRef()
-// CHECK: sil private @$s4main9setCxxRefyyFySpys5Int32VGXEfU_ : $@convention(thin) (UnsafeMutablePointer<Int32>) -> ()
-// CHECK: [[REF:%.*]] = function_ref @{{_Z15setStaticIntRefRi|\?setStaticIntRef@@YAXAEAH@Z}} : $@convention(c) (UnsafeMutablePointer<Int32>) -> ()
-// CHECK: apply [[REF]](%0) : $@convention(c) (UnsafeMutablePointer<Int32>) -> ()
+// CHECK: sil hidden @$s4main9setCxxRefyyF : $@convention(thin) () -> ()
+// CHECK: [[REF:%.*]] = function_ref @{{_Z15setStaticIntRefRi|\?setStaticIntRef@@YAXAEAH@Z}} : $@convention(c) (@inout Int32) -> ()
+// CHECK: apply [[REF]](%{{[0-9]+}}) : $@convention(c) (@inout Int32) -> ()
 
 func setCxxConstRef() {
   var val: CInt = 21
-  withUnsafePointer(to: &val) {
-    setConstStaticIntRef($0)
-  }
+  setConstStaticIntRef(&val)
 }
 
-// CHECK: // closure #1 in setCxxConstRef()
-// CHECK: sil private @$s4main14setCxxConstRefyyFySPys5Int32VGXEfU_ : $@convention(thin) (UnsafePointer<Int32>) -> ()
-// CHECK: [[REF:%.*]] = function_ref @{{_Z20setConstStaticIntRefRKi|\?setConstStaticIntRef@@YAXAEBH@Z}} : $@convention(c) (UnsafePointer<Int32>) -> ()
-// CHECK: apply [[REF]](%0) : $@convention(c) (UnsafePointer<Int32>) -> ()
+// CHECK: sil hidden @$s4main14setCxxConstRefyyF : $@convention(thin) () -> ()
+// CHECK: [[REF:%.*]] = function_ref @{{_Z20setConstStaticIntRefRKi|\?setConstStaticIntRef@@YAXAEBH@Z}} : $@convention(c) (@inout Int32) -> ()
+// CHECK: apply [[REF]](%{{[0-9]+}}) : $@convention(c) (@inout Int32) -> ()
 
 func setCxxRvalueRef() {
   var val: CInt = 21
-  withUnsafeMutablePointer(to: &val) {
-    setStaticIntRvalueRef($0)
-  }
+  setStaticIntRvalueRef(&val)
 }
 
-// CHECK: // closure #1 in setCxxRvalueRef()
-// CHECK: sil private @$s4main15setCxxRvalueRefyyFySpys5Int32VGXEfU_ : $@convention(thin) (UnsafeMutablePointer<Int32>) -> ()
-// CHECK: [[REF:%.*]] = function_ref @{{_Z21setStaticIntRvalueRefOi|\?setStaticIntRvalueRef@@YAX\$\$QEAH@Z}} : $@convention(c) (UnsafeMutablePointer<Int32>) -> ()
-// CHECK: apply [[REF]](%0) : $@convention(c) (UnsafeMutablePointer<Int32>) -> ()
+// CHECK: sil hidden @$s4main15setCxxRvalueRefyyF : $@convention(thin) () -> ()
+// CHECK: [[REF:%.*]] = function_ref @{{_Z21setStaticIntRvalueRefOi|\?setStaticIntRvalueRef@@YAX\$\$QEAH@Z}} : $@convention(c) (@inout Int32) -> ()
+// CHECK: apply [[REF]](%{{[0-9]+}}) : $@convention(c) (@inout Int32) -> ()
 
 func setCxxConstRvalueRef() {
   var val: CInt = 21
-  withUnsafePointer(to: &val) {
-    setConstStaticIntRvalueRef($0)
-  }
+  setConstStaticIntRvalueRef(&val)
 }
 
-// CHECK: // closure #1 in setCxxConstRvalueRef()
-// CHECK: sil private @$s4main20setCxxConstRvalueRefyyFySPys5Int32VGXEfU_ : $@convention(thin) (UnsafePointer<Int32>) -> ()
-// CHECK: [[REF:%.*]] = function_ref @{{_Z26setConstStaticIntRvalueRefOKi|\?setConstStaticIntRvalueRef@@YAX\$\$QEBH@Z}} : $@convention(c) (UnsafePointer<Int32>) -> ()
-// CHECK: apply [[REF]](%0) : $@convention(c) (UnsafePointer<Int32>) -> ()
+// CHECK: sil hidden @$s4main20setCxxConstRvalueRefyyF : $@convention(thin) () -> ()
+// CHECK: [[REF:%.*]] = function_ref @{{_Z26setConstStaticIntRvalueRefOKi|\?setConstStaticIntRvalueRef@@YAX\$\$QEBH@Z}} : $@convention(c) (@inout Int32) -> ()
+// CHECK: apply [[REF]](%{{[0-9]+}}) : $@convention(c) (@inout Int32) -> ()
diff --git a/test/Interop/Cxx/reference/reference.swift b/test/Interop/Cxx/reference/reference.swift
@@ -40,36 +40,28 @@ ReferenceTestSuite.test("write-rvalue-reference") {
 ReferenceTestSuite.test("pass-lvalue-reference") {
   expectNotEqual(21, getStaticInt())
   var val: CInt = 21
-  withUnsafeMutablePointer(to: &val) {
-    setStaticIntRef($0)
-  }
+  setStaticIntRef(&val)
   expectEqual(21, getStaticInt())
 }
 
 ReferenceTestSuite.test("pass-const-lvalue-reference") {
   expectNotEqual(22, getStaticInt())
   var val: CInt = 22
-  withUnsafePointer(to: &val) {
-    setConstStaticIntRef($0)
-  }
+  setConstStaticIntRef(&val)
   expectEqual(22, getStaticInt())
 }
 
 ReferenceTestSuite.test("pass-rvalue-reference") {
   expectNotEqual(52, getStaticInt())
   var val: CInt = 52
-  withUnsafeMutablePointer(to: &val) {
-    setStaticIntRvalueRef($0)
-  }
+  setStaticIntRvalueRef(&val)
   expectEqual(52, getStaticInt())
 }
 
 ReferenceTestSuite.test("pass-const-rvalue-reference") {
   expectNotEqual(53, getStaticInt())
   var val: CInt = 53
-  withUnsafePointer(to: &val) {
-    setConstStaticIntRvalueRef($0)
-  }
+  setConstStaticIntRvalueRef(&val)
   expectEqual(53, getStaticInt())
 }
 
diff --git a/test/Interop/Cxx/stdlib/Inputs/fake-toolchain/bin/clang b/test/Interop/Cxx/stdlib/Inputs/fake-toolchain/bin/clang
diff --git a/test/Interop/Cxx/stdlib/Inputs/fake-toolchain/include/c++/v1/fake-toolchain.h b/test/Interop/Cxx/stdlib/Inputs/fake-toolchain/include/c++/v1/fake-toolchain.h
@@ -0,0 +1,10 @@
+#ifndef TEST_INTEROP_CXX_STDLIB_INPUTS_FAKE_TOOLCHAIN_H
+#define TEST_INTEROP_CXX_STDLIB_INPUTS_FAKE_TOOLCHAIN_H
+
+namespace FakeNamespace {
+
+void foo(int x) {}
+
+}; // namespace FakeNamespace
+
+#endif
diff --git a/test/Interop/Cxx/stdlib/Inputs/fake-toolchain/include/c++/v1/module.modulemap b/test/Interop/Cxx/stdlib/Inputs/fake-toolchain/include/c++/v1/module.modulemap
@@ -0,0 +1,4 @@
+module FakeToolchain [system] {
+  header "fake-toolchain.h"
+  export *
+}
diff --git a/test/Interop/Cxx/stdlib/fake-toolchain-module-interface.swift b/test/Interop/Cxx/stdlib/fake-toolchain-module-interface.swift
@@ -0,0 +1,8 @@
+// RUN: %target-swift-ide-test -print-module -module-to-print=FakeToolchain -tools-directory %S/Inputs/fake-toolchain/bin -source-filename=x -enable-cxx-interop -Xcc -stdlib=libc++ | %FileCheck %s
+
+// Clang driver on Windows doesn't support -stdlib=libc++
+// XFAIL: OS=windows-msvc
+
+// CHECK: extension FakeNamespace {
+// CHECK:   static func foo(_ x: Int32)
+// CHECK: }
diff --git a/test/Interop/Cxx/templates/defaulted-template-type-parameter-module-interface.swift b/test/Interop/Cxx/templates/defaulted-template-type-parameter-module-interface.swift
@@ -18,5 +18,5 @@
 // The following types aren't imported correctly, but that does not have to do
 // with the fact that the template type paramaters are defaulted.
 // CHECK: func defaultedTemplatePointerTypeParam<T>(_ t: OpaquePointer!)
-// CHECK: func defaultedTemplatePointerReferenceTypeParam<T>(_ t: UnsafeMutablePointer<OpaquePointer?>)
+// CHECK: func defaultedTemplatePointerReferenceTypeParam<T>(_ t: inout OpaquePointer!)
 // CHECK: func defaultedTemplatePointerPointerTypeParam<T>(_ t: UnsafeMutablePointer<OpaquePointer?>!)
diff --git a/test/ScanDependencies/module_deps.swift b/test/ScanDependencies/module_deps.swift
@@ -127,7 +127,7 @@ import SubE
 // CHECK-NEXT: "-frontend"
 // CHECK-NEXT: "-only-use-extra-clang-opts"
 // CHECK-NEXT: "-Xcc"
-// CHECK-NEXT: "clang"
+// CHECK-NEXT: "BUILD_DIR/bin/clang"
 // CHECK:      "-fsystem-module",
 // CHECK-NEXT: "-emit-pcm",
 // CHECK-NEXT: "-module-name",
diff --git a/test/ScanDependencies/module_deps_cache_reuse.swift b/test/ScanDependencies/module_deps_cache_reuse.swift
@@ -111,7 +111,7 @@ import SubE
 // CHECK-NEXT: "-frontend"
 // CHECK-NEXT: "-only-use-extra-clang-opts"
 // CHECK-NEXT: "-Xcc"
-// CHECK-NEXT: "clang"
+// CHECK-NEXT: "BUILD_DIR/bin/clang"
 // CHECK-NEXT: "-Xcc"
 // CHECK-NEXT: "-fsyntax-only",
 // CHECK:      "-fsystem-module",
diff --git a/test/stdlib/ArrayBuffer_CopyContents.swift b/test/stdlib/ArrayBuffer_CopyContents.swift
@@ -15,6 +15,10 @@
 // REQUIRES: swift_stdlib_asserts
 // REQUIRES: foundation
 
+// Test is crashing with older runtimes. rdar://82125328
+// UNSUPPORTED: use_os_stdlib
+// UNSUPPORTED: back_deployment_runtime
+
 import Foundation
 import StdlibUnittest
 
diff --git a/tools/swift-ide-test/swift-ide-test.cpp b/tools/swift-ide-test/swift-ide-test.cpp
@@ -283,6 +283,11 @@ static llvm::cl::list<std::string>
 SwiftVersion("swift-version", llvm::cl::desc("Swift version"),
              llvm::cl::cat(Category));
 
+static llvm::cl::opt<std::string>
+ToolsDirectory("tools-directory",
+               llvm::cl::desc("Path to external executables (ld, clang, binutils)"),
+               llvm::cl::cat(Category));
+
 static llvm::cl::list<std::string>
 ModuleCachePath("module-cache-path", llvm::cl::desc("Clang module cache path"),
                 llvm::cl::cat(Category));
@@ -3914,6 +3919,12 @@ int main(int argc, char *argv[]) {
         InitInvok.getLangOptions().EffectiveLanguageVersion = actual.getValue();
     }
   }
+  if (!options::ToolsDirectory.empty()) {
+    SmallString<128> toolsDir(options::ToolsDirectory);
+    llvm::sys::path::append(toolsDir, "clang");
+    InitInvok.getClangImporterOptions().clangPath =
+        std::string(toolsDir);
+  }
   if (!options::ModuleCachePath.empty()) {
     // Honor the *last* -module-cache-path specified.
     InitInvok.getClangImporterOptions().ModuleCachePath =
