[pull] swiftwasm from main

cmake/modules/AddSwift.cmake

@@ -796,6 +796,7 @@ function(add_libswift name)
   # Create a static libswift library containing all module object files.
   add_library(${name} STATIC ${all_obj_files})
   set_target_properties(${name} PROPERTIES LINKER_LANGUAGE CXX)
+  set_property(GLOBAL APPEND PROPERTY SWIFT_BUILDTREE_EXPORTS ${name})
 endfunction()
 
 macro(add_swift_tool_subdirectory name)

cmake/modules/SwiftConfig.cmake.in

@@ -17,6 +17,8 @@ set(SWIFT_LIBRARY_DIR "@SWIFT_LIBRARY_DIRS@")
 set(SWIFT_CMAKE_DIR "@SWIFT_CMAKE_DIR@")
 set(SWIFT_BINARY_DIR "@SWIFT_BINARY_DIR@")
 
+set(LIBSWIFT_BUILD_MODE "@LIBSWIFT_BUILD_MODE@")
+
 set(CMARK_TARGETS_FILE @SWIFT_PATH_TO_CMARK_BUILD@/src/cmarkTargets.cmake)
 if(NOT TARGET libcmark_static AND EXISTS ${CMARK_TARGETS_FILE})
   include(${CMARK_TARGETS_FILE})

docs/SIL.rst

@@ -3985,13 +3985,41 @@ bind_memory
 
   sil-instruction ::= 'bind_memory' sil-operand ',' sil-operand 'to' sil-type
 
-  bind_memory %0 : $Builtin.RawPointer, %1 : $Builtin.Word to $T
+  %token = bind_memory %0 : $Builtin.RawPointer, %1 : $Builtin.Word to $T
   // %0 must be of $Builtin.RawPointer type
   // %1 must be of $Builtin.Word type
+  // %token is an opaque $Builtin.Word representing the previously bound types
+  // for this memory region.
 
 Binds memory at ``Builtin.RawPointer`` value ``%0`` to type ``$T`` with enough
 capacity to hold ``%1`` values. See SE-0107: UnsafeRawPointer.
 
+Produces a opaque token representing the previous memory state. For
+memory binding semantics, this state includes the type that the memory
+was previously bound to. The token cannot, however, be used to
+retrieve a metatype. It's value is only meaningful to the Swift
+runtime for typed pointer verification.
+
+rebind_memory
+`````````````
+
+::
+
+  sil-instruction ::= 'rebind_memory' sil-operand ' 'to' sil-value
+
+  %out_token = rebind_memory %0 : $Builtin.RawPointer to %in_token
+  // %0 must be of $Builtin.RawPointer type
+  // %in_token represents a cached set of bound types from a prior memory state.
+  // %out_token is an opaque $Builtin.Word representing the previously bound
+  // types for this memory region.
+
+This instruction's semantics are identical to ``bind_memory``, except
+that the types to which memory will be bound, and the extent of the
+memory region is unknown at compile time. Instead, the bound-types are
+represented by a token that was produced by a prior memory binding
+operation. ``%in_token`` must be the result of bind_memory or
+rebind_memory.
+
 begin_access
 ````````````
 

include/swift/ABI/MetadataValues.h

@@ -2022,6 +2022,12 @@ enum class JobPriority : size_t {
   Unspecified     = 0x00,
 };
 
+/// A tri-valued comparator which orders higher priorities first.
+inline int descendingPriorityOrder(JobPriority lhs,
+                                   JobPriority rhs) {
+  return (lhs == rhs ? 0 : lhs > rhs ? -1 : 1);
+}
+
 /// Flags for task creation.
 class TaskCreateFlags : public FlagSet<size_t> {
 public:

include/swift/AST/ASTMangler.h

@@ -56,6 +56,10 @@ class ASTMangler : public Mangler {
   /// to fill these in.
   bool AllowSymbolicReferences = false;
 
+  /// If enabled, allows the use of standard substitutions for types in the
+  /// standard library.
+  bool AllowStandardSubstitutions = true;
+
   /// If enabled, allows the use of standard substitutions for types in the
   /// concurrency library.
   bool AllowConcurrencyStandardSubstitutions = true;

include/swift/AST/Builtins.def

@@ -452,9 +452,18 @@ BUILTIN_SIL_OPERATION(BeginCOWMutation_native, "beginCOWMutation_native", Specia
 /// inout argument. After calling this builtin, the buffer must not be mutated.
 BUILTIN_SIL_OPERATION(EndCOWMutation, "endCOWMutation", Special)
 
-/// bindMemory : <T> (Builtin.RawPointer, Builtin.Word, T.Type) -> ()
+/// bindMemory : <T> (Builtin.RawPointer, Builtin.Word, T.Type) -> Builtin.Word
+///
+/// Binds memory to a statically known type. Returns an opaque token
+/// representing the memory region's previously bound types.
 BUILTIN_SIL_OPERATION(BindMemory, "bindMemory", Special)
 
+/// rebindMemory : (Builtin.RawPointer, Builtin.Word) -> Builtin.Word
+///
+/// Binds memory to the types represented by an opaque token operand. Returns an
+/// opaque token representing the memory region's previously bound types.
+BUILTIN_SIL_OPERATION(RebindMemory, "rebindMemory", Special)
+
 /// allocWithTailElems_<n>(C.Type,
 ///                    Builtin.Word, E1.Type, ... , Builtin.Word, En.Type) -> C\
 ///

include/swift/AST/Decl.h

@@ -169,6 +169,7 @@ enum class DescriptiveDeclKind : uint8_t {
   Method,
   StaticMethod,
   ClassMethod,
+  DistributedMethod,
   Getter,
   Setter,
   Addressor,
@@ -5300,6 +5301,9 @@ class VarDecl : public AbstractStorageDecl {
   /// Returns true if the name is the self identifier and is implicit.
   bool isSelfParameter() const;
 
+  /// Check whether the variable is the "self" of an actor method.
+  bool isActorSelf() const;
+
   /// Determine whether this property will be part of the implicit memberwise
   /// initializer.
   ///

include/swift/AST/DiagnosticsSema.def

@@ -4363,7 +4363,7 @@ NOTE(note_add_distributed_to_decl,none,
      "add 'distributed' to %0 to make this %1 witness the protocol requirement",
      (DeclName, DescriptiveDeclKind))
 NOTE(note_distributed_requirement_defined_here,none,
-     "distributed function requirement %0 declared here",
+     "distributed instance method requirement %0 declared here",
      (DeclName))
 NOTE(note_add_globalactor_to_function,none,
      "add '@%0' to make %1 %2 part of global actor %3", 
@@ -4502,13 +4502,13 @@ NOTE(note_distributed_actor_isolated_method,none,
      "distributed actor-isolated %0 %1 declared here",
      (DescriptiveDeclKind, DeclName))
 ERROR(distributed_actor_isolated_method,none,
-      "only 'distributed' functions can be called on a potentially remote distributed actor",
+      "only 'distributed' instance methods can be called on a potentially remote distributed actor",
       ())
 ERROR(distributed_actor_func_param_not_codable,none,
-      "distributed function parameter '%0' of type %1 does not conform to 'Codable'",
+      "distributed instance method parameter '%0' of type %1 does not conform to 'Codable'",
       (StringRef, Type))
 ERROR(distributed_actor_func_result_not_codable,none,
-      "distributed function result type %0 does not conform to 'Codable'",
+      "distributed instance method result type %0 does not conform to 'Codable'",
       (Type))
 ERROR(distributed_actor_remote_func_implemented_manually,none,
       "distributed function's %0 remote counterpart %1 cannot not be implemented manually.",
@@ -4519,6 +4519,9 @@ ERROR(nonisolated_distributed_actor_storage,none,
 ERROR(distributed_actor_func_nonisolated, none,
       "function %0 cannot be both 'nonisolated' and 'distributed'",
       (DeclName))
+ERROR(distributed_actor_func_private, none,
+      "%0 %1 cannot be 'private'",
+      (DescriptiveDeclKind, DeclName))
 ERROR(distributed_actor_remote_func_is_not_static,none,
       "remote function %0 must be static.",
       (DeclName))
@@ -4628,7 +4631,7 @@ ERROR(actor_instance_property_wrapper,none,
       (Identifier, Identifier))
 
 ERROR(distributed_actor_func_defined_outside_of_distributed_actor,none,
-      "distributed function %0 is declared outside of an distributed actor",
+      "distributed instance method %0 is declared outside of an distributed actor",
       (DeclName))
 ERROR(distributed_actor_local_var,none,
       "'distributed' can not be applied to local variables",
@@ -4648,7 +4651,7 @@ ERROR(distributed_actor_not_actor_func,none,
       "'distributed' can only be applied to distributed actor async functions",
       ())
 ERROR(distributed_actor_func_static,none,
-      "'distributed' functions cannot be 'static'",
+      "'distributed' method cannot be 'static'",
       ())
 ERROR(distributed_actor_func_not_in_distributed_actor,none,
       "'distributed' function can only be declared within 'distributed actor'",

include/swift/AST/Expr.h

@@ -4367,7 +4367,7 @@ class ApplyExpr : public Expr {
   /// Is this application _implicitly_ required to be a throwing call?
   /// This can happen if the function is actually a proxy function invocation,
   /// which may throw, regardless of the target function throwing, e.g.
-  /// a distributed function call on a 'remote' actor, may throw due to network
+  /// a distributed instance method call on a 'remote' actor, may throw due to network
   /// issues reported by the transport, regardless if the actual target function
   /// can throw.
   bool implicitlyThrows() const {
@@ -5562,24 +5562,43 @@ class KeyPathExpr : public Expr {
 private:
   llvm::MutableArrayRef<Component> Components;
 
-public:
-  /// Create a new #keyPath expression.
-  KeyPathExpr(ASTContext &C,
-              SourceLoc keywordLoc, SourceLoc lParenLoc,
-              ArrayRef<Component> components,
-              SourceLoc rParenLoc,
-              bool isImplicit = false);
+  KeyPathExpr(SourceLoc startLoc, Expr *parsedRoot, Expr *parsedPath,
+              SourceLoc endLoc, bool hasLeadingDot, bool isObjC,
+              bool isImplicit);
 
+  /// Create a key path with unresolved root and path expressions.
   KeyPathExpr(SourceLoc backslashLoc, Expr *parsedRoot, Expr *parsedPath,
-              bool hasLeadingDot, bool isImplicit = false)
-      : Expr(ExprKind::KeyPath, isImplicit), StartLoc(backslashLoc),
-        EndLoc(parsedPath ? parsedPath->getEndLoc() : parsedRoot->getEndLoc()),
-        ParsedRoot(parsedRoot), ParsedPath(parsedPath),
-        HasLeadingDot(hasLeadingDot) {
-    assert((parsedRoot || parsedPath) &&
-           "keypath must have either root or path");
-    Bits.KeyPathExpr.IsObjC = false;
-  }
+              bool hasLeadingDot, bool isImplicit);
+
+  /// Create a key path with components.
+  KeyPathExpr(ASTContext &ctx, SourceLoc startLoc,
+              ArrayRef<Component> components, SourceLoc endLoc, bool isObjC,
+              bool isImplicit);
+
+public:
+  /// Create a new parsed Swift key path expression.
+  static KeyPathExpr *createParsed(ASTContext &ctx, SourceLoc backslashLoc,
+                                   Expr *parsedRoot, Expr *parsedPath,
+                                   bool hasLeadingDot);
+
+  /// Create a new parsed #keyPath expression.
+  static KeyPathExpr *createParsedPoundKeyPath(ASTContext &ctx,
+                                               SourceLoc keywordLoc,
+                                               SourceLoc lParenLoc,
+                                               ArrayRef<Component> components,
+                                               SourceLoc rParenLoc);
+
+  /// Create an implicit Swift key path expression with a set of resolved
+  /// components.
+  static KeyPathExpr *createImplicit(ASTContext &ctx, SourceLoc backslashLoc,
+                                     ArrayRef<Component> components,
+                                     SourceLoc endLoc);
+
+  /// Create an implicit Swift key path expression with a root and path
+  /// expression to be resolved.
+  static KeyPathExpr *createImplicit(ASTContext &ctx, SourceLoc backslashLoc,
+                                     Expr *parsedRoot, Expr *parsedPath,
+                                     bool hasLeadingDot);
 
   SourceLoc getLoc() const { return StartLoc; }
   SourceRange getSourceRange() const { return SourceRange(StartLoc, EndLoc); }
@@ -5592,10 +5611,9 @@ class KeyPathExpr : public Expr {
     return Components;
   }
 
-  /// Resolve the components of an un-type-checked expr. This copies over the
-  /// components from the argument array.
-  void resolveComponents(ASTContext &C,
-                         ArrayRef<Component> resolvedComponents);
+  /// Set the key path components. This copies over the components from the
+  /// argument array.
+  void setComponents(ASTContext &C, ArrayRef<Component> newComponents);
 
   /// Indicates if the key path expression is composed by a single invalid
   /// component. e.g. missing component `\Root`

include/swift/AST/IRGenOptions.h

@@ -356,6 +356,10 @@ class IRGenOptions {
   /// Whether to disable using mangled names for accessing concrete type metadata.
   unsigned DisableConcreteTypeMetadataMangledNameAccessors : 1;
 
+  /// Whether to disable referencing stdlib symbols via mangled names in
+  /// reflection mangling.
+  unsigned DisableStandardSubstitutionsInReflectionMangling : 1;
+
   unsigned EnableGlobalISel : 1;
 
   unsigned VirtualFunctionElimination : 1;
@@ -425,6 +429,7 @@ class IRGenOptions {
         GenerateProfile(false), EnableDynamicReplacementChaining(false),
         DisableRoundTripDebugTypes(false), DisableDebuggerShadowCopies(false),
         DisableConcreteTypeMetadataMangledNameAccessors(false),
+        DisableStandardSubstitutionsInReflectionMangling(false),
         EnableGlobalISel(false), VirtualFunctionElimination(false),
         WitnessMethodElimination(false), ConditionalRuntimeRecords(false),
         InternalizeAtLink(false),

include/swift/AST/SILOptions.h

@@ -30,6 +30,17 @@
 
 namespace swift {
 
+enum class LexicalLifetimesOption : uint8_t {
+  // Do not insert any lexical lifetimes.
+  Off = 0,
+
+  // Insert lexical lifetimes and do not remove them until OSSA is lowered. This
+  // is experimental.
+  ExperimentalLate,
+};
+
+class SILModule;
+
 class SILOptions {
 public:
   /// Controls the aggressiveness of the performance inliner.
@@ -45,7 +56,7 @@ class SILOptions {
   bool RemoveRuntimeAsserts = false;
 
   /// Enable experimental support for emitting defined borrow scopes.
-  bool EnableExperimentalLexicalLifetimes = false;
+  LexicalLifetimesOption LexicalLifetimes = LexicalLifetimesOption::Off;
 
   /// Force-run SIL copy propagation to shorten object lifetime in whatever
   /// optimization pipeline is currently used.
@@ -226,6 +237,12 @@ class SILOptions {
   bool shouldOptimize() const {
     return OptMode > OptimizationMode::NoOptimization;
   }
+
+  /// Returns true if we support inserting lexical lifetimes given the current
+  /// SIL stage.
+  ///
+  /// Defined in SILModule.h.
+  bool supportsLexicalLifetimes(const SILModule &mod) const;
 };
 
 } // end namespace swift