Merge pull request swiftlang#34596 from rintaro/ide-completion-rdar71063455

[CodeCompletion] Deduplicate results in ExprContextInfo

Author: rintaro

lib/IDE/CodeCompletion.cpp

@@ -4366,13 +4366,18 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
 
   void getUnresolvedMemberCompletions(ArrayRef<Type> Types) {
     NeedLeadingDot = !HaveDot;
+
+    SmallPtrSet<CanType, 4> seenTypes;
     for (auto T : Types) {
-      if (!T)
+      if (!T || !seenTypes.insert(T->getCanonicalType()).second)
         continue;
+
       if (auto objT = T->getOptionalObjectType()) {
         // If this is optional type, perform completion for the object type.
         // i.e. 'let _: Enum??? = .enumMember' is legal.
-        getUnresolvedMemberCompletions(objT->lookThroughAllOptionalTypes());
+        objT = objT->lookThroughAllOptionalTypes();
+        if (seenTypes.insert(objT->getCanonicalType()).second)
+          getUnresolvedMemberCompletions(objT);
 
         // Add 'nil' keyword with erasing '.' instruction.
         unsigned bytesToErase = 0;

lib/IDE/ExprContextAnalysis.cpp

@@ -795,8 +795,8 @@ class ExprContextAnalyzer {
       bool MayNeedName = !HasName && !E->isImplicit() &&
                          (isa<CallExpr>(E) | isa<SubscriptExpr>(E) ||
                           isa<UnresolvedMemberExpr>(E));
-      SmallPtrSet<TypeBase *, 4> seenTypes;
-      llvm::SmallSet<std::pair<Identifier, TypeBase *>, 4> seenArgs;
+      SmallPtrSet<CanType, 4> seenTypes;
+      llvm::SmallSet<std::pair<Identifier, CanType>, 4> seenArgs;
       for (auto &typeAndDecl : Candidates) {
         DeclContext *memberDC = nullptr;
         if (typeAndDecl.Decl)
@@ -820,15 +820,16 @@ class ExprContextAnalyzer {
                             paramList->get(Pos)->isVariadic());
 
           if (paramType.hasLabel() && MayNeedName) {
-            if (seenArgs.insert({paramType.getLabel(), ty.getPointer()}).second)
+            if (seenArgs.insert({paramType.getLabel(), ty->getCanonicalType()})
+                    .second)
               recordPossibleParam(&paramType, !canSkip);
           } else {
             auto argTy = ty;
             if (paramType.isInOut())
               argTy = InOutType::get(argTy);
             else if (paramType.isAutoClosure() && argTy->is<AnyFunctionType>())
               argTy = argTy->castTo<AnyFunctionType>()->getResult();
-            if (seenTypes.insert(argTy.getPointer()).second)
+            if (seenTypes.insert(argTy->getCanonicalType()).second)
               recordPossibleType(argTy);
           }
           if (!canSkip)
@@ -837,7 +838,7 @@ class ExprContextAnalyzer {
         // If the argument position is out of expeceted number, indicate that
         // with optional nullptr param.
         if (Position >= Params.size()) {
-          if (seenArgs.insert({Identifier(), nullptr}).second)
+          if (seenArgs.insert({Identifier(), CanType()}).second)
             recordPossibleParam(nullptr, /*isRequired=*/false);
         }
       }

test/IDE/complete_unresolved_members.swift

@@ -127,6 +127,7 @@
 // RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=AUTOCLOSURE_OPT | %FileCheck %s -check-prefix=UNRESOLVED_3_OPT
 // RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=AUTOCLOSURE_FUNCTY | %FileCheck %s -check-prefix=UNRESOLVED_3
 // RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=AUTOCLOSURE_FUNCTY_OPT | %FileCheck %s -check-prefix=UNRESOLVED_3_OPT
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=SUGAR_TYPE | %FileCheck %s -check-prefix=SUGAR_TYPE
 
 enum SomeEnum1 {
   case South
@@ -843,3 +844,27 @@ func testAutoclosreFuncTy(fn: (@autoclosure () -> SomeEnum1) -> Void, fnOpt: (@a
   fnOpt(.#^AUTOCLOSURE_FUNCTY_OPT^#)
   // Same as UNRESOLVED_3_OPT
 }
+
+func testSameType() {
+  typealias EnumAlias = SomeEnum1
+  func testSugarType(_ arg: Optional<SomeEnum1>, arg2: Int8) {}
+  func testSugarType(_ arg: SomeEnum1?, arg2: Int16) {}
+  func testSugarType(_ arg: Optional<EnumAlias>, arg2: Int32) {}
+  func testSugarType(_ arg: EnumAlias?, arg2: Int64) {}
+  func testSugarType(_ arg: SomeEnum1, arg2: Int) {}
+  func testSugarType(_ arg: EnumAlias, arg2: String) {}
+
+  testSugarType(.#^SUGAR_TYPE^#
+// Ensure results aren't duplicated.
+// SUGAR_TYPE: Begin completions, 9 items
+// SUGAR_TYPE-DAG: Decl[EnumElement]/CurrNominal/TypeRelation[Identical]: South[#SomeEnum1#];
+// SUGAR_TYPE-DAG: Decl[EnumElement]/CurrNominal/TypeRelation[Identical]: North[#SomeEnum1#];
+// SUGAR_TYPE-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: hash({#(self): SomeEnum1#})[#(into: inout Hasher) -> Void#];
+// SUGAR_TYPE-DAG: Keyword[nil]/None/Erase[1]/TypeRelation[Identical]: nil[#Optional<SomeEnum1>#];
+// SUGAR_TYPE-DAG: Decl[EnumElement]/CurrNominal/IsSystem/TypeRelation[Identical]: none[#Optional<SomeEnum1>#];
+// SUGAR_TYPE-DAG: Decl[EnumElement]/CurrNominal/IsSystem/TypeRelation[Identical]: some({#SomeEnum1#})[#Optional<SomeEnum1>#];
+// SUGAR_TYPE-DAG: Decl[InstanceMethod]/CurrNominal/IsSystem: map({#(self): Optional<SomeEnum1>#})[#((SomeEnum1) throws -> U) -> U?#];
+// SUGAR_TYPE-DAG: Decl[InstanceMethod]/CurrNominal/IsSystem: flatMap({#(self): Optional<SomeEnum1>#})[#((SomeEnum1) throws -> U?) -> U?#];
+// SUGAR_TYPE-DAG: Decl[InstanceMethod]/CurrNominal/IsSystem/TypeRelation[Invalid]: hash({#(self): Optional<SomeEnum1>#})[#(into: inout Hasher) -> Void#];
+// SUGAR_TYPE: End completions
+}