Merge pull request swiftlang#22630 from xedin/add-generic-context-to-locator

xedin · web-flow · commit b009bf61541d · 2019-02-15T17:36:19.000-08:00
[ConstraintLocator] Add generic signature to `OpenedGeneric` element
diff --git a/lib/Sema/CSDiagnostics.cpp b/lib/Sema/CSDiagnostics.cpp
@@ -99,30 +99,35 @@ const Requirement &RequirementFailure::getRequirement() const {
   // If this is a conditional requirement failure we need to
   // fetch conformance from constraint system associated with
   // type requirement this conditional conformance belongs to.
-  if (isConditional()) {
-    auto conformanceRef = getConformanceRef();
-    return conformanceRef.getConditionalRequirements()[getRequirementIndex()];
-  }
-
-  return getGenericContext()->getGenericRequirements()[getRequirementIndex()];
+  auto requirements = isConditional()
+                          ? Conformance->getConditionalRequirements()
+                          : Signature->getRequirements();
+  return requirements[getRequirementIndex()];
 }
 
-ProtocolConformanceRef RequirementFailure::getConformanceRef() const {
-  assert(isConditional());
-
+ProtocolConformance *RequirementFailure::getConformanceForConditionalReq(
+    ConstraintLocator *locator) {
   auto &cs = getConstraintSystem();
-  auto *locator = getLocator();
+  auto path = locator->getPath();
+  assert(!path.empty());
+
+  if (!path.back().isConditionalRequirement()) {
+    assert(path.back().isTypeParameterRequirement());
+    return nullptr;
+  }
 
-  auto *typeReqLoc =
-      cs.getConstraintLocator(getRawAnchor(), locator->getPath().drop_back(),
-                              /*summaryFlags=*/0);
+  auto *typeReqLoc = cs.getConstraintLocator(getRawAnchor(), path.drop_back(),
+                                             /*summaryFlags=*/0);
 
-  auto conformance = llvm::find_if(
+  auto result = llvm::find_if(
       cs.CheckedConformances,
       [&](const std::pair<ConstraintLocator *, ProtocolConformanceRef>
               &conformance) { return conformance.first == typeReqLoc; });
-  assert(conformance != cs.CheckedConformances.end());
-  return conformance->second;
+  assert(result != cs.CheckedConformances.end());
+
+  auto conformance = result->second;
+  assert(conformance.isConcrete());
+  return conformance.getConcrete();
 }
 
 ValueDecl *RequirementFailure::getDeclRef() const {
@@ -169,13 +174,25 @@ ValueDecl *RequirementFailure::getDeclRef() const {
   return ownerType->getAnyGeneric();
 }
 
+GenericSignature *RequirementFailure::getSignature(ConstraintLocator *locator) {
+  if (isConditional())
+    return Conformance->getGenericSignature();
+
+  auto path = locator->getPath();
+  for (auto iter = path.rbegin(); iter != path.rend(); ++iter) {
+    const auto &elt = *iter;
+    if (elt.getKind() == ConstraintLocator::OpenedGeneric)
+      return elt.getGenericSignature();
+  }
+
+  llvm_unreachable("Type requirement failure should always have signature");
+}
+
 const DeclContext *RequirementFailure::getRequirementDC() const {
   // In case of conditional requirement failure, we don't
   // have to guess where the it comes from.
-  if (isConditional()) {
-    auto *conformance = getConformanceRef().getConcrete();
-    return conformance->getDeclContext();
-  }
+  if (isConditional())
+    return Conformance->getDeclContext();
 
   const auto &req = getRequirement();
   auto *DC = AffectedDecl->getDeclContext();
@@ -242,10 +259,9 @@ void RequirementFailure::emitRequirementNote(const Decl *anchor, Type lhs,
   auto &req = getRequirement();
 
   if (isConditional()) {
-    auto *conformance = getConformanceRef().getConcrete();
     emitDiagnostic(anchor, diag::requirement_implied_by_conditional_conformance,
-                   resolveType(conformance->getType()),
-                   conformance->getProtocol()->getDeclaredInterfaceType());
+                   resolveType(Conformance->getType()),
+                   Conformance->getProtocol()->getDeclaredInterfaceType());
     return;
   }
 
diff --git a/lib/Sema/CSDiagnostics.h b/lib/Sema/CSDiagnostics.h
@@ -166,20 +166,29 @@ class RequirementFailure : public FailureDiagnostic {
   using DiagInReference = Diag<DescriptiveDeclKind, DeclName, Type, Type, Type>;
   using DiagAsNote = Diag<Type, Type, Type, Type, StringRef>;
 
+  /// If this failure associated with one of the conditional requirements,
+  /// this field would represent conformance where requirement comes from.
+  const ProtocolConformance *Conformance = nullptr;
+
+  /// The source of the requirement, if available. One exception
+  /// is failure associated with conditional requirement where
+  /// underlying conformance is specialized.
+  const GenericSignature *Signature;
+
   const ValueDecl *AffectedDecl;
   /// If possible, find application expression associated
   /// with current generic requirement failure, that helps
   /// to diagnose failures related to arguments.
   const ApplyExpr *Apply = nullptr;
 
-  /// If this failure associated with one of the conditional requirements.
-  bool IsConditional = false;
-
 public:
   RequirementFailure(ConstraintSystem &cs, Expr *expr, RequirementKind kind,
                      ConstraintLocator *locator)
-      : FailureDiagnostic(expr, cs, locator), AffectedDecl(getDeclRef()) {
+      : FailureDiagnostic(expr, cs, locator),
+        Conformance(getConformanceForConditionalReq(locator)),
+        Signature(getSignature(locator)), AffectedDecl(getDeclRef()) {
     assert(locator);
+    assert(isConditional() || Signature);
     assert(AffectedDecl);
 
     auto path = locator->getPath();
@@ -190,8 +199,6 @@ class RequirementFailure : public FailureDiagnostic {
            last.isConditionalRequirement());
     assert(static_cast<RequirementKind>(last.getValue2()) == kind);
 
-    IsConditional = last.isConditionalRequirement();
-
     // It's possible sometimes not to have no base expression.
     if (!expr)
       return;
@@ -227,11 +234,7 @@ class RequirementFailure : public FailureDiagnostic {
 
 protected:
   /// Determine whether this is a conditional requirement failure.
-  bool isConditional() const { return IsConditional; }
-
-  /// If this is a failure in condition requirement, retrieve
-  /// conformance information.
-  ProtocolConformanceRef getConformanceRef() const;
+  bool isConditional() const { return bool(Conformance); }
 
   /// Retrieve declaration contextual where current
   /// requirement has been introduced.
@@ -268,11 +271,19 @@ class RequirementFailure : public FailureDiagnostic {
   /// Retrieve declaration associated with failing generic requirement.
   ValueDecl *getDeclRef() const;
 
+  /// Retrieve generic signature where this parameter originates from.
+  GenericSignature *getSignature(ConstraintLocator *locator);
+
   void emitRequirementNote(const Decl *anchor, Type lhs, Type rhs) const;
 
   /// Determine whether given declaration represents a static
   /// or instance property/method, excluding operators.
   static bool isStaticOrInstanceMember(const ValueDecl *decl);
+
+  /// If this is a failure in conditional requirement, retrieve
+  /// conformance information.
+  ProtocolConformance *
+  getConformanceForConditionalReq(ConstraintLocator *locator);
 };
 
 /// Diagnostics for failed conformance checks originating from
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
@@ -1612,20 +1612,27 @@ static ConstraintFix *fixRequirementFailure(ConstraintSystem &cs, Type type1,
   if (type1->hasDependentMember() || type2->hasDependentMember())
     return nullptr;
 
-  auto req = path.back();
+  auto reqPath = path.take_back(2);
+  auto req = reqPath.back();
 
   ConstraintLocator *reqLoc = nullptr;
   if (req.isConditionalRequirement()) {
-    // If underlaying conformance requirement has been fixed as
-    // we there is no reason to fix up conditional requirements.
-    if (cs.hasFixFor(cs.getConstraintLocator(anchor, req)))
+    // path is - ... -> open generic -> type req # -> cond req #,
+    // to identify type requirement we only need `open generic -> type req #`
+    // part, because that's how fixes for type requirements are recorded.
+    reqPath = path.drop_back().take_back(2);
+    // If underlying conformance requirement has been fixed,
+    // then there is no reason to fix up conditional requirements.
+    if (cs.hasFixFor(cs.getConstraintLocator(anchor, reqPath,
+                                             /*summaryFlags=*/0)))
       return nullptr;
 
     // For conditional requirements we need a full path.
     reqLoc = cs.getConstraintLocator(anchor, path, /*summaryFlags=*/0);
   } else {
     // Build simplified locator which only contains anchor and requirement info.
-    reqLoc = cs.getConstraintLocator(anchor, req);
+    reqLoc = cs.getConstraintLocator(anchor, reqPath,
+                                     /*summaryFlags=*/0);
   }
 
   auto reqKind = static_cast<RequirementKind>(req.getValue2());
@@ -2784,9 +2791,14 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
         path.back().isConditionalRequirement()) {
       ConstraintLocator *reqLoc = nullptr;
       if (path.back().isConditionalRequirement()) {
+        // Drop 'conditional requirement' element remainder
+        // of the path is going to point to type requirement
+        // this conditional comes from.
+        auto reqPath = ArrayRef<LocatorPathElt>(path).drop_back();
         // Underlying conformance requirement is itself fixed,
-        // this wouldn't lead to right solution.
-        if (hasFixFor(getConstraintLocator(anchor, path.back())))
+        // this wouldn't lead to a right solution.
+        if (hasFixFor(getConstraintLocator(anchor, reqPath.take_back(2),
+                                           /*summaryFlags=*/0)))
           return SolutionKind::Error;
 
         // For conditional requirements we need complete path, which includes
@@ -2795,8 +2807,11 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
       } else {
         // Let's strip all of the unnecessary information from locator,
         // diagnostics only care about anchor - to lookup type,
-        // and what was the requirement# which is not satisfied.
-        reqLoc = getConstraintLocator(anchor, path.back());
+        // generic signature where requirement comes from, and
+        // what was the requirement# which is not satisfied.
+        auto reqPath = ArrayRef<LocatorPathElt>(path).take_back(2);
+        reqLoc = getConstraintLocator(anchor, reqPath,
+                                      /*summaryFlags=*/0);
       }
 
       auto *fix = MissingConformance::create(*this, type, protocol, reqLoc);
diff --git a/lib/Sema/ConstraintLocator.h b/lib/Sema/ConstraintLocator.h
@@ -152,12 +152,12 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     case AutoclosureResult:
     case Requirement:
     case Witness:
-    case OpenedGeneric:
     case ImplicitlyUnwrappedDisjunctionChoice:
     case DynamicLookupResult:
     case ContextualType:
       return 0;
 
+    case OpenedGeneric:
     case GenericArgument:
     case NamedTupleElement:
     case TupleElement:
@@ -236,6 +236,7 @@ class ConstraintLocator : public llvm::FoldingSetNode {
       StoredGenericParameter,
       StoredRequirement,
       StoredWitness,
+      StoredGenericSignature,
       StoredKindAndValue
     };
 
@@ -249,11 +250,11 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     /// kind. Use \c encodeStorage and \c decodeStorage to work with this value.
     ///
     /// \note The "storage kind" is stored in the  \c storedKind field.
-    uint64_t storage : 62;
+    uint64_t storage : 61;
 
     /// The kind of value stored in \c storage. Valid values are those
     /// from the StoredKind enum.
-    uint64_t storedKind : 2;
+    uint64_t storedKind : 3;
 
     /// Encode a path element kind and a value into the storage format.
     static uint64_t encodeStorage(PathElementKind kind, unsigned value) {
@@ -281,6 +282,10 @@ class ConstraintLocator : public llvm::FoldingSetNode {
              "Path element kind does not require 2 values");
     }
 
+    PathElement(GenericSignature *sig)
+        : storage((reinterpret_cast<uintptr_t>(sig) >> 3)),
+          storedKind(StoredGenericSignature) {}
+
     friend class ConstraintLocator;
 
   public:
@@ -292,7 +297,7 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     }
 
     PathElement(GenericTypeParamType *type)
-      : storage((reinterpret_cast<uintptr_t>(type) >> 2)),
+      : storage((reinterpret_cast<uintptr_t>(type) >> 3)),
         storedKind(StoredGenericParameter)
     {
       static_assert(alignof(GenericTypeParamType) >= 4,
@@ -301,7 +306,7 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     }
 
     PathElement(PathElementKind kind, ValueDecl *decl)
-      : storage((reinterpret_cast<uintptr_t>(decl) >> 2)),
+      : storage((reinterpret_cast<uintptr_t>(decl) >> 3)),
         storedKind(kind == Witness ? StoredWitness : StoredRequirement)
     {
       assert((kind == Witness || kind == Requirement) &&
@@ -339,6 +344,10 @@ class ConstraintLocator : public llvm::FoldingSetNode {
       return PathElement(KeyPathComponent, position);
     }
 
+    static PathElement getOpenedGeneric(GenericSignature *sig) {
+      return PathElement(sig);
+    }
+
     /// Get a path element for a conditional requirement.
     static PathElement
     getConditionalRequirementComponent(unsigned index, RequirementKind kind) {
@@ -364,6 +373,9 @@ class ConstraintLocator : public llvm::FoldingSetNode {
       case StoredWitness:
         return Witness;
 
+      case StoredGenericSignature:
+        return OpenedGeneric;
+
       case StoredKindAndValue:
         return decodeStorage(storage).first;
       }
@@ -399,22 +411,28 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     /// Retrieve the declaration for a witness path element.
     ValueDecl *getWitness() const {
       assert(getKind() == Witness && "Is not a witness");
-      return reinterpret_cast<ValueDecl *>(storage << 2);
+      return reinterpret_cast<ValueDecl *>(storage << 3);
     }
 
     /// Retrieve the actual archetype for a generic parameter path
     /// element.
     GenericTypeParamType *getGenericParameter() const {
       assert(getKind() == GenericParameter &&
              "Not a generic parameter path element");
-      return reinterpret_cast<GenericTypeParamType *>(storage << 2);
+      return reinterpret_cast<GenericTypeParamType *>(storage << 3);
     }
 
     /// Retrieve the declaration for a requirement path element.
     ValueDecl *getRequirement() const {
       assert((static_cast<StoredKind>(storedKind) == StoredRequirement) &&
              "Is not a requirement");
-      return reinterpret_cast<ValueDecl *>(storage << 2);
+      return reinterpret_cast<ValueDecl *>(storage << 3);
+    }
+
+    GenericSignature *getGenericSignature() const {
+      assert((static_cast<StoredKind>(storedKind) == StoredGenericSignature) &&
+             "Is not an opened generic");
+      return reinterpret_cast<GenericSignature *>(storage << 3);
     }
 
     /// Return the summary flags for this particular element.
diff --git a/lib/Sema/ConstraintSystem.cpp b/lib/Sema/ConstraintSystem.cpp
@@ -1079,7 +1079,7 @@ void ConstraintSystem::openGeneric(
   // Remember that any new constraints generated by opening this generic are
   // due to the opening.
   locatorPtr = getConstraintLocator(
-                     locator.withPathElement(ConstraintLocator::OpenedGeneric));
+      locator.withPathElement(LocatorPathElt::getOpenedGeneric(sig)));
 
   bindArchetypesFromContext(*this, outerDC, locatorPtr, replacements);
 
@@ -1124,7 +1124,7 @@ void ConstraintSystem::openGenericRequirements(
 
     addConstraint(
         *openedReq,
-        locator.withPathElement(ConstraintLocator::OpenedGeneric)
+        locator.withPathElement(LocatorPathElt::getOpenedGeneric(signature))
             .withPathElement(
                 LocatorPathElt::getTypeRequirementComponent(pos, kind)));
   }
