cppshift 0.1.0

CPP parser and transpiler
Documentation 
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

//! Type AST nodes for C++20
//!
//! Analogous to `syn::Type`.

use crate::SourceSpan;

use super::expr::Expr;
use super::item::Path;
use super::punct::Punctuated;

/// The kind of a fundamental (built-in) type.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum FundamentalKind {
    Void,
    Bool,
    Char,
    Char8,
    Char16,
    Char32,
    Wchar,
    Short,
    Int,
    Long,
    LongLong,
    Float,
    Double,
    LongDouble,
    SignedChar,
    UnsignedChar,
    UnsignedShort,
    UnsignedInt,
    UnsignedLong,
    UnsignedLongLong,
}

/// CV (const/volatile) qualifiers.
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct CvQualifiers {
    pub const_token: bool,
    pub volatile_token: bool,
}

/// A C++ type, analogous to `syn::Type`.
#[derive(Debug, Clone, PartialEq)]
pub enum Type<'de> {
    /// Fundamental type: `int`, `double`, `void`, etc.
    Fundamental(TypeFundamental<'de>),
    /// Named type: `MyClass`, `std::string`
    Path(TypePath<'de>),
    /// Pointer: `T*`
    Ptr(TypePtr<'de>),
    /// Lvalue reference: `T&`
    Reference(TypeReference<'de>),
    /// Rvalue reference: `T&&`
    RvalueReference(TypeRvalueReference<'de>),
    /// Array: `T[N]`
    Array(TypeArray<'de>),
    /// Function pointer: `int(*)(int, int)`
    FnPtr(TypeFnPtr<'de>),
    /// `auto`
    Auto(TypeAuto<'de>),
    /// `decltype(expr)`
    Decltype(TypeDecltype<'de>),
    /// Template instantiation: `vector<int>`, `map<string, int>`
    TemplateInst(TypeTemplateInst<'de>),
    /// CV-qualified type wrapper
    Qualified(TypeQualified<'de>),
}

/// A fundamental (built-in) type.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct TypeFundamental<'de> {
    pub span: SourceSpan<'de>,
    pub kind: FundamentalKind,
}

/// A named type via a path: `MyClass`, `std::string`.
///
/// Analogous to `syn::TypePath`.
#[derive(Debug, Clone, PartialEq)]
pub struct TypePath<'de> {
    pub path: Path<'de>,
}

/// Pointer type: `T*`.
///
/// Analogous to `syn::TypePtr`.
#[derive(Debug, Clone, PartialEq)]
pub struct TypePtr<'de> {
    pub cv: CvQualifiers,
    pub pointee: Box<Type<'de>>,
}

/// Lvalue reference type: `T&`.
///
/// Analogous to `syn::TypeReference`.
#[derive(Debug, Clone, PartialEq)]
pub struct TypeReference<'de> {
    pub cv: CvQualifiers,
    pub referent: Box<Type<'de>>,
}

/// Rvalue reference type: `T&&` (C++ specific).
#[derive(Debug, Clone, PartialEq)]
pub struct TypeRvalueReference<'de> {
    pub referent: Box<Type<'de>>,
}

/// Array type: `T[N]`.
///
/// Analogous to `syn::TypeArray`.
#[derive(Debug, Clone, PartialEq)]
pub struct TypeArray<'de> {
    pub element: Box<Type<'de>>,
    pub size: Option<Expr<'de>>,
}

/// Function pointer type: `int(*)(int, int)`.
///
/// Analogous to `syn::TypeBareFn`.
#[derive(Debug, Clone, PartialEq)]
pub struct TypeFnPtr<'de> {
    pub return_type: Box<Type<'de>>,
    pub params: Punctuated<'de, Type<'de>>,
}

/// `auto` type.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct TypeAuto<'de> {
    pub span: SourceSpan<'de>,
}

/// `decltype(expr)`.
#[derive(Debug, Clone, PartialEq)]
pub struct TypeDecltype<'de> {
    pub expr: Expr<'de>,
}

/// Template instantiation type: `vector<int>`, `map<string, int>`.
#[derive(Debug, Clone, PartialEq)]
pub struct TypeTemplateInst<'de> {
    pub path: Path<'de>,
    pub args: Vec<TemplateArg<'de>>,
}

/// A template argument (type or expression).
#[derive(Debug, Clone, PartialEq)]
pub enum TemplateArg<'de> {
    Type(Type<'de>),
    Expr(Expr<'de>),
}

/// A CV-qualified type: `const T`, `volatile T`, `const volatile T`.
#[derive(Debug, Clone, PartialEq)]
pub struct TypeQualified<'de> {
    pub cv: CvQualifiers,
    pub ty: Box<Type<'de>>,
}

/// A template argument for use in paths.
#[derive(Debug, Clone, PartialEq)]
pub struct AngleBracketedArgs<'de> {
    pub args: Vec<TemplateArg<'de>>,
}