cpptooling.analyzer.clang.ast.declaration source code

1 /**
2 Copyright: Copyright (c) 2016, Joakim Brännström. All rights reserved.
3 License: MPL-2
4 Author: Joakim Brännström (joakim.brannstrom@gmx.com)
5 
6 This Source Code Form is subject to the terms of the Mozilla Public License,
7 v.2.0. If a copy of the MPL was not distributed with this file, You can obtain
8 one at http://mozilla.org/MPL/2.0/.
9 
10 DO NOT EDIT. THIS FILE IS GENERATED.
11 See the generator script source/devtool/generator_clang_ast_nodes.d
12 */
13 module cpptooling.analyzer.clang.ast.declaration;
14 import cpptooling.analyzer.clang.ast.node : Node;
15 
16 abstract class Declaration : Node {
17     import clang.Cursor : Cursor;
18     import cpptooling.analyzer.clang.ast : Visitor;
19 
20     Cursor cursor;
21     alias cursor this;
22 
23     this(Cursor cursor) @safe {
24         this.cursor = cursor;
25     }
26 
27     override void accept(Visitor v) @safe const {
28         static import cpptooling.analyzer.clang.ast;
29         cpptooling.analyzer.clang.ast.accept(cursor, v);
30     }
31 }
32 
33 
34 final class UnexposedDecl : Declaration {
35     import clang.Cursor : Cursor;
36     this(Cursor cursor) @safe {
37         super(cursor);
38     }
39 
40     override void accept(Visitor v) @safe const {
41         static import cpptooling.analyzer.clang.ast;
42         cpptooling.analyzer.clang.ast.accept(cursor, v);
43     }
44 }
45 
46 final class StructDecl : Declaration {
47     import clang.Cursor : Cursor;
48     this(Cursor cursor) @safe {
49         super(cursor);
50     }
51 
52     override void accept(Visitor v) @safe const {
53         static import cpptooling.analyzer.clang.ast;
54         cpptooling.analyzer.clang.ast.accept(cursor, v);
55     }
56 }
57 
58 final class UnionDecl : Declaration {
59     import clang.Cursor : Cursor;
60     this(Cursor cursor) @safe {
61         super(cursor);
62     }
63 
64     override void accept(Visitor v) @safe const {
65         static import cpptooling.analyzer.clang.ast;
66         cpptooling.analyzer.clang.ast.accept(cursor, v);
67     }
68 }
69 
70 final class ClassDecl : Declaration {
71     import clang.Cursor : Cursor;
72     this(Cursor cursor) @safe {
73         super(cursor);
74     }
75 
76     override void accept(Visitor v) @safe const {
77         static import cpptooling.analyzer.clang.ast;
78         cpptooling.analyzer.clang.ast.accept(cursor, v);
79     }
80 }
81 
82 final class EnumDecl : Declaration {
83     import clang.Cursor : Cursor;
84     this(Cursor cursor) @safe {
85         super(cursor);
86     }
87 
88     override void accept(Visitor v) @safe const {
89         static import cpptooling.analyzer.clang.ast;
90         cpptooling.analyzer.clang.ast.accept(cursor, v);
91     }
92 }
93 
94 final class FieldDecl : Declaration {
95     import clang.Cursor : Cursor;
96     this(Cursor cursor) @safe {
97         super(cursor);
98     }
99 
100     override void accept(Visitor v) @safe const {
101         static import cpptooling.analyzer.clang.ast;
102         cpptooling.analyzer.clang.ast.accept(cursor, v);
103     }
104 }
105 
106 final class EnumConstantDecl : Declaration {
107     import clang.Cursor : Cursor;
108     this(Cursor cursor) @safe {
109         super(cursor);
110     }
111 
112     override void accept(Visitor v) @safe const {
113         static import cpptooling.analyzer.clang.ast;
114         cpptooling.analyzer.clang.ast.accept(cursor, v);
115     }
116 }
117 
118 final class FunctionDecl : Declaration {
119     import clang.Cursor : Cursor;
120     this(Cursor cursor) @safe {
121         super(cursor);
122     }
123 
124     override void accept(Visitor v) @safe const {
125         static import cpptooling.analyzer.clang.ast;
126         cpptooling.analyzer.clang.ast.accept(cursor, v);
127     }
128 }
129 
130 final class VarDecl : Declaration {
131     import clang.Cursor : Cursor;
132     this(Cursor cursor) @safe {
133         super(cursor);
134     }
135 
136     override void accept(Visitor v) @safe const {
137         static import cpptooling.analyzer.clang.ast;
138         cpptooling.analyzer.clang.ast.accept(cursor, v);
139     }
140 }
141 
142 final class ParmDecl : Declaration {
143     import clang.Cursor : Cursor;
144     this(Cursor cursor) @safe {
145         super(cursor);
146     }
147 
148     override void accept(Visitor v) @safe const {
149         static import cpptooling.analyzer.clang.ast;
150         cpptooling.analyzer.clang.ast.accept(cursor, v);
151     }
152 }
153 
154 final class ObjCInterfaceDecl : Declaration {
155     import clang.Cursor : Cursor;
156     this(Cursor cursor) @safe {
157         super(cursor);
158     }
159 
160     override void accept(Visitor v) @safe const {
161         static import cpptooling.analyzer.clang.ast;
162         cpptooling.analyzer.clang.ast.accept(cursor, v);
163     }
164 }
165 
166 final class ObjCCategoryDecl : Declaration {
167     import clang.Cursor : Cursor;
168     this(Cursor cursor) @safe {
169         super(cursor);
170     }
171 
172     override void accept(Visitor v) @safe const {
173         static import cpptooling.analyzer.clang.ast;
174         cpptooling.analyzer.clang.ast.accept(cursor, v);
175     }
176 }
177 
178 final class ObjCProtocolDecl : Declaration {
179     import clang.Cursor : Cursor;
180     this(Cursor cursor) @safe {
181         super(cursor);
182     }
183 
184     override void accept(Visitor v) @safe const {
185         static import cpptooling.analyzer.clang.ast;
186         cpptooling.analyzer.clang.ast.accept(cursor, v);
187     }
188 }
189 
190 final class ObjCPropertyDecl : Declaration {
191     import clang.Cursor : Cursor;
192     this(Cursor cursor) @safe {
193         super(cursor);
194     }
195 
196     override void accept(Visitor v) @safe const {
197         static import cpptooling.analyzer.clang.ast;
198         cpptooling.analyzer.clang.ast.accept(cursor, v);
199     }
200 }
201 
202 final class ObjCIvarDecl : Declaration {
203     import clang.Cursor : Cursor;
204     this(Cursor cursor) @safe {
205         super(cursor);
206     }
207 
208     override void accept(Visitor v) @safe const {
209         static import cpptooling.analyzer.clang.ast;
210         cpptooling.analyzer.clang.ast.accept(cursor, v);
211     }
212 }
213 
214 final class ObjCInstanceMethodDecl : Declaration {
215     import clang.Cursor : Cursor;
216     this(Cursor cursor) @safe {
217         super(cursor);
218     }
219 
220     override void accept(Visitor v) @safe const {
221         static import cpptooling.analyzer.clang.ast;
222         cpptooling.analyzer.clang.ast.accept(cursor, v);
223     }
224 }
225 
226 final class ObjCClassMethodDecl : Declaration {
227     import clang.Cursor : Cursor;
228     this(Cursor cursor) @safe {
229         super(cursor);
230     }
231 
232     override void accept(Visitor v) @safe const {
233         static import cpptooling.analyzer.clang.ast;
234         cpptooling.analyzer.clang.ast.accept(cursor, v);
235     }
236 }
237 
238 final class ObjCImplementationDecl : Declaration {
239     import clang.Cursor : Cursor;
240     this(Cursor cursor) @safe {
241         super(cursor);
242     }
243 
244     override void accept(Visitor v) @safe const {
245         static import cpptooling.analyzer.clang.ast;
246         cpptooling.analyzer.clang.ast.accept(cursor, v);
247     }
248 }
249 
250 final class ObjCCategoryImplDecl : Declaration {
251     import clang.Cursor : Cursor;
252     this(Cursor cursor) @safe {
253         super(cursor);
254     }
255 
256     override void accept(Visitor v) @safe const {
257         static import cpptooling.analyzer.clang.ast;
258         cpptooling.analyzer.clang.ast.accept(cursor, v);
259     }
260 }
261 
262 final class TypedefDecl : Declaration {
263     import clang.Cursor : Cursor;
264     this(Cursor cursor) @safe {
265         super(cursor);
266     }
267 
268     override void accept(Visitor v) @safe const {
269         static import cpptooling.analyzer.clang.ast;
270         cpptooling.analyzer.clang.ast.accept(cursor, v);
271     }
272 }
273 
274 final class CxxMethod : Declaration {
275     import clang.Cursor : Cursor;
276     this(Cursor cursor) @safe {
277         super(cursor);
278     }
279 
280     override void accept(Visitor v) @safe const {
281         static import cpptooling.analyzer.clang.ast;
282         cpptooling.analyzer.clang.ast.accept(cursor, v);
283     }
284 }
285 
286 final class Namespace : Declaration {
287     import clang.Cursor : Cursor;
288     this(Cursor cursor) @safe {
289         super(cursor);
290     }
291 
292     override void accept(Visitor v) @safe const {
293         static import cpptooling.analyzer.clang.ast;
294         cpptooling.analyzer.clang.ast.accept(cursor, v);
295     }
296 }
297 
298 final class LinkageSpec : Declaration {
299     import clang.Cursor : Cursor;
300     this(Cursor cursor) @safe {
301         super(cursor);
302     }
303 
304     override void accept(Visitor v) @safe const {
305         static import cpptooling.analyzer.clang.ast;
306         cpptooling.analyzer.clang.ast.accept(cursor, v);
307     }
308 }
309 
310 final class Constructor : Declaration {
311     import clang.Cursor : Cursor;
312     this(Cursor cursor) @safe {
313         super(cursor);
314     }
315 
316     override void accept(Visitor v) @safe const {
317         static import cpptooling.analyzer.clang.ast;
318         cpptooling.analyzer.clang.ast.accept(cursor, v);
319     }
320 }
321 
322 final class Destructor : Declaration {
323     import clang.Cursor : Cursor;
324     this(Cursor cursor) @safe {
325         super(cursor);
326     }
327 
328     override void accept(Visitor v) @safe const {
329         static import cpptooling.analyzer.clang.ast;
330         cpptooling.analyzer.clang.ast.accept(cursor, v);
331     }
332 }
333 
334 final class ConversionFunction : Declaration {
335     import clang.Cursor : Cursor;
336     this(Cursor cursor) @safe {
337         super(cursor);
338     }
339 
340     override void accept(Visitor v) @safe const {
341         static import cpptooling.analyzer.clang.ast;
342         cpptooling.analyzer.clang.ast.accept(cursor, v);
343     }
344 }
345 
346 final class TemplateTypeParameter : Declaration {
347     import clang.Cursor : Cursor;
348     this(Cursor cursor) @safe {
349         super(cursor);
350     }
351 
352     override void accept(Visitor v) @safe const {
353         static import cpptooling.analyzer.clang.ast;
354         cpptooling.analyzer.clang.ast.accept(cursor, v);
355     }
356 }
357 
358 final class NonTypeTemplateParameter : Declaration {
359     import clang.Cursor : Cursor;
360     this(Cursor cursor) @safe {
361         super(cursor);
362     }
363 
364     override void accept(Visitor v) @safe const {
365         static import cpptooling.analyzer.clang.ast;
366         cpptooling.analyzer.clang.ast.accept(cursor, v);
367     }
368 }
369 
370 final class TemplateTemplateParameter : Declaration {
371     import clang.Cursor : Cursor;
372     this(Cursor cursor) @safe {
373         super(cursor);
374     }
375 
376     override void accept(Visitor v) @safe const {
377         static import cpptooling.analyzer.clang.ast;
378         cpptooling.analyzer.clang.ast.accept(cursor, v);
379     }
380 }
381 
382 final class FunctionTemplate : Declaration {
383     import clang.Cursor : Cursor;
384     this(Cursor cursor) @safe {
385         super(cursor);
386     }
387 
388     override void accept(Visitor v) @safe const {
389         static import cpptooling.analyzer.clang.ast;
390         cpptooling.analyzer.clang.ast.accept(cursor, v);
391     }
392 }
393 
394 final class ClassTemplate : Declaration {
395     import clang.Cursor : Cursor;
396     this(Cursor cursor) @safe {
397         super(cursor);
398     }
399 
400     override void accept(Visitor v) @safe const {
401         static import cpptooling.analyzer.clang.ast;
402         cpptooling.analyzer.clang.ast.accept(cursor, v);
403     }
404 }
405 
406 final class ClassTemplatePartialSpecialization : Declaration {
407     import clang.Cursor : Cursor;
408     this(Cursor cursor) @safe {
409         super(cursor);
410     }
411 
412     override void accept(Visitor v) @safe const {
413         static import cpptooling.analyzer.clang.ast;
414         cpptooling.analyzer.clang.ast.accept(cursor, v);
415     }
416 }
417 
418 final class NamespaceAlias : Declaration {
419     import clang.Cursor : Cursor;
420     this(Cursor cursor) @safe {
421         super(cursor);
422     }
423 
424     override void accept(Visitor v) @safe const {
425         static import cpptooling.analyzer.clang.ast;
426         cpptooling.analyzer.clang.ast.accept(cursor, v);
427     }
428 }
429 
430 final class UsingDirective : Declaration {
431     import clang.Cursor : Cursor;
432     this(Cursor cursor) @safe {
433         super(cursor);
434     }
435 
436     override void accept(Visitor v) @safe const {
437         static import cpptooling.analyzer.clang.ast;
438         cpptooling.analyzer.clang.ast.accept(cursor, v);
439     }
440 }
441 
442 final class TypeAliasDecl : Declaration {
443     import clang.Cursor : Cursor;
444     this(Cursor cursor) @safe {
445         super(cursor);
446     }
447 
448     override void accept(Visitor v) @safe const {
449         static import cpptooling.analyzer.clang.ast;
450         cpptooling.analyzer.clang.ast.accept(cursor, v);
451     }
452 }
453 
454 final class ObjCSynthesizeDecl : Declaration {
455     import clang.Cursor : Cursor;
456     this(Cursor cursor) @safe {
457         super(cursor);
458     }
459 
460     override void accept(Visitor v) @safe const {
461         static import cpptooling.analyzer.clang.ast;
462         cpptooling.analyzer.clang.ast.accept(cursor, v);
463     }
464 }
465 
466 final class ObjCDynamicDecl : Declaration {
467     import clang.Cursor : Cursor;
468     this(Cursor cursor) @safe {
469         super(cursor);
470     }
471 
472     override void accept(Visitor v) @safe const {
473         static import cpptooling.analyzer.clang.ast;
474         cpptooling.analyzer.clang.ast.accept(cursor, v);
475     }
476 }
477 
478 final class CxxAccessSpecifier : Declaration {
479     import clang.Cursor : Cursor;
480     this(Cursor cursor) @safe {
481         super(cursor);
482     }
483 
484     override void accept(Visitor v) @safe const {
485         static import cpptooling.analyzer.clang.ast;
486         cpptooling.analyzer.clang.ast.accept(cursor, v);
487     }
488 }
489