[clang] NFC: remove trailing white spaces from some tests

clang/test/CXX/drs/dr3xx.cpp

namespace dr384 { // dr384: yes
 
   int main() {
     N1::X<N2::Z> v;
     v.f(0);
   }
 }
 
 namespace dr385 { // dr385: yes
-  struct A { protected: void f(); }; 
+  struct A { protected: void f(); };
   struct B : A { using A::f; };
   struct C : A { void g(B b) { b.f(); } };
   void h(B b) { b.f(); }
 
   struct D { int n; }; // expected-note {{member}}
   struct E : protected D {}; // expected-note {{protected}}
   struct F : E { friend int i(E); };
   int i(E e) { return e.n; } // expected-error {{protected member}}

clang/test/CXX/expr/expr.prim/expr.prim.lambda/p4-1y.cpp

 // RUN: %clang_cc1 -fsyntax-only -std=c++1y %s -verify
 
 int a;
 int &b = [] (int &r) -> decltype(auto) { return r; } (a);
 int &c = [] (int &r) -> decltype(auto) { return (r); } (a);
 int &d = [] (int &r) -> auto & { return r; } (a);
 int &e = [] (int &r) -> auto { return r; } (a); // expected-error {{cannot bind to a temporary}}
 int &f = [] (int r) -> decltype(auto) { return r; } (a); // expected-error {{cannot bind to a temporary}}
 int &g = [] (int r) -> decltype(auto) { return (r); } (a); // expected-warning {{reference to stack}}
 
 
-int test_explicit_auto_return() 
+int test_explicit_auto_return()
 {
     struct X {};
     auto L = [](auto F, auto a) { return F(a); };
     auto M = [](auto a) -> auto { return a; }; // OK
     auto MRef = [](auto b) -> auto& { return b; }; //expected-warning{{reference to stack}}
     auto MPtr = [](auto c) -> auto* { return &c; }; //expected-warning{{address of stack}}
     auto MDeclType = [](auto&& d) -> decltype(auto) { return static_cast<decltype(d)>(d); }; //OK
     M(3);
-    
     auto &&x = MDeclType(X{});
     auto &&x1 = M(X{});
     auto &&x2 = MRef(X{});//expected-note{{in instantiation of}}
     auto &&x3 = MPtr(X{}); //expected-note{{in instantiation of}}
-    return 0;    
+    return 0;
 }
 
-int test_implicit_auto_return() 
-{  
+int test_implicit_auto_return()
+{
   {
     auto M = [](auto a) { return a; };
     struct X {};
     X x = M(X{});
-    
   }
 }
- 
 int test_multiple_returns()  {
-    auto M = [](auto a) { 
+    auto M = [](auto a) {
       bool k;
       if (k)
         return a;
       else
         return 5; //expected-error{{deduced as 'int' here}}
-    }; 
+    };
     M(3); // OK
     M('a'); //expected-note{{in instantiation of}}
   return 0;
 }
 int test_no_parameter_list()
 {
   static int si = 0;
     auto M = [] { return 5; }; // OK
     auto M2 = [] -> auto && { return si; };
 #if __cplusplus <= 202002L
       // expected-warning@-2{{is a C++2b extension}}
 #endif
     M();
 }
 
 int test_conditional_in_return() {
-  auto Fac = [](auto f, auto n) { 
+  auto Fac = [](auto f, auto n) {
     return n <= 0 ? n : f(f, n - 1) * n;
   };
   // FIXME: this test causes a recursive limit - need to error more gracefully.
   //Fac(Fac, 3);
 
 }
 No newline at end of file

clang/test/CXX/special/class.copy/p33-0x.cpp

else
     return x;
 }
 
 void throw_move_only(X x) {
   X x2;
   throw x;
   throw x2;
 }
-  
 namespace PR10142 {
   struct X {
     X();
     X(X&&);
     X(const X&) = delete; // expected-note 2{{'X' has been explicitly marked deleted here}}
   };
 
   void f(int i) {

clang/test/CXX/temp/temp.decls/temp.mem/p5.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
-struct A { 
+struct A {
   template <class T> operator T*();
-}; 
+};
 
 template <class T> A::operator T*() { return 0; }
 template <> A::operator char*(){ return 0; } // specialization
 template A::operator void*(); // explicit instantiation
 
-int main() { 
+int main() {
   A a;
-  int *ip; 
+  int *ip;
   ip = a.operator int*();
 }
 
 // PR5742
 namespace PR5742 {
   template <class T> struct A { };
   template <class T> struct B { };
 
   struct S {
     template <class T> operator T();
   } s;
 
   void f() {
     s.operator A<A<int> >();
     s.operator A<B<int> >();
     s.operator A<B<A<int> > >();
   }
 }
 
 // PR5762
 class Foo {
  public:
   template <typename T> operator T();
-  
   template <typename T>
   T As() {
     return this->operator T();
   }
 
   template <typename T>
   T As2() {
     return operator T();
   }
-  
   int AsInt() {
     return this->operator int();
   }
 };
 
 template float Foo::As();
 template double Foo::As2();
 
 // Partial ordering with conversion function templates.
 struct X0 {
   template<typename T> operator T*() {
     T x = 1; // expected-note{{variable 'x' declared const here}}
     x = 17; // expected-error{{cannot assign to variable 'x' with const-qualified type 'const int'}}
   }
-  
   template<typename T> operator T*() const; // expected-note{{explicit instantiation refers here}}
-  
   template<typename T> operator const T*() const {
     T x = T();
     return x; // expected-error{{cannot initialize return object of type 'const char *' with an lvalue of type 'char'}} \
     // expected-error{{cannot initialize return object of type 'const int *' with an lvalue of type 'int'}}
   }
 };
 
 template X0::operator const char*() const; // expected-note{{'X0::operator const char *<char>' requested here}}

clang/test/SemaCXX/conversion-function.cpp

-// RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -Wbind-to-temporary-copy -verify %s 
+// RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -Wbind-to-temporary-copy -verify %s
 // RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -Wbind-to-temporary-copy -verify -std=c++98 %s
 // RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -Wbind-to-temporary-copy -verify -std=c++11 %s
 
-class X { 
+class X {
 public:
   operator bool();
   operator int() const;
 
   bool f() {
     return operator bool();
   }
 

 typedef int array_type[10];
 
 class Y {
 public:
   void operator bool(int, ...) const; // expected-error{{conversion function cannot have a return type}} \
   // expected-error{{conversion function cannot have any parameters}}
 
   operator bool(int a = 4, int b = 6) const; // expected-error{{conversion function cannot have any parameters}}
-  
-  
   operator float(...) const;  // expected-error{{conversion function cannot be variadic}}
-  
-  
   operator func_type(); // expected-error{{conversion function cannot convert to a function type}}
   operator array_type(); // expected-error{{conversion function cannot convert to an array type}}
 };
 
 
 typedef int INT;
 typedef INT* INT_PTR;
 
-class Z { 
+class Z {
   operator int(); // expected-note {{previous declaration is here}}
   operator int**(); // expected-note {{previous declaration is here}}
-  
   operator INT();  // expected-error{{conversion function cannot be redeclared}}
   operator INT_PTR*(); // expected-error{{conversion function cannot be redeclared}}
 };
 
 
 class A { };
 
 class B : public A {

 
 C::operator const char*() const { return 0; }
 
 void f(const C& c) {
   const char* v = c;
 }
 
 // Test. Conversion in base class is visible in derived class.
-class XB { 
+class XB {
 public:
   operator int(); // expected-note {{candidate function}}
 };
 
-class Yb : public XB { 
+class Yb : public XB {
 public:
   operator char(); // expected-note {{candidate function}}
 };
 
 void f(Yb& a) {
   if (a) { } // expected-error {{conversion from 'Yb' to 'bool' is ambiguous}}
   int i = a; // OK. calls XB::operator int();
   char ch = a;  // OK. calls Yb::operator char();
 }
 
 // Test conversion + copy construction.
 class AutoPtrRef { };
 
 class AutoPtr {
   AutoPtr(AutoPtr &); // expected-note{{declared private here}}
-  
 public:
   AutoPtr();
   AutoPtr(AutoPtrRef);
-  
   operator AutoPtrRef();
 };
 
 AutoPtr make_auto_ptr();
 
 AutoPtr test_auto_ptr(bool Cond) {
   AutoPtr p1( make_auto_ptr() );
-  
   AutoPtr p;
   if (Cond)
     return p; // expected-error{{calling a private constructor}}
-  
   return AutoPtr();
 }
 
 struct A1 {
   A1(const char *);
   ~A1();
 
 private:
namespace source_locations {
   };
 
   void f() {
     A<float, float> &af = E(); // expected-error{{no viable conversion}}
     A<float, int> &af2 = E();
     const A<float, int> &caf2 = E();
   }
 
-  // Check 
+  // Check
   template<typename T>
   struct E2 {
     operator T
     * // expected-error{{pointer to a reference}}
     () const;
   };
 
   E2<int&> e2i; // expected-note{{in instantiation}}

 #else
     // expected-error-re@-4 {{cannot specify any part of a return type in the declaration of a conversion function; use an alias template to declare a conversion to 'T (&)()'{{$}}}}
 #endif
 
   };
 }
 
 namespace smart_ptr {
-  class Y { 
+  class Y {
     class YRef { };
 
     Y(Y&);
 
   public:
     Y();
     Y(YRef);
 
#endif
   }
 }
 
 struct Any {
   Any(...);
 };
 
 struct Other {
-  Other(const Other &); 
+  Other(const Other &);
   Other();
 };
 
 void test_any() {
   Any any = Other();
 #if __cplusplus <= 199711L
   // expected-error@-2 {{cannot pass object of non-POD type 'Other' through variadic constructor; call will abort at runtime}}
 #else
namespace PR7055 {
 
   auto_ptr foo();
 
   X e(foo());
 
   struct Y {
     Y(X);
   };
-  
   Y f2(foo());
 }
 
 namespace PR7934 {
   typedef unsigned char uint8;
 
   struct MutablePtr {
     MutablePtr() : ptr(0) {}
namespace rdar8018274 {
   struct Base {
     operator int();
   };
 
   struct Derived1 : Base { };
 
   struct Derived2 : Base { };
 
-  struct SuperDerived : Derived1, Derived2 { 
+  struct SuperDerived : Derived1, Derived2 {
     using Derived1::operator int;
   };
 
   struct UeberDerived : SuperDerived {
     operator long();
   };
 
   void test2(UeberDerived ud) {
     int i = ud; // expected-error{{ambiguous conversion from derived class 'rdar8018274::UeberDerived' to base class 'rdar8018274::Base'}}
   }
 
   struct Base2 {
     operator int();
   };
 
   struct Base3 {
     operator int();
   };
 
-  struct Derived23 : Base2, Base3 { 
+  struct Derived23 : Base2, Base3 {
     using Base2::operator int;
   };
 
   struct ExtraDerived23 : Derived23 { };
 
   void test3(ExtraDerived23 ed) {
     int i = ed;
   }

 }
 
 namespace PR9336 {
   template<class T>
   struct generic_list
   {
     template<class Container>
     operator Container()
-    { 
+    {
       Container ar;
       T* i;
       ar[0]=*i;
       return ar;
     }
   };
 
   template<class T>

clang/test/SemaCXX/cxx1y-deduced-return-type.cpp

 namespace MemberTemplatesWithDeduction {
   struct M {
     template<class T> auto foo(T t) { return t; }
     template<class T> auto operator()(T t) const { return t; }
     template<class T> static __attribute__((unused)) int static_foo(T) {
       return 5;
     }
     template<class T> operator T() { return T{}; }
-    operator auto() { return &static_foo<int>; } 
+    operator auto() { return &static_foo<int>; }
   };
   struct N : M {
     using M::foo;
     using M::operator();
     using M::static_foo;
     using M::operator auto;
   };
-  
   template <class T> int test() {
     int i = T{}.foo(3);
     T m = T{}.foo(M{});
     int j = T{}(3);
     M m2 = M{}(M{});
     int k = T{}.static_foo(4);
     int l = T::static_foo(5);
     int l2 = T{};
     struct X { };
     X x = T{};
     return 0;
   }
   int Minst = test<M>();
   int Ninst = test<N>();
-  
 }
 }
 
 // We resolve a wording bug here: 'decltype(auto)' should not be modeled as a
 // decltype-specifier, just as a simple-type-specifier. All the extra places
 // where a decltype-specifier can appear make no sense for 'decltype(auto)'.
 namespace DecltypeAutoShouldNotBeADecltypeSpecifier {
   namespace NNS {
namespace CurrentInstantiation {
   int k1 = S<int>().g();
   int k2 = S<int>().h(false);
 
   template<typename T> struct U {
  #ifndef DELAYED_TEMPLATE_PARSING
     auto f(); // expected-note {{here}}
     int g() { return f(); } // expected-error {{cannot be used before it is defined}}
  #else
-    auto f(); 
-    int g() { return f(); } 
+    auto f();
+    int g() { return f(); }
  #endif
   };
- #ifndef DELAYED_TEMPLATE_PARSING 
+ #ifndef DELAYED_TEMPLATE_PARSING
   template int U<int>::g(); // expected-note {{in instantiation of}}
  #else
   template int U<int>::g();
  #endif
   template<typename T> auto U<T>::f() { return T(); }
   template int U<short>::g(); // ok
 }