// RUN: %clang_cc1 -fsyntax-only -verify -Wunused -Wunused-template -Wunused-member-function -Wno-unused-local-typedefs \
// RUN:            -Wno-c++11-extensions -Wno-c++14-extensions -std=c++98 %s
// RUN: %clang_cc1 -fsyntax-only -verify -Wunused -Wunused-template -Wunused-member-function -Wno-unused-local-typedefs -std=c++14 %s

#ifdef HEADER

static void headerstatic() {} // expected-warning{{unused function 'headerstatic'}}
static inline void headerstaticinline() {}

namespace {
void headeranon() {} // expected-warning{{unused function 'headeranon'}}
inline void headerinlineanon() {}
}

namespace test7
{
  template<typename T>
  static inline void foo(T) { }

  // This should not emit an unused-function warning since it inherits
  // the static storage type from the base template.
  template<>
  inline void foo(int) {  }

  // Partial specialization
  template<typename T, typename U>
  static inline void bar(T, U) { }

  template<typename U>
  inline void bar(int, U) { }

  template<>
  inline void bar(int, int) { }
};

namespace pr19713 {
#if __cplusplus >= 201103L
  static constexpr int constexpr1() { return 1; }
  constexpr int constexpr2() { return 2; }
#endif
}

#else
#define HEADER
#include "warn-unused-filescoped.cpp"

static void f1(); // expected-warning{{unused function 'f1'}}

namespace {
void f2(); // expected-warning{{unused function 'f2'}}

void f3() {} // expected-warning{{unused function 'f3'}}

struct S {
  void m1() {} // expected-warning{{unused member function 'm1'}}
  void m2();   // expected-warning{{unused member function 'm2'}}
  void m3();
  S(const S &);
  void operator=(const S &);
};

  template <typename T>
  struct TS {
    void m();
  };
  template <> void TS<int>::m() {} // expected-warning{{unused member function 'm'}}

  template <typename T>
  void tf() {}                  // expected-warning{{unused function template 'tf'}}
  template <> void tf<int>() {} // expected-warning{{unused function 'tf<int>'}}

  struct VS {
    virtual void vm() { }
  };
  
  struct SVS : public VS {
    void vm() { }
  };
}

void S::m3() {} // expected-warning{{unused member function 'm3'}}

static inline void f4() {} // expected-warning{{unused function 'f4'}}
const unsigned int cx = 0; // expected-warning{{unused variable 'cx'}}
const unsigned int cy = 0;
int f5() { return cy; }

static int x1; // expected-warning{{unused variable 'x1'}}

namespace {
int x2; // expected-warning{{unused variable 'x2'}}

struct S2 {
  static int x; // expected-warning{{unused variable 'x'}}
};

  template <typename T>
  struct TS2 {
    static int x;
  };
  template <> int TS2<int>::x; // expected-warning{{unused variable 'x'}}

  template <typename T, typename U> int vt = 0; // expected-warning {{unused variable template 'vt'}}
  template <typename T> int vt<T, void> = 0;
  template <> int vt<void, void> = 0; // expected-warning {{unused variable 'vt<void, void>'}}
}

namespace PR8841 {
  // Ensure that friends of class templates are considered to have a dependent
  // context and not marked unused.
  namespace {
    template <typename T> struct X {
      friend bool operator==(const X&, const X&) { return false; }
    };
  }
  template <typename T> void template_test(X<T> x) {
    (void)(x == x);
  }
  void test() {
    X<int> x;
    template_test(x);
  }
}

namespace test4 {
  namespace { struct A {}; }

  void test(A a); // expected-warning {{unused function 'test'}}
  extern "C" void test4(A a);
}

namespace rdar8733476 {
static void foo() {}                         // expected-warning {{function 'foo' is not needed and will not be emitted}}
template <typename T> static void foo_t() {} // expected-warning {{unused function template 'foo_t'}}
template <> void foo_t<int>() {}             // expected-warning {{function 'foo_t<int>' is not needed and will not be emitted}}

template <int>
void bar() {
  foo();
  foo_t<int>();
  foo_t<void>();
}
}

namespace test5 {
  static int n = 0;
  static int &r = n;
  int f(int &);
  int k = f(r);

  // FIXME: We should produce warnings for both of these.
  static const int m = n;
  int x = sizeof(m);
  static const double d = 0.0; // expected-warning{{variable 'd' is not needed and will not be emitted}}
  int y = sizeof(d);

  namespace {
  // FIXME: Should be "unused variable template 'var_t'" instead.
  template <typename T> const double var_t = 0; // expected-warning {{unused variable 'var_t'}}
  template <> const double var_t<int> = 0;      // expected-warning {{variable 'var_t<int>' is not needed and will not be emitted}}
  int z = sizeof(var_t<int>);                   // expected-warning {{unused variable 'z'}}
  }                                             // namespace
}

namespace unused_nested {
  class outer {
    void func1();
    struct {
      void func2() {
      }
    } x;
  };
}

namespace unused {
  struct {
    void func() { // expected-warning {{unused member function 'func'}}
    }
  } x; // expected-warning {{unused variable 'x'}}
}

namespace test6 {
  typedef struct { // expected-warning {{add a tag name}}
    void bar(); // expected-note {{}}
  } A; // expected-note {{}}

  typedef struct {
    void bar();  // expected-warning {{unused member function 'bar'}}
  } *B;

  struct C {
    void bar();
  };
}

namespace pr14776 {
  namespace {
    struct X {};
  }
  X a = X(); // expected-warning {{unused variable 'a'}}
  auto b = X(); // expected-warning {{unused variable 'b'}}
}

namespace UndefinedInternalStaticMember {
  namespace {
    struct X {
      static const unsigned x = 3;
      int y[x];
    };
  }
}

namespace test8 {
static void func();
void bar() { void func() __attribute__((used)); }
static void func() {}
}

namespace test9 {
template <typename T>
static void completeRedeclChainForTemplateSpecialization() {} // expected-warning {{unused function template 'completeRedeclChainForTemplateSpecialization'}}
}

namespace test10 {
#if __cplusplus >= 201103L
// FIXME: Warn on template definitions with no instantiations?
template<class T>
constexpr T pi = T(3.14);
#endif
}

namespace pr19713 {
#if __cplusplus >= 201103L
  // FIXME: We should warn on both of these.
static constexpr int constexpr3() { return 1; } // expected-warning {{unused function 'constexpr3'}}
constexpr int constexpr4() { return 2; }
#endif
}

#endif