RequirementMachine: Remove the older 'concrete type in domain' hack

Author: slavapestov

lib/AST/RequirementMachine/PropertyMap.cpp

@@ -304,7 +304,6 @@ void PropertyMap::clear() {
 
   Trie.clear();
   Entries.clear();
-  ConcreteTypeInDomainMap.clear();
 }
 
 /// Build the property map from all rules of the form T.[p] => T, where
@@ -375,10 +374,6 @@ PropertyMap::buildPropertyMap(unsigned maxIterations,
   // Now, check for conflicts between superclass and concrete type rules.
   checkConcreteTypeRequirements(inducedRules);
 
-  // We collect terms with fully concrete types so that we can re-use them
-  // to tie off recursion in the next step.
-  computeConcreteTypeInDomainMap();
-
   // Now, we merge concrete type rules with conformance rules, by adding
   // relations between associated type members of type parameters with
   // the concrete type witnesses in the concrete type's conformance.

lib/AST/RequirementMachine/PropertyMap.h

@@ -165,9 +165,6 @@ class PropertyMap {
   std::vector<PropertyBag *> Entries;
   Trie<PropertyBag *, MatchKind::Longest> Trie;
 
-  using ConcreteTypeInDomain = std::pair<CanType, ArrayRef<const ProtocolDecl *>>;
-  llvm::DenseMap<ConcreteTypeInDomain, Term> ConcreteTypeInDomainMap;
-
   // Building the property map introduces new induced rules, which
   // runs another round of Knuth-Bendix completion, which rebuilds the
   // property map again.
@@ -235,7 +232,6 @@ class PropertyMap {
   void checkConcreteTypeRequirements(
                    SmallVectorImpl<InducedRule> &inducedRules);
 
-  void computeConcreteTypeInDomainMap();
   void concretizeNestedTypesFromConcreteParents(
                    SmallVectorImpl<InducedRule> &inducedRules);
 

lib/AST/RequirementMachine/PropertyUnification.cpp

@@ -578,33 +578,6 @@ void PropertyMap::checkConcreteTypeRequirements(
   }
 }
 
-/// For each fully-concrete type, find the shortest term having that concrete type.
-/// This is later used by computeConstraintTermForTypeWitness().
-void PropertyMap::computeConcreteTypeInDomainMap() {
-  for (auto *props : Entries) {
-    if (!props->isConcreteType())
-      continue;
-
-    auto concreteType = props->ConcreteType->getConcreteType();
-    if (concreteType->hasTypeParameter())
-      continue;
-
-    assert(props->ConcreteType->getSubstitutions().empty());
-
-    auto domain = props->Key.getRootProtocols();
-    auto concreteTypeKey = std::make_pair(concreteType, domain);
-
-    auto found = ConcreteTypeInDomainMap.find(concreteTypeKey);
-    if (found != ConcreteTypeInDomainMap.end())
-      continue;
-
-    auto inserted = ConcreteTypeInDomainMap.insert(
-        std::make_pair(concreteTypeKey, props->Key));
-    assert(inserted.second);
-    (void) inserted;
-  }
-}
-
 void PropertyMap::concretizeNestedTypesFromConcreteParents(
     SmallVectorImpl<InducedRule> &inducedRules) {
   for (auto *props : Entries) {
@@ -1003,9 +976,6 @@ MutableTerm PropertyMap::computeConstraintTermForTypeWitness(
   if (requirementKind == RequirementKind::SameType &&
       typeWitnessSymbol.getConcreteType() == concreteType &&
       typeWitnessSymbol.getSubstitutions() == substitutions) {
-    // FIXME: ConcreteTypeInDomainMap should support substitutions so
-    // that we can remove this.
-
     if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
       llvm::dbgs() << "^^ Type witness is the same as the concrete type\n";
     }
@@ -1028,29 +998,6 @@ MutableTerm PropertyMap::computeConstraintTermForTypeWitness(
     return result;
   }
 
-  // If the type witness is completely concrete, try to introduce a
-  // same-type requirement with another representative type parameter,
-  // if we have one.
-  if (!typeWitness->hasTypeParameter()) {
-    // Check if we have a shorter representative we can use.
-    auto domain = key.getRootProtocols();
-    auto concreteTypeKey = std::make_pair(typeWitness, domain);
-
-    auto found = ConcreteTypeInDomainMap.find(concreteTypeKey);
-    if (found != ConcreteTypeInDomainMap.end()) {
-      MutableTerm result(found->second);
-      if (result != subjectType) {
-        if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
-          llvm::dbgs() << "^^ Type witness can re-use property bag of "
-                       << found->second << "\n";
-        }
-
-        // FIXME: Record a rewrite path.
-        return result;
-      }
-    }
-  }
-
   // Otherwise, add a concrete type requirement for the type witness.
   //
   // Add a rule: