Resolve master conflicts

include/swift/AST/DiagnosticsSIL.def

@@ -108,7 +108,7 @@ ERROR(capture_before_declaration_defer,none,
 NOTE(captured_value_declared_here,none,
      "captured value declared here", ())
 
-#define SELECT_ESCAPING_CLOSURE_KIND "escaping %select{local function|closure}0"
+#define SELECT_ESCAPING_CLOSURE_KIND "escaping %select{local function|closure|autoclosure}0"
 
 // Invalid escaping capture diagnostics.
 ERROR(escaping_inout_capture,none,
@@ -133,6 +133,10 @@ ERROR(escaping_noescape_var_capture,none,
 
 NOTE(value_captured_here,none,"captured here", ())
 
+NOTE(copy_inout_captured_by_autoclosure,none, "pass a copy of %0", (Identifier))
+
+NOTE(copy_self_captured_by_autoclosure,none, "pass a copy of 'self'", ())
+
 #undef SELECT_ESCAPING_CLOSURE_KIND
 
 NOTE(value_captured_transitively,none,

include/swift/AST/Expr.h

@@ -3759,7 +3759,12 @@ class ClosureExpr : public AbstractClosureExpr {
     assert(hasExplicitResultType() && "No explicit result type");
     return ExplicitResultType;
   }
-
+
+  TypeRepr *getExplicitResultTypeRepr() const {
+    assert(hasExplicitResultType() && "No explicit result type");
+    return ExplicitResultType.getTypeRepr();
+  }
+
   void setExplicitResultType(SourceLoc arrowLoc, TypeLoc resultType) {
     ArrowLoc = arrowLoc;
     ExplicitResultType = resultType;

lib/AST/Availability.cpp

@@ -132,9 +132,29 @@ void AvailabilityInference::applyInferredAvailableAttrs(
   }
 }
 
+/// Returns true if the introduced version in \p newAttr should be used instead
+/// of the introduced version in \p prevAttr when both are attached to the same
+/// declaration and refer to the active platform.
+static bool isBetterThan(const AvailableAttr *newAttr,
+                         const AvailableAttr *prevAttr) {
+  assert(newAttr);
+
+  // If there is no prevAttr, newAttr of course wins.
+  if (!prevAttr)
+    return true;
+
+  // If they belong to the same platform, the one that introduces later wins.
+  if (prevAttr->Platform == newAttr->Platform)
+    return prevAttr->Introduced.getValue() < newAttr->Introduced.getValue();
+
+  // If the new attribute's platform inherits from the old one, it wins.
+  return inheritsAvailabilityFromPlatform(newAttr->Platform,
+                                          prevAttr->Platform);
+}
+
 Optional<AvailabilityContext>
 AvailabilityInference::annotatedAvailableRange(const Decl *D, ASTContext &Ctx) {
-  Optional<AvailabilityContext> AnnotatedRange;
+  const AvailableAttr *bestAvailAttr = nullptr;
 
   for (auto Attr : D->getAttrs()) {
     auto *AvailAttr = dyn_cast<AvailableAttr>(Attr);
@@ -145,21 +165,15 @@ AvailabilityInference::annotatedAvailableRange(const Decl *D, ASTContext &Ctx) {
       continue;
     }
 
-    AvailabilityContext AttrRange{
-        VersionRange::allGTE(AvailAttr->Introduced.getValue())};
-
-    // If we have multiple introduction versions, we will conservatively
-    // assume the worst case scenario. We may want to be more precise here
-    // in the future or emit a diagnostic.
-
-    if (AnnotatedRange.hasValue()) {
-      AnnotatedRange.getValue().intersectWith(AttrRange);
-    } else {
-      AnnotatedRange = AttrRange;
-    }
+    if (isBetterThan(AvailAttr, bestAvailAttr))
+      bestAvailAttr = AvailAttr;
   }
 
-  return AnnotatedRange;
+  if (!bestAvailAttr)
+    return None;
+
+  return AvailabilityContext{
+    VersionRange::allGTE(bestAvailAttr->Introduced.getValue())};
 }
 
 AvailabilityContext AvailabilityInference::availableRange(const Decl *D,

lib/SILOptimizer/Mandatory/DiagnoseInvalidEscapingCaptures.cpp

@@ -17,6 +17,7 @@
 
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/DiagnosticsSIL.h"
+#include "swift/AST/Expr.h"
 #include "swift/AST/Types.h"
 #include "swift/SIL/ApplySite.h"
 #include "swift/SIL/InstructionUtils.h"
@@ -332,17 +333,22 @@ static void checkPartialApply(ASTContext &Context, DeclContext *DC,
   // Should match SELECT_ESCAPING_CLOSURE_KIND in DiagnosticsSIL.def.
   enum {
     EscapingLocalFunction,
-    EscapingClosure
+    EscapingClosure,
+    EscapingAutoClosure,
   } functionKind = EscapingClosure;
 
   if (auto *F = PAI->getReferencedFunctionOrNull()) {
     if (auto loc = F->getLocation()) {
-      if (loc.isASTNode<FuncDecl>())
+      if (loc.isASTNode<FuncDecl>()) {
         functionKind = EscapingLocalFunction;
+      } else if (loc.isASTNode<AutoClosureExpr>()) {
+        functionKind = EscapingAutoClosure;
+      }
     }
   }
   // First, diagnose the inout captures, if any.
   for (auto inoutCapture : inoutCaptures) {
+    Optional<Identifier> paramName = None;
     if (isUseOfSelfInInitializer(inoutCapture)) {
       diagnose(Context, PAI->getLoc(), diag::escaping_mutable_self_capture,
                functionKind);
@@ -352,14 +358,23 @@ static void checkPartialApply(ASTContext &Context, DeclContext *DC,
         diagnose(Context, PAI->getLoc(), diag::escaping_mutable_self_capture,
                  functionKind);
       else {
+        paramName = param->getName();
         diagnose(Context, PAI->getLoc(), diag::escaping_inout_capture,
                  functionKind, param->getName());
         diagnose(Context, param->getLoc(), diag::inout_param_defined_here,
                  param->getName());
       }
     }
-
-    diagnoseCaptureLoc(Context, DC, PAI, inoutCapture);
+    if (functionKind != EscapingAutoClosure) {
+      diagnoseCaptureLoc(Context, DC, PAI, inoutCapture);
+      continue;
+    }
+    // For an autoclosure capture, present a way to fix the problem.
+    if (paramName)
+      diagnose(Context, PAI->getLoc(), diag::copy_inout_captured_by_autoclosure,
+               paramName.getValue());
+    else
+      diagnose(Context, PAI->getLoc(), diag::copy_self_captured_by_autoclosure);
   }
 
   // Finally, diagnose captures of values with noescape type.

lib/Sema/CSApply.cpp

@@ -166,10 +166,17 @@ ConstraintLocator *Solution::getCalleeLocator(ConstraintLocator *locator,
 }
 
 ConstraintLocator *
-Solution::getConstraintLocator(Expr *anchor,
+Solution::getConstraintLocator(const Expr *anchor,
                                ArrayRef<LocatorPathElt> path) const {
   auto &cs = getConstraintSystem();
-  return cs.getConstraintLocator(anchor, path);
+  return cs.getConstraintLocator(const_cast<Expr *>(anchor), path);
+}
+
+ConstraintLocator *
+Solution::getConstraintLocator(ConstraintLocator *base,
+                               ArrayRef<LocatorPathElt> path) const {
+  auto &cs = getConstraintSystem();
+  return cs.getConstraintLocator(base, path);
 }
 
 /// Return the implicit access kind for a MemberRefExpr with the