Drop CheckingWithValidSignature from the validation state machine

CodaFi · CodaFi · commit b135928125d0 · 2019-09-20T22:22:49.000-07:00
Now that the generic signature is computable on demand, this predicate is doubly useless.  All of the callers intended to ask "hasInterfaceType" anyways.
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -279,7 +279,6 @@ class alignas(1 << DeclAlignInBits) Decl {
   enum class ValidationState {
     Unchecked,
     Checking,
-    CheckingWithValidSignature,
     Checked,
   };
 
@@ -850,19 +849,11 @@ class alignas(1 << DeclAlignInBits) Decl {
     case ValidationState::Checked:
       return false;
     case ValidationState::Checking:
-    case ValidationState::CheckingWithValidSignature:
       return true;
     }
     llvm_unreachable("Unknown ValidationState");
   }
 
-  /// Update the validation state for the declaration to allow access to the
-  /// generic signature.
-  void setSignatureIsValidated() {
-    assert(getValidationState() == ValidationState::Checking);
-    setValidationState(ValidationState::CheckingWithValidSignature);
-  }
-
   bool hasValidationStarted() const {
     return getValidationState() > ValidationState::Unchecked;
   }
@@ -1769,11 +1760,6 @@ class ExtensionDecl final : public GenericContext, public Decl,
 
   void setInherited(MutableArrayRef<TypeLoc> i) { Inherited = i; }
 
-  /// Whether we have fully checked the extension signature.
-  bool hasValidSignature() const {
-    return getValidationState() > ValidationState::CheckingWithValidSignature;
-  }
-
   bool hasDefaultAccessLevel() const {
     return Bits.ExtensionDecl.DefaultAndMaxAccessLevel != 0;
   }
@@ -2608,8 +2594,6 @@ class ValueDecl : public Decl {
 
   /// Set the interface type for the given value.
   void setInterfaceType(Type type);
-
-  bool hasValidSignature() const;
   
   /// isInstanceMember - Determine whether this value is an instance member
   /// of an enum or protocol.
diff --git a/lib/AST/ASTVerifier.cpp b/lib/AST/ASTVerifier.cpp
@@ -2968,7 +2968,7 @@ class Verifier : public ASTWalker {
     void verifyChecked(AbstractFunctionDecl *AFD) {
       PrettyStackTraceDecl debugStack("verifying AbstractFunctionDecl", AFD);
 
-      if (!AFD->hasValidSignature()) {
+      if (!AFD->hasInterfaceType()) {
         if (isa<AccessorDecl>(AFD) && AFD->isImplicit())
           return;
 
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -2720,14 +2720,6 @@ void ValueDecl::setInterfaceType(Type type) {
   TypeAndAccess.setPointer(type);
 }
 
-bool ValueDecl::hasValidSignature() const {
-  if (!hasInterfaceType())
-    return false;
-  // FIXME -- The build blows up if the correct code is used:
-  // return getValidationState() > ValidationState::CheckingWithValidSignature;
-  return getValidationState() != ValidationState::Checking;
-}
-
 Optional<ObjCSelector> ValueDecl::getObjCRuntimeName(
                                               bool skipIsObjCResolution) const {
   if (auto func = dyn_cast<AbstractFunctionDecl>(this))
diff --git a/lib/IDE/CodeCompletion.cpp b/lib/IDE/CodeCompletion.cpp
@@ -2046,7 +2046,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     auto *GenericSig = VD->getInnermostDeclContext()
         ->getGenericSignatureOfContext();
 
-    assert(VD->hasValidSignature());
+    assert(VD->hasInterfaceType());
     Type T = VD->getInterfaceType();
 
     if (ExprType) {
@@ -2135,7 +2135,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     addValueBaseName(Builder, Name);
     setClangDeclKeywords(VD, Pairs, Builder);
 
-    if (!VD->hasValidSignature())
+    if (!VD->hasInterfaceType())
       return;
 
     // Add a type annotation.
diff --git a/lib/Sema/CSDiag.cpp b/lib/Sema/CSDiag.cpp
@@ -1329,7 +1329,7 @@ DeclContext *FailureDiagnosis::findDeclContext(Expr *subExpr) const {
         // variables would be accessible to name lookup of the subexpression and
         // may thus leak in.  Reset them to UnresolvedTypes for safe measures.
         assert(llvm::all_of(*closure->getParameters(), [](const ParamDecl *PD) {
-          if (PD->hasValidSignature()) {
+          if (PD->hasInterfaceType()) {
             auto paramTy = PD->getType();
             return !(paramTy->hasTypeVariable() || paramTy->hasError());
           }
@@ -5345,7 +5345,7 @@ diagnoseAmbiguousMultiStatementClosure(ClosureExpr *closure) {
         if (auto DRE = dyn_cast<DeclRefExpr>(childExpr)) {
           if (auto param = dyn_cast<ParamDecl>(DRE->getDecl())) {
             auto paramType =
-                param->hasValidSignature() ? param->getType() : Type();
+                param->hasInterfaceType() ? param->getType() : Type();
             if (!paramType || paramType->hasTypeVariable()) {
               hasUnresolvedParams = true;
               return nullptr;
diff --git a/lib/Sema/CSDiagnostics.cpp b/lib/Sema/CSDiagnostics.cpp
@@ -1473,7 +1473,7 @@ bool TrailingClosureAmbiguityFailure::diagnoseAsNote() {
     const ParamDecl *param = paramList->getArray().back();
 
     // Sanity-check that the trailing closure corresponds to this parameter.
-    if (!param->hasValidSignature() ||
+    if (!param->hasInterfaceType() ||
         !param->getInterfaceType()->is<AnyFunctionType>())
       return false;
 
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
@@ -2144,7 +2144,7 @@ static ConstraintFix *fixPropertyWrapperFailure(
   };
 
   auto applyFix = [&](Fix fix, VarDecl *decl, Type type) -> ConstraintFix * {
-    if (!decl->hasValidSignature() || !type)
+    if (!decl->hasInterfaceType() || !type)
       return nullptr;
 
     if (baseTy->isEqual(type))
diff --git a/lib/Sema/CalleeCandidateInfo.cpp b/lib/Sema/CalleeCandidateInfo.cpp
@@ -61,7 +61,7 @@ OverloadCandidate::OverloadCandidate(ValueDecl *decl, bool skipCurriedSelf)
     : declOrExpr(decl), skipCurriedSelf(skipCurriedSelf), substituted(false) {
 
   if (auto *PD = dyn_cast<ParamDecl>(decl)) {
-    if (PD->hasValidSignature())
+    if (PD->hasInterfaceType())
       entityType = PD->getType();
     else
       entityType = PD->getASTContext().TheUnresolvedType;
diff --git a/lib/Sema/CodeSynthesis.cpp b/lib/Sema/CodeSynthesis.cpp
@@ -540,7 +540,7 @@ synthesizeDesignatedInitOverride(AbstractFunctionDecl *fn, void *context) {
 
   auto *superclassCtor = (ConstructorDecl *) context;
 
-  if (!superclassCtor->hasValidSignature())
+  if (!superclassCtor->hasInterfaceType())
     ctx.getLazyResolver()->resolveDeclSignature(superclassCtor);
 
   // Reference to super.init.
@@ -856,9 +856,9 @@ static void addImplicitConstructorsToStruct(StructDecl *decl, ASTContext &ctx) {
       if (!var->isMemberwiseInitialized(/*preferDeclaredProperties=*/true))
         continue;
 
-      if (!var->hasValidSignature())
+      if (!var->hasInterfaceType())
         ctx.getLazyResolver()->resolveDeclSignature(var);
-      if (!var->hasValidSignature())
+      if (!var->hasInterfaceType())
         return;
     }
   }
@@ -923,9 +923,9 @@ static void addImplicitConstructorsToClass(ClassDecl *decl, ASTContext &ctx) {
   if (!decl->hasClangNode()) {
     for (auto member : decl->getMembers()) {
       if (auto ctor = dyn_cast<ConstructorDecl>(member)) {
-        if (!ctor->hasValidSignature())
+        if (!ctor->hasInterfaceType())
           ctx.getLazyResolver()->resolveDeclSignature(ctor);
-        if (!ctor->hasValidSignature())
+        if (!ctor->hasInterfaceType())
           return;
       }
     }
@@ -1081,7 +1081,7 @@ static void addImplicitConstructorsToClass(ClassDecl *decl, ASTContext &ctx) {
 
       // We have a designated initializer. Create an override of it.
       // FIXME: Validation makes sure we get a generic signature here.
-      if (!decl->hasValidSignature())
+      if (!decl->hasInterfaceType())
         ctx.getLazyResolver()->resolveDeclSignature(decl);
 
       if (auto ctor = createDesignatedInitOverride(
diff --git a/lib/Sema/ConstraintSystem.cpp b/lib/Sema/ConstraintSystem.cpp
@@ -819,7 +819,7 @@ Type ConstraintSystem::getUnopenedTypeOfReference(VarDecl *value, Type baseType,
         if (auto *param = dyn_cast<ParamDecl>(var))
           return getType(param);
 
-        if (!var->hasValidSignature()) {
+        if (!var->hasInterfaceType()) {
           if (!var->isInvalid()) {
             TC.diagnose(var->getLoc(), diag::recursive_decl_reference,
                         var->getDescriptiveKind(), var->getName());
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -1151,7 +1151,7 @@ static bool hasSingleNonVariadicParam(SubscriptDecl *decl,
     return false;
 
   auto *index = indices->get(0);
-  if (index->isVariadic() || !index->hasValidSignature())
+  if (index->isVariadic() || !index->hasInterfaceType())
     return false;
 
   if (ignoreLabel) {
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -2881,7 +2881,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     checkUnsupportedNestedType(PD);
 
     TC.validateDecl(PD);
-    if (!PD->hasValidSignature())
+    if (!PD->hasInterfaceType())
       return;
 
     auto *SF = PD->getParentSourceFile();
@@ -3731,12 +3731,12 @@ void TypeChecker::validateDecl(ValueDecl *D) {
     return;
 
   // Handling validation failure due to re-entrancy is left
-  // up to the caller, who must call hasValidSignature() to
+  // up to the caller, who must call hasInterfaceType() to
   // check that validateDecl() returned a fully-formed decl.
   if (D->hasValidationStarted()) {
     // If this isn't reentrant (i.e. D has already been validated), the
     // signature better be valid.
-    assert(D->isBeingValidated() || D->hasValidSignature());
+    assert(D->isBeingValidated() || D->hasInterfaceType());
     return;
   }
 
@@ -3759,7 +3759,7 @@ void TypeChecker::validateDecl(ValueDecl *D) {
   auto dc = D->getDeclContext();
   if (auto nominal = dyn_cast<NominalTypeDecl>(dc)) {
     validateDecl(nominal);
-    if (!nominal->hasValidSignature())
+    if (!nominal->hasInterfaceType())
       return;
   } else if (auto ext = dyn_cast<ExtensionDecl>(dc)) {
     // If we're currently validating, or have already validated this extension,
@@ -3776,14 +3776,14 @@ void TypeChecker::validateDecl(ValueDecl *D) {
           (void)ext->getGenericSignature();
       }
     }
-    if (!ext->hasValidSignature())
+    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()) {
-    assert(D->hasValidSignature());
+    assert(D->hasInterfaceType());
     return;
   }
 
@@ -3940,7 +3940,7 @@ void TypeChecker::validateDecl(ValueDecl *D) {
     if (auto accessor = dyn_cast<AccessorDecl>(FD)) {
       auto *storage = accessor->getStorage();
       validateDecl(storage);
-      if (!storage->hasValidSignature())
+      if (!storage->hasInterfaceType())
         return;
     }
 
@@ -4046,7 +4046,6 @@ void TypeChecker::validateDecl(ValueDecl *D) {
                        FD->getBodyResultTypeLoc(), resolution);
     // FIXME: Roll all of this interface type computation into a request.
     FD->computeType();
-    FD->setSignatureIsValidated();
 
     // Member functions need some special validation logic.
     if (FD->getDeclContext()->isTypeContext()) {
@@ -4091,11 +4090,6 @@ void TypeChecker::validateDecl(ValueDecl *D) {
     typeCheckParameterList(CD->getParameters(), res,
                            TypeResolverContext::AbstractFunctionDecl);
     CD->computeType();
-
-    // We want the constructor to be available for name lookup as soon
-    // as it has a valid interface type.
-    CD->setSignatureIsValidated();
-
     break;
   }
 
@@ -4108,8 +4102,6 @@ void TypeChecker::validateDecl(ValueDecl *D) {
     typeCheckParameterList(DD->getParameters(), res,
                            TypeResolverContext::AbstractFunctionDecl);
     DD->computeType();
-
-    DD->setSignatureIsValidated();
     break;
   }
 
@@ -4125,8 +4117,6 @@ void TypeChecker::validateDecl(ValueDecl *D) {
                        SD->getElementTypeLoc(), res);
     SD->computeType();
 
-    SD->setSignatureIsValidated();
-
     if (SD->getOpaqueResultTypeDecl()) {
       if (auto SF = SD->getInnermostDeclContext()->getParentSourceFile()) {
         SF->markDeclWithOpaqueResultTypeAsValidated(SD);
@@ -4170,8 +4160,6 @@ void TypeChecker::validateDecl(ValueDecl *D) {
     // type.
     EED->computeType();
 
-    EED->setSignatureIsValidated();
-
     if (auto argTy = EED->getArgumentInterfaceType()) {
       assert(argTy->isMaterializable());
       (void) argTy;
@@ -4181,7 +4169,7 @@ void TypeChecker::validateDecl(ValueDecl *D) {
   }
   }
 
-  assert(D->hasValidSignature());
+  assert(D->hasInterfaceType());
 }
 
 llvm::Expected<DeclRange>
diff --git a/lib/Sema/TypeCheckNameLookup.cpp b/lib/Sema/TypeCheckNameLookup.cpp
@@ -497,7 +497,7 @@ LookupTypeResult TypeChecker::lookupMemberType(DeclContext *dc,
       auto *protocol = cast<ProtocolDecl>(assocType->getDeclContext());
 
       // If we're validating the protocol recursively, bail out.
-      if (!protocol->hasValidSignature())
+      if (!protocol->hasInterfaceType())
         continue;
 
       auto conformance = conformsToProtocol(type, protocol, dc,
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
@@ -330,7 +330,7 @@ swift::matchWitness(
     return RequirementMatch(witness, MatchKind::KindConflict);
 
   // If the witness has not been validated yet, do so now.
-  if (!witness->hasValidSignature()) {
+  if (!witness->hasInterfaceType()) {
     auto &ctx = dc->getASTContext();
     ctx.getLazyResolver()->resolveDeclSignature(witness);
   }
@@ -340,7 +340,7 @@ swift::matchWitness(
     return RequirementMatch(witness, MatchKind::WitnessInvalid);
 
   // If we're currently validating the witness, bail out.
-  if (!witness->hasValidSignature())
+  if (!witness->hasInterfaceType())
     return RequirementMatch(witness, MatchKind::Circularity);
 
   // Get the requirement and witness attributes.
@@ -3854,11 +3854,11 @@ void ConformanceChecker::resolveValueWitnesses() {
       continue;
     }
 
-    // Make sure we've validated the requirement.
+    // Make sure we've got an interface type.
     if (!requirement->hasInterfaceType())
       TC.validateDecl(requirement);
 
-    if (requirement->isInvalid() || !requirement->hasValidSignature()) {
+    if (requirement->isInvalid() || !requirement->hasInterfaceType()) {
       Conformance->setInvalid();
       continue;
     }
diff --git a/lib/Sema/TypeCheckProtocolInference.cpp b/lib/Sema/TypeCheckProtocolInference.cpp
@@ -453,7 +453,7 @@ AssociatedTypeInference::inferTypeWitnessesViaValueWitnesses(
 
     // Validate the requirement.
     tc.validateDecl(req);
-    if (req->isInvalid() || !req->hasValidSignature())
+    if (req->isInvalid() || !req->hasInterfaceType())
       continue;
 
     // Check whether any of the associated types we care about are
@@ -501,7 +501,7 @@ static Type getWitnessTypeForMatching(TypeChecker &tc,
   if (!witness->hasInterfaceType())
     tc.validateDecl(witness);
 
-  if (witness->isInvalid() || !witness->hasValidSignature())
+  if (witness->isInvalid() || !witness->hasInterfaceType())
     return Type();
 
   if (!witness->getDeclContext()->isTypeContext()) {
@@ -2039,7 +2039,7 @@ void ConformanceChecker::resolveSingleWitness(ValueDecl *requirement) {
   if (!requirement->hasInterfaceType())
     TC.validateDecl(requirement);
 
-  if (requirement->isInvalid() || !requirement->hasValidSignature()) {
+  if (requirement->isInvalid() || !requirement->hasInterfaceType()) {
     Conformance->setInvalid();
     return;
   }
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
@@ -1423,7 +1423,7 @@ class TypeChecker final : public LazyResolver {
         [&](VarDecl *var) -> Type {
           validateDecl(var);
 
-          if (!var->hasValidSignature() || var->isInvalid())
+          if (!var->hasInterfaceType() || var->isInvalid())
             return ErrorType::get(Context);
 
           return wantInterfaceType ? value->getInterfaceType()
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
@@ -3262,7 +3262,7 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
     //
     // FIXME: Once accessor synthesis and getInterfaceType() itself are
     // request-ified this goes away.
-    if (!fn->hasValidSignature()) {
+    if (!fn->hasInterfaceType()) {
       assert(fn->isImplicit());
       S.M->getASTContext().getLazyResolver()->resolveDeclSignature(
           const_cast<AccessorDecl *>(fn));
