diff --git a/gcc/rust/backend/rust-compile-context.cc b/gcc/rust/backend/rust-compile-context.cc index cb2addf6c217..0687398808d0 100644 --- a/gcc/rust/backend/rust-compile-context.cc +++ b/gcc/rust/backend/rust-compile-context.cc @@ -142,5 +142,52 @@ Context::type_hasher (tree type) return hstate.end (); } +void +Context::push_closure_context (HirId id) +{ + auto it = closure_bindings.find (id); + rust_assert (it == closure_bindings.end ()); + + closure_bindings.insert ({id, {}}); + closure_scope_bindings.push_back (id); +} + +void +Context::pop_closure_context () +{ + rust_assert (!closure_scope_bindings.empty ()); + + HirId ref = closure_scope_bindings.back (); + closure_scope_bindings.pop_back (); + closure_bindings.erase (ref); +} + +void +Context::insert_closure_binding (HirId id, tree expr) +{ + rust_assert (!closure_scope_bindings.empty ()); + + HirId ref = closure_scope_bindings.back (); + closure_bindings[ref].insert ({id, expr}); +} + +bool +Context::lookup_closure_binding (HirId id, tree *expr) +{ + if (closure_scope_bindings.empty ()) + return false; + + HirId ref = closure_scope_bindings.back (); + auto it = closure_bindings.find (ref); + rust_assert (it != closure_bindings.end ()); + + auto iy = it->second.find (id); + if (iy == it->second.end ()) + return false; + + *expr = iy->second; + return true; +} + } // namespace Compile } // namespace Rust diff --git a/gcc/rust/backend/rust-compile-context.h b/gcc/rust/backend/rust-compile-context.h index 658b9a3f595f..7744f01dca33 100644 --- a/gcc/rust/backend/rust-compile-context.h +++ b/gcc/rust/backend/rust-compile-context.h @@ -345,6 +345,11 @@ class Context return mangler.mangle_item (ty, path); } + void push_closure_context (HirId id); + void pop_closure_context (); + void insert_closure_binding (HirId id, tree expr); + bool lookup_closure_binding (HirId id, tree *expr); + std::vector &get_type_decls () { return type_decls; } std::vector<::Bvariable *> &get_var_decls () { return var_decls; } std::vector &get_const_decls () { return const_decls; } @@ -377,6 +382,10 @@ class Context std::map implicit_pattern_bindings; std::map main_variants; + // closure bindings + std::vector closure_scope_bindings; + std::map> closure_bindings; + // To GCC middle-end std::vector type_decls; std::vector<::Bvariable *> var_decls; diff --git a/gcc/rust/backend/rust-compile-expr.cc b/gcc/rust/backend/rust-compile-expr.cc index b077a12f7a35..e50df63821f6 100644 --- a/gcc/rust/backend/rust-compile-expr.cc +++ b/gcc/rust/backend/rust-compile-expr.cc @@ -2824,10 +2824,25 @@ CompileExpr::visit (HIR::ClosureExpr &expr) // lets ignore state capture for now we need to instantiate the struct anyway // then generate the function - std::vector vals; - // TODO - // setup argument captures based on the mode? + for (const auto &capture : closure_tyty->get_captures ()) + { + // lookup the HirId + HirId ref = UNKNOWN_HIRID; + bool ok = ctx->get_mappings ()->lookup_node_to_hir (capture, &ref); + rust_assert (ok); + + // lookup the var decl + Bvariable *var = nullptr; + bool found = ctx->lookup_var_decl (ref, &var); + rust_assert (found); + + // FIXME + // this should bes based on the closure move-ability + tree var_expr = var->get_tree (expr.get_locus ()); + tree val = address_expression (var_expr, expr.get_locus ()); + vals.push_back (val); + } translated = ctx->get_backend ()->constructor_expression (compiled_closure_tyty, false, @@ -2874,8 +2889,29 @@ CompileExpr::generate_closure_function (HIR::ClosureExpr &expr, DECL_ARTIFICIAL (self_param->get_decl ()) = 1; param_vars.push_back (self_param); + // push a new context + ctx->push_closure_context (expr.get_mappings ().get_hirid ()); + // setup the implicit argument captures - // TODO + size_t idx = 0; + for (const auto &capture : closure_tyty.get_captures ()) + { + // lookup the HirId + HirId ref = UNKNOWN_HIRID; + bool ok = ctx->get_mappings ()->lookup_node_to_hir (capture, &ref); + rust_assert (ok); + + // get the assessor + tree binding = ctx->get_backend ()->struct_field_expression ( + self_param->get_tree (expr.get_locus ()), idx, expr.get_locus ()); + tree indirection = indirect_expression (binding, expr.get_locus ()); + + // insert bindings + ctx->insert_closure_binding (ref, indirection); + + // continue + idx++; + } // args tuple tree args_type @@ -2905,7 +2941,10 @@ CompileExpr::generate_closure_function (HIR::ClosureExpr &expr, } if (!ctx->get_backend ()->function_set_parameters (fndecl, param_vars)) - return error_mark_node; + { + ctx->pop_closure_context (); + return error_mark_node; + } // lookup locals HIR::Expr *function_body = expr.get_expr ().get (); @@ -2972,6 +3011,7 @@ CompileExpr::generate_closure_function (HIR::ClosureExpr &expr, gcc_assert (TREE_CODE (bind_tree) == BIND_EXPR); DECL_SAVED_TREE (fndecl) = bind_tree; + ctx->pop_closure_context (); ctx->pop_fn (); ctx->push_function (fndecl); diff --git a/gcc/rust/backend/rust-compile-resolve-path.cc b/gcc/rust/backend/rust-compile-resolve-path.cc index f89da2bdcd55..eaa748ada3ed 100644 --- a/gcc/rust/backend/rust-compile-resolve-path.cc +++ b/gcc/rust/backend/rust-compile-resolve-path.cc @@ -121,6 +121,14 @@ ResolvePathRef::resolve (const HIR::PathIdentSegment &final_segment, return constant_expr; } + // maybe closure binding + tree closure_binding = error_mark_node; + if (ctx->lookup_closure_binding (ref, &closure_binding)) + { + TREE_USED (closure_binding) = 1; + return closure_binding; + } + // this might be a variable reference or a function reference Bvariable *var = nullptr; if (ctx->lookup_var_decl (ref, &var)) diff --git a/gcc/rust/backend/rust-compile-type.cc b/gcc/rust/backend/rust-compile-type.cc index 5e56e0a0b5d1..4c72d6f56855 100644 --- a/gcc/rust/backend/rust-compile-type.cc +++ b/gcc/rust/backend/rust-compile-type.cc @@ -19,6 +19,7 @@ #include "rust-compile-type.h" #include "rust-compile-expr.h" #include "rust-constexpr.h" +#include "rust-gcc.h" #include "tree.h" @@ -99,11 +100,39 @@ TyTyResolveCompile::visit (const TyTy::InferType &) void TyTyResolveCompile::visit (const TyTy::ClosureType &type) { + auto mappings = ctx->get_mappings (); + std::vector fields; + + size_t i = 0; + for (const auto &capture : type.get_captures ()) + { + // lookup the HirId + HirId ref = UNKNOWN_HIRID; + bool ok = mappings->lookup_node_to_hir (capture, &ref); + rust_assert (ok); + + // lookup the var decl type + TyTy::BaseType *lookup = nullptr; + bool found = ctx->get_tyctx ()->lookup_type (ref, &lookup); + rust_assert (found); + + // FIXME get the var pattern name + std::string mappings_name = "capture_" + std::to_string (i); + + // FIXME + // this should be based on the closure move-ability + tree decl_type = TyTyResolveCompile::compile (ctx, lookup); + tree capture_type = build_reference_type (decl_type); + fields.push_back (Backend::typed_identifier (mappings_name, capture_type, + type.get_ident ().locus)); + } + tree type_record = ctx->get_backend ()->struct_type (fields); RS_CLOSURE_FLAG (type_record) = 1; - std::string named_struct_str = type.get_ident ().path.get () + "{{closure}}"; + std::string named_struct_str + = type.get_ident ().path.get () + "::{{closure}}"; translated = ctx->get_backend ()->named_type (named_struct_str, type_record, type.get_ident ().locus); } diff --git a/gcc/rust/resolve/rust-ast-resolve-expr.cc b/gcc/rust/resolve/rust-ast-resolve-expr.cc index 60b3ebacc2c4..2063dceb2e1e 100644 --- a/gcc/rust/resolve/rust-ast-resolve-expr.cc +++ b/gcc/rust/resolve/rust-ast-resolve-expr.cc @@ -209,7 +209,7 @@ ResolveExpr::visit (AST::IfLetExpr &expr) for (auto &pattern : expr.get_patterns ()) { - PatternDeclaration::go (pattern.get ()); + PatternDeclaration::go (pattern.get (), Rib::ItemType::Var); } ResolveExpr::go (expr.get_if_block ().get (), prefix, canonical_prefix); @@ -343,7 +343,7 @@ ResolveExpr::visit (AST::LoopExpr &expr) auto label_lifetime_node_id = label.get_lifetime ().get_node_id (); resolver->get_label_scope ().insert ( CanonicalPath::new_seg (expr.get_node_id (), label_name), - label_lifetime_node_id, label.get_locus (), false, + label_lifetime_node_id, label.get_locus (), false, Rib::ItemType::Label, [&] (const CanonicalPath &, NodeId, Location locus) -> void { rust_error_at (label.get_locus (), "label redefined multiple times"); rust_error_at (locus, "was defined here"); @@ -400,7 +400,7 @@ ResolveExpr::visit (AST::WhileLoopExpr &expr) auto label_lifetime_node_id = label.get_lifetime ().get_node_id (); resolver->get_label_scope ().insert ( CanonicalPath::new_seg (label.get_node_id (), label_name), - label_lifetime_node_id, label.get_locus (), false, + label_lifetime_node_id, label.get_locus (), false, Rib::ItemType::Label, [&] (const CanonicalPath &, NodeId, Location locus) -> void { rust_error_at (label.get_locus (), "label redefined multiple times"); rust_error_at (locus, "was defined here"); @@ -429,7 +429,7 @@ ResolveExpr::visit (AST::ForLoopExpr &expr) auto label_lifetime_node_id = label.get_lifetime ().get_node_id (); resolver->get_label_scope ().insert ( CanonicalPath::new_seg (label.get_node_id (), label_name), - label_lifetime_node_id, label.get_locus (), false, + label_lifetime_node_id, label.get_locus (), false, Rib::ItemType::Label, [&] (const CanonicalPath &, NodeId, Location locus) -> void { rust_error_at (label.get_locus (), "label redefined multiple times"); rust_error_at (locus, "was defined here"); @@ -446,7 +446,7 @@ ResolveExpr::visit (AST::ForLoopExpr &expr) resolver->push_new_label_rib (resolver->get_type_scope ().peek ()); // resolve the expression - PatternDeclaration::go (expr.get_pattern ().get ()); + PatternDeclaration::go (expr.get_pattern ().get (), Rib::ItemType::Var); ResolveExpr::go (expr.get_iterator_expr ().get (), prefix, canonical_prefix); ResolveExpr::go (expr.get_loop_block ().get (), prefix, canonical_prefix); @@ -520,7 +520,7 @@ ResolveExpr::visit (AST::MatchExpr &expr) // insert any possible new patterns for (auto &pattern : arm.get_patterns ()) { - PatternDeclaration::go (pattern.get ()); + PatternDeclaration::go (pattern.get (), Rib::ItemType::Var); } // resolve the body @@ -581,9 +581,13 @@ ResolveExpr::visit (AST::ClosureExprInner &expr) resolve_closure_param (p); } + resolver->push_closure_context (expr.get_node_id ()); + ResolveExpr::go (expr.get_definition_expr ().get (), prefix, canonical_prefix); + resolver->pop_closure_context (); + resolver->get_name_scope ().pop (); resolver->get_type_scope ().pop (); resolver->get_label_scope ().pop (); @@ -606,9 +610,14 @@ ResolveExpr::visit (AST::ClosureExprInnerTyped &expr) } ResolveType::go (expr.get_return_type ().get ()); + + resolver->push_closure_context (expr.get_node_id ()); + ResolveExpr::go (expr.get_definition_block ().get (), prefix, canonical_prefix); + resolver->pop_closure_context (); + resolver->get_name_scope ().pop (); resolver->get_type_scope ().pop (); resolver->get_label_scope ().pop (); @@ -617,7 +626,7 @@ ResolveExpr::visit (AST::ClosureExprInnerTyped &expr) void ResolveExpr::resolve_closure_param (AST::ClosureParam ¶m) { - PatternDeclaration::go (param.get_pattern ().get ()); + PatternDeclaration::go (param.get_pattern ().get (), Rib::ItemType::Param); if (param.has_type_given ()) ResolveType::go (param.get_type ().get ()); diff --git a/gcc/rust/resolve/rust-ast-resolve-implitem.h b/gcc/rust/resolve/rust-ast-resolve-implitem.h index 29dbe3436f5e..f334b71b884a 100644 --- a/gcc/rust/resolve/rust-ast-resolve-implitem.h +++ b/gcc/rust/resolve/rust-ast-resolve-implitem.h @@ -56,7 +56,7 @@ class ResolveToplevelImplItem : public ResolverBase auto path = prefix.append (decl); resolver->get_type_scope ().insert ( - path, type.get_node_id (), type.get_locus (), false, + path, type.get_node_id (), type.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (type.get_locus ()); r.add_range (locus); @@ -72,6 +72,7 @@ class ResolveToplevelImplItem : public ResolverBase resolver->get_name_scope ().insert ( path, constant.get_node_id (), constant.get_locus (), false, + Rib::ItemType::Const, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (constant.get_locus ()); r.add_range (locus); @@ -87,6 +88,7 @@ class ResolveToplevelImplItem : public ResolverBase resolver->get_name_scope ().insert ( path, function.get_node_id (), function.get_locus (), false, + Rib::ItemType::Function, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (function.get_locus ()); r.add_range (locus); @@ -102,6 +104,7 @@ class ResolveToplevelImplItem : public ResolverBase resolver->get_name_scope ().insert ( path, method.get_node_id (), method.get_locus (), false, + Rib::ItemType::Function, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (method.get_locus ()); r.add_range (locus); @@ -141,6 +144,7 @@ class ResolveTopLevelTraitItems : public ResolverBase resolver->get_name_scope ().insert ( path, function.get_node_id (), function.get_locus (), false, + Rib::ItemType::Function, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (function.get_locus ()); r.add_range (locus); @@ -159,6 +163,7 @@ class ResolveTopLevelTraitItems : public ResolverBase resolver->get_name_scope ().insert ( path, method.get_node_id (), method.get_locus (), false, + Rib::ItemType::Function, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (method.get_locus ()); r.add_range (locus); @@ -177,6 +182,7 @@ class ResolveTopLevelTraitItems : public ResolverBase resolver->get_name_scope ().insert ( path, constant.get_node_id (), constant.get_locus (), false, + Rib::ItemType::Const, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (constant.get_locus ()); r.add_range (locus); @@ -194,7 +200,7 @@ class ResolveTopLevelTraitItems : public ResolverBase auto cpath = canonical_prefix.append (decl); resolver->get_type_scope ().insert ( - path, type.get_node_id (), type.get_locus (), false, + path, type.get_node_id (), type.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (type.get_locus ()); r.add_range (locus); @@ -233,6 +239,7 @@ class ResolveToplevelExternItem : public ResolverBase resolver->get_name_scope ().insert ( path, function.get_node_id (), function.get_locus (), false, + Rib::ItemType::Function, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (function.get_locus ()); r.add_range (locus); @@ -251,6 +258,7 @@ class ResolveToplevelExternItem : public ResolverBase resolver->get_name_scope ().insert ( path, item.get_node_id (), item.get_locus (), false, + Rib::ItemType::Static, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (item.get_locus ()); r.add_range (locus); diff --git a/gcc/rust/resolve/rust-ast-resolve-item.cc b/gcc/rust/resolve/rust-ast-resolve-item.cc index 7f45161fa141..8b9990f75f43 100644 --- a/gcc/rust/resolve/rust-ast-resolve-item.cc +++ b/gcc/rust/resolve/rust-ast-resolve-item.cc @@ -82,7 +82,8 @@ ResolveTraitItems::visit (AST::TraitItemFunc &func) for (auto ¶m : function.get_function_params ()) { ResolveType::go (param.get_type ().get ()); - PatternDeclaration::go (param.get_pattern ().get ()); + PatternDeclaration::go (param.get_pattern ().get (), + Rib::ItemType::Param); } if (function.has_where_clause ()) @@ -138,14 +139,15 @@ ResolveTraitItems::visit (AST::TraitItemMethod &func) AST::TypePath self_type_path (std::move (segments), self_param.get_locus ()); ResolveType::go (&self_type_path); - PatternDeclaration::go (&self_pattern); + PatternDeclaration::go (&self_pattern, Rib::ItemType::Param); // we make a new scope so the names of parameters are resolved and shadowed // correctly for (auto ¶m : function.get_function_params ()) { ResolveType::go (param.get_type ().get ()); - PatternDeclaration::go (param.get_pattern ().get ()); + PatternDeclaration::go (param.get_pattern ().get (), + Rib::ItemType::Param); } if (function.has_where_clause ()) @@ -499,10 +501,8 @@ ResolveItem::visit (AST::Function &function) for (auto ¶m : function.get_function_params ()) { ResolveType::go (param.get_type ().get ()); - PatternDeclaration::go (param.get_pattern ().get ()); - - // the mutability checker needs to verify for immutable decls the number - // of assignments are <1. This marks an implicit assignment + PatternDeclaration::go (param.get_pattern ().get (), + Rib::ItemType::Param); } // resolve the function body @@ -631,14 +631,15 @@ ResolveItem::visit (AST::Method &method) AST::TypePath self_type_path (std::move (segments), self_param.get_locus ()); ResolveType::go (&self_type_path); - PatternDeclaration::go (&self_pattern); + PatternDeclaration::go (&self_pattern, Rib::ItemType::Param); // we make a new scope so the names of parameters are resolved and shadowed // correctly for (auto ¶m : method.get_function_params ()) { ResolveType::go (param.get_type ().get ()); - PatternDeclaration::go (param.get_pattern ().get ()); + PatternDeclaration::go (param.get_pattern ().get (), + Rib::ItemType::Param); } // resolve any where clause items diff --git a/gcc/rust/resolve/rust-ast-resolve-pattern.cc b/gcc/rust/resolve/rust-ast-resolve-pattern.cc index 9386d36d25eb..05dadfd6cd7b 100644 --- a/gcc/rust/resolve/rust-ast-resolve-pattern.cc +++ b/gcc/rust/resolve/rust-ast-resolve-pattern.cc @@ -49,7 +49,7 @@ PatternDeclaration::visit (AST::TupleStructPattern &pattern) for (auto &inner_pattern : items_no_range.get_patterns ()) { - PatternDeclaration::go (inner_pattern.get ()); + PatternDeclaration::go (inner_pattern.get (), type); } } break; diff --git a/gcc/rust/resolve/rust-ast-resolve-pattern.h b/gcc/rust/resolve/rust-ast-resolve-pattern.h index fcbb23fdf088..6e86c4092507 100644 --- a/gcc/rust/resolve/rust-ast-resolve-pattern.h +++ b/gcc/rust/resolve/rust-ast-resolve-pattern.h @@ -55,9 +55,9 @@ class PatternDeclaration : public ResolverBase using Rust::Resolver::ResolverBase::visit; public: - static void go (AST::Pattern *pattern) + static void go (AST::Pattern *pattern, Rib::ItemType type) { - PatternDeclaration resolver; + PatternDeclaration resolver (type); pattern->accept_vis (resolver); }; @@ -67,14 +67,14 @@ class PatternDeclaration : public ResolverBase // as new refs to this decl will match back here so it is ok to overwrite resolver->get_name_scope ().insert ( CanonicalPath::new_seg (pattern.get_node_id (), pattern.get_ident ()), - pattern.get_node_id (), pattern.get_locus ()); + pattern.get_node_id (), pattern.get_locus (), type); } void visit (AST::WildcardPattern &pattern) override { resolver->get_name_scope ().insert ( CanonicalPath::new_seg (pattern.get_node_id (), "_"), - pattern.get_node_id (), pattern.get_locus ()); + pattern.get_node_id (), pattern.get_locus (), type); } // cases in a match expression @@ -89,7 +89,9 @@ class PatternDeclaration : public ResolverBase void visit (AST::RangePattern &pattern) override; private: - PatternDeclaration () : ResolverBase () {} + PatternDeclaration (Rib::ItemType type) : ResolverBase (), type (type) {} + + Rib::ItemType type; }; } // namespace Resolver diff --git a/gcc/rust/resolve/rust-ast-resolve-stmt.h b/gcc/rust/resolve/rust-ast-resolve-stmt.h index 6f21bc35a333..cf74ea245da8 100644 --- a/gcc/rust/resolve/rust-ast-resolve-stmt.h +++ b/gcc/rust/resolve/rust-ast-resolve-stmt.h @@ -64,6 +64,7 @@ class ResolveStmt : public ResolverBase resolver->get_name_scope ().insert ( path, constant.get_node_id (), constant.get_locus (), false, + Rib::ItemType::Const, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (constant.get_locus ()); r.add_range (locus); @@ -82,7 +83,7 @@ class ResolveStmt : public ResolverBase canonical_prefix); } - PatternDeclaration::go (stmt.get_pattern ().get ()); + PatternDeclaration::go (stmt.get_pattern ().get (), Rib::ItemType::Var); if (stmt.has_type ()) ResolveType::go (stmt.get_type ().get ()); } @@ -97,6 +98,7 @@ class ResolveStmt : public ResolverBase resolver->get_type_scope ().insert ( path, struct_decl.get_node_id (), struct_decl.get_locus (), false, + Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (struct_decl.get_locus ()); r.add_range (locus); @@ -128,6 +130,7 @@ class ResolveStmt : public ResolverBase resolver->get_type_scope ().insert ( path, enum_decl.get_node_id (), enum_decl.get_locus (), false, + Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (enum_decl.get_locus ()); r.add_range (locus); @@ -158,7 +161,7 @@ class ResolveStmt : public ResolverBase mappings->insert_canonical_path (item.get_node_id (), cpath); resolver->get_type_scope ().insert ( - path, item.get_node_id (), item.get_locus (), false, + path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (item.get_locus ()); r.add_range (locus); @@ -177,7 +180,7 @@ class ResolveStmt : public ResolverBase mappings->insert_canonical_path (item.get_node_id (), cpath); resolver->get_type_scope ().insert ( - path, item.get_node_id (), item.get_locus (), false, + path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (item.get_locus ()); r.add_range (locus); @@ -202,7 +205,7 @@ class ResolveStmt : public ResolverBase mappings->insert_canonical_path (item.get_node_id (), cpath); resolver->get_type_scope ().insert ( - path, item.get_node_id (), item.get_locus (), false, + path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (item.get_locus ()); r.add_range (locus); @@ -227,7 +230,7 @@ class ResolveStmt : public ResolverBase mappings->insert_canonical_path (item.get_node_id (), cpath); resolver->get_type_scope ().insert ( - path, item.get_node_id (), item.get_locus (), false, + path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (item.get_locus ()); r.add_range (locus); @@ -247,6 +250,7 @@ class ResolveStmt : public ResolverBase resolver->get_type_scope ().insert ( path, struct_decl.get_node_id (), struct_decl.get_locus (), false, + Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (struct_decl.get_locus ()); r.add_range (locus); @@ -283,6 +287,7 @@ class ResolveStmt : public ResolverBase resolver->get_type_scope ().insert ( path, union_decl.get_node_id (), union_decl.get_locus (), false, + Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (union_decl.get_locus ()); r.add_range (locus); @@ -317,6 +322,7 @@ class ResolveStmt : public ResolverBase resolver->get_name_scope ().insert ( path, function.get_node_id (), function.get_locus (), false, + Rib::ItemType::Function, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (function.get_locus ()); r.add_range (locus); @@ -343,7 +349,8 @@ class ResolveStmt : public ResolverBase for (auto ¶m : function.get_function_params ()) { ResolveType::go (param.get_type ().get ()); - PatternDeclaration::go (param.get_pattern ().get ()); + PatternDeclaration::go (param.get_pattern ().get (), + Rib::ItemType::Param); } // resolve the function body diff --git a/gcc/rust/resolve/rust-ast-resolve-toplevel.h b/gcc/rust/resolve/rust-ast-resolve-toplevel.h index 43ae8e476733..c07152022d93 100644 --- a/gcc/rust/resolve/rust-ast-resolve-toplevel.h +++ b/gcc/rust/resolve/rust-ast-resolve-toplevel.h @@ -57,6 +57,7 @@ class ResolveTopLevel : public ResolverBase resolver->get_name_scope ().insert ( path, module.get_node_id (), module.get_locus (), false, + Rib::ItemType::Module, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (module.get_locus ()); r.add_range (locus); @@ -85,6 +86,7 @@ class ResolveTopLevel : public ResolverBase resolver->get_type_scope ().insert ( path, alias.get_node_id (), alias.get_locus (), false, + Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (alias.get_locus ()); r.add_range (locus); @@ -105,6 +107,7 @@ class ResolveTopLevel : public ResolverBase resolver->get_type_scope ().insert ( path, struct_decl.get_node_id (), struct_decl.get_locus (), false, + Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (struct_decl.get_locus ()); r.add_range (locus); @@ -125,6 +128,7 @@ class ResolveTopLevel : public ResolverBase resolver->get_type_scope ().insert ( path, enum_decl.get_node_id (), enum_decl.get_locus (), false, + Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (enum_decl.get_locus ()); r.add_range (locus); @@ -147,7 +151,7 @@ class ResolveTopLevel : public ResolverBase auto cpath = canonical_prefix.append (decl); resolver->get_type_scope ().insert ( - path, item.get_node_id (), item.get_locus (), false, + path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (item.get_locus ()); r.add_range (locus); @@ -165,7 +169,7 @@ class ResolveTopLevel : public ResolverBase auto cpath = canonical_prefix.append (decl); resolver->get_type_scope ().insert ( - path, item.get_node_id (), item.get_locus (), false, + path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (item.get_locus ()); r.add_range (locus); @@ -183,7 +187,7 @@ class ResolveTopLevel : public ResolverBase auto cpath = canonical_prefix.append (decl); resolver->get_type_scope ().insert ( - path, item.get_node_id (), item.get_locus (), false, + path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (item.get_locus ()); r.add_range (locus); @@ -201,7 +205,7 @@ class ResolveTopLevel : public ResolverBase auto cpath = canonical_prefix.append (decl); resolver->get_type_scope ().insert ( - path, item.get_node_id (), item.get_locus (), false, + path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (item.get_locus ()); r.add_range (locus); @@ -220,6 +224,7 @@ class ResolveTopLevel : public ResolverBase resolver->get_type_scope ().insert ( path, struct_decl.get_node_id (), struct_decl.get_locus (), false, + Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (struct_decl.get_locus ()); r.add_range (locus); @@ -240,6 +245,7 @@ class ResolveTopLevel : public ResolverBase resolver->get_type_scope ().insert ( path, union_decl.get_node_id (), union_decl.get_locus (), false, + Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (union_decl.get_locus ()); r.add_range (locus); @@ -259,7 +265,7 @@ class ResolveTopLevel : public ResolverBase auto cpath = canonical_prefix.append (decl); resolver->get_name_scope ().insert ( - path, var.get_node_id (), var.get_locus (), false, + path, var.get_node_id (), var.get_locus (), false, Rib::ItemType::Static, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (var.get_locus ()); r.add_range (locus); @@ -280,6 +286,7 @@ class ResolveTopLevel : public ResolverBase resolver->get_name_scope ().insert ( path, constant.get_node_id (), constant.get_locus (), false, + Rib::ItemType::Const, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (constant.get_locus ()); r.add_range (locus); @@ -300,6 +307,7 @@ class ResolveTopLevel : public ResolverBase resolver->get_name_scope ().insert ( path, function.get_node_id (), function.get_locus (), false, + Rib::ItemType::Function, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (function.get_locus ()); r.add_range (locus); @@ -343,6 +351,7 @@ class ResolveTopLevel : public ResolverBase resolver->get_name_scope ().insert ( impl_prefix, impl_block.get_node_id (), impl_block.get_locus (), false, + Rib::ItemType::TraitImpl, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (impl_block.get_locus ()); r.add_range (locus); @@ -362,6 +371,7 @@ class ResolveTopLevel : public ResolverBase resolver->get_type_scope ().insert ( path, trait.get_node_id (), trait.get_locus (), false, + Rib::ItemType::Trait, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (trait.get_locus ()); r.add_range (locus); @@ -437,6 +447,7 @@ class ResolveTopLevel : public ResolverBase resolver->get_type_scope ().insert ( decl, resolved_crate, extern_crate.get_locus (), false, + Rib::ItemType::ExternCrate, [&] (const CanonicalPath &, NodeId, Location locus) -> void { RichLocation r (extern_crate.get_locus ()); r.add_range (locus); diff --git a/gcc/rust/resolve/rust-ast-resolve-type.h b/gcc/rust/resolve/rust-ast-resolve-type.h index 5a71268c0d44..8e1dbc68e7b6 100644 --- a/gcc/rust/resolve/rust-ast-resolve-type.h +++ b/gcc/rust/resolve/rust-ast-resolve-type.h @@ -177,7 +177,7 @@ class ResolveGenericParam : public ResolverBase auto seg = CanonicalPath::new_seg (param.get_node_id (), param.get_type_representation ()); resolver->get_type_scope ().insert ( - seg, param.get_node_id (), param.get_locus (), false, + seg, param.get_node_id (), param.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, Location locus) -> void { rust_error_at (param.get_locus (), "generic param redefined multiple times"); diff --git a/gcc/rust/resolve/rust-name-resolver.cc b/gcc/rust/resolve/rust-name-resolver.cc index ba8c1a821e36..59aed21bd876 100644 --- a/gcc/rust/resolve/rust-name-resolver.cc +++ b/gcc/rust/resolve/rust-name-resolver.cc @@ -19,40 +19,17 @@ #include "rust-name-resolver.h" #include "rust-ast-full.h" -#define MKBUILTIN_TYPE(_X, _R, _TY) \ - do \ - { \ - AST::PathIdentSegment seg (_X, Linemap::predeclared_location ()); \ - auto typePath = ::std::unique_ptr ( \ - new AST::TypePathSegment (::std::move (seg), false, \ - Linemap::predeclared_location ())); \ - ::std::vector< ::std::unique_ptr > segs; \ - segs.push_back (::std::move (typePath)); \ - auto builtin_type \ - = new AST::TypePath (::std::move (segs), \ - Linemap::predeclared_location (), false); \ - _R.push_back (builtin_type); \ - tyctx->insert_builtin (_TY->get_ref (), builtin_type->get_node_id (), \ - _TY); \ - mappings->insert_node_to_hir (builtin_type->get_node_id (), \ - _TY->get_ref ()); \ - mappings->insert_canonical_path ( \ - builtin_type->get_node_id (), \ - CanonicalPath::new_seg (builtin_type->get_node_id (), _X)); \ - } \ - while (0) - namespace Rust { namespace Resolver { Rib::Rib (CrateNum crateNum, NodeId node_id) - : crate_num (crateNum), node_id (node_id), - mappings (Analysis::Mappings::get ()) + : crate_num (crateNum), node_id (node_id) {} void Rib::insert_name ( const CanonicalPath &path, NodeId id, Location locus, bool shadow, + ItemType type, std::function dup_cb) { auto it = path_mappings.find (path); @@ -69,9 +46,10 @@ Rib::insert_name ( } path_mappings[path] = id; - reverse_path_mappings.insert (std::pair (id, path)); - decls_within_rib.insert (std::pair (id, locus)); + reverse_path_mappings.insert ({id, path}); + decls_within_rib.insert ({id, locus}); references[id] = {}; + decl_type_mappings.insert ({id, type}); } bool @@ -128,6 +106,17 @@ Rib::decl_was_declared_here (NodeId def) const return false; } +bool +Rib::lookup_decl_type (NodeId def, ItemType *type) const +{ + auto it = decl_type_mappings.find (def); + if (it == decl_type_mappings.end ()) + return false; + + *type = it->second; + return true; +} + void Rib::debug () const { @@ -151,15 +140,17 @@ Scope::Scope (CrateNum crate_num) : crate_num (crate_num) {} void Scope::insert ( const CanonicalPath &ident, NodeId id, Location locus, bool shadow, + Rib::ItemType type, std::function dup_cb) { - peek ()->insert_name (ident, id, locus, shadow, dup_cb); + peek ()->insert_name (ident, id, locus, shadow, type, dup_cb); } void -Scope::insert (const CanonicalPath &ident, NodeId id, Location locus) +Scope::insert (const CanonicalPath &ident, NodeId id, Location locus, + Rib::ItemType type) { - peek ()->insert_name (ident, id, locus, true, + peek ()->insert_name (ident, id, locus, true, type, [] (const CanonicalPath &, NodeId, Location) -> void { }); } @@ -178,6 +169,39 @@ Scope::lookup (const CanonicalPath &ident, NodeId *id) return lookup != UNKNOWN_NODEID; } +bool +Scope::lookup_decl_type (NodeId id, Rib::ItemType *type) +{ + bool found = false; + iterate ([&] (const Rib *r) -> bool { + if (r->decl_was_declared_here (id)) + { + bool ok = r->lookup_decl_type (id, type); + rust_assert (ok); + found = true; + return false; + } + return true; + }); + return found; +} + +bool +Scope::lookup_rib_for_decl (NodeId id, const Rib **rib) +{ + bool found = false; + iterate ([&] (const Rib *r) -> bool { + if (r->decl_was_declared_here (id)) + { + *rib = r; + found = true; + return false; + } + return true; + }); + return found; +} + void Scope::iterate (std::function cb) { @@ -344,6 +368,7 @@ Resolver::insert_builtin_types (Rib *r) builtin->as_string ()); r->insert_name (builtin_path, builtin->get_node_id (), Linemap::predeclared_location (), false, + Rib::ItemType::Type, [] (const CanonicalPath &, NodeId, Location) -> void {}); } } @@ -387,24 +412,24 @@ Resolver::generate_builtins () auto str = new TyTy::StrType (mappings->get_next_hir_id ()); auto never = new TyTy::NeverType (mappings->get_next_hir_id ()); - MKBUILTIN_TYPE ("u8", builtins, u8); - MKBUILTIN_TYPE ("u16", builtins, u16); - MKBUILTIN_TYPE ("u32", builtins, u32); - MKBUILTIN_TYPE ("u64", builtins, u64); - MKBUILTIN_TYPE ("u128", builtins, u128); - MKBUILTIN_TYPE ("i8", builtins, i8); - MKBUILTIN_TYPE ("i16", builtins, i16); - MKBUILTIN_TYPE ("i32", builtins, i32); - MKBUILTIN_TYPE ("i64", builtins, i64); - MKBUILTIN_TYPE ("i128", builtins, i128); - MKBUILTIN_TYPE ("bool", builtins, rbool); - MKBUILTIN_TYPE ("f32", builtins, f32); - MKBUILTIN_TYPE ("f64", builtins, f64); - MKBUILTIN_TYPE ("usize", builtins, usize); - MKBUILTIN_TYPE ("isize", builtins, isize); - MKBUILTIN_TYPE ("char", builtins, char_tyty); - MKBUILTIN_TYPE ("str", builtins, str); - MKBUILTIN_TYPE ("!", builtins, never); + setup_builtin ("u8", u8); + setup_builtin ("u16", u16); + setup_builtin ("u32", u32); + setup_builtin ("u64", u64); + setup_builtin ("u128", u128); + setup_builtin ("i8", i8); + setup_builtin ("i16", i16); + setup_builtin ("i32", i32); + setup_builtin ("i64", i64); + setup_builtin ("i128", i128); + setup_builtin ("bool", rbool); + setup_builtin ("f32", f32); + setup_builtin ("f64", f64); + setup_builtin ("usize", usize); + setup_builtin ("isize", isize); + setup_builtin ("char", char_tyty); + setup_builtin ("str", str); + setup_builtin ("!", never); // unit type () TyTy::TupleType *unit_tyty @@ -418,11 +443,32 @@ Resolver::generate_builtins () set_unit_type_node_id (unit_type->get_node_id ()); } +void +Resolver::setup_builtin (const std::string &name, TyTy::BaseType *tyty) +{ + AST::PathIdentSegment seg (name, Linemap::predeclared_location ()); + auto typePath = ::std::unique_ptr ( + new AST::TypePathSegment (::std::move (seg), false, + Linemap::predeclared_location ())); + ::std::vector< ::std::unique_ptr > segs; + segs.push_back (::std::move (typePath)); + auto builtin_type + = new AST::TypePath (::std::move (segs), Linemap::predeclared_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 ( + builtin_type->get_node_id (), + CanonicalPath::new_seg (builtin_type->get_node_id (), name)); +} + void Resolver::insert_resolved_name (NodeId refId, NodeId defId) { resolved_names[refId] = defId; get_name_scope ().append_reference_for_def (refId, defId); + insert_captured_item (defId); } bool @@ -519,5 +565,104 @@ Resolver::lookup_resolved_misc (NodeId refId, NodeId *defId) return true; } +void +Resolver::push_closure_context (NodeId closure_expr_id) +{ + auto it = closures_capture_mappings.find (closure_expr_id); + rust_assert (it == closures_capture_mappings.end ()); + + closures_capture_mappings.insert ({closure_expr_id, {}}); + closure_context.push_back (closure_expr_id); +} + +void +Resolver::pop_closure_context () +{ + rust_assert (!closure_context.empty ()); + closure_context.pop_back (); +} + +void +Resolver::insert_captured_item (NodeId id) +{ + // nothing to do unless we are in a closure context + if (closure_context.empty ()) + return; + + // check that this is a VAR_DECL? + Scope &name_scope = get_name_scope (); + Rib::ItemType type = Rib::ItemType::Unknown; + bool found = name_scope.lookup_decl_type (id, &type); + if (!found) + return; + + // RIB Function { let a, let b } id = 1; + // RIB Closure { let c } id = 2; + // RIB IfStmt { } id = 3; + // RIB ... { ... } id = 4 + // + // if we have a resolved_node_id of 'a' and the current rib is '3' we know + // this is binding exists in a rib with id < the closure rib id, other wise + // its just a normal binding and we don't care + // + // Problem the node id's dont work like this because the inner most items are + // created first so this means the root will have a larger id and a simple + // less than or greater than check wont work for more complex scoping cases + // but we can use our current rib context to figure this out by checking if + // the rib id the decl we care about exists prior to the rib for the closure + // id + + const Rib *r = nullptr; + bool ok = name_scope.lookup_rib_for_decl (id, &r); + rust_assert (ok); + NodeId decl_rib_node_id = r->get_node_id (); + + // iterate the closure context and add in the mapping for all to handle the + // case of nested closures + for (auto &closure_expr_id : closure_context) + { + if (!decl_needs_capture (decl_rib_node_id, closure_expr_id, name_scope)) + continue; + + // is this a valid binding to take + bool is_var_decl_p = type == Rib::ItemType::Var; + if (!is_var_decl_p) + { + // FIXME is this an error case? + return; + } + + // append it to the context info + auto it = closures_capture_mappings.find (closure_expr_id); + rust_assert (it != closures_capture_mappings.end ()); + + it->second.insert (id); + } +} + +bool +Resolver::decl_needs_capture (NodeId decl_rib_node_id, + NodeId closure_rib_node_id, const Scope &scope) +{ + for (const auto &rib : scope.get_context ()) + { + bool rib_is_closure = rib->get_node_id () == closure_rib_node_id; + bool rib_is_decl = rib->get_node_id () == decl_rib_node_id; + if (rib_is_closure) + return false; + else if (rib_is_decl) + return true; + } + return false; +} + +const std::set & +Resolver::get_captures (NodeId id) const +{ + auto it = closures_capture_mappings.find (id); + rust_assert (it != closures_capture_mappings.end ()); + return it->second; +} + } // namespace Resolver } // namespace Rust diff --git a/gcc/rust/resolve/rust-name-resolver.h b/gcc/rust/resolve/rust-name-resolver.h index 3716bb053835..5bfdeb748ae2 100644 --- a/gcc/rust/resolve/rust-name-resolver.h +++ b/gcc/rust/resolve/rust-name-resolver.h @@ -30,13 +30,33 @@ namespace Resolver { class Rib { public: - // Rust uses local_def_ids assigned by def_collector on the AST - // lets use NodeId instead + enum ItemType + { + Var, + Param, + Function, + Type, + Module, + Static, + Const, + Trait, + Impl, + TraitImpl, + ExternCrate, + MacroDecl, + Label, + Unknown + }; + + // FIXME + // Rust uses local_def_ids assigned by def_collector on the AST. Consider + // moving to a local-def-id Rib (CrateNum crateNum, NodeId node_id); // this takes the relative paths of items within a compilation unit for lookup void insert_name ( const CanonicalPath &path, NodeId id, Location locus, bool shadow, + ItemType type, std::function dup_cb); bool lookup_canonical_path (const NodeId &id, CanonicalPath *ident); @@ -45,6 +65,7 @@ class Rib void append_reference_for_def (NodeId def, NodeId ref); bool have_references_for_node (NodeId def) const; bool decl_was_declared_here (NodeId def) const; + bool lookup_decl_type (NodeId def, ItemType *type) const; void debug () const; std::string debug_str () const; @@ -59,7 +80,7 @@ class Rib std::map reverse_path_mappings; std::map decls_within_rib; std::map> references; - Analysis::Mappings *mappings; + std::map decl_type_mappings; }; class Scope @@ -69,10 +90,14 @@ class Scope void insert (const CanonicalPath &ident, NodeId id, Location locus, bool shadow, + Rib::ItemType type, std::function dup_cb); - void insert (const CanonicalPath &ident, NodeId id, Location locus); + void insert (const CanonicalPath &ident, NodeId id, Location locus, + Rib::ItemType type = Rib::ItemType::Unknown); bool lookup (const CanonicalPath &ident, NodeId *id); + bool lookup_decl_type (NodeId id, Rib::ItemType *type); + bool lookup_rib_for_decl (NodeId id, const Rib **rib); void iterate (std::function cb); void iterate (std::function cb) const; @@ -86,6 +111,8 @@ class Scope CrateNum get_crate_num () const { return crate_num; } + const std::vector &get_context () const { return stack; }; + private: CrateNum crate_num; std::vector stack; @@ -168,10 +195,20 @@ class Resolver return current_module_stack.at (current_module_stack.size () - 2); } + void push_closure_context (NodeId closure_expr_id); + void pop_closure_context (); + void insert_captured_item (NodeId id); + const std::set &get_captures (NodeId id) const; + +protected: + bool decl_needs_capture (NodeId decl_rib_node_id, NodeId closure_rib_node_id, + const Scope &scope); + private: Resolver (); void generate_builtins (); + void setup_builtin (const std::string &name, TyTy::BaseType *tyty); Analysis::Mappings *mappings; TypeCheckContext *tyctx; @@ -210,6 +247,10 @@ class Resolver // keep track of the current module scope ids std::vector current_module_stack; + + // captured variables mappings + std::vector closure_context; + std::map> closures_capture_mappings; }; } // namespace Resolver diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc index 8911a1d99f7d..7ea1bd900ba6 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc @@ -1492,8 +1492,10 @@ TypeCheckExpr::visit (HIR::ClosureExpr &expr) expr.get_locus ()); // generate the closure type + NodeId closure_node_id = expr.get_mappings ().get_nodeid (); + const std::set &captures = resolver->get_captures (closure_node_id); infered = new TyTy::ClosureType (ref, id, ident, closure_args, result_type, - subst_refs); + subst_refs, captures); // FIXME // all closures automatically inherit the appropriate fn trait. Lets just diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc index e56bdd17b873..86f40af0fbe5 100644 --- a/gcc/rust/typecheck/rust-tyty.cc +++ b/gcc/rust/typecheck/rust-tyty.cc @@ -1675,8 +1675,7 @@ std::string ClosureType::as_string () const { std::string params_buf = parameters->as_string (); - return "|" + params_buf + "| {" + result_type.get_tyty ()->as_string () - + "} {" + raw_bounds_as_string () + "}"; + return "|" + params_buf + "| {" + result_type.get_tyty ()->as_string () + "}"; } BaseType * @@ -1714,7 +1713,7 @@ ClosureType::clone () const { return new ClosureType (get_ref (), get_ty_ref (), ident, id, (TyTy::TupleType *) parameters->clone (), result_type, - clone_substs (), get_combined_refs (), + clone_substs (), captures, get_combined_refs (), specified_bounds); } diff --git a/gcc/rust/typecheck/rust-tyty.h b/gcc/rust/typecheck/rust-tyty.h index 9a9f0aa915ee..8b39e5138fb7 100644 --- a/gcc/rust/typecheck/rust-tyty.h +++ b/gcc/rust/typecheck/rust-tyty.h @@ -1628,13 +1628,15 @@ class ClosureType : public BaseType, public SubstitutionRef ClosureType (HirId ref, DefId id, RustIdent ident, TyTy::TupleType *parameters, TyVar result_type, std::vector subst_refs, + std::set captures, std::set refs = std::set (), std::vector specified_bounds = std::vector ()) : BaseType (ref, ref, TypeKind::CLOSURE, ident, refs), SubstitutionRef (std::move (subst_refs), SubstitutionArgumentMappings::error ()), - parameters (parameters), result_type (std::move (result_type)), id (id) + parameters (parameters), result_type (std::move (result_type)), id (id), + captures (captures) { LocalDefId local_def_id = id.localDefId; rust_assert (local_def_id != UNKNOWN_LOCAL_DEFID); @@ -1644,13 +1646,15 @@ class ClosureType : public BaseType, public SubstitutionRef ClosureType (HirId ref, HirId ty_ref, RustIdent ident, DefId id, TyTy::TupleType *parameters, TyVar result_type, std::vector subst_refs, + std::set captures, std::set refs = std::set (), std::vector specified_bounds = std::vector ()) : BaseType (ref, ty_ref, TypeKind::CLOSURE, ident, refs), SubstitutionRef (std::move (subst_refs), SubstitutionArgumentMappings::error ()), - parameters (parameters), result_type (std::move (result_type)), id (id) + parameters (parameters), result_type (std::move (result_type)), id (id), + captures (captures) { LocalDefId local_def_id = id.localDefId; rust_assert (local_def_id != UNKNOWN_LOCAL_DEFID); @@ -1699,10 +1703,13 @@ class ClosureType : public BaseType, public SubstitutionRef void setup_fn_once_output () const; + const std::set &get_captures () const { return captures; } + private: TyTy::TupleType *parameters; TyVar result_type; DefId id; + std::set captures; }; class ArrayType : public BaseType diff --git a/gcc/testsuite/rust/execute/torture/closure3.rs b/gcc/testsuite/rust/execute/torture/closure3.rs new file mode 100644 index 000000000000..62cf3a082cff --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/closure3.rs @@ -0,0 +1,33 @@ +// { dg-output "3\n" } +extern "C" { + fn printf(s: *const i8, ...); +} + +#[lang = "fn_once"] +pub trait FnOnce { + #[lang = "fn_once_output"] + type Output; + + extern "rust-call" fn call_once(self, args: Args) -> Self::Output; +} + +fn f i32>(g: F) { + let call = g(1); + unsafe { + let a = "%i\n\0"; + let b = a as *const str; + let c = b as *const i8; + + printf(c, call); + } +} + +pub fn main() -> i32 { + let capture = 2; + let a = |i: i32| { + let b = i + capture; + b + }; + f(a); + 0 +}