Merge remote-tracking branch 'github/master' into HEAD

Author: ainu-bot

README.md

@@ -165,8 +165,9 @@ First, create a directory for all of the Swift sources:
 **Note:** This is important since update-checkout (see below) checks out
 repositories next to the Swift source directory. This means that if one clones
 Swift and has other unrelated repositories, update-checkout may not clone those
-repositories and will update them instead. Additionally, ensure Python 2.7 is being
-used for this step, whether via conda environment or other means.
+repositories and will update them instead. Be aware that `update-checkout`
+currently does not support paths with non-ASCII characters. If such characters
+are present in the path to `swift-source`, `update-checkout` will fail.
 
 **TensorFlow Support:** To build with TensorFlow support, the `tensorflow`
 scheme must be specified when cloning sources. The `tensorflow` scheme pins

docs/DebuggingTheCompiler.rst

@@ -548,10 +548,17 @@ it's quite easy to do this manually:
 
   a. Add the compiler option ``-Xllvm -sil-opt-pass-count=<n>``, where ``<n>``
      is the number of optimizations to run.
-  b. Bisect: find n where the executable crashes, but does not crash with n-1.
-     Note that n can be quite large, e.g. > 100000 (just try
-     n = 10, 100, 1000, 10000, etc. to find an upper bound).
-  c. Add another option ``-Xllvm -sil-print-pass-name``. The output can be
+
+  b. Bisect: find n where the executable crashes, but does not crash
+     with n-1. First just try n = 10, 100, 1000, 10000, etc. to find
+     an upper bound). Then can either bisect the invocation by hand or
+     place the invocation into a script and use
+     ``./llvm-project/llvm/utils/bisect`` to automatically bisect
+     based on the scripts error code. Example invocation::
+
+       bisect --start=0 --end=10000 ./invoke_swift_passing_N.sh "%(count)s"
+
+  c. Once one finds ``n``, Add another option ``-Xllvm -sil-print-pass-name``. The output can be
      large, so it's best to redirect stderr to a file (``2> output``).
      In the output search for the last pass before ``stage Address Lowering``.
      It should be the ``Run #<n-1>``. This line tells you the name of the bad

docs/DevelopmentTips.md

@@ -41,3 +41,25 @@ Given the size of artifacts generated, you might also want to bump the cache siz
 You can run some compiles to see if it is actually doing something by running `sccache --show-stats`. Depending on the exact compilation task you're running, you might see very different cache hit rates. For example, `sccache` is particularly effective if you're rebuilding LLVM, which doesn't change so frequently from the Swift compiler's perspective. On the other hand, if you're changing the compiler's AST, the cache hit rate is likely to be much lower.
 
 One known issue with `sccache` is that you might occassionally get an "error: Connection to server timed out", even though you didn't stop the server. Simply re-running the build command usually works.
+
+## Memory usage
+
+When building Swift, peak memory usage happens during the linking phases that produce llvm and swift executables. In case your build fails because a process ran out of RAM, you can use one or more of the following techniques to reduce the peak memory usage.
+
+### Reduce the amount of debug symbols
+
+We can use debug symbols for only the part of the project we intend to work on. For example, when working on the compiler itself, we can build with debug symbols enabled only for the compiler:
+
+```
+build-script --release --debug-swift
+```
+
+### Reduce the number of parallel link jobs
+
+By default, `build-script` will spawn as many parallel compile / link jobs as there are CPUs in the machine. We can reduce the number of parallel link jobs by setting the `LLVM_PARALLEL_LINK_JOBS` and `SWIFT_PARALLEL_LINK_JOBS` CMake properties. We can set them through the `--llvm-cmake-options` and `--swift-cmake-options` arguments to `build-script`.
+
+For example, to have `build-script` spawn only one link job at a time, we can invoke it as:
+
+```
+build-script --llvm-cmake-options==-DLLVM_PARALLEL_LINK_JOBS=1 --swift-cmake-options=-DSWIFT_PARALLEL_LINK_JOBS=1
+```

include/swift/AST/Decl.h

@@ -5266,7 +5266,7 @@ class VarDecl : public AbstractStorageDecl {
   ///
   /// \code
   /// @Lazy var i = 17
-  /// \end
+  /// \endcode
   ///
   /// Or when there is no initializer but each composed property wrapper has
   /// a suitable `init(wrappedValue:)`.

include/swift/AST/Expr.h

@@ -4041,7 +4041,61 @@ class OpaqueValueExpr : public Expr {
   SourceRange getSourceRange() const { return Range; }
 
   static bool classof(const Expr *E) {
-    return E->getKind() == ExprKind::OpaqueValue; 
+    return E->getKind() == ExprKind::OpaqueValue;
+  }
+};
+
+/// A placeholder to substitute with a \c wrappedValue initialization expression
+/// for a property with an attached property wrapper.
+///
+/// Wrapped value placeholder expressions are injected around the
+/// \c wrappedValue argument in a synthesized \c init(wrappedValue:)
+/// call. This injection happens for properties with attached property wrappers
+/// that can be initialized out-of-line with a wrapped value expression, rather
+/// than calling \c init(wrappedValue:) explicitly.
+///
+/// Wrapped value placeholders store the original initialization expression
+/// if one exists, along with an opaque value placeholder that can be bound
+/// to a different wrapped value expression.
+class PropertyWrapperValuePlaceholderExpr : public Expr {
+  SourceRange Range;
+  OpaqueValueExpr *Placeholder;
+  Expr *WrappedValue;
+
+  PropertyWrapperValuePlaceholderExpr(SourceRange Range, Type Ty,
+                                      OpaqueValueExpr *placeholder,
+                                      Expr *wrappedValue)
+      : Expr(ExprKind::PropertyWrapperValuePlaceholder, /*Implicit=*/true, Ty),
+        Range(Range), Placeholder(placeholder), WrappedValue(wrappedValue) {}
+
+public:
+  static PropertyWrapperValuePlaceholderExpr *
+  create(ASTContext &ctx, SourceRange range, Type ty, Expr *wrappedValue);
+
+  /// The original wrappedValue initialization expression provided via
+  /// \c = on a proprety with attached property wrappers.
+  Expr *getOriginalWrappedValue() const {
+    return WrappedValue;
+  }
+
+  void setOriginalWrappedValue(Expr *value) {
+    WrappedValue = value;
+  }
+
+  /// An opaque value placeholder that will be used to substitute in a
+  /// different wrapped value expression for out-of-line initialization.
+  OpaqueValueExpr *getOpaqueValuePlaceholder() const {
+    return Placeholder;
+  }
+
+  void setOpaqueValuePlaceholder(OpaqueValueExpr *placeholder) {
+    Placeholder = placeholder;
+  }
+
+  SourceRange getSourceRange() const { return Range; }
+
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::PropertyWrapperValuePlaceholder;
   }
 };
 

include/swift/AST/ExprNodes.def

@@ -126,6 +126,7 @@ EXPR(VarargExpansion, Expr)
 EXPR(DynamicType, Expr)
 EXPR(RebindSelfInConstructor, Expr)
 EXPR(OpaqueValue, Expr)
+EXPR(PropertyWrapperValuePlaceholder, Expr)
 EXPR(DefaultArgument, Expr)
 EXPR(BindOptional, Expr)
 EXPR(OptionalEvaluation, Expr)

include/swift/AST/PropertyWrappers.h

@@ -141,7 +141,7 @@ struct PropertyWrapperBackingPropertyInfo {
   ///
   /// \code
   /// @Lazy var i = 17
-  /// \end
+  /// \endcode
   ///
   /// This is the specified initial value (\c 17), which is suitable for
   /// embedding in the expression \c initializeFromOriginal.
@@ -190,12 +190,13 @@ void simple_display(
     llvm::raw_ostream &out,
     const PropertyWrapperBackingPropertyInfo &backingInfo);
 
-/// Given the initializer for the given property with an attached property
-/// wrapper, dig out the original initialization expression.
+/// Given the initializer for a property with an attached property wrapper,
+/// dig out the wrapped value placeholder for the original initialization
+/// expression.
 ///
-/// Cannot just dig out the getOriginalInit() value because this function checks
-/// types, etc. Erroneous code won't return a result from here.
-Expr *findOriginalPropertyWrapperInitialValue(VarDecl *var, Expr *init);
+/// \note The wrapped value placeholder is injected for properties that can
+/// be initialized out-of-line using an expression of the wrapped property type.
+PropertyWrapperValuePlaceholderExpr *findWrappedValuePlaceholder(Expr *init);
 
 } // end namespace swift
 

lib/AST/ASTDumper.cpp

@@ -2511,6 +2511,18 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
 
+  void visitPropertyWrapperValuePlaceholderExpr(
+      PropertyWrapperValuePlaceholderExpr *E) {
+    printCommon(E, "property_wrapper_value_placeholder_expr");
+    OS << '\n';
+    printRec(E->getOpaqueValuePlaceholder());
+    if (auto *value = E->getOriginalWrappedValue()) {
+      OS << '\n';
+      printRec(value);
+    }
+    PrintWithColorRAII(OS, ParenthesisColor) << ')';
+  }
+
   void visitDefaultArgumentExpr(DefaultArgumentExpr *E) {
     printCommon(E, "default_argument_expr");
     OS << " default_args_owner=";

lib/AST/ASTWalker.cpp

@@ -508,6 +508,23 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
 
   Expr *visitOpaqueValueExpr(OpaqueValueExpr *E) { return E; }
 
+  Expr *visitPropertyWrapperValuePlaceholderExpr(
+      PropertyWrapperValuePlaceholderExpr *E) {
+    if (auto *placeholder = doIt(E->getOpaqueValuePlaceholder()))
+      E->setOpaqueValuePlaceholder(dyn_cast<OpaqueValueExpr>(placeholder));
+    else
+      return nullptr;
+
+    if (E->getOriginalWrappedValue()) {
+      if (auto *newValue = doIt(E->getOriginalWrappedValue()))
+        E->setOriginalWrappedValue(newValue);
+      else
+        return nullptr;
+    }
+
+    return E;
+  }
+
   Expr *visitDefaultArgumentExpr(DefaultArgumentExpr *E) { return E; }
 
   Expr *visitInterpolatedStringLiteralExpr(InterpolatedStringLiteralExpr *E) {

lib/AST/Decl.cpp

@@ -6408,105 +6408,27 @@ void ParamDecl::setDefaultArgumentCaptureInfo(CaptureInfo captures) {
   DefaultValueAndFlags.getPointer()->Captures = captures;
 }
 
-/// Return nullptr if there is no property wrapper
-Expr *swift::findOriginalPropertyWrapperInitialValue(VarDecl *var,
-                                                     Expr *init) {
-  auto *PBD = var->getParentPatternBinding();
-  if (!PBD)
-    return nullptr;
-
-  // If there is no '=' on the pattern, there was no initial value.
-  if (PBD->getEqualLoc(0).isInvalid() && !PBD->isDefaultInitializable())
-    return nullptr;
-
-  ASTContext &ctx = var->getASTContext();
-  auto dc = var->getInnermostDeclContext();
-  const auto wrapperAttrs = var->getAttachedPropertyWrappers();
-  if (wrapperAttrs.empty())
-    return nullptr;
-  auto innermostAttr = wrapperAttrs.back();
-  auto innermostNominal = evaluateOrDefault(
-      ctx.evaluator, CustomAttrNominalRequest{innermostAttr, dc}, nullptr);
-  if (!innermostNominal)
-    return nullptr;
-
-      // Walker
+PropertyWrapperValuePlaceholderExpr *
+swift::findWrappedValuePlaceholder(Expr *init) {
   class Walker : public ASTWalker {
   public:
-    NominalTypeDecl *innermostNominal;
-    Expr *initArg = nullptr;
-
-    Walker(NominalTypeDecl *innermostNominal)
-      : innermostNominal(innermostNominal) { }
+    PropertyWrapperValuePlaceholderExpr *placeholder = nullptr;
 
     virtual std::pair<bool, Expr *> walkToExprPre(Expr *E) override {
-      if (initArg)
+      if (placeholder)
         return { false, E };
 
-      if (auto call = dyn_cast<CallExpr>(E)) {
-        ASTContext &ctx = innermostNominal->getASTContext();
-
-        // We're looking for an implicit call.
-        if (!call->isImplicit())
-          return { true, E };
-
-        // ... which may call the constructor of another property
-        // wrapper if there are multiple wrappers attached to the
-        // property.
-        if (auto tuple = dyn_cast<TupleExpr>(call->getArg())) {
-          if (tuple->getNumElements() > 0) {
-            for (unsigned i : range(tuple->getNumElements())) {
-              if (tuple->getElementName(i) == ctx.Id_wrappedValue ||
-                  tuple->getElementName(i) == ctx.Id_initialValue) {
-                auto elem = tuple->getElement(i)->getSemanticsProvidingExpr();
-
-                // Look through autoclosures.
-                if (auto autoclosure = dyn_cast<AutoClosureExpr>(elem))
-                  elem = autoclosure->getSingleExpressionBody();
-
-                if (elem->isImplicit() && isa<CallExpr>(elem)) {
-                  return { true, E };
-                }
-              }
-            }
-          }
-        }
-
-        // ... producing a value of the same nominal type as the
-        // innermost property wrapper.
-        if (!call->getType() ||
-            call->getType()->getAnyNominal() != innermostNominal)
-          return { false, E };
-
-        // Find the implicit initialValue/wrappedValue argument.
-        if (auto tuple = dyn_cast<TupleExpr>(call->getArg())) {
-          for (unsigned i : range(tuple->getNumElements())) {
-            if (tuple->getElementName(i) == ctx.Id_wrappedValue ||
-                tuple->getElementName(i) == ctx.Id_initialValue) {
-              initArg = tuple->getElement(i);
-              return { false, E };
-            }
-          }
-        }
+      if (auto *value = dyn_cast<PropertyWrapperValuePlaceholderExpr>(E)) {
+        placeholder = value;
+        return { false, value };
       }
 
       return { true, E };
     }
-  } walker(innermostNominal);
+  } walker;
   init->walk(walker);
 
-  Expr *initArg = walker.initArg;
-  if (initArg) {
-    initArg = initArg->getSemanticsProvidingExpr();
-    if (auto autoclosure = dyn_cast<AutoClosureExpr>(initArg)) {
-      if (!var->isInnermostPropertyWrapperInitUsesEscapingAutoClosure()) {
-        // Remove the autoclosure part only for non-escaping autoclosures
-        initArg =
-            autoclosure->getSingleExpressionBody()->getSemanticsProvidingExpr();
-      }
-    }
-  }
-  return initArg;
+  return walker.placeholder;
 }
 
 /// Writes a tuple expression where each element is either `nil` or another such
@@ -6605,7 +6527,7 @@ ParamDecl::getDefaultValueStringRepresentation(
         }
 
         auto init =
-            findOriginalPropertyWrapperInitialValue(original, parentInit);
+            findWrappedValuePlaceholder(parentInit)->getOriginalWrappedValue();
         return extractInlinableText(getASTContext().SourceMgr, init, scratch);
       }
     }

lib/AST/Expr.cpp

@@ -311,6 +311,7 @@ ConcreteDeclRef Expr::getReferencedDecl(bool stopAtParenExpr) const {
   PASS_THROUGH_REFERENCE(RebindSelfInConstructor, getSubExpr);
 
   NO_REFERENCE(OpaqueValue);
+  NO_REFERENCE(PropertyWrapperValuePlaceholder);
   NO_REFERENCE(DefaultArgument);
 
   PASS_THROUGH_REFERENCE(BindOptional, getSubExpr);
@@ -624,6 +625,7 @@ bool Expr::canAppendPostfixExpression(bool appendingPostfixOperator) const {
 
   case ExprKind::RebindSelfInConstructor:
   case ExprKind::OpaqueValue:
+  case ExprKind::PropertyWrapperValuePlaceholder:
   case ExprKind::DefaultArgument:
   case ExprKind::BindOptional:
   case ExprKind::OptionalEvaluation:
@@ -1403,6 +1405,17 @@ static ValueDecl *getCalledValue(Expr *E) {
   return nullptr;
 }
 
+PropertyWrapperValuePlaceholderExpr *
+PropertyWrapperValuePlaceholderExpr::create(ASTContext &ctx, SourceRange range,
+                                            Type ty, Expr *wrappedValue) {
+  auto *placeholder =
+      new (ctx) OpaqueValueExpr(range, ty, /*isPlaceholder=*/true);
+
+  return new (ctx) PropertyWrapperValuePlaceholderExpr(range, ty,
+                                                       placeholder,
+                                                       wrappedValue);
+}
+
 const ParamDecl *DefaultArgumentExpr::getParamDecl() const {
   return getParameterAt(DefaultArgsOwner.getDecl(), ParamIndex);
 }

lib/LLVMPasses/LLVMMergeFunctions.cpp

@@ -1126,7 +1126,7 @@ bool SwiftMergeFunctions::replaceDirectCallers(Function *Old, Function *New,
                         cast<PointerType>(New->getType())->getAddressSpace());
 
     Value *Callee = ConstantExpr::getBitCast(New, FPtrType);
-    CallInst *NewCI = Builder.CreateCall(Callee, NewArgs);
+    CallInst *NewCI = Builder.CreateCall(FType, Callee, NewArgs);
     NewCI->setCallingConv(CI->getCallingConv());
     // Don't transfer attributes from the function to the callee. Function
     // attributes typically aren't relevant to the calling convention or ABI.