+#include "rust-ice-finalizer.h"

+ resolver->push_new_label_rib (resolver->get_label_scope ().peek ());

+ resolver->push_new_label_rib (resolver->get_label_scope ().peek ());

+ resolver->push_new_label_rib (resolver->get_label_scope ().peek ());

+ rust_error_at (label.get_locus (), "label defined multiple times");

+ rust_error_at (label.get_locus (), "label defined multiple times");

+ rust_error_at (label.get_locus (), "label defined multiple times");

+ rust_error_at (label.get_locus (), "label defined multiple times");

+ resolver->push_new_label_rib (resolver->get_label_scope ().peek ());

+ resolver->push_new_label_rib (resolver->get_label_scope ().peek ());

+ resolver->push_new_label_rib (resolver->get_label_scope ().peek ());

+ resolver->push_new_label_rib (resolver->get_label_scope ().peek ());

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ resolver->push_new_label_rib (resolver->get_label_scope ().peek ());

+ ResolveGenericParams::go (function.get_generic_params (), prefix,

+ canonical_prefix);

+ ResolveGenericParams::go (alias.get_generic_params (), prefix,

+ canonical_prefix);

+ resolver->push_new_label_rib (resolver->get_label_scope ().peek ());

+ ResolveGenericParams::go (struct_decl.get_generic_params (), prefix,

+ canonical_prefix);

+ ResolveGenericParams::go (enum_decl.get_generic_params (), prefix,

+ canonical_prefix);

+ ResolveGenericParams::go (struct_decl.get_generic_params (), prefix,

+ canonical_prefix);

+ ResolveGenericParams::go (union_decl.get_generic_params (), prefix,

+ canonical_prefix);

+ resolver->push_new_label_rib (resolver->get_label_scope ().peek ());

+ ResolveGenericParams::go (function.get_generic_params (), prefix,

+ canonical_prefix);

+ ResolveGenericParams::go (impl_block.get_generic_params (), prefix,

+ canonical_prefix);

+ resolver->push_new_label_rib (resolver->get_label_scope ().peek ());

+ ResolveGenericParams::go (impl_block.get_generic_params (), prefix,

+ canonical_prefix);

+ ResolveGenericParams::go_single (trait.get_implicit_self (), prefix,

+ canonical_prefix);

+ ResolveGenericParams::go (trait.get_generic_params (), prefix,

+ canonical_prefix);

+ {

+ // avoid duplicate node ids

+ auto prefix_copy

+ = AST::SimplePath ({}, prefix.has_opening_scope_resolution (),

+ prefix.get_locus ());

+ for (auto &seg : prefix.get_segments ())

+ prefix_copy.get_segments ().push_back (

+ AST::SimplePathSegment (seg.get_segment_name (),

+ seg.get_locus ()));

+

+ import->add_prefix (std::move (prefix_copy));

+ }

+ resolver->push_new_label_rib (resolver->get_label_scope ().peek ());

+ ResolveGenericParams::go (function.get_generic_params (), prefix,

+ canonical_prefix);

+// Copyright (C) 2020-2024 Free Software Foundation, Inc.

+#include "rust-hir-map.h"

+ if (expr.is_lang_item ())

+ return Analysis::Mappings::get ().get_lang_item_node (

+ expr.get_lang_item ());

+

+ "leading path segment %qs can only be used at the "

+ "beginning of a path",

+

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok = resolver->lookup_resolved_name (segment.get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == module_scope_id);

+ else

+ resolver->insert_resolved_name (segment.get_node_id (),

+ module_scope_id);

+

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok = resolver->lookup_resolved_name (segment.get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == module_scope_id);

+ else

+ resolver->insert_resolved_name (segment.get_node_id (),

+ module_scope_id);

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok = resolver->lookup_resolved_name (segment.get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node);

+ else

+ resolver->insert_resolved_name (segment.get_node_id (),

+ resolved_node);

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok = resolver->lookup_resolved_type (segment.get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node);

+ else

+ resolver->insert_resolved_type (segment.get_node_id (),

+ resolved_node);

+

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok = resolver->lookup_resolved_name (segment.get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == module_scope_id);

+ else

+ resolver->insert_resolved_name (segment.get_node_id (),

+ module_scope_id);

+

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok

+ = resolver->lookup_resolved_name (segment.get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node);

+ else

+ resolver->insert_resolved_name (segment.get_node_id (),

+ resolved_node);

+

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok

+ = resolver->lookup_resolved_type (segment.get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node);

+ else

+ resolver->insert_resolved_type (segment.get_node_id (),

+ resolved_node);

+ "Cannot find path %<%s%> in this scope",

+ "Cannot find path %<%s%> in this scope",

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok

+ = resolver->lookup_resolved_name (expr.get_node_id (), &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node_id);

+ else

+ resolver->insert_resolved_name (expr.get_node_id (),

+ resolved_node_id);

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok

+ = resolver->lookup_resolved_type (expr.get_node_id (), &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node_id);

+ else

+ resolver->insert_resolved_type (expr.get_node_id (),

+ resolved_node_id);

+

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok = resolver->lookup_resolved_name (segment.get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == module_scope_id);

+ else

+ resolver->insert_resolved_name (segment.get_node_id (),

+ module_scope_id);

+ if (!is_first_segment)

+ {

+ rust_error_at (segment.get_locus (),

+ "%<super%> can only be used in start position");

+ return UNKNOWN_NODEID;

+ }

+

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok = resolver->lookup_resolved_name (segment.get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == module_scope_id);

+ else

+ resolver->insert_resolved_name (segment.get_node_id (),

+ module_scope_id);

+

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok = resolver->lookup_resolved_name (segment.get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node);

+ else

+ resolver->insert_resolved_name (segment.get_node_id (),

+ resolved_node);

+

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok = resolver->lookup_resolved_type (segment.get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node);

+ else

+ resolver->insert_resolved_type (segment.get_node_id (),

+ resolved_node);

+ "Cannot find path %<%s%> in this scope",

+

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok = resolver->lookup_resolved_name (segment.get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node);

+ else

+ resolver->insert_resolved_name (segment.get_node_id (),

+ resolved_node);

+

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok = resolver->lookup_resolved_type (segment.get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node);

+ else

+ resolver->insert_resolved_type (segment.get_node_id (),

+ resolved_node);

+ "cannot find simple path segment %<%s%> in this scope",

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok

+ = resolver->lookup_resolved_name (expr.get_node_id (), &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node_id);

+ else

+ resolver->insert_resolved_name (expr.get_node_id (),

+ resolved_node_id);

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok

+ = resolver->lookup_resolved_type (expr.get_node_id (), &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node_id);

+ else

+ resolver->insert_resolved_type (expr.get_node_id (),

+ resolved_node_id);

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ ResolveExpr::go (stmt.get_init_expr (), prefix, canonical_prefix);

+

+ if (stmt.has_else_expr ())

+ ResolveExpr::go (stmt.get_else_expr (), prefix, canonical_prefix);

+ rust_error_at (r, "defined multiple times");

+ ResolveGenericParams::go (struct_decl.get_generic_params (), prefix,

+ canonical_prefix);

+ rust_error_at (r, "defined multiple times");

+ ResolveGenericParams::go (enum_decl.get_generic_params (), prefix,

+ canonical_prefix);

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ ResolveGenericParams::go (struct_decl.get_generic_params (), prefix,

+ canonical_prefix);

+ rust_error_at (r, "defined multiple times");

+ ResolveGenericParams::go (union_decl.get_generic_params (), prefix,

+ canonical_prefix);

+ rust_error_at (r, "defined multiple times");

+ resolver->push_new_label_rib (resolver->get_label_scope ().peek ());

+ ResolveGenericParams::go (function.get_generic_params (), prefix,

+ canonical_prefix);

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ auto duplicate_item

+ = [&] (const CanonicalPath &, NodeId, location_t locus) -> void {

+ rich_location r (line_table, struct_decl.get_locus ());

+ r.add_range (locus);

+ rust_error_at (r, "defined multiple times");

+ };

+

+ resolver->get_type_scope ().insert (path, struct_decl.get_node_id (),

+ struct_decl.get_locus (), false,

+ Rib::ItemType::Type, duplicate_item);

+

+ if (struct_decl.is_unit_struct ())

+ resolver->get_name_scope ().insert (path, struct_decl.get_node_id (),

+ struct_decl.get_locus (), false,

+ Rib::ItemType::Type, duplicate_item);

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+ rust_error_at (r, "defined multiple times");

+NodeId

+ResolveType::go (AST::Type &type)

+{

+ ResolveType resolver;

+ type.accept_vis (resolver);

+ return resolver.resolved_node;

+}

+

+void

+ResolveType::visit (AST::BareFunctionType &fntype)

+{

+ for (auto &param : fntype.get_function_params ())

+ ResolveType::go (param.get_type ());

+

+ if (fntype.has_return_type ())

+ ResolveType::go (fntype.get_return_type ());

+}

+

+void

+ResolveType::visit (AST::TupleType &tuple)

+{

+ if (tuple.is_unit_type ())

+ {

+ resolved_node = resolver->get_unit_type_node_id ();

+ return;

+ }

+

+ for (auto &elem : tuple.get_elems ())

+ ResolveType::go (*elem);

+}

+

+void

+ResolveType::visit (AST::TypePath &path)

+{

+ ResolveRelativeTypePath::go (path, resolved_node);

+}

+

+void

+ResolveType::visit (AST::QualifiedPathInType &path)

+{

+ ResolveRelativeQualTypePath::go (path);

+}

+

+ // nothing to do

+void

+ResolveType::visit (AST::ImplTraitType &type)

+{

+ for (auto &bound : type.get_type_param_bounds ())

+ ResolveTypeBound::go (*bound);

+}

+

+void

+ResolveType::visit (AST::ImplTraitTypeOneBound &type)

+{

+ ResolveTypeBound::go (type.get_trait_bound ());

+}

+

+ "leading path segment %qs can only be used at the "

+ "beginning of a path",

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok = resolver->lookup_resolved_type (segment->get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node);

+ else

+ resolver->insert_resolved_type (segment->get_node_id (),

+ resolved_node);

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok = resolver->lookup_resolved_name (segment->get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node);

+ else

+ resolver->insert_resolved_name (segment->get_node_id (),

+ resolved_node);

+

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok = resolver->lookup_resolved_name (segment->get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == module_scope_id);

+ else

+ resolver->insert_resolved_name (segment->get_node_id (),

+ module_scope_id);

+

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok

+ = resolver->lookup_resolved_name (segment->get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node);

+ else

+ resolver->insert_resolved_name (segment->get_node_id (),

+ resolved_node);

+

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok

+ = resolver->lookup_resolved_type (segment->get_node_id (),

+ &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node);

+ else

+ resolver->insert_resolved_type (segment->get_node_id (),

+ resolved_node);

+ "could not resolve type path %qs",

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok

+ = resolver->lookup_resolved_name (path.get_node_id (), &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node_id);

+ else

+ resolver->insert_resolved_name (path.get_node_id (),

+ resolved_node_id);

+ NodeId existing = UNKNOWN_NODEID;

+ bool ok

+ = resolver->lookup_resolved_type (path.get_node_id (), &existing);

+

+ if (ok)

+ rust_assert (existing == resolved_node_id);

+ else

+ resolver->insert_resolved_type (path.get_node_id (),

+ resolved_node_id);

+ static NodeId go (AST::Type &type);

+ void visit (AST::BareFunctionType &fntype) override;

+ void visit (AST::TupleType &tuple) override;

+ void visit (AST::TypePath &path) override;

+ void visit (AST::QualifiedPathInType &path) override;

+ void visit (AST::ImplTraitType &type) override;

+ void visit (AST::ImplTraitTypeOneBound &type) override;

+class ResolveGenericParams : public ResolverBase

+ static void go (std::vector<std::unique_ptr<AST::GenericParam>> &params,

+ const CanonicalPath &prefix,

+ const CanonicalPath &canonical_prefix)

+ ResolveGenericParams resolver (prefix, canonical_prefix);

+

+ // this needs to be done in two phases as they can be used and defined later

+ // in bounds

+ for (auto &param : params)

+ param->accept_vis (resolver);

+

+ resolver.first_pass = false;

+

+ for (auto &param : params)

+ param->accept_vis (resolver);

+ }

+

+ static void go_single (AST::GenericParam &param, const CanonicalPath &prefix,

+ const CanonicalPath &canonical_prefix)

+ {

+ ResolveGenericParams resolver (prefix, canonical_prefix);

+

+ param.accept_vis (resolver);

+ resolver.first_pass = false;

+ if (first_pass)

+ ResolveType::go (param.get_type ());

+ else if (param.has_default_value ())

+ if (first_pass)

+ {

+ // if it has a type lets resolve it

+ if (param.has_type ())

+ ResolveType::go (param.get_type ());

+

+ auto seg = CanonicalPath::new_seg (

+ param.get_node_id (), param.get_type_representation ().as_string ());

+ resolver->get_type_scope ().insert (

+ seg, param.get_node_id (), param.get_locus (), false,

+ Rib::ItemType::Type,

+ [&] (const CanonicalPath &, NodeId, location_t locus) -> void {

+ rust_error_at (param.get_locus (),

+ "generic param defined multiple times");

+ rust_error_at (locus, "was defined here");

+ });

+

+ mappings.insert_canonical_path (param.get_node_id (), seg);

+ }

+ else if (param.has_type_param_bounds ())

+ ResolveTypeBound::go (*bound);

+ ResolveGenericParams (const CanonicalPath &prefix,

+ const CanonicalPath &canonical_prefix)

+ : ResolverBase (), first_pass (true), prefix (prefix),

+ bool first_pass;

+ resolver->push_new_label_rib (resolver->get_label_scope ().peek ());

+#include "rust-attribute-values.h"

+Early::Early (NameResolutionContext &ctx)

+ : DefaultResolver (ctx), toplevel (TopLevel (ctx)), dirty (false)

+ auto resolved

+ = ctx.resolve_path (glob.to_resolve.get_segments (), Namespace::Types);

+ bool is_macro_use = false;

+

+ for (const auto &attr : module.get_outer_attrs ())

+ {

+ if (attr.get_path ().as_string () == Values::Attributes::MACRO_USE)

+ {

+ is_macro_use = true;

+ break;

+ }

+ }

+

+ if (!is_macro_use)

+ textual_scope.push ();

+ if (!is_macro_use)

+ textual_scope.pop ();

+ definition = ctx.resolve_path (path.get_segments (), Namespace::Macros);

+ "could not resolve macro invocation %qs",

+ path.as_string ().c_str ()));

+ auto definition = ctx.resolve_path (trait.get ().get_segments (),

+ Namespace::Macros);

+ auto definition = ctx.resolve_path (attr.get_path ().get_segments (),

+ Namespace::Macros);

+void

+Early::finalize_simple_import (const Early::ImportPair &mapping)

+{

+ // FIXME: We probably need to store namespace information

+

+ auto locus = mapping.import_kind.to_resolve.get_locus ();

+ auto data = mapping.data;

+ auto identifier

+ = mapping.import_kind.to_resolve.get_final_segment ().get_segment_name ();

+

+ for (auto &&definition : data.definitions ())

+ toplevel

+ .insert_or_error_out (

+ identifier, locus, definition.first.get_node_id (), definition.second /* TODO: This isn't clear - it would be better if it was called .ns or something */);

+}

+

+void

+Early::finalize_glob_import (NameResolutionContext &ctx,

+ const Early::ImportPair &mapping)

+{

+ auto module = Analysis::Mappings::get ().lookup_ast_module (

+ mapping.data.module ().get_node_id ());

+ rust_assert (module);

+

+ GlobbingVisitor glob_visitor (ctx);

+ glob_visitor.go (module.value ());

+}

+

+void

+Early::finalize_rebind_import (const Early::ImportPair &mapping)

+{

+ // We can fetch the value here as `resolve_rebind` will only be called on

+ // imports of the right kind

+ auto &path = mapping.import_kind.to_resolve;

+ auto &rebind = mapping.import_kind.rebind.value ();

+ auto data = mapping.data;

+

+ location_t locus = UNKNOWN_LOCATION;

+ std::string declared_name;

+

+ // FIXME: This needs to be done in `FinalizeImports`

+ switch (rebind.get_new_bind_type ())

+ {

+ case AST::UseTreeRebind::NewBindType::IDENTIFIER:

+ declared_name = rebind.get_identifier ().as_string ();

+ locus = rebind.get_identifier ().get_locus ();

+ break;

+ case AST::UseTreeRebind::NewBindType::NONE: {

+ const auto &segments = path.get_segments ();

+ // We don't want to insert `self` with `use module::self`

+ if (path.get_final_segment ().is_lower_self_seg ())

+ {

+ rust_assert (segments.size () > 1);

+ declared_name = segments[segments.size () - 2].as_string ();

+ }

+ else

+ declared_name = path.get_final_segment ().as_string ();

+ locus = path.get_final_segment ().get_locus ();

+ break;

+ }

+ case AST::UseTreeRebind::NewBindType::WILDCARD:

+ rust_unreachable ();

+ break;

+ }

+

+ for (auto &&definition : data.definitions ())

+ toplevel.insert_or_error_out (

+ declared_name, locus, definition.first.get_node_id (), definition.second /* TODO: This isn't clear - it would be better if it was called .ns or something */);

+}

+

+void

+Early::visit (AST::UseDeclaration &decl)

+{

+ auto &imports = toplevel.get_imports_to_resolve ();

+ auto current_import = imports.find (decl.get_node_id ());

+ if (current_import != imports.end ())

+ {

+ build_import_mapping (*current_import);

+ }

+

+ // Once this is done, we finalize their resolution

+ for (const auto &mapping : import_mappings.get (decl.get_node_id ()))

+ switch (mapping.import_kind.kind)

+ {

+ case TopLevel::ImportKind::Kind::Glob:

+ finalize_glob_import (ctx, mapping);

+ break;

+ case TopLevel::ImportKind::Kind::Simple:

+ finalize_simple_import (mapping);

+ break;

+ case TopLevel::ImportKind::Kind::Rebind:

+ finalize_rebind_import (mapping);

+ break;

+ }

+

+ DefaultResolver::visit (decl);

+}

+

+ TopLevel toplevel;

+ void visit (AST::UseDeclaration &) override;

+ ctx.resolve_path (segments, Namespace::Values)

+ .map (pair_with_ns (Namespace::Values));

+ ctx.resolve_path (segments, Namespace::Types)

+ .map (pair_with_ns (Namespace::Types));

+ ctx.resolve_path (segments, Namespace::Macros)

+ .map (pair_with_ns (Namespace::Macros));

+

+ void finalize_simple_import (const Early::ImportPair &mapping);

+

+ void finalize_glob_import (NameResolutionContext &ctx,

+ const Early::ImportPair &mapping);

+

+ void finalize_rebind_import (const Early::ImportPair &mapping);

+ if (!path.is_lang_item ())

+ for (auto &segment : path.get_segments ())

+ if (segment.has_generic_args ())

+ resolve_generic_args (segment.get_generic_args ());

+ rust_error_at (invoc.get_locus (), ErrorCode::E0433,

+ "could not resolve macro invocation %qs",

+

+ lang_prelude (Node (Rib (Rib::Kind::Prelude), UNKNOWN_NODEID, root)),

+

+ // TODO: Should we be using the forever stack root as the crate scope?

+ // TODO: Is this how we should be getting the crate node id?

+ auto &mappings = Analysis::Mappings::get ();

+ root.id = *mappings.crate_num_to_nodeid (mappings.get_current_crate ());

+ tl::expected<NodeId, DuplicateNameError> insert_variant (Identifier name,

+ NodeId id);

+

+ tl::optional<Rib::Definition> get_lang_prelude (const Identifier &name);

+ tl::optional<Rib::Definition> get_lang_prelude (const std::string &name);

+ tl::optional<Rib::Definition> resolve_path (

+ const std::vector<S> &segments,

+ std::function<void (const S &, NodeId)> insert_segment_resolution);

+ std::string as_debug_string () const;

+ bool is_prelude () const;

+ /* The forever stack's actual nodes */

+ /*

+ * A special prelude node used currently for resolving language builtins

+ * It has the root node as a parent, and acts as a "special case" for name

+ * resolution

+ */

+ Node lang_prelude;

+

+ const std::string &next, const std::string &next_next) const;

+ const Node &node) const;

+ tl::optional<SegIterator<S>> find_starting_point (

+ const std::vector<S> &segments,

+ std::reference_wrapper<Node> &starting_point,

+ std::function<void (const S &, NodeId)> insert_segment_resolution);

+ tl::optional<Node &> resolve_segments (

+ Node &starting_point, const std::vector<S> &segments,

+ SegIterator<S> iterator,

+ std::function<void (const S &, NodeId)> insert_segment_resolution);

+

+ tl::optional<Rib::Definition> resolve_final_segment (Node &final_node,

+ std::string &seg_name,

+ bool is_lower_self);

+#include "rust-unwrap-segment.h"

+ForeverStack<N>::Node::is_prelude () const

+{

+ return rib.kind == Rib::Kind::Prelude;

+}

+

+template <Namespace N>

+bool

+ if (rib.kind == Rib::Kind::Prelude)

+ {

+ // If you push_inner into the prelude from outside the root, you will pop

+ // back into the root, which could screw up a traversal.

+ rust_assert (&cursor_reference.get () == &root);

+ // Prelude doesn't have an access path

+ rust_assert (!link.path);

+ update_cursor (this->lang_prelude);

+ return;

+ }

+template <>

+inline tl::expected<NodeId, DuplicateNameError>

+ForeverStack<Namespace::Types>::insert_variant (Identifier name, NodeId node)

+{

+ return insert_inner (peek (), name.as_string (),

+ Rib::Definition::NonShadowable (node, true));

+}

+

+ if (found.is_variant ())

+ return KeepGoing::Yes;

+ // for most namespaces, we do not need to care about various ribs -

+ // they are available from all contexts if defined in the current

+ // scope, or an outermore one. so if we do have a candidate, we can

+ // return it directly and stop iterating

+template <Namespace N>

+tl::optional<Rib::Definition>

+ForeverStack<N>::get_lang_prelude (const Identifier &name)

+{

+ return lang_prelude.rib.get (name.as_string ());

+}

+

+template <Namespace N>

+tl::optional<Rib::Definition>

+ForeverStack<N>::get_lang_prelude (const std::string &name)

+{

+ return lang_prelude.rib.get (name);

+}

+

+ const std::vector<S> &segments, std::reference_wrapper<Node> &starting_point,

+ std::function<void (const S &, NodeId)> insert_segment_resolution)

+ auto &outer_seg = *iterator;

+

+ if (unwrap_segment_get_lang_item (outer_seg).has_value ())

+ break;

+

+ auto &seg = unwrap_type_segment (outer_seg);

+ bool is_self_or_crate

+ insert_segment_resolution (outer_seg, starting_point.get ().id);

+ // insert segment resolution and exit

+ starting_point = find_closest_module (starting_point);

+ insert_segment_resolution (outer_seg, starting_point.get ().id);

+ starting_point = find_closest_module (starting_point);

+

+ insert_segment_resolution (outer_seg, starting_point.get ().id);

+ typename std::vector<S>::const_iterator iterator,

+ std::function<void (const S &, NodeId)> insert_segment_resolution)

+ Node *current_node = &starting_point;

+ auto &outer_seg = *iterator;

+

+ if (auto lang_item = unwrap_segment_get_lang_item (outer_seg))

+ {

+ NodeId seg_id = Analysis::Mappings::get ().get_lang_item_node (

+ lang_item.value ());

+ current_node = &dfs_node (root, seg_id).value ();

+

+ insert_segment_resolution (outer_seg, seg_id);

+ continue;

+ }

+

+ auto &seg = unwrap_type_segment (outer_seg);

+ std::string str = seg.as_string ();

+ /*

+ * On every iteration this loop either

+ *

+ * 1. terminates

+ *

+ * 2. decreases the depth of the node pointed to by current_node until

+ * current_node reaches the root

+ *

+ * 3. If the root node is reached, and we were not able to resolve the

+ * segment, we search the prelude rib for the segment, by setting

+ * current_node to point to the prelude, and toggling the

+ * searched_prelude boolean to true. If current_node is the prelude

+ * rib, and searched_prelude is true, we will exit.

+ *

+ * This ensures termination.

+ *

+ */

+ bool searched_prelude = false;

+ while (true)

+ // may set the value of child

+ for (auto &kv : current_node->children)

+ {

+ auto &link = kv.first;

+

+ if (link.path.map_or (

+ [&str] (Identifier path) {

+ auto &path_str = path.as_string ();

+ return str == path_str;

+ },

+ false))

+ {

+ child = kv.second;

+ break;

+ }

+ }

+ if (child.has_value ())

+ if (N == Namespace::Types)

+ {

+ auto rib_lookup = current_node->rib.get (seg.as_string ());

+ if (rib_lookup && !rib_lookup->is_ambiguous ())

+ {

+ insert_segment_resolution (outer_seg,

+ rib_lookup->get_node_id ());

+ return tl::nullopt;

+ }

+ }

+

+ if (current_node->is_root () && !searched_prelude)

+ {

+ searched_prelude = true;

+ current_node = &lang_prelude;

+ continue;

+ }

+

+ if (!is_start (iterator, segments)

+ || current_node->rib.kind == Rib::Kind::Module

+ || current_node->is_prelude ())

+ {

+ return tl::nullopt;

+ }

+

+ current_node = &current_node->parent.value ();

+ // if child didn't contain a value

+ // the while loop above should have return'd or kept looping

+ insert_segment_resolution (outer_seg, current_node->id);

+template <>

+inline tl::optional<Rib::Definition>

+ForeverStack<Namespace::Types>::resolve_final_segment (Node &final_node,

+ std::string &seg_name,

+ bool is_lower_self)

+{

+ if (is_lower_self)

+ return Rib::Definition::NonShadowable (final_node.id);

+ else

+ return final_node.rib.get (seg_name);

+}

+

+template <Namespace N>

+tl::optional<Rib::Definition>

+ForeverStack<N>::resolve_final_segment (Node &final_node, std::string &seg_name,

+ bool is_lower_self)

+{

+ return final_node.rib.get (seg_name);

+}

+

+ForeverStack<N>::resolve_path (

+ const std::vector<S> &segments,

+ std::function<void (const S &, NodeId)> insert_segment_resolution)

+ {

+ auto &seg = segments.front ();

+ if (auto lang_item = unwrap_segment_get_lang_item (seg))

+ {

+ NodeId seg_id = Analysis::Mappings::get ().get_lang_item_node (

+ lang_item.value ());

+

+ insert_segment_resolution (seg, seg_id);

+ // TODO: does NonShadowable matter?

+ return Rib::Definition::NonShadowable (seg_id);

+ }

+

+ tl::optional<Rib::Definition> res

+ = get (unwrap_type_segment (segments.back ()).as_string ());

+

+ if (!res)

+ res = get_lang_prelude (

+ unwrap_type_segment (segments.back ()).as_string ());

+

+ if (res && !res->is_ambiguous ())

+ insert_segment_resolution (segments.back (), res->get_node_id ());

+ return res;

+ }

+ return find_starting_point (segments, starting_point,

+ insert_segment_resolution)

+ .and_then ([this, &segments, &starting_point, &insert_segment_resolution] (

+ return resolve_segments (starting_point.get (), segments, iterator,

+ insert_segment_resolution);

+ .and_then ([this, &segments, &insert_segment_resolution] (

+ Node final_node) -> tl::optional<Rib::Definition> {

+ // leave resolution within impl blocks to type checker

+ if (final_node.rib.kind == Rib::Kind::TraitOrImpl)

+ return tl::nullopt;

+

+ auto &seg = unwrap_type_segment (segments.back ());

+ std::string seg_name = seg.as_string ();

+

+ // assuming this can't be a lang item segment

+ tl::optional<Rib::Definition> res

+ = resolve_final_segment (final_node, seg_name,

+ seg.is_lower_self_seg ());

+ // Ok we didn't find it in the rib, Lets try the prelude...

+ if (!res)

+ res = get_lang_prelude (seg_name);

+

+ if (res && !res->is_ambiguous ())

+ insert_segment_resolution (segments.back (), res->get_node_id ());

+

+ return res;

+ if (current.id == child.id)

+ auto &mappings = Analysis::Mappings::get ();

+ CrateNum crate_num = mappings.lookup_crate_num (root.id).value ();

+ auto path = Resolver::CanonicalPath::new_seg (

+ root.id, mappings.get_crate_name (crate_num).value ());

+ path.set_crate_num (crate_num);

+

+ return dfs_node (starting_point, to_find)

+ .map ([] (const Node &x) -> const Rib & { return x.rib; });

+ const std::string &next_next) const

+ std::string rib_kind = Rib::kind_to_string (rib.kind);

+ stream << next << "rib [" << rib_kind << "]: {";

+ stream << "}\n";

+ else

+ {

+ stream << "\n";

+ }

+ const ForeverStack<N>::Node &node) const

+ForeverStack<N>::as_debug_string () const

+// Copyright (C) 2020-2024 Free Software Foundation, Inc.

+

+// This file is part of GCC.

+

+// GCC is free software; you can redistribute it and/or modify it under

+// the terms of the GNU General Public License as published by the Free

+// Software Foundation; either version 3, or (at your option) any later

+// version.

+

+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY

+// WARRANTY; without even the implied warranty of MERCHANTABILITY or

+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

+// for more details.

+

+// You should have received a copy of the GNU General Public License

+// along with GCC; see the file COPYING3. If not see

+// <http://www.gnu.org/licenses/>.

+

+#include "rust-ice-finalizer.h"

+

+namespace Rust {

+namespace Resolver {

+

+void ATTRIBUTE_NORETURN

+funny_ice_text_finalizer (diagnostic_text_output_format &text_output,

+ const diagnostic_info *diagnostic,

+ diagnostic_t diag_kind)

+{

+ gcc_assert (diag_kind == DK_ICE_NOBT);

+ default_diagnostic_text_finalizer (text_output, diagnostic, diag_kind);

+ fnotice (stderr, "You have broken GCC Rust. This is a feature.\n");

+ exit (ICE_EXIT_CODE);

+}

+

+} // namespace Resolver

+} // namespace Rust

+// Copyright (C) 2020-2024 Free Software Foundation, Inc.

+

+// This file is part of GCC.

+

+// GCC is free software; you can redistribute it and/or modify it under

+// the terms of the GNU General Public License as published by the Free

+// Software Foundation; either version 3, or (at your option) any later

+// version.

+

+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY

+// WARRANTY; without even the implied warranty of MERCHANTABILITY or

+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

+// for more details.

+

+// You should have received a copy of the GNU General Public License

+// along with GCC; see the file COPYING3. If not see

+// <http://www.gnu.org/licenses/>.

+

+#ifndef RUST_ICE_FINALIZER_H

+#define RUST_ICE_FINALIZER_H

+

+#include "rust-linemap.h"

+#include "diagnostic.h"

+

+namespace Rust {

+namespace Resolver {

+

+/* The "break rust" Easter egg.

+

+ Backstory: once upon a time, there used to be a bug in rustc: it would ICE

+ during typechecking on a 'break' with an expression outside of a loop. The

+ issue has been reported [0] and fixed [1], but in recognition of this, as a

+ special Easter egg, "break rust" was made to intentionally cause an ICE.

+

+ [0]: https://github.com/rust-lang/rust/issues/43162

+ [1]: https://github.com/rust-lang/rust/pull/43745

+

+ This was made in a way that does not break valid programs: namely, it only

+ happens when the 'break' is outside of a loop (so invalid anyway).

+

+ GCC Rust supports this essential feature as well, but in a slightly

+ different way. Instead of delaying the error until type checking, we emit

+ it here in the resolution phase. We, too, only do this to programs that

+ are already invalid: we only emit our funny ICE if the name "rust" (which

+ must be immediately inside a break-with-a-value expression) fails to

+ resolve. Note that "break (rust)" does not trigger our ICE, only using

+ "break rust" directly does, and only if there's no "rust" in scope. We do

+ this in the same way regardless of whether the "break" is outside of a loop

+ or inside one.

+

+ As a GNU extension, we also support "break gcc", much to the same effect,

+ subject to the same rules. */

+

+/* The finalizer for our funny ICE. This prints a custom message instead of

+ the default bug reporting instructions, as there is no bug to report. */

+

+void ATTRIBUTE_NORETURN

+funny_ice_text_finalizer (diagnostic_text_output_format &text_output,

+ const diagnostic_info *diagnostic,

+ diagnostic_t diag_kind);

+

+} // namespace Resolver

+} // namespace Rust

+

+#endif /* ! RUST_ICE_FINALIZER_H */

+#include "rust-ice-finalizer.h"

+#include "rust-ast.h"

+ // There's a special Rib for putting prelude items, since prelude items need

+ // to satisfy certain special rules.

+ ctx.scoped (Rib::Kind::Prelude, 0, [this, &ty_ctx] (void) -> void {

+ for (const auto &builtin : builtins)

+ {

+ auto ok = ctx.types.insert (builtin.name, builtin.node_id);

+ rust_assert (ok);

+ ctx.mappings.insert_node_to_hir (builtin.node_id, builtin.hir_id);

+ ty_ctx.insert_builtin (builtin.hir_id, builtin.node_id, builtin.type);

+ }

+ });

+ if (let.has_else_expr ())

+ visit (let.get_init_expr ());

+

+Late::visit (AST::BreakExpr &expr)

+{

+ if (expr.has_break_expr ())

+ {

+ auto &break_expr = expr.get_break_expr ();

+ if (break_expr.get_expr_kind () == AST::Expr::Kind::Identifier)

+ {

+ /* This is a break with an expression, and the expression is

+ just a single identifier. See if the identifier is either

+ "rust" or "gcc", in which case we have "break rust" or "break

+ gcc", and so may need to emit our funny error. We cannot yet

+ emit the error here though, because the identifier may still

+ be in scope, and ICE'ing on valid programs would not be very

+ funny. */

+ std::string ident

+ = static_cast<AST::IdentifierExpr &> (expr.get_break_expr ())

+ .as_string ();

+ if (ident == "rust" || ident == "gcc")

+ funny_error = true;

+ }

+ }

+

+ DefaultResolver::visit (expr);

+

+ funny_error = false;

+}

+

+void

+ else if (funny_error)

+ {

+ diagnostic_text_finalizer (global_dc) = Resolver::funny_ice_text_finalizer;

+ emit_diagnostic (DK_ICE_NOBT, expr.get_locus (), -1,

+ "are you trying to break %s? how dare you?",

+ expr.as_string ().c_str ());

+ }

+ if (auto type = ctx.types.get_lang_prelude (expr.get_ident ()))

+ {

+ resolved = type;

+ }

+ else

+ {

+ rust_error_at (expr.get_locus (), ErrorCode::E0425,

+ "cannot find value %qs in this scope",

+ expr.get_ident ().as_string ().c_str ());

+ return;

+ }

+ }

+

+ if (resolved->is_ambiguous ())

+ {

+ rust_error_at (expr.get_locus (), ErrorCode::E0659, "%qs is ambiguous",

+ expr.as_string ().c_str ());

+Late::visit (AST::StructExprFieldIdentifier &expr)

+{

+ tl::optional<Rib::Definition> resolved = tl::nullopt;

+

+ if (auto value = ctx.values.get (expr.get_field_name ()))

+ {

+ resolved = value;

+ }

+ // seems like we don't need a type namespace lookup

+ else

+ {

+ rust_error_at (expr.get_locus (), "could not resolve struct field: %qs",

+ expr.get_field_name ().as_string ().c_str ());

+ return;

+ }

+

+ if (resolved->is_ambiguous ())

+ {

+ rust_error_at (expr.get_locus (), ErrorCode::E0659, "%qs is ambiguous",

+ expr.as_string ().c_str ());

+ return;

+ }

+

+ ctx.map_usage (Usage (expr.get_node_id ()),

+ Definition (resolved->get_node_id ()));

+}

+

+void

+ DefaultResolver::visit (expr);

+

+ if (expr.is_lang_item ())

+ {

+ ctx.map_usage (Usage (expr.get_node_id ()),

+ Definition (Analysis::Mappings::get ().get_lang_item_node (

+ expr.get_lang_item ())));

+ return;

+ }

+

+ auto resolved = ctx.resolve_path (expr.get_segments (), Namespace::Values,

+ Namespace::Types);

+ if (!ctx.lookup (expr.get_segments ().front ().get_node_id ()))

+ rust_error_at (expr.get_locus (),

+ "could not resolve path expression: %qs",

+ expr.as_simple_path ().as_string ().c_str ());

+ DefaultResolver::visit (type);

+ // take care of only simple cases

+ // TODO: remove this?

+ rust_assert (!type.has_opening_scope_resolution_op ());

+ // this *should* mostly work

+ // TODO: make sure typepath-like path resolution (?) is working

+ auto resolved = ctx.resolve_path (type.get_segments (), Namespace::Types);

+

+ if (!resolved.has_value ())

+ {

+ if (!ctx.lookup (type.get_segments ().front ()->get_node_id ()))

+ rust_error_at (type.get_locus (), "could not resolve type path %qs",

+ type.as_string ().c_str ());

+ return;

+ }

+

+ if (resolved->is_ambiguous ())

+ {

+ rust_error_at (type.get_locus (), ErrorCode::E0659, "%qs is ambiguous",

+ type.as_string ().c_str ());

+ return;

+ }

+

+ ctx.map_usage (Usage (type.get_node_id ()),

+ Definition (resolved->get_node_id ()));

+ visit_outer_attrs (s);

+ visit_inner_attrs (s);

+ DefaultResolver::visit (s.get_struct_name ());

+

+ auto resolved

+ = ctx.resolve_path (s.get_struct_name ().get_segments (), Namespace::Types);

+ visit_outer_attrs (s);

+ visit_inner_attrs (s);

+ DefaultResolver::visit (s.get_struct_name ());

+ visit (s.get_struct_base ());

+

+ auto resolved

+ = ctx.resolve_path (s.get_struct_name ().get_segments (), Namespace::Types);

+ visit_outer_attrs (s);

+ visit_inner_attrs (s);

+ DefaultResolver::visit (s.get_struct_name ());

+ if (s.has_struct_base ())

+ visit (s.get_struct_base ());

+ for (auto &field : s.get_fields ())

+ visit (field);

+

+ auto resolved

+ = ctx.resolve_path (s.get_struct_name ().get_segments (), Namespace::Types);

+template <class Closure>

+static void

+add_captures (Closure &closure, NameResolutionContext &ctx)

+{

+ auto vals = ctx.values.peek ().get_values ();

+ for (auto &val : vals)

+ {

+ ctx.mappings.add_capture (closure.get_node_id (),

+ val.second.get_node_id ());

+ }

+}

+

+void

+Late::visit (AST::ClosureExprInner &closure)

+{

+ add_captures (closure, ctx);

+ DefaultResolver::visit (closure);

+}

+

+void

+Late::visit (AST::ClosureExprInnerTyped &closure)

+{

+ add_captures (closure, ctx);

+ DefaultResolver::visit (closure);

+}

+

+#include "rust-expr.h"

+ void visit (AST::StructExprFieldIdentifier &) override;

+ void visit (AST::BreakExpr &) override;

+ void visit (AST::ClosureExprInner &) override;

+ void visit (AST::ClosureExprInnerTyped &) override;

+

+ bool funny_error;

+NameResolutionContext::insert_variant (Identifier name, NodeId id)

+{

+ return types.insert_variant (name, id);

+}

+

+tl::expected<NodeId, DuplicateNameError>

+ // NOTE: You must be at the root node when pushing the prelude rib.

+ // This could work... I'm not sure why you would want to do this though.

+ rust_assert (rib_kind != Rib::Kind::Prelude);

+

+ tl::expected<NodeId, DuplicateNameError> insert_variant (Identifier name,

+ NodeId id);

+

+ template <typename S>

+ tl::optional<Rib::Definition> resolve_path (const std::vector<S> &segments,

+ Namespace ns)

+ {

+ std::function<void (const S &, NodeId)> insert_segment_resolution

+ = [this] (const S &seg, NodeId id) {

+ auto seg_id = unwrap_segment_node_id (seg);

+ if (resolved_nodes.find (Usage (seg_id)) == resolved_nodes.end ())

+ map_usage (Usage (seg_id), Definition (id));

+ };

+ switch (ns)

+ {

+ case Namespace::Values:

+ return values.resolve_path (segments, insert_segment_resolution);

+ case Namespace::Types:

+ return types.resolve_path (segments, insert_segment_resolution);

+ case Namespace::Macros:

+ return macros.resolve_path (segments, insert_segment_resolution);

+ case Namespace::Labels:

+ return labels.resolve_path (segments, insert_segment_resolution);

+ default:

+ rust_unreachable ();

+ }

+ }

+

+ template <typename S, typename... Args>

+ tl::optional<Rib::Definition> resolve_path (const std::vector<S> &segments,

+ Args... ns_args)

+ {

+ std::initializer_list<Namespace> namespaces = {ns_args...};

+

+ for (auto ns : namespaces)

+ {

+ if (auto ret = resolve_path (segments, ns))

+ return ret;

+ }

+

+ return tl::nullopt;

+ }

+

+ rust_assert (resolved_names.find (refId) == resolved_names.end ());

+

+ rust_assert (resolved_types.find (refId) == resolved_types.end ());

+ rust_assert (!flag_name_resolution_2_0);

+

+ std::string as_debug_string () const

+ {

+ std::stringstream ss;

+

+ ss << "Names:\n";

+ for (auto &n : name_ribs)

+ {

+ ss << "\tNodeID: " << n.first << " Rib: " << n.second->debug_str ()

+ << "\n";

+ }

+ ss << "Types:\n";

+ for (auto &n : type_ribs)

+ {

+ ss << "\tNodeID: " << n.first << " Rib: " << n.second->debug_str ()

+ << "\n";

+ }

+ ss << "Macros:\n";

+

+ for (auto &n : macro_ribs)

+ {

+ ss << "\tNodeID: " << n.first << " Rib: " << n.second->debug_str ()

+ << "\n";

+ }

+

+ ss << "Labels:\n";

+

+ for (auto &n : label_ribs)

+ {

+ ss << "\tNodeID: " << n.first << " Rib: " << n.second->debug_str ()

+ << "\n";

+ }

+

+ return ss.str ();

+ }

+

+Rib::Definition::Definition (NodeId id, Mode mode, bool enum_variant)

+ : enum_variant (enum_variant)

+bool

+Rib::Definition::is_variant () const

+{

+ return enum_variant;

+}

+

+ if (enum_variant)

+ out << "(enum variant)";

+ return Definition (id, Mode::SHADOWABLE, false);

+Rib::Definition::NonShadowable (NodeId id, bool enum_variant)

+ return Definition (id, Mode::NON_SHADOWABLE, enum_variant);

+ return Definition (id, Mode::GLOBBED, false);

+ static Definition NonShadowable (NodeId id, bool enum_variant = false);

+ // Enum variant should be skipped when dealing with inner definition.

+ // struct E2;

+ //

+ // enum MyEnum<T> /* <-- Should be kept */{

+ // E2 /* <-- Should be skipped */ (E2);

+ // }

+ bool enum_variant;

+

+ bool is_variant () const;

+

+ Definition (NodeId id, Mode mode, bool enum_variant);

+ /* Prelude rib, used for both the language prelude (i32,usize,etc) and the

+ * (future) {std,core}::prelude::* import. A regular rib with the

+ * restriction that you cannot `use` items from the Prelude

+ */

+ Prelude,

+ static std::string kind_to_string (Rib::Kind kind)

+ {

+ switch (kind)

+ {

+ case Rib::Kind::Normal:

+ return "Normal";

+ case Rib::Kind::Module:

+ return "Module";

+ case Rib::Kind::Function:

+ return "Function";

+ case Rib::Kind::ConstantItem:

+ return "ConstantItem";

+ case Rib::Kind::TraitOrImpl:

+ return "TraitOrImpl";

+ case Rib::Kind::Item:

+ return "Item";

+ case Rib::Kind::Closure:

+ return "Closure";

+ case Rib::Kind::MacroDefinition:

+ return "Macro definition";

+ case Rib::Kind::ForwardTypeParamBan:

+ return "Forward type param ban";

+ case Rib::Kind::ConstParamType:

+ return "Const Param Type";

+ default:

+ rust_unreachable ();

+ }

+ }

+

+TopLevel::insert_enum_variant_or_error_out (const Identifier &identifier,

+ const T &node)

+ insert_enum_variant_or_error_out (identifier, node.get_locus (),

+ node.get_node_id ());

+TopLevel::check_multiple_insertion_error (

+ tl::expected<NodeId, DuplicateNameError> result, const Identifier &identifier,

+ const location_t &locus, const NodeId node_id)

+void

+TopLevel::insert_enum_variant_or_error_out (const Identifier &identifier,

+ const location_t &locus,

+ const NodeId node_id)

+{

+ // keep track of each node's location to provide useful errors

+ node_locations.emplace (node_id, locus);

+

+ auto result = ctx.insert_variant (identifier, node_id);

+ check_multiple_insertion_error (result, identifier, locus, node_id);

+}

+

+template <typename T>

+void

+TopLevel::insert_or_error_out (const Identifier &identifier, const T &node,

+ Namespace ns)

+{

+ insert_or_error_out (identifier, node.get_locus (), node.get_node_id (), ns);

+}

+

+void

+TopLevel::insert_or_error_out (const Identifier &identifier,

+ const location_t &locus, const NodeId &node_id,

+ Namespace ns)

+{

+ // keep track of each node's location to provide useful errors

+ node_locations.emplace (node_id, locus);

+

+ auto result = ctx.insert (identifier, node_id, ns);

+ check_multiple_insertion_error (result, identifier, locus, node_id);

+}

+ // We do want to visit with the default visitor instead of default resolver

+ // because we don't want to insert the scope twice.

+ // We do want to visit using the default visitor instead of default resolver

+ // because we don't want to insert the scope twice.

+ auto num_opt = mappings.lookup_crate_name (crate.get_referenced_crate ());

+

+ if (!num_opt)

+ {

+ rust_error_at (crate.get_locus (), "unknown crate %qs",

+ crate.get_referenced_crate ().c_str ());

+ return;

+ }

+

+ CrateNum num = *num_opt;

+ insert_enum_variant_or_error_out (variant.get_identifier (), variant);

+ insert_enum_variant_or_error_out (variant.get_identifier (), variant);

+ insert_enum_variant_or_error_out (variant.get_identifier (), variant);

+ std::unordered_map<NodeId, std::vector<ImportKind>> &get_imports_to_resolve ()

+ return imports_to_resolve;

+ void check_multiple_insertion_error (

+ tl::expected<NodeId, DuplicateNameError> result,

+ const Identifier &identifier, const location_t &locus,

+ const NodeId node_id);

+

+ * Insert a new definition or error out if a definition with the same name

+ * was already present in the same namespace in the same scope.

+ template <typename T>

+ void insert_enum_variant_or_error_out (const Identifier &identifier,

+ const T &node);

+

+ void insert_enum_variant_or_error_out (const Identifier &identifier,

+ const location_t &locus,

+ const NodeId node_id);

+