---

yaml
---
r: 322559
b: refs/heads/tensorflow-next
c: a4ba16a
h: refs/heads/master
i:
  322557: 79b79c2
  322555: f537078
  322551: 270ad14
  322543: a3cb49a
  322527: 332b7a4
  322495: 313bccd
  322431: 135e8b1
  322303: 20b4ec2
  322047: 31861de
  321535: 6830862

Author: swift-ci

[refs]

@@ -1461,4 +1461,4 @@ refs/heads/master-rebranch: 86e95c23aa0d37f24ec138b7853146c1cead2e40
 refs/heads/rdar-53901732: 9bd06af3284e18a109cdbf9aa59d833b24eeca7b
 refs/heads/revert-26776-subst-always-returns-a-type: 1b8e18fdd391903a348970a4c848995d4cdd789c
 refs/heads/tensorflow-merge: 8b854f62f80d4476cb383d43c4aac2001dde3cec
-refs/heads/tensorflow-next: 13323102ebd342a71552ec921604e9c35002579e
+refs/heads/tensorflow-next: a4ba16a58df5ba21c5092a2db677d4296890bb8a

branches/tensorflow-next/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;

branches/tensorflow-next/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,

branches/tensorflow-next/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)
 //===----------------------------------------------------------------------===//

branches/tensorflow-next/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);