Merge pull request #23733 from slavapestov/prepare-to-be-removed

IDE: Remove prepareForRetypechecking()

Author: slavapestov

lib/IDE/CodeCompletion.cpp

@@ -1304,8 +1304,6 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks {
       return std::make_pair(ParsedExpr->getType(), refDecl);
     }
 
-    prepareForRetypechecking(ParsedExpr);
-
     ConcreteDeclRef ReferencedDecl = nullptr;
     Expr *ModifiedExpr = ParsedExpr;
     if (auto T = getTypeOfCompletionContextExpr(P.Context, CurDeclContext,
@@ -3340,7 +3338,6 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     if (expr->getType() && !expr->getType()->hasError())
       return expr;
 
-    prepareForRetypechecking(expr);
     if (!typeCheckExpression(const_cast<DeclContext *>(CurrDeclContext), expr))
       return expr;
     return LHS;

lib/IDE/ConformingMethodList.cpp

@@ -75,7 +75,6 @@ void ConformingMethodListCallbacks::doneParsing() {
 
   // Type check the expression if needed.
   if (!T || T->is<ErrorType>()) {
-    prepareForRetypechecking(ParsedExpr);
     ConcreteDeclRef ReferencedDecl = nullptr;
     auto optT = getTypeOfCompletionContextExpr(P.Context, CurDeclContext,
                                                CompletionTypeCheckKind::Normal,

lib/IDE/ExprContextAnalysis.cpp

@@ -31,53 +31,6 @@
 using namespace swift;
 using namespace ide;
 
-//===----------------------------------------------------------------------===//
-// prepareForRetypechecking(Expr *)
-//===----------------------------------------------------------------------===//
-
-/// Prepare the given expression for type-checking again, prinicipally by
-/// erasing any ErrorType types on the given expression, allowing later
-/// type-checking to make progress.
-///
-/// FIXME: this is fundamentally a workaround for the fact that we may end up
-/// typechecking parts of an expression more than once - first for checking
-/// the context, and later for checking more-specific things like unresolved
-/// members.  We should restructure code-completion type-checking so that we
-/// never typecheck more than once (or find a more principled way to do it).
-void swift::ide::prepareForRetypechecking(Expr *E) {
-  assert(E);
-  struct Eraser : public ASTWalker {
-    std::pair<bool, Expr *> walkToExprPre(Expr *expr) override {
-      if (expr && expr->getType() && (expr->getType()->hasError() ||
-                                      expr->getType()->hasUnresolvedType()))
-        expr->setType(Type());
-      if (auto *ACE = dyn_cast_or_null<AutoClosureExpr>(expr)) {
-        return { true, ACE->getSingleExpressionBody() };
-      }
-      return { true, expr };
-    }
-    bool walkToTypeLocPre(TypeLoc &TL) override {
-      if (TL.getType() && (TL.getType()->hasError() ||
-                           TL.getType()->hasUnresolvedType()))
-        TL.setType(Type());
-      return true;
-    }
-
-    std::pair<bool, Pattern*> walkToPatternPre(Pattern *P) override {
-      if (P && P->hasType() && (P->getType()->hasError() ||
-                                P->getType()->hasUnresolvedType())) {
-        P->setType(Type());
-      }
-      return { true, P };
-    }
-    std::pair<bool, Stmt *> walkToStmtPre(Stmt *S) override {
-      return { false, S };
-    }
-  };
-
-  E->walk(Eraser());
-}
-
 //===----------------------------------------------------------------------===//
 // typeCheckContextUntil(DeclContext, SourceLoc)
 //===----------------------------------------------------------------------===//

lib/IDE/ExprContextAnalysis.h

@@ -25,11 +25,6 @@ class AnyFunctionType;
 
 namespace ide {
 
-/// Prepare the given expression for type-checking again, prinicipally by
-/// erasing any ErrorType types on the given expression, allowing later
-/// type-checking to make progress.
-void prepareForRetypechecking(Expr *E);
-
 /// Type check parent contexts of the given decl context, and the body of the
 /// given context until \c Loc if the context is a function body.
 void typeCheckContextUntil(DeclContext *DC, SourceLoc Loc);