+// RUN: %clang_cc1 -triple x86_64-apple-darwin11 -fsyntax-only -fobjc-arc -fblocks -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s

+ // CHECK: fix-it:"{{.*}}":{35:20-35:35}:"__bridge_retained"

+CFTypeRef fixits() {

+ // expected-note{{use __bridge to convert directly (no change in ownership)}} expected-note{{use CFBridgingRelease call to transfer ownership of a +1 'CFTypeRef' (aka 'const void *') into ARC}}

+ // CHECK: fix-it:"{{.*}}":{40:17-40:17}:"CFBridgingRelease("

+ // CHECK: fix-it:"{{.*}}":{40:36-40:36}:")"

+

+ // CHECK: fix-it:"{{.*}}":{45:30-45:30}:"CFBridgingRetain("

+ // CHECK: fix-it:"{{.*}}":{45:47-45:47}:")"

+

+ return (obj1); // expected-error{{implicit conversion of Objective-C pointer type 'id' to C pointer type 'CFTypeRef' (aka 'const void *') requires a bridged cast}} \

+ // expected-note{{use __bridge to convert directly (no change in ownership)}} \

+ // expected-note{{use CFBridgingRetain call to make an ARC object available as a +1 'CFTypeRef' (aka 'const void *')}}

+ // CHECK: fix-it:"{{.*}}":{51:10-51:10}:"(__bridge CFTypeRef)"

+ // CHECK: fix-it:"{{.*}}":{51:10-51:10}:"CFBridgingRetain"

+}

+

+CFTypeRef fixitsWithSpace(id obj) {

+ return(obj); // expected-error{{implicit conversion of Objective-C pointer type 'id' to C pointer type 'CFTypeRef' (aka 'const void *') requires a bridged cast}} \

+ // expected-note{{use __bridge to convert directly (no change in ownership)}} \

+ // expected-note{{use CFBridgingRetain call to make an ARC object available as a +1 'CFTypeRef' (aka 'const void *')}}

+ // CHECK: fix-it:"{{.*}}":{59:9-59:9}:"(__bridge CFTypeRef)"

+ // CHECK: fix-it:"{{.*}}":{59:9-59:9}:" CFBridgingRetain"

+#pragma clang arc_cf_code_audited begin

+#pragma clang arc_cf_code_audited end

+ x = (id) CFCreateString0(); // expected-error {{requires a bridged cast}} expected-note {{CFBridgingRelease call to transfer}}

+ x = (id) CFCreateString1(); // expected-error {{requires a bridged cast}} expected-note {{CFBridgingRelease call to transfer}}

+ x = (id) CFMakeString3(); // expected-error {{requires a bridged cast}} expected-note {{CFBridgingRelease call to transfer}}

+ x = (id) CFCreateString3(); // expected-error {{requires a bridged cast}} expected-note {{CFBridgingRelease call to transfer}}

+// RUN: %clang_cc1 -triple x86_64-apple-darwin11 -fsyntax-only -fobjc-arc -verify %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin11 -fsyntax-only -fobjc-arc -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s

+// rdar://11913153

+

+typedef const struct __CFString * CFStringRef;

+typedef struct __CFString * CFMutableStringRef;

+typedef signed long CFIndex;

+typedef const struct __CFAllocator * CFAllocatorRef;

+

+extern const CFStringRef kCFBundleNameKey;

+

+@protocol NSCopying @end

+

+@interface NSDictionary

+- (id)objectForKeyedSubscript:(id<NSCopying>)key;

+@end

+

+#pragma clang arc_cf_code_audited begin

+extern

+CFMutableStringRef CFStringCreateMutable(CFAllocatorRef alloc, CFIndex maxLength);

+#pragma clang arc_cf_code_audited end

+

+typedef const void * CFTypeRef;

+

+id CFBridgingRelease(CFTypeRef __attribute__((cf_consumed)) X);

+

+@interface NSMutableString @end

+

+NSMutableString *test() {

+ NSDictionary *infoDictionary;

+ infoDictionary[kCFBundleNameKey] = 0; // expected-error {{indexing expression is invalid because subscript type 'CFStringRef' (aka 'const struct __CFString *') is not an integral or Objective-C pointer type}} \

+ // expected-error {{implicit conversion of C pointer type 'CFStringRef' (aka 'const struct __CFString *') to Objective-C pointer type '__strong id<NSCopying>' requires a bridged cast}} \

+ // expected-note {{use __bridge to convert directly (no change in ownership)}} \

+ // expected-note {{use CFBridgingRelease call to transfer ownership of a +1 'CFStringRef' (aka 'const struct __CFString *') into ARC}}

+ return infoDictionary[CFStringCreateMutable(((void*)0), 100)]; // expected-error {{indexing expression is invalid because subscript type 'CFMutableStringRef' (aka 'struct __CFString *') is not an integral or Objective-C pointer type}} \

+ // expected-error {{implicit conversion of C pointer type 'CFMutableStringRef' (aka 'struct __CFString *') to Objective-C pointer type '__strong id<NSCopying>' requires a bridged cast}} \

+ // expected-note {{use CFBridgingRelease call to transfer ownership of a +1 'CFMutableStringRef' (aka 'struct __CFString *') into ARC}}

+

+}

+

+// CHECK: fix-it:"{{.*}}":{31:18-31:18}:"(__bridge __strong id<NSCopying>)("

+// CHECK: fix-it:"{{.*}}":{31:34-31:34}:")"

+// CHECK: fix-it:"{{.*}}":{31:18-31:18}:"CFBridgingRelease("

+// CHECK: fix-it:"{{.*}}":{31:34-31:34}:")"

+// CHECK: fix-it:"{{.*}}":{35:25-35:25}:"CFBridgingRelease("

+// CHECK: fix-it:"{{.*}}":{35:63-35:63}:")"

+ __weak void *v; // expected-warning {{'__weak' only applies to Objective-C object or block pointer types}}

+

+// rdar://11253688

+@interface Boom

+@property (readonly) const void * innerPointer __attribute__((objc_returns_inner_pointer)); // expected-error {{'objc_returns_inner_pointer' attribute only applies to methods}}

+@end

+// RUN: %clang_cc1 -triple x86_64-apple-darwin11 -fobjc-runtime-has-weak -fsyntax-only -fobjc-arc -fblocks -fobjc-exceptions -verify -Wno-objc-root-class %s

+

+// rdar://problem/11144407

+@interface Test3

+@property (strong) id exception;

+@end

+void test3(Test3 *t3) {

+ @throw t3.exception;

+}

+ x = (id) auditedCreateString(); // expected-error {{requires a bridged cast}} expected-note {{use CFBridgingRelease call to}}

+ x = (id) (cond ? auditedCreateString() : (void*) 0); // expected-error {{requires a bridged cast}} expected-note {{use CFBridgingRelease call to}}

+ x = (id) (cond ? (void*) 0 : auditedCreateString()); // expected-error {{requires a bridged cast}} expected-note {{use CFBridgingRelease call to}}

+ x = (id) (cond ? (CFStringRef) @"help" : auditedCreateString()); // expected-error {{requires a bridged cast}} expected-note {{use CFBridgingRelease call to}}

+ __strong int non_objc_type; // expected-warning {{'__strong' only applies to Objective-C object or block pointer types}}

+// rdar://11814185

+@interface Radar11814185

+@property (nonatomic, weak) Radar11814185* picker1;

++ alloc;

+- init;

+@end

+

+@implementation Radar11814185

+

+@synthesize picker1;

+

+- (void)viewDidLoad

+{

+ picker1 = [[Radar11814185 alloc] init]; // expected-warning {{assigning retained object to weak variable; object will be released after assignment}}

+ self.picker1 = [[Radar11814185 alloc] init]; // expected-warning {{assigning retained object to weak property; object will be released after assignment}}

+}

+

++ alloc { return 0; }

+- init { return 0; }

+@end

+

+ [self bar].x = 10; // expected-error {{assigning to 'readonly' return result of an Objective-C message not allowed}}

+// RUN: %clang_cc1 -triple i386-unknown-unknown -fobjc-runtime=macosx-fragile-10.5 %s -fsyntax-only

+

+@protocol P

+- (void)proto_method __attribute__((availability(macosx,introduced=10.1,deprecated=10.2))); // expected-note 2 {{method 'proto_method' declared here}}

+@end

+

+@interface A <P>

+- (void)method __attribute__((availability(macosx,introduced=10.1,deprecated=10.2))); // expected-note {{method 'method' declared here}}

+// rdar://11475360

+- (void)method; // expected-note {{method 'method' declared here}}

+ [b method]; // expected-warning {{'method' is deprecated: first deprecated in Mac OS X 10.2}}

+ [a proto_method]; // expected-warning{{'proto_method' is deprecated: first deprecated in Mac OS X 10.2}}

+ [b proto_method]; // expected-warning{{'proto_method' is deprecated: first deprecated in Mac OS X 10.2}}

+ int X __attribute__((deprecated)); // expected-note 2 {{declared here}}

++ (void)F __attribute__((deprecated)); // expected-note 2 {{declared here}}

+- (void)f __attribute__((deprecated)); // expected-note 4 {{declared here}}

+- (void)p __attribute__((deprecated)); // expected-note {{declared here}}

+@property (assign, setter = MySetter:) int FooBar __attribute__ ((deprecated)); // expected-note 2 {{declared here}}

+@interface DEPRECATED { // expected-note 2 {{declared here}}

+@property int test2 __attribute__((deprecated)); // expected-note 4 {{declared here}}

+

+

+typedef struct {

+ int x;

+} footype __attribute((deprecated)); // expected-note 2 {{declared here}}

+

+@interface foo {

+ footype a; // expected-warning {{'footype' is deprecated}}

+ footype b __attribute((deprecated));

+}

+@property footype c; // expected-warning {{'footype' is deprecated}}

+@property footype d __attribute((deprecated));

+@end

+

+// In C, enum constants have the type of the underlying integer type, not the

+// enumeration they are part of. We pretend the constants have enum type when

+// they are mixed with other expressions of enum type.

+enum CStyleEnum {

+ CSE_Value = 1

+};

+enum CStyleEnum getCSE();

+typedef enum CStyleEnum (^cse_block_t)();

+

+void testCStyleEnumInference(bool arg) {

+ cse_block_t a;

+

+ // No warnings here.

+ a = ^{ return getCSE(); };

+

+ a = ^{ // expected-error {{incompatible block pointer types assigning to 'cse_block_t' (aka 'enum CStyleEnum (^)()') from 'int (^)(void)'}}

+ return 1;

+ };

+ a = ^{ // expected-error {{incompatible block pointer types assigning to 'cse_block_t' (aka 'enum CStyleEnum (^)()') from 'int (^)(void)'}}

+ return CSE_Value;

+ };

+

+ // No warnings here.

+ a = ^{ if (arg) return CSE_Value; else return getCSE(); };

+ a = ^{ if (arg) return getCSE(); else return CSE_Value; };

+

+ // These two blocks actually return 'int'

+ a = ^{ // expected-error {{incompatible block pointer types assigning to 'cse_block_t' (aka 'enum CStyleEnum (^)()') from 'int (^)(void)'}}

+ if (arg)

+ return 1;

+ else

+ return CSE_Value;

+ };

+

+ a = ^{ // expected-error {{incompatible block pointer types assigning to 'cse_block_t' (aka 'enum CStyleEnum (^)()') from 'int (^)(void)'}}

+ if (arg)

+ return CSE_Value;

+ else

+ return 1;

+ };

+}

+

+

+enum FixedTypeEnum : unsigned {

+ FTE_Value = 1U

+};

+enum FixedTypeEnum getFTE();

+typedef enum FixedTypeEnum (^fte_block_t)();

+

+void testFixedTypeEnumInference(bool arg) {

+ fte_block_t a;

+

+ // No warnings here.

+ a = ^{ return getFTE(); };

+

+ // Since we fixed the underlying type of the enum, this is considered a

+ // compatible block type.

+ a = ^{

+ return 1U;

+ };

+ a = ^{

+ return FTE_Value;

+ };

+

+ // No warnings here.

+ a = ^{ if (arg) return FTE_Value; else return FTE_Value; };

+ a = ^{ if (arg) return getFTE(); else return getFTE(); };

+ a = ^{ if (arg) return FTE_Value; else return getFTE(); };

+ a = ^{ if (arg) return getFTE(); else return FTE_Value; };

+

+ // These two blocks actually return 'unsigned'.

+ a = ^{

+ if (arg)

+ return 1U;

+ else

+ return FTE_Value;

+ };

+

+ a = ^{

+ if (arg)

+ return FTE_Value;

+ else

+ return 1U;

+ };

+}

+

+

+enum {

+ AnonymousValue = 1

+};

+

+enum : short {

+ FixedAnonymousValue = 1

+};

+

+typedef enum {

+ TDE_Value

+} TypeDefEnum;

+TypeDefEnum getTDE();

+

+typedef enum : short {

+ TDFTE_Value

+} TypeDefFixedTypeEnum;

+TypeDefFixedTypeEnum getTDFTE();

+

+typedef int (^int_block_t)();

+typedef short (^short_block_t)();

+void testAnonymousEnumTypes(int arg) {

+ int_block_t IB;

+ IB = ^{ return AnonymousValue; };

+ IB = ^{ if (arg) return TDE_Value; else return getTDE(); }; // expected-error {{incompatible block pointer}}

+ IB = ^{ if (arg) return getTDE(); else return TDE_Value; }; // expected-error {{incompatible block pointer}}

+

+ // Since we fixed the underlying type of the enum, these are considered

+ // compatible block types anyway.

+ short_block_t SB;

+ SB = ^{ return FixedAnonymousValue; };

+ SB = ^{ if (arg) return TDFTE_Value; else return getTDFTE(); };

+ SB = ^{ if (arg) return getTDFTE(); else return TDFTE_Value; };

+}

+// RUN: %clang_cc1 -fsyntax-only -verify -Wattributes %s

+

+typedef long NSInteger;

+typedef unsigned long NSUInteger;

+typedef signed char BOOL;

+

+@interface NSNumber

+@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;

++ (NSNumber *)numberWithInteger:(NSInteger)value;

++ (NSNumber *)numberWithUnsignedInteger:(NSUInteger)value;

+@end

+

+typedef struct {

+ int x, y, z;

+} point;

+

+void testStruct() {

+ point p = { 0, 0, 0 };

+ id boxed = @(p); // expected-error {{illegal type 'point' used in a boxed expression}}

+}

+

+void testPointers() {

+ void *null = 0;

+ id boxed_null = @(null); // expected-error {{illegal type 'void *' used in a boxed expression}}

+ int numbers[] = { 0, 1, 2 };

+ id boxed_numbers = @(numbers); // expected-error {{illegal type 'int *' used in a boxed expression}}

+}

+

+void testInvalid() {

+ @(not_defined); // expected-error {{use of undeclared identifier 'not_defined'}}

+}

+

+enum MyEnum {

+ ME_foo

+};

+

+enum ForwE;

+

+void testEnum(void *p) {

+ enum MyEnum myen;

+ id box = @(myen);

+ box = @(ME_foo);

+ box = @(*(enum ForwE*)p); // expected-error {{incomplete type 'enum ForwE' used in a boxed expression}}

+}

+

+// <rdar://problem/11478173>

+@interface Unrelated

+- foo;

+@end

+

+@interface Blah (Blarg) // expected-error{{cannot find interface declaration for 'Blah'}}

+- foo;

+@end

+// RUN: %clang_cc1 %s -fobjc-runtime=macosx-fragile-10.5 -fsyntax-only -verify

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fobjc-arc -x objective-c %s.fixed -fsyntax-only

+ str = [[NSString alloc] initWithString:@"foo"]; // expected-warning {{redundant}}

+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fobjc-arc -x objective-c %s.fixed -fsyntax-only

+ str = @"foo"; // expected-warning {{redundant}}

+// RUN: %clang_cc1 -fobjc-runtime=macosx-fragile-10.5 -fsyntax-only -verify -Wno-objc-root-class %s

+@property(readwrite, copy) id object; // expected-warning {{property attribute in class extension does not match the primary class}}

+@property(readonly) id object1; // expected-error {{illegal redeclaration of property in class extension 'ReadOnly' (attribute must be 'readwrite', while its primary must be 'readonly')}}

+@property (readwrite, assign) int indentLevel; // OK. assign the default in any case.

+@property (copy) id foo; // expected-error {{illegal redeclaration of property in class extension 'Bar' (attribute must be 'readwrite', while its primary must be 'readonly')}}

+@property (copy) id fee; // expected-error {{illegal redeclaration of property in class extension 'Bar' (attribute must be 'readwrite', while its primary must be 'readonly')}}

+@property (readwrite) NSString *foo; // expected-error {{type of property 'NSString *' in class extension does not match property type in primary class}}

+@property (readwrite, strong) NSRect bar; // expected-error {{type of property 'NSRect' in class extension does not match property type in primary class}}

+// RUN: %clang_cc1 -triple x86_64-apple-darwin11 -fsyntax-only -fobjc-arc -fblocks -verify %s

+// RUN: %clang_cc1 -triple x86_64-apple-darwin11 -fsyntax-only -fobjc-arc -fblocks -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s

+// rdar://11987838

+

+@protocol NSObject

+- dealloc; // expected-error {{return type must be correctly specified as 'void' under ARC, instead of 'id'}}

+// CHECK: fix-it:"{{.*}}":{6:3-6:3}:"(void)"

+@end

+

+@protocol Foo <NSObject> @end

+

+@interface Root <Foo>

+@end

+

+@interface Baz : Root {

+}

+@end

+

+@implementation Baz

+- (id) dealloc { // expected-error {{return type must be correctly specified as 'void' under ARC, instead of 'id'}}

+// CHECK: fix-it:"{{.*}}":{20:5-20:7}:"void"

+}

+

+@end

+

+// RUN: %clang_cc1 -fsyntax-only -fobjc-default-synthesize-properties -Wobjc-missing-property-synthesis -verify -Wno-objc-root-class %s

+// rdar://11295716

+@property int howMany; // expected-warning {{auto property synthesis is synthesizing property not explicitly synthesized}}

+@property (retain) NSString* what; // expected-warning {{auto property synthesis is synthesizing property not explicitly synthesized}}

+@implementation SynthItAll // expected-note 2 {{detected while default synthesizing properties in class implementation}}

+@property (nonatomic) int howMany; // expected-warning {{auto property synthesis is synthesizing property not explicitly synthesized}}

+@property (nonatomic, retain) NSString* what; // expected-warning {{auto property synthesis is synthesizing property not explicitly synthesized}}

+@implementation SynthSetter // expected-note 2 {{detected while default synthesizing properties in class implementation}}

+@property (nonatomic) int howMany; // expected-warning {{auto property synthesis is synthesizing property not explicitly synthesized}}

+@property (nonatomic, retain) NSString* what; // expected-warning {{auto property synthesis is synthesizing property not explicitly synthesized}}

+@implementation SynthGetter // expected-note 2 {{detected while default synthesizing properties in class implementation}}

+@interface rdar11333367

+@property enum A x; // expected-note {{forward declaration of 'enum A'}} expected-note {{property declared here}}

+@property struct B y; // expected-note {{forward declaration of 'struct B'}} expected-note {{property declared here}} \

+ // expected-warning {{auto property synthesis is synthesizing property not explicitly synthesized}}

+@end

+@implementation rdar11333367 // expected-error {{cannot synthesize property 'y' with incomplete type 'struct B'}} \

+ // expected-note {{detected while default synthesizing properties in class implementation}}

+@synthesize x; // expected-error {{cannot synthesize property 'x' with incomplete type 'enum A'}}

+@end

+ id uid; // expected-note {{ivar is declared here}}

+@property (readwrite, assign) id uid; // expected-note {{property declared here}}

+// rdar://11671080

+@implementation Test3 // expected-warning {{autosynthesized property 'uid' will use synthesized instance variable '_uid', not existing instance variable 'uid'}}

+// rdar://11671080

+@interface Test8

+{

+ id _y;

+ id y; // expected-note {{ivar is declared here}}

+}

+@property(copy) id y; // expected-note {{property declared here}}

+@end

+

+

+@implementation Test8 @end // expected-warning {{autosynthesized property 'y' will use instance variable '_y', not existing instance variable 'y'}}

+

+// RUN: %clang_cc1 -fsyntax-only -Werror -verify -Wno-objc-root-class %s

+// rdar://10387088

+

+@interface MyClass

+- (void)someMethod;

+@end

+

+@implementation MyClass

+- (void)someMethod {

+ [self privateMethod]; // clang already does not warn here

+}

+

+int bar(MyClass * myObject) {

+ [myObject privateMethod];

+ return gorfbar(myObject);

+}

+- (void)privateMethod { }

+

+int gorfbar(MyClass * myObject) {

+ [myObject privateMethod];

+ [myObject privateMethod1];

+ return getMe + bar(myObject);

+}

+

+int KR(myObject)

+MyClass * myObject;

+{

+ [myObject privateMethod];

+ [myObject privateMethod1];

+ return getMe + bar(myObject);

+}

+

+- (void)privateMethod1 {

+ getMe = getMe+1;

+}

+

+static int getMe;

+

+static int test() {

+ return 0;

+}

+

+@end

+// RUN: %clang_cc1 -fsyntax-only -fobjc-default-synthesize-properties -verify -Wno-objc-root-class %s

+@property (readwrite) char bar; // expected-error{{illegal redeclaration of 'readwrite' property in class extension 'Foo' (perhaps you intended this to be a 'readwrite' redeclaration of a 'readonly' public property?)}}

+// RUN: %clang_cc1 -Wno-objc-root-class -verify %s

+#define CFSTR(cStr) ((CFStringRef) __builtin___CFStringMakeConstantString ("" cStr ""))

+

+// This function is used instead of the builtin if -fno-constant-cfstrings.

+// The definition on Mac OS X is NOT annotated with format_arg as of 10.8,

+// but clang will implicitly add the attribute if it's not written.

+extern CFStringRef __CFStringMakeConstantString(const char *);

+ CFStringCreateWithFormat(CFSTR("%i"),test); // expected-warning{{format specifies type 'int' but the argument has type 'long long'}}

+ MyCFStringCreateWithFormat(CFSTR("%@")); // expected-warning {{more '%' conversions than data arguments}}

+#include "format-strings-system.h"

+

+// Test it inhibits diag only for macros in system headers

+#define MyNSLocalizedString(key) GetLocalizedString(key)

+#define MyNSAssert(fmt, arg) NSLog(fmt, arg, 0, 0)

+ [Foo fooWithFormat:MyNSLocalizedString(@"format"), @"arg"]; // expected-warning {{format string is not a string literal}}}

+}

+

+void check_NSAssert() {

+ NSAssert(@"Hello %@", @"World"); // no-warning

+ MyNSAssert(@"Hello %@", @"World"); // expected-warning {{data argument not used by format string}}

+void test_toll_free_bridging(CFStringRef x, id y) {

+ CFStringCreateWithFormat(CFSTR("%@"), x); // no-warning

+

+ NSLog(@"%@", y); // no-warning

+ CFStringCreateWithFormat(CFSTR("%@"), y); // no-warning

+void test_nonBuiltinCFStrings() {

+ CFStringCreateWithFormat(__CFStringMakeConstantString("%@"), 1); // expected-warning{{format specifies type 'id' but the argument has type 'int'}}

+}

+

+

+// Don't crash on an invalid argument expression.

+// <rdar://problem/11890818>

+@interface NSDictionary : NSObject

+- (id)objectForKeyedSubscript:(id)key;

+@end

+

+void testInvalidFormatArgument(NSDictionary *dict) {

+ NSLog(@"no specifiers", dict[CFSTR("abc")]); // expected-error{{indexing expression is invalid because subscript type 'CFStringRef' (aka 'const struct __CFString *') is not an integral or Objective-C pointer type}}

+ NSLog(@"%@", dict[CFSTR("abc")]); // expected-error{{indexing expression is invalid because subscript type 'CFStringRef' (aka 'const struct __CFString *') is not an integral or Objective-C pointer type}}

+ NSLog(@"%@ %@", dict[CFSTR("abc")]); // expected-error{{indexing expression is invalid because subscript type 'CFStringRef' (aka 'const struct __CFString *') is not an integral or Objective-C pointer type}}

+

+ [Foo fooWithFormat:@"no specifiers", dict[CFSTR("abc")]]; // expected-error{{indexing expression is invalid because subscript type 'CFStringRef' (aka 'const struct __CFString *') is not an integral or Objective-C pointer type}}

+ [Foo fooWithFormat:@"%@", dict[CFSTR("abc")]]; // expected-error{{indexing expression is invalid because subscript type 'CFStringRef' (aka 'const struct __CFString *') is not an integral or Objective-C pointer type}}

+ [Foo fooWithFormat:@"%@ %@", dict[CFSTR("abc")]]; // expected-error{{indexing expression is invalid because subscript type 'CFStringRef' (aka 'const struct __CFString *') is not an integral or Objective-C pointer type}} expected-warning{{more '%' conversions than data arguments}}

+}

+

+

+// <rdar://problem/11825593>

+void testByValueObjectInFormat(Foo *obj) {

+ printf("%d %d %d", 1L, *obj, 1L); // expected-error {{cannot pass object with interface type 'Foo' by value to variadic function; expected type from format string was 'int'}} expected-warning 2 {{format specifies type 'int' but the argument has type 'long'}}

+

+ [Bar log2:@"%d", *obj]; // expected-error {{cannot pass object with interface type 'Foo' by value to variadic method; expected type from format string was 'int'}}

+}

+

+

+#pragma clang system_header

+

+@class NSString;

+

+// Do not emit warnings when using NSLocalizedString

+extern NSString *GetLocalizedString(NSString *str);

+#define NSLocalizedString(key) GetLocalizedString(key)

+

+#define NSAssert(fmt, arg) NSLog(fmt, arg, 0, 0)

+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s

+

+@interface MyParent {

+ int X;

+}

+@end

+@implementation MyParent

+@end

+

+@interface MyParent(AA) {

+}

+@end

+@implementation MyParent (AA)

+- (void) setX: (int)in {X = in - 2;}

+- (int) X {return X;}

+@end

+

+@interface MyClass : MyParent

+@end

+@implementation MyClass

+@end

+

+int foo(MyClass *o) {

+ o.X = 2;

+ return o.X;

+} \ No newline at end of file

+// RUN: %clang_cc1 -fsyntax-only -fobjc-default-synthesize-properties -Wno-objc-root-class -verify %s

+// RUN: %clang_cc1 -x objective-c++ -fsyntax-only -fobjc-default-synthesize-properties -Wno-objc-root-class -verify %s

+// rdar://11448209

+

+#define READONLY readonly

+

+@class NSView;

+

+#define IBOutlet __attribute__((iboutlet))

+

+@interface I

+@property (getter = MyGetter, readonly, assign) IBOutlet NSView *myView; // expected-note {{property declared here}} \

+ // expected-note {{readonly IBOutlet property should be changed to be readwrite}}

+

+@property (readonly) IBOutlet NSView *myView1; // expected-note {{readonly IBOutlet property should be changed to be readwrite}} \

+ // expected-note {{property declared here}}

+

+@property (getter = MyGetter, READONLY) IBOutlet NSView *myView2; // expected-note {{property declared here}}

+

+@end

+

+@implementation I // expected-warning 3 {{readonly IBOutlet property when auto-synthesized may not work correctly with 'nib' loader}}

+@end

+// rdar://11356439

+typedef int id; // expected-error {{typedef redefinition with different types ('int' vs 'id')}}

+typedef double id; // expected-error {{typedef redefinition with different types ('double' vs 'id')}}

+

+typedef char *id; // expected-error {{typedef redefinition with different types ('char *' vs 'id')}}

+

+typedef union U{ int iu; } *id; // expected-error {{typedef redefinition with different types ('union U *' vs 'id')}}

+

+void test11356439(id o) {

+ o->x; // expected-error {{member reference base type 'id' is not a structure or union}}

+}

+// RUN: %clang_cc1 -triple i386-apple-darwin9 -fobjc-runtime=macosx-fragile-10.5 %s -fsyntax-only -verify

+// RUN: %clang_cc1 %s -fsyntax-only -verify -triple i386-apple-darwin9 -fobjc-runtime=macosx-fragile-10.5

+// RUN: %clang_cc1 -fobjc-runtime=macosx-fragile-10.5 -fsyntax-only -verify %s

+ g0(1, *(foo*)a0); // expected-error {{cannot pass object with interface type 'foo' by value through variadic function}}

+- Func:(int)XXXX, id object; // expected-warning {{use of C-style parameters in Objective-C method declarations is deprecated}}

+- Func:(int)XXXX, id object { return object; } // expected-warning {{use of C-style parameters in Objective-C method declarations is deprecated}}

+// RUN: %clang_cc1 -fsyntax-only -Wno-deprecated-declarations -verify %s

+// rdar://11460990

+

+typedef unsigned int CGDirectDisplayID;

+

+@interface NSObject @end

+

+@interface BrightnessAssistant : NSObject {}

+- (void)BrightnessAssistantUnregisterForNotifications:(void*) observer; // expected-note {{previous definition is here}}

+@end

+@implementation BrightnessAssistant // expected-note {{implementation started here}}

+- (void)BrightnessAssistantUnregisterForNotifications:(CGDirectDisplayID) displayID, void* observer // expected-warning {{conflicting parameter types in implementation of 'BrightnessAssistantUnregisterForNotifications:': 'void *' vs 'CGDirectDisplayID'}}

+@end // expected-error {{expected method body}} // expected-error {{missing '@end'}}

+@property(nonatomic,readwrite,retain) NSArray* err_outline; // expected-error {{type of property 'NSArray *' in class extension does not match property type in primary class}}

+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class -Wobjc-interface-ivars %s

+// rdar://10763173

+

+@interface I

+{

+ @protected int P_IVAR; // expected-warning {{declaration of ivars in the interface is deprecated}}

+

+ @public int PU_IVAR; // expected-warning {{declaration of ivars in the interface is deprecated}}

+

+ @private int PRV_IVAR; // expected-warning {{declaration of ivars in the interface is deprecated}}

+}

+@end

+

+@interface I()

+{

+ int I1;

+ int I2;

+}

+@end

+

+@interface I()

+{

+ int I3, I4;

+}

+@end

+

+@implementation I

+{

+ int I5;

+ int I6;

+}

+@end

+// RUN: %clang_cc1 -fsyntax-only -fobjc-arc -fobjc-runtime-has-weak -Wsuper-class-method-mismatch -verify %s

+// rdar://11793793

+

+@class NSString;

+

+@interface Super

+@property (nonatomic) NSString *thingy;

+@property () __weak id PROP;

+@end

+

+@interface Sub : Super

+@end

+

+@implementation Sub

+- (void)setThingy:(NSString *)val

+{

+ [super setThingy:val];

+}

+@synthesize PROP;

+@end

+@property (nonatomic, retain) __attribute__((NSObject)) CGColorRefNoNSObject color; // // no-warning

+// rdar://11569860

+@interface A { int i; }

+@property(retain) __attribute__((NSObject)) int i; // expected-error {{__attribute ((NSObject)) is for pointer types only}} \

+ // expected-error {{property with 'retain (or strong)' attribute must be of object type}}

+@end

+

+@implementation A

+@synthesize i;

+@end

+

+ array[f] = array; // expected-error {{indexing expression is invalid because subscript type 'float' is not an integral or Objective-C pointer type}}

+ return array[3.14]; // expected-error {{indexing expression is invalid because subscript type 'double' is not an integral or Objective-C pointer type}}

+ array[2] = i; // expected-error {{cannot assign to this array because assigning method's 2nd parameter of type 'int' is not an Objective-C pointer type}}

+ // expected-error {{cannot assign to this array because assigning method's 2nd parameter of type 'id *' is not an Objective-C pointer type}}

+ oldObject = array[10]++; // expected-error {{illegal operation on Objective-C container subscripting}}

+ oldObject = array[10]--; // expected-error {{illegal operation on Objective-C container subscripting}}

+ oldObject = --array[10]; // expected-error {{illegal operation on Objective-C container subscripting}}

+// RUN: %clang_cc1 -fsyntax-only -Wno-deprecated-declarations -verify -Wno-objc-root-class %s

+ dict["name"] = @666; // expected-error {{indexing expression is invalid because subscript type 'char *' is not an Objective-C pointer}}

+// RUN: %clang_cc1 -fsyntax-only -Wno-everything -Wobjc-literal-compare "-Dnil=((id)0)" -verify %s

+// RUN: %clang_cc1 -fsyntax-only -Wno-everything -Wobjc-literal-compare "-Dnil=(id)0" -verify %s

+// RUN: %clang_cc1 -fsyntax-only -Wno-everything -Wobjc-literal-compare "-Dnil=0" -verify %s

+

+// (test the warning flag as well)

+

+typedef signed char BOOL;

+

+@interface BaseObject

++ (instancetype)new;

+@end

+

+@interface NSObject : BaseObject

+- (BOOL)isEqual:(id)other;

+@end

+

+@interface NSNumber : NSObject

++ (NSNumber *)numberWithInt:(int)value;

++ (NSNumber *)numberWithDouble:(double)value;

++ (NSNumber *)numberWithBool:(BOOL)value;

+@end

+

+@interface NSArray : NSObject

++ (id)arrayWithObjects:(const id [])objects count:(unsigned long)cnt;

+@end

+

+@interface NSDictionary : NSObject

++ (id)dictionaryWithObjects:(const id [])objects forKeys:(const id [])keys count:(unsigned long)cnt;

+@end

+

+@interface NSString : NSObject

+@end

+

+void testComparisonsWithFixits(id obj) {

+ if (obj == @"") return; // expected-warning{{direct comparison of a string literal has undefined behavior}} expected-note{{use 'isEqual:' instead}}

+ if (obj != @"") return; // expected-warning{{direct comparison of a string literal has undefined behavior}} expected-note{{use 'isEqual:' instead}}

+ if (@"" == obj) return; // expected-warning{{direct comparison of a string literal has undefined behavior}} expected-note{{use 'isEqual:' instead}}

+ if (@"" == @"") return; // expected-warning{{direct comparison of a string literal has undefined behavior}} expected-note{{use 'isEqual:' instead}}

+

+ if (@[] == obj) return; // expected-warning{{direct comparison of an array literal has undefined behavior}} expected-note{{use 'isEqual:' instead}}

+ if (@{} == obj) return; // expected-warning{{direct comparison of a dictionary literal has undefined behavior}} expected-note{{use 'isEqual:' instead}}

+ if (@12 == obj) return; // expected-warning{{direct comparison of a numeric literal has undefined behavior}} expected-note{{use 'isEqual:' instead}}

+ if (@1.0 == obj) return; // expected-warning{{direct comparison of a numeric literal has undefined behavior}} expected-note{{use 'isEqual:' instead}}

+ if (@__objc_yes == obj) return; // expected-warning{{direct comparison of a numeric literal has undefined behavior}} expected-note{{use 'isEqual:' instead}}

+ if (@(1+1) == obj) return; // expected-warning{{direct comparison of a boxed expression has undefined behavior}} expected-note{{use 'isEqual:' instead}}

+}

+

+

+@interface BadEqualReturnString : NSString

+- (void)isEqual:(id)other;

+@end

+

+@interface BadEqualArgString : NSString

+- (BOOL)isEqual:(int)other;

+@end

+

+

+void testComparisonsWithoutFixits() {

+ if ([BaseObject new] == @"") return; // expected-warning{{direct comparison of a string literal has undefined behavior}}

+

+ if ([BadEqualReturnString new] == @"") return; // expected-warning{{direct comparison of a string literal has undefined behavior}}

+ if ([BadEqualArgString new] == @"") return; // expected-warning{{direct comparison of a string literal has undefined behavior}}

+

+ if (@"" < @"") return; // expected-warning{{direct comparison of a string literal has undefined behavior}}

+ if (@"" > @"") return; // expected-warning{{direct comparison of a string literal has undefined behavior}}

+ if (@"" <= @"") return; // expected-warning{{direct comparison of a string literal has undefined behavior}}

+ if (@"" >= @"") return; // expected-warning{{direct comparison of a string literal has undefined behavior}}

+}

+

+

+#pragma clang diagnostic push

+#pragma clang diagnostic ignored "-Wobjc-string-compare"

+

+void testWarningFlags(id obj) {

+ if (obj == @"") return; // no-warning

+ if (@"" == obj) return; // no-warning

+

+ if (obj == @1) return; // expected-warning{{direct comparison of a numeric literal has undefined behavior}} expected-note{{use 'isEqual:' instead}}

+ if (@1 == obj) return; // expected-warning{{direct comparison of a numeric literal has undefined behavior}} expected-note{{use 'isEqual:' instead}}

+}

+

+#pragma clang diagnostic pop

+

+

+void testNilComparison() {

+ // Don't warn when comparing to nil in a macro.

+#define RETURN_IF_NIL(x) if (x == nil || nil == x) return

+ RETURN_IF_NIL(@"");

+ RETURN_IF_NIL(@1);

+ RETURN_IF_NIL(@1.0);

+ RETURN_IF_NIL(@[]);

+ RETURN_IF_NIL(@{});

+ RETURN_IF_NIL(@__objc_yes);

+ RETURN_IF_NIL(@(1+1));

+}

+

+

+id stringBoxingNoSuchMethod(const char *str) {

+ return @(str); // expected-error {{declaration of 'stringWithUTF8String:' is missing in NSString class}}

+}

++ (int)numberWithBool:(BOOL)value; // expected-note 2 {{method returns unexpected type 'int' (should be an object type)}}

+@end

+

+@interface NSString

++ (char)stringWithUTF8String:(const char *)value; // expected-note 2 {{method returns unexpected type 'char' (should be an object type)}}

++ (id)arrayWithObjects:(const int [])objects // expected-note 2 {{first parameter has unexpected type 'const int *' (should be 'const id *')}}

+ forKeys:(const int [])keys // expected-note 2 {{second parameter has unexpected type 'const int *' (should be 'const id *')}}

+// All tests are doubled to make sure that a bad method is not saved

+// and then used un-checked.

+ (void)@__objc_yes; // expected-error{{literal construction method 'numberWithBool:' has incompatible signature}}

+ id array2 = @[ @17 ]; // expected-error{{literal construction method 'arrayWithObjects:count:' has incompatible signature}}

+ id dict2 = @{ @"hello" : @17 }; // expected-error{{literal construction method 'dictionaryWithObjects:forKeys:count:' has incompatible signature}}

+ id str = @("hello"); // expected-error{{literal construction method 'stringWithUTF8String:' has incompatible signature}}

+ id str2 = @("hello"); // expected-error{{literal construction method 'stringWithUTF8String:' has incompatible signature}}

+@property id p4; // expected-warning {{no 'assign', 'retain', or 'copy' attribute is specified - 'assign' is assumed}}, expected-warning {{default property attribute 'assign' not appropriate for non-GC object}}

+// RUN: %clang_cc1 -fsyntax-only -Wno-objc-root-class -Wreadonly-setter-attrs -verify %s

+// rdar://11656982

+@interface I0 <P0> @end

+@implementation I0

+@synthesize X;

+@end

+

+@interface I1 <P1> @end

+@implementation I1

+@synthesize X;

+@end

+

+@interface I2 <P2> @end

+@implementation I2

+@synthesize X;

+@end

+

+@interface I3 <P3> @end

+@implementation I3

+@synthesize X;

+@end

+

+@interface I4 <P4> @end

+@implementation I4

+@synthesize X;

+@end

+

+@interface I5 <P5> @end

+@implementation I5

+@synthesize X;

+@end

+

+@interface I6 <P6> @end

+@implementation I6

+@synthesize X;

+@end

++ (id)_componentCellWithRepresentedObject {

+ return self.gradientStyle;

+

+// rdar://11054153

+@interface rdar11054153

+@property int P; // expected-error {{type of property 'P' ('int') does not match type of accessor 'P' ('void')}}

+- (void)P; // expected-note {{declared here}}

+

+@property int P1; // expected-warning {{type of property 'P1' does not match type of accessor 'P1'}}

+- (double) P1; // expected-note {{declared here}}

+

+@property int P2; // expected-error {{type of property 'P2' ('int') does not match type of accessor 'P2' ('double *')}}

+- (double*)P2; // expected-note {{declared here}}

+

+@end

+

+@interface Test5

+{

+ void * _P; // expected-note {{ivar is declared here}}

+}

+@property int P;

+@end

+

+@implementation Test5

+@synthesize P=_P; // expected-error {{ype of property 'P' ('int') does not match type of ivar '_P' ('void *')}}

+@end

+

+@property (readonly) NSArray* pieces; // expected-warning {{type of property 'pieces' does not match type of accessor 'pieces'}}

+@property (readonly) NSMutableArray* first;

+- (NSMutableArray*) pieces; // expected-note 2 {{declared here}}

+ return container.first;

+

+// rdar://11363363

+@interface rdar11363363

+{

+ id R;

+}

+@property (copy) id p;

+@property (copy) id r;

+@property (copy) id Q;

+@property (copy) id t; // expected-note 2 {{property declared here}}

+@property (copy) id T; // expected-note 2 {{property declared here}}

+@property (copy) id Pxyz; // expected-note 2 {{property declared here}}

+@property (copy) id pxyz; // expected-note 2 {{property declared here}}

+@end

+

+@implementation rdar11363363

+@synthesize p;

+@synthesize r;

+@synthesize Q;

+@synthesize t, T;

+@synthesize Pxyz, pxyz;

+- (id) Meth {

+ self.P = 0;

+ self.q = 0;

+// rdar://11528439

+ self.t = 0; // expected-error {{synthesized properties 't' and 'T' both claim setter 'setT:'}}

+ self.T = 0; // expected-error {{synthesized properties 'T' and 't' both claim setter 'setT:'}}

+ self.Pxyz = 0; // expected-error {{synthesized properties 'Pxyz' and 'pxyz' both claim setter 'setPxyz:'}}

+ self.pxyz = 0; // expected-error {{synthesized properties 'pxyz' and 'Pxyz' both claim setter 'setPxyz:'}}

+ self.R = 0;

+ return self.R; // expected-error {{expected getter method not found on object of type 'rdar11363363 *'}}

+}

+@end

+

+// rdar://11499742

+@class BridgeFormatter;

+

+@interface FMXBridgeFormatter

+

+@property(assign, readwrite, getter=formatter, setter=setFormatter:) BridgeFormatter* cppFormatter;

+

+@end

+

+@implementation FMXBridgeFormatter

+@synthesize cppFormatter;

+

+- (void) dealloc

+{

+ self.formatter = 0;

+}

+@end

+

+// RUN: %clang_cc1 -triple i386-apple-darwin9 -fobjc-runtime=macosx-fragile-10.5 -fsyntax-only -verify -Wno-objc-root-class %s

+@property id prop_id; // expected-warning {{no 'assign', 'retain', or 'copy' attribute is specified - 'assign' is assumed}}, expected-warning {{default property attribute 'assign' not appropriate for non-GC object}}

+__attribute ((deprecated)) @protocol MyProto1 // expected-note 7 {{declared here}}

+// RUN: %clang_cc1 -fsyntax-only -Wno-deprecated-declarations -verify %s

+ PROP = value; // OK

+// RUN: %clang_cc1 -verify -Wno-deprecated-declarations -Wno-objc-root-class %s

+

+// <rdar://problem/11460990>

+

+@interface WeirdNSString : NSString

+- (id)initWithCString:(const char*)string, void *blah;

+@end

+int g1[ sizeof(I0) // expected-error {{application of 'sizeof' to interface 'I0' is not supported on this architecture and platform}}

+int g2[ sizeof(I0) // expected-error {{application of 'sizeof' to interface 'I0' is not supported on this architecture and platform}}

+typedef struct { @defs(I1); } I1_defs; // expected-error {{use of @defs is not supported on this architecture and platform}}

+ P = P+5; // expected-error {{arithmetic on pointer to interface 'I0', which is not a constant size for this architecture and platform}}

+ P = 5+P; // expected-error {{arithmetic on pointer to interface 'I0', which is not a constant size for this architecture and platform}}

+ P = P-5; // expected-error {{arithmetic on pointer to interface 'I0', which is not a constant size for this architecture and platform}}

+ unsigned long attributeRuns[1024 + sizeof(I)]; // expected-error {{application of 'sizeof' to interface 'I' is not supported on this architecture and platform}}

+ ++f; // expected-error {{arithmetic on pointer to interface 'Foo', which is not a constant size for this architecture and platform}}

+ --f; // expected-error {{arithmetic on pointer to interface 'Foo', which is not a constant size for this architecture and platform}}

+@interface DEPRECATED // expected-note {{declared here}}

+// RUN: %clang_cc1 -fsyntax-only -Weverything -verify %s

+// rdar://11656982

+/** Normally, a property cannot be both 'readonly' and having a "write" attribute

+ (copy/retain/etc.). But, property declaration in primary class and protcols

+ are tentative as they may be overridden into a 'readwrite' property in class

+ extensions. Postpone diagnosing such warnings until the class implementation

+ is seen.

+*/

+

+@interface Super {

+}

+@end

+

+@class NSString;

+

+@interface MyClass : Super

+@property(nonatomic, copy, readonly) NSString *prop;

+@property(nonatomic, copy, readonly) id warnProp; // expected-warning {{property attributes 'readonly' and 'copy' are mutually exclusive}}

+@end

+

+@interface MyClass ()

+@property(nonatomic, copy, readwrite) NSString *prop;

+@end

+

+@implementation MyClass

+@synthesize prop;

+@synthesize warnProp;

+@end

+

+

+@protocol P

+@property(nonatomic, copy, readonly) NSString *prop;

+@property(nonatomic, copy, readonly) id warnProp; // expected-warning {{property attributes 'readonly' and 'copy' are mutually exclusive}}

+@end

+

+@interface YourClass : Super <P>

+@end

+

+@interface YourClass ()

+@property(nonatomic, copy, readwrite) NSString *prop;

+@end

+

+@implementation YourClass

+@synthesize prop;

+@synthesize warnProp;

+@end

+

+// rdar://10777111

+static NSString *x = @"hi"; // expected-warning {{unused variable 'x'}}

+@interface CL // expected-note 2 {{class declared here}} // expected-note 2 {{declared here}}

+// RUN: %clang_cc1 -fsyntax-only -fobjc-arc -fobjc-runtime-has-weak -Wdirect-ivar-access -verify -Wno-objc-root-class %s

+// rdar://6505197

+

+__attribute__((objc_root_class)) @interface MyObject {

+@public

+ id _myMaster;

+ id _isTickledPink;

+ int _myIntProp;

+}

+@property(retain) id myMaster;

+@property(assign) id isTickledPink; // expected-note {{property declared here}}

+@property int myIntProp;

+@end

+

+@implementation MyObject

+

+@synthesize myMaster = _myMaster;

+@synthesize isTickledPink = _isTickledPink; // expected-error {{existing ivar '_isTickledPink' for property 'isTickledPink'}}

+@synthesize myIntProp = _myIntProp;

+

+- (void) doSomething {

+ _myMaster = _isTickledPink; // expected-warning {{instance variable '_myMaster' is being directly accessed}} \

+ // expected-warning {{instance variable '_isTickledPink' is being directly accessed}}

+}

+

+- (id) init {

+ _myMaster=0;

+ return _myMaster;

+}

+- (void) dealloc { _myMaster = 0; }

+@end

+

+MyObject * foo ()

+{

+ MyObject* p=0;

+ p.isTickledPink = p.myMaster; // ok

+ p->_isTickledPink = (*p)._myMaster; // expected-warning {{instance variable '_isTickledPink' is being directly accessed}} \

+ // expected-warning {{instance variable '_myMaster' is being directly accessed}}

+ if (p->_myIntProp) // expected-warning {{instance variable '_myIntProp' is being directly accessed}}

+ p->_myIntProp = 0; // expected-warning {{instance variable '_myIntProp' is being directly accessed}}

+ return p->_isTickledPink; // expected-warning {{instance variable '_isTickledPink' is being directly accessed}}

+}

+

+@interface ITest32 {

+@public

+ id ivar;

+}

+@end

+

+id Test32(__weak ITest32 *x) {

+ __weak ITest32 *y;

+ x->ivar = 0; // expected-error {{dereferencing a __weak pointer is not allowed}}

+ return y ? y->ivar // expected-error {{dereferencing a __weak pointer is not allowed}}

+ : (*x).ivar; // expected-error {{dereferencing a __weak pointer is not allowed}}

+}

+

+ id firstobj;

+

+// rdar://11702488

+// If an ivar is (1) the first ivar in a root class and (2) named `isa`,

+// then it should get the same warnings that id->isa gets.

+

+@interface BaseClass {

+@public

+ Class isa; // expected-note 3 {{ivar is declared here}}

+}

+@end

+

+@interface OtherClass {

+@public

+ id firstIvar;

+ Class isa; // note, not first ivar;

+}

+@end

+

+@interface Subclass : BaseClass @end

+

+@interface SiblingClass : BaseClass @end

+

+@interface Root @end

+

+@interface hasIsa : Root {

+@public

+ Class isa; // note, isa is not in root class

+}

+@end

+

+@implementation Subclass

+-(void)method {

+ hasIsa *u;

+ id v;

+ BaseClass *w;

+ Subclass *x;

+ SiblingClass *y;

+ OtherClass *z;

+ (void)v->isa; // expected-warning {{direct access to objective-c's isa is deprecated}}

+ (void)w->isa; // expected-warning {{direct access to objective-c's isa is deprecated}}

+ (void)x->isa; // expected-warning {{direct access to objective-c's isa is deprecated}}

+ (void)y->isa; // expected-warning {{direct access to objective-c's isa is deprecated}}

+ (void)z->isa;

+ (void)u->isa;

+}

+@end

+

+// RUN: %clang_cc1 -fsyntax-only -Wno-objc-root-class -verify %s

+// rdar://11618852

+

+@protocol TestProtocol

+- (void)newProtocolMethod;

+- (void)deprecatedProtocolMethod __attribute__((deprecated)); // expected-note 2 {{method 'deprecatedProtocolMethod' declared here}}

+@end

+

+@interface NSObject @end

+

+@interface TestClass : NSObject <TestProtocol>

+

+- (void)newInstanceMethod;

+- (void)deprecatedInstanceMethod __attribute__((deprecated)); // expected-note {{method 'deprecatedInstanceMethod' declared here}}

+

+@end

+

+int main(int argc, const char * argv[])

+{

+

+ TestClass *testObj = (TestClass*)0;

+ [testObj newInstanceMethod];

+ [testObj deprecatedInstanceMethod]; // expected-warning {{'deprecatedInstanceMethod' is deprecated}}

+

+ [testObj newProtocolMethod];

+ [testObj deprecatedProtocolMethod]; // expected-warning {{'deprecatedProtocolMethod' is deprecated}}

+

+ id <TestProtocol> testProto = testObj;

+ [testProto newProtocolMethod];

+ [testProto deprecatedProtocolMethod]; // expected-warning {{'deprecatedProtocolMethod' is deprecated}}

+ return 0;

+}

+// RUN: %clang_cc1 -fsyntax-only -fblocks -verify -Wno-objc-root-class %s

+// rdar://11761511

+// RUN: %clang_cc1 -fsyntax-only -fobjc-runtime-has-weak -fobjc-arc -fblocks -Wno-objc-root-class -Wreceiver-is-weak -verify %s

+ weakx.block = ^{ [x actNow]; }; // expected-warning {{weak receiver may be unpredictably null in ARC mode}}

+

+@interface Test

+{

+ __weak Test* weak_prop;

+}

+- (void) Meth;

+@property __weak Test* weak_prop; // expected-note {{property declared here}}

+@property (weak, atomic) id weak_atomic_prop; // expected-note {{property declared here}}

+- (__weak id) P; // expected-note {{method 'P' declared here}}

+@end

+

+@implementation Test

+- (void) Meth {

+ if (self.weak_prop) {

+ self.weak_prop = 0;

+ }

+ if (self.weak_atomic_prop) {

+ self.weak_atomic_prop = 0;

+ }

+ [self.weak_prop Meth]; // expected-warning {{weak property may be unpredictably null in ARC mode}}

+ id pi = self.P;

+

+ [self.weak_atomic_prop Meth]; // expected-warning {{weak property may be unpredictably null in ARC mode}}

+

+ [self.P Meth]; // expected-warning {{weak implicit property may be unpredictably null in ARC mode}}

+}

+

+- (__weak id) P { return 0; }

+@dynamic weak_prop, weak_atomic_prop;

+@end

+

+

+@interface MyClass {

+ __weak MyClass *_parent;

+}

+@property (weak) MyClass *parent; // expected-note 2 {{property declared here}}

+@end

+

+@implementation MyClass

+@synthesize parent = _parent;

+

+- (void)doSomething

+{

+ [[self parent] doSomething]; // expected-warning {{weak property may be unpredictably null in ARC mode}}

+

+ (void)self.parent.doSomething; // expected-warning {{weak property may be unpredictably null in ARC mode}}

+}

+

+@end

+

+

+// Weak properties on protocols can be synthesized by an adopting class.

+@protocol MyProtocol

+@property (weak) id object; // expected-note 2 {{property declared here}}

+@end

+

+void testProtocol(id <MyProtocol> input) {

+ [[input object] Meth]; // expected-warning {{weak property may be unpredictably null in ARC mode}}

+ [input.object Meth]; // expected-warning {{weak property may be unpredictably null in ARC mode}}

+}

+