[CodeCompletion] Remove code completion results from extensions that can never apply. rdar://24562621

Author: nkcsgexi

lib/AST/LookupVisibleDecls.cpp

@@ -20,6 +20,7 @@
 #include "swift/AST/AST.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/STLExtras.h"
+#include "swift/Sema/IDETypeChecking.h"
 #include "llvm/ADT/SetVector.h"
 #include <set>
 
@@ -174,6 +175,9 @@ static void doGlobalExtensionLookup(Type BaseType,
 
   // Look in each extension of this type.
   for (auto extension : nominal->getExtensions()) {
+    if (!isExtensionApplied(*const_cast<DeclContext*>(CurrDC), BaseType,
+                            extension))
+      continue;
     bool validatedExtension = false;
     if (TypeResolver && extension->getAsProtocolExtensionContext()) {
       if (!TypeResolver->isProtocolExtensionUsable(

lib/Sema/CSGen.cpp

@@ -3156,55 +3156,91 @@ Type swift::checkMemberType(DeclContext &DC, Type BaseTy,
   return Type();
 }
 
-bool swift::isExtensionApplied(DeclContext &DC, Type BaseTy,
-                               const ExtensionDecl *ED) {
+static ArrayRef<Identifier> getSubstitutableTypeNames(SubstitutableType *Ty,
+                                           std::vector<Identifier> &Scratch,
+                                                      bool &IsSelfDependent) {
+  IsSelfDependent = false;
+  for (auto Cur = Ty; Cur; Cur = Cur->getParent()) {
+    if (Cur->getName().str() == "Self") {
+      IsSelfDependent = true;
+      break;
+    }
+    Scratch.insert(Scratch.begin(), Cur->getName());
+  }
+  return llvm::makeArrayRef(Scratch);
+}
 
-  // We need to make sure the extension is about the give type decl.
-  bool FoundExtension = false;
-  if (auto ND = BaseTy->getNominalOrBoundGenericNominal()) {
-    for (auto ET : ND->getExtensions()) {
-      if (ET == ED) {
-        FoundExtension = true;
-        break;
-      }
+static ArrayRef<Identifier> getDependentMemberNames(DependentMemberType *Dep,
+                                            std::vector<Identifier> &Scratch,
+                                                    bool &IsSelfDependent) {
+  DependentMemberType *Prev = nullptr;
+  IsSelfDependent = false;
+  for (DependentMemberType *Cur = Dep; Cur;
+       Prev = Cur, Cur = Cur->getBase()->getAs<DependentMemberType>()) {
+    Scratch.insert(Scratch.begin(), Cur->getName());
+    Prev = Cur;
+  }
+  if (Type Base = Prev->getBase()) {
+    if (SubstitutableType *Sub = Base->getAs<SubstitutableType>()) {
+      getSubstitutableTypeNames(Sub, Scratch, IsSelfDependent);
     }
   }
-  assert(FoundExtension && "Cannot find the extension.");
-  ConstraintSystemOptions Options;
+  return llvm::makeArrayRef(Scratch);
+}
 
+bool swift::isExtensionApplied(DeclContext &DC, Type BaseTy,
+                               const ExtensionDecl *ED) {
+  ConstraintSystemOptions Options;
+  NominalTypeDecl *Nominal = BaseTy->getNominalOrBoundGenericNominal();
+  if (!Nominal || !BaseTy->isSpecialized() ||
+      ED->getGenericRequirements().empty())
+    return true;
   std::unique_ptr<TypeChecker> CreatedTC;
   // If the current ast context has no type checker, create one for it.
   auto *TC = static_cast<TypeChecker*>(DC.getASTContext().getLazyResolver());
   if (!TC) {
     CreatedTC.reset(new TypeChecker(DC.getASTContext()));
     TC = CreatedTC.get();
   }
-
-  // Build substitution map for the given type.
-  SmallVector<Type, 3> Scratch;
-  auto genericArgs = BaseTy->getAllGenericArgs(Scratch);
-  TypeSubstitutionMap substitutions;
-  auto genericParams = BaseTy->getNominalOrBoundGenericNominal()
-                         ->getInnermostGenericParamTypes();
-  assert(genericParams.size() == genericArgs.size());
-  for (unsigned i = 0, n = genericParams.size(); i != n; ++i) {
-    auto gp = genericParams[i]->getCanonicalType()->castTo<GenericTypeParamType>();
-    substitutions[gp] = genericArgs[i];
-  }
   ConstraintSystem CS(*TC, &DC, Options);
   auto Loc = CS.getConstraintLocator(nullptr);
-  if (ED->getGenericRequirements().empty())
-    return true;
+  std::vector<Identifier> Scratch;
+  bool Failed = false;
+  SmallVector<Type, 3> TypeScratch;
+
+  // Prepare type substitution map.
+  auto GenericArgs = BaseTy->getAllGenericArgs(TypeScratch);
+  TypeSubstitutionMap Substitutions;
+  auto GenericParams = Nominal->getInnermostGenericParamTypes();
+  assert(GenericParams.size() == GenericArgs.size());
+  for (unsigned I = 0, N = GenericParams.size(); I != N; ++I) {
+    auto GP = GenericParams[I]->getCanonicalType()->castTo<GenericTypeParamType>();
+    Substitutions[GP] = GenericArgs[I];
+  }
+  auto resolveType = [&](Type Ty) {
+    ArrayRef<Identifier> Names;
+    bool IsSelfDependent = false;
+    if (SubstitutableType *Sub = Ty->getAs<SubstitutableType>()) {
+      Scratch.clear();
+      Names = getSubstitutableTypeNames(Sub, Scratch, IsSelfDependent);
+    } else if (DependentMemberType *Dep = Ty->getAs<DependentMemberType>()) {
+      Scratch.clear();
+      Names = getDependentMemberNames(Dep, Scratch, IsSelfDependent);
+    } else
+      return Ty;
+    return IsSelfDependent ? checkMemberType(DC, BaseTy, Names)
+      :Ty.subst(DC.getParentModule(), Substitutions,
+                                       SubstFlags::IgnoreMissing);
+  };
   auto createMemberConstraint = [&](Requirement &Req, ConstraintKind Kind) {
-
-    // Use the substitution map of the given type to substitute the parameter of
-    // the extension.
-    auto First = Req.getFirstType().subst(ED->getParentModule(), substitutions,
-      SubstFlags::IgnoreMissing);
-
+    auto First = resolveType(Req.getFirstType());
+    auto Second = resolveType(Req.getSecondType());
+    if (First.isNull() || Second.isNull()) {
+      Failed = true;
+      return;
+    }
     // Add constraints accordingly.
-    CS.addConstraint(Constraint::create(CS, Kind, First, Req.getSecondType(),
-                                        DeclName(), Loc));
+    CS.addConstraint(Constraint::create(CS, Kind, First, Second, DeclName(), Loc));
   };
 
   // For every requirement, add a constraint.
@@ -3223,6 +3259,8 @@ bool swift::isExtensionApplied(DeclContext &DC, Type BaseTy,
         break;
     }
   }
+  if (Failed)
+    return true;
 
   // Having a solution implies the extension's requirements have been fulfilled.
   return CS.solveSingle().hasValue();

test/IDE/complete_from_constraint_extensions.swift

@@ -0,0 +1,35 @@
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=CONSTRAINT1 | FileCheck %s -check-prefix=CONSTRAINT1
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=CONSTRAINT2 | FileCheck %s -check-prefix=CONSTRAINT2
+
+public protocol P1 {}
+public protocol P2 {}
+public struct Example<T: Any> {}
+
+extension Example where T: P1 {
+  func P1Method() {}
+}
+
+extension Example where T: P2 {
+  func P2Method() {}
+}
+
+public struct S1 : P1 {}
+public struct S2 : P2 {}
+
+func foo1() {
+  var I1 = Example<S1>()
+  I1.#^CONSTRAINT1^#
+}
+
+// CONSTRAINT1: 	 Begin completions, 1 items
+// CONSTRAINT1-NEXT: Decl[InstanceMethod]/CurrNominal:   P1Method()[#Void#]; name=P1Method()
+// CONSTRAINT1-NEXT: End completions
+
+func foo2() {
+  var I2 = Example<S2>()
+  I2.#^CONSTRAINT2^#
+}
+
+// CONSTRAINT2:      Begin completions, 1 items
+// CONSTRAINT2-NEXT: Decl[InstanceMethod]/CurrNominal:   P2Method()[#Void#]; name=P2Method()
+// CONSTRAINT2-NEXT: End completions

test/IDE/complete_from_stdlib.swift

@@ -129,7 +129,6 @@ func testArchetypeReplacement1<FOO : Equatable>(_ a: [FOO]) {
 // PRIVATE_NOMINAL_MEMBERS_5-DAG: Decl[InstanceMethod]/CurrNominal:   append({#(newElement): Equatable#})[#Void#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_5-DAG: Decl[InstanceMethod]/CurrNominal:   insert({#(newElement): Equatable#}, {#at: Int#})[#Void#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_5-DAG: Decl[InstanceMethod]/CurrNominal:   popLast()[#Equatable?#]{{; name=.+}}
-// PRIVATE_NOMINAL_MEMBERS_5-DAG: Decl[InstanceMethod]/Super:         makeIterator()[#IndexingIterator<[Equatable]>#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_5-DAG: Decl[InstanceVar]/Super:            isEmpty[#Bool#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_5-DAG: Decl[InstanceVar]/Super:            first[#Equatable?#]{{; name=.+}}
 // PRIVATE_NOMINAL_MEMBERS_5-DAG: Decl[InstanceMethod]/Super:         dropFirst({#(n): Int#})[#ArraySlice<Equatable>#]{{; name=.+}}