RequirementMachine: Stub out support for superclass and concrete type requirements

Author: slavapestov

include/swift/AST/RewriteSystem.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_REWRITESYSTEM_H
 #define SWIFT_REWRITESYSTEM_H
 
+#include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/LayoutConstraint.h"
@@ -350,14 +351,20 @@ class RewriteContext final {
   RewriteContext &operator=(const RewriteContext &) = delete;
   RewriteContext &operator=(RewriteContext &&) = delete;
 
+  ASTContext &Context;
+
 public:
   /// Statistical counters.
   UnifiedStatsReporter *Stats;
 
-  RewriteContext(UnifiedStatsReporter *stats) : Stats(stats) {}
+  RewriteContext(ASTContext &ctx) : Context(ctx), Stats(ctx.Stats) {}
+
+  Term getTermForType(CanType paramType, const ProtocolDecl *proto);
+
+  MutableTerm getMutableTermForType(CanType paramType,
+                                    const ProtocolDecl *proto);
 
-  MutableTerm getTermForType(CanType paramType,
-                             const ProtocolDecl *proto);
+  ASTContext &getASTContext() { return Context; }
 };
 
 /// A rewrite rule that replaces occurrences of LHS with RHS.

lib/AST/RequirementMachine.cpp

@@ -37,6 +37,10 @@ struct RewriteSystemBuilder {
   ProtocolGraph Protocols;
   std::vector<std::pair<MutableTerm, MutableTerm>> Rules;
 
+  CanType getConcreteSubstitutionSchema(CanType concreteType,
+                                        const ProtocolDecl *proto,
+                                        SmallVector<Term> &result);
+
   RewriteSystemBuilder(RewriteContext &ctx, bool debug)
     : Context(ctx), Debug(debug) {}
   void addGenericSignature(CanGenericSignature sig);
@@ -48,6 +52,32 @@ struct RewriteSystemBuilder {
 
 } // end namespace
 
+/// Given a concrete type that may contain type parameters in structural positions,
+/// collect all the structural type parameter components, and replace them all with
+/// fresh generic parameters. The fresh generic parameters all have a depth of 0,
+/// and the index is an index into the 'result' array.
+///
+/// For example, given the concrete type Foo<X.Y, Array<Z>>, this produces the
+/// result type Foo<τ_0_0, Array<τ_0_1>>, with result array {X.Y, Z}.
+CanType
+RewriteSystemBuilder::getConcreteSubstitutionSchema(CanType concreteType,
+                                                    const ProtocolDecl *proto,
+                                                    SmallVector<Term> &result) {
+  if (!concreteType->hasTypeParameter())
+    return concreteType;
+
+  return CanType(concreteType.transformRec(
+    [&](Type t) -> Optional<Type> {
+      if (!t->isTypeParameter())
+        return None;
+
+      unsigned index = result.size();
+      result.push_back(Context.getTermForType(CanType(t), proto));
+
+      return CanGenericTypeParamType::get(/*depth=*/0, index, Context.getASTContext());
+    }));
+}
+
 void RewriteSystemBuilder::addGenericSignature(CanGenericSignature sig) {
   // Collect all protocols transitively referenced from the generic signature's
   // requirements.
@@ -115,8 +145,12 @@ void RewriteSystemBuilder::addRequirement(const Requirement &req,
     llvm::dbgs() << "\n";
   }
 
+  // Compute the left hand side.
   auto subjectType = CanType(req.getFirstType());
-  auto subjectTerm = Context.getTermForType(subjectType, proto);
+  auto subjectTerm = Context.getMutableTermForType(subjectType, proto);
+
+  // Compute the right hand side.
+  MutableTerm constraintTerm;
 
   switch (req.getKind()) {
   case RequirementKind::Conformance: {
@@ -127,55 +161,72 @@ void RewriteSystemBuilder::addRequirement(const Requirement &req,
     // Intuitively, this means "any type ending with T conforms to P".
     auto *proto = req.getProtocolDecl();
 
-    auto constraintTerm = subjectTerm;
+    constraintTerm = subjectTerm;
     constraintTerm.add(Atom::forProtocol(proto, Context));
-
-    Rules.emplace_back(subjectTerm, constraintTerm);
     break;
   }
 
-  case RequirementKind::Superclass:
-    // FIXME: Implement
+  case RequirementKind::Superclass: {
+    // A superclass requirement T : C<X, Y> becomes a rewrite rule
+    //
+    //   T.[superclass: C<X, Y>] => T
+    auto otherType = CanType(req.getSecondType());
+
+    SmallVector<Term> substitutions;
+    otherType = getConcreteSubstitutionSchema(otherType, proto,
+                                              substitutions);
+
+    constraintTerm = subjectTerm;
+    constraintTerm.add(Atom::forSuperclass(otherType, substitutions,
+                                           Context));
     break;
+  }
 
   case RequirementKind::Layout: {
     // A layout requirement T : L becomes a rewrite rule
     //
     //   T.[L] == T
-    auto constraintTerm = subjectTerm;
+    constraintTerm = subjectTerm;
     constraintTerm.add(Atom::forLayout(req.getLayoutConstraint(),
                                        Context));
-
-    Rules.emplace_back(subjectTerm, constraintTerm);
     break;
   }
 
   case RequirementKind::SameType: {
-    // A same-type requirement T == U becomes a rewrite rule
-    //
-    //   T == U
     auto otherType = CanType(req.getSecondType());
 
-    // FIXME: Handle concrete types
-    if (!otherType->isTypeParameter())
+    if (!otherType->isTypeParameter()) {
+      // A concrete same-type requirement T == C<X, Y> becomes a
+      // rewrite rule
+      //
+      //   T.[concrete: C<X, Y>] => T
+      SmallVector<Term> substitutions;
+      otherType = getConcreteSubstitutionSchema(otherType, proto,
+                                                substitutions);
+
+      constraintTerm = subjectTerm;
+      constraintTerm.add(Atom::forConcreteType(otherType, substitutions,
+                                               Context));
       break;
+    }
 
-    auto otherTerm = Context.getTermForType(otherType, proto);
-
-    Rules.emplace_back(subjectTerm, otherTerm);
+    constraintTerm = Context.getMutableTermForType(otherType, proto);
     break;
   }
   }
+
+  Rules.emplace_back(subjectTerm, constraintTerm);
 }
 
+
 /// We use the PIMPL pattern to avoid creeping header dependencies.
 struct RequirementMachine::Implementation {
   RewriteContext Context;
   RewriteSystem System;
   bool Complete = false;
 
-  Implementation(ASTContext &ctx)
-    : Context(ctx.Stats), System(Context) {}
+  explicit Implementation(ASTContext &ctx)
+      : Context(ctx), System(Context) {}
 };
 
 RequirementMachine::RequirementMachine(ASTContext &ctx) : Context(ctx) {

lib/AST/RewriteSystem.cpp

@@ -865,6 +865,11 @@ void MutableTerm::dump(llvm::raw_ostream &out) const {
   }
 }
 
+Term RewriteContext::getTermForType(CanType paramType,
+                                    const ProtocolDecl *proto) {
+  return Term::get(getMutableTermForType(paramType, proto), *this);
+}
+
 /// Map an interface type to a term.
 ///
 /// If \p proto is null, this is a term relative to a generic
@@ -877,8 +882,8 @@ void MutableTerm::dump(llvm::raw_ostream &out) const {
 /// The bound associated types in the interface type are ignored; the
 /// resulting term consists entirely of a root atom followed by zero
 /// or more name atoms.
-MutableTerm RewriteContext::getTermForType(CanType paramType,
-                                           const ProtocolDecl *proto) {
+MutableTerm RewriteContext::getMutableTermForType(CanType paramType,
+                                                  const ProtocolDecl *proto) {
   assert(paramType->isTypeParameter());
 
   // Collect zero or more nested type names in reverse order.