Merge pull request #27553 from slavapestov/circular-validation-cleanups-4

Circular validation cleanups, part 4

Author: slavapestov

lib/AST/ASTMangler.cpp

@@ -2372,13 +2372,9 @@ CanType ASTMangler::getDeclTypeForMangling(
   }
 
 
-  Type type = decl->getInterfaceType()
-                  ->getReferenceStorageReferent();
-  if (type->hasArchetype()) {
-    assert(isa<ParamDecl>(decl) && "Only ParamDecl's still have archetypes");
-    type = type->mapTypeOutOfContext();
-  }
-  CanType canTy = type->getCanonicalType();
+  auto canTy = decl->getInterfaceType()
+                   ->getReferenceStorageReferent()
+                   ->getCanonicalType();
 
   if (auto gft = dyn_cast<GenericFunctionType>(canTy)) {
     genericSig = gft.getGenericSignature();

lib/AST/Decl.cpp

@@ -2731,8 +2731,11 @@ Type ValueDecl::getInterfaceType() const {
     // Our clients that don't register the lazy resolver are relying on the
     // fact that they can't pull an interface type out to avoid doing work.
     // This is a necessary evil until we can wean them off.
-    if (auto resolver = getASTContext().getLazyResolver())
+    if (auto resolver = getASTContext().getLazyResolver()) {
       resolver->resolveDeclSignature(const_cast<ValueDecl *>(this));
+      if (!hasInterfaceType())
+        return ErrorType::get(getASTContext());
+    }
   }
   return TypeAndAccess.getPointer();
 }
@@ -2741,13 +2744,7 @@ void ValueDecl::setInterfaceType(Type type) {
   if (type) {
     assert(!type->hasTypeVariable() && "Type variable in interface type");
     assert(!type->is<InOutType>() && "Interface type must be materializable");
-
-    // ParamDecls in closure contexts can have type variables
-    // archetype in them during constraint generation.
-    if (!(isa<ParamDecl>(this) && isa<AbstractClosureExpr>(getDeclContext()))) {
-      assert(!type->hasArchetype() &&
-             "Archetype in interface type");
-    }
+    assert(!type->hasArchetype() && "Archetype in interface type");
 
     if (type->hasError())
       setInvalid();

lib/IDE/CodeCompletion.cpp

@@ -868,7 +868,7 @@ calculateTypeRelationForDecl(const Decl *D, Type ExpectedType,
                              bool UseFuncResultType = true) {
   auto VD = dyn_cast<ValueDecl>(D);
   auto DC = D->getDeclContext();
-  if (!VD || !VD->getInterfaceType())
+  if (!VD)
     return CodeCompletionResult::ExpectedTypeRelation::Unrelated;
 
   if (auto FD = dyn_cast<AbstractFunctionDecl>(VD)) {

lib/IDE/ExprContextAnalysis.cpp

@@ -888,9 +888,6 @@ bool swift::ide::isReferenceableByImplicitMemberExpr(
   if (VD->isOperator())
     return false;
 
-  if (!VD->getInterfaceType())
-    return false;
-
   if (T->getOptionalObjectType() &&
       VD->getModuleContext()->isStdlibModule()) {
     // In optional context, ignore '.init(<some>)', 'init(nilLiteral:)',

lib/IDE/TypeContextInfo.cpp

@@ -139,10 +139,6 @@ void ContextInfoCallbacks::getImplicitMembers(
       if (VD->isOperator())
         return false;
 
-      if (!VD->getInterfaceType()) {
-        return false;
-      }
-
       // Enum element decls can always be referenced by implicit member
       // expression.
       if (isa<EnumElementDecl>(VD))

lib/SIL/SILFunctionType.cpp

@@ -136,8 +136,6 @@ static CanType getKnownType(Optional<CanType> &cacheSlot, ASTContext &C,
       if (!typeDecl)
         return CanType();
 
-      assert(typeDecl->hasInterfaceType() &&
-             "bridged type must be type-checked");
       return typeDecl->getDeclaredInterfaceType()->getCanonicalType();
     })();
   }

lib/SILGen/SILGen.cpp

@@ -107,8 +107,6 @@ getBridgingFn(Optional<SILDeclRef> &cacheSlot,
       llvm::report_fatal_error("unable to set up the ObjC bridge!");
     }
 
-    assert(fd->hasInterfaceType() && "bridging functions must be type-checked");
-
     // Check that the function takes the expected arguments and returns the
     // expected result type.
     SILDeclRef c(fd);

lib/Sema/CSGen.cpp

@@ -2028,8 +2028,9 @@ namespace {
 
         // If a type was explicitly specified, use its opened type.
         if (auto type = param->getTypeLoc().getType()) {
+          paramType = closureExpr->mapTypeIntoContext(type);
           // FIXME: Need a better locator for a pattern as a base.
-          paramType = CS.openUnboundGenericType(type, locator);
+          paramType = CS.openUnboundGenericType(paramType, locator);
           internalType = paramType;
         } else {
           // Otherwise, create fresh type variables.

lib/Sema/CodeSynthesis.cpp

@@ -841,18 +841,6 @@ static void addImplicitConstructorsToStruct(StructDecl *decl, ASTContext &ctx) {
   assert(!decl->hasUnreferenceableStorage() &&
          "User-defined structs cannot have unreferenceable storage");
 
-  // Bail out if we're validating one of our stored properties already;
-  // we'll revisit the issue later.
-  for (auto member : decl->getMembers()) {
-    if (auto var = dyn_cast<VarDecl>(member)) {
-      if (!var->isMemberwiseInitialized(/*preferDeclaredProperties=*/true))
-        continue;
-
-      if (!var->getInterfaceType())
-        return;
-    }
-  }
-
   decl->setAddedImplicitInitializers();
 
   // Check whether there is a user-declared constructor or an instance
@@ -913,7 +901,7 @@ static void addImplicitConstructorsToClass(ClassDecl *decl, ASTContext &ctx) {
   if (!decl->hasClangNode()) {
     for (auto member : decl->getMembers()) {
       if (auto ctor = dyn_cast<ConstructorDecl>(member)) {
-        if (!ctor->getInterfaceType())
+        if (ctor->isRecursiveValidation())
           return;
       }
     }

lib/Sema/DerivedConformanceCodable.cpp

@@ -117,12 +117,6 @@ static CodableConformanceType varConformsToCodable(TypeChecker &tc,
   //   var x: Int // <- we get to valuate x's var decl here, but its type
   //              //    hasn't yet been evaluated
   // }
-  //
-  // If the var decl didn't validate, it may still not have a type; confirm it
-  // has a type before ensuring the type conforms to Codable.
-  if (!varDecl->getInterfaceType())
-    return TypeNotValidated;
-
   bool isIUO = varDecl->isImplicitlyUnwrappedOptional();
   return typeConformsToCodable(context, varDecl->getValueInterfaceType(),
                                isIUO, proto);

lib/Sema/DerivedConformanceEquatableHashable.cpp

@@ -47,8 +47,8 @@ associatedValuesNotConformingToProtocol(DeclContext *DC, EnumDecl *theEnum,
                                         ProtocolDecl *protocol) {
   SmallVector<ParamDecl *, 3> nonconformingAssociatedValues;
   for (auto elt : theEnum->getAllElements()) {
-    if (!elt->getInterfaceType())
-      continue;
+    // FIXME: Remove this once getInterfaceType() on a ParamDecl works.
+    (void) elt->getInterfaceType();
 
     auto PL = elt->getParameterList();
     if (!PL)

lib/Sema/LookupVisibleDecls.cpp

@@ -279,8 +279,11 @@ static void doDynamicLookup(VisibleDeclConsumer &Consumer,
       if (!D->isObjC())
         return;
 
-      // Ensure that the declaration has a type.
-      if (!D->getInterfaceType()) return;
+      if (D->isRecursiveValidation())
+        return;
+
+      // FIXME: This is used to compute isInvalid() below.
+      (void) D->getInterfaceType();
 
       switch (D->getKind()) {
 #define DECL(ID, SUPER) \
@@ -757,9 +760,11 @@ class OverrideFilteringConsumer : public VisibleDeclConsumer {
         continue;
       }
 
-      if (!VD->getInterfaceType()) {
+      if (VD->isRecursiveValidation())
         continue;
-      }
+
+      // FIXME: This is used to compute isInvalid() below.
+      (void) VD->getInterfaceType();
 
       auto &PossiblyConflicting = DeclsByName[VD->getBaseName()];
 
@@ -801,11 +806,14 @@ class OverrideFilteringConsumer : public VisibleDeclConsumer {
       for (auto I = PossiblyConflicting.begin(), E = PossiblyConflicting.end();
            I != E; ++I) {
         auto *OtherVD = *I;
-        if (OtherVD->isInvalid() || !OtherVD->getInterfaceType()) {
-          // For some invalid decls it might be impossible to compute the
-          // signature, for example, if the types could not be resolved.
+        if (OtherVD->isRecursiveValidation())
+          continue;
+
+        // FIXME: This is used to compute isInvalid() below.
+        (void) OtherVD->getInterfaceType();
+
+        if (OtherVD->isInvalid())
           continue;
-        }
 
         auto OtherSignature = OtherVD->getOverloadSignature();
         auto OtherSignatureType = OtherVD->getOverloadSignatureType();

lib/Sema/TypeCheckCircularity.cpp

@@ -249,10 +249,7 @@ bool CircularityChecker::expandStruct(CanType type, StructDecl *S,
       S->getModuleContext(), S);
 
   for (auto field: S->getStoredProperties()) {
-    if (!field->getInterfaceType())
-      continue;
-
-    auto fieldType =field->getInterfaceType().subst(subMap);
+    auto fieldType =field->getValueInterfaceType().subst(subMap);
     if (addMember(type, field, fieldType, depth))
       return true;
   }
@@ -283,9 +280,6 @@ bool CircularityChecker::expandEnum(CanType type, EnumDecl *E,
     if (!elt->hasAssociatedValues())
       continue;
 
-    if (!elt->getInterfaceType())
-      continue;
-
     auto eltType = elt->getArgumentInterfaceType().subst(subMap);
     if (addMember(type, elt, eltType, depth))
       return true;
@@ -614,9 +608,6 @@ void CircularityChecker::diagnoseNonWellFoundedEnum(EnumDecl *E) {
       return false;
 
     for (auto elt: elts) {
-      if (!elt->getInterfaceType())
-        return false;
-
       if (!elt->isIndirect() && !E->isIndirect())
         return false;
 

lib/Sema/TypeCheckConstraints.cpp

@@ -440,12 +440,6 @@ static bool findNonMembers(TypeChecker &TC,
     if (!isValid(D))
       return false;
 
-    // FIXME: Circularity hack.
-    if (!D->getInterfaceType()) {
-      AllDeclRefs = false;
-      continue;
-    }
-
     if (matchesDeclRefKind(D, refKind))
       ResultValues.push_back(D);
   }
@@ -1356,8 +1350,7 @@ bool PreCheckExpression::walkToClosureExprPre(ClosureExpr *closure) {
   options |= TypeResolutionFlags::AllowUnboundGenerics;
   bool hadParameterError = false;
 
-  auto resolution = TypeResolution::forContextual(closure);
-  if (TC.typeCheckParameterList(PL, resolution, options)) {
+  if (TC.typeCheckParameterList(PL, closure, options)) {
     // If we encounter an error validating the parameter list, don't bail.
     // Instead, go on to validate any potential result type, and bail
     // afterwards.  This allows for better diagnostics, and keeps the
@@ -1367,8 +1360,9 @@ bool PreCheckExpression::walkToClosureExprPre(ClosureExpr *closure) {
 
   // Validate the result type, if present.
   if (closure->hasExplicitResultType() &&
-      TypeChecker::validateType(TC.Context, closure->getExplicitResultTypeLoc(),
-                                resolution,
+      TypeChecker::validateType(TC.Context,
+                                closure->getExplicitResultTypeLoc(),
+                                TypeResolution::forContextual(closure),
                                 TypeResolverContext::InExpression)) {
     return false;
   }