[thirdparty/gcc.git] / gcc / rust / hir / rust-ast-lower-stmt.h

// 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_AST_LOWER_STMT
#define RUST_AST_LOWER_STMT

#include "rust-diagnostics.h"

#include "rust-ast-lower-base.h"
#include "rust-ast-lower-enumitem.h"
#include "rust-ast-lower-type.h"
#include "rust-ast-lower-block.h"
#include "rust-ast-lower-expr.h"
#include "rust-ast-lower-pattern.h"

namespace Rust {
namespace HIR {

class ASTLoweringStmt : public ASTLoweringBase
{
  using Rust::HIR::ASTLoweringBase::visit;

public:
  static HIR::Stmt *translate (AST::Stmt *stmt, bool *terminated)
  {
    ASTLoweringStmt resolver;
    stmt->accept_vis (resolver);

    rust_assert (resolver.translated != nullptr);
    *terminated = resolver.terminated;
    resolver.mappings->insert_location (
      resolver.translated->get_mappings ().get_hirid (),
      resolver.translated->get_locus ());
    resolver.mappings->insert_hir_stmt (resolver.translated);
    if (resolver.translated->is_item ())
      {
	HIR::Item *i = static_cast<HIR::Item *> (resolver.translated);

	auto defid = resolver.translated->get_mappings ().get_defid ();

	resolver.handle_outer_attributes (*i);
	resolver.mappings->insert_hir_item (i);
	resolver.mappings->insert_defid_mapping (defid, i);
      }

    return resolver.translated;
  }

  void visit (AST::ExprStmtWithBlock &stmt) override
  {
    HIR::ExprWithBlock *expr
      = ASTLoweringExprWithBlock::translate (stmt.get_expr ().get (),
					     &terminated);

    auto crate_num = mappings->get_current_crate ();
    Analysis::NodeMapping mapping (crate_num, stmt.get_node_id (),
				   mappings->get_next_hir_id (crate_num),
				   UNKNOWN_LOCAL_DEFID);
    translated
      = new HIR::ExprStmtWithBlock (mapping,
				    std::unique_ptr<HIR::ExprWithBlock> (expr),
				    stmt.get_locus (),
				    !stmt.is_semicolon_followed ());
  }

  void visit (AST::ExprStmtWithoutBlock &stmt) override
  {
    HIR::Expr *expr
      = ASTLoweringExpr::translate (stmt.get_expr ().get (), &terminated);

    auto crate_num = mappings->get_current_crate ();
    Analysis::NodeMapping mapping (crate_num, stmt.get_node_id (),
				   mappings->get_next_hir_id (crate_num),
				   UNKNOWN_LOCAL_DEFID);
    translated
      = new HIR::ExprStmtWithoutBlock (mapping,
				       std::unique_ptr<HIR::Expr> (expr),
				       stmt.get_locus ());
  }

  void visit (AST::ConstantItem &constant) override
  {
    HIR::Visibility vis = translate_visibility (constant.get_visibility ());

    HIR::Type *type = ASTLoweringType::translate (constant.get_type ().get ());
    HIR::Expr *expr = ASTLoweringExpr::translate (constant.get_expr ().get ());

    auto crate_num = mappings->get_current_crate ();
    Analysis::NodeMapping mapping (crate_num, constant.get_node_id (),
				   mappings->get_next_hir_id (crate_num),
				   mappings->get_next_localdef_id (crate_num));

    translated = new HIR::ConstantItem (mapping, constant.get_identifier (),
					vis, std::unique_ptr<HIR::Type> (type),
					std::unique_ptr<HIR::Expr> (expr),
					constant.get_outer_attrs (),
					constant.get_locus ());
  }

  void visit (AST::LetStmt &stmt) override
  {
    HIR::Pattern *variables
      = ASTLoweringPattern::translate (stmt.get_pattern ().get ());
    HIR::Type *type = stmt.has_type ()
			? ASTLoweringType::translate (stmt.get_type ().get ())
			: nullptr;
    HIR::Expr *init_expression
      = stmt.has_init_expr ()
	  ? ASTLoweringExpr::translate (stmt.get_init_expr ().get ())
	  : nullptr;

    auto crate_num = mappings->get_current_crate ();
    Analysis::NodeMapping mapping (crate_num, stmt.get_node_id (),
				   mappings->get_next_hir_id (crate_num),
				   UNKNOWN_LOCAL_DEFID);
    translated
      = new HIR::LetStmt (mapping, std::unique_ptr<HIR::Pattern> (variables),
			  std::unique_ptr<HIR::Expr> (init_expression),
			  std::unique_ptr<HIR::Type> (type),
			  stmt.get_outer_attrs (), stmt.get_locus ());
  }

  void visit (AST::TupleStruct &struct_decl) override
  {
    std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
    if (struct_decl.has_generics ())
      {
	generic_params
	  = lower_generic_params (struct_decl.get_generic_params ());
      }

    std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
    HIR::WhereClause where_clause (std::move (where_clause_items));
    HIR::Visibility vis = translate_visibility (struct_decl.get_visibility ());

    std::vector<HIR::TupleField> fields;
    for (AST::TupleField &field : struct_decl.get_fields ())
      {
	HIR::Visibility vis = translate_visibility (field.get_visibility ());
	HIR::Type *type
	  = ASTLoweringType::translate (field.get_field_type ().get ());

	auto crate_num = mappings->get_current_crate ();
	Analysis::NodeMapping mapping (crate_num, field.get_node_id (),
				       mappings->get_next_hir_id (crate_num),
				       mappings->get_next_localdef_id (
					 crate_num));

	HIR::TupleField translated_field (mapping,
					  std::unique_ptr<HIR::Type> (type),
					  vis, field.get_locus (),
					  field.get_outer_attrs ());
	fields.push_back (std::move (translated_field));
      }

    auto crate_num = mappings->get_current_crate ();
    Analysis::NodeMapping mapping (crate_num, struct_decl.get_node_id (),
				   mappings->get_next_hir_id (crate_num),
				   mappings->get_next_localdef_id (crate_num));

    translated = new HIR::TupleStruct (mapping, std::move (fields),
				       struct_decl.get_identifier (),
				       std::move (generic_params),
				       std::move (where_clause), vis,
				       struct_decl.get_outer_attrs (),
				       struct_decl.get_locus ());
  }

  void visit (AST::StructStruct &struct_decl) override
  {
    std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
    if (struct_decl.has_generics ())
      {
	generic_params
	  = lower_generic_params (struct_decl.get_generic_params ());
      }

    std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
    HIR::WhereClause where_clause (std::move (where_clause_items));
    HIR::Visibility vis = translate_visibility (struct_decl.get_visibility ());

    bool is_unit = struct_decl.is_unit_struct ();
    std::vector<HIR::StructField> fields;
    for (AST::StructField &field : struct_decl.get_fields ())
      {
	HIR::Visibility vis = translate_visibility (field.get_visibility ());
	HIR::Type *type
	  = ASTLoweringType::translate (field.get_field_type ().get ());

	auto crate_num = mappings->get_current_crate ();
	Analysis::NodeMapping mapping (crate_num, field.get_node_id (),
				       mappings->get_next_hir_id (crate_num),
				       mappings->get_next_localdef_id (
					 crate_num));

	HIR::StructField translated_field (mapping, field.get_field_name (),
					   std::unique_ptr<HIR::Type> (type),
					   vis, field.get_locus (),
					   field.get_outer_attrs ());

	if (struct_field_name_exists (fields, translated_field))
	  break;

	fields.push_back (std::move (translated_field));
      }

    auto crate_num = mappings->get_current_crate ();
    Analysis::NodeMapping mapping (crate_num, struct_decl.get_node_id (),
				   mappings->get_next_hir_id (crate_num),
				   mappings->get_next_localdef_id (crate_num));

    translated = new HIR::StructStruct (mapping, std::move (fields),
					struct_decl.get_identifier (),
					std::move (generic_params),
					std::move (where_clause), is_unit, vis,
					struct_decl.get_outer_attrs (),
					struct_decl.get_locus ());
  }

  void visit (AST::Union &union_decl) override
  {
    std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
    if (union_decl.has_generics ())
      {
	generic_params
	  = lower_generic_params (union_decl.get_generic_params ());
      }

    std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
    HIR::WhereClause where_clause (std::move (where_clause_items));
    HIR::Visibility vis = translate_visibility (union_decl.get_visibility ());

    std::vector<HIR::StructField> variants;
    for (AST::StructField &variant : union_decl.get_variants ())
      {
	HIR::Visibility vis = translate_visibility (variant.get_visibility ());
	HIR::Type *type
	  = ASTLoweringType::translate (variant.get_field_type ().get ());

	auto crate_num = mappings->get_current_crate ();
	Analysis::NodeMapping mapping (crate_num, variant.get_node_id (),
				       mappings->get_next_hir_id (crate_num),
				       mappings->get_next_localdef_id (
					 crate_num));

	HIR::StructField translated_variant (mapping, variant.get_field_name (),
					     std::unique_ptr<HIR::Type> (type),
					     vis, variant.get_locus (),
					     variant.get_outer_attrs ());

	if (struct_field_name_exists (variants, translated_variant))
	  break;

	variants.push_back (std::move (translated_variant));
      }

    auto crate_num = mappings->get_current_crate ();
    Analysis::NodeMapping mapping (crate_num, union_decl.get_node_id (),
				   mappings->get_next_hir_id (crate_num),
				   mappings->get_next_localdef_id (crate_num));

    translated
      = new HIR::Union (mapping, union_decl.get_identifier (), vis,
			std::move (generic_params), std::move (where_clause),
			std::move (variants), union_decl.get_outer_attrs (),
			union_decl.get_locus ());
  }

  void visit (AST::Enum &enum_decl) override
  {
    std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
    if (enum_decl.has_generics ())
      {
	generic_params = lower_generic_params (enum_decl.get_generic_params ());
      }

    std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
    HIR::WhereClause where_clause (std::move (where_clause_items));
    HIR::Visibility vis = translate_visibility (enum_decl.get_visibility ());

    // bool is_unit = enum_decl.is_zero_variant ();
    std::vector<std::unique_ptr<HIR::EnumItem>> items;
    for (auto &variant : enum_decl.get_variants ())
      {
	HIR::EnumItem *hir_item
	  = ASTLoweringEnumItem::translate (variant.get ());
	items.push_back (std::unique_ptr<HIR::EnumItem> (hir_item));
      }

    auto crate_num = mappings->get_current_crate ();
    Analysis::NodeMapping mapping (crate_num, enum_decl.get_node_id (),
				   mappings->get_next_hir_id (crate_num),
				   mappings->get_next_localdef_id (crate_num));

    translated = new HIR::Enum (mapping, enum_decl.get_identifier (), vis,
				std::move (generic_params),
				std::move (where_clause), /* is_unit, */
				std::move (items), enum_decl.get_outer_attrs (),
				enum_decl.get_locus ());
  }

  void visit (AST::EmptyStmt &empty) override
  {
    auto crate_num = mappings->get_current_crate ();
    Analysis::NodeMapping mapping (crate_num, empty.get_node_id (),
				   mappings->get_next_hir_id (crate_num),
				   mappings->get_next_localdef_id (crate_num));

    translated = new HIR::EmptyStmt (mapping, 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
      = lower_qualifiers (function.get_qualifiers ());
    HIR::Visibility vis = translate_visibility (function.get_visibility ());

    // 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),
				   mappings->get_next_localdef_id (crate_num));

    mappings->insert_location (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 (),
			   HIR::SelfParam::error (), locus);

    // add the mappings for the function params at the end
    for (auto &param : fn->get_function_params ())
      {
	mappings->insert_hir_param (&param);
	mappings->insert_location (mapping.get_hirid (), param.get_locus ());
      }

    translated = fn;
  }

  void visit (AST::ExternBlock &extern_block) override
  {
    translated = lower_extern_block (extern_block);
  }

private:
  ASTLoweringStmt () : translated (nullptr), terminated (false) {}

  HIR::Stmt *translated;
  bool terminated;
};

} // namespace HIR
} // namespace Rust

#endif // RUST_AST_LOWER_PATTERN
Commit	Line	Data
a945c346	1	// Copyright (C) 2020-2024 Free Software Foundation, Inc.
7999cf32 PH	2
	3	// This file is part of GCC.
	4
	5	// GCC is free software; you can redistribute it and/or modify it under
	6	// the terms of the GNU General Public License as published by the Free
	7	// Software Foundation; either version 3, or (at your option) any later
	8	// version.
	9
	10	// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	11	// WARRANTY; without even the implied warranty of MERCHANTABILITY or
	12	// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	13	// for more details.
	14
	15	// You should have received a copy of the GNU General Public License
	16	// along with GCC; see the file COPYING3. If not see
	17	// <http://www.gnu.org/licenses/>.
	18
	19	#ifndef RUST_AST_LOWER_STMT
	20	#define RUST_AST_LOWER_STMT
	21
	22	#include "rust-diagnostics.h"
	23
	24	#include "rust-ast-lower-base.h"
	25	#include "rust-ast-lower-enumitem.h"
	26	#include "rust-ast-lower-type.h"
	27	#include "rust-ast-lower-block.h"
	28	#include "rust-ast-lower-expr.h"
	29	#include "rust-ast-lower-pattern.h"
	30
	31	namespace Rust {
	32	namespace HIR {
	33
	34	class ASTLoweringStmt : public ASTLoweringBase
	35	{
	36	using Rust::HIR::ASTLoweringBase::visit;
	37
	38	public:
	39	static HIR::Stmt translate (AST::Stmt stmt, bool *terminated)
	40	{
	41	ASTLoweringStmt resolver;
	42	stmt->accept_vis (resolver);
	43
	44	rust_assert (resolver.translated != nullptr);
	45	*terminated = resolver.terminated;
	46	resolver.mappings->insert_location (
	47	resolver.translated->get_mappings ().get_hirid (),
	48	resolver.translated->get_locus ());
	49	resolver.mappings->insert_hir_stmt (resolver.translated);
	50	if (resolver.translated->is_item ())
	51	{
	52	HIR::Item i = static_cast<HIR::Item > (resolver.translated);
	53
	54	auto defid = resolver.translated->get_mappings ().get_defid ();
	55
	56	resolver.handle_outer_attributes (*i);
	57	resolver.mappings->insert_hir_item (i);
	58	resolver.mappings->insert_defid_mapping (defid, i);
	59	}
	60
	61	return resolver.translated;
	62	}
	63
	64	void visit (AST::ExprStmtWithBlock &stmt) override
	65	{
66	HIR::ExprWithBlock *expr
67	= ASTLoweringExprWithBlock::translate (stmt.get_expr ().get (),
68	&terminated);
69
70	auto crate_num = mappings->get_current_crate ();
71	Analysis::NodeMapping mapping (crate_num, stmt.get_node_id (),
72	mappings->get_next_hir_id (crate_num),
73	UNKNOWN_LOCAL_DEFID);
74	translated
75	= new HIR::ExprStmtWithBlock (mapping,
76	std::unique_ptr<HIR::ExprWithBlock> (expr),
77	stmt.get_locus (),
78	!stmt.is_semicolon_followed ());
79	}
80
81	void visit (AST::ExprStmtWithoutBlock &stmt) override
82	{
83	HIR::Expr *expr
84	= ASTLoweringExpr::translate (stmt.get_expr ().get (), &terminated);
85
86	auto crate_num = mappings->get_current_crate ();
87	Analysis::NodeMapping mapping (crate_num, stmt.get_node_id (),
88	mappings->get_next_hir_id (crate_num),
89	UNKNOWN_LOCAL_DEFID);
90	translated
91	= new HIR::ExprStmtWithoutBlock (mapping,
92	std::unique_ptr<HIR::Expr> (expr),
93	stmt.get_locus ());
94	}
95
96	void visit (AST::ConstantItem &constant) override
97	{
98	HIR::Visibility vis = translate_visibility (constant.get_visibility ());
99
100	HIR::Type *type = ASTLoweringType::translate (constant.get_type ().get ());
101	HIR::Expr *expr = ASTLoweringExpr::translate (constant.get_expr ().get ());
102
103	auto crate_num = mappings->get_current_crate ();
104	Analysis::NodeMapping mapping (crate_num, constant.get_node_id (),
105	mappings->get_next_hir_id (crate_num),
106	mappings->get_next_localdef_id (crate_num));
107
108	translated = new HIR::ConstantItem (mapping, constant.get_identifier (),
109	vis, std::unique_ptr<HIR::Type> (type),
110	std::unique_ptr<HIR::Expr> (expr),
111	constant.get_outer_attrs (),
112	constant.get_locus ());
113	}
114
115	void visit (AST::LetStmt &stmt) override
116	{
117	HIR::Pattern *variables
118	= ASTLoweringPattern::translate (stmt.get_pattern ().get ());
119	HIR::Type *type = stmt.has_type ()
120	? ASTLoweringType::translate (stmt.get_type ().get ())
121	: nullptr;
122	HIR::Expr *init_expression
123	= stmt.has_init_expr ()
124	? ASTLoweringExpr::translate (stmt.get_init_expr ().get ())
125	: nullptr;
126
127	auto crate_num = mappings->get_current_crate ();
128	Analysis::NodeMapping mapping (crate_num, stmt.get_node_id (),
129	mappings->get_next_hir_id (crate_num),
130	UNKNOWN_LOCAL_DEFID);
131	translated
132	= new HIR::LetStmt (mapping, std::unique_ptr<HIR::Pattern> (variables),
133	std::unique_ptr<HIR::Expr> (init_expression),
134	std::unique_ptr<HIR::Type> (type),
135	stmt.get_outer_attrs (), stmt.get_locus ());
136	}
137
138	void visit (AST::TupleStruct &struct_decl) override
139	{
140	std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
141	if (struct_decl.has_generics ())
142	{
143	generic_params
144	= lower_generic_params (struct_decl.get_generic_params ());
145	}
146
147	std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
148	HIR::WhereClause where_clause (std::move (where_clause_items));
149	HIR::Visibility vis = translate_visibility (struct_decl.get_visibility ());
150
151	std::vector<HIR::TupleField> fields;
152	for (AST::TupleField &field : struct_decl.get_fields ())
153	{
154	HIR::Visibility vis = translate_visibility (field.get_visibility ());
155	HIR::Type *type
156	= ASTLoweringType::translate (field.get_field_type ().get ());
157
158	auto crate_num = mappings->get_current_crate ();
159	Analysis::NodeMapping mapping (crate_num, field.get_node_id (),
160	mappings->get_next_hir_id (crate_num),
161	mappings->get_next_localdef_id (
162	crate_num));
163
164	HIR::TupleField translated_field (mapping,
165	std::unique_ptr<HIR::Type> (type),
166	vis, field.get_locus (),
167	field.get_outer_attrs ());
168	fields.push_back (std::move (translated_field));
169	}
170
171	auto crate_num = mappings->get_current_crate ();
172	Analysis::NodeMapping mapping (crate_num, struct_decl.get_node_id (),
173	mappings->get_next_hir_id (crate_num),
174	mappings->get_next_localdef_id (crate_num));
175
176	translated = new HIR::TupleStruct (mapping, std::move (fields),
177	struct_decl.get_identifier (),
178	std::move (generic_params),
179	std::move (where_clause), vis,
180	struct_decl.get_outer_attrs (),
181	struct_decl.get_locus ());
182	}
183
184	void visit (AST::StructStruct &struct_decl) override
185	{
186	std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
187	if (struct_decl.has_generics ())
188	{
189	generic_params
190	= lower_generic_params (struct_decl.get_generic_params ());
191	}
192
193	std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
194	HIR::WhereClause where_clause (std::move (where_clause_items));
195	HIR::Visibility vis = translate_visibility (struct_decl.get_visibility ());
196
197	bool is_unit = struct_decl.is_unit_struct ();
198	std::vector<HIR::StructField> fields;
199	for (AST::StructField &field : struct_decl.get_fields ())
200	{
201	HIR::Visibility vis = translate_visibility (field.get_visibility ());
202	HIR::Type *type
203	= ASTLoweringType::translate (field.get_field_type ().get ());
204
205	auto crate_num = mappings->get_current_crate ();
206	Analysis::NodeMapping mapping (crate_num, field.get_node_id (),
207	mappings->get_next_hir_id (crate_num),
208	mappings->get_next_localdef_id (
209	crate_num));
210
211	HIR::StructField translated_field (mapping, field.get_field_name (),
212	std::unique_ptr<HIR::Type> (type),
213	vis, field.get_locus (),
214	field.get_outer_attrs ());
215
216	if (struct_field_name_exists (fields, translated_field))
217	break;
218
219	fields.push_back (std::move (translated_field));
220	}
221
222	auto crate_num = mappings->get_current_crate ();
223	Analysis::NodeMapping mapping (crate_num, struct_decl.get_node_id (),
224	mappings->get_next_hir_id (crate_num),
225	mappings->get_next_localdef_id (crate_num));
226
227	translated = new HIR::StructStruct (mapping, std::move (fields),
228	struct_decl.get_identifier (),
229	std::move (generic_params),
230	std::move (where_clause), is_unit, vis,
231	struct_decl.get_outer_attrs (),
232	struct_decl.get_locus ());
233	}
234
235	void visit (AST::Union &union_decl) override
236	{
237	std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
238	if (union_decl.has_generics ())
239	{
240	generic_params
241	= lower_generic_params (union_decl.get_generic_params ());
242	}
243
244	std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
245	HIR::WhereClause where_clause (std::move (where_clause_items));
246	HIR::Visibility vis = translate_visibility (union_decl.get_visibility ());
247
248	std::vector<HIR::StructField> variants;
249	for (AST::StructField &variant : union_decl.get_variants ())
250	{
251	HIR::Visibility vis = translate_visibility (variant.get_visibility ());
252	HIR::Type *type
253	= ASTLoweringType::translate (variant.get_field_type ().get ());
254
255	auto crate_num = mappings->get_current_crate ();
256	Analysis::NodeMapping mapping (crate_num, variant.get_node_id (),
257	mappings->get_next_hir_id (crate_num),
258	mappings->get_next_localdef_id (
259	crate_num));
260
261	HIR::StructField translated_variant (mapping, variant.get_field_name (),
262	std::unique_ptr<HIR::Type> (type),
263	vis, variant.get_locus (),
264	variant.get_outer_attrs ());
265
266	if (struct_field_name_exists (variants, translated_variant))
267	break;
268
269	variants.push_back (std::move (translated_variant));
270	}
271
272	auto crate_num = mappings->get_current_crate ();
273	Analysis::NodeMapping mapping (crate_num, union_decl.get_node_id (),
274	mappings->get_next_hir_id (crate_num),
275	mappings->get_next_localdef_id (crate_num));
276
277	translated
278	= new HIR::Union (mapping, union_decl.get_identifier (), vis,
279	std::move (generic_params), std::move (where_clause),
280	std::move (variants), union_decl.get_outer_attrs (),
281	union_decl.get_locus ());
282	}
283
284	void visit (AST::Enum &enum_decl) override
285	{
286	std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
287	if (enum_decl.has_generics ())
288	{
289	generic_params = lower_generic_params (enum_decl.get_generic_params ());
290	}
291
292	std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
293	HIR::WhereClause where_clause (std::move (where_clause_items));
294	HIR::Visibility vis = translate_visibility (enum_decl.get_visibility ());
295
296	// bool is_unit = enum_decl.is_zero_variant ();
297	std::vector<std::unique_ptr<HIR::EnumItem>> items;
298	for (auto &variant : enum_decl.get_variants ())
299	{
300	HIR::EnumItem *hir_item
301	= ASTLoweringEnumItem::translate (variant.get ());
302	items.push_back (std::unique_ptr<HIR::EnumItem> (hir_item));
303	}
304
305	auto crate_num = mappings->get_current_crate ();
306	Analysis::NodeMapping mapping (crate_num, enum_decl.get_node_id (),
307	mappings->get_next_hir_id (crate_num),
308	mappings->get_next_localdef_id (crate_num));
309
310	translated = new HIR::Enum (mapping, enum_decl.get_identifier (), vis,
311	std::move (generic_params),
312	std::move (where_clause), /* is_unit, */
313	std::move (items), enum_decl.get_outer_attrs (),
314	enum_decl.get_locus ());
315	}
316
317	void visit (AST::EmptyStmt &empty) override
318	{
319	auto crate_num = mappings->get_current_crate ();
320	Analysis::NodeMapping mapping (crate_num, empty.get_node_id (),
321	mappings->get_next_hir_id (crate_num),
322	mappings->get_next_localdef_id (crate_num));
323
324	translated = new HIR::EmptyStmt (mapping, empty.get_locus ());
325	}
326
327	void visit (AST::Function &function) override
328	{
329	// ignore for now and leave empty
330	std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
331	HIR::WhereClause where_clause (std::move (where_clause_items));
332	HIR::FunctionQualifiers qualifiers
333	= lower_qualifiers (function.get_qualifiers ());
334	HIR::Visibility vis = translate_visibility (function.get_visibility ());
335
336	// need
337	std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
338	if (function.has_generics ())
339	{
340	generic_params = lower_generic_params (function.get_generic_params ());
341	}
342
343	Identifier function_name = function.get_function_name ();
344	Location locus = function.get_locus ();
345
346	std::unique_ptr<HIR::Type> return_type
347	= function.has_return_type () ? std::unique_ptr<HIR::Type> (
348	ASTLoweringType::translate (function.get_return_type ().get ()))
349	: nullptr;
350
351	std::vector<HIR::FunctionParam> function_params;
352	for (auto &param : function.get_function_params ())
353	{
354	auto translated_pattern = std::unique_ptr<HIR::Pattern> (
355	ASTLoweringPattern::translate (param.get_pattern ().get ()));
356	auto translated_type = std::unique_ptr<HIR::Type> (
357	ASTLoweringType::translate (param.get_type ().get ()));
358
359	auto crate_num = mappings->get_current_crate ();
360	Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
361	mappings->get_next_hir_id (crate_num),
362	UNKNOWN_LOCAL_DEFID);
363
364	auto hir_param
365	= HIR::FunctionParam (mapping, std::move (translated_pattern),
366	std::move (translated_type),
367	param.get_locus ());
368	function_params.push_back (hir_param);
369	}
370
371	bool terminated = false;
372	std::unique_ptr<HIR::BlockExpr> function_body
373	= std::unique_ptr<HIR::BlockExpr> (
374	ASTLoweringBlock::translate (function.get_definition ().get (),
375	&terminated));
376
377	auto crate_num = mappings->get_current_crate ();
378	Analysis::NodeMapping mapping (crate_num, function.get_node_id (),
379	mappings->get_next_hir_id (crate_num),
380	mappings->get_next_localdef_id (crate_num));
381
382	mappings->insert_location (function_body->get_mappings ().get_hirid (),
383	function.get_locus ());
384
385	auto fn
386	= new HIR::Function (mapping, std::move (function_name),
387	std::move (qualifiers), std::move (generic_params),
388	std::move (function_params), std::move (return_type),
389	std::move (where_clause), std::move (function_body),
390	std::move (vis), function.get_outer_attrs (),
391	HIR::SelfParam::error (), locus);
392
393	// add the mappings for the function params at the end
394	for (auto &param : fn->get_function_params ())
395	{
396	mappings->insert_hir_param (&param);
397	mappings->insert_location (mapping.get_hirid (), param.get_locus ());
398	}
399
400	translated = fn;
401	}
402
403	void visit (AST::ExternBlock &extern_block) override
404	{
405	translated = lower_extern_block (extern_block);
406	}
407
408	private:
409	ASTLoweringStmt () : translated (nullptr), terminated (false) {}
410
411	HIR::Stmt *translated;
412	bool terminated;
413	};
414
415	} // namespace HIR
416	} // namespace Rust
417
418	#endif // RUST_AST_LOWER_PATTERN