Vendor import of clang trunk r257626:vendor/clang/clang-trunk-r257626

https://llvm.org/svn/llvm-project/cfe/trunk@257626

4 files changed, 124 insertions, 30 deletions

diff --git a/test/SemaCXX/anonymous-union.cpp b/test/SemaCXX/anonymous-union.cpp
index 3520245a03a8..0b654266f75f 100644
--- a/test/SemaCXX/anonymous-union.cpp
+++ b/test/SemaCXX/anonymous-union.cpp
@@ -62,11 +62,11 @@ void test_unqual_references(X x, const X xc) {
 
 struct Redecl {
   int x; // expected-note{{previous declaration is here}}
-  class y { };
+  class y { }; // expected-note{{previous declaration is here}}
 
   union {
     int x; // expected-error{{member of anonymous union redeclares 'x'}}
-    float y;
+    float y; // expected-error{{member of anonymous union redeclares 'y'}}
     double z; // expected-note{{previous declaration is here}}
     double zz; // expected-note{{previous definition is here}}
   };
diff --git a/test/SemaCXX/conversion.cpp b/test/SemaCXX/conversion.cpp
index b8f0e076a2bc..4c4089c6aae7 100644
--- a/test/SemaCXX/conversion.cpp
+++ b/test/SemaCXX/conversion.cpp
@@ -77,30 +77,8 @@ void test3() {
   // CHECK: note: expanded from macro 'FINIT'
 #define FINIT int a3 = NULL;
   FINIT // expected-warning {{implicit conversion of NULL constant to 'int'}}
-
-  // we don't catch the case of #define FOO NULL ... int i = FOO; but that seems a bit narrow anyway
-  // and avoiding that helps us skip these cases:
-#define NULL_COND(cond) ((cond) ? &a : NULL)
-  bool bl2 = NULL_COND(true); // don't warn on NULL conversion through the conditional operator across a macro boundary
-  if (NULL_COND(true))
-    ;
-  while (NULL_COND(true))
-    ;
-  for (; NULL_COND(true); )
-    ;
-  do ;
-  while(NULL_COND(true));
-
-#define NULL_WRAPPER NULL_COND(false)
-  if (NULL_WRAPPER)
-    ;
-  while (NULL_WRAPPER)
-    ;
-  for (; NULL_WRAPPER;)
-    ;
-  do
-    ;
-  while (NULL_WRAPPER);
+  // we don't catch the case of #define FOO NULL ... int i = FOO; but that
+  // seems a bit narrow anyway and avoiding that helps us skip other cases.
 
   int *ip = NULL;
   int (*fp)() = NULL;
@@ -116,9 +94,9 @@ namespace test4 {
   // FIXME: We should warn for non-dependent args (only when the param type is also non-dependent) only once
   // not once for the template + once for every instantiation
   template<typename T>
-  void tmpl(char c = NULL, // expected-warning 4 {{implicit conversion of NULL constant to 'char'}}
+  void tmpl(char c = NULL, // expected-warning 3 {{implicit conversion of NULL constant to 'char'}}
             T a = NULL, // expected-warning {{implicit conversion of NULL constant to 'char'}} \
-                           expected-warning 2 {{implicit conversion of NULL constant to 'int'}}
+                           expected-warning {{implicit conversion of NULL constant to 'int'}}
             T b = 1024) { // expected-warning {{implicit conversion from 'int' to 'char' changes value from 1024 to 0}}
   }
 
@@ -129,8 +107,7 @@ namespace test4 {
   void func() {
     tmpl<char>(); // expected-note 2 {{in instantiation of default function argument expression for 'tmpl<char>' required here}}
     tmpl<int>(); // expected-note 2 {{in instantiation of default function argument expression for 'tmpl<int>' required here}}
-    // FIXME: We should warn only once for each template instantiation - not once for each call
-    tmpl<int>(); // expected-note 2 {{in instantiation of default function argument expression for 'tmpl<int>' required here}}
+    tmpl<int>();
     tmpl2<int*>();
   }
 }
@@ -157,3 +134,97 @@ namespace test7 {
     return nullptr; // expected-warning {{implicit conversion of nullptr constant to 'bool'}}
   }
 }
+
+namespace test8 {
+  #define NULL_COND(cond) ((cond) ? &num : NULL)
+  #define NULL_WRAPPER NULL_COND(false)
+
+  // don't warn on NULL conversion through the conditional operator across a
+  // macro boundary
+  void macro() {
+    int num;
+    bool b = NULL_COND(true);
+    if (NULL_COND(true)) {}
+    while (NULL_COND(true)) {}
+    for (;NULL_COND(true);) {}
+    do {} while (NULL_COND(true));
+
+    if (NULL_WRAPPER) {}
+    while (NULL_WRAPPER) {}
+    for (;NULL_WRAPPER;) {}
+    do {} while (NULL_WRAPPER);
+  }
+
+  // Identical to the previous function except with a template argument.
+  // This ensures that template instantiation does not introduce any new
+  // warnings.
+  template <typename X>
+  void template_and_macro() {
+    int num;
+    bool b = NULL_COND(true);
+    if (NULL_COND(true)) {}
+    while (NULL_COND(true)) {}
+    for (;NULL_COND(true);) {}
+    do {} while (NULL_COND(true));
+
+    if (NULL_WRAPPER) {}
+    while (NULL_WRAPPER) {}
+    for (;NULL_WRAPPER;) {}
+    do {} while (NULL_WRAPPER);
+  }
+
+  // Identical to the previous function except the template argument affects
+  // the conditional statement.
+  template <typename X>
+  void template_and_macro2() {
+    X num;
+    bool b = NULL_COND(true);
+    if (NULL_COND(true)) {}
+    while (NULL_COND(true)) {}
+    for (;NULL_COND(true);) {}
+    do {} while (NULL_COND(true));
+
+    if (NULL_WRAPPER) {}
+    while (NULL_WRAPPER) {}
+    for (;NULL_WRAPPER;) {}
+    do {} while (NULL_WRAPPER);
+  }
+
+  void run() {
+    template_and_macro<int>();
+    template_and_macro<double>();
+    template_and_macro2<int>();
+    template_and_macro2<double>();
+  }
+}
+
+// Don't warn on a nullptr to bool conversion when the nullptr is the return
+// type of a function.
+namespace test9 {
+  typedef decltype(nullptr) nullptr_t;
+  nullptr_t EXIT();
+
+  bool test() {
+    return EXIT();
+  }
+}
+
+// Test NULL macro inside a macro has same warnings nullptr inside a macro.
+namespace test10 {
+#define test1(cond) \
+      ((cond) ? nullptr : NULL)
+#define test2(cond) \
+      ((cond) ? NULL : nullptr)
+
+#define assert(cond) \
+      ((cond) ? foo() : bar())
+  void foo();
+  void bar();
+
+  void run(int x) {
+    if (test1(x)) {}
+    if (test2(x)) {}
+    assert(test1(x));
+    assert(test2(x));
+  }
+}
diff --git a/test/SemaCXX/linkage-invalid-decl.cpp b/test/SemaCXX/linkage-invalid-decl.cpp
new file mode 100644
index 000000000000..0a991baf9d7d
--- /dev/null
+++ b/test/SemaCXX/linkage-invalid-decl.cpp
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// This invalid declaration used to call infinite recursion in linkage
+// calculation for enum as a function argument.
+inline foo(A)(enum E;
+// expected-error@-1 {{unknown type name 'foo'}}
+// expected-error@-2 {{ISO C++ forbids forward references to 'enum' types}}
+// expected-error@-3 {{expected ')'}}
+// expected-note@-4 {{to match this '('}}
diff --git a/test/SemaCXX/pass-object-size.cpp b/test/SemaCXX/pass-object-size.cpp
index bec0c1c55f29..94c9cc9c8aa0 100644
--- a/test/SemaCXX/pass-object-size.cpp
+++ b/test/SemaCXX/pass-object-size.cpp
@@ -120,3 +120,17 @@ void Bar() {
   (void)+[](void *const p __attribute__((pass_object_size(0)))) {}; //expected-error-re{{invalid argument type '(lambda at {{.*}})' to unary expression}}
 }
 }
+
+namespace ovlbug {
+// Directly calling an address-of function expression (e.g. in (&foo)(args...))
+// doesn't go through regular address-of-overload logic. This caused the above
+// code to generate an ICE.
+void DirectAddrOf(void *__attribute__((pass_object_size(0))));
+void DirectAddrOfOvl(void *__attribute__((pass_object_size(0))));
+void DirectAddrOfOvl(int *);
+
+void Test() {
+  (&DirectAddrOf)(nullptr); //expected-error{{cannot take address of function 'DirectAddrOf' because parameter 1 has pass_object_size attribute}}
+  (&DirectAddrOfOvl)((char*)nullptr); //expected-error{{no matching function}} expected-note@129{{candidate address cannot be taken because parameter 1 has pass_object_size attribute}} expected-note@130{{candidate function not viable: no known conversion from 'char *' to 'int *' for 1st argument}}
+}
+}