Sema: Simplify validateDecl()

Remove the early return in the case where one of our parent contexts was
being validated, and replace it with a simpler check that is only
performed in some callers related to associated type inference; we want
to bail out in one specific case only, which is that the declaration
is inside an extension whose generic signature is in the process of
being computed.

Author: slavapestov

include/swift/AST/Decl.h

@@ -857,17 +857,6 @@ class alignas(1 << DeclAlignInBits) Decl {
     return getValidationState() > ValidationState::Unchecked;
   }
 
-  /// Manually indicate that validation is complete for the declaration. For
-  /// example: during importing, code synthesis, or derived conformances.
-  ///
-  /// For normal code validation, please use DeclValidationRAII instead.
-  ///
-  /// FIXME -- Everything should use DeclValidationRAII instead of this.
-  void setValidationToChecked() {
-    if (!isBeingValidated())
-      Bits.Decl.ValidationState = unsigned(ValidationState::Checked);
-  }
-
   bool escapedFromIfConfig() const {
     return Bits.Decl.EscapedFromIfConfig;
   }

lib/AST/Decl.cpp

@@ -2706,7 +2706,7 @@ bool ValueDecl::hasInterfaceType() const {
 }
 
 bool ValueDecl::isRecursiveValidation() const {
-  if (hasValidationStarted() || !hasInterfaceType())
+  if (hasValidationStarted() && !hasInterfaceType())
     return true;
 
   if (auto *vd = dyn_cast<VarDecl>(this))

lib/AST/NameLookup.cpp

@@ -487,9 +487,9 @@ static void recordShadowedDecls(ArrayRef<ValueDecl *> decls,
       // If the decl is currently being validated, this is likely a recursive
       // reference and we'll want to skip ahead so as to avoid having its type
       // attempt to desugar itself.
-      auto ifaceType = decl->getInterfaceType();
-      if (!ifaceType)
+      if (decl->isRecursiveValidation())
         continue;
+      auto ifaceType = decl->getInterfaceType();
 
       // FIXME: the canonical type makes a poor signature, because we don't
       // canonicalize away default arguments.

lib/Sema/TypeCheckDecl.cpp

@@ -3226,10 +3226,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       return;
     }
 
-    // Validate the nominal type declaration being extended.
-    (void)nominal->getInterfaceType();
-    (void)ED->getGenericSignature();
-    ED->setValidationToChecked();
+    // Produce any diagnostics for the generic signature.
+    (void) ED->getGenericSignature();
 
     if (extType && !extType->hasError()) {
       // The first condition catches syntactic forms like
@@ -3865,54 +3863,14 @@ void TypeChecker::validateDecl(ValueDecl *D) {
   // Handling validation failure due to re-entrancy is left
   // up to the caller, who must call hasInterfaceType() to
   // check that validateDecl() returned a fully-formed decl.
-  if (D->hasValidationStarted() || D->hasInterfaceType())
+  if (D->isBeingValidated() || D->hasInterfaceType())
     return;
 
-  // FIXME: It would be nicer if Sema would always synthesize fully-typechecked
-  // declarations, but for now, you can make an imported type conform to a
-  // protocol with property requirements, which requires synthesizing getters
-  // and setters, etc.
-  if (!isa<VarDecl>(D) && !isa<AccessorDecl>(D)) {
-    assert(isa<SourceFile>(D->getDeclContext()->getModuleScopeContext()) &&
-           "Should not validate imported or deserialized declarations");
-  }
-
   PrettyStackTraceDecl StackTrace("validating", D);
   FrontendStatsTracer StatsTracer(Context.Stats, "validate-decl", D);
 
   checkForForbiddenPrefix(D);
 
-  // Validate the context.
-  auto dc = D->getDeclContext();
-  if (auto nominal = dyn_cast<NominalTypeDecl>(dc)) {
-    if (!nominal->getInterfaceType())
-      return;
-  } else if (auto ext = dyn_cast<ExtensionDecl>(dc)) {
-    // If we're currently validating, or have already validated this extension,
-    // there's nothing more to do now.
-    if (!ext->hasValidationStarted()) {
-      DeclValidationRAII IBV(ext);
-
-      if (auto *nominal = ext->getExtendedNominal()) {
-        // Validate the nominal type declaration being extended.
-        // FIXME(InterfaceTypeRequest): isInvalid() should be based on the interface type.
-        (void)nominal->getInterfaceType();
-        
-        // Eagerly validate the generic signature of the extension.
-        (void)ext->getGenericSignature();
-      }
-    }
-    if (ext->getValidationState() == Decl::ValidationState::Checking)
-      return;
-  }
-
-  // Validating the parent may have triggered validation of this declaration,
-  // so just return if that was the case.
-  if (D->hasValidationStarted() || D->hasInterfaceType()) {
-    assert(D->hasInterfaceType());
-    return;
-  }
-
   if (Context.Stats)
     Context.Stats->getFrontendCounters().NumDeclsValidated++;
 

lib/Sema/TypeCheckNameLookup.cpp

@@ -504,10 +504,6 @@ LookupTypeResult TypeChecker::lookupMemberType(DeclContext *dc,
       // member entirely.
       auto *protocol = cast<ProtocolDecl>(assocType->getDeclContext());
 
-      // If we're validating the protocol recursively, bail out.
-      if (!protocol->hasInterfaceType())
-        continue;
-
       auto conformance = conformsToProtocol(type, protocol, dc,
                                             conformanceOptions);
       if (!conformance) {

lib/Sema/TypeCheckProtocolInference.cpp

@@ -492,9 +492,12 @@ static Type mapErrorTypeToOriginal(Type type) {
 static Type getWitnessTypeForMatching(TypeChecker &tc,
                                       NormalProtocolConformance *conformance,
                                       ValueDecl *witness) {
-  if (!witness->getInterfaceType())
+  if (witness->isRecursiveValidation())
     return Type();
 
+  // FIXME: This is here to trigger the isInvalid() computation.
+  (void) witness->getInterfaceType();
+
   if (witness->isInvalid())
     return Type();