[CodeCompletion] Only include results from other modules once

In case of ambigous expression/global completions, we call `getValueCompletionsInDeclContext` multiple times for the amigous solutions to the constraint system. This can cause modules to be included multiple times in `RequestedCachedResults` and thus global results from these modules are reported multiple times. Make `RequestedCachedResults` a set so we don’t get duplicate results.

rdar://92048610

Author: ahoppen

include/swift/IDE/CompletionLookup.h

@@ -209,9 +209,17 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     static RequestedResultsTy toplevelResults() {
       return {nullptr, false, false, false, true};
     }
+
+    friend bool operator==(const RequestedResultsTy &LHS,
+                           const RequestedResultsTy &RHS) {
+      return LHS.TheModule == RHS.TheModule && LHS.OnlyTypes == RHS.OnlyTypes &&
+             LHS.OnlyPrecedenceGroups == RHS.OnlyPrecedenceGroups &&
+             LHS.NeedLeadingDot == RHS.NeedLeadingDot &&
+             LHS.IncludeModuleQualifier == RHS.IncludeModuleQualifier;
+    }
   };
 
-  std::vector<RequestedResultsTy> RequestedCachedResults;
+  llvm::SetVector<RequestedResultsTy> RequestedCachedResults;
 
 public:
   CompletionLookup(CodeCompletionResultSink &Sink, ASTContext &Ctx,
@@ -598,4 +606,29 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
 } // end namespace ide
 } // end namespace swift
 
+namespace llvm {
+using RequestedResultsTy = swift::ide::CompletionLookup::RequestedResultsTy;
+template <>
+struct DenseMapInfo<RequestedResultsTy> {
+  static inline RequestedResultsTy getEmptyKey() {
+    return {DenseMapInfo<swift::ModuleDecl *>::getEmptyKey(), false, false,
+            false, false};
+  }
+  static inline RequestedResultsTy getTombstoneKey() {
+    return {DenseMapInfo<swift::ModuleDecl *>::getTombstoneKey(), false, false,
+            false, false};
+  }
+  static unsigned getHashValue(const RequestedResultsTy &Val) {
+    return hash_combine(
+        DenseMapInfo<swift::ModuleDecl *>::getHashValue(Val.TheModule),
+        Val.OnlyTypes, Val.OnlyPrecedenceGroups, Val.NeedLeadingDot,
+        Val.IncludeModuleQualifier);
+  }
+  static bool isEqual(const RequestedResultsTy &LHS,
+                      const RequestedResultsTy &RHS) {
+    return LHS == RHS;
+  }
+};
+} // namespace llvm
+
 #endif // SWIFT_IDE_COMPLETIONLOOKUP_H

lib/IDE/CompletionLookup.cpp

@@ -2076,7 +2076,7 @@ bool CompletionLookup::tryModuleCompletions(Type ExprType, bool TypesOnly) {
                                        .withModuleQualifier(false);
       if (TypesOnly)
         Request = Request.onlyTypes();
-      RequestedCachedResults.push_back(Request);
+      RequestedCachedResults.insert(Request);
     }
     return true;
   }
@@ -2639,7 +2639,7 @@ void CompletionLookup::getValueCompletionsInDeclContext(SourceLoc Loc,
 
   lookupVisibleDecls(FilteringConsumer, CurrDeclContext,
                      /*IncludeTopLevel=*/false, Loc);
-  RequestedCachedResults.push_back(
+  RequestedCachedResults.insert(
       RequestedResultsTy::toplevelResults().withModuleQualifier(
           ModuleQualifier));
 
@@ -2941,9 +2941,9 @@ void CompletionLookup::collectPrecedenceGroups() {
     if (Module == CurrModule)
       continue;
 
-    RequestedCachedResults.push_back(RequestedResultsTy::fromModule(Module)
-                                         .onlyPrecedenceGroups()
-                                         .withModuleQualifier(false));
+    RequestedCachedResults.insert(RequestedResultsTy::fromModule(Module)
+                                      .onlyPrecedenceGroups()
+                                      .withModuleQualifier(false));
   }
 }
 
@@ -3033,7 +3033,7 @@ void CompletionLookup::getTypeCompletionsInDeclContext(SourceLoc Loc,
   lookupVisibleDecls(AccessFilteringConsumer, CurrDeclContext,
                      /*IncludeTopLevel=*/false, Loc);
 
-  RequestedCachedResults.push_back(
+  RequestedCachedResults.insert(
       RequestedResultsTy::toplevelResults().onlyTypes().withModuleQualifier(
           ModuleQualifier));
 }

test/IDE/complete_from_swift_module.swift

@@ -53,6 +53,9 @@
 // rdar://15305873 Code completion: implement proper shadowing of declarations represented by cached results
 // FIXME: %FileCheck %s -check-prefix=TOP_LEVEL_1_NEGATIVE < %t.compl.txt
 
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -I %t -code-completion-token=AMBIGOUS_RESULT_BUILER > %t.compl.txt
+// RUN: %FileCheck %s -check-prefix=AMBIGOUS_RESULT_BUILER < %t.compl.txt
+
 // ERROR_COMMON: found code completion token
 // ERROR_COMMON-NOT: Begin completions
 
@@ -161,3 +164,28 @@ func foo() -> foo_swift_module.#^MODULE_TYPE_QUALIFIED^# {}
 // MODULE_TYPE_QUALIFIED: Decl[Struct]/OtherModule[foo_swift_module]: FooSwiftStruct[#FooSwiftStruct#]; name=FooSwiftStruct
 // MODULE_TYPE_QUALIFIED: Decl[Struct]/OtherModule[foo_swift_module]: BarGenericSwiftStruct2[#BarGenericSwiftStruct2#]; name=BarGenericSwiftStruct2
 // MODULE_TYPE_QUALIFIED: End completions
+
+// rdar://92048610
+func testAmbiguousResultBuilder() {
+  @resultBuilder
+  struct MyBuilder {
+    static func buildBlock(_ x: Int) -> Int {}
+  }
+
+  struct Foo {
+    init(arg: Int = 1, @MyBuilder content: () -> Int) {}
+    init(arg: Int = 1) {}
+  }
+
+  func test() {
+    Foo {
+      #^AMBIGOUS_RESULT_BUILER^#
+    }
+    // Results should only contain globalVar once
+    // AMBIGOUS_RESULT_BUILER: Begin completions
+    // AMBIGOUS_RESULT_BUILER-NOT: globalVar
+    // AMBIGOUS_RESULT_BUILER-DAG: Decl[GlobalVar]/OtherModule[foo_swift_module]: globalVar[#Int#]; name=globalVar
+    // AMBIGOUS_RESULT_BUILER-NOT: globalVar
+    // AMBIGOUS_RESULT_BUILER: End completions
+  }
+}