[NFC] Remove Non-Mutating Usages of Typechecker::validateType

Author: CodaFi

lib/Sema/CSGen.cpp

@@ -23,6 +23,7 @@
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/PrettyStackTrace.h"
 #include "swift/AST/SubstitutionMap.h"
+#include "swift/AST/TypeCheckRequests.h"
 #include "swift/Sema/IDETypeChecking.h"
 #include "swift/Subsystems.h"
 #include "llvm/ADT/APInt.h"
@@ -1713,13 +1714,12 @@ namespace {
           for (size_t i = 0, size = specializations.size(); i < size; ++i) {
             TypeResolutionOptions options(TypeResolverContext::InExpression);
             options |= TypeResolutionFlags::AllowUnboundGenerics;
-            auto tyLoc = TypeLoc{specializations[i]};
-            if (TypeChecker::validateType(
-                    tyLoc, TypeResolution::forContextual(CS.DC, options)))
+            auto result = TypeResolution::forContextual(CS.DC, options)
+                              .resolveType(specializations[i]);
+            if (result->hasError())
               return Type();
 
-            CS.addConstraint(ConstraintKind::Bind,
-                             typeVars[i], tyLoc.getType(),
+            CS.addConstraint(ConstraintKind::Bind, typeVars[i], result,
                              locator);
           }
 

lib/Sema/TypeCheckConstraints.cpp

@@ -1916,12 +1916,11 @@ Expr *PreCheckExpression::simplifyTypeConstructionWithLiteralArg(Expr *E) {
     TypeResolutionOptions options(TypeResolverContext::InExpression);
     options |= TypeResolutionFlags::AllowUnboundGenerics;
 
-    typeLoc = TypeLoc(typeExpr->getTypeRepr(), Type());
-    bool hadError = TypeChecker::validateType(
-        typeLoc, TypeResolution::forContextual(DC, options));
-
-    if (hadError)
+    auto result = TypeResolution::forContextual(DC, options)
+                      .resolveType(typeExpr->getTypeRepr());
+    if (result->hasError())
       return nullptr;
+    typeLoc = TypeLoc{typeExpr->getTypeRepr(), result};
   }
 
   if (!typeLoc.getType() || !typeLoc.getType()->getAnyNominal())

lib/Sema/TypeCheckDecl.cpp

@@ -1431,15 +1431,13 @@ static NominalTypeDecl *resolveSingleNominalTypeDecl(
     TypeResolutionFlags flags = TypeResolutionFlags(0)) {
   auto *TyR = new (Ctx) SimpleIdentTypeRepr(DeclNameLoc(loc),
                                             DeclNameRef(ident));
-  TypeLoc typeLoc = TypeLoc(TyR);
 
   TypeResolutionOptions options = TypeResolverContext::TypeAliasDecl;
   options |= flags;
-  if (TypeChecker::validateType(typeLoc,
-                                TypeResolution::forInterface(DC, options)))
+  auto result = TypeResolution::forInterface(DC, options).resolveType(TyR);
+  if (result->hasError())
     return nullptr;
-
-  return typeLoc.getType()->getAnyNominal();
+  return result->getAnyNominal();
 }
 
 bool swift::checkDesignatedTypes(OperatorDecl *OD,
@@ -1768,13 +1766,13 @@ UnderlyingTypeRequest::evaluate(Evaluator &evaluator,
     return ErrorType::get(typeAlias->getASTContext());
   }
 
-  auto underlyingLoc = TypeLoc(typeAlias->getUnderlyingTypeRepr());
-  if (TypeChecker::validateType(
-          underlyingLoc, TypeResolution::forInterface(typeAlias, options))) {
+  auto result = TypeResolution::forInterface(typeAlias, options)
+                    .resolveType(underlyingRepr);
+  if (result->hasError()) {
     typeAlias->setInvalid();
     return ErrorType::get(typeAlias->getASTContext());
   }
-  return underlyingLoc.getType();
+  return result;
 }
 
 /// Bind the given function declaration, which declares an operator, to the
@@ -2119,16 +2117,14 @@ static Type validateParameterType(ParamDecl *decl) {
                        TypeResolverContext::FunctionInput);
   options |= TypeResolutionFlags::Direct;
 
-  auto TL = TypeLoc(decl->getTypeRepr());
-
   auto &ctx = dc->getASTContext();
-  auto resolution = TypeResolution::forInterface(dc, options);
-  if (TypeChecker::validateType(TL, resolution)) {
+  auto Ty = TypeResolution::forInterface(dc, options)
+                .resolveType(decl->getTypeRepr());
+  if (Ty->hasError()) {
     decl->setInvalid();
     return ErrorType::get(ctx);
   }
 
-  Type Ty = TL.getType();
   if (decl->isVariadic()) {
     Ty = TypeChecker::getArraySliceType(decl->getStartLoc(), Ty);
     if (Ty.isNull()) {
@@ -2145,7 +2141,7 @@ static Type validateParameterType(ParamDecl *decl) {
 
     return Ty;
   }
-  return TL.getType();
+  return Ty;
 }
 
 Type

lib/Sema/TypeCheckGeneric.cpp

@@ -131,14 +131,11 @@ OpaqueResultTypeRequest::evaluate(Evaluator &evaluator,
   // Try to resolve the constraint repr. It should be some kind of existential
   // type.
   TypeResolutionOptions options(TypeResolverContext::GenericRequirement);
-  TypeLoc constraintTypeLoc(repr->getConstraint());
   // Pass along the error type if resolving the repr failed.
-  auto resolution = TypeResolution::forInterface(
-      dc, dc->getGenericSignatureOfContext(), options);
-  bool validationError =
-      TypeChecker::validateType(constraintTypeLoc, resolution);
-  auto constraintType = constraintTypeLoc.getType();
-  if (validationError)
+  auto constraintType = TypeResolution::forInterface(
+                            dc, dc->getGenericSignatureOfContext(), options)
+                            .resolveType(repr->getConstraint());
+  if (constraintType->hasError())
     return nullptr;
 
   // Error out if the constraint type isn't a class or existential type.