Sema: Remove ConstraintKind::OneWayBindParam and ConstraintKind::OneWayEqual

include/swift/AST/Expr.h

@@ -6413,33 +6413,6 @@ class SingleValueStmtExpr : public Expr {
   }
 };
 
-/// Expression node that effects a "one-way" constraint in
-/// the constraint system, allowing type information to flow from the
-/// subexpression outward but not the other way.
-///
-/// One-way expressions are generally implicit and synthetic, introduced by
-/// the type checker. However, there is a built-in expression of the
-/// form \c Builtin.one_way(x) that forms a one-way constraint coming out
-/// of expression `x` that can be used for testing purposes.
-class OneWayExpr : public Expr {
-  Expr *SubExpr;
-
-public:
-  /// Construct an implicit one-way expression from the given subexpression.
-  OneWayExpr(Expr *subExpr)
-     : Expr(ExprKind::OneWay, /*isImplicit=*/true), SubExpr(subExpr) { }
-
-  SourceLoc getLoc() const { return SubExpr->getLoc(); }
-  SourceRange getSourceRange() const { return SubExpr->getSourceRange(); }
-
-  Expr *getSubExpr() const { return SubExpr; }
-  void setSubExpr(Expr *subExpr) { SubExpr = subExpr; }
-
-  static bool classof(const Expr *E) {
-    return E->getKind() == ExprKind::OneWay;
-  }
-};
-
 class TypeJoinExpr final : public Expr,
                            private llvm::TrailingObjects<TypeJoinExpr, Expr *> {
   friend TrailingObjects;

include/swift/AST/ExprNodes.def

@@ -214,7 +214,6 @@ EXPR(KeyPath, Expr)
 EXPR(CurrentContextIsolation, Expr)
 EXPR(SingleValueStmt, Expr)
 UNCHECKED_EXPR(KeyPathDot, Expr)
-UNCHECKED_EXPR(OneWay, Expr)
 EXPR(Tap, Expr)
 UNCHECKED_EXPR(TypeJoin, Expr)
 EXPR(MacroExpansion, Expr)

include/swift/Sema/Constraint.h

@@ -150,11 +150,6 @@ enum class ConstraintKind : char {
   /// The key path type is chosen based on the selection of overloads for the
   /// member references along the path.
   KeyPath,
-  /// The first type will be equal to the second type, but only when the
-  /// second type has been fully determined (and mapped down to a concrete
-  /// type). At that point, this constraint will be treated like an `Equal`
-  /// constraint.
-  OneWayEqual,
   /// If there is no contextual info e.g. `_ = { 42 }` default first type
   /// to a second type. This is effectively a `Defaultable` constraint
   /// which one significant difference:
@@ -680,7 +675,6 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     case ConstraintKind::DynamicCallableApplicableFunction:
     case ConstraintKind::BindOverload:
     case ConstraintKind::OptionalObject:
-    case ConstraintKind::OneWayEqual:
     case ConstraintKind::FallbackType:
     case ConstraintKind::UnresolvedMemberChainBase:
     case ConstraintKind::PackElementOf:
@@ -826,11 +820,6 @@ class Constraint final : public llvm::ilist_node<Constraint>,
   /// from the rest of the constraint system.
   bool isIsolated() const { return IsIsolated; }
 
-  /// Whether this is a one-way constraint.
-  bool isOneWayConstraint() const {
-    return Kind == ConstraintKind::OneWayEqual;
-  }
-
   /// Retrieve the overload choice for an overload-binding constraint.
   OverloadChoice getOverloadChoice() const {
     assert(Kind == ConstraintKind::BindOverload);

include/swift/Sema/ConstraintGraph.h

@@ -332,12 +332,6 @@ class ConstraintGraph {
     /// The constraints in this component.
     TinyPtrVector<Constraint *> constraints;
 
-    /// The set of components that this component depends on, such that
-    /// the partial solutions of the those components need to be available
-    /// before this component can be solved.
-    ///
-    SmallVector<unsigned, 2> dependencies;
-
   public:
     Component(unsigned solutionIndex) : solutionIndex(solutionIndex) { }
 
@@ -353,11 +347,6 @@ class ConstraintGraph {
       return constraints;
     }
 
-    /// Records a component which this component depends on.
-    void recordDependency(const Component &component);
-
-    ArrayRef<unsigned> getDependencies() const { return dependencies; }
-
     unsigned getNumDisjunctions() const { return numDisjunctions; }
   };
 

include/swift/Sema/ConstraintSystem.h

@@ -4504,7 +4504,6 @@ class ConstraintSystem {
   /// \returns a possibly-sanitized initializer, or null if an error occurred.
   [[nodiscard]]
   Type generateConstraints(Pattern *P, ConstraintLocatorBuilder locator,
-                           bool bindPatternVarsOneWay,
                            PatternBindingDecl *patternBinding,
                            unsigned patternIndex);
 
@@ -5012,12 +5011,6 @@ class ConstraintSystem {
                                                  TypeMatchOptions flags,
                                                  ConstraintLocatorBuilder locator);
 
-  /// Attempt to simplify a one-way constraint.
-  SolutionKind simplifyOneWayConstraint(ConstraintKind kind,
-                                        Type first, Type second,
-                                        TypeMatchOptions flags,
-                                        ConstraintLocatorBuilder locator);
-
   /// Simplify an equality constraint between result and base types of
   /// an unresolved member chain.
   SolutionKind simplifyUnresolvedMemberChainBaseConstraint(

include/swift/Sema/SyntacticElementTarget.h

@@ -114,10 +114,6 @@ class SyntacticElementTarget {
       /// Whether the expression result will be discarded at the end.
       bool isDiscarded;
 
-      /// Whether to bind the variables encountered within the pattern to
-      /// fresh type variables via one-way constraints.
-      bool bindPatternVarsOneWay;
-
       union {
         struct {
           /// The pattern binding declaration for an initialization, if any.
@@ -165,10 +161,9 @@ class SyntacticElementTarget {
       ForEachStmt *stmt;
       DeclContext *dc;
       Pattern *pattern;
-      bool ignoreWhereClause;
       GenericEnvironment *packElementEnv;
       ForEachStmtInfo info;
-    } forEachStmt;
+    } forEachPreamble;
 
     PatternBindingDecl *patternBinding;
   };
@@ -246,35 +241,33 @@ class SyntacticElementTarget {
   }
 
   SyntacticElementTarget(ForEachStmt *stmt, DeclContext *dc,
-                         bool ignoreWhereClause,
                          GenericEnvironment *packElementEnv)
       : kind(Kind::forEachPreamble) {
-    forEachStmt.stmt = stmt;
-    forEachStmt.dc = dc;
-    forEachStmt.ignoreWhereClause = ignoreWhereClause;
-    forEachStmt.packElementEnv = packElementEnv;
+    forEachPreamble.stmt = stmt;
+    forEachPreamble.dc = dc;
+    forEachPreamble.packElementEnv = packElementEnv;
   }
 
   /// Form a target for the initialization of a pattern from an expression.
   static SyntacticElementTarget
   forInitialization(Expr *initializer, DeclContext *dc, Type patternType,
-                    Pattern *pattern, bool bindPatternVarsOneWay);
+                    Pattern *pattern);
 
   /// Form a target for the initialization of a pattern binding entry from
   /// an expression.
   static SyntacticElementTarget
   forInitialization(Expr *initializer, Type patternType,
                     PatternBindingDecl *patternBinding,
-                    unsigned patternBindingIndex, bool bindPatternVarsOneWay);
+                    unsigned patternBindingIndex);
 
   /// Form an expression target for a ReturnStmt.
   static SyntacticElementTarget
   forReturn(ReturnStmt *returnStmt, Type contextTy, DeclContext *dc);
 
-  /// Form a target for the preamble of a for-in loop, excluding its body.
+  /// Form a target for the preamble of a for-in loop, excluding its where
+  /// clause and body.
   static SyntacticElementTarget
   forForEachPreamble(ForEachStmt *stmt, DeclContext *dc,
-                     bool ignoreWhereClause = false,
                      GenericEnvironment *packElementEnv = nullptr);
 
   /// Form a target for a property with an attached property wrapper that is
@@ -376,7 +369,7 @@ class SyntacticElementTarget {
     }
 
     case Kind::forEachPreamble:
-      return forEachStmt.dc;
+      return forEachPreamble.dc;
     }
     llvm_unreachable("invalid decl context type");
   }
@@ -500,16 +493,6 @@ class SyntacticElementTarget {
     return false;
   }
 
-  /// Whether to bind the types of any variables within the pattern via
-  /// one-way constraints.
-  bool shouldBindPatternVarsOneWay() const {
-    if (kind == Kind::expression)
-      return expression.bindPatternVarsOneWay;
-    if (kind == Kind::forEachPreamble)
-      return !ignoreForEachWhereClause() && forEachStmt.stmt->getWhere();
-    return false;
-  }
-
   /// Whether or not an opaque value placeholder should be injected into the
   /// first \c wrappedValue argument of an apply expression so the initializer
   /// expression can be turned into a property wrapper generator function.
@@ -555,24 +538,19 @@ class SyntacticElementTarget {
     return expression.initialization.patternBindingIndex;
   }
 
-  bool ignoreForEachWhereClause() const {
-    assert(isForEachPreamble());
-    return forEachStmt.ignoreWhereClause;
-  }
-
   GenericEnvironment *getPackElementEnv() const {
     assert(isForEachPreamble());
-    return forEachStmt.packElementEnv;
+    return forEachPreamble.packElementEnv;
   }
 
   const ForEachStmtInfo &getForEachStmtInfo() const {
     assert(isForEachPreamble());
-    return forEachStmt.info;
+    return forEachPreamble.info;
   }
 
   ForEachStmtInfo &getForEachStmtInfo() {
     assert(isForEachPreamble());
-    return forEachStmt.info;
+    return forEachPreamble.info;
   }
 
   /// Whether this context infers an opaque return type.
@@ -599,7 +577,7 @@ class SyntacticElementTarget {
       return getInitializationPattern();
 
     if (kind == Kind::forEachPreamble)
-      return forEachStmt.pattern;
+      return forEachPreamble.pattern;
 
     return nullptr;
   }
@@ -612,7 +590,7 @@ class SyntacticElementTarget {
     }
 
     if (kind == Kind::forEachPreamble) {
-      forEachStmt.pattern = pattern;
+      forEachPreamble.pattern = pattern;
       return;
     }
 
@@ -743,7 +721,7 @@ class SyntacticElementTarget {
       return nullptr;
 
     case Kind::forEachPreamble:
-      return forEachStmt.stmt;
+      return forEachPreamble.stmt;
     }
     llvm_unreachable("invalid case label type");
   }
@@ -855,7 +833,7 @@ class SyntacticElementTarget {
 
     // For-in preamble target doesn't cover the body.
     case Kind::forEachPreamble:
-      auto *stmt = forEachStmt.stmt;
+      auto *stmt = forEachPreamble.stmt;
       SourceLoc startLoc = stmt->getForLoc();
       SourceLoc endLoc = stmt->getParsedSequence()->getEndLoc();
 
@@ -898,7 +876,7 @@ class SyntacticElementTarget {
     }
 
     case Kind::forEachPreamble:
-      return forEachStmt.stmt->getStartLoc();
+      return forEachPreamble.stmt->getStartLoc();
     }
     llvm_unreachable("invalid target type");
   }

lib/AST/ASTDumper.cpp

@@ -3339,12 +3339,6 @@ class PrintExpr : public ExprVisitor<PrintExpr, void, StringRef>,
     printFoot();
   }
 
-  void visitOneWayExpr(OneWayExpr *E, StringRef label) {
-    printCommon(E, "one_way_expr", label);
-    printRec(E->getSubExpr());
-    printFoot();
-  }
-
   void visitTapExpr(TapExpr *E, StringRef label) {
     printCommon(E, "tap_expr", label);
     printDeclRefField(E->getVar(), "var");

lib/AST/ASTPrinter.cpp

@@ -4884,10 +4884,6 @@ void PrintAST::visitCoerceExpr(CoerceExpr *expr) {
   printType(expr->getCastType());
 }
 
-void PrintAST::visitOneWayExpr(OneWayExpr *expr) {
-  llvm_unreachable("Not representable in source code");
-}
-
 void PrintAST::printClosure(AbstractClosureExpr *closure, CaptureListExpr *captureList) {
 
 }

lib/AST/ASTWalker.cpp

@@ -1332,18 +1332,6 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
     return E;
   }
 
-  Expr *visitOneWayExpr(OneWayExpr *E) {
-    if (auto oldSubExpr = E->getSubExpr()) {
-      if (auto subExpr = doIt(oldSubExpr)) {
-        E->setSubExpr(subExpr);
-      } else {
-        return nullptr;
-      }
-    }
-
-    return E;
-  }
-
   Expr *visitTapExpr(TapExpr *E) {
     if (auto oldSubExpr = E->getSubExpr()) {
       if (auto subExpr = doIt(oldSubExpr)) {

lib/AST/Expr.cpp

@@ -461,7 +461,6 @@ ConcreteDeclRef Expr::getReferencedDecl(bool stopAtParenExpr) const {
   NO_REFERENCE(KeyPath);
   NO_REFERENCE(KeyPathDot);
   PASS_THROUGH_REFERENCE(CurrentContextIsolation, getActor);
-  PASS_THROUGH_REFERENCE(OneWay, getSubExpr);
   NO_REFERENCE(Tap);
   NO_REFERENCE(TypeJoin);
   SIMPLE_REFERENCE(MacroExpansion, getMacroRef);
@@ -662,7 +661,6 @@ bool Expr::canAppendPostfixExpression(bool appendingPostfixOperator) const {
   case ExprKind::Error:
   case ExprKind::CodeCompletion:
   case ExprKind::LazyInitializer:
-  case ExprKind::OneWay:
     return false;
 
   case ExprKind::NilLiteral:
@@ -1037,7 +1035,6 @@ bool Expr::isValidParentOfTypeExpr(Expr *typeExpr) const {
   case ExprKind::ObjCSelector:
   case ExprKind::KeyPath:
   case ExprKind::KeyPathDot:
-  case ExprKind::OneWay:
   case ExprKind::Tap:
   case ExprKind::SingleValueStmt:
   case ExprKind::TypeJoin: