Fix-up EOL-styles changed by upstream.

2 files changed, 253 insertions, 253 deletions

diff --git a/test/CXX/expr/expr.prim/expr.prim.lambda/p15-star-this-capture.cpp b/test/CXX/expr/expr.prim/expr.prim.lambda/p15-star-this-capture.cpp
index eac6c40c6085..bae1e25add35 100644
--- a/test/CXX/expr/expr.prim/expr.prim.lambda/p15-star-this-capture.cpp
+++ b/test/CXX/expr/expr.prim/expr.prim.lambda/p15-star-this-capture.cpp
@@ -1,22 +1,22 @@
-// RUN: %clang_cc1 -fsyntax-only -std=c++1z %s -verify
-
-class NonCopyable {
-  NonCopyable(const NonCopyable&) = delete; //expected-note3{{explicitly marked deleted here}}
-  int x = 10;
-  void foo() {
-    auto L = [this] { return x; };
-    const auto &M = [*this] { return x; };//expected-error{{call to deleted}}
-    const auto &M2 = [this] () -> auto&& {
-      ++x;
-      return [*this] {  //expected-error{{call to deleted}} expected-warning{{reference to local}}
-         return ++x; //expected-error{{read-only}}
-      }; 
-    };
-    const auto &M3 = [*this] () mutable -> auto&& { //expected-error{{call to deleted}} 
-      ++x;
-      return [this] {  // expected-warning{{reference to local}}
-         return x;
-      }; 
-    };
-  }  
-};
+// RUN: %clang_cc1 -fsyntax-only -std=c++1z %s -verify

+

+class NonCopyable {

+  NonCopyable(const NonCopyable&) = delete; //expected-note3{{explicitly marked deleted here}}

+  int x = 10;

+  void foo() {

+    auto L = [this] { return x; };

+    const auto &M = [*this] { return x; };//expected-error{{call to deleted}}

+    const auto &M2 = [this] () -> auto&& {

+      ++x;

+      return [*this] {  //expected-error{{call to deleted}} expected-warning{{reference to local}}

+         return ++x; //expected-error{{read-only}}

+      }; 

+    };

+    const auto &M3 = [*this] () mutable -> auto&& { //expected-error{{call to deleted}} 

+      ++x;

+      return [this] {  // expected-warning{{reference to local}}

+         return x;

+      }; 

+    };

+  }  

+};

diff --git a/test/SemaCXX/cxx1z-lambda-star-this.cpp b/test/SemaCXX/cxx1z-lambda-star-this.cpp
index c23dd7b42719..a84e653f5c83 100644
--- a/test/SemaCXX/cxx1z-lambda-star-this.cpp
+++ b/test/SemaCXX/cxx1z-lambda-star-this.cpp
@@ -1,231 +1,231 @@
-// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -emit-llvm-only %s
-// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s -DDELAYED_TEMPLATE_PARSING
-// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fms-extensions %s -DMS_EXTENSIONS
-// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing -fms-extensions %s -DMS_EXTENSIONS -DDELAYED_TEMPLATE_PARSING
-
-template<class, class> constexpr bool is_same = false;
-template<class T> constexpr bool is_same<T, T> = true;
-
-namespace test_star_this {
-namespace ns1 {
-class A {
-  int x = 345;
-  auto foo() {
-    (void) [*this, this] { };  //expected-error{{'this' can appear only once}}
-    (void) [this] { ++x; };
-    (void) [*this] { ++x; };  //expected-error{{read-only variable}}
-    (void) [*this] () mutable { ++x; };
-    (void) [=] { return x; };
-    (void) [&, this] { return x; };
-    (void) [=, *this] { return x; };
-    (void) [&, *this] { return x; };
-  }
-};
-} // end ns1
-
-namespace ns2 {
-  class B {
-    B(const B&) = delete; //expected-note{{deleted here}}
-    int *x = (int *) 456;
-    void foo() {
-      (void)[this] { return x; };
-      (void)[*this] { return x; }; //expected-error{{call to deleted}}
-    }
-  };
-} // end ns2
-namespace ns3 {
-  class B {
-    B(const B&) = delete; //expected-note2{{deleted here}}
-    
-    int *x = (int *) 456;
-    public: 
-    template<class T = int>
-    void foo() {
-      (void)[this] { return x; };
-      (void)[*this] { return x; }; //expected-error2{{call to deleted}}
-    }
-    
-    B() = default;
-  } b;
-  B *c = (b.foo(), nullptr); //expected-note{{in instantiation}}
-} // end ns3
-
-namespace ns4 {
-template<class U>
-class B {
-  B(const B&) = delete; //expected-note{{deleted here}}
-  double d = 3.14;
-  public: 
-  template<class T = int>
-  auto foo() {
-    const auto &L = [*this] (auto a) mutable { //expected-error{{call to deleted}}
-      d += a; 
-      return [this] (auto b) { return d +=b; }; 
-    }; 
-  }
-  
-  B() = default;
-};
-void main() {
-  B<int*> b;
-  b.foo(); //expected-note{{in instantiation}}
-} // end main  
-} // end ns4
-namespace ns5 {
-
-struct X {
-  double d = 3.14;
-  X(const volatile X&);
-  void foo() {
-      
-  }
-  
-  void foo() const { //expected-note{{const}}
-    
-    auto L = [*this] () mutable { 
-      static_assert(is_same<decltype(this), X*>);
-      ++d;
-      auto M = [this] { 
-        static_assert(is_same<decltype(this), X*>);  
-        ++d;
-        auto N = [] {
-          static_assert(is_same<decltype(this), X*>); 
-        };
-      };
-    };
-    
-    auto L1 = [*this] { 
-      static_assert(is_same<decltype(this), const X*>);
-      auto M = [this] () mutable { 
-        static_assert(is_same<decltype(this), const X*>);  
-        auto N = [] {
-          static_assert(is_same<decltype(this), const X*>); 
-        };
-      };
-      auto M2 = [*this] () mutable { 
-        static_assert(is_same<decltype(this), X*>);  
-        auto N = [] {
-          static_assert(is_same<decltype(this), X*>); 
-        };
-      };
-    };
-    
-    auto GL1 = [*this] (auto a) { 
-      static_assert(is_same<decltype(this), const X*>);
-      auto M = [this] (auto b) mutable { 
-        static_assert(is_same<decltype(this), const X*>);  
-        auto N = [] (auto c) {
-          static_assert(is_same<decltype(this), const X*>); 
-        };
-        return N;
-      };
-      
-      auto M2 = [*this] (auto a) mutable { 
-        static_assert(is_same<decltype(this), X*>);  
-        auto N = [] (auto b) {
-          static_assert(is_same<decltype(this), X*>); 
-        };
-        return N;
-      };
-      return [=](auto a) mutable { M(a)(a); M2(a)(a); };
-    };
-    
-    GL1("abc")("abc");
-    
-    
-    auto L2 = [this] () mutable {
-      static_assert(is_same<decltype(this), const X*>);  
-      ++d; //expected-error{{cannot assign}}
-    };
-    auto GL = [*this] (auto a) mutable {
-      static_assert(is_same<decltype(this), X*>);
-      ++d;
-      auto M = [this] (auto b) { 
-        static_assert(is_same<decltype(this), X*>);  
-        ++d;
-        auto N = [] (auto c) {
-          static_assert(is_same<decltype(this), X*>); 
-        };
-        N(3.14);
-      };
-      M("abc");
-    };
-    GL(3.14);
- 
-  }
-  void foo() volatile const {
-    auto L = [this] () {
-      static_assert(is_same<decltype(this), const volatile X*>);
-      auto M = [*this] () mutable { 
-        static_assert(is_same<decltype(this), X*>);
-        auto N = [this] {
-          static_assert(is_same<decltype(this), X*>);
-          auto M = [] {
-            static_assert(is_same<decltype(this), X*>);
-          };
-        };
-        auto N2 = [*this] {
-          static_assert(is_same<decltype(this), const X*>);
-        };
-      };
-      auto M2 = [*this] () {
-        static_assert(is_same<decltype(this), const X*>); 
-        auto N = [this] {
-          static_assert(is_same<decltype(this), const X*>);
-        };
-      };
-    };
-  }
-  
-};
-
-} //end ns5
-namespace ns6 {
-struct X {
-  double d;
-  auto foo() const {
-    auto L = [*this] () mutable {
-      auto M = [=] (auto a) {
-        auto N = [this] {
-          ++d;
-          static_assert(is_same<decltype(this), X*>);
-          auto O = [*this] {
-            static_assert(is_same<decltype(this), const X*>);
-          };
-        };
-        N();
-        static_assert(is_same<decltype(this), X*>);
-      };
-      return M;
-    };
-    return L;
-  }
-}; 
-
-int main() {
-  auto L = X{}.foo();
-  auto M = L();
-  M(3.14);
-}
-} // end ns6
-namespace ns7 {
-
-struct X {
-  double d;
-  X();
-  X(const X&); 
-  X(X&) = delete;
-  auto foo() const {
-    //OK - the object used to initialize our capture is a const object and so prefers the non-deleted ctor.
-    const auto &&L = [*this] { };
-  }
-  
-}; 
-int main() {
-  X x;
-  x.foo();
-}
-} // end ns7
-
-} //end ns test_star_this
-
+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -emit-llvm-only %s

+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s -DDELAYED_TEMPLATE_PARSING

+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fms-extensions %s -DMS_EXTENSIONS

+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing -fms-extensions %s -DMS_EXTENSIONS -DDELAYED_TEMPLATE_PARSING

+

+template<class, class> constexpr bool is_same = false;

+template<class T> constexpr bool is_same<T, T> = true;

+

+namespace test_star_this {

+namespace ns1 {

+class A {

+  int x = 345;

+  auto foo() {

+    (void) [*this, this] { };  //expected-error{{'this' can appear only once}}

+    (void) [this] { ++x; };

+    (void) [*this] { ++x; };  //expected-error{{read-only variable}}

+    (void) [*this] () mutable { ++x; };

+    (void) [=] { return x; };

+    (void) [&, this] { return x; };

+    (void) [=, *this] { return x; };

+    (void) [&, *this] { return x; };

+  }

+};

+} // end ns1

+

+namespace ns2 {

+  class B {

+    B(const B&) = delete; //expected-note{{deleted here}}

+    int *x = (int *) 456;

+    void foo() {

+      (void)[this] { return x; };

+      (void)[*this] { return x; }; //expected-error{{call to deleted}}

+    }

+  };

+} // end ns2

+namespace ns3 {

+  class B {

+    B(const B&) = delete; //expected-note2{{deleted here}}

+    

+    int *x = (int *) 456;

+    public: 

+    template<class T = int>

+    void foo() {

+      (void)[this] { return x; };

+      (void)[*this] { return x; }; //expected-error2{{call to deleted}}

+    }

+    

+    B() = default;

+  } b;

+  B *c = (b.foo(), nullptr); //expected-note{{in instantiation}}

+} // end ns3

+

+namespace ns4 {

+template<class U>

+class B {

+  B(const B&) = delete; //expected-note{{deleted here}}

+  double d = 3.14;

+  public: 

+  template<class T = int>

+  auto foo() {

+    const auto &L = [*this] (auto a) mutable { //expected-error{{call to deleted}}

+      d += a; 

+      return [this] (auto b) { return d +=b; }; 

+    }; 

+  }

+  

+  B() = default;

+};

+void main() {

+  B<int*> b;

+  b.foo(); //expected-note{{in instantiation}}

+} // end main  

+} // end ns4

+namespace ns5 {

+

+struct X {

+  double d = 3.14;

+  X(const volatile X&);

+  void foo() {

+      

+  }

+  

+  void foo() const { //expected-note{{const}}

+    

+    auto L = [*this] () mutable { 

+      static_assert(is_same<decltype(this), X*>);

+      ++d;

+      auto M = [this] { 

+        static_assert(is_same<decltype(this), X*>);  

+        ++d;

+        auto N = [] {

+          static_assert(is_same<decltype(this), X*>); 

+        };

+      };

+    };

+    

+    auto L1 = [*this] { 

+      static_assert(is_same<decltype(this), const X*>);

+      auto M = [this] () mutable { 

+        static_assert(is_same<decltype(this), const X*>);  

+        auto N = [] {

+          static_assert(is_same<decltype(this), const X*>); 

+        };

+      };

+      auto M2 = [*this] () mutable { 

+        static_assert(is_same<decltype(this), X*>);  

+        auto N = [] {

+          static_assert(is_same<decltype(this), X*>); 

+        };

+      };

+    };

+    

+    auto GL1 = [*this] (auto a) { 

+      static_assert(is_same<decltype(this), const X*>);

+      auto M = [this] (auto b) mutable { 

+        static_assert(is_same<decltype(this), const X*>);  

+        auto N = [] (auto c) {

+          static_assert(is_same<decltype(this), const X*>); 

+        };

+        return N;

+      };

+      

+      auto M2 = [*this] (auto a) mutable { 

+        static_assert(is_same<decltype(this), X*>);  

+        auto N = [] (auto b) {

+          static_assert(is_same<decltype(this), X*>); 

+        };

+        return N;

+      };

+      return [=](auto a) mutable { M(a)(a); M2(a)(a); };

+    };

+    

+    GL1("abc")("abc");

+    

+    

+    auto L2 = [this] () mutable {

+      static_assert(is_same<decltype(this), const X*>);  

+      ++d; //expected-error{{cannot assign}}

+    };

+    auto GL = [*this] (auto a) mutable {

+      static_assert(is_same<decltype(this), X*>);

+      ++d;

+      auto M = [this] (auto b) { 

+        static_assert(is_same<decltype(this), X*>);  

+        ++d;

+        auto N = [] (auto c) {

+          static_assert(is_same<decltype(this), X*>); 

+        };

+        N(3.14);

+      };

+      M("abc");

+    };

+    GL(3.14);

+ 

+  }

+  void foo() volatile const {

+    auto L = [this] () {

+      static_assert(is_same<decltype(this), const volatile X*>);

+      auto M = [*this] () mutable { 

+        static_assert(is_same<decltype(this), X*>);

+        auto N = [this] {

+          static_assert(is_same<decltype(this), X*>);

+          auto M = [] {

+            static_assert(is_same<decltype(this), X*>);

+          };

+        };

+        auto N2 = [*this] {

+          static_assert(is_same<decltype(this), const X*>);

+        };

+      };

+      auto M2 = [*this] () {

+        static_assert(is_same<decltype(this), const X*>); 

+        auto N = [this] {

+          static_assert(is_same<decltype(this), const X*>);

+        };

+      };

+    };

+  }

+  

+};

+

+} //end ns5

+namespace ns6 {

+struct X {

+  double d;

+  auto foo() const {

+    auto L = [*this] () mutable {

+      auto M = [=] (auto a) {

+        auto N = [this] {

+          ++d;

+          static_assert(is_same<decltype(this), X*>);

+          auto O = [*this] {

+            static_assert(is_same<decltype(this), const X*>);

+          };

+        };

+        N();

+        static_assert(is_same<decltype(this), X*>);

+      };

+      return M;

+    };

+    return L;

+  }

+}; 

+

+int main() {

+  auto L = X{}.foo();

+  auto M = L();

+  M(3.14);

+}

+} // end ns6

+namespace ns7 {

+

+struct X {

+  double d;

+  X();

+  X(const X&); 

+  X(X&) = delete;

+  auto foo() const {

+    //OK - the object used to initialize our capture is a const object and so prefers the non-deleted ctor.

+    const auto &&L = [*this] { };

+  }

+  

+}; 

+int main() {

+  X x;

+  x.foo();

+}

+} // end ns7

+

+} //end ns test_star_this

+