Add support for nested functions

We missed that stmts in rust can be items like functions. This adds support
for resolution and compilation of nested functions. Rust allows nested
functions which are distinct to closures. Nested functions are not allowed
to encapsulate the enclosing scope so they can be extracted as normal functions.

Author: philberty

gcc/rust/backend/rust-compile-base.h

@@ -210,6 +210,9 @@ class HIRCompileBase : public HIR::HIRVisitor
   void compile_function_body (Bfunction *fndecl,
 			      std::unique_ptr<HIR::BlockExpr> &function_body,
 			      bool has_return_type);
+
+  bool compile_locals_for_block (Resolver::Rib &rib, Bfunction *fndecl,
+				 std::vector<Bvariable *> &locals);
 };
 
 } // namespace Compile

gcc/rust/backend/rust-compile-implitem.h

@@ -183,26 +183,10 @@ class CompileInherentImplItem : public HIRCompileBase
       }
 
     std::vector<Bvariable *> locals;
-    rib->iterate_decls ([&] (NodeId n, Location) mutable -> bool {
-      Resolver::Definition d;
-      bool ok = ctx->get_resolver ()->lookup_definition (n, &d);
-      rust_assert (ok);
-
-      HIR::Stmt *decl = nullptr;
-      ok = ctx->get_mappings ()->resolve_nodeid_to_stmt (d.parent, &decl);
-      rust_assert (ok);
-
-      Bvariable *compiled = CompileVarDecl::compile (fndecl, decl, ctx);
-      locals.push_back (compiled);
-
-      return true;
-    });
-
-    bool toplevel_item
-      = function.get_mappings ().get_local_defid () != UNKNOWN_LOCAL_DEFID;
-    Bblock *enclosing_scope
-      = toplevel_item ? NULL : ctx->peek_enclosing_scope ();
+    bool ok = compile_locals_for_block (*rib, fndecl, locals);
+    rust_assert (ok);
 
+    Bblock *enclosing_scope = NULL;
     HIR::BlockExpr *function_body = function.get_definition ().get ();
     Location start_location = function_body->get_locus ();
     Location end_location = function_body->get_closing_locus ();
@@ -409,26 +393,10 @@ class CompileInherentImplItem : public HIRCompileBase
       }
 
     std::vector<Bvariable *> locals;
-    rib->iterate_decls ([&] (NodeId n, Location) mutable -> bool {
-      Resolver::Definition d;
-      bool ok = ctx->get_resolver ()->lookup_definition (n, &d);
-      rust_assert (ok);
-
-      HIR::Stmt *decl = nullptr;
-      ok = ctx->get_mappings ()->resolve_nodeid_to_stmt (d.parent, &decl);
-      rust_assert (ok);
-
-      Bvariable *compiled = CompileVarDecl::compile (fndecl, decl, ctx);
-      locals.push_back (compiled);
-
-      return true;
-    });
-
-    bool toplevel_item
-      = method.get_mappings ().get_local_defid () != UNKNOWN_LOCAL_DEFID;
-    Bblock *enclosing_scope
-      = toplevel_item ? NULL : ctx->peek_enclosing_scope ();
+    bool ok = compile_locals_for_block (*rib, fndecl, locals);
+    rust_assert (ok);
 
+    Bblock *enclosing_scope = NULL;
     HIR::BlockExpr *function_body = method.get_function_body ().get ();
     Location start_location = function_body->get_locus ();
     Location end_location = function_body->get_closing_locus ();

gcc/rust/backend/rust-compile-item.h

@@ -213,26 +213,10 @@ class CompileItem : public HIRCompileBase
       }
 
     std::vector<Bvariable *> locals;
-    rib->iterate_decls ([&] (NodeId n, Location) mutable -> bool {
-      Resolver::Definition d;
-      bool ok = ctx->get_resolver ()->lookup_definition (n, &d);
-      rust_assert (ok);
-
-      HIR::Stmt *decl = nullptr;
-      ok = ctx->get_mappings ()->resolve_nodeid_to_stmt (d.parent, &decl);
-      rust_assert (ok);
-
-      Bvariable *compiled = CompileVarDecl::compile (fndecl, decl, ctx);
-      locals.push_back (compiled);
-
-      return true;
-    });
-
-    bool toplevel_item
-      = function.get_mappings ().get_local_defid () != UNKNOWN_LOCAL_DEFID;
-    Bblock *enclosing_scope
-      = toplevel_item ? NULL : ctx->peek_enclosing_scope ();
+    bool ok = compile_locals_for_block (*rib, fndecl, locals);
+    rust_assert (ok);
 
+    Bblock *enclosing_scope = NULL;
     HIR::BlockExpr *function_body = function.get_definition ().get ();
     Location start_location = function_body->get_locus ();
     Location end_location = function_body->get_closing_locus ();

gcc/rust/backend/rust-compile.cc

@@ -212,20 +212,8 @@ CompileBlock::visit (HIR::BlockExpr &expr)
     }
 
   std::vector<Bvariable *> locals;
-  rib->iterate_decls ([&] (NodeId n, Location) mutable -> bool {
-    Resolver::Definition d;
-    bool ok = ctx->get_resolver ()->lookup_definition (n, &d);
-    rust_assert (ok);
-
-    HIR::Stmt *decl = nullptr;
-    ok = ctx->get_mappings ()->resolve_nodeid_to_stmt (d.parent, &decl);
-    rust_assert (ok);
-
-    Bvariable *compiled = CompileVarDecl::compile (fndecl, decl, ctx);
-    locals.push_back (compiled);
-
-    return true;
-  });
+  bool ok = compile_locals_for_block (*rib, fndecl, locals);
+  rust_assert (ok);
 
   Bblock *enclosing_scope = ctx->peek_enclosing_scope ();
   Bblock *new_block
@@ -415,6 +403,41 @@ HIRCompileBase::compile_function_body (
     }
 }
 
+bool
+HIRCompileBase::compile_locals_for_block (Resolver::Rib &rib, Bfunction *fndecl,
+					  std::vector<Bvariable *> &locals)
+{
+  rib.iterate_decls ([&] (NodeId n, Location) mutable -> bool {
+    Resolver::Definition d;
+    bool ok = ctx->get_resolver ()->lookup_definition (n, &d);
+    rust_assert (ok);
+
+    HIR::Stmt *decl = nullptr;
+    ok = ctx->get_mappings ()->resolve_nodeid_to_stmt (d.parent, &decl);
+    rust_assert (ok);
+
+    // if its a function we extract this out side of this fn context
+    // and it is not a local to this function
+    bool is_item = ctx->get_mappings ()->lookup_hir_item (
+		     decl->get_mappings ().get_crate_num (),
+		     decl->get_mappings ().get_hirid ())
+		   != nullptr;
+    if (is_item)
+      {
+	HIR::Item *item = static_cast<HIR::Item *> (decl);
+	CompileItem::compile (item, ctx, true);
+	return true;
+      }
+
+    Bvariable *compiled = CompileVarDecl::compile (fndecl, decl, ctx);
+    locals.push_back (compiled);
+
+    return true;
+  });
+
+  return true;
+}
+
 // Mr Mangle time
 
 static const std::string kMangledSymbolPrefix = "_ZN";

gcc/rust/hir/rust-ast-lower-stmt.h

@@ -230,6 +230,91 @@ class ASTLoweringStmt : public ASTLoweringBase
 			       empty.get_locus ());
   }
 
+  void visit (AST::Function &function) override
+  {
+    // ignore for now and leave empty
+    std::vector<std::unique_ptr<HIR::WhereClauseItem> > where_clause_items;
+    HIR::WhereClause where_clause (std::move (where_clause_items));
+    HIR::FunctionQualifiers qualifiers (
+      HIR::FunctionQualifiers::AsyncConstStatus::NONE, false);
+    HIR::Visibility vis = HIR::Visibility::create_public ();
+
+    // need
+    std::vector<std::unique_ptr<HIR::GenericParam> > generic_params;
+    if (function.has_generics ())
+      {
+	generic_params = lower_generic_params (function.get_generic_params ());
+      }
+
+    Identifier function_name = function.get_function_name ();
+    Location locus = function.get_locus ();
+
+    std::unique_ptr<HIR::Type> return_type
+      = function.has_return_type () ? std::unique_ptr<HIR::Type> (
+	  ASTLoweringType::translate (function.get_return_type ().get ()))
+				    : nullptr;
+
+    std::vector<HIR::FunctionParam> function_params;
+    for (auto &param : function.get_function_params ())
+      {
+	auto translated_pattern = std::unique_ptr<HIR::Pattern> (
+	  ASTLoweringPattern::translate (param.get_pattern ().get ()));
+	auto translated_type = std::unique_ptr<HIR::Type> (
+	  ASTLoweringType::translate (param.get_type ().get ()));
+
+	auto crate_num = mappings->get_current_crate ();
+	Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
+				       mappings->get_next_hir_id (crate_num),
+				       UNKNOWN_LOCAL_DEFID);
+
+	auto hir_param
+	  = HIR::FunctionParam (mapping, std::move (translated_pattern),
+				std::move (translated_type),
+				param.get_locus ());
+	function_params.push_back (hir_param);
+      }
+
+    bool terminated = false;
+    std::unique_ptr<HIR::BlockExpr> function_body
+      = std::unique_ptr<HIR::BlockExpr> (
+	ASTLoweringBlock::translate (function.get_definition ().get (),
+				     &terminated));
+
+    auto crate_num = mappings->get_current_crate ();
+    Analysis::NodeMapping mapping (crate_num, function.get_node_id (),
+				   mappings->get_next_hir_id (crate_num),
+				   UNKNOWN_LOCAL_DEFID);
+
+    mappings->insert_location (crate_num,
+			       function_body->get_mappings ().get_hirid (),
+			       function.get_locus ());
+
+    auto fn
+      = new HIR::Function (mapping, std::move (function_name),
+			   std::move (qualifiers), std::move (generic_params),
+			   std::move (function_params), std::move (return_type),
+			   std::move (where_clause), std::move (function_body),
+			   std::move (vis), function.get_outer_attrs (), locus);
+
+    mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (),
+			       fn);
+    mappings->insert_hir_stmt (mapping.get_crate_num (), mapping.get_hirid (),
+			       fn);
+    mappings->insert_location (crate_num, mapping.get_hirid (),
+			       function.get_locus ());
+
+    // add the mappings for the function params at the end
+    for (auto &param : fn->get_function_params ())
+      {
+	mappings->insert_hir_param (mapping.get_crate_num (),
+				    param.get_mappings ().get_hirid (), &param);
+	mappings->insert_location (crate_num, mapping.get_hirid (),
+				   param.get_locus ());
+      }
+
+    translated = fn;
+  }
+
 private:
   ASTLoweringStmt () : translated (nullptr), terminated (false) {}
 

gcc/rust/resolve/rust-ast-resolve-stmt.h

@@ -129,6 +129,61 @@ class ResolveStmt : public ResolverBase
     resolver->get_type_scope ().pop ();
   }
 
+  void visit (AST::Function &function) override
+  {
+    auto path = ResolveFunctionItemToCanonicalPath::resolve (function);
+    resolver->get_name_scope ().insert (
+      path, function.get_node_id (), function.get_locus (), false,
+      [&] (const CanonicalPath &, NodeId, Location locus) -> void {
+	RichLocation r (function.get_locus ());
+	r.add_range (locus);
+	rust_error_at (r, "redefined multiple times");
+      });
+    resolver->insert_new_definition (function.get_node_id (),
+				     Definition{function.get_node_id (),
+						function.get_node_id ()});
+
+    NodeId scope_node_id = function.get_node_id ();
+    resolver->get_name_scope ().push (scope_node_id);
+    resolver->get_type_scope ().push (scope_node_id);
+    resolver->get_label_scope ().push (scope_node_id);
+    resolver->push_new_name_rib (resolver->get_name_scope ().peek ());
+    resolver->push_new_type_rib (resolver->get_type_scope ().peek ());
+    resolver->push_new_label_rib (resolver->get_type_scope ().peek ());
+
+    if (function.has_generics ())
+      {
+	for (auto &generic : function.get_generic_params ())
+	  ResolveGenericParam::go (generic.get (), function.get_node_id ());
+      }
+
+    if (function.has_return_type ())
+      ResolveType::go (function.get_return_type ().get (),
+		       function.get_node_id ());
+
+    // we make a new scope so the names of parameters are resolved and shadowed
+    // correctly
+    for (auto &param : function.get_function_params ())
+      {
+	ResolveType::go (param.get_type ().get (), param.get_node_id ());
+	PatternDeclaration::go (param.get_pattern ().get (),
+				param.get_node_id ());
+
+	// the mutability checker needs to verify for immutable decls the number
+	// of assignments are <1. This marks an implicit assignment
+	resolver->mark_assignment_to_decl (param.get_pattern ()->get_node_id (),
+					   param.get_node_id ());
+      }
+
+    // resolve the function body
+    ResolveExpr::go (function.get_definition ().get (),
+		     function.get_node_id ());
+
+    resolver->get_name_scope ().pop ();
+    resolver->get_type_scope ().pop ();
+    resolver->get_label_scope ().pop ();
+  }
+
 private:
   ResolveStmt (NodeId parent) : ResolverBase (parent) {}
 };

gcc/rust/resolve/rust-ast-resolve.cc

@@ -499,9 +499,8 @@ ResolvePath::resolve_path (AST::PathInExpression *expr)
   else
     {
       rust_error_at (expr->get_locus (),
-		     "unknown root segment in path %s lookup %s",
-		     expr->as_string ().c_str (),
-		     root_ident_seg.as_string ().c_str ());
+		     "Cannot find path %<%s%> in this scope",
+		     expr->as_string ().c_str ());
       return;
     }