reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

    1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98

// RUN: %clang_cc1 -Wreturn-type -fsyntax-only -std=c++11 -verify %s

class A {
public:
  A(const A&);
};

struct S {
  int i;
  double d;

  virtual void B() {}
};

union U {
  struct {
    int i;
    virtual void B() {} // Can only do this in C++11
  } t;
};

struct S2 {
  int i;
  double d;
};

extern "C" U f3( void ); // expected-warning {{'f3' has C-linkage specified, but returns user-defined type 'U' which is incompatible with C}}
extern "C" S f0(void); // expected-warning {{'f0' has C-linkage specified, but returns user-defined type 'S' which is incompatible with C}}
extern "C" A f4( void ); // expected-warning {{'f4' has C-linkage specified, but returns user-defined type 'A' which is incompatible with C}}

// These should all be fine
extern "C" S2 f5( void );
extern "C" void f2( A x );
extern "C" void f6( S s );
extern "C" void f7( U u );
extern "C" double f8(void);
extern "C" long long f11( void );
extern "C" A *f10( void );

extern "C" struct mypodstruct f12(); // expected-warning {{'f12' has C-linkage specified, but returns incomplete type 'struct mypodstruct' which could be incompatible with C}}

namespace test2 {
  // FIXME: we should probably suppress the first warning as the second one
  // is more precise.
  // For now this tests that a second 'extern "C"' is not necessary to trigger
  // the warning.
  struct A;
  extern "C" A f(void); // expected-warning {{'f' has C-linkage specified, but returns incomplete type 'test2::A' which could be incompatible with C}}
  struct A {
    A(const A&);
  };
  A f(void);  // no warning. warning is already issued on first declaration.
}

namespace test3 {
  struct A {
    A(const A&);
  };
  extern "C" {
    // Don't warn for static functions.
    static A f(void);
  }
}

// rdar://13364028
namespace rdar13364028 {
class A {
public:
    virtual int x();
};

extern "C" {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
A xyzzy();
#pragma clang diagnostic pop
A bbb(); // expected-warning {{'bbb' has C-linkage specified, but returns user-defined type 'rdar13364028::A' which is incompatible with C}}
A ccc() { // expected-warning {{'ccc' has C-linkage specified, but returns user-defined type 'rdar13364028::A' which is incompatible with C}}
  return A();
};
}

A xyzzy();

A xyzzy()
{
  return A();
}

A bbb()
{
  return A();
}

A bbb();

A ccc();
}