Improve diagnostics for unbound archetypes coming from a type, to indicate

information about where the archetype was defined.  Before:

t.swift:6:17: error: generic parameter 'T' could not be inferred
var a : Int = A.foo()
                ^

After:

t.swift:6:17: error: generic parameter 'T' could not be inferred
var a : Int = A.foo()
                ^
t.swift:2:8: note: 'T' declared as parameter to type 'A'
struct A<T> {
       ^

Author: lattner

include/swift/AST/DiagnosticsSema.def

@@ -595,6 +595,7 @@ NOTE(note_call_to_initializer,none,
 NOTE(note_init_parameter,none,
      "in initialization of parameter %0", (Identifier))
 
+
 ERROR(missing_nullary_call,none,
      "function produces expected type %0; did you mean to call it with '()'?",
      (Type))
@@ -672,6 +673,8 @@ ERROR(unbound_generic_parameter,none,
       "generic parameter %0 could not be inferred", (Type))
 ERROR(unbound_generic_parameter_cast,none,
       "generic parameter %0 could not be inferred in cast to %1", (Type, Type))
+NOTE(archetype_declared_in_type,none,
+     "%0 declared as parameter to type %1", (Type, Type))
 
 
 ERROR(string_index_not_integer,none,

lib/Sema/CSDiag.cpp

@@ -4733,6 +4733,12 @@ static void diagnoseUnboundArchetype(Expr *overallExpr,
     tc.diagnose(ECE->getLoc(), diag::unbound_generic_parameter_cast,
                 archetype, ECE->getCastTypeLoc().getType())
       .highlight(ECE->getCastTypeLoc().getSourceRange());
+
+    // Emit a note specifying where this came from, if we can find it.
+    if (auto *ND = ECE->getCastTypeLoc().getType()
+          ->getNominalOrBoundGenericNominal())
+      tc.diagnose(ND, diag::archetype_declared_in_type, archetype,
+                  ND->getDeclaredType());
     return;
   }
 
@@ -4744,19 +4750,28 @@ static void diagnoseUnboundArchetype(Expr *overallExpr,
   // If we have an anchor, drill into it to emit a
   // "note: archetype declared here".
   if (!anchor) return;
-  
+
+
+  if (auto TE = dyn_cast<TypeExpr>(anchor)) {
+    if (auto *ND = TE->getInstanceType()->getNominalOrBoundGenericNominal())
+      tc.diagnose(ND, diag::archetype_declared_in_type, archetype,
+                  ND->getDeclaredType());
+    return;
+  }
+
   ConcreteDeclRef resolved;
 
   // Simple case: direct reference to a declaration.
   if (auto dre = dyn_cast<DeclRefExpr>(anchor))
     resolved = dre->getDeclRef();
 
   // Simple case: direct reference to a declaration.
-  if (auto mre = dyn_cast<MemberRefExpr>(anchor))
-    resolved = mre->getMember();
+  if (auto MRE = dyn_cast<MemberRefExpr>(anchor))
+    resolved = MRE->getMember();
 
-  if (auto ctorRef = dyn_cast<OtherConstructorDeclRefExpr>(anchor))
-    resolved = ctorRef->getDeclRef();
+  if (auto OCDRE = dyn_cast<OtherConstructorDeclRefExpr>(anchor))
+    resolved = OCDRE->getDeclRef();
+
 
   // We couldn't resolve the locator to a declaration, so we're done.
   if (!resolved)

test/Constraints/construction.swift

@@ -20,7 +20,7 @@ enum Z {
   init(_ x: Int, _ y: Int) { self = .point(x, y) }
 }
 
-enum Optional<T> {
+enum Optional<T> {  // expected-note {{'T' declared as parameter to type 'Optional'}}
   case none
   case value(T)
 

test/Constraints/generics.swift

@@ -185,7 +185,7 @@ func r22509125<T>(a : T?) { // expected-note {{in call to function 'r22509125'}}
 
 
 // <rdar://problem/24267414> QoI: error: cannot convert value of type 'Int' to specified type 'Int'
-struct R24267414<T> {
+struct R24267414<T> {  // expected-note {{'T' declared as parameter to type 'R24267414'}}
   static func foo() -> Int {}
 }
 var _ : Int = R24267414.foo() // expected-error {{generic parameter 'T' could not be inferred}}

test/Constraints/incomplete_function_ref.swift

@@ -1,6 +1,6 @@
 // RUN: %target-parse-verify-swift
 
-struct MyCollection<Element> {
+struct MyCollection<Element> {  // expected-note {{'Element' declared as parameter to type 'MyCollection'}}
   func map<T>(transform: (Element) -> T) -> MyCollection<T> {
     fatalError("implement")
   }