Merge pull request #76123 from hamishknight/a-form-of-expression

[Sema] Remove `preCheckExpression`

Author: hamishknight

include/swift/Sema/ConstraintSystem.h

@@ -5404,10 +5404,6 @@ class ConstraintSystem {
   /// and folding sequence expressions.
   static bool preCheckTarget(SyntacticElementTarget &target);
 
-  /// Pre-check the expression, validating any types that occur in the
-  /// expression and folding sequence expressions.
-  static bool preCheckExpression(Expr *&expr, DeclContext *dc);
-
   /// Solve the system of constraints generated from provided target.
   ///
   /// \param target The target that we'll generate constraints from, which

lib/IDE/PostfixCompletion.cpp

@@ -317,8 +317,14 @@ getOperatorCompletionTypes(DeclContext *DC, Type LHSType, OperatorDecl *Op) {
     llvm_unreachable("unexpected operator kind");
   }
 
-  CS.preCheckExpression(OpCallExpr, DC);
-  OpCallExpr = CS.generateConstraints(OpCallExpr, DC);
+  auto target = SyntacticElementTarget(OpCallExpr, DC, CTP_Unused, Type(),
+                                       /*isDiscarded*/ true);
+  if (CS.preCheckTarget(target))
+    return {};
+  if (CS.generateConstraints(target))
+    return {};
+
+  OpCallExpr = target.getAsExpr();
 
   CS.assignFixedType(CS.getType(&LHS)->getAs<TypeVariableType>(), LHSType);
 

lib/Sema/CSDiagnostics.cpp

@@ -1649,7 +1649,7 @@ class VarDeclMultipleReferencesChecker : public ASTWalker {
     }
 
     // FIXME: We can see UnresolvedDeclRefExprs here because we have
-    // not yet run preCheckExpression() on the entire function body
+    // not yet run preCheckTarget() on the entire function body
     // yet.
     //
     // We could consider pre-checking more eagerly.

lib/Sema/CSGen.cpp

@@ -889,7 +889,7 @@ TypeVarRefCollector::walkToExprPre(Expr *expr) {
     inferTypeVars(DRE->getDecl());
 
   // FIXME: We can see UnresolvedDeclRefExprs here because we don't walk into
-  // patterns when running preCheckExpression, since we don't resolve patterns
+  // patterns when running preCheckTarget, since we don't resolve patterns
   // until CSGen. We ought to consider moving pattern resolution into
   // pre-checking, which would allow us to pre-check patterns normally.
   if (auto *declRef = dyn_cast<UnresolvedDeclRefExpr>(expr)) {

lib/Sema/PreCheckExpr.cpp

@@ -2440,19 +2440,3 @@ bool ConstraintSystem::preCheckTarget(SyntacticElementTarget &target) {
   target = *newTarget;
   return false;
 }
-
-/// Pre-check the expression, validating any types that occur in the
-/// expression and folding sequence expressions.
-bool ConstraintSystem::preCheckExpression(Expr *&expr, DeclContext *dc) {
-  auto &ctx = dc->getASTContext();
-  FrontendStatsTracer StatsTracer(ctx.Stats, "precheck-expr", expr);
-
-  PreCheckExpression preCheck(dc);
-
-  // Perform the pre-check.
-  if (auto result = expr->walk(preCheck)) {
-    expr = result;
-    return false;
-  }
-  return true;
-}

lib/Sema/TypeCheckCodeCompletion.cpp

@@ -300,9 +300,13 @@ static std::optional<Type>
 getTypeOfCompletionContextExpr(DeclContext *DC, CompletionTypeCheckKind kind,
                                Expr *&parsedExpr,
                                ConcreteDeclRef &referencedDecl) {
-  if (constraints::ConstraintSystem::preCheckExpression(parsedExpr, DC))
+  auto target = SyntacticElementTarget(parsedExpr, DC, CTP_Unused, Type(),
+                                       /*isDiscarded*/ true);
+  if (constraints::ConstraintSystem::preCheckTarget(target))
     return std::nullopt;
 
+  parsedExpr = target.getAsExpr();
+
   switch (kind) {
   case CompletionTypeCheckKind::Normal:
     // Handle below.

lib/Sema/TypeCheckDecl.cpp

@@ -550,7 +550,7 @@ BodyInitKindRequest::evaluate(Evaluator &evaluator,
         myKind = BodyInitKind::Delegating;
       else if (auto *declRef = dyn_cast<UnresolvedDeclRefExpr>(arg)) {
         // FIXME: We can see UnresolvedDeclRefExprs here because we have
-        // not yet run preCheckExpression() on the entire function body
+        // not yet run preCheckTarget() on the entire function body
         // yet.
         //
         // We could consider pre-checking more eagerly.

lib/Sema/TypeCheckExpr.cpp

@@ -290,9 +290,9 @@ static Expr *makeBinOp(ASTContext &Ctx, Expr *Op, Expr *LHS, Expr *RHS,
   if (auto *ternary = dyn_cast<TernaryExpr>(Op)) {
     // Resolve the ternary expression.
     if (!Ctx.CompletionCallback) {
-      // In code completion we might call preCheckExpression twice - once for
+      // In code completion we might call preCheckTarget twice - once for
       // the first pass and once for the second pass. This is fine since
-      // preCheckExpression idempotent.
+      // preCheckTarget is idempotent.
       assert(!ternary->isFolded() && "already folded if expr in sequence?!");
     }
     ternary->setCondExpr(LHS);
@@ -303,9 +303,9 @@ static Expr *makeBinOp(ASTContext &Ctx, Expr *Op, Expr *LHS, Expr *RHS,
   if (auto *assign = dyn_cast<AssignExpr>(Op)) {
     // Resolve the assignment expression.
     if (!Ctx.CompletionCallback) {
-      // In code completion we might call preCheckExpression twice - once for
+      // In code completion we might call preCheckTarget twice - once for
       // the first pass and once for the second pass. This is fine since
-      // preCheckExpression idempotent.
+      // preCheckTarget is idempotent.
       assert(!assign->isFolded() && "already folded assign expr in sequence?!");
     }
     assign->setDest(LHS);
@@ -316,9 +316,9 @@ static Expr *makeBinOp(ASTContext &Ctx, Expr *Op, Expr *LHS, Expr *RHS,
   if (auto *as = dyn_cast<ExplicitCastExpr>(Op)) {
     // Resolve the 'as' or 'is' expression.
     if (!Ctx.CompletionCallback) {
-      // In code completion we might call preCheckExpression twice - once for
+      // In code completion we might call preCheckTarget twice - once for
       // the first pass and once for the second pass. This is fine since
-      // preCheckExpression idempotent.
+      // preCheckTarget is idempotent.
       assert(!as->isFolded() && "already folded 'as' expr in sequence?!");
     }
     assert(RHS == as && "'as' with non-type RHS?!");
@@ -329,9 +329,9 @@ static Expr *makeBinOp(ASTContext &Ctx, Expr *Op, Expr *LHS, Expr *RHS,
   if (auto *arrow = dyn_cast<ArrowExpr>(Op)) {
     // Resolve the '->' expression.
     if (!Ctx.CompletionCallback) {
-      // In code completion we might call preCheckExpression twice - once for
+      // In code completion we might call preCheckTarget twice - once for
       // the first pass and once for the second pass. This is fine since
-      // preCheckExpression idempotent.
+      // preCheckTarget is idempotent.
       assert(!arrow->isFolded() && "already folded '->' expr in sequence?!");
     }
     arrow->setArgsExpr(LHS);

test/type/array.swift

@@ -42,7 +42,7 @@ func constructArray(_ n: Int) {
 
 typealias FixIt0 = Int[] // expected-error{{array types are now written with the brackets around the element type}}{{20-20=[}}{{23-24=}}
 
-// Make sure preCheckExpression() properly folds member types.
+// Make sure preCheckTarget() properly folds member types.
 
 class Outer {
   class Middle {

unittests/Sema/KeypathFunctionConversionTests.cpp

@@ -104,11 +104,11 @@ TEST_F(SemaTest, TestKeypathFunctionConversionPrefersNarrowConversion) {
       fDecls, DeclNameLoc(), FunctionRefKind::SingleApply, false);
   auto *callExpr = CallExpr::create(Context, fDRE, argList, false);
 
-  Expr *target = callExpr;
   ConstraintSystem cs(DC, ConstraintSystemOptions());
-  ASSERT_FALSE(cs.preCheckExpression(target, DC));
-  auto *expr = cs.generateConstraints(callExpr, DC);
-  ASSERT_TRUE(expr);
+  auto target = SyntacticElementTarget(callExpr, DC, CTP_Unused, Type(),
+                                       /*isDiscarded*/ true);
+  ASSERT_FALSE(cs.preCheckTarget(target));
+  ASSERT_FALSE(cs.generateConstraints(target));
 
   SmallVector<Solution, 2> solutions;
   cs.solve(solutions);