// RUN: %clang_cc1 %s -std=c++11 -fcxx-exceptions -fexceptions -fsyntax-only -Wignored-qualifiers -verify
// RUN: %clang_cc1 %s -std=c++14 -fcxx-exceptions -fexceptions -fsyntax-only -Wignored-qualifiers -verify

int test1() {
  throw;
}

// PR5071
template<typename T> T f() { }

template<typename T>
void g(T t) {
  return t * 2; // okay
}

template<typename T>
T h() {
  return 17;
}

// Don't warn on cv-qualified class return types, only scalar return types.
namespace ignored_quals {
struct S {};
const S class_c();
const volatile S class_cv();

const int scalar_c(); // expected-warning{{'const' type qualifier on return type has no effect}}
int const scalar_c2(); // expected-warning{{'const' type qualifier on return type has no effect}}

const
char*
const // expected-warning{{'const' type qualifier on return type has no effect}}
f();

char
const*
const // expected-warning{{'const' type qualifier on return type has no effect}}
g();

char* const h(); // expected-warning{{'const' type qualifier on return type has no effect}}
char* volatile i(); // expected-warning{{'volatile' type qualifier on return type has no effect}}

char*
volatile // expected-warning{{'const volatile' type qualifiers on return type have no effect}}
const
j();

const volatile int scalar_cv(); // expected-warning{{'const volatile' type qualifiers on return type have no effect}}

// FIXME: Maintain enough information that we can point the diagnostic at the 'volatile' keyword.
const
int S::*
volatile
mixed_ret(); // expected-warning {{'volatile' type qualifier on return type has no effect}}

const int volatile // expected-warning {{'const volatile' type qualifiers on return type have no effect}}
    (((parens())));

_Atomic(int) atomic();

_Atomic // expected-warning {{'_Atomic' type qualifier on return type has no effect}}
    int
    atomic();

auto trailing_return_type() ->
    const int; // expected-warning {{'const' type qualifier on return type has no effect}}

auto trailing_return_type_lambda = [](const int &x) ->
    const int // expected-warning {{'const' type qualifier on return type has no effect}}
    { return x; };

const int ret_array()[4]; // expected-error {{cannot return array}}
}

namespace PR9328 {
  typedef char *PCHAR;
  class Test
  {
    const PCHAR GetName() { return 0; } // expected-warning{{'const' type qualifier on return type has no effect}}
  };
}

class foo  {
  operator const int ();
  operator int * const ();
};

namespace PR10057 {
  struct S {
    ~S();
  };

  template <class VarType>
  void Test(const VarType& value) {
    return S() = value;
  }
}

namespace return_has_expr {
  struct S {
    S() {
      return 42; // expected-error {{constructor 'S' should not return a value}}
    }
    ~S() {
      return 42; // expected-error {{destructor '~S' should not return a value}}
    }
  };
}

// pr17759
namespace ctor_returns_void {
  void f() {}
  struct S {
    S() { return f(); } // expected-error {{constructor 'S' must not return void expression}}
    ~S() { return f(); } // expected-error {{destructor '~S' must not return void expression}}
  };

  template <typename T> struct ST {
    ST() { return f(); } // expected-error {{constructor 'ST<T>' must not return void expression}}
                         // expected-error@-1 {{constructor 'ST' must not return void expression}}
    ~ST() { return f(); } // expected-error {{destructor '~ST<T>' must not return void expression}}
                          // expected-error@-1 {{destructor '~ST' must not return void expression}}
  };

  ST<int> st; // expected-note {{in instantiation of member function 'ctor_returns_void::ST<int>::ST'}}
              // expected-note@-1 {{in instantiation of member function 'ctor_returns_void::ST<int>::~ST'}}
}

void cxx_unresolved_expr() {
  // The use of an undeclared variable tricks clang into building a
  // CXXUnresolvedConstructExpr, and the missing ')' gives it an invalid source
  // location for its rparen.  Check that emitting a diag on the range of the
  // expr doesn't assert.
  return int(undeclared, 4; // expected-error {{use of undeclared identifier 'undeclared'}}
}

#if __cplusplus >= 201402L
namespace GH43054 {
struct S{};
const auto foo() { return 0; } // expected-warning {{'const' type qualifier on return type has no effect}}
const auto bar() { return S{}; }
template <typename T>
const auto baz() { return T{}; }

void test() {
  baz<int>();
  baz<S>();

  []() -> const auto { // expected-warning {{'const' type qualifier on return type has no effect}}
    return 0;
  }();

  []() -> const auto {
    return S{};
  }();
}
}

#endif
