// TODO: put checks in constructor to enforce this rule?
SimplePathSegment (std::string segment_name, location_t locus)
: segment_name (std::move (segment_name)), locus (locus),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
/* Returns whether simple path segment is in an invalid state (currently, if
location_t locus = UNDEF_LOCATION)
: opening_scope_resolution (has_opening_scope_resolution),
segments (std::move (path_segments)), locus (locus),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
SimplePath (Identifier ident)
: opening_scope_resolution (false),
segments ({SimplePathSegment (ident.as_string (), ident.get_locus ())}),
locus (ident.get_locus ()),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
// Creates an empty SimplePath.
virtual void add_semicolon () {}
protected:
- Stmt () : node_id (Analysis::Mappings::get ()->get_next_node_id ()) {}
+ Stmt () : node_id (Analysis::Mappings::get ().get_next_node_id ()) {}
// Clone function implementation as pure virtual method
virtual Stmt *clone_stmt_impl () const = 0;
protected:
// Constructor
- Expr () : node_id (Analysis::Mappings::get ()->get_next_node_id ()) {}
+ Expr () : node_id (Analysis::Mappings::get ().get_next_node_id ()) {}
// Clone function implementation as pure virtual method
virtual Expr *clone_expr_impl () const = 0;
NodeId get_node_id () const { return node_id; }
protected:
- Type () : node_id (Analysis::Mappings::get ()->get_next_node_id ()) {}
+ Type () : node_id (Analysis::Mappings::get ().get_next_node_id ()) {}
// Clone function implementation as pure virtual method
virtual Type *clone_type_impl () const = 0;
// Constructor
Lifetime (LifetimeType type, std::string name = std::string (),
location_t locus = UNDEF_LOCATION)
- : TypeParamBound (Analysis::Mappings::get ()->get_next_node_id ()),
+ : TypeParamBound (Analysis::Mappings::get ().get_next_node_id ()),
lifetime_type (type), lifetime_name (std::move (name)), locus (locus)
{}
NodeId get_node_id () { return node_id; }
protected:
- GenericParam () : node_id (Analysis::Mappings::get ()->get_next_node_id ()) {}
+ GenericParam () : node_id (Analysis::Mappings::get ().get_next_node_id ()) {}
GenericParam (NodeId node_id) : node_id (node_id) {}
// Clone function implementation as pure virtual method
{
protected:
TraitItem (location_t locus)
- : node_id (Analysis::Mappings::get ()->get_next_node_id ()),
+ : node_id (Analysis::Mappings::get ().get_next_node_id ()),
vis (Visibility::create_private ()), locus (locus)
{}
TraitItem (Visibility vis, location_t locus)
- : node_id (Analysis::Mappings::get ()->get_next_node_id ()), vis (vis),
+ : node_id (Analysis::Mappings::get ().get_next_node_id ()), vis (vis),
locus (locus)
{}
class ExternalItem : public Visitable
{
public:
- ExternalItem () : node_id (Analysis::Mappings::get ()->get_next_node_id ()) {}
+ ExternalItem () : node_id (Analysis::Mappings::get ().get_next_node_id ()) {}
ExternalItem (NodeId node_id) : node_id (node_id) {}
Crate (std::vector<std::unique_ptr<Item>> items,
std::vector<Attribute> inner_attrs)
: inner_attrs (std::move (inner_attrs)), items (std::move (items)),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
// Copy constructor with vector clone
LoopLabel (Lifetime loop_label, location_t locus = UNDEF_LOCATION)
: label (std::move (loop_label)), locus (locus),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
// Returns whether the LoopLabel is in an error state.
NodeId get_node_id () const { return node_id; }
protected:
- ArrayElems () : node_id (Analysis::Mappings::get ()->get_next_node_id ()) {}
+ ArrayElems () : node_id (Analysis::Mappings::get ().get_next_node_id ()) {}
// pure virtual clone implementation
virtual ArrayElems *clone_array_elems_impl () const = 0;
// pure virtual clone implementation
virtual StructExprField *clone_struct_expr_field_impl () const = 0;
- StructExprField () : node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ StructExprField () : node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
NodeId node_id;
public:
MatchCase (MatchArm arm, std::unique_ptr<Expr> expr)
: arm (std::move (arm)), expr (std::move (expr)),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
MatchCase (const MatchCase &other)
= std::vector<std::unique_ptr<TypeParamBound>> (),
std::unique_ptr<Type> type = nullptr,
Attribute outer_attr = Attribute::create_empty ())
- : GenericParam (Analysis::Mappings::get ()->get_next_node_id ()),
+ : GenericParam (Analysis::Mappings::get ().get_next_node_id ()),
outer_attr (std::move (outer_attr)),
type_representation (std::move (type_representation)),
type_param_bounds (std::move (type_param_bounds)),
location_t locus)
: lifetime (std::move (lifetime)),
lifetime_bounds (std::move (lifetime_bounds)), locus (locus),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
std::string as_string () const override;
: for_lifetimes (std::move (for_lifetimes)),
bound_type (std::move (bound_type)),
type_param_bounds (std::move (type_param_bounds)),
- node_id (Analysis::Mappings::get ()->get_next_node_id ()), locus (locus)
+ node_id (Analysis::Mappings::get ().get_next_node_id ()), locus (locus)
{}
// Copy constructor requires clone
public:
WhereClause (std::vector<std::unique_ptr<WhereClauseItem>> where_clause_items)
: where_clause_items (std::move (where_clause_items)),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
// copy constructor with vector clone
public:
Param (std::vector<Attribute> outer_attrs, location_t locus)
: outer_attrs (std::move (outer_attrs)), locus (locus),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
virtual ~Param () = default;
virtual UseTree *clone_use_tree_impl () const = 0;
UseTree (location_t locus)
- : locus (locus), node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ : locus (locus), node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
};
std::vector<Attribute> outer_attrs = std::vector<Attribute> ())
: outer_attrs (std::move (outer_attrs)), visibility (std::move (vis)),
field_name (std::move (field_name)), field_type (std::move (field_type)),
- node_id (Analysis::Mappings::get ()->get_next_node_id ()), locus (locus)
+ node_id (Analysis::Mappings::get ().get_next_node_id ()), locus (locus)
{}
// Copy constructor
std::vector<Attribute> outer_attrs = std::vector<Attribute> ())
: outer_attrs (std::move (outer_attrs)), visibility (std::move (vis)),
field_type (std::move (field_type)),
- node_id (Analysis::Mappings::get ()->get_next_node_id ()), locus (locus)
+ node_id (Analysis::Mappings::get ().get_next_node_id ()), locus (locus)
{}
// Copy constructor with clone
std::vector<Attribute> outer_attrs, location_t locus)
: name (std::move (name)), param_type (std::move (param_type)),
outer_attrs (std::move (outer_attrs)),
- node_id (Analysis::Mappings::get ()->get_next_node_id ()), locus (locus),
+ node_id (Analysis::Mappings::get ().get_next_node_id ()), locus (locus),
variadic (false)
{}
location_t locus)
: name (std::move (name)), param_type (nullptr),
outer_attrs (std::move (outer_attrs)),
- node_id (Analysis::Mappings::get ()->get_next_node_id ()), locus (locus),
+ node_id (Analysis::Mappings::get ().get_next_node_id ()), locus (locus),
variadic (true)
{}
NamedFunctionParam (std::vector<Attribute> outer_attrs, location_t locus)
: name (""), param_type (nullptr), outer_attrs (std::move (outer_attrs)),
- node_id (Analysis::Mappings::get ()->get_next_node_id ()), locus (locus),
+ node_id (Analysis::Mappings::get ().get_next_node_id ()), locus (locus),
variadic (true)
{}
location_t locus, bool is_semi_coloned,
std::vector<std::unique_ptr<MacroInvocation>> &&pending_eager_invocs)
: TraitItem (locus), outer_attrs (std::move (outer_attrs)), locus (locus),
- node_id (Analysis::Mappings::get ()->get_next_node_id ()),
+ node_id (Analysis::Mappings::get ().get_next_node_id ()),
invoc_data (std::move (invoc_data)), is_semi_coloned (is_semi_coloned),
kind (kind), builtin_kind (builtin_kind),
pending_eager_invocs (std::move (pending_eager_invocs))
GenericArgs generic_args = GenericArgs::create_empty ())
: segment_name (std::move (segment_name)),
generic_args (std::move (generic_args)), locus (locus),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
/* Constructor for segment with generic arguments (from segment name and all
generic_args (GenericArgs (std::move (lifetime_args),
std::move (generic_args),
std::move (binding_args))),
- locus (locus), node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ locus (locus), node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
// Returns whether path expression segment is in an error state.
: PathPattern (std::move (path_segments)),
outer_attrs (std::move (outer_attrs)),
has_opening_scope_resolution (has_opening_scope_resolution),
- locus (locus), _node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ locus (locus), _node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
// Creates an error state path in expression.
bool has_separating_scope_resolution, location_t locus)
: ident_segment (std::move (ident_segment)), locus (locus),
has_separating_scope_resolution (has_separating_scope_resolution),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
TypePathSegment (std::string segment_name,
: ident_segment (PathIdentSegment (std::move (segment_name), locus)),
locus (locus),
has_separating_scope_resolution (has_separating_scope_resolution),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
TypePathSegment (TypePathSegment const &other)
TypePath trait_path = TypePath::create_error ())
: type_to_invoke_on (std::move (invoke_on_type)),
trait_path (std::move (trait_path)), locus (locus),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
// Copy constructor uses custom deep copy for Type to preserve polymorphism
: PathPattern (std::move (path_segments)),
outer_attrs (std::move (outer_attrs)),
path_type (std::move (qual_path_type)), locus (locus),
- _node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ _node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
/* TODO: maybe make a shortcut constructor that has QualifiedPathType
// Constructor for a literal pattern
LiteralPattern (Literal lit, location_t locus)
: lit (std::move (lit)), locus (locus),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
LiteralPattern (std::string val, Literal::LitType type, location_t locus,
PrimitiveCoreType type_hint)
: lit (Literal (std::move (val), type, type_hint)), locus (locus),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
location_t get_locus () const override final { return locus; }
std::unique_ptr<Pattern> to_bind = nullptr)
: Pattern (), variable_ident (std::move (ident)), is_ref (is_ref),
is_mut (is_mut), to_bind (std::move (to_bind)), locus (locus),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
IdentifierPattern (NodeId node_id, Identifier ident, location_t locus,
std::string as_string () const override { return std::string (1, '_'); }
WildcardPattern (location_t locus)
- : locus (locus), node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ : locus (locus), node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
location_t get_locus () const override final { return locus; }
std::string as_string () const override { return ".."; }
RestPattern (location_t locus)
- : locus (locus), node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ : locus (locus), node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
location_t get_locus () const override final { return locus; }
bool has_ellipsis_syntax = false)
: lower (std::move (lower)), upper (std::move (upper)),
has_ellipsis_syntax (has_ellipsis_syntax), locus (locus),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
// Copy constructor with clone
bool ref_has_two_amps, location_t locus)
: has_two_amps (ref_has_two_amps), is_mut (is_mut_reference),
pattern (std::move (pattern)), locus (locus),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
// Copy constructor requires clone
std::vector<Attribute> outer_attribs,
location_t locus)
: StructPatternField (std::move (outer_attribs), locus,
- Analysis::Mappings::get ()->get_next_node_id ()),
+ Analysis::Mappings::get ().get_next_node_id ()),
index (index), tuple_pattern (std::move (tuple_pattern))
{}
std::vector<Attribute> outer_attrs,
location_t locus)
: StructPatternField (std::move (outer_attrs), locus,
- Analysis::Mappings::get ()->get_next_node_id ()),
+ Analysis::Mappings::get ().get_next_node_id ()),
ident (std::move (ident)), ident_pattern (std::move (ident_pattern))
{}
StructPatternFieldIdent (Identifier ident, bool is_ref, bool is_mut,
std::vector<Attribute> outer_attrs, location_t locus)
: StructPatternField (std::move (outer_attrs), locus,
- Analysis::Mappings::get ()->get_next_node_id ()),
+ Analysis::Mappings::get ().get_next_node_id ()),
has_ref (is_ref), has_mut (is_mut), ident (std::move (ident))
{}
StructPatternElements elems
= StructPatternElements::create_empty ())
: path (std::move (struct_path)), elems (std::move (elems)),
- node_id (Analysis::Mappings::get ()->get_next_node_id ()), locus (locus)
+ node_id (Analysis::Mappings::get ().get_next_node_id ()), locus (locus)
{}
/* TODO: constructor to construct via elements included in
TupleStructPattern (PathInExpression tuple_struct_path,
std::unique_ptr<TupleStructItems> items)
: path (std::move (tuple_struct_path)), items (std::move (items)),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{
rust_assert (this->items != nullptr);
}
TuplePattern (std::unique_ptr<TuplePatternItems> items, location_t locus)
: items (std::move (items)), locus (locus),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{
rust_assert (this->items != nullptr);
}
GroupedPattern (std::unique_ptr<Pattern> pattern_in_parens, location_t locus)
: pattern_in_parens (std::move (pattern_in_parens)), locus (locus),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
// Copy constructor uses clone
SlicePattern (std::vector<std::unique_ptr<Pattern>> items, location_t locus)
: items (std::move (items)), locus (locus),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
// Copy constructor with vector clone
AltPattern (std::vector<std::unique_ptr<Pattern>> alts, location_t locus)
: alts (std::move (alts)), locus (locus),
- node_id (Analysis::Mappings::get ()->get_next_node_id ())
+ node_id (Analysis::Mappings::get ().get_next_node_id ())
{}
// Copy constructor with vector clone
bool opening_question_mark = false,
std::vector<LifetimeParam> for_lifetimes
= std::vector<LifetimeParam> ())
- : TypeParamBound (Analysis::Mappings::get ()->get_next_node_id ()),
+ : TypeParamBound (Analysis::Mappings::get ().get_next_node_id ()),
in_parens (in_parens), opening_question_mark (opening_question_mark),
for_lifetimes (std::move (for_lifetimes)),
type_path (std::move (type_path)), locus (locus)
// Now we can try and resolve the address since this might be a forward
// declared function, generic function which has not be compiled yet or
// its an not yet trait bound function
- HIR::Item *resolved_item = ctx->get_mappings ()->lookup_defid (id);
+ HIR::Item *resolved_item = ctx->get_mappings ().lookup_defid (id);
if (resolved_item != nullptr)
{
if (!fntype->has_substitutions_defined ())
// it might be resolved to a trait item
HIR::TraitItem *trait_item
- = ctx->get_mappings ()->lookup_trait_item_defid (id);
- HIR::Trait *trait = ctx->get_mappings ()->lookup_trait_item_mapping (
+ = ctx->get_mappings ().lookup_trait_item_defid (id);
+ HIR::Trait *trait = ctx->get_mappings ().lookup_trait_item_mapping (
trait_item->get_mappings ().get_hirid ());
Resolver::TraitReference *trait_ref
Resolver::Resolver *get_resolver () { return resolver; }
Resolver::TypeCheckContext *get_tyctx () { return tyctx; }
- Analysis::Mappings *get_mappings () { return mappings; }
+ Analysis::Mappings &get_mappings () { return mappings; }
void push_block (tree scope)
{
private:
Resolver::Resolver *resolver;
Resolver::TypeCheckContext *tyctx;
- Analysis::Mappings *mappings;
+ Analysis::Mappings &mappings;
Mangler mangler;
// state
TyTy::BaseType *expected = fncontext.retty;
location_t lvalue_locus
- = ctx->get_mappings ()->lookup_location (expected->get_ref ());
+ = ctx->get_mappings ().lookup_location (expected->get_ref ());
TyTy::BaseType *actual = nullptr;
bool ok = ctx->get_tyctx ()->lookup_type (
// process arguments
auto &argument = struct_expr.get_fields ().at (0);
auto lvalue_locus
- = ctx->get_mappings ()->lookup_location (expected->get_ty_ref ());
+ = ctx->get_mappings ().lookup_location (expected->get_ty_ref ());
auto rvalue_locus = argument->get_locus ();
auto rvalue = CompileStructExprField::Compile (argument.get (), ctx);
// process arguments
auto &argument = struct_expr.get_fields ().at (i);
auto lvalue_locus
- = ctx->get_mappings ()->lookup_location (expected->get_ty_ref ());
+ = ctx->get_mappings ().lookup_location (expected->get_ty_ref ());
auto rvalue_locus = argument->get_locus ();
auto rvalue = CompileStructExprField::Compile (argument.get (), ctx);
}
HirId ref = UNKNOWN_HIRID;
- if (!ctx->get_mappings ()->lookup_node_to_hir (resolved_node_id, &ref))
+ if (!ctx->get_mappings ().lookup_node_to_hir (resolved_node_id, &ref))
{
rust_fatal_error (expr.get_locus (), "reverse lookup label failure");
return;
}
HirId ref = UNKNOWN_HIRID;
- if (!ctx->get_mappings ()->lookup_node_to_hir (resolved_node_id, &ref))
+ if (!ctx->get_mappings ().lookup_node_to_hir (resolved_node_id, &ref))
{
rust_fatal_error (expr.get_locus (), "reverse lookup label failure");
return;
// coerce it if required
location_t lvalue_locus
- = ctx->get_mappings ()->lookup_location (expected->get_ty_ref ());
+ = ctx->get_mappings ().lookup_location (expected->get_ty_ref ());
location_t rvalue_locus = argument->get_locus ();
rvalue
= coercion_site (argument->get_mappings ().get_hirid (), rvalue,
// coerce it if required
location_t lvalue_locus
- = ctx->get_mappings ()->lookup_location (expected->get_ty_ref ());
+ = ctx->get_mappings ().lookup_location (expected->get_ty_ref ());
location_t rvalue_locus = argument->get_locus ();
rvalue = coercion_site (argument->get_mappings ().get_hirid (), rvalue,
actual, expected, lvalue_locus, rvalue_locus);
// coerce it if required
location_t lvalue_locus
- = ctx->get_mappings ()->lookup_location (expected->get_ty_ref ());
+ = ctx->get_mappings ().lookup_location (expected->get_ty_ref ());
location_t rvalue_locus = argument->get_locus ();
rvalue = coercion_site (argument->get_mappings ().get_hirid (), rvalue,
actual, expected, lvalue_locus, rvalue_locus);
{
// lookup the HirId
HirId ref = UNKNOWN_HIRID;
- bool ok = ctx->get_mappings ()->lookup_node_to_hir (capture, &ref);
+ bool ok = ctx->get_mappings ().lookup_node_to_hir (capture, &ref);
rust_assert (ok);
// lookup the var decl
const Resolver::CanonicalPath &parent_canonical_path
= closure_tyty.get_ident ().path;
NodeId node_id;
- bool ok = ctx->get_mappings ()->lookup_hir_to_node (
+ bool ok = ctx->get_mappings ().lookup_hir_to_node (
expr.get_mappings ().get_hirid (), &node_id);
rust_assert (ok);
Resolver::CanonicalPath path = parent_canonical_path.append (
{
// lookup the HirId
HirId ref = UNKNOWN_HIRID;
- bool ok = ctx->get_mappings ()->lookup_node_to_hir (capture, &ref);
+ bool ok = ctx->get_mappings ().lookup_node_to_hir (capture, &ref);
rust_assert (ok);
// get the assessor
{
// then we need to get the canonical path of it and mangle it
const Resolver::CanonicalPath *canonical_path = nullptr;
- bool ok = ctx->get_mappings ()->lookup_canonical_path (
+ bool ok = ctx->get_mappings ().lookup_canonical_path (
function.get_mappings ().get_nodeid (), &canonical_path);
rust_assert (ok);
TyTy::BaseType *resolved_type = concrete;
const Resolver::CanonicalPath *canonical_path = nullptr;
- bool ok = ctx->get_mappings ()->lookup_canonical_path (
+ bool ok = ctx->get_mappings ().lookup_canonical_path (
constant.get_mappings ().get_nodeid (), &canonical_path);
rust_assert (ok);
}
const Resolver::CanonicalPath *canonical_path = nullptr;
- bool ok = ctx->get_mappings ()->lookup_canonical_path (
+ bool ok = ctx->get_mappings ().lookup_canonical_path (
func.get_mappings ().get_nodeid (), &canonical_path);
rust_assert (ok);
if (it != generic_intrinsics.end ())
return it->second (ctx, fntype);
- location_t locus = ctx->get_mappings ()->lookup_location (fntype->get_ref ());
+ location_t locus = ctx->get_mappings ().lookup_location (fntype->get_ref ());
rust_error_at (locus, ErrorCode::E0093,
"unrecognized intrinsic function: %qs",
fntype->get_identifier ().c_str ());
tree type = TyTyResolveCompile::compile (ctx, resolved_type);
const Resolver::CanonicalPath *canonical_path = nullptr;
- ok = ctx->get_mappings ()->lookup_canonical_path (
+ ok = ctx->get_mappings ().lookup_canonical_path (
var.get_mappings ().get_nodeid (), &canonical_path);
rust_assert (ok);
else
{
const Resolver::CanonicalPath *canonical_path_ptr = nullptr;
- ok = ctx->get_mappings ()->lookup_canonical_path (mappings.get_nodeid (),
- &canonical_path_ptr);
+ ok = ctx->get_mappings ().lookup_canonical_path (mappings.get_nodeid (),
+ &canonical_path_ptr);
rust_assert (ok);
canonical_path = *canonical_path_ptr;
}
HirId parent_impl_block = UNKNOWN_HIRID;
HirId id = function.get_mappings ().get_hirid ();
HIR::ImplItem *impl_item
- = ctx->get_mappings ()->lookup_hir_implitem (id, &parent_impl_block);
+ = ctx->get_mappings ().lookup_hir_implitem (id, &parent_impl_block);
if (impl_item != nullptr)
{
Resolver::AssociatedImplTrait *impl = nullptr;
else
{
const Resolver::CanonicalPath *path = nullptr;
- bool ok = ctx->get_mappings ()->lookup_canonical_path (
+ bool ok = ctx->get_mappings ().lookup_canonical_path (
function.get_mappings ().get_nodeid (), &path);
rust_assert (ok);
}
HirId ref;
- if (!ctx->get_mappings ()->lookup_node_to_hir (ref_node_id, &ref))
+ if (!ctx->get_mappings ().lookup_node_to_hir (ref_node_id, &ref))
{
rust_error_at (expr_locus, "reverse call path lookup failure");
return error_mark_node;
const Analysis::NodeMapping &mappings,
location_t expr_locus, bool is_qualified_path)
{
- HIR::Item *resolved_item = ctx->get_mappings ()->lookup_hir_item (ref);
+ HIR::Item *resolved_item = ctx->get_mappings ().lookup_hir_item (ref);
HirId parent_block;
HIR::ExternalItem *resolved_extern_item
- = ctx->get_mappings ()->lookup_hir_extern_item (ref, &parent_block);
+ = ctx->get_mappings ().lookup_hir_extern_item (ref, &parent_block);
bool is_hir_item = resolved_item != nullptr;
bool is_hir_extern_item = resolved_extern_item != nullptr;
bool is_fn = lookup->get_kind () == TyTy::TypeKind::FNDEF;
HirId parent_impl_id = UNKNOWN_HIRID;
HIR::ImplItem *resolved_item
- = ctx->get_mappings ()->lookup_hir_implitem (ref, &parent_impl_id);
+ = ctx->get_mappings ().lookup_hir_implitem (ref, &parent_impl_id);
bool is_impl_item = resolved_item != nullptr;
if (is_impl_item)
{
{
// it might be resolved to a trait item
HIR::TraitItem *trait_item
- = ctx->get_mappings ()->lookup_hir_trait_item (ref);
- HIR::Trait *trait = ctx->get_mappings ()->lookup_trait_item_mapping (
+ = ctx->get_mappings ().lookup_hir_trait_item (ref);
+ HIR::Trait *trait = ctx->get_mappings ().lookup_trait_item_mapping (
trait_item->get_mappings ().get_hirid ());
Resolver::TraitReference *trait_ref
void
TyTyResolveCompile::visit (const TyTy::ClosureType &type)
{
- auto mappings = ctx->get_mappings ();
+ auto &mappings = ctx->get_mappings ();
std::vector<Backend::typed_identifier> fields;
{
// lookup the HirId
HirId ref = UNKNOWN_HIRID;
- bool ok = mappings->lookup_node_to_hir (capture, &ref);
+ bool ok = mappings.lookup_node_to_hir (capture, &ref);
rust_assert (ok);
// lookup the var decl type
{
auto ret = TyTyResolveCompile::compile (ctx, hir_type, trait_object_mode);
location_t return_type_locus
- = ctx->get_mappings ()->lookup_location (hir_type->get_ref ());
+ = ctx->get_mappings ().lookup_location (hir_type->get_ref ());
results.push_back (
Backend::typed_identifier ("_", ret, return_type_locus));
}
auto compiled_param = Backend::typed_identifier (
param_pair.first->as_string (), compiled_param_type,
- ctx->get_mappings ()->lookup_location (param_tyty->get_ref ()));
+ ctx->get_mappings ().lookup_location (param_tyty->get_ref ()));
parameters.push_back (compiled_param);
}
= TyTyResolveCompile::compile (ctx, field->get_field_type ());
Backend::typed_identifier f (field->get_name (), compiled_field_ty,
- ctx->get_mappings ()->lookup_location (
+ ctx->get_mappings ().lookup_location (
type.get_ty_ref ()));
fields.push_back (std::move (f));
}
tree enumeral_type
= TyTyResolveCompile::get_implicit_enumeral_node_type (ctx);
Backend::typed_identifier f (RUST_ENUM_DISR_FIELD_NAME, enumeral_type,
- ctx->get_mappings ()->lookup_location (
+ ctx->get_mappings ().lookup_location (
variant->get_id ()));
fields.push_back (std::move (f));
Backend::typed_identifier f (
field_name, compiled_field_ty,
- ctx->get_mappings ()->lookup_location (type.get_ty_ref ()));
+ ctx->get_mappings ().lookup_location (type.get_ty_ref ()));
fields.push_back (std::move (f));
}
std::string implicit_variant_name = variant->get_identifier ();
Backend::typed_identifier f (implicit_variant_name, variant_record,
- ctx->get_mappings ()->lookup_location (
+ ctx->get_mappings ().lookup_location (
type.get_ty_ref ()));
enum_fields.push_back (std::move (f));
}
// approach makes it simpler to use a C-only debugger, or
// GDB's C mode, when debugging Rust.
Backend::typed_identifier f ("__" + std::to_string (i), compiled_field_ty,
- ctx->get_mappings ()->lookup_location (
+ ctx->get_mappings ().lookup_location (
type.get_ty_ref ()));
fields.push_back (std::move (f));
}
tree uintptr_ty = build_pointer_type (uint);
Backend::typed_identifier f ("pointer", uintptr_ty,
- ctx->get_mappings ()->lookup_location (
+ ctx->get_mappings ().lookup_location (
type.get_ty_ref ()));
fields.push_back (std::move (f));
tree vtable_size = build_int_cst (size_type_node, items.size ());
tree vtable_type = Backend::array_type (uintptr_ty, vtable_size);
Backend::typed_identifier vtf ("vtable", vtable_type,
- ctx->get_mappings ()->lookup_location (
+ ctx->get_mappings ().lookup_location (
type.get_ty_ref ()));
fields.push_back (std::move (vtf));
location_t locus)
{
// DST's get wrapped in a pseudo reference that doesnt exist...
- const TyTy::ReferenceType r (ctx->get_mappings ()->get_next_hir_id (),
+ const TyTy::ReferenceType r (ctx->get_mappings ().get_next_hir_id (),
TyTy::TyVar (ty->get_ref ()), Mutability::Imm);
tree dynamic_object = TyTyResolveCompile::compile (ctx, &r);
v0_path (Rust::Compile::Context *ctx, const TyTy::BaseType *ty,
const Resolver::CanonicalPath &cpath)
{
- auto mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
V0Path v0path = {};
cpath.iterate_segs ([&] (const Resolver::CanonicalPath &seg) {
HirId hir_id;
- bool ok = mappings->lookup_node_to_hir (seg.get_node_id (), &hir_id);
+ bool ok = mappings.lookup_node_to_hir (seg.get_node_id (), &hir_id);
if (!ok)
{
// FIXME: generic arg in canonical path? (e.g. <i32> in crate::S<i32>)
HirId parent_impl_id = UNKNOWN_HIRID;
HIR::ImplItem *impl_item
- = mappings->lookup_hir_implitem (hir_id, &parent_impl_id);
- HIR::TraitItem *trait_item = mappings->lookup_hir_trait_item (hir_id);
- HIR::Item *item = mappings->lookup_hir_item (hir_id);
- HIR::Expr *expr = mappings->lookup_hir_expr (hir_id);
+ = mappings.lookup_hir_implitem (hir_id, &parent_impl_id);
+ HIR::TraitItem *trait_item = mappings.lookup_hir_trait_item (hir_id);
+ HIR::Item *item = mappings.lookup_hir_item (hir_id);
+ HIR::Expr *expr = mappings.lookup_hir_expr (hir_id);
if (impl_item != nullptr)
{
rust_debug ("Start mangling: %s", path.get ().c_str ());
// TODO: get Instanciating CrateNum
- // auto mappings = Analysis::Mappings::get ();
+ // auto &mappings = Analysis::Mappings::get ();
// std::string crate_name;
// bool ok = mappings->get_crate_name (path.get_crate_num (), crate_name);
// rust_assert (ok);
if (enable_dump_bir)
{
mkdir_wrapped ("bir_dump");
- auto mappings = Analysis::Mappings::get ();
- bool ok
- = mappings->get_crate_name (crate.get_mappings ().get_crate_num (),
- crate_name);
+ auto &mappings = Analysis::Mappings::get ();
+ bool ok = mappings.get_crate_name (crate.get_mappings ().get_crate_num (),
+ crate_name);
rust_assert (ok);
mkdir_wrapped ("nll_facts_gccrs");
}
} // namespace HIR
-} // namespace Rust
\ No newline at end of file
+} // namespace Rust
Resolver::resolve (HIR::Crate &crate)
{
PrivacyContext ctx;
- auto mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
auto resolver = Rust::Resolver::Resolver::get ();
auto ty_ctx = ::Rust::Resolver::TypeCheckContext::get ();
- VisibilityResolver (*mappings, *resolver).go (crate);
- PubRestrictedVisitor (*mappings).go (crate);
- PrivacyReporter (*mappings, *resolver, *ty_ctx).go (crate);
+ VisibilityResolver (mappings, *resolver).go (crate);
+ PubRestrictedVisitor (mappings).go (crate);
+ PrivacyReporter (mappings, *resolver, *ty_ctx).go (crate);
auto visitor = ReachabilityVisitor (ctx, *ty_ctx);
ConstChecker::ConstChecker ()
: resolver (*Resolver::Resolver::get ()),
- mappings (*Analysis::Mappings::get ())
+ mappings (Analysis::Mappings::get ())
{}
void
UnsafeChecker::UnsafeChecker ()
: context (*Resolver::TypeCheckContext::get ()),
resolver (*Resolver::Resolver::get ()),
- mappings (*Analysis::Mappings::get ())
+ mappings (Analysis::Mappings::get ())
{}
void
protected:
MarkLiveBase () : mappings (Analysis::Mappings::get ()) {}
- Analysis::Mappings *mappings;
+ Analysis::Mappings &mappings;
};
} // namespace Analysis
HirId hirId = worklist.back ();
worklist.pop_back ();
scannedSymbols.emplace (hirId);
- HIR::Item *item = mappings->lookup_hir_item (hirId);
+ HIR::Item *item = mappings.lookup_hir_item (hirId);
liveSymbols.emplace (hirId);
if (item != nullptr)
{
{ // the item maybe inside a trait impl
HirId parent_impl_id = UNKNOWN_HIRID;
HIR::ImplItem *implItem
- = mappings->lookup_hir_implitem (hirId, &parent_impl_id);
+ = mappings.lookup_hir_implitem (hirId, &parent_impl_id);
if (implItem != nullptr)
implItem->accept_vis (*this);
}
// node back to HIR
HirId ref;
- bool ok = mappings->lookup_node_to_hir (ref_node_id, &ref);
+ bool ok = mappings.lookup_node_to_hir (ref_node_id, &ref);
rust_assert (ok);
// it must resolve to some kind of HIR::Item or HIR::InheritImplItem
- HIR::Item *resolved_item = mappings->lookup_hir_item (ref);
+ HIR::Item *resolved_item = mappings.lookup_hir_item (ref);
if (resolved_item != nullptr)
{
mark_hir_id (resolved_item->get_mappings ().get_hirid ());
{
HirId parent_impl_id = UNKNOWN_HIRID;
HIR::ImplItem *resolved_item
- = mappings->lookup_hir_implitem (ref, &parent_impl_id);
+ = mappings.lookup_hir_implitem (ref, &parent_impl_id);
if (resolved_item != nullptr)
{
mark_hir_id (resolved_item->get_impl_mappings ().get_hirid ());
// node back to HIR
HirId ref;
- bool ok = mappings->lookup_node_to_hir (ref_node_id, &ref);
+ bool ok = mappings.lookup_node_to_hir (ref_node_id, &ref);
rust_assert (ok);
mark_hir_id (ref);
}
return false;
}
HirId ref;
- bool ok = mappings->lookup_node_to_hir (ref_node_id, &ref);
+ bool ok = mappings.lookup_node_to_hir (ref_node_id, &ref);
rust_assert (ok);
mark_hir_id (ref);
return true;
resolver->lookup_resolved_type (
alias.get_type_aliased ()->get_mappings ().get_nodeid (), &ast_node_id);
HirId hir_id;
- bool ok = mappings->lookup_node_to_hir (ast_node_id, &hir_id);
+ bool ok = mappings.lookup_node_to_hir (ast_node_id, &hir_id);
rust_assert (ok);
mark_hir_id (hir_id);
}
std::vector<HirId> worklist;
std::set<HirId> liveSymbols;
std::set<HirId> scannedSymbols;
- Analysis::Mappings *mappings;
+ Analysis::Mappings &mappings;
Resolver::Resolver *resolver;
Resolver::TypeCheckContext *tyctx;
MarkLive (std::vector<HirId> worklist)
HirId hirId = function.get_mappings ().get_hirid ();
if (should_warn (hirId) && !function.get_visibility ().is_public ())
{
- if (mappings->is_impl_item (hirId))
+ if (mappings.is_impl_item (hirId))
{
- HIR::ImplBlock *implBlock
- = mappings->lookup_associated_impl (hirId);
+ HIR::ImplBlock *implBlock = mappings.lookup_associated_impl (hirId);
if (!implBlock->has_trait_ref ())
{
rust_warning_at (
private:
std::set<HirId> live_symbols;
Resolver::Resolver *resolver;
- Analysis::Mappings *mappings;
+ Analysis::Mappings &mappings;
ScanDeadcode (std::set<HirId> &live_symbols)
: live_symbols (live_symbols), resolver (Resolver::Resolver::get ()),
// lookup the rules
AST::MacroRulesDefinition *rules_def = nullptr;
- bool ok = mappings->lookup_macro_invocation (invoc, &rules_def);
+ bool ok = mappings.lookup_macro_invocation (invoc, &rules_def);
// If there's no rule associated with the invocation, we can simply return
// early. The early name resolver will have already emitted an error.
AST::Fragment expand_derive_proc_macro (T &item, AST::SimplePath &path)
{
tl::optional<CustomDeriveProcMacro &> macro
- = mappings->lookup_derive_proc_macro_invocation (path);
+ = mappings.lookup_derive_proc_macro_invocation (path);
if (!macro.has_value ())
{
rust_error_at (path.get_locus (), "macro not found");
AST::MacroInvocation &invocation)
{
tl::optional<BangProcMacro &> macro
- = mappings->lookup_bang_proc_macro_invocation (invocation);
+ = mappings.lookup_bang_proc_macro_invocation (invocation);
if (!macro.has_value ())
{
rust_error_at (invocation.get_locus (), "macro not found");
AST::Fragment expand_attribute_proc_macro (T &item, AST::SimplePath &path)
{
tl::optional<AttributeProcMacro &> macro
- = mappings->lookup_attribute_proc_macro_invocation (path);
+ = mappings.lookup_attribute_proc_macro_invocation (path);
if (!macro.has_value ())
{
rust_error_at (path.get_locus (), "macro not found");
public:
Resolver::Resolver *resolver;
- Analysis::Mappings *mappings;
+ Analysis::Mappings &mappings;
};
} // namespace Rust
namespace Rust {
BangProcMacro::BangProcMacro (ProcMacro::Bang macro)
- : name (macro.name),
- node_id (Analysis::Mappings::get ()->get_next_node_id ()),
+ : name (macro.name), node_id (Analysis::Mappings::get ().get_next_node_id ()),
macro (macro.macro)
{}
AttributeProcMacro::AttributeProcMacro (ProcMacro::Attribute macro)
- : name (macro.name),
- node_id (Analysis::Mappings::get ()->get_next_node_id ()),
+ : name (macro.name), node_id (Analysis::Mappings::get ().get_next_node_id ()),
macro (macro.macro)
{}
CustomDeriveProcMacro::CustomDeriveProcMacro (ProcMacro::CustomDerive macro)
: trait_name (macro.trait_name),
attributes (macro.attributes, macro.attributes + macro.attr_size),
- node_id (Analysis::Mappings::get ()->get_next_node_id ()),
+ node_id (Analysis::Mappings::get ().get_next_node_id ()),
macro (macro.macro)
{}
lifetime_type = AST::Lifetime::STATIC;
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, lifetime.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
- mappings->insert_node_to_hir (mapping.get_nodeid (), mapping.get_hirid ());
+ mappings.insert_node_to_hir (mapping.get_nodeid (), mapping.get_hirid ());
return HIR::Lifetime (mapping, lifetime_type, lifetime.get_lifetime_name (),
lifetime.get_locus ());
{
HIR::Lifetime life = lower_lifetime (loop_label.get_lifetime ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, loop_label.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
- mappings->insert_node_to_hir (mapping.get_nodeid (), mapping.get_hirid ());
+ mappings.insert_node_to_hir (mapping.get_nodeid (), mapping.get_hirid ());
return HIR::LoopLabel (mapping, std::move (life), loop_label.get_locus ());
}
HIR::PathExprSegment
ASTLoweringBase::lower_path_expr_seg (AST::PathExprSegment &s)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, s.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
return HIR::PathExprSegment (
rust_assert (param.is_self ());
auto self = static_cast<AST::SelfParam &> (param);
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, self.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
if (self.has_type ())
{
auto lang_item_type = LangItem::Parse (lang_item_type_str);
if (lang_item_type)
- mappings->insert_lang_item (*lang_item_type,
- item.get_mappings ().get_defid ());
+ mappings.insert_lang_item (*lang_item_type,
+ item.get_mappings ().get_defid ());
else
rust_error_at (attr.get_locus (), "unknown lang item");
}
{
HIR::Visibility vis = translate_visibility (extern_block.get_visibility ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, extern_block.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
std::vector<std::unique_ptr<HIR::ExternalItem>> extern_items;
for (auto &item : extern_block.get_extern_items ())
extern_block.get_outer_attrs (),
extern_block.get_locus ());
- mappings->insert_hir_extern_block (hir_extern_block);
+ mappings.insert_hir_extern_block (hir_extern_block);
return hir_extern_block;
}
if (is_export)
{
- mappings->insert_exported_macro (def);
- mappings->insert_ast_item (&def);
- mappings->insert_location (def.get_node_id (), def.get_locus ());
+ mappings.insert_exported_macro (def);
+ mappings.insert_ast_item (&def);
+ mappings.insert_location (def.get_node_id (), def.get_locus ());
}
}
attr_mappings (Analysis::BuiltinAttributeMappings::get ())
{}
- Analysis::Mappings *mappings;
+ Analysis::Mappings &mappings;
Analysis::BuiltinAttributeMappings *attr_mappings;
HIR::Lifetime lower_lifetime (AST::Lifetime &lifetime,
expr.accept_vis (resolver);
if (resolver.translated != nullptr)
{
- resolver.mappings->insert_hir_expr (resolver.translated);
+ resolver.mappings.insert_hir_expr (resolver.translated);
}
*terminated = resolver.terminated;
HIR::BlockExpr *block
= ASTLoweringBlock::translate (expr.get_block_expr (), terminated);
- auto crate_num = resolver.mappings->get_current_crate ();
+ auto crate_num = resolver.mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- resolver.mappings->get_next_hir_id (
+ resolver.mappings.get_next_hir_id (
crate_num),
UNKNOWN_LOCAL_DEFID);
std::unique_ptr<HIR::BlockExpr> (block),
expr.get_outer_attrs (), expr.get_locus ());
- resolver.mappings->insert_hir_expr (translated);
+ resolver.mappings.insert_hir_expr (translated);
return translated;
}
expr.accept_vis (resolver);
if (resolver.translated != nullptr)
{
- resolver.mappings->insert_hir_expr (resolver.translated);
+ resolver.mappings.insert_hir_expr (resolver.translated);
}
*terminated = resolver.terminated;
return resolver.translated;
expr.accept_vis (resolver);
if (resolver.translated != nullptr)
{
- resolver.mappings->insert_hir_expr (resolver.translated);
+ resolver.mappings.insert_hir_expr (resolver.translated);
}
return resolver.translated;
}
expr.accept_vis (resolver);
if (resolver.translated != nullptr)
{
- resolver.mappings->insert_hir_expr (resolver.translated);
+ resolver.mappings.insert_hir_expr (resolver.translated);
}
*terminated = resolver.terminated;
HIR::LoopLabel loop_label = lower_loop_label (expr.get_loop_label ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
auto hirid = resolver.translated->get_mappings ().get_hirid ();
auto defid = resolver.translated->get_mappings ().get_defid ();
- resolver.mappings->insert_defid_mapping (defid, resolver.translated);
- resolver.mappings->insert_location (hirid,
- resolver.translated->get_locus ());
+ resolver.mappings.insert_defid_mapping (defid, resolver.translated);
+ resolver.mappings.insert_location (hirid,
+ resolver.translated->get_locus ());
return resolver.translated;
}
void visit (AST::EnumItem &item) override
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, item.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
if (item.has_visibility ())
rust_error_at (item.get_locus (),
void visit (AST::EnumItemTuple &item) override
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, item.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
if (item.has_visibility ())
rust_error_at (item.get_locus (),
HIR::Visibility vis = translate_visibility (field.get_visibility ());
HIR::Type *type = ASTLoweringType::translate (field.get_field_type ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping field_mapping (
- crate_num, field.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ crate_num, field.get_node_id (), mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
HIR::TupleField translated_field (field_mapping,
std::unique_ptr<HIR::Type> (type),
void visit (AST::EnumItemStruct &item) override
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, item.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
if (item.has_visibility ())
rust_error_at (item.get_locus (),
HIR::Visibility vis = translate_visibility (field.get_visibility ());
HIR::Type *type = ASTLoweringType::translate (field.get_field_type ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping field_mapping (
- crate_num, field.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ crate_num, field.get_node_id (), mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
HIR::StructField translated_field (field_mapping,
field.get_field_name (),
void visit (AST::EnumItemDiscriminant &item) override
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, item.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
if (item.has_visibility ())
rust_error_at (item.get_locus (),
return nullptr;
}
- resolver.mappings->insert_hir_expr (resolver.translated);
- resolver.mappings->insert_location (
+ resolver.mappings.insert_hir_expr (resolver.translated);
+ resolver.mappings.insert_location (
resolver.translated->get_mappings ().get_hirid (), expr.get_locus ());
if (terminated != nullptr)
HIR::Expr *tuple_expr
= ASTLoweringExpr::translate (expr.get_tuple_expr (), &terminated);
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
tuple_elements.push_back (std::unique_ptr<HIR::Expr> (t));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
? ASTLoweringExpr::translate (expr.get_returned_expr ())
: nullptr;
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated = new HIR::ReturnExpr (mapping, expr.get_locus (),
params.push_back (std::unique_ptr<HIR::Expr> (trans));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (
crate_num, UNKNOWN_NODEID /* this can map back to the AST*/,
- mappings->get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID);
+ mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID);
translated = new HIR::CallExpr (mapping, std::unique_ptr<HIR::Expr> (func),
std::move (params), expr.get_outer_attrs (),
params.push_back (std::unique_ptr<HIR::Expr> (trans));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ());
HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
void
ASTLoweringExpr::visit (AST::IdentifierExpr &expr)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping1 (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
Analysis::NodeMapping mapping2 (mapping1);
rust_assert (translated_array_elems != nullptr);
HIR::ArrayElems *elems = translated_array_elems;
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
HIR::Expr *array_index_expr
= ASTLoweringExpr::translate (expr.get_index_expr ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
elements.push_back (std::unique_ptr<HIR::Expr> (translated_elem));
}
- auto crate_num = mappings->get_current_crate ();
- Analysis::NodeMapping mapping (mappings->get_current_crate (),
+ auto crate_num = mappings.get_current_crate ();
+ Analysis::NodeMapping mapping (mappings.get_current_crate (),
elems.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated_array_elems
HIR::Expr *element = ASTLoweringExpr::translate (elems.get_elem_to_copy ());
HIR::Expr *num_copies = ASTLoweringExpr::translate (elems.get_num_copies ());
- auto crate_num = mappings->get_current_crate ();
- Analysis::NodeMapping mapping (mappings->get_current_crate (),
+ auto crate_num = mappings.get_current_crate ();
+ Analysis::NodeMapping mapping (mappings.get_current_crate (),
elems.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated_array_elems
void
ASTLoweringExpr::visit (AST::LiteralExpr &expr)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
HIR::Literal l = lower_literal (expr.get_literal ());
HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
rust_assert (rhs != nullptr);
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated = new HIR::ArithmeticOrLogicalExpr (
HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
rust_assert (rhs != nullptr);
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ());
rust_assert (rhs != nullptr);
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
HIR::Expr *negated_value
= ASTLoweringExpr::translate (expr.get_negated_expr ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
= new HIR::NegationExpr (mapping,
HIR::Type *type_to_cast_to
= lower_type_no_bounds (expr.get_type_to_cast_to ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
HIR::Expr *asignee_expr = ASTLoweringExpr::translate (expr.get_left_expr ());
HIR::Expr *value = ASTLoweringExpr::translate (expr.get_right_expr ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated = new HIR::CompoundAssignmentExpr (
HIR::PathInExpression copied_path (*path);
delete path;
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, struct_expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated = new HIR::StructExprStruct (mapping, copied_path,
fields.push_back (std::unique_ptr<HIR::StructExprField> (translated));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, struct_expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
HIR::Expr *paren_expr
= ASTLoweringExpr::translate (expr.get_expr_in_parens ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
{
HIR::Expr *receiver = ASTLoweringExpr::translate (expr.get_receiver_expr ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
= new HIR::FieldAccessExpr (mapping, std::unique_ptr<HIR::Expr> (receiver),
? ASTLoweringExpr::translate (expr.get_break_expr ())
: nullptr;
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
{
HIR::Lifetime break_label = lower_lifetime (expr.get_label ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
HIR::Expr *borrow_lvalue
= ASTLoweringExpr::translate (expr.get_borrowed_expr ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
auto *borrow_expr
if (expr.get_is_double_borrow ())
{
- NodeId artificial_double_borrow_id = mappings->get_next_node_id ();
+ NodeId artificial_double_borrow_id = mappings.get_next_node_id ();
Analysis::NodeMapping mapping (crate_num, artificial_double_borrow_id,
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
borrow_expr
HIR::Expr *dref_lvalue
= ASTLoweringExpr::translate (expr.get_dereferenced_expr ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
HIR::Expr *propagating_expr
= ASTLoweringExpr::translate (expr.get_propagating_expr ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated = new HIR::ErrorPropagationExpr (
mapping, std::unique_ptr<HIR::Expr> (propagating_expr),
void
ASTLoweringExpr::visit (AST::RangeFromToExpr &expr)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
HIR::Expr *range_from = ASTLoweringExpr::translate (expr.get_from_expr ());
void
ASTLoweringExpr::visit (AST::RangeFromExpr &expr)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
HIR::Expr *range_from = ASTLoweringExpr::translate (expr.get_from_expr ());
void
ASTLoweringExpr::visit (AST::RangeToExpr &expr)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
HIR::Expr *range_to = ASTLoweringExpr::translate (expr.get_to_expr ());
void
ASTLoweringExpr::visit (AST::RangeFullExpr &expr)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated = new HIR::RangeFullExpr (mapping, expr.get_locus ());
void
ASTLoweringExpr::visit (AST::RangeFromToInclExpr &expr)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
HIR::Expr *range_from = ASTLoweringExpr::translate (expr.get_from_expr ());
closure_params.push_back (std::move (p));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated
= new HIR::ClosureExpr (mapping, std::move (closure_params),
closure_params.push_back (std::move (p));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated
= new HIR::ClosureExpr (mapping, std::move (closure_params),
item->accept_vis (resolver);
rust_assert (resolver.translated != nullptr);
- resolver.mappings->insert_hir_extern_item (resolver.translated,
- parent_hirid);
- resolver.mappings->insert_location (
+ resolver.mappings.insert_hir_extern_item (resolver.translated,
+ parent_hirid);
+ resolver.mappings.insert_location (
resolver.translated->get_mappings ().get_hirid (),
resolver.translated->get_locus ());
HIR::Visibility vis = translate_visibility (item.get_visibility ());
HIR::Type *static_type = ASTLoweringType::translate (item.get_type ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, item.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated = new HIR::ExternalStaticItem (
mapping, item.get_identifier (), std::unique_ptr<HIR::Type> (static_type),
HIR::Type *param_type = ASTLoweringType::translate (param.get_type ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (
crate_num));
function_params.push_back (
std::unique_ptr<HIR::Type> (param_type)));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, function.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated = new HIR::ExternalFunctionItem (
mapping, function.get_function_name (), std::move (generic_params),
void visit (AST::ExternalTypeItem &type) override
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
HIR::Visibility vis = translate_visibility (type.get_visibility ());
auto locus = resolver.translated->get_locus ();
resolver.handle_outer_attributes (*resolver.item_cast);
- resolver.mappings->insert_hir_implitem (parent_impl_id,
- resolver.translated);
- resolver.mappings->insert_location (id, locus);
- resolver.mappings->insert_defid_mapping (defid, resolver.item_cast);
+ resolver.mappings.insert_hir_implitem (parent_impl_id,
+ resolver.translated);
+ resolver.mappings.insert_location (id, locus);
+ resolver.mappings.insert_defid_mapping (defid, resolver.item_cast);
}
return resolver.translated;
HIR::Type *existing_type
= ASTLoweringType::translate (alias.get_type_aliased ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, alias.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
auto type_alias
= new HIR::TypeAlias (mapping, alias.get_new_type_name (),
HIR::Type *type = ASTLoweringType::translate (constant.get_type (), true);
HIR::Expr *expr = ASTLoweringExpr::translate (constant.get_expr ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, constant.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
auto translated_constant
= new HIR::ConstantItem (mapping, constant.get_identifier (), vis,
auto translated_type = std::unique_ptr<HIR::Type> (
ASTLoweringType::translate (param.get_type ()));
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
auto hir_param
ASTLoweringBlock::translate (*function.get_definition ().value (),
&terminated));
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, function.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
- mappings->insert_location (function_body->get_mappings ().get_hirid (),
- function.get_locus ());
+ mappings.insert_location (function_body->get_mappings ().get_hirid (),
+ function.get_locus ());
auto fn
= new HIR::Function (mapping, std::move (function_name),
if (!fn->get_self_param ().is_error ())
{
// insert mappings for self
- mappings->insert_hir_self_param (&fn->get_self_param ());
- mappings->insert_location (
+ mappings.insert_hir_self_param (&fn->get_self_param ());
+ mappings.insert_location (
fn->get_self_param ().get_mappings ().get_hirid (),
fn->get_self_param ().get_locus ());
}
// add the mappings for the function params at the end
for (auto ¶m : fn->get_function_params ())
{
- mappings->insert_hir_param (¶m);
- mappings->insert_location (mapping.get_hirid (), param.get_locus ());
+ mappings.insert_hir_param (¶m);
+ mappings.insert_location (mapping.get_hirid (), param.get_locus ());
}
translated = fn;
auto locus = resolver.translated->get_trait_locus ();
resolver.handle_outer_attributes (*resolver.translated);
- resolver.mappings->insert_hir_trait_item (resolver.translated);
- resolver.mappings->insert_location (id, locus);
- resolver.mappings->insert_defid_mapping (defid, resolver.translated);
+ resolver.mappings.insert_hir_trait_item (resolver.translated);
+ resolver.mappings.insert_location (id, locus);
+ resolver.mappings.insert_defid_mapping (defid, resolver.translated);
}
return resolver.translated;
auto translated_type = std::unique_ptr<HIR::Type> (
ASTLoweringType::translate (param.get_type ()));
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
auto hir_param
&terminated))
: nullptr;
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, func.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
auto *trait_item
= new HIR::TraitItemFunc (mapping, std::move (decl), std::move (block_expr),
if (func.has_self_param ())
{
// insert mappings for self
- mappings->insert_hir_self_param (&self_param);
- mappings->insert_location (self_param.get_mappings ().get_hirid (),
- self_param.get_locus ());
+ mappings.insert_hir_self_param (&self_param);
+ mappings.insert_location (self_param.get_mappings ().get_hirid (),
+ self_param.get_locus ());
}
// add the mappings for the function params at the end
for (auto ¶m : trait_item->get_decl ().get_function_params ())
{
- mappings->insert_hir_param (¶m);
- mappings->insert_location (mapping.get_hirid (), param.get_locus ());
+ mappings.insert_hir_param (¶m);
+ mappings.insert_location (mapping.get_hirid (), param.get_locus ());
}
}
? ASTLoweringExpr::translate (constant.get_expr ())
: nullptr;
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, constant.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
HIR::TraitItemConst *trait_item
= new HIR::TraitItemConst (mapping, constant.get_identifier (),
ASTLowerTraitItem::visit (AST::TraitItemType &type)
{
std::vector<std::unique_ptr<HIR::TypeParamBound> > type_param_bounds;
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
HIR::TraitItemType *trait_item
= new HIR::TraitItemType (mapping, type.get_identifier (),
auto locus = resolver.translated->get_locus ();
resolver.handle_outer_attributes (*resolver.translated);
- resolver.mappings->insert_ast_item (&item);
- resolver.mappings->insert_hir_item (resolver.translated);
- resolver.mappings->insert_location (id, locus);
- resolver.mappings->insert_defid_mapping (defid, resolver.translated);
+ resolver.mappings.insert_ast_item (&item);
+ resolver.mappings.insert_hir_item (resolver.translated);
+ resolver.mappings.insert_location (id, locus);
+ resolver.mappings.insert_defid_mapping (defid, resolver.translated);
}
return resolver.translated;
void
ASTLoweringItem::visit (AST::Module &module)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, module.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
// should be lowered from module.get_vis()
HIR::Visibility vis = translate_visibility (module.get_visibility ());
= new HIR::Module (mapping, module.get_name (), module.get_locus (),
std::move (items), std::move (vis),
std::move (inner_attrs), std::move (outer_attrs));
- mappings->insert_module (static_cast<Module *> (translated));
+ mappings.insert_module (static_cast<Module *> (translated));
}
void
HIR::Type *existing_type
= ASTLoweringType::translate (alias.get_type_aliased ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, alias.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated
= new HIR::TypeAlias (mapping, alias.get_new_type_name (),
HIR::Visibility vis = translate_visibility (field.get_visibility ());
HIR::Type *type = ASTLoweringType::translate (field.get_field_type ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, field.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (
- crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
HIR::TupleField translated_field (mapping,
std::unique_ptr<HIR::Type> (type), vis,
fields.push_back (std::move (translated_field));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, struct_decl.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated = new HIR::TupleStruct (mapping, std::move (fields),
struct_decl.get_identifier (),
HIR::Visibility vis = translate_visibility (field.get_visibility ());
HIR::Type *type = ASTLoweringType::translate (field.get_field_type ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, field.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (
- crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
HIR::StructField translated_field (mapping, field.get_field_name (),
std::unique_ptr<HIR::Type> (type), vis,
fields.push_back (std::move (translated_field));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, struct_decl.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated = new HIR::StructStruct (mapping, std::move (fields),
struct_decl.get_identifier (),
items.push_back (std::unique_ptr<HIR::EnumItem> (hir_item));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, enum_decl.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
HIR::Enum *hir_enum
= new HIR::Enum (mapping, enum_decl.get_identifier (), vis,
translated = hir_enum;
for (auto &variant : hir_enum->get_variants ())
{
- mappings->insert_hir_enumitem (hir_enum, variant.get ());
+ mappings.insert_hir_enumitem (hir_enum, variant.get ());
}
}
HIR::Visibility vis = translate_visibility (variant.get_visibility ());
HIR::Type *type = ASTLoweringType::translate (variant.get_field_type ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, variant.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (
- crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
HIR::StructField translated_variant (mapping, variant.get_field_name (),
std::unique_ptr<HIR::Type> (type),
variants.push_back (std::move (translated_variant));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, union_decl.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated
= new HIR::Union (mapping, union_decl.get_identifier (), vis,
HIR::Type *type = ASTLoweringType::translate (var.get_type (), true);
HIR::Expr *expr = ASTLoweringExpr::translate (var.get_expr ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, var.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated = new HIR::StaticItem (mapping, var.get_identifier (),
var.is_mutable () ? Mutability::Mut
HIR::Type *type = ASTLoweringType::translate (constant.get_type (), true);
HIR::Expr *expr = ASTLoweringExpr::translate (constant.get_expr ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, constant.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated = new HIR::ConstantItem (mapping, constant.get_identifier (), vis,
std::unique_ptr<HIR::Type> (type),
auto translated_type = std::unique_ptr<HIR::Type> (
ASTLoweringType::translate (param.get_type ()));
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
auto hir_param
ASTLoweringBlock::translate (*function.get_definition ().value (),
&terminated));
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, function.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
- mappings->insert_location (function_body->get_mappings ().get_hirid (),
- function.get_locus ());
+ mappings.insert_location (function_body->get_mappings ().get_hirid (),
+ function.get_locus ());
auto fn
= new HIR::Function (mapping, std::move (function_name),
// add the mappings for the function params at the end
for (auto ¶m : fn->get_function_params ())
{
- mappings->insert_hir_param (¶m);
- mappings->insert_location (mapping.get_hirid (), param.get_locus ());
+ mappings.insert_hir_param (¶m);
+ mappings.insert_location (mapping.get_hirid (), param.get_locus ());
}
translated = fn;
HIR::Type *impl_type = ASTLoweringType::translate (impl_block.get_type ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, impl_block.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
std::vector<std::unique_ptr<HIR::ImplItem>> impl_items;
std::vector<HirId> impl_item_ids;
impl_block.get_locus ());
translated = hir_impl_block;
- mappings->insert_hir_impl_block (hir_impl_block);
+ mappings.insert_hir_impl_block (hir_impl_block);
for (auto &impl_item_id : impl_item_ids)
{
- mappings->insert_impl_item_mapping (impl_item_id, hir_impl_block);
+ mappings.insert_impl_item_mapping (impl_item_id, hir_impl_block);
}
}
trait_item_ids.push_back (lowered->get_mappings ().get_hirid ());
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, trait.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
auto trait_unsafety = Unsafety::Normal;
if (trait.is_unsafe ())
for (auto trait_item_id : trait_item_ids)
{
- mappings->insert_trait_item_mapping (trait_item_id, hir_trait);
+ mappings.insert_trait_item_mapping (trait_item_id, hir_trait);
}
}
HIR::TypePath *trait_ref
= ASTLowerTypePath::translate (impl_block.get_trait_path ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, impl_block.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
std::vector<std::unique_ptr<HIR::ImplItem>> impl_items;
std::vector<HirId> impl_item_ids;
impl_block.get_locus ());
translated = hir_impl_block;
- mappings->insert_hir_impl_block (hir_impl_block);
+ mappings.insert_hir_impl_block (hir_impl_block);
for (auto &impl_item_id : impl_item_ids)
{
- mappings->insert_impl_item_mapping (impl_item_id, hir_impl_block);
+ mappings.insert_impl_item_mapping (impl_item_id, hir_impl_block);
}
}
HIR::SimplePathSegment
ASTLoweringSimplePath::lower (const AST::SimplePathSegment &segment)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
auto node_id = segment.get_node_id ();
auto mapping = Analysis::NodeMapping (crate_num, node_id,
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
auto hir_seg = HIR::SimplePathSegment (mapping);
- mappings->insert_node_to_hir (node_id, mapping.get_hirid ());
- // mappings->insert_simple_path_segment (crate_num, node_id, &segment);
+ mappings.insert_node_to_hir (node_id, mapping.get_hirid ());
+ // mappings.insert_simple_path_segment (crate_num, node_id, &segment);
return hir_seg;
}
for (auto &segment : path.get_segments ())
segments.emplace_back (lower (segment));
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
auto node_id = path.get_node_id ();
auto mapping = Analysis::NodeMapping (crate_num, node_id,
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
auto lowered
= HIR::SimplePath (std::move (segments), mapping, path.get_locus ());
- mappings->insert_node_to_hir (node_id, mapping.get_hirid ());
- // mappings->insert_simple_path (crate_num, node_id, &path);
+ mappings.insert_node_to_hir (node_id, mapping.get_hirid ());
+ // mappings.insert_simple_path (crate_num, node_id, &path);
return lowered;
}
rust_assert (resolver.translated != nullptr);
- resolver.mappings->insert_hir_pattern (resolver.translated);
- resolver.mappings->insert_location (
+ resolver.mappings.insert_hir_pattern (resolver.translated);
+ resolver.mappings.insert_location (
resolver.translated->get_mappings ().get_hirid (), pattern.get_locus ());
return resolver.translated;
void
ASTLoweringPattern::visit (AST::IdentifierPattern &pattern)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
std::unique_ptr<Pattern> to_bind;
break;
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated = new HIR::TupleStructPattern (
auto &tuple
= static_cast<AST::StructPatternFieldTuplePat &> (*field);
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, tuple.get_node_id (),
- mappings->get_next_hir_id (
- crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
std::unique_ptr<HIR::Pattern> pat (
AST::StructPatternFieldIdentPat &ident
= static_cast<AST::StructPatternFieldIdentPat &> (*field);
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, ident.get_node_id (),
- mappings->get_next_hir_id (
- crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
std::unique_ptr<HIR::Pattern> pat (
AST::StructPatternFieldIdent &ident
= static_cast<AST::StructPatternFieldIdent &> (*field.get ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, ident.get_node_id (),
- mappings->get_next_hir_id (
- crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
f = new HIR::StructPatternFieldIdent (
// insert the reverse mappings and locations
auto field_id = f->get_mappings ().get_hirid ();
auto field_node_id = f->get_mappings ().get_nodeid ();
- mappings->insert_location (field_id, f->get_locus ());
- mappings->insert_node_to_hir (field_node_id, field_id);
+ mappings.insert_location (field_id, f->get_locus ());
+ mappings.insert_node_to_hir (field_node_id, field_id);
// add it to the lowered fields list
fields.push_back (std::unique_ptr<HIR::StructPatternField> (f));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
HIR::StructPatternElements elems (std::move (fields));
void
ASTLoweringPattern::visit (AST::WildcardPattern &pattern)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated = new HIR::WildcardPattern (mapping, pattern.get_locus ());
break;
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
void
ASTLoweringPattern::visit (AST::LiteralPattern &pattern)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
HIR::Literal l = lower_literal (pattern.get_literal ());
auto upper_bound = lower_range_pattern_bound (pattern.get_upper_bound ());
auto lower_bound = lower_range_pattern_bound (pattern.get_lower_bound ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
void
ASTLoweringPattern::visit (AST::ReferencePattern &pattern)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
HIR::Pattern *inner
if (pattern.is_double_reference ())
{
Analysis::NodeMapping mapping2 (crate_num, pattern.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
= new HIR::ReferencePattern (mapping2,
items.push_back (std::unique_ptr<HIR::Pattern> (item));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
void
ASTLoweringPattern::visit (AST::AltPattern &pattern)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
std::vector<std::unique_ptr<HIR::Pattern>> alts;
return nullptr;
*terminated = resolver.terminated;
- resolver.mappings->insert_location (
+ resolver.mappings.insert_location (
resolver.translated->get_mappings ().get_hirid (),
resolver.translated->get_locus ());
- resolver.mappings->insert_hir_stmt (resolver.translated);
+ resolver.mappings.insert_hir_stmt (resolver.translated);
return resolver.translated;
}
{
HIR::Expr *expr = ASTLoweringExpr::translate (stmt.get_expr (), &terminated);
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, stmt.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
= new HIR::ExprStmt (mapping, std::unique_ptr<HIR::Expr> (expr),
= stmt.has_init_expr () ? ASTLoweringExpr::translate (stmt.get_init_expr ())
: nullptr;
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, stmt.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
= new HIR::LetStmt (mapping, std::unique_ptr<HIR::Pattern> (variables),
void
ASTLoweringStmt::visit (AST::EmptyStmt &empty)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, empty.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated = new HIR::EmptyStmt (mapping, empty.get_locus ());
}
field.accept_vis (compiler);
rust_assert (compiler.translated != nullptr);
- compiler.mappings->insert_hir_struct_field (compiler.translated);
- compiler.mappings->insert_location (
+ compiler.mappings.insert_hir_struct_field (compiler.translated);
+ compiler.mappings.insert_location (
compiler.translated->get_mappings ().get_hirid (), field.get_locus ());
return compiler.translated;
void
ASTLowerTypePath::visit (AST::TypePathSegmentFunction &segment)
{
- auto crate_num = mappings->get_current_crate ();
- auto hirid = mappings->get_next_hir_id (crate_num);
+ auto crate_num = mappings.get_current_crate ();
+ auto hirid = mappings.get_next_hir_id (crate_num);
Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid,
UNKNOWN_LOCAL_DEFID);
void
ASTLowerTypePath::visit (AST::TypePathSegment &segment)
{
- auto crate_num = mappings->get_current_crate ();
- auto hirid = mappings->get_next_hir_id (crate_num);
+ auto crate_num = mappings.get_current_crate ();
+ auto hirid = mappings.get_next_hir_id (crate_num);
Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid,
UNKNOWN_LOCAL_DEFID);
auto generic_args = lower_generic_args (segment.get_generic_args ());
- auto crate_num = mappings->get_current_crate ();
- auto hirid = mappings->get_next_hir_id (crate_num);
+ auto crate_num = mappings.get_current_crate ();
+ auto hirid = mappings.get_next_hir_id (crate_num);
Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid,
UNKNOWN_LOCAL_DEFID);
std::unique_ptr<HIR::TypePathSegment> (translated_segment));
}
- auto crate_num = mappings->get_current_crate ();
- auto hirid = mappings->get_next_hir_id (crate_num);
+ auto crate_num = mappings.get_current_crate ();
+ auto hirid = mappings.get_next_hir_id (crate_num);
Analysis::NodeMapping mapping (crate_num, path.get_node_id (), hirid,
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_localdef_id (crate_num));
translated
= new HIR::TypePath (std::move (mapping), std::move (translated_segments),
void
ASTLowerQualifiedPathInType::visit (AST::QualifiedPathInType &path)
{
- auto crate_num = mappings->get_current_crate ();
- auto hirid = mappings->get_next_hir_id (crate_num);
+ auto crate_num = mappings.get_current_crate ();
+ auto hirid = mappings.get_next_hir_id (crate_num);
Analysis::NodeMapping qual_mappings (
crate_num, path.get_qualified_path_type ().get_node_id (), hirid,
UNKNOWN_LOCAL_DEFID);
}
Analysis::NodeMapping mapping (crate_num, path.get_node_id (), hirid,
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_localdef_id (crate_num));
translated = new HIR::QualifiedPathInType (std::move (mapping),
std::move (qual_path_type),
std::move (associated_segment),
type.accept_vis (resolver);
rust_assert (resolver.translated != nullptr);
- resolver.mappings->insert_hir_type (resolver.translated);
- resolver.mappings->insert_location (
+ resolver.mappings.insert_hir_type (resolver.translated);
+ resolver.mappings.insert_location (
resolver.translated->get_mappings ().get_hirid (),
resolver.translated->get_locus ());
default_to_static_lifetime);
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, fntype.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated = new HIR::BareFunctionType (
std::move (mapping), std::move (lifetime_params), std::move (qualifiers),
elems.push_back (std::unique_ptr<HIR::Type> (t));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, tuple.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated = new HIR::TupleType (std::move (mapping), std::move (elems),
tuple.get_locus ());
default_to_static_lifetime);
HIR::Expr *array_size = ASTLoweringExpr::translate (type.get_size_expr ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated
= new HIR::ArrayType (mapping, std::unique_ptr<HIR::Type> (translated_type),
= ASTLoweringType::translate (type.get_base_type (),
default_to_static_lifetime);
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated = new HIR::ReferenceType (mapping,
type.get_has_mut () ? Mutability::Mut
= ASTLoweringType::translate (type.get_type_pointed_to (),
default_to_static_lifetime);
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated
= new HIR::RawPointerType (mapping,
= ASTLoweringType::translate (type.get_elem_type (),
default_to_static_lifetime);
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated
= new HIR::SliceType (mapping, std::unique_ptr<HIR::Type> (base_type),
void
ASTLoweringType::visit (AST::InferredType &type)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated = new HIR::InferredType (mapping, type.get_locus ());
}
void
ASTLoweringType::visit (AST::NeverType &type)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated = new HIR::NeverType (mapping, type.get_locus ());
}
= ASTLoweringTypeBounds::translate (type.get_trait_bound ());
bounds.push_back (std::unique_ptr<HIR::TypeParamBound> (translated_bound));
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated = new HIR::TraitObjectType (mapping, std::move (bounds),
type.get_locus (), type.is_dyn ());
std::unique_ptr<HIR::TypeParamBound> (translated_bound));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated = new HIR::TraitObjectType (mapping, std::move (bounds),
type.get_locus (), type.is_dyn ());
param.accept_vis (resolver);
rust_assert (resolver.translated != nullptr);
- resolver.mappings->insert_location (
+ resolver.mappings.insert_location (
resolver.translated->get_mappings ().get_hirid (), param.get_locus ());
- resolver.mappings->insert_hir_generic_param (resolver.translated);
+ resolver.mappings.insert_hir_generic_param (resolver.translated);
return resolver.translated;
}
void
ASTLowerGenericParam::visit (AST::LifetimeParam ¶m)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
HIR::Lifetime lt (mapping, param.get_lifetime ().get_lifetime_type (),
param.get_lifetime ().get_lifetime_name (),
void
ASTLowerGenericParam::visit (AST::ConstGenericParam ¶m)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
auto type = ASTLoweringType::translate (param.get_type ());
? ASTLoweringType::translate (param.get_type ())
: nullptr;
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
- mappings->get_next_hir_id (crate_num),
- mappings->get_next_localdef_id (crate_num));
+ mappings.get_next_hir_id (crate_num),
+ mappings.get_next_localdef_id (crate_num));
translated
= new HIR::TypeParam (mapping, param.get_type_representation (),
type.accept_vis (resolver);
rust_assert (resolver.translated != nullptr);
- resolver.mappings->insert_location (
+ resolver.mappings.insert_location (
resolver.translated->get_mappings ().get_hirid (),
resolver.translated->get_locus ());
AST::TypePath &ast_trait_path = bound.get_type_path ();
HIR::TypePath *trait_path = ASTLowerTypePath::translate (ast_trait_path);
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, bound.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
BoundPolarity polarity = bound.has_opening_question_mark ()
rust_assert (compiler.translated != nullptr);
// FIXME
- // compiler.mappings->insert_location (
+ // compiler.mappings.insert_location (
// compiler.translated->get_mappings ().get_hirid (),
// compiler.translated->get_locus ());
lifetime_bounds.push_back (std::move (ll));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, item.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated = new HIR::LifetimeWhereClauseItem (mapping, std::move (l),
type_param_bounds.push_back (std::unique_ptr<HIR::TypeParamBound> (b));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, item.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
items.push_back (std::unique_ptr<HIR::Item> (translated));
}
- auto mappings = Analysis::Mappings::get ();
- auto crate_num = mappings->get_current_crate ();
+ auto &mappings = Analysis::Mappings::get ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, astCrate.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
return std::unique_ptr<HIR::Crate> (
}
bool tail_reachable = !block_did_terminate;
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
= new HIR::BlockExpr (mapping, std::move (block_stmts),
HIR::BlockExpr *block
= ASTLoweringBlock::translate (expr.get_if_block (), &ignored_terminated);
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated = new HIR::IfExpr (mapping, std::unique_ptr<HIR::Expr> (condition),
terminated = if_block_terminated && else_block_termianted;
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated = new HIR::IfExprConseqElse (
HIR::BlockExpr *block
= ASTLoweringBlock::translate (expr.get_if_block (), &ignored_terminated);
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated = new HIR::IfLetExpr (mapping, std::move (patterns),
rust_assert (else_block);
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated = new HIR::IfLetExprConseqElse (
{
HIR::Expr *value = ASTLoweringExpr::translate (field.get_value ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, field.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated = new HIR::StructExprFieldIdentifierValue (
{
HIR::Expr *value = ASTLoweringExpr::translate (field.get_value ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, field.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
void
ASTLowerStructExprField::visit (AST::StructExprFieldIdentifier &field)
{
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, field.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
HIR::Expr *loop_condition
= ASTLoweringExpr::translate (expr.get_predicate_expr (), &terminated);
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
std::unique_ptr<HIR::Expr> (kase_guard_expr),
match_case.get_arm ().get_outer_attrs ());
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
HIR::MatchCase kase (std::move (mapping), std::move (arm),
match_arms.push_back (std::move (kase));
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated
// insert the mappings for the segment
HIR::PathExprSegment *lowered_seg = &path_segments.back ();
- mappings->insert_hir_path_expr_seg (lowered_seg);
+ mappings.insert_hir_path_expr_seg (lowered_seg);
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated = new HIR::PathInExpression (mapping, std::move (path_segments),
? ASTLowerTypePath::translate (qualified_type.get_as_type_path ())
: nullptr;
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, qualified_type.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
return HIR::QualifiedPathType (mapping, std::unique_ptr<HIR::Type> (type),
// insert the mappings for the segment
HIR::PathExprSegment *lowered_seg = &path_segments.back ();
- mappings->insert_hir_path_expr_seg (lowered_seg);
+ mappings.insert_hir_path_expr_seg (lowered_seg);
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
translated = new HIR::QualifiedPathInExpression (mapping, qual_path_type,
// lookup the AST node for this
AST::Item *item = nullptr;
bool ok
- = mappings->lookup_ast_item (trait.get_mappings ().get_nodeid (), &item);
+ = mappings.lookup_ast_item (trait.get_mappings ().get_nodeid (), &item);
rust_assert (ok);
std::stringstream oss;
{
// lookup the AST node for this
AST::Item *item = nullptr;
- bool ok = mappings->lookup_ast_item (fn.get_mappings ().get_nodeid (), &item);
+ bool ok = mappings.lookup_ast_item (fn.get_mappings ().get_nodeid (), &item);
rust_assert (ok);
// is this a CFG macro or not
AST::Dump dumper (oss);
AST::Item *item;
- auto ok = mappings->lookup_ast_item (macro, &item);
+ auto ok = mappings.lookup_ast_item (macro, &item);
rust_assert (ok);
dumper.go (*item);
};
PublicInterface::PublicInterface (HIR::Crate &crate)
- : crate (crate), mappings (*Analysis::Mappings::get ()), context ()
+ : crate (crate), mappings (Analysis::Mappings::get ()), context ()
{}
void
std::string
PublicInterface::expected_metadata_filename ()
{
- auto mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
- const std::string current_crate_name = mappings->get_current_crate_name ();
+ const std::string current_crate_name = mappings.get_current_crate_name ();
return current_crate_name + extension_path;
}
const std::string &get_interface_buffer () const;
private:
- Analysis::Mappings *mappings;
+ Analysis::Mappings &mappings;
std::vector<std::reference_wrapper<const HIR::Module>> module_stack;
std::string public_interface_buffer;
bool resolve_visibility (const AST::Visibility &vis);
Resolver *resolver;
- Analysis::Mappings *mappings;
+ Analysis::Mappings &mappings;
NodeId resolved_node;
};
rust_error_at (r, "redefined multiple times");
});
- mappings->insert_canonical_path (function.get_node_id (), cpath);
+ mappings.insert_canonical_path (function.get_node_id (), cpath);
}
void visit (AST::TraitItemConst &constant) override
rust_error_at (r, "redefined multiple times");
});
- mappings->insert_canonical_path (constant.get_node_id (), cpath);
+ mappings.insert_canonical_path (constant.get_node_id (), cpath);
}
void visit (AST::TraitItemType &type) override
rust_error_at (r, "redefined multiple times");
});
- mappings->insert_canonical_path (type.get_node_id (), cpath);
+ mappings.insert_canonical_path (type.get_node_id (), cpath);
}
private:
});
NodeId current_module = resolver->peek_current_module_scope ();
- mappings->insert_module_child_item (current_module, decl);
+ mappings.insert_module_child_item (current_module, decl);
}
void visit (AST::ExternalStaticItem &item) override
});
NodeId current_module = resolver->peek_current_module_scope ();
- mappings->insert_module_child_item (current_module, decl);
+ mappings.insert_module_child_item (current_module, decl);
}
void visit (AST::ExternalTypeItem &type) override
});
NodeId current_module = resolver->peek_current_module_scope ();
- mappings->insert_module_child_item (current_module, decl);
+ mappings.insert_module_child_item (current_module, decl);
}
private:
function.get_function_name ().as_string ());
auto path = prefix.append (decl);
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (function.get_node_id (), cpath);
+ mappings.insert_canonical_path (function.get_node_id (), cpath);
NodeId scope_node_id = function.get_node_id ();
resolver->get_name_scope ().push (scope_node_id);
type.get_identifier ().as_string ());
auto path = prefix.append (decl);
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (type.get_node_id (), cpath);
+ mappings.insert_canonical_path (type.get_node_id (), cpath);
for (auto &bound : type.get_type_param_bounds ())
ResolveTypeBound::go (*bound);
constant.get_identifier ().as_string ());
auto path = prefix.append (decl);
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (constant.get_node_id (), cpath);
+ mappings.insert_canonical_path (constant.get_node_id (), cpath);
ResolveType::go (constant.get_type ());
alias.get_new_type_name ().as_string ());
auto path = prefix.append (talias);
auto cpath = canonical_prefix.append (talias);
- mappings->insert_canonical_path (alias.get_node_id (), cpath);
+ mappings.insert_canonical_path (alias.get_node_id (), cpath);
NodeId scope_node_id = alias.get_node_id ();
resolver->get_type_scope ().push (scope_node_id);
module.get_name ().as_string ());
auto path = prefix.append (mod);
auto cpath = canonical_prefix.append (mod);
- mappings->insert_canonical_path (module.get_node_id (), cpath);
+ mappings.insert_canonical_path (module.get_node_id (), cpath);
resolve_visibility (module.get_visibility ());
struct_decl.get_identifier ().as_string ());
auto path = prefix.append (decl);
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (struct_decl.get_node_id (), cpath);
+ mappings.insert_canonical_path (struct_decl.get_node_id (), cpath);
resolve_visibility (struct_decl.get_visibility ());
enum_decl.get_identifier ().as_string ());
auto path = prefix.append (decl);
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (enum_decl.get_node_id (), cpath);
+ mappings.insert_canonical_path (enum_decl.get_node_id (), cpath);
resolve_visibility (enum_decl.get_visibility ());
item.get_identifier ().as_string ());
auto path = prefix.append (decl);
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (item.get_node_id (), cpath);
+ mappings.insert_canonical_path (item.get_node_id (), cpath);
}
void
item.get_identifier ().as_string ());
auto path = prefix.append (decl);
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (item.get_node_id (), cpath);
+ mappings.insert_canonical_path (item.get_node_id (), cpath);
for (auto &field : item.get_tuple_fields ())
{
item.get_identifier ().as_string ());
auto path = prefix.append (decl);
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (item.get_node_id (), cpath);
+ mappings.insert_canonical_path (item.get_node_id (), cpath);
for (auto &field : item.get_struct_fields ())
{
auto path = prefix.append (decl);
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (item.get_node_id (), cpath);
+ mappings.insert_canonical_path (item.get_node_id (), cpath);
}
void
struct_decl.get_identifier ().as_string ());
auto path = prefix.append (decl);
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (struct_decl.get_node_id (), cpath);
+ mappings.insert_canonical_path (struct_decl.get_node_id (), cpath);
resolve_visibility (struct_decl.get_visibility ());
union_decl.get_identifier ().as_string ());
auto path = prefix.append (decl);
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (union_decl.get_node_id (), cpath);
+ mappings.insert_canonical_path (union_decl.get_node_id (), cpath);
resolve_visibility (union_decl.get_visibility ());
var.get_identifier ().as_string ());
auto path = prefix.append (decl);
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (var.get_node_id (), cpath);
+ mappings.insert_canonical_path (var.get_node_id (), cpath);
ResolveType::go (var.get_type ());
ResolveExpr::go (var.get_expr (), path, cpath);
constant.get_identifier ());
auto path = prefix.append (decl);
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (constant.get_node_id (), cpath);
+ mappings.insert_canonical_path (constant.get_node_id (), cpath);
resolve_visibility (constant.get_visibility ());
auto path = prefix.append (decl);
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (function.get_node_id (), cpath);
+ mappings.insert_canonical_path (function.get_node_id (), cpath);
resolve_visibility (function.get_visibility ());
continue;
auto decl = CanonicalPath::new_seg (resolved_node_id, import.get_name ());
- mappings->insert_module_child_item (current_module, decl);
+ mappings.insert_module_child_item (current_module, decl);
resolver->get_type_scope ().insert (decl, resolved_node_id,
path.get_locus (),
auto path = prefix.append (decl);
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (function.get_node_id (), cpath);
+ mappings.insert_canonical_path (function.get_node_id (), cpath);
resolve_visibility (function.get_visibility ());
&& previous_resolved_node_id == module_scope_id)
{
tl::optional<CanonicalPath &> resolved_child
- = mappings->lookup_module_child (module_scope_id,
- ident_seg.as_string ());
+ = mappings.lookup_module_child (module_scope_id,
+ ident_seg.as_string ());
if (resolved_child.has_value ())
{
NodeId resolved_node = resolved_child->get_node_id ();
bool did_resolve_segment = resolved_node_id != UNKNOWN_NODEID;
if (did_resolve_segment)
{
- if (mappings->node_is_module (resolved_node_id)
- || mappings->node_is_crate (resolved_node_id))
+ if (mappings.node_is_module (resolved_node_id)
+ || mappings.node_is_crate (resolved_node_id))
{
module_scope_id = resolved_node_id;
}
}
tl::optional<CanonicalPath &> resolved_child
- = mappings->lookup_module_child (module_scope_id,
- segment.get_segment_name ());
+ = mappings.lookup_module_child (module_scope_id,
+ segment.get_segment_name ());
if (resolved_child.has_value ())
{
NodeId resolved_node = resolved_child->get_node_id ();
return UNKNOWN_NODEID;
}
- if (mappings->node_is_module (resolved_node_id))
+ if (mappings.node_is_module (resolved_node_id))
{
module_scope_id = resolved_node_id;
}
constant.get_identifier ());
auto path = decl; // this ensures we have the correct relative resolution
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (constant.get_node_id (), cpath);
+ mappings.insert_canonical_path (constant.get_node_id (), cpath);
resolver->get_name_scope ().insert (
path, constant.get_node_id (), constant.get_locus (), false,
struct_decl.get_identifier ().as_string ());
auto path = decl; // this ensures we have the correct relative resolution
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (struct_decl.get_node_id (), cpath);
+ mappings.insert_canonical_path (struct_decl.get_node_id (), cpath);
resolver->get_type_scope ().insert (
path, struct_decl.get_node_id (), struct_decl.get_locus (), false,
enum_decl.get_identifier ().as_string ());
auto path = decl; // this ensures we have the correct relative resolution
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (enum_decl.get_node_id (), cpath);
+ mappings.insert_canonical_path (enum_decl.get_node_id (), cpath);
resolver->get_type_scope ().insert (
path, enum_decl.get_node_id (), enum_decl.get_locus (), false,
item.get_identifier ().as_string ()));
auto path = decl; // this ensures we have the correct relative resolution
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (item.get_node_id (), cpath);
+ mappings.insert_canonical_path (item.get_node_id (), cpath);
resolver->get_type_scope ().insert (
path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type,
item.get_identifier ().as_string ()));
auto path = decl; // this ensures we have the correct relative resolution
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (item.get_node_id (), cpath);
+ mappings.insert_canonical_path (item.get_node_id (), cpath);
resolver->get_type_scope ().insert (
path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type,
item.get_identifier ().as_string ()));
auto path = decl; // this ensures we have the correct relative resolution
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (item.get_node_id (), cpath);
+ mappings.insert_canonical_path (item.get_node_id (), cpath);
resolver->get_type_scope ().insert (
path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type,
item.get_identifier ().as_string ()));
auto path = decl; // this ensures we have the correct relative resolution
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (item.get_node_id (), cpath);
+ mappings.insert_canonical_path (item.get_node_id (), cpath);
resolver->get_type_scope ().insert (
path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type,
struct_decl.get_identifier ().as_string ());
auto path = decl; // this ensures we have the correct relative resolution
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (struct_decl.get_node_id (), cpath);
+ mappings.insert_canonical_path (struct_decl.get_node_id (), cpath);
resolver->get_type_scope ().insert (
path, struct_decl.get_node_id (), struct_decl.get_locus (), false,
union_decl.get_identifier ().as_string ());
auto path = decl; // this ensures we have the correct relative resolution
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (union_decl.get_node_id (), cpath);
+ mappings.insert_canonical_path (union_decl.get_node_id (), cpath);
resolver->get_type_scope ().insert (
path, union_decl.get_node_id (), union_decl.get_locus (), false,
function.get_function_name ().as_string ());
auto path = decl; // this ensures we have the correct relative resolution
auto cpath = canonical_prefix.append (decl);
- mappings->insert_canonical_path (function.get_node_id (), cpath);
+ mappings.insert_canonical_path (function.get_node_id (), cpath);
resolver->get_name_scope ().insert (
path, function.get_node_id (), function.get_locus (), false,
item.accept_vis (resolver);
NodeId current_module = resolver.resolver->peek_current_module_scope ();
- resolver.mappings->insert_child_item_to_parent_module_mapping (
+ resolver.mappings.insert_child_item_to_parent_module_mapping (
item.get_node_id (), current_module);
}
});
NodeId current_module = resolver->peek_current_module_scope ();
- mappings->insert_module_child_item (current_module, mod);
- mappings->insert_module_child (current_module, module.get_node_id ());
+ mappings.insert_module_child_item (current_module, mod);
+ mappings.insert_module_child (current_module, module.get_node_id ());
resolver->push_new_module_scope (module.get_node_id ());
for (auto &item : module.get_items ())
resolver->pop_module_scope ();
- mappings->insert_canonical_path (module.get_node_id (), cpath);
+ mappings.insert_canonical_path (module.get_node_id (), cpath);
}
void visit (AST::TypeAlias &alias) override
});
NodeId current_module = resolver->peek_current_module_scope ();
- mappings->insert_module_child_item (current_module, talias);
- mappings->insert_canonical_path (alias.get_node_id (), cpath);
+ mappings.insert_module_child_item (current_module, talias);
+ mappings.insert_canonical_path (alias.get_node_id (), cpath);
}
void visit (AST::TupleStruct &struct_decl) override
});
NodeId current_module = resolver->peek_current_module_scope ();
- mappings->insert_module_child_item (current_module, decl);
- mappings->insert_canonical_path (struct_decl.get_node_id (), cpath);
+ mappings.insert_module_child_item (current_module, decl);
+ mappings.insert_canonical_path (struct_decl.get_node_id (), cpath);
}
void visit (AST::Enum &enum_decl) override
resolver->pop_module_scope ();
NodeId current_module = resolver->peek_current_module_scope ();
- mappings->insert_module_child_item (current_module, decl);
- mappings->insert_canonical_path (enum_decl.get_node_id (), cpath);
+ mappings.insert_module_child_item (current_module, decl);
+ mappings.insert_canonical_path (enum_decl.get_node_id (), cpath);
}
void visit (AST::EnumItem &item) override
rust_error_at (r, "redefined multiple times");
});
- mappings->insert_canonical_path (item.get_node_id (), cpath);
+ mappings.insert_canonical_path (item.get_node_id (), cpath);
NodeId current_module = resolver->peek_current_module_scope ();
- mappings->insert_module_child_item (current_module, decl);
- mappings->insert_module_child (current_module, item.get_node_id ());
+ mappings.insert_module_child_item (current_module, decl);
+ mappings.insert_module_child (current_module, item.get_node_id ());
}
void visit (AST::EnumItemTuple &item) override
rust_error_at (r, "redefined multiple times");
});
- mappings->insert_canonical_path (item.get_node_id (), cpath);
+ mappings.insert_canonical_path (item.get_node_id (), cpath);
NodeId current_module = resolver->peek_current_module_scope ();
- mappings->insert_module_child_item (current_module, decl);
- mappings->insert_module_child (current_module, item.get_node_id ());
+ mappings.insert_module_child_item (current_module, decl);
+ mappings.insert_module_child (current_module, item.get_node_id ());
}
void visit (AST::EnumItemStruct &item) override
rust_error_at (r, "redefined multiple times");
});
- mappings->insert_canonical_path (item.get_node_id (), cpath);
+ mappings.insert_canonical_path (item.get_node_id (), cpath);
NodeId current_module = resolver->peek_current_module_scope ();
- mappings->insert_module_child_item (current_module, decl);
- mappings->insert_module_child (current_module, item.get_node_id ());
+ mappings.insert_module_child_item (current_module, decl);
+ mappings.insert_module_child (current_module, item.get_node_id ());
}
void visit (AST::EnumItemDiscriminant &item) override
rust_error_at (r, "redefined multiple times");
});
- mappings->insert_canonical_path (item.get_node_id (), cpath);
+ mappings.insert_canonical_path (item.get_node_id (), cpath);
NodeId current_module = resolver->peek_current_module_scope ();
- mappings->insert_module_child_item (current_module, decl);
- mappings->insert_module_child (current_module, item.get_node_id ());
+ mappings.insert_module_child_item (current_module, decl);
+ mappings.insert_module_child (current_module, item.get_node_id ());
}
void visit (AST::StructStruct &struct_decl) override
});
NodeId current_module = resolver->peek_current_module_scope ();
- mappings->insert_module_child_item (current_module, decl);
- mappings->insert_canonical_path (struct_decl.get_node_id (), cpath);
+ mappings.insert_module_child_item (current_module, decl);
+ mappings.insert_canonical_path (struct_decl.get_node_id (), cpath);
}
void visit (AST::Union &union_decl) override
});
NodeId current_module = resolver->peek_current_module_scope ();
- mappings->insert_module_child_item (current_module, decl);
- mappings->insert_canonical_path (union_decl.get_node_id (), cpath);
+ mappings.insert_module_child_item (current_module, decl);
+ mappings.insert_canonical_path (union_decl.get_node_id (), cpath);
}
void visit (AST::StaticItem &var) override
});
NodeId current_module = resolver->peek_current_module_scope ();
- mappings->insert_module_child_item (current_module, decl);
- mappings->insert_canonical_path (var.get_node_id (), cpath);
+ mappings.insert_module_child_item (current_module, decl);
+ mappings.insert_canonical_path (var.get_node_id (), cpath);
}
void visit (AST::ConstantItem &constant) override
});
NodeId current_module = resolver->peek_current_module_scope ();
- mappings->insert_module_child_item (current_module, decl);
- mappings->insert_canonical_path (constant.get_node_id (), cpath);
+ mappings.insert_module_child_item (current_module, decl);
+ mappings.insert_canonical_path (constant.get_node_id (), cpath);
}
void visit (AST::Function &function) override
});
NodeId current_module = resolver->peek_current_module_scope ();
- mappings->insert_module_child_item (current_module, decl);
- mappings->insert_canonical_path (function.get_node_id (), cpath);
+ mappings.insert_module_child_item (current_module, decl);
+ mappings.insert_canonical_path (function.get_node_id (), cpath);
}
void visit (AST::InherentImpl &impl_block) override
ResolveTopLevelTraitItems::go (item.get (), path, cpath);
NodeId current_module = resolver->peek_current_module_scope ();
- mappings->insert_module_child_item (current_module, decl);
- mappings->insert_canonical_path (trait.get_node_id (), cpath);
+ mappings.insert_module_child_item (current_module, decl);
+ mappings.insert_canonical_path (trait.get_node_id (), cpath);
}
void visit (AST::ExternBlock &extern_block) override
NodeId resolved_crate = UNKNOWN_NODEID;
if (extern_crate.references_self ())
{
- CrateNum crate_num = mappings->get_current_crate ();
- bool ok = mappings->crate_num_to_nodeid (crate_num, resolved_crate);
+ CrateNum crate_num = mappings.get_current_crate ();
+ bool ok = mappings.crate_num_to_nodeid (crate_num, resolved_crate);
rust_assert (ok);
}
else
{
CrateNum found_crate_num = UNKNOWN_CRATENUM;
bool found
- = mappings->lookup_crate_name (extern_crate.get_referenced_crate (),
- found_crate_num);
+ = mappings.lookup_crate_name (extern_crate.get_referenced_crate (),
+ found_crate_num);
if (!found)
{
rust_error_at (extern_crate.get_locus (), "unknown crate %qs",
}
bool ok
- = mappings->crate_num_to_nodeid (found_crate_num, resolved_crate);
+ = mappings.crate_num_to_nodeid (found_crate_num, resolved_crate);
if (!ok)
{
rust_internal_error_at (extern_crate.get_locus (),
ResolveRelativeTypePath::go (AST::TypePath &path, NodeId &resolved_node_id)
{
auto resolver = Resolver::get ();
- auto mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
NodeId module_scope_id = resolver->peek_current_module_scope ();
NodeId previous_resolved_node_id = module_scope_id;
&& previous_resolved_node_id == module_scope_id)
{
tl::optional<CanonicalPath &> resolved_child
- = mappings->lookup_module_child (module_scope_id,
- ident_seg.as_string ());
+ = mappings.lookup_module_child (module_scope_id,
+ ident_seg.as_string ());
if (resolved_child.has_value ())
{
NodeId resolved_node = resolved_child->get_node_id ();
bool did_resolve_segment = resolved_node_id != UNKNOWN_NODEID;
if (did_resolve_segment)
{
- if (mappings->node_is_module (resolved_node_id)
- || mappings->node_is_crate (resolved_node_id))
+ if (mappings.node_is_module (resolved_node_id)
+ || mappings.node_is_crate (resolved_node_id))
{
module_scope_id = resolved_node_id;
}
return;
const CanonicalPath *type_path = nullptr;
- if (mappings->lookup_canonical_path (resolved_node, &type_path))
+ if (mappings.lookup_canonical_path (resolved_node, &type_path))
{
auto &final_seg = path.get_segments ().back ();
switch (final_seg->get_type ())
rust_error_at (locus, "was defined here");
});
- mappings->insert_canonical_path (param.get_node_id (), seg);
+ mappings.insert_canonical_path (param.get_node_id (), seg);
}
private:
: resolver (Resolver::get ()), mappings (Analysis::Mappings::get ())
{
// these are global
- resolver->get_type_scope ().push (mappings->get_next_node_id ());
+ resolver->get_type_scope ().push (mappings.get_next_node_id ());
resolver->insert_builtin_types (resolver->get_type_scope ().peek ());
resolver->push_new_type_rib (resolver->get_type_scope ().peek ());
}
NameResolution::go (AST::Crate &crate)
{
// lookup current crate name
- CrateNum cnum = mappings->get_current_crate ();
+ CrateNum cnum = mappings.get_current_crate ();
std::string crate_name;
- bool ok = mappings->get_crate_name (cnum, crate_name);
+ bool ok = mappings.get_crate_name (cnum, crate_name);
rust_assert (ok);
// setup the ribs
NameResolution ();
Resolver *resolver;
- Analysis::Mappings *mappings;
+ Analysis::Mappings &mappings;
};
} // namespace Resolver
// now do we need to keep mappings or something? or insert "uses" into our
// ForeverStack? can we do that? are mappings simpler?
- auto mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
AST::MacroRulesDefinition *rules_def = nullptr;
- if (!mappings->lookup_macro_def (definition->get_node_id (), &rules_def))
+ if (!mappings.lookup_macro_def (definition->get_node_id (), &rules_def))
{
// Macro definition not found, maybe it is not expanded yet.
return;
}
AST::MacroRulesDefinition *tmp_def = nullptr;
- if (mappings->lookup_macro_invocation (invoc, &tmp_def))
+ if (mappings.lookup_macro_invocation (invoc, &tmp_def))
return;
- mappings->insert_macro_invocation (invoc, rules_def);
+ mappings.insert_macro_invocation (invoc, rules_def);
}
void
Early::visit_attributes (std::vector<AST::Attribute> &attrs)
{
- auto mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
for (auto &attr : attrs)
{
continue;
}
- auto pm_def = mappings->lookup_derive_proc_macro_def (
+ auto pm_def = mappings.lookup_derive_proc_macro_def (
definition->get_node_id ());
rust_assert (pm_def.has_value ());
- mappings->insert_derive_proc_macro_invocation (trait,
- pm_def.value ());
+ mappings.insert_derive_proc_macro_invocation (trait,
+ pm_def.value ());
}
}
else if (Analysis::BuiltinAttributeMappings::get ()
"could not resolve attribute macro invocation");
return;
}
- auto pm_def = mappings->lookup_attribute_proc_macro_def (
+ auto pm_def = mappings.lookup_attribute_proc_macro_def (
definition->get_node_id ());
rust_assert (pm_def.has_value ());
- mappings->insert_attribute_proc_macro_invocation (attr.get_path (),
- pm_def.value ());
+ mappings.insert_attribute_proc_macro_invocation (attr.get_path (),
+ pm_def.value ());
}
}
}
EarlyNameResolver::EarlyNameResolver ()
: current_scope (UNKNOWN_NODEID), resolver (*Resolver::get ()),
- mappings (*Analysis::Mappings::get ())
+ mappings (Analysis::Mappings::get ())
{}
void
static NodeId
next_node_id ()
{
- return Analysis::Mappings::get ()->get_next_node_id ();
+ return Analysis::Mappings::get ().get_next_node_id ();
};
static HirId
next_hir_id ()
{
- return Analysis::Mappings::get ()->get_next_hir_id ();
+ return Analysis::Mappings::get ().get_next_hir_id ();
};
void
namespace Resolver2_0 {
NameResolutionContext::NameResolutionContext ()
- : mappings (*Analysis::Mappings::get ())
+ : mappings (Analysis::Mappings::get ())
{}
tl::expected<NodeId, DuplicateNameError>
Resolver::Resolver ()
: mappings (Analysis::Mappings::get ()), tyctx (TypeCheckContext::get ()),
- name_scope (Scope (mappings->get_current_crate ())),
- type_scope (Scope (mappings->get_current_crate ())),
- label_scope (Scope (mappings->get_current_crate ())),
- macro_scope (Scope (mappings->get_current_crate ())),
+ name_scope (Scope (mappings.get_current_crate ())),
+ type_scope (Scope (mappings.get_current_crate ())),
+ label_scope (Scope (mappings.get_current_crate ())),
+ macro_scope (Scope (mappings.get_current_crate ())),
global_type_node_id (UNKNOWN_NODEID), unit_ty_node_id (UNKNOWN_NODEID)
{
generate_builtins ();
Resolver::generate_builtins ()
{
auto u8
- = new TyTy::UintType (mappings->get_next_hir_id (), TyTy::UintType::U8);
+ = new TyTy::UintType (mappings.get_next_hir_id (), TyTy::UintType::U8);
auto u16
- = new TyTy::UintType (mappings->get_next_hir_id (), TyTy::UintType::U16);
+ = new TyTy::UintType (mappings.get_next_hir_id (), TyTy::UintType::U16);
auto u32
- = new TyTy::UintType (mappings->get_next_hir_id (), TyTy::UintType::U32);
+ = new TyTy::UintType (mappings.get_next_hir_id (), TyTy::UintType::U32);
auto u64
- = new TyTy::UintType (mappings->get_next_hir_id (), TyTy::UintType::U64);
+ = new TyTy::UintType (mappings.get_next_hir_id (), TyTy::UintType::U64);
auto u128
- = new TyTy::UintType (mappings->get_next_hir_id (), TyTy::UintType::U128);
- auto i8 = new TyTy::IntType (mappings->get_next_hir_id (), TyTy::IntType::I8);
+ = new TyTy::UintType (mappings.get_next_hir_id (), TyTy::UintType::U128);
+ auto i8 = new TyTy::IntType (mappings.get_next_hir_id (), TyTy::IntType::I8);
auto i16
- = new TyTy::IntType (mappings->get_next_hir_id (), TyTy::IntType::I16);
+ = new TyTy::IntType (mappings.get_next_hir_id (), TyTy::IntType::I16);
auto i32
- = new TyTy::IntType (mappings->get_next_hir_id (), TyTy::IntType::I32);
+ = new TyTy::IntType (mappings.get_next_hir_id (), TyTy::IntType::I32);
auto i64
- = new TyTy::IntType (mappings->get_next_hir_id (), TyTy::IntType::I64);
+ = new TyTy::IntType (mappings.get_next_hir_id (), TyTy::IntType::I64);
auto i128
- = new TyTy::IntType (mappings->get_next_hir_id (), TyTy::IntType::I128);
- auto rbool = new TyTy::BoolType (mappings->get_next_hir_id ());
+ = new TyTy::IntType (mappings.get_next_hir_id (), TyTy::IntType::I128);
+ auto rbool = new TyTy::BoolType (mappings.get_next_hir_id ());
auto f32
- = new TyTy::FloatType (mappings->get_next_hir_id (), TyTy::FloatType::F32);
+ = new TyTy::FloatType (mappings.get_next_hir_id (), TyTy::FloatType::F32);
auto f64
- = new TyTy::FloatType (mappings->get_next_hir_id (), TyTy::FloatType::F64);
- auto usize = new TyTy::USizeType (mappings->get_next_hir_id ());
- auto isize = new TyTy::ISizeType (mappings->get_next_hir_id ());
- auto char_tyty = new TyTy::CharType (mappings->get_next_hir_id ());
- auto str = new TyTy::StrType (mappings->get_next_hir_id ());
- auto never = new TyTy::NeverType (mappings->get_next_hir_id ());
+ = new TyTy::FloatType (mappings.get_next_hir_id (), TyTy::FloatType::F64);
+ auto usize = new TyTy::USizeType (mappings.get_next_hir_id ());
+ auto isize = new TyTy::ISizeType (mappings.get_next_hir_id ());
+ auto char_tyty = new TyTy::CharType (mappings.get_next_hir_id ());
+ auto str = new TyTy::StrType (mappings.get_next_hir_id ());
+ auto never = new TyTy::NeverType (mappings.get_next_hir_id ());
setup_builtin ("u8", u8);
setup_builtin ("u16", u16);
// unit type ()
TyTy::TupleType *unit_tyty
- = TyTy::TupleType::get_unit_type (mappings->get_next_hir_id ());
+ = TyTy::TupleType::get_unit_type (mappings.get_next_hir_id ());
std::vector<std::unique_ptr<AST::Type> > elems;
AST::TupleType *unit_type
= new AST::TupleType (std::move (elems), BUILTINS_LOCATION);
= new AST::TypePath (::std::move (segs), BUILTINS_LOCATION, false);
builtins.push_back (builtin_type);
tyctx->insert_builtin (tyty->get_ref (), builtin_type->get_node_id (), tyty);
- mappings->insert_node_to_hir (builtin_type->get_node_id (), tyty->get_ref ());
- mappings->insert_canonical_path (
+ mappings.insert_node_to_hir (builtin_type->get_node_id (), tyty->get_ref ());
+ mappings.insert_canonical_path (
builtin_type->get_node_id (),
CanonicalPath::new_seg (builtin_type->get_node_id (), name));
}
void generate_builtins ();
void setup_builtin (const std::string &name, TyTy::BaseType *tyty);
- Analysis::Mappings *mappings;
+ Analysis::Mappings &mappings;
TypeCheckContext *tyctx;
std::vector<AST::Type *> builtins;
ctx.scoped (Rib::Kind::Module, module.get_node_id (), sub_visitor,
module.get_name ());
- if (Analysis::Mappings::get ()->lookup_ast_module (module.get_node_id ())
+ if (Analysis::Mappings::get ().lookup_ast_module (module.get_node_id ())
== tl::nullopt)
- Analysis::Mappings::get ()->insert_ast_module (&module);
+ Analysis::Mappings::get ().insert_ast_module (&module);
}
void
void
TopLevel::visit (AST::ExternCrate &crate)
{
+ auto &mappings = Analysis::Mappings::get ();
CrateNum num;
- rust_assert (Analysis::Mappings::get ()->lookup_crate_name (
- crate.get_referenced_crate (), num));
+ rust_assert (mappings.lookup_crate_name (crate.get_referenced_crate (), num));
- auto attribute_macros
- = Analysis::Mappings::get ()->lookup_attribute_proc_macros (num);
+ auto attribute_macros = mappings.lookup_attribute_proc_macros (num);
- auto bang_macros = Analysis::Mappings::get ()->lookup_bang_proc_macros (num);
+ auto bang_macros = mappings.lookup_bang_proc_macros (num);
- auto derive_macros
- = Analysis::Mappings::get ()->lookup_derive_proc_macros (num);
+ auto derive_macros = mappings.lookup_derive_proc_macros (num);
auto sub_visitor = [&] () {
// TODO: Find a way to keep this part clean without the double dispatch.
{
insert_macros (derive_macros.value (), ctx);
for (auto ¯o : derive_macros.value ())
- Analysis::Mappings::get ()->insert_derive_proc_macro_def (macro);
+ mappings.insert_derive_proc_macro_def (macro);
}
if (attribute_macros.has_value ())
{
insert_macros (attribute_macros.value (), ctx);
for (auto ¯o : attribute_macros.value ())
- Analysis::Mappings::get ()->insert_attribute_proc_macro_def (macro);
+ mappings.insert_attribute_proc_macro_def (macro);
}
if (bang_macros.has_value ())
{
insert_macros (bang_macros.value (), ctx);
for (auto ¯o : bang_macros.value ())
- Analysis::Mappings::get ()->insert_bang_proc_macro_def (macro);
+ mappings.insert_bang_proc_macro_def (macro);
}
};
if (macro.get_kind () == AST::MacroRulesDefinition::MacroKind::DeclMacro)
insert_or_error_out (macro.get_rule_name (), macro, Namespace::Macros);
- auto mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
AST::MacroRulesDefinition *tmp = nullptr;
- if (mappings->lookup_macro_def (macro.get_node_id (), &tmp))
+ if (mappings.lookup_macro_def (macro.get_node_id (), &tmp))
return;
- mappings->insert_macro_def (¯o);
+ mappings.insert_macro_def (¯o);
}
void
return false;
auto result
- = Analysis::Mappings::get ()->lookup_ast_module (resolved->get_node_id ());
+ = Analysis::Mappings::get ().lookup_ast_module (resolved->get_node_id ());
if (!result.has_value ())
return false;
Session &
Session::get_instance ()
{
- static Session instance;
+ static Session instance{};
return instance;
}
options.set_crate_name (crate_name);
}
- CrateNum crate_num = mappings->get_next_crate_num (options.get_crate_name ());
- mappings->set_current_crate (crate_num);
+ CrateNum crate_num = mappings.get_next_crate_num (options.get_crate_name ());
+ mappings.set_current_crate (crate_num);
rust_debug ("Attempting to parse file: %s", file);
compile_crate (file);
void
Session::handle_crate_name (const AST::Crate &parsed_crate)
{
- auto mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
auto crate_name_changed = false;
auto error = Error (UNDEF_LOCATION, std::string ());
}
crate_name_changed = true;
options.set_crate_name (msg_str);
- mappings->set_crate_name (mappings->get_current_crate (), msg_str);
+ mappings.set_crate_name (mappings.get_current_crate (), msg_str);
}
options.crate_name_set_manually |= crate_name_changed;
return;
// setup the mappings for this AST
- CrateNum current_crate = mappings->get_current_crate ();
+ CrateNum current_crate = mappings.get_current_crate ();
AST::Crate &parsed_crate
- = mappings->insert_ast_crate (std::move (ast_crate), current_crate);
+ = mappings.insert_ast_crate (std::move (ast_crate), current_crate);
/* basic pipeline:
* - lex
return;
// add the mappings to it
- HIR::Crate &hir = mappings->insert_hir_crate (std::move (lowered));
+ HIR::Crate &hir = mappings.insert_hir_crate (std::move (lowered));
if (options.dump_option_enabled (CompileOptions::HIR_DUMP))
{
dump_hir (hir);
{
// has it already been loaded?
CrateNum found_crate_num = UNKNOWN_CRATENUM;
- bool found = mappings->lookup_crate_name (crate_name, found_crate_num);
+ bool found = mappings.lookup_crate_name (crate_name, found_crate_num);
if (found)
{
NodeId resolved_node_id = UNKNOWN_NODEID;
bool resolved
- = mappings->crate_num_to_nodeid (found_crate_num, resolved_node_id);
+ = mappings.crate_num_to_nodeid (found_crate_num, resolved_node_id);
rust_assert (resolved);
return resolved_node_id;
}
// ensure the current vs this crate name don't collide
- const std::string current_crate_name = mappings->get_current_crate_name ();
+ const std::string current_crate_name = mappings.get_current_crate_name ();
if (current_crate_name.compare (extern_crate.get_crate_name ()) == 0)
{
rust_error_at (locus, "current crate name %qs collides with this",
}
// setup mappings
- CrateNum saved_crate_num = mappings->get_current_crate ();
+ CrateNum saved_crate_num = mappings.get_current_crate ();
CrateNum crate_num
- = mappings->get_next_crate_num (extern_crate.get_crate_name ());
- mappings->set_current_crate (crate_num);
+ = mappings.get_next_crate_num (extern_crate.get_crate_name ());
+ mappings.set_current_crate (crate_num);
// then lets parse this as a 2nd crate
Lexer lex (extern_crate.get_metadata (), linemap);
std::unique_ptr<AST::Crate> metadata_crate = parser.parse_crate ();
AST::Crate &parsed_crate
- = mappings->insert_ast_crate (std::move (metadata_crate), crate_num);
+ = mappings.insert_ast_crate (std::move (metadata_crate), crate_num);
std::vector<AttributeProcMacro> attribute_macros;
std::vector<CustomDeriveProcMacro> derive_macros;
}
}
- mappings->insert_attribute_proc_macros (crate_num, attribute_macros);
- mappings->insert_bang_proc_macros (crate_num, bang_macros);
- mappings->insert_derive_proc_macros (crate_num, derive_macros);
+ mappings.insert_attribute_proc_macros (crate_num, attribute_macros);
+ mappings.insert_bang_proc_macros (crate_num, bang_macros);
+ mappings.insert_derive_proc_macros (crate_num, derive_macros);
// name resolve it
Resolver::NameResolution::Resolve (parsed_crate);
// perform hir lowering
std::unique_ptr<HIR::Crate> lowered
= HIR::ASTLowering::Resolve (parsed_crate);
- HIR::Crate &hir = mappings->insert_hir_crate (std::move (lowered));
+ HIR::Crate &hir = mappings.insert_hir_crate (std::move (lowered));
// perform type resolution
Resolver::TypeResolution::Resolve (hir);
// always restore the crate_num
- mappings->set_current_crate (saved_crate_num);
+ mappings.set_current_crate (saved_crate_num);
return parsed_crate.get_node_id ();
}
Linemap *linemap;
// mappings
- Analysis::Mappings *mappings;
+ Analysis::Mappings &mappings;
public:
/* Get a reference to the static session instance */
static Session &get_instance ();
- Session () = default;
~Session () = default;
/* This initializes the compiler session. Corresponds to langhook
NodeId load_extern_crate (const std::string &crate_name, location_t locus);
private:
+ Session () : mappings (Analysis::Mappings::get ()) {}
void compile_crate (const char *filename);
bool enable_dump (std::string arg);
if (!is_valid_type)
return Adjustment::get_error ();
- auto mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
auto context = TypeCheckContext::get ();
const auto ref_base = static_cast<const TyTy::ArrayType *> (ty);
auto slice_elem = ref_base->get_element_type ();
auto slice
- = new TyTy::SliceType (mappings->get_next_hir_id (), ty->get_ident ().locus,
+ = new TyTy::SliceType (mappings.get_next_hir_id (), ty->get_ident ().locus,
TyTy::TyVar (slice_elem->get_ref ()));
context->insert_implicit_type (slice);
Adjustment::AdjustmentType *requires_ref_adjustment)
{
auto context = TypeCheckContext::get ();
- auto mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
// look up lang item for arithmetic type
std::string associated_item_name = LangItem::ToString (lang_item_type);
DefId respective_lang_item_id = UNKNOWN_DEFID;
bool lang_item_defined
- = mappings->lookup_lang_item (lang_item_type, &respective_lang_item_id);
+ = mappings.lookup_lang_item (lang_item_type, &respective_lang_item_id);
if (!lang_item_defined)
return false;
rust_assert (lookup->get_kind () == TyTy::TypeKind::FNDEF);
fn = static_cast<TyTy::FnType *> (lookup);
- location_t unify_locus = mappings->lookup_location (lhs->get_ref ());
+ location_t unify_locus = mappings.lookup_location (lhs->get_ref ());
unify_site (lhs->get_ref (),
TyTy::TyWithLocation (fn->get_self_type ()),
TyTy::TyWithLocation (adjusted_self), unify_locus);
// here, we would coerce from `!` to `?T`.
if (expected->has_substitutions_defined () && !expected->is_concrete ())
{
- location_t locus = mappings->lookup_location (receiver->get_ref ());
+ location_t locus = mappings.lookup_location (receiver->get_ref ());
TyTy::TyVar implicit_var
= TyTy::TyVar::get_implicit_infer_var (locus);
try_result = CoercionResult{{}, implicit_var.get_tyty ()};
}
else if (unsafe_error)
{
- // location_t lhs = mappings->lookup_location (receiver->get_ref ());
- // location_t rhs = mappings->lookup_location (expected->get_ref ());
+ // location_t lhs = mappings.lookup_location (receiver->get_ref ());
+ // location_t rhs = mappings.lookup_location (expected->get_ref ());
// object_unsafe_error (locus, lhs, rhs);
return false;
}
if (!coerceable_mutability (from_mutbl, to_mutbl))
{
- location_t lhs = mappings->lookup_location (receiver->get_ref ());
- location_t rhs = mappings->lookup_location (expected->get_ref ());
+ location_t lhs = mappings.lookup_location (receiver->get_ref ());
+ location_t rhs = mappings.lookup_location (expected->get_ref ());
mismatched_mutability_error (locus, lhs, rhs);
return TypeCoercionRules::CoercionResult::get_error ();
}
if (!coerceable_mutability (from_mutbl, to_mutbl))
{
- location_t lhs = mappings->lookup_location (receiver->get_ref ());
- location_t rhs = mappings->lookup_location (expected->get_ref ());
+ location_t lhs = mappings.lookup_location (receiver->get_ref ());
+ location_t rhs = mappings.lookup_location (expected->get_ref ());
mismatched_mutability_error (locus, lhs, rhs);
return TypeCoercionRules::CoercionResult::get_error ();
}
if (!coerceable_mutability (from_mutbl, to_mutbl))
{
unsafe_error = true;
- location_t lhs = mappings->lookup_location (source->get_ref ());
- location_t rhs = mappings->lookup_location (target->get_ref ());
+ location_t lhs = mappings.lookup_location (source->get_ref ());
+ location_t rhs = mappings.lookup_location (target->get_ref ());
mismatched_mutability_error (locus, lhs, rhs);
return TypeCoercionRules::CoercionResult::get_error ();
}
if (!coerceable_mutability (from_mutbl, to_mutbl))
{
unsafe_error = true;
- location_t lhs = mappings->lookup_location (source->get_ref ());
- location_t rhs = mappings->lookup_location (target->get_ref ());
+ location_t lhs = mappings.lookup_location (source->get_ref ());
+ location_t rhs = mappings.lookup_location (target->get_ref ());
mismatched_mutability_error (locus, lhs, rhs);
return TypeCoercionRules::CoercionResult::get_error ();
}
private:
// context info
- Analysis::Mappings *mappings;
+ Analysis::Mappings &mappings;
TypeCheckContext *context;
// search
// assemble inherent impl items
std::vector<impl_item_candidate> inherent_impl_fns;
- mappings->iterate_impl_items (
+ mappings.iterate_impl_items (
[&] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) mutable -> bool {
bool is_trait_impl = impl->has_trait_ref ();
if (is_trait_impl)
};
std::vector<trait_item_candidate> trait_fns;
- mappings->iterate_impl_blocks (
+ mappings.iterate_impl_blocks (
[&] (HirId id, HIR::ImplBlock *impl) mutable -> bool {
bool is_trait_impl = impl->has_trait_ref ();
if (!is_trait_impl)
OverlappingImplItemPass pass;
// generate mappings
- pass.mappings->iterate_impl_items (
+ pass.mappings.iterate_impl_items (
[&] (HirId id, HIR::ImplItem *impl_item, HIR::ImplBlock *impl) -> bool {
// ignoring trait-impls might need thought later on
if (impl->has_trait_ref ())
PathProbeCandidate::EnumItemCandidate enum_item_candidate{adt, v};
PathProbeCandidate candidate{PathProbeCandidate::CandidateType::ENUM_VARIANT,
receiver->clone (),
- mappings->lookup_location (adt->get_ty_ref ()),
+ mappings.lookup_location (adt->get_ty_ref ()),
enum_item_candidate};
candidates.insert (std::move (candidate));
}
void
PathProbeType::process_impl_items_for_candidates ()
{
- mappings->iterate_impl_items (
+ mappings.iterate_impl_items (
[&] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) mutable -> bool {
process_impl_item_candidate (id, item, impl);
return true;
void
PathProbeImplTrait::process_trait_impl_items_for_candidates ()
{
- mappings->iterate_impl_items (
+ mappings.iterate_impl_items (
[&] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) mutable -> bool {
// just need to check if this is an impl block for this trait the next
// function checks the receiver
}
HirId hir_node = UNKNOWN_HIRID;
- if (!mappings->lookup_node_to_hir (ref, &hir_node))
+ if (!mappings.lookup_node_to_hir (ref, &hir_node))
{
rust_error_at (path.get_locus (), "Failed to resolve path to hir-id");
return false;
}
- HIR::Item *resolved_item = mappings->lookup_hir_item (hir_node);
+ HIR::Item *resolved_item = mappings.lookup_hir_item (hir_node);
rust_assert (resolved_item != nullptr);
rust_assert (resolved_item->get_item_kind () == HIR::Item::ItemKind::Trait);
*resolved = static_cast<HIR::Trait *> (resolved_item);
Analysis::NodeMapping
TraitItemReference::get_parent_trait_mappings () const
{
- auto mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
HIR::Trait *trait
- = mappings->lookup_trait_item_mapping (get_mappings ().get_hirid ());
+ = mappings.lookup_trait_item_mapping (get_mappings ().get_hirid ());
rust_assert (trait != nullptr);
return trait->get_mappings ();
auto ok = context->lookup_builtin ("u8", &u8);
rust_assert (ok);
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping capacity_mapping (crate_num, UNKNOWN_NODEID,
- mappings->get_next_hir_id (
+ mappings.get_next_hir_id (
crate_num),
UNKNOWN_LOCAL_DEFID);
context->insert_type (capacity_mapping, expected_ty);
Analysis::NodeMapping array_mapping (crate_num, UNKNOWN_NODEID,
- mappings->get_next_hir_id (
+ mappings.get_next_hir_id (
crate_num),
UNKNOWN_LOCAL_DEFID);
TyTy::TypeBoundPredicate
TypeCheckBase::get_marker_predicate (LangItem::Kind item_type, location_t locus)
{
- DefId item_id = mappings->get_lang_item (item_type, locus);
- HIR::Item *item = mappings->lookup_defid (item_id);
+ DefId item_id = mappings.get_lang_item (item_type, locus);
+ HIR::Item *item = mappings.lookup_defid (item_id);
rust_assert (item != nullptr);
rust_assert (item->get_item_kind () == HIR::Item::ItemKind::Trait);
TyTy::TypeBoundPredicate get_marker_predicate (LangItem::Kind item_type,
location_t locus);
- Analysis::Mappings *mappings;
+ Analysis::Mappings &mappings;
Resolver *resolver;
TypeCheckContext *context;
};
Analysis::NodeMapping mapping (item.get_mappings ().get_crate_num (),
item.get_mappings ().get_nodeid (),
- mappings->get_next_hir_id (
+ mappings.get_next_hir_id (
item.get_mappings ().get_crate_num ()),
item.get_mappings ().get_local_defid ());
HIR::LiteralExpr *discim_expr
context->insert_type (mapping, isize);
const CanonicalPath *canonical_path = nullptr;
- ok = mappings->lookup_canonical_path (item.get_mappings ().get_nodeid (),
- &canonical_path);
+ ok = mappings.lookup_canonical_path (item.get_mappings ().get_nodeid (),
+ &canonical_path);
rust_assert (ok);
RustIdent ident{*canonical_path, item.get_locus ()};
TyTy::TyWithLocation (capacity_type), item.get_locus ());
const CanonicalPath *canonical_path = nullptr;
- bool ok = mappings->lookup_canonical_path (item.get_mappings ().get_nodeid (),
- &canonical_path);
+ bool ok = mappings.lookup_canonical_path (item.get_mappings ().get_nodeid (),
+ &canonical_path);
rust_assert (ok);
RustIdent ident{*canonical_path, item.get_locus ()};
Analysis::NodeMapping mapping (item.get_mappings ().get_crate_num (),
item.get_mappings ().get_nodeid (),
- mappings->get_next_hir_id (
+ mappings.get_next_hir_id (
item.get_mappings ().get_crate_num ()),
item.get_mappings ().get_local_defid ());
HIR::LiteralExpr *discim_expr
context->insert_type (mapping, isize);
const CanonicalPath *canonical_path = nullptr;
- ok = mappings->lookup_canonical_path (item.get_mappings ().get_nodeid (),
- &canonical_path);
+ ok = mappings.lookup_canonical_path (item.get_mappings ().get_nodeid (),
+ &canonical_path);
rust_assert (ok);
RustIdent ident{*canonical_path, item.get_locus ()};
Analysis::NodeMapping mapping (item.get_mappings ().get_crate_num (),
item.get_mappings ().get_nodeid (),
- mappings->get_next_hir_id (
+ mappings.get_next_hir_id (
item.get_mappings ().get_crate_num ()),
item.get_mappings ().get_local_defid ());
HIR::LiteralExpr *discrim_expr
context->insert_type (mapping, isize);
const CanonicalPath *canonical_path = nullptr;
- ok = mappings->lookup_canonical_path (item.get_mappings ().get_nodeid (),
- &canonical_path);
+ ok = mappings.lookup_canonical_path (item.get_mappings ().get_nodeid (),
+ &canonical_path);
rust_assert (ok);
RustIdent ident{*canonical_path, item.get_locus ()};
DefId respective_lang_item_id = UNKNOWN_DEFID;
bool lang_item_defined
- = mappings->lookup_lang_item (lang_item_type, &respective_lang_item_id);
+ = mappings.lookup_lang_item (lang_item_type, &respective_lang_item_id);
// we need to have it maybe
if (!lang_item_defined)
}
// look it up and it _must_ be a struct definition
- HIR::Item *item = mappings->lookup_defid (respective_lang_item_id);
+ HIR::Item *item = mappings.lookup_defid (respective_lang_item_id);
rust_assert (item != nullptr);
TyTy::BaseType *item_type = nullptr;
DefId respective_lang_item_id = UNKNOWN_DEFID;
bool lang_item_defined
- = mappings->lookup_lang_item (lang_item_type, &respective_lang_item_id);
+ = mappings.lookup_lang_item (lang_item_type, &respective_lang_item_id);
// we need to have it maybe
if (!lang_item_defined)
}
// look it up and it _must_ be a struct definition
- HIR::Item *item = mappings->lookup_defid (respective_lang_item_id);
+ HIR::Item *item = mappings.lookup_defid (respective_lang_item_id);
rust_assert (item != nullptr);
TyTy::BaseType *item_type = nullptr;
DefId respective_lang_item_id = UNKNOWN_DEFID;
bool lang_item_defined
- = mappings->lookup_lang_item (lang_item_type, &respective_lang_item_id);
+ = mappings.lookup_lang_item (lang_item_type, &respective_lang_item_id);
// we need to have it maybe
if (!lang_item_defined)
}
// look it up and it _must_ be a struct definition
- HIR::Item *item = mappings->lookup_defid (respective_lang_item_id);
+ HIR::Item *item = mappings.lookup_defid (respective_lang_item_id);
rust_assert (item != nullptr);
TyTy::BaseType *item_type = nullptr;
DefId respective_lang_item_id = UNKNOWN_DEFID;
bool lang_item_defined
- = mappings->lookup_lang_item (lang_item_type, &respective_lang_item_id);
+ = mappings.lookup_lang_item (lang_item_type, &respective_lang_item_id);
// we need to have it maybe
if (!lang_item_defined)
}
// look it up and it _must_ be a struct definition
- HIR::Item *item = mappings->lookup_defid (respective_lang_item_id);
+ HIR::Item *item = mappings.lookup_defid (respective_lang_item_id);
rust_assert (item != nullptr);
TyTy::BaseType *item_type = nullptr;
DefId respective_lang_item_id = UNKNOWN_DEFID;
bool lang_item_defined
- = mappings->lookup_lang_item (lang_item_type, &respective_lang_item_id);
+ = mappings.lookup_lang_item (lang_item_type, &respective_lang_item_id);
// we need to have it maybe
if (!lang_item_defined)
}
// look it up and it _must_ be a struct definition
- HIR::Item *item = mappings->lookup_defid (respective_lang_item_id);
+ HIR::Item *item = mappings.lookup_defid (respective_lang_item_id);
rust_assert (item != nullptr);
TyTy::BaseType *item_type = nullptr;
expr.get_locus ());
}
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, UNKNOWN_NODEID,
- mappings->get_next_hir_id (crate_num),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
std::string capacity_str = std::to_string (elems.get_num_elements ());
capacity_expr = new HIR::LiteralExpr (mapping, capacity_str,
}
// we generate an implicit hirid for the closure args
- HirId implicit_args_id = mappings->get_next_hir_id ();
+ HirId implicit_args_id = mappings.get_next_hir_id ();
TyTy::TupleType *closure_args
= new TyTy::TupleType (implicit_args_id, expr.get_locus (),
parameter_types);
LangItem::Kind lang_item_type = LangItem::Kind::FN_ONCE;
DefId respective_lang_item_id = UNKNOWN_DEFID;
bool lang_item_defined
- = mappings->lookup_lang_item (lang_item_type, &respective_lang_item_id);
+ = mappings.lookup_lang_item (lang_item_type, &respective_lang_item_id);
if (!lang_item_defined)
{
// FIXME
rust_assert (lang_item_defined);
// these lang items are always traits
- HIR::Item *item = mappings->lookup_defid (respective_lang_item_id);
+ HIR::Item *item = mappings.lookup_defid (respective_lang_item_id);
rust_assert (item->get_item_kind () == HIR::Item::ItemKind::Trait);
HIR::Trait *trait_item = static_cast<HIR::Trait *> (item);
// lets generate an implicit Type so that it resolves to the implict tuple
// type we have created
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (crate_num, expr.get_mappings ().get_nodeid (),
implicit_args_id, UNKNOWN_LOCAL_DEFID);
HIR::TupleType *implicit_tuple
std::string associated_item_name = LangItem::ToString (lang_item_type);
DefId respective_lang_item_id = UNKNOWN_DEFID;
bool lang_item_defined
- = mappings->lookup_lang_item (lang_item_type, &respective_lang_item_id);
+ = mappings.lookup_lang_item (lang_item_type, &respective_lang_item_id);
// probe for the lang-item
if (!lang_item_defined)
}
// crate implicit tuple
- HirId implicit_arg_id = mappings->get_next_hir_id ();
- Analysis::NodeMapping mapping (mappings->get_current_crate (), UNKNOWN_NODEID,
+ HirId implicit_arg_id = mappings.get_next_hir_id ();
+ Analysis::NodeMapping mapping (mappings.get_current_crate (), UNKNOWN_NODEID,
implicit_arg_id, UNKNOWN_LOCAL_DEFID);
TyTy::TupleType *tuple
auto param_tyty = TypeCheckType::Resolve (param.get_type ().get ());
// these are implicit mappings and not used
- auto crate_num = mappings->get_current_crate ();
- Analysis::NodeMapping mapping (crate_num, mappings->get_next_node_id (),
- mappings->get_next_hir_id (crate_num),
+ auto crate_num = mappings.get_current_crate ();
+ Analysis::NodeMapping mapping (crate_num, mappings.get_next_node_id (),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
HIR::IdentifierPattern *param_pattern
if (function.is_method ())
{
// these are implicit mappings and not used
- auto crate_num = mappings->get_current_crate ();
- Analysis::NodeMapping mapping (crate_num, mappings->get_next_node_id (),
- mappings->get_next_hir_id (crate_num),
+ auto crate_num = mappings.get_current_crate ();
+ Analysis::NodeMapping mapping (crate_num, mappings.get_next_node_id (),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
// add the synthetic self param at the front, this is a placeholder for
const CanonicalPath *canonical_path = nullptr;
bool ok
- = mappings->lookup_canonical_path (function.get_mappings ().get_nodeid (),
- &canonical_path);
+ = mappings.lookup_canonical_path (function.get_mappings ().get_nodeid (),
+ &canonical_path);
rust_assert (ok);
RustIdent ident{*canonical_path, function.get_locus ()};
else
{
const CanonicalPath *canonical_path = nullptr;
- bool ok = mappings->lookup_canonical_path (
+ bool ok = mappings.lookup_canonical_path (
struct_decl.get_mappings ().get_nodeid (), &canonical_path);
rust_assert (ok);
= parse_repr_options (attrs, struct_decl.get_locus ());
auto *type = new TyTy::ADTType (
- struct_decl.get_mappings ().get_hirid (), mappings->get_next_hir_id (),
+ struct_decl.get_mappings ().get_hirid (), mappings.get_next_hir_id (),
struct_decl.get_identifier ().as_string (), ident,
TyTy::ADTType::ADTKind::TUPLE_STRUCT, std::move (variants),
std::move (substitutions), repr,
else
{
const CanonicalPath *canonical_path = nullptr;
- bool ok = mappings->lookup_canonical_path (
+ bool ok = mappings.lookup_canonical_path (
struct_decl.get_mappings ().get_nodeid (), &canonical_path);
rust_assert (ok);
= parse_repr_options (attrs, struct_decl.get_locus ());
auto *type = new TyTy::ADTType (
- struct_decl.get_mappings ().get_hirid (), mappings->get_next_hir_id (),
+ struct_decl.get_mappings ().get_hirid (), mappings.get_next_hir_id (),
struct_decl.get_identifier ().as_string (), ident,
TyTy::ADTType::ADTKind::STRUCT_STRUCT, std::move (variants),
std::move (substitutions), repr,
// get the path
const CanonicalPath *canonical_path = nullptr;
bool ok
- = mappings->lookup_canonical_path (enum_decl.get_mappings ().get_nodeid (),
- &canonical_path);
+ = mappings.lookup_canonical_path (enum_decl.get_mappings ().get_nodeid (),
+ &canonical_path);
rust_assert (ok);
RustIdent ident{*canonical_path, enum_decl.get_locus ()};
// multi variant ADT
auto *type
= new TyTy::ADTType (enum_decl.get_mappings ().get_hirid (),
- mappings->get_next_hir_id (),
+ mappings.get_next_hir_id (),
enum_decl.get_identifier ().as_string (), ident,
TyTy::ADTType::ADTKind::ENUM, std::move (variants),
std::move (substitutions));
// get the path
const CanonicalPath *canonical_path = nullptr;
bool ok
- = mappings->lookup_canonical_path (union_decl.get_mappings ().get_nodeid (),
- &canonical_path);
+ = mappings.lookup_canonical_path (union_decl.get_mappings ().get_nodeid (),
+ &canonical_path);
rust_assert (ok);
RustIdent ident{*canonical_path, union_decl.get_locus ()};
auto *type
= new TyTy::ADTType (union_decl.get_mappings ().get_hirid (),
- mappings->get_next_hir_id (),
+ mappings.get_next_hir_id (),
union_decl.get_identifier ().as_string (), ident,
TyTy::ADTType::ADTKind::UNION, std::move (variants),
std::move (substitutions));
else
{
const CanonicalPath *canonical_path = nullptr;
- bool ok = mappings->lookup_canonical_path (
+ bool ok = mappings.lookup_canonical_path (
function.get_mappings ().get_nodeid (), &canonical_path);
rust_assert (ok);
// node back to HIR
HirId ref;
- if (!mappings->lookup_node_to_hir (ref_node_id, &ref))
+ if (!mappings.lookup_node_to_hir (ref_node_id, &ref))
{
rust_error_at (seg.get_locus (), "456 reverse lookup failure");
rust_debug_loc (seg.get_locus (),
return new TyTy::ErrorType (expr.get_mappings ().get_hirid ());
}
- auto seg_is_module = (nullptr != mappings->lookup_module (ref));
- auto seg_is_crate = mappings->is_local_hirid_crate (ref);
+ auto seg_is_module = (nullptr != mappings.lookup_module (ref));
+ auto seg_is_crate = mappings.is_local_hirid_crate (ref);
if (seg_is_module || seg_is_crate)
{
// A::B::C::this_is_a_module::D::E::F
// is it an enum item?
std::pair<HIR::Enum *, HIR::EnumItem *> enum_item_lookup
- = mappings->lookup_hir_enumitem (ref);
+ = mappings.lookup_hir_enumitem (ref);
bool is_enum_item = enum_item_lookup.first != nullptr
&& enum_item_lookup.second != nullptr;
if (is_enum_item)
HirId variant_id = variant->get_id ();
std::pair<HIR::Enum *, HIR::EnumItem *> enum_item_lookup
- = mappings->lookup_hir_enumitem (variant_id);
+ = mappings.lookup_hir_enumitem (variant_id);
bool enum_item_ok = enum_item_lookup.first != nullptr
&& enum_item_lookup.second != nullptr;
rust_assert (enum_item_ok);
size_t got_field_count)
{
rich_location r (line_table, pattern.get_locus ());
- r.add_range (mappings->lookup_location (parent->get_ref ()));
+ r.add_range (mappings.lookup_location (parent->get_ref ()));
rust_error_at (r,
"expected a tuple with %lu %s, found one "
"with %lu %s",
if (resolver.infered->get_kind () != TyTy::TypeKind::ERROR)
{
resolver.context->insert_implicit_type (resolver.infered);
- resolver.mappings->insert_location (resolver.infered->get_ref (),
- pattern->get_locus ());
+ resolver.mappings.insert_location (resolver.infered->get_ref (),
+ pattern->get_locus ());
}
return resolver.infered;
}
HIR::StructExprField *implicit_field = nullptr;
AST::AttrVec outer_attribs;
- auto crate_num = mappings->get_current_crate ();
+ auto crate_num = mappings.get_current_crate ();
Analysis::NodeMapping mapping (
crate_num,
struct_expr.struct_base->base_struct->get_mappings ()
.get_nodeid (),
- mappings->get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID);
+ mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID);
HIR::Expr *field_value = new HIR::FieldAccessExpr (
mapping, std::unique_ptr<HIR::Expr> (receiver), missing,
else
{
// needs a new implicit ID
- HirId ref = mappings->get_next_hir_id ();
+ HirId ref = mappings.get_next_hir_id ();
return_type = TyTy::TupleType::get_unit_type (ref);
context->insert_implicit_type (ref, return_type);
}
// node back to HIR
HirId ref = UNKNOWN_HIRID;
- if (!mappings->lookup_node_to_hir (ref_node_id, &ref))
+ if (!mappings.lookup_node_to_hir (ref_node_id, &ref))
{
if (is_root)
{
return root_tyty;
}
- auto seg_is_module = (nullptr != mappings->lookup_module (ref));
- auto seg_is_crate = mappings->is_local_hirid_crate (ref);
+ auto seg_is_module = (nullptr != mappings.lookup_module (ref));
+ auto seg_is_crate = mappings.is_local_hirid_crate (ref);
if (seg_is_module || seg_is_crate)
{
// A::B::C::this_is_a_module::D::E::F
// We need two possible parameter types. One with no Bounds and one with
// the bounds. the Self type for the bounds cannot itself contain the
// bounds otherwise it will be a trait cycle
- HirId implicit_id = mappings->get_next_hir_id ();
+ HirId implicit_id = mappings.get_next_hir_id ();
TyTy::ParamType *p
= new TyTy::ParamType (param.get_type_representation ().as_string (),
param.get_locus (), implicit_id, param,
// node back to HIR
HirId ref;
- if (!mappings->lookup_node_to_hir (ref_node_id, &ref))
+ if (!mappings.lookup_node_to_hir (ref_node_id, &ref))
{
// FIXME
rust_error_at (UNDEF_LOCATION, "where-clause reverse lookup failure");
TyTy::BaseType *lookup;
if (!context->lookup_type (ref, &lookup))
{
- rust_error_at (mappings->lookup_location (ref),
+ rust_error_at (mappings.lookup_location (ref),
"Failed to resolve where-clause binding type: %s",
binding_type_path->as_string ().c_str ());
return;
if (function.is_method ())
{
// these are implicit mappings and not used
- auto mappings = Analysis::Mappings::get ();
- auto crate_num = mappings->get_current_crate ();
- Analysis::NodeMapping mapping (crate_num, mappings->get_next_node_id (),
- mappings->get_next_hir_id (crate_num),
+ auto &mappings = Analysis::Mappings::get ();
+ auto crate_num = mappings.get_current_crate ();
+ Analysis::NodeMapping mapping (crate_num, mappings.get_next_node_id (),
+ mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
// add the synthetic self param at the front, this is a placeholder
TypeCheckPattern::Resolve (param.get_param_name ().get (), param_tyty);
}
- auto mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
const CanonicalPath *canonical_path = nullptr;
- bool ok = mappings->lookup_canonical_path (fn.get_mappings ().get_nodeid (),
- &canonical_path);
+ bool ok = mappings.lookup_canonical_path (fn.get_mappings ().get_nodeid (),
+ &canonical_path);
rust_assert (ok);
RustIdent ident{*canonical_path, fn.get_locus ()};
bool
query_type (HirId reference, TyTy::BaseType **result)
{
- Analysis::Mappings *mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
TypeCheckContext *context = TypeCheckContext::get ();
if (context->query_in_progress (reference))
context->insert_query (reference);
std::pair<HIR::Enum *, HIR::EnumItem *> enum_candidiate
- = mappings->lookup_hir_enumitem (reference);
+ = mappings.lookup_hir_enumitem (reference);
bool enum_candidiate_ok
= enum_candidiate.first != nullptr && enum_candidiate.second != nullptr;
if (enum_candidiate_ok)
return true;
}
- HIR::Item *item = mappings->lookup_hir_item (reference);
+ HIR::Item *item = mappings.lookup_hir_item (reference);
if (item != nullptr)
{
rust_debug_loc (item->get_locus (), "resolved item {%u} to", reference);
HirId parent_impl_id = UNKNOWN_HIRID;
HIR::ImplItem *impl_item
- = mappings->lookup_hir_implitem (reference, &parent_impl_id);
+ = mappings.lookup_hir_implitem (reference, &parent_impl_id);
if (impl_item != nullptr)
{
HIR::ImplBlock *impl_block
- = mappings->lookup_hir_impl_block (parent_impl_id);
+ = mappings.lookup_hir_impl_block (parent_impl_id);
rust_assert (impl_block != nullptr);
// found an impl item
// is it an impl_type?
HIR::ImplBlock *impl_block_by_type = nullptr;
bool found_impl_block_type
- = mappings->lookup_impl_block_type (reference, &impl_block_by_type);
+ = mappings.lookup_impl_block_type (reference, &impl_block_by_type);
if (found_impl_block_type)
{
*result = TypeCheckItem::ResolveImplBlockSelf (*impl_block_by_type);
// is it an extern item?
HirId parent_extern_block_id = UNKNOWN_HIRID;
HIR::ExternalItem *extern_item
- = mappings->lookup_hir_extern_item (reference, &parent_extern_block_id);
+ = mappings.lookup_hir_extern_item (reference, &parent_extern_block_id);
if (extern_item != nullptr)
{
HIR::ExternBlock *block
- = mappings->lookup_hir_extern_block (parent_extern_block_id);
+ = mappings.lookup_hir_extern_block (parent_extern_block_id);
rust_assert (block != nullptr);
*result = TypeCheckTopLevelExternItem::Resolve (extern_item, *block);
}
// more?
- location_t possible_locus = mappings->lookup_location (reference);
+ location_t possible_locus = mappings.lookup_location (reference);
rust_debug_loc (possible_locus, "query system failed to resolve: [%u]",
reference);
context->query_completed (reference);
void
TypeCheckContext::compute_inference_variables (bool error)
{
- auto mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
// default inference variables if possible
iterate ([&] (HirId id, TyTy::BaseType *ty) mutable -> bool {
TyTy::InferType *infer_var = static_cast<TyTy::InferType *> (ty);
TyTy::BaseType *default_type;
- rust_debug_loc (mappings->lookup_location (id),
+ rust_debug_loc (mappings.lookup_location (id),
"trying to default infer-var: %s",
infer_var->as_string ().c_str ());
bool ok = infer_var->default_type (&default_type);
if (!ok)
{
if (error)
- rust_error_at (mappings->lookup_location (id), ErrorCode::E0282,
+ rust_error_at (mappings.lookup_location (id), ErrorCode::E0282,
"type annotations needed");
return true;
}
rust_assert (result);
rust_assert (result->get_kind () != TyTy::TypeKind::ERROR);
result->set_ref (id);
- insert_type (Analysis::NodeMapping (mappings->get_current_crate (), 0, id,
+ insert_type (Analysis::NodeMapping (mappings.get_current_crate (), 0, id,
UNKNOWN_LOCAL_DEFID),
result);
{
std::vector<std::pair<HIR::TypePath *, HIR::ImplBlock *>>
possible_trait_paths;
- mappings->iterate_impl_blocks (
+ mappings.iterate_impl_blocks (
[&] (HirId id, HIR::ImplBlock *impl) mutable -> bool {
// we are filtering for trait-impl-blocks
if (!impl->has_trait_ref ())
TypeBoundsProbe::assemble_builtin_candidate (LangItem::Kind lang_item)
{
DefId id;
- bool found_lang_item = mappings->lookup_lang_item (lang_item, &id);
+ bool found_lang_item = mappings.lookup_lang_item (lang_item, &id);
if (!found_lang_item)
return;
- HIR::Item *item = mappings->lookup_defid (id);
+ HIR::Item *item = mappings.lookup_defid (id);
if (item == nullptr)
return;
// assemble the reference
TraitReference *trait_ref = TraitResolver::Resolve (*trait);
- trait_references.push_back ({trait_ref, mappings->lookup_builtin_marker ()});
+ trait_references.push_back ({trait_ref, mappings.lookup_builtin_marker ()});
rust_debug ("Added builtin lang_item: %s for %s",
LangItem::ToString (lang_item).c_str (),
// we need to make implicit generic args which must be an implicit
// Tuple
- auto crate_num = mappings->get_current_crate ();
- HirId implicit_args_id = mappings->get_next_hir_id ();
+ auto crate_num = mappings.get_current_crate ();
+ HirId implicit_args_id = mappings.get_next_hir_id ();
Analysis::NodeMapping mapping (crate_num,
final_seg->get_mappings ().get_nodeid (),
implicit_args_id, UNKNOWN_LOCAL_DEFID);
rust_assert (fn.has_return_type ());
TypeCheckType::Resolve (fn.get_return_type ().get ());
- HIR::TraitItem *trait_item = mappings->lookup_trait_item_lang_item (
+ HIR::TraitItem *trait_item = mappings.lookup_trait_item_lang_item (
LangItem::Kind::FN_ONCE_OUTPUT, final_seg->get_locus ());
std::vector<HIR::GenericArgsBinding> bindings;
BaseType *param_ty = fnparam.second;
location_t param_locus
= fn_param_pattern == nullptr
- ? mappings->lookup_location (param_ty->get_ref ())
+ ? mappings.lookup_location (param_ty->get_ref ())
: fn_param_pattern->get_locus ();
HirId coercion_side_id = argument->get_mappings ().get_hirid ();
BaseType *param_ty = fnparam.second;
location_t param_locus
= fn_param_pattern == nullptr
- ? mappings->lookup_location (param_ty->get_ref ())
+ ? mappings.lookup_location (param_ty->get_ref ())
: fn_param_pattern->get_locus ();
auto argument_expr_tyty = argument.get_argument_type ();
HIR::CallExpr &call;
TyTy::VariantDef &variant;
Resolver::TypeCheckContext *context;
- Analysis::Mappings *mappings;
+ Analysis::Mappings &mappings;
};
class Argument
location_t receiver_locus;
TyTy::BaseType *adjusted_self;
Resolver::TypeCheckContext *context;
- Analysis::Mappings *mappings;
+ Analysis::Mappings &mappings;
};
} // namespace TyTy
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
ok = false;
if (emit_error_flag)
{
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
location_t base_locus
- = mappings->lookup_location (get_base ()->get_ref ());
+ = mappings.lookup_location (get_base ()->get_ref ());
rich_location r (line_table, ref_locus);
r.add_range (base_locus);
rust_error_at (r, "expected [%s] got [%s]",
emit_error_flag (emit_errors)
{}
- Analysis::Mappings *mappings;
+ Analysis::Mappings &mappings;
Resolver::TypeCheckContext *context;
bool ok;
return;
}
- location_t ref_locus = mappings->lookup_location (type.get_ref ());
+ location_t ref_locus = mappings.lookup_location (type.get_ref ());
ok = base->bounds_compatible (type, ref_locus, false);
}
if (!param->can_resolve ())
return;
- auto mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
auto context = Resolver::TypeCheckContext::get ();
- context->insert_type (Analysis::NodeMapping (mappings->get_current_crate (),
+ context->insert_type (Analysis::NodeMapping (mappings.get_current_crate (),
UNKNOWN_NODEID,
param->get_ref (),
UNKNOWN_LOCAL_DEFID),
if (associated == nullptr && ambigious)
{
// go for the first one? or error out?
- auto &mappings = *Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
const auto &type_param = subst.get_generic_param ();
const auto *trait_ref = bound.get ();
TyVar
TyVar::get_implicit_infer_var (location_t locus)
{
- auto mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
auto context = Resolver::TypeCheckContext::get ();
- InferType *infer = new InferType (mappings->get_next_hir_id (),
+ InferType *infer = new InferType (mappings.get_next_hir_id (),
InferType::InferTypeKind::GENERAL,
InferType::TypeHint::Default (), locus);
- context->insert_type (Analysis::NodeMapping (mappings->get_current_crate (),
+ context->insert_type (Analysis::NodeMapping (mappings.get_current_crate (),
UNKNOWN_NODEID,
infer->get_ref (),
UNKNOWN_LOCAL_DEFID),
infer);
- mappings->insert_location (infer->get_ref (), locus);
+ mappings.insert_location (infer->get_ref (), locus);
return TyVar (infer->get_ref ());
}
TyVar
TyVar::monomorphized_clone () const
{
- auto mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
auto context = Resolver::TypeCheckContext::get ();
// this needs a new hirid
TyTy::BaseType *c = get_tyty ()->monomorphized_clone ();
- c->set_ref (mappings->get_next_hir_id ());
+ c->set_ref (mappings.get_next_hir_id ());
// insert it
- context->insert_type (Analysis::NodeMapping (mappings->get_current_crate (),
+ context->insert_type (Analysis::NodeMapping (mappings.get_current_crate (),
UNKNOWN_NODEID, c->get_ref (),
UNKNOWN_LOCAL_DEFID),
c);
TyWithLocation::TyWithLocation (BaseType *ty) : ty (ty)
{
- auto mappings = Analysis::Mappings::get ();
- locus = mappings->lookup_location (ty->get_ref ());
+ auto &mappings = Analysis::Mappings::get ();
+ locus = mappings.lookup_location (ty->get_ref ());
}
} // namespace TyTy
if (emit_error)
{
rich_location r (line_table,
- mappings->lookup_location (get_ref ()));
+ mappings.lookup_location (get_ref ()));
r.add_range (predicate.get_locus ());
- r.add_range (mappings->lookup_location (i.get_hirid ()));
+ r.add_range (mappings.lookup_location (i.get_hirid ()));
std::string rich_msg
= "expected " + bound_ty->destructure ()->get_name ()
// chain of references accordingly to ensure we don't loose the ability to
// update the inference variables when we solve the type
- auto mappings = Analysis::Mappings::get ();
+ auto &mappings = Analysis::Mappings::get ();
auto context = Resolver::TypeCheckContext::get ();
InferType *clone
- = new InferType (mappings->get_next_hir_id (), get_infer_kind (),
+ = new InferType (mappings.get_next_hir_id (), get_infer_kind (),
default_hint, get_ident ().locus, get_combined_refs ());
- context->insert_type (Analysis::NodeMapping (mappings->get_current_crate (),
+ context->insert_type (Analysis::NodeMapping (mappings.get_current_crate (),
UNKNOWN_NODEID,
clone->get_ref (),
UNKNOWN_LOCAL_DEFID),
clone);
- mappings->insert_location (clone->get_ref (),
- mappings->lookup_location (get_ref ()));
+ mappings.insert_location (clone->get_ref (),
+ mappings.lookup_location (get_ref ()));
// setup the chain to reference this
clone->append_reference (get_ref ());
ADTType::handle_substitions (SubstitutionArgumentMappings &subst_mappings)
{
auto adt = clone ()->as<ADTType> ();
- adt->set_ty_ref (mappings->get_next_hir_id ());
+ adt->set_ty_ref (mappings.get_next_hir_id ());
adt->used_arguments = subst_mappings;
for (auto &sub : adt->get_substs ())
TupleType *
TupleType::handle_substitions (SubstitutionArgumentMappings &mappings)
{
- auto mappings_table = Analysis::Mappings::get ();
+ auto &mappings_table = Analysis::Mappings::get ();
auto tuple = clone ()->as<TupleType> ();
- tuple->set_ref (mappings_table->get_next_hir_id ());
- tuple->set_ty_ref (mappings_table->get_next_hir_id ());
+ tuple->set_ref (mappings_table.get_next_hir_id ());
+ tuple->set_ty_ref (mappings_table.get_next_hir_id ());
for (size_t i = 0; i < tuple->fields.size (); i++)
{
FnType::handle_substitions (SubstitutionArgumentMappings &subst_mappings)
{
FnType *fn = static_cast<FnType *> (clone ());
- fn->set_ty_ref (mappings->get_next_hir_id ());
+ fn->set_ty_ref (mappings.get_next_hir_id ());
fn->used_arguments = subst_mappings;
for (auto &sub : fn->get_substs ())
DefId trait_id = UNKNOWN_DEFID;
bool trait_lang_item_defined
- = mappings->lookup_lang_item (fn_once_lang_item, &trait_id);
+ = mappings.lookup_lang_item (fn_once_lang_item, &trait_id);
rust_assert (trait_lang_item_defined);
DefId trait_item_id = UNKNOWN_DEFID;
bool trait_item_lang_item_defined
- = mappings->lookup_lang_item (fn_once_output_lang_item, &trait_item_id);
+ = mappings.lookup_lang_item (fn_once_output_lang_item, &trait_item_id);
rust_assert (trait_item_lang_item_defined);
// resolve to the trait
- HIR::Item *item = mappings->lookup_defid (trait_id);
+ HIR::Item *item = mappings.lookup_defid (trait_id);
rust_assert (item->get_item_kind () == HIR::Item::ItemKind::Trait);
HIR::Trait *trait = static_cast<HIR::Trait *> (item);
rust_assert (!trait_ref->is_error ());
// resolve to trait item
- HIR::TraitItem *trait_item
- = mappings->lookup_trait_item_defid (trait_item_id);
+ HIR::TraitItem *trait_item = mappings.lookup_trait_item_defid (trait_item_id);
rust_assert (trait_item != nullptr);
rust_assert (trait_item->get_item_kind ()
== HIR::TraitItem::TraitItemKind::TYPE);
ArrayType *
ArrayType::handle_substitions (SubstitutionArgumentMappings &mappings)
{
- auto mappings_table = Analysis::Mappings::get ();
+ auto &mappings_table = Analysis::Mappings::get ();
ArrayType *ref = static_cast<ArrayType *> (clone ());
- ref->set_ty_ref (mappings_table->get_next_hir_id ());
+ ref->set_ty_ref (mappings_table.get_next_hir_id ());
// might be &T or &ADT so this needs to be recursive
auto base = ref->get_element_type ();
SliceType *
SliceType::handle_substitions (SubstitutionArgumentMappings &mappings)
{
- auto mappings_table = Analysis::Mappings::get ();
+ auto &mappings_table = Analysis::Mappings::get ();
SliceType *ref = static_cast<SliceType *> (clone ());
- ref->set_ty_ref (mappings_table->get_next_hir_id ());
+ ref->set_ty_ref (mappings_table.get_next_hir_id ());
// might be &T or &ADT so this needs to be recursive
auto base = ref->get_element_type ();
ReferenceType *
ReferenceType::handle_substitions (SubstitutionArgumentMappings &mappings)
{
- auto mappings_table = Analysis::Mappings::get ();
+ auto &mappings_table = Analysis::Mappings::get ();
ReferenceType *ref = static_cast<ReferenceType *> (clone ());
- ref->set_ty_ref (mappings_table->get_next_hir_id ());
+ ref->set_ty_ref (mappings_table.get_next_hir_id ());
// might be &T or &ADT so this needs to be recursive
auto base = ref->get_base ();
PointerType *
PointerType::handle_substitions (SubstitutionArgumentMappings &mappings)
{
- auto mappings_table = Analysis::Mappings::get ();
+ auto &mappings_table = Analysis::Mappings::get ();
PointerType *ref = static_cast<PointerType *> (clone ());
- ref->set_ty_ref (mappings_table->get_next_hir_id ());
+ ref->set_ty_ref (mappings_table.get_next_hir_id ());
// might be &T or &ADT so this needs to be recursive
auto base = ref->get_base ();
}
// this is the new subst that this needs to pass
- p->set_ref (mappings->get_next_hir_id ());
+ p->set_ref (mappings.get_next_hir_id ());
p->set_ty_ref (arg.get_tyty ()->get_ref ());
return p;
// }
ProjectionType *projection = static_cast<ProjectionType *> (clone ());
- projection->set_ty_ref (mappings->get_next_hir_id ());
+ projection->set_ty_ref (mappings.get_next_hir_id ());
projection->used_arguments = subst_mappings;
auto context = Resolver::TypeCheckContext::get ();
std::set<HirId> combined;
RustIdent ident;
- Analysis::Mappings *mappings;
+ Analysis::Mappings &mappings;
};
/** Unified interface for all function-like types. */
std::vector<InferenceSite> &infers)
: lhs (lhs), rhs (rhs), locus (locus), commit_flag (commit_flag),
emit_error (emit_error), infer_flag (infer), commits (commits),
- infers (infers), mappings (*Analysis::Mappings::get ()),
+ infers (infers), mappings (Analysis::Mappings::get ()),
context (*TypeCheckContext::get ())
{}
TyTy::BaseType *resolved)
{
TypeCheckContext &context = *TypeCheckContext::get ();
- Analysis::Mappings &mappings = *Analysis::Mappings::get ();
+ Analysis::Mappings &mappings = Analysis::Mappings::get ();
TyTy::BaseType *b = base->destructure ();
TyTy::BaseType *o = other->destructure ();
Mappings::~Mappings () { delete builtinMarker; }
-Mappings *
+Mappings &
Mappings::get ()
{
- static std::unique_ptr<Mappings> instance;
- if (!instance)
- instance = std::unique_ptr<Mappings> (new Mappings ());
-
- return instance.get ();
+ static Mappings instance{};
+ return instance;
}
CrateNum
class Mappings
{
public:
- static Mappings *get ();
+ static Mappings &get ();
~Mappings ();
CrateNum get_next_crate_num (const std::string &name);
std::map<HirId, HIR::Trait *> hirTraitItemsToTraitMappings;
std::map<HirId, HIR::Pattern *> hirPatternMappings;
std::map<LangItem::Kind, DefId> lang_item_mappings;
- std::map<NodeId, const Resolver::CanonicalPath> paths;
+ std::map<NodeId, Resolver::CanonicalPath> paths;
std::map<NodeId, location_t> locations;
std::map<NodeId, HirId> nodeIdToHirMappings;
std::map<HirId, NodeId> hirIdToNodeMappings;
projects / thirdparty / gcc.git / commitdiff
