RequirementMachine: Remove RewriteSystem::TypeWitness

Author: slavapestov

lib/AST/RequirementMachine/PropertyRelations.cpp

@@ -143,55 +143,4 @@ unsigned RewriteSystem::recordSameTypeWitnessRelation(
   return recordRelation(
       Term::get(lhsTerm, Context),
       Term::get(rhsTerm, Context));
-}
-
-RewriteSystem::TypeWitness::TypeWitness(
-    Term lhs, llvm::PointerUnion<Symbol, Term> rhs)
-  : LHS(lhs), RHS(rhs) {
-  assert(LHS.size() >= 2);
-  assert(getConcreteConformance().getKind() ==
-         Symbol::Kind::ConcreteConformance);
-  assert(getAssocType().getKind() == Symbol::Kind::AssociatedType);
-  if (RHS.is<Symbol>())
-    assert(RHS.get<Symbol>().getKind() == Symbol::Kind::ConcreteType);
-  assert(getAssocType().getProtocols().size() == 1);
-  assert(getAssocType().getProtocols()[0] ==
-         getConcreteConformance().getProtocol());
-}
-
-namespace swift {
-namespace rewriting {
-bool operator==(const RewriteSystem::TypeWitness &lhs,
-                const RewriteSystem::TypeWitness &rhs) {
-  return lhs.LHS == rhs.LHS && lhs.RHS == rhs.RHS;
-}
-}
-}
-
-void RewriteSystem::TypeWitness::dump(llvm::raw_ostream &out) const {
-  out << "Subject type: " << LHS << "\n";
-  if (RHS.is<Symbol>())
-    out << "Concrete type witness: " << RHS.get<Symbol>() << "\n";
-  else
-    out << "Abstract type witness: " << RHS.get<Term>() << "\n";
-}
-
-unsigned RewriteSystem::recordTypeWitness(
-    RewriteSystem::TypeWitness witness) {
-  unsigned index = TypeWitnesses.size();
-  auto inserted = TypeWitnessMap.insert(std::make_pair(witness.LHS, index));
-
-  if (!inserted.second) {
-    index = inserted.first->second;
-  } else {
-    TypeWitnesses.push_back(witness);
-  }
-
-  assert(TypeWitnesses[index] == witness);
-  return index;
-}
-
-const RewriteSystem::TypeWitness &
-RewriteSystem::getTypeWitness(unsigned index) const {
-  return TypeWitnesses[index];
 }

lib/AST/RequirementMachine/RewriteSystem.h

@@ -360,69 +360,6 @@ class RewriteSystem final {
       Symbol concreteConformanceSymbol,
       Symbol associatedTypeSymbol);
 
-  /// A type witness has a subject type, stored in LHS, which takes the form:
-  ///
-  /// T.[concrete: C : P].[P:X]
-  ///
-  /// For some concrete type C, protocol P and associated type X.
-  ///
-  /// The type witness of X in the conformance C : P is either a concrete type,
-  /// or an abstract type parameter.
-  ///
-  /// If it is a concrete type, then RHS stores the concrete type symbol.
-  ///
-  /// If it is an abstract type parameter, then RHS stores the type term.
-  ///
-  /// Think of these as rewrite rules which are lazily created, but always
-  /// "there" -- they encode information about concrete conformances, which
-  /// are solved outside of the requirement machine itself.
-  ///
-  /// We don't want to eagerly pull in all concrete conformances and walk
-  /// them recursively introducing rewrite rules.
-  ///
-  /// The RewriteStep::{Concrete,Same,Abstract}TypeWitness rewrite step kinds
-  /// reference TypeWitnesses via their RuleID field.
-  ///
-  /// Type witnesses are recorded lazily in property map construction, in
-  /// PropertyMap::computeConstraintTermForTypeWitness().
-  struct TypeWitness {
-    Term LHS;
-    llvm::PointerUnion<Symbol, Term> RHS;
-
-    TypeWitness(Term lhs, llvm::PointerUnion<Symbol, Term> rhs);
-
-    friend bool operator==(const TypeWitness &lhs,
-                           const TypeWitness &rhs);
-
-    Symbol getConcreteConformance() const {
-      return *(LHS.end() - 2);
-    }
-
-    Symbol getAssocType() const {
-      return *(LHS.end() - 1);
-    }
-
-    Symbol getConcreteType() const {
-      return RHS.get<Symbol>();
-    }
-
-    Term getAbstractType() const {
-      return RHS.get<Term>();
-    }
-
-    void dump(llvm::raw_ostream &out) const;
-  };
-
-private:
-  /// Cache for concrete type witnesses. The value in the map is an index
-  /// into the vector.
-  llvm::DenseMap<Term, unsigned> TypeWitnessMap;
-  std::vector<TypeWitness> TypeWitnesses;
-
-public:
-  unsigned recordTypeWitness(TypeWitness witness);
-  const TypeWitness &getTypeWitness(unsigned index) const;
-
 private:
   //////////////////////////////////////////////////////////////////////////////
   ///