[CSClosure] (Mostly NFC) Renames and introduction of AnyFunctionRef

Cherry-pick of #58423

The changes rename `ClosureBodyElement` to `SyntacticElement` to indicate that
contained element could come from not just closure but a function body as well.

Both constraint generator and solution application walkers have been renamed as well,
and switched to use `AnyFunctionRef` instead of `ClosureExpr`.

Author: xedin

include/swift/Sema/Constraint.h

@@ -209,10 +209,9 @@ enum class ConstraintKind : char {
   /// inferred from a conversion, so the check is more relax comparing to
   /// `ConformsTo`.
   TransitivelyConformsTo,
-  /// Represents an AST node contained in a body of a closure. It has only
-  /// one type - type variable representing type of a node, other side is
-  /// the AST node to infer the type for.
-  ClosureBodyElement,
+  /// Represents an AST node contained in a body of a function/closure.
+  /// It only has an AST node to generate constraints and infer the type for.
+  SyntacticElement,
   /// Do not add new uses of this, it only exists to retain compatibility for
   /// rdar://85263844.
   ///
@@ -240,8 +239,8 @@ enum class ConstraintClassification : char {
   /// A conjunction constraint.
   Conjunction,
 
-  /// An element of a closure body.
-  ClosureElement,
+  /// An element of a closure/function body.
+  SyntacticElement,
 };
 
 /// Specifies a restriction on the kind of conversion that should be
@@ -450,7 +449,7 @@ class Constraint final : public llvm::ilist_node<Constraint>,
       ContextualTypeInfo Context;
       /// Identifies whether result of this node is unused.
       bool IsDiscarded;
-    } ClosureElement;
+    } SyntacticElement;
   };
 
   /// The locator that describes where in the expression this
@@ -591,12 +590,12 @@ class Constraint final : public llvm::ilist_node<Constraint>,
       Optional<TrailingClosureMatching> trailingClosureMatching,
       ConstraintLocator *locator);
 
-  static Constraint *createClosureBodyElement(ConstraintSystem &cs,
+  static Constraint *createSyntacticElement(ConstraintSystem &cs,
                                               ASTNode node,
                                               ConstraintLocator *locator,
                                               bool isDiscarded = false);
 
-  static Constraint *createClosureBodyElement(ConstraintSystem &cs,
+  static Constraint *createSyntacticElement(ConstraintSystem &cs,
                                               ASTNode node,
                                               ContextualTypeInfo context,
                                               ConstraintLocator *locator,
@@ -710,8 +709,8 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     case ConstraintKind::Conjunction:
       return ConstraintClassification::Conjunction;
 
-    case ConstraintKind::ClosureBodyElement:
-      return ConstraintClassification::ClosureElement;
+    case ConstraintKind::SyntacticElement:
+      return ConstraintClassification::SyntacticElement;
     }
 
     llvm_unreachable("Unhandled ConstraintKind in switch.");
@@ -734,7 +733,7 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     case ConstraintKind::ValueWitness:
       return Member.First;
 
-    case ConstraintKind::ClosureBodyElement:
+    case ConstraintKind::SyntacticElement:
       llvm_unreachable("closure body element constraint has no type operands");
 
     default:
@@ -748,7 +747,7 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     case ConstraintKind::Disjunction:
     case ConstraintKind::Conjunction:
     case ConstraintKind::BindOverload:
-    case ConstraintKind::ClosureBodyElement:
+    case ConstraintKind::SyntacticElement:
       llvm_unreachable("constraint has no second type");
 
     case ConstraintKind::ValueMember:
@@ -857,19 +856,19 @@ class Constraint final : public llvm::ilist_node<Constraint>,
     return Member.UseDC;
   }
 
-  ASTNode getClosureElement() const {
-    assert(Kind == ConstraintKind::ClosureBodyElement);
-    return ClosureElement.Element;
+  ASTNode getSyntacticElement() const {
+    assert(Kind == ConstraintKind::SyntacticElement);
+    return SyntacticElement.Element;
   }
 
   ContextualTypeInfo getElementContext() const {
-    assert(Kind == ConstraintKind::ClosureBodyElement);
-    return ClosureElement.Context;
+    assert(Kind == ConstraintKind::SyntacticElement);
+    return SyntacticElement.Context;
   }
 
   bool isDiscardedElement() const {
-    assert(Kind == ConstraintKind::ClosureBodyElement);
-    return ClosureElement.IsDiscarded;
+    assert(Kind == ConstraintKind::SyntacticElement);
+    return SyntacticElement.IsDiscarded;
   }
 
   /// For an applicable function constraint, retrieve the trailing closure

include/swift/Sema/ConstraintLocator.h

@@ -1012,11 +1012,11 @@ class LocatorPathElt::ConstructorMemberType final
   }
 };
 
-class LocatorPathElt::ClosureBodyElement final
+class LocatorPathElt::SyntacticElement final
     : public StoredPointerElement<void> {
 public:
-  ClosureBodyElement(ASTNode element)
-      : StoredPointerElement(PathElementKind::ClosureBodyElement,
+  SyntacticElement(ASTNode element)
+      : StoredPointerElement(PathElementKind::SyntacticElement,
                              element.getOpaqueValue()) {
     assert(element);
   }
@@ -1054,7 +1054,7 @@ class LocatorPathElt::ClosureBodyElement final
   }
 
   static bool classof(const LocatorPathElt *elt) {
-    return elt->getKind() == PathElementKind::ClosureBodyElement;
+    return elt->getKind() == PathElementKind::SyntacticElement;
   }
 };
 

include/swift/Sema/ConstraintLocatorPathElts.def

@@ -229,8 +229,9 @@ CUSTOM_LOCATOR_PATH_ELT(ImplicitConversion)
 /// An implicit call to a 'dynamicMember' subscript for a dynamic member lookup.
 SIMPLE_LOCATOR_PATH_ELT(ImplicitDynamicMemberSubscript)
 
-/// The element of the closure body e.g. statement, declaration, or expression.
-CUSTOM_LOCATOR_PATH_ELT(ClosureBodyElement)
+/// The element of the closure/function body e.g. statement, pattern,
+/// declaration, or expression.
+CUSTOM_LOCATOR_PATH_ELT(SyntacticElement)
 
 /// The element of the pattern binding declaration.
 CUSTOM_LOCATOR_PATH_ELT(PatternBindingElement)

include/swift/Sema/ConstraintSystem.h

@@ -5084,9 +5084,9 @@ class ConstraintSystem {
                  TypeMatchOptions flags,
                  ConstraintLocatorBuilder locator);
 
-  /// Simplify a closure body element constraint by generating required
+  /// Simplify a syntactic element constraint by generating required
   /// constraints to represent the given element in constraint system.
-  SolutionKind simplifyClosureBodyElementConstraint(
+  SolutionKind simplifySyntacticElementConstraint(
       ASTNode element, ContextualTypeInfo context, bool isDiscarded,
       TypeMatchOptions flags, ConstraintLocatorBuilder locator);
 

lib/Sema/CSBindings.cpp

@@ -1385,7 +1385,7 @@ void PotentialBindings::infer(Constraint *constraint) {
   case ConstraintKind::EscapableFunctionOf:
   case ConstraintKind::OpenedExistentialOf:
   case ConstraintKind::KeyPath:
-  case ConstraintKind::ClosureBodyElement:
+  case ConstraintKind::SyntacticElement:
   case ConstraintKind::Conjunction:
   case ConstraintKind::BindTupleOfFunctionParams:
     // Constraints from which we can't do anything.