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
|
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: clang-17
// <utility>
// LWG-3382 NTTP for pair and array:
// pair<T, U> is a structural type ([temp.param]) if T and U are both structural types.
#include <utility>
#include <functional>
#include <string>
struct LiteralBase {};
struct LiteralNSDM {};
struct LiteralType : LiteralBase {
LiteralNSDM nsdm;
};
struct NotALiteral {
NotALiteral() {}
};
int i;
NotALiteral not_a_literal;
namespace test_full_type {
template <class T, class U, std::pair<T, U> P>
struct test {};
using A = test<int, int, std::pair{0, 1}>;
using B = test<int&, int&, std::make_pair(std::ref(i), std::ref(i))>;
using C = test<const int&, const int&, std::make_pair(std::cref(i), std::cref(i))>;
using D = test<LiteralType, LiteralType, std::pair<LiteralType, LiteralType>{}>;
using E = test<int*, int*, std::pair<int*, int*>{&i, &i}>;
using F = test<NotALiteral&, NotALiteral&, std::make_pair(std::ref(not_a_literal), std::ref(not_a_literal))>;
using G = test<int&&, int&&, std::pair<int&&, int&&>{std::move(i), std::move(i)}>;
// expected-error@*:* {{type 'std::pair<int &&, int &&>' of non-type template parameter is not a structural type}}
using H = test<NotALiteral, NotALiteral, std::pair<NotALiteral, NotALiteral>{}>;
// expected-error@*:* {{non-type template parameter has non-literal type 'std::pair<NotALiteral, NotALiteral>'}}
using I = test<std::string, std::string, std::pair<std::string, std::string>{}>;
// expected-error-re@*:* {{type 'std::pair<{{(std::)?}}string, {{(std::)?}}string>' {{(\(aka 'pair<basic_string<char>, basic_string<char>>'\) )?}}of non-type template parameter is not a structural type}}
} // namespace test_full_type
namespace test_ctad {
template <std::pair P>
struct test {};
using A = test<std::pair{2, 3}>;
using B = test<std::make_pair(std::ref(i), std::ref(i))>;
using C = test<std::make_pair(std::cref(i), std::cref(i))>;
using D = test<std::pair<LiteralType, LiteralType>{}>;
using E = test<std::pair<int*, int*>{&i, &i}>;
using F = test<std::make_pair(std::ref(not_a_literal), std::ref(not_a_literal))>;
using G = test<std::pair<int&&, int&&>{std::move(i), std::move(i)}>;
// expected-error@-1 {{type 'std::pair<int &&, int &&>' of non-type template parameter is not a structural type}}
using H = test<std::pair<NotALiteral, NotALiteral>{}>;
// expected-error@-1 {{non-type template parameter has non-literal type 'std::pair<NotALiteral, NotALiteral>'}}
using I = test<std::pair<std::string, std::string>{}>;
// expected-error@-1 {{type 'std::pair<string, string>' (aka 'std::pair<std::string, std::string>') of non-type template parameter is not a structural type}}
} // namespace test_ctad
namespace test_auto {
template <auto P>
struct test {};
using A = test<std::pair{4, 5}>;
using B = test<std::make_pair(std::ref(i), std::ref(i))>;
using C = test<std::make_pair(std::cref(i), std::cref(i))>;
using D = test<std::pair<LiteralType, LiteralType>{}>;
using E = test<std::pair<int*, int*>{&i, &i}>;
using F = test<std::make_pair(std::ref(not_a_literal), std::ref(not_a_literal))>;
using G = test<std::pair<int&&, int&&>{std::move(i), std::move(i)}>;
// expected-error@-1 {{type 'std::pair<int &&, int &&>' of non-type template parameter is not a structural type}}
using H = test<std::pair<NotALiteral, NotALiteral>{}>;
// expected-error@-1 {{non-type template parameter has non-literal type 'std::pair<NotALiteral, NotALiteral>'}}
using I = test<std::pair<std::string, std::string>{}>;
// expected-error@-1 {{type 'std::pair<std::string, std::string>' (aka 'pair<basic_string<char>, basic_string<char>>') of non-type template parameter is not a structural type}}
} // namespace test_auto
|
