[TypeChecker] Typecheck statement condition on demand

from NamingPatternRequest.

Author: rintaro

lib/Sema/TypeCheckConstraints.cpp

@@ -2564,6 +2564,29 @@ bool TypeChecker::typeCheckStmtCondition(StmtCondition &cond, DeclContext *dc,
   return false;
 }
 
+bool TypeChecker::typeCheckConditionForStatement(LabeledConditionalStmt *stmt,
+                                                 DeclContext *dc) {
+  Diag<> diagnosticForAlwaysTrue = diag::invalid_diagnostic;
+  switch (stmt->getKind()) {
+  case StmtKind::If:
+    diagnosticForAlwaysTrue = diag::if_always_true;
+    break;
+  case StmtKind::While:
+    diagnosticForAlwaysTrue = diag::while_always_true;
+    break;
+  case StmtKind::Guard:
+    diagnosticForAlwaysTrue = diag::guard_always_succeeds;
+    break;
+  default:
+    llvm_unreachable("unknown LabeledConditionalStmt kind");
+  }
+
+  StmtCondition cond = stmt->getCond();
+  bool result = typeCheckStmtCondition(cond, dc, diagnosticForAlwaysTrue);
+  stmt->setCond(cond);
+  return result;
+}
+
 /// Find the '~=` operator that can compare an expression inside a pattern to a
 /// value of a given type.
 bool TypeChecker::typeCheckExprPattern(ExprPattern *EP, DeclContext *DC,

lib/Sema/TypeCheckDecl.cpp

@@ -2360,23 +2360,33 @@ NamingPatternRequest::evaluate(Evaluator &evaluator, VarDecl *VD) const {
   if (!namingPattern) {
     auto *canVD = VD->getCanonicalVarDecl();
     namingPattern = canVD->NamingPattern;
+  }
+
+  if (!namingPattern) {
+    // Try type checking parent conditional statement.
+    if (auto parentStmt = VD->getParentPatternStmt()) {
+      if (auto LCS = dyn_cast<LabeledConditionalStmt>(parentStmt)) {
+        TypeChecker::typeCheckConditionForStatement(LCS, VD->getDeclContext());
+        namingPattern = VD->NamingPattern;
+      }
+    }
+  }
 
+  if (!namingPattern) {
     // HACK: If no other diagnostic applies, emit a generic diagnostic about
     // a variable being unbound. We can't do better than this at the
     // moment because TypeCheckPattern does not reliably invalidate parts of
     // the pattern AST on failure.
     //
     // Once that's through, this will only fire during circular validation.
-    if (!namingPattern) {
-      if (VD->hasInterfaceType() &&
-          !VD->isInvalid() && !VD->getParentPattern()->isImplicit()) {
-        VD->diagnose(diag::variable_bound_by_no_pattern, VD->getName());
-      }
-
-      VD->getParentPattern()->setType(ErrorType::get(Context));
-      setBoundVarsTypeError(VD->getParentPattern(), Context);
-      return nullptr;
+    if (VD->hasInterfaceType() &&
+        !VD->isInvalid() && !VD->getParentPattern()->isImplicit()) {
+      VD->diagnose(diag::variable_bound_by_no_pattern, VD->getName());
     }
+
+    VD->getParentPattern()->setType(ErrorType::get(Context));
+    setBoundVarsTypeError(VD->getParentPattern(), Context);
+    return nullptr;
   }
 
   if (!namingPattern->hasType()) {

lib/Sema/TypeCheckStmt.cpp

@@ -625,9 +625,7 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
   }
 
   Stmt *visitIfStmt(IfStmt *IS) {
-    StmtCondition C = IS->getCond();
-    TypeChecker::typeCheckStmtCondition(C, DC, diag::if_always_true);
-    IS->setCond(C);
+    TypeChecker::typeCheckConditionForStatement(IS, DC);
 
     AddLabeledStmt ifNest(*this, IS);
 
@@ -644,10 +642,8 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
   }
 
   Stmt *visitGuardStmt(GuardStmt *GS) {
-    StmtCondition C = GS->getCond();
-    TypeChecker::typeCheckStmtCondition(C, DC, diag::guard_always_succeeds);
-    GS->setCond(C);
-    
+    TypeChecker::typeCheckConditionForStatement(GS, DC);
+
     AddLabeledStmt ifNest(*this, GS);
 
     Stmt *S = GS->getBody();
@@ -665,9 +661,7 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
   }
 
   Stmt *visitWhileStmt(WhileStmt *WS) {
-    StmtCondition C = WS->getCond();
-    TypeChecker::typeCheckStmtCondition(C, DC, diag::while_always_true);
-    WS->setCond(C);
+    TypeChecker::typeCheckConditionForStatement(WS, DC);
 
     AddLabeledStmt loopNest(*this, WS);
     Stmt *S = WS->getBody();

lib/Sema/TypeChecker.h

@@ -756,7 +756,16 @@ void checkSwitchExhaustiveness(const SwitchStmt *stmt, const DeclContext *DC,
 /// \returns true if an error occurred, false otherwise.
 bool typeCheckCondition(Expr *&expr, DeclContext *dc);
 
-/// Type check the given 'if' or 'while' statement condition, which
+/// Type check the given 'if', 'while', or 'guard' statement condition.
+///
+/// \param stmt The conditional statement to type-check, which will be modified
+/// in place.
+///
+/// \returns true if an error occurred, false otherwise.
+bool typeCheckConditionForStatement(LabeledConditionalStmt *stmt,
+                                    DeclContext *dc);
+
+/// Type check the given 'if', 'while', or 'guard' statement condition, which
 /// either converts an expression to a logic value or bind variables to the
 /// contents of an Optional.
 ///

test/IDE/complete_skipbody.swift

@@ -8,15 +8,25 @@ struct MyStruct {
   var y: Int { 1 }
 }
 
-func test(value: MyStruct) {
+func test(valueOptOpt: MyStruct??) {
 
   let FORBIDDEN_localVar = 1
   let unrelated = FORBIDDEN_Struct()
+
+  let valueOpt = valueOptOpt!
+
   guard let a = unrelated.FORBIDDEN_method() else {
     return
   }
 
-  _ = value.#^COMPLETE^#
+  guard let value = valueOpt else {
+    return
+  }
+
+  if (value.x == 1) {
+    let unrelated2 = FORBIDDEN_Struct()
+    _ = value.#^COMPLETE^#
+  }
 }
 
 // CHECK: Begin completions, 3 items