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

// RUN: %clang_cc1 -fsyntax-only -verify %s 
typedef int INT;
typedef INT REALLY_INT; // expected-note {{previous definition is here}}
typedef REALLY_INT REALLY_REALLY_INT;
typedef REALLY_INT BOB;
typedef float REALLY_INT; // expected-error{{typedef redefinition with different types ('float' vs 'INT' (aka 'int'))}}

struct X {
  typedef int result_type; // expected-note {{previous definition is here}}
  typedef INT result_type; // expected-error {{redefinition of 'result_type'}}
};

struct Y; // expected-note{{previous definition is here}}
typedef int Y;  // expected-error{{typedef redefinition with different types ('int' vs 'Y')}}

typedef int Y2; // expected-note{{declared here}}
struct Y2; // expected-error{{definition of type 'Y2' conflicts with typedef of the same name}}

void f(); // expected-note{{previous definition is here}}
typedef int f; // expected-error{{redefinition of 'f' as different kind of symbol}}

typedef int f2; // expected-note{{previous definition is here}}
void f2(); // expected-error{{redefinition of 'f2' as different kind of symbol}}

typedef struct s s; 
typedef int I; 
typedef int I; 
typedef I I; 

struct s { };

// PR5874
namespace test1 {
  typedef int foo;
  namespace a { using test1::foo; };
  typedef int foo;
  using namespace a; 
  foo x;
}

namespace PR6923 {
  struct A;

  extern "C" {
    struct A;
    typedef struct A A;
  }

  struct A;
}

namespace PR7462 {
  struct A {};
  typedef int operator! (A); // expected-error{{typedef name must be an identifier}}
  int i = !A(); // expected-error{{invalid argument type}}
}

template<typename T>
typedef T f(T t) { return t; } // expected-error {{function definition declared 'typedef'}}
int k = f(0);
int k2 = k;

namespace PR11630 {
  template <class T>
  struct S
  {
    static const unsigned C = 1;
    static void f()
    {
      typedef int q[C == 1 ? 1 : -1]; // expected-note{{previous definition is here}}
      typedef int q[C >= 1 ? 2 : -2]; // expected-error{{typedef redefinition with different types ('int [2]' vs 'int [1]')}}
      typedef int n[C == 1 ? 1 : -1];
      typedef int n[C >= 1 ? 1 : -1];
    }
  };

  template <int T>
  struct S2
  {
    static void f()
    {
      typedef int q[1];  // expected-note{{previous definition is here}}
      typedef int q[T];  // expected-error{{typedef redefinition with different types ('int [2]' vs 'int [1]')}}
    }
  };

  void f() {
    S<int> a;
    a.f(); // expected-note{{in instantiation of member function 'PR11630::S<int>::f' requested here}}
    S2<1> b;
    b.f();
    S2<2> b2;
    b2.f(); // expected-note{{in instantiation of member function 'PR11630::S2<2>::f' requested here}}
  }
}