New note for users that have wrongly assumed that generic param conformances use the same separators as type conformances.

Author: gregomni

include/swift/AST/DiagnosticsSema.def

@@ -94,6 +94,9 @@ ERROR(could_not_find_enum_case,none,
 
 NOTE(did_you_mean_raw_type,none,
      "did you mean to specify a raw type on the enum declaration?", ())
+     
+NOTE(did_you_mean_generic_param_as_conformance,none,
+     "did you mean to declare %0 as a protocol conformance for %1?", (DeclName, Type))
 
 NOTE(any_as_anyobject_fixit, none,
      "cast 'Any' to 'AnyObject' or use 'as!' to force downcast to a more specific type to access members", ())

lib/Sema/CSDiagnostics.cpp

@@ -31,6 +31,8 @@
 #include "swift/AST/SourceFile.h"
 #include "swift/AST/Stmt.h"
 #include "swift/AST/Types.h"
+#include "swift/AST/GenericEnvironment.h"
+#include "swift/AST/NameLookupRequests.h"
 #include "swift/Basic/SourceLoc.h"
 #include "swift/Parse/Lexer.h"
 #include "llvm/ADT/ArrayRef.h"
@@ -3109,6 +3111,53 @@ DeclName MissingMemberFailure::findCorrectEnumCaseName(
   return (candidate ? candidate->getName() : DeclName());
 }
 
+bool MissingMemberFailure::findUnintendedExtraGenericParam(Type instanceTy, FunctionRefKind functionKind) {
+  auto archetype = instanceTy->getAs<ArchetypeType>();
+  if (!archetype)
+    return false;
+  auto genericTy = archetype->mapTypeOutOfContext()->getAs<GenericTypeParamType>();
+  if (!genericTy)
+    return false;
+  
+  for (auto param : archetype->getGenericEnvironment()->getGenericParams()) {
+    // Find a param at the same depth and one index past the type we're dealing with
+    if (param->getDepth() != genericTy->getDepth() || param->getIndex() != genericTy->getIndex() + 1)
+      continue;
+    
+    auto &cs = getConstraintSystem();
+    auto paramDecl = param->getDecl();
+    auto descriptor = UnqualifiedLookupDescriptor(
+        DeclNameRef(param->getName()), paramDecl->getDeclContext()->getParentForLookup(), paramDecl->getStartLoc(),
+        UnqualifiedLookupFlags::KnownPrivate | UnqualifiedLookupFlags::TypeLookup);
+    auto lookup = evaluateOrDefault(cs.getASTContext().evaluator, UnqualifiedLookupRequest{descriptor}, {});
+    for (auto &result : lookup) {
+      if (auto proto = dyn_cast_or_null<ProtocolDecl>(result.getValueDecl())) {
+        auto memberLookup = cs.performMemberLookup(
+            ConstraintKind::ValueMember, getName().withoutArgumentLabels(),
+            proto->getDeclaredType(), functionKind, getLocator(),
+            /*includeInaccessibleMembers=*/true);
+        if (memberLookup.ViableCandidates.size() || memberLookup.UnviableCandidates.size()) {
+          SourceLoc loc = genericTy->getDecl()->getSourceRange().End;
+          StringRef replacement;
+          
+          if (archetype->getConformsTo().size()) {
+            loc = loc.getAdvancedLoc(archetype->getConformsTo().back()->getName().getLength());
+            replacement = " &";
+          } else {
+            loc = loc.getAdvancedLoc(archetype->getName().getLength());
+            replacement = ":";
+          }
+          emitDiagnosticAt(loc, diag::did_you_mean_generic_param_as_conformance, paramDecl->getName(), archetype)
+              .fixItReplaceChars(loc, loc.getAdvancedLoc(1), replacement);
+          return true;
+        }
+      }
+    }
+    break;
+  }
+  return false;
+}
+
 bool MissingMemberFailure::diagnoseAsError() {
   auto anchor = getRawAnchor();
   auto memberBase = getAnchor();
@@ -3217,6 +3266,7 @@ bool MissingMemberFailure::diagnoseAsError() {
       }
     } else {
       emitBasicError(baseType);
+      findUnintendedExtraGenericParam(instanceTy, FunctionRefKind::DoubleApply);
     }
   } else if (auto moduleTy = baseType->getAs<ModuleType>()) {
     emitDiagnosticAt(::getLoc(memberBase), diag::no_member_of_module,
@@ -3278,6 +3328,7 @@ bool MissingMemberFailure::diagnoseAsError() {
         correction->addFixits(diagnostic);
       } else {
         emitBasicError(baseType);
+        findUnintendedExtraGenericParam(baseType, FunctionRefKind::SingleApply);
       }
     }
   }

lib/Sema/CSDiagnostics.h

@@ -1066,6 +1066,8 @@ class MissingMemberFailure final : public InvalidMemberRefFailure {
   static DeclName findCorrectEnumCaseName(Type Ty,
                                           TypoCorrectionResults &corrections,
                                           DeclNameRef memberName);
+  
+  bool findUnintendedExtraGenericParam(Type instanceTy, FunctionRefKind functionKind);
 };
 
 /// Diagnose cases where a member only accessible on generic constraints

test/Sema/diag_unintended_generic_param.swift

@@ -0,0 +1,24 @@
+// RUN: %target-typecheck-verify-swift
+
+protocol Proto {
+  init?(string: String)
+  func foo()
+}
+
+struct TypedFoo<T: Hashable, Proto> {
+  // expected-note@-1 {{did you mean to declare 'Proto' as a protocol conformance for 'T'?}} {{28-29= &}}
+  func foo(value: String) {
+    if let str = T.init(string:value) { // expected-error {{type 'T' has no member 'init'}}
+      print(str)
+    }
+  }
+}
+
+func bar<T, Proto>(arg: T) { // expected-error {{generic parameter 'Proto' is not used in function signature}}
+  // expected-note@-1 {{did you mean to declare 'Proto' as a protocol conformance for 'T'?}} {{11-12=:}}
+  arg.foo() // expected-error {{value of type 'T' has no member 'foo'}}
+}
+
+func baz<T: Hashable, Proto>(arg: T) { // expected-error {{generic parameter 'Proto' is not used in function signature}}
+  arg.ugh() // expected-error {{value of type 'T' has no member 'ugh'}}
+}