Sema: Lazily validate protocol members

Author: slavapestov

lib/Sema/CSApply.cpp

@@ -846,7 +846,9 @@ namespace {
       // Class members might be virtually dispatched, so we need to know
       // the full layout of the class.
       if (auto *classDecl = dyn_cast<ClassDecl>(member->getDeclContext()))
-        tc.requestClassLayout(classDecl);
+        tc.requestNominalLayout(classDecl);
+      if (auto *protocolDecl = dyn_cast<ProtocolDecl>(member->getDeclContext()))
+        tc.requestNominalLayout(protocolDecl);
 
       auto refTy = solution.simplifyType(openedFullType);
 

lib/Sema/TypeCheckDecl.cpp

@@ -6907,7 +6907,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         if (auto nominal = extendedTy->getAnyNominal()) {
           TC.validateDecl(nominal);
           if (auto *classDecl = dyn_cast<ClassDecl>(nominal))
-            TC.requestClassLayout(classDecl);
+            TC.requestNominalLayout(classDecl);
 
           // Check the raw values of an enum, since we might synthesize
           // RawRepresentable while checking conformances on this extension.
@@ -7611,7 +7611,14 @@ void TypeChecker::validateDecl(ValueDecl *D) {
       markAsObjC(*this, proto, isObjC);
     }
 
-    DeclsToFinalize.insert(proto);
+    // FIXME: IRGen likes to emit @objc protocol descriptors even if the
+    // protocol comes from a different module or translation unit.
+    //
+    // It would be nice if it didn't have to do that, then we could remove
+    // this case.
+    if (proto->isObjC())
+      requestNominalLayout(proto);
+
     break;
   }
 
@@ -7797,8 +7804,17 @@ void TypeChecker::validateDeclForNameLookup(ValueDecl *D) {
       validateDeclForNameLookup(ATD);
     }
 
-    // Make sure the protocol is fully validated by the end of Sema.
-    DeclsToFinalize.insert(proto);
+    // Compute the requirement signature later to avoid circularity.
+    DelayedRequirementSignatures.insert(proto);
+
+    // FIXME: IRGen likes to emit @objc protocol descriptors even if the
+    // protocol comes from a different module or translation unit.
+    //
+    // It would be nice if it didn't have to do that, then we could remove
+    // this case.
+    if (proto->isObjC())
+      requestNominalLayout(proto);
+
     break;
   }
   case DeclKind::AssociatedType: {
@@ -7888,22 +7904,22 @@ static bool shouldValidateMemberDuringFinalization(NominalTypeDecl *nominal,
   return false;
 }
 
-void TypeChecker::requestClassLayout(ClassDecl *classDecl) {
-  if (classDecl->hasValidatedLayout())
+void TypeChecker::requestNominalLayout(NominalTypeDecl *nominalDecl) {
+  if (nominalDecl->hasValidatedLayout())
     return;
 
-  classDecl->setHasValidatedLayout();
+  nominalDecl->setHasValidatedLayout();
 
-  if (isa<SourceFile>(classDecl->getModuleScopeContext()))
-    DeclsToFinalize.insert(classDecl);
+  if (isa<SourceFile>(nominalDecl->getModuleScopeContext()))
+    DeclsToFinalize.insert(nominalDecl);
 }
 
 void TypeChecker::requestSuperclassLayout(ClassDecl *classDecl) {
   auto superclassTy = classDecl->getSuperclass();
   if (superclassTy) {
     auto *superclassDecl = superclassTy->getClassOrBoundGenericClass();
     if (superclassDecl)
-      requestClassLayout(superclassDecl);
+      requestNominalLayout(superclassDecl);
   }
 }
 

lib/Sema/TypeChecker.cpp

@@ -447,6 +447,16 @@ static void typeCheckFunctionsAndExternalDecls(TypeChecker &TC) {
       llvm_unreachable("Unhandled external definition kind");
     }
 
+    // Complete any protocol requirement signatures that were delayed
+    // because the protocol was validated via validateDeclForNameLookup().
+    while (!TC.DelayedRequirementSignatures.empty()) {
+      auto decl = TC.DelayedRequirementSignatures.pop_back_val();
+      if (decl->isInvalid() || TC.Context.hadError())
+        continue;
+
+      TC.validateDecl(decl);
+    }
+
     // Validate any referenced declarations for SIL's purposes.
     // Note: if we ever start putting extension members in vtables, we'll need
     // to validate those members too.
@@ -470,6 +480,7 @@ static void typeCheckFunctionsAndExternalDecls(TypeChecker &TC) {
   } while (currentFunctionIdx < TC.definedFunctions.size() ||
            currentExternalDef < TC.Context.ExternalDefinitions.size() ||
            !TC.DeclsToFinalize.empty() ||
+           !TC.DelayedRequirementSignatures.empty() ||
            !TC.UsedConformances.empty());
 
   // FIXME: Horrible hack. Store this somewhere more appropriate.

lib/Sema/TypeChecker.h

@@ -715,6 +715,11 @@ class TypeChecker final : public LazyResolver {
   /// we can hand them off to SILGen etc.
   llvm::SetVector<ValueDecl *> DeclsToFinalize;
 
+  /// The list of protocols that need their requirement signatures computed,
+  /// because they were first validated by validateDeclForNameLookup(),
+  /// which skips this step.
+  llvm::SetVector<ProtocolDecl *> DelayedRequirementSignatures;
+
   /// The list of types whose circularity checks were delayed.
   SmallVector<NominalTypeDecl*, 8> DelayedCircularityChecks;
 
@@ -1068,7 +1073,7 @@ class TypeChecker final : public LazyResolver {
 
   /// Request that the given class needs to have all members validated
   /// after everything in the translation unit has been processed.
-  void requestClassLayout(ClassDecl *classDecl);
+  void requestNominalLayout(NominalTypeDecl *nominalDecl);
 
   /// Request that the superclass of the given class, if any, needs to have
   /// all members validated after everything in the translation unit has

validation-test/compiler_scale/class_members.gyb

@@ -14,6 +14,4 @@ class Class${N} {
     static var prop = 0
     subscript(n: Int) -> Int { return 0 }
 % end
-
-    struct Nested {}
 }

validation-test/compiler_scale/protocol_members.gyb

@@ -0,0 +1,17 @@
+// RUN: %scale-test --sum-multi --typecheck --begin 5 --end 16 --step 5 --select validateDecl %s
+// REQUIRES: OS=macosx
+// REQUIRES: asserts
+
+protocol Protocol${N} {
+% if int(N) > 1:
+    func method(_: Protocol${int(N)-1})
+    var prop: Protocol${int(N)-1} { get set }
+    static var prop: Protocol${int(N)-1} { get set }
+    subscript(n: Int) -> Protocol${int(N)-1} { get set }
+% else:
+    func method()
+    var prop: Int { get set }
+    static var prop: Int { get set }
+    subscript(n: Int) -> Int { get set }
+% end
+}

validation-test/compiler_scale/struct_members.gyb

@@ -14,6 +14,4 @@ struct Struct${N} {
     static var prop = 0
     subscript(n: Int) -> Int { return 0 }
 % end
-
-    struct Nested {}
 }