Simplify the interface to Module::lookupConformance.

Rather than returning a weird PointerIntPair, return an
Optional<ProtocolConformanceRef>. NFC

Author: DougGregor

include/swift/AST/Module.h

@@ -147,19 +147,6 @@ enum ASTNameLookupFlags {
                           NL_RemoveNonVisible | NL_RemoveOverridden
 };
 
-/// Describes the result of looking for the conformance of a given type
-/// to a specific protocol.
-enum class ConformanceKind {
-  /// The type does not conform to the protocol.
-  DoesNotConform,
-  /// The type conforms to the protocol, with the given conformance.
-  Conforms,
-};
-
-/// The result of looking for a specific conformance.
-typedef llvm::PointerIntPair<ProtocolConformance *, 2, ConformanceKind>
-  LookupConformanceResult;
-
 /// Discriminator for file-units.
 enum class FileUnitKind {
   /// For a .swift source file.
@@ -386,24 +373,18 @@ class ModuleDecl : public TypeDecl, public DeclContext {
   /// Look for the conformance of the given type to the given protocol.
   ///
   /// This routine determines whether the given \c type conforms to the given
-  /// \c protocol. It only looks for explicit conformances (which are
-  /// required by the language), and will return a \c ProtocolConformance*
-  /// describing the conformance.
-  ///
-  /// During type-checking, it is possible that this routine will find an
-  /// explicit declaration of conformance that has not yet been type-checked,
-  /// in which case it will return note the presence of an unchecked
-  /// conformance.
+  /// \c protocol.
   ///
   /// \param type The type for which we are computing conformance.
   ///
   /// \param protocol The protocol to which we are computing conformance.
   ///
   /// \param resolver The lazy resolver.
   ///
-  /// \returns The result of the conformance search, with a conformance
-  /// structure when possible.
-  LookupConformanceResult
+  /// \returns The result of the conformance search, which will be
+  /// None if the type does not conform to the protocol or contain a
+  /// ProtocolConformanceRef if it does conform.
+  Optional<ProtocolConformanceRef>
   lookupConformance(Type type, ProtocolDecl *protocol, LazyResolver *resolver);
 
   /// Find a member named \p name in \p container that was declared in this

lib/AST/ASTContext.cpp

@@ -3605,13 +3605,7 @@ ASTContext::getBridgedToObjC(const DeclContext *dc, Type type,
   // Check whether the type conforms to _BridgedToObjectiveC.
   auto conformance
     = dc->getParentModule()->lookupConformance(type, bridgedProto, resolver);
-
-  switch (conformance.getInt()) {
-  case ConformanceKind::Conforms:
-    // The type conforms, and we know the conformance, so we can look up the
-    // bridged type below.
-    break;
-  case ConformanceKind::DoesNotConform:
+  if (!conformance) {
     // If we haven't imported Foundation but this is a whitelisted type,
     // behave as above.
     if (knownBridgedToObjC)
@@ -3621,7 +3615,7 @@ ASTContext::getBridgedToObjC(const DeclContext *dc, Type type,
 
   // Find the type we bridge to.
   return ProtocolConformance::getTypeWitnessByName(type,
-                                               conformance.getPointer(),
+                                               conformance->getConcrete(),
                                                getIdentifier("_ObjectiveCType"),
                                                resolver);
 }

lib/AST/ArchetypeBuilder.cpp

@@ -280,20 +280,15 @@ static ProtocolConformance *getSuperConformance(
   auto conformance =
     builder.getModule().lookupConformance(superclass, proto,
                                           builder.getLazyResolver());
-  switch (conformance.getInt()) {
-  case ConformanceKind::Conforms: {
-    // Conformance to this protocol is redundant; update the requirement source
-    // appropriately.
-    updateRequirementSource(
-      conformsSource,
-      RequirementSource(RequirementSource::Protocol,
-                        pa->getSuperclassSource().getLoc()));
-    return conformance.getPointer();
-  }
+  if (!conformance) return nullptr;
 
-  case ConformanceKind::DoesNotConform:
-    return nullptr;
-  }
+  // Conformance to this protocol is redundant; update the requirement source
+  // appropriately.
+  updateRequirementSource(
+    conformsSource,
+    RequirementSource(RequirementSource::Protocol,
+                      pa->getSuperclassSource().getLoc()));
+  return conformance->getConcrete();
 }
 
 /// If there is a same-type requirement to be added for the given nested type
@@ -1217,15 +1212,15 @@ bool ArchetypeBuilder::addSameTypeRequirementToConcrete(
       auto protocol = conforms.first;
       auto conformance = Mod.lookupConformance(Concrete, protocol,
                                                getLazyResolver());
-      if (conformance.getInt() == ConformanceKind::DoesNotConform) {
+      if (!conformance) {
         Diags.diagnose(Source.getLoc(),
                        diag::requires_generic_param_same_type_does_not_conform,
                        Concrete, protocol->getName());
         return true;
       }
 
-      assert(conformance.getPointer() && "No conformance pointer?");
-      conformances[protocol] = conformance.getPointer();
+      assert(conformance->isConcrete() && "Abstract conformance?");
+      conformances[protocol] = conformance->getConcrete();
     }
   }
 

lib/AST/ConformanceLookupTable.cpp

@@ -815,7 +815,9 @@ ProtocolConformance *ConformanceLookupTable::getConformance(
                                   .getPointer();
 
     // Form the inherited conformance.
-    conformance = ctx.getInheritedConformance(type, inheritedConformance);
+    conformance = ctx.getInheritedConformance(
+                    type,
+                    inheritedConformance->getConcrete());
   } else {
     // Create or find the normal conformance.
     Type conformingType = conformingDC->getDeclaredTypeInContext();

lib/AST/Module.cpp

@@ -739,23 +739,17 @@ ArrayRef<Substitution> BoundGenericType::getSubstitutions(
 
     SmallVector<ProtocolConformanceRef, 4> conformances;
     for (auto proto : archetype->getConformsTo()) {
-      // If the type is a type variable or is dependent, just fill in null
+      // If the type is a type variable or is dependent, just fill in empty
       // conformances.
       if (type->is<TypeVariableType>() || type->isTypeParameter()) {
         conformances.push_back(ProtocolConformanceRef(proto));
 
       // Otherwise, find the conformances.
       } else {
-        auto conforms = module->lookupConformance(type, proto, resolver);
-        switch (conforms.getInt()) {
-        case ConformanceKind::Conforms:
-          conformances.push_back(
-                         ProtocolConformanceRef(proto, conforms.getPointer()));
-          break;
-        case ConformanceKind::DoesNotConform:
+        if (auto conforms = module->lookupConformance(type, proto, resolver))
+          conformances.push_back(*conforms);
+        else
           conformances.push_back(ProtocolConformanceRef(proto));
-          break;
-        }
       }
     }
 
@@ -778,28 +772,28 @@ ArrayRef<Substitution> BoundGenericType::getSubstitutions(
   return permanentSubs;
 }
 
-LookupConformanceResult Module::lookupConformance(Type type,
-                                                  ProtocolDecl *protocol,
-                                                  LazyResolver *resolver) {
+Optional<ProtocolConformanceRef>
+Module::lookupConformance(Type type, ProtocolDecl *protocol,
+                          LazyResolver *resolver) {
   ASTContext &ctx = getASTContext();
 
   // An archetype conforms to a protocol if the protocol is listed in the
   // archetype's list of conformances.
   if (auto archetype = type->getAs<ArchetypeType>()) {
     if (protocol->isSpecificProtocol(KnownProtocolKind::AnyObject)) {
       if (archetype->requiresClass())
-        return { nullptr, ConformanceKind::Conforms };
-      return { nullptr, ConformanceKind::DoesNotConform };
+        return ProtocolConformanceRef(protocol);
+
+      return None;
     }
 
     for (auto ap : archetype->getConformsTo()) {
       if (ap == protocol || ap->inheritsFrom(protocol))
-        return { nullptr, ConformanceKind::Conforms };
+        return ProtocolConformanceRef(protocol);
     }
 
-    if (!archetype->getSuperclass()) {
-      return { nullptr, ConformanceKind::DoesNotConform };
-    }
+    if (!archetype->getSuperclass())
+      return None;
   }
 
   // An existential conforms to a protocol if the protocol is listed in the
@@ -815,74 +809,68 @@ LookupConformanceResult Module::lookupConformance(Type type,
     for (auto proto : protocols) {
       if (!proto->isObjC() &&
           !proto->isSpecificProtocol(KnownProtocolKind::AnyObject))
-        return { nullptr, ConformanceKind::DoesNotConform };
+        return None;
     }
 
     // If the existential type cannot be represented or the protocol does not
     // conform to itself, there's no point in looking further.
     if (!protocol->existentialConformsToSelf() ||
         !protocol->existentialTypeSupported(resolver))
-      return { nullptr, ConformanceKind::DoesNotConform };
+      return None;
 
     // Special-case AnyObject, which may not be in the list of conformances.
     if (protocol->isSpecificProtocol(KnownProtocolKind::AnyObject)) {
-      return { nullptr, type->isClassExistentialType()
-                          ? ConformanceKind::Conforms
-                          : ConformanceKind::DoesNotConform };
+      if (type->isClassExistentialType())
+        return ProtocolConformanceRef(protocol);
+
+      return None;
     }
 
     // Look for this protocol within the existential's list of conformances.
     for (auto proto : protocols) {
-      if (proto == protocol || proto->inheritsFrom(protocol)) {
-        return { nullptr, ConformanceKind::Conforms };
-      }
+      if (proto == protocol || proto->inheritsFrom(protocol))
+        return ProtocolConformanceRef(protocol);
     }
 
     // We didn't find our protocol in the existential's list; it doesn't
     // conform.
-    return { nullptr, ConformanceKind::DoesNotConform };
+    return None;
   }
 
   // Check for protocol conformance of archetype via superclass requirement.
   if (auto archetype = type->getAs<ArchetypeType>()) {
     if (auto super = archetype->getSuperclass()) {
-      auto inheritedConformance = lookupConformance(super, protocol, resolver);
-      switch (inheritedConformance.getInt()) {
-      case ConformanceKind::DoesNotConform:
-        return { nullptr, ConformanceKind::DoesNotConform };
-      case ConformanceKind::Conforms:
-        auto result =
-          ctx.getInheritedConformance(type, inheritedConformance.getPointer());
-        return { result, ConformanceKind::Conforms };
+      if (auto inheritedConformance = lookupConformance(super, protocol,
+                                                        resolver)) {
+        return ProtocolConformanceRef(
+                 ctx.getInheritedConformance(
+                   type,
+                   inheritedConformance->getConcrete()));
       }
+
+      return None;
     }
   }
 
   // UnresolvedType is a placeholder for an unknown type used when generating
   // diagnostics.  We consider it to conform to all protocols, since the
   // intended type might have.
   if (type->is<UnresolvedType>()) {
-    return {
-      ctx.getConformance(type, protocol, protocol->getLoc(), this,
-                         ProtocolConformanceState::Complete),
-      ConformanceKind::Conforms
-    };
+    return ProtocolConformanceRef(
+             ctx.getConformance(type, protocol, protocol->getLoc(), this,
+                                ProtocolConformanceState::Complete));
   }
 
 
   auto nominal = type->getAnyNominal();
 
   // If we don't have a nominal type, there are no conformances.
-  // FIXME: We may have implicit conformances for some cases. Handle those
-  // here.
-  if (!nominal) {
-    return { nullptr, ConformanceKind::DoesNotConform };
-  }
+  if (!nominal) return None;
 
   // Find the (unspecialized) conformance.
   SmallVector<ProtocolConformance *, 2> conformances;
   if (!nominal->lookupConformance(this, protocol, conformances))
-    return { nullptr, ConformanceKind::DoesNotConform };
+    return None;
 
   // FIXME: Ambiguity resolution.
   auto conformance = conformances.front();
@@ -905,19 +893,13 @@ LookupConformanceResult Module::lookupConformance(Type type,
     // Compute the conformance for the inherited type.
     auto inheritedConformance = lookupConformance(superclassTy, protocol,
                                                   resolver);
-    switch (inheritedConformance.getInt()) {
-    case ConformanceKind::DoesNotConform:
-      llvm_unreachable("We already found the inherited conformance");
-
-    case ConformanceKind::Conforms:
-      // Create inherited conformance below.
-      break;
-    }
+    assert(inheritedConformance &&
+           "We already found the inherited conformance");
 
     // Create the inherited conformance entry.
     conformance
-      = ctx.getInheritedConformance(type, inheritedConformance.getPointer());
-    return { conformance, ConformanceKind::Conforms };
+      = ctx.getInheritedConformance(type, inheritedConformance->getConcrete());
+    return ProtocolConformanceRef(conformance);
   }
 
   // If the type is specialized, find the conformance for the generic type.
@@ -938,18 +920,18 @@ LookupConformanceResult Module::lookupConformance(Type type,
 
       for (auto sub : substitutions) {
         if (sub.getReplacement()->is<ErrorType>())
-          return { nullptr, ConformanceKind::DoesNotConform };
+          return None;
       }
 
       // Create the specialized conformance entry.
       auto result = ctx.getSpecializedConformance(type, conformance,
                                                   substitutions);
-      return { result, ConformanceKind::Conforms };
+      return ProtocolConformanceRef(result);
     }
   }
 
   // Record and return the simple conformance.
-  return { conformance, ConformanceKind::Conforms };
+  return ProtocolConformanceRef(conformance);
 }
 
 namespace {

lib/AST/ProtocolConformance.cpp

@@ -358,12 +358,13 @@ SpecializedProtocolConformance::getTypeWitnessSubstAndDecl(
   for (auto proto : assocType->getConformingProtocols(resolver)) {
     auto conforms = conformingModule->lookupConformance(specializedType, proto,
                                                         resolver);
-    assert((conforms.getInt() == ConformanceKind::Conforms ||
+    assert((conforms ||
             specializedType->is<TypeVariableType>() ||
             specializedType->isTypeParameter() ||
             specializedType->is<ErrorType>()) &&
            "Improperly checked substitution");
-    conformances.push_back(ProtocolConformanceRef(proto, conforms.getPointer()));
+    conformances.push_back(conforms ? *conforms 
+                                    : ProtocolConformanceRef(proto));
   }
 
   // Form the substitution.

lib/AST/Type.cpp

@@ -2407,24 +2407,21 @@ static Type getMemberForBaseType(Module *module,
     auto proto = assocType->getProtocol();
     // FIXME: Introduce substituted type node here?
     auto conformance = module->lookupConformance(substBase, proto, resolver);
-    switch (conformance.getInt()) {
-    case ConformanceKind::DoesNotConform:
+    if (!conformance)
       return Type();
 
-    case ConformanceKind::Conforms:
-      // If we have an unsatisfied type witness while we're checking the
-      // conformances we're supposed to skip this conformance's unsatisfied type
-      // witnesses, and we have an unsatisfied type witness, return
-      // "missing".
-      assert(conformance.getPointer());
-      if (conformance.getPointer()->getRootNormalConformance()->getState()
-            == ProtocolConformanceState::CheckingTypeWitnesses &&
-          !conformance.getPointer()->hasTypeWitness(assocType, nullptr))
-        return Type();
+    // If we have an unsatisfied type witness while we're checking the
+    // conformances we're supposed to skip this conformance's unsatisfied type
+    // witnesses, and we have an unsatisfied type witness, return
+    // "missing".
+    assert(conformance->isConcrete());
+    if (conformance->getConcrete()->getRootNormalConformance()->getState()
+          == ProtocolConformanceState::CheckingTypeWitnesses &&
+        !conformance->getConcrete()->hasTypeWitness(assocType, nullptr))
+      return Type();
 
-      return conformance.getPointer()->getTypeWitness(assocType, resolver)
-               .getReplacement();
-    }
+    return conformance->getConcrete()->getTypeWitness(assocType, resolver)
+             .getReplacement();
   }
 
   // FIXME: This is a fallback. We want the above, conformance-based