[ConstraintSystem] Revert new disjunction favoring algorithm

include/swift/Basic/LangOptions.h

@@ -906,6 +906,9 @@ namespace swift {
     /// is for testing purposes.
     std::vector<std::string> DebugForbidTypecheckPrefixes;
 
+    /// Disable the shrink phase of the expression type checker.
+    bool SolverDisableShrink = false;
+
     /// Enable experimental operator designated types feature.
     bool EnableOperatorDesignatedTypes = false;
 

include/swift/Option/FrontendOptions.td

@@ -832,6 +832,10 @@ 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_shrink :
+  Flag<["-"], "solver-disable-shrink">,
+  HelpText<"Disable the shrink phase of expression type checking">;
+
 def solver_disable_splitter : Flag<["-"], "solver-disable-splitter">,
   HelpText<"Disable the component splitter phase of expression type checking">;
 

include/swift/Sema/Constraint.h

@@ -818,6 +818,11 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     });
   }
 
+  /// Returns the number of resolved argument types for an applied disjunction
+  /// constraint. This is always zero for disjunctions that do not represent
+  /// an applied overload.
+  unsigned countResolvedArgumentTypes(ConstraintSystem &cs) const;
+
   /// Determine if this constraint represents explicit conversion,
   /// e.g. coercion constraint "as X" which forms a disjunction.
   bool isExplicitConversion() const;

include/swift/Sema/ConstraintSystem.h

@@ -488,14 +488,6 @@ class TypeVariableType::Implementation {
   /// literal (represented by `ArrayExpr` and `DictionaryExpr` in AST).
   bool isCollectionLiteralType() const;
 
-  /// Determine whether this type variable represents a literal such
-  /// as an integer value, a floating-point value with and without a sign.
-  bool isNumberLiteralType() const;
-
-  /// Determine whether this type variable represents a result type of a
-  /// function call.
-  bool isFunctionResult() const;
-
   /// Retrieve the representative of the equivalence class to which this
   /// type variable belongs.
   ///
@@ -2250,6 +2242,10 @@ class ConstraintSystem {
 
   llvm::SetVector<TypeVariableType *> TypeVariables;
 
+  /// Maps expressions to types for choosing a favored overload
+  /// type in a disjunction constraint.
+  llvm::DenseMap<Expr *, TypeBase *> FavoredTypes;
+
   /// Maps discovered closures to their types inferred
   /// from declared parameters/result and body.
   ///
@@ -2462,6 +2458,74 @@ class ConstraintSystem {
       SynthesizedConformances;
 
 private:
+  /// Describe the candidate expression for partial solving.
+  /// This class used by shrink & solve methods which apply
+  /// variation of directional path consistency algorithm in attempt
+  /// to reduce scopes of the overload sets (disjunctions) in the system.
+  class Candidate {
+    Expr *E;
+    DeclContext *DC;
+    llvm::BumpPtrAllocator &Allocator;
+
+    // Contextual Information.
+    Type CT;
+    ContextualTypePurpose CTP;
+
+  public:
+    Candidate(ConstraintSystem &cs, Expr *expr, Type ct = Type(),
+              ContextualTypePurpose ctp = ContextualTypePurpose::CTP_Unused)
+        : E(expr), DC(cs.DC), Allocator(cs.Allocator), CT(ct), CTP(ctp) {}
+
+    /// Return underlying expression.
+    Expr *getExpr() const { return E; }
+
+    /// Try to solve this candidate sub-expression
+    /// and re-write it's OSR domains afterwards.
+    ///
+    /// \param shrunkExprs The set of expressions which
+    /// domains have been successfully shrunk so far.
+    ///
+    /// \returns true on solver failure, false otherwise.
+    bool solve(llvm::SmallSetVector<OverloadSetRefExpr *, 4> &shrunkExprs);
+
+    /// Apply solutions found by solver as reduced OSR sets for
+    /// for current and all of it's sub-expressions.
+    ///
+    /// \param solutions The solutions found by running solver on the
+    /// this candidate expression.
+    ///
+    /// \param shrunkExprs The set of expressions which
+    /// domains have been successfully shrunk so far.
+    void applySolutions(
+        llvm::SmallVectorImpl<Solution> &solutions,
+        llvm::SmallSetVector<OverloadSetRefExpr *, 4> &shrunkExprs) const;
+
+    /// Check if attempt at solving of the candidate makes sense given
+    /// the current conditions - number of shrunk domains which is related
+    /// to the given candidate over the total number of disjunctions present.
+    static bool
+    isTooComplexGiven(ConstraintSystem *const cs,
+                      llvm::SmallSetVector<OverloadSetRefExpr *, 4> &shrunkExprs) {
+      SmallVector<Constraint *, 8> disjunctions;
+      cs->collectDisjunctions(disjunctions);
+
+      unsigned unsolvedDisjunctions = disjunctions.size();
+      for (auto *disjunction : disjunctions) {
+        auto *locator = disjunction->getLocator();
+        if (!locator)
+          continue;
+
+        if (auto *OSR = getAsExpr<OverloadSetRefExpr>(locator->getAnchor())) {
+          if (shrunkExprs.count(OSR) > 0)
+            --unsolvedDisjunctions;
+        }
+      }
+
+      // The threshold used to be `TypeCheckerOpts.SolverShrinkUnsolvedThreshold`
+      return unsolvedDisjunctions >= 10;
+    }
+  };
+
   /// Describes the current solver state.
   struct SolverState {
     SolverState(ConstraintSystem &cs,
@@ -2985,6 +3049,15 @@ class ConstraintSystem {
     return nullptr;
   }
 
+  TypeBase* getFavoredType(Expr *E) {
+    assert(E != nullptr);
+    return this->FavoredTypes[E];
+  }
+  void setFavoredType(Expr *E, TypeBase *T) {
+    assert(E != nullptr);
+    this->FavoredTypes[E] = T;
+  }
+
   /// Set the type in our type map for the given node, and record the change
   /// in the trail.
   ///
@@ -5239,11 +5312,19 @@ class ConstraintSystem {
   /// \returns true if an error occurred, false otherwise.
   bool solveSimplified(SmallVectorImpl<Solution> &solutions);
 
+  /// Find reduced domains of disjunction constraints for given
+  /// expression, this is achieved to solving individual sub-expressions
+  /// and combining resolving types. Such algorithm is called directional
+  /// path consistency because it goes from children to parents for all
+  /// related sub-expressions taking union of their domains.
+  ///
+  /// \param expr The expression to find reductions for.
+  void shrink(Expr *expr);
+
   /// Pick a disjunction from the InactiveConstraints list.
   ///
-  /// \returns The selected disjunction and a set of it's favored choices.
-  std::optional<std::pair<Constraint *, llvm::TinyPtrVector<Constraint *>>>
-  selectDisjunction();
+  /// \returns The selected disjunction.
+  Constraint *selectDisjunction();
 
   /// Pick a conjunction from the InactiveConstraints list.
   ///
@@ -5432,6 +5513,11 @@ class ConstraintSystem {
   bool applySolutionToBody(TapExpr *tapExpr,
                            SyntacticElementTargetRewriter &rewriter);
 
+  /// Reorder the disjunctive clauses for a given expression to
+  /// increase the likelihood that a favored constraint will be successfully
+  /// resolved before any others.
+  void optimizeConstraints(Expr *e);
+
   void startExpressionTimer(ExpressionTimer::AnchorType anchor);
 
   /// Determine if we've already explored too many paths in an
@@ -6172,8 +6258,7 @@ class DisjunctionChoiceProducer : public BindingProducer<DisjunctionChoice> {
 public:
   using Element = DisjunctionChoice;
 
-  DisjunctionChoiceProducer(ConstraintSystem &cs, Constraint *disjunction,
-                            llvm::TinyPtrVector<Constraint *> &favorites)
+  DisjunctionChoiceProducer(ConstraintSystem &cs, Constraint *disjunction)
       : BindingProducer(cs, disjunction->shouldRememberChoice()
                                 ? disjunction->getLocator()
                                 : nullptr),
@@ -6183,11 +6268,6 @@ class DisjunctionChoiceProducer : public BindingProducer<DisjunctionChoice> {
     assert(disjunction->getKind() == ConstraintKind::Disjunction);
     assert(!disjunction->shouldRememberChoice() || disjunction->getLocator());
 
-    // Mark constraints as favored. This information
-    // is going to be used by partitioner.
-    for (auto *choice : favorites)
-      cs.favorConstraint(choice);
-
     // Order and partition the disjunction choices.
     partitionDisjunction(Ordering, PartitionBeginning);
   }
@@ -6232,9 +6312,8 @@ class DisjunctionChoiceProducer : public BindingProducer<DisjunctionChoice> {
   // Partition the choices in the disjunction into groups that we will
   // iterate over in an order appropriate to attempt to stop before we
   // have to visit all of the options.
-  void
-  partitionDisjunction(SmallVectorImpl<unsigned> &Ordering,
-                       SmallVectorImpl<unsigned> &PartitionBeginning);
+  void partitionDisjunction(SmallVectorImpl<unsigned> &Ordering,
+                            SmallVectorImpl<unsigned> &PartitionBeginning);
 
   /// Partition the choices in the range \c first to \c last into groups and
   /// order the groups in the best order to attempt based on the argument

lib/Frontend/CompilerInvocation.cpp

@@ -1859,6 +1859,9 @@ static bool ParseTypeCheckerArgs(TypeCheckerOptions &Opts, ArgList &Args,
     Opts.DebugForbidTypecheckPrefixes.push_back(A);
   }
 
+  if (Args.getLastArg(OPT_solver_disable_shrink))
+    Opts.SolverDisableShrink = true;
+
   if (Args.getLastArg(OPT_solver_disable_splitter))
     Opts.SolverDisableSplitter = true;
 

lib/Sema/CMakeLists.txt

@@ -13,7 +13,6 @@ add_swift_host_library(swiftSema STATIC
   CSStep.cpp
   CSTrail.cpp
   CSFix.cpp
-  CSOptimizer.cpp
   CSDiagnostics.cpp
   CodeSynthesis.cpp
   CodeSynthesisDistributedActor.cpp

lib/Sema/CSBindings.cpp

@@ -31,19 +31,14 @@ using namespace swift;
 using namespace constraints;
 using namespace inference;
 
+
 void ConstraintGraphNode::initBindingSet() {
   ASSERT(!hasBindingSet());
   ASSERT(forRepresentativeVar());
 
   Set.emplace(CG.getConstraintSystem(), TypeVar, Potential);
 }
 
-/// Check whether there exists a type that could be implicitly converted
-/// to a given type i.e. is the given type is Double or Optional<..> this
-/// function is going to return true because CGFloat could be converted
-/// to a Double and non-optional value could be injected into an optional.
-static bool hasConversions(Type);
-
 static std::optional<Type> checkTypeOfBinding(TypeVariableType *typeVar,
                                               Type type);
 
@@ -1310,31 +1305,7 @@ bool BindingSet::isViable(PotentialBinding &binding, bool isTransitive) {
     if (!existingNTD || NTD != existingNTD)
       continue;
 
-    // What is going on in this method needs to be thoroughly re-evaluated!
-    //
-    // This logic aims to skip dropping bindings if
-    // collection type has conversions i.e. in situations like:
-    //
-    // [$T1] conv $T2
-    // $T2 conv [(Int, String)]
-    // $T2.Element equal $T5.Element
-    //
-    // `$T1` could be bound to `(i: Int, v: String)` after
-    // `$T2` is bound to `[(Int, String)]` which is is a problem
-    // because it means that `$T2` was attempted to early
-    // before the solver had a chance to discover all viable
-    // bindings.
-    //
-    // Let's say existing binding is `[(Int, String)]` and
-    // relation is "exact", in this case there is no point
-    // tracking `[$T1]` because upcasts are only allowed for
-    // subtype and other conversions.
-    if (existing->Kind != AllowedBindingKind::Exact) {
-      if (existingType->isKnownStdlibCollectionType() &&
-          hasConversions(existingType)) {
-        continue;
-      }
-    }
+    // FIXME: What is going on here needs to be thoroughly re-evaluated.
 
     // If new type has a type variable it shouldn't
     // be considered  viable.