[TypeChecker] Rework type-checking of for-in statements

Change the way how `for-in` statements are type-checked, where a lot of
information has to be recorded in a statement in order for SILGen to generate
appropriate calls to `makeIterator` and `next` witnesses.

Instead of just finding a witness, solver would now:

- Synthesize:
  - Iterator variable with its initializer - `$generator = <sequence>.makeIterator()`;
  - Call to `$generator.next()` which is called by each loop iteration;
- Verify that type of pattern is convertible to type of `next()`

Doing so significantly simplifies SILGen, removes the need to carry type information
in `ForEachStmt` and enables iterating over existential types.

Resolves: rdar://92177656

Author: xedin

include/swift/AST/Stmt.h

@@ -743,8 +743,8 @@ class ForEachStmt : public LabeledStmt {
 
   // Set by Sema:
   ProtocolConformanceRef sequenceConformance = ProtocolConformanceRef();
-  VarDecl *iteratorVar = nullptr;
-  Expr *iteratorVarRef = nullptr;
+  PatternBindingDecl *iteratorVar = nullptr;
+  Expr *nextCall = nullptr;
   OpaqueValueExpr *elementExpr = nullptr;
   Expr *convertElementExpr = nullptr;
 
@@ -759,11 +759,11 @@ class ForEachStmt : public LabeledStmt {
     setPattern(Pat);
   }
 
-  void setIteratorVar(VarDecl *var) { iteratorVar = var; }
-  VarDecl *getIteratorVar() const { return iteratorVar; }
+  void setIteratorVar(PatternBindingDecl *var) { iteratorVar = var; }
+  PatternBindingDecl *getIteratorVar() const { return iteratorVar; }
 
-  void setIteratorVarRef(Expr *var) { iteratorVarRef = var; }
-  Expr *getIteratorVarRef() const { return iteratorVarRef; }
+  void setNextCall(Expr *next) { nextCall = next; }
+  Expr *getNextCall() const { return nextCall; }
 
   void setElementExpr(OpaqueValueExpr *expr) { elementExpr = expr; }
   OpaqueValueExpr *getElementExpr() const { return elementExpr; }
@@ -802,8 +802,12 @@ class ForEachStmt : public LabeledStmt {
   /// by this foreach loop, as it was written in the source code and
   /// subsequently type-checked. To determine the semantic behavior of this
   /// expression to extract a range, use \c getRangeInit().
-  Expr *getSequence() const { return Sequence; }
-  void setSequence(Expr *S) { Sequence = S; }
+  Expr *getParsedSequence() const { return Sequence; }
+  void setParsedSequence(Expr *S) { Sequence = S; }
+
+  /// Type-checked version of the sequence or nullptr if this statement
+  /// yet to be type-checked.
+  Expr *getTypeCheckedSequence() const;
 
   /// getBody - Retrieve the body of the loop.
   BraceStmt *getBody() const { return Body; }

include/swift/Sema/Constraint.h

@@ -137,11 +137,6 @@ enum class ConstraintKind : char {
   /// name, and the type of that member, when referenced as a value, is the
   /// second type.
   UnresolvedValueMember,
-  /// The first type conforms to the protocol in which the member requirement
-  /// resides. Once the conformance is resolved, the value witness will be
-  /// determined, and the type of that witness, when referenced as a value,
-  /// will be bound to the second type.
-  ValueWitness,
   /// The first type can be defaulted to the second (which currently
   /// cannot be dependent).  This is more like a type property than a
   /// relational constraint.
@@ -411,18 +406,11 @@ class Constraint final : public llvm::ilist_node<Constraint>,
       /// The type of the member.
       Type Second;
 
-      union {
-        /// If non-null, the name of a member of the first type is that
-        /// being related to the second type.
-        ///
-        /// Used for ValueMember an UnresolvedValueMember constraints.
-        DeclNameRef Name;
-
-        /// If non-null, the member being referenced.
-        ///
-        /// Used for ValueWitness constraints.
-        ValueDecl *Ref;
-      } Member;
+      /// If non-null, the name of a member of the first type is that
+      /// being related to the second type.
+      ///
+      /// Used for ValueMember an UnresolvedValueMember constraints.
+      DeclNameRef Name;
 
       /// The DC in which the use appears.
       DeclContext *UseDC;
@@ -537,12 +525,6 @@ class Constraint final : public llvm::ilist_node<Constraint>,
                                   FunctionRefKind functionRefKind,
                                   ConstraintLocator *locator);
 
-  /// Create a new value witness constraint.
-  static Constraint *createValueWitness(
-      ConstraintSystem &cs, ConstraintKind kind, Type first, Type second,
-      ValueDecl *requirement, DeclContext *useDC,
-      FunctionRefKind functionRefKind, ConstraintLocator *locator);
-
   /// Create an overload-binding constraint.
   static Constraint *createBindOverload(ConstraintSystem &cs, Type type, 
                                         OverloadChoice choice, 
@@ -690,7 +672,6 @@ class Constraint final : public llvm::ilist_node<Constraint>,
 
     case ConstraintKind::ValueMember:
     case ConstraintKind::UnresolvedValueMember:
-    case ConstraintKind::ValueWitness:
     case ConstraintKind::PropertyWrapper:
       return ConstraintClassification::Member;
 
@@ -730,7 +711,6 @@ class Constraint final : public llvm::ilist_node<Constraint>,
 
     case ConstraintKind::ValueMember:
     case ConstraintKind::UnresolvedValueMember:
-    case ConstraintKind::ValueWitness:
       return Member.First;
 
     case ConstraintKind::SyntacticElement:
@@ -752,7 +732,6 @@ class Constraint final : public llvm::ilist_node<Constraint>,
 
     case ConstraintKind::ValueMember:
     case ConstraintKind::UnresolvedValueMember:
-    case ConstraintKind::ValueWitness:
       return Member.Second;
 
     default:
@@ -778,20 +757,13 @@ class Constraint final : public llvm::ilist_node<Constraint>,
   DeclNameRef getMember() const {
     assert(Kind == ConstraintKind::ValueMember ||
            Kind == ConstraintKind::UnresolvedValueMember);
-    return Member.Member.Name;
-  }
-
-  /// Retrieve the requirement being referenced by a value witness constraint.
-  ValueDecl *getRequirement() const {
-    assert(Kind == ConstraintKind::ValueWitness);
-    return Member.Member.Ref;
+    return Member.Name;
   }
 
   /// Determine the kind of function reference we have for a member reference.
   FunctionRefKind getFunctionRefKind() const {
     if (Kind == ConstraintKind::ValueMember ||
-        Kind == ConstraintKind::UnresolvedValueMember ||
-        Kind == ConstraintKind::ValueWitness)
+        Kind == ConstraintKind::UnresolvedValueMember)
       return static_cast<FunctionRefKind>(TheFunctionRefKind);
 
     // Conservative answer: drop all of the labels.
@@ -851,8 +823,7 @@ class Constraint final : public llvm::ilist_node<Constraint>,
   /// Retrieve the DC in which the member was used.
   DeclContext *getMemberUseDC() const {
     assert(Kind == ConstraintKind::ValueMember ||
-           Kind == ConstraintKind::UnresolvedValueMember ||
-           Kind == ConstraintKind::ValueWitness);
+           Kind == ConstraintKind::UnresolvedValueMember);
     return Member.UseDC;
   }