Sema: intro a request evaluator to get the structural type of type aliases

This request evaluator doesn't rely on the previous execution of
a compilation phase but it caches the result in a compatible way.

Author: xymus

include/swift/AST/Decl.h

@@ -2893,6 +2893,8 @@ class TypeAliasDecl : public GenericTypeDecl {
   /// For generic typealiases, return the unbound generic type.
   UnboundGenericType *getUnboundGenericType() const;
 
+  Type getStructuralType() const;
+
   bool isCompatibilityAlias() const {
     return Bits.TypeAliasDecl.IsCompatibilityAlias;
   }

include/swift/AST/TypeCheckRequests.h

@@ -33,6 +33,7 @@ class GenericParamList;
 struct PropertyDelegateBackingPropertyInfo;
 class RequirementRepr;
 class SpecializeAttr;
+class TypeAliasDecl;
 struct TypeLoc;
 
 /// Display a nominal type or extension thereof.
@@ -547,6 +548,33 @@ class PropertyDelegateBackingPropertyInfoRequest :
   void noteCycleStep(DiagnosticEngine &diags) const;
 };
 
+/// Retrieve the structural type of an alias type.
+class StructuralTypeRequest :
+    public SimpleRequest<StructuralTypeRequest,
+                         CacheKind::SeparatelyCached,
+                         Type,
+                         TypeAliasDecl*> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<Type> evaluate(Evaluator &eval, TypeAliasDecl *d) const;
+
+public:
+  // Cycle handling.
+  void diagnoseCycle(DiagnosticEngine &diags) const;
+  void noteCycleStep(DiagnosticEngine &diags) const;
+
+  // Separate caching.
+  bool isCached() const { return true; };
+  Optional<Type> getCachedResult() const;
+  void cacheResult(Type value) const;
+};
+
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -23,6 +23,7 @@ SWIFT_TYPEID(IsFinalRequest)
 SWIFT_TYPEID(IsDynamicRequest)
 SWIFT_TYPEID(RequirementRequest)
 SWIFT_TYPEID(USRGenerationRequest)
+SWIFT_TYPEID(StructuralTypeRequest)
 SWIFT_TYPEID(DefaultTypeRequest)
 SWIFT_TYPEID(MangleLocalTypeDeclRequest)
 SWIFT_TYPEID(PropertyDelegateTypeInfoRequest)

lib/AST/Decl.cpp

@@ -3436,6 +3436,13 @@ UnboundGenericType *TypeAliasDecl::getUnboundGenericType() const {
       parentTy, getASTContext());
 }
 
+Type TypeAliasDecl::getStructuralType() const {
+  auto &context = getASTContext();
+  return evaluateOrDefault(context.evaluator,
+                           StructuralTypeRequest { const_cast<TypeAliasDecl *>(this) },
+                           Type());
+}
+
 Type AbstractTypeParamDecl::getSuperclass() const {
   auto *genericEnv = getDeclContext()->getGenericEnvironmentOfContext();
   assert(genericEnv != nullptr && "Too much circularity");

lib/AST/TypeCheckRequests.cpp

@@ -660,3 +660,27 @@ void swift::simple_display(llvm::raw_ostream &out, const Type &type) {
   else
     out << "null";
 }
+
+//----------------------------------------------------------------------------//
+// StructuralTypeRequest.
+//----------------------------------------------------------------------------//
+
+void StructuralTypeRequest::diagnoseCycle(DiagnosticEngine &diags) const {
+  diags.diagnose(SourceLoc(), diag::circular_reference);
+}
+
+void StructuralTypeRequest::noteCycleStep(DiagnosticEngine &diags) const {
+  diags.diagnose(SourceLoc(), diag::circular_reference_through);
+}
+
+Optional<Type> StructuralTypeRequest::getCachedResult() const {
+  auto decl = std::get<0>(getStorage());
+  if (decl->getUnderlyingTypeLoc().getType())
+    return decl->getUnderlyingTypeLoc().getType();
+  return None;
+}
+
+void StructuralTypeRequest::cacheResult(Type value) const {
+  auto decl = std::get<0>(getStorage());
+  decl->getUnderlyingTypeLoc().setType(value);
+}

lib/Sema/TypeCheckGeneric.cpp

@@ -1008,3 +1008,11 @@ RequirementRequest::evaluate(Evaluator &evaluator,
   }
   llvm_unreachable("unhandled kind");
 }
+
+llvm::Expected<Type>
+swift::StructuralTypeRequest::evaluate(Evaluator &evaluator,
+                                       TypeAliasDecl *D) const {
+  auto typeRepr = D->getUnderlyingTypeLoc().getTypeRepr();
+  auto resolution = TypeResolution::forStructural(D);
+  return resolution.resolveType(typeRepr, None);
+}