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
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
// Copyright (C) 2020-2024 Free Software Foundation, Inc.
// This file is part of GCC.
// GCC is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 3, or (at your option) any later
// version.
// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
// for more details.
// You should have received a copy of the GNU General Public License
// along with GCC; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#ifndef RUST_HIR_GENERIC_PARAM_H
#define RUST_HIR_GENERIC_PARAM_H
#include "rust-hir-visitable.h"
#include "rust-hir-bound.h"
namespace Rust {
namespace HIR {
/* Base generic parameter in HIR. Abstract - can be represented by a Lifetime or
* Type param */
class GenericParam : public FullVisitable
{
public:
using FullVisitable::accept_vis;
virtual ~GenericParam () {}
enum class GenericKind
{
TYPE,
LIFETIME,
CONST,
};
virtual AST::AttrVec &get_outer_attrs () = 0;
virtual bool has_outer_attribute () const = 0;
// Unique pointer custom clone function
std::unique_ptr<GenericParam> clone_generic_param () const
{
return std::unique_ptr<GenericParam> (clone_generic_param_impl ());
}
virtual std::string as_string () const = 0;
virtual location_t get_locus () const = 0;
Analysis::NodeMapping get_mappings () const { return mappings; }
enum GenericKind get_kind () const { return kind; }
protected:
// Clone function implementation as pure virtual method
virtual GenericParam *clone_generic_param_impl () const = 0;
Analysis::NodeMapping mappings;
enum GenericKind kind;
GenericParam (Analysis::NodeMapping mapping,
enum GenericKind kind = GenericKind::TYPE);
};
// A lifetime generic parameter (as opposed to a type generic parameter)
class LifetimeParam : public GenericParam
{
Lifetime lifetime;
// bool has_lifetime_bounds;
// LifetimeBounds lifetime_bounds;
std::vector<Lifetime> lifetime_bounds; // inlined LifetimeBounds
AST::AttrVec outer_attrs;
location_t locus;
public:
Lifetime get_lifetime () { return lifetime; }
// Returns whether the lifetime param has any lifetime bounds.
bool has_lifetime_bounds () const { return !lifetime_bounds.empty (); }
std::vector<Lifetime> &get_lifetime_bounds () { return lifetime_bounds; }
// Returns whether the lifetime param has an outer attribute.
bool has_outer_attribute () const override { return outer_attrs.size () > 1; }
AST::AttrVec &get_outer_attrs () override { return outer_attrs; }
// Returns whether the lifetime param is in an error state.
bool is_error () const { return lifetime.is_error (); }
// Constructor
LifetimeParam (Analysis::NodeMapping mappings, Lifetime lifetime,
location_t locus = UNDEF_LOCATION,
std::vector<Lifetime> lifetime_bounds
= std::vector<Lifetime> (),
AST::AttrVec outer_attrs = std::vector<AST::Attribute> ());
// TODO: remove copy and assignment operator definitions - not required
// Copy constructor with clone
LifetimeParam (LifetimeParam const &other);
// Overloaded assignment operator to clone attribute
LifetimeParam &operator= (LifetimeParam const &other);
// move constructors
LifetimeParam (LifetimeParam &&other) = default;
LifetimeParam &operator= (LifetimeParam &&other) = default;
std::string as_string () const override;
void accept_vis (HIRFullVisitor &vis) override;
location_t get_locus () const override final { return locus; }
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
LifetimeParam *clone_generic_param_impl () const override
{
return new LifetimeParam (*this);
}
};
class ConstGenericParam : public GenericParam
{
public:
ConstGenericParam (std::string name, std::unique_ptr<Type> type,
std::unique_ptr<Expr> default_expression,
Analysis::NodeMapping mapping, location_t locus);
ConstGenericParam (const ConstGenericParam &other);
bool has_outer_attribute () const override { return false; }
AST::AttrVec &get_outer_attrs () override { return outer_attrs; }
std::string as_string () const override final;
void accept_vis (HIRFullVisitor &vis) override final;
location_t get_locus () const override final { return locus; };
bool has_default_expression () { return default_expression != nullptr; }
std::string get_name () { return name; }
Type &get_type ()
{
rust_assert (type);
return *type;
}
Expr &get_default_expression () { return *default_expression; }
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
ConstGenericParam *clone_generic_param_impl () const override
{
return new ConstGenericParam (*this);
}
private:
std::string name;
std::unique_ptr<Type> type;
/* const params have no outer attrs, should be empty */
AST::AttrVec outer_attrs = std::vector<AST::Attribute> ();
/* Optional - can be a null pointer if there is no default expression */
std::unique_ptr<Expr> default_expression;
location_t locus;
};
} // namespace HIR
} // namespace Rust
#endif
|
