Add name-resolution and HIR lowering for extern blocks

This is the initial patch to do the ground work to support extern blocks.
Type resolution and Generic output still needs to be done to actually
support extern blocks.

Addresses #421

Author: philberty

gcc/rust/ast/rust-ast.h

@@ -1364,6 +1364,8 @@ class TraitImplItem
 class ExternalItem
 {
 public:
+  ExternalItem () : node_id (Analysis::Mappings::get ()->get_next_node_id ()) {}
+
   virtual ~ExternalItem () {}
 
   // Unique pointer custom clone function
@@ -1379,9 +1381,13 @@ class ExternalItem
   virtual void mark_for_strip () = 0;
   virtual bool is_marked_for_strip () const = 0;
 
+  NodeId get_node_id () const { return node_id; }
+
 protected:
   // Clone function implementation as pure virtual method
   virtual ExternalItem *clone_external_item_impl () const = 0;
+
+  NodeId node_id;
 };
 
 /* Data structure to store the data used in macro invocations and macro
@@ -1513,36 +1519,36 @@ class MacroInvocationSemi : public MacroItem,
     return new MacroInvocationSemi (*this);
   }
 
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
+  /* Use covariance to implement clone function as returning this object
+   * rather than base */
   MacroInvocationSemi *clone_item_impl () const final override
   {
     return clone_macro_invocation_semi_impl ();
   }
 
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
+  /* Use covariance to implement clone function as returning this object
+   * rather than base */
   MacroInvocationSemi *clone_inherent_impl_item_impl () const final override
   {
     return clone_macro_invocation_semi_impl ();
   }
 
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
+  /* Use covariance to implement clone function as returning this object
+   * rather than base */
   MacroInvocationSemi *clone_trait_impl_item_impl () const final override
   {
     return clone_macro_invocation_semi_impl ();
   }
 
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
+  /* Use covariance to implement clone function as returning this object
+   * rather than base */
   MacroInvocationSemi *clone_trait_item_impl () const final override
   {
     return clone_macro_invocation_semi_impl ();
   }
 
-  /* Use covariance to implement clone function as returning this object rather
-   * than base */
+  /* Use covariance to implement clone function as returning this object
+   * rather than base */
   MacroInvocationSemi *clone_external_item_impl () const final override
   {
     return clone_macro_invocation_semi_impl ();

gcc/rust/ast/rust-item.h

@@ -3910,16 +3910,17 @@ class ExternalStaticItem : public ExternalItem
   ExternalStaticItem (Identifier item_name, std::unique_ptr<Type> item_type,
 		      bool is_mut, Visibility vis,
 		      std::vector<Attribute> outer_attrs, Location locus)
-    : outer_attrs (std::move (outer_attrs)), visibility (std::move (vis)),
-      item_name (std::move (item_name)), locus (locus), has_mut (is_mut),
-      item_type (std::move (item_type))
+    : ExternalItem (), outer_attrs (std::move (outer_attrs)),
+      visibility (std::move (vis)), item_name (std::move (item_name)),
+      locus (locus), has_mut (is_mut), item_type (std::move (item_type))
   {}
 
   // Copy constructor
   ExternalStaticItem (ExternalStaticItem const &other)
     : outer_attrs (other.outer_attrs), visibility (other.visibility),
       item_name (other.item_name), locus (other.locus), has_mut (other.has_mut)
   {
+    node_id = other.node_id;
     // guard to prevent null dereference (only required if error state)
     if (other.item_type != nullptr)
       item_type = other.item_type->clone_type ();
@@ -3928,6 +3929,7 @@ class ExternalStaticItem : public ExternalItem
   // Overloaded assignment operator to clone
   ExternalStaticItem &operator= (ExternalStaticItem const &other)
   {
+    node_id = other.node_id;
     outer_attrs = other.outer_attrs;
     visibility = other.visibility;
     item_name = other.item_name;
@@ -3974,6 +3976,10 @@ class ExternalStaticItem : public ExternalItem
     return item_type;
   }
 
+  Identifier get_identifier () const { return item_name; }
+
+  bool is_mut () const { return has_mut; }
+
 protected:
   /* Use covariance to implement clone function as returning this object
    * rather than base */
@@ -3997,6 +4003,8 @@ struct NamedFunctionParam
   // seemingly new since writing this node
   std::vector<Attribute> outer_attrs;
 
+  NodeId node_id;
+
 public:
   /* Returns whether the named function parameter has a name (i.e. name is not
    * '_'). */
@@ -4011,6 +4019,8 @@ struct NamedFunctionParam
     return param_type == nullptr;
   }
 
+  std::string get_name () const { return name; }
+
   // Creates an error state named function parameter.
   static NamedFunctionParam create_error ()
   {
@@ -4020,13 +4030,15 @@ struct NamedFunctionParam
   NamedFunctionParam (std::string name, std::unique_ptr<Type> param_type,
 		      std::vector<Attribute> outer_attrs)
     : name (std::move (name)), param_type (std::move (param_type)),
-      outer_attrs (std::move (outer_attrs))
+      outer_attrs (std::move (outer_attrs)),
+      node_id (Analysis::Mappings::get ()->get_next_node_id ())
   {}
 
   // Copy constructor
   NamedFunctionParam (NamedFunctionParam const &other)
     : name (other.name), outer_attrs (other.outer_attrs)
   {
+    node_id = other.node_id;
     // guard to prevent null dereference (only required if error state)
     if (other.param_type != nullptr)
       param_type = other.param_type->clone_type ();
@@ -4037,6 +4049,7 @@ struct NamedFunctionParam
   // Overloaded assignment operator to clone
   NamedFunctionParam &operator= (NamedFunctionParam const &other)
   {
+    node_id = other.node_id;
     name = other.name;
     // has_name = other.has_name;
     outer_attrs = other.outer_attrs;
@@ -4070,6 +4083,8 @@ struct NamedFunctionParam
     rust_assert (param_type != nullptr);
     return param_type;
   }
+
+  NodeId get_node_id () const { return node_id; }
 };
 
 // A function item used in an extern block
@@ -4133,9 +4148,9 @@ class ExternalFunctionItem : public ExternalItem
     std::vector<NamedFunctionParam> function_params, bool has_variadics,
     std::vector<Attribute> variadic_outer_attrs, Visibility vis,
     std::vector<Attribute> outer_attrs, Location locus)
-    : outer_attrs (std::move (outer_attrs)), visibility (std::move (vis)),
-      item_name (std::move (item_name)), locus (locus),
-      generic_params (std::move (generic_params)),
+    : ExternalItem (), outer_attrs (std::move (outer_attrs)),
+      visibility (std::move (vis)), item_name (std::move (item_name)),
+      locus (locus), generic_params (std::move (generic_params)),
       return_type (std::move (return_type)),
       where_clause (std::move (where_clause)),
       function_params (std::move (function_params)),
@@ -4155,6 +4170,7 @@ class ExternalFunctionItem : public ExternalItem
       has_variadics (other.has_variadics),
       variadic_outer_attrs (other.variadic_outer_attrs)
   {
+    node_id = other.node_id;
     // guard to prevent null pointer dereference
     if (other.return_type != nullptr)
       return_type = other.return_type->clone_type ();
@@ -4175,6 +4191,7 @@ class ExternalFunctionItem : public ExternalItem
     function_params = other.function_params;
     has_variadics = other.has_variadics;
     variadic_outer_attrs = other.variadic_outer_attrs;
+    node_id = other.node_id;
 
     // guard to prevent null pointer dereference
     if (other.return_type != nullptr)
@@ -4237,6 +4254,8 @@ class ExternalFunctionItem : public ExternalItem
     return return_type;
   }
 
+  Identifier get_identifier () const { return item_name; };
+
 protected:
   /* Use covariance to implement clone function as returning this object
    * rather than base */
@@ -4275,6 +4294,8 @@ class ExternBlock : public VisItem
   // Returns whether extern block has ABI name.
   bool has_abi () const { return !abi.empty (); }
 
+  std::string get_abi () const { return abi; }
+
   ExternBlock (std::string abi,
 	       std::vector<std::unique_ptr<ExternalItem> > extern_items,
 	       Visibility vis, std::vector<Attribute> inner_attrs,

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

@@ -0,0 +1,121 @@
+// Copyright (C) 2020 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_AST_LOWER_EXTERN_ITEM
+#define RUST_AST_LOWER_EXTERN_ITEM
+
+#include "rust-ast-lower-base.h"
+#include "rust-ast-lower-type.h"
+
+namespace Rust {
+namespace HIR {
+
+class ASTLoweringExternItem : public ASTLoweringBase
+{
+  using Rust::HIR::ASTLoweringBase::visit;
+
+public:
+  static HIR::ExternalItem *translate (AST::ExternalItem *item)
+  {
+    ASTLoweringExternItem resolver;
+    item->accept_vis (resolver);
+    return resolver.translated;
+  }
+
+  void visit (AST::ExternalStaticItem &item) override
+  {
+    HIR::Visibility vis = HIR::Visibility::create_public ();
+    HIR::Type *static_type
+      = ASTLoweringType::translate (item.get_type ().get ());
+
+    auto crate_num = mappings->get_current_crate ();
+    Analysis::NodeMapping mapping (crate_num, item.get_node_id (),
+				   mappings->get_next_hir_id (crate_num),
+				   mappings->get_next_localdef_id (crate_num));
+    mappings->insert_location (crate_num, mapping.get_hirid (),
+			       item.get_locus ());
+
+    HIR::ExternalStaticItem *static_item
+      = new HIR::ExternalStaticItem (mapping, item.get_identifier (),
+				     std::unique_ptr<HIR::Type> (static_type),
+				     item.is_mut (), std::move (vis),
+				     item.get_outer_attrs (),
+				     item.get_locus ());
+
+    translated = static_item;
+  }
+
+  void visit (AST::ExternalFunctionItem &function) override
+  {
+    std::vector<std::unique_ptr<HIR::WhereClauseItem> > where_clause_items;
+    HIR::WhereClause where_clause (std::move (where_clause_items));
+    HIR::Visibility vis = HIR::Visibility::create_public ();
+
+    std::vector<std::unique_ptr<HIR::GenericParam> > generic_params;
+    if (function.has_generics ())
+      generic_params = lower_generic_params (function.get_generic_params ());
+
+    HIR::Type *return_type
+      = function.has_return_type ()
+	  ? ASTLoweringType::translate (function.get_return_type ().get ())
+	  : nullptr;
+
+    std::vector<HIR::NamedFunctionParam> function_params;
+    for (auto &param : function.get_function_params ())
+      {
+	HIR::Type *param_type
+	  = ASTLoweringType::translate (param.get_type ().get ());
+	Identifier param_name = param.get_name ();
+
+	auto crate_num = mappings->get_current_crate ();
+	Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
+				       mappings->get_next_hir_id (crate_num),
+				       mappings->get_next_localdef_id (
+					 crate_num));
+
+	function_params.push_back (
+	  HIR::NamedFunctionParam (mapping, param_name,
+				   std::unique_ptr<HIR::Type> (param_type)));
+      }
+
+    auto crate_num = mappings->get_current_crate ();
+    Analysis::NodeMapping mapping (crate_num, function.get_node_id (),
+				   mappings->get_next_hir_id (crate_num),
+				   mappings->get_next_localdef_id (crate_num));
+    mappings->insert_location (crate_num, mapping.get_hirid (),
+			       function.get_locus ());
+
+    HIR::ExternalFunctionItem *function_item = new HIR::ExternalFunctionItem (
+      mapping, function.get_identifier (), std::move (generic_params),
+      std::unique_ptr<HIR::Type> (return_type), std::move (where_clause),
+      std::move (function_params), function.is_variadic (), std::move (vis),
+      function.get_outer_attrs (), function.get_locus ());
+
+    translated = function_item;
+  }
+
+private:
+  ASTLoweringExternItem () : translated (nullptr) {}
+
+  HIR::ExternalItem *translated;
+};
+
+} // namespace HIR
+} // namespace Rust
+
+#endif // RUST_AST_LOWER_ITEM

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

@@ -28,6 +28,7 @@
 #include "rust-ast-lower-expr.h"
 #include "rust-ast-lower-pattern.h"
 #include "rust-ast-lower-block.h"
+#include "rust-ast-lower-extern.h"
 
 namespace Rust {
 namespace HIR {
@@ -553,6 +554,37 @@ class ASTLoweringItem : public ASTLoweringBase
       }
   }
 
+  void visit (AST::ExternBlock &extern_block) override
+  {
+    HIR::Visibility vis = HIR::Visibility::create_public ();
+
+    std::vector<std::unique_ptr<HIR::ExternalItem> > extern_items;
+    for (auto &item : extern_block.get_extern_items ())
+      {
+	HIR::ExternalItem *lowered
+	  = ASTLoweringExternItem::translate (item.get ());
+	extern_items.push_back (std::unique_ptr<HIR::ExternalItem> (lowered));
+      }
+
+    auto crate_num = mappings->get_current_crate ();
+    Analysis::NodeMapping mapping (crate_num, extern_block.get_node_id (),
+				   mappings->get_next_hir_id (crate_num),
+				   mappings->get_next_localdef_id (crate_num));
+
+    mappings->insert_defid_mapping (mapping.get_defid (), translated);
+    mappings->insert_location (crate_num, mapping.get_hirid (),
+			       extern_block.get_locus ());
+
+    HIR::ExternBlock *hir_extern_block
+      = new HIR::ExternBlock (mapping, extern_block.get_abi (),
+			      std::move (extern_items), std::move (vis),
+			      extern_block.get_inner_attrs (),
+			      extern_block.get_outer_attrs (),
+			      extern_block.get_locus ());
+
+    translated = hir_extern_block;
+  }
+
 private:
   ASTLoweringItem () : translated (nullptr) {}
 

gcc/rust/hir/tree/rust-hir-full-test.cc

@@ -3399,8 +3399,9 @@ ExternalFunctionItem::as_string () const
 	}
     }
 
-  // add type on new line
-  str += "\n (return) Type: " + return_type->as_string ();
+  // add type on new line)
+  str += "\n (return) Type: "
+	 + (has_return_type () ? return_type->as_string () : "()");
 
   // where clause
   str += "\n Where clause: ";