[Sema] NFC: Refactor getUnopenedTypeOfReference to accept callback for type

Author: xedin

lib/Sema/ConstraintSystem.cpp

@@ -800,23 +800,22 @@ static bool doesStorageProduceLValue(TypeChecker &TC,
       !storage->isSetterMutating();
 }
 
-Type TypeChecker::getUnopenedTypeOfReference(VarDecl *value, Type baseType,
-                                             DeclContext *UseDC, Type valueType,
-                                             const DeclRefExpr *base,
-                                             bool wantInterfaceType) {
-
-  Type requestedType = valueType;
-  if (!requestedType) {
-    validateDecl(value);
-    if (!value->hasValidSignature() || value->isInvalid())
-      return ErrorType::get(Context);
-
-    requestedType =
-        (wantInterfaceType ? value->getInterfaceType() : value->getType());
-  }
+Type ConstraintSystem::getUnopenedTypeOfReference(VarDecl *value, Type baseType,
+                                                  DeclContext *UseDC,
+                                                  const DeclRefExpr *base,
+                                                  bool wantInterfaceType) {
+  return TC.getUnopenedTypeOfReference(
+      value, baseType, UseDC,
+      [&](VarDecl *var) -> Type { return getType(var, wantInterfaceType); },
+      base, wantInterfaceType);
+}
 
-  requestedType = requestedType->getWithoutSpecifierType()
-    ->getReferenceStorageReferent();
+Type TypeChecker::getUnopenedTypeOfReference(
+    VarDecl *value, Type baseType, DeclContext *UseDC,
+    llvm::function_ref<Type(VarDecl *)> getType, const DeclRefExpr *base,
+    bool wantInterfaceType) {
+  Type requestedType =
+      getType(value)->getWithoutSpecifierType()->getReferenceStorageReferent();
 
   // If we're dealing with contextual types, and we referenced this type from
   // a different context, map the type.
@@ -1016,8 +1015,8 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
 
   // Determine the type of the value, opening up that type if necessary.
   bool wantInterfaceType = !varDecl->getDeclContext()->isLocalContext();
-  Type valueType = TC.getUnopenedTypeOfReference(
-      varDecl, Type(), DC, getTypeOrNull(varDecl), base, wantInterfaceType);
+  Type valueType =
+      getUnopenedTypeOfReference(varDecl, Type(), DC, base, wantInterfaceType);
 
   assert(!valueType->hasUnboundGenericType() &&
          !valueType->hasTypeParameter());
@@ -1337,9 +1336,8 @@ ConstraintSystem::getTypeOfMemberReference(
       refType = FunctionType::get(indicesTy, elementTy,
                                   AnyFunctionType::ExtInfo());
     } else {
-      refType = TC.getUnopenedTypeOfReference(cast<VarDecl>(value), baseTy,
-                                              useDC, getTypeOrNull(value), base,
-                                              /*wantInterfaceType=*/true);
+      refType = getUnopenedTypeOfReference(cast<VarDecl>(value), baseTy, useDC,
+                                           base, /*wantInterfaceType=*/true);
     }
 
     auto selfTy = outerDC->getSelfInterfaceType();

lib/Sema/ConstraintSystem.h

@@ -1654,18 +1654,12 @@ class ConstraintSystem {
     return ParamTypes.find(P)->second;
   }
 
-  Type getTypeOrNull(const ValueDecl *D) const {
-    if (auto *P = dyn_cast<ParamDecl>(D))
-      return getType(P);
-    return Type();
-  }
-
-  Type getTypeOrInterfaceType(const ValueDecl *D) const {
+  Type getType(const VarDecl *D, bool wantInterfaceType = true) const {
     if (auto *P = dyn_cast<ParamDecl>(D))
       return getType(P);
 
     assert(D->hasValidSignature());
-    return D->getInterfaceType();
+    return wantInterfaceType ? D->getInterfaceType() : D->getType();
   }
 
   /// Cache the type of the expression argument and return that same
@@ -2240,6 +2234,22 @@ class ConstraintSystem {
                           DeclContext *useDC,
                           const DeclRefExpr *base = nullptr);
 
+  /// Return the type-of-reference of the given value.
+  ///
+  /// \param baseType if non-null, return the type of a member reference to
+  ///   this value when the base has the given type
+  ///
+  /// \param UseDC The context of the access.  Some variables have different
+  ///   types depending on where they are used.
+  ///
+  /// \param base The optional base expression of this value reference
+  ///
+  /// \param wantInterfaceType Whether we want the interface type, if available.
+  Type getUnopenedTypeOfReference(VarDecl *value, Type baseType,
+                                  DeclContext *UseDC,
+                                  const DeclRefExpr *base = nullptr,
+                                  bool wantInterfaceType = false);
+
   /// \brief Retrieve the type of a reference to the given value declaration,
   /// as a member with a base of the given type.
   ///

lib/Sema/TypeChecker.h

@@ -1745,17 +1745,46 @@ class TypeChecker final : public LazyResolver {
   /// \param UseDC The context of the access.  Some variables have different
   ///   types depending on where they are used.
   ///
-  /// \param valueType The optional type associated with given value, if it's
-  /// not set, type of the declaration is going to be used instead.
-  ///
   /// \param base The optional base expression of this value reference
   ///
   /// \param wantInterfaceType Whether we want the interface type, if available.
+  ///
+  /// \param getType Optional callback to extract a type for given declaration.
   Type getUnopenedTypeOfReference(VarDecl *value, Type baseType,
-                                  DeclContext *UseDC, Type valueType = Type(),
+                                  DeclContext *UseDC,
+                                  llvm::function_ref<Type(VarDecl *)> getType,
                                   const DeclRefExpr *base = nullptr,
                                   bool wantInterfaceType = false);
 
+  /// Return the type-of-reference of the given value.
+  ///
+  /// \param baseType if non-null, return the type of a member reference to
+  ///   this value when the base has the given type
+  ///
+  /// \param UseDC The context of the access.  Some variables have different
+  ///   types depending on where they are used.
+  ///
+  /// \param base The optional base expression of this value reference
+  ///
+  /// \param wantInterfaceType Whether we want the interface type, if available.
+  Type getUnopenedTypeOfReference(VarDecl *value, Type baseType,
+                                  DeclContext *UseDC,
+                                  const DeclRefExpr *base = nullptr,
+                                  bool wantInterfaceType = false) {
+    return getUnopenedTypeOfReference(
+        value, baseType, UseDC,
+        [&](VarDecl *var) -> Type {
+          validateDecl(var);
+
+          if (!var->hasValidSignature() || var->isInvalid())
+            return ErrorType::get(Context);
+
+          return wantInterfaceType ? value->getInterfaceType()
+                                   : value->getType();
+        },
+        base, wantInterfaceType);
+  }
+
   /// \brief Retrieve the default type for the given protocol.
   ///
   /// Some protocols, particularly those that correspond to literals, have