Merge pull request #4325 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

docs/CppInteropability/GettingStartedWithC++Interop.md

@@ -1,6 +1,6 @@
 #  Getting started with C++ Interoperability
 
-This document is desgined to get you started with bidirectional API-level interoperability between Swift and C++.
+This document is designed to get you started with bidirectional API-level interoperability between Swift and C++.
 
 ## Table of Contents
 
@@ -35,7 +35,7 @@ Add the C++ module to the include path and enable C++ interop:
 - Navigate to your project directory 
 - In `Project` navigate to `Build Settings` -> `Swift Compiler`
 - Under `Custom Flags` -> `Other Swift Flags` add`-Xfrontend -enable-cxx-interop`
-- Under `Search Paths` -> `Import Paths` add your search path to the C++ module (i.e, `./ProjectName/Cxx`).
+- Under `Search Paths` -> `Import Paths` add your search path to the C++ module (i.e, `./ProjectName/Cxx`). Repeat this step in `Other Swift Flags` 
 
 ```
 //Add to Other Swift Flags and Import Paths respectively
@@ -46,15 +46,14 @@ Add the C++ module to the include path and enable C++ interop:
 - This should now allow your to import your C++ Module into any `.swift` file.
 
 ```
-//In ViewController.swift
-import UIKit
+//In ContentView.swift
+import SwiftUI
 import Cxx
 
-class ViewController: UIViewController {
-    override func viewDidLoad() {
-        super.viewDidLoad()
-        let result = cxxFunction(7)
-        print(result)
+struct ContentView: View {
+    var body: some View {
+        Text("Cxx function result: \(cxxFunction(7))")
+            .padding()
     }
 }
 ```
@@ -86,8 +85,8 @@ int cxxFunction(int n);
 After creating your Swift package project, follow the steps [Creating a Module to contain your C++ source code](#creating-a-module-to-contain-your-c-source-code) in your `Source` directory
 
 - In your Package Manifest, you need to configure the Swift target's dependencies and compiler flags
-- In this example the name of the package is `Cxx_Interop`
-- Swift code will be in `Sources/Cxx_Interop` called `main.swift`
+- In this example the name of the package is `CxxInterop`
+- Swift code will be in `Sources/CxxInterop` called `main.swift`
 - C++ source code follows the example shown in [Creating a Module to contain your C++ source code](#creating-a-module-to-contain-your-c-source-code)
 - Under targets, add the name of your C++ module and the directory containing the Swift code as a target.
 - In the target defining your Swift target, add a`dependencies` to the C++ Module, the `path`, `source`, and `swiftSettings` with `unsafeFlags` with the source to the C++ Module, and enable `-enable-cxx-interop`
@@ -98,25 +97,25 @@ After creating your Swift package project, follow the steps [Creating a Module t
 import PackageDescription
 
 let package = Package(
-    name: "Cxx_Interop",
+    name: "CxxInterop",
     platforms: [.macOS(.v12)],
     products: [
         .library(
             name: "Cxx",
             targets: ["Cxx"]),
         .library(
-            name: "Cxx_Interop",
-            targets: ["Cxx_Interop"]),
+            name: "CxxInterop",
+            targets: ["CxxInterop"]),
     ],
     targets: [
         .target(
             name: "Cxx",
             dependencies: []
         ),
         .executableTarget(
-            name: "Cxx_Interop",
+            name: "CxxInterop",
             dependencies: ["Cxx"],
-            path: "./Sources/Cxx_Interop",
+            path: "./Sources/CxxInterop",
             sources: [ "main.swift" ],
             swiftSettings: [.unsafeFlags([
                 "-I", "Sources/Cxx",
@@ -135,14 +134,14 @@ let package = Package(
 
 import Cxx
 
-public struct Cxx_Interop {
+public struct CxxInterop {
     
     public func callCxxFunction(n: Int32) -> Int32 {
         return cxxFunction(n: n)
     }
 }
 
-print(Cxx_Interop().callCxxFunction(n: 7))
+print(CxxInterop().callCxxFunction(n: 7))
 //outputs: 7
 
 ```
@@ -161,7 +160,7 @@ After creating your project follow the steps [Creating a Module to contain your
 
 cmake_minimum_required(VERSION 3.18)
 
-project(Cxx_Interop LANGUAGES CXX Swift)
+project(CxxInterop LANGUAGES CXX Swift)
 
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED YES)
@@ -176,10 +175,10 @@ target_compile_options(cxx-support PRIVATE
 target_include_directories(cxx-support PUBLIC
   ${CMAKE_SOURCE_DIR}/Sources/Cxx)
 
-add_executable(Cxx_Interop ./Sources/Cxx_Interop/main.swift)
-target_compile_options(Cxx_Interop PRIVATE
+add_executable(CxxInterop ./Sources/CxxInterop/main.swift)
+target_compile_options(CxxInterop PRIVATE
   "SHELL:-Xfrontend -enable-cxx-interop"
-target_link_libraries(Cxx_Interop PRIVATE cxx-support)
+target_link_libraries(CxxInterop PRIVATE cxx-support)
 
 ```
 
@@ -188,14 +187,14 @@ target_link_libraries(Cxx_Interop PRIVATE cxx-support)
 
 import Cxx
 
-public struct Cxx_Interop {
+public struct CxxInterop {
     public static func main() {
         let result = cxxFunction(7)
         print(result)
     }
 }
 
-Cxx_Interop.main()
+CxxInterop.main()
 
 ```
 

include/swift/ABI/TypeIdentity.h

@@ -19,6 +19,7 @@
 #define SWIFT_ABI_TYPEIDENTITY_H
 
 #include "swift/Basic/LLVM.h"
+#include <llvm/ADT/Optional.h>
 #include <llvm/ADT/StringRef.h>
 
 namespace swift {

include/swift/AST/ActorIsolation.h

@@ -47,7 +47,7 @@ bool isLetAccessibleAnywhere(const ModuleDecl *fromModule, VarDecl *let);
 /// the actors with which it can interact.
 class ActorIsolation {
 public:
-  enum Kind {
+  enum Kind : uint8_t {
     /// The actor isolation has not been specified. It is assumed to be
     /// unsafe to interact with this declaration from any actor.
     Unspecified = 0,
@@ -69,18 +69,19 @@ class ActorIsolation {
   };
 
 private:
-  Kind kind;
   union {
     NominalTypeDecl *actor;
     Type globalActor;
     void *pointer;
   };
+  uint8_t kind : 3;
+  uint8_t isolatedByPreconcurrency : 1;
 
   ActorIsolation(Kind kind, NominalTypeDecl *actor)
-      : kind(kind), actor(actor) { }
+      : actor(actor), kind(kind), isolatedByPreconcurrency(false) { }
 
   ActorIsolation(Kind kind, Type globalActor)
-      : kind(kind), globalActor(globalActor) { }
+      : globalActor(globalActor), kind(kind), isolatedByPreconcurrency(false) { }
 
 public:
   static ActorIsolation forUnspecified() {
@@ -100,7 +101,7 @@ class ActorIsolation {
         unsafe ? GlobalActorUnsafe : GlobalActor, globalActor);
   }
 
-  Kind getKind() const { return kind; }
+  Kind getKind() const { return (Kind)kind; }
 
   operator Kind() const { return getKind(); }
 
@@ -122,6 +123,16 @@ class ActorIsolation {
     return globalActor;
   }
 
+  bool preconcurrency() const {
+    return isolatedByPreconcurrency;
+  }
+
+  ActorIsolation withPreconcurrency(bool value) const {
+    auto copy = *this;
+    copy.isolatedByPreconcurrency = value;
+    return copy;
+  }
+
   /// Determine whether this isolation will require substitution to be
   /// evaluated.
   bool requiresSubstitution() const;
@@ -134,10 +145,10 @@ class ActorIsolation {
     if (lhs.isGlobalActor() && rhs.isGlobalActor())
       return areTypesEqual(lhs.globalActor, rhs.globalActor);
 
-    if (lhs.kind != rhs.kind)
+    if (lhs.getKind() != rhs.getKind())
       return false;
 
-    switch (lhs.kind) {
+    switch (lhs.getKind()) {
     case Independent:
     case Unspecified:
       return true;

include/swift/AST/Decl.h

@@ -5930,6 +5930,14 @@ class SubscriptDecl : public GenericContext, public AbstractStorageDecl {
                                DeclContext *Parent,
                                GenericParamList *GenericParams);
 
+  static SubscriptDecl *create(ASTContext &Context, DeclName Name,
+                               SourceLoc StaticLoc,
+                               StaticSpellingKind StaticSpelling,
+                               SourceLoc SubscriptLoc, ParameterList *Indices,
+                               SourceLoc ArrowLoc, Type ElementTy,
+                               DeclContext *Parent,
+                               GenericParamList *GenericParams);
+
   static SubscriptDecl *createImported(ASTContext &Context, DeclName Name,
                                        SourceLoc SubscriptLoc,
                                        ParameterList *Indices,

include/swift/AST/DiagnosticsSema.def

@@ -4500,9 +4500,10 @@ NOTE(note_distributed_actor_system_conformance_missing_adhoc_requirement,none,
 ERROR(override_implicit_unowned_executor,none,
       "cannot override an actor's 'unownedExecutor' property that wasn't "
       "explicitly defined", ())
-ERROR(actor_isolated_from_deinit,none,
-      "actor-isolated %0 %1 can not be referenced from a non-isolated deinit",
-      (DescriptiveDeclKind, DeclName))
+ERROR(actor_isolated_from_decl,none,
+      "actor-isolated %0 %1 can not be referenced from a non-isolated "
+      "%select{deinit|autoclosure|closure}2",
+      (DescriptiveDeclKind, DeclName, unsigned))
 ERROR(actor_isolated_non_self_reference,none,
         "actor-isolated %0 %1 can not be "
         "%select{referenced|mutated|used 'inout'}2 "

include/swift/AST/Expr.h

@@ -255,7 +255,7 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
     Kind : 2
   );
 
-  SWIFT_INLINE_BITFIELD(ClosureExpr, AbstractClosureExpr, 1+1+1,
+  SWIFT_INLINE_BITFIELD(ClosureExpr, AbstractClosureExpr, 1+1+1+1,
     /// True if closure parameters were synthesized from anonymous closure
     /// variables.
     HasAnonymousClosureVars : 1,
@@ -266,7 +266,11 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
 
     /// True if this @Sendable async closure parameter should implicitly
     /// inherit the actor context from where it was formed.
-    InheritActorContext : 1
+    InheritActorContext : 1,
+
+    /// True if this closure's actor isolation behavior was determined by an
+    /// \c \@preconcurrency declaration.
+    IsolatedByPreconcurrency : 1
   );
 
   SWIFT_INLINE_BITFIELD_FULL(BindOptionalExpr, Expr, 16,
@@ -3537,40 +3541,46 @@ class ClosureActorIsolation {
   };
 
 private:
-    /// The actor to which this closure is isolated.
+    /// The actor to which this closure is isolated, plus a bit indicating
+    /// whether the isolation was imposed by a preconcurrency declaration.
     ///
-    /// There are three possible states:
+    /// There are three possible states for the pointer:
     ///   - NULL: The closure is independent of any actor.
     ///   - VarDecl*: The 'self' variable for the actor instance to which
     ///     this closure is isolated. It will always have a type that conforms
     ///     to the \c Actor protocol.
     ///   - Type: The type of the global actor on which
-  llvm::PointerUnion<VarDecl *, Type> storage;
+  llvm::PointerIntPair<llvm::PointerUnion<VarDecl *, Type>, 1, bool> storage;
 
-  ClosureActorIsolation(VarDecl *selfDecl) : storage(selfDecl) { }
-  ClosureActorIsolation(Type globalActorType) : storage(globalActorType) { }
+  ClosureActorIsolation(VarDecl *selfDecl, bool preconcurrency)
+      : storage(selfDecl, preconcurrency) { }
+  ClosureActorIsolation(Type globalActorType, bool preconcurrency)
+      : storage(globalActorType, preconcurrency) { }
 
 public:
-  ClosureActorIsolation() : storage() { }
+  ClosureActorIsolation(bool preconcurrency = false)
+      : storage(nullptr, preconcurrency) { }
 
-  static ClosureActorIsolation forIndependent() {
-    return ClosureActorIsolation();
+  static ClosureActorIsolation forIndependent(bool preconcurrency) {
+    return ClosureActorIsolation(preconcurrency);
   }
 
-  static ClosureActorIsolation forActorInstance(VarDecl *selfDecl) {
-    return ClosureActorIsolation(selfDecl);
+  static ClosureActorIsolation forActorInstance(VarDecl *selfDecl,
+                                                bool preconcurrency) {
+    return ClosureActorIsolation(selfDecl, preconcurrency);
   }
 
-  static ClosureActorIsolation forGlobalActor(Type globalActorType) {
-    return ClosureActorIsolation(globalActorType);
+  static ClosureActorIsolation forGlobalActor(Type globalActorType,
+                                              bool preconcurrency) {
+    return ClosureActorIsolation(globalActorType, preconcurrency);
   }
 
   /// Determine the kind of isolation.
   Kind getKind() const {
-    if (storage.isNull())
+    if (storage.getPointer().isNull())
       return Kind::Independent;
 
-    if (storage.is<VarDecl *>())
+    if (storage.getPointer().is<VarDecl *>())
       return Kind::ActorInstance;
 
     return Kind::GlobalActor;
@@ -3587,11 +3597,15 @@ class ClosureActorIsolation {
   }
 
   VarDecl *getActorInstance() const {
-    return storage.dyn_cast<VarDecl *>();
+    return storage.getPointer().dyn_cast<VarDecl *>();
   }
 
   Type getGlobalActor() const {
-    return storage.dyn_cast<Type>();
+    return storage.getPointer().dyn_cast<Type>();
+  }
+
+  bool preconcurrency() const {
+    return storage.getInt();
   }
 };
 
@@ -3864,6 +3878,16 @@ class ClosureExpr : public AbstractClosureExpr {
     Bits.ClosureExpr.InheritActorContext = value;
   }
 
+  /// Whether the closure's concurrency behavior was determined by an
+  /// \c \@preconcurrency declaration.
+  bool isIsolatedByPreconcurrency() const {
+    return Bits.ClosureExpr.IsolatedByPreconcurrency;
+  }
+
+  void setIsolatedByPreconcurrency(bool value = true) {
+    Bits.ClosureExpr.IsolatedByPreconcurrency = value;
+  }
+
   /// Determine whether this closure expression has an
   /// explicitly-specified result type.
   bool hasExplicitResultType() const { return ArrowLoc.isValid(); }

include/swift/AST/Module.h

@@ -939,6 +939,9 @@ inline SourceLoc extractNearestSourceLoc(const ModuleDecl *mod) {
   return extractNearestSourceLoc(static_cast<const Decl *>(mod));
 }
 
+/// Collects modules that this module imports via `@_exported import`.
+void collectParsedExportedImports(const ModuleDecl *M, SmallPtrSetImpl<ModuleDecl *> &Imports);
+
 } // end namespace swift
 
 #endif

include/swift/Basic/DiverseStack.h

@@ -395,8 +395,7 @@ class DiverseValueBuffer {
 public:
   DiverseValueBuffer(const T &value) {
     size_t size = value.allocated_size();
-    data.reserve(size);
-    data.set_size(size);
+    data.resize_for_overwrite(size);
     memcpy(data.data(), reinterpret_cast<const void *>(&value), size);
   }
 

include/swift/Basic/Fingerprint.h

@@ -15,6 +15,7 @@
 
 #include "swift/Basic/StableHasher.h"
 #include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 

include/swift/Basic/SourceLoc.h

@@ -20,6 +20,7 @@
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/LLVM.h"
 #include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/SMLoc.h"
 #include <functional>