Merge pull request swiftlang#21704 from slavapestov/remove-restate-filtering-consumer

Fix a crash by removing the RestateFilteringConsumer

Author: slavapestov

lib/AST/Type.cpp

@@ -432,7 +432,7 @@ Type TypeBase::addCurriedSelfType(const DeclContext *dc) {
                              genericFn->getExtInfo());
   }
 
-  auto selfTy = dc->getDeclaredInterfaceType();
+  auto selfTy = dc->getSelfInterfaceType();
   auto selfParam = AnyFunctionType::Param(selfTy);
   if (sig)
     return GenericFunctionType::get(sig, {selfParam}, type);
@@ -853,7 +853,6 @@ Type TypeBase::getMetatypeInstanceType() {
   if (auto metaTy = getAs<AnyMetatypeType>())
     return metaTy->getInstanceType();
 
-  // For mutable value type methods, we need to dig through inout types.
   return this;
 }
 

lib/IDE/CodeCompletion.cpp

@@ -3180,20 +3180,26 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     Kind = LookupKind::ValueExpr;
     NeedLeadingDot = !HaveDot;
 
-    // This is horrible
     ExprType = ExprType->getRValueType();
+    assert(!ExprType->hasTypeParameter());
+
     this->ExprType = ExprType;
-    if (ExprType->hasTypeParameter()) {
-      DeclContext *DC = nullptr;
-      if (VD)
-        DC = VD->getInnermostDeclContext();
-      else if (auto NTD = ExprType->getInOutObjectType()
-                   ->getMetatypeInstanceType()->getAnyNominal())
-        DC = NTD;
-      if (DC)
-        ExprType = DC->mapTypeIntoContext(ExprType);
+
+    // Open existential types, so that lookupVisibleMemberDecls() can properly
+    // substitute them.
+    bool WasOptional = false;
+    if (auto OptionalType = ExprType->getOptionalObjectType()) {
+      ExprType = OptionalType;
+      WasOptional = true;
     }
 
+    if (!ExprType->getMetatypeInstanceType()->isAnyObject())
+      if (ExprType->isAnyExistentialType())
+        ExprType = OpenedArchetypeType::getAny(ExprType);
+
+    if (WasOptional)
+      ExprType = OptionalType::get(ExprType);
+
     // Handle special cases
     bool isIUO = VD && VD->getAttrs()
         .hasAttribute<ImplicitlyUnwrappedOptionalAttr>();
@@ -4188,13 +4194,12 @@ class CompletionOverrideLookup : public swift::VisibleDeclConsumer {
     }
   }
 
-  void addDesignatedInitializers(Type CurrTy) {
+  void addDesignatedInitializers(NominalTypeDecl *NTD) {
     if (hasFuncIntroducer || hasVarIntroducer || hasTypealiasIntroducer ||
         hasOverridabilityModifier)
       return;
 
-    assert(CurrTy);
-    const auto *CD = dyn_cast_or_null<ClassDecl>(CurrTy->getAnyNominal());
+    const auto *CD = dyn_cast<ClassDecl>(NTD);
     if (!CD)
       return;
     if (!CD->hasSuperclass())
@@ -4211,14 +4216,12 @@ class CompletionOverrideLookup : public swift::VisibleDeclConsumer {
     }
   }
 
-  void addAssociatedTypes(Type CurrTy) {
+  void addAssociatedTypes(NominalTypeDecl *NTD) {
     if (!hasTypealiasIntroducer &&
         (hasFuncIntroducer || hasVarIntroducer || hasInitializerModifier ||
          hasOverride || hasOverridabilityModifier))
       return;
 
-    NominalTypeDecl *NTD = CurrTy->getAnyNominal();
-
     for (auto Conformance : NTD->getAllConformances()) {
       auto Proto = Conformance->getProtocol();
       if (!Proto->isAccessibleFrom(CurrDeclContext))
@@ -4244,13 +4247,14 @@ class CompletionOverrideLookup : public swift::VisibleDeclConsumer {
     if (isa<ProtocolDecl>(CurrDeclContext))
       return;
 
-    Type CurrTy = CurrDeclContext->getDeclaredTypeInContext();
+    Type CurrTy = CurrDeclContext->getSelfTypeInContext();
+    auto *NTD = CurrDeclContext->getSelfNominalTypeDecl();
     if (CurrTy && !CurrTy->is<ErrorType>()) {
       lookupVisibleMemberDecls(*this, CurrTy, CurrDeclContext,
                                TypeResolver,
                                /*includeInstanceMembers=*/false);
-      addDesignatedInitializers(CurrTy);
-      addAssociatedTypes(CurrTy);
+      addDesignatedInitializers(NTD);
+      addAssociatedTypes(NTD);
     }
   }
 };

lib/Sema/LookupVisibleDecls.cpp

@@ -466,92 +466,6 @@ lookupVisibleMemberDeclsImpl(Type BaseTy, VisibleDeclConsumer &Consumer,
                              GenericSignatureBuilder *GSB,
                              VisitedSet &Visited);
 
-// Filters out restated declarations from a protocol hierarchy
-// or equivalent requirements from protocol composition types.
-class RestateFilteringConsumer : public VisibleDeclConsumer {
-  LazyResolver *resolver;
-
-  using FoundDecl = std::pair<ValueDecl*, DeclVisibilityKind>;
-  using NameAndType = std::pair<DeclName, CanType>;
-
-  llvm::DenseMap<DeclName, FoundDecl> foundVars;
-  llvm::DenseMap<NameAndType, FoundDecl> foundFuncs;
-  llvm::MapVector<ValueDecl*, DeclVisibilityKind> declsToReport;
-
-  template <typename K>
-  void addDecl(llvm::DenseMap<K, FoundDecl> &Map, K Key, FoundDecl FD) {
-    // Add the declaration if we haven't found an equivalent yet, otherwise
-    // replace the equivalent if the found decl has a higher access level.
-    auto existingDecl = Map.find(Key);
-
-    if ((existingDecl == Map.end()) ||
-        (Map[Key].first->getFormalAccess() < FD.first->getFormalAccess())) {
-      if (existingDecl != Map.end())
-        declsToReport.erase({existingDecl->getSecond().first});
-      Map[Key] = FD;
-      declsToReport.insert(FD);
-    }
-  }
-
-  CanType stripSelfRequirementsIfNeeded(ValueDecl *VD,
-                                        GenericFunctionType *GFT) const {
-    // Preserve the generic signature if this is a subscript, which are uncurried,
-    // or if we have generic params other than Self. Otherwise, use
-    // the resultType of the curried function type.
-    // When we keep the generic signature, we remove the requirements
-    // from Self to make sure they don't prevent us from recognizing restatements.
-    auto params = GFT->getGenericParams();
-    if (params.size() == 1 && !isa<SubscriptDecl>(VD)) {
-      return GFT->getResult()->getCanonicalType();
-    }
-    auto Self = VD->getDeclContext()->getSelfInterfaceType();
-    SmallVector<Requirement, 4> newReqs;
-    for (auto req: GFT->getRequirements()) {
-      if (!Self->isEqual(req.getFirstType()))
-        newReqs.push_back(req);
-    }
-    auto newSig = GenericSignature::get(params, newReqs, false);
-
-    return GenericFunctionType::get(newSig, GFT->getParams(),
-                                    GFT->getResult(), GFT->getExtInfo())
-      ->getCanonicalType();
-  }
-
-public:
-  RestateFilteringConsumer(Type baseTy, const DeclContext *DC,
-                           LazyResolver *resolver)
-  : resolver(resolver) {
-    assert(DC && baseTy && !baseTy->hasLValueType());
-  }
-
-  void foundDecl(ValueDecl *VD, DeclVisibilityKind Reason) override {
-    assert(VD);
-    // If this isn't a protocol context, don't look further into the decl.
-    if (!isa<ProtocolDecl>(VD->getDeclContext())) {
-      declsToReport.insert({VD, Reason});
-      return;
-    }
-    if (resolver)
-      resolver->resolveDeclSignature(VD);
-
-    if (!VD->hasInterfaceType()) {
-      declsToReport.insert({VD, Reason});
-      return;
-    }
-    if (auto GFT = VD->getInterfaceType()->getAs<GenericFunctionType>()) {
-      auto type = stripSelfRequirementsIfNeeded(VD, GFT);
-      addDecl(foundFuncs, {VD->getFullName(), type}, {VD, Reason});
-      return;
-    }
-    addDecl(foundVars, VD->getFullName(), {VD, Reason});
-  }
-
-  void feedResultsToConsumer(VisibleDeclConsumer &Consumer) const {
-    for (const auto entry: declsToReport)
-      Consumer.foundDecl(entry.first, entry.second);
-  }
-};
-
 static void
   lookupVisibleProtocolMemberDecls(Type BaseTy, ProtocolType *PT,
                                    VisibleDeclConsumer &Consumer,
@@ -637,12 +551,11 @@ static void lookupVisibleMemberDeclsImpl(
     for (auto Proto : Archetype->getConformsTo())
       lookupVisibleProtocolMemberDecls(
           BaseTy, Proto->getDeclaredType(), Consumer, CurrDC, LS,
-          getReasonForSuper(Reason), TypeResolver, GSB, Visited);
+          Reason, TypeResolver, GSB, Visited);
 
     if (auto superclass = Archetype->getSuperclass())
       lookupVisibleMemberDeclsImpl(superclass, Consumer, CurrDC, LS,
-                                   getReasonForSuper(Reason), TypeResolver,
-                                   GSB, Visited);
+                                   Reason, TypeResolver, GSB, Visited);
     return;
   }
 
@@ -763,17 +676,6 @@ template <> struct DenseMapInfo<FoundDeclTy> {
 
 namespace {
 
-/// Hack to guess at whether substituting into the type of a declaration will
-/// be okay.
-/// FIXME: This is awful. We should either have Type::subst() work for
-/// GenericFunctionType, or we should kill it outright.
-static bool shouldSubstIntoDeclType(Type type) {
-  auto genericFnType = type->getAs<GenericFunctionType>();
-  if (!genericFnType) return true;
-
-  return false;
-}
-
 class OverrideFilteringConsumer : public VisibleDeclConsumer {
 public:
   std::set<ValueDecl *> AllFoundDecls;
@@ -782,16 +684,12 @@ class OverrideFilteringConsumer : public VisibleDeclConsumer {
   Type BaseTy;
   const DeclContext *DC;
   LazyResolver *TypeResolver;
-  bool IsTypeLookup = false;
 
   OverrideFilteringConsumer(Type BaseTy, const DeclContext *DC,
                             LazyResolver *resolver)
-      : BaseTy(BaseTy), DC(DC), TypeResolver(resolver) {
+      : BaseTy(BaseTy->getMetatypeInstanceType()),
+        DC(DC), TypeResolver(resolver) {
     assert(!BaseTy->hasLValueType());
-    if (auto *MetaTy = BaseTy->getAs<AnyMetatypeType>()) {
-      BaseTy = MetaTy->getInstanceType();
-      IsTypeLookup = true;
-    }
     assert(DC && BaseTy);
   }
 
@@ -801,7 +699,9 @@ class OverrideFilteringConsumer : public VisibleDeclConsumer {
 
     // If this kind of declaration doesn't participate in overriding, there's
     // no filtering to do here.
-    if (!isa<AbstractFunctionDecl>(VD) && !isa<AbstractStorageDecl>(VD)) {
+    if (!isa<AbstractFunctionDecl>(VD) &&
+        !isa<AbstractStorageDecl>(VD) &&
+        !isa<AssociatedTypeDecl>(VD)) {
       DeclsToReport.insert(FoundDeclTy(VD, Reason));
       return;
     }
@@ -852,7 +752,8 @@ class OverrideFilteringConsumer : public VisibleDeclConsumer {
     // don't substitute either.
     bool shouldSubst = (!BaseTy->isAnyObject() &&
                         !BaseTy->hasTypeVariable() &&
-                        BaseTy->getNominalOrBoundGenericNominal() &&
+                        (BaseTy->getNominalOrBoundGenericNominal() ||
+                         BaseTy->is<ArchetypeType>()) &&
                         VD->getDeclContext()->isTypeContext());
     ModuleDecl *M = DC->getParentModule();
 
@@ -865,8 +766,7 @@ class OverrideFilteringConsumer : public VisibleDeclConsumer {
 
     auto FoundSignature = VD->getOverloadSignature();
     auto FoundSignatureType = VD->getOverloadSignatureType();
-    if (FoundSignatureType && shouldSubst &&
-        shouldSubstIntoDeclType(FoundSignatureType)) {
+    if (FoundSignatureType && shouldSubst) {
       auto subs = BaseTy->getMemberSubstitutionMap(M, VD);
       if (auto CT = FoundSignatureType.subst(subs))
         FoundSignatureType = CT->getCanonicalType();
@@ -883,8 +783,7 @@ class OverrideFilteringConsumer : public VisibleDeclConsumer {
 
       auto OtherSignature = OtherVD->getOverloadSignature();
       auto OtherSignatureType = OtherVD->getOverloadSignatureType();
-      if (OtherSignatureType && shouldSubst &&
-          shouldSubstIntoDeclType(OtherSignatureType)) {
+      if (OtherSignatureType && shouldSubst) {
         auto subs = BaseTy->getMemberSubstitutionMap(M, OtherVD);
         if (auto CT = OtherSignatureType.subst(subs))
           OtherSignatureType = CT->getCanonicalType();
@@ -926,13 +825,11 @@ static void lookupVisibleMemberDecls(
     LookupState LS, DeclVisibilityKind Reason, LazyResolver *TypeResolver,
     GenericSignatureBuilder *GSB) {
   OverrideFilteringConsumer overrideConsumer(BaseTy, CurrDC, TypeResolver);
-  RestateFilteringConsumer restateConsumer(BaseTy, CurrDC, TypeResolver);
   VisitedSet Visited;
-  lookupVisibleMemberDeclsImpl(BaseTy, restateConsumer, CurrDC, LS, Reason,
+  lookupVisibleMemberDeclsImpl(BaseTy, overrideConsumer, CurrDC, LS, Reason,
                                TypeResolver, GSB, Visited);
 
   // Report the declarations we found to the real consumer.
-  restateConsumer.feedResultsToConsumer(overrideConsumer);
   for (const auto &DeclAndReason : overrideConsumer.DeclsToReport)
     Consumer.foundDecl(DeclAndReason.D, DeclAndReason.Reason);
 }

test/IDE/complete_from_stdlib.swift

@@ -148,7 +148,7 @@ func testArchetypeReplacement2<BAR : Equatable>(_ a: [BAR]) {
 // PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/CurrNominal:   append({#(newElement): Equatable#})[#Void#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/CurrNominal:   insert({#(newElement): Equatable#}, {#at: Int#})[#Void#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         dropFirst()[#ArraySlice<Equatable>#]{{; name=.+}}
-// PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         dropLast()[#ArraySlice<Equatable>#]{{; name=.+}}
+// PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         dropLast()[#[Equatable]#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         enumerated()[#EnumeratedSequence<[Equatable]>#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         min({#by: (Equatable, Equatable) throws -> Bool##(Equatable, Equatable) throws -> Bool#})[' rethrows'][#Equatable?#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_6-DAG: Decl[InstanceMethod]/Super:         max({#by: (Equatable, Equatable) throws -> Bool##(Equatable, Equatable) throws -> Bool#})[' rethrows'][#Equatable?#]{{; name=.+}}

test/IDE/complete_members_optional.swift

@@ -29,17 +29,17 @@ func optionalMembers1(_ a: HasOptionalMembers1) {
   a.#^OPTIONAL_MEMBERS_1^#
 }
 // OPTIONAL_MEMBERS_1: Begin completions, 3 items
-// OPTIONAL_MEMBERS_1-DAG: Decl[InstanceMethod]/CurrNominal:   optionalInstanceFunc?()[#Int#]{{; name=.+$}}
-// OPTIONAL_MEMBERS_1-DAG: Decl[InstanceVar]/CurrNominal:      optionalInstanceProperty[#Int?#]{{; name=.+$}}
+// OPTIONAL_MEMBERS_1-DAG: Decl[InstanceMethod]/CurrNominal: optionalInstanceFunc?()[#Int#]{{; name=.+$}}
+// OPTIONAL_MEMBERS_1-DAG: Decl[InstanceVar]/CurrNominal: optionalInstanceProperty[#Int?#]{{; name=.+$}}
 // OPTIONAL_MEMBERS_1-DAG: Keyword[self]/CurrNominal: self[#HasOptionalMembers1#]; name=self
 // OPTIONAL_MEMBERS_1: End completions
 
 func optionalMembers2<T : HasOptionalMembers1>(_ a: T) {
   T.#^OPTIONAL_MEMBERS_2^#
 }
 // OPTIONAL_MEMBERS_2: Begin completions, 4 items
-// OPTIONAL_MEMBERS_2-DAG: Decl[InstanceMethod]/Super:         optionalInstanceFunc?({#self: HasOptionalMembers1#})[#() -> Int#]{{; name=.+$}}
-// OPTIONAL_MEMBERS_2-DAG: Decl[StaticMethod]/Super:           optionalClassFunc?()[#Int#]{{; name=.+$}}
-// OPTIONAL_MEMBERS_2-DAG: Decl[StaticVar]/Super:              optionalClassProperty[#Int?#]{{; name=.+$}}
+// OPTIONAL_MEMBERS_2-DAG: Decl[InstanceMethod]/CurrNominal: optionalInstanceFunc?({#self: HasOptionalMembers1#})[#() -> Int#]{{; name=.+$}}
+// OPTIONAL_MEMBERS_2-DAG: Decl[StaticMethod]/CurrNominal: optionalClassFunc?()[#Int#]{{; name=.+$}}
+// OPTIONAL_MEMBERS_2-DAG: Decl[StaticVar]/CurrNominal: optionalClassProperty[#Int?#]{{; name=.+$}}
 // OPTIONAL_MEMBERS_2-DAG: Keyword[self]/CurrNominal: self[#T.Type#]; name=self
 // OPTIONAL_MEMBERS_2: End completions

test/IDE/complete_operators.swift

@@ -279,8 +279,8 @@ func testInfix15<T: P where T.T == S2>() {
   T#^INFIX_15^#
 }
 // INFIX_15: Begin completions, 3 items
-// INFIX_15-NEXT: Decl[AssociatedType]/Super:         .T; name=T
-// INFIX_15-NEXT: Decl[InstanceMethod]/Super:         .foo({#self: P#})[#() -> S2#]; name=foo(P)
+// INFIX_15-NEXT: Decl[AssociatedType]/CurrNominal:   .T; name=T
+// INFIX_15-NEXT: Decl[InstanceMethod]/CurrNominal:   .foo({#self: P#})[#() -> S2#]; name=foo(P)
 // INFIX_15-NEXT: Keyword[self]/CurrNominal:          .self[#T.Type#]; name=self
 // INFIX_15: End completions
 

test/IDE/complete_type.swift

@@ -456,7 +456,7 @@ typealias FooTypealias = Int
 //===---
 
 // TYPE_IN_PROTOCOL: Begin completions
-// TYPE_IN_PROTOCOL-DAG: Decl[GenericTypeParam]/Super: Self[#Self#]{{; name=.+$}}
+// TYPE_IN_PROTOCOL-DAG: Decl[GenericTypeParam]/CurrNominal: Self[#Self#]{{; name=.+$}}
 // TYPE_IN_PROTOCOL: End completions
 
 protocol TestSelf1 {
@@ -1013,7 +1013,7 @@ func testTypeIdentifierGeneric1<
     >(a: GenericFoo.#^TYPE_IDENTIFIER_GENERIC_1^#
 
 // TYPE_IDENTIFIER_GENERIC_1: Begin completions
-// TYPE_IDENTIFIER_GENERIC_1-NEXT: Decl[AssociatedType]/Super: FooTypeAlias1{{; name=.+$}}
+// TYPE_IDENTIFIER_GENERIC_1-NEXT: Decl[AssociatedType]/CurrNominal: FooTypeAlias1{{; name=.+$}}
 // TYPE_IDENTIFIER_GENERIC_1-NEXT: Keyword/None:          Type[#GenericFoo.Type#]
 // TYPE_IDENTIFIER_GENERIC_1-NEXT: End completions
 
@@ -1022,8 +1022,8 @@ func testTypeIdentifierGeneric2<
     >(a: GenericFoo.#^TYPE_IDENTIFIER_GENERIC_2^#
 
 // TYPE_IDENTIFIER_GENERIC_2: Begin completions
-// TYPE_IDENTIFIER_GENERIC_2-NEXT: Decl[AssociatedType]/Super: BarTypeAlias1{{; name=.+$}}
-// TYPE_IDENTIFIER_GENERIC_2-NEXT: Decl[AssociatedType]/Super: FooTypeAlias1{{; name=.+$}}
+// TYPE_IDENTIFIER_GENERIC_2-NEXT: Decl[AssociatedType]/CurrNominal: BarTypeAlias1{{; name=.+$}}
+// TYPE_IDENTIFIER_GENERIC_2-NEXT: Decl[AssociatedType]/CurrNominal: FooTypeAlias1{{; name=.+$}}
 // TYPE_IDENTIFIER_GENERIC_2-NEXT: Keyword/None:          Type[#GenericFoo.Type#]
 // TYPE_IDENTIFIER_GENERIC_2-NEXT: End completions
 

test/IDE/complete_type_subscript.swift

@@ -100,7 +100,7 @@ extension G6 {
   subscript(b x: T.#^GEN_EXT_PARAM_6^#) -> Int { return 0 }
   subscript(b x: Int) -> T.#^GEN_EXT_RETURN_6^# { return 0 }
 }
-// GEN_PARAM_6-DAG: Decl[AssociatedType]/Super:         Assoc;
+// GEN_PARAM_6-DAG: Decl[AssociatedType]/CurrNominal:   Assoc;
 // GEN_PARAM_6-DAG: Keyword/None:                       Type[#T.Type#];
 
 // RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=GENPROTO_PARAM_1 | %FileCheck %s -check-prefix=GENPROTO_1
@@ -116,5 +116,5 @@ extension GP1 {
   subscript(b x: I.#^GENPROTO_EXT_PARAM_1^#) -> Int { return 1 }
   subscript(b x: Int) -> I.#^GENPROTO_EXT_RETURN_1^# { return 1 }
 }
-// GENPROTO_1-DAG: Decl[AssociatedType]/Super:         Assoc;
+// GENPROTO_1-DAG: Decl[AssociatedType]/CurrNominal:   Assoc;
 // GENPROTO_1-DAG: Keyword/None:                       Type[#Self.I.Type#];