forked from OSchip/llvm-project
473 lines
18 KiB
Objective-C
473 lines
18 KiB
Objective-C
// RUN: %clang_cc1 -fblocks -fsyntax-only %s -verify -Wmethod-signatures
|
|
|
|
// Tests Objective-C 'kindof' types.
|
|
|
|
#if !__has_feature(objc_kindof)
|
|
#error does not support __kindof
|
|
#endif
|
|
|
|
@protocol NSObject
|
|
@end
|
|
|
|
@protocol NSCopying
|
|
- (id)copy;
|
|
+ (Class)classCopy;
|
|
@end
|
|
|
|
@protocol NSRandomProto
|
|
- (void)randomMethod;
|
|
+ (void)randomClassMethod;
|
|
@end
|
|
|
|
__attribute__((objc_root_class))
|
|
@interface NSObject <NSObject>
|
|
- (NSObject *)retain;
|
|
@end
|
|
|
|
@interface NSString : NSObject <NSCopying> // expected-note{{receiver is instance of class declared here}}
|
|
- (void)compare:(NSString *)string;
|
|
- (NSString *)stringByAppendingString:(NSString *)string;
|
|
+ (instancetype)string;
|
|
@end
|
|
|
|
@interface NSMutableString : NSString
|
|
- (void)appendString:(NSString *)string;
|
|
@end
|
|
|
|
@interface NSNumber : NSObject <NSCopying>
|
|
- (NSNumber *)numberByAddingNumber:(NSNumber *)number;
|
|
@end
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Parsing and semantic analysis for __kindof
|
|
// ---------------------------------------------------------------------------
|
|
|
|
// Test proper application of __kindof.
|
|
typedef __kindof NSObject *typedef1;
|
|
typedef NSObject __kindof *typedef2;
|
|
typedef __kindof NSObject<NSCopying> typedef3;
|
|
typedef NSObject<NSCopying> __kindof *typedef4;
|
|
typedef __kindof id<NSCopying> typedef5;
|
|
typedef __kindof Class<NSCopying> typedef6;
|
|
|
|
// Test redundancy of __kindof.
|
|
typedef __kindof id __kindof redundant_typedef1;
|
|
typedef __kindof NSObject __kindof *redundant_typedef2;
|
|
|
|
// Test application of __kindof to typedefs.
|
|
typedef NSObject *NSObject_ptr_typedef;
|
|
typedef NSObject NSObject_typedef;
|
|
typedef __kindof NSObject_ptr_typedef typedef_typedef1;
|
|
typedef __kindof NSObject_typedef typedef_typedef2;
|
|
|
|
// Test application of __kindof to non-object types.
|
|
typedef __kindof int nonobject_typedef1; // expected-error{{'__kindof' specifier cannot be applied to non-object type 'int'}}
|
|
typedef NSObject **NSObject_ptr_ptr;
|
|
typedef __kindof NSObject_ptr_ptr nonobject_typedef2; // expected-error{{'__kindof' specifier cannot be applied to non-object type 'NSObject_ptr_ptr' (aka 'NSObject **')}}
|
|
|
|
// Test application of __kindof outside of the decl-specifiers.
|
|
typedef NSObject * __kindof bad_specifier_location1; // expected-error{{'__kindof' type specifier must precede the declarator}}
|
|
typedef NSObject bad_specifier_location2 __kindof; // expected-error{{expected ';' after top level declarator}}
|
|
// expected-warning@-1{{declaration does not declare anything}}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Pretty printing of __kindof
|
|
// ---------------------------------------------------------------------------
|
|
void test_pretty_print(int *ip) {
|
|
__kindof NSObject *kindof_NSObject;
|
|
ip = kindof_NSObject; // expected-warning{{from '__kindof NSObject *'}}
|
|
|
|
__kindof NSObject_ptr_typedef kindof_NSObject_ptr;
|
|
ip = kindof_NSObject_ptr; // expected-warning{{from '__kindof NSObject_ptr_typedef'}}
|
|
|
|
__kindof id <NSCopying> *kindof_NSCopying;
|
|
ip = kindof_NSCopying; // expected-warning{{from '__kindof id<NSCopying> *'}}
|
|
|
|
__kindof NSObject_ptr_typedef *kindof_NSObject_ptr_typedef;
|
|
ip = kindof_NSObject_ptr_typedef; // expected-warning{{from '__kindof NSObject_ptr_typedef *'}}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Basic implicit conversions (dropping __kindof, upcasts, etc.)
|
|
// ---------------------------------------------------------------------------
|
|
void test_add_remove_kindof_conversions(void) {
|
|
__kindof NSObject *kindof_NSObject_obj;
|
|
NSObject *NSObject_obj;
|
|
|
|
// Conversion back and forth
|
|
kindof_NSObject_obj = NSObject_obj;
|
|
NSObject_obj = kindof_NSObject_obj;
|
|
|
|
// Qualified-id conversion back and forth.
|
|
__kindof id <NSCopying> kindof_id_NSCopying_obj;
|
|
id <NSCopying> id_NSCopying_obj;
|
|
kindof_id_NSCopying_obj = id_NSCopying_obj;
|
|
id_NSCopying_obj = kindof_id_NSCopying_obj;
|
|
}
|
|
|
|
void test_upcast_conversions(void) {
|
|
__kindof NSObject *kindof_NSObject_obj;
|
|
NSObject *NSObject_obj;
|
|
|
|
// Upcasts
|
|
__kindof NSString *kindof_NSString_obj;
|
|
NSString *NSString_obj;
|
|
kindof_NSObject_obj = kindof_NSString_obj;
|
|
kindof_NSObject_obj = NSString_obj;
|
|
NSObject_obj = kindof_NSString_obj;
|
|
NSObject_obj = NSString_obj;
|
|
|
|
// "Upcasts" with qualified-id.
|
|
__kindof id <NSCopying> kindof_id_NSCopying_obj;
|
|
id <NSCopying> id_NSCopying_obj;
|
|
kindof_id_NSCopying_obj = kindof_NSString_obj;
|
|
kindof_id_NSCopying_obj = NSString_obj;
|
|
id_NSCopying_obj = kindof_NSString_obj;
|
|
id_NSCopying_obj = NSString_obj;
|
|
}
|
|
|
|
|
|
void test_ptr_object_conversions(void) {
|
|
__kindof NSObject **ptr_kindof_NSObject_obj;
|
|
NSObject **ptr_NSObject_obj;
|
|
|
|
// Conversions back and forth.
|
|
ptr_kindof_NSObject_obj = ptr_NSObject_obj;
|
|
ptr_NSObject_obj = ptr_kindof_NSObject_obj;
|
|
|
|
// Conversions back and forth with qualified-id.
|
|
__kindof id <NSCopying> *ptr_kindof_id_NSCopying_obj;
|
|
id <NSCopying> *ptr_id_NSCopying_obj;
|
|
ptr_kindof_id_NSCopying_obj = ptr_id_NSCopying_obj;
|
|
ptr_id_NSCopying_obj = ptr_kindof_id_NSCopying_obj;
|
|
|
|
// Upcasts.
|
|
__kindof NSString **ptr_kindof_NSString_obj;
|
|
NSString **ptr_NSString_obj;
|
|
ptr_kindof_NSObject_obj = ptr_kindof_NSString_obj;
|
|
ptr_kindof_NSObject_obj = ptr_NSString_obj;
|
|
ptr_NSObject_obj = ptr_kindof_NSString_obj;
|
|
ptr_NSObject_obj = ptr_NSString_obj;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Implicit downcasting
|
|
// ---------------------------------------------------------------------------
|
|
void test_downcast_conversions(void) {
|
|
__kindof NSObject *kindof_NSObject_obj;
|
|
NSObject *NSObject_obj;
|
|
__kindof NSString *kindof_NSString_obj;
|
|
NSString *NSString_obj;
|
|
|
|
// Implicit downcasting.
|
|
kindof_NSString_obj = kindof_NSObject_obj;
|
|
kindof_NSString_obj = NSObject_obj; // expected-warning{{assigning to '__kindof NSString *' from 'NSObject *'}}
|
|
NSString_obj = kindof_NSObject_obj;
|
|
NSString_obj = NSObject_obj; // expected-warning{{assigning to 'NSString *' from 'NSObject *'}}
|
|
|
|
// Implicit downcasting with qualified id.
|
|
__kindof id <NSCopying> kindof_NSCopying_obj;
|
|
id <NSCopying> NSCopying_obj;
|
|
kindof_NSString_obj = kindof_NSCopying_obj;
|
|
kindof_NSString_obj = NSCopying_obj; // expected-warning{{from incompatible type 'id<NSCopying>'}}
|
|
NSString_obj = kindof_NSCopying_obj;
|
|
NSString_obj = NSCopying_obj; // expected-warning{{from incompatible type 'id<NSCopying>'}}
|
|
kindof_NSObject_obj = kindof_NSCopying_obj;
|
|
kindof_NSObject_obj = NSCopying_obj; // expected-warning{{from incompatible type 'id<NSCopying>'}}
|
|
NSObject_obj = kindof_NSCopying_obj;
|
|
NSObject_obj = NSCopying_obj; // expected-warning{{from incompatible type 'id<NSCopying>'}}
|
|
}
|
|
|
|
void test_crosscast_conversions(void) {
|
|
__kindof NSString *kindof_NSString_obj;
|
|
NSString *NSString_obj;
|
|
__kindof NSNumber *kindof_NSNumber_obj;
|
|
NSNumber *NSNumber_obj;
|
|
|
|
NSString_obj = kindof_NSNumber_obj; // expected-warning{{from '__kindof NSNumber *'}}
|
|
}
|
|
|
|
@interface NSCell : NSObject
|
|
@end
|
|
@interface NSCellSub : NSCell
|
|
@end
|
|
@interface NSCellSub2 : NSCell
|
|
@end
|
|
@interface NSCellSubSub : NSCellSub
|
|
@end
|
|
|
|
typedef signed char BOOL;
|
|
void test_conditional(BOOL flag) {
|
|
NSCellSubSub *result;
|
|
__kindof NSCellSub *kindof_Sub;
|
|
NSCell *cell;
|
|
NSCellSub *sub;
|
|
NSCellSub2 *sub2;
|
|
NSCellSubSub *subsub;
|
|
|
|
// LHS is kindof NSCellSub, RHS is NSCell --> kindof NSCell
|
|
// LHS is kindof NSCellSub, RHS is NSCellSub --> kindof NSCellSub
|
|
// LHS is kindof NSCellSub, RHS is NSCellSub2 --> kindof NSCell
|
|
// LHS is kindof NSCellSub, RHS is NSCellSubSub --> kindof NSCellSub
|
|
result = flag ? kindof_Sub : cell;
|
|
result = flag ? kindof_Sub : sub;
|
|
result = flag ? kindof_Sub : sub2;
|
|
result = flag ? kindof_Sub : subsub;
|
|
|
|
result = flag ? cell : kindof_Sub;
|
|
result = flag ? sub : kindof_Sub;
|
|
result = flag ? sub2 : kindof_Sub;
|
|
result = flag ? subsub : kindof_Sub;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Blocks
|
|
// ---------------------------------------------------------------------------
|
|
void test_block_conversions(void) {
|
|
// Adding/removing __kindof from return type.
|
|
__kindof NSString *(^kindof_NSString_void_block)(void);
|
|
NSString *(^NSString_void_block)(void);
|
|
kindof_NSString_void_block = NSString_void_block;
|
|
NSString_void_block = kindof_NSString_void_block;
|
|
|
|
// Covariant return type.
|
|
__kindof NSMutableString *(^kindof_NSMutableString_void_block)(void);
|
|
NSMutableString *(^NSMutableString_void_block)(void);
|
|
kindof_NSString_void_block = NSMutableString_void_block;
|
|
NSString_void_block = kindof_NSMutableString_void_block;
|
|
kindof_NSString_void_block = NSMutableString_void_block;
|
|
NSString_void_block = kindof_NSMutableString_void_block;
|
|
|
|
// "Covariant" return type via downcasting rule.
|
|
kindof_NSMutableString_void_block = NSString_void_block; // expected-error{{from 'NSString *(^)(void)'}}
|
|
NSMutableString_void_block = kindof_NSString_void_block;
|
|
kindof_NSMutableString_void_block = NSString_void_block; // expected-error{{from 'NSString *(^)(void)'}}
|
|
NSMutableString_void_block = kindof_NSString_void_block;
|
|
|
|
// Cross-casted return type.
|
|
__kindof NSNumber *(^kindof_NSNumber_void_block)(void);
|
|
NSNumber *(^NSNumber_void_block)(void);
|
|
kindof_NSString_void_block = NSNumber_void_block; // expected-error{{from 'NSNumber *(^)(void)'}}
|
|
NSString_void_block = kindof_NSNumber_void_block; // expected-error{{'__kindof NSNumber *(^)(void)'}}
|
|
kindof_NSString_void_block = NSNumber_void_block; // expected-error{{from 'NSNumber *(^)(void)'}}
|
|
NSString_void_block = kindof_NSNumber_void_block; // expected-error{{'__kindof NSNumber *(^)(void)'}}
|
|
|
|
// Adding/removing __kindof from argument type.
|
|
void (^void_kindof_NSString_block)(__kindof NSString *);
|
|
void (^void_NSString_block)(NSString *);
|
|
void_kindof_NSString_block = void_NSString_block;
|
|
void_NSString_block = void_kindof_NSString_block;
|
|
|
|
// Contravariant argument type.
|
|
void (^void_kindof_NSMutableString_block)(__kindof NSMutableString *);
|
|
void (^void_NSMutableString_block)(NSMutableString *);
|
|
void_kindof_NSMutableString_block = void_kindof_NSString_block;
|
|
void_kindof_NSMutableString_block = void_NSString_block;
|
|
void_NSMutableString_block = void_kindof_NSString_block;
|
|
void_NSMutableString_block = void_NSString_block;
|
|
|
|
// "Contravariant" argument type via downcasting rule.
|
|
void_kindof_NSString_block = void_kindof_NSMutableString_block;
|
|
void_kindof_NSString_block = void_NSMutableString_block;
|
|
void_NSString_block = void_kindof_NSMutableString_block; // expected-error{{from 'void (^)(__kindof NSMutableString *)'}}
|
|
void_NSString_block = void_NSMutableString_block; // expected-error{{from 'void (^)(NSMutableString *)'}}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Messaging __kindof types.
|
|
// ---------------------------------------------------------------------------
|
|
void message_kindof_object(__kindof NSString *kindof_NSString) {
|
|
[kindof_NSString retain]; // in superclass
|
|
[kindof_NSString stringByAppendingString:0]; // in class
|
|
[kindof_NSString appendString:0]; // in subclass
|
|
[kindof_NSString numberByAddingNumber: 0]; // expected-warning{{instance method '-numberByAddingNumber:' not found (return type defaults to 'id')}}
|
|
[kindof_NSString randomMethod]; // in protocol
|
|
}
|
|
|
|
void message_kindof_qualified_id(__kindof id <NSCopying> kindof_NSCopying) {
|
|
[kindof_NSCopying copy]; // in protocol
|
|
[kindof_NSCopying stringByAppendingString:0]; // in some class
|
|
[kindof_NSCopying randomMethod]; // in unrelated protocol
|
|
}
|
|
|
|
void message_kindof_qualified_class(
|
|
__kindof Class <NSCopying> kindof_NSCopying) {
|
|
[kindof_NSCopying classCopy]; // in protocol
|
|
[kindof_NSCopying string]; // in some class
|
|
[kindof_NSCopying randomClassMethod]; // in unrelated protocol
|
|
}
|
|
|
|
// Make sure we don't emit warning about multiple methods found.
|
|
typedef int NSInteger;
|
|
@interface Foo : NSObject
|
|
- (NSString*)test;
|
|
@end
|
|
@interface Bar : NSObject
|
|
- (NSInteger)test;
|
|
@end
|
|
void test(__kindof Bar *kBar) {
|
|
[kBar test];
|
|
}
|
|
|
|
// Make sure we don't emit warning about no method found.
|
|
@interface A : NSObject
|
|
@property (readonly, getter=isActive) BOOL active;
|
|
@end
|
|
@interface B : NSObject
|
|
@property (getter=isActive, readonly) BOOL active;
|
|
@end
|
|
void foo(void) {
|
|
__kindof B *NSApp;
|
|
if ([NSApp isActive]) {
|
|
}
|
|
}
|
|
|
|
typedef const struct CGPath *CGPathRef;
|
|
@interface C : NSObject
|
|
@property (copy) NSString *path;
|
|
@end
|
|
@interface D : NSObject
|
|
@property CGPathRef path __attribute__((availability(macosx,unavailable)));
|
|
@end
|
|
// Make sure we choose "NSString *path" for [s1 path].
|
|
void bar(id s1, id s2) {
|
|
return [[s1 path] compare:[s2 path]];
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// __kindof within specialized types
|
|
// ---------------------------------------------------------------------------
|
|
@interface NSArray<T> : NSObject
|
|
@end
|
|
|
|
void implicit_convert_array(NSArray<__kindof NSString *> *kindofStringsArray,
|
|
NSArray<NSString *> *stringsArray,
|
|
NSArray<__kindof NSMutableString *>
|
|
*kindofMutStringsArray,
|
|
NSArray<NSMutableString *> *mutStringsArray) {
|
|
// Adding/removing __kindof is okay.
|
|
kindofStringsArray = stringsArray;
|
|
stringsArray = kindofStringsArray;
|
|
|
|
// Other covariant and contravariant conversions still not permitted.
|
|
kindofStringsArray = mutStringsArray; // expected-warning{{incompatible pointer types}}
|
|
stringsArray = kindofMutStringsArray; // expected-warning{{incompatible pointer types}}
|
|
mutStringsArray = kindofStringsArray; // expected-warning{{incompatible pointer types}}
|
|
|
|
// Adding/removing nested __kindof is okay.
|
|
NSArray<NSArray<__kindof NSString *> *> *kindofStringsArrayArray;
|
|
NSArray<NSArray<NSString *> *> *stringsArrayArray;
|
|
kindofStringsArrayArray = stringsArrayArray;
|
|
stringsArrayArray = kindofStringsArrayArray;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// __kindof + nullability
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void testNullability(void) {
|
|
// The base type being a pointer type tickles the bug.
|
|
extern __kindof id <NSCopying> _Nonnull getSomeCopyable(void);
|
|
NSString *string = getSomeCopyable(); // no-warning
|
|
|
|
void processCopyable(__typeof(getSomeCopyable()) string);
|
|
processCopyable(0); // expected-warning{{null passed to a callee that requires a non-null argument}}
|
|
}
|
|
|
|
// Make sure that we don't emit a warning about conflicting parameter types
|
|
// between __kindof id and id.
|
|
@interface A2 : NSObject
|
|
- (void)test:(__kindof id)T;
|
|
@end
|
|
@implementation A2
|
|
- (void)test:(id)T {
|
|
}
|
|
@end
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// __kindof on type parameters
|
|
// ---------------------------------------------------------------------------
|
|
|
|
@interface NSGeneric<ObjectType> : NSObject
|
|
- (void)test:(__kindof ObjectType)T; // expected-note{{passing argument to parameter 'T' here}}
|
|
- (void)mapUsingBlock:(id (^)(__kindof ObjectType))block;
|
|
@property (copy) ObjectType object;
|
|
@property (copy) __kindof ObjectType kindof_object;
|
|
|
|
@property (copy) __kindof ObjectType _Nonnull nonnull_kindof_object;
|
|
@end
|
|
@implementation NSGeneric
|
|
- (void)test:(id)T {
|
|
}
|
|
- (void)mapUsingBlock:(id (^)(id))block {
|
|
}
|
|
@end
|
|
|
|
@interface NSDefaultGeneric<ObjectType : NSString *> : NSObject
|
|
@property (copy) ObjectType object;
|
|
@property (copy) __kindof ObjectType kindof_object;
|
|
@end
|
|
|
|
void testGeneric(NSGeneric<NSString*> *generic) {
|
|
NSObject *NSObject_obj;
|
|
// Assign from NSObject_obj to __kindof NSString*.
|
|
[generic test:NSObject_obj]; // expected-warning{{incompatible pointer types sending 'NSObject *' to parameter of type '__kindof NSString *'}}
|
|
NSString *NSString_str;
|
|
[generic test:NSString_str];
|
|
}
|
|
|
|
void testGenericAssignment(void) {
|
|
NSMutableString *NSMutableString_str;
|
|
NSNumber *NSNumber_obj;
|
|
|
|
NSGeneric<NSString*> *generic;
|
|
NSMutableString_str = generic.object; // expected-warning{{incompatible pointer types}}
|
|
NSNumber_obj = generic.object; // expected-warning{{incompatible pointer types}}
|
|
NSMutableString_str = generic.kindof_object;
|
|
NSNumber_obj = generic.kindof_object; // expected-warning{{incompatible pointer types assigning to 'NSNumber *' from '__kindof NSString *'}}
|
|
|
|
NSGeneric<__kindof NSString*> *kindof_generic;
|
|
NSMutableString_str = kindof_generic.object;
|
|
NSNumber_obj = kindof_generic.object; // expected-warning{{incompatible pointer types assigning to 'NSNumber *' from '__kindof NSString *'}}
|
|
NSMutableString_str = kindof_generic.kindof_object;
|
|
NSNumber_obj = kindof_generic.kindof_object; // expected-warning{{incompatible pointer types assigning to 'NSNumber *' from '__kindof __kindof NSString *'}}
|
|
|
|
NSDefaultGeneric *default_generic;
|
|
NSMutableString_str = default_generic.object;
|
|
NSNumber_obj = default_generic.object; // expected-warning{{incompatible pointer types}}
|
|
NSMutableString_str = default_generic.kindof_object;
|
|
NSNumber_obj = default_generic.kindof_object; // expected-warning{{incompatible pointer types assigning to 'NSNumber *' from '__kindof __kindof NSString *'}}
|
|
|
|
typedef NSString *Typedef_NSString;
|
|
NSGeneric<Typedef_NSString> *typedef_generic;
|
|
NSMutableString_str = typedef_generic.object; // expected-warning{{incompatible pointer types}}
|
|
NSNumber_obj = typedef_generic.object; // expected-warning{{incompatible pointer types}}
|
|
NSMutableString_str = typedef_generic.kindof_object;
|
|
NSNumber_obj = typedef_generic.kindof_object; // expected-warning{{incompatible pointer types assigning to 'NSNumber *' from '__kindof Typedef_NSString'}}
|
|
}
|
|
|
|
void testKindofNonObjectType(void) {
|
|
typedef void (^BlockType)(int);
|
|
NSGeneric<BlockType> *generic;
|
|
}
|
|
|
|
void testKindofNullability(NSGeneric<NSString*> *generic) {
|
|
generic.nonnull_kindof_object = 0; // expected-warning{{null passed to a callee that requires a non-null argument}}
|
|
}
|
|
|
|
// Check that clang doesn't crash when a type parameter is illegal.
|
|
@interface Array1<T> : NSObject
|
|
@end
|
|
|
|
@interface I1 : NSObject
|
|
@end
|
|
|
|
@interface Array1<__kindof I1*>(extensions1) // expected-error{{expected type parameter name}}
|
|
@end
|
|
|
|
@interface Array2<T1, T2, T3> : NSObject
|
|
@end
|
|
|
|
@interface Array2<T, T, __kindof I1*>(extensions2) // expected-error{{expected type parameter name}} expected-error{{redeclaration of type parameter 'T'}}
|
|
@end
|