Whenever we complain about a failed initialization of a function or

method parameter, provide a note pointing at the parameter itself so
the user does not have to manually look for the function/method being
called and match up parameters to arguments. For example, we now get:

t.c:4:5: warning: incompatible pointer types passing 'long *' to
parameter of
      type 'int *' [-pedantic]
  f(long_ptr);
    ^~~~~~~~
t.c:1:13: note: passing argument to parameter 'x' here
void f(int *x);
            ^

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@102038 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td
index eb53d6ca3847ba02d3a392a63ba39ffb4587ef55..aad880a7dd6a416ae43d385f881b8720a21f2cd3 100644 (file)
--- a/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/include/clang/Basic/DiagnosticSemaKinds.td
@@ -2077,7 +2077,10 @@ def warn_setter_getter_impl_required_in_category : Warning<
   "use @dynamic or provide a method implementation in category">;
 def note_property_impl_required : Note<
   "implementation is here">;
-
+def note_parameter_named_here : Note<
+  "passing argument to parameter %0 here">;
+def note_parameter_here : Note<
+  "passing argument to parameter here">;
 
 // C++ casts
 // These messages adhere to the TryCast pattern: %0 is an int specifying the

diff --git a/lib/Sema/Sema.h b/lib/Sema/Sema.h
index a284803ed6bef4e52c9f719555fe9686e37b7a0b..5333684522a5ba6013f8c8977c3890d8b7dfb2fb 100644 (file)
--- a/lib/Sema/Sema.h
+++ b/lib/Sema/Sema.h
@@ -4076,7 +4076,8 @@ public:
   bool DiagnoseAssignmentResult(AssignConvertType ConvTy,
                                 SourceLocation Loc,
                                 QualType DstType, QualType SrcType,
-                                Expr *SrcExpr, AssignmentAction Action);
+                                Expr *SrcExpr, AssignmentAction Action,
+                                bool *Complained = 0);
 
   /// CheckAssignmentConstraints - Perform type checking for assignment,
   /// argument passing, variable initialization, and function return values.

diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp
index 265f44c999a919e740da840c216828cbfa1a98e5..3621f70ffcb910ad4dd49969c7b0d671870b9769 100644 (file)
--- a/lib/Sema/SemaExpr.cpp
+++ b/lib/Sema/SemaExpr.cpp
@@ -7036,7 +7036,11 @@ static void MakeObjCStringLiteralFixItHint(Sema& SemaRef, QualType DstType,
 bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
                                     SourceLocation Loc,
                                     QualType DstType, QualType SrcType,
-                                    Expr *SrcExpr, AssignmentAction Action) {
+                                    Expr *SrcExpr, AssignmentAction Action,
+                                    bool *Complained) {
+  if (Complained)
+    *Complained = false;
+
   // Decode the result (notice that AST's are still created for extensions).
   bool isInvalid = false;
   unsigned DiagKind;
@@ -7121,6 +7125,8 @@ bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
   
   Diag(Loc, DiagKind) << FirstType << SecondType << Action
     << SrcExpr->getSourceRange() << Hint;
+  if (Complained)
+    *Complained = true;
   return isInvalid;
 }
 

diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp
index 6a9efbddbdf716bbfb678af0516e0d71164c39f6..eae5f63efa5f21e939d3a2b2ec55d03a39c611e2 100644 (file)
--- a/lib/Sema/SemaInit.cpp
+++ b/lib/Sema/SemaInit.cpp
@@ -3308,6 +3308,20 @@ static Sema::OwningExprResult CopyObject(Sema &S,
                                  move_arg(ConstructorArgs));
 }
 
+void InitializationSequence::PrintInitLocationNote(Sema &S,
+                                              const InitializedEntity &Entity) {
+  if (Entity.getKind() == InitializedEntity::EK_Parameter && Entity.getDecl()) {
+    if (Entity.getDecl()->getLocation().isInvalid())
+      return;
+
+    if (Entity.getDecl()->getDeclName())
+      S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_named_here)
+        << Entity.getDecl()->getDeclName();
+    else
+      S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_here);
+  }
+}
+
 Action::OwningExprResult 
 InitializationSequence::Perform(Sema &S,
                                 const InitializedEntity &Entity,
@@ -3474,6 +3488,7 @@ InitializationSequence::Perform(Sema &S,
         S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
           << Entity.getType().isVolatileQualified()
           << CurInitExpr->getSourceRange();
+        PrintInitLocationNote(S, Entity);
         return S.ExprError();
       }
         
@@ -3695,10 +3710,16 @@ InitializationSequence::Perform(Sema &S,
             == Sema::Compatible)
         ConvTy = Sema::Compatible;
 
+      bool Complained;
       if (S.DiagnoseAssignmentResult(ConvTy, Kind.getLocation(),
                                      Step->Type, SourceType,
-                                     CurInitExpr, getAssignmentAction(Entity)))
+                                     CurInitExpr, 
+                                     getAssignmentAction(Entity),
+                                     &Complained)) {
+        PrintInitLocationNote(S, Entity);
         return S.ExprError();
+      } else if (Complained)
+        PrintInitLocationNote(S, Entity);
 
       CurInit.release();
       CurInit = S.Owned(CurInitExpr);
@@ -3972,6 +3993,7 @@ bool InitializationSequence::Diagnose(Sema &S,
     break;
   }
   
+  PrintInitLocationNote(S, Entity);
   return true;
 }
 

diff --git a/lib/Sema/SemaInit.h b/lib/Sema/SemaInit.h
index ba11470d24a3aae28aa4319396db81efa02709b4..5f2592fb77cf4cb69b65d183575986227ba6120f 100644 (file)
--- a/lib/Sema/SemaInit.h
+++ b/lib/Sema/SemaInit.h
@@ -542,7 +542,11 @@ private:
   
   /// \brief The candidate set created when initialization failed.
   OverloadCandidateSet FailedCandidateSet;
-  
+
+  /// \brief Prints a follow-up note that highlights the location of
+  /// the initialized entity, if it's remote.
+  void PrintInitLocationNote(Sema &S, const InitializedEntity &Entity);
+
 public:
   /// \brief Try to perform initialization of the given entity, creating a 
   /// record of the steps required to perform the initialization.

diff --git a/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p2.cpp b/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p2.cpp
index f9bac40c9ddbe43d8dd7d3333076573e9ad5e5dc..30393961b3f38bcffc7d7d0a2f4165c83bfa097a 100644 (file)
--- a/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p2.cpp
+++ b/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p2.cpp
@@ -36,7 +36,7 @@ namespace Numbers {
     double d;
   };
   Number zero(0.0f);
-  void g(Number);
+  void g(Number); // expected-note 2{{passing argument to parameter here}}
 }
 
 void test2() {

diff --git a/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p1.cpp b/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p1.cpp
index 3581f79b0adfa90bbe28d0ecf13946ff938890c1..c51c2cacc3212b66622132072e56ad76cd84ceb3 100644 (file)
--- a/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p1.cpp
+++ b/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p1.cpp
@@ -12,7 +12,8 @@ namespace Test0 {
   test<1> foo(class foo);
 
   namespace A {
-    test<2> foo(class ::foo); // expected-note {{candidate}}
+    test<2> foo(class ::foo); // expected-note {{candidate}} \
+    // expected-note{{passing argument to parameter here}}
 
     void test0() {
       using ::foo;

diff --git a/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p5.cpp b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p5.cpp
index 7ee052c5f9cb71f840d0269ceb12fdedd761d860..3100e56a080edc7e8c7bc452e759962c2c224c0e 100644 (file)
--- a/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p5.cpp
+++ b/test/CXX/dcl.decl/dcl.meaning/dcl.fct.default/p5.cpp
@@ -2,7 +2,8 @@
 
 float global_f;
 
-void f0(int *ip = &global_f); // expected-error{{cannot initialize}}
+void f0(int *ip = &global_f); // expected-error{{cannot initialize}} \
+// expected-note{{passing argument to parameter 'ip' here}}
 
 // Example from C++03 standard
 int a = 1; 

diff --git a/test/PCH/functions.c b/test/PCH/functions.c
index 5d7849e12931a0ae4f5d7afbca1e92b5129a7bfa..23becb60e8ed47480ec249f4a8969a28cf5966df 100644 (file)
--- a/test/PCH/functions.c
+++ b/test/PCH/functions.c
@@ -6,7 +6,7 @@
 // RUN: %clang_cc1 -include-pch %t -fsyntax-only -verify %s 
 
 int f0(int x0, int y0, ...) { return x0 + y0; }
-
+// expected-note{{passing argument to parameter here}}
 float *test_f1(int val, double x, double y) {
   if (val > 5)
     return f1(x, y);

diff --git a/test/PCH/functions.h b/test/PCH/functions.h
index 39724300816a04f94c46ece4ccf5cdbb1f6b630c..f57400fc846b0fe97067a2c239b3cbdfa0be0abd 100644 (file)
--- a/test/PCH/functions.h
+++ b/test/PCH/functions.h
@@ -1,6 +1,9 @@
 /* For use with the functions.c test */
 
-int f0(int x, int y, ...);
+
+
+
+int f0(int x, int y, ...); 
 float *f1(float x, float y);
 
 void g0(int *);

diff --git a/test/Sema/array-constraint.c b/test/Sema/array-constraint.c
index 8b577fa5d701ae2ad1643637bcad60e40e9e6cfe..9fcac25abe968f1e568e5dce5c8d21a9efc15bb1 100644 (file)
--- a/test/Sema/array-constraint.c
+++ b/test/Sema/array-constraint.c
@@ -43,7 +43,7 @@ void check_size() {
 static int I;
 typedef int TA[I]; // expected-error {{variable length array declaration not allowed at file scope}}
 
-void strFunc(char *);
+void strFunc(char *); // expected-note{{passing argument to parameter here}}
 const char staticAry[] = "test";
 void checkStaticAry() { 
   strFunc(staticAry); // expected-warning{{passing 'char const [5]' to parameter of type 'char *' discards qualifiers}}

diff --git a/test/Sema/attr-format.c b/test/Sema/attr-format.c
index 0fadf98f978f2ed32427b880a6a5563ccbad8156..a223e08f5a4848f05f65b3f111511c4885fa027e 100644 (file)
--- a/test/Sema/attr-format.c
+++ b/test/Sema/attr-format.c
@@ -45,7 +45,7 @@ void e2(char *str, int c, ...) __attribute__((format(printf0, 2,3))); // expecte
 // FreeBSD usage
 #define __printf0like(fmt,va) __attribute__((__format__(__printf0__,fmt,va)))
 void null(int i, const char *a, ...) __printf0like(2,0); // no-error
-void null(int i, const char *a, ...) {
+void null(int i, const char *a, ...) { // expected-note{{passing argument to parameter 'a' here}}
   if (a)
     (void)0/* vprintf(...) would go here */;
 }

diff --git a/test/Sema/block-misc.c b/test/Sema/block-misc.c
index e31cdb5bcd07bc232116c7ad91c6cd8621fa9a6f..accd4bac14708842a4254c16aa4b590c19772e11 100644 (file)
--- a/test/Sema/block-misc.c
+++ b/test/Sema/block-misc.c
@@ -139,7 +139,7 @@ void test14() {
 
 enum { LESS };
 
-void foo(long (^comp)()) {
+void foo(long (^comp)()) { // expected-note{{passing argument to parameter 'comp' here}}
 }
 
 void (^test15f)(void);

diff --git a/test/Sema/format-strings.c b/test/Sema/format-strings.c
index dcc4c35d01ecae0186996feba3ff4d512eab1364..bdc2bb0c9abeaa8b213c1b876463d5fe408f2ee0 100644 (file)
--- a/test/Sema/format-strings.c
+++ b/test/Sema/format-strings.c
@@ -4,7 +4,7 @@
 typedef __typeof(sizeof(int)) size_t;
 typedef struct _FILE FILE;
 int fprintf(FILE *, const char *restrict, ...);
-int printf(const char *restrict, ...);
+int printf(const char *restrict, ...); // expected-note{{passing argument to parameter here}}
 int snprintf(char *restrict, size_t, const char *restrict, ...);
 int sprintf(char *restrict, const char *restrict, ...);
 int vasprintf(char **, const char *, va_list);
@@ -12,7 +12,7 @@ int asprintf(char **, const char *, ...);
 int vfprintf(FILE *, const char *restrict, va_list);
 int vprintf(const char *restrict, va_list);
 int vsnprintf(char *, size_t, const char *, va_list);
-int vsprintf(char *restrict, const char *restrict, va_list);
+int vsprintf(char *restrict, const char *restrict, va_list); // expected-note{{passing argument to parameter here}}
 
 char * global_fmt;
 

diff --git a/test/Sema/incompatible-sign.c b/test/Sema/incompatible-sign.c
index b3c1e9a44e826054b0b7272e90a16957a6c2cb21..6249feb6b1e711aa2d99429fb2f6b2e1d126c391 100644 (file)
--- a/test/Sema/incompatible-sign.c
+++ b/test/Sema/incompatible-sign.c
@@ -1,5 +1,5 @@
 // RUN: %clang_cc1 %s -verify -fsyntax-only
 
-int a(int* x);
+int a(int* x); // expected-note{{passing argument to parameter 'x' here}}
 int b(unsigned* y) { return a(y); } // expected-warning {{passing 'unsigned int *' to parameter of type 'int *' converts between pointers to integer types with different sign}}
 

diff --git a/test/Sema/predefined-function.c b/test/Sema/predefined-function.c
index 74bc86fa57073ef5a6ab540ec3ae9160eaac123a..1c40b6e8c2c0ec30f1c9fa3f7733ed4f5d352d89 100644 (file)
--- a/test/Sema/predefined-function.c
+++ b/test/Sema/predefined-function.c
@@ -4,7 +4,8 @@ char *funk(int format);
 enum Test {A=-1};
 char *funk(enum Test x);
 
-int eli(float b); // expected-note {{previous declaration is here}}
+int eli(float b); // expected-note {{previous declaration is here}} \
+// expected-note{{passing argument to parameter 'b' here}}
 int b(int c) {return 1;}
 
 int foo();

diff --git a/test/Sema/transparent-union.c b/test/Sema/transparent-union.c
index 03f6a53d059a04834c5cb6084c4980a65290a1b2..cdfc8506d1b5d5b50dc4bdac803d494f8c7c48b6 100644 (file)
--- a/test/Sema/transparent-union.c
+++ b/test/Sema/transparent-union.c
@@ -4,7 +4,7 @@ typedef union {
   float *fp;
 } TU __attribute__((transparent_union));
 
-void f(TU);
+void f(TU); // expected-note{{passing argument to parameter here}}
 
 void g(int *ip, float *fp, char *cp) {
   f(ip);

diff --git a/test/Sema/vector-assign.c b/test/Sema/vector-assign.c
index e06072928d4b87fa3dd49ef5877c78109f787e7c..05fc3b13db0c94e605dd324af7686488d7b6f5a6 100644 (file)
--- a/test/Sema/vector-assign.c
+++ b/test/Sema/vector-assign.c
@@ -47,7 +47,7 @@ float test2(__attribute__((vector_size(16))) float a, int b) {
 typedef long long __attribute__((__vector_size__(2 * sizeof(long long))))
 longlongvec;
 
-void test3a(longlongvec *);
+void test3a(longlongvec *); // expected-note{{passing argument to parameter here}}
 void test3(const unsigned *src) {
   test3a(src);  // expected-warning {{incompatible pointer types passing 'unsigned int const *' to parameter of type 'longlongvec *'}}
 }

diff --git a/test/Sema/vector-cast.c b/test/Sema/vector-cast.c
index e655147d445d21ea649161ac248711801b34993c..a717e8611019140d923a6bc9028cec9391a3b685 100644 (file)
--- a/test/Sema/vector-cast.c
+++ b/test/Sema/vector-cast.c
@@ -30,7 +30,7 @@ type 't1' and integer type 'short' of different size}}
 }
 
 
-void f2(t2 X);
+void f2(t2 X); // expected-note{{passing argument to parameter 'X' here}}
 
 void f3(t3 Y) {
   f2(Y);  // expected-warning {{incompatible vector types passing 't3' to parameter of type 't2'}}

diff --git a/test/SemaCXX/default1.cpp b/test/SemaCXX/default1.cpp
index 790208aa1d050a93eb8dd8e3700465190d7e67f2..e9d8a2f767bcb224958c33a5ea6ea4a9f259b814 100644 (file)
--- a/test/SemaCXX/default1.cpp
+++ b/test/SemaCXX/default1.cpp
@@ -14,7 +14,8 @@ void h(int i, int j = 2, int k = 3,
        int n);// expected-error {{missing default argument on parameter 'n'}}
 
 struct S { } s;
-void i(int = s) { } // expected-error {{no viable conversion}}
+void i(int = s) { } // expected-error {{no viable conversion}} \
+// expected-note{{passing argument to parameter here}}
 
 struct X { 
   X(int);
@@ -26,6 +27,8 @@ struct Y { // expected-note 2{{candidate}}
   explicit Y(int);
 };
 
-void k(Y y = 17); // expected-error{{no viable conversion}}
+void k(Y y = 17); // expected-error{{no viable conversion}} \
+// expected-note{{passing argument to parameter 'y' here}}
 
-void kk(Y = 17); // expected-error{{no viable conversion}}
+void kk(Y = 17); // expected-error{{no viable conversion}} \
+// expected-note{{passing argument to parameter here}}

diff --git a/test/SemaCXX/default2.cpp b/test/SemaCXX/default2.cpp
index a0999c0c4c62a114b578eb7aa79616e821a9f368..d9f1edf3b2a11db9305409ee54d38084e7426bdf 100644 (file)
--- a/test/SemaCXX/default2.cpp
+++ b/test/SemaCXX/default2.cpp
@@ -102,7 +102,8 @@ void test_Z(const Z& z) {
 struct ZZ {
   static ZZ g(int = 17);
 
-  void f(ZZ z = g()); // expected-error{{no matching constructor for initialization}}
+  void f(ZZ z = g()); // expected-error{{no matching constructor for initialization}} \
+  // expected-note{{passing argument to parameter 'z' here}}
 
   ZZ(ZZ&, int = 17); // expected-note{{candidate constructor}}
 };

diff --git a/test/SemaCXX/elaborated-type-specifier.cpp b/test/SemaCXX/elaborated-type-specifier.cpp
index 3cd3a1bc224101ae594ac3f8cd0e134933d943ac..2d0b571e02733b0b7533ecbb936eac85e9b27f46 100644 (file)
--- a/test/SemaCXX/elaborated-type-specifier.cpp
+++ b/test/SemaCXX/elaborated-type-specifier.cpp
@@ -22,7 +22,7 @@ namespace NS {
     void test_elab2(struct S4 *s4);
   };
 
-  void X::test_elab2(S4 *s4) { }
+  void X::test_elab2(S4 *s4) { } // expected-note{{passing argument to parameter 's4' here}}
 }
 
 void test_X_elab(NS::X x) {

diff --git a/test/SemaCXX/member-location.cpp b/test/SemaCXX/member-location.cpp
index c3099d25e0e1b46504a331284c9b2e3019764a30..6f7e1f577519a394e2d6c73c78edae0205db5441 100644 (file)
--- a/test/SemaCXX/member-location.cpp
+++ b/test/SemaCXX/member-location.cpp
@@ -1,5 +1,8 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // PR4103: Make sure we have a location for the error
-class A { float a(int *); int b(); };
+class A { 
+  float a(int *); // expected-note{{passing argument to parameter here}}
+  int b(); 
+};
 int A::b() { return a(a((int*)0)); } // expected-error {{cannot initialize a parameter of type 'int *' with an rvalue of type 'float'}}
 

diff --git a/test/SemaCXX/overload-call.cpp b/test/SemaCXX/overload-call.cpp
index 472e805c29c8106ab24f193aec0c6f6e253bb579..feec9df6b7a566d4e7f8a84ffe2457484936738e 100644 (file)
--- a/test/SemaCXX/overload-call.cpp
+++ b/test/SemaCXX/overload-call.cpp
@@ -425,7 +425,7 @@ namespace PR6078 {
 namespace PR6177 {
   struct String { String(char const*); };
 
-  void f(bool const volatile&);
+  void f(bool const volatile&); // expected-note{{passing argument to parameter here}}
   void f(String);
 
   void g() { f(""); } // expected-error{{volatile lvalue reference to type 'bool const volatile' cannot bind to a value of unrelated type 'char const [1]'}}

diff --git a/test/SemaCXX/ref-init-ambiguous.cpp b/test/SemaCXX/ref-init-ambiguous.cpp
index 8844162052d9a6c769cab773ddb61cb6d722b9a2..a8e95a39539d50b05b34d3efa43f090d49911d85 100644 (file)
--- a/test/SemaCXX/ref-init-ambiguous.cpp
+++ b/test/SemaCXX/ref-init-ambiguous.cpp
@@ -17,7 +17,7 @@ void test(C c) {
   const E2 &e2 = c; // expected-error {{reference initialization of type 'E2 const &' with initializer of type 'C' is ambiguous}}
 }
 
-void foo(const E2 &);
+void foo(const E2 &);// expected-note{{passing argument to parameter here}}
 
 const E2 & re(C c) {
     foo(c); // expected-error {{reference initialization of type 'E2 const &' with initializer of type 'C' is ambiguous}}

diff --git a/test/SemaObjC/argument-checking.m b/test/SemaObjC/argument-checking.m
index 19caf3271c681e67535998605acddc29caa25a95..9019a0fb24e4ca26238b892e481068f44a7a37cb 100644 (file)
--- a/test/SemaObjC/argument-checking.m
+++ b/test/SemaObjC/argument-checking.m
@@ -2,14 +2,15 @@
 
 struct S { int a; };
 
-extern int charStarFunc(char *);
-extern int charFunc(char);
+extern int charStarFunc(char *); // expected-note{{passing argument to parameter here}}
+extern int charFunc(char); // expected-note{{passing argument to parameter here}}
 
 @interface Test
 +alloc;
--(int)charStarMeth:(char *)s;
--structMeth:(struct S)s;
--structMeth:(struct S)s :(struct S)s2;
+-(int)charStarMeth:(char *)s; // expected-note{{passing argument to parameter 's' here}}
+-structMeth:(struct S)s; // expected-note{{passing argument to parameter 's' here}}
+-structMeth:(struct S)s 
+   :(struct S)s2; // expected-note{{passing argument to parameter 's2' here}}
 @end
 
 void test() {

diff --git a/test/SemaObjC/block-type-safety.m b/test/SemaObjC/block-type-safety.m
index 2b31cacd73c9739b324b6d12bfe217a275449568..402a658f3e354dd5c8e7bd1c7da540d1de776057 100644 (file)
--- a/test/SemaObjC/block-type-safety.m
+++ b/test/SemaObjC/block-type-safety.m
@@ -4,7 +4,7 @@
 @interface Super  @end
 @interface Sub : Super @end
 
-void f2(void(^f)(Super *)) {
+void f2(void(^f)(Super *)) { // expected-note{{passing argument to parameter 'f' here}}
     Super *o;
     f(o);
 }
@@ -18,7 +18,7 @@ void r0(Super* (^f)()) {
      Super *o = f();
 }
 
-void r1(Sub* (^f)()) {
+void r1(Sub* (^f)()) { // expected-note{{passing argument to parameter 'f' here}}
     Sub *o = f();
 }
 
@@ -95,7 +95,7 @@ void test2(void)
 @end
 
 @protocol P, P2;
-void f4(void (^f)(id<P> x)) {
+void f4(void (^f)(id<P> x)) { // expected-note{{passing argument to parameter 'f' here}}
     NSArray<P2> *b;
     f(b);      // expected-warning {{passing 'NSArray<P2> *' to parameter of incompatible type 'id<P>'}}
 }

diff --git a/test/SemaObjC/blocks.m b/test/SemaObjC/blocks.m
index 10239e5488d076cf8c8cb78ec74728f597bded32..15aa5811cc53518a0be4dc98c042c5b0acaf94f4 100644 (file)
--- a/test/SemaObjC/blocks.m
+++ b/test/SemaObjC/blocks.m
@@ -21,7 +21,7 @@ void foo4(id (^objectCreationBlock)(int)) {
     return bar4(objectCreationBlock);
 }
 
-void bar5(id(^)(void));
+void bar5(id(^)(void)); // expected-note{{passing argument to parameter here}}
 void foo5(id (^objectCreationBlock)(int)) {
     return bar5(objectCreationBlock); // expected-error {{incompatible block pointer types passing 'id (^)(int)' to parameter of type 'id (^)(void)'}}
 }

diff --git a/test/SemaObjC/class-method-self.m b/test/SemaObjC/class-method-self.m
index ec0edf1200816839e8019f46519c5f32dcc7d6ad..ba70644ebae8ba61ef371515cef893dd62b65905 100644 (file)
--- a/test/SemaObjC/class-method-self.m
+++ b/test/SemaObjC/class-method-self.m
@@ -3,7 +3,7 @@
 typedef struct objc_class *Class;
 @interface XX
 
-- (void)addObserver:(XX*)o;
+- (void)addObserver:(XX*)o; // expected-note 2{{passing argument to parameter 'o' here}}
 
 @end
 

diff --git a/test/SemaObjC/compatible-protocol-qualified-types.m b/test/SemaObjC/compatible-protocol-qualified-types.m
index 1c9cc2c49472c9a2279ac54e7a9af2d003b85d79..0342622a11e100e7d4ca2796a923f2df3a7ac1e8 100644 (file)
--- a/test/SemaObjC/compatible-protocol-qualified-types.m
+++ b/test/SemaObjC/compatible-protocol-qualified-types.m
@@ -44,7 +44,7 @@ extern NSString * const XCActiveSelectionLevel;
 
 @interface NSTextStorage : NSObject
 
-- (void)setDelegate:(id <NSTextStorageDelegate>)delegate;
+- (void)setDelegate:(id <NSTextStorageDelegate>)delegate; // expected-note{{passing argument to parameter 'delegate' here}}
 - (id <NSTextStorageDelegate>)delegate;
 
 @end

diff --git a/test/SemaObjC/comptypes-legal.m b/test/SemaObjC/comptypes-legal.m
index e318d332f360d6ff3432d88f7070fb4daf12e06e..d83d559ee64c076a2f06a9566f6af270edda8499 100644 (file)
--- a/test/SemaObjC/comptypes-legal.m
+++ b/test/SemaObjC/comptypes-legal.m
@@ -26,7 +26,7 @@ NSObject *ExternFunc (NSObject *filePath, NSObject *key);
 typedef id FuncSignature (NSObject *arg1, Derived *arg2);
 
 @interface Derived: NSObject
-+ (void)registerFunc:(FuncSignature *)function;
++ (void)registerFunc:(FuncSignature *)function; // expected-note{{passing argument to parameter 'function' here}}
 @end
 
 void foo(void)

diff --git a/test/SemaObjC/incompatible-protocol-qualified-types.m b/test/SemaObjC/incompatible-protocol-qualified-types.m
index 23cb50a3629c35f4fcb87d5b803ee1db6e4e489b..494d23e8b267890842841d31cf3618dbc0eb4c9a 100644 (file)
--- a/test/SemaObjC/incompatible-protocol-qualified-types.m
+++ b/test/SemaObjC/incompatible-protocol-qualified-types.m
@@ -8,7 +8,7 @@
 
 @interface INTF @end
 
-INTF <MyProto1> * Func(INTF <MyProto1, MyProto2> *p2)
+INTF <MyProto1> * Func(INTF <MyProto1, MyProto2> *p2) // expected-note{{passing argument to parameter 'p2' here}}
 {
        return p2;
 }

diff --git a/test/SemaObjC/method-arg-qualifier-warning.m b/test/SemaObjC/method-arg-qualifier-warning.m
index a064a7d7a55a6f89ac42d001faa7860fde216ecf..463fb7fd777af4665738629538a4f337f593a125 100644 (file)
--- a/test/SemaObjC/method-arg-qualifier-warning.m
+++ b/test/SemaObjC/method-arg-qualifier-warning.m
@@ -3,7 +3,7 @@
 typedef signed char BOOL;
 
 @interface NSString
-- (BOOL)isEqualToString:(NSString *)aString;
+- (BOOL)isEqualToString:(NSString *)aString; // expected-note 2{{passing argument to parameter 'aString' here}}
 @end
 
 static const NSString * Identifier1 =   @"Identifier1";

diff --git a/test/SemaObjC/protocol-id-test-3.m b/test/SemaObjC/protocol-id-test-3.m
index 89f11c3d75f54e8b1acbfb84ae828d0ff5588713..624bab0c223a910420073c3907f3e1a1f50c74b7 100644 (file)
--- a/test/SemaObjC/protocol-id-test-3.m
+++ b/test/SemaObjC/protocol-id-test-3.m
@@ -8,7 +8,7 @@
 
 @interface INTF @end
 
-id<MyProto1> Func(INTF <MyProto1, MyProto2> *p2)
+id<MyProto1> Func(INTF <MyProto1, MyProto2> *p2) // expected-note 2{{passing argument to parameter 'p2' here}}
 {
        return p2;
 }

diff --git a/test/SemaObjC/protocol-typecheck.m b/test/SemaObjC/protocol-typecheck.m
index 3d98df8aaba06610ed9ac2ef371af269d597c55a..4eb1b2641af2b7f7555ab73220b400a15379621c 100644 (file)
--- a/test/SemaObjC/protocol-typecheck.m
+++ b/test/SemaObjC/protocol-typecheck.m
@@ -9,7 +9,7 @@
 @interface XX
 
 - (void)setFlexElement:(NSObject <PWhatever, XCElementP> *)flexer;
-- (void)setFlexElement2:(NSObject <PWhatever, XCElementSpacerP> *)flexer;
+- (void)setFlexElement2:(NSObject <PWhatever, XCElementSpacerP> *)flexer; // expected-note{{passing argument to parameter 'flexer' here}}
 
 @end
 

diff --git a/test/SemaObjC/warn-incompatible-builtin-types.m b/test/SemaObjC/warn-incompatible-builtin-types.m
index 8806d63baa3f0660a4cc9c77aecf9c4f3e634af1..79c8cea6654543ce7488414ad5b5116603cc6cf9 100644 (file)
--- a/test/SemaObjC/warn-incompatible-builtin-types.m
+++ b/test/SemaObjC/warn-incompatible-builtin-types.m
@@ -2,7 +2,7 @@
 // rdar 7634850
 
 @interface Foo
-- (void)foo:(Class)class;
+- (void)foo:(Class)class; // expected-note{{passing argument to parameter 'class' here}}
 @end
 
 void FUNC() {

diff --git a/test/SemaObjC/warn-superclass-method-mismatch.m b/test/SemaObjC/warn-superclass-method-mismatch.m
index a4005ad2b29310ea456b08e4bf77192aa216b529..52054739d53ec0310e7fab8c8892d32e2da6b0ee 100644 (file)
--- a/test/SemaObjC/warn-superclass-method-mismatch.m
+++ b/test/SemaObjC/warn-superclass-method-mismatch.m
@@ -9,7 +9,7 @@
 @interface Base : Root
 -(void) method: (int*) x; // expected-note {{previous declaration is here}}
 -(void) method1: (Base*) x; // expected-note {{previous declaration is here}}
--(void) method2: (Sub*) x;
+-(void) method2: (Sub*) x; // expected-note{{passing argument to parameter 'x' here}}
 + method3: (int)x1 : (Base *)x2 : (float)x3; // expected-note {{previous declaration is here}}
 + mathod4: (id)x1;
 - method5: (int) x : (double) d; // expected-note {{previous declaration is here}}

diff --git a/test/SemaObjCXX/message.mm b/test/SemaObjCXX/message.mm
index 97ee499aff75aa8194e1a6c0532910a4ae11ada5..b75608e2327afbe869030b1ecb1afb257daf108e 100644 (file)
--- a/test/SemaObjCXX/message.mm
+++ b/test/SemaObjCXX/message.mm
@@ -84,9 +84,11 @@ struct MutableString : public String { };
 
 // C++-specific parameter types
 @interface I5
-- method:(const String&)str1 other:(String&)str2;
+- method:(const String&)str1 
+   other:(String&)str2; // expected-note{{passing argument to parameter 'str2' here}}
 @end
 
 void test_I5(I5 *i5, String s) {
   [i5 method:"hello" other:s];
+  [i5 method:s other:"world"]; // expected-error{{non-const lvalue reference to type 'String' cannot bind to a value of unrelated type 'char const [6]'}}
 }

diff --git a/test/SemaObjCXX/objc-pointer-conv.mm b/test/SemaObjCXX/objc-pointer-conv.mm
index 2504dcedb84de0f5bcf936b3abf34373625a3c3e..cc3264fcc4623dae4ef14a2b79e77cdef5f5c751 100644 (file)
--- a/test/SemaObjCXX/objc-pointer-conv.mm
+++ b/test/SemaObjCXX/objc-pointer-conv.mm
@@ -26,7 +26,7 @@ void RandomFunc(CFMDRef theDict, const void *key, const void *value);
 @end
 
 @interface I
-- (void) Meth : (I*) Arg;
+- (void) Meth : (I*) Arg; // expected-note{{passing argument to parameter 'Arg' here}}
 @end
 
 void Func (I* arg);  // expected-note {{candidate function not viable: no known conversion from 'I const *' to 'I *' for 1st argument}}

diff --git a/test/SemaTemplate/default-expr-arguments.cpp b/test/SemaTemplate/default-expr-arguments.cpp
index d2cc45b0352b2e23d11032c0cb2d94df13fbb520..40b7f2b3cfac2b556188ebc4373686846a376559 100644 (file)
--- a/test/SemaTemplate/default-expr-arguments.cpp
+++ b/test/SemaTemplate/default-expr-arguments.cpp
@@ -7,7 +7,8 @@ C<char>::C(int a0);
 
 struct S { }; // expected-note 3 {{candidate constructor (the implicit copy constructor)}}
 
-template<typename T> void f1(T a, T b = 10) { } // expected-error{{no viable conversion}}
+template<typename T> void f1(T a, T b = 10) { } // expected-error{{no viable conversion}} \
+// expected-note{{passing argument to parameter 'b' here}}
 
 template<typename T> void f2(T a, T b = T()) { }
 
@@ -25,8 +26,10 @@ void g() {
 }
 
 template<typename T> struct F {
-  F(T t = 10); // expected-error{{no viable conversion}}
-  void f(T t = 10); // expected-error{{no viable conversion}}
+  F(T t = 10); // expected-error{{no viable conversion}} \
+  // expected-note{{passing argument to parameter 't' here}}
+  void f(T t = 10); // expected-error{{no viable conversion}} \
+  // expected-note{{passing argument to parameter 't' here}}
 };
 
 struct FD : F<int> { };
@@ -99,7 +102,8 @@ void test_x2(X2<int> x2i, X2<NotDefaultConstructible> x2n) {
 // PR5283
 namespace PR5283 {
 template<typename T> struct A {
-  A(T = 1); // expected-error 3 {{cannot initialize a parameter of type 'int *' with an rvalue of type 'int'}}
+  A(T = 1); // expected-error 3 {{cannot initialize a parameter of type 'int *' with an rvalue of type 'int'}} \
+  // expected-note 3{{passing argument to parameter here}}
 };
 
 struct B : A<int*> { 

diff --git a/test/SemaTemplate/instantiate-member-template.cpp b/test/SemaTemplate/instantiate-member-template.cpp
index c1260cf6a81e2a4c748740860791cd8aea267314..ae8425e716ee6feb93031d3e97e8de294a3d5599 100644 (file)
--- a/test/SemaTemplate/instantiate-member-template.cpp
+++ b/test/SemaTemplate/instantiate-member-template.cpp
@@ -44,7 +44,7 @@ struct X1 {
   
   template<typename U>
   struct Inner3 {
-    void f0(T t, U u) {
+    void f0(T t, U u) { // expected-note{{passing argument to parameter 't' here}}
       (void)(t + u); // expected-error{{invalid operands}}
     }