Iterative type checker: compute inherited protocols of a protocol.

Introduce a type check request for computing inherited protocols and
start using it in a few places.

Swift SVN r32562

Author: DougGregor

include/swift/Sema/IterativeTypeChecker.h

@@ -20,6 +20,7 @@
 #define SWIFT_SEMA_ITERATIVE_TYPE_CHECKER_H
 
 #include "swift/Sema/TypeCheckRequest.h"
+#include "swift/AST/DiagnosticEngine.h"
 #include "swift/Basic/LLVM.h"
 #include "llvm/ADT/STLExtras.h"
 
@@ -54,6 +55,15 @@ class IterativeTypeChecker {
 public:
   IterativeTypeChecker(TypeChecker &tc) : TC(tc) { }
 
+  ASTContext &getASTContext() const;
+
+  DiagnosticEngine &getDiags() const;
+
+  template<typename ...ArgTypes>
+  InFlightDiagnostic diagnose(ArgTypes &&...Args) {
+    return getDiags().diagnose(std::forward<ArgTypes>(Args)...);
+  }
+
   /// Determine whether the given request has already been satisfied.
   bool isSatisfied(TypeCheckRequest request);
 

include/swift/Sema/TypeCheckRequest.h

@@ -28,6 +28,7 @@ namespace swift {
 class ClassDecl;
 class EnumDecl;
 class ExtensionDecl;
+class ProtocolDecl;
 class TypeDecl;
 
 /// A request to the type checker to compute some particular kind of

include/swift/Sema/TypeCheckRequestKinds.def

@@ -37,6 +37,7 @@
 TYPE_CHECK_REQUEST_PAYLOAD(Class, ClassDecl *)
 TYPE_CHECK_REQUEST_PAYLOAD(Enum, EnumDecl *)
 TYPE_CHECK_REQUEST_PAYLOAD(InheritedClauseEntry, std::pair<llvm::PointerUnion<TypeDecl *, ExtensionDecl *>, unsigned>)
+TYPE_CHECK_REQUEST_PAYLOAD(Protocol, ProtocolDecl *)
 
 /// Perform type checking on an entry in the inherited clause of a
 /// type or extension.
@@ -48,5 +49,8 @@ TYPE_CHECK_REQUEST(TypeCheckSuperclass, Class)
 /// Perform type checking on the raw type of a particular enum.
 TYPE_CHECK_REQUEST(TypeCheckRawType, Enum)
 
+/// Compute the set of inherited protocols for a given protocl
+TYPE_CHECK_REQUEST(InheritedProtocols, Protocol)
+
 #undef TYPE_CHECK_REQUEST_PAYLOAD
 #undef TYPE_CHECK_REQUEST

lib/AST/Decl.cpp

@@ -1722,7 +1722,10 @@ Type ValueDecl::getInterfaceType() const {
   if (auto assocType = dyn_cast<AssociatedTypeDecl>(this)) {
     auto proto = cast<ProtocolDecl>(getDeclContext());
     (void)proto->getType(); // make sure we've computed the type.
-    auto selfTy = proto->getGenericParamTypes().back();
+    // FIXME: the generic parameter types list should never be empty.
+    auto selfTy = proto->getGenericParamTypes().empty()
+                    ? proto->getProtocolSelf()->getType()
+                    : proto->getGenericParamTypes().back();
     auto &ctx = getASTContext();
     InterfaceTy = DependentMemberType::get(
                     selfTy,

lib/Sema/ITCDecl.cpp

@@ -25,7 +25,8 @@ using namespace swift;
 //----------------------------------------------------------------------------//
 // Inheritance clause handling
 //----------------------------------------------------------------------------//
-static std::tuple<TypeResolutionOptions, DeclContext *, MutableArrayRef<TypeLoc>>
+static std::tuple<TypeResolutionOptions, DeclContext *,
+                  MutableArrayRef<TypeLoc>>
 decomposeInheritedClauseDecl(
   llvm::PointerUnion<TypeDecl *, ExtensionDecl *> decl) {
   TypeResolutionOptions options;
@@ -110,7 +111,7 @@ void IterativeTypeChecker::satisfyTypeCheckInheritedClauseEntry(
   // FIXME: Recursion into existing type checker.
   PartialGenericTypeToArchetypeResolver resolver(TC);
   if (TC.validateType(*inherited, dc, options, &resolver)) {
-    inherited->setInvalidType(TC.Context);
+    inherited->setInvalidType(getASTContext());
   }
 }
 
@@ -212,3 +213,71 @@ void IterativeTypeChecker::satisfyTypeCheckRawType(EnumDecl *enumDecl) {
   // Set the raw type.
   enumDecl->setRawType(rawType);
 }
+
+//----------------------------------------------------------------------------//
+// Inherited protocols
+//----------------------------------------------------------------------------//
+bool IterativeTypeChecker::isInheritedProtocolsSatisfied(ProtocolDecl *payload){
+  return payload->isInheritedProtocolsValid();
+}
+
+void IterativeTypeChecker::enumerateDependenciesOfInheritedProtocols(
+       ProtocolDecl *payload,
+       llvm::function_ref<void(TypeCheckRequest)> fn) {
+  // Computing the set of inherited protocols depends on the complete
+  // inheritance clause.
+  // FIXME: Technically, we only need very basic name binding.
+  auto inheritedClause = payload->getInherited();
+  for (unsigned i = 0, n = inheritedClause.size(); i != n; ++i) {
+    TypeLoc &inherited = inheritedClause[i];
+
+    // If this inherited type has not been resolved, we depend on it.
+    if (!inherited.getType()) {
+      fn(TypeCheckRequest(TypeCheckRequest::TypeCheckInheritedClauseEntry,
+                          { payload, i }));
+    }
+  }
+}
+
+void IterativeTypeChecker::satisfyInheritedProtocols(ProtocolDecl *protocol) {
+  // Gather all of the existential types in the inherited list.
+  // Loop through the inheritance clause looking for a non-existential
+  // nominal type.
+  llvm::SmallSetVector<ProtocolDecl *, 4> allProtocols;
+  for (const auto &inherited : protocol->getInherited()) {
+    if (!inherited.getType()) continue;
+
+    // Collect existential types.
+    // FIXME: We'd prefer to keep what the user wrote here.
+    SmallVector<ProtocolDecl *, 4> protocols;
+    if (inherited.getType()->isExistentialType(protocols)) {
+      allProtocols.insert(protocols.begin(), protocols.end());
+    }
+  }
+
+  // FIXME: Hack to deal with recursion elsewhere.
+  if (protocol->isInheritedProtocolsValid())
+    return;
+
+  // Check for circular inheritance.
+  // FIXME: The diagnostics here should be improved.
+  bool diagnosedCircularity = false;
+  for (unsigned i = 0, n = allProtocols.size(); i != n; /*in loop*/) {
+    if (allProtocols[i] == protocol ||
+        allProtocols[i]->inheritsFrom(protocol)) {
+      if (!diagnosedCircularity) {
+        diagnose(protocol,
+                 diag::circular_protocol_def, protocol->getName().str());
+        diagnosedCircularity = true;
+      }
+
+      allProtocols.remove(allProtocols[i]);
+      --n;
+      continue;
+    }
+
+    ++i;
+  }
+
+  protocol->setInheritedProtocols(getASTContext().AllocateCopy(allProtocols));
+}

lib/Sema/IterativeTypeChecker.cpp

@@ -16,10 +16,19 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "TypeChecker.h"
 #include "swift/Sema/IterativeTypeChecker.h"
 #include "swift/AST/Decl.h"
 using namespace swift;
 
+ASTContext &IterativeTypeChecker::getASTContext() const {
+  return TC.Context;
+}
+
+DiagnosticEngine &IterativeTypeChecker::getDiags() const {
+  return getASTContext().Diags;
+}
+
 /// Determine whether the given request has already been satisfied.
 bool IterativeTypeChecker::isSatisfied(TypeCheckRequest request) {
   switch (request.getKind()) {

lib/Sema/TypeCheckDecl.cpp

@@ -3171,9 +3171,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       // need to propagate recursive properties now.
       TAD->getAliasType()->setRecursiveProperties(
                        TAD->getUnderlyingType()->getRecursiveProperties());
-
-      if (!isa<ProtocolDecl>(TAD->getDeclContext()))
-        TC.checkInheritanceClause(TAD);
     }
 
     if (IsSecondPass)
@@ -3537,6 +3534,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       checkAccessibility(TC, PD);
       for (auto member : PD->getMembers())
         checkAccessibility(TC, member);
+      TC.checkInheritanceClause(PD);
       return;
     }
 
@@ -5871,7 +5869,10 @@ void TypeChecker::validateDecl(ValueDecl *D, bool resolveTypeParams) {
     checkGenericParamList(&builder, gp, proto->getDeclContext());
     finalizeGenericParamList(builder, gp, proto, *this);
 
-    checkInheritanceClause(D);
+    // Record inherited protocols.
+    IterativeTypeChecker ITC(*this);
+    ITC.satisfy(TypeCheckRequest(TypeCheckRequest::InheritedProtocols, proto));
+
     validateAttributes(*this, D);
 
     // Set the underlying type of each of the associated types to the
@@ -6362,7 +6363,8 @@ void TypeChecker::validateExtension(ExtensionDecl *ext) {
 
 ArrayRef<ProtocolDecl *>
 TypeChecker::getDirectConformsTo(ProtocolDecl *proto) {
-  checkInheritanceClause(proto);
+  IterativeTypeChecker ITC(*this);
+  ITC.satisfy(TypeCheckRequest(TypeCheckRequest::InheritedProtocols, proto));
   return proto->getInheritedProtocols(nullptr);
 }
 

validation-test/compiler_crashers/1843-llvm-bitstreamcursor-readrecord.swift renamed to validation-test/compiler_crashers_fixed/1843-llvm-bitstreamcursor-readrecord.swift

@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)

validation-test/compiler_crashers/26570-swift-valuedecl-getinterfacetype.swift renamed to validation-test/compiler_crashers_fixed/26570-swift-valuedecl-getinterfacetype.swift

@@ -1,4 +1,4 @@
-// RUN: not --crash %target-swift-frontend %s -parse
+// RUN: not %target-swift-frontend %s -parse
 // Distributed under the terms of the MIT license
 // Test case submitted to project by https://github.com/practicalswift (practicalswift)
 // Test case found by fuzzing