KJ16609/gcc
1
0
Fork 0
mirror of https://gcc.gnu.org/git/gcc.git synced 2026-02-22 20:01:22 -05:00
Code Issues Packages Projects Releases Wiki Activity

gccrs: Create and use CompilePatternLet visitor for compiling let statments

Browse Source 
gcc/rust/ChangeLog:

	* backend/rust-compile-pattern.cc (CompilePatternLet::visit): New function.
	* backend/rust-compile-stmt.cc (CompileStmt::visit): Likewise.
	* backend/rust-compile-pattern.h (class CompilePatternLet): New visitor.

Signed-off-by: Owen Avery <powerboat9.gamer@gmail.com>
This commit is contained in:
Owen Avery
2023-01-27 11:47:30 -05:00
committed by Arthur Cohen
parent 51b607c222
commit ad9d75f508
3 changed files with 148 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
gcc/rust/backend/rust-compile-pattern.cc
View File

@@ -341,5 +341,63 @@ CompilePatternBindings::visit (HIR::GroupedPattern &pattern)
pattern.get_item ()->accept_vis (*this);
}
void
CompilePatternLet::visit (HIR::IdentifierPattern &pattern)
{
Bvariable *var = nullptr;
rust_assert (
ctx->lookup_var_decl (pattern.get_pattern_mappings ().get_hirid (), &var));
auto fnctx = ctx->peek_fn ();
if (ty->is_unit ())
{
ctx->add_statement (init_expr);
tree stmt_type = TyTyResolveCompile::compile (ctx, ty);
auto unit_type_init_expr
= ctx->get_backend ()->constructor_expression (stmt_type, false, {}, -1,
rval_locus);
auto s = ctx->get_backend ()->init_statement (fnctx.fndecl, var,
unit_type_init_expr);
ctx->add_statement (s);
}
else
{
auto s
= ctx->get_backend ()->init_statement (fnctx.fndecl, var, init_expr);
ctx->add_statement (s);
}
}
void
CompilePatternLet::visit (HIR::WildcardPattern &pattern)
{
Bvariable *var = nullptr;
rust_assert (
ctx->lookup_var_decl (pattern.get_pattern_mappings ().get_hirid (), &var));
auto fnctx = ctx->peek_fn ();
if (ty->is_unit ())
{
ctx->add_statement (init_expr);
tree stmt_type = TyTyResolveCompile::compile (ctx, ty);
auto unit_type_init_expr
= ctx->get_backend ()->constructor_expression (stmt_type, false, {}, -1,
rval_locus);
auto s = ctx->get_backend ()->init_statement (fnctx.fndecl, var,
unit_type_init_expr);
ctx->add_statement (s);
}
else
{
auto s
= ctx->get_backend ()->init_statement (fnctx.fndecl, var, init_expr);
ctx->add_statement (s);
}
}
} // namespace Compile
} // namespace Rust

87
gcc/rust/backend/rust-compile-pattern.h
View File

@@ -91,5 +91,92 @@ protected:
tree match_scrutinee_expr;
};
class CompilePatternLet : public HIRCompileBase, public HIR::HIRPatternVisitor
{
public:
static void Compile (HIR::Pattern *pattern, tree init_expr,
TyTy::BaseType *ty, Location rval_locus, Context *ctx)
{
CompilePatternLet compiler (ctx, init_expr, ty, rval_locus);
pattern->accept_vis (compiler);
}
void visit (HIR::IdentifierPattern &) override;
void visit (HIR::WildcardPattern &) override;
// check for unimplemented Pattern HIR nodes.
void visit (HIR::GroupedPattern &pattern) override
{
rust_sorry_at (pattern.get_locus (),
"grouped pattern let statements not supported");
}
void visit (HIR::LiteralPattern &pattern) override
{
rust_sorry_at (pattern.get_locus (),
"literal pattern let statements not supported");
}
void visit (HIR::PathInExpression &pattern) override
{
rust_sorry_at (pattern.get_locus (),
"path-in-expression pattern let statements not supported");
}
void visit (HIR::QualifiedPathInExpression &pattern) override
{
rust_sorry_at (
pattern.get_locus (),
"qualified-path-in-expression pattern let statements not supported");
}
void visit (HIR::RangePattern &pattern) override
{
rust_sorry_at (pattern.get_locus (),
"range pattern let statements not supported");
}
void visit (HIR::ReferencePattern &pattern) override
{
rust_sorry_at (pattern.get_locus (),
"reference pattern let statements not supported");
}
void visit (HIR::SlicePattern &pattern) override
{
rust_sorry_at (pattern.get_locus (),
"slice pattern let statements not supported");
}
void visit (HIR::StructPattern &pattern) override
{
rust_sorry_at (pattern.get_locus (),
"struct pattern let statements not supported");
}
void visit (HIR::TuplePattern &pattern) override
{
rust_sorry_at (pattern.get_locus (),
"tuple pattern let statements not supported");
}
void visit (HIR::TupleStructPattern &pattern) override
{
rust_sorry_at (pattern.get_locus (),
"tuple-struct pattern let statements not supported");
}
protected:
CompilePatternLet (Context *ctx, tree init_expr, TyTy::BaseType *ty,
Location rval_locus)
: HIRCompileBase (ctx), init_expr (init_expr), ty (ty),
rval_locus (rval_locus)
{}
tree init_expr;
TyTy::BaseType *ty;
Location rval_locus;
};
} // namespace Compile
} // namespace Rust

31
gcc/rust/backend/rust-compile-stmt.cc
View File

@@ -16,6 +16,7 @@
// along with GCC; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include "rust-compile-pattern.h"
#include "rust-compile-stmt.h"
#include "rust-compile-expr.h"
@@ -53,7 +54,7 @@ CompileStmt::visit (HIR::LetStmt &stmt)
if (!stmt.has_init_expr ())
return;
const HIR::Pattern &stmt_pattern = *stmt.get_pattern ();
HIR::Pattern &stmt_pattern = *stmt.get_pattern ();
HirId stmt_id = stmt_pattern.get_pattern_mappings ().get_hirid ();
TyTy::BaseType *ty = nullptr;
@@ -65,15 +66,6 @@ CompileStmt::visit (HIR::LetStmt &stmt)
return;
}
Bvariable *var = nullptr;
if (!ctx->lookup_var_decl (stmt_id, &var))
{
// FIXME this should be an assertion instead and use error mark node
rust_fatal_error (stmt.get_locus (),
"failed to lookup compiled variable declaration");
return;
}
tree init = CompileExpr::Compile (stmt.get_init_expr (), ctx);
// FIXME use error_mark_node, check that CompileExpr returns error_mark_node
// on failure and make this an assertion
@@ -84,7 +76,6 @@ CompileStmt::visit (HIR::LetStmt &stmt)
bool ok = ctx->get_tyctx ()->lookup_type (
stmt.get_init_expr ()->get_mappings ().get_hirid (), &actual);
rust_assert (ok);
tree stmt_type = TyTyResolveCompile::compile (ctx, ty);
Location lvalue_locus = stmt.get_pattern ()->get_locus ();
Location rvalue_locus = stmt.get_init_expr ()->get_locus ();
@@ -92,23 +83,7 @@ CompileStmt::visit (HIR::LetStmt &stmt)
init = coercion_site (stmt.get_mappings ().get_hirid (), init, actual,
expected, lvalue_locus, rvalue_locus);
auto fnctx = ctx->peek_fn ();
if (ty->is_unit ())
{
ctx->add_statement (init);
auto unit_type_init_expr
= ctx->get_backend ()->constructor_expression (stmt_type, false, {}, -1,
rvalue_locus);
auto s = ctx->get_backend ()->init_statement (fnctx.fndecl, var,
unit_type_init_expr);
ctx->add_statement (s);
}
else
{
auto s = ctx->get_backend ()->init_statement (fnctx.fndecl, var, init);
ctx->add_statement (s);
}
CompilePatternLet::Compile (&stmt_pattern, init, ty, rvalue_locus, ctx);
}
} // namespace Compile