Merge pull request #42079 from slavapestov/rqm-simplify-type-for-term

RequirementMachine: Simplify getTypeForSymbolRange() a bit

Author: slavapestov

lib/AST/RequirementMachine/GenericSignatureQueries.cpp

@@ -307,6 +307,21 @@ bool RequirementMachine::isCanonicalTypeInContext(Type type) const {
   return !type.walk(Walker(*this));
 }
 
+/// Given a type parameter 'T.A1.A2...An', a suffix length m where m <= n,
+/// and a replacement type U, produce the type 'U.A(n-m)...An' by replacing
+/// 'T.A1...A(n-m-1)' with 'U'.
+static Type substPrefixType(Type type, unsigned suffixLength, Type prefixType,
+                            GenericSignature sig) {
+  if (suffixLength == 0)
+    return prefixType;
+
+  auto *memberType = type->castTo<DependentMemberType>();
+  auto substBaseType = substPrefixType(memberType->getBase(), suffixLength - 1,
+                                       prefixType, sig);
+  return memberType->substBaseType(substBaseType,
+                                   LookUpConformanceInSignature(sig.getPointer()));
+}
+
 /// Unlike most other queries, the input type can be any type, not just a
 /// type parameter.
 ///
@@ -416,31 +431,9 @@ Type RequirementMachine::getCanonicalTypeInContext(
       abort();
     }
 
-    // Compute the type of the unresolved suffix term V, rooted in the
-    // generic parameter τ_0_0.
-    auto origType = Map.getRelativeTypeForTerm(term, prefix);
-
-    // Substitute τ_0_0 in the above relative type with the concrete type
-    // for U.
-    //
-    // Example: if T == A.B.C and the longest valid prefix is A.B which
-    // maps to a concrete type Foo<Int>, then we have:
-    //
-    // U == A.B
-    // V == C
-    //
-    // prefixType == Foo<Int>
-    // origType   == τ_0_0.C
-    // substType  == Foo<Int>.C
-    //
-    auto substType = origType.subst(
-      [&](SubstitutableType *type) -> Type {
-        assert(cast<GenericTypeParamType>(type)->getDepth() == 0);
-        assert(cast<GenericTypeParamType>(type)->getIndex() == 0);
-
-        return prefixType;
-      },
-      LookUpConformanceInSignature(Sig.getPointer()));
+    // Compute the type of the unresolved suffix term V.
+    auto substType = substPrefixType(t, term.size() - prefix.size(),
+                                     prefixType, Sig);
 
     // FIXME: Recursion guard is needed here
     return getCanonicalTypeInContext(substType, genericParams);

lib/AST/RequirementMachine/InterfaceType.cpp

@@ -143,57 +143,6 @@ MutableTerm RewriteContext::getMutableTermForType(CanType paramType,
   return MutableTerm(symbols);
 }
 
-/// Map an associated type symbol to an associated type declaration.
-///
-/// Note that the protocol graph is not part of the caching key; each
-/// protocol graph is a subgraph of the global inheritance graph, so
-/// the specific choice of subgraph does not change the result.
-AssociatedTypeDecl *RewriteContext::getAssociatedTypeForSymbol(Symbol symbol) {
-  auto found = AssocTypes.find(symbol);
-  if (found != AssocTypes.end())
-    return found->second;
-
-  assert(symbol.getKind() == Symbol::Kind::AssociatedType);
-  auto name = symbol.getName();
-
-  AssociatedTypeDecl *assocType = nullptr;
-
-  // An associated type symbol [P1:A] stores a protocol 'P' and an
-  // identifier 'A'.
-  //
-  // We map it back to a AssociatedTypeDecl by looking for associated
-  // types named 'A' in 'P' and all protocols 'P' inherits. If there
-  // are multiple candidates, we discard overrides, and then pick the
-  // candidate that is minimal with respect to the linear order
-  // defined by TypeDecl::compare().
-  auto *proto = symbol.getProtocol();
-
-  auto checkOtherAssocType = [&](AssociatedTypeDecl *otherAssocType) {
-    otherAssocType = otherAssocType->getAssociatedTypeAnchor();
-
-    if (otherAssocType->getName() == name &&
-        (assocType == nullptr ||
-         TypeDecl::compare(otherAssocType->getProtocol(),
-                           assocType->getProtocol()) < 0)) {
-      assocType = otherAssocType;
-    }
-  };
-
-  for (auto *otherAssocType : proto->getAssociatedTypeMembers()) {
-    checkOtherAssocType(otherAssocType);
-  }
-
-  for (auto *inheritedProto : getInheritedProtocols(proto)) {
-    for (auto *otherAssocType : inheritedProto->getAssociatedTypeMembers()) {
-      checkOtherAssocType(otherAssocType);
-    }
-  }
-
-  assert(assocType && "Need to look harder");
-  AssocTypes[symbol] = assocType;
-  return assocType;
-}
-
 /// Find the most canonical associated type declaration with the given
 /// name among a set of conforming protocols stored in this property map
 /// entry.
@@ -230,18 +179,13 @@ AssociatedTypeDecl *PropertyBag::getAssociatedType(Identifier name) {
   return assocType;
 }
 
-/// Compute the interface type for a range of symbols, with an optional
-/// root type.
-///
-/// If the root type is specified, we wrap it in a series of
-/// DependentMemberTypes. Otherwise, the root is computed from
-/// the first symbol of the range.
+/// Compute the interface type for a range of symbols.
 static Type
-getTypeForSymbolRange(const Symbol *begin, const Symbol *end, Type root,
+getTypeForSymbolRange(const Symbol *begin, const Symbol *end,
                       TypeArrayView<GenericTypeParamType> genericParams,
                       const PropertyMap &map) {
   auto &ctx = map.getRewriteContext();
-  Type result = root;
+  Type result;
 
   auto handleRoot = [&](GenericTypeParamType *genericParam) {
     assert(genericParam->isCanonical());
@@ -328,12 +272,13 @@ getTypeForSymbolRange(const Symbol *begin, const Symbol *end, Type root,
       continue;
     }
 
-    // We should have a resolved type at this point.
-    AssociatedTypeDecl *assocType;
+    assert(symbol.getKind() == Symbol::Kind::AssociatedType);
 
+    MutableTerm prefix;
     if (begin == iter) {
-      // FIXME: Eliminate this case once merged associated types are gone.
-      assocType = ctx.getAssociatedTypeForSymbol(symbol);
+      // If the term begins with an associated type symbol, look for the
+      // associated type in the protocol itself.
+      prefix.add(Symbol::forProtocol(symbol.getProtocol(), ctx));
     } else {
       // The protocol stored in an associated type symbol appearing in a
       // canonical term is not necessarily the right protocol to look for
@@ -343,41 +288,40 @@ getTypeForSymbolRange(const Symbol *begin, const Symbol *end, Type root,
       //
       // Instead, find all protocols that the prefix conforms to, and look
       // for an associated type in those protocols.
-      MutableTerm prefix(begin, iter);
-      assert(prefix.size() > 0);
+      prefix.append(begin, iter);
+    }
 
-      auto *props = map.lookUpProperties(prefix.rbegin(), prefix.rend());
-      if (props == nullptr) {
-        llvm::errs() << "Cannot build interface type for term "
-                     << MutableTerm(begin, end) << "\n";
-        llvm::errs() << "Prefix does not conform to any protocols: "
-                     << prefix << "\n\n";
-        map.dump(llvm::errs());
-        abort();
-      }
+    auto *props = map.lookUpProperties(prefix.rbegin(), prefix.rend());
+    if (props == nullptr) {
+      llvm::errs() << "Cannot build interface type for term "
+                   << MutableTerm(begin, end) << "\n";
+      llvm::errs() << "Prefix does not conform to any protocols: "
+                   << prefix << "\n\n";
+      map.dump(llvm::errs());
+      abort();
+    }
 
-      // Assert that the associated type's protocol appears among the set
-      // of protocols that the prefix conforms to.
-  #ifndef NDEBUG
-      auto conformsTo = props->getConformsTo();
-      assert(std::find(conformsTo.begin(), conformsTo.end(),
-                       symbol.getProtocol())
-             != conformsTo.end());
-  #endif
-
-      assocType = props->getAssociatedType(symbol.getName());
-      if (assocType == nullptr) {
-        llvm::errs() << "Cannot build interface type for term "
-                     << MutableTerm(begin, end) << "\n";
-        llvm::errs() << "Prefix term does not not have a nested type named "
-                     << symbol.getName() << ": "
-                     << prefix << "\n";
-        llvm::errs() << "Property map entry: ";
-        props->dump(llvm::errs());
-        llvm::errs() << "\n\n";
-        map.dump(llvm::errs());
-        abort();
-      }
+    // Assert that the associated type's protocol appears among the set
+    // of protocols that the prefix conforms to.
+#ifndef NDEBUG
+    auto conformsTo = props->getConformsTo();
+    assert(std::find(conformsTo.begin(), conformsTo.end(),
+                     symbol.getProtocol())
+           != conformsTo.end());
+#endif
+
+    auto *assocType = props->getAssociatedType(symbol.getName());
+    if (assocType == nullptr) {
+      llvm::errs() << "Cannot build interface type for term "
+                   << MutableTerm(begin, end) << "\n";
+      llvm::errs() << "Prefix term does not not have a nested type named "
+                   << symbol.getName() << ": "
+                   << prefix << "\n";
+      llvm::errs() << "Property map entry: ";
+      props->dump(llvm::errs());
+      llvm::errs() << "\n\n";
+      map.dump(llvm::errs());
+      abort();
     }
 
     result = DependentMemberType::get(result, assocType);
@@ -388,26 +332,12 @@ getTypeForSymbolRange(const Symbol *begin, const Symbol *end, Type root,
 
 Type PropertyMap::getTypeForTerm(Term term,
                       TypeArrayView<GenericTypeParamType> genericParams) const {
-  return getTypeForSymbolRange(term.begin(), term.end(), Type(),
-                               genericParams, *this);
+  return getTypeForSymbolRange(term.begin(), term.end(), genericParams, *this);
 }
 
 Type PropertyMap::getTypeForTerm(const MutableTerm &term,
                       TypeArrayView<GenericTypeParamType> genericParams) const {
-  return getTypeForSymbolRange(term.begin(), term.end(), Type(),
-                               genericParams, *this);
-}
-
-Type PropertyMap::getRelativeTypeForTerm(
-    const MutableTerm &term, const MutableTerm &prefix) const {
-  assert(std::equal(prefix.begin(), prefix.end(), term.begin()));
-
-  auto genericParam =
-      CanGenericTypeParamType::get(/*type sequence*/ false, 0, 0,
-                                   Context.getASTContext());
-  return getTypeForSymbolRange(
-      term.begin() + prefix.size(), term.end(), genericParam,
-      { }, *this);
+  return getTypeForSymbolRange(term.begin(), term.end(), genericParams, *this);
 }
 
 /// Concrete type terms are written in terms of generic parameter types that

lib/AST/RequirementMachine/PropertyMap.h

@@ -232,9 +232,6 @@ class PropertyMap {
   Type getTypeForTerm(const MutableTerm &term,
                       TypeArrayView<GenericTypeParamType> genericParams) const;
 
-  Type getRelativeTypeForTerm(
-                      const MutableTerm &term, const MutableTerm &prefix) const;
-
   Type getTypeFromSubstitutionSchema(
                       Type schema,
                       ArrayRef<Term> substitutions,

lib/AST/RequirementMachine/RewriteContext.h

@@ -52,9 +52,6 @@ class RewriteContext final {
   llvm::DenseMap<const ProtocolDecl *,
                  llvm::TinyPtrVector<const ProtocolDecl *>> AllInherited;
 
-  /// Cache for associated type declarations.
-  llvm::DenseMap<Symbol, AssociatedTypeDecl *> AssocTypes;
-
   /// Requirement machines built from generic signatures.
   llvm::DenseMap<GenericSignature, RequirementMachine *> Machines;
 
@@ -194,8 +191,6 @@ class RewriteContext final {
                                                 ArrayRef<Term> substitutions,
                                                 SmallVectorImpl<Term> &result);
 
-  AssociatedTypeDecl *getAssociatedTypeForSymbol(Symbol symbol);
-
   //////////////////////////////////////////////////////////////////////////////
   ///
   /// Construction of requirement machines for connected components in the