Sema: Split off getTypeOfMemberReferenceImpl() from getTypeOfMemberReference()

Author: slavapestov

include/swift/Sema/ConstraintSystem.h

@@ -4463,6 +4463,13 @@ class ConstraintSystem {
                           DeclContext *useDC,
                           PreparedOverloadBuilder *preparedOverload);
 
+  /// \returns the opened type, the thrown error type, and the base object type.
+  std::tuple<Type, Type, Type> getTypeOfMemberReferenceImpl(
+      Type baseTy, ValueDecl *decl, DeclContext *useDC, bool isDynamicLookup,
+      FunctionRefInfo functionRefInfo, ConstraintLocator *locator,
+      SmallVectorImpl<OpenedType> *replacements = nullptr,
+      PreparedOverloadBuilder *preparedOverload = nullptr);
+
   /// Retrieve the type of a reference to the given value declaration,
   /// as a member with a base of the given type.
   ///

lib/Sema/TypeOfReference.cpp

@@ -1851,29 +1851,20 @@ static FunctionType *applyOptionality(ValueDecl *value, FunctionType *fnTy) {
                            fnTy->getExtInfo());
 }
 
-DeclReferenceType ConstraintSystem::getTypeOfMemberReference(
+std::tuple<Type, Type, Type>
+ConstraintSystem::getTypeOfMemberReferenceImpl(
     Type baseTy, ValueDecl *value, DeclContext *useDC, bool isDynamicLookup,
     FunctionRefInfo functionRefInfo, ConstraintLocator *locator,
     SmallVectorImpl<OpenedType> *replacementsPtr,
     PreparedOverloadBuilder *preparedOverload) {
+  ASSERT(!isa<TypeDecl>(value));
   ASSERT(!!preparedOverload == PreparingOverload);
   recordFixIfNeededForPlaceholderInDecl(*this, value, locator);
 
   // Figure out the instance type used for the base.
   Type baseRValueTy = baseTy->getRValueType();
   auto baseObjTy = baseRValueTy->getMetatypeInstanceType();
 
-  // If the base is a module type, just use the type of the decl.
-  if (baseObjTy->is<ModuleType>()) {
-    return getTypeOfReference(value, functionRefInfo, locator, useDC,
-                              preparedOverload);
-  }
-
-  if (auto *typeDecl = dyn_cast<TypeDecl>(value)) {
-    return getTypeOfMemberTypeReference(baseObjTy, typeDecl,
-                                        locator, preparedOverload);
-  }
-
   // Figure out the declaration context to use when opening this type.
   DeclContext *innerDC = value->getInnermostDeclContext();
   DeclContext *outerDC = value->getDeclContext();
@@ -1914,7 +1905,7 @@ DeclReferenceType ConstraintSystem::getTypeOfMemberReference(
       isa<MacroDecl>(value)) {
     auto interfaceType = value->getInterfaceType();
     if (interfaceType->is<ErrorType>() || isa<MacroDecl>(value))
-      return { interfaceType, interfaceType, interfaceType, interfaceType, Type() };
+      return { interfaceType, Type(), baseObjTy };
 
     if (outerDC->getSelfClassDecl()) {
       if (isa<ConstructorDecl>(value)) {
@@ -2030,6 +2021,40 @@ DeclReferenceType ConstraintSystem::getTypeOfMemberReference(
     }
   }
 
+  return { openedType, thrownErrorType, baseObjTy };
+}
+
+DeclReferenceType ConstraintSystem::getTypeOfMemberReference(
+    Type baseTy, ValueDecl *value, DeclContext *useDC, bool isDynamicLookup,
+    FunctionRefInfo functionRefInfo, ConstraintLocator *locator,
+    SmallVectorImpl<OpenedType> *replacementsPtr,
+    PreparedOverloadBuilder *preparedOverload) {
+  ASSERT(!!preparedOverload == PreparingOverload);
+
+  // Figure out the instance type used for the base.
+  Type baseRValueTy = baseTy;
+  Type baseObjTy = baseRValueTy->getMetatypeInstanceType();
+
+  // If the base is a module type, just use the type of the decl.
+  if (baseObjTy->getMetatypeInstanceType()->is<ModuleType>()) {
+    return getTypeOfReference(value, functionRefInfo, locator, useDC,
+                              preparedOverload);
+  }
+
+  if (auto *typeDecl = dyn_cast<TypeDecl>(value)) {
+    return getTypeOfMemberTypeReference(baseObjTy, typeDecl,
+                                        locator, preparedOverload);
+  }
+
+  Type openedType, thrownErrorType;
+  std::tie(openedType, thrownErrorType, baseObjTy)
+      = getTypeOfMemberReferenceImpl(baseTy, value, useDC,
+                                     isDynamicLookup, functionRefInfo,
+                                     locator, replacementsPtr,
+                                     preparedOverload);
+
+  auto hasAppliedSelf = doesMemberRefApplyCurriedSelf(baseRValueTy, value);
+
   // Adjust the opened type for concurrency.
   Type origOpenedType = openedType;
   if (isRequirementOrWitness(locator)) {