Sema: Better prepared overloads, part 2

include/swift/Basic/LangOptions.h

@@ -1011,6 +1011,9 @@ namespace swift {
 
     /// Disable the component splitter phase of the expression type checker.
     bool SolverDisableSplitter = false;
+
+    /// Enable the experimental "prepared overloads" optimization.
+    bool SolverEnablePreparedOverloads = false;
   };
 
   /// Options for controlling the behavior of the Clang importer.

include/swift/Option/FrontendOptions.td

@@ -883,6 +883,12 @@ def solver_scope_threshold_EQ : Joined<["-"], "solver-scope-threshold=">,
 def solver_trail_threshold_EQ : Joined<["-"], "solver-trail-threshold=">,
   HelpText<"Expression type checking trail change limit">;
 
+def solver_disable_prepared_overloads : Flag<["-"], "solver-disable-prepared-overloads">,
+  HelpText<"Disable experimental prepared overloads optimization">;
+
+def solver_enable_prepared_overloads : Flag<["-"], "solver-enable-prepared-overloads">,
+  HelpText<"Enable experimental prepared overloads optimization">;
+
 def solver_disable_splitter : Flag<["-"], "solver-disable-splitter">,
   HelpText<"Disable the component splitter phase of expression type checking">;
 

include/swift/Sema/ConstraintSystem.h

@@ -3795,7 +3795,7 @@ class ConstraintSystem {
   /// Add a constraint that binds an overload set to a specific choice.
   void addBindOverloadConstraint(Type boundTy, OverloadChoice choice,
                                  ConstraintLocator *locator, DeclContext *useDC) {
-    resolveOverload(locator, boundTy, choice, useDC,
+    resolveOverload(choice, useDC, locator, boundTy,
                     /*preparedOverload=*/nullptr);
   }
 
@@ -4437,24 +4437,18 @@ class ConstraintSystem {
   FunctionType *adjustFunctionTypeForConcurrency(
       FunctionType *fnType, Type baseType, ValueDecl *decl, DeclContext *dc,
       unsigned numApplies, bool isMainDispatchQueue,
-      ArrayRef<OpenedType> replacements, ConstraintLocatorBuilder locator,
-      PreparedOverloadBuilder *preparedOverload);
+      bool openGlobalActorType, ConstraintLocatorBuilder locator);
 
   /// Retrieve the type of a reference to the given value declaration.
   ///
   /// For references to polymorphic function types, this routine "opens up"
   /// the type by replacing each instance of an archetype with a fresh type
   /// variable.
   ///
-  /// \param decl The declarations whose type is being computed.
-  ///
   /// \returns a description of the type of this declaration reference.
   DeclReferenceType getTypeOfReference(
-                          ValueDecl *decl,
-                          FunctionRefInfo functionRefInfo,
-                          ConstraintLocatorBuilder locator,
-                          DeclContext *useDC,
-                          PreparedOverloadBuilder *preparedOverload);
+      OverloadChoice choice, DeclContext *useDC, ConstraintLocatorBuilder locator,
+      PreparedOverloadBuilder *preparedOverload);
 
   /// Retrieve the type of a reference to the given value declaration,
   /// as a member with a base of the given type.
@@ -4463,15 +4457,10 @@ class ConstraintSystem {
   /// this routine "opens up" the type by replacing each instance of a generic
   /// parameter with a fresh type variable.
   ///
-  /// \param isDynamicLookup Indicates that this declaration was found via
-  /// dynamic lookup.
-  ///
   /// \returns a description of the type of this declaration reference.
   DeclReferenceType getTypeOfMemberReference(
-      Type baseTy, ValueDecl *decl, DeclContext *useDC, bool isDynamicLookup,
-      FunctionRefInfo functionRefInfo, ConstraintLocator *locator,
-      SmallVectorImpl<OpenedType> *replacements = nullptr,
-      PreparedOverloadBuilder *preparedOverload = nullptr);
+      OverloadChoice choice, DeclContext *useDC, ConstraintLocator *locator,
+      PreparedOverloadBuilder *preparedOverload);
 
   /// Retrieve a list of generic parameter types solver has "opened" (replaced
   /// with a type variable) at the given location.
@@ -4483,7 +4472,25 @@ class ConstraintSystem {
   }
 
 private:
-  DeclReferenceType getTypeOfMemberTypeReference(
+  /// \returns The opened type and the thrown error type.
+  std::pair<Type, Type> getTypeOfReferencePre(
+       OverloadChoice choice, DeclContext *useDC, ConstraintLocatorBuilder locator,
+       PreparedOverloadBuilder *preparedOverload);
+
+  DeclReferenceType getTypeOfReferencePost(
+       OverloadChoice choice, DeclContext *useDC, ConstraintLocatorBuilder locator,
+       Type openedType, Type thrownErrorType);
+
+  /// \returns the opened type and the thrown error type.
+  std::pair<Type, Type> getTypeOfMemberReferencePre(
+      OverloadChoice choice, DeclContext *useDC, ConstraintLocator *locator,
+      PreparedOverloadBuilder *preparedOverload);
+
+  DeclReferenceType getTypeOfMemberReferencePost(
+      OverloadChoice choice, DeclContext *useDC, ConstraintLocator *locator,
+      Type openedType, Type thrownErrorType);
+
+  Type getTypeOfMemberTypeReference(
       Type baseObjTy, TypeDecl *typeDecl, ConstraintLocator *locator,
       PreparedOverloadBuilder *preparedOverload);
 
@@ -4513,8 +4520,7 @@ class ConstraintSystem {
   /// determine the reference type of the member reference.
   Type getMemberReferenceTypeFromOpenedType(
       Type type, Type baseObjTy, ValueDecl *value,
-      ConstraintLocator *locator, bool hasAppliedSelf, bool isDynamicLookup,
-      ArrayRef<OpenedType> replacements);
+      ConstraintLocator *locator, bool hasAppliedSelf, bool isDynamicLookup);
 
   /// Add the constraints needed to bind an overload's type variable.
   void bindOverloadType(const SelectedOverload &overload, Type boundType,
@@ -4918,26 +4924,31 @@ class ConstraintSystem {
                               SelectedOverload choice);
 
   /// Build and allocate a prepared overload in the solver arena.
-  PreparedOverload *prepareOverload(ConstraintLocator *locator,
-                                    OverloadChoice choice,
-                                    DeclContext *useDC);
+  PreparedOverload *prepareOverload(OverloadChoice choice,
+                                    DeclContext *useDC,
+                                    ConstraintLocator *locator);
 
   /// Populate the prepared overload with all type variables and constraints
   /// that are to be introduced into the constraint system when this choice
   /// is taken.
-  DeclReferenceType
-  prepareOverloadImpl(ConstraintLocator *locator,
-                      OverloadChoice choice,
+  ///
+  /// Returns a pair consisting of the opened type, and the thrown error type.
+  ///
+  /// FIXME: As a transitional mechanism, if preparedOverload is nullptr, this
+  /// immediately performs all operations.
+  std::pair<Type, Type>
+  prepareOverloadImpl(OverloadChoice choice,
                       DeclContext *useDC,
+                      ConstraintLocator *locator,
                       PreparedOverloadBuilder *preparedOverload);
 
   void replayChanges(
       ConstraintLocator *locator,
       PreparedOverload *preparedOverload);
 
   /// Resolve the given overload set to the given choice.
-  void resolveOverload(ConstraintLocator *locator, Type boundType,
-                       OverloadChoice choice, DeclContext *useDC,
+  void resolveOverload(OverloadChoice choice, DeclContext *useDC,
+                       ConstraintLocator *locator, Type boundType,
                        PreparedOverload *preparedOverload);
 
   /// Simplify a type, by replacing type variables with either their

include/swift/Sema/OverloadChoice.h

@@ -126,20 +126,19 @@ class OverloadChoice {
   /// FIXME: This needs three bits. Can we pack them somewhere?
   FunctionRefInfo TheFunctionRefInfo = FunctionRefInfo::unappliedBaseName();
 
-public:
-  OverloadChoice() : BaseAndDeclKind(nullptr, 0), DeclOrKind() {}
-
   OverloadChoice(Type base, ValueDecl *value,
                  FunctionRefInfo functionRefInfo)
     : BaseAndDeclKind(base, 0),
       TheFunctionRefInfo(functionRefInfo) {
-    assert(!base || !base->hasTypeParameter());
     assert((reinterpret_cast<uintptr_t>(value) & (uintptr_t)0x03) == 0 &&
            "Badly aligned decl");
 
     DeclOrKind = value;
   }
 
+public:
+  OverloadChoice() : BaseAndDeclKind(nullptr, 0), DeclOrKind() {}
+
   OverloadChoice(Type base, OverloadChoiceKind kind)
       : BaseAndDeclKind(base, 0), DeclOrKind(uint32_t(kind)) {
     assert(base && "Must have a base type for overload choice");
@@ -162,6 +161,22 @@ class OverloadChoice {
            BaseAndDeclKind.getInt() == 0 && DeclOrKind.isNull();
   }
 
+  /// Retrieve an overload choice for a declaration that was found via
+  /// unqualified lookup.
+  static OverloadChoice getDecl(ValueDecl *value,
+                                FunctionRefInfo functionRefInfo) {
+    return OverloadChoice(Type(), value, functionRefInfo);
+  }
+
+
+  /// Retrieve an overload choice for a declaration that was found via
+  /// qualified lookup.
+  static OverloadChoice getDecl(Type base, ValueDecl *value,
+                                FunctionRefInfo functionRefInfo) {
+    ASSERT(!base->hasTypeParameter());
+    return OverloadChoice(base, value, functionRefInfo);
+  }
+
   /// Retrieve an overload choice for a declaration that was found via
   /// dynamic lookup.
   static OverloadChoice getDeclViaDynamic(Type base, ValueDecl *value,

include/swift/Sema/PreparedOverload.h

@@ -144,38 +144,29 @@ class PreparedOverload final :
   using Change = PreparedOverloadChange;
 
 private:
+  Type OpenedType;
+  Type ThrownErrorType;
   size_t Count;
-  DeclReferenceType DeclType;
 
   size_t numTrailingObjects(OverloadToken<Change>) const {
     return Count;
   }
 
 public:
-  PreparedOverload(const DeclReferenceType &declType, ArrayRef<Change> changes)
-    : Count(changes.size()), DeclType(declType) {
+  PreparedOverload(Type openedType, Type thrownErrorType,
+                   ArrayRef<Change> changes)
+    : OpenedType(openedType), ThrownErrorType(thrownErrorType),
+      Count(changes.size()) {
     std::uninitialized_copy(changes.begin(), changes.end(),
                             getTrailingObjects<Change>());
   }
 
   Type getOpenedType() const {
-    return DeclType.openedType;
+    return OpenedType;
   }
 
-  Type getAdjustedOpenedType() const {
-    return DeclType.adjustedOpenedType;
-  }
-
-  Type getReferenceType() const {
-    return DeclType.referenceType;
-  }
-
-  Type getAdjustedReferenceType() const {
-    return DeclType.adjustedReferenceType;
-  }
-
-  Type getThrownErrorTypeOnAccess() const {
-    return DeclType.thrownErrorTypeOnAccess;
+  Type getThrownErrorType() const {
+    return ThrownErrorType;
   }
 
   ArrayRef<Change> getChanges() const {

lib/Frontend/CompilerInvocation.cpp

@@ -2000,6 +2000,10 @@ static bool ParseTypeCheckerArgs(TypeCheckerOptions &Opts, ArgList &Args,
   if (Args.getLastArg(OPT_solver_disable_splitter))
     Opts.SolverDisableSplitter = true;
 
+  if (Args.hasArg(OPT_solver_enable_prepared_overloads) ||
+      Args.hasArg(OPT_solver_disable_prepared_overloads))
+    Opts.SolverEnablePreparedOverloads = Args.hasArg(OPT_solver_enable_prepared_overloads);
+
   if (FrontendOpts.RequestedAction == FrontendOptions::ActionType::Immediate)
     Opts.DeferToRuntime = true;
 

lib/Sema/CSDiagnostics.cpp

@@ -2457,9 +2457,10 @@ AssignmentFailure::resolveImmutableBase(Expr *expr) const {
       const auto &declRef = SE->getDecl();
       if (auto *subscript =
               dyn_cast_or_null<SubscriptDecl>(declRef.getDecl())) {
-        if (isImmutable(subscript))
-          return {expr, OverloadChoice(getType(SE->getBase()), subscript,
-                                       FunctionRefInfo::doubleBaseNameApply())};
+        if (isImmutable(subscript)) {
+          return {expr, OverloadChoice::getDecl(getType(SE->getBase()), subscript,
+                                                FunctionRefInfo::doubleBaseNameApply())};
+        }
       }
     }
 
@@ -2514,8 +2515,8 @@ AssignmentFailure::resolveImmutableBase(Expr *expr) const {
     // If the member isn't settable, then it is the problem: return it.
     if (auto member = dyn_cast<AbstractStorageDecl>(MRE->getMember().getDecl()))
       if (isImmutable(member))
-        return {expr, OverloadChoice(getType(MRE->getBase()), member,
-                                     FunctionRefInfo::singleBaseNameApply())};
+        return {expr, OverloadChoice::getDecl(getType(MRE->getBase()), member,
+                                              FunctionRefInfo::singleBaseNameApply())};
 
     // If we weren't able to resolve a member or if it is mutable, then the
     // problem must be with the base, recurse.
@@ -2535,8 +2536,8 @@ AssignmentFailure::resolveImmutableBase(Expr *expr) const {
   }
 
   if (auto *DRE = dyn_cast<DeclRefExpr>(expr))
-    return {expr, OverloadChoice(Type(), DRE->getDecl(),
-                                 FunctionRefInfo::unappliedBaseName())};
+    return {expr, OverloadChoice::getDecl(DRE->getDecl(),
+                                          FunctionRefInfo::unappliedBaseName())};
 
   // Look through x!
   if (auto *FVE = dyn_cast<ForceValueExpr>(expr))

lib/Sema/CSGen.cpp

@@ -1020,7 +1020,7 @@ namespace {
                   options);
       SmallVector<OverloadChoice, 4> outerChoices;
       for (auto decl : outerAlternatives) {
-        outerChoices.push_back(OverloadChoice(Type(), decl, functionRefInfo));
+        outerChoices.push_back(OverloadChoice::getDecl(decl, functionRefInfo));
       }
       CS.addValueMemberConstraint(
           baseTy, name, tv, CurDC, functionRefInfo, outerChoices,
@@ -1044,8 +1044,8 @@ namespace {
       auto tv = CS.createTypeVariable(memberLocator,
                                       TVO_CanBindToLValue | TVO_CanBindToNoEscape);
 
-      OverloadChoice choice =
-          OverloadChoice(CS.getType(base), decl, functionRefInfo);
+      auto choice =
+          OverloadChoice::getDecl(CS.getType(base), decl, functionRefInfo);
 
       auto locator = CS.getConstraintLocator(expr, ConstraintLocator::Member);
       CS.addBindOverloadConstraint(tv, choice, locator, CurDC);
@@ -1162,7 +1162,7 @@ namespace {
       // a known subscript here. This might be cleaner if we split off a new
       // UnresolvedSubscriptExpr from SubscriptExpr.
       if (auto decl = declOrNull) {
-        OverloadChoice choice = OverloadChoice(
+        auto choice = OverloadChoice::getDecl(
             baseTy, decl, FunctionRefInfo::doubleBaseNameApply());
         CS.addBindOverloadConstraint(memberTy, choice, memberLocator,
                                      CurDC);
@@ -1657,8 +1657,8 @@ namespace {
       // resolve it. This records the overload for use later.
       auto tv = CS.createTypeVariable(locator, options);
 
-      OverloadChoice choice =
-          OverloadChoice(Type(), E->getDecl(), E->getFunctionRefInfo());
+      auto choice =
+          OverloadChoice::getDecl(E->getDecl(), E->getFunctionRefInfo());
       CS.addBindOverloadConstraint(tv, choice, locator, CurDC);
       return tv;
     }
@@ -1775,8 +1775,8 @@ namespace {
         if (decls[i]->isInvalid())
           continue;
 
-        OverloadChoice choice =
-            OverloadChoice(Type(), decls[i], expr->getFunctionRefInfo());
+        auto choice =
+            OverloadChoice::getDecl(decls[i], expr->getFunctionRefInfo());
         choices.push_back(choice);
       }
 
@@ -4110,7 +4110,7 @@ namespace {
         // logic.
         if (result->isInvalid())
           continue;
-        OverloadChoice choice = OverloadChoice(Type(), result, functionRefInfo);
+        auto choice = OverloadChoice::getDecl(result, functionRefInfo);
         choices.push_back(choice);
       }