Make more high-level type checking endpoints utility

CodaFi · CodaFi · commit 63896c1fc59d · 2019-11-10T13:03:46.000-08:00
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -3124,7 +3124,7 @@ namespace {
       auto castContextKind =
           SuppressDiagnostics ? CheckedCastContextKind::None
                               : CheckedCastContextKind::IsExpr;
-      auto castKind = cs.getTypeChecker().typeCheckCheckedCast(
+      auto castKind = TypeChecker::typeCheckCheckedCast(
           fromType, toType, castContextKind, cs.DC, expr->getLoc(), sub,
           expr->getCastTypeLoc().getSourceRange());
 
@@ -3576,7 +3576,7 @@ namespace {
                               : CheckedCastContextKind::ForcedCast;
 
       auto fromType = cs.getType(sub);
-      auto castKind = cs.getTypeChecker().typeCheckCheckedCast(
+      auto castKind = TypeChecker::typeCheckCheckedCast(
           fromType, toType, castContextKind, cs.DC, expr->getLoc(), sub,
           expr->getCastTypeLoc().getSourceRange());
       switch (castKind) {
@@ -3657,7 +3657,7 @@ namespace {
             : CheckedCastContextKind::ConditionalCast;
 
       auto fromType = cs.getType(sub);
-      auto castKind = cs.getTypeChecker().typeCheckCheckedCast(
+      auto castKind = TypeChecker::typeCheckCheckedCast(
           fromType, toType, castContextKind, cs.DC, expr->getLoc(), sub,
           expr->getCastTypeLoc().getSourceRange());
       switch (castKind) {
@@ -5676,12 +5676,10 @@ static Expr *buildElementConversion(ExprRewriter &rewriter,
                                     ConstraintLocatorBuilder locator,
                                     Expr *element) {
   auto &cs = rewriter.getConstraintSystem();
-
-  auto &tc = rewriter.getConstraintSystem().getTypeChecker();
   if (bridged &&
-      tc.typeCheckCheckedCast(srcType, destType,
-                              CheckedCastContextKind::None, cs.DC,
-                              SourceLoc(), nullptr, SourceRange())
+      TypeChecker::typeCheckCheckedCast(srcType, destType,
+                                        CheckedCastContextKind::None, cs.DC,
+                                        SourceLoc(), nullptr, SourceRange())
         != CheckedCastKind::Coercion) {
     if (auto conversion =
           rewriter.buildObjCBridgeExpr(element, destType, locator))
diff --git a/lib/Sema/CSDiagnostics.cpp b/lib/Sema/CSDiagnostics.cpp
@@ -2682,10 +2682,10 @@ bool ContextualFailure::tryTypeCoercionFixIt(
   if (!toType->hasTypeRepr())
     return false;
 
-  auto &TC = getTypeChecker();
   CheckedCastKind Kind =
-      TC.typeCheckCheckedCast(fromType, toType, CheckedCastContextKind::None,
-                              getDC(), SourceLoc(), nullptr, SourceRange());
+      TypeChecker::typeCheckCheckedCast(fromType, toType,
+                                        CheckedCastContextKind::None, getDC(),
+                                        SourceLoc(), nullptr, SourceRange());
 
   if (Kind != CheckedCastKind::Unresolved) {
     auto *anchor = getAnchor();
diff --git a/lib/Sema/CSFix.cpp b/lib/Sema/CSFix.cpp
@@ -138,8 +138,6 @@ CoerceToCheckedCast *CoerceToCheckedCast::attempt(ConstraintSystem &cs,
   if (fromType->hasTypeVariable() || toType->hasTypeVariable())
     return nullptr;
 
-  auto &TC = cs.getTypeChecker();
-
   auto *expr = locator->getAnchor();
   if (auto *assignExpr = dyn_cast<AssignExpr>(expr))
     expr = assignExpr->getSrc();
@@ -149,9 +147,10 @@ CoerceToCheckedCast *CoerceToCheckedCast::attempt(ConstraintSystem &cs,
 
   auto subExpr = coerceExpr->getSubExpr();
   auto castKind =
-      TC.typeCheckCheckedCast(fromType, toType, CheckedCastContextKind::None,
-                              cs.DC, coerceExpr->getLoc(), subExpr,
-                              coerceExpr->getCastTypeLoc().getSourceRange());
+      TypeChecker::typeCheckCheckedCast(fromType, toType,
+                                        CheckedCastContextKind::None, cs.DC,
+                                        coerceExpr->getLoc(), subExpr,
+                                        coerceExpr->getCastTypeLoc().getSourceRange());
 
   // Invalid cast.
   if (castKind == CheckedCastKind::Unresolved)
diff --git a/lib/Sema/CSGen.cpp b/lib/Sema/CSGen.cpp
@@ -2332,7 +2332,7 @@ namespace {
           Type exnType = CS.getASTContext().getErrorDecl()->getDeclaredType();
           if (!exnType)
             return false;
-          if (CS.TC.coercePatternToType(pattern,
+          if (TypeChecker::coercePatternToType(pattern,
                                         TypeResolution::forContextual(CS.DC),
                                         exnType,
                                         TypeResolverContext::InExpression)) {
diff --git a/lib/Sema/TypeCheckConstraints.cpp b/lib/Sema/TypeCheckConstraints.cpp
@@ -2758,6 +2758,7 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
     }
   };
 
+  auto &Context = DC->getASTContext();
   BindingListener listener(Context, pattern, initializer);
   if (!initializer)
     return true;
@@ -2858,7 +2859,7 @@ bool TypeChecker::typeCheckPatternBinding(PatternBindingDecl *PBD,
       DC = initContext;
   }
 
-  bool hadError = typeCheckBinding(pattern, init, DC);
+  bool hadError = TypeChecker::typeCheckBinding(pattern, init, DC);
   if (!init) {
     PBD->setInvalid();
     return true;
@@ -2967,7 +2968,6 @@ bool TypeChecker::typeCheckForEachBinding(DeclContext *dc, ForEachStmt *stmt) {
     Expr *appliedSolution(Solution &solution, Expr *expr) override {
       // Figure out what types the constraints decided on.
       auto &cs = solution.getConstraintSystem();
-      auto &tc = cs.getTypeChecker();
       InitType = solution.simplifyType(InitType);
       SequenceType = solution.simplifyType(SequenceType);
 
@@ -2982,8 +2982,9 @@ bool TypeChecker::typeCheckForEachBinding(DeclContext *dc, ForEachStmt *stmt) {
       Pattern *pattern = Stmt->getPattern();
       TypeResolutionOptions options(TypeResolverContext::ForEachStmt);
       options |= TypeResolutionFlags::OverrideType;
-      if (tc.coercePatternToType(pattern, TypeResolution::forContextual(cs.DC),
-                                 InitType, options)) {
+      if (TypeChecker::coercePatternToType(pattern,
+                                           TypeResolution::forContextual(cs.DC),
+                                           InitType, options)) {
         return nullptr;
       }
 
@@ -3000,30 +3001,31 @@ bool TypeChecker::typeCheckForEachBinding(DeclContext *dc, ForEachStmt *stmt) {
   assert(seq && "type-checking an uninitialized for-each statement?");
 
   // Type-check the for-each loop sequence and element pattern.
-  auto resultTy = typeCheckExpression(seq, dc, &listener);
+  auto resultTy = TypeChecker::typeCheckExpression(seq, dc, &listener);
   return !resultTy;
 }
 
 bool TypeChecker::typeCheckCondition(Expr *&expr, DeclContext *dc) {
   // If this expression is already typechecked and has type Bool, then just
   // re-typecheck it.
   if (expr->getType() && expr->getType()->isBool()) {
-    auto resultTy = typeCheckExpression(expr, dc);
+    auto resultTy = TypeChecker::typeCheckExpression(expr, dc);
     return !resultTy;
   }
 
-  auto *boolDecl = Context.getBoolDecl();
+  auto *boolDecl = dc->getASTContext().getBoolDecl();
   if (!boolDecl)
     return true;
 
-  auto resultTy = typeCheckExpression(
+  auto resultTy = TypeChecker::typeCheckExpression(
       expr, dc, TypeLoc::withoutLoc(boolDecl->getDeclaredType()),
       CTP_Condition);
   return !resultTy;
 }
 
 bool TypeChecker::typeCheckStmtCondition(StmtCondition &cond, DeclContext *dc,
                                          Diag<> diagnosticForAlwaysTrue) {
+  auto &Context = dc->getASTContext();
   bool hadError = false;
   bool hadAnyFalsable = false;
   for (auto &elt : cond) {
@@ -3069,15 +3071,15 @@ bool TypeChecker::typeCheckStmtCondition(StmtCondition &cond, DeclContext *dc,
     TypeResolutionOptions options(TypeResolverContext::InExpression);
     options |= TypeResolutionFlags::AllowUnspecifiedTypes;
     options |= TypeResolutionFlags::AllowUnboundGenerics;
-    if (typeCheckPattern(pattern, dc, options)) {
+    if (TypeChecker::typeCheckPattern(pattern, dc, options)) {
       typeCheckPatternFailed();
       continue;
     }
 
     // If the pattern didn't get a type, it's because we ran into some
     // unknown types along the way. We'll need to check the initializer.
     auto init = elt.getInitializer();
-    hadError |= typeCheckBinding(pattern, init, dc);
+    hadError |= TypeChecker::typeCheckBinding(pattern, init, dc);
     elt.setPattern(pattern);
     elt.setInitializer(init);
     hadAnyFalsable |= pattern->isRefutablePattern();
@@ -3097,6 +3099,7 @@ bool TypeChecker::typeCheckStmtCondition(StmtCondition &cond, DeclContext *dc,
 /// value of a given type.
 bool TypeChecker::typeCheckExprPattern(ExprPattern *EP, DeclContext *DC,
                                        Type rhsType) {
+  auto &Context = DC->getASTContext();
   FrontendStatsTracer StatsTracer(Context.Stats, "typecheck-expr-pattern", EP);
   PrettyStackTracePattern stackTrace(Context, "type-checking", EP);
 
@@ -3295,7 +3298,8 @@ bool TypeChecker::isObjCBridgedTo(Type type1, Type type2, DeclContext *dc,
 }
 
 bool TypeChecker::checkedCastMaySucceed(Type t1, Type t2, DeclContext *dc) {
-  auto kind = typeCheckCheckedCast(t1, t2, CheckedCastContextKind::None, dc,
+  auto kind = TypeChecker::typeCheckCheckedCast(t1, t2,
+                                                CheckedCastContextKind::None, dc,
                                    SourceLoc(), nullptr, SourceRange());
   return (kind != CheckedCastKind::Unresolved);
 }
@@ -3842,12 +3846,12 @@ void ConstraintSystem::print(raw_ostream &out) const {
 
 /// Determine the semantics of a checked cast operation.
 CheckedCastKind TypeChecker::typeCheckCheckedCast(Type fromType,
-                                 Type toType,
-                                 CheckedCastContextKind contextKind,
-                                 DeclContext *dc,
-                                 SourceLoc diagLoc,
-                                 Expr *fromExpr,
-                                 SourceRange diagToRange) {
+                                                  Type toType,
+                                                  CheckedCastContextKind contextKind,
+                                                  DeclContext *dc,
+                                                  SourceLoc diagLoc,
+                                                  Expr *fromExpr,
+                                                  SourceRange diagToRange) {
   SourceRange diagFromRange;
   if (fromExpr)
     diagFromRange = fromExpr->getSourceRange();
@@ -3928,6 +3932,7 @@ CheckedCastKind TypeChecker::typeCheckCheckedCast(Type fromType,
 
   // If the unwrapped from/to types are equivalent or bridged, this isn't a real
   // downcast. Complain.
+  auto &Context = dc->getASTContext();
   if (extraFromOptionals > 0) {
     switch (typeCheckCheckedCast(fromType, toType,
                                  CheckedCastContextKind::None, dc,
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -2585,16 +2585,13 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     checkAccessControl(PBD);
 
-    // FIXME: Remove TypeChecker dependency.
-    auto &TC = *Ctx.getLegacyGlobalTypeChecker();
-
     // If the initializers in the PBD aren't checked yet, do so now.
     for (auto i : range(PBD->getNumPatternEntries())) {
       if (!PBD->isInitialized(i))
         continue;
 
       if (!PBD->isInitializerChecked(i)) {
-        TC.typeCheckPatternBinding(PBD, i);
+        TypeChecker::typeCheckPatternBinding(PBD, i);
       }
 
       if (!PBD->isInvalid()) {
diff --git a/lib/Sema/TypeCheckPattern.cpp b/lib/Sema/TypeCheckPattern.cpp
@@ -711,7 +711,7 @@ static bool validateTypedPattern(TypeResolution resolution,
 
 bool TypeChecker::typeCheckPattern(Pattern *P, DeclContext *dc,
                                    TypeResolutionOptions options) {
-  auto &diags = dc->getASTContext().Diags;
+  auto &Context = dc->getASTContext();
   switch (P->getKind()) {
   // Type-check paren patterns by checking the sub-pattern and
   // propagating that type out.
@@ -722,7 +722,7 @@ bool TypeChecker::typeCheckPattern(Pattern *P, DeclContext *dc,
       SP = PP->getSubPattern();
     else
       SP = cast<VarPattern>(P)->getSubPattern();
-    if (typeCheckPattern(SP, dc, options)) {
+    if (TypeChecker::typeCheckPattern(SP, dc, options)) {
       P->setType(ErrorType::get(Context));
       return true;
     }
@@ -748,9 +748,9 @@ bool TypeChecker::typeCheckPattern(Pattern *P, DeclContext *dc,
       return hadError;
 
     Pattern *subPattern = TP->getSubPattern();
-    if (coercePatternToType(subPattern, resolution, P->getType(),
-                            options|TypeResolutionFlags::FromNonInferredPattern,
-                            TP->getTypeLoc()))
+    if (TypeChecker::coercePatternToType(subPattern, resolution, P->getType(),
+                                         options|TypeResolutionFlags::FromNonInferredPattern,
+                                         TP->getTypeLoc()))
       hadError = true;
     else {
       TP->setSubPattern(subPattern);
@@ -768,7 +768,7 @@ bool TypeChecker::typeCheckPattern(Pattern *P, DeclContext *dc,
     if (options & TypeResolutionFlags::AllowUnspecifiedTypes)
       return false;
 
-    diags.diagnose(P->getLoc(), diag::cannot_infer_type_for_pattern);
+    Context.Diags.diagnose(P->getLoc(), diag::cannot_infer_type_for_pattern);
     P->setType(ErrorType::get(Context));
     if (auto named = dyn_cast<NamedPattern>(P)) {
       if (auto var = named->getDecl()) {
@@ -788,7 +788,7 @@ bool TypeChecker::typeCheckPattern(Pattern *P, DeclContext *dc,
     for (unsigned i = 0, e = tuplePat->getNumElements(); i != e; ++i) {
       TuplePatternElt &elt = tuplePat->getElement(i);
       Pattern *pattern = elt.getPattern();
-      if (typeCheckPattern(pattern, dc, elementOptions)) {
+      if (TypeChecker::typeCheckPattern(pattern, dc, elementOptions)) {
         hadError = true;
         continue;
       }
@@ -822,7 +822,8 @@ bool TypeChecker::typeCheckPattern(Pattern *P, DeclContext *dc,
   case PatternKind::Expr:
     // In a let/else, these always require an initial value to match against.
     if (!(options & TypeResolutionFlags::AllowUnspecifiedTypes)) {
-      diags.diagnose(P->getLoc(), diag::refutable_pattern_requires_initializer);
+      Context.Diags.diagnose(P->getLoc(),
+                             diag::refutable_pattern_requires_initializer);
       P->setType(ErrorType::get(Context));
       return true;
     }
@@ -883,7 +884,8 @@ bool TypeChecker::coercePatternToType(Pattern *&P, TypeResolution resolution,
   }
 
   auto dc = resolution.getDeclContext();
-  auto &diags = dc->getASTContext().Diags;
+  auto &Context = dc->getASTContext();
+  auto &diags = Context.Diags;
   auto subOptions = options;
   subOptions.setContext(None);
   switch (P->getKind()) {
@@ -1041,7 +1043,7 @@ bool TypeChecker::coercePatternToType(Pattern *&P, TypeResolution resolution,
     auto decayToParen = [&]() -> bool {
       assert(canDecayToParen);
       Pattern *sub = TP->getElement(0).getPattern();
-      if (this->coercePatternToType(sub, resolution, type, subOptions))
+      if (TypeChecker::coercePatternToType(sub, resolution, type, subOptions))
         return true;
       
       if (TP->getLParenLoc().isValid()) {
@@ -1132,10 +1134,10 @@ bool TypeChecker::coercePatternToType(Pattern *&P, TypeResolution resolution,
                                              NLE->getLoc(), NLE->getLoc(),
                                              NoneEnumElement->getName(),
                                              NoneEnumElement, nullptr, false);
-        return coercePatternToType(P, resolution, type, options);
+        return TypeChecker::coercePatternToType(P, resolution, type, options);
       }
     }
-    return typeCheckExprPattern(cast<ExprPattern>(P), dc, type);
+    return TypeChecker::typeCheckExprPattern(cast<ExprPattern>(P), dc, type);
   }
       
   // Coerce an 'is' pattern by determining the cast kind.
@@ -1176,14 +1178,14 @@ bool TypeChecker::coercePatternToType(Pattern *&P, TypeResolution resolution,
 
 
     CheckedCastKind castKind
-      = typeCheckCheckedCast(type, IP->getCastTypeLoc().getType(),
-                             type->hasError()
-                               ? CheckedCastContextKind::None
-                               : CheckedCastContextKind::IsPattern,
-                             dc,
-                             IP->getLoc(),
-                             nullptr,
-                             IP->getCastTypeLoc().getSourceRange());
+      = TypeChecker::typeCheckCheckedCast(type, IP->getCastTypeLoc().getType(),
+                                          type->hasError()
+                                            ? CheckedCastContextKind::None
+                                            : CheckedCastContextKind::IsPattern,
+                                          dc,
+                                          IP->getLoc(),
+                                          nullptr,
+                                          IP->getCastTypeLoc().getSourceRange());
     switch (castKind) {
     case CheckedCastKind::Unresolved:
       return true;
diff --git a/lib/Sema/TypeCheckPropertyWrapper.cpp b/lib/Sema/TypeCheckPropertyWrapper.cpp
@@ -538,7 +538,7 @@ PropertyWrapperBackingPropertyTypeRequest::evaluate(
     // FIXME(InterfaceTypeRequest): Remove this.
     (void)var->getInterfaceType();
     if (!binding->isInitializerChecked(index))
-      tc.typeCheckPatternBinding(binding, index);
+      TypeChecker::typeCheckPatternBinding(binding, index);
 
     Type type = ctx.getSideCachedPropertyWrapperBackingPropertyType(var);
     assert(type || ctx.Diags.hadAnyError());
diff --git a/lib/Sema/TypeCheckStmt.cpp b/lib/Sema/TypeCheckStmt.cpp
diff --git a/lib/Sema/TypeCheckStorage.cpp b/lib/Sema/TypeCheckStorage.cpp
diff --git a/lib/Sema/TypeChecker.cpp b/lib/Sema/TypeChecker.cpp
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
