Merge branch 'main' into wip-experimental-isolated-deinit

Author: ktoso

.github/CODEOWNERS

@@ -70,7 +70,7 @@
 /include/swift/AST/Evaluator*                      @CodaFi @slavapestov
 /include/swift/Basic/                              @DougGregor
 /include/swift/Basic/Features.def                  @DougGregor @hborla
-/include/swift/ClangImporter                       @zoecarver @hyp @egorzhdan @beccadax @ian-twilightcoder
+/include/swift/ClangImporter                       @zoecarver @hyp @egorzhdan @beccadax @ian-twilightcoder @Xazax-hun
 /include/swift/DependencyScan                      @artemcm
 /include/swift/Driver*/                            @artemcm
 /include/swift/Frontend*/                          @artemcm @tshortli
@@ -81,7 +81,7 @@
 /include/swift/Migrator/                           @nkcsgexi
 /include/swift/Option/*Options*                    @tshortli
 /include/swift/Parse/                              @ahoppen @bnbarham @CodaFi @DougGregor @hamishknight @rintaro
-/include/swift/PrintAsClang                        @zoecarver @hyp @egorzhdan
+/include/swift/PrintAsClang                        @zoecarver @hyp @egorzhdan @Xazax-hun
 /include/swift/Refactoring                         @ahoppen @bnbarham @hamishknight @rintaro
 /include/swift/Runtime/                            @rjmccall
 /include/swift/SIL/                                @jckarter
@@ -116,7 +116,7 @@
 /lib/ASTGen/                                        @ahoppen @bnbarham @CodaFi @hamishknight @rintaro
 /lib/Basic/                                         @DougGregor
 /lib/Basic/Windows                                  @compnerd
-/lib/ClangImporter                                  @zoecarver @hyp @egorzhdan @beccadax @ian-twilightcoder
+/lib/ClangImporter                                  @zoecarver @hyp @egorzhdan @beccadax @ian-twilightcoder @Xazax-hun
 /lib/ClangImporter/DWARFImporter*                   @adrian-prantl
 /lib/DependencyScan                                 @artemcm
 /lib/Driver*/                                       @artemcm
@@ -135,7 +135,7 @@
 /lib/Markup/                                        @nkcsgexi
 /lib/Migrator/                                      @nkcsgexi
 /lib/Parse/                                         @ahoppen @bnbarham @CodaFi @DougGregor @hamishknight @rintaro
-/lib/PrintAsClang                                   @zoecarver @hyp @egorzhdan
+/lib/PrintAsClang                                   @zoecarver @hyp @egorzhdan @Xazax-hun
 /lib/Refactoring/                                   @ahoppen @bnbarham @hamishknight @rintaro
 /lib/SIL/                                           @jckarter
 /lib/SIL/**/*DebugInfo*                             @adrian-prantl
@@ -177,7 +177,7 @@
 /stdlib/public/*Demangl*/                 @rjmccall
 /stdlib/public/Backtracing/               @al45tair
 /stdlib/public/Concurrency/               @ktoso
-/stdlib/public/Cxx/                       @zoecarver @hyp @egorzhdan
+/stdlib/public/Cxx/                       @zoecarver @hyp @egorzhdan @Xazax-hun
 /stdlib/public/Distributed/               @ktoso
 /stdlib/public/Observation/               @phausler
 /stdlib/public/SwiftRemoteMirror/         @slavapestov
@@ -202,7 +202,7 @@
 /test/IDE/                                          @ahoppen @bnbarham @hamishknight @rintaro
 /test/IRGen/                                        @rjmccall
 /test/Index/                                        @ahoppen @bnbarham @hamishknight @rintaro
-/test/Interop/                                      @zoecarver @hyp @egorzhdan
+/test/Interop/                                      @zoecarver @hyp @egorzhdan @Xazax-hun
 /test/Migrator/                                     @nkcsgexi
 /test/Parse/                                        @ahoppen @bnbarham @CodaFi @DougGregor @hamishknight @rintaro
 /test/Profiler                                      @ahoppen @bnbarham @hamishknight @rintaro

CHANGELOG.md

@@ -5,6 +5,22 @@
 
 ## Swift (next)
 
+* [SE-0444][]:
+  When the upcoming feature `MemberImportVisibility` is enabled, Swift will
+  require that a module be directly imported in a source file when resolving
+  member declarations from that module:
+  
+  ```swift
+  let recipe = "2 slices of bread, 1.5 tbs peanut butter".parse()
+  // error: instance method 'parse()' is inaccessible due to missing import of
+  //        defining module 'RecipeKit'
+  // note:  add import of module 'RecipeKit'
+  ```
+  
+  This new behavior prevents ambiguities from arising when a transitively
+  imported module declares a member that conflicts with a member of a directly
+  imported module.
+
 * Syntactic SourceKit queries no longer attempt to provide information
   within the inactive `#if` regions. For example, given:
 
@@ -10629,6 +10645,7 @@ using the `.dynamicType` member to retrieve the type of an expression should mig
 [SE-0428]: https://github.com/apple/swift-evolution/blob/main/proposals/0428-resolve-distributed-actor-protocols.md
 [SE-0431]: https://github.com/apple/swift-evolution/blob/main/proposals/0431-isolated-any-functions.md
 [SE-0442]: https://github.com/swiftlang/swift-evolution/blob/main/proposals/0442-allow-taskgroup-childtaskresult-type-to-be-inferred.md
+[SE-0444]: https://github.com/swiftlang/swift-evolution/blob/main/proposals/0444-member-import-visibility.md
 [#64927]: <https://github.com/apple/swift/issues/64927>
 [#42697]: <https://github.com/apple/swift/issues/42697>
 [#42728]: <https://github.com/apple/swift/issues/42728>

CMakeLists.txt

@@ -434,9 +434,8 @@ if("${CMAKE_SYSTEM_NAME}" STREQUAL "Windows" AND BOOTSTRAPPING_MODE STREQUAL "HO
 endif()
 
 if(BRIDGING_MODE STREQUAL "DEFAULT" OR NOT BRIDGING_MODE)
-  if(CMAKE_BUILD_TYPE STREQUAL "Debug" OR "${SWIFT_HOST_VARIANT_SDK}" STREQUAL "WINDOWS" OR (CMAKE_Swift_COMPILER AND CMAKE_Swift_COMPILER_VERSION VERSION_LESS 5.8))
+  if(CMAKE_BUILD_TYPE STREQUAL "Debug" OR (CMAKE_Swift_COMPILER AND CMAKE_Swift_COMPILER_VERSION VERSION_LESS 5.8))
     # In debug builds, to workaround a problem with LLDB's `po` command (rdar://115770255).
-    # On Windows, to workaround a build problem.
     # If the host Swift version is less than 5.8, use pure mode to workaround a C++ interop compiler crash.
     set(BRIDGING_MODE "PURE")
   else()

SwiftCompilerSources/CMakeLists.txt

@@ -177,6 +177,8 @@ function(add_swift_compiler_modules_library name)
   if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
     list(APPEND swift_compile_options "-static")
     list(APPEND sdk_option "-sdk" "${SWIFT_PATH_TO_SWIFT_SDK}")
+    # For "swift/shims/*.h".
+    list(APPEND sdk_option "-I" "${SWIFT_PATH_TO_SWIFT_SDK}/usr/lib")
 
     # Workaround a crash in the LoadableByAddress pass
     # https://github.com/apple/swift/issues/73254
@@ -188,6 +190,12 @@ function(add_swift_compiler_modules_library name)
     if (CMAKE_Swift_COMPILER_VERSION VERSION_LESS 6.0)
       list(APPEND swift_compile_options "-Xcc" "-D_ALLOW_COMPILER_AND_STL_VERSION_MISMATCH")
     endif()
+
+    # Make 'offsetof()' a const value.
+    list(APPEND swift_compile_options "-Xcc" "-D_CRT_USE_BUILTIN_OFFSETOF")
+
+    # Workaround for https://github.com/swiftlang/llvm-project/issues/7172
+    list(APPEND swift_compile_options "-Xcc" "-Xclang" "-Xcc" "-fmodule-format=raw")
   else()
     list(APPEND sdk_option "-I" "${swift_exec_bin_dir}/../lib" "-I" "${sdk_path}/usr/lib")
   endif()

SwiftCompilerSources/Package.swift

@@ -58,9 +58,6 @@ private extension Target {
 let package = Package(
   name: "SwiftCompilerSources",
   platforms: [
-    // We need at least macOS 13 here to avoid hitting an availability error
-    // for CxxStdlib. It's only needed for the package though, the CMake build
-    // works fine with a lower deployment target.
     .macOS(.v13),
   ],
   products: [

SwiftCompilerSources/Sources/Optimizer/DataStructures/FunctionUses.swift

@@ -128,21 +128,21 @@ struct FunctionUses {
 
     for vTable in context.vTables {
       for entry in vTable.entries {
-        markUnknown(entry.function)
+        markUnknown(entry.implementation)
       }
     }
 
     for witnessTable in context.witnessTables {
       for entry in witnessTable.entries {
-        if entry.kind == .Method, let f = entry.methodFunction {
+        if entry.kind == .method, let f = entry.methodFunction {
           markUnknown(f)
         }
       }
     }
 
     for witnessTable in context.defaultWitnessTables {
       for entry in witnessTable.entries {
-        if entry.kind == .Method, let f = entry.methodFunction {
+        if entry.kind == .method, let f = entry.methodFunction {
           markUnknown(f)
         }
       }

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt

@@ -7,6 +7,7 @@
 # See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 
 swift_compiler_sources(Optimizer
+  SimplifyAllocRefDynamic.swift
   SimplifyApply.swift
   SimplifyBeginBorrow.swift
   SimplifyBeginCOWMutation.swift

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyAllocRefDynamic.swift

@@ -0,0 +1,54 @@
+//===--- SimplifyAllocRefDynamic.swift ------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+
+extension AllocRefDynamicInst : OnoneSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+    /// Optimize alloc_ref_dynamic of a known type to alloc_ref:
+    ///
+    ///   %3 = metatype SubClass.Type
+    ///   %4 = upcast %3 : SubClass.Type to BaseClass.Type
+    ///   %6 = alloc_ref_dynamic [...] %4 : BaseClass.Type, $BaseClass
+    ///   %8 = (... some use of ...) %6 : $BaseClass
+    /// ->
+    ///   %6 = alloc_ref [...] $SubClass
+    ///   %7 = upcast %6 : $SubClass to $BaseClass
+    ///   %8 = (... some use of ...) %7 : $BaseClass
+
+    let type: Type
+    let emitUpcast: Bool
+    if let metatypeInst = metatypeOperand.value as? MetatypeInst {
+      type = metatypeInst.type.loweredInstanceTypeOfMetatype(in: parentFunction)
+      emitUpcast = false
+    } else if let upcastInst = metatypeOperand.value as? UpcastInst,
+        let metatypeInst = upcastInst.operands[0].value as? MetatypeInst {
+      type = metatypeInst.type.loweredInstanceTypeOfMetatype(in: parentFunction)
+      emitUpcast = true
+    } else {
+      return
+    }
+
+    let builder = Builder(before: self, context)
+    let newAlloc = builder.createAllocRef(type, isObjC: self.isObjC, canAllocOnStack: self.canAllocOnStack, isBare: false,
+      tailAllocatedTypes: self.tailAllocatedTypes, tailAllocatedCounts: Array(self.tailAllocatedCounts.values))
+    
+    let result: Value
+    if emitUpcast {
+      result = builder.createUpcast(from: newAlloc, to: self.type)
+    } else {
+      result = newAlloc
+    }
+    uses.replaceAll(with: result, context)
+    context.erase(instruction: self)
+  }
+}

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyRefCasts.swift

@@ -116,7 +116,10 @@ private func insertCompensatingInstructions(for inst: Instruction, in failureBlo
   let newInst: SingleValueInstruction
   switch inst {
   case let ier as InitExistentialRefInst:
-    newInst = builder.createInitExistentialRef(instance: newArg, existentialType: ier.type, useConformancesOf: ier)
+    newInst = builder.createInitExistentialRef(instance: newArg,
+                                               existentialType: ier.type,
+                                               formalConcreteType: ier.formalConcreteType,
+                                               conformances: ier.conformances)
   case let uc as UpcastInst:
     newInst = builder.createUpcast(from: newArg, to: uc.type)
   default:

SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift

@@ -33,13 +33,23 @@ let mandatoryPerformanceOptimizations = ModulePass(name: "mandatory-performance-
   // For embedded Swift, optimize all the functions (there cannot be any
   // generics, type metadata, etc.)
   if moduleContext.options.enableEmbeddedSwift {
+    // We need to specialize all vtables which are referenced from non-generic contexts. Beside
+    // `alloc_ref`s of generic classes in non-generic functions, we also need to specialize generic
+    // superclasses of non-generic classes. E.g. `class Derived : Base<Int> {}`
+    specializeVTablesOfSuperclasses(moduleContext)
+
     worklist.addAllNonGenericFunctions(of: moduleContext)
   } else {
     worklist.addAllPerformanceAnnotatedFunctions(of: moduleContext)
     worklist.addAllAnnotatedGlobalInitOnceFunctions(of: moduleContext)
   }
 
   optimizeFunctionsTopDown(using: &worklist, moduleContext)
+
+  if moduleContext.options.enableEmbeddedSwift {
+    // Print errors for generic functions in vtables, which is not allowed in embedded Swift.
+    checkVTablesForGenericFunctions(moduleContext)
+  }
 }
 
 private func optimizeFunctionsTopDown(using worklist: inout FunctionWorklist,
@@ -92,17 +102,26 @@ private func optimize(function: Function, _ context: FunctionPassContext, _ modu
       // Embedded Swift specific transformations
       case let alloc as AllocRefInst:
         if context.options.enableEmbeddedSwift {
-          specializeVTableAndAddEntriesToWorklist(for: alloc.type, in: function, context, moduleContext, &worklist)
+          specializeVTableAndAddEntriesToWorklist(for: alloc.type, in: function,
+                                                  errorLocation: alloc.location,
+                                                  moduleContext, &worklist)
         }
       case let metatype as MetatypeInst:
         if context.options.enableEmbeddedSwift {
-          specializeVTableAndAddEntriesToWorklist(for: metatype.type, in: function, context, moduleContext, &worklist)
+          specializeVTableAndAddEntriesToWorklist(for: metatype.type, in: function,
+                                                  errorLocation: metatype.location,
+                                                  moduleContext, &worklist)
         }
       case let classMethod as ClassMethodInst:
         if context.options.enableEmbeddedSwift {
           _ = context.specializeClassMethodInst(classMethod)
         }
 
+      case let initExRef as InitExistentialRefInst:
+        if context.options.enableEmbeddedSwift {
+          specializeWitnessTables(for: initExRef, moduleContext, &worklist)
+        }
+
       // We need to de-virtualize deinits of non-copyable types to be able to specialize the deinitializers.
       case let destroyValue as DestroyValueInst:
         if !devirtualizeDeinits(of: destroyValue, simplifyCtxt) {
@@ -144,19 +163,24 @@ private func optimize(function: Function, _ context: FunctionPassContext, _ modu
 }
 
 private func specializeVTableAndAddEntriesToWorklist(for type: Type, in function: Function,
-                                                     _ context: FunctionPassContext, _ moduleContext: ModulePassContext,
+                                                     errorLocation: Location,
+                                                     _ moduleContext: ModulePassContext,
                                                      _ worklist: inout FunctionWorklist) {
   let vTablesCountBefore = moduleContext.vTables.count
 
-  guard context.specializeVTable(for: type, in: function) != nil else {
+  guard specializeVTable(forClassType: type, errorLocation: errorLocation, moduleContext) != nil else {
     return
   }
 
   // More than one new vtable might have been created (superclasses), process them all
   let vTables = moduleContext.vTables
   for i in vTablesCountBefore ..< vTables.count {
-    for entry in vTables[i].entries {
-      worklist.pushIfNotVisited(entry.function)
+    for entry in vTables[i].entries
+      // A new vtable can still contain a generic function if the method couldn't be specialized for some reason
+      // and an error has been printed. Exclude generic functions to not run into an assert later.
+      where !entry.implementation.isGeneric
+    {
+      worklist.pushIfNotVisited(entry.implementation)
     }
   }
 }
@@ -240,6 +264,45 @@ private func shouldInline(apply: FullApplySite, callee: Function, alreadyInlined
   return false
 }
 
+private func specializeWitnessTables(for initExRef: InitExistentialRefInst, _ context: ModulePassContext,
+                                     _ worklist: inout FunctionWorklist)
+{
+  for conformance in initExRef.conformances where conformance.isConcrete {
+    let origWitnessTable = context.lookupWitnessTable(for: conformance)
+    if conformance.isSpecialized {
+      if origWitnessTable == nil {
+        let wt = specializeWitnessTable(forConformance: conformance, errorLocation: initExRef.location, context)
+        worklist.addWitnessMethods(of: wt)
+      }
+    } else if let origWitnessTable {
+      checkForGenericMethods(in: origWitnessTable, errorLocation: initExRef.location, context)
+    }
+  }
+}
+
+private func checkForGenericMethods(in witnessTable: WitnessTable,
+                                    errorLocation: Location,
+                                    _ context: ModulePassContext)
+{
+  for entry in witnessTable.entries where entry.kind == .method {
+    if let method = entry.methodFunction,
+       method.isGeneric
+    {
+      context.diagnosticEngine.diagnose(errorLocation.sourceLoc, .cannot_specialize_witness_method,
+                                        entry.methodRequirement)
+      return
+    }
+  }
+}
+
+private func checkVTablesForGenericFunctions(_ context: ModulePassContext) {
+  for vTable in context.vTables where !vTable.class.isGenericAtAnyLevel {
+    for entry in vTable.entries where entry.implementation.isGeneric {
+      context.diagnosticEngine.diagnose(entry.methodDecl.location.sourceLoc, .non_final_generic_class_function)
+    }
+  }
+}
+
 private extension FullApplySite {
   func resultIsUsedInGlobalInitialization() -> SmallProjectionPath? {
     guard parentFunction.isGlobalInitOnceFunction,
@@ -445,6 +508,18 @@ fileprivate struct FunctionWorklist {
     }
   }
 
+  mutating func addWitnessMethods(of witnessTable: WitnessTable) {
+    for entry in witnessTable.entries where entry.kind == .method {
+      if let method = entry.methodFunction,
+         // A new witness table can still contain a generic function if the method couldn't be specialized for
+         // some reason and an error has been printed. Exclude generic functions to not run into an assert later.
+         !method.isGeneric
+      {
+        pushIfNotVisited(method)
+      }
+    }
+  }
+
   mutating func pushIfNotVisited(_ element: Function) {
     if pushedFunctions.insert(element).inserted {
       functions.append(element)