Merge remote-tracking branch 'apple/main' into katei/merge-main-2022-08-19

Author: kateinoigakukun

docs/DevelopmentTips.md

@@ -21,17 +21,17 @@ Going further, for various reasons the standard library has lots of warnings. Th
 Copy the invocation that has  ` -o <build-path>/swift-macosx-x86_64/stdlib/public/core/iphonesimulator/i386/Swift.o`, so that we can perform the actual call to swiftc ourselves. Tack on `-suppress-warnings` at the end, and now we have the command to just build `Swift.o` for i386 while only displaying the actual errors.
 
 ### 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`.
+By default, the compiler builds with the `bootstrapping-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. 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:
+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 `bootstrapping-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`.
+* Build the toolchain locally in `bootstrapping-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`.
@@ -124,4 +124,4 @@ To setup this environment a few steps are necessary:
 
 Now you are all set. You can build and debug like with a native Xcode project.
 
-If the project structure changes, e.g. new source files are added or deleted, you just have to re-create the LLVM and Swift projects with `utils/build-script --skip-build --xcode --skip-early-swift-driver`.
+If the project structure changes, e.g. new source files are added or deleted, you just have to re-create the LLVM and Swift projects with `utils/build-script --skip-build --xcode --skip-early-swift-driver`.

docs/SIL.rst

@@ -4862,36 +4862,6 @@ into a ``copy_block`` and a ``is_escaping``/``cond_fail``/``destroy_value`` at
 the end of the lifetime of the objective c closure parameter to check whether
 the sentinel closure was escaped.
 
-builtin "unsafeGuaranteed"
-``````````````````````````
-
-::
-
-  sil-instruction := 'builtin' '"unsafeGuaranteed"' '<' sil-type '>' '(' sil-operand')' ':' sil-type
-
-  %1 = builtin "unsafeGuaranteed"<T>(%0 : $T) : ($T, Builtin.Int1)
-  // $T must be of AnyObject type.
-
-Asserts that there exists another reference of the value ``%0`` for the scope
-delineated by the call of this builtin up to the first call of a ``builtin
-"unsafeGuaranteedEnd"`` instruction that uses the second element ``%1.1`` of the
-returned value. If no such instruction can be found nothing can be assumed. This
-assertion holds for uses of the first tuple element of the returned value
-``%1.0`` within this scope. The returned reference value equals the input
-``%0``.
-
-builtin "unsafeGuaranteedEnd"
-`````````````````````````````
-
-::
-
-  sil-instruction := 'builtin' '"unsafeGuaranteedEnd"' '(' sil-operand')'
-
-  %1 = builtin "unsafeGuaranteedEnd"(%0 : $Builtin.Int1)
-  // $T must be of AnyObject type.
-
-Ends the scope for the ``builtin "unsafeGuaranteed"`` instruction.
-
 Literals
 ~~~~~~~~
 

include/swift/AST/ASTWalker.h

@@ -50,6 +50,25 @@ struct ReferenceMetaData {
       : Kind(Kind), AccKind(AccKind), isImplicit(isImplicit) {}
 };
 
+/// Specifies how the initialization expression of a \c lazy variable should be
+/// walked by the ASTWalker.
+enum class LazyInitializerWalking {
+  /// No lazy initialization expressions will be walked.
+  None,
+
+  /// The lazy initialization expression will only be walked as a part of
+  /// the variable's pattern binding decl. This is the default behavior, and is
+  /// consistent with the initializer being syntactically part of the pattern
+  /// binding.
+  InPatternBinding,
+
+  /// The lazy initialization expression will only be walked as part of the
+  /// body of the synthesized accessor for the lazy variable. In such an
+  /// accessor, the expression is denoted by LazyInitializerExpr. This is mainly
+  /// useful for code emission.
+  InAccessor
+};
+
 /// An abstract class used to traverse an AST.
 class ASTWalker {
 public:
@@ -193,15 +212,13 @@ class ASTWalker {
   /// params in AbstractFunctionDecl and NominalTypeDecl.
   virtual bool shouldWalkIntoGenericParams() { return false; }
 
-  /// This method configures whether the walker should walk into the
-  /// initializers of lazy variables.  These initializers are semantically
-  /// different from other initializers in their context and so sometimes
-  /// should not be visited.
-  ///
-  /// Note that visiting the body of the lazy getter will find a
-  /// LazyInitializerExpr with the initializer as its sub-expression.
-  /// However, ASTWalker does not walk into LazyInitializerExprs on its own.
-  virtual bool shouldWalkIntoLazyInitializers() { return true; }
+  /// This method configures how the walker should walk the initializers of
+  /// lazy variables. These initializers are semantically different from other
+  /// initializers in their context and so sometimes should be visited as part
+  /// of the synthesized getter, or should not be visited at all.
+  virtual LazyInitializerWalking getLazyInitializerWalkingBehavior() {
+    return LazyInitializerWalking::InPatternBinding;
+  }
 
   /// This method configures whether the walker should visit the body of a
   /// closure that was checked separately from its enclosing expression.

include/swift/AST/Builtins.def

@@ -723,12 +723,6 @@ BUILTIN_MISC_OPERATION(AssignTakeArray, "assignTakeArray", "", Special)
 /// This builtin indicates to the optimizer that the buffer is not mutable.
 BUILTIN_MISC_OPERATION(COWBufferForReading, "COWBufferForReading", "n", Special)
 
-// unsafeGuaranteed has type <T: AnyObject> T -> (T, Builtin.Int8)
-BUILTIN_MISC_OPERATION(UnsafeGuaranteed, "unsafeGuaranteed", "", Special)
-
-// unsafeGuaranteedEnd has type (Builtin.Int8) -> ()
-BUILTIN_MISC_OPERATION(UnsafeGuaranteedEnd, "unsafeGuaranteedEnd", "", Special)
-
 // getObjCTypeEncoding has type <T> T.Type -> RawPointer
 BUILTIN_MISC_OPERATION(GetObjCTypeEncoding, "getObjCTypeEncoding", "n", Special)
 

include/swift/AST/Expr.h

@@ -5314,6 +5314,7 @@ class LazyInitializerExpr : public Expr {
   SourceLoc getLoc() const { return SubExpr->getLoc(); }
 
   Expr *getSubExpr() const { return SubExpr; }
+  void setSubExpr(Expr *subExpr) { SubExpr = subExpr; }
 
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::LazyInitializer;

include/swift/AST/Module.h

@@ -685,9 +685,8 @@ class ModuleDecl
   // Is \p spiGroup accessible as an explicitly imported SPI from this module?
   bool isImportedAsSPI(Identifier spiGroup, const ModuleDecl *fromModule) const;
 
-  /// Is \p targetDecl from a module that is imported as \c @_weakLinked from
-  /// this module?
-  bool isImportedAsWeakLinked(const Decl *targetDecl) const;
+  /// Is \p module imported as \c @_weakLinked from this module?
+  bool isImportedAsWeakLinked(const ModuleDecl *module) const;
 
   /// \sa getImportedModules
   enum class ImportFilterKind {

include/swift/SIL/SILFunction.h

@@ -19,6 +19,7 @@
 
 #include "swift/AST/ASTNode.h"
 #include "swift/AST/Availability.h"
+#include "swift/AST/Module.h"
 #include "swift/AST/ResilienceExpansion.h"
 #include "swift/Basic/ProfileCounter.h"
 #include "swift/Basic/SwiftObjectHeader.h"
@@ -64,11 +65,6 @@ enum IsDistributed_t {
   IsNotDistributed,
   IsDistributed,
 };
-enum IsWeakImported_t {
-  IsNotWeakImported,
-  IsWeakImportedByModule,
-  IsAlwaysWeakImported,
-};
 
 enum class PerformanceConstraints : uint8_t {
   None = 0,
@@ -222,6 +218,10 @@ class SILFunction
   /// The AST decl context of the function.
   DeclContext *DeclCtxt = nullptr;
 
+  /// The module that defines this function. This member should only be set as
+  /// a fallback when a \c DeclCtxt is unavailable.
+  ModuleDecl *ParentModule = nullptr;
+
   /// The profiler for instrumentation based profiling, or null if profiling is
   /// disabled.
   SILProfiler *Profiler = nullptr;
@@ -322,8 +322,9 @@ class SILFunction
   /// would indicate.
   unsigned HasCReferences : 1;
 
-  /// Whether cross-module references to this function should use weak linking.
-  unsigned IsWeakImported : 2;
+  /// Whether cross-module references to this function should always use weak
+  /// linking.
+  unsigned IsAlwaysWeakImported : 1;
 
   /// Whether the implementation can be dynamically replaced.
   unsigned IsDynamicReplaceable : 1;
@@ -801,19 +802,11 @@ class SILFunction
 
   /// Returns whether this function's symbol must always be weakly referenced
   /// across module boundaries.
-  bool isAlwaysWeakImported() const {
-    return IsWeakImported == IsWeakImported_t::IsAlwaysWeakImported;
-  }
-
-  /// Returns whether this function's symbol was referenced by a module that
-  /// imports the defining module \c @_weakLinked.
-  bool isWeakImportedByModule() const {
-    return IsWeakImported == IsWeakImported_t::IsWeakImportedByModule;
-  }
+  bool isAlwaysWeakImported() const { return IsAlwaysWeakImported; }
 
-  void setIsWeakImported(IsWeakImported_t value) { IsWeakImported = value; }
+  void setIsAlwaysWeakImported(bool value) { IsAlwaysWeakImported = value; }
 
-  bool isWeakImported() const;
+  bool isWeakImported(ModuleDecl *module) const;
 
   /// Returns whether this function implementation can be dynamically replaced.
   IsDynamicallyReplaceable_t isDynamicallyReplaceable() const {
@@ -960,6 +953,18 @@ class SILFunction
     DeclCtxt = (DS ? DebugScope->Loc.getAsDeclContext() : nullptr);
   }
 
+  /// Returns the module that defines this function.
+  ModuleDecl *getParentModule() const {
+    return DeclCtxt ? DeclCtxt->getParentModule() : ParentModule;
+  }
+
+  /// Sets \c ParentModule as fallback if \c DeclCtxt is not available to
+  /// provide the parent module.
+  void setParentModule(ModuleDecl *module) {
+    assert(!DeclCtxt && "already have a DeclCtxt");
+    ParentModule = module;
+  }
+
   /// Initialize the debug scope for debug info on SIL level
   /// (-sil-based-debuginfo).
   void setSILDebugScope(const SILDebugScope *DS) {

include/swift/SILOptimizer/Analysis/ARCAnalysis.h

@@ -392,35 +392,6 @@ class ConsumedArgToEpilogueReleaseMatcher {
 /// Match a call to a trap BB with no ARC relevant side effects.
 bool isARCInertTrapBB(const SILBasicBlock *BB);
 
-/// Get the two result values of the builtin "unsafeGuaranteed" instruction.
-///
-/// Gets the (GuaranteedValue, Token) tuple from a call to "unsafeGuaranteed"
-/// if the tuple elements are identified by a single tuple_extract use.
-/// Otherwise, returns a (nullptr, nullptr) tuple.
-std::pair<SingleValueInstruction *, SingleValueInstruction *>
-getSingleUnsafeGuaranteedValueResult(BuiltinInst *UnsafeGuaranteedInst);
-
-/// Get the single builtin "unsafeGuaranteedEnd" user of a builtin
-/// "unsafeGuaranteed"'s token.
-BuiltinInst *getUnsafeGuaranteedEndUser(SILValue UnsafeGuaranteedToken);
-
-/// Walk forwards from an unsafeGuaranteedEnd builtin instruction looking for a
-/// release on the reference returned by the matching unsafeGuaranteed builtin
-/// ignoring releases on the way.
-/// Return nullptr if no release is found.
-///
-///    %4 = builtin "unsafeGuaranteed"<Foo>(%0 : $Foo) : $(Foo, Builtin.Int8)
-///    %5 = tuple_extract %4 : $(Foo, Builtin.Int8), 0
-///    %6 = tuple_extract %4 : $(Foo, Builtin.Int8), 1
-///    %12 = builtin "unsafeGuaranteedEnd"(%6 : $Builtin.Int8) : $()
-///    strong_release %5 : $Foo // <-- Matching release.
-///
-/// Alternatively, look for the release before the unsafeGuaranteedEnd.
-SILInstruction *findReleaseToMatchUnsafeGuaranteedValue(
-    SILInstruction *UnsafeGuaranteedEndI, SILInstruction *UnsafeGuaranteedI,
-    SILValue UnsafeGuaranteedValue, SILBasicBlock &BB,
-    RCIdentityFunctionInfo &RCFI);
-
 } // end namespace swift
 
 #endif

include/swift/SILOptimizer/PassManager/Passes.def

@@ -410,8 +410,6 @@ PASS(StringOptimization, "string-optimization",
      "Optimization for String operations")
 PASS(SwiftArrayPropertyOpt, "array-property-opt",
      "Loop Specialization for Array Properties")
-PASS(UnsafeGuaranteedPeephole, "unsafe-guaranteed-peephole",
-     "SIL retain/release Peephole Removal for Builtin.unsafeGuaranteed")
 PASS(UsePrespecialized, "use-prespecialized",
      "Use Pre-Specialized Functions")
 PASS(OwnershipDumper, "ownership-dumper",

include/swift/Sema/IDETypeChecking.h

@@ -304,6 +304,8 @@ namespace swift {
     BuildArray,
     BuildLimitedAvailability,
     BuildFinalResult,
+    BuildPartialBlockFirst,
+    BuildPartialBlockAccumulated,
   };
 
   /// Try to infer the component type of a result builder from the type