RequirementMachine: Introduce Rule::isProtocolTypeAliasRule()

There are two kinds of protocol typealiases:

1) The underlying type is a type parameter. These rules look like
   [P].A => X where X is the underlying type.

2) The underlying type is a concrete type. These rules look like
   [P].A.[concrete: C] => [P].A.

The isProtocolTypeAliasRule() predicate detects both cases and
returns the type alias name ('A', in the above examples). For now
it's not used anywhere, since we don't actually introduce these
rules for any reason.

Author: slavapestov

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -120,6 +120,48 @@ bool Rule::isProtocolRefinementRule() const {
   return false;
 }
 
+/// A protocol typealias rule takes one of the following two forms,
+/// where T is a name symbol:
+///
+/// 1) [P].T => X
+/// 2) [P].T.[concrete: C] => [P].T
+///
+/// The first case is where the protocol's underlying type is another
+/// type parameter. The second case is where the protocol's underlying
+/// type is a concrete type.
+///
+/// In the first case, X must be fully resolved, that is, it must not
+/// contain any name symbols.
+///
+/// If this rule is a protocol typealias rule, returns its name. Otherwise
+/// returns None.
+Optional<Identifier> Rule::isProtocolTypeAliasRule() const {
+  if (LHS.size() != 2 && LHS.size() != 3)
+    return None;
+
+  if (LHS[0].getKind() != Symbol::Kind::Protocol ||
+      LHS[1].getKind() != Symbol::Kind::Name)
+    return None;
+
+  if (LHS.size() == 2) {
+    // This is the case where the underlying type is a type parameter.
+    //
+    // We shouldn't have unresolved symbols on the right hand side;
+    // they should have been simplified away.
+    if (RHS.containsUnresolvedSymbols())
+      return None;
+  } else {
+    // This is the case where the underlying type is concrete.
+    assert(LHS.size() == 3);
+
+    auto prop = isPropertyRule();
+    if (!prop || prop->getKind() != Symbol::Kind::ConcreteType)
+      return None;
+  }
+
+  return LHS[1].getName();
+}
+
 /// Returns the length of the left hand side.
 unsigned Rule::getDepth() const {
   auto result = LHS.size();

lib/AST/RequirementMachine/RewriteSystem.h

@@ -140,6 +140,8 @@ class Rule final {
             RHS.containsUnresolvedSymbols());
   }
 
+  Optional<Identifier> isProtocolTypeAliasRule() const;
+
   void markLHSSimplified() {
     assert(!LHSSimplified);
     LHSSimplified = true;