Merge branch 'main' into address-only-operators

Author: Huddie

SwiftCompilerSources/CMakeLists.txt

@@ -75,7 +75,7 @@ function(add_swift_compiler_modules_library name)
 
   set(swift_compile_options
       "-Xfrontend" "-validate-tbd-against-ir=none"
-      "-Xfrontend" "-enable-cxx-interop"
+      "-Xfrontend" "-enable-experimental-cxx-interop"
       "-Xcc" "-UIBOutlet" "-Xcc" "-UIBAction" "-Xcc" "-UIBInspectable")
   if (NOT BOOTSTRAPPING_MODE STREQUAL "HOSTTOOLS")
     list(APPEND swift_compile_options "-Xfrontend" "-disable-implicit-string-processing-module-import")

SwiftCompilerSources/Package.swift

@@ -17,7 +17,7 @@ private extension Target {
   static let defaultSwiftSettings: [SwiftSetting] = [
     .unsafeFlags([
       "-Xfrontend", "-validate-tbd-against-ir=none",
-      "-Xfrontend", "-enable-cxx-interop",
+      "-Xfrontend", "-enable-experimental-cxx-interop",
       // Bridging modules and headers
       "-Xcc", "-I", "-Xcc", "../include",
       "-cross-module-optimization"

SwiftCompilerSources/Sources/SIL/BasicBlock.swift

@@ -25,7 +25,8 @@ final public class BasicBlock : ListNode, CustomStringConvertible, HasShortDescr
   public var function: Function { SILBasicBlock_getFunction(bridged).function }
 
   public var description: String {
-    String(_cxxString: SILBasicBlock_debugDescription(bridged))
+    let stdString = SILBasicBlock_debugDescription(bridged)
+    return String(_cxxString: stdString)
   }
   public var shortDescription: String { name }
 

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -21,7 +21,8 @@ final public class Function : CustomStringConvertible, HasShortDescription {
   }
 
   final public var description: String {
-    String(_cxxString: SILFunction_debugDescription(bridged))
+    let stdString = SILFunction_debugDescription(bridged)
+    return String(_cxxString: stdString)
   }
 
   public var shortDescription: String { name.string }

SwiftCompilerSources/Sources/SIL/GlobalVariable.swift

@@ -19,7 +19,8 @@ final public class GlobalVariable : CustomStringConvertible, HasShortDescription
   }
 
   public var description: String {
-    String(_cxxString: SILGlobalVariable_debugDescription(bridged))
+    let stdString = SILGlobalVariable_debugDescription(bridged)
+    return String(_cxxString: stdString)
   }
 
   public var shortDescription: String { name.string }

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -38,7 +38,8 @@ public class Instruction : ListNode, CustomStringConvertible, Hashable {
   final public var function: Function { block.function }
 
   final public var description: String {
-    String(_cxxString: SILNode_debugDescription(bridgedNode))
+    let stdString = SILNode_debugDescription(bridgedNode)
+    return String(_cxxString: stdString)
   }
 
   final public var operands: OperandArray {
@@ -142,7 +143,8 @@ public class SingleValueInstruction : Instruction, Value {
 
 public final class MultipleValueInstructionResult : Value {
   final public var description: String {
-    String(_cxxString: SILNode_debugDescription(bridgedNode))
+    let stdString = SILNode_debugDescription(bridgedNode)
+    return String(_cxxString: stdString)
   }
 
   public var instruction: Instruction {

SwiftCompilerSources/Sources/SIL/Value.swift

@@ -81,7 +81,8 @@ public enum Ownership {
 
 extension Value {
   public var description: String {
-    String(_cxxString: SILNode_debugDescription(bridgedNode))
+    let stdString = SILNode_debugDescription(bridgedNode)
+    return String(_cxxString: stdString)
   }
 
   public var uses: UseList {

docs/ABI/Mangling.rst

@@ -349,6 +349,7 @@ Entities
   entity-spec ::= 'fE'                       // ivar destroyer; untyped
   entity-spec ::= 'fe'                       // ivar initializer; untyped
   entity-spec ::= 'Tv' NATURAL               // outlined global variable (from context function)
+  entity-spec ::= 'Tv' NATURAL 'r'           // outlined global read-only object
   entity-spec ::= 'Te' bridge-spec           // outlined objective c method call
 
   entity-spec ::= decl-name label-list function-signature generic-signature? 'F'    // function

docs/CppInteroperability/CppInteroperabilityStatus.md

@@ -140,7 +140,31 @@ This status table describes which of the following Swift language features have
 | **Swift Language Feature**     | **Implemented Experimental Support For Using It In C++** |
 |--------------------------------|----------------------------------------------------------|
 | Top-level `@_cdecl` functions  | Yes                                                      |
-| Top-level Swift functions      | Partially, only with C compatible types                  |
-| `inout` parameters             | No                                                       |
+| Top-level Swift functions      | Partially, only with primitive and Swift struct types    |
+| `inout` parameters             | Yes                                                      |
 | Variadic parameters            | No                                                       |
 | Multiple return values         | No                                                       |
+
+**Structs**
+
+| **Swift Language Feature**     | **Implemented Experimental Support For Using It In C++** |
+|--------------------------------|----------------------------------------------------------|
+| Fixed layout structs           | Yes                                                      |
+| Resilient / opaque structs     | Yes                                                      |
+| Copy and destroy semantics     | Yes                                                      |
+| Initializers                   | Partially, as static `init` methods. No failable support |
+
+**Methods**
+
+| **Swift Language Feature**     | **Implemented Experimental Support For Using It In C++** |
+|--------------------------------|----------------------------------------------------------|
+| Instance methods               | Yes, for structs only                                    |
+| Static methods                 | No                                                       |
+
+**Properties**
+
+| **Swift Language Feature**     | **Implemented Experimental Support For Using It In C++** |
+|--------------------------------|----------------------------------------------------------|
+| Getter accessors               | Yes, via `get<name>`. For structs only                   |
+| Setter accessors               | No                                                       |
+| Mutation accessors             | No                                                       |

docs/DevelopmentTips.md

@@ -23,10 +23,25 @@ Copy the invocation that has  ` -o <build-path>/swift-macosx-x86_64/stdlib/publi
 ### Choosing the bootstrapping mode
 By default, the compiler builds with the `boostrapping-with-hostlibs` (macOS) or `bootstrapping` (Linux) bootstrapping mode. To speed up local development it's recommended to build with the `hosttools` mode: `utils/build-script --bootstrapping=hosttools`.
 
-It requires a recently new swift toolchain to be installed on your build machine. On macOS this comes with your Xcode installation.
+It requires a recently new swift toolchain to be installed on your build machine. You might need to download and install a nightly Swift toolchain to build the Swift project in `hosttools` mode.
 
 Not that changing the bootstrapping mode needs a reconfiguration.
 
+#### Using a locally built Swift toolchain
+
+If you do not want to install a nightly Swift toolchain, or you need to debug Swift code within SwiftCompilerSources, you can build the Swift toolchain in `boostrapping-with-hostlibs` mode on your local machine once, and then use this toolchain to iterate on your changes with the `hosttools` mode:
+
+* Build the toolchain locally in `boostrapping-with-hostlibs` mode: `./utils/build-toolchain com.yourname`.
+* Copy the `swift-LOCAL-YYYY-MM-DD.xctoolchain` file from `./swift-nightly-install/Library/Developer/Toolchains` to `/Library/Developer/Toolchains`.
+* Launch Xcode, in the menu bar select _Xcode_ > _Toolchains_ > _Local Swift Development Snapshot YYYY-MM-DD_.
+* Remove the Swift build directory: `./build`.
+* Run the Swift build script with the locally built Swift toolchain in `hosttools` mode: `TOOLCHAINS=com.yourname.YYYYMMDD ./utils/build-script --bootstrapping=hosttools`. Repeat this step as you iterate on your change.
+
+To debug using LLDB, run LLDB from the locally built toolchain with a couple of environment variables set:
+```
+DYLD_LIBRARY_PATH=/Library/Developer/Toolchains/swift-LOCAL-YYYY-MM-DD.xctoolchain/usr/lib/swift/macosx DYLD_FRAMEWORK_PATH=/Applications/Xcode.app/Contents/Developer/Library/Frameworks /Library/Developer/Toolchains/swift-LOCAL-YYYY-MM-DD.xctoolchain/usr/bin/lldb
+```
+
 ### Working with two build directories
 For developing and debugging you are probably building a debug configuration of swift. But it's often beneficial to also build a release-assert configuration in parallel (`utils/build-script -R`).
 

docs/HowToGuides/GettingStarted.md

@@ -376,6 +376,7 @@ In project settings, locate `Build, Execution, Deployment > CMake`. You will nee
     - `-D SWIFT_PATH_TO_CMARK_BUILD=SOME_PATH/swift-project/build/Ninja-RelWithDebInfoAssert/cmark-macosx-arm64 -D LLVM_DIR=SOME_PATH/swift-project/build/Ninja-RelWithDebInfoAssert/llvm-macosx-arm64/lib/cmake/llvm -D Clang_DIR=SOME_PATH/swift-project/build/Ninja-RelWithDebInfoAssert/llvm-macosx-arm64/lib/cmake/clang -D CMAKE_BUILD_TYPE=RelWithDebInfoAssert -G Ninja -S .`
     - replace the `SOME_PATH` to the path where your `swift-project` directory is
     - the CMAKE_BUILD_TYPE should match the build configuration name, so if you named this profile `RelWithDebInfo` the CMAKE_BUILD_TYPE should also be `RelWithDebInfo`
+    - **Note**: If you're using an intel machine to build swift, you'll need to replace the architecture in the options. (ex: `arm64` with `x86_64`)
 
 With this done, CLion should be able to successfully import the project and have full autocomplete and code navigation powers.
 

include/swift/ABI/Metadata.h

@@ -55,6 +55,7 @@ template <typename Runtime> struct TargetStructMetadata;
 template <typename Runtime> struct TargetOpaqueMetadata;
 template <typename Runtime> struct TargetValueMetadata;
 template <typename Runtime> struct TargetForeignClassMetadata;
+template <typename Runtime> struct TargetForeignReferenceTypeMetadata;
 template <typename Runtime> struct TargetContextDescriptor;
 template <typename Runtime> class TargetTypeContextDescriptor;
 template <typename Runtime> class TargetClassDescriptor;
@@ -258,6 +259,7 @@ struct TargetMetadata {
     case MetadataKind::Class:
     case MetadataKind::ObjCClassWrapper:
     case MetadataKind::ForeignClass:
+    case MetadataKind::ForeignReferenceType:
       return true;
 
     default:
@@ -375,6 +377,9 @@ struct TargetMetadata {
     case MetadataKind::ForeignClass:
       return static_cast<const TargetForeignClassMetadata<Runtime> *>(this)
           ->Description;
+    case MetadataKind::ForeignReferenceType:
+      return static_cast<const TargetForeignReferenceTypeMetadata<Runtime> *>(this)
+          ->Description;
     default:
       return nullptr;
     }
@@ -1159,6 +1164,44 @@ struct TargetForeignClassMetadata : public TargetForeignTypeMetadata<Runtime> {
 };
 using ForeignClassMetadata = TargetForeignClassMetadata<InProcess>;
 
+/// The structure of metadata objects for foreign reference types.
+/// A foreign reference type is a non-Swift, non-Objective-C foreign type with
+/// reference semantics. Foreign reference types are pointers/reference to
+/// value types marked with the "import_as_ref" attribute.
+///
+/// Foreign reference types may have *custom* reference counting operations, or
+/// they may be immortal (and therefore trivial).
+///
+/// We assume for now that foreign reference types are entirely opaque
+/// to Swift introspection.
+template <typename Runtime>
+struct TargetForeignReferenceTypeMetadata : public TargetForeignTypeMetadata<Runtime> {
+  using StoredPointer = typename Runtime::StoredPointer;
+
+  /// An out-of-line description of the type.
+  TargetSignedPointer<Runtime, const TargetClassDescriptor<Runtime> * __ptrauth_swift_type_descriptor> Description;
+
+  /// Reserved space.  For now, this should be zero-initialized.
+  /// If this is used for anything in the future, at least some of these
+  /// first bits should be flags.
+  StoredPointer Reserved[1];
+
+  ConstTargetMetadataPointer<Runtime, TargetClassDescriptor>
+  getDescription() const {
+    return Description;
+  }
+
+  typename Runtime::StoredSignedPointer
+  getDescriptionAsSignedPointer() const {
+    return Description;
+  }
+
+  static bool classof(const TargetMetadata<Runtime> *metadata) {
+    return metadata->getKind() == MetadataKind::ForeignReferenceType;
+  }
+};
+using ForeignReferenceTypeMetadata = TargetForeignReferenceTypeMetadata<InProcess>;
+
 /// The common structure of metadata for structs and enums.
 template <typename Runtime>
 struct TargetValueMetadata : public TargetMetadata<Runtime> {

include/swift/ABI/MetadataKind.def

@@ -53,6 +53,9 @@ NOMINALTYPEMETADATAKIND(Optional, 2 | MetadataKindIsNonHeap)
 /// A foreign class, such as a Core Foundation class.
 METADATAKIND(ForeignClass, 3 | MetadataKindIsNonHeap)
 
+/// A non-Swift non-Objective-C class type.
+METADATAKIND(ForeignReferenceType, 4 | MetadataKindIsNonHeap)
+
 /// A type whose value is not exposed in the metadata system.
 METADATAKIND(Opaque, 0 | MetadataKindIsRuntimePrivate | MetadataKindIsNonHeap)
 

include/swift/ABI/MetadataValues.h

@@ -899,6 +899,7 @@ class ExtendedExistentialTypeShapeFlags {
   SpecialKind getSpecialKind() const {
     return SpecialKind((Data & SpecialKindMask) >> SpecialKindShift);
   }
+  bool isOpaque() const { return getSpecialKind() == SpecialKind::None; }
   bool isClassConstrained() const {
     return getSpecialKind() == SpecialKind::Class;
   }

include/swift/APIDigester/ModuleAnalyzerNodes.h

@@ -157,6 +157,7 @@ struct CheckerOptions {
   bool PrintModule;
   bool SwiftOnly;
   bool SkipOSCheck;
+  bool SkipRemoveDeprecatedCheck;
   bool CompilerStyle;
   bool Migrator;
   StringRef LocationFilter;

include/swift/AST/ASTContext.h

@@ -223,11 +223,13 @@ class ASTContext final {
   ASTContext(const ASTContext&) = delete;
   void operator=(const ASTContext&) = delete;
 
-  ASTContext(LangOptions &langOpts, TypeCheckerOptions &typecheckOpts,
-             SILOptions &silOpts, SearchPathOptions &SearchPathOpts,
-             ClangImporterOptions &ClangImporterOpts,
-             symbolgraphgen::SymbolGraphOptions &SymbolGraphOpts,
-             SourceManager &SourceMgr, DiagnosticEngine &Diags);
+  ASTContext(
+      LangOptions &langOpts, TypeCheckerOptions &typecheckOpts,
+      SILOptions &silOpts, SearchPathOptions &SearchPathOpts,
+      ClangImporterOptions &ClangImporterOpts,
+      symbolgraphgen::SymbolGraphOptions &SymbolGraphOpts,
+      SourceManager &SourceMgr, DiagnosticEngine &Diags,
+      std::function<bool(llvm::StringRef, bool)> PreModuleImportCallback = {});
 
 public:
   // Members that should only be used by ASTContext.cpp.
@@ -238,11 +240,13 @@ class ASTContext final {
 
   void operator delete(void *Data) throw();
 
-  static ASTContext *get(LangOptions &langOpts, TypeCheckerOptions &typecheckOpts,
-                         SILOptions &silOpts, SearchPathOptions &SearchPathOpts,
-                         ClangImporterOptions &ClangImporterOpts,
-                         symbolgraphgen::SymbolGraphOptions &SymbolGraphOpts,
-                         SourceManager &SourceMgr, DiagnosticEngine &Diags);
+  static ASTContext *
+  get(LangOptions &langOpts, TypeCheckerOptions &typecheckOpts,
+      SILOptions &silOpts, SearchPathOptions &SearchPathOpts,
+      ClangImporterOptions &ClangImporterOpts,
+      symbolgraphgen::SymbolGraphOptions &SymbolGraphOpts,
+      SourceManager &SourceMgr, DiagnosticEngine &Diags,
+      std::function<bool(llvm::StringRef, bool)> PreModuleImportCallback = {});
   ~ASTContext();
 
   /// Optional table of counters to report, nullptr when not collecting.
@@ -374,6 +378,10 @@ class ASTContext final {
   llvm::BumpPtrAllocator &
   getAllocator(AllocationArena arena = AllocationArena::Permanent) const;
 
+  /// An optional generic callback function invoked prior to importing a module.
+  mutable std::function<bool(llvm::StringRef ModuleName, bool IsOverlay)>
+      PreModuleImportCallback;
+
 public:
   /// Allocate - Allocate memory from the ASTContext bump pointer.
   void *Allocate(unsigned long bytes, unsigned alignment,
@@ -1107,6 +1115,9 @@ class ASTContext final {
   /// If a module by this name has already been loaded, the existing module will
   /// be returned.
   ///
+  /// \param ModulePath The module's \c ImportPath which describes
+  /// the name of the module being loaded, possibly including submodules.
+
   /// \returns The requested module, or NULL if the module cannot be found.
   ModuleDecl *getModule(ImportPath::Module ModulePath);
 

include/swift/AST/ASTMangler.h

@@ -197,7 +197,7 @@ class ASTMangler : public Mangler {
                                              Type GlobalActorBound,
                                              ModuleDecl *Module);
 
-  std::string mangleDistributedThunk(const FuncDecl *thunk);
+  std::string mangleDistributedThunk(const AbstractFunctionDecl *thunk);
 
   /// Mangle a completion handler block implementation function, used for importing ObjC
   /// APIs as async.

include/swift/AST/Attr.def

@@ -664,7 +664,7 @@ SIMPLE_DECL_ATTR(_inheritActorContext, InheritActorContext,
 // 117 was 'spawn' and is now unused
 
 CONTEXTUAL_SIMPLE_DECL_ATTR(distributed, DistributedActor,
-  DeclModifier | OnClass | OnFunc | OnVar |
+  DeclModifier | OnClass | OnFunc | OnAccessor | OnVar |
   ABIBreakingToAdd | ABIBreakingToRemove |
   APIBreakingToAdd | APIBreakingToRemove,
   118)
@@ -735,6 +735,12 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(_local, KnownToBeLocal,
   APIBreakingToAdd | APIBreakingToRemove,
   130)
 
+SIMPLE_DECL_ATTR(_distributed_thunk, DistributedThunk,
+  OnFunc | UserInaccessible |
+  ABIBreakingToAdd | ABIBreakingToRemove |
+  APIBreakingToAdd | APIBreakingToRemove,
+  131)
+
 // If you're adding a new underscored attribute here, please document it in
 // docs/ReferenceGuides/UnderscoredAttributes.md.
 

include/swift/AST/Decl.h

@@ -5355,6 +5355,10 @@ class VarDecl : public AbstractStorageDecl {
   /// Does this have a 'distributed' modifier?
   bool isDistributed() const;
 
+  /// Return a distributed thunk if this computed property is marked as
+  /// 'distributed' and and nullptr otherwise.
+  FuncDecl *getDistributedThunk() const;
+
   /// Is this var known to be a "local" distributed actor,
   /// if so the implicit throwing ans some isolation checks can be skipped.
   bool isKnownToBeLocal() const;
@@ -5744,6 +5748,10 @@ class ParamDecl : public VarDecl {
     Bits.ParamDecl.defaultArgumentKind = static_cast<unsigned>(K);
   }
 
+  void setDefaultArgumentKind(ArgumentAttrs K) {
+    setDefaultArgumentKind(K.argumentKind);
+  }
+
   bool isNoImplicitCopy() const {
     return getAttrs().hasAttribute<NoImplicitCopyAttr>();
   }
@@ -6406,6 +6414,9 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// A function is concurrent if it has the @Sendable attribute.
   bool isSendable() const;
 
+  /// Determine if function has 'nonisolated' attribute
+  bool isNonisolated() const;
+
   /// Returns true if the function is a suitable 'async' context.
   ///
   /// Functions that are an 'async' context can make calls to 'async' functions.
@@ -6425,6 +6436,10 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// Returns 'true' if the function is distributed.
   bool isDistributed() const;
 
+  /// Is this a thunk function used to access a distributed method outside
+  /// of its actor isolation context?
+  bool isDistributedThunk() const;
+
   /// For a 'distributed' target (func or computed property),
   /// get the 'thunk' responsible for performing the 'remoteCall'.
   ///
@@ -6753,7 +6768,7 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   bool hasDynamicSelfResult() const;
 
   /// The async function marked as the alternative to this function, if any.
-  AbstractFunctionDecl *getAsyncAlternative() const;
+  AbstractFunctionDecl *getAsyncAlternative(bool isKnownObjC = false) const;
 
   /// If \p asyncAlternative is set, then compare its parameters to this
   /// (presumed synchronous) function's parameters to find the index of the