Port getInterfaceType() patterns in ancillary libraries

Author: CodaFi

lib/ClangImporter/ImportType.cpp

@@ -2297,9 +2297,6 @@ Type ClangImporter::Implementation::getNamedSwiftType(ModuleDecl *module,
 
   assert(!decl->hasClangNode() && "picked up the original type?");
 
-  if (auto *lazyResolver = SwiftContext.getLazyResolver())
-    lazyResolver->resolveDeclSignature(decl);
-
   if (auto *nominalDecl = dyn_cast<NominalTypeDecl>(decl))
     return nominalDecl->getDeclaredType();
   return decl->getDeclaredInterfaceType();

lib/IDE/CodeCompletion.cpp

@@ -2046,8 +2046,8 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     auto *GenericSig = VD->getInnermostDeclContext()
         ->getGenericSignatureOfContext();
 
-    assert(VD->hasInterfaceType());
     Type T = VD->getInterfaceType();
+    assert(!T.isNull());
 
     if (ExprType) {
       Type ContextTy = VD->getDeclContext()->getDeclaredInterfaceType();
@@ -2984,10 +2984,9 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
 
     if (IsSwiftKeyPathExpr && !SwiftKeyPathFilter(D, Reason))
       return;
-
-    if (!D->hasInterfaceType())
-      D->getASTContext().getLazyResolver()->resolveDeclSignature(D);
-
+    
+    // FIXME(InterfaceTypeRequest): Remove this.
+    (void)D->getInterfaceType();
     switch (Kind) {
     case LookupKind::ValueExpr:
       if (auto *CD = dyn_cast<ConstructorDecl>(D)) {
@@ -3144,9 +3143,9 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
 
   bool handleEnumElement(ValueDecl *D, DeclVisibilityKind Reason,
                          DynamicLookupInfo dynamicLookupInfo) {
-    if (!D->hasInterfaceType())
-      D->getASTContext().getLazyResolver()->resolveDeclSignature(D);
-
+    // FIXME(InterfaceTypeRequest): Remove this.
+    (void)D->getInterfaceType();
+    
     if (auto *EED = dyn_cast<EnumElementDecl>(D)) {
       addEnumElementRef(EED, Reason, dynamicLookupInfo,
                         /*HasTypeContext=*/true);
@@ -3155,8 +3154,8 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
       llvm::DenseSet<EnumElementDecl *> Elements;
       ED->getAllElements(Elements);
       for (auto *Ele : Elements) {
-        if (!Ele->hasInterfaceType())
-          D->getASTContext().getLazyResolver()->resolveDeclSignature(Ele);
+        // FIXME(InterfaceTypeRequest): Remove this.
+        (void)Ele->getInterfaceType();
         addEnumElementRef(Ele, Reason, dynamicLookupInfo,
                           /*HasTypeContext=*/true);
       }
@@ -4330,8 +4329,8 @@ class CompletionOverrideLookup : public swift::VisibleDeclConsumer {
         (D->isStatic() && D->getAttrs().hasAttribute<HasInitialValueAttr>()))
       return;
 
-    if (!D->hasInterfaceType())
-      D->getASTContext().getLazyResolver()->resolveDeclSignature(D);
+    // FIXME(InterfaceTypeRequest): Remove this.
+    (void)D->getInterfaceType();
 
     bool hasIntroducer = hasFuncIntroducer ||
                          hasVarIntroducer ||

lib/IDE/ExprContextAnalysis.cpp

@@ -284,12 +284,10 @@ static void collectPossibleCalleesByQualifiedLookup(
       continue;
     if (!isMemberDeclApplied(&DC, baseTy->getMetatypeInstanceType(), VD))
       continue;
-    if (!VD->hasInterfaceType()) {
-      VD->getASTContext().getLazyResolver()->resolveDeclSignature(VD);
-      if (!VD->hasInterfaceType())
-        continue;
-    }
     Type declaredMemberType = VD->getInterfaceType();
+    if (!declaredMemberType) {
+      continue;
+    }
     if (!declaredMemberType->is<AnyFunctionType>())
       continue;
     if (VD->getDeclContext()->isTypeContext()) {
@@ -899,7 +897,7 @@ bool swift::ide::isReferenceableByImplicitMemberExpr(
   if (VD->isOperator())
     return false;
 
-  if (!VD->hasInterfaceType())
+  if (!VD->getInterfaceType())
     return false;
 
   if (T->getOptionalObjectType() &&

lib/IDE/TypeContextInfo.cpp

@@ -139,10 +139,8 @@ void ContextInfoCallbacks::getImplicitMembers(
       if (VD->isOperator())
         return false;
 
-      if (!VD->hasInterfaceType()) {
-        TypeResolver->resolveDeclSignature(VD);
-        if (!VD->hasInterfaceType())
-          return false;
+      if (!VD->getInterfaceType()) {
+        return false;
       }
 
       // Enum element decls can always be referenced by implicit member

lib/IRGen/GenEnum.cpp

@@ -5777,10 +5777,7 @@ EnumImplStrategy::get(TypeConverter &TC, SILType type, EnumDecl *theEnum) {
       elementsWithPayload.push_back({elt, nativeTI, nativeTI});
       continue;
     }
-
-    if (!elt->hasInterfaceType())
-      TC.IGM.Context.getLazyResolver()->resolveDeclSignature(elt);
-
+    
     // Compute whether this gives us an apparent payload or dynamic layout.
     // Note that we do *not* apply substitutions from a bound generic instance
     // yet. We want all instances of a generic enum to share an implementation

lib/IRGen/GenType.cpp

@@ -1920,9 +1920,6 @@ namespace {
         return true;
 
       for (auto field : decl->getStoredProperties()) {
-        if (!field->hasInterfaceType())
-          IGM.Context.getLazyResolver()->resolveDeclSignature(field);
-
         if (visit(field->getInterfaceType()->getCanonicalType()))
           return true;
       }
@@ -1947,9 +1944,6 @@ namespace {
         if (!elt->hasAssociatedValues() || elt->isIndirect())
           continue;
 
-        if (!elt->hasInterfaceType())
-          IGM.Context.getLazyResolver()->resolveDeclSignature(elt);
-
         if (visit(elt->getArgumentInterfaceType()->getCanonicalType()))
           return true;
       }

lib/SIL/SILType.cpp

@@ -139,18 +139,13 @@ bool SILType::canRefCast(SILType operTy, SILType resultTy, SILModule &M) {
 
 SILType SILType::getFieldType(VarDecl *field,
                               TypeConverter &TC) const {
-  auto baseTy = getASTType();
-
-  if (!field->hasInterfaceType())
-    TC.Context.getLazyResolver()->resolveDeclSignature(field);
-
   AbstractionPattern origFieldTy = TC.getAbstractionPattern(field);
   CanType substFieldTy;
   if (field->hasClangNode()) {
     substFieldTy = origFieldTy.getType();
   } else {
     substFieldTy =
-      baseTy->getTypeOfMember(&TC.M, field, nullptr)->getCanonicalType();
+      getASTType()->getTypeOfMember(&TC.M, field, nullptr)->getCanonicalType();
   }
 
   auto loweredTy = TC.getLoweredRValueType(origFieldTy, substFieldTy);
@@ -175,9 +170,6 @@ SILType SILType::getEnumElementType(EnumElementDecl *elt,
     return SILType(objectType, getCategory());
   }
 
-  if (!elt->hasInterfaceType())
-    TC.Context.getLazyResolver()->resolveDeclSignature(elt);
-
   // If the case is indirect, then the payload is boxed.
   if (elt->isIndirect() || elt->getParentEnum()->isIndirect()) {
     auto box = TC.getBoxTypeForEnumElement(*this, elt);

lib/SIL/TypeLowering.cpp

@@ -1267,10 +1267,6 @@ namespace {
 
       // Classify the type according to its stored properties.
       for (auto field : D->getStoredProperties()) {
-        // FIXME: Remove this once getInterfaceType() is a request.
-        if (!field->hasInterfaceType())
-          TC.Context.getLazyResolver()->resolveDeclSignature(field);
-
         auto substFieldType =
           field->getInterfaceType().subst(subMap)->getCanonicalType();
 
@@ -1313,11 +1309,7 @@ namespace {
           properties.setNonTrivial();
           continue;
         }
-
-        // FIXME: Remove this once getInterfaceType() is a request.
-        if (!elt->hasInterfaceType())
-          TC.Context.getLazyResolver()->resolveDeclSignature(elt);
-
+        
         auto substEltType =
           elt->getArgumentInterfaceType().subst(subMap)->getCanonicalType();
 
@@ -1895,11 +1887,6 @@ getFunctionInterfaceTypeWithCaptures(TypeConverter &TC,
 
 CanAnyFunctionType TypeConverter::makeConstantInterfaceType(SILDeclRef c) {
   auto *vd = c.loc.dyn_cast<ValueDecl *>();
-
-  if (vd && !vd->hasInterfaceType()) {
-    Context.getLazyResolver()->resolveDeclSignature(vd);
-  }
-
   switch (c.kind) {
   case SILDeclRef::Kind::Func: {
     CanAnyFunctionType funcTy;
@@ -2612,11 +2599,6 @@ CanSILBoxType TypeConverter::getBoxTypeForEnumElement(SILType enumType,
   assert(elt->isIndirect() || elt->getParentEnum()->isIndirect());
 
   auto &C = M.getASTContext();
-
-  // FIXME: Remove this once getInterfaceType() is a request.
-  if (!elt->hasInterfaceType())
-    Context.getLazyResolver()->resolveDeclSignature(elt);
-
   auto boxSignature = getCanonicalSignatureOrNull(
       enumDecl->getGenericSignature());
 
@@ -2688,9 +2670,6 @@ static void countNumberOfInnerFields(unsigned &fieldsCount, TypeConverter &TC,
       if (elt->isIndirect())
         continue;
 
-      if (!elt->hasInterfaceType())
-        TC.Context.getLazyResolver()->resolveDeclSignature(elt);
-
       // Although one might assume enums have a fields count of 1
       // Which holds true for current uses of this code
       // (we shouldn't expand enums)

lib/SILOptimizer/Analysis/DestructorAnalysis.cpp

@@ -74,11 +74,6 @@ bool DestructorAnalysis::isSafeType(CanType Ty) {
 
     // Check the stored properties.
     for (auto SP : Struct->getStoredProperties()) {
-      // FIXME: Remove this once getInterfaceType() is a request.
-      if (!SP->hasInterfaceType()) {
-        ASTContext &Ctx = Mod->getSwiftModule()->getASTContext();
-        Ctx.getLazyResolver()->resolveDeclSignature(SP);
-      }
       if (!isSafeType(SP->getInterfaceType()->getCanonicalType()))
         return cacheResult(Ty, false);
     }