/* Check for finding the prototype
   when there is exactly one available. */
/* Contributed by David Ayers <d.ayers@inode.at>  */
/* { dg-do compile } */

#include <objc/Object.h>

struct _MyStruct
{
  unsigned long a;
  unsigned long b;
  unsigned long c;
};
typedef struct _MyStruct MyStruct;

/* Class declares method directly.  */
@interface Class1
+ (Class1 *)class1;
- (MyStruct)getStruct1;
@end

void foo1(void)
{
  MyStruct strct;
  Class1  *varClass1;
  id       varId;

  strct = [[Class1 class1] getStruct1];
  strct = [Class1 getStruct1];

  varClass1 = [Class1 class1];
  strct = [varClass1 getStruct1];

  varId = [Class1 class1];
  strct = [(Class1 *)varId getStruct1];
}

/* Superclass declares method.  */
@interface Class2 : Class1
+ (Class2 *)class2;
- (MyStruct)getStruct2;
@end

void foo2(void)
{
  MyStruct strct;
  Class2  *varClass2;
  id       varId;

  strct = [[Class2 class2] getStruct1];
  strct = [Class2 getStruct1];
  strct = [[Class2 class2] getStruct2];
  strct = [Class2 getStruct2]; /* { dg-warning "receiver of type .Class2. may not respond to .\\+getStruct2." } */
  /* { dg-warning "no prototype found for .\\+getStruct2." "" { target *-*-* } 53 } */
  /* { dg-warning "\\(Messages without a matching method prototype" "" { target *-*-* } 53 } */
  /* { dg-warning "will be assumed to return .id. and accept" "" { target *-*-* } 53 } */
  /* { dg-warning ".\\.\\.\\.. as arguments\\.\\)" "" { target *-*-* } 53 } */
  /* { dg-error "incompatible types in assignment" "" { target *-*-* } 53 } */

  varClass2 = [Class2 class2];
  strct = [varClass2 getStruct1];
  strct = [varClass2 getStruct2];

  varId = [Class2 class2];
  strct = [(Class2 *)varId getStruct1];
  strct = [(Class2 *)varId getStruct2];
}

/* Protocol declares method.  */
@protocol Proto1
- (MyStruct)getStruct3;
@end

@interface Class0
@end

@interface Class3 <Proto1>
+ (Class3 *)class3;
+ (id<Proto1>)class3Proto1id;
+ (Class3<Proto1> *)class3Proto1Class3;
+ (Class0<Proto1> *)class3Proto1Class0;
@end

void foo3(void)
{
  MyStruct strct;
  Class3          *varClass3;
  id <Proto1>      varProto1;
  Class3 <Proto1> *varClass3Proto1;
  Class0 <Proto1> *varClass0Proto1;
  id               varId;

  strct = [[Class3 class3] getStruct3];
  strct = [Class3 getStruct3];

  strct = [[Class3 class3Proto1id] getStruct3];
  strct = [[Class3 class3Proto1Class3] getStruct3];

  varClass3 = [Class3 class3];
  strct = [varClass3 getStruct3];
  varProto1 = [Class3 class3Proto1id];
  strct = [varProto1 getStruct3];
  varClass3Proto1 = [Class3 class3Proto1Class3];
  strct = [varClass3Proto1 getStruct3];
  varClass0Proto1 = [Class3 class3Proto1Class0];
  strct = [varClass0Proto1 getStruct3];

  varId = [Class3 class3];
  strct = [(Class3 *)varId getStruct3];
  strct = [(id <Proto1>)varId getStruct3];
  strct = [(Class3 <Proto1> *)varId getStruct3];
  strct = [(Class0 <Proto1> *)varId getStruct3];
}

/* Protocol from Inherited class declares method.  */

@protocol Proto2
- (MyStruct)getStruct4;
@end

@interface Class4 : Class3 <Proto2>
+ (Class4 *)class4;
+ (id<Proto1>)class4Proto1id;
+ (id<Proto2>)class4Proto2id;
+ (Class4<Proto1> *)class4Proto1Class4;
+ (Class4<Proto2> *)class4Proto2Class4;
@end

void foo4(void)
{
  MyStruct strct;
  Class4          *varClass4;
  Class4 <Proto1> *varClass4Proto1;
  Class4 <Proto2> *varClass4Proto2;
  id              varId;

  strct = [[Class4 class4] getStruct3];
  strct = [Class4 getStruct3];
  strct = [[Class4 class4] getStruct4];
  strct = [Class4 getStruct4]; /* { dg-warning "receiver of type .Class4. may not respond to .\\+getStruct4." } */
  /* { dg-warning "no prototype found for .\\+getStruct4." "" { target *-*-* } 140 } */
  /* { dg-error "incompatible types in assignment" "" { target *-*-* } 140 } */

  strct = [[Class4 class4Proto1id] getStruct3];
  strct = [[Class4 class4Proto2id] getStruct4];
  strct = [[Class4 class4Proto1Class4] getStruct3];
  strct = [[Class4 class4Proto2Class4] getStruct4];

  varClass4 = [Class4 class4];
  strct = [varClass4 getStruct3];
  strct = [varClass4 getStruct4];

  varClass4Proto1 = [Class4 class4Proto1Class4];
  strct = [varClass4Proto1 getStruct3];
  strct = [varClass4Proto1 getStruct4];

  varClass4Proto2 = [Class4 class4Proto2Class4];
  strct = [varClass4Proto2 getStruct3];
  strct = [varClass4Proto2 getStruct4];

  varId = [Class4 class4];
  strct = [(Class4 *)varId getStruct3];
  strct = [(Class4 *)varId getStruct4];
  strct = [(id <Proto1>)varId getStruct3];
  strct = [(id <Proto1>)varId getStruct4]; /* { dg-warning "receiver of type .id \\<Proto1\\>. may not respond to .\\-getStruct4." } */
  strct = [(id <Proto2>)varId getStruct3]; /* { dg-warning "receiver of type .id \\<Proto2\\>. may not respond to .\\-getStruct3." } */
  strct = [(id <Proto2>)varId getStruct4];
  strct = [(Class4 <Proto1> *)varId getStruct3];
  strct = [(Class4 <Proto1> *)varId getStruct4];
  strct = [(Class4 <Proto2> *)varId getStruct3];
  strct = [(Class4 <Proto2> *)varId getStruct4];
}

/* Category declares method. */

@interface Class5
+ (Class5 *)class5;
@end
@interface Class5 (Category1)
- (MyStruct)getStruct5;
@end

void foo5(void)
{
  MyStruct strct;
  Class5  *varClass5;
  id       varId;

  strct = [[Class5 class5] getStruct5];
  strct = [Class5 getStruct5];

  varClass5 = [Class5 class5];
  strct = [varClass5 getStruct5];

  varId = [Class5 class5];
  strct = [(Class5 *)varId getStruct5];
}  

/* Category is inherited.  */
@interface Class6 : Class5
+ (Class6 *)class6;
@end
@interface Class6 (Category2)
- (MyStruct)getStruct6;
@end

void foo6(void)
{
  MyStruct strct;
  Class6  *varClass6;
  id       varId;

  strct = [[Class6 class6] getStruct5];
  strct = [Class6 getStruct5];
  strct = [[Class6 class6] getStruct6];
  strct = [Class6 getStruct6]; /* { dg-warning "receiver of type .Class6. may not respond to .\\+getStruct6." } */
  /* { dg-warning "no prototype found for .\\+getStruct6." "" { target *-*-* } 216 } */
  /* { dg-error "incompatible types in assignment" "" { target *-*-* } 216 } */

  varClass6 = [Class6 class6];
  strct = [varClass6 getStruct5];
  strct = [varClass6 getStruct6];

  varId = [Class6 class6];
  strct = [(Class6 *)varId getStruct5];
  strct = [(Class6 *)varId getStruct6];
}  

/* Category's protocol declares method. */

@protocol Proto3
- (MyStruct)getStruct7;
@end
@interface Class7
+ (Class7 *)class7;
+ (id<Proto3>)class7Proto3;
+ (Class7<Proto3> *)class7Proto3Class7;
@end
@interface Class7 (Category3) <Proto3>
@end

void foo7(void)
{
  MyStruct        strct;
  Class7         *varClass7;
  id<Proto3>      varProto3;
  Class7<Proto3> *varClass7Proto3;
  id              varId;

  strct = [[Class7 class7] getStruct7];
  strct = [Class7 getStruct7];

  strct = [[Class7 class7] getStruct7];
  strct = [[Class7 class7Proto3] getStruct7];
  strct = [[Class7 class7Proto3Class7] getStruct7];

  varClass7 = [Class7 class7];
  strct = [varClass7 getStruct7];
  varProto3 = [Class7 class7Proto3];
  strct = [varProto3 getStruct7];
  varClass7Proto3 = [Class7 class7Proto3Class7];
  strct = [varClass7Proto3 getStruct7];

  varId = [Class7 class7];
  strct = [(Class7 *)varId getStruct7];
  strct = [(id<Proto3>)varId getStruct7];
  strct = [(Class7<Proto3>*)varId getStruct7];
}  

/* Inherited category's protocol declares method. */

@interface Class8 : Class7
+ (Class8 *)class8;
+ (Class8 <Proto3> *)class8Proto3Class7;
@end

void foo8(void)
{
  MyStruct        strct;
  Class8         *varClass8;
  Class8<Proto3> *varClass8Proto3;
  id              varId;

  strct = [[Class8 class8] getStruct7];
  strct = [Class8 getStruct7];

  strct = [[Class8 class8] getStruct7];
  strct = [[Class8 class8Proto3Class7] getStruct7];

  varClass8 = [Class8 class8];
  strct = [varClass8 getStruct7];
  varClass8Proto3 = [Class8 class8Proto3Class7];
  strct = [varClass8Proto3 getStruct7];

  varId = [Class8 class8];
  strct = [(Class8 *)varId getStruct7];
  strct = [(Class8<Proto3>*)varId getStruct7];
}  

/* Inherited Protocol declares method.  */

@protocol Proto4 <Proto3>
- (MyStruct)getStruct9;
@end

@interface Class9 <Proto4>
+ (Class9 *)class9;
+ (id<Proto4>)class9Proto4id;
+ (Class9<Proto4> *)class9Proto4Class9;
+ (Class0<Proto4> *)class9Proto4Class0;
@end

void foo9(void)
{
  MyStruct strct;
  Class9          *varClass9;
  id <Proto4>      varProto4;
  Class9 <Proto4> *varClass9Proto4;
  Class0 <Proto4> *varClass0Proto4;
  id              varId;

  strct = [[Class9 class9] getStruct7];
  strct = [Class9 getStruct9];

  strct = [[Class9 class9Proto4id] getStruct7];
  strct = [[Class9 class9Proto4Class9] getStruct7];
  strct = [[Class9 class9Proto4Class0] getStruct7];

  varClass9 = [Class9 class9];
  strct = [varClass9 getStruct7];

  varProto4 = [Class9 class9Proto4id];
  strct = [varProto4 getStruct7];

  varClass9Proto4 = [Class9 class9Proto4Class9];
  strct = [varClass9Proto4 getStruct7];

  varClass0Proto4 = [Class9 class9Proto4Class0];
  strct = [varClass0Proto4 getStruct7];

  varId = [Class9 class9];
  strct = [(Class9 *)varId getStruct7];
  strct = [(id <Proto4>)varId getStruct7];
  strct = [(Class9 <Proto4> *)varId getStruct7];
  strct = [(Class0 <Proto4> *)varId getStruct7];
}

/* Implicit local declaraions in class.  */

@interface Class10
@end
@implementation Class10
-(MyStruct)getStruct10
{
  MyStruct strct = { 1UL, 1UL, 1UL };
  return strct;
}
-(void)useInInstance10
{
  MyStruct strct;
  Class10 *varClass10 = self;
  id       varId = self;

  strct = [self getStruct10];
  strct = [varClass10 getStruct10];
  strct = [(Class10 *)varId getStruct10];
}
+(void)useInClass10
{
  MyStruct strct;
  strct = [self getStruct10];
}
@end

/* Implicit local declaraions in category.  */

@implementation Class10 (Category4)
-(MyStruct)getStruct11
{
  MyStruct strct = { 1UL, 1UL, 1UL };
  return strct;
}
-(void)useInInstance11
{
  MyStruct strct;
  Class10 *varClass10 = self;
  id       varId = self;

  strct = [self getStruct11];
  strct = [varClass10 getStruct11];
  strct = [(Class10 *)varId getStruct11];
}
+(void)useInClass11
{
  MyStruct strct;
  strct = [self getStruct11];
}
@end