[Sema] Remove replaceInvalidRefsWithErrors param

Doesn't seem like anything is relying on setting
this to `false` anymore, remove it.

Author: hamishknight

include/swift/Sema/ConstraintSystem.h

@@ -5402,19 +5402,11 @@ class ConstraintSystem {
 public:
   /// Pre-check the target, validating any types that occur in it
   /// and folding sequence expressions.
-  ///
-  /// \param replaceInvalidRefsWithErrors Indicates whether it's allowed
-  /// to replace any discovered invalid member references with `ErrorExpr`.
-  static bool preCheckTarget(SyntacticElementTarget &target,
-                             bool replaceInvalidRefsWithErrors);
+  static bool preCheckTarget(SyntacticElementTarget &target);
 
   /// Pre-check the expression, validating any types that occur in the
   /// expression and folding sequence expressions.
-  ///
-  /// \param replaceInvalidRefsWithErrors Indicates whether it's allowed
-  /// to replace any discovered invalid member references with `ErrorExpr`.
-  static bool preCheckExpression(Expr *&expr, DeclContext *dc,
-                                 bool replaceInvalidRefsWithErrors);
+  static bool preCheckExpression(Expr *&expr, DeclContext *dc);
 
   /// Solve the system of constraints generated from provided target.
   ///

include/swift/Sema/IDETypeChecking.h

@@ -158,8 +158,7 @@ namespace swift {
 
   /// Thunk around \c TypeChecker::resolveDeclRefExpr to make it available to
   /// \c swift::ide
-  Expr *resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE, DeclContext *Context,
-                         bool replaceInvalidRefsWithErrors);
+  Expr *resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE, DeclContext *Context);
 
   LookupResult
   lookupSemanticMember(DeclContext *DC, Type ty, DeclName name);

lib/IDE/IDETypeChecking.cpp

@@ -1022,9 +1022,8 @@ swift::getShorthandShadows(CaptureListExpr *CaptureList, DeclContext *DC) {
     }
 
     if (auto UDRE = dyn_cast<UnresolvedDeclRefExpr>(Init)) {
-      if (DC) {
-        Init = resolveDeclRefExpr(UDRE, DC, /*replaceInvalidRefsWithErrors=*/false);
-      }
+      if (DC)
+        Init = resolveDeclRefExpr(UDRE, DC);
     }
 
     auto *ReferencedVar = Init->getReferencedDecl().getDecl();
@@ -1045,9 +1044,8 @@ swift::getShorthandShadows(LabeledConditionalStmt *CondStmt, DeclContext *DC) {
 
     Expr *Init = Cond.getInitializer();
     if (auto UDRE = dyn_cast<UnresolvedDeclRefExpr>(Init)) {
-      if (DC) {
-        Init = resolveDeclRefExpr(UDRE, DC, /*replaceInvalidRefsWithErrors=*/false);
-      }
+      if (DC)
+        Init = resolveDeclRefExpr(UDRE, DC);
     }
 
     auto ReferencedVar = Init->getReferencedDecl().getDecl();

lib/IDE/PostfixCompletion.cpp

@@ -292,8 +292,7 @@ getOperatorCompletionTypes(DeclContext *DC, Type LHSType, OperatorDecl *Op) {
   UnresolvedDeclRefExpr UDRE(DeclNameRef(Op->getName()),
                              getDeclRefKindOfOperator(Op), DeclNameLoc(Loc));
   DiagnosticTransaction IgnoreDiags(DC->getASTContext().Diags);
-  Expr *OpExpr =
-      resolveDeclRefExpr(&UDRE, DC, /*replaceInvalidRefsWithErrors=*/true);
+  Expr *OpExpr = resolveDeclRefExpr(&UDRE, DC);
   IgnoreDiags.abort();
   if (isa<ErrorExpr>(OpExpr)) {
     // If we couldn't resolve the operator (e.g. because there is only an
@@ -318,7 +317,7 @@ getOperatorCompletionTypes(DeclContext *DC, Type LHSType, OperatorDecl *Op) {
     llvm_unreachable("unexpected operator kind");
   }
 
-  CS.preCheckExpression(OpCallExpr, DC, /*replaceInvalidRefsWithErrors=*/true);
+  CS.preCheckExpression(OpCallExpr, DC);
   OpCallExpr = CS.generateConstraints(OpCallExpr, DC);
 
   CS.assignFixedType(CS.getType(&LHS)->getAs<TypeVariableType>(), LHSType);

lib/Sema/BuilderTransform.cpp

@@ -1316,8 +1316,7 @@ class PreCheckResultBuilderApplication : public ASTWalker {
       // Suppress any diagnostics which could be produced by this expression.
       DiagnosticTransaction transaction(diagEngine);
 
-      HasError |= ConstraintSystem::preCheckExpression(
-          E, DC, /*replaceInvalidRefsWithErrors=*/true);
+      HasError |= ConstraintSystem::preCheckExpression(E, DC);
 
       HasError |= transaction.hasErrors();
 

lib/Sema/CSSimplify.cpp

@@ -10761,7 +10761,7 @@ static bool inferEnumMemberThroughTildeEqualsOperator(
 
   DiagnosticTransaction diagnostics(ctx.Diags);
   {
-    if (cs.preCheckTarget(target, /*replaceInvalidRefWithErrors=*/true)) {
+    if (cs.preCheckTarget(target)) {
       // Skip diagnostics if they are disabled, otherwise it would result in
       // duplicate diagnostics, since this operation is going to be repeated
       // in diagnostic mode.

lib/Sema/CSSyntacticElement.cpp

@@ -557,7 +557,7 @@ class SyntacticElementConstraintGenerator
   void visitExprPattern(ExprPattern *EP) {
     auto target = SyntacticElementTarget::forExprPattern(EP);
 
-    if (cs.preCheckTarget(target, /*replaceInvalidRefWithErrors=*/true)) {
+    if (cs.preCheckTarget(target)) {
       hadError = true;
       return;
     }
@@ -771,8 +771,7 @@ class SyntacticElementConstraintGenerator
           init, patternType, patternBinding, index,
           /*bindPatternVarsOneWay=*/false);
 
-      if (ConstraintSystem::preCheckTarget(
-              target, /*replaceInvalidRefsWithErrors=*/true))
+      if (ConstraintSystem::preCheckTarget(target))
         return std::nullopt;
 
       return target;

lib/Sema/PreCheckExpr.cpp

@@ -406,8 +406,7 @@ static BinaryExpr *getCompositionExpr(Expr *expr) {
 /// returning the resultant expression. Context is the DeclContext used
 /// for the lookup.
 Expr *TypeChecker::resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE,
-                                      DeclContext *DC,
-                                      bool replaceInvalidRefsWithErrors) {
+                                      DeclContext *DC) {
   // Process UnresolvedDeclRefExpr by doing an unqualified lookup.
   DeclNameRef Name = UDRE->getName();
   SourceLoc Loc = UDRE->getLoc();
@@ -431,10 +430,10 @@ Expr *TypeChecker::resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE,
     LookupName = DeclNameRef(lookupName);
   }
 
+  auto &Context = DC->getASTContext();
+
   auto errorResult = [&]() -> Expr * {
-    if (replaceInvalidRefsWithErrors)
-      return new (DC->getASTContext()) ErrorExpr(UDRE->getSourceRange());
-    return UDRE;
+    return new (Context) ErrorExpr(UDRE->getSourceRange());
   };
 
   // Perform standard value name lookup.
@@ -449,8 +448,6 @@ Expr *TypeChecker::resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE,
   bool AllDeclRefs = true;
   SmallVector<ValueDecl*, 4> ResultValues;
 
-  auto &Context = DC->getASTContext();
-
   // First, look for a local binding in scope.
   if (Loc.isValid() && !Name.isOperator()) {
     ASTScope::lookupLocalDecls(DC->getParentSourceFile(),
@@ -487,8 +484,7 @@ Expr *TypeChecker::resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE,
           Context.Diags.diagnose(Loc, diag::use_local_before_declaration, Name);
           Context.Diags.diagnose(innerDecl, diag::decl_declared_here,
                                  localDeclAfterUse);
-          Expr *error = new (Context) ErrorExpr(UDRE->getSourceRange());
-          return error;
+          return errorResult();
         }
 
         Lookup.shiftDownResults();
@@ -705,7 +701,7 @@ Expr *TypeChecker::resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE,
           UDRE->getRefKind() == DeclRefKind::BinaryOperator
               ? 0
               : UDRE->getRefKind() == DeclRefKind::PrefixOperator ? 1 : 2);
-      return new (Context) ErrorExpr(UDRE->getSourceRange());
+      return errorResult();
     }
 
     // For operators, sort the results so that non-generic operations come
@@ -844,7 +840,7 @@ Expr *TypeChecker::resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE,
     auto *Decl = Result.getValueDecl();
     Context.Diags.diagnose(Decl, diag::decl_declared_here, Decl);
   }
-  return new (Context) ErrorExpr(UDRE->getSourceRange());
+  return errorResult();
 }
 
 /// If an expression references 'self.init' or 'super.init' in an
@@ -1036,10 +1032,6 @@ namespace {
 
     Expr *ParentExpr;
 
-    /// Indicates whether pre-check is allowed to insert
-    /// implicit `ErrorExpr` in place of invalid references.
-    bool UseErrorExprs;
-
     /// A stack of expressions being walked, used to determine where to
     /// insert RebindSelfInConstructorExpr nodes.
     llvm::SmallVector<Expr *, 8> ExprStack;
@@ -1107,10 +1099,8 @@ namespace {
     void markAcceptableDiscardExprs(Expr *E);
 
   public:
-    PreCheckExpression(DeclContext *dc, Expr *parent,
-                       bool replaceInvalidRefsWithErrors)
-        : Ctx(dc->getASTContext()), DC(dc), ParentExpr(parent),
-          UseErrorExprs(replaceInvalidRefsWithErrors) {}
+    PreCheckExpression(DeclContext *dc, Expr *parent)
+        : Ctx(dc->getASTContext()), DC(dc), ParentExpr(parent) {}
 
     ASTContext &getASTContext() const { return Ctx; }
 
@@ -1232,8 +1222,7 @@ namespace {
                         new (Ctx) ErrorExpr(unresolved->getSourceRange()));
         }
 
-        auto *refExpr =
-            TypeChecker::resolveDeclRefExpr(unresolved, DC, UseErrorExprs);
+        auto *refExpr = TypeChecker::resolveDeclRefExpr(unresolved, DC);
 
         // Check whether this is standalone `self` in init accessor, which
         // is invalid.
@@ -2461,14 +2450,13 @@ Expr *PreCheckExpression::simplifyTypeConstructionWithLiteralArg(Expr *E) {
              : nullptr;
 }
 
-bool ConstraintSystem::preCheckTarget(SyntacticElementTarget &target,
-                                      bool replaceInvalidRefsWithErrors) {
+bool ConstraintSystem::preCheckTarget(SyntacticElementTarget &target) {
   auto *DC = target.getDeclContext();
 
   bool hadErrors = false;
 
   if (auto *expr = target.getAsExpr()) {
-    hadErrors |= preCheckExpression(expr, DC, replaceInvalidRefsWithErrors);
+    hadErrors |= preCheckExpression(expr, DC);
     // Even if the pre-check fails, expression still has to be re-set.
     target.setExpr(expr);
   }
@@ -2479,12 +2467,10 @@ bool ConstraintSystem::preCheckTarget(SyntacticElementTarget &target,
     auto *sequenceExpr = stmt->getParsedSequence();
     auto *whereExpr = stmt->getWhere();
 
-    hadErrors |= preCheckExpression(sequenceExpr, DC,
-                                    /*replaceInvalidRefsWithErrors=*/true);
+    hadErrors |= preCheckExpression(sequenceExpr, DC);
 
     if (whereExpr) {
-      hadErrors |= preCheckExpression(whereExpr, DC,
-                                      /*replaceInvalidRefsWithErrors=*/true);
+      hadErrors |= preCheckExpression(whereExpr, DC);
     }
 
     // Update sequence and where expressions to pre-checked versions.
@@ -2501,12 +2487,11 @@ bool ConstraintSystem::preCheckTarget(SyntacticElementTarget &target,
 
 /// Pre-check the expression, validating any types that occur in the
 /// expression and folding sequence expressions.
-bool ConstraintSystem::preCheckExpression(Expr *&expr, DeclContext *dc,
-                                          bool replaceInvalidRefsWithErrors) {
+bool ConstraintSystem::preCheckExpression(Expr *&expr, DeclContext *dc) {
   auto &ctx = dc->getASTContext();
   FrontendStatsTracer StatsTracer(ctx.Stats, "precheck-expr", expr);
 
-  PreCheckExpression preCheck(dc, expr, replaceInvalidRefsWithErrors);
+  PreCheckExpression preCheck(dc, expr);
 
   // Perform the pre-check.
   if (auto result = expr->walk(preCheck)) {

lib/Sema/TypeCheckCodeCompletion.cpp

@@ -221,10 +221,7 @@ bool TypeChecker::typeCheckForCodeCompletion(
   if (needsPrecheck) {
     // First, pre-check the expression, validating any types that occur in the
     // expression and folding sequence expressions.
-    auto failedPreCheck =
-        ConstraintSystem::preCheckTarget(target,
-                                         /*replaceInvalidRefsWithErrors=*/true);
-
+    auto failedPreCheck = ConstraintSystem::preCheckTarget(target);
     if (failedPreCheck)
       return false;
   }
@@ -303,9 +300,7 @@ static std::optional<Type>
 getTypeOfCompletionContextExpr(DeclContext *DC, CompletionTypeCheckKind kind,
                                Expr *&parsedExpr,
                                ConcreteDeclRef &referencedDecl) {
-  if (constraints::ConstraintSystem::preCheckExpression(
-          parsedExpr, DC,
-          /*replaceInvalidRefsWithErrors=*/true))
+  if (constraints::ConstraintSystem::preCheckExpression(parsedExpr, DC))
     return std::nullopt;
 
   switch (kind) {

lib/Sema/TypeCheckConstraints.cpp

@@ -478,10 +478,8 @@ TypeChecker::typeCheckTarget(SyntacticElementTarget &target,
 
   // First, pre-check the target, validating any types that occur in the
   // expression and folding sequence expressions.
-  if (ConstraintSystem::preCheckTarget(
-          target, /*replaceInvalidRefsWithErrors=*/true)) {
+  if (ConstraintSystem::preCheckTarget(target))
     return errorResult();
-  }
 
   // Check whether given target has a code completion token which requires
   // special handling. Returns true if handled, in which case we've already