Sema: Simplify substMemberTypeWithBase()

The isTypeReference parameter is now always true, so change
the function to just take a TypeDecl.

Author: slavapestov

lib/Sema/TypeCheckGeneric.cpp

@@ -206,7 +206,7 @@ Type CompleteGenericTypeResolver::resolveDependentMemberType(
   // concrete type, or resolve its components down to another dependent member.
   if (auto alias = nestedPA->getTypeAliasDecl()) {
     return TC.substMemberTypeWithBase(DC->getParentModule(), alias,
-                                      baseTy, true);
+                                      baseTy);
   }
 
   Identifier name = ref->getIdentifier();

lib/Sema/TypeCheckNameLookup.cpp

@@ -369,8 +369,7 @@ LookupTypeResult TypeChecker::lookupMemberType(DeclContext *dc,
 
     // Substitute the base into the member's type.
     auto memberType = substMemberTypeWithBase(dc->getParentModule(),
-                                              typeDecl, type,
-                                              /*isTypeReference=*/true);
+                                              typeDecl, type);
 
     // FIXME: It is not clear why this substitution can fail, but the
     // standard library won't build without this check.

lib/Sema/TypeCheckType.cpp

@@ -337,7 +337,7 @@ Type TypeChecker::resolveTypeInContext(
           }
 
           return substMemberTypeWithBase(parentDC->getParentModule(), typeDecl,
-                                         fromType, /*isTypeReference=*/true);
+                                         fromType);
         }
       }
 
@@ -378,7 +378,7 @@ Type TypeChecker::resolveTypeInContext(
         }
 
         return substMemberTypeWithBase(parentDC->getParentModule(), typeDecl,
-                                       fromType, /*isTypeReference=*/true);
+                                       fromType);
       }
 
       if (auto superclassTy = getSuperClassOf(fromType))
@@ -1142,8 +1142,7 @@ static Type resolveNestedIdentTypeComponent(
 
     // Otherwise, simply substitute the parent type into the member.
     memberType = TC.substMemberTypeWithBase(DC->getParentModule(), typeDecl,
-                                            parentTy,
-                                            /*isTypeReference=*/true);
+                                            parentTy);
 
     // Propagate failure.
     if (!memberType || memberType->hasError()) return memberType;
@@ -2797,21 +2796,18 @@ Type TypeResolver::buildProtocolType(
 }
 
 Type TypeChecker::substMemberTypeWithBase(Module *module,
-                                          const ValueDecl *member,
-                                          Type baseTy, bool isTypeReference) {
-  Type memberType = isTypeReference
-                      ? cast<TypeDecl>(member)->getDeclaredInterfaceType()
-                      : member->getInterfaceType();
-  if (isTypeReference) {
-    // The declared interface type for a generic type will have the type
-    // arguments; strip them off.
-    if (auto nominalTypeDecl = dyn_cast<NominalTypeDecl>(member)) {
-      if (auto boundGenericTy = memberType->getAs<BoundGenericType>()) {
-        memberType = UnboundGenericType::get(
-                       const_cast<NominalTypeDecl *>(nominalTypeDecl),
-                       boundGenericTy->getParent(),
-                       Context);
-      }
+                                          const TypeDecl *member,
+                                          Type baseTy) {
+  Type memberType = member->getDeclaredInterfaceType();
+
+  // The declared interface type for a generic type will have the type
+  // arguments; strip them off.
+  if (auto nominalTypeDecl = dyn_cast<NominalTypeDecl>(member)) {
+    if (auto boundGenericTy = memberType->getAs<BoundGenericType>()) {
+      memberType = UnboundGenericType::get(
+                     const_cast<NominalTypeDecl *>(nominalTypeDecl),
+                     boundGenericTy->getParent(),
+                     Context);
     }
   }
 

lib/Sema/TypeChecker.h

@@ -855,17 +855,14 @@ class TypeChecker final : public LazyResolver {
                                     bool isGenericSignature,
                                     GenericTypeResolver *resolver);
 
-  /// \brief Substitute the given base type into the type of the given member,
-  /// producing the effective type that the member will have.
+  /// \brief Substitute the given base type into the type of the given nested type,
+  /// producing the effective type that the nested type will have.
   ///
   /// \param module The module in which the substitution will be performed.
   /// \param member The member whose type projection is being computed.
   /// \param baseTy The base type that will be substituted for the 'Self' of the
   /// member.
-  /// \param isTypeReference Whether this is a reference to a type declaration
-  /// within a type context.
-  Type substMemberTypeWithBase(Module *module, const ValueDecl *member,
-                               Type baseTy, bool isTypeReference);
+  Type substMemberTypeWithBase(Module *module, const TypeDecl *member, Type baseTy);
 
   /// \brief Retrieve the superclass type of the given type, or a null type if
   /// the type has no supertype.