Sema: Simplify ConstraintSystem::getUnopenedTypeOfReference()

Author: slavapestov

include/swift/Sema/ConstraintSystem.h

@@ -4374,39 +4374,6 @@ class ConstraintSystem {
                                   bool wantInterfaceType = false,
                                   bool adjustForPreconcurrency = true);
 
-  /// 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 locator The locator anchored at this value reference, when
-  /// it is a member reference.
-  ///
-  /// \param wantInterfaceType Whether we want the interface type, if available.
-  ///
-  /// \param getType Optional callback to extract a type for given declaration.
-  static Type
-  getUnopenedTypeOfReference(
-      VarDecl *value, Type baseType, DeclContext *UseDC,
-      llvm::function_ref<Type(VarDecl *)> getType,
-      ConstraintLocator *locator,
-      bool wantInterfaceType = false,
-      bool adjustForPreconcurrency = true,
-      llvm::function_ref<Type(const AbstractClosureExpr *)> getClosureType =
-        [](const AbstractClosureExpr *) {
-          return Type();
-        },
-      llvm::function_ref<bool(const ClosureExpr *)> isolatedByPreconcurrency =
-        [](const ClosureExpr *closure) {
-          return closure->isIsolatedByPreconcurrency();
-        },
-      llvm::function_ref<bool(Expr *)> isAssignTarget = [](Expr *) {
-        return false;
-      });
-
   /// Given the opened type and a pile of information about a member reference,
   /// determine the reference type of the member reference.
   Type getMemberReferenceTypeFromOpenedType(

lib/Sema/TypeOfReference.cpp

@@ -503,43 +503,31 @@ Type ConstraintSystem::getUnopenedTypeOfReference(
     VarDecl *value, Type baseType, DeclContext *UseDC,
     ConstraintLocator *locator, bool wantInterfaceType,
     bool adjustForPreconcurrency) {
-  return ConstraintSystem::getUnopenedTypeOfReference(
-      value, baseType, UseDC,
-      [&](VarDecl *var) -> Type {
-        if (Type type = getTypeIfAvailable(var))
-          return type;
-
-        if (!var->hasInterfaceType()) {
-          return ErrorType::get(getASTContext());
-        }
-
-        return wantInterfaceType ? var->getInterfaceType() : var->getTypeInContext();
-      },
-      locator, wantInterfaceType, adjustForPreconcurrency,
-      GetClosureType{*this},
-      ClosureIsolatedByPreconcurrency{*this},
-      IsInLeftHandSideOfAssignment{*this});
-}
+  Type requestedType;
+  if (Type type = getTypeIfAvailable(value)) {
+    requestedType = type;
+  } else if (!value->hasInterfaceType()) {
+    requestedType = ErrorType::get(getASTContext());
+  } else {
+    requestedType = (wantInterfaceType
+                     ? value->getInterfaceType()
+                     : value->getTypeInContext());
+  }
 
-Type ConstraintSystem::getUnopenedTypeOfReference(
-    VarDecl *value, Type baseType, DeclContext *UseDC,
-    llvm::function_ref<Type(VarDecl *)> getType,
-    ConstraintLocator *locator,
-    bool wantInterfaceType, bool adjustForPreconcurrency,
-    llvm::function_ref<Type(const AbstractClosureExpr *)> getClosureType,
-    llvm::function_ref<bool(const ClosureExpr *)> isolatedByPreconcurrency,
-    llvm::function_ref<bool(Expr *)> isAssignTarget) {
-  Type requestedType =
-      getType(value)->getWithoutSpecifierType()->getReferenceStorageReferent();
+  requestedType =
+      requestedType->getWithoutSpecifierType()->getReferenceStorageReferent();
 
   // Strip pack expansion types off of pack references.
   if (auto *expansion = requestedType->getAs<PackExpansionType>())
     requestedType = expansion->getPatternType();
 
   // Adjust the type for concurrency if requested.
-  if (adjustForPreconcurrency)
+  if (adjustForPreconcurrency) {
     requestedType = adjustVarTypeForConcurrency(
-        requestedType, value, UseDC, getClosureType, isolatedByPreconcurrency);
+        requestedType, value, UseDC,
+        GetClosureType{*this},
+        ClosureIsolatedByPreconcurrency{*this});
+  }
 
   // If we're dealing with contextual types, and we referenced this type from
   // a different context, map the type.
@@ -553,7 +541,8 @@ Type ConstraintSystem::getUnopenedTypeOfReference(
 
   // Qualify storage declarations with an lvalue when appropriate.
   // Otherwise, they yield rvalues (and the access must be a load).
-  if (doesStorageProduceLValue(value, baseType, UseDC, isAssignTarget,
+  if (doesStorageProduceLValue(value, baseType, UseDC,
+                               IsInLeftHandSideOfAssignment{*this},
                                locator) &&
       !requestedType->hasError()) {
     return LValueType::get(requestedType);