From Jason Turner

[dcl.attr.annotation]

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpgzfs3g7v/{from.md → to.md} +353 -0
tmp/tmpgzfs3g7v/{from.md → to.md} RENAMED
@@ -0,0 +1,353 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ ### Annotations <a id="dcl.attr.annotation">[[dcl.attr.annotation]]</a>
2
+
3
+ An annotation may be applied to any declaration of a type, type alias,
4
+ variable, function, namespace, enumerator, *base-specifier*, or
5
+ non-static data member.
6
+
7
+ Let E be the expression
8
+ `std::meta::reflect_constant(constant-expression)`. E shall be a
9
+ constant expression; the result of E is the *underlying constant* of the
10
+ annotation.
11
+
12
+ Each *annotation* produces a unique annotation.
13
+
14
+ Substituting into an *annotation* is not in the immediate context.
15
+
16
+ [*Example 1*:
17
+
18
+ ``` cpp
19
+ [[=1]] void f();
20
+ [[=2, =3, =2]] void g();
21
+ void g [[=4, =2]] ();
22
+ ```
23
+
24
+ `f` has one annotation and `g` has five annotations. These can be
25
+ queried with metafunctions such as `std::{}meta::{}annotations_of`
26
+ [[meta.reflection.annotation]].
27
+
28
+ — *end example*]
29
+
30
+ [*Example 2*:
31
+
32
+ ``` cpp
33
+ template<class T>
34
+ [[=T::type()]] void f(T t);
35
+
36
+ void f(int);
37
+
38
+ void g() {
39
+ f(0); // OK
40
+ f('0'); // error, substituting into the annotation results in an invalid expression
41
+ }
42
+ ```
43
+
44
+ — *end example*]
45
+
46
+ <!-- Link reference definitions -->
47
+ [basic.align]: basic.md#basic.align
48
+ [basic.compound]: basic.md#basic.compound
49
+ [basic.contract.general]: basic.md#basic.contract.general
50
+ [basic.def]: basic.md#basic.def
51
+ [basic.def.odr]: basic.md#basic.def.odr
52
+ [basic.fundamental]: basic.md#basic.fundamental
53
+ [basic.indet]: basic.md#basic.indet
54
+ [basic.life]: basic.md#basic.life
55
+ [basic.link]: basic.md#basic.link
56
+ [basic.lookup]: basic.md#basic.lookup
57
+ [basic.lookup.argdep]: basic.md#basic.lookup.argdep
58
+ [basic.lookup.elab]: basic.md#basic.lookup.elab
59
+ [basic.lookup.general]: basic.md#basic.lookup.general
60
+ [basic.lookup.qual]: basic.md#basic.lookup.qual
61
+ [basic.lookup.udir]: basic.md#basic.lookup.udir
62
+ [basic.lookup.unqual]: basic.md#basic.lookup.unqual
63
+ [basic.lval]: expr.md#basic.lval
64
+ [basic.namespace]: #basic.namespace
65
+ [basic.namespace.general]: #basic.namespace.general
66
+ [basic.pre]: basic.md#basic.pre
67
+ [basic.scope.namespace]: basic.md#basic.scope.namespace
68
+ [basic.scope.scope]: basic.md#basic.scope.scope
69
+ [basic.start]: basic.md#basic.start
70
+ [basic.start.dynamic]: basic.md#basic.start.dynamic
71
+ [basic.start.static]: basic.md#basic.start.static
72
+ [basic.stc]: basic.md#basic.stc
73
+ [basic.stc.auto]: basic.md#basic.stc.auto
74
+ [basic.stc.dynamic]: basic.md#basic.stc.dynamic
75
+ [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
76
+ [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
77
+ [basic.stc.static]: basic.md#basic.stc.static
78
+ [basic.stc.thread]: basic.md#basic.stc.thread
79
+ [basic.type.qualifier]: basic.md#basic.type.qualifier
80
+ [class]: class.md#class
81
+ [class.access]: class.md#class.access
82
+ [class.access.base]: class.md#class.access.base
83
+ [class.base.init]: class.md#class.base.init
84
+ [class.bit]: class.md#class.bit
85
+ [class.compare.default]: class.md#class.compare.default
86
+ [class.conv.ctor]: class.md#class.conv.ctor
87
+ [class.conv.fct]: class.md#class.conv.fct
88
+ [class.copy.assign]: class.md#class.copy.assign
89
+ [class.copy.ctor]: class.md#class.copy.ctor
90
+ [class.copy.elision]: class.md#class.copy.elision
91
+ [class.ctor]: class.md#class.ctor
92
+ [class.default.ctor]: class.md#class.default.ctor
93
+ [class.dtor]: class.md#class.dtor
94
+ [class.expl.init]: class.md#class.expl.init
95
+ [class.friend]: class.md#class.friend
96
+ [class.inhctor.init]: class.md#class.inhctor.init
97
+ [class.init]: class.md#class.init
98
+ [class.mem]: class.md#class.mem
99
+ [class.mem.general]: class.md#class.mem.general
100
+ [class.member.lookup]: basic.md#class.member.lookup
101
+ [class.mfct]: class.md#class.mfct
102
+ [class.mi]: class.md#class.mi
103
+ [class.name]: class.md#class.name
104
+ [class.pre]: class.md#class.pre
105
+ [class.qual]: basic.md#class.qual
106
+ [class.static]: class.md#class.static
107
+ [class.static.data]: class.md#class.static.data
108
+ [class.temporary]: basic.md#class.temporary
109
+ [class.union]: class.md#class.union
110
+ [class.union.anon]: class.md#class.union.anon
111
+ [class.virtual]: class.md#class.virtual
112
+ [conv]: expr.md#conv
113
+ [conv.array]: expr.md#conv.array
114
+ [conv.func]: expr.md#conv.func
115
+ [conv.general]: expr.md#conv.general
116
+ [conv.integral]: expr.md#conv.integral
117
+ [conv.lval]: expr.md#conv.lval
118
+ [conv.prom]: expr.md#conv.prom
119
+ [conv.ptr]: expr.md#conv.ptr
120
+ [conv.qual]: expr.md#conv.qual
121
+ [conv.rval]: expr.md#conv.rval
122
+ [coroutine.handle]: support.md#coroutine.handle
123
+ [coroutine.handle.resumption]: support.md#coroutine.handle.resumption
124
+ [csetjmp.syn]: support.md#csetjmp.syn
125
+ [dcl]: #dcl
126
+ [dcl.align]: #dcl.align
127
+ [dcl.ambig.res]: #dcl.ambig.res
128
+ [dcl.array]: #dcl.array
129
+ [dcl.asm]: #dcl.asm
130
+ [dcl.attr]: #dcl.attr
131
+ [dcl.attr.annotation]: #dcl.attr.annotation
132
+ [dcl.attr.assume]: #dcl.attr.assume
133
+ [dcl.attr.deprecated]: #dcl.attr.deprecated
134
+ [dcl.attr.fallthrough]: #dcl.attr.fallthrough
135
+ [dcl.attr.grammar]: #dcl.attr.grammar
136
+ [dcl.attr.indet]: #dcl.attr.indet
137
+ [dcl.attr.likelihood]: #dcl.attr.likelihood
138
+ [dcl.attr.nodiscard]: #dcl.attr.nodiscard
139
+ [dcl.attr.noreturn]: #dcl.attr.noreturn
140
+ [dcl.attr.nouniqueaddr]: #dcl.attr.nouniqueaddr
141
+ [dcl.attr.unused]: #dcl.attr.unused
142
+ [dcl.constexpr]: #dcl.constexpr
143
+ [dcl.constinit]: #dcl.constinit
144
+ [dcl.contract]: #dcl.contract
145
+ [dcl.contract.func]: #dcl.contract.func
146
+ [dcl.contract.res]: #dcl.contract.res
147
+ [dcl.decl]: #dcl.decl
148
+ [dcl.decl.general]: #dcl.decl.general
149
+ [dcl.enum]: #dcl.enum
150
+ [dcl.fct]: #dcl.fct
151
+ [dcl.fct.def]: #dcl.fct.def
152
+ [dcl.fct.def.coroutine]: #dcl.fct.def.coroutine
153
+ [dcl.fct.def.default]: #dcl.fct.def.default
154
+ [dcl.fct.def.delete]: #dcl.fct.def.delete
155
+ [dcl.fct.def.general]: #dcl.fct.def.general
156
+ [dcl.fct.def.replace]: #dcl.fct.def.replace
157
+ [dcl.fct.default]: #dcl.fct.default
158
+ [dcl.fct.spec]: #dcl.fct.spec
159
+ [dcl.friend]: #dcl.friend
160
+ [dcl.init]: #dcl.init
161
+ [dcl.init.aggr]: #dcl.init.aggr
162
+ [dcl.init.general]: #dcl.init.general
163
+ [dcl.init.list]: #dcl.init.list
164
+ [dcl.init.ref]: #dcl.init.ref
165
+ [dcl.init.string]: #dcl.init.string
166
+ [dcl.inline]: #dcl.inline
167
+ [dcl.link]: #dcl.link
168
+ [dcl.meaning]: #dcl.meaning
169
+ [dcl.meaning.general]: #dcl.meaning.general
170
+ [dcl.mptr]: #dcl.mptr
171
+ [dcl.name]: #dcl.name
172
+ [dcl.pre]: #dcl.pre
173
+ [dcl.ptr]: #dcl.ptr
174
+ [dcl.ref]: #dcl.ref
175
+ [dcl.spec]: #dcl.spec
176
+ [dcl.spec.auto]: #dcl.spec.auto
177
+ [dcl.spec.auto.general]: #dcl.spec.auto.general
178
+ [dcl.spec.general]: #dcl.spec.general
179
+ [dcl.stc]: #dcl.stc
180
+ [dcl.struct.bind]: #dcl.struct.bind
181
+ [dcl.type]: #dcl.type
182
+ [dcl.type.auto.deduct]: #dcl.type.auto.deduct
183
+ [dcl.type.class.deduct]: #dcl.type.class.deduct
184
+ [dcl.type.cv]: #dcl.type.cv
185
+ [dcl.type.decltype]: #dcl.type.decltype
186
+ [dcl.type.elab]: #dcl.type.elab
187
+ [dcl.type.general]: #dcl.type.general
188
+ [dcl.type.pack.index]: #dcl.type.pack.index
189
+ [dcl.type.simple]: #dcl.type.simple
190
+ [dcl.type.splice]: #dcl.type.splice
191
+ [dcl.typedef]: #dcl.typedef
192
+ [depr.ellipsis.comma]: future.md#depr.ellipsis.comma
193
+ [depr.volatile.type]: future.md#depr.volatile.type
194
+ [enum]: #enum
195
+ [enum.udecl]: #enum.udecl
196
+ [except.ctor]: except.md#except.ctor
197
+ [except.handle]: except.md#except.handle
198
+ [except.pre]: except.md#except.pre
199
+ [except.spec]: except.md#except.spec
200
+ [except.throw]: except.md#except.throw
201
+ [expr.alignof]: expr.md#expr.alignof
202
+ [expr.assign]: expr.md#expr.assign
203
+ [expr.await]: expr.md#expr.await
204
+ [expr.call]: expr.md#expr.call
205
+ [expr.cast]: expr.md#expr.cast
206
+ [expr.comma]: expr.md#expr.comma
207
+ [expr.const]: expr.md#expr.const
208
+ [expr.const.cast]: expr.md#expr.const.cast
209
+ [expr.mptr.oper]: expr.md#expr.mptr.oper
210
+ [expr.new]: expr.md#expr.new
211
+ [expr.post.incr]: expr.md#expr.post.incr
212
+ [expr.pre.incr]: expr.md#expr.pre.incr
213
+ [expr.prim.id]: expr.md#expr.prim.id
214
+ [expr.prim.id.unqual]: expr.md#expr.prim.id.unqual
215
+ [expr.prim.lambda]: expr.md#expr.prim.lambda
216
+ [expr.prim.lambda.closure]: expr.md#expr.prim.lambda.closure
217
+ [expr.prim.this]: expr.md#expr.prim.this
218
+ [expr.prop]: expr.md#expr.prop
219
+ [expr.ref]: expr.md#expr.ref
220
+ [expr.reflect]: expr.md#expr.reflect
221
+ [expr.static.cast]: expr.md#expr.static.cast
222
+ [expr.sub]: expr.md#expr.sub
223
+ [expr.throw]: expr.md#expr.throw
224
+ [expr.type.conv]: expr.md#expr.type.conv
225
+ [expr.unary]: expr.md#expr.unary
226
+ [expr.unary.op]: expr.md#expr.unary.op
227
+ [expr.yield]: expr.md#expr.yield
228
+ [initializer.list.syn]: support.md#initializer.list.syn
229
+ [intro.abstract]: intro.md#intro.abstract
230
+ [intro.execution]: basic.md#intro.execution
231
+ [intro.object]: basic.md#intro.object
232
+ [intro.races]: basic.md#intro.races
233
+ [lex.charset]: lex.md#lex.charset
234
+ [lex.digraph]: lex.md#lex.digraph
235
+ [lex.key]: lex.md#lex.key
236
+ [lex.name]: lex.md#lex.name
237
+ [lex.phases]: lex.md#lex.phases
238
+ [lex.string]: lex.md#lex.string
239
+ [lex.string.uneval]: lex.md#lex.string.uneval
240
+ [meta.reflection.annotation]: meta.md#meta.reflection.annotation
241
+ [module.interface]: module.md#module.interface
242
+ [module.reach]: module.md#module.reach
243
+ [module.unit]: module.md#module.unit
244
+ [namespace.alias]: #namespace.alias
245
+ [namespace.def]: #namespace.def
246
+ [namespace.def.general]: #namespace.def.general
247
+ [namespace.qual]: basic.md#namespace.qual
248
+ [namespace.udecl]: #namespace.udecl
249
+ [namespace.udir]: #namespace.udir
250
+ [namespace.unnamed]: #namespace.unnamed
251
+ [over]: over.md#over
252
+ [over.binary]: over.md#over.binary
253
+ [over.literal]: over.md#over.literal
254
+ [over.match]: over.md#over.match
255
+ [over.match.best]: over.md#over.match.best
256
+ [over.match.class.deduct]: over.md#over.match.class.deduct
257
+ [over.match.conv]: over.md#over.match.conv
258
+ [over.match.copy]: over.md#over.match.copy
259
+ [over.match.ctor]: over.md#over.match.ctor
260
+ [over.match.funcs]: over.md#over.match.funcs
261
+ [over.match.list]: over.md#over.match.list
262
+ [over.match.ref]: over.md#over.match.ref
263
+ [over.match.viable]: over.md#over.match.viable
264
+ [over.oper]: over.md#over.oper
265
+ [over.sub]: over.md#over.sub
266
+ [special]: class.md#special
267
+ [std.modules]: library.md#std.modules
268
+ [stmt]: stmt.md#stmt
269
+ [stmt.ambig]: stmt.md#stmt.ambig
270
+ [stmt.dcl]: stmt.md#stmt.dcl
271
+ [stmt.expr]: stmt.md#stmt.expr
272
+ [stmt.if]: stmt.md#stmt.if
273
+ [stmt.iter]: stmt.md#stmt.iter
274
+ [stmt.label]: stmt.md#stmt.label
275
+ [stmt.pre]: stmt.md#stmt.pre
276
+ [stmt.return]: stmt.md#stmt.return
277
+ [stmt.return.coroutine]: stmt.md#stmt.return.coroutine
278
+ [stmt.select]: stmt.md#stmt.select
279
+ [stmt.switch]: stmt.md#stmt.switch
280
+ [support.runtime]: support.md#support.runtime
281
+ [temp.arg.nontype]: temp.md#temp.arg.nontype
282
+ [temp.arg.type]: temp.md#temp.arg.type
283
+ [temp.decls]: temp.md#temp.decls
284
+ [temp.deduct]: temp.md#temp.deduct
285
+ [temp.deduct.call]: temp.md#temp.deduct.call
286
+ [temp.deduct.decl]: temp.md#temp.deduct.decl
287
+ [temp.deduct.guide]: temp.md#temp.deduct.guide
288
+ [temp.dep.type]: temp.md#temp.dep.type
289
+ [temp.expl.spec]: temp.md#temp.expl.spec
290
+ [temp.explicit]: temp.md#temp.explicit
291
+ [temp.fct]: temp.md#temp.fct
292
+ [temp.inst]: temp.md#temp.inst
293
+ [temp.local]: temp.md#temp.local
294
+ [temp.names]: temp.md#temp.names
295
+ [temp.param]: temp.md#temp.param
296
+ [temp.pre]: temp.md#temp.pre
297
+ [temp.res]: temp.md#temp.res
298
+ [temp.res.general]: temp.md#temp.res.general
299
+ [temp.spec.general]: temp.md#temp.spec.general
300
+ [temp.spec.partial]: temp.md#temp.spec.partial
301
+ [temp.variadic]: temp.md#temp.variadic
302
+ [term.odr.use]: basic.md#term.odr.use
303
+ [term.padding.bits]: basic.md#term.padding.bits
304
+ [term.scalar.type]: basic.md#term.scalar.type
305
+ [term.unevaluated.operand]: expr.md#term.unevaluated.operand
306
+
307
+ [^1]: There is no special provision for a *decl-specifier-seq* that
308
+ lacks a *type-specifier* or that has a *type-specifier* that only
309
+ specifies *cv-qualifier*s. The “implicit int” rule of C is no longer
310
+ supported.
311
+
312
+ [^2]: As indicated by syntax, cv-qualifiers are a significant component
313
+ in function return types.
314
+
315
+ [^3]: One can explicitly disambiguate the parse either by introducing a
316
+ comma (so the ellipsis will be parsed as part of the
317
+ *parameter-declaration-clause*) or by introducing a name for the
318
+ parameter (so the ellipsis will be parsed as part of the
319
+ *declarator-id*).
320
+
321
+ [^4]: This means that default arguments cannot appear, for example, in
322
+ declarations of pointers to functions, references to functions, or
323
+ `typedef` declarations.
324
+
325
+ [^5]: As specified in  [[conv.ptr]], converting an integer literal whose
326
+ value is `0` to a pointer type results in a null pointer value.
327
+
328
+ [^6]: The syntax provides for empty *braced-init-list*s, but nonetheless
329
+ C++ does not have zero length arrays.
330
+
331
+ [^7]: This requires a conversion function [[class.conv.fct]] returning a
332
+ reference type.
333
+
334
+ [^8]: Implementations are permitted to provide additional predefined
335
+ variables with names that are reserved to the implementation
336
+ [[lex.name]]. If a predefined variable is not odr-used
337
+ [[term.odr.use]], its string value need not be present in the
338
+ program image.
339
+
340
+ [^9]: This set of values is used to define promotion and conversion
341
+ semantics for the enumeration type. It does not preclude an
342
+ expression of enumeration type from having a value that falls
343
+ outside this range.
344
+
345
+ [^10]: During name lookup in a class hierarchy, some ambiguities can be
346
+ resolved by considering whether one member hides the other along
347
+ some paths [[class.member.lookup]]. There is no such
348
+ disambiguation when considering the set of names found as a result
349
+ of following \*using-directive\*s.
350
+
351
+ [^11]: A *using-declaration* with more than one *using-declarator* is
352
+ equivalent to a corresponding sequence of *using-declaration*s with
353
+ one *using-declarator* each.