[AST] Sink ProtocolConformance::getWitness() down into NormalProtocolConformance.

NormalProtocolConformance has the only correct implementation of this
functionality. Instead, providing a safer getWitnessDecl() that
doesn't promise substitutions that are incorrect (and not actually
used by any clients).

Author: DougGregor

include/swift/AST/ProtocolConformance.h

@@ -182,41 +182,16 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance {
     return false;
   }
 
-  /// Retrieve the non-type witness for the given requirement.
-  Witness getWitness(ValueDecl *requirement, LazyResolver *resolver) const;
+  /// Retrieve the value witness declaration corresponding to the given
+  /// requirement.
+  ValueDecl *getWitnessDecl(ValueDecl *requirement,
+                            LazyResolver *resolver) const;
 
 private:
   /// Determine whether we have a witness for the given requirement.
   bool hasWitness(ValueDecl *requirement) const;
 
 public:
-  /// Apply the given function object to each value witness within this
-  /// protocol conformance.
-  ///
-  /// The function object should accept a \c ValueDecl* for the requirement
-  /// followed by the \c Witness for the witness. Note that a generic
-  /// witness will only be specialized if the conformance came from the current
-  /// file.
-  template<typename F>
-  void forEachValueWitness(LazyResolver *resolver, F f) const {
-    const ProtocolDecl *protocol = getProtocol();
-    for (auto req : protocol->getMembers()) {
-      auto valueReq = dyn_cast<ValueDecl>(req);
-      if (!valueReq || isa<AssociatedTypeDecl>(valueReq) ||
-          valueReq->isInvalid())
-        continue;
-
-      if (!valueReq->isProtocolRequirement())
-        continue;
-
-      // If we don't have and cannot resolve witnesses, skip it.
-      if (!resolver && !hasWitness(valueReq))
-        continue;
-
-      f(valueReq, getWitness(valueReq, resolver));
-    }
-  }
-
   /// Retrieve the protocol conformance for the inherited protocol.
   ProtocolConformance *getInheritedConformance(ProtocolDecl *protocol) const;
 
@@ -457,6 +432,33 @@ class NormalProtocolConformance : public ProtocolConformance,
   /// Set the witness for the given requirement.
   void setWitness(ValueDecl *requirement, Witness witness) const;
 
+  /// Apply the given function object to each value witness within this
+  /// protocol conformance.
+  ///
+  /// The function object should accept a \c ValueDecl* for the requirement
+  /// followed by the \c Witness for the witness. Note that a generic
+  /// witness will only be specialized if the conformance came from the current
+  /// file.
+  template<typename F>
+  void forEachValueWitness(LazyResolver *resolver, F f) const {
+    const ProtocolDecl *protocol = getProtocol();
+    for (auto req : protocol->getMembers()) {
+      auto valueReq = dyn_cast<ValueDecl>(req);
+      if (!valueReq || isa<AssociatedTypeDecl>(valueReq) ||
+          valueReq->isInvalid())
+        continue;
+
+      if (!valueReq->isProtocolRequirement())
+        continue;
+
+      // If we don't have and cannot resolve witnesses, skip it.
+      if (!resolver && !hasWitness(valueReq))
+        continue;
+
+      f(valueReq, getWitness(valueReq, resolver));
+    }
+  }
+
   /// Retrieve the protocol conformances that satisfy the requirements of the
   /// protocol, which line up with the conformance constraints in the
   /// protocol's requirement signature.
@@ -565,10 +567,6 @@ class SpecializedProtocolConformance : public ProtocolConformance,
   getTypeWitnessAndDecl(AssociatedTypeDecl *assocType,
                         LazyResolver *resolver) const;
 
-  /// Retrieve the value witness corresponding to the given requirement.
-  Witness getWitness(ValueDecl *requirement, LazyResolver *resolver) const;
-
-
   /// Given that the requirement signature of the protocol directly states
   /// that the given dependent type must conform to the given protocol,
   /// return its associated conformance.
@@ -665,12 +663,6 @@ class InheritedProtocolConformance : public ProtocolConformance,
     return InheritedConformance->getTypeWitnessAndDecl(assocType, resolver);
   }
 
-  /// Retrieve the value witness corresponding to the given requirement.
-  Witness getWitness(ValueDecl *requirement, LazyResolver *resolver) const {
-    // FIXME: Substitute!
-    return InheritedConformance->getWitness(requirement, resolver);
-  }
-
   /// Given that the requirement signature of the protocol directly states
   /// that the given dependent type must conform to the given protocol,
   /// return its associated conformance.

lib/AST/ConformanceLookupTable.cpp

@@ -1103,7 +1103,8 @@ ConformanceLookupTable::getSatisfiedProtocolRequirementsForMember(
       if (conf->isInvalid())
         continue;
 
-      conf->forEachValueWitness(resolver, [&](ValueDecl *req,
+      auto normal = conf->getRootNormalConformance();
+      normal->forEachValueWitness(resolver, [&](ValueDecl *req,
                                               ConcreteDeclRef witness) {
         if (witness.getDecl() == member)
           reqs.push_back(req);

lib/AST/ProtocolConformance.cpp

@@ -251,9 +251,22 @@ Type ProtocolConformance::getTypeWitness(AssociatedTypeDecl *assocType,
   return getTypeWitnessAndDecl(assocType, resolver).first;
 }
 
-Witness ProtocolConformance::getWitness(ValueDecl *requirement,
-                                        LazyResolver *resolver) const {
-  CONFORMANCE_SUBCLASS_DISPATCH(getWitness, (requirement, resolver))
+ValueDecl *ProtocolConformance::getWitnessDecl(ValueDecl *requirement,
+                                               LazyResolver *resolver) const {
+  switch (getKind()) {
+  case ProtocolConformanceKind::Normal:
+    return cast<NormalProtocolConformance>(this)->getWitness(requirement,
+                                                             resolver)
+      .getDecl();
+
+  case ProtocolConformanceKind::Inherited:
+    return cast<InheritedProtocolConformance>(this)
+      ->getInheritedConformance()->getWitnessDecl(requirement, resolver);
+
+  case ProtocolConformanceKind::Specialized:
+    return cast<SpecializedProtocolConformance>(this)
+      ->getGenericConformance()->getWitnessDecl(requirement, resolver);
+  }
 }
 
 /// Determine whether the witness for the given requirement
@@ -704,13 +717,6 @@ SpecializedProtocolConformance::getTypeWitnessAndDecl(
   return TypeWitnesses[assocType];
 }
 
-Witness
-SpecializedProtocolConformance::getWitness(ValueDecl *requirement,
-                                           LazyResolver *resolver) const {
-  // FIXME: Apply substitutions here!
-  return GenericConformance->getWitness(requirement, resolver);
-}
-
 ProtocolConformanceRef
 SpecializedProtocolConformance::getAssociatedConformance(Type assocType,
                                                 ProtocolDecl *protocol,

lib/SILGen/SILGenBridging.cpp

@@ -44,7 +44,7 @@ emitBridgeNativeToObjectiveC(SILGenFunction &SGF,
   if (!requirement) return None;
 
   // Retrieve the _bridgeToObjectiveC witness.
-  auto witness = conformance->getWitness(requirement, nullptr);
+  auto witness = conformance->getWitnessDecl(requirement, nullptr);
   assert(witness);
 
   // Determine the type we're bridging to.
@@ -55,7 +55,7 @@ emitBridgeNativeToObjectiveC(SILGenFunction &SGF,
   assert(objcType);
 
   // Create a reference to the witness.
-  SILDeclRef witnessConstant(witness.getDecl());
+  SILDeclRef witnessConstant(witness);
   auto witnessRef = SGF.emitGlobalFunctionRef(loc, witnessConstant);
 
   // Determine the substitutions.
@@ -65,10 +65,10 @@ emitBridgeNativeToObjectiveC(SILGenFunction &SGF,
 
   // FIXME: Figure out the right SubstitutionMap stuff if the witness
   // has generic parameters of its own.
-  assert(!cast<FuncDecl>(witness.getDecl())->isGeneric() &&
+  assert(!cast<FuncDecl>(witness)->isGeneric() &&
          "Generic witnesses not supported");
 
-  auto *dc = cast<FuncDecl>(witness.getDecl())->getDeclContext();
+  auto *dc = cast<FuncDecl>(witness)->getDeclContext();
   auto *genericSig = dc->getGenericSignatureOfContext();
   auto typeSubMap = swiftValueType->getContextSubstitutionMap(
       SGF.SGM.SwiftModule, dc);
@@ -118,11 +118,11 @@ emitBridgeObjectiveCToNative(SILGenFunction &SGF,
   if (!requirement) return None;
 
   // Retrieve the _unconditionallyBridgeFromObjectiveC witness.
-  auto witness = conformance->getWitness(requirement, nullptr);
+  auto witness = conformance->getWitnessDecl(requirement, nullptr);
   assert(witness);
 
   // Create a reference to the witness.
-  SILDeclRef witnessConstant(witness.getDecl());
+  SILDeclRef witnessConstant(witness);
   auto witnessRef = SGF.emitGlobalFunctionRef(loc, witnessConstant);
 
   // Determine the substitutions.

lib/SILGen/SILGenConvert.cpp

@@ -483,10 +483,12 @@ ManagedValue SILGenFunction::emitExistentialErasure(
       // Devirtualize.  Maybe this should be done implicitly by
       // emitPropertyLValue?
       if (storedNSErrorConformance->isConcrete()) {
-        if (auto witnessVar = storedNSErrorConformance->getConcrete()
-                                          ->getWitness(nsErrorVar, nullptr)) {
-          nsErrorVar = cast<VarDecl>(witnessVar.getDecl());
-          nsErrorVarSubstitutions = witnessVar.getSubstitutions();
+        if (auto normal = dyn_cast<NormalProtocolConformance>(
+                                    storedNSErrorConformance->getConcrete())) {
+          if (auto witnessVar = normal->getWitness(nsErrorVar, nullptr)) {
+            nsErrorVar = cast<VarDecl>(witnessVar.getDecl());
+            nsErrorVarSubstitutions = witnessVar.getSubstitutions();
+          }
         }
       }
 

lib/Sema/CSApply.cpp

@@ -166,7 +166,7 @@ static DeclTy *findNamedWitnessImpl(
     return requirement;
   auto concrete = conformance->getConcrete();
   // FIXME: Dropping substitutions here.
-  return cast_or_null<DeclTy>(concrete->getWitness(requirement, &tc).getDecl());
+  return cast_or_null<DeclTy>(concrete->getWitnessDecl(requirement, &tc));
 }
 
 static bool shouldAccessStorageDirectly(Expr *base, VarDecl *member,
@@ -426,16 +426,15 @@ namespace {
                                     (ConformanceCheckFlags::InExpression|
                                          ConformanceCheckFlags::Used));
             if (conformance && conformance->isConcrete()) {
-              if (auto witnessRef =
-                    conformance->getConcrete()->getWitness(decl, &tc)) {
+              if (auto witness =
+                        conformance->getConcrete()->getWitnessDecl(decl, &tc)) {
                 // Hack up an AST that we can type-check (independently) to get
                 // it into the right form.
                 // FIXME: the hop through 'getDecl()' is because
                 // SpecializedProtocolConformance doesn't substitute into
                 // witnesses' ConcreteDeclRefs.
                 Type expectedFnType = simplifiedFnType->getResult();
                 Expr *refExpr;
-                ValueDecl *witness = witnessRef.getDecl();
                 if (witness->getDeclContext()->isTypeContext()) {
                   Expr *base =
                     TypeExpr::createImplicitHack(loc.getBaseNameLoc(), baseTy,

lib/Sema/CSRanking.cpp

@@ -200,8 +200,7 @@ static Comparison compareWitnessAndRequirement(TypeChecker &tc, DeclContext *dc,
 
   // If the witness and the potential witness are not the same, there's no
   // ordering here.
-  if (conformance->getConcrete()->getWitness(req, &tc).getDecl()
-        != potentialWitness)
+  if (conformance->getConcrete()->getWitnessDecl(req, &tc) != potentialWitness)
     return Comparison::Unordered;
 
   // We have a requirement/witness match.

lib/Sema/TypeCheckNameLookup.cpp

@@ -155,7 +155,7 @@ namespace {
           witness = concrete->getTypeWitnessAndDecl(assocType, &TC)
             .second;
         } else if (found->isProtocolRequirement()) {
-          witness = concrete->getWitness(found, &TC).getDecl();
+          witness = concrete->getWitnessDecl(found, &TC);
         }
 
         // FIXME: the "isa<ProtocolDecl>()" check will be wrong for

lib/Sema/TypeCheckProtocol.cpp

@@ -2696,7 +2696,7 @@ ConformanceChecker::resolveWitnessViaLookup(ValueDecl *requirement) {
         if (auto conformance =
               TC.conformsToProtocol(Adoptee, derivableProto, DC, None)) {
           if (conformance->isConcrete())
-            conformance->getConcrete()->getWitness(derivable, &TC);
+            (void)conformance->getConcrete()->getWitnessDecl(derivable, &TC);
         }
       }
     }
@@ -5990,7 +5990,7 @@ TypeChecker::findWitnessedObjCRequirements(const ValueDecl *witness,
       }
       if (!*conformance) continue;
 
-      const Decl *found = (*conformance)->getWitness(req, this).getDecl();
+      const Decl *found = (*conformance)->getWitnessDecl(req, this);
 
       if (!found) {
         // If we have an optional requirement in an inherited conformance,