Add the clang library to the repo (with some of my changes, too).

80 files changed, 4063 insertions, 0 deletions

diff --git a/clang/test/SemaObjCXX/Inputs/arc-system-header.h b/clang/test/SemaObjCXX/Inputs/arc-system-header.h
new file mode 100644
index 0000000..d7adeb4
--- /dev/null
+++ b/clang/test/SemaObjCXX/Inputs/arc-system-header.h
@@ -0,0 +1,14 @@
+@interface B
+@end
+
+
+@interface A {
+@public
+  union {
+    struct {
+      B *b;
+    } a_b;
+    void *void_ptr;
+  } data;
+}
+@end
diff --git a/clang/test/SemaObjCXX/NSString-type.mm b/clang/test/SemaObjCXX/NSString-type.mm
new file mode 100644
index 0000000..1033866
--- /dev/null
+++ b/clang/test/SemaObjCXX/NSString-type.mm
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -x objective-c++ -triple x86_64-apple-darwin10 -fblocks -fsyntax-only -verify %s
+// rdar://10907410
+
+void test(id pid, Class pclass) {
+  void (^block)(void) = @"help"; // expected-error {{cannot initialize a variable of type 'void (^)()' with an rvalue of type 'NSString *'}}
+  void (^block1)(void) = pid;
+  void (^block2)(void) = @"help"; // expected-error {{cannot initialize a variable of type 'void (^)()' with an rvalue of type 'NSString *'}}
+  void (^block3)(void) = @"help"; // expected-error {{cannot initialize a variable of type 'void (^)()' with an rvalue of type 'NSString *'}}
+}
+
diff --git a/clang/test/SemaObjCXX/arc-0x.mm b/clang/test/SemaObjCXX/arc-0x.mm
new file mode 100644
index 0000000..28eec51
--- /dev/null
+++ b/clang/test/SemaObjCXX/arc-0x.mm
@@ -0,0 +1,53 @@
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fobjc-arc -verify -fblocks -fobjc-exceptions %s
+
+// "Move" semantics, trivial version.
+void move_it(__strong id &&from) {
+  id to = static_cast<__strong id&&>(from);
+}
+
+// Deduction with 'auto'.
+@interface A
++ alloc;
+- init;
+@end
+
+// Ensure that deduction works with lifetime qualifiers.
+void deduction(id obj) {
+  auto a = [[A alloc] init];
+  __strong A** aPtr = &a;
+
+  auto a2([[A alloc] init]);
+  __strong A** aPtr2 = &a2;
+
+  __strong id *idp = new auto(obj);
+
+  __strong id array[17];
+  for (auto x : array) {
+    __strong id *xPtr = &x;
+  }
+
+  @try {
+  } @catch (auto e) { // expected-error {{'auto' not allowed in exception declaration}}
+  }
+}
+
+// rdar://problem/11068137
+void test1a() {
+  __autoreleasing id p; // expected-note 2 {{'p' declared here}}
+  (void) [&p] {};
+  (void) [p] {}; // expected-error {{cannot capture __autoreleasing variable in a lambda by copy}}
+  (void) [=] { (void) p; }; // expected-error {{cannot capture __autoreleasing variable in a lambda by copy}}
+}
+void test1b() {
+  __autoreleasing id v;
+  __autoreleasing id &p = v; // expected-note 2 {{'p' declared here}}
+  (void) [&p] {};
+  (void) [p] {}; // expected-error {{cannot capture __autoreleasing variable in a lambda by copy}}
+  (void) [=] { (void) p; }; // expected-error {{cannot capture __autoreleasing variable in a lambda by copy}}
+}
+void test1c() {
+  __autoreleasing id v; // expected-note {{'v' declared here}}
+  __autoreleasing id &p = v;
+  (void) ^{ (void) p; };
+  (void) ^{ (void) v; }; // expected-error {{cannot capture __autoreleasing variable in a block}}
+}
diff --git a/clang/test/SemaObjCXX/arc-bool-conversion.mm b/clang/test/SemaObjCXX/arc-bool-conversion.mm
new file mode 100644
index 0000000..d8f840e
--- /dev/null
+++ b/clang/test/SemaObjCXX/arc-bool-conversion.mm
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -fsyntax-only -fobjc-arc -verify -fblocks -triple x86_64-apple-darwin10.0.0 %s
+// rdar://9310049
+
+bool fn(id obj) {
+    return (bool)obj;
+}
+
diff --git a/clang/test/SemaObjCXX/arc-bridged-cast.mm b/clang/test/SemaObjCXX/arc-bridged-cast.mm
new file mode 100644
index 0000000..1ea67a3
--- /dev/null
+++ b/clang/test/SemaObjCXX/arc-bridged-cast.mm
@@ -0,0 +1,36 @@
+// RUN: %clang_cc1 -triple x86_64-apple-darwin11 -fsyntax-only -fobjc-arc -fblocks -verify %s
+
+typedef const void *CFTypeRef;
+typedef const struct __CFString *CFStringRef;
+
+@interface NSString
+@end
+
+CFTypeRef CFCreateSomething();
+CFStringRef CFCreateString();
+CFTypeRef CFGetSomething();
+CFStringRef CFGetString();
+
+id CreateSomething();
+NSString *CreateNSString();
+
+template<typename IdType, typename StringType, typename IntPtrType>
+void from_cf() {
+  id obj1 = (__bridge_transfer IdType)CFCreateSomething();
+  id obj2 = (__bridge_transfer StringType)CFCreateString();
+  (__bridge IntPtrType)CFCreateSomething(); // expected-error{{incompatible types casting 'CFTypeRef' (aka 'const void *') to 'int *' with a __bridge cast}}
+  id obj3 = (__bridge IdType)CFGetSomething();
+  id obj4 = (__bridge StringType)CFGetString();
+}
+
+template void from_cf<id, NSString*, int*>(); // expected-note{{in instantiation of function template specialization}}
+
+template<typename IdType, typename StringType>
+void to_cf(id obj) {
+  CFTypeRef cf1 = (__bridge_retained IdType)CreateSomething();
+  CFStringRef cf2 = (__bridge_retained StringType)CreateNSString();
+  CFTypeRef cf3 = (__bridge IdType)CreateSomething();
+  CFStringRef cf4 = (__bridge StringType)CreateNSString(); 
+}
+
+template void to_cf<CFTypeRef, CFStringRef>(id);
diff --git a/clang/test/SemaObjCXX/arc-libstdcxx.mm b/clang/test/SemaObjCXX/arc-libstdcxx.mm
new file mode 100644
index 0000000..71771b4
--- /dev/null
+++ b/clang/test/SemaObjCXX/arc-libstdcxx.mm
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -fsyntax-only -fobjc-arc -fobjc-arc-cxxlib=libstdc++ -fobjc-runtime-has-weak -verify %s
+
+@interface A @end
+
+int check0[std::__is_scalar<__strong id>::__value? -1 : 1];
+int check1[std::__is_scalar<__weak id>::__value? -1 : 1];
+int check2[std::__is_scalar<__autoreleasing id>::__value? -1 : 1];
+int check3[std::__is_scalar<__strong A*>::__value? -1 : 1];
+int check4[std::__is_scalar<__weak A*>::__value? -1 : 1];
+int check5[std::__is_scalar<__autoreleasing A*>::__value? -1 : 1];
diff --git a/clang/test/SemaObjCXX/arc-memfunc.mm b/clang/test/SemaObjCXX/arc-memfunc.mm
new file mode 100644
index 0000000..274f873
--- /dev/null
+++ b/clang/test/SemaObjCXX/arc-memfunc.mm
@@ -0,0 +1,15 @@
+// RUN: %clang_cc1 -fsyntax-only -fobjc-arc -verify -fblocks %s
+
+struct X0 {
+  static id makeObject1() __attribute__((ns_returns_retained));
+  id makeObject2() __attribute__((ns_returns_retained));
+};
+
+void test_X0(X0 x0, X0 *x0p) {
+  X0::makeObject1();
+  x0.makeObject2();
+  x0p->makeObject2();
+  id (X0::*pmf)() __attribute__((ns_returns_retained)) = &X0::makeObject2;
+  (x0.*pmf)();
+  (x0p->*pmf)();
+}
diff --git a/clang/test/SemaObjCXX/arc-non-pod.mm b/clang/test/SemaObjCXX/arc-non-pod.mm
new file mode 100644
index 0000000..1c5cf7a
--- /dev/null
+++ b/clang/test/SemaObjCXX/arc-non-pod.mm
@@ -0,0 +1,116 @@
+// RUN: %clang_cc1 -fsyntax-only -fobjc-arc -Warc-abi -verify -fblocks -triple x86_64-apple-darwin10.0.0 %s
+
+// Classes that have an Objective-C object pointer.
+struct HasObjectMember0 { // expected-warning{{'HasObjectMember0' cannot be shared between ARC and non-ARC code; add a copy constructor, a copy assignment operator, and a destructor to make it ABI-compatible}}
+  id x;
+};
+
+struct HasObjectMember1 { // expected-warning{{'HasObjectMember1' cannot be shared between ARC and non-ARC code; add a copy constructor, a copy assignment operator, and a destructor to make it ABI-compatible}}
+  id x[3];
+};
+
+struct HasObjectMember2 { // expected-warning{{'HasObjectMember2' cannot be shared between ARC and non-ARC code; add a copy constructor, a copy assignment operator, and a destructor to make it ABI-compatible}}
+  id x[3][2];
+};
+
+// Don't complain if the type has non-external linkage
+namespace {
+  struct HasObjectMember3 {
+    id x[3][2];
+  };
+}
+
+// Don't complain if the Objective-C pointer type was explicitly given
+// no ownership.
+struct HasObjectMember3 { 
+  __unsafe_unretained id x[3][2];
+};
+
+struct HasBlockPointerMember0 { // expected-warning{{'HasBlockPointerMember0' cannot be shared between ARC and non-ARC code; add a copy constructor, a copy assignment operator, and a destructor to make it ABI-compatible}}
+  int (^bp)(int);
+};
+
+struct HasBlockPointerMember1 { // expected-warning{{'HasBlockPointerMember1' cannot be shared between ARC and non-ARC code; add a copy constructor, a copy assignment operator, and a destructor to make it ABI-compatible}}
+  int (^bp[2][3])(int);
+};
+
+struct NonPOD {
+  NonPOD(const NonPOD&);
+};
+
+struct HasObjectMemberAndNonPOD0 { // expected-warning{{'HasObjectMemberAndNonPOD0' cannot be shared between ARC and non-ARC code; add a non-trivial copy assignment operator to make it ABI-compatible}} \
+  // expected-warning{{'HasObjectMemberAndNonPOD0' cannot be shared between ARC and non-ARC code; add a non-trivial destructor to make it ABI-compatible}}
+  id x;
+  NonPOD np;
+};
+
+struct HasObjectMemberAndNonPOD1 { // expected-warning{{'HasObjectMemberAndNonPOD1' cannot be shared between ARC and non-ARC code; add a non-trivial copy assignment operator to make it ABI-compatible}} \
+  // expected-warning{{'HasObjectMemberAndNonPOD1' cannot be shared between ARC and non-ARC code; add a non-trivial destructor to make it ABI-compatible}}
+  NonPOD np;
+  id x[3];
+};
+
+struct HasObjectMemberAndNonPOD2 { // expected-warning{{'HasObjectMemberAndNonPOD2' cannot be shared between ARC and non-ARC code; add a non-trivial copy assignment operator to make it ABI-compatible}} \
+  // expected-warning{{'HasObjectMemberAndNonPOD2' cannot be shared between ARC and non-ARC code; add a non-trivial destructor to make it ABI-compatible}}
+  NonPOD np;
+  id x[3][2];
+};
+
+struct HasObjectMemberAndNonPOD3 {
+  HasObjectMemberAndNonPOD3 &operator=(const HasObjectMemberAndNonPOD3&);
+  ~HasObjectMemberAndNonPOD3();
+  NonPOD np;
+  id x[3][2];
+};
+
+struct HasBlockPointerMemberAndNonPOD0 { // expected-warning{{'HasBlockPointerMemberAndNonPOD0' cannot be shared between ARC and non-ARC code; add a non-trivial copy assignment operator to make it ABI-compatible}} \
+// expected-warning{{'HasBlockPointerMemberAndNonPOD0' cannot be shared between ARC and non-ARC code; add a non-trivial destructor to make it ABI-compatible}}
+  NonPOD np;
+  int (^bp)(int);
+};
+
+struct HasBlockPointerMemberAndNonPOD1 { // expected-warning{{'HasBlockPointerMemberAndNonPOD1' cannot be shared between ARC and non-ARC code; add a non-trivial copy assignment operator to make it ABI-compatible}} \
+// expected-warning{{'HasBlockPointerMemberAndNonPOD1' cannot be shared between ARC and non-ARC code; add a non-trivial destructor to make it ABI-compatible}}
+  NonPOD np;
+  int (^bp[2][3])(int);
+};
+
+int check_non_pod_objc_pointer0[__is_pod(id)? 1 : -1];
+int check_non_pod_objc_pointer1[__is_pod(__strong id)? -1 : 1];
+int check_non_pod_objc_pointer2[__is_pod(__unsafe_unretained id)? 1 : -1];
+int check_non_pod_objc_pointer3[__is_pod(id[2][3])? 1 : -1];
+int check_non_pod_objc_pointer4[__is_pod(__unsafe_unretained id[2][3])? 1 : -1];
+int check_non_pod_block0[__is_pod(int (^)(int))? 1 : -1];
+int check_non_pod_block1[__is_pod(int (^ __unsafe_unretained)(int))? 1 : -1];
+int check_non_pod_block2[__is_pod(int (^ __strong)(int))? -1 : 1];
+
+struct FlexibleArrayMember0 {
+  int length;
+  id array[]; // expected-error{{flexible array member 'array' of non-POD element type 'id __strong[]'}}
+};
+
+struct FlexibleArrayMember1 {
+  int length;
+  __unsafe_unretained id array[];
+};
+
+// It's okay to pass a retainable type through an ellipsis.
+void variadic(...);
+void test_variadic() {
+  variadic(1, 17, @"Foo");
+}
+
+// It's okay to create a VLA of retainable types.
+void vla(int n) {
+  id vla[n];
+}
+
+@interface Crufty {
+  union {
+    struct {
+      id object; // expected-note{{has __strong ownership}}
+    } an_object; // expected-error{{union member 'an_object' has a non-trivial copy constructor}}
+    void *ptr;
+  } storage;
+}
+@end
diff --git a/clang/test/SemaObjCXX/arc-nsconsumed-errors.mm b/clang/test/SemaObjCXX/arc-nsconsumed-errors.mm
new file mode 100644
index 0000000..93f5d99
--- /dev/null
+++ b/clang/test/SemaObjCXX/arc-nsconsumed-errors.mm
@@ -0,0 +1,20 @@
+// RUN: %clang_cc1 -fsyntax-only -fobjc-arc -verify -fblocks -triple x86_64-apple-darwin10.0.0 %s
+// rdar://10187884
+
+typedef void (^blk)(id, __attribute((ns_consumed)) id);
+typedef void (^blk1)(__attribute((ns_consumed))id, __attribute((ns_consumed)) id);
+blk a = ^void (__attribute((ns_consumed)) id, __attribute((ns_consumed)) id){}; // expected-error {{cannot initialize a variable of type '__strong blk'}}
+
+blk b = ^void (id, __attribute((ns_consumed)) id){};
+
+blk c = ^void (__attribute((ns_consumed)) id, __attribute((ns_consumed)) id){}; // expected-error {{cannot initialize a variable of type '__strong blk'}}
+
+blk d = ^void (id, id) {}; // expected-error {{cannot initialize a variable of type '__strong blk'}}
+
+blk1 a1 = ^void (__attribute((ns_consumed)) id, id){}; // expected-error {{cannot initialize a variable of type '__strong blk1'}}
+
+blk1 b2 = ^void (id, __attribute((ns_consumed)) id){}; // expected-error {{cannot initialize a variable of type '__strong blk1'}}
+
+blk1 c3 = ^void (__attribute((ns_consumed)) id, __attribute((ns_consumed)) id){};
+
+blk1 d4 = ^void (id, id) {}; // expected-error {{cannot initialize a variable of type '__strong blk1'}}
diff --git a/clang/test/SemaObjCXX/arc-object-init-destroy.mm b/clang/test/SemaObjCXX/arc-object-init-destroy.mm
new file mode 100644
index 0000000..e10e3ea
--- /dev/null
+++ b/clang/test/SemaObjCXX/arc-object-init-destroy.mm
@@ -0,0 +1,52 @@
+// RUN: %clang_cc1 -fobjc-runtime-has-weak -fsyntax-only -fobjc-arc -verify -Warc-abi -fblocks -triple x86_64-apple-darwin10.0.0 %s
+
+typedef __strong id strong_id;
+typedef __weak id weak_id;
+void test_pseudo_destructors(__strong id *sptr, __weak id *wptr) {
+  sptr->~id(); // okay
+  wptr->~id(); // okay
+  sptr->~strong_id(); // okay
+  wptr->~weak_id();
+  sptr->~weak_id(); // expected-error{{pseudo-destructor destroys object of type '__strong id' with inconsistently-qualified type 'weak_id' (aka '__weak id')}}
+  wptr->strong_id::~strong_id(); // expected-error{{pseudo-destructor destroys object of type '__weak id' with inconsistently-qualified type 'strong_id' (aka '__strong id')}}
+  
+  sptr->id::~id(); // okay
+  wptr->id::~id(); // okay
+}
+
+void test_delete(__strong id *sptr, __weak id *wptr) {
+  delete sptr;
+  delete wptr;
+  delete [] sptr; // expected-warning{{destroying an array of '__strong id'; this array must not have been allocated from non-ARC code}}
+  delete [] wptr; // expected-warning{{destroying an array of '__weak id'; this array must not have been allocated from non-ARC code}}
+}
+
+void test_new(int n) {
+  (void)new strong_id;
+  (void)new weak_id;
+  (void)new strong_id [n]; // expected-warning{{allocating an array of 'strong_id' (aka '__strong id'); this array must not be deleted in non-ARC code}}
+  (void)new weak_id [n]; // expected-warning{{allocating an array of 'weak_id' (aka '__weak id'); this array must not be deleted in non-ARC code}}
+
+  (void)new __strong id;
+  (void)new __weak id;
+  (void)new __strong id [n]; // expected-warning{{allocating an array of '__strong id'; this array must not be deleted in non-ARC code}}
+
+  // Infer '__strong'.
+  __strong id *idptr = new id;
+  __strong id *idptr2 = new id [n]; // expected-warning{{allocating an array of '__strong id'; this array must not be deleted in non-ARC code}}
+
+  // ... but not for arrays.
+  typedef id id_array[2][3];
+  (void)new id_array; // expected-error{{'new' cannot allocate an array of 'id' with no explicit ownership}}
+
+  typedef __strong id strong_id_array[2][3];
+  typedef __strong id strong_id_3[3];
+  strong_id_3 *idptr3 = new strong_id_array; // expected-warning{{allocating an array of '__strong id'; this array must not be deleted in non-ARC code}}
+}
+
+void test_jump_scope() {
+  goto done; // expected-error{{goto into protected scope}}
+  __strong id x; // expected-note{{jump bypasses initialization of retaining variable}}
+ done:
+  return;
+}
diff --git a/clang/test/SemaObjCXX/arc-overloading.mm b/clang/test/SemaObjCXX/arc-overloading.mm
new file mode 100644
index 0000000..a749417
--- /dev/null
+++ b/clang/test/SemaObjCXX/arc-overloading.mm
@@ -0,0 +1,202 @@
+// RUN: %clang_cc1 -fobjc-runtime-has-weak -fsyntax-only -fobjc-arc -verify -fblocks -Wno-objc-root-class %s
+
+// Simple ownership conversions + diagnostics.
+int &f0(id __strong const *); // expected-note{{candidate function not viable: 1st argument ('__weak id *') has __weak ownership, but parameter has __strong ownership}}
+
+void test_f0() {
+  id __strong *sip;
+  id __strong const *csip;
+  id __weak *wip;
+  id __autoreleasing *aip;
+  id __unsafe_unretained *uip;
+
+  int &ir1 = f0(sip);
+  int &ir2 = f0(csip);
+  int &ir3 = f0(aip);
+  int &ir4 = f0(uip);
+  f0(wip); // expected-error{{no matching function for call to 'f0'}}
+}
+
+// Simple overloading
+int &f1(id __strong const *);
+float &f1(id __weak const *);
+
+void test_f1() {
+  id __strong *sip;
+  id __strong const *csip;
+  id __weak *wip;
+  id __autoreleasing *aip;
+  id __unsafe_unretained *uip;
+
+  int &ir1 = f1(sip);
+  int &ir2 = f1(csip);
+  float &fr1 = f1(wip);
+  int &ir3 = f1(aip);
+  int &ir4 = f1(uip);
+}
+
+// Simple overloading
+int &f2(id __strong const *); // expected-note{{candidate function}}
+float &f2(id __autoreleasing const *); // expected-note{{candidate function}}
+
+void test_f2() {
+  id __strong *sip;
+  id __strong const *csip;
+  id __weak *wip;
+  id __autoreleasing *aip;
+  id __unsafe_unretained *uip;
+
+  // Prefer non-ownership conversions to ownership conversions.
+  int &ir1 = f2(sip);
+  int &ir2 = f2(csip);
+  float &fr1 = f2(aip);
+
+  f2(uip); // expected-error{{call to 'f2' is ambiguous}}
+}
+
+// Writeback conversion
+int &f3(id __autoreleasing *); // expected-note{{candidate function not viable: 1st argument ('__unsafe_unretained id *') has __unsafe_unretained ownership, but parameter has __autoreleasing ownership}}
+
+void test_f3() {
+  id __strong sip;
+  id __weak wip;
+  id __autoreleasing aip;
+  id __unsafe_unretained uip;
+
+  int &ir1 = f3(&sip);
+  int &ir2 = f3(&wip);
+  int &ir3 = f3(&aip);
+  f3(&uip); // expected-error{{no matching function for call to 'f3'}}
+}
+
+// Writeback conversion vs. no conversion
+int &f4(id __autoreleasing *);
+float &f4(id __strong *);
+
+void test_f4() {
+  id __strong sip;
+  id __weak wip;
+  id __autoreleasing aip;
+  extern __weak id weak_global_ptr;
+
+  float &fr1 = f4(&sip);
+  int &ir1 = f4(&wip);
+  int &ir2 = f4(&aip);
+  int &ir3 = f4(&weak_global_ptr); // expected-error{{passing address of non-local object to __autoreleasing parameter for write-back}}
+}
+
+// Writeback conversion vs. other conversion.
+int &f5(id __autoreleasing *);
+float &f5(id const __unsafe_unretained *);
+
+void test_f5() {
+  id __strong sip;
+  id __weak wip;
+  id __autoreleasing aip;
+
+  int &ir1 = f5(&wip);
+  float &fr1 = f5(&sip);
+  int &ir2 = f5(&aip);
+}
+
+@interface A
+@end
+
+int &f6(id __autoreleasing *);
+float &f6(id const __unsafe_unretained *);
+
+void test_f6() {
+  A* __strong sip;
+  A* __weak wip;
+  A* __autoreleasing aip;
+
+  int &ir1 = f6(&wip);
+  float &fr1 = f6(&sip);
+  int &ir2 = f6(&aip);
+}
+
+// Reference binding
+void f7(__strong id&); // expected-note{{candidate function not viable: 1st argument ('__weak id') has __weak ownership, but parameter has __strong ownership}} \
+ // expected-note{{candidate function not viable: 1st argument ('__autoreleasing id') has __autoreleasing ownership, but parameter has __strong ownership}} \
+ // expected-note{{candidate function not viable: 1st argument ('__unsafe_unretained id') has __unsafe_unretained ownership, but parameter has __strong ownership}}
+
+void test_f7() {
+  __strong id strong_id;
+  __weak id weak_id;
+  __autoreleasing id autoreleasing_id;
+  __unsafe_unretained id unsafe_id;
+  f7(strong_id);
+  f7(weak_id); // expected-error{{no matching function for call to 'f7'}}
+  f7(autoreleasing_id); // expected-error{{no matching function for call to 'f7'}}
+  f7(unsafe_id); // expected-error{{no matching function for call to 'f7'}}
+}
+
+void f8(const __strong id&);
+
+void test_f8() {
+  __strong id strong_id;
+  __weak id weak_id;
+  __autoreleasing id autoreleasing_id;
+  __unsafe_unretained id unsafe_id;
+
+  f8(strong_id);
+  f8(weak_id);
+  f8(autoreleasing_id);
+  f8(unsafe_id);
+}
+
+int &f9(__strong id&);
+float &f9(const __autoreleasing id&);
+
+void test_f9() {
+  __strong id strong_id;
+  __weak id weak_id;
+  __autoreleasing id autoreleasing_id;
+  __unsafe_unretained id unsafe_id;
+
+  int &ir1 = f9(strong_id);
+  float &fr1 = f9(autoreleasing_id);
+  float &fr2 = f9(unsafe_id);
+  float &fr2a = f9(weak_id);
+
+  __strong A *strong_a;
+  __weak A *weak_a;
+  __autoreleasing A *autoreleasing_a;
+  __unsafe_unretained A *unsafe_unretained_a;
+  float &fr3 = f9(strong_a);
+  float &fr4 = f9(autoreleasing_a);
+  float &fr5 = f9(unsafe_unretained_a);
+  float &fr6 = f9(weak_a);
+
+  const __autoreleasing id& ar1 = strong_a;
+  const __autoreleasing id& ar2 = autoreleasing_a;
+  const __autoreleasing id& ar3 = unsafe_unretained_a;
+  const __autoreleasing id& ar4 = weak_a;
+}
+
+// rdar://9790531
+void f9790531(void *inClientData); // expected-note {{candidate function not viable: cannot implicitly convert argument of type 'MixerEQGraphTestDelegate *const __strong' to 'void *' for 1st argument under ARC}}
+void f9790531_1(struct S*inClientData); // expected-note {{candidate function not viable}}
+void f9790531_2(char * inClientData); // expected-note {{candidate function not viable}}
+
+@class UIApplication;
+
+@interface MixerEQGraphTestDelegate
+- (void)applicationDidFinishLaunching;
+@end
+
+@implementation MixerEQGraphTestDelegate
+- (void)applicationDidFinishLaunching {
+    f9790531(self); // expected-error {{no matching function for call to 'f9790531'}}
+    f9790531_1(self); // expected-error {{no matching function for call to 'f9790531_1'}}
+    f9790531_2(self); // expected-error {{no matching function for call to 'f9790531_2'}}
+}
+@end
+
+class rdar10142572 {
+  id f() __attribute__((ns_returns_retained));
+  id g(); // expected-note{{previous declaration}}
+};
+
+id rdar10142572::f() { return 0; } // okay: merged down
+id __attribute__((ns_returns_retained)) rdar10142572::g() { return 0; } // expected-error{{function declared with the ns_returns_retained attribute was previously declared without the ns_returns_retained attribute}}
diff --git a/clang/test/SemaObjCXX/arc-ppe.mm b/clang/test/SemaObjCXX/arc-ppe.mm
new file mode 100644
index 0000000..c9ff811
--- /dev/null
+++ b/clang/test/SemaObjCXX/arc-ppe.mm
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -fobjc-arc %s
+
+// Make sure the ARC auto-deduction of id* in unevaluated contexts
+// works correctly in cases where we can't immediately tell whether the
+// context is unevaluated.
+
+namespace std {
+  class type_info;
+}
+
+int& NP(void*);
+void test1() { (void)typeid(NP((void*)(id*)0)); }
+
+class Poly { virtual ~Poly(); };
+Poly& P(void*);
+void test2() { (void)typeid(P((void*)(id*)0)); } // expected-error {{pointer to non-const type 'id'}}
diff --git a/clang/test/SemaObjCXX/arc-system-header.mm b/clang/test/SemaObjCXX/arc-system-header.mm
new file mode 100644
index 0000000..107b5b5
--- /dev/null
+++ b/clang/test/SemaObjCXX/arc-system-header.mm
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -fobjc-arc -isystem %S/Inputs %s -verify
+
+#include <arc-system-header.h>
+
+void f(A* a) {
+  a->data.void_ptr = 0;
+  a->data.a_b.b = 0; // expected-error{{'a_b' is unavailable: this system field has retaining ownership}}
+}
+// Silly location below
+// expected-note{{declaration has been explicitly marked unavailable here}}
diff --git a/clang/test/SemaObjCXX/arc-templates.mm b/clang/test/SemaObjCXX/arc-templates.mm
new file mode 100644
index 0000000..9eca846
--- /dev/null
+++ b/clang/test/SemaObjCXX/arc-templates.mm
@@ -0,0 +1,268 @@
+// RUN: %clang_cc1 -fobjc-runtime-has-weak -fsyntax-only -fobjc-arc -verify -fblocks %s
+
+@interface A
+@end
+
+template<typename T, typename U>
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+// Instantiation for reference/pointer types that will get lifetime
+// adjustments.
+template<typename T>
+struct X0 {
+  typedef T* pointer; // okay: ends up being strong.
+  typedef T& reference; // okay: ends up being strong
+};
+
+void test_X0() {
+  X0<id> x0id;
+  X0<A*> x0a;
+  X0<__strong A*> x0sa;
+
+  id __strong *ptr;
+  id __strong val;
+  X0<__strong id>::pointer &ptr_ref = ptr;
+  X0<__strong id>::reference ref = val;
+}
+
+int check_infer_strong[is_same<id, __strong id>::value? 1 : -1];
+
+// Check template argument deduction (e.g., for specialization) using
+// lifetime qualifiers.
+template<typename T>
+struct is_pointer_strong {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_pointer_strong<__strong T*> {
+  static const bool value = true;
+};
+
+int check_ptr_strong1[is_pointer_strong<__strong id*>::value? 1 : -1];
+int check_ptr_strong2[is_pointer_strong<__weak id*>::value? -1 : 1];
+int check_ptr_strong3[is_pointer_strong<__autoreleasing id*>::value? -1 : 1];
+int check_ptr_strong4[is_pointer_strong<__unsafe_unretained id*>::value? -1 : 1];
+int check_ptr_strong5[is_pointer_strong<id>::value? -1 : 1];
+
+// Check substitution into lifetime-qualified dependent types.
+template<typename T>
+struct make_strong_pointer {
+  typedef __strong T *type;
+};
+
+template<typename T>
+struct make_strong_pointer<__weak T> {
+  typedef __strong T *type;
+};
+
+template<typename T>
+struct make_strong_pointer<__autoreleasing T> {
+  typedef __strong T *type;
+};
+
+template<typename T>
+struct make_strong_pointer<__unsafe_unretained T> {
+  typedef __strong T *type;
+};
+
+// Adding qualifiers
+int check_make_strong1[is_same<make_strong_pointer<id>::type, __strong id *>::value ? 1 : -1];
+int check_make_strong2[is_same<make_strong_pointer<A*>::type, A* __strong *>::value ? 1 : -1];
+
+// Adding redundant qualifiers
+int check_make_strong3[is_same<make_strong_pointer<__strong id>::type, __strong id *>::value ? 1 : -1];
+int check_make_strong4[is_same<make_strong_pointer<__strong A*>::type, A* __strong *>::value ? 1 : -1];
+
+// Adding nonsensical qualifiers.
+int check_make_strong5[is_same<make_strong_pointer<int>::type, int *>::value ? 1 : -1];
+int check_make_strong6[is_same<make_strong_pointer<__weak id>::type, __strong id *>::value ? 1 : -1];
+
+template<typename T>
+struct make_weak {
+  typedef __weak T type;
+};
+
+int check_make_weak0[is_same<make_weak<id>::type, __weak id>::value? 1 : -1];
+int check_make_weak1[is_same<make_weak<__strong id>::type, __weak id>::value? 1 : -1];
+int check_make_weak2[is_same<make_weak<__autoreleasing id>::type, __weak id>::value? 1 : -1];
+
+template<typename T>
+struct make_weak_fail {
+  typedef T T_type;
+  typedef __weak T_type type; // expected-error{{the type 'T_type' (aka '__weak id') is already explicitly ownership-qualified}} \
+  // expected-error{{the type 'T_type' (aka '__strong id') is already explicitly ownership-qualified}}
+};
+
+int check_make_weak_fail0[is_same<make_weak_fail<__weak id>::type, __weak id>::value? 1 : -1]; // expected-note{{in instantiation of template class 'make_weak_fail<__weak id>' requested here}}
+
+int check_make_weak_fail1[is_same<make_weak_fail<id>::type, __weak id>::value? -1 : 1]; // expected-note{{in instantiation of template class 'make_weak_fail<id>' requested here}}
+
+// Check template argument deduction from function templates.
+template<typename T> struct identity { };
+
+template<typename T> identity<T> accept_strong_ptr(__strong T*);
+template<typename T> identity<T> accept_strong_ref(__strong T&);
+
+template<typename T> identity<T> accept_any_ptr(T*);
+template<typename T> identity<T> accept_any_ref(T&);
+
+void test_func_deduction_id() {
+  __strong id *sip;
+  __weak id *wip;
+  __autoreleasing id *aip;
+  __unsafe_unretained id *uip;
+
+  identity<id> res1 = accept_strong_ptr(sip);
+  identity<__strong id> res2 = accept_any_ptr(sip);
+
+  __strong id si;
+  __weak id wi;
+  __autoreleasing id ai;
+  __unsafe_unretained id ui;
+  identity<id> res3 = accept_strong_ref(si);
+  identity<__strong id> res4 = accept_any_ref(si);
+  identity<__weak id> res5 = accept_any_ref(wi);
+  identity<__autoreleasing id> res6 = accept_any_ref(ai);
+  identity<__unsafe_unretained id> res7 = accept_any_ref(ui);
+}
+
+void test_func_deduction_A() {
+  __strong A * *sip;
+  __weak A * *wip;
+  __autoreleasing A * *aip;
+  __unsafe_unretained A * *uip;
+
+  identity<A *> res1 = accept_strong_ptr(sip);
+  identity<__strong A *> res2 = accept_any_ptr(sip);
+
+  __strong A * si;
+  __weak A * wi;
+  __autoreleasing A * ai;
+  __unsafe_unretained A * ui;
+  identity<A *> res3 = accept_strong_ref(si);
+  identity<__strong A *> res4 = accept_any_ref(si);
+  identity<__weak A *> res5 = accept_any_ref(wi);
+  identity<__autoreleasing A *> res6 = accept_any_ref(ai);
+  identity<__unsafe_unretained A *> res7 = accept_any_ref(ui);
+}
+
+// Test partial ordering (qualified vs. non-qualified).
+template<typename T>
+struct classify_pointer_pointer {
+  static const unsigned value = 0;
+};
+
+template<typename T>
+struct classify_pointer_pointer<T*> {
+  static const unsigned value = 1;
+};
+
+template<typename T>
+struct classify_pointer_pointer<__strong T*> {
+  static const unsigned value = 2;
+};
+
+template<typename T>
+struct classify_pointer_pointer<__weak T*> {
+  static const unsigned value = 3;
+};
+
+template<typename T>
+struct classify_pointer_pointer<T&> {
+  static const unsigned value = 4;
+};
+
+template<typename T>
+struct classify_pointer_pointer<__strong T&> {
+  static const unsigned value = 5;
+};
+
+template<typename T>
+struct classify_pointer_pointer<__weak T&> {
+  static const unsigned value = 6;
+};
+
+int classify_ptr1[classify_pointer_pointer<int>::value == 0? 1 : -1];
+int classify_ptr2[classify_pointer_pointer<int *>::value == 1? 1 : -1];
+int classify_ptr3[classify_pointer_pointer<id __strong *>::value == 2? 1 : -1];
+int classify_ptr4[classify_pointer_pointer<id __weak *>::value == 3? 1 : -1];
+int classify_ptr5[classify_pointer_pointer<int&>::value == 4? 1 : -1];
+int classify_ptr6[classify_pointer_pointer<id __strong&>::value == 5? 1 : -1];
+int classify_ptr7[classify_pointer_pointer<id __weak&>::value == 6? 1 : -1];
+int classify_ptr8[classify_pointer_pointer<id __autoreleasing&>::value == 4? 1 : -1];
+int classify_ptr9[classify_pointer_pointer<id __unsafe_unretained&>::value == 4? 1 : -1];
+int classify_ptr10[classify_pointer_pointer<id __autoreleasing *>::value == 1? 1 : -1];
+int classify_ptr11[classify_pointer_pointer<id __unsafe_unretained *>::value == 1? 1 : -1];
+int classify_ptr12[classify_pointer_pointer<int *>::value == 1? 1 : -1];
+int classify_ptr13[classify_pointer_pointer<A * __strong *>::value == 2? 1 : -1];
+int classify_ptr14[classify_pointer_pointer<A * __weak *>::value == 3? 1 : -1];
+int classify_ptr15[classify_pointer_pointer<int&>::value == 4? 1 : -1];
+int classify_ptr16[classify_pointer_pointer<A * __strong&>::value == 5? 1 : -1];
+int classify_ptr17[classify_pointer_pointer<A * __weak&>::value == 6? 1 : -1];
+int classify_ptr18[classify_pointer_pointer<A * __autoreleasing&>::value == 4? 1 : -1];
+int classify_ptr19[classify_pointer_pointer<A * __unsafe_unretained&>::value == 4? 1 : -1];
+int classify_ptr20[classify_pointer_pointer<A * __autoreleasing *>::value == 1? 1 : -1];
+int classify_ptr21[classify_pointer_pointer<A * __unsafe_unretained *>::value == 1? 1 : -1];
+
+template<typename T> int& qual_vs_unqual_ptr(__strong T*);
+template<typename T> double& qual_vs_unqual_ptr(__weak T*);
+template<typename T> float& qual_vs_unqual_ptr(T*);
+template<typename T> int& qual_vs_unqual_ref(__strong T&);
+template<typename T> double& qual_vs_unqual_ref(__weak T&);
+template<typename T> float& qual_vs_unqual_ref(T&);
+
+void test_qual_vs_unqual_id() {
+  __strong id *sip;
+  __weak id *wip;
+  __autoreleasing id *aip;
+  __unsafe_unretained id *uip;
+
+  int &ir1 = qual_vs_unqual_ptr(sip);
+  double &dr1 = qual_vs_unqual_ptr(wip);
+  float &fr1 = qual_vs_unqual_ptr(aip);
+  float &fr2 = qual_vs_unqual_ptr(uip);
+
+  int &ir2 = qual_vs_unqual_ref(*sip);
+  double &dr2 = qual_vs_unqual_ref(*wip);
+  float &fr3 = qual_vs_unqual_ref(*aip);
+  float &fr4 = qual_vs_unqual_ref(*uip);
+}
+
+void test_qual_vs_unqual_a() {
+  __strong A * *sap;
+  __weak A * *wap;
+  __autoreleasing A * *aap;
+  __unsafe_unretained A * *uap;
+
+  int &ir1 = qual_vs_unqual_ptr(sap);
+  double &dr1 = qual_vs_unqual_ptr(wap);
+  float &fr1 = qual_vs_unqual_ptr(aap);
+  float &fr2 = qual_vs_unqual_ptr(uap);
+
+  int &ir2 = qual_vs_unqual_ref(*sap);
+  double &dr2 = qual_vs_unqual_ref(*wap);
+  float &fr3 = qual_vs_unqual_ref(*aap);
+  float &fr4 = qual_vs_unqual_ref(*uap);
+}
+
+namespace rdar9828157 {
+  // Template argument deduction involving lifetime qualifiers and
+  // non-lifetime types.
+  class A { };
+
+  template<typename T> float& f(T&);
+  template<typename T> int& f(__strong T&);
+  template<typename T> double& f(__weak T&);
+
+  void test_f(A* ap) {
+    float &fr = (f)(ap);  
+  }
+}
diff --git a/clang/test/SemaObjCXX/arc-type-conversion.mm b/clang/test/SemaObjCXX/arc-type-conversion.mm
new file mode 100644
index 0000000..fd42513
--- /dev/null
+++ b/clang/test/SemaObjCXX/arc-type-conversion.mm
@@ -0,0 +1,218 @@
+// RUN: %clang_cc1 -fobjc-runtime-has-weak -fsyntax-only -fobjc-arc -verify -fblocks %s
+// rdar://8843600
+
+void * cvt(id arg) // expected-note{{candidate function not viable: cannot convert argument of incomplete type 'void *' to '__strong id'}}
+{
+  void* voidp_val;
+  (void)(int*)arg; // expected-error {{cast of an Objective-C pointer to 'int *' is disallowed with ARC}}
+  (void)(id)arg;
+  (void)(__autoreleasing id*)arg; // expected-error{{C-style cast from 'id' to '__autoreleasing id *' casts away qualifiers}}
+  (void)(id*)arg; // expected-error{{C-style cast from 'id' to '__strong id *' casts away qualifiers}}
+
+  (void)(__autoreleasing id**)voidp_val;
+  (void)(void*)voidp_val;
+  (void)(void**)arg; // expected-error {{cast of an Objective-C pointer to 'void **' is disallowed}}
+  cvt((void*)arg); // expected-error {{no matching function for call to 'cvt'}}
+  cvt(0);
+  (void)(__strong id**)(0);
+
+  // FIXME: Diagnostic could be better here.
+  return arg; // expected-error{{cannot initialize return object of type 'void *' with an lvalue of type '__strong id'}}
+}
+
+// rdar://8898937
+namespace rdar8898937 {
+
+typedef void (^dispatch_block_t)(void);
+
+void dispatch_once(dispatch_block_t block);
+static void _dispatch_once(dispatch_block_t block)
+{
+  dispatch_once(block);
+}
+
+}
+
+void static_casts(id arg) {
+  void* voidp_val;
+  (void)static_cast<int*>(arg); // expected-error {{cannot cast from type 'id' to pointer type 'int *'}}
+  (void)static_cast<id>(arg);
+  (void)static_cast<__autoreleasing id*>(arg); // expected-error{{cannot cast from type 'id' to pointer type '__autoreleasing id *'}}
+  (void)static_cast<id*>(arg); // expected-error {{cannot cast from type 'id' to pointer type '__strong id *'}}
+
+  (void)static_cast<__autoreleasing id**>(voidp_val);
+  (void)static_cast<void*>(voidp_val);
+  (void)static_cast<void**>(arg); // expected-error {{cannot cast from type 'id' to pointer type 'void **'}}
+  (void)static_cast<__strong id**>(0);  
+
+  __strong id *idp;
+  (void)static_cast<__autoreleasing id*>(idp); // expected-error{{static_cast from '__strong id *' to '__autoreleasing id *' is not allowed}}
+  (void)static_cast<__weak id*>(idp); // expected-error{{static_cast from '__strong id *' to '__weak id *' is not allowed}}
+}
+
+void test_const_cast(__strong id *sip, __weak id *wip, 
+                     const __strong id *csip, __weak const id *cwip) {
+  // Cannot use const_cast to cast between ownership qualifications or
+  // add/remove ownership qualifications.
+  (void)const_cast<__strong id *>(wip); // expected-error{{is not allowed}}
+  (void)const_cast<__weak id *>(sip); // expected-error{{is not allowed}}
+
+  // It's acceptable to cast away constness.
+  (void)const_cast<__strong id *>(csip);
+  (void)const_cast<__weak id *>(cwip);
+}
+
+void test_reinterpret_cast(__strong id *sip, __weak id *wip, 
+                           const __strong id *csip, __weak const id *cwip) {
+  // Okay to reinterpret_cast to add/remove/change ownership
+  // qualifications.
+  (void)reinterpret_cast<__strong id *>(wip);
+  (void)reinterpret_cast<__weak id *>(sip);
+
+  // Not allowed to cast away constness
+  (void)reinterpret_cast<__strong id *>(csip); // expected-error{{reinterpret_cast from '__strong id const *' to '__strong id *' casts away qualifiers}}
+  (void)reinterpret_cast<__weak id *>(cwip); // expected-error{{reinterpret_cast from '__weak id const *' to '__weak id *' casts away qualifiers}}
+  (void)reinterpret_cast<__weak id *>(csip); // expected-error{{reinterpret_cast from '__strong id const *' to '__weak id *' casts away qualifiers}}
+  (void)reinterpret_cast<__strong id *>(cwip); // expected-error{{reinterpret_cast from '__weak id const *' to '__strong id *' casts away qualifiers}}
+}
+
+void test_cstyle_cast(__strong id *sip, __weak id *wip, 
+                      const __strong id *csip, __weak const id *cwip) {
+  // C-style casts aren't allowed to change Objective-C ownership
+  // qualifiers (beyond what the normal implicit conversion allows).
+
+  (void)(__strong id *)wip; // expected-error{{C-style cast from '__weak id *' to '__strong id *' casts away qualifiers}}
+  (void)(__strong id *)cwip; // expected-error{{C-style cast from '__weak id const *' to '__strong id *' casts away qualifiers}}
+  (void)(__weak id *)sip; // expected-error{{C-style cast from '__strong id *' to '__weak id *' casts away qualifiers}}
+  (void)(__weak id *)csip; // expected-error{{C-style cast from '__strong id const *' to '__weak id *' casts away qualifiers}}
+
+  (void)(__strong const id *)wip; // expected-error{{C-style cast from '__weak id *' to '__strong id const *' casts away qualifiers}}
+  (void)(__strong const id *)cwip; // expected-error{{C-style cast from '__weak id const *' to '__strong id const *' casts away qualifiers}}
+  (void)(__weak const id *)sip; // expected-error{{C-style cast from '__strong id *' to '__weak id const *' casts away qualifiers}}
+  (void)(__weak const id *)csip; // expected-error{{C-style cast from '__strong id const *' to '__weak id const *' casts away qualifiers}}
+  (void)(__autoreleasing const id *)wip; // expected-error{{C-style cast from '__weak id *' to '__autoreleasing id const *' casts away qualifiers}}
+  (void)(__autoreleasing const id *)cwip; // expected-error{{C-style cast from '__weak id const *' to '__autoreleasing id const *' casts away qualifiers}}
+  (void)(__autoreleasing const id *)sip;
+  (void)(__autoreleasing const id *)csip;
+}
+
+void test_functional_cast(__strong id *sip, __weak id *wip,
+                          __autoreleasing id *aip) {
+  // Functional casts aren't allowed to change Objective-C ownership
+  // qualifiers (beyond what the normal implicit conversion allows).
+
+  typedef __strong id *strong_id_pointer;
+  typedef __weak id *weak_id_pointer;
+  typedef __autoreleasing id *autoreleasing_id_pointer;
+
+  typedef const __strong id *const_strong_id_pointer;
+  typedef const __weak id *const_weak_id_pointer;
+  typedef const __autoreleasing id *const_autoreleasing_id_pointer;
+
+  (void)strong_id_pointer(wip); // expected-error{{functional-style cast from '__weak id *' to 'strong_id_pointer' (aka '__strong id *') casts away qualifiers}}
+  (void)weak_id_pointer(sip); // expected-error{{functional-style cast from '__strong id *' to 'weak_id_pointer' (aka '__weak id *') casts away qualifiers}}
+  (void)autoreleasing_id_pointer(sip); // expected-error{{functional-style cast from '__strong id *' to 'autoreleasing_id_pointer' (aka '__autoreleasing id *') casts away qualifiers}}
+  (void)autoreleasing_id_pointer(wip); // expected-error{{functional-style cast from '__weak id *' to 'autoreleasing_id_pointer' (aka '__autoreleasing id *') casts away qualifiers}}
+  (void)const_strong_id_pointer(wip); // expected-error{{functional-style cast from '__weak id *' to 'const_strong_id_pointer' (aka 'const __strong id *') casts away qualifiers}}
+  (void)const_weak_id_pointer(sip); // expected-error{{functional-style cast from '__strong id *' to 'const_weak_id_pointer' (aka 'const __weak id *') casts away qualifiers}}
+  (void)const_autoreleasing_id_pointer(sip);
+  (void)const_autoreleasing_id_pointer(aip);
+  (void)const_autoreleasing_id_pointer(wip); // expected-error{{functional-style cast from '__weak id *' to 'const_autoreleasing_id_pointer' (aka 'const __autoreleasing id *') casts away qualifiers}}
+}
+
+void test_unsafe_unretained(__strong id *sip, __weak id *wip,
+                            __autoreleasing id *aip,
+                            __unsafe_unretained id *uip,
+                            const __unsafe_unretained id *cuip) {
+  uip = sip; // expected-error{{assigning to '__unsafe_unretained id *' from incompatible type '__strong id *'}}
+  uip = wip; // expected-error{{assigning to '__unsafe_unretained id *' from incompatible type '__weak id *'}}
+  uip = aip; // expected-error{{assigning to '__unsafe_unretained id *' from incompatible type '__autoreleasing id *'}}
+
+  cuip = sip;
+  cuip = wip; // expected-error{{assigning to '__unsafe_unretained id const *' from incompatible type '__weak id *'}}
+  cuip = aip;
+}
+
+void to_void(__strong id *sip, __weak id *wip,
+             __autoreleasing id *aip,
+             __unsafe_unretained id *uip) {
+  void *vp1 = sip;
+  void *vp2 = wip;
+  void *vp3 = aip;
+  void *vp4 = uip;
+  (void)(void*)sip;
+  (void)(void*)wip;
+  (void)(void*)aip;
+  (void)(void*)uip;
+  (void)static_cast<void*>(sip);
+  (void)static_cast<void*>(wip);
+  (void)static_cast<void*>(aip);
+  (void)static_cast<void*>(uip);
+  (void)reinterpret_cast<void*>(sip);
+  (void)reinterpret_cast<void*>(wip);
+  (void)reinterpret_cast<void*>(aip);
+  (void)reinterpret_cast<void*>(uip);
+
+  (void)(void*)&sip;
+  (void)(void*)&wip;
+  (void)(void*)&aip;
+  (void)(void*)&uip;
+  (void)static_cast<void*>(&sip);
+  (void)static_cast<void*>(&wip);
+  (void)static_cast<void*>(&aip);
+  (void)static_cast<void*>(&uip);
+  (void)reinterpret_cast<void*>(&sip);
+  (void)reinterpret_cast<void*>(&wip);
+  (void)reinterpret_cast<void*>(&aip);
+  (void)reinterpret_cast<void*>(&uip);
+}
+
+void from_void(void *vp) {
+  __strong id *sip = (__strong id *)vp;
+  __weak id *wip = (__weak id *)vp;
+  __autoreleasing id *aip = (__autoreleasing id *)vp;
+  __unsafe_unretained id *uip = (__unsafe_unretained id *)vp;
+  __strong id *sip2 = static_cast<__strong id *>(vp);
+  __weak id *wip2 = static_cast<__weak id *>(vp);
+  __autoreleasing id *aip2 = static_cast<__autoreleasing id *>(vp);
+  __unsafe_unretained id *uip2 = static_cast<__unsafe_unretained id *>(vp);
+  __strong id *sip3 = reinterpret_cast<__strong id *>(vp);
+  __weak id *wip3 = reinterpret_cast<__weak id *>(vp);
+  __autoreleasing id *aip3 = reinterpret_cast<__autoreleasing id *>(vp);
+  __unsafe_unretained id *uip3 = reinterpret_cast<__unsafe_unretained id *>(vp);
+
+  __strong id **sipp = (__strong id **)vp;
+  __weak id **wipp = (__weak id **)vp;
+  __autoreleasing id **aipp = (__autoreleasing id **)vp;
+  __unsafe_unretained id **uipp = (__unsafe_unretained id **)vp;
+
+  sip = vp; // expected-error{{assigning to '__strong id *' from incompatible type 'void *'}}
+  wip = vp; // expected-error{{assigning to '__weak id *' from incompatible type 'void *'}}
+  aip = vp; // expected-error{{assigning to '__autoreleasing id *' from incompatible type 'void *'}}
+  uip = vp; // expected-error{{assigning to '__unsafe_unretained id *' from incompatible type 'void *'}}
+}
+
+typedef void (^Block)();
+typedef void (^Block_strong)() __strong;
+typedef void (^Block_autoreleasing)() __autoreleasing;
+
+@class NSString;
+
+void ownership_transfer_in_cast(void *vp, Block *pblk) {
+  __strong NSString **sip2 = static_cast<NSString **>(static_cast<__strong id *>(vp));
+  __strong NSString **&si2pref = static_cast<NSString **&>(sip2);
+  __weak NSString **wip2 = static_cast<NSString **>(static_cast<__weak id *>(vp));
+  __autoreleasing id *aip2 = static_cast<id *>(static_cast<__autoreleasing id *>(vp));
+  __unsafe_unretained id *uip2 = static_cast<id *>(static_cast<__unsafe_unretained id *>(vp));
+  __strong id *sip3 = reinterpret_cast<id *>(reinterpret_cast<__strong id *>(vp));
+  __weak id *wip3 = reinterpret_cast<id *>(reinterpret_cast<__weak id *>(vp));
+  __autoreleasing id *aip3 = reinterpret_cast<id *>(reinterpret_cast<__autoreleasing id *>(vp));
+  __unsafe_unretained id *uip3 = reinterpret_cast<id *>(reinterpret_cast<__unsafe_unretained id *>(vp));
+
+  Block_strong blk_strong1;
+  Block_strong blk_strong2 = static_cast<Block>(blk_strong1);
+  Block_autoreleasing *blk_auto = static_cast<Block*>(pblk);
+}
+
+// Make sure we don't crash.
+void writeback_test(NSString & &) {} // expected-error {{type name declared as a reference to a reference}}
diff --git a/clang/test/SemaObjCXX/arc-type-traits.mm b/clang/test/SemaObjCXX/arc-type-traits.mm
new file mode 100644
index 0000000..9877870
--- /dev/null
+++ b/clang/test/SemaObjCXX/arc-type-traits.mm
@@ -0,0 +1,90 @@
+// RUN: %clang_cc1 -fsyntax-only -fobjc-arc -fobjc-runtime-has-weak -verify %s
+
+// Check the results of the various type-trait query functions on
+// lifetime-qualified types in ARC.
+
+#define JOIN3(X,Y) X ## Y
+#define JOIN2(X,Y) JOIN3(X,Y)
+#define JOIN(X,Y) JOIN2(X,Y)
+
+#define TRAIT_IS_TRUE(Trait, Type) char JOIN2(Trait,__LINE__)[Trait(Type)? 1 : -1]
+#define TRAIT_IS_FALSE(Trait, Type) char JOIN2(Trait,__LINE__)[Trait(Type)? -1 : 1]
+  
+// __has_nothrow_assign
+TRAIT_IS_TRUE(__has_nothrow_assign, __strong id);
+TRAIT_IS_TRUE(__has_nothrow_assign, __weak id);
+TRAIT_IS_TRUE(__has_nothrow_assign, __autoreleasing id);
+TRAIT_IS_TRUE(__has_nothrow_assign, __unsafe_unretained id);
+
+// __has_nothrow_copy
+TRAIT_IS_TRUE(__has_nothrow_copy, __strong id);
+TRAIT_IS_TRUE(__has_nothrow_copy, __weak id);
+TRAIT_IS_TRUE(__has_nothrow_copy, __autoreleasing id);
+TRAIT_IS_TRUE(__has_nothrow_copy, __unsafe_unretained id);
+
+// __has_nothrow_constructor
+TRAIT_IS_TRUE(__has_nothrow_constructor, __strong id);
+TRAIT_IS_TRUE(__has_nothrow_constructor, __weak id);
+TRAIT_IS_TRUE(__has_nothrow_constructor, __autoreleasing id);
+TRAIT_IS_TRUE(__has_nothrow_constructor, __unsafe_unretained id);
+
+// __has_trivial_assign
+TRAIT_IS_FALSE(__has_trivial_assign, __strong id);
+TRAIT_IS_FALSE(__has_trivial_assign, __weak id);
+TRAIT_IS_FALSE(__has_trivial_assign, __autoreleasing id);
+TRAIT_IS_TRUE(__has_trivial_assign, __unsafe_unretained id);
+
+// __has_trivial_copy
+TRAIT_IS_FALSE(__has_trivial_copy, __strong id);
+TRAIT_IS_FALSE(__has_trivial_copy, __weak id);
+TRAIT_IS_FALSE(__has_trivial_copy, __autoreleasing id);
+TRAIT_IS_TRUE(__has_trivial_copy, __unsafe_unretained id);
+
+// __has_trivial_constructor
+TRAIT_IS_FALSE(__has_trivial_constructor, __strong id);
+TRAIT_IS_FALSE(__has_trivial_constructor, __weak id);
+TRAIT_IS_FALSE(__has_trivial_constructor, __autoreleasing id);
+TRAIT_IS_TRUE(__has_trivial_constructor, __unsafe_unretained id);
+
+// __has_trivial_destructor
+TRAIT_IS_FALSE(__has_trivial_destructor, __strong id);
+TRAIT_IS_FALSE(__has_trivial_destructor, __weak id);
+TRAIT_IS_TRUE(__has_trivial_destructor, __autoreleasing id);
+TRAIT_IS_TRUE(__has_trivial_destructor, __unsafe_unretained id);
+
+// __is_literal
+TRAIT_IS_TRUE(__is_literal, __strong id);
+TRAIT_IS_TRUE(__is_literal, __weak id);
+TRAIT_IS_TRUE(__is_literal, __autoreleasing id);
+TRAIT_IS_TRUE(__is_literal, __unsafe_unretained id);
+
+// __is_literal_type
+TRAIT_IS_TRUE(__is_literal_type, __strong id);
+TRAIT_IS_TRUE(__is_literal_type, __weak id);
+TRAIT_IS_TRUE(__is_literal_type, __autoreleasing id);
+TRAIT_IS_TRUE(__is_literal_type, __unsafe_unretained id);
+
+// __is_pod
+TRAIT_IS_FALSE(__is_pod, __strong id);
+TRAIT_IS_FALSE(__is_pod, __weak id);
+TRAIT_IS_FALSE(__is_pod, __autoreleasing id);
+TRAIT_IS_TRUE(__is_pod, __unsafe_unretained id);
+
+// __is_trivial
+TRAIT_IS_FALSE(__is_trivial, __strong id);
+TRAIT_IS_FALSE(__is_trivial, __weak id);
+TRAIT_IS_FALSE(__is_trivial, __autoreleasing id);
+TRAIT_IS_TRUE(__is_trivial, __unsafe_unretained id);
+
+// __is_scalar
+TRAIT_IS_FALSE(__is_scalar, __strong id);
+TRAIT_IS_FALSE(__is_scalar, __weak id);
+TRAIT_IS_FALSE(__is_scalar, __autoreleasing id);
+TRAIT_IS_TRUE(__is_scalar, __unsafe_unretained id);
+
+// __is_standard_layout
+TRAIT_IS_TRUE(__is_standard_layout, __strong id);
+TRAIT_IS_TRUE(__is_standard_layout, __weak id);
+TRAIT_IS_TRUE(__is_standard_layout, __autoreleasing id);
+TRAIT_IS_TRUE(__is_standard_layout, __unsafe_unretained id);
+
diff --git a/clang/test/SemaObjCXX/arc-unavailable-for-weakref.mm b/clang/test/SemaObjCXX/arc-unavailable-for-weakref.mm
new file mode 100644
index 0000000..2a80aeb
--- /dev/null
+++ b/clang/test/SemaObjCXX/arc-unavailable-for-weakref.mm
@@ -0,0 +1,50 @@
+// RUN: %clang_cc1 -x objective-c++ -triple x86_64-apple-darwin11 -fobjc-runtime-has-weak -fsyntax-only -fobjc-arc -verify %s
+// rdar://9693477
+
+__attribute__((objc_arc_weak_reference_unavailable))
+@interface NSOptOut1072  // expected-note {{class is declared here}}
+@end
+
+@interface sub : NSOptOut1072 @end // expected-note 2 {{class is declared here}}
+
+int main() {
+  __weak sub *w2; // expected-error {{class is incompatible with __weak references}}
+
+  __weak NSOptOut1072 *ns1; // expected-error {{class is incompatible with __weak references}}
+
+  id obj;
+
+  ns1 = (__weak sub *)obj; // expected-error {{assignment of a weak-unavailable object to a __weak object}} \
+                           // expected-error {{class is incompatible with __weak references}} \
+                           // expected-error {{explicit ownership qualifier on cast result has no effect}}
+}
+
+// rdar://9732636
+__attribute__((objc_arc_weak_reference_unavailable))
+@interface NOWEAK
++ (id) new;
+@end
+
+NOWEAK * Test1() {
+  NOWEAK * strong1 = [NOWEAK new];
+  __weak id weak1;
+  weak1 = strong1; // expected-error {{assignment of a weak-unavailable object to a __weak object}}
+
+  __weak id weak2 = strong1; // expected-error {{assignment of a weak-unavailable object to a __weak object}}
+  return (__weak id)strong1; // expected-error {{cast of weak-unavailable object of type 'NOWEAK *' to a __weak object of type '__weak id'}} \
+                             // expected-error {{explicit ownership qualifier on cast result has no effect}}
+}
+
+@protocol P @end
+@protocol P1 @end
+
+NOWEAK<P, P1> * Test2() {
+  NOWEAK<P, P1> * strong1 = 0;
+  __weak id<P> weak1;
+  weak1 = strong1; // expected-error {{assignment of a weak-unavailable object to a __weak object}}
+
+  __weak id<P> weak2 = strong1; // expected-error {{assignment of a weak-unavailable object to a __weak object}}
+  return (__weak id<P, P1>)strong1; // expected-error {{cast of weak-unavailable object of type 'NOWEAK<P,P1> *' to a __weak object of type '__weak id<P,P1>'}} \
+                                    // expected-error {{explicit ownership qualifier on cast result has no effect}}
+}
+
diff --git a/clang/test/SemaObjCXX/arc-unbridged-cast.mm b/clang/test/SemaObjCXX/arc-unbridged-cast.mm
new file mode 100644
index 0000000..0b3ba07
--- /dev/null
+++ b/clang/test/SemaObjCXX/arc-unbridged-cast.mm
@@ -0,0 +1,110 @@
+// RUN: %clang_cc1 -triple x86_64-apple-darwin11 -fsyntax-only -fobjc-arc -verify %s
+
+typedef const struct __CFString * CFStringRef;
+typedef const void * CFTypeRef;
+extern "C" CFTypeRef CFBridgingRetain(id X);
+extern "C" id CFBridgingRelease(CFTypeRef);
+
+
+@interface Object
+@property CFStringRef property;
+- (CFStringRef) implicitProperty;
+- (CFStringRef) newString;
+- (CFStringRef) makeString;
+@end
+
+extern Object *object;
+
+// rdar://9744349
+id test0(void) {
+  id p1 = (id)[object property];
+  id p2 = (__bridge_transfer id)[object property];
+  id p3 = (__bridge id)[object property];
+  return (id) object.property;
+}
+
+// rdar://10140692
+CFStringRef unauditedString(void);
+CFStringRef plusOneString(void) __attribute__((cf_returns_retained));
+
+#pragma clang arc_cf_code_audited begin
+CFStringRef auditedString(void);
+CFStringRef auditedCreateString(void);
+#pragma clang arc_cf_code_audited end
+
+void test1(int cond) {
+  id x;
+  x = (id) auditedString();
+  x = (id) (cond ? auditedString() : (void*) 0);
+  x = (id) (cond ? (void*) 0 : auditedString());
+  x = (id) (cond ? (CFStringRef) @"help" : auditedString());
+
+  x = (id) unauditedString(); // expected-error {{requires a bridged cast}} expected-note {{use __bridge to}} expected-note {{use CFBridgingRelease call to}}
+  x = (id) (cond ? unauditedString() : (void*) 0); // expected-error {{requires a bridged cast}} expected-note {{use __bridge to}} expected-note {{use CFBridgingRelease call to}}
+  x = (id) (cond ? (void*) 0 : unauditedString()); // expected-error {{requires a bridged cast}} expected-note {{use __bridge to}} expected-note {{use CFBridgingRelease call to}}
+  x = (id) (cond ? (CFStringRef) @"help" : unauditedString()); // expected-error {{requires a bridged cast}} expected-note {{use __bridge to}} expected-note {{use CFBridgingRelease call to}}
+
+  x = (id) auditedCreateString(); // expected-error {{requires a bridged cast}} expected-note {{use __bridge to}} expected-note {{use CFBridgingRelease call to}}
+  x = (id) (cond ? auditedCreateString() : (void*) 0); // expected-error {{requires a bridged cast}} expected-note {{use __bridge to}} expected-note {{use CFBridgingRelease call to}}
+  x = (id) (cond ? (void*) 0 : auditedCreateString()); // expected-error {{requires a bridged cast}} expected-note {{use __bridge to}} expected-note {{use CFBridgingRelease call to}}
+  x = (id) (cond ? (CFStringRef) @"help" : auditedCreateString()); // expected-error {{requires a bridged cast}} expected-note {{use __bridge to}} expected-note {{use CFBridgingRelease call to}}
+
+  x = (id) [object property];
+  x = (id) (cond ? [object property] : (void*) 0);
+  x = (id) (cond ? (void*) 0 : [object property]);
+  x = (id) (cond ? (CFStringRef) @"help" : [object property]);  
+
+  x = (id) object.property;
+  x = (id) (cond ? object.property : (void*) 0);
+  x = (id) (cond ? (void*) 0 : object.property);
+  x = (id) (cond ? (CFStringRef) @"help" : object.property);  
+
+  x = (id) object.implicitProperty;
+  x = (id) (cond ? object.implicitProperty : (void*) 0);
+  x = (id) (cond ? (void*) 0 : object.implicitProperty);
+  x = (id) (cond ? (CFStringRef) @"help" : object.implicitProperty);  
+
+  x = (id) [object makeString];
+  x = (id) (cond ? [object makeString] : (void*) 0);
+  x = (id) (cond ? (void*) 0 : [object makeString]);
+  x = (id) (cond ? (CFStringRef) @"help" : [object makeString]);  
+
+  x = (id) [object newString];
+  x = (id) (cond ? [object newString] : (void*) 0);
+  x = (id) (cond ? (void*) 0 : [object newString]);
+  x = (id) (cond ? (CFStringRef) @"help" : [object newString]); // a bit questionable
+}
+
+// rdar://problem/10246264
+@interface CFTaker
+- (void) takeOrdinary: (CFStringRef) arg;
+- (void) takeVariadic: (int) n, ...;
+- (void) takeConsumed: (CFStringRef __attribute__((cf_consumed))) arg;
+@end
+void testCFTaker(CFTaker *taker, id string) {
+  [taker takeOrdinary: (CFStringRef) string];
+  [taker takeVariadic: 1, (CFStringRef) string];
+  [taker takeConsumed: (CFStringRef) string]; // expected-error {{cast of Objective-C pointer type 'id' to C pointer type 'CFStringRef'}} expected-note {{use __bridge to}} expected-note {{use CFBridgingRetain call to}}
+}
+
+void takeCFOrdinaryUnaudited(CFStringRef arg);
+void takeCFVariadicUnaudited(int n, ...);
+void takeCFConsumedUnaudited(CFStringRef __attribute__((cf_consumed)) arg);
+#pragma clang arc_cf_code_audited begin
+void takeCFOrdinaryAudited(CFStringRef arg);
+void takeCFVariadicAudited(int n, ...);
+void takeCFConsumedAudited(CFStringRef __attribute__((cf_consumed)) arg);
+#pragma clang arc_cf_code_audited end
+
+void testTakerFunctions(id string) {
+  takeCFOrdinaryUnaudited((CFStringRef) string); // expected-error {{cast of Objective-C pointer type 'id' to C pointer type 'CFStringRef'}} expected-note {{use __bridge to}} expected-note {{use CFBridgingRetain call to}}
+  takeCFVariadicUnaudited(1, (CFStringRef) string); // expected-error {{cast of Objective-C pointer type 'id' to C pointer type 'CFStringRef'}} expected-note {{use __bridge to}} expected-note {{use CFBridgingRetain call to}}
+  takeCFConsumedUnaudited((CFStringRef) string); // expected-error {{cast of Objective-C pointer type 'id' to C pointer type 'CFStringRef'}} expected-note {{use __bridge to}} expected-note {{use CFBridgingRetain call to}}
+
+  void (*taker)(CFStringRef) = 0;
+  taker((CFStringRef) string); // expected-error {{cast of Objective-C pointer type 'id' to C pointer type 'CFStringRef'}} expected-note {{use __bridge to}} expected-note {{use CFBridgingRetain call to}}
+
+  takeCFOrdinaryAudited((CFStringRef) string);
+  takeCFVariadicAudited(1, (CFStringRef) string);
+  takeCFConsumedAudited((CFStringRef) string); // expected-error {{cast of Objective-C pointer type 'id' to C pointer type 'CFStringRef'}} expected-note {{use __bridge to}} expected-note {{use CFBridgingRetain call to}}
+}
diff --git a/clang/test/SemaObjCXX/argument-dependent-lookup.mm b/clang/test/SemaObjCXX/argument-dependent-lookup.mm
new file mode 100644
index 0000000..a25cc68
--- /dev/null
+++ b/clang/test/SemaObjCXX/argument-dependent-lookup.mm
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// <rdar://problem/9142559>: For the purposes of Argument-Dependent
+// Lookup, Objective-C classes are considered to be in the global
+// namespace.
+
+@interface NSFoo
+@end
+
+template<typename T>
+void f(T t) {
+  g(t);
+}
+
+void g(NSFoo*);
+
+void test(NSFoo *foo) {
+  f(foo);
+}
diff --git a/clang/test/SemaObjCXX/blocks.mm b/clang/test/SemaObjCXX/blocks.mm
new file mode 100644
index 0000000..09d614d
--- /dev/null
+++ b/clang/test/SemaObjCXX/blocks.mm
@@ -0,0 +1,146 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -fblocks -Wno-objc-root-class %s
+@protocol NSObject;
+
+void bar(id(^)(void));
+void foo(id <NSObject>(^objectCreationBlock)(void)) {
+    return bar(objectCreationBlock); // OK
+}
+
+void bar2(id(*)(void));
+void foo2(id <NSObject>(*objectCreationBlock)(void)) {
+    return bar2(objectCreationBlock); // expected-warning{{incompatible pointer types passing 'id<NSObject> (*)()' to parameter of type 'id (*)()'}}
+}
+
+void bar3(id(*)()); // expected-note{{candidate function}}
+void foo3(id (*objectCreationBlock)(int)) {
+    return bar3(objectCreationBlock); // expected-error{{no matching}}
+}
+
+void bar4(id(^)()); // expected-note{{candidate function}}
+void foo4(id (^objectCreationBlock)(int)) {
+    return bar4(objectCreationBlock); // expected-error{{no matching}}
+}
+
+void foo5(id (^x)(int)) {
+  if (x) { }
+}
+
+// <rdar://problem/6590445>
+@interface Foo {
+    @private
+    void (^_block)(void);
+}
+- (void)bar;
+@end
+
+namespace N {
+  class X { };      
+  void foo(X);
+}
+
+@implementation Foo
+- (void)bar {
+    _block();
+    foo(N::X()); // okay
+}
+@end
+
+typedef signed char BOOL;
+void foo6(void *block) {  
+	void (^vb)(id obj, int idx, BOOL *stop) = (void (^)(id, int, BOOL *))block;
+    BOOL (^bb)(id obj, int idx, BOOL *stop) = (BOOL (^)(id, int, BOOL *))block;
+}
+
+// <rdar://problem/8600419>: Require that the types of block
+// parameters are complete.
+namespace N1 {
+  template<class _T> class ptr; // expected-note{{template is declared here}}
+
+  template<class _T>
+    class foo {
+  public:
+    void bar(void (^)(ptr<_T>));
+  };
+
+  class X;
+
+  void test2();
+
+  void test()
+  {
+    foo<X> f;
+    f.bar(^(ptr<X> _f) { // expected-error{{implicit instantiation of undefined template 'N1::ptr<N1::X>'}}
+        test2();
+      });
+  }
+}
+
+// Make sure we successfully instantiate the copy constructor of a
+// __block variable's type.
+namespace N2 {
+  template <int n> struct A {
+    A() {}
+    A(const A &other) {
+      int invalid[-n]; // expected-error 2 {{array with a negative size}}
+    }
+  };
+
+  void test1() {
+    __block A<1> x; // expected-note {{requested here}}
+  }
+
+  template <int n> void test2() {
+    __block A<n> x; // expected-note {{requested here}}
+  }
+  template void test2<2>();
+}
+
+// Handle value-dependent block declaration references.
+namespace N3 {
+  template<int N> struct X { };
+
+  template<int N>
+  void f() {
+    X<N> xN = ^() { return X<N>(); }();
+  }
+}
+
+// rdar://8979379
+
+@interface A
+@end
+
+@interface B : A
+@end
+
+void f(int (^bl)(A* a)); // expected-note {{candidate function not viable: no known conversion from 'int (^)(B *)' to 'int (^)(A *)' for 1st argument}}
+
+void g() {
+  f(^(B* b) { return 0; }); // expected-error {{no matching function for call to 'f'}}
+}
+
+namespace DependentReturn {
+  template<typename T>
+  void f(T t) {
+    (void)^(T u) {
+      if (t != u)
+        return t + u;
+      else
+        return;
+    };
+
+    (void)^(T u) {
+      if (t == u)
+        return;
+      else
+        return t + u;
+    };
+  }
+
+  struct X { };
+  void operator+(X, X);
+  bool operator==(X, X);
+  bool operator!=(X, X);
+
+  template void f<X>(X);
+}
diff --git a/clang/test/SemaObjCXX/category-lookup.mm b/clang/test/SemaObjCXX/category-lookup.mm
new file mode 100644
index 0000000..0e87025
--- /dev/null
+++ b/clang/test/SemaObjCXX/category-lookup.mm
@@ -0,0 +1,10 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+@interface NSObject @end
+
+@interface NSObject (NSScriptClassDescription)
+@end
+
+void f() {
+  NSScriptClassDescription *f; // expected-error {{use of undeclared identifier 'NSScriptClassDescription'}}
+}
diff --git a/clang/test/SemaObjCXX/composite-objc-pointertype.mm b/clang/test/SemaObjCXX/composite-objc-pointertype.mm
new file mode 100644
index 0000000..684f633
--- /dev/null
+++ b/clang/test/SemaObjCXX/composite-objc-pointertype.mm
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
+
+@interface Foo
+@end
+
+@implementation Foo
+- (id)test {
+        id bar;
+    Class cl;
+    Foo *f;
+
+    (void)((bar!= 0) ? bar : 0);
+    (void)((cl != 0) ? cl : 0);
+    (void)((f != 0) ? 0 : f);
+    return (0 == 1) ? 0 : bar;
+}
+@end
+
diff --git a/clang/test/SemaObjCXX/conditional-expr.mm b/clang/test/SemaObjCXX/conditional-expr.mm
new file mode 100644
index 0000000..a6b7c08
--- /dev/null
+++ b/clang/test/SemaObjCXX/conditional-expr.mm
@@ -0,0 +1,67 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+@protocol P0
+@end
+@protocol P1
+@end
+@protocol P2
+@end
+
+@interface A <P0>
+@end
+
+@interface B : A
+@end
+
+void bar(id x);
+void barP0(id<P0> x);
+void barP1(id<P1> x);
+void barP2(id<P2> x);
+
+void f0(A *a) {
+  id l = a;
+}
+
+void f1(id x, A *a) {
+  id<P0> l = a;
+}
+
+void f2(id<P1> x) {
+  id<P0> l = x; // expected-error {{cannot initialize a variable of type 'id<P0>' with an lvalue of type 'id<P1>'}}
+}
+
+void f3(A *a) {
+  id<P1> l = a; // expected-error {{cannot initialize a variable of type 'id<P1>' with an lvalue of type 'A *'}}
+}
+
+void f4(int cond, id x, A *a) {
+  bar(cond ? x : a);
+}
+
+void f5(int cond, A *a, B *b) {
+  bar(cond ? a : b);
+}
+
+void f6(int cond, id x, A *a) {
+  bar(cond ? (id<P0, P1>) x : a);
+}
+
+void f7(int cond, id x, A *a) {
+  bar(cond ? a : (id<P0, P1>) x);
+}
+
+void f8(int cond, id<P0,P1> x0, id<P0,P2> x1) {
+  barP0(cond ? x0 : x1); // expected-warning {{incompatible operand types ('id<P0,P1>' and 'id<P0,P2>')}}
+}
+
+void f9(int cond, id<P0,P1> x0, id<P0,P2> x1) {
+  barP1(cond ? x0 : x1); // expected-warning {{incompatible operand types ('id<P0,P1>' and 'id<P0,P2>')}}
+}
+
+void f10(int cond, id<P0,P1> x0, id<P0,P2> x1) {
+  barP2(cond ? x0 : x1); // expected-warning {{incompatible operand types ('id<P0,P1>' and 'id<P0,P2>')}}
+}
+
+int f11(int cond, A* a, B* b) {
+  return (cond? b : a)->x; // expected-error{{'A' does not have a member named 'x'}}
+}
diff --git a/clang/test/SemaObjCXX/const-cast.mm b/clang/test/SemaObjCXX/const-cast.mm
new file mode 100644
index 0000000..933fd47
--- /dev/null
+++ b/clang/test/SemaObjCXX/const-cast.mm
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+@class Foo;
+
+void test() {
+    const Foo *foo1 = 0;
+    Foo *foo2 = foo1; // expected-error {{cannot initialize}}
+}
+
+void test1() {
+    const Foo *foo1 = 0;
+    Foo *foo2 = const_cast<Foo*>(foo1);
+}
diff --git a/clang/test/SemaObjCXX/conversion-ranking.mm b/clang/test/SemaObjCXX/conversion-ranking.mm
new file mode 100644
index 0000000..6c1408b
--- /dev/null
+++ b/clang/test/SemaObjCXX/conversion-ranking.mm
@@ -0,0 +1,89 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+@protocol P1
+@end
+
+@interface A <P1>
+@end
+
+@interface B : A
+@end
+
+@interface C : B
+@end
+
+template<typename T>
+struct ConvertsTo {
+  operator T() const;
+};
+
+
+// conversion of C* to B* is better than conversion of C* to A*.
+int &f0(A*);
+float &f0(B*);
+
+void test_f0(C *c) {
+  float &fr1 = f0(c);
+}
+
+// conversion of B* to A* is better than conversion of C* to A*
+void f1(A*);
+
+struct ConvertsToBoth {
+private:
+  operator C*() const;
+
+public:
+  operator B*() const;
+};
+
+void test_f1(ConvertsTo<B*> toB, ConvertsTo<C*> toC, ConvertsToBoth toBoth) {
+  f1(toB);
+  f1(toC);
+  f1(toBoth);
+};
+
+// A conversion to an a non-id object pointer type is better than a 
+// conversion to 'id'.
+int &f2(A*);
+float &f2(id);
+
+void test_f2(B *b) {
+  int &ir = f2(b);
+}
+
+// A conversion to an a non-Class object pointer type is better than a 
+// conversion to 'Class'.
+int &f3(A*);
+float &f3(Class);
+
+void test_f3(B *b) {
+  int &ir = f3(b);
+}
+
+// When both conversions convert to 'id' or 'Class', pick the most
+// specific type to convert from.
+void f4(id);
+
+void test_f4(ConvertsTo<B*> toB, ConvertsTo<C*> toC, ConvertsToBoth toBoth) {
+  f4(toB);
+  f4(toC);
+  f4(toBoth);
+}
+
+void f5(id<P1>);
+
+void test_f5(ConvertsTo<B*> toB, ConvertsTo<C*> toC, ConvertsToBoth toBoth) {
+  f5(toB);
+  f5(toC);
+  f5(toBoth);
+}
+
+
+// A conversion to an a non-id object pointer type is better than a 
+// conversion to qualified 'id'.
+int &f6(A*);
+float &f6(id<P1>);
+
+void test_f6(B *b) {
+  int &ir = f6(b);
+}
diff --git a/clang/test/SemaObjCXX/conversion-to-objc-pointer-2.mm b/clang/test/SemaObjCXX/conversion-to-objc-pointer-2.mm
new file mode 100644
index 0000000..b03d4d8
--- /dev/null
+++ b/clang/test/SemaObjCXX/conversion-to-objc-pointer-2.mm
@@ -0,0 +1,88 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// rdar: // 7963410
+
+@protocol NSObject @end
+@interface NSObject
+- (id)init;
+- (id) alloc;
+- (id) autorelease;
+@end
+
+template<class T>
+class TNSAutoRef
+{
+public:
+	TNSAutoRef(T t)
+		:	fRef(t)
+		{ }
+
+	~TNSAutoRef()
+		{ }
+
+	operator T() const
+		{ return fRef; }
+
+private:
+	T fRef;
+};
+
+
+#pragma mark -
+
+
+@protocol TFooProtocol <NSObject>
+
+- (void) foo;
+@end
+
+
+#pragma mark -
+
+
+@interface TFoo : NSObject
+
+- (void) setBlah: (id<TFooProtocol>)blah;
+@end
+
+
+#pragma mark -
+
+
+@implementation TFoo
+
+- (void) setBlah: (id<TFooProtocol>)blah
+	{ }
+@end
+
+
+#pragma mark -
+
+
+@interface TBar : NSObject
+
+- (void) setBlah: (id)blah;
+@end
+
+#pragma mark -
+
+
+@implementation TBar
+
+- (void) setBlah: (id)blah
+	{ }
+@end
+
+
+#pragma mark -
+
+
+int main (int argc, const char * argv[]) {
+
+	NSObject* object1 = [[[NSObject alloc] init] autorelease];
+	TNSAutoRef<NSObject*> object2([[NSObject alloc] init]);
+	TNSAutoRef<TBar*> bar([[TBar alloc] init]);
+	[bar setBlah: object1];				// <== Does not compile.  It should.
+        if (object1 == object2)
+	  [bar setBlah: object2];				// <== Does not compile.  It should.
+	return 0;
+}
diff --git a/clang/test/SemaObjCXX/conversion-to-objc-pointer.mm b/clang/test/SemaObjCXX/conversion-to-objc-pointer.mm
new file mode 100644
index 0000000..235aaac
--- /dev/null
+++ b/clang/test/SemaObjCXX/conversion-to-objc-pointer.mm
@@ -0,0 +1,50 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// rdar: // 7963410
+
+template<class T>
+class TNSAutoRef
+{
+public:
+	TNSAutoRef(T t)
+		:	fRef(t)
+		{ }
+
+	~TNSAutoRef()
+		{  }
+
+	operator T() const
+		{ return fRef; }
+	
+	T Get() const
+		{ return fRef; }
+
+private:
+	T fRef;
+};
+
+@interface NSObject
+- (id) alloc;
+- (id)init;
+@end
+
+@interface TFoo : NSObject
+- (void) foo;
+@end
+
+@implementation TFoo
+- (void) foo {}
+@end
+
+@interface TBar : NSObject
+- (void) foo;
+@end
+
+@implementation TBar 
+- (void) foo {}
+@end
+
+int main () {
+	TNSAutoRef<TBar*> bar([[TBar alloc] init]);
+	[bar foo];
+	return 0;
+}
diff --git a/clang/test/SemaObjCXX/cstyle-block-pointer-cast.mm b/clang/test/SemaObjCXX/cstyle-block-pointer-cast.mm
new file mode 100644
index 0000000..0f982ba
--- /dev/null
+++ b/clang/test/SemaObjCXX/cstyle-block-pointer-cast.mm
@@ -0,0 +1,42 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -fblocks -Wno-objc-root-class %s
+// radar 7562285
+
+typedef int (^blocktype)(int a, int b);
+
+@interface A {
+    A* a;
+    id b;
+    Class c;
+}
+- (blocktype)Meth;
+@end
+
+@implementation A
+- (blocktype)Meth {
+        if (b)
+	  return (blocktype)b;
+        else if (a)
+          return (blocktype)a; // expected-error {{C-style cast from 'A *' to 'blocktype' (aka 'int (^)(int, int)') is not allowed}}
+        else
+          return (blocktype)c;
+}
+@end
+
+@interface B {
+    blocktype a;
+    blocktype b;
+    blocktype c;
+}
+- (id)Meth;
+@end
+
+@implementation B
+- (id)Meth {
+        if (a)
+          return (A*)a; // expected-error {{C-style cast from 'blocktype' (aka 'int (^)(int, int)') to 'A *' is not allowed}}
+        if (b)
+	  return (id)b;
+        if (c)
+	  return (Class)b;
+}
+@end
diff --git a/clang/test/SemaObjCXX/cstyle-cast.mm b/clang/test/SemaObjCXX/cstyle-cast.mm
new file mode 100644
index 0000000..29a8404
--- /dev/null
+++ b/clang/test/SemaObjCXX/cstyle-cast.mm
@@ -0,0 +1,40 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+@protocol P @end
+@interface I @end
+
+struct X { X(); };
+
+void test1(X x) {
+  void *cft;
+  id oct = (id)cft;
+
+  Class ccct;
+  ccct = (Class)cft;
+
+  I* iict = (I*)cft;
+
+  id<P> qid = (id<P>)cft;
+
+  I<P> *ip = (I<P>*)cft;
+
+  (id)x; // expected-error {{cannot convert 'X' to 'id' without a conversion operator}}
+
+  id *pid = (id*)ccct;
+
+  id<P> *qpid = (id<P>*)ccct;
+
+  int **pii;
+
+  ccct = (Class)pii;
+
+  qpid = (id<P>*)pii;
+
+  iict = (I*)pii;
+
+  pii = (int **)ccct;
+
+  pii = (int **)qpid;
+  
+}
+
diff --git a/clang/test/SemaObjCXX/cxxoperator-selector.mm b/clang/test/SemaObjCXX/cxxoperator-selector.mm
new file mode 100644
index 0000000..f1aecab
--- /dev/null
+++ b/clang/test/SemaObjCXX/cxxoperator-selector.mm
@@ -0,0 +1,24 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
+// rdar:// 8328250
+
+@class NSDate;
+
+@interface XSGraphDataSet 
+- and;
+- xor;
+- or;
+
+- ||; // expected-error {{expected selector for Objective-C method}}
+
+- &&; // expected-error {{expected selector for Objective-C method}}
+
+- (void)dataSetForValuesBetween:(NSDate *)startDate and:(NSDate *)endDate;
+@end
+
+@implementation XSGraphDataSet
+- (id) and{return 0; };
+- (id) xor{return 0; };
+- (id) or{return 0; };
+
+- (void)dataSetForValuesBetween:(NSDate *)startDate and:(NSDate *)endDate { return; }
+@end
diff --git a/clang/test/SemaObjCXX/debugger-cast-result-to-id.mm b/clang/test/SemaObjCXX/debugger-cast-result-to-id.mm
new file mode 100644
index 0000000..cd7aa7b
--- /dev/null
+++ b/clang/test/SemaObjCXX/debugger-cast-result-to-id.mm
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -fdebugger-support -fdebugger-cast-result-to-id -funknown-anytype -fsyntax-only -verify %s
+
+// rdar://problem/9416370
+namespace test0 {
+  void test(id x) {
+    if ([x foo]) {} // expected-error {{no known method '-foo'; cast the message send to the method's return type}}
+    [x foo];
+  }
+}
+
+// rdar://10988847
+@class NSString; // expected-note {{forward declaration of class here}}
+namespace test1 {
+  void rdar10988847() {
+    id s = [NSString stringWithUTF8String:"foo"]; // expected-warning {{receiver 'NSString' is a forward class and corresponding @interface may not exist}}
+  }
+}
diff --git a/clang/test/SemaObjCXX/deduction.mm b/clang/test/SemaObjCXX/deduction.mm
new file mode 100644
index 0000000..220f368
--- /dev/null
+++ b/clang/test/SemaObjCXX/deduction.mm
@@ -0,0 +1,65 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+@class NSString;
+
+// Reduced from WebKit.
+namespace test0 {
+  template <typename T> struct RemovePointer {
+    typedef T Type;
+  };
+
+  template <typename T> struct RemovePointer<T*> {
+    typedef T Type;
+  };
+
+  template <typename T> struct RetainPtr {
+    typedef typename RemovePointer<T>::Type ValueType;
+    typedef ValueType* PtrType;
+    RetainPtr(PtrType ptr);
+  };
+ 
+  void test(NSString *S) {
+    RetainPtr<NSString*> ptr(S);
+  }
+
+  void test(id S) {
+    RetainPtr<id> ptr(S);
+  }
+}
+
+@class Test1Class;
+@protocol Test1Protocol;
+namespace test1 {
+  template <typename T> struct RemovePointer {
+    typedef T type;
+  };
+  template <typename T> struct RemovePointer<T*> {
+    typedef T type;
+  };
+  template <typename A, typename B> struct is_same {};
+  template <typename A> struct is_same<A,A> {
+    static void foo();
+  };
+  template <typename T> struct tester {
+    void test() {
+      is_same<T, typename RemovePointer<T>::type*>::foo(); // expected-error 2 {{no member named 'foo'}}
+    }
+  };
+
+  template struct tester<id>;
+  template struct tester<id<Test1Protocol> >;
+  template struct tester<Class>;
+  template struct tester<Class<Test1Protocol> >;
+  template struct tester<Test1Class*>;
+  template struct tester<Test1Class<Test1Protocol>*>;
+
+  template struct tester<Test1Class>; // expected-note {{in instantiation}}
+  template struct tester<Test1Class<Test1Protocol> >; // expected-note {{in instantiation}}
+}
+
+namespace test2 {
+  template <typename T> void foo(const T* t) {}
+  void test(id x) {
+    foo(x);
+  }
+}
diff --git a/clang/test/SemaObjCXX/exceptions-fragile.mm b/clang/test/SemaObjCXX/exceptions-fragile.mm
new file mode 100644
index 0000000..91b7077
--- /dev/null
+++ b/clang/test/SemaObjCXX/exceptions-fragile.mm
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fobjc-fragile-abi -fsyntax-only -verify %s 
+
+@interface NSException @end
+void opaque();
+
+namespace test0 {
+  void test() {
+    try {
+    } catch (NSException *e) { // expected-warning {{can not catch an exception thrown with @throw in C++ in the non-unified exception model}}
+    }
+  }
+}
diff --git a/clang/test/SemaObjCXX/expr-objcxx.mm b/clang/test/SemaObjCXX/expr-objcxx.mm
new file mode 100644
index 0000000..e70a001
--- /dev/null
+++ b/clang/test/SemaObjCXX/expr-objcxx.mm
@@ -0,0 +1,4 @@
+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only
+
+// rdar://8366474
+void *P =  @selector(foo::bar::);
diff --git a/clang/test/SemaObjCXX/foreach-block.mm b/clang/test/SemaObjCXX/foreach-block.mm
new file mode 100644
index 0000000..91bd0c8
--- /dev/null
+++ b/clang/test/SemaObjCXX/foreach-block.mm
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -fblocks %s
+// rdar://8295106
+
+int main() {
+id array;
+
+    for (int (^b)(void) in array) {
+        if (b() == 10000) {
+            return 1;
+        }
+    }
+
+    int (^b)(void) in array; // expected-error {{expected ';' at end of declaration}}
+}
diff --git a/clang/test/SemaObjCXX/fragile-abi-object-assign.m b/clang/test/SemaObjCXX/fragile-abi-object-assign.m
new file mode 100644
index 0000000..5bb3ac6
--- /dev/null
+++ b/clang/test/SemaObjCXX/fragile-abi-object-assign.m
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 -x objective-c++ -triple x86_64-apple-darwin11 -fsyntax-only -fobjc-fragile-abi -verify -Wno-objc-root-class %s
+// rdar://10731065
+
+@interface MyView {}
+@end
+
+@implementation MyViewTemplate // expected-warning {{cannot find interface declaration for 'MyViewTemplate'}}
+- (id) createRealObject {
+  id realObj;
+  *(MyView *) realObj = *(MyView *) self; // expected-error {{cannot assign to class object}}
+}
+@end
+
diff --git a/clang/test/SemaObjCXX/function-pointer-void-star.mm b/clang/test/SemaObjCXX/function-pointer-void-star.mm
new file mode 100644
index 0000000..8d3d625
--- /dev/null
+++ b/clang/test/SemaObjCXX/function-pointer-void-star.mm
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+extern "C" id (*_dealloc)(id) ;
+
+void foo() {
+        extern void *_original_dealloc;
+        if (_dealloc == _original_dealloc) { }
+        if (_dealloc != _original_dealloc) { }
+}
diff --git a/clang/test/SemaObjCXX/gc-attributes.mm b/clang/test/SemaObjCXX/gc-attributes.mm
new file mode 100644
index 0000000..4549683
--- /dev/null
+++ b/clang/test/SemaObjCXX/gc-attributes.mm
@@ -0,0 +1,22 @@
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fobjc-gc -fsyntax-only -verify %s
+
+@interface A
+@end
+
+void f0(__strong A**); // expected-note{{candidate function not viable: 1st argument ('A *__weak *') has __weak ownership, but parameter has __strong ownership}}
+
+void test_f0() {
+  A *a;
+  static __weak A *a2;
+  f0(&a);
+  f0(&a2); // expected-error{{no matching function}}
+}
+
+void f1(__weak A**); // expected-note{{candidate function not viable: 1st argument ('A *__strong *') has __strong ownership, but parameter has __weak ownership}}
+
+void test_f1() {
+  A *a;
+  __strong A *a2;
+  f1(&a);
+  f1(&a2); // expected-error{{no matching function}}
+}
diff --git a/clang/test/SemaObjCXX/goto.mm b/clang/test/SemaObjCXX/goto.mm
new file mode 100644
index 0000000..55bde99
--- /dev/null
+++ b/clang/test/SemaObjCXX/goto.mm
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
+
+// PR9495
+struct NonPOD { NonPOD(); ~NonPOD(); };
+
+@interface A
+@end
+
+@implementation A
+- (void)method:(bool)b {
+  NonPOD np;
+  if (b) {
+    goto undeclared; // expected-error{{use of undeclared label 'undeclared'}}
+  }
+}
+@end
diff --git a/clang/test/SemaObjCXX/instantiate-expr.mm b/clang/test/SemaObjCXX/instantiate-expr.mm
new file mode 100644
index 0000000..75a5b7e
--- /dev/null
+++ b/clang/test/SemaObjCXX/instantiate-expr.mm
@@ -0,0 +1,75 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+@interface A {
+@public
+  int ivar;
+}
+@property int prop;
+@end
+
+typedef struct objc_object {
+    Class isa;
+} *id;
+
+// Test instantiation of value-dependent ObjCIvarRefExpr,
+// ObjCIsaRefExpr, and ObjCPropertyRefExpr nodes.
+A *get_an_A(unsigned);
+id get_an_id(unsigned);
+
+template<unsigned N, typename T, typename U, typename V>
+void f(U value, V value2) {
+  get_an_A(N)->ivar = value; // expected-error{{assigning to 'int' from incompatible type 'int *'}}
+  get_an_A(N).prop = value2; // expected-error{{assigning to 'int' from incompatible type 'double *'}}
+  T c = get_an_id(N)->isa; // expected-error{{cannot initialize a variable of type 'int' with an lvalue of type 'Class'}} \
+                           // expected-warning 5 {{direct access to objective-c's isa is deprecated in favor of object_setClass() and object_getClass()}}
+}
+
+template void f<6, Class>(int, int); // expected-note{{in instantiation of}}
+template void f<7, Class>(int*, int); // expected-note{{in instantiation of}}
+template void f<8, Class>(int, double*); // expected-note{{in instantiation of}}
+template void f<9, int>(int, int); // expected-note{{in instantiation of}}
+
+// Test instantiation of unresolved member reference expressions to an
+// ivar reference.
+template<typename T, typename U, typename V>
+void f2(T ptr, U value, V value2) {
+  ptr->ivar = value; // expected-error{{assigning to 'int' from incompatible type 'int *'}}
+  ptr.prop = value2; // expected-error{{assigning to 'int' from incompatible type 'double *'}}
+}
+
+template void f2(A*, int, int);
+template void f2(A*, int*, int); // expected-note{{instantiation of}}
+template void f2(A*, int, double*); // expected-note{{instantiation of}}
+
+// Test instantiation of unresolved member referfence expressions to
+// an isa.
+template<typename T, typename U>
+void f3(U ptr) {
+  T c = ptr->isa; // expected-error{{cannot initialize a variable of type 'int' with an lvalue of type 'Class'}} \
+                  // expected-warning 2 {{direct access to objective-c's isa is deprecated in favor of object_setClass() and object_getClass()}}
+}
+
+template void f3<Class>(id); // expected-note{{in instantiation of}}
+template void f3<int>(id); // expected-note{{instantiation of}}
+
+// Implicit setter/getter
+@interface B
+- (int)foo;
+- (void)setFoo:(int)value;
+@end
+
+template<typename T>
+void f4(B *b, T value) {
+  b.foo = value; // expected-error{{assigning to 'int' from incompatible type 'int *'}}
+}
+
+template void f4(B*, int);
+template void f4(B*, int*); // expected-note{{in instantiation of function template specialization 'f4<int *>' requested here}}
+
+template<typename T, typename U>
+void f5(T ptr, U value) {
+  ptr.foo = value; // expected-error{{assigning to 'int' from incompatible type 'int *'}}
+}
+
+template void f5(B*, int);
+template void f5(B*, int*); // expected-note{{in instantiation of function template specialization 'f5<B *, int *>' requested here}}
diff --git a/clang/test/SemaObjCXX/instantiate-message.mm b/clang/test/SemaObjCXX/instantiate-message.mm
new file mode 100644
index 0000000..e09b182
--- /dev/null
+++ b/clang/test/SemaObjCXX/instantiate-message.mm
@@ -0,0 +1,50 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// Test template instantiation of Objective-C message sends.
+
+@interface ClassMethods
++ (ClassMethods *)method1:(void*)ptr;
+@end
+
+template<typename T>
+struct identity {
+  typedef T type;
+};
+
+template<typename R, typename T, typename Arg1>
+void test_class_method(Arg1 arg1) {
+  R *result1 = [T method1:arg1];
+  R *result2 = [typename identity<T>::type method1:arg1];
+  R *result3 = [ClassMethods method1:arg1]; // expected-error{{cannot initialize a variable of type 'ClassMethods2 *' with an rvalue of type 'ClassMethods *'}}
+}
+
+template void test_class_method<ClassMethods, ClassMethods>(void*);
+template void test_class_method<ClassMethods, ClassMethods>(int*);
+
+@interface ClassMethods2
++ (ClassMethods2 *)method1:(int*)ptr;
+@end
+
+template void test_class_method<ClassMethods2, ClassMethods2>(int*); // expected-note{{in instantiation of}}
+
+
+@interface InstanceMethods
+- (InstanceMethods *)method1:(void*)ptr;
+@end
+
+template<typename R, typename T, typename Arg1>
+void test_instance_method(Arg1 arg1) {
+  T *receiver = 0;
+  InstanceMethods *im = 0;
+  R *result1 = [receiver method1:arg1];
+  R *result2 = [im method1:arg1]; // expected-error{{cannot initialize a variable of type 'InstanceMethods2 *' with an rvalue of type 'InstanceMethods *'}}
+}
+
+template void test_instance_method<InstanceMethods, InstanceMethods>(void*);
+template void test_instance_method<InstanceMethods, InstanceMethods>(int*);
+
+@interface InstanceMethods2
+- (InstanceMethods2 *)method1:(void*)ptr;
+@end
+
+template void test_instance_method<InstanceMethods2, InstanceMethods2>(int*); // expected-note{{in instantiation of}}
diff --git a/clang/test/SemaObjCXX/instantiate-method-return.mm b/clang/test/SemaObjCXX/instantiate-method-return.mm
new file mode 100644
index 0000000..2a3ae32
--- /dev/null
+++ b/clang/test/SemaObjCXX/instantiate-method-return.mm
@@ -0,0 +1,26 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
+// PR7386
+
+@class NSObject;
+
+class A;
+template<class T> class V {};
+
+@protocol Protocol
+- (V<A*>)protocolMethod;
+@end
+
+
+@interface I<Protocol>
+@end
+
+
+@implementation I
+- (void)randomMethod:(id)info {
+  V<A*> vec([self protocolMethod]);
+}
+
+- (V<A*>)protocolMethod {
+  V<A*> va; return va;
+}
+@end
diff --git a/clang/test/SemaObjCXX/instantiate-stmt.mm b/clang/test/SemaObjCXX/instantiate-stmt.mm
new file mode 100644
index 0000000..ff72858
--- /dev/null
+++ b/clang/test/SemaObjCXX/instantiate-stmt.mm
@@ -0,0 +1,78 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -fobjc-exceptions %s
+
+@interface NSException
+@end
+
+// @throw
+template<typename T>
+void throw_test(T value) {
+  @throw value; // expected-error{{@throw requires an Objective-C object type ('int' invalid)}}
+}
+
+template void throw_test(NSException *);
+template void throw_test(int); // expected-note{{in instantiation of}}
+
+// @synchronized
+template<typename T>
+void synchronized_test(T value) {
+  @synchronized (value) { // expected-error{{@synchronized requires an Objective-C object type ('int' invalid)}}
+    value = 0;
+  }
+}
+
+template void synchronized_test(NSException *);
+template void synchronized_test(int); // expected-note{{in instantiation of}}
+
+// fast enumeration
+@interface NSArray
+- (unsigned int)countByEnumeratingWithState:  (struct __objcFastEnumerationState *)state objects:  (id *)items count:(unsigned int)stackcount;
+@end
+
+@interface NSString
+@end
+
+struct vector {};
+
+template<typename T> void eat(T);
+
+template<typename E, typename T>
+void fast_enumeration_test(T collection) {
+  for (E element in collection) { // expected-error{{selector element type 'int' is not a valid object}} \
+    // expected-error{{collection expression type 'vector' is not a valid object}}
+    eat(element);
+  }
+
+  E element;
+  for (element in collection) // expected-error{{selector element type 'int' is not a valid object}} \
+    // expected-error{{collection expression type 'vector' is not a valid object}}
+    eat(element);
+
+  for (NSString *str in collection) // expected-error{{collection expression type 'vector' is not a valid object}}
+    eat(str);
+
+  NSString *str;
+  for (str in collection) // expected-error{{collection expression type 'vector' is not a valid object}}
+    eat(str);
+}
+
+template void fast_enumeration_test<NSString *>(NSArray*);
+template void fast_enumeration_test<int>(NSArray*); // expected-note{{in instantiation of}}
+template void fast_enumeration_test<NSString *>(vector); // expected-note{{in instantiation of}}
+
+// @try/@catch/@finally
+
+template<typename T, typename U>
+void try_catch_finally_test(U value) {
+  @try {
+    value = 1; // expected-error{{assigning to 'int *' from incompatible type 'int'}}
+  }
+  @catch (T obj) { // expected-error{{@catch parameter is not a pointer to an interface type}}
+    id x = obj;
+  } @finally {
+    value = 0;
+  }
+}
+
+template void try_catch_finally_test<NSString *>(int);
+template void try_catch_finally_test<NSString *>(int*); // expected-note{{in instantiation of}}
+template void try_catch_finally_test<NSString>(int); // expected-note{{in instantiation of function template specialization 'try_catch_finally_test<NSString, int>' requested here}}
diff --git a/clang/test/SemaObjCXX/ivar-construct.mm b/clang/test/SemaObjCXX/ivar-construct.mm
new file mode 100644
index 0000000..a066fca
--- /dev/null
+++ b/clang/test/SemaObjCXX/ivar-construct.mm
@@ -0,0 +1,37 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
+struct Y { 
+  Y(); 
+
+private:
+  ~Y(); // expected-note 3{{declared private here}}
+};
+
+template<typename T>
+struct X : T { }; // expected-error 2{{private destructor}}
+
+struct Z; // expected-note{{forward declaration}}
+
+@interface A {
+  X<Y> x; // expected-note{{implicit default destructor}}
+  Y y; // expected-error{{private destructor}}
+}
+@end
+
+@implementation A // expected-note{{implicit default constructor}}
+@end
+
+@interface B {
+  Z z; // expected-error{{incomplete type}}
+}
+@end
+
+@implementation B
+@end
+
+// <rdar://problem/11284902>
+template<typename T> struct Incomplete; // expected-note{{declared here}}
+
+@interface C {
+  Incomplete<int> a[4][4][4]; // expected-error{{implicit instantiation of undefined template 'Incomplete<int>'}}
+}
+@end
diff --git a/clang/test/SemaObjCXX/ivar-lookup.mm b/clang/test/SemaObjCXX/ivar-lookup.mm
new file mode 100644
index 0000000..fc99c15
--- /dev/null
+++ b/clang/test/SemaObjCXX/ivar-lookup.mm
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
+@interface Ivar
+- (float*)method;
+@end
+
+@interface A {
+  A *Ivar;
+}
+- (int*)method;
+@end
+
+@implementation A
+- (int*)method {
+  int *ip = [Ivar method]; // Okay; calls A's method on the instance variable Ivar.
+                           // Note that Objective-C calls Ivar's method.
+  return 0;
+}
+@end
diff --git a/clang/test/SemaObjCXX/ivar-reference-type.mm b/clang/test/SemaObjCXX/ivar-reference-type.mm
new file mode 100644
index 0000000..2b5df45
--- /dev/null
+++ b/clang/test/SemaObjCXX/ivar-reference-type.mm
@@ -0,0 +1,5 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+@interface A {
+  int &r; // expected-error {{instance variables cannot be of reference type}}
+}
+@end
diff --git a/clang/test/SemaObjCXX/ivar-struct.mm b/clang/test/SemaObjCXX/ivar-struct.mm
new file mode 100644
index 0000000..3f9c7eb
--- /dev/null
+++ b/clang/test/SemaObjCXX/ivar-struct.mm
@@ -0,0 +1,7 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+@interface A {
+  struct X {
+    int x, y;
+  } X;
+}
+@end
diff --git a/clang/test/SemaObjCXX/linkage-spec.mm b/clang/test/SemaObjCXX/linkage-spec.mm
new file mode 100644
index 0000000..584571d
--- /dev/null
+++ b/clang/test/SemaObjCXX/linkage-spec.mm
@@ -0,0 +1,21 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+extern "C" {
+@class Protocol;
+}
+
+// <rdar://problem/7827709>
+extern "C" {
+@class I;
+}
+
+@interface I
+@end
+
+// rdar://10015110
+@protocol VKAnnotation;
+extern "C" {
+
+@protocol VKAnnotation
+  @property (nonatomic, assign) id coordinate;
+@end
+}
diff --git a/clang/test/SemaObjCXX/literals.mm b/clang/test/SemaObjCXX/literals.mm
new file mode 100644
index 0000000..6cdd207
--- /dev/null
+++ b/clang/test/SemaObjCXX/literals.mm
@@ -0,0 +1,187 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++0x -fblocks %s
+
+// rdar://11231426
+typedef signed char BOOL;
+
+void y(BOOL (^foo)());
+
+void x() {
+    y(^{
+        return __objc_yes;
+    });
+}
+
+@protocol NSCopying
+- copy;
+@end
+
+@interface NSObject
+@end
+
+@interface NSNumber : NSObject <NSCopying>
+-copy;
+@end
+
+@interface NSNumber (NSNumberCreation)
++ (NSNumber *)numberWithChar:(char)value;
++ (NSNumber *)numberWithUnsignedChar:(unsigned char)value;
++ (NSNumber *)numberWithShort:(short)value;
++ (NSNumber *)numberWithUnsignedShort:(unsigned short)value;
++ (NSNumber *)numberWithInt:(int)value;
++ (NSNumber *)numberWithUnsignedInt:(unsigned int)value;
++ (NSNumber *)numberWithLong:(long)value;
++ (NSNumber *)numberWithUnsignedLong:(unsigned long)value;
++ (NSNumber *)numberWithLongLong:(long long)value;
++ (NSNumber *)numberWithUnsignedLongLong:(unsigned long long)value;
++ (NSNumber *)numberWithFloat:(float)value;
++ (NSNumber *)numberWithDouble:(double)value;
++ (NSNumber *)numberWithBool:(BOOL)value;
+@end
+
+@interface NSArray : NSObject <NSCopying>
+-copy;
+@end
+
+@interface NSArray (NSArrayCreation)
++ (id)arrayWithObjects:(const id [])objects count:(unsigned long)cnt;
+@end
+
+@interface NSDictionary
++ (id)dictionaryWithObjects:(const id [])objects forKeys:(const id<NSCopying> [])keys count:(unsigned long)cnt;
+@end
+
+template<typename T>
+struct ConvertibleTo {
+  operator T();
+};
+
+template<typename T>
+struct ExplicitlyConvertibleTo {
+  explicit operator T();
+};
+
+template<typename T>
+class PrivateConvertibleTo {
+private:
+  operator T(); // expected-note{{declared private here}}
+};
+
+template<typename T> ConvertibleTo<T> makeConvertible();
+
+struct X {
+  ConvertibleTo<id> x;
+  ConvertibleTo<id> get();
+};
+
+template<typename T> T test_numeric_instantiation() {
+  return @-17.42;
+}
+
+template id test_numeric_instantiation();
+
+void test_convertibility(ConvertibleTo<NSArray*> toArray,
+                         ConvertibleTo<id> toId,
+                         ConvertibleTo<int (^)(int)> toBlock,
+                         ConvertibleTo<int> toInt,
+                         ExplicitlyConvertibleTo<NSArray *> toArrayExplicit) {
+  id array = @[ 
+               toArray,
+               toId,
+               toBlock,
+               toInt // expected-error{{collection element of type 'ConvertibleTo<int>' is not an Objective-C object}}
+              ];
+  id array2 = @[ toArrayExplicit ]; // expected-error{{collection element of type 'ExplicitlyConvertibleTo<NSArray *>' is not an Objective-C object}}
+
+  id array3 = @[ 
+                makeConvertible<id>(),
+                               makeConvertible<id>, // expected-error{{collection element of type 'ConvertibleTo<id> ()' is not an Objective-C object}}
+               ];
+
+  X x;
+  id array4 = @[ x.x ];
+  id array5 = @[ x.get ]; // expected-error{{reference to non-static member function must be called}}
+  id array6 = @[ PrivateConvertibleTo<NSArray*>() ]; // expected-error{{operator NSArray *' is a private member of 'PrivateConvertibleTo<NSArray *>'}}
+}
+
+template<typename T>
+void test_array_literals(T t) {
+  id arr = @[ @17, t ]; // expected-error{{collection element of type 'int' is not an Objective-C object}}
+}
+
+template void test_array_literals(id);
+template void test_array_literals(NSArray*);
+template void test_array_literals(int); // expected-note{{in instantiation of function template specialization 'test_array_literals<int>' requested here}}
+
+template<typename T, typename U>
+void test_dictionary_literals(T t, U u) {
+  NSObject *object;
+  id dict = @{ 
+    @17 : t, // expected-error{{collection element of type 'int' is not an Objective-C object}}
+    u : @42 // expected-error{{collection element of type 'int' is not an Objective-C object}}
+  };
+
+  id dict2 = @{ 
+    object : @"object" // expected-error{{cannot initialize a parameter of type 'const id<NSCopying>' with an rvalue of type 'NSObject *'}}
+  }; 
+}
+
+template void test_dictionary_literals(id, NSArray*);
+template void test_dictionary_literals(NSArray*, id);
+template void test_dictionary_literals(int, id); // expected-note{{in instantiation of function template specialization 'test_dictionary_literals<int, id>' requested here}}
+template void test_dictionary_literals(id, int); // expected-note{{in instantiation of function template specialization 'test_dictionary_literals<id, int>' requested here}}
+
+template<typename ...Args>
+void test_bad_variadic_array_literal(Args ...args) {
+  id arr1 = @[ args ]; // expected-error{{initializer contains unexpanded parameter pack 'args'}}
+}
+
+template<typename ...Args>
+void test_variadic_array_literal(Args ...args) {
+  id arr1 = @[ args... ]; // expected-error{{collection element of type 'int' is not an Objective-C object}}
+}
+template void test_variadic_array_literal(id);
+template void test_variadic_array_literal(id, NSArray*);
+template void test_variadic_array_literal(id, int, NSArray*); // expected-note{{in instantiation of function template specialization 'test_variadic_array_literal<id, int, NSArray *>' requested here}}
+
+template<typename ...Args>
+void test_bad_variadic_dictionary_literal(Args ...args) {
+  id dict = @{ args : @17 }; // expected-error{{initializer contains unexpanded parameter pack 'args'}}
+}
+
+// Test array literal pack expansions. 
+template<typename T, typename U>
+struct pair {
+  T first;
+  U second;
+};
+
+template<typename T, typename ...Ts, typename ... Us>
+void test_variadic_dictionary_expansion(T t, pair<Ts, Us>... key_values) {
+  id dict = @{ 
+    t : key_values.second ..., // expected-error{{collection element of type 'int' is not an Objective-C object}}
+    key_values.first : key_values.second ..., // expected-error{{collection element of type 'float' is not an Objective-C object}}
+    key_values.second : t ...
+  };
+}
+
+template void test_variadic_dictionary_expansion(id, 
+                                                 pair<NSNumber*, id>,
+                                                 pair<id, ConvertibleTo<id>>);
+template void test_variadic_dictionary_expansion(NSNumber *, // expected-note{{in instantiation of function template specialization}}
+                                                 pair<NSNumber*, int>,
+                                                 pair<id, ConvertibleTo<id>>);
+template void test_variadic_dictionary_expansion(NSNumber *, // expected-note{{in instantiation of function template specialization}}
+                                                 pair<NSNumber*, id>,
+                                                 pair<float, ConvertibleTo<id>>);
+
+// Test parsing 
+struct key {
+  static id value;
+};
+
+id key;
+id value;
+
+void test_dictionary_colon() {
+  id dict = @{ key : value };
+}
diff --git a/clang/test/SemaObjCXX/message.mm b/clang/test/SemaObjCXX/message.mm
new file mode 100644
index 0000000..5ac2f40
--- /dev/null
+++ b/clang/test/SemaObjCXX/message.mm
@@ -0,0 +1,127 @@
+// RUN: %clang_cc1 -fsyntax-only -fobjc-fragile-abi -verify -Wno-objc-root-class %s
+@interface I1
+- (int*)method;
+@end
+
+@implementation I1
+- (int*)method {
+  struct x { };
+  [x method]; // expected-error{{receiver type 'x' is not an Objective-C class}}
+  return 0;
+}
+@end
+
+typedef struct { int x; } ivar;
+
+@interface I2 {
+  id ivar;
+}
+- (int*)method;
++ (void)method;
+@end
+
+struct I2_holder {
+  I2_holder();
+
+  I2 *get();
+};
+
+I2 *operator+(I2_holder, int);
+
+@implementation I2
+- (int*)method {
+  [ivar method];
+
+  // Test instance messages that start with a simple-type-specifier.
+  [I2_holder().get() method];
+  [I2_holder().get() + 17 method];
+  return 0;
+}
++ (void)method {
+  [ivar method]; // expected-error{{receiver type 'ivar' is not an Objective-C class}}
+}
+@end
+
+// Class message sends
+@interface I3
++ (int*)method;
+@end
+
+@interface I4 : I3
++ (int*)otherMethod;
+@end
+
+template<typename T>
+struct identity {
+  typedef T type;
+};
+
+@implementation I4
++ (int *)otherMethod {
+  // Test class messages that use non-trivial simple-type-specifiers
+  // or typename-specifiers.
+  if (false) {
+    if (true)
+      return [typename identity<I3>::type method]; // expected-warning{{occurs outside of a template}}
+
+    return [::I3 method];
+  }
+
+  int* ip1 = {[super method]};
+  int* ip2 = {[::I3 method]};
+  int* ip3 = {[typename identity<I3>::type method]}; // expected-warning{{occurs outside of a template}}
+  int* ip4 = {[typename identity<I2_holder>::type().get() method]}; // expected-warning{{occurs outside of a template}}
+  int array[5] = {[3] = 2};
+  return [super method];
+}
+@end
+
+struct String {
+  String(const char *);
+};
+
+struct MutableString : public String { };
+
+// C++-specific parameter types
+@interface I5
+- 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 'const char [6]'}}
+}
+
+// <rdar://problem/8483253>
+@interface A
+
+struct X { };
+
++ (A *)create:(void (*)(void *x, X r, void *data))callback
+	      callbackData:(void *)callback_data;
+
+@end
+
+
+void foo(void)
+{
+  void *fun;
+  void *ptr;
+  X r;
+  A *im = [A create:(void (*)(void *cgl_ctx, X r, void *data)) fun
+             callbackData:ptr];
+}
+
+// <rdar://problem/8807070>
+template<typename T> struct X1; // expected-note{{template is declared here}}
+
+@interface B
++ (X1<int>)blah;
++ (X1<float>&)blarg;
+@end
+
+void f() {
+  [B blah]; // expected-error{{implicit instantiation of undefined template 'X1<int>'}}
+  [B blarg];
+}
diff --git a/clang/test/SemaObjCXX/namespace-lookup.mm b/clang/test/SemaObjCXX/namespace-lookup.mm
new file mode 100644
index 0000000..205b443
--- /dev/null
+++ b/clang/test/SemaObjCXX/namespace-lookup.mm
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// <rdar://problem/9388207>
+@interface A
+@end
+
+@interface A(N)
+@end
+
+@protocol M
+@end
+
+namespace N { }
+namespace M { }
diff --git a/clang/test/SemaObjCXX/null_objc_pointer.mm b/clang/test/SemaObjCXX/null_objc_pointer.mm
new file mode 100644
index 0000000..0da9e50
--- /dev/null
+++ b/clang/test/SemaObjCXX/null_objc_pointer.mm
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -Wnull-arithmetic %s
+#define NULL __null
+
+@interface X
+@end
+
+void f() {
+  bool b;
+  X *d;
+  b = d < NULL || NULL < d || d > NULL || NULL > d;
+  b = d <= NULL || NULL <= d || d >= NULL || NULL >= d;
+  b = d == NULL || NULL == d || d != NULL || NULL != d;
+}
diff --git a/clang/test/SemaObjCXX/nullptr.mm b/clang/test/SemaObjCXX/nullptr.mm
new file mode 100644
index 0000000..2b29b04
--- /dev/null
+++ b/clang/test/SemaObjCXX/nullptr.mm
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -std=c++11 -fblocks -fsyntax-only -verify %s
+
+@interface A
+@end
+
+void comparisons(A *a) {
+  (void)(a == nullptr);
+  (void)(nullptr == a);
+}
+
+void assignment(A *a) {
+  a = nullptr;
+}
+
+int PR10145a = (void(^)())0 == nullptr;
+int PR10145b = nullptr == (void(^)())0;
diff --git a/clang/test/SemaObjCXX/objc-container-subscripting.mm b/clang/test/SemaObjCXX/objc-container-subscripting.mm
new file mode 100644
index 0000000..c835cbe
--- /dev/null
+++ b/clang/test/SemaObjCXX/objc-container-subscripting.mm
@@ -0,0 +1,138 @@
+// RUN: %clang_cc1 -fblocks -triple x86_64-apple-darwin11 -fsyntax-only -std=c++11 -verify %s
+
+@class NSArray;
+
+@interface NSMutableDictionary
+- (id)objectForKeyedSubscript:(id)key;
+- (void)setObject:(id)object forKeyedSubscript:(id)key; // expected-note {{passing argument to parameter 'object' here}}
+@end
+
+template<typename T, typename U, typename O>
+void test_dictionary_subscripts(T base, U key, O obj) {
+  base[key] = obj; // expected-error {{expected method to write array element not found on object of type 'NSMutableDictionary *'}} \
+                   // expected-error {{cannot initialize a parameter of type 'id' with an lvalue of type 'int'}}
+  obj = base[key];  // expected-error {{expected method to read array element not found on object of type 'NSMutableDictionary *'}} \
+                    // expected-error {{assigning to 'int' from incompatible type 'id'}}
+     
+}
+
+template void test_dictionary_subscripts(NSMutableDictionary*, id, NSArray *ns);
+
+template void test_dictionary_subscripts(NSMutableDictionary*, NSArray *ns, id);
+
+template void test_dictionary_subscripts(NSMutableDictionary*, int, id); // expected-note {{in instantiation of function template specialization 'test_dictionary_subscripts<NSMutableDictionary *, int, id>' requested here}}
+
+template void test_dictionary_subscripts(NSMutableDictionary*, id, int); // expected-note {{in instantiation of function template specialization 'test_dictionary_subscripts<NSMutableDictionary *, id, int>' requested here}}
+
+
+@interface NSMutableArray
+- (id)objectAtIndexedSubscript:(int)index;
+- (void)setObject:(id)object atIndexedSubscript:(int)index;
+@end
+
+template<typename T, typename U, typename O>
+void test_array_subscripts(T base, U index, O obj) {
+  base[index] = obj; // expected-error {{indexing expression is invalid because subscript type 'double' is not an integral or objective-C pointer type}}
+  obj = base[index]; // expected-error {{indexing expression is invalid because subscript type 'double' is not an integral or objective-C pointer type}}
+}
+
+template void  test_array_subscripts(NSMutableArray *, int, id);
+template void  test_array_subscripts(NSMutableArray *, short, id);
+enum E { e };
+
+template void  test_array_subscripts(NSMutableArray *, E, id);
+
+template void  test_array_subscripts(NSMutableArray *, double, id); // expected-note {{in instantiation of function template specialization 'test_array_subscripts<NSMutableArray *, double, id>' requested here}}
+
+template<typename T>
+struct ConvertibleTo {
+  operator T();
+};
+
+template<typename T>
+struct ExplicitlyConvertibleTo {
+  explicit operator T();
+};
+
+template<typename T> ConvertibleTo<T> makeConvertible();
+
+struct X {
+  ConvertibleTo<id> x;
+  ConvertibleTo<id> get();
+};
+
+NSMutableArray *test_array_convertibility(ConvertibleTo<NSMutableArray*> toArray,
+                         ConvertibleTo<id> toId,
+                         ConvertibleTo<int (^)(int)> toBlock,
+                         ConvertibleTo<int> toInt,
+                         ExplicitlyConvertibleTo<NSMutableArray *> toArrayExplicit) {
+  id array;
+
+  array[1] = toArray;
+
+  array[4] = array[1];
+ 
+  toArrayExplicit[2] = toId; // expected-error {{type 'ExplicitlyConvertibleTo<NSMutableArray *>' does not provide a subscript operator}}
+
+  return array[toInt];
+  
+}
+
+id test_dict_convertibility(ConvertibleTo<NSMutableDictionary*> toDict,
+                         ConvertibleTo<id> toId,
+                         ConvertibleTo<int (^)(int)> toBlock,
+                         ConvertibleTo<int> toInt,
+                         ExplicitlyConvertibleTo<NSMutableDictionary *> toDictExplicit) {
+
+
+  NSMutableDictionary *Dict;
+  id Id;
+  Dict[toId] = toBlock;
+
+  Dict[toBlock] = toBlock;
+
+  Dict[toBlock] = Dict[toId] = Dict[toBlock];
+
+  Id = toDictExplicit[toId] = Id; // expected-error {{no viable overloaded operator[] for type 'ExplicitlyConvertibleTo<NSMutableDictionary *>'}}
+
+  return Dict[toBlock];
+}
+
+
+template<typename ...Args>
+void test_bad_variadic_array_subscripting(Args ...args) {
+  id arr1;
+  arr1[3] = args; // expected-error {{expression contains unexpanded parameter pack 'args'}}
+}
+
+template<typename ...Args>
+void test_variadic_array_subscripting(Args ...args) {
+  id arr[] = {args[3]...}; // which means: {a[3], b[3], c[3]};
+}
+
+template void test_variadic_array_subscripting(id arg1, NSMutableArray* arg2, id arg3);
+
+@class Key;
+
+template<typename Index, typename ...Args>
+void test_variadic_dictionary_subscripting(Index I, Args ...args) {
+  id arr[] = {args[I]...}; // which means: {a[3], b[3], c[3]};
+}
+
+template void test_variadic_dictionary_subscripting(Key *key, id arg1, NSMutableDictionary* arg2, id arg3);
+
+template<int N>
+id get(NSMutableArray *array) {
+ return array[N]; // array[N] should be a value- and instantiation-dependent ObjCSubscriptRefExpr
+}
+
+struct WeirdIndex {
+   operator int(); // expected-note {{type conversion function declared here}}
+   operator id(); // expected-note {{type conversion function declared here}}
+};
+
+id FUNC(WeirdIndex w) {
+  NSMutableArray *array;
+  return array[w]; // expected-error {{indexing expression is invalid because subscript type 'WeirdIndex' has multiple type conversion functions}}
+}
+
diff --git a/clang/test/SemaObjCXX/objc-decls-inside-namespace.mm b/clang/test/SemaObjCXX/objc-decls-inside-namespace.mm
new file mode 100644
index 0000000..0702071
--- /dev/null
+++ b/clang/test/SemaObjCXX/objc-decls-inside-namespace.mm
@@ -0,0 +1,32 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
+
+namespace C {
+
+@protocol P; //expected-error{{Objective-C declarations may only appear in global scope}}
+
+@class Bar; //expected-error{{Objective-C declarations may only appear in global scope}}
+
+@compatibility_alias Foo Bar; //expected-error{{Objective-C declarations may only appear in global scope}}
+
+@interface A //expected-error{{Objective-C declarations may only appear in global scope}}
+@end
+
+@implementation A //expected-error{{Objective-C declarations may only appear in global scope}}
+@end
+
+@protocol P //expected-error{{Objective-C declarations may only appear in global scope}}
+@end
+
+@interface A(C) //expected-error{{Objective-C declarations may only appear in global scope}}
+@end
+
+@implementation A(C) //expected-error{{Objective-C declarations may only appear in global scope}}
+@end
+
+@interface B @end //expected-error{{Objective-C declarations may only appear in global scope}}
+@implementation B //expected-error{{Objective-C declarations may only appear in global scope}}
++ (void) foo {}
+@end
+
+}
+
diff --git a/clang/test/SemaObjCXX/objc-extern-c.mm b/clang/test/SemaObjCXX/objc-extern-c.mm
new file mode 100644
index 0000000..6bd3761
--- /dev/null
+++ b/clang/test/SemaObjCXX/objc-extern-c.mm
@@ -0,0 +1,30 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+@protocol P // expected-note {{previous}}
+-(void)meth1;
+@end
+
+@interface I // expected-note {{previous}}
+@end
+
+@interface I2
+@end
+@interface I2(C) // expected-note {{previous}}
+@end
+
+extern "C" {
+@protocol P // expected-warning {{duplicate protocol definition of 'P' is ignored}}
+-(void)meth2;
+@end
+
+@interface I // expected-error {{duplicate}}
+@end
+
+@interface I2(C) // expected-warning {{duplicate}}
+@end
+}
+
+void test(id<P> p) {
+  [p meth1];
+  [p meth2]; // expected-warning {{not found}}
+}
diff --git a/clang/test/SemaObjCXX/objc-pointer-conv.mm b/clang/test/SemaObjCXX/objc-pointer-conv.mm
new file mode 100644
index 0000000..611b7bc
--- /dev/null
+++ b/clang/test/SemaObjCXX/objc-pointer-conv.mm
@@ -0,0 +1,48 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
+
+typedef const void * VoidStar;
+
+typedef struct __CFDictionary * CFMDRef;
+
+void RandomFunc(CFMDRef theDict, const void *key, const void *value);
+
+@interface Foo
+- (void)_apply:(void (*)(const void *, const void *, void *))func context:(void *)context;
+- (void)a:(id *)objects b:(id *)keys;
+@end
+
+@implementation Foo
+- (void)_apply:(void (*)(const void *, const void *, void *))func context:(void *)context {
+	id item;
+	id obj;
+    func(item, obj, context);
+}
+
+- (void)a:(id *)objects b:(id *)keys {
+    VoidStar dict;
+	id key;
+    RandomFunc((CFMDRef)dict, key, objects[3]);
+}
+@end
+
+@interface I
+- (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 'const I *' to 'I *' for 1st argument}}
+
+void foo(const I *p, I* sel) {
+  [sel Meth : p];	// expected-error {{cannot initialize a parameter of type 'I *' with an lvalue of type 'const I *'}}
+  Func(p);		// expected-error {{no matching function for call to 'Func'}}
+}
+
+@interface DerivedFromI : I
+@end
+
+void accept_derived(DerivedFromI*);
+
+void test_base_to_derived(I* i) {
+  accept_derived(i); // expected-warning{{incompatible pointer types passing 'I *' to parameter of type 'DerivedFromI *'}}
+  DerivedFromI *di = i; // expected-warning{{incompatible pointer types initializing 'DerivedFromI *' with an expression of type 'I *'}}
+  DerivedFromI *di2 = (DerivedFromI *)i;
+}
diff --git a/clang/test/SemaObjCXX/objc2-merge-gc-attribue-decl.mm b/clang/test/SemaObjCXX/objc2-merge-gc-attribue-decl.mm
new file mode 100644
index 0000000..7be5f17
--- /dev/null
+++ b/clang/test/SemaObjCXX/objc2-merge-gc-attribue-decl.mm
@@ -0,0 +1,51 @@
+// RUN: %clang_cc1 -triple i386-apple-darwin9 -fobjc-gc -fsyntax-only -verify %s
+@interface INTF @end
+
+extern INTF* p2;
+extern __strong INTF* p2;
+
+extern __strong id p1;
+extern id p1;
+
+extern id CFRunLoopGetMain();
+extern __strong id CFRunLoopGetMain();
+
+extern __strong id CFRunLoopGetMain2();
+extern id CFRunLoopGetMain2();
+
+extern INTF* CFRunLoopGetMain3();
+extern __strong INTF* CFRunLoopGetMain3();
+
+extern __strong INTF* CFRunLoopGetMain4();
+extern INTF* CFRunLoopGetMain4();
+
+typedef id ID;
+extern ID CFRunLoopGetMain5();
+extern __strong id CFRunLoopGetMain5();
+
+extern __strong id CFRunLoopGetMain6();
+extern ID CFRunLoopGetMain6();
+
+extern ID CFRunLoopGetMain7();
+extern __strong ID CFRunLoopGetMain7();
+
+extern __strong ID CFRunLoopGetMain8();
+extern ID CFRunLoopGetMain8();
+
+extern __weak id WLoopGetMain(); // expected-note {{previous declaration is here}}
+extern id WLoopGetMain();	// expected-error {{functions that differ only in their return type cannot be overloaded}}
+
+extern id p3;	// expected-note {{previous definition is here}}
+extern __weak id p3;	// expected-error {{redefinition of 'p3' with a different type}}
+
+extern void *p4; // expected-note {{previous definition is here}}
+extern void * __strong p4; // expected-error {{redefinition of 'p4' with a different type}}
+
+extern id p5;
+extern __strong id p5;
+
+extern char* __strong p6; // expected-note {{previous definition is here}}
+extern char* p6; // expected-error {{redefinition of 'p6' with a different type}}
+
+extern __strong char* p7; // expected-note {{previous definition is here}}
+extern char* p7; // expected-error {{redefinition of 'p7' with a different type}}
diff --git a/clang/test/SemaObjCXX/overload-1.mm b/clang/test/SemaObjCXX/overload-1.mm
new file mode 100644
index 0000000..fc17ca2
--- /dev/null
+++ b/clang/test/SemaObjCXX/overload-1.mm
@@ -0,0 +1,25 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+@protocol Proto1 @end
+
+@protocol Proto2 @end
+
+void f(id<Proto1> *) { }		// expected-note {{previous definition is here}}
+
+void f(id<Proto1, Proto2> *) { }	// expected-error {{conflicting types for 'f'}}
+
+void f(Class<Proto1> *) { }		// expected-note {{previous definition is here}}
+
+void f(Class<Proto1, Proto2> *) { }	// expected-error {{conflicting types for 'f'}}
+
+@interface I @end
+
+void f(I<Proto1> *) { }		// expected-note {{previous definition is here}}
+
+void f(I<Proto1, Proto2> *) { }		// expected-error {{conflicting types for 'f'}}
+
+@interface I1 @end
+
+void f1(I<Proto1> *) { }
+
+void f1(I1<Proto1, Proto2> *) { }
diff --git a/clang/test/SemaObjCXX/overload-gc.mm b/clang/test/SemaObjCXX/overload-gc.mm
new file mode 100644
index 0000000..5488ea5
--- /dev/null
+++ b/clang/test/SemaObjCXX/overload-gc.mm
@@ -0,0 +1,24 @@
+// RUN: %clang_cc1 -fsyntax-only -triple i386-apple-darwin9 -fobjc-gc -verify %s
+
+void f0(__weak id *);
+
+void test_f0(id *x) {
+  f0(x);
+}
+
+@interface A
+@end
+
+void f1(__weak id*);
+void test_f1(__weak A** a) {
+  f1(a);
+}
+
+@interface B : A
+@end
+
+void f2(__weak A**);
+void test_f2(__weak B** b) {
+  f2(b);
+}
+
diff --git a/clang/test/SemaObjCXX/overload.mm b/clang/test/SemaObjCXX/overload.mm
new file mode 100644
index 0000000..6f24c59
--- /dev/null
+++ b/clang/test/SemaObjCXX/overload.mm
@@ -0,0 +1,179 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
+@interface Foo
+@end
+
+@implementation Foo
+
+void func(id);
+
++ zone {
+ func(self);
+ return self;
+}
+@end
+
+@protocol P0
+@end
+
+@protocol P1
+@end
+
+@interface A <P0>
+@end
+
+@interface B : A
+@end
+
+@interface C <P1>
+@end
+
+int& f(A*); // expected-note {{candidate}}
+float& f(B*); // expected-note {{candidate}}
+void g(A*);
+
+int& h(A*);
+float& h(id);
+
+void test0(A* a, B* b, id val) {
+  int& i1 = f(a);
+  float& f1 = f(b);
+
+  // GCC succeeds here, which is clearly ridiculous.
+  float& f2 = f(val); // expected-error {{ambiguous}}
+
+  g(a);
+  g(b);
+  g(val);
+  int& i2 = h(a);
+  float& f3 = h(val);
+
+  int& i3 = h(b);
+}
+
+void test1(A* a) {
+  B* b = a; // expected-warning{{incompatible pointer types initializing 'B *' with an expression of type 'A *'}}
+  B *c; c = a; // expected-warning{{incompatible pointer types assigning to 'B *' from 'A *'}}
+}
+
+void test2(A** ap) {
+  B** bp = ap; // expected-warning{{incompatible pointer types initializing 'B **' with an expression of type 'A **'}}
+  bp = ap; // expected-warning{{incompatible pointer types assigning to 'B **' from 'A **'}}
+}
+
+// FIXME: we should either allow overloading here or give a better diagnostic
+int& cv(A*); // expected-note {{previous declaration}} expected-note 2 {{not viable}}
+float& cv(const A*); // expected-error {{cannot be overloaded}}
+
+int& cv2(void*);
+float& cv2(const void*);
+
+void cv_test(A* a, B* b, const A* ac, const B* bc) {
+  int &i1 = cv(a);
+  int &i2 = cv(b);
+  float &f1 = cv(ac); // expected-error {{no matching function}}
+  float &f2 = cv(bc); // expected-error {{no matching function}}
+  int& i3 = cv2(a);
+  float& f3 = cv2(ac);
+}
+
+// We agree with GCC that these can't be overloaded.
+int& qualid(id<P0>); // expected-note {{previous declaration}} expected-note {{not viable}}
+float& qualid(id<P1>); // expected-error {{cannot be overloaded}}
+
+void qualid_test(A *a, B *b, C *c) {
+  int& i1 = qualid(a);
+  int& i2 = qualid(b);
+
+  // This doesn't work only because the overload was rejected above.
+  float& f1 = qualid(c); // expected-error {{no matching function}}
+
+  id<P0> p1 = 0;
+  p1 = 0;
+}
+
+
+@class NSException;
+typedef struct {
+    void (*throw_exc)(id);
+}
+objc_exception_functions_t;
+
+void (*_NSExceptionRaiser(void))(NSException *) {
+    objc_exception_functions_t exc_funcs;
+    return exc_funcs.throw_exc; // expected-warning{{incompatible pointer types returning 'void (*)(id)' from a function with result type 'void (*)(NSException *)'}}
+}
+
+namespace test5 {
+  void foo(bool);
+  void foo(void *);
+
+  void test(id p) {
+    foo(p);
+  }
+}
+
+// rdar://problem/8592139
+namespace test6 {
+  void foo(id); // expected-note{{candidate function}}
+  void foo(A*) __attribute__((unavailable)); // expected-note {{explicitly made unavailable}}
+
+  void test(B *b) {
+    foo(b); // expected-error {{call to unavailable function 'foo'}}
+  }
+}
+
+namespace rdar8714395 {
+  int &f(const void*);
+  float &f(const Foo*);
+
+  int &f2(const void*);
+  float &f2(Foo const* const *);
+
+  int &f3(const void*);
+  float &f3(Foo const**);
+
+  void g(Foo *p) {
+    float &fr = f(p);
+    float &fr2 = f2(&p);
+    int &ir = f3(&p);
+  }
+
+  
+}
+
+namespace rdar8734046 {
+  void f1(id);
+  void f2(id<P0>);
+  void g(const A *a) {
+    f1(a);
+    f2(a);
+  }
+}
+
+namespace PR9735 {
+  int &f3(const A*);
+  float &f3(const void*);
+
+  void test_f(B* b, const B* bc) {
+    int &ir1 = f3(b);
+    int &ir2 = f3(bc);
+  }
+}
+
+@interface D : B
+@end
+
+namespace rdar9327203 {
+  int &f(void* const&, int);
+  float &f(void* const&, long);
+  
+  void g(id x) { 
+    int &fr = (f)(x, 0); 
+  }
+}
+
+namespace class_id {
+  // it's okay to overload Class with id.
+  void f(Class) { }
+  void f(id) { }
+}
diff --git a/clang/test/SemaObjCXX/parameters.mm b/clang/test/SemaObjCXX/parameters.mm
new file mode 100644
index 0000000..1a7869d
--- /dev/null
+++ b/clang/test/SemaObjCXX/parameters.mm
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -verify %s
+
+@interface A
+@end
+
+template<typename T>
+struct X0 {
+  void f(T); // expected-error{{interface type 'A' cannot be passed by value}}
+};
+
+X0<A> x0a; // expected-note{{instantiation}}
+
+
+struct test2 { virtual void foo() = 0; }; // expected-note {{unimplemented}}
+@interface Test2
+- (void) foo: (test2) foo; // expected-error {{parameter type 'test2' is an abstract class}}
+@end
diff --git a/clang/test/SemaObjCXX/pointer-to-objc-pointer-conv.mm b/clang/test/SemaObjCXX/pointer-to-objc-pointer-conv.mm
new file mode 100644
index 0000000..d0f8404
--- /dev/null
+++ b/clang/test/SemaObjCXX/pointer-to-objc-pointer-conv.mm
@@ -0,0 +1,49 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+@interface G
+@end
+
+@interface F
+- (void)bar:(id *)objects;
+- (void)foo:(G**)objects;
+@end
+
+
+void a() {
+	F *b;
+	G **keys;
+	[b bar:keys];
+
+	id *PID;
+	[b foo:PID];
+
+}
+
+
+// pr7936
+@interface I1 @end
+
+class Wrapper {
+public:
+  operator id() const { return (id)_value; }
+  operator Class() const { return (Class)_value; }
+  operator I1*() const { return (I1*)_value; }
+
+  bool Compare(id obj) { return *this == obj; }
+  bool CompareClass(Class obj) { return *this == obj; }
+  bool CompareI1(I1* obj) { return *this == obj; }
+
+  Wrapper &operator*();
+  Wrapper &operator[](int);
+  Wrapper& operator->*(int);
+
+private:
+  long _value;
+};
+
+void f() {
+  Wrapper w;
+  w[0];
+  *w;
+  w->*(0);
+}
diff --git a/clang/test/SemaObjCXX/propert-dot-error.mm b/clang/test/SemaObjCXX/propert-dot-error.mm
new file mode 100644
index 0000000..2237411
--- /dev/null
+++ b/clang/test/SemaObjCXX/propert-dot-error.mm
@@ -0,0 +1,69 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
+// rdar: // 8379892
+
+struct X {
+  X();
+  X(const X&);
+  ~X();
+
+  static int staticData;
+  int data;
+  void method();
+};
+
+@interface A {
+  X xval;
+}
+
+- (X)x;
+- (void)setx:(X)x;
+@end
+
+void f(A* a) {
+  a.x = X(); // expected-error {{no setter method 'setX:' for assignment to property}}
+}
+
+struct Y : X { };
+
+@interface B {
+@private
+  Y *y;
+}
+- (Y)value;
+- (void)setValue : (Y) arg;
+@property Y value;
+@end
+
+void g(B *b) {
+  b.value.data = 17; // expected-error {{not assignable}}
+  b.value.staticData = 17;
+  b.value.method();
+}
+
+@interface C
+@end
+
+@implementation C
+- (void)method:(B *)b {
+  // <rdar://problem/8985943>
+  b.operator+ = 17; // expected-error{{'operator+' is not a valid property name (accessing an object of type 'B *')}}
+  b->operator+ = 17; // expected-error{{'B' does not have a member named 'operator+'}}
+}
+@end
+
+// PR9759
+class Forward;
+@interface D {
+@public
+  int ivar;
+}
+
+@property int property;
+@end
+
+void testD(D *d) {
+  d.Forward::property = 17; // expected-error{{property access cannot be qualified with 'Forward::'}}
+  d->Forward::ivar = 12; // expected-error{{ivar access cannot be qualified with 'Forward::'}}
+  d.D::property = 17; // expected-error{{expected a class or namespace}}
+  d->D::ivar = 12; // expected-error{{expected a class or namespace}}
+}
diff --git a/clang/test/SemaObjCXX/properties.mm b/clang/test/SemaObjCXX/properties.mm
new file mode 100644
index 0000000..3c6b138
--- /dev/null
+++ b/clang/test/SemaObjCXX/properties.mm
@@ -0,0 +1,108 @@
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -Wno-objc-root-class %s
+
+struct X { 
+  void f() const;
+  ~X();
+};
+
+@interface A {
+  X x_;
+}
+
+- (const X&)x;
+- (void)setx:(const X&)other;
+@end
+
+@implementation A
+
+- (const X&)x { return x_; }
+- (void)setx:(const X&)other { x_ = other; }
+- (void)method {
+  self.x.f();
+}
+@end
+
+// rdar://problem/10444030
+@interface Test2
+- (void) setY: (int) y;
+- (int) z;
+@end
+void test2(Test2 *a) {
+  auto y = a.y; // expected-error {{expected getter method not found on object of type 'Test2 *'}}
+  auto z = a.z;
+}
+
+// rdar://problem/10672108
+@interface Test3
+- (int) length;
+@end
+void test3(Test3 *t) {
+  char vla[t.length] = {}; // expected-error {{variable-sized object may not be initialized}}
+  char *heaparray = new char[t.length];
+}
+
+// <rdar://problem/10672501>
+namespace std {
+  template<typename T> void count();
+}
+
+@interface Test4
+- (X&) prop;
+@end
+
+void test4(Test4 *t) {
+  (void)const_cast<const X&>(t.prop);
+  (void)dynamic_cast<X&>(t.prop);
+  (void)reinterpret_cast<int&>(t.prop);
+}
+
+@interface Test5 {
+@public
+  int count;
+}
+@property int count;
+@end
+
+void test5(Test5* t5) {
+  if (t5.count < 2) { }
+  if (t5->count < 2) { }
+}
+
+
+@interface Test6
++ (Class)class;
+- (Class)class;
+@end
+
+void test6(Test6 *t6) {
+  Class x = t6.class;
+  Class x2 = Test6.class;
+}
+
+template<typename T>
+void test6_template(T *t6) {
+  Class x = t6.class;
+}
+
+template void test6_template(Test6*);
+
+// rdar://problem/10965735
+struct Test7PointerMaker {
+  operator char *() const;
+};
+@interface Test7
+- (char*) implicit_property;
+- (char) bad_implicit_property;
+- (Test7PointerMaker) implicit_struct_property;
+@property int *explicit_property;
+@property int bad_explicit_property;
+@property Test7PointerMaker explicit_struct_property;
+@end
+void test7(Test7 *ptr) {
+  delete ptr.implicit_property;
+  delete ptr.bad_implicit_property; // expected-error {{cannot delete expression of type 'char'}}
+  delete ptr.explicit_property;
+  delete ptr.bad_explicit_property; // expected-error {{cannot delete expression of type 'int'}}
+  delete ptr.implicit_struct_property;
+  delete ptr.explicit_struct_property;
+}
diff --git a/clang/test/SemaObjCXX/property-reference.mm b/clang/test/SemaObjCXX/property-reference.mm
new file mode 100644
index 0000000..b86ae5e
--- /dev/null
+++ b/clang/test/SemaObjCXX/property-reference.mm
@@ -0,0 +1,59 @@
+// RUN: %clang_cc1 -x objective-c++ -triple x86_64-apple-darwin10 -fsyntax-only -verify -Wno-objc-root-class %s
+// rdar://9070460
+
+class TCPPObject
+{
+public:
+	TCPPObject(const TCPPObject& inObj);
+	TCPPObject();
+	~TCPPObject();
+	
+	TCPPObject& operator=(const TCPPObject& inObj)const ; // expected-note {{'operator=' declared here}}
+
+	void* Data();
+	
+private:
+	void* fData;
+};
+
+
+typedef const TCPPObject& CREF_TCPPObject;
+
+@interface TNSObject
+@property (assign, readwrite, nonatomic) CREF_TCPPObject cppObjectNonAtomic;
+@property (assign, readwrite) CREF_TCPPObject cppObjectAtomic;
+@property (assign, readwrite, nonatomic) const TCPPObject& cppObjectDynamic;
+@end
+
+
+@implementation TNSObject
+
+@synthesize cppObjectNonAtomic;
+@synthesize cppObjectAtomic; // expected-error{{atomic property of reference type 'CREF_TCPPObject' (aka 'const TCPPObject &') cannot have non-trivial assignment operator}}
+@dynamic cppObjectDynamic;
+
+- (const TCPPObject&) cppObjectNonAtomic
+{
+	return cppObjectNonAtomic;
+}
+
+- (void) setCppObjectNonAtomic: (const TCPPObject&)cppObject
+{
+	cppObjectNonAtomic = cppObject;
+}
+@end
+
+
+// <rdar://problem/11052352>
+@interface NSObject
++ alloc;
+- init;
+- class;
+@end
+
+template<typename T> void f() {
+  NSObject *o = [NSObject.alloc init];
+  [o class];
+}
+
+template void f<int>();
diff --git a/clang/test/SemaObjCXX/property-synthesis-error.mm b/clang/test/SemaObjCXX/property-synthesis-error.mm
new file mode 100644
index 0000000..4b726d8
--- /dev/null
+++ b/clang/test/SemaObjCXX/property-synthesis-error.mm
@@ -0,0 +1,74 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
+// rdar: //8550657
+
+@interface NSArray @end
+
+@interface NSMutableArray : NSArray @end
+
+@interface MyClass
+{
+  NSMutableArray * _array;
+}
+
+@property (readonly) NSMutableArray * array;
+
+@end
+
+@interface MyClass ()
+
+@property (readwrite) NSMutableArray * array;
+
+@end
+
+@implementation MyClass
+
+@synthesize array=_array;
+
+@end
+
+int main(void)
+{
+  return 0;
+}
+
+// rdar://6137845
+class TCPPObject
+{
+public:
+ TCPPObject(const TCPPObject& inObj);
+ TCPPObject();
+ ~TCPPObject();
+ TCPPObject& operator=(const TCPPObject& inObj); // expected-note {{'operator=' declared here}}
+private:
+ void* fData;
+};
+
+class Trivial
+{
+public:
+ Trivial(const Trivial& inObj);
+ Trivial();
+ ~Trivial();
+private:
+ void* fData;
+};
+
+@interface MyDocument
+{
+@private
+ TCPPObject _cppObject;
+ TCPPObject _ncppObject;
+ Trivial _tcppObject;
+}
+@property (assign, readwrite) const TCPPObject& cppObject;
+@property (assign, readwrite, nonatomic) const TCPPObject& ncppObject;
+@property (assign, readwrite) const Trivial& tcppObject;
+@end
+
+@implementation MyDocument
+
+@synthesize cppObject = _cppObject; // expected-error {{atomic property of reference type 'const TCPPObject &' cannot have non-trivial assignment operator}}
+@synthesize ncppObject = _ncppObject;
+
+@synthesize tcppObject = _tcppObject;
+@end
diff --git a/clang/test/SemaObjCXX/property-type-mismatch.mm b/clang/test/SemaObjCXX/property-type-mismatch.mm
new file mode 100644
index 0000000..059793c
--- /dev/null
+++ b/clang/test/SemaObjCXX/property-type-mismatch.mm
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// rdar://9740328
+
+@protocol P1;
+
+@interface NSObject
+@end
+
+@interface A : NSObject
+@property (assign) NSObject<P1> *prop;
+@end
+
+@protocol P2 <P1>
+@end
+
+@interface B : A
+@property (assign) NSObject<P2> *prop;
+@end
+
diff --git a/clang/test/SemaObjCXX/protocol-lookup.mm b/clang/test/SemaObjCXX/protocol-lookup.mm
new file mode 100644
index 0000000..bd8444c
--- /dev/null
+++ b/clang/test/SemaObjCXX/protocol-lookup.mm
@@ -0,0 +1,56 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+@protocol NSObject
+- retain;
+- release;
+@end
+
+@interface NSObject
+- init;
+- dealloc;
+@end
+
+@protocol Foo <NSObject>
+@end
+
+@protocol Bar <Foo>
+@end
+
+@interface Baz : NSObject {
+	id <Foo> _foo;
+	id <Bar> _bar;
+}
+- (id)initWithFoo:(id <Foo>)foo bar:(id <Bar>)bar;
+@end
+
+@implementation Baz
+
+- (id)init
+{
+	return [self initWithFoo:0 bar:0];
+}
+
+- (id)initWithFoo:(id <Foo>)foo bar:(id <Bar>)bar
+{
+	self = [super init];
+	if (self != 0) {
+		_foo = [foo retain];
+		_bar = [bar retain];
+	}
+	return self;
+}
+
+- dealloc
+{
+	[_foo release];
+	[_bar release];
+	[super dealloc];
+	return 0;
+}
+
+@end
+
+void rdar8575095(id a) {
+  [id<NSObject>(a) retain];
+  id<NSObject> x(id<NSObject>(0));
+  id<NSObject> x2(id<NSObject>(y)); // expected-warning{{parentheses were disambiguated as a function declarator}}
+}
diff --git a/clang/test/SemaObjCXX/references.mm b/clang/test/SemaObjCXX/references.mm
new file mode 100644
index 0000000..3a52200
--- /dev/null
+++ b/clang/test/SemaObjCXX/references.mm
@@ -0,0 +1,62 @@
+// RUN: %clang_cc1 -verify -emit-llvm -o - %s
+
+// Test reference binding.
+
+typedef struct {
+  int f0;
+  int f1;
+} T;
+
+@interface A
+@property (assign) T p0;
+@property (assign) T& p1; 
+@end
+
+int f0(const T& t) {
+  return t.f0;
+}
+
+int f1(A *a) {
+  return f0(a.p0);
+}
+
+int f2(A *a) {
+  return f0(a.p1);	
+}
+
+// PR7740
+@class NSString;
+
+void f3(id);
+void f4(NSString &tmpstr) {
+  f3(&tmpstr);
+}
+
+// PR7741
+@protocol P1 @end
+@protocol P2 @end
+@protocol P3 @end
+@interface foo<P1> {} @end
+@interface bar : foo <P1, P2, P3> {} @end
+typedef bar baz;
+
+struct ToBar {
+  operator bar&() const;
+};
+
+void f5(foo&);
+void f5b(foo<P1>&);
+void f5c(foo<P2>&);
+void f5d(foo<P3>&);
+void f6(baz* x) { 
+  f5(*x); 
+  f5b(*x); 
+  f5c(*x); 
+  f5d(*x);
+  (void)((foo&)*x);
+  f5(ToBar());
+  f5b(ToBar());
+  f5c(ToBar());
+  f5d(ToBar());
+  (void)((foo&)ToBar());
+}
diff --git a/clang/test/SemaObjCXX/reinterpret-cast-objc-pointertype.mm b/clang/test/SemaObjCXX/reinterpret-cast-objc-pointertype.mm
new file mode 100644
index 0000000..fcabade
--- /dev/null
+++ b/clang/test/SemaObjCXX/reinterpret-cast-objc-pointertype.mm
@@ -0,0 +1,23 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+@interface NSString @end
+
+typedef const struct __CFString * CFStringRef;
+const NSString* fRef;
+
+CFStringRef func() {
+  return reinterpret_cast<CFStringRef>(fRef);
+}
+
+CFStringRef fRef1;
+
+const NSString* func1() {
+  return reinterpret_cast<const NSString*>(fRef1);
+}
+
+@interface I @end
+const I *fRef2;
+
+const NSString* func2() {
+  return reinterpret_cast<const NSString*>(fRef2);
+}
diff --git a/clang/test/SemaObjCXX/related-result-type-inference.mm b/clang/test/SemaObjCXX/related-result-type-inference.mm
new file mode 100644
index 0000000..675e6ac
--- /dev/null
+++ b/clang/test/SemaObjCXX/related-result-type-inference.mm
@@ -0,0 +1,71 @@
+// RUN: %clang_cc1 -verify %s
+
+@interface Unrelated
+@end
+
+@interface NSObject
++ (id)new;
++ (id)alloc;
+- (NSObject *)init;
+
+- (id)retain;  // expected-note 2{{instance method 'retain' is assumed to return an instance of its receiver type ('NSArray *')}}
+- autorelease;
+
+- (id)self;
+
+- (id)copy;
+- (id)mutableCopy;
+
+// Do not infer when instance/class mismatches
+- (id)newNotInferred;
+- (id)alloc;
++ (id)initWithBlarg;
++ (id)self;
+
+// Do not infer when the return types mismatch.
+- (Unrelated *)initAsUnrelated;
+@end
+
+@interface NSString : NSObject
+- (id)init;
+- (id)initWithCString:(const char*)string;
+@end
+
+@interface NSArray : NSObject
+- (unsigned)count;
+@end
+
+@interface NSBlah 
+@end
+
+@interface NSMutableArray : NSArray
+@end
+
+@interface NSBlah ()
++ (Unrelated *)newUnrelated;
+@end
+
+void test_inference() {
+  // Inference based on method family
+  __typeof__(([[NSString alloc] init])) *str = (NSString**)0;
+  __typeof__(([[[[NSString new] self] retain] autorelease])) *str2 = (NSString **)0;
+  __typeof__(([[NSString alloc] initWithCString:"blah"])) *str3 = (NSString**)0;
+
+  // Not inferred
+  __typeof__(([[NSString new] copy])) *id1 = (id*)0;
+
+  // Not inferred due to instance/class mismatches
+  __typeof__(([[NSString new] newNotInferred])) *id2 = (id*)0;
+  __typeof__(([[NSString new] alloc])) *id3 = (id*)0;
+  __typeof__(([NSString self])) *id4 = (id*)0;
+  __typeof__(([NSString initWithBlarg])) *id5 = (id*)0;
+
+  // Not inferred due to return type mismatch
+  __typeof__(([[NSString alloc] initAsUnrelated])) *unrelated = (Unrelated**)0;
+  __typeof__(([NSBlah newUnrelated])) *unrelated2 = (Unrelated**)0;  
+
+  NSArray *arr = [[NSMutableArray alloc] init];
+  NSMutableArray *marr = [arr retain]; // expected-warning{{incompatible pointer types initializing 'NSMutableArray *' with an expression of type 'NSArray *'}}
+  marr = [arr retain]; // expected-warning{{incompatible pointer types assigning to 'NSMutableArray *' from 'NSArray *'}}
+  arr = [marr retain];
+}
diff --git a/clang/test/SemaObjCXX/reserved-keyword-methods.mm b/clang/test/SemaObjCXX/reserved-keyword-methods.mm
new file mode 100644
index 0000000..1302128
--- /dev/null
+++ b/clang/test/SemaObjCXX/reserved-keyword-methods.mm
@@ -0,0 +1,42 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+#define FOR_EACH_KEYWORD(macro) \
+macro(asm) \
+macro(bool) \
+macro(catch) \
+macro(class) \
+macro(const_cast) \
+macro(delete) \
+macro(dynamic_cast) \
+macro(explicit) \
+macro(export) \
+macro(false) \
+macro(friend) \
+macro(mutable) \
+macro(namespace) \
+macro(new) \
+macro(operator) \
+macro(private) \
+macro(protected) \
+macro(public) \
+macro(reinterpret_cast) \
+macro(static_cast) \
+macro(template) \
+macro(this) \
+macro(throw) \
+macro(true) \
+macro(try) \
+macro(typename) \
+macro(typeid) \
+macro(using) \
+macro(virtual) \
+macro(wchar_t)
+
+
+#define DECLARE_METHOD(name) - (void)name;
+#define DECLARE_PROPERTY_WITH_GETTER(name) @property (getter=name) int prop_##name;
+@interface A 
+//FOR_EACH_KEYWORD(DECLARE_METHOD)
+FOR_EACH_KEYWORD(DECLARE_PROPERTY_WITH_GETTER)
+@end
+
diff --git a/clang/test/SemaObjCXX/standard-conversion-to-bool.mm b/clang/test/SemaObjCXX/standard-conversion-to-bool.mm
new file mode 100644
index 0000000..2e69848
--- /dev/null
+++ b/clang/test/SemaObjCXX/standard-conversion-to-bool.mm
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+@class NSString;
+id a;
+NSString *b;
+
+void f() {
+  bool b1 = a;
+  bool b2 = b;
+}
+
+
diff --git a/clang/test/SemaObjCXX/static-cast.mm b/clang/test/SemaObjCXX/static-cast.mm
new file mode 100644
index 0000000..e282702
--- /dev/null
+++ b/clang/test/SemaObjCXX/static-cast.mm
@@ -0,0 +1,29 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+@protocol NSTextViewDelegate;
+
+@interface NSResponder @end
+
+class AutoreleaseObject
+{
+public:
+ AutoreleaseObject();
+ ~AutoreleaseObject();
+
+
+ AutoreleaseObject& operator=(NSResponder* inValue);
+ AutoreleaseObject& operator=(const AutoreleaseObject& inValue);
+
+ AutoreleaseObject(const AutoreleaseObject& inValue);
+
+ operator NSResponder*() const;
+};
+
+
+void InvokeSaveFocus()
+{
+ AutoreleaseObject mResolvedFirstResponder;
+ id<NSTextViewDelegate> Mydelegate;
+ mResolvedFirstResponder = static_cast<NSResponder*>(Mydelegate);
+}
+
diff --git a/clang/test/SemaObjCXX/unknown-anytype.mm b/clang/test/SemaObjCXX/unknown-anytype.mm
new file mode 100644
index 0000000..b28b135
--- /dev/null
+++ b/clang/test/SemaObjCXX/unknown-anytype.mm
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 -fdebugger-support -funknown-anytype -fsyntax-only -verify %s
+
+// rdar://problem/9416370
+namespace test0 {
+  void test(id x) {
+    if ([x foo]) {} // expected-error {{no known method '-foo'; cast the message send to the method's return type}}
+    [x foo]; // expected-error {{no known method '-foo'; cast the message send to the method's return type}}
+  }
+}
diff --git a/clang/test/SemaObjCXX/vararg-non-pod.mm b/clang/test/SemaObjCXX/vararg-non-pod.mm
new file mode 100644
index 0000000..5a6281d
--- /dev/null
+++ b/clang/test/SemaObjCXX/vararg-non-pod.mm
@@ -0,0 +1,32 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s -Wno-error=non-pod-varargs
+
+extern char version[];
+
+@protocol P;
+
+class C {
+public:
+  C(int);
+};
+
+@interface D 
+- (void)g:(int)a, ...;
+@end
+
+void t1(D *d)
+{
+  C c(10);
+
+  [d g:10, c]; // expected-warning{{cannot pass object of non-POD type 'C' through variadic method; call will abort at runtime}}
+  [d g:10, version];
+}
+
+void t2(D *d, id p)
+{
+  [d g:10, p];
+}
+
+void t3(D *d, id<P> p)
+{
+  [d g:10, p];
+}
diff --git a/clang/test/SemaObjCXX/vla.mm b/clang/test/SemaObjCXX/vla.mm
new file mode 100644
index 0000000..d6da1c0
--- /dev/null
+++ b/clang/test/SemaObjCXX/vla.mm
@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+@interface Data
+- (unsigned)length;
+- (void)getData:(void*)buffer;
+@end
+
+void test(Data *d) {
+  char buffer[[d length]];
+  [d getData:buffer];
+}
+
diff --git a/clang/test/SemaObjCXX/void_to_obj.mm b/clang/test/SemaObjCXX/void_to_obj.mm
new file mode 100644
index 0000000..97151fd
--- /dev/null
+++ b/clang/test/SemaObjCXX/void_to_obj.mm
@@ -0,0 +1,26 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
+
+// <rdar://problem/6463729>
+@class XX;
+
+void func() {
+  XX *obj;
+  void *vv;
+
+  obj = vv; // expected-error{{assigning to 'XX *' from incompatible type 'void *'}}
+}
+
+// <rdar://problem/7952457>
+@interface I
+{
+  void* delegate;
+}
+- (I*) Meth;
+- (I*) Meth1;
+@end
+
+@implementation I 
+- (I*) Meth { return static_cast<I*>(delegate); }
+- (I*) Meth1 { return reinterpret_cast<I*>(delegate); }
+@end
+
diff --git a/clang/test/SemaObjCXX/warn-strict-selector-match.mm b/clang/test/SemaObjCXX/warn-strict-selector-match.mm
new file mode 100644
index 0000000..330b10b
--- /dev/null
+++ b/clang/test/SemaObjCXX/warn-strict-selector-match.mm
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1  -Wstrict-selector-match -fsyntax-only -verify %s
+
+@interface Base
+- (id) meth1: (Base *)arg1; 	// expected-note {{using}}
+- (id) window;	// expected-note {{using}}
+@end
+
+@interface Derived: Base
+- (id) meth1: (Derived *)arg1;	// expected-note {{also found}}
+- (Base *) window;	// expected-note {{also found}}
+@end
+
+void foo(void) {
+  id r;
+
+  [r meth1:r];	// expected-warning {{multiple methods named 'meth1:' found}}
+  [r window]; 	// expected-warning {{multiple methods named 'window' found}}
+}