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
+