Merge pull request #4723 from swiftwasm/katei/merge-main-2022-07-30

Merge main 2022-07-30

Author: kateinoigakukun

CHANGELOG.md

@@ -10,7 +10,7 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
   The compiler flag `-enable-upcoming-feature X` can now be used to enable a specific feature `X` that has been accepted by the evolution process, but whose introduction into the language is waiting for the next major version (e.g., version 6). The `X` is specified by any proposal that falls into this category:
   * `ConciseMagicFile` enables the new `#file` semantics in [SE-0274][].
   * `ForwardTrailingClosures` disables the "backward" scanning behavior of [SE-0286][].
-  * `BareSlashRegexLiterals` enables the regex literal syntax of [SE-0352][].
+  * `BareSlashRegexLiterals` enables the regex literal syntax of [SE-0354][].
 
   Features can be detected in source code with `#if hasFeature(X)`.
 

CMakeLists.txt

@@ -454,6 +454,15 @@ set(SWIFT_DARWIN_DEPLOYMENT_VERSION_TVOS "9.0" CACHE STRING
 set(SWIFT_DARWIN_DEPLOYMENT_VERSION_WATCHOS "2.0" CACHE STRING
     "Minimum deployment target version for watchOS")
 
+#
+#  Compatibility library deployment versions
+#
+
+set(COMPATIBILITY_MINIMUM_DEPLOYMENT_VERSION_OSX "10.9")
+set(COMPATIBILITY_MINIMUM_DEPLOYMENT_VERSION_IOS "7.0")
+set(COMPATIBILITY_MINIMUM_DEPLOYMENT_VERSION_TVOS "9.0")
+set(COMPATIBILITY_MINIMUM_DEPLOYMENT_VERSION_WATCHOS "2.0")
+
 #
 # User-configurable debugging options.
 #

SwiftCompilerSources/CMakeLists.txt

@@ -165,6 +165,7 @@ function(add_swift_compiler_modules_library name)
     add_custom_command_target(dep_target OUTPUT ${module_obj_file}
       WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
       DEPENDS ${sources} ${deps} ${ALS_DEPENDS}
+        importedHeaderDependencies
       COMMAND ${ALS_SWIFT_EXEC} "-c" "-o" ${module_obj_file}
               ${sdk_option}
               "-target" ${target}
@@ -229,6 +230,24 @@ else()
 
   add_subdirectory(Sources)
 
+  # This is a hack to get correct dependencies from imported C++ headers:
+  # step 1: generate a dummy source file, which just includes all headers defined in include/swift/module.modulemap
+  add_custom_command(
+    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/HeaderDependencies.cpp"
+    COMMAND
+        "sed"
+        -n -e "/header/!d" -e "s/.*header/#include/" -e "w ${CMAKE_CURRENT_BINARY_DIR}/HeaderDependencies.cpp"
+        "${CMAKE_SOURCE_DIR}/include/swift/module.modulemap"
+    DEPENDS "${CMAKE_SOURCE_DIR}/include/swift/module.modulemap"
+    COMMENT "Generate HeaderDependencies.cpp"
+)
+  
+  # step 2: build a library containing that source file. This library depends on all the included header files.
+  #         The swift modules can now depend on that target.
+  #         Note that this library is unused, i.e. not linked to anything.   
+  add_library(importedHeaderDependencies "${CMAKE_CURRENT_BINARY_DIR}/HeaderDependencies.cpp")
+  target_include_directories(importedHeaderDependencies PRIVATE "${CMAKE_SOURCE_DIR}/include/swift")
+
   if(${BOOTSTRAPPING_MODE} MATCHES "HOSTTOOLS|CROSSCOMPILE")
 
     if (NOT SWIFT_EXEC_FOR_SWIFT_MODULES)

SwiftCompilerSources/Sources/AST/DiagnosticEngine.swift

@@ -21,7 +21,7 @@ public protocol DiagnosticArgument {
 }
 extension String: DiagnosticArgument {
   public func _withBridgedDiagnosticArgument(_ fn: (swift.DiagnosticArgument) -> Void) {
-    withBridgedStringRef { fn(swift.DiagnosticArgument(llvm.StringRef($0))) }
+    _withStringRef { fn(swift.DiagnosticArgument($0)) }
   }
 }
 extension Int: DiagnosticArgument {
@@ -42,10 +42,10 @@ public struct DiagnosticFixIt {
   }
 
   func withBridgedDiagnosticFixIt(_ fn: (swift.DiagnosticInfo.FixIt) -> Void) {
-    text.withBridgedStringRef { bridgedTextRef in
+    text._withStringRef { bridgedTextRef in
       let bridgedDiagnosticFixIt = swift.DiagnosticInfo.FixIt(
         swift.CharSourceRange(start.bridged, UInt32(byteLength)),
-        llvm.StringRef(bridgedTextRef),
+        bridgedTextRef,
         llvm.ArrayRef<swift.DiagnosticArgument>())
       fn(bridgedDiagnosticFixIt)
     }

SwiftCompilerSources/Sources/Basic/Utils.swift

@@ -18,16 +18,18 @@ import std
 //===----------------------------------------------------------------------===//
 
 public struct StringRef : CustomStringConvertible, CustomReflectable {
-  let _bridged : BridgedStringRef
+  let _bridged: llvm.StringRef
 
-  public init(bridged: BridgedStringRef) { self._bridged = bridged }
+  public init(bridged: llvm.StringRef) { self._bridged = bridged }
 
   public var string: String { _bridged.string }
   public var description: String { string }
   public var customMirror: Mirror { Mirror(self, children: []) }
 
   public static func ==(lhs: StringRef, rhs: StaticString) -> Bool {
-    let lhsBuffer = UnsafeBufferPointer<UInt8>(start: lhs._bridged.data, count: Int(lhs._bridged.length))
+    let lhsBuffer = UnsafeBufferPointer<UInt8>(
+      start: lhs._bridged.__bytes_beginUnsafe(),
+      count: Int(lhs._bridged.__bytes_endUnsafe() - lhs._bridged.__bytes_beginUnsafe()))
     return rhs.withUTF8Buffer { (rhsBuffer: UnsafeBufferPointer<UInt8>) in
       if lhsBuffer.count != rhsBuffer.count { return false }
       return lhsBuffer.elementsEqual(rhsBuffer, by: ==)
@@ -41,24 +43,19 @@ public struct StringRef : CustomStringConvertible, CustomReflectable {
 //                            Bridging Utilities
 //===----------------------------------------------------------------------===//
 
-extension BridgedStringRef {
-  public var string: String {
-    let buffer = UnsafeBufferPointer<UInt8>(start: data, count: Int(length))
-    return String(decoding: buffer, as: UTF8.self)
-  }
-}
-
 extension llvm.StringRef {
-  public init(_ bridged: BridgedStringRef) {
-    self.init(bridged.data, bridged.length)
+  public var string: String {
+    String(_cxxString: self.str())
   }
 }
 
 extension String {
-  public func withBridgedStringRef<T>(_ c: (BridgedStringRef) -> T) -> T {
+  /// Underscored to avoid name collision with Swift LLVM Bindings.
+  /// To be replaced with a bindings call once bindings are a dependency.
+  public func _withStringRef<T>(_ c: (llvm.StringRef) -> T) -> T {
     var str = self
     return str.withUTF8 { buffer in
-      return c(BridgedStringRef(data: buffer.baseAddress, length: buffer.count))
+      return c(llvm.StringRef(buffer.baseAddress, buffer.count))
     }
   }
 

SwiftCompilerSources/Sources/Optimizer/PassManager/PassContext.swift

@@ -66,7 +66,7 @@ struct PassContext {
 
   func loadFunction(name: StaticString) -> Function? {
     return name.withUTF8Buffer { (nameBuffer: UnsafeBufferPointer<UInt8>) in
-      PassContext_loadFunction(_bridged, BridgedStringRef(data: nameBuffer.baseAddress, length: nameBuffer.count)).function
+      PassContext_loadFunction(_bridged, llvm.StringRef(nameBuffer.baseAddress, nameBuffer.count)).function
     }
   }
 

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -24,15 +24,15 @@ public func initializeSwiftModules() {
 private func registerPass(
       _ pass: FunctionPass,
       _ runFn: @escaping (@convention(c) (BridgedFunctionPassCtxt) -> ())) {
-  pass.name.withBridgedStringRef { nameStr in
+  pass.name._withStringRef { nameStr in
     SILPassManager_registerFunctionPass(nameStr, runFn)
   }
 }
 
 private func registerPass<InstType: Instruction>(
       _ pass: InstructionPass<InstType>,
       _ runFn: @escaping (@convention(c) (BridgedInstructionPassCtxt) -> ())) {
-  pass.name.withBridgedStringRef { nameStr in
+  pass.name._withStringRef { nameStr in
     SILCombine_registerInstructionPass(nameStr, runFn)
   }
 }

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -61,7 +61,7 @@ public struct Builder {
       operandType: Type, resultType: Type, arguments: [Value]) -> BuiltinInst {
     notifyInstructionsChanged()
     return arguments.withBridgedValues { valuesRef in
-      return name.withBridgedStringRef { nameStr in
+      return name._withStringRef { nameStr in
         let bi = SILBuilder_createBuiltinBinaryFunction(
           bridged, nameStr, operandType.bridged, resultType.bridged, valuesRef)
         return bi.getAs(BuiltinInst.self)
@@ -71,7 +71,7 @@ public struct Builder {
 
   public func createCondFail(condition: Value, message: String) -> CondFailInst {
     notifyInstructionsChanged()
-    return message.withBridgedStringRef { messageStr in
+    return message._withStringRef { messageStr in
       let cf = SILBuilder_createCondFail(bridged, condition.bridged, messageStr)
       return cf.getAs(CondFailInst.self)
     }

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -67,7 +67,7 @@ final public class Function : CustomStringConvertible, HasShortDescription {
 
   public func hasSemanticsAttribute(_ attr: StaticString) -> Bool {
     attr.withUTF8Buffer { (buffer: UnsafeBufferPointer<UInt8>) in
-      SILFunction_hasSemanticsAttr(bridged, BridgedStringRef(data: buffer.baseAddress!, length: buffer.count)) != 0
+      SILFunction_hasSemanticsAttr(bridged, llvm.StringRef(buffer.baseAddress!, buffer.count)) != 0
     }
   }
 
@@ -105,18 +105,18 @@ final public class Function : CustomStringConvertible, HasShortDescription {
       // writeFn
       { (f: BridgedFunction, os: BridgedOStream, idx: Int) in
         let s = f.function.effects.argumentEffects[idx].description
-        s.withBridgedStringRef { OStream_write(os, $0) }
+        s._withStringRef { OStream_write(os, $0) }
       },
       // parseFn:
-      { (f: BridgedFunction, str: BridgedStringRef, fromSIL: Int, isDerived: Int, paramNames: BridgedArrayRef) -> BridgedParsingError in
+      { (f: BridgedFunction, str: llvm.StringRef, fromSIL: Int, isDerived: Int, paramNames: BridgedArrayRef) -> BridgedParsingError in
         do {
           var parser = StringParser(str.string)
           let effect: ArgumentEffect
           if fromSIL != 0 {
             effect = try parser.parseEffectFromSIL(for: f.function, isDerived: isDerived != 0)
           } else {
-            let paramToIdx = paramNames.withElements(ofType: BridgedStringRef.self) {
-                (buffer: UnsafeBufferPointer<BridgedStringRef>) -> Dictionary<String, Int> in
+            let paramToIdx = paramNames.withElements(ofType: llvm.StringRef.self) {
+                (buffer: UnsafeBufferPointer<llvm.StringRef>) -> Dictionary<String, Int> in
               let keyValPairs = buffer.enumerated().lazy.map { ($0.1.string, $0.0) }
               return Dictionary(uniqueKeysWithValues: keyValPairs)
             }

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -14,7 +14,7 @@ import Basic
 import SILBridging
 
 private func register<T: AnyObject>(_ cl: T.Type) {
-  String(describing: cl).withBridgedStringRef { nameStr in
+  String(describing: cl)._withStringRef { nameStr in
     let metatype = unsafeBitCast(cl, to: SwiftMetatype.self)
     registerBridgedClass(nameStr, metatype)
   }