File: ast-restore.test

package info (click to toggle)
swiftlang 6.0.3-2
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 2,519,992 kB
  • sloc: cpp: 9,107,863; ansic: 2,040,022; asm: 1,135,751; python: 296,500; objc: 82,456; f90: 60,502; lisp: 34,951; pascal: 19,946; sh: 18,133; perl: 7,482; ml: 4,937; javascript: 4,117; makefile: 3,840; awk: 3,535; xml: 914; fortran: 619; cs: 573; ruby: 573
file content (91 lines) | stat: -rw-r--r-- 3,416 bytes parent folder | download | duplicates (12)
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
REQUIRES: system-windows, msvc
RUN: %build --compiler=msvc --nodefaultlib --output=%t.exe %S/Inputs/AstRestoreTest.cpp
RUN: env LLDB_USE_NATIVE_PDB_READER=0 lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=ENUM %s
RUN: env LLDB_USE_NATIVE_PDB_READER=1 lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=ENUM %s
RUN: lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=GLOBAL %s
RUN: lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=BASE %s
RUN: env LLDB_USE_NATIVE_PDB_READER=0 lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=CLASS %s
RUN: env LLDB_USE_NATIVE_PDB_READER=1 lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=CLASS %s
RUN: lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=INNER %s
RUN: lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=TEMPLATE %s
RUN: lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=FOO %s
RUN: lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=MAIN %s

ENUM: Module: {{.*}}
ENUM: namespace N0 {
ENUM:     namespace N1 {
ENUM:         namespace  {
ENUM:             enum Enum {
ENUM:                 Enum_0,
ENUM:                 Enum_1,
ENUM:                 Enum_2,
ENUM:                 Enum_3
ENUM:             };
ENUM:         }
ENUM:     }
ENUM: }

GLOBAL: Module: {{.*}}
GLOBAL: namespace N0 {
GLOBAL:     namespace N1 {
GLOBAL:         N0::N1::(anonymous namespace)::Enum Global;
GLOBAL:     }
GLOBAL: }

BASE: Module: {{.*}}
BASE: namespace N0 {
BASE:     namespace N1 {
BASE:         struct Base {
BASE:             N0::N1::(anonymous namespace)::Enum m_e;
BASE:         };
BASE:     }
BASE: }

CLASS: Module: {{.*}}
CLASS: namespace N0 {
CLASS:     namespace N1 {
CLASS:         class Class : public N0::N1::Base {
CLASS-DAG:             const N0::N1::(anonymous namespace)::Enum m_ce;
CLASS-DAG:             static int ClassStatic;
CLASS-DAG:             static const int ClassStaticConst = 8;
CLASS-DAG:             static const int ClassStaticConstexpr = 9;
CLASS-DAG:             static constexpr float ClassStaticConstexprFloat = 10.F;
CLASS-DAG:             static constexpr double ClassStaticConstexprDouble = 11.;
CLASS-DAG:             static constexpr double ClassStaticConstexprLongDouble = 12.;
CLASS-DAG:             static const N0::N1::(anonymous namespace)::Enum ClassStaticConstEnum = 8;
CLASS-DAG:             static const N0::N1::(anonymous namespace)::ScopedEnum ClassStaticConstScopedEnum = 4;
CLASS-DAG:             N0::N1::Class::Inner m_inner;
CLASS-DAG:             {{(inline )?}}Class(N0::N1::(anonymous namespace)::Enum);
CLASS-DAG:             {{(static )?}}{{(inline )?}}int StaticFunc(const N0::N1::Class &);
CLASS-DAG:             {{(inline )?}}int PrivateFunc(const N0::N1::Class::Inner &);
CLASS:         };
CLASS:     }
CLASS: }

INNER: Module: {{.*}}
INNER: namespace N0 {
INNER:     namespace N1 {
INNER:         class Class : public N0::N1::Base {
INNER:             struct Inner {
INNER:                 char x;
INNER:                 short y;
INNER:                 int z;
INNER:             };
INNER:         };
INNER:     }
INNER: }

TEMPLATE: Module: {{.*}}
TEMPLATE: struct Template<N0::N1::Class> {
TEMPLATE:     inline void TemplateFunc<1>();
TEMPLATE: };

FOO: Module: {{.*}}
FOO: namespace N0 {
FOO:     namespace N1 {
FOO:         void foo();
FOO:     }
FOO: }

MAIN: Module: {{.*}}
MAIN: int main();