Merge pull request #24204 from xymus/structural-type-request

GSB: use a request for the structural type of type aliases

Author: xymus

include/swift/AST/ASTTypeIDZone.def

@@ -20,3 +20,4 @@ SWIFT_TYPEID(Type)
 SWIFT_TYPEID(PropertyDelegateBackingPropertyInfo)
 SWIFT_TYPEID(PropertyDelegateTypeInfo)
 SWIFT_TYPEID_NAMED(CustomAttr *, CustomAttr)
+SWIFT_TYPEID_NAMED(TypeAliasDecl *, TypeAliasDecl)

include/swift/AST/ASTTypeIDs.h

@@ -26,6 +26,7 @@ struct PropertyDelegateBackingPropertyInfo;
 struct PropertyDelegateTypeInfo;
 class Type;
 class VarDecl;
+class TypeAliasDecl;
 
 #define SWIFT_AST_TYPEID_ZONE 1
 

include/swift/AST/Decl.h

@@ -2896,6 +2896,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,30 @@ class PropertyDelegateBackingPropertyInfoRequest :
   void noteCycleStep(DiagnosticEngine &diags) const;
 };
 
+/// Retrieve the structural type of an alias type.
+class StructuralTypeRequest :
+    public SimpleRequest<StructuralTypeRequest,
+                         CacheKind::Cached,
+                         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;
+
+  // Caching.
+  bool isCached() const { return true; }
+};
+
 // 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

@@ -3451,6 +3451,15 @@ UnboundGenericType *TypeAliasDecl::getUnboundGenericType() const {
       parentTy, getASTContext());
 }
 
+Type TypeAliasDecl::getStructuralType() const {
+  assert(!getGenericParams());
+  
+  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/GenericSignatureBuilder.cpp

@@ -3805,13 +3805,12 @@ PotentialArchetype *GenericSignatureBuilder::realizePotentialArchetype(
   return pa;
 }
 
-static Type getStructuralType(TypeDecl *typeDecl, LazyResolver *resolver) {
+static Type getStructuralType(TypeDecl *typeDecl) {
   if (auto typealias = dyn_cast<TypeAliasDecl>(typeDecl)) {
-    // Resolve the underlying type, if we haven't done so yet.
-    if (!typealias->hasInterfaceType())
-      resolver->resolveDeclSignature(typealias);
+    if (auto resolved = typealias->getUnderlyingTypeLoc().getType())
+      return resolved;
 
-    return typealias->getUnderlyingTypeLoc().getType();
+    return typealias->getStructuralType();
   }
 
   return typeDecl->getDeclaredInterfaceType();
@@ -3826,7 +3825,7 @@ static Type substituteConcreteType(GenericSignatureBuilder &builder,
 
   // Form an unsubstituted type referring to the given type declaration,
   // for use in an inferred same-type requirement.
-  auto type = getStructuralType(concreteDecl, builder.getLazyResolver());
+  auto type = getStructuralType(concreteDecl);
   if (!type)
     return Type();
 
@@ -4164,8 +4163,14 @@ ConstraintResult GenericSignatureBuilder::expandConformanceRequirement(
       if (inheritedProto == proto) return TypeWalker::Action::Continue;
 
       for (auto req : inheritedProto->getMembers()) {
-        if (auto typeReq = dyn_cast<TypeDecl>(req))
+        if (auto typeReq = dyn_cast<TypeDecl>(req)) {
+          // Ignore generic types
+          if (auto genReq = dyn_cast<GenericTypeDecl>(req))
+            if (genReq->getGenericParams())
+              continue;
+
           inheritedTypeDecls[typeReq->getFullName()].push_back(typeReq);
+        }
       }
       return TypeWalker::Action::Continue;
     });
@@ -4228,10 +4233,10 @@ ConstraintResult GenericSignatureBuilder::expandConformanceRequirement(
   // An inferred same-type requirement between the two type declarations
   // within this protocol or a protocol it inherits.
   auto addInferredSameTypeReq = [&](TypeDecl *first, TypeDecl *second) {
-    Type firstType = getStructuralType(first, getLazyResolver());
+    Type firstType = getStructuralType(first);
     if (!firstType) return;
 
-    Type secondType = getStructuralType(second, getLazyResolver());
+    Type secondType = getStructuralType(second);
     if (!secondType) return;
 
     auto inferredSameTypeSource =

lib/AST/TypeCheckRequests.cpp

@@ -652,3 +652,15 @@ 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);
+}

lib/Sema/TypeCheckGeneric.cpp

@@ -1008,3 +1008,17 @@ RequirementRequest::evaluate(Evaluator &evaluator,
   }
   llvm_unreachable("unhandled kind");
 }
+
+llvm::Expected<Type>
+swift::StructuralTypeRequest::evaluate(Evaluator &evaluator,
+                                       TypeAliasDecl *D) const {
+  TypeResolutionOptions options(TypeResolverContext::TypeAliasDecl);
+  if (!D->getDeclContext()->isCascadingContextForLookup(
+        /*functionsAreNonCascading*/true)) {
+    options |= TypeResolutionFlags::KnownNonCascadingDependency;
+  }
+
+  auto typeRepr = D->getUnderlyingTypeLoc().getTypeRepr();
+  auto resolution = TypeResolution::forStructural(D);
+  return resolution.resolveType(typeRepr, options);
+}

validation-test/compiler_crashers/28861-gpdecl-getdepth-generictypeparamdecl-invaliddepth-parameter-hasnt-been-validated.swift renamed to validation-test/compiler_crashers_fixed/28861-gpdecl-getdepth-generictypeparamdecl-invaliddepth-parameter-hasnt-been-validated.swift

@@ -6,6 +6,6 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 
 // REQUIRES: asserts
-// RUN: not --crash %target-swift-frontend %s -emit-ir
+// RUN: not %target-swift-frontend %s -emit-ir
 protocol
 P{protocol A:P{{}}typealias e:A{}class a<a{}class a