Merge pull request #3954 from swiftwasm/katei/merge-main-2021-12-07

Merge main 2021-12-07

Author: MaxDesiatov

CMakeLists.txt

@@ -194,6 +194,8 @@ cmake_dependent_option(LIBSWIFT_BUILD_MODE "How to build libswift. Possible valu
     BOOTSTRAPPING: libswift is built with a 2-stage bootstrapping process
     BOOTSTRAPPING-WITH-HOSTLIBS:   libswift is built with a 2-stage bootstrapping process,
                    but the compiler links against the host system swift libs (macOS only)
+    CROSSCOMPILE:  libswift is cross-compiled with a native host compiler, provided in
+                   `SWIFT_NATIVE_SWIFT_TOOLS_PATH` (non-Darwin only)
     CROSSCOMPILE-WITH-HOSTLIBS:    libswift is built with a bootstrapping-with-hostlibs compiled
                                    compiler, provided in `SWIFT_NATIVE_SWIFT_TOOLS_PATH`"
   OFF "NOT CMAKE_GENERATOR STREQUAL \"Xcode\"" OFF)
@@ -625,6 +627,8 @@ elseif(LIBSWIFT_BUILD_MODE MATCHES "BOOTSTRAPPING.*")
   set(SWIFT_EXEC_FOR_LIBSWIFT "${SWIFT_NATIVE_SWIFT_TOOLS_PATH}/swiftc")
   if(LIBSWIFT_BUILD_MODE STREQUAL "BOOTSTRAPPING-WITH-HOSTLIBS")
     set(LIBSWIFT_BUILD_MODE "CROSSCOMPILE-WITH-HOSTLIBS")
+  elseif(LIBSWIFT_BUILD_MODE STREQUAL "BOOTSTRAPPING")
+    set(LIBSWIFT_BUILD_MODE "CROSSCOMPILE")
   else()
     set(LIBSWIFT_BUILD_MODE "HOSTTOOLS")
   endif()

cmake/modules/AddSwift.cmake

@@ -741,6 +741,10 @@ function(add_libswift name)
       get_filename_component(swift_exec_bin_dir ${ALS_SWIFT_EXEC} DIRECTORY)
       set(sdk_option ${sdk_option} "-resource-dir" "${swift_exec_bin_dir}/../bootstrapping0/lib/swift")
     endif()
+  elseif(${LIBSWIFT_BUILD_MODE} STREQUAL "CROSSCOMPILE")
+    set(sdk_option "-sdk" "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${SWIFT_HOST_VARIANT_ARCH}_PATH}")
+    get_filename_component(swift_exec_bin_dir ${ALS_SWIFT_EXEC} DIRECTORY)
+    set(sdk_option ${sdk_option} "-resource-dir" "${swift_exec_bin_dir}/../lib/swift")
   endif()
   get_versioned_target_triple(target ${SWIFT_HOST_VARIANT_SDK}
       ${SWIFT_HOST_VARIANT_ARCH} "${deployment_version}")
@@ -967,22 +971,28 @@ function(add_swift_host_tool executable)
       BUILD_WITH_INSTALL_RPATH YES
       INSTALL_RPATH "${RPATH_LIST}")
 
-  elseif(SWIFT_HOST_VARIANT_SDK STREQUAL "LINUX" AND ASHT_HAS_LIBSWIFT AND LIBSWIFT_BUILD_MODE)
+  elseif(SWIFT_HOST_VARIANT_SDK MATCHES "LINUX|ANDROID|OPENBSD" AND ASHT_HAS_LIBSWIFT AND LIBSWIFT_BUILD_MODE)
     set(swiftrt "swiftImageRegistrationObject${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_OBJECT_FORMAT}-${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}-${SWIFT_HOST_VARIANT_ARCH}")
-    if(LIBSWIFT_BUILD_MODE STREQUAL "HOSTTOOLS")
+    if(${LIBSWIFT_BUILD_MODE} MATCHES "HOSTTOOLS|CROSSCOMPILE")
       # At build time and and run time, link against the swift libraries in the
       # installed host toolchain.
       get_filename_component(swift_bin_dir ${SWIFT_EXEC_FOR_LIBSWIFT} DIRECTORY)
       get_filename_component(swift_dir ${swift_bin_dir} DIRECTORY)
-      set(host_lib_dir "${swift_dir}/lib/swift/linux")
+      set(host_lib_dir "${swift_dir}/lib/swift/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}")
 
       target_link_libraries(${executable} PRIVATE ${swiftrt})
       target_link_libraries(${executable} PRIVATE "swiftCore")
 
       target_link_directories(${executable} PRIVATE ${host_lib_dir})
-      set_target_properties(${executable} PROPERTIES
-        BUILD_WITH_INSTALL_RPATH YES
-        INSTALL_RPATH  "${host_lib_dir}")
+      if(LIBSWIFT_BUILD_MODE STREQUAL "HOSTTOOLS")
+        set_target_properties(${executable} PROPERTIES
+          BUILD_WITH_INSTALL_RPATH YES
+          INSTALL_RPATH  "${host_lib_dir}")
+      else()
+        set_target_properties(${executable} PROPERTIES
+          BUILD_WITH_INSTALL_RPATH YES
+          INSTALL_RPATH  "$ORIGIN/../lib/swift/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}")
+      endif()
 
     elseif(LIBSWIFT_BUILD_MODE STREQUAL "BOOTSTRAPPING")
       # At build time link against the built swift libraries from the
@@ -998,7 +1008,7 @@ function(add_swift_host_tool executable)
       # bootstrapping stage.
       set_target_properties(${executable} PROPERTIES
         BUILD_WITH_INSTALL_RPATH YES
-        INSTALL_RPATH  "$ORIGIN/../lib/swift/${SWIFT_SDK_LINUX_LIB_SUBDIR}")
+        INSTALL_RPATH  "$ORIGIN/../lib/swift/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}")
 
     elseif(LIBSWIFT_BUILD_MODE STREQUAL "BOOTSTRAPPING-WITH-HOSTLIBS")
       message(FATAL_ERROR "LIBSWIFT_BUILD_MODE 'BOOTSTRAPPING-WITH-HOSTLIBS' not supported on Linux")

docs/ReferenceGuides/UnderscoredAttributes.md

@@ -634,3 +634,8 @@ calls a runtime function which allocates memory or locks, respectively.
 The `@_noLocks` attribute implies `@_noAllocation` because a memory allocation
 also locks.
 
+## `@_unavailableFromAsync`
+
+Marks a synchronous API as being unavailable from asynchronous contexts. Direct
+usage of annotated API from asynchronous contexts will result in a warning from
+the compiler.

include/swift/AST/Attr.def

@@ -699,6 +699,12 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(_const, CompileTimeConst,
   ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
   126)
 
+SIMPLE_DECL_ATTR(_unavailableFromAsync, UnavailableFromAsync,
+  OnFunc | OnConstructor | UserInaccessible |
+  ABIStableToAdd | ABIStableToRemove |
+  APIBreakingToAdd | APIStableToRemove,
+  127)
+
 // If you're adding a new underscored attribute here, please document it in
 // docs/ReferenceGuides/UnderscoredAttributes.md.
 

include/swift/AST/DeclContext.h

@@ -296,6 +296,9 @@ class alignas(1 << DeclContextAlignInBits) DeclContext
   /// Returns the kind of context this is.
   DeclContextKind getContextKind() const;
 
+  /// Returns whether this context asynchronous
+  bool isAsyncContext() const;
+
   /// Returns whether this context has value semantics.
   bool hasValueSemantics() const;
 

include/swift/AST/DiagnosticsSIL.def

@@ -741,7 +741,7 @@ NOTE(sil_movekillscopyablevalue_use_here, none,
 NOTE(sil_movekillscopyablevalue_value_consumed_in_loop, none,
      "cyclic move here. move will occur multiple times in the loop", ())
 ERROR(sil_movekillscopyablevalue_move_applied_to_unsupported_move, none,
-      "_move applied to value that the compiler does not supporting checking.",
+      "_move applied to value that the compiler does not support checking",
       ())
 
 #define UNDEFINE_DIAGNOSTIC_MACROS

include/swift/AST/DiagnosticsSema.def

@@ -4491,6 +4491,10 @@ ERROR(concurrent_access_of_local_capture,none,
       "%select{mutation of|reference to}0 captured %1 %2 in "
       "concurrently-executing code",
       (bool, DescriptiveDeclKind, DeclName))
+ERROR(non_sendable_capture,none,
+      "capture of %1 with non-sendable type %0 in a `@Sendable` closure",
+      (Type, DeclName))
+
 NOTE(actor_isolated_sync_func,none,
      "calls to %0 %1 from outside of its actor context are "
      "implicitly asynchronous",
@@ -4705,6 +4709,15 @@ ERROR(actor_isolation_superclass_mismatch,none,
       "%0 class %1 has different actor isolation from %2 superclass %3",
       (ActorIsolation, DeclName, ActorIsolation, DeclName))
 
+ERROR(async_decl_must_be_available_from_async,none,
+        "asynchronous %0 must be available from asynchronous contexts",
+        (DescriptiveDeclKind))
+ERROR(async_named_decl_must_be_available_from_async,none,
+        "asynchronous %0 %1 must be available from asynchronous contexts",
+        (DescriptiveDeclKind, DeclName))
+ERROR(async_unavailable_decl,none,
+      "%0 %1 is unavailable from asynchronous contexts", (DescriptiveDeclKind, DeclBaseName))
+
 //------------------------------------------------------------------------------
 // MARK: Type Check Types
 //------------------------------------------------------------------------------

include/swift/AST/Expr.h

@@ -3601,6 +3601,13 @@ class AbstractClosureExpr : public DeclContext, public Expr {
   /// Only valid when \c hasSingleExpressionBody() is true.
   Expr *getSingleExpressionBody() const;
 
+  /// Whether this closure has a body
+  bool hasBody() const;
+
+  /// Returns the body of closures that have a body
+  /// returns nullptr if the closure doesn't have a body
+  BraceStmt *getBody() const;
+
   ClosureActorIsolation getActorIsolation() const { return actorIsolation; }
 
   void setActorIsolation(ClosureActorIsolation actorIsolation) {

include/swift/Option/FrontendOptions.td

@@ -262,12 +262,12 @@ def enable_experimental_concurrency :
 def disable_lexical_lifetimes :
   Flag<["-"], "disable-lexical-lifetimes">,
   HelpText<"Disables early lexical lifetimes. Mutually exclusive with "
-           "-enable-experimental-lexical-lifetimes">;
+           "-enable-lexical-lifetimes">;
 
-def enable_experimental_lexical_lifetimes :
-  Flag<["-"], "enable-experimental-lexical-lifetimes">,
-  HelpText<"Enable experimental lexical lifetimes. Mutually exclusive with "
-           "-disable-early-lexical-lifetimes">;
+def enable_lexical_lifetimes :
+  Flag<["-"], "enable-lexical-lifetimes">,
+  HelpText<"Enable lexical lifetimes. Mutually exclusive with "
+           "-disable-lexical-lifetimes">;
 
 def enable_experimental_move_only :
   Flag<["-"], "enable-experimental-move-only">,

include/swift/SIL/BasicBlockDatastructures.h

@@ -43,6 +43,10 @@ class BasicBlockSetVector {
   iterator begin() const { return vector.begin(); }
   iterator end() const { return vector.end(); }
 
+  llvm::iterator_range<iterator> getRange() const {
+    return llvm::make_range(begin(), end());
+  }
+
   bool empty() const { return vector.empty(); }
 
   bool contains(SILBasicBlock *block) const { return set.contains(block); }

include/swift/SIL/SILBuilder.h

@@ -1271,6 +1271,13 @@ class SILBuilder {
                   MoveValueInst(getSILDebugLocation(loc), operand));
   }
 
+  MarkUnresolvedMoveAddrInst *createMarkUnresolvedMoveAddr(SILLocation loc,
+                                                           SILValue srcAddr,
+                                                           SILValue takeAddr) {
+    return insert(new (getModule()) MarkUnresolvedMoveAddrInst(
+        getSILDebugLocation(loc), srcAddr, takeAddr));
+  }
+
   UnconditionalCheckedCastInst *
   createUnconditionalCheckedCast(SILLocation Loc, SILValue op,
                                  SILType destLoweredTy,

include/swift/SIL/SILCloner.h

@@ -1341,6 +1341,16 @@ SILCloner<ImplClass>::visitCopyAddrInst(CopyAddrInst *Inst) {
                 Inst->isInitializationOfDest()));
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitMarkUnresolvedMoveAddrInst(
+    MarkUnresolvedMoveAddrInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  auto *MVI = getBuilder().createMarkUnresolvedMoveAddr(
+      getOpLocation(Inst->getLoc()), getOpValue(Inst->getSrc()),
+      getOpValue(Inst->getDest()));
+  recordClonedInstruction(Inst, MVI);
+}
+
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitBindMemoryInst(BindMemoryInst *Inst) {

include/swift/SIL/SILInstruction.h

@@ -1793,6 +1793,10 @@ struct SILDebugVariable {
            Implicit == V.Implicit && Type == V.Type && Loc == V.Loc &&
            Scope == V.Scope;
   }
+
+  bool isLet() const { return Name.size() && Constant; }
+
+  bool isVar() const { return Name.size() && !Constant; }
 };
 
 /// A DebugVariable where storage for the strings has been
@@ -2004,7 +2008,20 @@ class AllocStackInst final
     auto VI = TailAllocatedDebugVariable(RawValue);
     return VI.get(getDecl(), getTrailingObjects<char>(), AuxVarType, VarDeclLoc,
                   VarDeclScope, DIExprElements);
-  };
+  }
+
+  bool isLet() const {
+    if (auto varInfo = getVarInfo())
+      return varInfo->isLet();
+    return false;
+  }
+
+  bool isVar() const {
+    if (auto varInfo = getVarInfo())
+      return varInfo->isVar();
+    return false;
+  }
+
   void setArgNo(unsigned N) {
     auto RawValue = SILNode::Bits.AllocStackInst.VarInfo;
     auto VI = TailAllocatedDebugVariable(RawValue);
@@ -7424,6 +7441,35 @@ class MoveValueInst
   void setAllowsDiagnostics(bool newValue) { allowDiagnostics = newValue; }
 };
 
+/// Equivalent to a copy_addr to [init] except that it is used for diagnostics
+/// and should not be pattern matched. During the diagnostic passes, the "move
+/// function" checker for addresses always converts this to a copy_addr [init]
+/// (if we emitted a diagnostic and proved we could not emit a move here) or a
+/// copy_addr [take][init] if we can. So this should never occur in canonical
+/// SIL.
+class MarkUnresolvedMoveAddrInst
+    : public InstructionBase<SILInstructionKind::MarkUnresolvedMoveAddrInst,
+                             NonValueInstruction>,
+      public CopyLikeInstruction {
+  friend class SILBuilder;
+
+  FixedOperandList<2> Operands;
+
+  MarkUnresolvedMoveAddrInst(SILDebugLocation DebugLoc, SILValue srcAddr,
+                             SILValue takeAddr)
+      : InstructionBase(DebugLoc), Operands(this, srcAddr, takeAddr) {}
+
+public:
+  SILValue getSrc() const { return Operands[Src].get(); }
+  SILValue getDest() const { return Operands[Dest].get(); }
+
+  void setSrc(SILValue V) { Operands[Src].set(V); }
+  void setDest(SILValue V) { Operands[Dest].set(V); }
+
+  ArrayRef<Operand> getAllOperands() const { return Operands.asArray(); }
+  MutableArrayRef<Operand> getAllOperands() { return Operands.asArray(); }
+};
+
 /// Given an object reference, return true iff it is non-nil and refers
 /// to a native swift object with strong reference count of 1.
 class IsUniqueInst

include/swift/SIL/SILNodes.def

@@ -591,8 +591,15 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
                     SingleValueInstruction, None, MayRelease)
   // A move_value is an OSSA only instruction. Its result does not have any side
   // effects relative to other OSSA values like copy_value.
-  SINGLE_VALUE_INST(MoveValueInst, move_value,
-                    SingleValueInstruction, None, DoesNotRelease)
+  SINGLE_VALUE_INST(MoveValueInst, move_value, SingleValueInstruction, None,
+                    DoesNotRelease)
+  
+  // A move_addr is a Raw SIL only instruction that is equivalent to a copy_addr
+  // [init]. It is lowered during the diagnostic passes to a copy_addr [init] if
+  // the move checker found uses that prevented us from converting this to a
+  // move or if we do not find such uses, a copy_addr [init] [take].
+  NON_VALUE_INST(MarkUnresolvedMoveAddrInst, mark_unresolved_move_addr,
+                 SILInstruction, None, DoesNotRelease)
 
   // IsUnique does not actually write to memory but should be modeled
   // as such. Its operand is a pointer to an object reference. The

include/swift/SILOptimizer/PassManager/Passes.def

@@ -427,6 +427,9 @@ PASS(MoveKillsCopyableValuesChecker, "sil-move-kills-copyable-values-checker",
      "to _move do not have any uses later than the _move")
 PASS(LexicalLifetimeEliminator, "sil-lexical-lifetime-eliminator",
      "Pass that removes lexical lifetime markers from borrows and alloc stack")
+PASS(MoveKillsCopyableAddressesChecker, "sil-move-kills-copyable-addresses-checker",
+     "Pass that checks that any copyable (non-move only) address that is passed "
+     "to _move do not have any uses later than the _move")
 PASS(PruneVTables, "prune-vtables",
      "Mark class methods that do not require vtable dispatch")
 PASS_RANGE(AllPasses, AADumper, PruneVTables)

include/swift/Sema/CSBindings.h

@@ -338,6 +338,14 @@ class BindingSet {
 
   TypeVariableType *getTypeVariable() const { return Info.TypeVar; }
 
+  /// Check whether this binding set belongs to a type variable
+  /// that represents a result type of a closure.
+  bool forClosureResult() const;
+
+  /// Check whether this binding set belongs to a type variable
+  /// that represents a generic parameter.
+  bool forGenericParameter() const;
+
   bool canBeNil() const;
 
   /// If this type variable doesn't have any viable bindings, or

include/swift/Sema/CSFix.h

@@ -2308,6 +2308,10 @@ class SpecifyClosureParameterType final : public ConstraintFix {
 
   bool diagnose(const Solution &solution, bool asNote = false) const override;
 
+  bool diagnoseForAmbiguity(CommonFixesArray commonFixes) const override {
+    return diagnose(*commonFixes.front().first);
+  }
+
   static SpecifyClosureParameterType *create(ConstraintSystem &cs,
                                              ConstraintLocator *locator);
 

include/swift/Sema/Constraint.h

@@ -442,6 +442,8 @@ class Constraint final : public llvm::ilist_node<Constraint>,
       ASTNode Element;
       /// Contextual information associated with the element (if any).
       ContextualTypeInfo Context;
+      /// Identifies whether result of this node is unused.
+      bool IsDiscarded;
     } ClosureElement;
   };
 
@@ -495,7 +497,7 @@ class Constraint final : public llvm::ilist_node<Constraint>,
              SmallPtrSetImpl<TypeVariableType *> &typeVars);
 
   /// Construct a closure body element constraint.
-  Constraint(ASTNode node, ContextualTypeInfo context,
+  Constraint(ASTNode node, ContextualTypeInfo context, bool isDiscarded,
              ConstraintLocator *locator,
              SmallPtrSetImpl<TypeVariableType *> &typeVars);
 
@@ -585,12 +587,14 @@ class Constraint final : public llvm::ilist_node<Constraint>,
 
   static Constraint *createClosureBodyElement(ConstraintSystem &cs,
                                               ASTNode node,
-                                              ConstraintLocator *locator);
+                                              ConstraintLocator *locator,
+                                              bool isDiscarded = false);
 
   static Constraint *createClosureBodyElement(ConstraintSystem &cs,
                                               ASTNode node,
                                               ContextualTypeInfo context,
-                                              ConstraintLocator *locator);
+                                              ConstraintLocator *locator,
+                                              bool isDiscarded = false);
 
   /// Determine the kind of constraint.
   ConstraintKind getKind() const { return Kind; }
@@ -857,6 +861,11 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     return ClosureElement.Context;
   }
 
+  bool isDiscardedElement() const {
+    assert(Kind == ConstraintKind::ClosureBodyElement);
+    return ClosureElement.IsDiscarded;
+  }
+
   /// For an applicable function constraint, retrieve the trailing closure
   /// matching rule.
   Optional<TrailingClosureMatching> getTrailingClosureMatching() const;