Define ResolveTypeRequest

Author: CodaFi

include/swift/AST/DiagnosticsCommon.def

@@ -152,6 +152,9 @@ WARNING(warn_property_wrapper_module_scope,none,
         "wrapper %0; please qualify the reference with %1",
         (DeclNameRef, Identifier))
 
+NOTE(circular_type_resolution_note,none,
+     "while resolving type %0", (TypeRepr *))
+
 //------------------------------------------------------------------------------
 // MARK: Cross-import overlay loading diagnostics
 //------------------------------------------------------------------------------

include/swift/AST/TypeCheckRequests.h

@@ -50,6 +50,7 @@ class TrailingWhereClause;
 class TypeAliasDecl;
 class TypeLoc;
 class Witness;
+class TypeResolution;
 struct TypeWitnessAndDecl;
 class ValueDecl;
 enum class OpaqueReadOwnership: uint8_t;
@@ -2406,6 +2407,28 @@ class HasImplementationOnlyImportsRequest
   bool isCached() const { return true; }
 };
 
+class ResolveTypeRequest
+    : public SimpleRequest<ResolveTypeRequest,
+                           Type(TypeResolution *, TypeRepr *),
+                           RequestFlags::Uncached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+public:
+  // Cycle handling.
+  void noteCycleStep(DiagnosticEngine &diags) const;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  Type evaluate(Evaluator &evaluator, TypeResolution *resolution,
+                TypeRepr *repr) const;
+};
+
+void simple_display(llvm::raw_ostream &out, const TypeResolution *resolution);
+SourceLoc extractNearestSourceLoc(const TypeRepr *repr);
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -226,6 +226,8 @@ SWIFT_REQUEST(TypeChecker, ResolveImplicitMemberRequest,
 SWIFT_REQUEST(TypeChecker, ResolveTypeEraserTypeRequest,
               Type(ProtocolDecl *, TypeEraserAttr *),
               SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, ResolveTypeRequest,
+              Type (TypeResolution *, TypeRepr *), Uncached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, SPIGroupsRequest,
               llvm::ArrayRef<Identifier>(Decl *),
               Cached, NoLocationInfo)

lib/AST/TypeCheckRequests.cpp

@@ -1501,3 +1501,23 @@ void swift::simple_display(llvm::raw_ostream &out,
   out << "implicit import of ";
   simple_display(out, import.Module);
 }
+
+//----------------------------------------------------------------------------//
+// ResolveTypeRequest computation.
+//----------------------------------------------------------------------------//
+
+void ResolveTypeRequest::noteCycleStep(DiagnosticEngine &diags) const {
+  auto *repr = std::get<1>(getStorage());
+  diags.diagnose(repr->getLoc(), diag::circular_type_resolution_note, repr);
+}
+
+void swift::simple_display(llvm::raw_ostream &out,
+                           const TypeResolution *resolution) {
+  out << "while resolving type ";
+}
+
+SourceLoc swift::extractNearestSourceLoc(const TypeRepr *repr) {
+  if (!repr)
+    return SourceLoc();
+  return repr->getLoc();
+}

lib/Sema/TypeCheckType.cpp

@@ -21,7 +21,6 @@
 #include "TypeCheckType.h"
 #include "TypoCorrection.h"
 
-#include "swift/Strings.h"
 #include "swift/AST/ASTDemangler.h"
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/ASTWalker.h"
@@ -35,12 +34,14 @@
 #include "swift/AST/PrettyStackTrace.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/SourceFile.h"
+#include "swift/AST/TypeCheckRequests.h"
 #include "swift/AST/TypeLoc.h"
 #include "swift/AST/TypeResolutionStage.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/Statistic.h"
 #include "swift/Basic/StringExtras.h"
 #include "swift/ClangImporter/ClangImporter.h"
+#include "swift/Strings.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
@@ -1748,7 +1749,7 @@ bool TypeChecker::validateType(TypeLoc &Loc, TypeResolution resolution) {
   if (auto *Stats = resolution.getASTContext().Stats)
     Stats->getFrontendCounters().NumTypesValidated++;
 
-  Type type = resolution.resolveType(Loc.getTypeRepr());
+  auto type = resolution.resolveType(Loc.getTypeRepr());
   Loc.setType(type);
 
   return type->hasError();
@@ -1871,34 +1872,39 @@ namespace {
 
 Type TypeResolution::resolveType(TypeRepr *TyR) {
   auto &ctx = getASTContext();
-  FrontendStatsTracer StatsTracer(ctx.Stats,
-                                  "resolve-type", TyR);
-  PrettyStackTraceTypeRepr stackTrace(ctx, "resolving", TyR);
-
-  TypeResolver typeResolver(*this);
-
-  auto result = typeResolver.resolveType(TyR, getOptions());
+  auto Ty =
+      evaluateOrDefault(ctx.evaluator, ResolveTypeRequest{this, TyR}, Type());
+  if (!Ty)
+    return ErrorType::get(ctx);
+  return Ty;
+}
 
-  if (result) {
-    // If we resolved down to an error, make sure to mark the typeRepr as invalid
-    // so we don't produce a redundant diagnostic.
-    if (result->hasError()) {
-      TyR->setInvalid();
-      return result;
-    }
+Type ResolveTypeRequest::evaluate(Evaluator &evaluator,
+                                  TypeResolution *resolution,
+                                  TypeRepr *TyR) const {
+  const auto options = resolution->getOptions();
+  auto &ctx = resolution->getASTContext();
+  auto result =
+      TypeResolver(*resolution).resolveType(TyR, resolution->getOptions());
 
-    auto loc = TyR->getLoc();
+  // If we resolved down to an error, make sure to mark the typeRepr as invalid
+  // so we don't produce a redundant diagnostic.
+  if (result->hasError()) {
+    TyR->setInvalid();
+    return result;
+  }
 
-    if (options.contains(TypeResolutionFlags::SILType)
-        && !result->isLegalSILType()) {
-      ctx.Diags.diagnose(loc, diag::illegal_sil_type, result);
-      return ErrorType::get(ctx);
-    }
+  auto loc = TyR->getLoc();
 
-    if (validateAutoClosureAttributeUse(ctx.Diags, TyR, result, options))
-      return ErrorType::get(ctx);
+  if (options.contains(TypeResolutionFlags::SILType)
+      && !result->isLegalSILType()) {
+    ctx.Diags.diagnose(loc, diag::illegal_sil_type, result);
+    return ErrorType::get(ctx);
   }
 
+  if (validateAutoClosureAttributeUse(ctx.Diags, TyR, result, options))
+    return ErrorType::get(ctx);
+
   return result;
 }
 

test/CircularReferences/global_typealias.swift

@@ -1,6 +1,6 @@
 // RUN: %target-typecheck-verify-swift
 
-typealias A = B // expected-error {{type alias 'A' references itself}} expected-note {{through reference here}}
-typealias C = D // expected-note {{through reference here}} expected-note {{through reference here}}
-typealias D = (A, Int) // expected-note {{through reference here}} expected-note {{through reference here}}
-typealias B = C // expected-note {{through reference here}} expected-note {{through reference here}}
+typealias A = B // expected-error {{type alias 'A' references itself}} expected-note {{while resolving type 'B'}} expected-note {{through reference here}}
+typealias C = D // expected-note {{through reference here}} expected-note {{while resolving type 'D'}} expected-note {{through reference here}}
+typealias D = (A, Int) // expected-note {{through reference here}} expected-note {{while resolving type '(A, Int)'}} expected-note {{through reference here}}
+typealias B = C // expected-note {{through reference here}} expected-note {{while resolving type 'C'}} expected-note {{through reference here}}

test/Generics/generic_types.swift

@@ -231,7 +231,8 @@ class Bottom<T : Bottom<Top>> {}
 // expected-error@-1 {{generic class 'Bottom' references itself}}
 // expected-note@-2 {{type declared here}}
 // expected-error@-3 {{circular reference}}
-// expected-note@-4 {{through reference here}}
+// expected-note@-4 {{while resolving type 'Bottom<Top>'}}
+// expected-note@-5 {{through reference here}}
 
 // Invalid inheritance clause
 

test/Sema/circular_decl_checking.swift

@@ -66,7 +66,7 @@ class X {
 // <rdar://problem/17144076> recursive typealias causes a segfault in the type checker
 struct SomeStruct<A> {
   typealias A = A // this is OK now -- the underlying type is the generic parameter 'A'
-  typealias B = B // expected-error {{type alias 'B' references itself}}
+  typealias B = B // expected-error {{type alias 'B' references itself}} expected-note {{while resolving type 'B'}}
 }
 
 // <rdar://problem/27680407> Infinite recursion when using fully-qualified associatedtype name that has not been defined with typealias

test/Sema/diag_typealias.swift

@@ -2,4 +2,4 @@
 
 struct S {}
 
-typealias S = S // expected-error {{type alias 'S' references itself}} expected-note {{through reference here}}
+typealias S = S // expected-error {{type alias 'S' references itself}} expected-note {{while resolving type 'S'}} expected-note {{through reference here}}

test/decl/circularity.swift

@@ -71,7 +71,8 @@ class C1 {
 class C2: C1, P {
     override func run(a: A) {}
     // expected-error@-1 {{circular reference}}
-    // expected-note@-2 2{{through reference here}}
+    // expected-note@-2 {{while resolving type 'A'}}
+    // expected-note@-3 2{{through reference here}}
 }
 
 // Another crash to the above
@@ -98,7 +99,8 @@ class C4 {
 
 class D4 : C4, P1 { // expected-note 2 {{through reference here}}
   required init(x: X) { // expected-error {{circular reference}}
-    // expected-note@-1 2{{through reference here}}
+    // expected-note@-1 {{while resolving type 'X'}}
+    // expected-note@-2 2{{through reference here}}
     super.init(x: x)
   }
 }