Attempt to use references and smart pointers whenever possible.
gcc/rust/ChangeLog:
* backend/rust-compile-base.cc (HIRCompileBase::compile_function_body):
Remove usage of get function to retrieve a raw pointer.
* backend/rust-compile-base.h:
Change API usage from raw pointer to a reference.
* backend/rust-compile-block.cc (CompileBlock::compile): Likewise.
(CompileBlock::visit): Likewise.
(CompileConditionalBlocks::visit): Likewise.
* backend/rust-compile-block.h: Likewise.
* backend/rust-compile-expr.cc (CompileExpr::Compile): Likewise.
(CompileExpr::visit): Likewise.
(check_match_scrutinee): Likewise.
(CompileExpr::array_value_expr): Likewise.
(CompileExpr::array_copied_expr): Likewise.
(CompileExpr::generate_closure_function): Likewise.
(CompileExpr::generate_possible_fn_trait_call): Likewise.
* backend/rust-compile-expr.h: Likewise.
* backend/rust-compile-fnparam.cc (CompileFnParam::compile): Likewise.
(CompileFnParam::visit): Likewise.
* backend/rust-compile-fnparam.h: Likewise.
* backend/rust-compile-implitem.cc (CompileTraitItem::visit): Likewise.
* backend/rust-compile-intrinsic.cc (compile_fn_params): Likewise.
* backend/rust-compile-item.cc (CompileItem::visit): Likewise.
* backend/rust-compile-pattern.cc (CompilePatternCheckExpr::visit):
Likewise.
(compile_range_pattern_bound): Likewise.
(CompilePatternBindings::visit): Likewise.
(CompilePatternLet::visit): Likewise.
* backend/rust-compile-pattern.h: Likewise.
* backend/rust-compile-resolve-path.cc (ResolvePathRef::resolve):
Likewise.
(HIRCompileBase::query_compile): Likewise.
* backend/rust-compile-stmt.cc (CompileStmt::visit): Likewise.
* backend/rust-compile-struct-field-expr.cc (CompileStructExprField::Compile):
Likewise.
(CompileStructExprField::visit): Likewise.
* backend/rust-compile-struct-field-expr.h: Likewise.
* backend/rust-compile-type.cc (TyTyResolveCompile::visit): Likewise.
* backend/rust-compile-var-decl.h: Likewise.
* backend/rust-compile.cc: Likewise.
* backend/rust-mangle-v0.cc (v0_inherent_or_trait_impl_path): Likewise.
* checks/errors/borrowck/rust-bir-builder-expr-stmt.cc (ExprStmtBuilder::visit):
Likewise.
* checks/errors/borrowck/rust-bir-builder-lazyboolexpr.h: Likewise.
* checks/errors/borrowck/rust-bir-builder-pattern.h: Likewise.
* checks/errors/borrowck/rust-bir-builder-struct.h: Likewise.
* checks/errors/borrowck/rust-bir-builder.h: Likewise.
* checks/errors/borrowck/rust-function-collector.h: Likewise.
* checks/errors/privacy/rust-privacy-reporter.cc (PrivacyReporter::check_type_privacy):
Likewise.
(PrivacyReporter::visit): Likewise.
* checks/errors/privacy/rust-privacy-reporter.h: Likewise.
* checks/errors/privacy/rust-reachability.cc (ReachabilityVisitor::visit):
Likewise.
* checks/errors/rust-const-checker.cc (ConstChecker::visit): Likewise.
* checks/errors/rust-unsafe-checker.cc (UnsafeChecker::visit):
Likewise.
* checks/lints/rust-lint-marklive.cc (MarkLive::visit): Likewise.
* checks/lints/rust-lint-marklive.h: Likewise.
* hir/rust-hir-dump.cc (Dump::visit): Likewise.
* hir/tree/rust-hir-expr.h: Likewise.
* hir/tree/rust-hir-item.h: Likewise.
* hir/tree/rust-hir-path.h: Likewise.
* hir/tree/rust-hir-pattern.h: Likewise.
* hir/tree/rust-hir-stmt.h: Likewise.
* hir/tree/rust-hir-type.h: Likewise.
* hir/tree/rust-hir.h: Likewise.
* typecheck/rust-autoderef.cc: Likewise.
* typecheck/rust-hir-dot-operator.cc (MethodResolver::select):
Likewise.
* typecheck/rust-hir-inherent-impl-overlap.h: Likewise.
* typecheck/rust-hir-path-probe.cc (PathProbeType::process_impl_item_candidate):
Likewise.
(PathProbeImplTrait::process_trait_impl_items_for_candidates): Likewise.
* typecheck/rust-hir-trait-resolve.cc (TraitResolver::resolve_trait):
Likewise.
(TraitItemReference::resolve_item): Likewise.
* typecheck/rust-hir-type-check-base.cc: Likewise.
* typecheck/rust-hir-type-check-base.h: Likewise.
* typecheck/rust-hir-type-check-enumitem.cc (TypeCheckEnumItem::Resolve):
Likewise.
(TypeCheckEnumItem::visit): Likewise.
* typecheck/rust-hir-type-check-enumitem.h: Likewise.
* typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::Resolve):
Likewise.
(TypeCheckExpr::visit): Likewise.
(TypeCheckExpr::resolve_fn_trait_call): Likewise.
* typecheck/rust-hir-type-check-expr.h: Likewise.
* typecheck/rust-hir-type-check-implitem.cc (TypeCheckTopLevelExternItem::Resolve):
Likewise.
(TypeCheckTopLevelExternItem::visit): Likewise.
(TypeCheckImplItem::visit): Likewise.
(TypeCheckImplItemWithTrait::visit): Likewise.
* typecheck/rust-hir-type-check-implitem.h: Likewise.
* typecheck/rust-hir-type-check-item.cc (TypeCheckItem::visit): Likewise.
(TypeCheckItem::resolve_impl_item): Likewise.
(TypeCheckItem::resolve_impl_block_substitutions): Likewise.
(TypeCheckItem::resolve_impl_block_self): Likewise.
* typecheck/rust-hir-type-check-path.cc (TypeCheckExpr::visit): Likewise.
(TypeCheckExpr::resolve_segments): Likewise.
* typecheck/rust-hir-type-check-pattern.cc (TypeCheckPattern::Resolve):
Likewise.
(TypeCheckPattern::visit): Likewise.
(ClosureParamInfer::Resolve): Likewise.
(ClosureParamInfer::visit): Likewise.
* typecheck/rust-hir-type-check-pattern.h: Likewise.
* typecheck/rust-hir-type-check-stmt.cc (TypeCheckStmt::Resolve):
Likewise.
(TypeCheckStmt::visit): Likewise.
* typecheck/rust-hir-type-check-stmt.h: Likewise.
* typecheck/rust-hir-type-check-struct-field.h: Likewise.
* typecheck/rust-hir-type-check-struct.cc (TypeCheckStructExpr::TypeCheckStructExpr):
Likewise.
(TypeCheckStructExpr::Resolve): Likewise.
(TypeCheckStructExpr::resolve): Likewise.
(TypeCheckStructExpr::visit): Likewise.
* typecheck/rust-hir-type-check-type.cc (TypeCheckResolveGenericArguments::resolve):
Likewise.
(TypeCheckType::Resolve): Likewise.
(TypeCheckType::visit): Likewise.
(TypeCheckType::resolve_root_path): Likewise.
(TypeResolveGenericParam::Resolve): Likewise.
(TypeResolveGenericParam::visit): Likewise.
(ResolveWhereClauseItem::visit): Likewise.
* typecheck/rust-hir-type-check-type.h: Likewise.
* typecheck/rust-hir-type-check.cc (TraitItemReference::get_type_from_fn):
Likewise.
* typecheck/rust-hir-type-check.h: Likewise.
* typecheck/rust-type-util.cc (query_type): Likewise.
* typecheck/rust-typecheck-context.cc (TypeCheckContextItem::TypeCheckContextItem):
Likewise.
* typecheck/rust-tyty-bounds.cc (TypeBoundsProbe::scan): Likewise.
(TypeCheckBase::get_predicate_from_bound): Likewise.
* typecheck/rust-tyty-call.cc (TypeCheckCallExpr::visit): Likewise.
(TypeCheckMethodCallExpr::go): Likewise.
(TypeCheckMethodCallExpr::check): Likewise.
* typecheck/rust-tyty-subst.cc: Likewise.
* typecheck/rust-tyty.cc (BaseType::monomorphized_clone): Likewise.
(VariantDef::VariantDef): Remove copy constructor.
(VariantDef::operator=): Change to move operator.
(VariantDef::get_discriminant): Replace return type to a reference
instead of a reference to a unique pointer.
(VariantDef::clone): Change to references.
(VariantDef::monomorphized_clone): Likewise.
(FnType::as_string): Likewise.
(FnType::clone): Likewise.
* typecheck/rust-tyty.h: Likewise.
* util/rust-hir-map.cc (Mappings::insert_hir_impl_block): Likewise.
* backend/rust-compile-asm.cc: Use a reference instead of the raw
pointer value.
* checks/errors/borrowck/rust-bir-builder-pattern.cc: Use references.
* checks/errors/rust-hir-pattern-analysis.cc: Likewise.
Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>
{
auto out = output.get_out ();
- tree out_tree = CompileExpr::Compile (out.expr.get (), this->ctx);
+ tree out_tree = CompileExpr::Compile (*out.expr, this->ctx);
// expects a tree list
// TODO: This assumes that the output is a register
std::string expr_name = "=r";
{
auto in = input.get_in ();
- tree in_tree = CompileExpr::Compile (in.expr.get (), this->ctx);
+ tree in_tree = CompileExpr::Compile (*in.expr, this->ctx);
// expects a tree list
// TODO: This assumes that the input is a register
std::string expr_name = "r";
if (function_body.has_expr ())
{
- location_t locus = function_body.get_final_expr ()->get_locus ();
- tree return_value = CompileExpr::Compile (function_body.expr.get (), ctx);
+ location_t locus = function_body.get_final_expr ().get_locus ();
+ tree return_value
+ = CompileExpr::Compile (function_body.get_final_expr (), ctx);
// we can only return this if non unit value return type
if (!fn_return_ty->is_unit ())
size_t i = is_method ? 1 : 0;
for (auto &referenced_param : function_params)
{
- auto tyty_param = fntype->param_at (i++);
+ auto &tyty_param = fntype->param_at (i++);
auto param_tyty = tyty_param.second;
auto compiled_param_type = TyTyResolveCompile::compile (ctx, param_tyty);
location_t param_locus = referenced_param.get_locus ();
Bvariable *compiled_param_var
- = CompileFnParam::compile (ctx, fndecl, &referenced_param,
+ = CompileFnParam::compile (ctx, fndecl, referenced_param,
compiled_param_type, param_locus);
param_vars.push_back (compiled_param_var);
- const HIR::Pattern ¶m_pattern = *referenced_param.get_param_name ();
+ const HIR::Pattern ¶m_pattern = referenced_param.get_param_name ();
ctx->insert_var_decl (param_pattern.get_mappings ().get_hirid (),
compiled_param_var);
}
tree
HIRCompileBase::compile_constant_item (
TyTy::BaseType *resolved_type, const Resolver::CanonicalPath &canonical_path,
- HIR::Expr *const_value_expr, location_t locus)
+ HIR::Expr &const_value_expr, location_t locus)
{
const std::string &ident = canonical_path.get ();
tree type = TyTyResolveCompile::compile (ctx, resolved_type);
tree const_type = build_qualified_type (type, TYPE_QUAL_CONST);
bool is_block_expr
- = const_value_expr->get_expression_type () == HIR::Expr::ExprType::Block;
+ = const_value_expr.get_expression_type () == HIR::Expr::ExprType::Block;
// in order to compile a block expr we want to reuse as much existing
// machineary that we already have. This means the best approach is to
TREE_READONLY (fndecl) = 1;
tree enclosing_scope = NULL_TREE;
- location_t start_location = const_value_expr->get_locus ();
- location_t end_location = const_value_expr->get_locus ();
+ location_t start_location = const_value_expr.get_locus ();
+ location_t end_location = const_value_expr.get_locus ();
if (is_block_expr)
{
- HIR::BlockExpr *function_body
- = static_cast<HIR::BlockExpr *> (const_value_expr);
- start_location = function_body->get_locus ();
- end_location = function_body->get_end_locus ();
+ HIR::BlockExpr &function_body
+ = static_cast<HIR::BlockExpr &> (const_value_expr);
+ start_location = function_body.get_locus ();
+ end_location = function_body.get_end_locus ();
}
tree code_block = Backend::block (fndecl, enclosing_scope, {} /*locals*/,
if (is_block_expr)
{
- HIR::BlockExpr *function_body
- = static_cast<HIR::BlockExpr *> (const_value_expr);
- compile_function_body (fndecl, *function_body, resolved_type);
+ HIR::BlockExpr &function_body
+ = static_cast<HIR::BlockExpr &> (const_value_expr);
+ compile_function_body (fndecl, function_body, resolved_type);
}
else
{
tree return_expr
= Backend::return_statement (fndecl, value,
- const_value_expr->get_locus ());
+ const_value_expr.get_locus ());
ctx->add_statement (return_expr);
}
tree compile_constant_item (TyTy::BaseType *resolved_type,
const Resolver::CanonicalPath &canonical_path,
- HIR::Expr *const_value_expr, location_t locus);
+ HIR::Expr &const_value_expr, location_t locus);
tree compile_function (const std::string &fn_name, HIR::SelfParam &self_param,
std::vector<HIR::FunctionParam> &function_params,
{}
tree
-CompileBlock::compile (HIR::BlockExpr *expr, Context *ctx, Bvariable *result)
+CompileBlock::compile (HIR::BlockExpr &expr, Context *ctx, Bvariable *result)
{
CompileBlock compiler (ctx, result);
- compiler.visit (*expr);
+ compiler.visit (expr);
return compiler.translated;
}
if (expr.has_expr ())
{
- tree compiled_expr = CompileExpr::Compile (expr.expr.get (), ctx);
+ tree compiled_expr = CompileExpr::Compile (expr.get_final_expr (), ctx);
if (result != nullptr)
{
- location_t locus = expr.get_final_expr ()->get_locus ();
+ location_t locus = expr.get_final_expr ().get_locus ();
tree result_reference = Backend::var_expression (result, locus);
tree assignment
{
fncontext fnctx = ctx->peek_fn ();
tree fndecl = fnctx.fndecl;
- tree condition_expr
- = CompileExpr::Compile (expr.get_if_condition ().get (), ctx);
- tree then_block
- = CompileBlock::compile (expr.get_if_block ().get (), ctx, result);
+ tree condition_expr = CompileExpr::Compile (expr.get_if_condition (), ctx);
+ tree then_block = CompileBlock::compile (expr.get_if_block (), ctx, result);
translated = Backend::if_statement (fndecl, condition_expr, then_block, NULL,
expr.get_locus ());
{
fncontext fnctx = ctx->peek_fn ();
tree fndecl = fnctx.fndecl;
- tree condition_expr
- = CompileExpr::Compile (expr.get_if_condition ().get (), ctx);
- tree then_block
- = CompileBlock::compile (expr.get_if_block ().get (), ctx, result);
+ tree condition_expr = CompileExpr::Compile (expr.get_if_condition (), ctx);
+ tree then_block = CompileBlock::compile (expr.get_if_block (), ctx, result);
// else block
std::vector<Bvariable *> locals;
- location_t start_location = expr.get_else_block ()->get_locus ();
- location_t end_location = expr.get_else_block ()->get_locus (); // FIXME
+ location_t start_location = expr.get_else_block ().get_locus ();
+ location_t end_location = expr.get_else_block ().get_locus (); // FIXME
tree enclosing_scope = ctx->peek_enclosing_scope ();
tree else_block = Backend::block (fndecl, enclosing_scope, locals,
start_location, end_location);
ctx->push_block (else_block);
tree else_stmt_decl
- = CompileExprWithBlock::compile (expr.get_else_block ().get (), ctx,
- result);
+ = CompileExprWithBlock::compile (&expr.get_else_block (), ctx, result);
ctx->add_statement (else_stmt_decl);
class CompileBlock : private HIRCompileBase
{
public:
- static tree compile (HIR::BlockExpr *expr, Context *ctx, Bvariable *result);
+ static tree compile (HIR::BlockExpr &expr, Context *ctx, Bvariable *result);
protected:
void visit (HIR::BlockExpr &expr);
void visit (HIR::BlockExpr &expr) override
{
- translated = CompileBlock::compile (&expr, ctx, result);
+ translated = CompileBlock::compile (expr, ctx, result);
}
// Empty visit for unused Expression HIR nodes.
{}
tree
-CompileExpr::Compile (HIR::Expr *expr, Context *ctx)
+CompileExpr::Compile (HIR::Expr &expr, Context *ctx)
{
CompileExpr compiler (ctx);
- expr->accept_vis (compiler);
+ expr.accept_vis (compiler);
return compiler.translated;
}
void
CompileExpr::visit (HIR::TupleIndexExpr &expr)
{
- HIR::Expr *tuple_expr = expr.get_tuple_expr ().get ();
+ HIR::Expr &tuple_expr = expr.get_tuple_expr ();
TupleIndex index = expr.get_tuple_index ();
tree receiver_ref = CompileExpr::Compile (tuple_expr, ctx);
TyTy::BaseType *tuple_expr_ty = nullptr;
bool ok
- = ctx->get_tyctx ()->lookup_type (tuple_expr->get_mappings ().get_hirid (),
+ = ctx->get_tyctx ()->lookup_type (tuple_expr.get_mappings ().get_hirid (),
&tuple_expr_ty);
rust_assert (ok);
std::vector<tree> vals;
for (auto &elem : expr.get_tuple_elems ())
{
- auto e = CompileExpr::Compile (elem.get (), ctx);
+ auto e = CompileExpr::Compile (*elem, ctx);
vals.push_back (e);
}
auto fncontext = ctx->peek_fn ();
tree return_value = expr.has_return_expr ()
- ? CompileExpr::Compile (expr.return_expr.get (), ctx)
+ ? CompileExpr::Compile (expr.get_expr (), ctx)
: unit_expression (expr.get_locus ());
if (expr.has_return_expr ())
CompileExpr::visit (HIR::ArithmeticOrLogicalExpr &expr)
{
auto op = expr.get_expr_type ();
- auto lhs = CompileExpr::Compile (expr.get_lhs ().get (), ctx);
- auto rhs = CompileExpr::Compile (expr.get_rhs ().get (), ctx);
+ auto lhs = CompileExpr::Compile (expr.get_lhs (), ctx);
+ auto rhs = CompileExpr::Compile (expr.get_rhs (), ctx);
// this might be an operator overload situation lets check
TyTy::FnType *fntype;
auto lang_item_type
= LangItem::OperatorToLangItem (expr.get_expr_type ());
translated = resolve_operator_overload (lang_item_type, expr, lhs, rhs,
- expr.get_lhs ().get (),
- expr.get_rhs ().get ());
+ expr.get_lhs (), expr.get_rhs ());
return;
}
CompileExpr::visit (HIR::CompoundAssignmentExpr &expr)
{
auto op = expr.get_expr_type ();
- auto lhs = CompileExpr::Compile (expr.get_lhs ().get (), ctx);
- auto rhs = CompileExpr::Compile (expr.get_rhs ().get (), ctx);
+ auto lhs = CompileExpr::Compile (expr.get_lhs (), ctx);
+ auto rhs = CompileExpr::Compile (expr.get_rhs (), ctx);
// this might be an operator overload situation lets check
TyTy::FnType *fntype;
expr.get_expr_type ());
auto compound_assignment
= resolve_operator_overload (lang_item_type, expr, lhs, rhs,
- expr.get_lhs ().get (),
- expr.get_rhs ().get ());
+ expr.get_lhs (), expr.get_rhs ());
ctx->add_statement (compound_assignment);
return;
{
auto op = expr.get_expr_type ();
- const auto literal_expr = expr.get_expr ().get ();
+ auto &literal_expr = expr.get_expr ();
// If it's a negated integer/float literal, we can return early
if (op == NegationOperator::NEGATE
- && literal_expr->get_expression_type () == HIR::Expr::ExprType::Lit)
+ && literal_expr.get_expression_type () == HIR::Expr::ExprType::Lit)
{
- auto new_literal_expr = static_cast<HIR::LiteralExpr *> (literal_expr);
- auto lit_type = new_literal_expr->get_lit_type ();
+ auto &new_literal_expr = static_cast<HIR::LiteralExpr &> (literal_expr);
+ auto lit_type = new_literal_expr.get_lit_type ();
if (lit_type == HIR::Literal::LitType::INT
|| lit_type == HIR::Literal::LitType::FLOAT)
{
- new_literal_expr->set_negative ();
+ new_literal_expr.set_negative ();
translated = CompileExpr::Compile (literal_expr, ctx);
return;
}
auto lang_item_type = LangItem::NegationOperatorToLangItem (op);
translated
= resolve_operator_overload (lang_item_type, expr, negated_expr,
- nullptr, expr.get_expr ().get (), nullptr);
+ nullptr, expr.get_expr (), tl::nullopt);
return;
}
CompileExpr::visit (HIR::ComparisonExpr &expr)
{
auto op = expr.get_expr_type ();
- auto lhs = CompileExpr::Compile (expr.get_lhs ().get (), ctx);
- auto rhs = CompileExpr::Compile (expr.get_rhs ().get (), ctx);
+ auto lhs = CompileExpr::Compile (expr.get_lhs (), ctx);
+ auto rhs = CompileExpr::Compile (expr.get_rhs (), ctx);
auto location = expr.get_locus ();
translated = Backend::comparison_expression (op, lhs, rhs, location);
CompileExpr::visit (HIR::LazyBooleanExpr &expr)
{
auto op = expr.get_expr_type ();
- auto lhs = CompileExpr::Compile (expr.get_lhs ().get (), ctx);
- auto rhs = CompileExpr::Compile (expr.get_rhs ().get (), ctx);
+ auto lhs = CompileExpr::Compile (expr.get_lhs (), ctx);
+ auto rhs = CompileExpr::Compile (expr.get_rhs (), ctx);
auto location = expr.get_locus ();
translated = Backend::lazy_boolean_expression (op, lhs, rhs, location);
TyTy::BaseType *casted_tyty = nullptr;
if (!ctx->get_tyctx ()->lookup_type (
- expr.get_casted_expr ()->get_mappings ().get_hirid (), &casted_tyty))
+ expr.get_casted_expr ().get_mappings ().get_hirid (), &casted_tyty))
{
translated = error_mark_node;
return;
}
auto type_to_cast_to = TyTyResolveCompile::compile (ctx, type_to_cast_to_ty);
- auto casted_expr = CompileExpr::Compile (expr.get_casted_expr ().get (), ctx);
+ auto casted_expr = CompileExpr::Compile (expr.get_casted_expr (), ctx);
std::vector<Resolver::Adjustment> *adjustments = nullptr;
bool ok = ctx->get_tyctx ()->lookup_cast_autoderef_mappings (
&ret_var_stmt);
ctx->add_statement (ret_var_stmt);
- auto block_stmt = CompileBlock::compile (&expr, ctx, tmp);
+ auto block_stmt = CompileBlock::compile (expr, ctx, tmp);
rust_assert (TREE_CODE (block_stmt) == BIND_EXPR);
ctx->add_statement (block_stmt);
void
CompileExpr::visit (HIR::UnsafeBlockExpr &expr)
{
- expr.get_block_expr ()->accept_vis (*this);
+ expr.get_block_expr ().accept_vis (*this);
}
void
auto lvalue_locus
= ctx->get_mappings ().lookup_location (expected->get_ty_ref ());
auto rvalue_locus = argument->get_locus ();
- auto rvalue = CompileStructExprField::Compile (argument.get (), ctx);
+ auto rvalue = CompileStructExprField::Compile (*argument, ctx);
TyTy::BaseType *actual = nullptr;
bool ok = ctx->get_tyctx ()->lookup_type (
auto lvalue_locus
= ctx->get_mappings ().lookup_location (expected->get_ty_ref ());
auto rvalue_locus = argument->get_locus ();
- auto rvalue = CompileStructExprField::Compile (argument.get (), ctx);
+ auto rvalue = CompileStructExprField::Compile (*argument, ctx);
TyTy::BaseType *actual = nullptr;
bool ok = ctx->get_tyctx ()->lookup_type (
std::vector<tree> ctor_arguments;
if (adt->is_enum ())
{
- HIR::Expr *discrim_expr = variant->get_discriminant ();
+ HIR::Expr &discrim_expr = variant->get_discriminant ();
tree discrim_expr_node = CompileExpr::Compile (discrim_expr, ctx);
tree folded_discrim_expr = fold_expr (discrim_expr_node);
tree qualifier = folded_discrim_expr;
void
CompileExpr::visit (HIR::GroupedExpr &expr)
{
- translated = CompileExpr::Compile (expr.get_expr_in_parens ().get (), ctx);
+ translated = CompileExpr::Compile (expr.get_expr_in_parens (), ctx);
}
void
CompileExpr::visit (HIR::FieldAccessExpr &expr)
{
- HIR::Expr *receiver_expr = expr.get_receiver_expr ().get ();
+ HIR::Expr &receiver_expr = expr.get_receiver_expr ();
tree receiver_ref = CompileExpr::Compile (receiver_expr, ctx);
// resolve the receiver back to ADT type
TyTy::BaseType *receiver = nullptr;
if (!ctx->get_tyctx ()->lookup_type (
- expr.get_receiver_expr ()->get_mappings ().get_hirid (), &receiver))
+ expr.get_receiver_expr ().get_mappings ().get_hirid (), &receiver))
{
- rust_error_at (expr.get_receiver_expr ()->get_locus (),
+ rust_error_at (expr.get_receiver_expr ().get_locus (),
"unresolved type for receiver");
return;
}
ctx->push_loop_begin_label (loop_begin_label);
tree code_block
- = CompileBlock::compile (expr.get_loop_block ().get (), ctx, nullptr);
+ = CompileBlock::compile (expr.get_loop_block (), ctx, nullptr);
tree loop_expr = Backend::loop_expression (code_block, expr.get_locus ());
ctx->add_statement (loop_expr);
}
std::vector<Bvariable *> locals;
- location_t start_location = expr.get_loop_block ()->get_locus ();
- location_t end_location = expr.get_loop_block ()->get_locus (); // FIXME
+ location_t start_location = expr.get_loop_block ().get_locus ();
+ location_t end_location = expr.get_loop_block ().get_locus (); // FIXME
tree enclosing_scope = ctx->peek_enclosing_scope ();
tree loop_block = Backend::block (fnctx.fndecl, enclosing_scope, locals,
ctx->add_statement (loop_begin_label_decl);
ctx->push_loop_begin_label (loop_begin_label);
- tree condition
- = CompileExpr::Compile (expr.get_predicate_expr ().get (), ctx);
+ tree condition = CompileExpr::Compile (expr.get_predicate_expr (), ctx);
tree exit_condition = fold_build1_loc (expr.get_locus (), TRUTH_NOT_EXPR,
boolean_type_node, condition);
tree exit_expr = Backend::exit_expression (exit_condition, expr.get_locus ());
ctx->add_statement (exit_expr);
tree code_block_stmt
- = CompileBlock::compile (expr.get_loop_block ().get (), ctx, nullptr);
+ = CompileBlock::compile (expr.get_loop_block (), ctx, nullptr);
rust_assert (TREE_CODE (code_block_stmt) == BIND_EXPR);
ctx->add_statement (code_block_stmt);
{
if (expr.has_break_expr ())
{
- tree compiled_expr = CompileExpr::Compile (expr.get_expr ().get (), ctx);
+ tree compiled_expr = CompileExpr::Compile (expr.get_expr (), ctx);
Bvariable *loop_result_holder = ctx->peek_loop_context ();
tree result_reference
= Backend::var_expression (loop_result_holder,
- expr.get_expr ()->get_locus ());
+ expr.get_expr ().get_locus ());
tree assignment
= Backend::assignment_statement (result_reference, compiled_expr,
void
CompileExpr::visit (HIR::BorrowExpr &expr)
{
- tree main_expr = CompileExpr::Compile (expr.get_expr ().get (), ctx);
+ tree main_expr = CompileExpr::Compile (expr.get_expr (), ctx);
if (RS_DST_FLAG_P (TREE_TYPE (main_expr)))
{
translated = main_expr;
return;
}
- tree main_expr = CompileExpr::Compile (expr.get_expr ().get (), ctx);
+ tree main_expr = CompileExpr::Compile (expr.get_expr (), ctx);
// this might be an operator overload situation lets check
TyTy::FnType *fntype;
auto lang_item_type = LangItem::Kind::DEREF;
tree operator_overload_call
= resolve_operator_overload (lang_item_type, expr, main_expr, nullptr,
- expr.get_expr ().get (), nullptr);
+ expr.get_expr (), tl::nullopt);
// rust deref always returns a reference from this overload then we can
// actually do the indirection
void
CompileExpr::visit (HIR::AssignmentExpr &expr)
{
- auto lvalue = CompileExpr::Compile (expr.get_lhs ().get (), ctx);
- auto rvalue = CompileExpr::Compile (expr.get_rhs ().get (), ctx);
+ auto lvalue = CompileExpr::Compile (expr.get_lhs (), ctx);
+ auto rvalue = CompileExpr::Compile (expr.get_rhs (), ctx);
// assignments are coercion sites so lets convert the rvalue if necessary
TyTy::BaseType *expected = nullptr;
bool ok;
ok = ctx->get_tyctx ()->lookup_type (
- expr.get_lhs ()->get_mappings ().get_hirid (), &expected);
+ expr.get_lhs ().get_mappings ().get_hirid (), &expected);
rust_assert (ok);
ok = ctx->get_tyctx ()->lookup_type (
- expr.get_rhs ()->get_mappings ().get_hirid (), &actual);
+ expr.get_rhs ().get_mappings ().get_hirid (), &actual);
rust_assert (ok);
rvalue = coercion_site (expr.get_mappings ().get_hirid (), rvalue, actual,
- expected, expr.get_lhs ()->get_locus (),
- expr.get_rhs ()->get_locus ());
+ expected, expr.get_lhs ().get_locus (),
+ expr.get_rhs ().get_locus ());
// rust_debug_loc (expr.get_locus (), "XXXXXX assignment");
// debug_tree (rvalue);
{
TyTy::BaseType *scrutinee_expr_tyty = nullptr;
if (!ctx->get_tyctx ()->lookup_type (
- expr.get_scrutinee_expr ()->get_mappings ().get_hirid (),
+ expr.get_scrutinee_expr ().get_mappings ().get_hirid (),
&scrutinee_expr_tyty))
{
return TyTy::TypeKind::ERROR;
// lets compile the scrutinee expression
tree match_scrutinee_rval
- = CompileExpr::Compile (expr.get_scrutinee_expr ().get (), ctx);
+ = CompileExpr::Compile (expr.get_scrutinee_expr (), ctx);
Bvariable *match_scrutinee_tmp_var
= Backend::temporary_variable (fnctx.fndecl, enclosing_scope,
ctx->add_statement (ret_var_stmt);
tree match_scrutinee_expr = match_scrutinee_tmp_var->get_tree (
- expr.get_scrutinee_expr ()->get_locus ());
+ expr.get_scrutinee_expr ().get_locus ());
tree assignment
= Backend::assignment_statement (match_scrutinee_expr, match_scrutinee_rval,
ctx->push_block (arm_body_block);
// setup the bindings for the block
- CompilePatternBindings::Compile (kase_pattern.get (),
- match_scrutinee_expr, ctx);
+ CompilePatternBindings::Compile (*kase_pattern, match_scrutinee_expr,
+ ctx);
// compile the expr and setup the assignment if required when tmp !=
// NULL
location_t arm_locus = kase_arm.get_locus ();
- tree kase_expr_tree
- = CompileExpr::Compile (kase.get_expr ().get (), ctx);
+ tree kase_expr_tree = CompileExpr::Compile (kase.get_expr (), ctx);
tree result_reference = Backend::var_expression (tmp, arm_locus);
tree assignment
= Backend::assignment_statement (result_reference, kase_expr_tree,
ctx->pop_block ();
tree check_expr
- = CompilePatternCheckExpr::Compile (kase_pattern.get (),
+ = CompilePatternCheckExpr::Compile (*kase_pattern,
match_scrutinee_expr, ctx);
tree check_stmt
{
TyTy::BaseType *tyty = nullptr;
if (!ctx->get_tyctx ()->lookup_type (
- expr.get_fnexpr ()->get_mappings ().get_hirid (), &tyty))
+ expr.get_fnexpr ().get_mappings ().get_hirid (), &tyty))
{
rust_error_at (expr.get_locus (), "unknown type");
return;
{
HirId variant_id;
bool ok = ctx->get_tyctx ()->lookup_variant_definition (
- expr.get_fnexpr ()->get_mappings ().get_hirid (), &variant_id);
+ expr.get_fnexpr ().get_mappings ().get_hirid (), &variant_id);
rust_assert (ok);
ok = adt->lookup_variant_by_id (variant_id, &variant,
for (size_t i = 0; i < expr.get_arguments ().size (); i++)
{
auto &argument = expr.get_arguments ().at (i);
- auto rvalue = CompileExpr::Compile (argument.get (), ctx);
+ auto rvalue = CompileExpr::Compile (*argument, ctx);
// assignments are coercion sites so lets convert the rvalue if
// necessary
std::vector<tree> ctor_arguments;
if (adt->is_enum ())
{
- HIR::Expr *discrim_expr = variant->get_discriminant ();
+ HIR::Expr &discrim_expr = variant->get_discriminant ();
tree discrim_expr_node = CompileExpr::Compile (discrim_expr, ctx);
tree folded_discrim_expr = fold_expr (discrim_expr_node);
tree qualifier = folded_discrim_expr;
}
const TyTy::FnType *fn = static_cast<const TyTy::FnType *> (base);
- auto param = fn->param_at (index);
+ auto ¶m = fn->param_at (index);
*result = param.second;
return true;
};
- auto fn_address = CompileExpr::Compile (expr.get_fnexpr ().get (), ctx);
+ auto fn_address = CompileExpr::Compile (expr.get_fnexpr (), ctx);
// is this a closure call?
bool possible_trait_call
for (size_t i = 0; i < expr.get_arguments ().size (); i++)
{
auto &argument = expr.get_arguments ().at (i);
- auto rvalue = CompileExpr::Compile (argument.get (), ctx);
+ auto rvalue = CompileExpr::Compile (*argument, ctx);
if (is_variadic && i >= required_num_args)
{
CompileExpr::visit (HIR::MethodCallExpr &expr)
{
// method receiver
- tree self = CompileExpr::Compile (expr.get_receiver ().get (), ctx);
+ tree self = CompileExpr::Compile (expr.get_receiver (), ctx);
// lookup the expected function type
TyTy::BaseType *lookup_fntype = nullptr;
// lookup the autoderef mappings
HirId autoderef_mappings_id
- = expr.get_receiver ()->get_mappings ().get_hirid ();
+ = expr.get_receiver ().get_mappings ().get_hirid ();
std::vector<Resolver::Adjustment> *adjustments = nullptr;
ok = ctx->get_tyctx ()->lookup_autoderef_mappings (autoderef_mappings_id,
&adjustments);
// apply adjustments for the fn call
self = resolve_adjustements (*adjustments, self,
- expr.get_receiver ()->get_locus ());
+ expr.get_receiver ().get_locus ());
std::vector<tree> args;
args.push_back (self); // adjusted self
for (size_t i = 0; i < expr.get_arguments ().size (); i++)
{
auto &argument = expr.get_arguments ().at (i);
- auto rvalue = CompileExpr::Compile (argument.get (), ctx);
+ auto rvalue = CompileExpr::Compile (*argument, ctx);
// assignments are coercion sites so lets convert the rvalue if
// necessary, offset from the already adjusted implicit self
tree
CompileExpr::resolve_operator_overload (LangItem::Kind lang_item_type,
HIR::OperatorExprMeta expr, tree lhs,
- tree rhs, HIR::Expr *lhs_expr,
- HIR::Expr *rhs_expr)
+ tree rhs, HIR::Expr &lhs_expr,
+ tl::optional<HIR::Expr &> rhs_expr)
{
TyTy::FnType *fntype;
bool is_op_overload = ctx->get_tyctx ()->lookup_operator_overload (
rust_assert (ok);
// apply adjustments for the fn call
- tree self = resolve_adjustements (*adjustments, lhs, lhs_expr->get_locus ());
+ tree self = resolve_adjustements (*adjustments, lhs, lhs_expr.get_locus ());
std::vector<tree> args;
args.push_back (self); // adjusted self
const TyTy::ArrayType &array_tyty
= static_cast<const TyTy::ArrayType &> (*tyty);
- HIR::ArrayElems &elements = *expr.get_internal_elements ();
+ HIR::ArrayElems &elements = expr.get_internal_elements ();
switch (elements.get_array_expr_type ())
{
case HIR::ArrayElems::ArrayExprType::VALUES: {
size_t i = 0;
for (auto &elem : elems.get_values ())
{
- tree translated_expr = CompileExpr::Compile (elem.get (), ctx);
+ tree translated_expr = CompileExpr::Compile (*elem, ctx);
constructor.push_back (translated_expr);
indexes.push_back (i++);
}
}
ctx->push_const_context ();
- tree capacity_expr
- = CompileExpr::Compile (elems.get_num_copies_expr ().get (), ctx);
+ tree capacity_expr = CompileExpr::Compile (elems.get_num_copies_expr (), ctx);
ctx->pop_const_context ();
if (!TREE_CONSTANT (capacity_expr))
}
// get the compiled value
- tree translated_expr
- = CompileExpr::Compile (elems.get_elem_to_copy ().get (), ctx);
+ tree translated_expr = CompileExpr::Compile (elems.get_elem_to_copy (), ctx);
tree max_domain = TYPE_MAX_VALUE (domain);
tree min_domain = TYPE_MIN_VALUE (domain);
void
CompileExpr::visit (HIR::RangeFromToExpr &expr)
{
- tree from = CompileExpr::Compile (expr.get_from_expr ().get (), ctx);
- tree to = CompileExpr::Compile (expr.get_to_expr ().get (), ctx);
+ tree from = CompileExpr::Compile (expr.get_from_expr (), ctx);
+ tree to = CompileExpr::Compile (expr.get_to_expr (), ctx);
if (from == error_mark_node || to == error_mark_node)
{
translated = error_mark_node;
void
CompileExpr::visit (HIR::RangeFromExpr &expr)
{
- tree from = CompileExpr::Compile (expr.get_from_expr ().get (), ctx);
+ tree from = CompileExpr::Compile (expr.get_from_expr (), ctx);
if (from == error_mark_node)
{
translated = error_mark_node;
void
CompileExpr::visit (HIR::RangeToExpr &expr)
{
- tree to = CompileExpr::Compile (expr.get_to_expr ().get (), ctx);
+ tree to = CompileExpr::Compile (expr.get_to_expr (), ctx);
if (to == error_mark_node)
{
translated = error_mark_node;
void
CompileExpr::visit (HIR::RangeFromToInclExpr &expr)
{
- tree from = CompileExpr::Compile (expr.get_from_expr ().get (), ctx);
- tree to = CompileExpr::Compile (expr.get_to_expr ().get (), ctx);
+ tree from = CompileExpr::Compile (expr.get_from_expr (), ctx);
+ tree to = CompileExpr::Compile (expr.get_to_expr (), ctx);
if (from == error_mark_node || to == error_mark_node)
{
translated = error_mark_node;
void
CompileExpr::visit (HIR::ArrayIndexExpr &expr)
{
- tree array_reference
- = CompileExpr::Compile (expr.get_array_expr ().get (), ctx);
- tree index = CompileExpr::Compile (expr.get_index_expr ().get (), ctx);
+ tree array_reference = CompileExpr::Compile (expr.get_array_expr (), ctx);
+ tree index = CompileExpr::Compile (expr.get_index_expr (), ctx);
// this might be an core::ops::index lang item situation
TyTy::FnType *fntype;
auto lang_item_type = LangItem::Kind::INDEX;
tree operator_overload_call
= resolve_operator_overload (lang_item_type, expr, array_reference,
- index, expr.get_array_expr ().get (),
- expr.get_index_expr ().get ());
+ index, expr.get_array_expr (),
+ expr.get_index_expr ());
tree actual_type = TREE_TYPE (operator_overload_call);
bool can_indirect = TYPE_PTR_P (actual_type) || TYPE_REF_P (actual_type);
// indirection if required
TyTy::BaseType *array_expr_ty = nullptr;
bool ok = ctx->get_tyctx ()->lookup_type (
- expr.get_array_expr ()->get_mappings ().get_hirid (), &array_expr_ty);
+ expr.get_array_expr ().get_mappings ().get_hirid (), &array_expr_ty);
rust_assert (ok);
// do we need to add an indirect reference
= Backend::struct_field_expression (args_param_expr, i,
closure_param.get_locus ());
- CompilePatternBindings::Compile (closure_param.get_pattern ().get (),
+ CompilePatternBindings::Compile (closure_param.get_pattern (),
compiled_param_var, ctx);
i++;
}
}
// lookup locals
- HIR::Expr *function_body = expr.get_expr ().get ();
+ HIR::Expr &function_body = expr.get_expr ();
bool is_block_expr
- = function_body->get_expression_type () == HIR::Expr::ExprType::Block;
+ = function_body.get_expression_type () == HIR::Expr::ExprType::Block;
if (is_block_expr)
{
- auto body_mappings = function_body->get_mappings ();
+ auto body_mappings = function_body.get_mappings ();
if (flag_name_resolution_2_0)
{
auto nr_ctx
}
tree enclosing_scope = NULL_TREE;
- location_t start_location = function_body->get_locus ();
- location_t end_location = function_body->get_locus ();
+ location_t start_location = function_body.get_locus ();
+ location_t end_location = function_body.get_locus ();
if (is_block_expr)
{
- HIR::BlockExpr *body = static_cast<HIR::BlockExpr *> (function_body);
- start_location = body->get_locus ();
- end_location = body->get_end_locus ();
+ auto &body = static_cast<HIR::BlockExpr &> (function_body);
+ start_location = body.get_locus ();
+ end_location = body.get_end_locus ();
}
tree code_block = Backend::block (fndecl, enclosing_scope, {} /*locals*/,
if (is_block_expr)
{
- HIR::BlockExpr *body = static_cast<HIR::BlockExpr *> (function_body);
- compile_function_body (fndecl, *body, tyret);
+ auto &body = static_cast<HIR::BlockExpr &> (function_body);
+ compile_function_body (fndecl, body, tyret);
}
else
{
tree value = CompileExpr::Compile (function_body, ctx);
tree return_expr
- = Backend::return_statement (fndecl, value,
- function_body->get_locus ());
+ = Backend::return_statement (fndecl, value, function_body.get_locus ());
ctx->add_statement (return_expr);
}
}
// need to apply any autoderef's to the self argument
- HIR::Expr *fnexpr = expr.get_fnexpr ().get ();
- HirId autoderef_mappings_id = fnexpr->get_mappings ().get_hirid ();
+ HIR::Expr &fnexpr = expr.get_fnexpr ();
+ HirId autoderef_mappings_id = fnexpr.get_mappings ().get_hirid ();
std::vector<Resolver::Adjustment> *adjustments = nullptr;
bool ok = ctx->get_tyctx ()->lookup_autoderef_mappings (autoderef_mappings_id,
&adjustments);
std::vector<tree> tuple_arg_vals;
for (auto &argument : expr.get_arguments ())
{
- auto rvalue = CompileExpr::Compile (argument.get (), ctx);
+ auto rvalue = CompileExpr::Compile (*argument, ctx);
tuple_arg_vals.push_back (rvalue);
}
class CompileExpr : private HIRCompileBase, protected HIR::HIRExpressionVisitor
{
public:
- static tree Compile (HIR::Expr *expr, Context *ctx);
+ static tree Compile (HIR::Expr &expr, Context *ctx);
void visit (HIR::TupleIndexExpr &expr) override;
void visit (HIR::TupleExpr &expr) override;
tree resolve_operator_overload (LangItem::Kind lang_item_type,
HIR::OperatorExprMeta expr, tree lhs,
- tree rhs, HIR::Expr *lhs_expr,
- HIR::Expr *rhs_expr);
+ tree rhs, HIR::Expr &lhs_expr,
+ tl::optional<HIR::Expr &> rhs_expr);
tree compile_bool_literal (const HIR::LiteralExpr &expr,
const TyTy::BaseType *tyty);
{}
Bvariable *
-CompileFnParam::compile (Context *ctx, tree fndecl, HIR::FunctionParam *param,
+CompileFnParam::compile (Context *ctx, tree fndecl, HIR::FunctionParam ¶m,
tree decl_type, location_t locus)
{
CompileFnParam compiler (ctx, fndecl, decl_type, locus);
- param->get_param_name ()->accept_vis (compiler);
+ param.get_param_name ().accept_vis (compiler);
return compiler.compiled_param;
}
Bvariable *
-CompileFnParam::compile (Context *ctx, tree fndecl, HIR::Pattern *param,
+CompileFnParam::compile (Context *ctx, tree fndecl, HIR::Pattern ¶m,
tree decl_type, location_t locus)
{
CompileFnParam compiler (ctx, fndecl, decl_type, locus);
- param->accept_vis (compiler);
+ param.accept_vis (compiler);
return compiler.compiled_param;
}
CompileFnParam::visit (HIR::StructPattern &pattern)
{
tree tmp_param_var = create_tmp_param_var (decl_type);
- CompilePatternBindings::Compile (&pattern, tmp_param_var, ctx);
+ CompilePatternBindings::Compile (pattern, tmp_param_var, ctx);
}
void
CompileFnParam::visit (HIR::TupleStructPattern &pattern)
{
tree tmp_param_var = create_tmp_param_var (decl_type);
- CompilePatternBindings::Compile (&pattern, tmp_param_var, ctx);
+ CompilePatternBindings::Compile (pattern, tmp_param_var, ctx);
}
void
CompileFnParam::visit (HIR::ReferencePattern &pattern)
{
tree tmp_param_var = create_tmp_param_var (decl_type);
- CompilePatternBindings::Compile (&pattern, tmp_param_var, ctx);
+ CompilePatternBindings::Compile (pattern, tmp_param_var, ctx);
}
Bvariable *
{
public:
static Bvariable *compile (Context *ctx, tree fndecl,
- HIR::FunctionParam *param, tree decl_type,
+ HIR::FunctionParam ¶m, tree decl_type,
location_t locus);
- static Bvariable *compile (Context *ctx, tree fndecl, HIR::Pattern *param,
+ static Bvariable *compile (Context *ctx, tree fndecl, HIR::Pattern ¶m,
tree decl_type, location_t locus);
void visit (HIR::IdentifierPattern &pattern) override;
rust_assert (canonical_path);
- HIR::Expr *const_value_expr = constant.get_expr ().get ();
+ HIR::Expr &const_value_expr = constant.get_expr ();
tree const_expr
= compile_constant_item (resolved_type, *canonical_path, const_value_expr,
constant.get_locus ());
function.get_self (), function.get_function_params (),
function.get_qualifiers (), vis,
func.get_outer_attrs (), func.get_locus (),
- func.get_block_expr ().get (), *canonical_path, fntype);
+ &func.get_block_expr (), *canonical_path, fntype);
reference = address_expression (fndecl, ref_locus);
}
location_t param_locus = referenced_param->get_locus ();
Bvariable *compiled_param_var
- = CompileFnParam::compile (ctx, fndecl, referenced_param,
+ = CompileFnParam::compile (ctx, fndecl, *referenced_param,
compiled_param_type, param_locus);
compiled_param_variables->push_back (compiled_param_var);
rust_assert (canonical_path.has_value ());
- HIR::Expr *const_value_expr = var.get_expr ().get ();
+ HIR::Expr &const_value_expr = var.get_expr ();
ctx->push_const_context ();
tree value = compile_constant_item (resolved_type, *canonical_path,
const_value_expr, var.get_locus ());
.value ();
}
- HIR::Expr *const_value_expr = constant.get_expr ().get ();
+ HIR::Expr &const_value_expr = constant.get_expr ();
ctx->push_const_context ();
tree const_expr
= compile_constant_item (resolved_type, canonical_path, const_value_expr,
function.get_function_params (),
function.get_qualifiers (), function.get_visibility (),
function.get_outer_attrs (), function.get_locus (),
- function.get_definition ().get (), canonical_path,
- fntype);
+ &function.get_definition (), canonical_path, fntype);
reference = address_expression (fndecl, ref_locus);
if (function.get_qualifiers ().is_const ())
{
TyTy::BaseType *self_lookup = nullptr;
if (!ctx->get_tyctx ()->lookup_type (
- impl_block.get_type ()->get_mappings ().get_hirid (), &self_lookup))
+ impl_block.get_type ().get_mappings ().get_hirid (), &self_lookup))
{
rust_error_at (impl_block.get_locus (), "failed to resolve type of impl");
return;
// must be enum
match_scrutinee_expr = scrutinee_expr_qualifier_expr;
- HIR::Expr *discrim_expr = variant->get_discriminant ();
+ HIR::Expr &discrim_expr = variant->get_discriminant ();
tree discrim_expr_node = CompileExpr::Compile (discrim_expr, ctx);
check_expr
CompilePatternCheckExpr::visit (HIR::LiteralPattern &pattern)
{
// Compile the literal
- HIR::LiteralExpr *litexpr
- = new HIR::LiteralExpr (pattern.get_mappings (), pattern.get_literal (),
- pattern.get_locus (),
- std::vector<AST::Attribute> ());
+ auto litexpr = Rust::make_unique<HIR::LiteralExpr> (
+ HIR::LiteralExpr (pattern.get_mappings (), pattern.get_literal (),
+ pattern.get_locus (), std::vector<AST::Attribute> ()));
// Note: Floating point literals are currently accepted but will likely be
// forbidden in LiteralPatterns in a future version of Rust.
rust_sorry_at (pattern.get_locus (), "floating-point literal in pattern");
}
- tree lit = CompileExpr::Compile (litexpr, ctx);
+ tree lit = CompileExpr::Compile (*litexpr, ctx);
check_expr = Backend::comparison_expression (ComparisonOperator::EQUAL,
match_scrutinee_expr, lit,
}
static tree
-compile_range_pattern_bound (HIR::RangePatternBound *bound,
+compile_range_pattern_bound (HIR::RangePatternBound &bound,
Analysis::NodeMapping mappings, location_t locus,
Context *ctx)
{
tree result = NULL_TREE;
- switch (bound->get_bound_type ())
+ switch (bound.get_bound_type ())
{
case HIR::RangePatternBound::RangePatternBoundType::LITERAL: {
- HIR::RangePatternBoundLiteral &ref
- = *static_cast<HIR::RangePatternBoundLiteral *> (bound);
+ auto &ref = static_cast<HIR::RangePatternBoundLiteral &> (bound);
- HIR::LiteralExpr *litexpr
- = new HIR::LiteralExpr (mappings, ref.get_literal (), locus,
+ HIR::LiteralExpr litexpr (mappings, ref.get_literal (), locus,
std::vector<AST::Attribute> ());
result = CompileExpr::Compile (litexpr, ctx);
break;
case HIR::RangePatternBound::RangePatternBoundType::PATH: {
- HIR::RangePatternBoundPath &ref
- = *static_cast<HIR::RangePatternBoundPath *> (bound);
+ auto &ref = static_cast<HIR::RangePatternBoundPath &> (bound);
result = ResolvePathRef::Compile (ref.get_path (), ctx);
break;
case HIR::RangePatternBound::RangePatternBoundType::QUALPATH: {
- HIR::RangePatternBoundQualPath &ref
- = *static_cast<HIR::RangePatternBoundQualPath *> (bound);
+ auto &ref = static_cast<HIR::RangePatternBoundQualPath &> (bound);
result = ResolvePathRef::Compile (ref.get_qualified_path (), ctx);
void
CompilePatternCheckExpr::visit (HIR::RangePattern &pattern)
{
- tree upper = compile_range_pattern_bound (pattern.get_upper_bound ().get (),
+ tree upper = compile_range_pattern_bound (pattern.get_upper_bound (),
pattern.get_mappings (),
pattern.get_locus (), ctx);
- tree lower = compile_range_pattern_bound (pattern.get_lower_bound ().get (),
+ tree lower = compile_range_pattern_bound (pattern.get_lower_bound (),
pattern.get_mappings (),
pattern.get_locus (), ctx);
{
match_scrutinee_expr
= indirect_expression (match_scrutinee_expr, pattern.get_locus ());
- pattern.get_referenced_pattern ()->accept_vis (*this);
+ pattern.get_referenced_pattern ().accept_vis (*this);
}
void
{
auto &alts = pattern.get_alts ();
- check_expr = CompilePatternCheckExpr::Compile (alts.at (0).get (),
+ check_expr = CompilePatternCheckExpr::Compile (*alts.at (0),
match_scrutinee_expr, ctx);
auto end = alts.end ();
for (auto i = alts.begin () + 1; i != end; i++)
{
tree next_expr
- = CompilePatternCheckExpr::Compile (i->get (), match_scrutinee_expr,
- ctx);
+ = CompilePatternCheckExpr::Compile (**i, match_scrutinee_expr, ctx);
check_expr = Backend::arithmetic_or_logical_expression (
ArithmeticOrLogicalOperator::BITWISE_OR, check_expr, next_expr,
(*i)->get_locus ());
// // would be DECL_QUALIFIER i think. For now this will just access the
// // first record field and its respective qualifier because it will
// // always be set because this is all a big special union
- HIR::Expr *discrim_expr = variant->get_discriminant ();
+ HIR::Expr &discrim_expr = variant->get_discriminant ();
tree discrim_expr_node = CompileExpr::Compile (discrim_expr, ctx);
// find discriminant field of scrutinee
ident.get_locus ());
tree check_expr_sub
- = CompilePatternCheckExpr::Compile (ident.get_pattern ().get (),
+ = CompilePatternCheckExpr::Compile (ident.get_pattern (),
field_expr, ctx);
check_expr = Backend::arithmetic_or_logical_expression (
ArithmeticOrLogicalOperator::BITWISE_AND, check_expr,
- check_expr_sub, ident.get_pattern ()->get_locus ());
+ check_expr_sub, ident.get_pattern ().get_locus ());
}
break;
rust_assert (ok);
// find expected discriminant
- HIR::Expr *discrim_expr = variant->get_discriminant ();
+ HIR::Expr &discrim_expr = variant->get_discriminant ();
tree discrim_expr_node = CompileExpr::Compile (discrim_expr, ctx);
// find discriminant field of scrutinee
tuple_field_index = 0;
}
- std::unique_ptr<HIR::TupleStructItems> &items = pattern.get_items ();
- switch (items->get_item_type ())
+ HIR::TupleStructItems &items = pattern.get_items ();
+ switch (items.get_item_type ())
{
case HIR::TupleStructItems::RANGED: {
// TODO
case HIR::TupleStructItems::MULTIPLE: {
HIR::TupleStructItemsNoRange &items_no_range
- = static_cast<HIR::TupleStructItemsNoRange &> (*items.get ());
+ = static_cast<HIR::TupleStructItemsNoRange &> (items);
rust_assert (items_no_range.get_patterns ().size ()
== variant->num_fields ());
pattern->get_locus ());
tree check_expr_sub
- = CompilePatternCheckExpr::Compile (pattern.get (), field_expr,
- ctx);
+ = CompilePatternCheckExpr::Compile (*pattern, field_expr, ctx);
check_expr = Backend::arithmetic_or_logical_expression (
ArithmeticOrLogicalOperator::BITWISE_AND, check_expr,
check_expr_sub, pattern->get_locus ());
{
check_expr = boolean_true_node;
- switch (pattern.get_items ()->get_item_type ())
+ switch (pattern.get_items ().get_item_type ())
{
case HIR::TuplePatternItems::RANGED: {
// TODO
case HIR::TuplePatternItems::MULTIPLE: {
auto &items = static_cast<HIR::TuplePatternItemsMultiple &> (
- *pattern.get_items ());
+ pattern.get_items ());
size_t tuple_field_index = 0;
for (auto &pat : items.get_patterns ())
pat->get_locus ());
tree check_expr_sub
- = CompilePatternCheckExpr::Compile (pat.get (), field_expr, ctx);
+ = CompilePatternCheckExpr::Compile (*pat, field_expr, ctx);
check_expr = Backend::arithmetic_or_logical_expression (
ArithmeticOrLogicalOperator::BITWISE_AND, check_expr,
check_expr_sub, pat->get_locus ());
rust_assert (variant->get_variant_type ()
== TyTy::VariantDef::VariantType::TUPLE);
- std::unique_ptr<HIR::TupleStructItems> &items = pattern.get_items ();
- switch (items->get_item_type ())
+ HIR::TupleStructItems &items = pattern.get_items ();
+ switch (items.get_item_type ())
{
case HIR::TupleStructItems::RANGED: {
// TODO
case HIR::TupleStructItems::MULTIPLE: {
HIR::TupleStructItemsNoRange &items_no_range
- = static_cast<HIR::TupleStructItemsNoRange &> (*items.get ());
+ = static_cast<HIR::TupleStructItemsNoRange &> (items);
rust_assert (items_no_range.get_patterns ().size ()
== variant->num_fields ());
tree derefed
= indirect_expression (match_scrutinee_expr, pattern.get_locus ());
- CompilePatternBindings::Compile (pattern.get_referenced_pattern ().get (),
- derefed, ctx);
+ CompilePatternBindings::Compile (pattern.get_referenced_pattern (), derefed,
+ ctx);
}
void
tree access_expr = Backend::var_expression (tmp_var, pattern.get_locus ());
ctx->add_statement (init_stmt);
- switch (pattern.get_items ()->get_item_type ())
+ switch (pattern.get_items ().get_item_type ())
{
case HIR::TuplePatternItems::ItemType::RANGED: {
size_t tuple_idx = 0;
auto &items
- = static_cast<HIR::TuplePatternItemsRanged &> (*pattern.get_items ());
+ = static_cast<HIR::TuplePatternItemsRanged &> (pattern.get_items ());
auto &items_lower = items.get_lower_patterns ();
auto &items_upper = items.get_upper_patterns ();
case HIR::TuplePatternItems::ItemType::MULTIPLE: {
size_t tuple_idx = 0;
auto &items = static_cast<HIR::TuplePatternItemsMultiple &> (
- *pattern.get_items ());
+ pattern.get_items ());
for (auto &sub : items.get_patterns ())
{
public HIR::HIRPatternVisitor
{
public:
- static tree Compile (HIR::Pattern *pattern, tree match_scrutinee_expr,
+ static tree Compile (HIR::Pattern &pattern, tree match_scrutinee_expr,
Context *ctx)
{
CompilePatternCheckExpr compiler (ctx, match_scrutinee_expr);
- pattern->accept_vis (compiler);
+ pattern.accept_vis (compiler);
rust_assert (compiler.check_expr);
return compiler.check_expr;
}
public HIR::HIRPatternVisitor
{
public:
- static void Compile (HIR::Pattern *pattern, tree match_scrutinee_expr,
+ static void Compile (HIR::Pattern &pattern, tree match_scrutinee_expr,
Context *ctx)
{
CompilePatternBindings compiler (ctx, match_scrutinee_expr);
- pattern->accept_vis (compiler);
+ pattern.accept_vis (compiler);
}
void visit (HIR::StructPattern &pattern) override;
tree compiled_adt_type = TyTyResolveCompile::compile (ctx, adt);
// make the ctor for the union
- HIR::Expr *discrim_expr = variant->get_discriminant ();
+ HIR::Expr &discrim_expr = variant->get_discriminant ();
tree discrim_expr_node = CompileExpr::Compile (discrim_expr, ctx);
tree folded_discrim_expr = fold_expr (discrim_expr_node);
tree qualifier = folded_discrim_expr;
TyTy::BaseType *self = nullptr;
bool ok = ctx->get_tyctx ()->lookup_type (
- impl->get_type ()->get_mappings ().get_hirid (), &self);
+ impl->get_type ().get_mappings ().get_hirid (), &self);
rust_assert (ok);
if (!lookup->has_substitutions_defined ())
void
CompileStmt::visit (HIR::ExprStmt &stmt)
{
- translated = CompileExpr::Compile (stmt.get_expr ().get (), ctx);
+ translated = CompileExpr::Compile (stmt.get_expr (), ctx);
}
void
CompileStmt::visit (HIR::LetStmt &stmt)
{
- HIR::Pattern &stmt_pattern = *stmt.get_pattern ();
+ HIR::Pattern &stmt_pattern = stmt.get_pattern ();
HirId stmt_id = stmt_pattern.get_mappings ().get_hirid ();
TyTy::BaseType *ty = nullptr;
if (!stmt.has_init_expr ())
return;
- tree init = CompileExpr::Compile (stmt.get_init_expr ().get (), ctx);
+ 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
if (init == nullptr)
TyTy::BaseType *actual = nullptr;
bool ok = ctx->get_tyctx ()->lookup_type (
- stmt.get_init_expr ()->get_mappings ().get_hirid (), &actual);
+ stmt.get_init_expr ().get_mappings ().get_hirid (), &actual);
rust_assert (ok);
- location_t lvalue_locus = stmt.get_pattern ()->get_locus ();
- location_t rvalue_locus = stmt.get_init_expr ()->get_locus ();
+ location_t lvalue_locus = stmt.get_pattern ().get_locus ();
+ location_t rvalue_locus = stmt.get_init_expr ().get_locus ();
TyTy::BaseType *expected = ty;
init = coercion_site (stmt.get_mappings ().get_hirid (), init, actual,
expected, lvalue_locus, rvalue_locus);
{}
tree
-CompileStructExprField::Compile (HIR::StructExprField *field, Context *ctx)
+CompileStructExprField::Compile (HIR::StructExprField &field, Context *ctx)
{
CompileStructExprField compiler (ctx);
- switch (field->get_kind ())
+ switch (field.get_kind ())
{
case HIR::StructExprField::StructExprFieldKind::IDENTIFIER:
- compiler.visit (static_cast<HIR::StructExprFieldIdentifier &> (*field));
+ compiler.visit (static_cast<HIR::StructExprFieldIdentifier &> (field));
break;
case HIR::StructExprField::StructExprFieldKind::IDENTIFIER_VALUE:
compiler.visit (
- static_cast<HIR::StructExprFieldIdentifierValue &> (*field));
+ static_cast<HIR::StructExprFieldIdentifierValue &> (field));
break;
case HIR::StructExprField::StructExprFieldKind::INDEX_VALUE:
- compiler.visit (static_cast<HIR::StructExprFieldIndexValue &> (*field));
+ compiler.visit (static_cast<HIR::StructExprFieldIndexValue &> (field));
break;
}
return compiler.translated;
void
CompileStructExprField::visit (HIR::StructExprFieldIdentifierValue &field)
{
- translated = CompileExpr::Compile (field.get_value ().get (), ctx);
+ translated = CompileExpr::Compile (field.get_value (), ctx);
}
void
CompileStructExprField::visit (HIR::StructExprFieldIndexValue &field)
{
- translated = CompileExpr::Compile (field.get_value ().get (), ctx);
+ translated = CompileExpr::Compile (field.get_value (), ctx);
}
void
HIR::GenericArgs::create_empty ());
HIR::PathInExpression expr (mappings_copy2, {seg}, field.get_locus (), false,
{});
- translated = CompileExpr::Compile (&expr, ctx);
+ translated = CompileExpr::Compile (expr, ctx);
}
} // namespace Compile
class CompileStructExprField : private HIRCompileBase
{
public:
- static tree Compile (HIR::StructExprField *field, Context *ctx);
+ static tree Compile (HIR::StructExprField &field, Context *ctx);
protected:
void visit (HIR::StructExprFieldIdentifierValue &field);
= TyTyResolveCompile::compile (ctx, type.get_element_type ());
ctx->push_const_context ();
- tree capacity_expr = CompileExpr::Compile (&type.get_capacity_expr (), ctx);
+ tree capacity_expr = CompileExpr::Compile (type.get_capacity_expr (), ctx);
ctx->pop_const_context ();
tree folded_capacity_expr = fold_expr (capacity_expr);
void visit (HIR::TuplePattern &pattern) override
{
- switch (pattern.get_items ()->get_item_type ())
+ switch (pattern.get_items ().get_item_type ())
{
case HIR::TuplePatternItems::ItemType::MULTIPLE: {
rust_assert (TREE_CODE (translated_type) == RECORD_TYPE);
auto &items = static_cast<HIR::TuplePatternItemsMultiple &> (
- *pattern.get_items ());
+ pattern.get_items ());
size_t offs = 0;
for (auto &sub : items.get_patterns ())
HIR::ImplBlock *impl_block = item.second;
rust_assert (impl_block != nullptr);
- // Lookup type for potentially associated impl.
- std::unique_ptr<HIR::Type> &self_type_path = impl_block->get_type ();
-
// Checks for empty impl blocks, triggered by Sized trait.
- if (self_type_path == nullptr)
+ if (!impl_block->has_type ())
continue;
+ // Lookup type for potentially associated impl.
+ HIR::Type &self_type_path = impl_block->get_type ();
+
// Convert HIR::Type to TyTy::BaseType
TyTy::BaseType *self = nullptr;
bool ok = ctx->get_tyctx ()->lookup_type (
- self_type_path->get_mappings ().get_hirid (), &self);
+ self_type_path.get_mappings ().get_hirid (), &self);
rust_assert (ok);
// lookup impl type
TyTy::BaseType *impl_ty = nullptr;
ok = ctx->get_tyctx ()->lookup_type (
- impl_block->get_type ()->get_mappings ().get_hirid (), &impl_ty);
+ impl_block->get_type ().get_mappings ().get_hirid (), &impl_ty);
rust_assert (ok);
// FIXME: dummy value for now
TyTy::BaseType *trait_ty = nullptr;
ok = ctx->get_tyctx ()->lookup_type (
- impl_block->get_trait_ref ()->get_mappings ().get_hirid (), &trait_ty);
+ impl_block->get_trait_ref ().get_mappings ().get_hirid (), &trait_ty);
rust_assert (ok);
v0path.trait_type = v0_type_prefix (ctx, trait_ty);
void
ExprStmtBuilder::visit (HIR::BorrowExpr &expr)
{
- auto operand = visit_expr (*expr.get_expr ());
+ auto operand = visit_expr (expr.get_expr ());
if (ctx.place_db[operand].is_constant ())
{
// Cannot borrow a constant, must create a temporary copy.
void
ExprStmtBuilder::visit (HIR::DereferenceExpr &expr)
{
- auto operand = visit_expr (*expr.get_expr ());
+ auto operand = visit_expr (expr.get_expr ());
return_place (ctx.place_db.lookup_or_add_path (Place::DEREF,
lookup_type (expr), operand),
expr.get_locus ());
void
ExprStmtBuilder::visit (HIR::NegationExpr &expr)
{
- PlaceId operand = visit_expr (*expr.get_expr ());
- return_expr (new Operator<1> ({move_place (operand, expr.get_locus ())}),
+ PlaceId operand = visit_expr (expr.get_expr ());
+ return_expr (new Operator<1> (
+ {move_place (operand, expr.get_expr ().get_locus ())}),
lookup_type (expr), expr.get_locus ());
}
void
ExprStmtBuilder::visit (HIR::ArithmeticOrLogicalExpr &expr)
{
- PlaceId lhs = visit_expr (*expr.get_lhs ());
- PlaceId rhs = visit_expr (*expr.get_rhs ());
+ PlaceId lhs = visit_expr (expr.get_lhs ());
+ PlaceId rhs = visit_expr (expr.get_rhs ());
return_expr (new Operator<2> (
- {move_place (lhs, expr.get_lhs ()->get_locus ()),
- move_place (rhs, expr.get_rhs ()->get_locus ())}),
+ {move_place (lhs, expr.get_lhs ().get_locus ()),
+ move_place (rhs, expr.get_rhs ().get_locus ())}),
lookup_type (expr), expr.get_locus ());
}
void
ExprStmtBuilder::visit (HIR::ComparisonExpr &expr)
{
- PlaceId lhs = visit_expr (*expr.get_lhs ());
- PlaceId rhs = visit_expr (*expr.get_rhs ());
+ PlaceId lhs = visit_expr (expr.get_lhs ());
+ PlaceId rhs = visit_expr (expr.get_rhs ());
return_expr (new Operator<2> (
- {move_place (lhs, expr.get_lhs ()->get_locus ()),
- move_place (rhs, expr.get_rhs ()->get_locus ())}),
+ {move_place (lhs, expr.get_lhs ().get_locus ()),
+ move_place (rhs, expr.get_rhs ().get_locus ())}),
lookup_type (expr), expr.get_locus ());
}
void
ExprStmtBuilder::visit (HIR::TypeCastExpr &expr)
{
- auto operand = visit_expr (*expr.get_expr ());
+ auto operand = visit_expr (expr.get_expr ());
return_expr (new Operator<1> ({operand}), lookup_type (expr),
expr.get_locus ());
}
void
ExprStmtBuilder::visit (HIR::AssignmentExpr &expr)
{
- auto lhs = visit_expr (*expr.get_lhs ());
- auto rhs = visit_expr (*expr.get_rhs ());
+ auto lhs = visit_expr (expr.get_lhs ());
+ auto rhs = visit_expr (expr.get_rhs ());
push_assignment (lhs, rhs, expr.get_locus ());
translated = INVALID_PLACE;
}
void
ExprStmtBuilder::visit (HIR::CompoundAssignmentExpr &expr)
{
- auto lhs = visit_expr (*expr.get_lhs ());
- auto rhs = visit_expr (*expr.get_rhs ());
+ auto lhs = visit_expr (expr.get_lhs ());
+ auto rhs = visit_expr (expr.get_rhs ());
push_assignment (lhs, new Operator<2> ({lhs, rhs}), expr.get_locus ());
}
void
ExprStmtBuilder::visit (HIR::GroupedExpr &expr)
{
- return_place (visit_expr (*expr.get_expr_in_parens ()), expr.get_locus ());
+ return_place (visit_expr (expr.get_expr_in_parens ()), expr.get_locus ());
}
void
ExprStmtBuilder::visit (HIR::ArrayExpr &expr)
{
auto &elems = expr.get_internal_elements ();
- switch (elems->get_array_expr_type ())
+ switch (elems.get_array_expr_type ())
{
case HIR::ArrayElems::VALUES: {
- auto &elem_vals = (static_cast<HIR::ArrayElemsValues &> (*elems));
+ auto &elem_vals = (static_cast<HIR::ArrayElemsValues &> (elems));
auto init_values = visit_list (elem_vals.get_values ());
// collect locations
std::vector<location_t> value_locations;
break;
}
case HIR::ArrayElems::COPIED: {
- auto &elem_copied = (static_cast<HIR::ArrayElemsCopied &> (*elems));
- auto init = visit_expr (*elem_copied.get_elem_to_copy ());
+ auto &elem_copied = (static_cast<HIR::ArrayElemsCopied &> (elems));
+ auto init = visit_expr (elem_copied.get_elem_to_copy ());
return_expr (new InitializerExpr ({init}), lookup_type (expr),
expr.get_locus ());
break;
void
ExprStmtBuilder::visit (HIR::ArrayIndexExpr &expr)
{
- auto lhs = visit_expr (*expr.get_array_expr ());
- auto rhs = visit_expr (*expr.get_index_expr ());
+ auto lhs = visit_expr (expr.get_array_expr ());
+ auto rhs = visit_expr (expr.get_index_expr ());
// The index is not tracked in BIR.
std::ignore = rhs;
return_place (ctx.place_db.lookup_or_add_path (Place::INDEX,
void
ExprStmtBuilder::visit (HIR::TupleIndexExpr &expr)
{
- auto tuple = visit_expr (*expr.get_tuple_expr ());
+ auto tuple = visit_expr (expr.get_tuple_expr ());
return_place (ctx.place_db.lookup_or_add_path (Place::FIELD,
lookup_type (expr), tuple,
expr.get_tuple_index ()),
void
ExprStmtBuilder::visit (HIR::CallExpr &expr)
{
- PlaceId fn = visit_expr (*expr.get_fnexpr ());
+ PlaceId fn = visit_expr (expr.get_fnexpr ());
std::vector<PlaceId> arguments = visit_list (expr.get_arguments ());
const auto fn_type
void
ExprStmtBuilder::visit (HIR::FieldAccessExpr &expr)
{
- auto receiver = visit_expr (*expr.get_receiver_expr ());
+ auto receiver = visit_expr (expr.get_receiver_expr ());
auto type = autoderef (receiver);
rust_assert (type->get_kind () == TyTy::ADT);
auto adt = type->as<TyTy::ADTType> ();
if (block.has_expr () && !unreachable)
{
push_assignment (block_ctx.label_var,
- visit_expr (*block.get_final_expr ()),
+ visit_expr (block.get_final_expr ()),
block.get_start_locus ());
}
if (!ctx.get_current_bb ().is_terminated ())
}
else if (block.has_expr () && !unreachable)
{
- return_place (visit_expr (*block.get_final_expr (),
+ return_place (visit_expr (block.get_final_expr (),
take_or_create_return_place (
- lookup_type (*block.get_final_expr ()))),
+ lookup_type (block.get_final_expr ()))),
block.get_start_locus ());
}
LoopAndLabelCtx info = brk.has_label () ? get_label_ctx (brk.get_label ())
: get_unnamed_loop_ctx ();
if (brk.has_break_expr ())
- push_assignment (info.label_var, visit_expr (*brk.get_expr ()),
+ push_assignment (info.label_var, visit_expr (brk.get_expr ()),
brk.get_locus ());
start_new_consecutive_bb ();
void
ExprStmtBuilder::visit (HIR::RangeFromToExpr &range)
{
- auto from = visit_expr (*range.get_from_expr ());
- auto to = visit_expr (*range.get_to_expr ());
+ auto from = visit_expr (range.get_from_expr ());
+ auto to = visit_expr (range.get_to_expr ());
return_expr (new InitializerExpr ({from, to}), lookup_type (range),
range.get_locus ());
}
void
ExprStmtBuilder::visit (HIR::RangeFromExpr &expr)
{
- auto from = visit_expr (*expr.get_from_expr ());
+ auto from = visit_expr (expr.get_from_expr ());
return_expr (new InitializerExpr ({from}), lookup_type (expr),
expr.get_locus ());
}
void
ExprStmtBuilder::visit (HIR::RangeToExpr &expr)
{
- auto to = visit_expr (*expr.get_to_expr ());
+ auto to = visit_expr (expr.get_to_expr ());
return_expr (new InitializerExpr ({to}), lookup_type (expr),
expr.get_locus ());
}
void
ExprStmtBuilder::visit (HIR::RangeFromToInclExpr &expr)
{
- auto from = visit_expr (*expr.get_from_expr ());
- auto to = visit_expr (*expr.get_to_expr ());
+ auto from = visit_expr (expr.get_from_expr ());
+ auto to = visit_expr (expr.get_to_expr ());
return_expr (new InitializerExpr ({from, to}), lookup_type (expr),
expr.get_locus ());
}
void
ExprStmtBuilder::visit (HIR::RangeToInclExpr &expr)
{
- auto to = visit_expr (*expr.get_to_expr ());
+ auto to = visit_expr (expr.get_to_expr ());
return_expr (new InitializerExpr ({to}), lookup_type (expr),
expr.get_locus ());
}
if (ret.has_return_expr ())
{
push_assignment (RETURN_VALUE_PLACE,
- move_place (visit_expr (*ret.get_expr ()),
- ret.get_expr ()->get_locus ()),
- ret.get_expr ()->get_locus ());
+ move_place (visit_expr (ret.get_expr ()),
+ ret.get_expr ().get_locus ()),
+ ret.get_expr ().get_locus ());
}
unwind_until (ROOT_SCOPE);
push_return (ret.get_locus ());
{
auto loop = setup_loop (expr);
- std::ignore = visit_expr (*expr.get_loop_block ());
+ std::ignore = visit_expr (expr.get_loop_block ());
if (!ctx.get_current_bb ().is_terminated ())
push_goto (loop.continue_bb);
{
auto loop = setup_loop (expr);
- auto cond_val = visit_expr (*expr.get_predicate_expr ());
+ auto cond_val = visit_expr (expr.get_predicate_expr ());
auto body_bb = new_bb ();
push_switch (cond_val, expr.get_locus (), {body_bb, loop.break_bb});
ctx.current_bb = body_bb;
- std::ignore = visit_expr (*expr.get_loop_block ());
+ std::ignore = visit_expr (expr.get_loop_block ());
push_goto (loop.continue_bb);
ctx.current_bb = loop.break_bb;
{
// If without else cannot return a non-unit value (see [E0317]).
- if (expr.get_if_block ()->statements.empty ())
+ if (expr.get_if_block ().statements.empty ())
return;
- push_switch (visit_expr (*expr.get_if_condition ()), expr.get_locus ());
+ push_switch (visit_expr (expr.get_if_condition ()), expr.get_locus ());
BasicBlockId if_block = ctx.current_bb;
ctx.current_bb = new_bb ();
BasicBlockId then_start_block = ctx.current_bb;
- std::ignore = visit_expr (*expr.get_if_block ());
+ std::ignore = visit_expr (expr.get_if_block ());
if (!ctx.get_current_bb ().is_terminated ())
push_goto (INVALID_BB); // Resolved later.
BasicBlockId then_end_block = ctx.current_bb;
void
ExprStmtBuilder::visit (HIR::IfExprConseqElse &expr)
{
- push_switch (move_place (visit_expr (*expr.get_if_condition ()),
- expr.get_if_condition ()->get_locus ()),
+ push_switch (move_place (visit_expr (expr.get_if_condition ()),
+ expr.get_if_condition ().get_locus ()),
expr.get_locus ());
BasicBlockId if_end_bb = ctx.current_bb;
ctx.current_bb = new_bb ();
BasicBlockId then_start_bb = ctx.current_bb;
- std::ignore = visit_expr (*expr.get_if_block (), result);
+ std::ignore = visit_expr (expr.get_if_block (), result);
if (!ctx.get_current_bb ().is_terminated ())
push_goto (INVALID_BB); // Resolved later.
BasicBlockId then_end_bb = ctx.current_bb;
ctx.current_bb = new_bb ();
BasicBlockId else_start_bb = ctx.current_bb;
- std::ignore = visit_expr (*expr.get_else_block (), result);
+ std::ignore = visit_expr (expr.get_else_block (), result);
if (!ctx.get_current_bb ().is_terminated ())
push_goto (INVALID_BB); // Resolved later.
BasicBlockId else_end_bb = ctx.current_bb;
tl::optional<TyTy::BaseType *> type_annotation;
if (stmt.has_type ())
- type_annotation = lookup_type (*stmt.get_type ());
+ type_annotation = lookup_type (stmt.get_type ());
- if (stmt.get_pattern ()->get_pattern_type () == HIR::Pattern::IDENTIFIER)
+ if (stmt.get_pattern ().get_pattern_type () == HIR::Pattern::IDENTIFIER)
{
// Only if a pattern is just an identifier, no destructuring is needed.
// Hoverer PatternBindingBuilder cannot change existing temporary
// (init expr is evaluated before pattern binding) into a
// variable, so it would emit extra assignment.
- auto var = declare_variable (stmt.get_pattern ()->get_mappings ());
+ auto var = declare_variable (stmt.get_pattern ().get_mappings ());
if (stmt.has_type ())
- push_user_type_ascription (var, lookup_type (*stmt.get_type ()));
+ push_user_type_ascription (var, lookup_type (stmt.get_type ()));
if (stmt.has_init_expr ())
- std::ignore = visit_expr (*stmt.get_init_expr (), var);
+ std::ignore = visit_expr (stmt.get_init_expr (), var);
}
else
{
if (stmt.has_init_expr ())
- init = visit_expr (*stmt.get_init_expr ());
+ init = visit_expr (stmt.get_init_expr ());
PatternBindingBuilder (ctx, init, type_annotation)
- .go (*stmt.get_pattern ());
+ .go (stmt.get_pattern ());
}
}
void
ExprStmtBuilder::visit (HIR::ExprStmt &stmt)
{
- PlaceId result = visit_expr (*stmt.get_expr ());
+ PlaceId result = visit_expr (stmt.get_expr ());
// We must read the value for current liveness and we must not store it into
// the same place.
if (result != INVALID_PLACE)
protected:
void visit (HIR::LazyBooleanExpr &expr) override
{
- auto lhs = visit_expr (*expr.get_lhs ());
- push_switch (move_place (lhs, expr.get_lhs ()->get_locus ()),
+ auto lhs = visit_expr (expr.get_lhs ());
+ push_switch (move_place (lhs, expr.get_lhs ().get_locus ()),
expr.get_locus (), {short_circuit_bb});
start_new_consecutive_bb ();
- return_place (visit_expr (*expr.get_rhs ()), expr.get_locus ());
+ return_place (visit_expr (expr.get_rhs ()), expr.get_locus ());
}
void visit (HIR::GroupedExpr &expr) override
{
- expr.get_expr_in_parens ()->accept_vis (*this);
+ expr.get_expr_in_parens ().accept_vis (*this);
}
protected:
return ty->as<TyTy::ReferenceType> ()->get_base ();
});
- pattern.get_referenced_pattern ()->accept_vis (*this);
+ pattern.get_referenced_pattern ().accept_vis (*this);
}
void
init = init.map ([&] (PlaceId id) {
return ctx.place_db.lookup_or_add_path (
- Place::FIELD, lookup_type (*tuple->get_tuple_pattern ()), id,
+ Place::FIELD, lookup_type (tuple->get_tuple_pattern ()), id,
tuple->get_index ());
});
->get_field_type ();
});
- tuple->get_tuple_pattern ()->accept_vis (*this);
+ tuple->get_tuple_pattern ().accept_vis (*this);
break;
}
case HIR::StructPatternField::IDENT_PAT: {
field_ty->get_field_type (),
saved.init.value (),
field_index);
- ident_field->get_pattern ()->accept_vis (*this);
+ ident_field->get_pattern ().accept_vis (*this);
break;
}
case HIR::StructPatternField::IDENT: {
SavedState saved (this);
size_t index = 0;
- switch (pattern.get_items ()->get_item_type ())
+ switch (pattern.get_items ().get_item_type ())
{
case HIR::TuplePatternItems::MULTIPLE: {
auto &items = static_cast<HIR::TuplePatternItemsMultiple &> (
- *pattern.get_items ());
+ pattern.get_items ());
visit_tuple_fields (items.get_patterns (), saved, index);
break;
}
case HIR::TuplePatternItems::RANGED: {
auto &items
- = static_cast<HIR::TuplePatternItemsRanged &> (*pattern.get_items ());
+ = static_cast<HIR::TuplePatternItemsRanged &> (pattern.get_items ());
auto tyty = ctx.place_db[init.value ()].tyty;
rust_assert (tyty->get_kind () == TyTy::TUPLE);
});
size_t index = 0;
- switch (pattern.get_items ()->get_item_type ())
+ switch (pattern.get_items ().get_item_type ())
{
case HIR::TupleStructItems::RANGED: {
auto &items
- = static_cast<HIR::TupleStructItemsRange &> (*pattern.get_items ());
+ = static_cast<HIR::TupleStructItemsRange &> (pattern.get_items ());
rust_assert (type->get_kind () == TyTy::ADT);
auto adt_ty = static_cast<TyTy::ADTType *> (type);
}
case HIR::TupleStructItems::MULTIPLE: {
auto &items
- = static_cast<HIR::TupleStructItemsNoRange &> (*pattern.get_items ());
+ = static_cast<HIR::TupleStructItemsNoRange &> (pattern.get_items ());
visit_tuple_fields (items.get_patterns (), saved, index);
break;
}
void visit (HIR::QualifiedPathInExpression &expression) override {}
void visit (HIR::RangePattern &pattern) override {}
};
+
} // namespace BIR
} // namespace Rust
}
void visit (HIR::StructExprFieldIdentifierValue &field) override
{
- auto value = ExprStmtBuilder (ctx).build (*field.get_value ());
+ auto value = ExprStmtBuilder (ctx).build (field.get_value ());
handle_named_field (field, value);
}
void visit (HIR::StructExprFieldIndexValue &field) override
{
- auto value = ExprStmtBuilder (ctx).build (*field.get_value ());
+ auto value = ExprStmtBuilder (ctx).build (field.get_value ());
coercion_site (value,
struct_ty->get_field_at_index (field.get_tuple_index ())
->get_field_type ());
for (auto ¶m : function.get_function_params ())
handle_param (param);
- handle_body (*function.get_definition ());
+ handle_body (function.get_definition ());
auto region_hir_map
= map_region_to_hir (function.get_generic_params (), ctx.fn_free_regions);
void handle_param (HIR::FunctionParam ¶m)
{
- auto param_type = lookup_type (*param.get_param_name ());
+ auto param_type = lookup_type (param.get_param_name ());
auto &pattern = param.get_param_name ();
- if (pattern->get_pattern_type () == HIR::Pattern::IDENTIFIER
- && !static_cast<HIR::IdentifierPattern &> (*pattern).get_is_ref ())
+ if (pattern.get_pattern_type () == HIR::Pattern::IDENTIFIER
+ && !static_cast<HIR::IdentifierPattern &> (pattern).get_is_ref ())
{
// Avoid useless temporary variable for parameter to look like MIR.
- translated = declare_variable (pattern->get_mappings ());
+ translated = declare_variable (pattern.get_mappings ());
ctx.arguments.push_back (translated);
}
else
translated = ctx.place_db.add_temporary (param_type);
ctx.arguments.push_back (translated);
PatternBindingBuilder (ctx, translated, tl::nullopt)
- .go (*param.get_param_name ());
+ .go (param.get_param_name ());
}
- rust_assert (param.get_type () != nullptr);
-
// Set parameter place to use functions regions, not the fresh ones.
ctx.place_db[translated].regions
= bind_regions (Resolver::TypeCheckContext::get ()
body.get_end_locus ());
}
auto return_location = body.has_expr ()
- ? body.get_final_expr ()->get_locus ()
+ ? body.get_final_expr ().get_locus ()
: body.get_end_locus ();
push_return (return_location);
}
void visit (HIR::Function &function) override
{
functions.push_back (&function);
- function.get_definition ()->accept_vis (*this);
+ function.get_definition ().accept_vis (*this);
}
void visit (HIR::ClosureExpr &closure) override
{
closures.push_back (&closure);
- closure.get_expr ()->accept_vis (*this);
+ closure.get_expr ().accept_vis (*this);
}
// TODO: recurse for nested closures and functions.
}
void
-PrivacyReporter::check_type_privacy (const HIR::Type *type)
+PrivacyReporter::check_type_privacy (const HIR::Type &type)
{
- rust_assert (type);
-
TyTy::BaseType *lookup = nullptr;
- rust_assert (
- ty_ctx.lookup_type (type->get_mappings ().get_hirid (), &lookup));
+ rust_assert (ty_ctx.lookup_type (type.get_mappings ().get_hirid (), &lookup));
- auto node_mappings = type->get_mappings ();
- return check_base_type_privacy (node_mappings, lookup, type->get_locus ());
+ auto node_mappings = type.get_mappings ();
+ return check_base_type_privacy (node_mappings, lookup, type.get_locus ());
}
void
void
PrivacyReporter::visit (HIR::BorrowExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::DereferenceExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::ErrorPropagationExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::NegationExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::ArithmeticOrLogicalExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::ComparisonExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::LazyBooleanExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::TypeCastExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::AssignmentExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::CompoundAssignmentExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::GroupedExpr &expr)
{
- expr.get_expr_in_parens ()->accept_vis (*this);
+ expr.get_expr_in_parens ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::ArrayExpr &expr)
{
- HIR::ArrayElems &elements = *expr.get_internal_elements ();
+ HIR::ArrayElems &elements = expr.get_internal_elements ();
switch (elements.get_array_expr_type ())
{
case HIR::ArrayElems::ArrayExprType::VALUES: {
- HIR::ArrayElemsValues &elems
- = static_cast<HIR::ArrayElemsValues &> (elements);
+ auto &elems = static_cast<HIR::ArrayElemsValues &> (elements);
for (auto &value : elems.get_values ())
value->accept_vis (*this);
}
return;
case HIR::ArrayElems::ArrayExprType::COPIED:
- HIR::ArrayElemsCopied &elems
- = static_cast<HIR::ArrayElemsCopied &> (elements);
- elems.get_elem_to_copy ()->accept_vis (*this);
+ auto &elems = static_cast<HIR::ArrayElemsCopied &> (elements);
+ elems.get_elem_to_copy ().accept_vis (*this);
}
}
void
PrivacyReporter::visit (HIR::ArrayIndexExpr &expr)
{
- expr.get_array_expr ()->accept_vis (*this);
- expr.get_index_expr ()->accept_vis (*this);
+ expr.get_array_expr ().accept_vis (*this);
+ expr.get_index_expr ().accept_vis (*this);
}
void
void
PrivacyReporter::visit (HIR::TupleIndexExpr &expr)
{
- expr.get_tuple_expr ()->accept_vis (*this);
+ expr.get_tuple_expr ().accept_vis (*this);
}
void
void
PrivacyReporter::visit (HIR::StructExprFieldIdentifierValue &field)
{
- field.get_value ()->accept_vis (*this);
+ field.get_value ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::StructExprFieldIndexValue &field)
{
- field.get_value ()->accept_vis (*this);
+ field.get_value ().accept_vis (*this);
}
void
void
PrivacyReporter::visit (HIR::CallExpr &expr)
{
- expr.get_fnexpr ()->accept_vis (*this);
+ expr.get_fnexpr ().accept_vis (*this);
for (auto ¶m : expr.get_arguments ())
param->accept_vis (*this);
void
PrivacyReporter::visit (HIR::MethodCallExpr &expr)
{
- expr.get_receiver ()->accept_vis (*this);
+ expr.get_receiver ().accept_vis (*this);
for (auto ¶m : expr.get_arguments ())
param->accept_vis (*this);
void
PrivacyReporter::visit (HIR::FieldAccessExpr &expr)
{
- expr.get_receiver_expr ()->accept_vis (*this);
+ expr.get_receiver_expr ().accept_vis (*this);
// FIXME: We should also check if the field is public?
}
stmt->accept_vis (*this);
auto &last_expr = expr.get_final_expr ();
- if (last_expr)
- last_expr->accept_vis (*this);
+ last_expr.accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::BreakExpr &expr)
{
auto &break_expr = expr.get_expr ();
- if (break_expr)
- break_expr->accept_vis (*this);
+ break_expr.accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::RangeFromToExpr &expr)
{
- expr.get_from_expr ()->accept_vis (*this);
- expr.get_to_expr ()->accept_vis (*this);
+ expr.get_from_expr ().accept_vis (*this);
+ expr.get_to_expr ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::RangeFromExpr &expr)
{
- expr.get_from_expr ()->accept_vis (*this);
+ expr.get_from_expr ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::RangeToExpr &expr)
{
- expr.get_to_expr ()->accept_vis (*this);
+ expr.get_to_expr ().accept_vis (*this);
}
void
void
PrivacyReporter::visit (HIR::RangeFromToInclExpr &expr)
{
- expr.get_from_expr ()->accept_vis (*this);
- expr.get_to_expr ()->accept_vis (*this);
+ expr.get_from_expr ().accept_vis (*this);
+ expr.get_to_expr ().accept_vis (*this);
}
void
void
PrivacyReporter::visit (HIR::ReturnExpr &expr)
{
- if (expr.get_expr ())
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::UnsafeBlockExpr &expr)
{
- expr.get_block_expr ()->accept_vis (*this);
+ expr.get_block_expr ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::LoopExpr &expr)
{
- expr.get_loop_block ()->accept_vis (*this);
+ expr.get_loop_block ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::WhileLoopExpr &expr)
{
- expr.get_predicate_expr ()->accept_vis (*this);
- expr.get_loop_block ()->accept_vis (*this);
+ expr.get_predicate_expr ().accept_vis (*this);
+ expr.get_loop_block ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::WhileLetLoopExpr &expr)
{
- expr.get_cond ()->accept_vis (*this);
- expr.get_loop_block ()->accept_vis (*this);
+ expr.get_cond ().accept_vis (*this);
+ expr.get_loop_block ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::IfExpr &expr)
{
- expr.get_if_condition ()->accept_vis (*this);
- expr.get_if_block ()->accept_vis (*this);
+ expr.get_if_condition ().accept_vis (*this);
+ expr.get_if_block ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::IfExprConseqElse &expr)
{
- expr.get_if_condition ()->accept_vis (*this);
- expr.get_if_block ()->accept_vis (*this);
- expr.get_else_block ()->accept_vis (*this);
+ expr.get_if_condition ().accept_vis (*this);
+ expr.get_if_block ().accept_vis (*this);
+ expr.get_else_block ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::MatchExpr &expr)
{
- expr.get_scrutinee_expr ()->accept_vis (*this);
+ expr.get_scrutinee_expr ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::Function &function)
{
for (auto ¶m : function.get_function_params ())
- check_type_privacy (param.get_type ().get ());
+ check_type_privacy (param.get_type ());
- function.get_definition ()->accept_vis (*this);
+ function.get_definition ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::ConstantItem &const_item)
{
// TODO: We need to visit the type
- const_item.get_expr ()->accept_vis (*this);
+ const_item.get_expr ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::StaticItem &static_item)
{
// TODO: We need to visit the type
- static_item.get_expr ()->accept_vis (*this);
+ static_item.get_expr ().accept_vis (*this);
}
void
void
PrivacyReporter::visit (HIR::LetStmt &stmt)
{
- if (stmt.get_type ())
- check_type_privacy (stmt.get_type ().get ());
+ check_type_privacy (stmt.get_type ());
- if (stmt.get_init_expr ())
- stmt.get_init_expr ()->accept_vis (*this);
+ stmt.get_init_expr ().accept_vis (*this);
}
void
PrivacyReporter::visit (HIR::ExprStmt &stmt)
{
- stmt.get_expr ()->accept_vis (*this);
+ stmt.get_expr ().accept_vis (*this);
}
} // namespace Privacy
* @param type Reference to an explicit type used in a statement, expression
* or parameter
*/
- void check_type_privacy (const HIR::Type *type);
+ void check_type_privacy (const HIR::Type &type);
virtual void visit (HIR::StructExprFieldIdentifier &field);
virtual void visit (HIR::StructExprFieldIdentifierValue &field);
{
for (auto &field : struct_item.get_fields ())
if (field.get_visibility ().is_public ())
- ctx.update_reachability (field.get_field_type ()->get_mappings (),
+ ctx.update_reachability (field.get_field_type ().get_mappings (),
struct_reach);
}
void
ConstChecker::visit (BorrowExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
ConstChecker::visit (DereferenceExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
ConstChecker::visit (ErrorPropagationExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
ConstChecker::visit (NegationExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
ConstChecker::visit (ArithmeticOrLogicalExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
ConstChecker::visit (ComparisonExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
ConstChecker::visit (LazyBooleanExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
ConstChecker::visit (TypeCastExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
ConstChecker::visit (AssignmentExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
ConstChecker::visit (CompoundAssignmentExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
ConstChecker::visit (GroupedExpr &expr)
{
- expr.get_expr_in_parens ()->accept_vis (*this);
+ expr.get_expr_in_parens ().accept_vis (*this);
}
void
void
ConstChecker::visit (ArrayElemsCopied &elems)
{
- elems.get_elem_to_copy ()->accept_vis (*this);
+ elems.get_elem_to_copy ().accept_vis (*this);
const_context.enter (elems.get_mappings ().get_hirid ());
- elems.get_num_copies_expr ()->accept_vis (*this);
+ elems.get_num_copies_expr ().accept_vis (*this);
const_context.exit ();
}
void
ConstChecker::visit (ArrayExpr &expr)
{
- expr.get_internal_elements ()->accept_vis (*this);
+ expr.get_internal_elements ().accept_vis (*this);
}
void
ConstChecker::visit (ArrayIndexExpr &expr)
{
- expr.get_array_expr ()->accept_vis (*this);
- expr.get_index_expr ()->accept_vis (*this);
+ expr.get_array_expr ().accept_vis (*this);
+ expr.get_index_expr ().accept_vis (*this);
}
void
void
ConstChecker::visit (TupleIndexExpr &expr)
{
- expr.get_tuple_expr ()->accept_vis (*this);
+ expr.get_tuple_expr ().accept_vis (*this);
}
void
void
ConstChecker::visit (StructExprFieldIdentifierValue &field)
{
- field.get_value ()->accept_vis (*this);
+ field.get_value ().accept_vis (*this);
}
void
ConstChecker::visit (StructExprFieldIndexValue &field)
{
- field.get_value ()->accept_vis (*this);
+ field.get_value ().accept_vis (*this);
}
void
void
ConstChecker::visit (CallExpr &expr)
{
- if (!expr.get_fnexpr ())
+ if (!expr.has_fnexpr ())
return;
- NodeId ast_node_id = expr.get_fnexpr ()->get_mappings ().get_nodeid ();
+ NodeId ast_node_id = expr.get_fnexpr ().get_mappings ().get_nodeid ();
NodeId ref_node_id;
if (flag_name_resolution_2_0)
void
ConstChecker::visit (MethodCallExpr &expr)
{
- expr.get_receiver ()->accept_vis (*this);
+ expr.get_receiver ().accept_vis (*this);
for (auto &arg : expr.get_arguments ())
arg->accept_vis (*this);
void
ConstChecker::visit (FieldAccessExpr &expr)
{
- expr.get_receiver_expr ()->accept_vis (*this);
+ expr.get_receiver_expr ().accept_vis (*this);
}
void
ConstChecker::visit (ClosureExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
stmt->accept_vis (*this);
if (expr.has_expr ())
- expr.get_final_expr ()->accept_vis (*this);
+ expr.get_final_expr ().accept_vis (*this);
}
void
ConstChecker::visit (BreakExpr &expr)
{
if (expr.has_break_expr ())
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
ConstChecker::visit (RangeFromToExpr &expr)
{
- expr.get_from_expr ()->accept_vis (*this);
- expr.get_to_expr ()->accept_vis (*this);
+ expr.get_from_expr ().accept_vis (*this);
+ expr.get_to_expr ().accept_vis (*this);
}
void
ConstChecker::visit (RangeFromExpr &expr)
{
- expr.get_from_expr ()->accept_vis (*this);
+ expr.get_from_expr ().accept_vis (*this);
}
void
ConstChecker::visit (RangeToExpr &expr)
{
- expr.get_to_expr ()->accept_vis (*this);
+ expr.get_to_expr ().accept_vis (*this);
}
void
void
ConstChecker::visit (RangeFromToInclExpr &expr)
{
- expr.get_from_expr ()->accept_vis (*this);
- expr.get_to_expr ()->accept_vis (*this);
+ expr.get_from_expr ().accept_vis (*this);
+ expr.get_to_expr ().accept_vis (*this);
}
void
ConstChecker::visit (ReturnExpr &expr)
{
if (expr.has_return_expr ())
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
ConstChecker::visit (UnsafeBlockExpr &expr)
{
- expr.get_block_expr ()->accept_vis (*this);
+ expr.get_block_expr ().accept_vis (*this);
}
void
ConstChecker::visit (LoopExpr &expr)
{
- expr.get_loop_block ()->accept_vis (*this);
+ expr.get_loop_block ().accept_vis (*this);
}
void
ConstChecker::visit (WhileLoopExpr &expr)
{
- expr.get_predicate_expr ()->accept_vis (*this);
- expr.get_loop_block ()->accept_vis (*this);
+ expr.get_predicate_expr ().accept_vis (*this);
+ expr.get_loop_block ().accept_vis (*this);
}
void
ConstChecker::visit (WhileLetLoopExpr &expr)
{
- expr.get_cond ()->accept_vis (*this);
- expr.get_loop_block ()->accept_vis (*this);
+ expr.get_cond ().accept_vis (*this);
+ expr.get_loop_block ().accept_vis (*this);
}
void
ConstChecker::visit (IfExpr &expr)
{
- expr.get_if_condition ()->accept_vis (*this);
- expr.get_if_block ()->accept_vis (*this);
+ expr.get_if_condition ().accept_vis (*this);
+ expr.get_if_block ().accept_vis (*this);
}
void
ConstChecker::visit (IfExprConseqElse &expr)
{
- expr.get_if_condition ()->accept_vis (*this);
- expr.get_if_block ()->accept_vis (*this);
- expr.get_else_block ()->accept_vis (*this);
+ expr.get_if_condition ().accept_vis (*this);
+ expr.get_if_block ().accept_vis (*this);
+ expr.get_else_block ().accept_vis (*this);
}
void
ConstChecker::visit (MatchExpr &expr)
{
- expr.get_scrutinee_expr ()->accept_vis (*this);
+ expr.get_scrutinee_expr ().accept_vis (*this);
for (auto &match_arm : expr.get_match_cases ())
- match_arm.get_expr ()->accept_vis (*this);
+ match_arm.get_expr ().accept_vis (*this);
}
void
ConstGenericCtx::Function);
for (auto ¶m : function.get_function_params ())
- param.get_type ()->accept_vis (*this);
+ param.get_type ().accept_vis (*this);
- function.get_definition ()->accept_vis (*this);
+ function.get_definition ().accept_vis (*this);
if (const_fn)
const_context.exit ();
{
const_context.enter (item.get_mappings ().get_hirid ());
- item.get_discriminant_expression ()->accept_vis (*this);
+ item.get_discriminant_expression ().accept_vis (*this);
const_context.exit ();
}
{
const_context.enter (const_item.get_mappings ().get_hirid ());
- const_item.get_expr ()->accept_vis (*this);
+ const_item.get_expr ().accept_vis (*this);
const_context.exit ();
}
{
const_context.enter (static_item.get_mappings ().get_hirid ());
- static_item.get_expr ()->accept_vis (*this);
+ static_item.get_expr ().accept_vis (*this);
const_context.exit ();
}
ConstChecker::visit (TraitItemFunc &item)
{
if (item.has_block_defined ())
- item.get_block_expr ()->accept_vis (*this);
+ item.get_block_expr ().accept_vis (*this);
}
void
ConstChecker::visit (TraitItemConst &item)
{
if (item.has_expr ())
- item.get_expr ()->accept_vis (*this);
+ item.get_expr ().accept_vis (*this);
}
void
ConstChecker::visit (LetStmt &stmt)
{
if (stmt.has_init_expr ())
- stmt.get_init_expr ()->accept_vis (*this);
+ stmt.get_init_expr ().accept_vis (*this);
}
void
ConstChecker::visit (ExprStmt &stmt)
{
- stmt.get_expr ()->accept_vis (*this);
+ stmt.get_expr ().accept_vis (*this);
}
void
{
const_context.enter (type.get_mappings ().get_hirid ());
- type.get_size_expr ()->accept_vis (*this);
+ type.get_size_expr ().accept_vis (*this);
const_context.exit ();
}
void
PatternChecker::visit (BorrowExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
PatternChecker::visit (DereferenceExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
PatternChecker::visit (ErrorPropagationExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
PatternChecker::visit (NegationExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
PatternChecker::visit (ArithmeticOrLogicalExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
PatternChecker::visit (ComparisonExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
PatternChecker::visit (LazyBooleanExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
PatternChecker::visit (TypeCastExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
PatternChecker::visit (AssignmentExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
PatternChecker::visit (CompoundAssignmentExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
PatternChecker::visit (GroupedExpr &expr)
{
- expr.get_expr_in_parens ()->accept_vis (*this);
+ expr.get_expr_in_parens ().accept_vis (*this);
}
void
void
PatternChecker::visit (ArrayElemsCopied &elems)
{
- elems.get_elem_to_copy ()->accept_vis (*this);
+ elems.get_elem_to_copy ().accept_vis (*this);
}
void
PatternChecker::visit (ArrayExpr &expr)
{
- expr.get_internal_elements ()->accept_vis (*this);
+ expr.get_internal_elements ().accept_vis (*this);
}
void
PatternChecker::visit (ArrayIndexExpr &expr)
{
- expr.get_array_expr ()->accept_vis (*this);
- expr.get_index_expr ()->accept_vis (*this);
+ expr.get_array_expr ().accept_vis (*this);
+ expr.get_index_expr ().accept_vis (*this);
}
void
void
PatternChecker::visit (TupleIndexExpr &expr)
{
- expr.get_tuple_expr ()->accept_vis (*this);
+ expr.get_tuple_expr ().accept_vis (*this);
}
void
void
PatternChecker::visit (StructExprFieldIdentifierValue &field)
{
- field.get_value ()->accept_vis (*this);
+ field.get_value ().accept_vis (*this);
}
void
PatternChecker::visit (StructExprFieldIndexValue &field)
{
- field.get_value ()->accept_vis (*this);
+ field.get_value ().accept_vis (*this);
}
void
void
PatternChecker::visit (CallExpr &expr)
{
- if (!expr.get_fnexpr ())
+ if (!expr.has_fnexpr ())
return;
- NodeId ast_node_id = expr.get_fnexpr ()->get_mappings ().get_nodeid ();
+ NodeId ast_node_id = expr.get_fnexpr ().get_mappings ().get_nodeid ();
NodeId ref_node_id;
if (flag_name_resolution_2_0)
{
void
PatternChecker::visit (MethodCallExpr &expr)
{
- expr.get_receiver ()->accept_vis (*this);
+ expr.get_receiver ().accept_vis (*this);
for (auto &arg : expr.get_arguments ())
arg->accept_vis (*this);
void
PatternChecker::visit (FieldAccessExpr &expr)
{
- expr.get_receiver_expr ()->accept_vis (*this);
+ expr.get_receiver_expr ().accept_vis (*this);
}
void
PatternChecker::visit (ClosureExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
stmt->accept_vis (*this);
if (expr.has_expr ())
- expr.get_final_expr ()->accept_vis (*this);
+ expr.get_final_expr ().accept_vis (*this);
}
void
PatternChecker::visit (BreakExpr &expr)
{
if (expr.has_break_expr ())
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
PatternChecker::visit (RangeFromToExpr &expr)
{
- expr.get_from_expr ()->accept_vis (*this);
- expr.get_to_expr ()->accept_vis (*this);
+ expr.get_from_expr ().accept_vis (*this);
+ expr.get_to_expr ().accept_vis (*this);
}
void
PatternChecker::visit (RangeFromExpr &expr)
{
- expr.get_from_expr ()->accept_vis (*this);
+ expr.get_from_expr ().accept_vis (*this);
}
void
PatternChecker::visit (RangeToExpr &expr)
{
- expr.get_to_expr ()->accept_vis (*this);
+ expr.get_to_expr ().accept_vis (*this);
}
void
void
PatternChecker::visit (RangeFromToInclExpr &expr)
{
- expr.get_from_expr ()->accept_vis (*this);
- expr.get_to_expr ()->accept_vis (*this);
+ expr.get_from_expr ().accept_vis (*this);
+ expr.get_to_expr ().accept_vis (*this);
}
void
PatternChecker::visit (RangeToInclExpr &expr)
{
- expr.get_to_expr ()->accept_vis (*this);
+ expr.get_to_expr ().accept_vis (*this);
}
void
PatternChecker::visit (ReturnExpr &expr)
{
if (expr.has_return_expr ())
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
PatternChecker::visit (UnsafeBlockExpr &expr)
{
- expr.get_block_expr ()->accept_vis (*this);
+ expr.get_block_expr ().accept_vis (*this);
}
void
PatternChecker::visit (LoopExpr &expr)
{
- expr.get_loop_block ()->accept_vis (*this);
+ expr.get_loop_block ().accept_vis (*this);
}
void
PatternChecker::visit (WhileLoopExpr &expr)
{
- expr.get_predicate_expr ()->accept_vis (*this);
- expr.get_loop_block ()->accept_vis (*this);
+ expr.get_predicate_expr ().accept_vis (*this);
+ expr.get_loop_block ().accept_vis (*this);
}
void
PatternChecker::visit (WhileLetLoopExpr &expr)
{
- expr.get_cond ()->accept_vis (*this);
- expr.get_loop_block ()->accept_vis (*this);
+ expr.get_cond ().accept_vis (*this);
+ expr.get_loop_block ().accept_vis (*this);
}
void
PatternChecker::visit (IfExpr &expr)
{
- expr.get_if_condition ()->accept_vis (*this);
- expr.get_if_block ()->accept_vis (*this);
+ expr.get_if_condition ().accept_vis (*this);
+ expr.get_if_block ().accept_vis (*this);
}
void
PatternChecker::visit (IfExprConseqElse &expr)
{
- expr.get_if_condition ()->accept_vis (*this);
- expr.get_if_block ()->accept_vis (*this);
- expr.get_else_block ()->accept_vis (*this);
+ expr.get_if_condition ().accept_vis (*this);
+ expr.get_if_block ().accept_vis (*this);
+ expr.get_else_block ().accept_vis (*this);
}
void
PatternChecker::visit (MatchExpr &expr)
{
- expr.get_scrutinee_expr ()->accept_vis (*this);
+ expr.get_scrutinee_expr ().accept_vis (*this);
for (auto &match_arm : expr.get_match_cases ())
- match_arm.get_expr ()->accept_vis (*this);
+ match_arm.get_expr ().accept_vis (*this);
// match expressions are only an entrypoint
TyTy::BaseType *scrutinee_ty;
bool ok = tyctx.lookup_type (
- expr.get_scrutinee_expr ()->get_mappings ().get_hirid (), &scrutinee_ty);
+ expr.get_scrutinee_expr ().get_mappings ().get_hirid (), &scrutinee_ty);
rust_assert (ok);
check_match_usefulness (&tyctx, scrutinee_ty, expr);
void
PatternChecker::visit (Function &function)
{
- function.get_definition ()->accept_vis (*this);
+ function.get_definition ().accept_vis (*this);
}
void
void
PatternChecker::visit (ConstantItem &const_item)
{
- const_item.get_expr ()->accept_vis (*this);
+ const_item.get_expr ().accept_vis (*this);
}
void
PatternChecker::visit (StaticItem &static_item)
{
- static_item.get_expr ()->accept_vis (*this);
+ static_item.get_expr ().accept_vis (*this);
}
void
PatternChecker::visit (TraitItemFunc &item)
{
if (item.has_block_defined ())
- item.get_block_expr ()->accept_vis (*this);
+ item.get_block_expr ().accept_vis (*this);
}
void
PatternChecker::visit (TraitItemConst &item)
{
if (item.has_expr ())
- item.get_expr ()->accept_vis (*this);
+ item.get_expr ().accept_vis (*this);
}
void
PatternChecker::visit (LetStmt &stmt)
{
if (stmt.has_init_expr ())
- stmt.get_init_expr ()->accept_vis (*this);
+ stmt.get_init_expr ().accept_vis (*this);
}
void
PatternChecker::visit (ExprStmt &stmt)
{
- stmt.get_expr ()->accept_vis (*this);
+ stmt.get_expr ().accept_vis (*this);
}
void
// forward declarations
static DeconstructedPat
-lower_pattern (Resolver::TypeCheckContext *ctx, HIR::Pattern *pattern,
+lower_pattern (Resolver::TypeCheckContext *ctx, HIR::Pattern &pattern,
TyTy::BaseType *scrutinee_ty);
static DeconstructedPat
lower_tuple_pattern (Resolver::TypeCheckContext *ctx,
- HIR::TupleStructPattern *pattern,
+ HIR::TupleStructPattern &pattern,
TyTy::VariantDef *variant, Constructor &ctor)
{
int arity = variant->get_fields ().size ();
- HIR::TupleStructItems *elems = pattern->get_items ().get ();
+ HIR::TupleStructItems &elems = pattern.get_items ();
std::vector<DeconstructedPat> fields;
- switch (elems->get_item_type ())
+ switch (elems.get_item_type ())
{
case HIR::TupleStructItems::ItemType::MULTIPLE: {
- HIR::TupleStructItemsNoRange *multiple
- = static_cast<HIR::TupleStructItemsNoRange *> (elems);
+ HIR::TupleStructItemsNoRange &multiple
+ = static_cast<HIR::TupleStructItemsNoRange &> (elems);
rust_assert (variant->get_fields ().size ()
- == multiple->get_patterns ().size ());
- for (size_t i = 0; i < multiple->get_patterns ().size (); i++)
+ == multiple.get_patterns ().size ());
+
+ for (size_t i = 0; i < multiple.get_patterns ().size (); i++)
{
fields.push_back (
- lower_pattern (ctx, multiple->get_patterns ().at (i).get (),
+ lower_pattern (ctx, *multiple.get_patterns ().at (i),
variant->get_fields ().at (i)->get_field_type ()));
}
- return DeconstructedPat (ctor, arity, fields, pattern->get_locus ());
+ return DeconstructedPat (ctor, arity, fields, pattern.get_locus ());
}
break;
case HIR::TupleStructItems::ItemType::RANGED: {
static DeconstructedPat
lower_struct_pattern (Resolver::TypeCheckContext *ctx,
- HIR::StructPattern *pattern, TyTy::VariantDef *variant,
+ HIR::StructPattern &pattern, TyTy::VariantDef *variant,
Constructor ctor)
{
int arity = variant->get_fields ().size ();
// Initialize all field patterns to wildcard.
std::vector<DeconstructedPat> fields
= std::vector<DeconstructedPat> (arity, DeconstructedPat::make_wildcard (
- pattern->get_locus ()));
+ pattern.get_locus ()));
std::map<std::string, int> field_map;
for (int i = 0; i < arity; i++)
}
// Fill in the fields with the present patterns.
- HIR::StructPatternElements elems = pattern->get_struct_pattern_elems ();
+ HIR::StructPatternElements elems = pattern.get_struct_pattern_elems ();
for (auto &elem : elems.get_struct_pattern_fields ())
{
switch (elem->get_item_type ())
int field_idx
= field_map.at (ident->get_identifier ().as_string ());
fields.at (field_idx)
- = DeconstructedPat::make_wildcard (pattern->get_locus ());
+ = DeconstructedPat::make_wildcard (pattern.get_locus ());
}
break;
case HIR::StructPatternField::ItemType::IDENT_PAT: {
int field_idx
= field_map.at (ident_pat->get_identifier ().as_string ());
fields.at (field_idx) = lower_pattern (
- ctx, ident_pat->get_pattern ().get (),
+ ctx, ident_pat->get_pattern (),
variant->get_fields ().at (field_idx)->get_field_type ());
}
break;
}
}
- return DeconstructedPat{ctor, arity, fields, pattern->get_locus ()};
+ return DeconstructedPat{ctor, arity, fields, pattern.get_locus ()};
};
static DeconstructedPat
-lower_pattern (Resolver::TypeCheckContext *ctx, HIR::Pattern *pattern,
+lower_pattern (Resolver::TypeCheckContext *ctx, HIR::Pattern &pattern,
TyTy::BaseType *scrutinee_ty)
{
- HIR::Pattern::PatternType pat_type = pattern->get_pattern_type ();
+ HIR::Pattern::PatternType pat_type = pattern.get_pattern_type ();
switch (pat_type)
{
case HIR::Pattern::PatternType::WILDCARD:
case HIR::Pattern::PatternType::IDENTIFIER: {
- return DeconstructedPat::make_wildcard (pattern->get_locus ());
+ return DeconstructedPat::make_wildcard (pattern.get_locus ());
}
break;
case HIR::Pattern::PatternType::PATH: {
// structs
// https://doc.rust-lang.org/reference/patterns.html#path-patterns
// unimplemented. Treat this pattern as wildcard for now.
- return DeconstructedPat::make_wildcard (pattern->get_locus ());
+ return DeconstructedPat::make_wildcard (pattern.get_locus ());
}
break;
case HIR::Pattern::PatternType::REFERENCE: {
// TODO: unimplemented. Treat this pattern as wildcard for now.
- return DeconstructedPat::make_wildcard (pattern->get_locus ());
+ return DeconstructedPat::make_wildcard (pattern.get_locus ());
}
break;
case HIR::Pattern::PatternType::STRUCT:
HirId path_id = UNKNOWN_HIRID;
if (pat_type == HIR::Pattern::PatternType::STRUCT)
{
- HIR::StructPattern *struct_pattern
- = static_cast<HIR::StructPattern *> (pattern);
- path_id = struct_pattern->get_path ().get_mappings ().get_hirid ();
+ HIR::StructPattern &struct_pattern
+ = static_cast<HIR::StructPattern &> (pattern);
+ path_id = struct_pattern.get_path ().get_mappings ().get_hirid ();
}
else
{
- HIR::TupleStructPattern *tuple_pattern
- = static_cast<HIR::TupleStructPattern *> (pattern);
- path_id = tuple_pattern->get_path ().get_mappings ().get_hirid ();
+ HIR::TupleStructPattern &tuple_pattern
+ = static_cast<HIR::TupleStructPattern &> (pattern);
+ path_id = tuple_pattern.get_path ().get_mappings ().get_hirid ();
}
rust_assert (scrutinee_ty->get_kind () == TyTy::TypeKind::ADT);
if (pat_type == HIR::Pattern::PatternType::STRUCT)
{
- HIR::StructPattern *struct_pattern
- = static_cast<HIR::StructPattern *> (pattern);
+ HIR::StructPattern &struct_pattern
+ = static_cast<HIR::StructPattern &> (pattern);
return lower_struct_pattern (ctx, struct_pattern, variant, ctor);
}
else
{
- HIR::TupleStructPattern *tuple_pattern
- = static_cast<HIR::TupleStructPattern *> (pattern);
+ HIR::TupleStructPattern &tuple_pattern
+ = static_cast<HIR::TupleStructPattern &> (pattern);
return lower_tuple_pattern (ctx, tuple_pattern, variant, ctor);
}
}
break;
case HIR::Pattern::PatternType::TUPLE: {
// TODO: unimplemented. Treat this pattern as wildcard for now.
- return DeconstructedPat::make_wildcard (pattern->get_locus ());
+ return DeconstructedPat::make_wildcard (pattern.get_locus ());
}
break;
case HIR::Pattern::PatternType::SLICE: {
// TODO: unimplemented. Treat this pattern as wildcard for now.
- return DeconstructedPat::make_wildcard (pattern->get_locus ());
+ return DeconstructedPat::make_wildcard (pattern.get_locus ());
}
break;
case HIR::Pattern::PatternType::ALT: {
// TODO: unimplemented. Treat this pattern as wildcard for now.
- return DeconstructedPat::make_wildcard (pattern->get_locus ());
+ return DeconstructedPat::make_wildcard (pattern.get_locus ());
}
break;
case HIR::Pattern::PatternType::LITERAL: {
// TODO: unimplemented. Treat this pattern as wildcard for now.
- return DeconstructedPat::make_wildcard (pattern->get_locus ());
+ return DeconstructedPat::make_wildcard (pattern.get_locus ());
}
break;
case HIR::Pattern::PatternType::RANGE: {
// TODO: unimplemented. Treat this pattern as wildcard for now.
- return DeconstructedPat::make_wildcard (pattern->get_locus ());
+ return DeconstructedPat::make_wildcard (pattern.get_locus ());
}
break;
case HIR::Pattern::PatternType::GROUPED: {
// TODO: unimplemented. Treat this pattern as wildcard for now.
- return DeconstructedPat::make_wildcard (pattern->get_locus ());
+ return DeconstructedPat::make_wildcard (pattern.get_locus ());
}
break;
default: {
rust_assert (arm.get_arm ().get_patterns ().size () > 0);
DeconstructedPat pat
- = lower_pattern (ctx, arm.get_arm ().get_patterns ().at (0).get (),
- scrutinee_ty);
+ = lower_pattern (ctx, *arm.get_arm ().get_patterns ().at (0), scrutinee_ty);
return MatchArm (pat, arm.get_arm ().has_match_arm_guard ());
}
HIR::MatchExpr &expr, WitnessMatrix &witness)
{
TyTy::BaseType *scrutinee_ty;
- bool ok = ctx->lookup_type (
- expr.get_scrutinee_expr ()->get_mappings ().get_hirid (), &scrutinee_ty);
+ bool ok
+ = ctx->lookup_type (expr.get_scrutinee_expr ().get_mappings ().get_hirid (),
+ &scrutinee_ty);
rust_assert (ok);
if (!witness.empty ())
if (i != witness.get_stacks ().size () - 1)
buf << " and ";
}
- rust_error_at (expr.get_scrutinee_expr ()->get_locus (),
+ rust_error_at (expr.get_scrutinee_expr ().get_locus (),
"non-exhaustive patterns: %s not covered",
buf.str ().c_str ());
}
void
UnsafeChecker::visit (BorrowExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
UnsafeChecker::visit (DereferenceExpr &expr)
{
TyTy::BaseType *to_deref_type;
- auto to_deref = expr.get_expr ()->get_mappings ().get_hirid ();
+ auto to_deref = expr.get_expr ().get_mappings ().get_hirid ();
rust_assert (context.lookup_type (to_deref, &to_deref_type));
void
UnsafeChecker::visit (ErrorPropagationExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
UnsafeChecker::visit (NegationExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
UnsafeChecker::visit (ArithmeticOrLogicalExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
UnsafeChecker::visit (ComparisonExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
UnsafeChecker::visit (LazyBooleanExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
UnsafeChecker::visit (TypeCastExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
UnsafeChecker::visit (AssignmentExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
UnsafeChecker::visit (CompoundAssignmentExpr &expr)
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void
UnsafeChecker::visit (GroupedExpr &expr)
{
- expr.get_expr_in_parens ()->accept_vis (*this);
+ expr.get_expr_in_parens ().accept_vis (*this);
}
void
void
UnsafeChecker::visit (ArrayElemsCopied &elems)
{
- elems.get_elem_to_copy ()->accept_vis (*this);
+ elems.get_elem_to_copy ().accept_vis (*this);
}
void
UnsafeChecker::visit (ArrayExpr &expr)
{
- expr.get_internal_elements ()->accept_vis (*this);
+ expr.get_internal_elements ().accept_vis (*this);
}
void
UnsafeChecker::visit (ArrayIndexExpr &expr)
{
- expr.get_array_expr ()->accept_vis (*this);
- expr.get_index_expr ()->accept_vis (*this);
+ expr.get_array_expr ().accept_vis (*this);
+ expr.get_index_expr ().accept_vis (*this);
}
void
void
UnsafeChecker::visit (TupleIndexExpr &expr)
{
- expr.get_tuple_expr ()->accept_vis (*this);
+ expr.get_tuple_expr ().accept_vis (*this);
}
void
void
UnsafeChecker::visit (StructExprFieldIdentifierValue &field)
{
- field.get_value ()->accept_vis (*this);
+ field.get_value ().accept_vis (*this);
}
void
UnsafeChecker::visit (StructExprFieldIndexValue &field)
{
- field.get_value ()->accept_vis (*this);
+ field.get_value ().accept_vis (*this);
}
void
void
UnsafeChecker::visit (CallExpr &expr)
{
- if (!expr.get_fnexpr ())
+ if (!expr.has_fnexpr ())
return;
- NodeId ast_node_id = expr.get_fnexpr ()->get_mappings ().get_nodeid ();
+ NodeId ast_node_id = expr.get_fnexpr ().get_mappings ().get_nodeid ();
NodeId ref_node_id;
// There are no unsafe types, and functions are defined in the name resolver.
check_unsafe_call (static_cast<Function *> (method->first),
expr.get_locus (), "method");
- expr.get_receiver ()->accept_vis (*this);
+ expr.get_receiver ().accept_vis (*this);
for (auto &arg : expr.get_arguments ())
arg->accept_vis (*this);
void
UnsafeChecker::visit (FieldAccessExpr &expr)
{
- expr.get_receiver_expr ()->accept_vis (*this);
+ expr.get_receiver_expr ().accept_vis (*this);
if (unsafe_context.is_in_context ())
return;
TyTy::BaseType *receiver_ty;
auto ok = context.lookup_type (
- expr.get_receiver_expr ()->get_mappings ().get_hirid (), &receiver_ty);
+ expr.get_receiver_expr ().get_mappings ().get_hirid (), &receiver_ty);
rust_assert (ok);
if (receiver_ty->get_kind () == TyTy::TypeKind::ADT)
void
UnsafeChecker::visit (ClosureExpr &expr)
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
stmt->accept_vis (*this);
if (expr.has_expr ())
- expr.get_final_expr ()->accept_vis (*this);
+ expr.get_final_expr ().accept_vis (*this);
}
void
UnsafeChecker::visit (BreakExpr &expr)
{
if (expr.has_break_expr ())
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
UnsafeChecker::visit (RangeFromToExpr &expr)
{
- expr.get_from_expr ()->accept_vis (*this);
- expr.get_to_expr ()->accept_vis (*this);
+ expr.get_from_expr ().accept_vis (*this);
+ expr.get_to_expr ().accept_vis (*this);
}
void
UnsafeChecker::visit (RangeFromExpr &expr)
{
- expr.get_from_expr ()->accept_vis (*this);
+ expr.get_from_expr ().accept_vis (*this);
}
void
UnsafeChecker::visit (RangeToExpr &expr)
{
- expr.get_to_expr ()->accept_vis (*this);
+ expr.get_to_expr ().accept_vis (*this);
}
void
void
UnsafeChecker::visit (RangeFromToInclExpr &expr)
{
- expr.get_from_expr ()->accept_vis (*this);
- expr.get_to_expr ()->accept_vis (*this);
+ expr.get_from_expr ().accept_vis (*this);
+ expr.get_to_expr ().accept_vis (*this);
}
void
UnsafeChecker::visit (RangeToInclExpr &expr)
{
- expr.get_to_expr ()->accept_vis (*this);
+ expr.get_to_expr ().accept_vis (*this);
}
void
UnsafeChecker::visit (ReturnExpr &expr)
{
if (expr.has_return_expr ())
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void
{
unsafe_context.enter (expr.get_mappings ().get_hirid ());
- expr.get_block_expr ()->accept_vis (*this);
+ expr.get_block_expr ().accept_vis (*this);
unsafe_context.exit ();
}
void
UnsafeChecker::visit (LoopExpr &expr)
{
- expr.get_loop_block ()->accept_vis (*this);
+ expr.get_loop_block ().accept_vis (*this);
}
void
UnsafeChecker::visit (WhileLoopExpr &expr)
{
- expr.get_predicate_expr ()->accept_vis (*this);
- expr.get_loop_block ()->accept_vis (*this);
+ expr.get_predicate_expr ().accept_vis (*this);
+ expr.get_loop_block ().accept_vis (*this);
}
void
UnsafeChecker::visit (WhileLetLoopExpr &expr)
{
- expr.get_cond ()->accept_vis (*this);
- expr.get_loop_block ()->accept_vis (*this);
+ expr.get_cond ().accept_vis (*this);
+ expr.get_loop_block ().accept_vis (*this);
}
void
UnsafeChecker::visit (IfExpr &expr)
{
- expr.get_if_condition ()->accept_vis (*this);
- expr.get_if_block ()->accept_vis (*this);
+ expr.get_if_condition ().accept_vis (*this);
+ expr.get_if_block ().accept_vis (*this);
}
void
UnsafeChecker::visit (IfExprConseqElse &expr)
{
- expr.get_if_condition ()->accept_vis (*this);
- expr.get_if_block ()->accept_vis (*this);
- expr.get_else_block ()->accept_vis (*this);
+ expr.get_if_condition ().accept_vis (*this);
+ expr.get_if_block ().accept_vis (*this);
+ expr.get_else_block ().accept_vis (*this);
}
void
UnsafeChecker::visit (MatchExpr &expr)
{
- expr.get_scrutinee_expr ()->accept_vis (*this);
+ expr.get_scrutinee_expr ().accept_vis (*this);
for (auto &match_arm : expr.get_match_cases ())
- match_arm.get_expr ()->accept_vis (*this);
+ match_arm.get_expr ().accept_vis (*this);
}
void
if (is_unsafe_fn)
unsafe_context.enter (function.get_mappings ().get_hirid ());
- function.get_definition ()->accept_vis (*this);
+ function.get_definition ().accept_vis (*this);
if (is_unsafe_fn)
unsafe_context.exit ();
void
UnsafeChecker::visit (ConstantItem &const_item)
{
- const_item.get_expr ()->accept_vis (*this);
+ const_item.get_expr ().accept_vis (*this);
}
void
UnsafeChecker::visit (StaticItem &static_item)
{
- static_item.get_expr ()->accept_vis (*this);
+ static_item.get_expr ().accept_vis (*this);
}
void
UnsafeChecker::visit (TraitItemFunc &item)
{
if (item.has_block_defined ())
- item.get_block_expr ()->accept_vis (*this);
+ item.get_block_expr ().accept_vis (*this);
}
void
UnsafeChecker::visit (TraitItemConst &item)
{
if (item.has_expr ())
- item.get_expr ()->accept_vis (*this);
+ item.get_expr ().accept_vis (*this);
}
void
UnsafeChecker::visit (LetStmt &stmt)
{
if (stmt.has_init_expr ())
- stmt.get_init_expr ()->accept_vis (*this);
+ stmt.get_init_expr ().accept_vis (*this);
}
void
UnsafeChecker::visit (ExprStmt &stmt)
{
- stmt.get_expr ()->accept_vis (*this);
+ stmt.get_expr ().accept_vis (*this);
}
void
void
MarkLive::visit (HIR::MethodCallExpr &expr)
{
- expr.get_receiver ()->accept_vis (*this);
+ expr.get_receiver ().accept_vis (*this);
visit_path_segment (expr.get_method_name ());
for (auto &argument : expr.get_arguments ())
argument->accept_vis (*this);
MarkLive::visit (HIR::FieldAccessExpr &expr)
{
// visit receiver at first
- expr.get_receiver_expr ()->accept_vis (*this);
+ expr.get_receiver_expr ().accept_vis (*this);
// resolve the receiver back to ADT type
TyTy::BaseType *receiver = nullptr;
if (!tyctx->lookup_type (
- expr.get_receiver_expr ()->get_mappings ().get_hirid (), &receiver))
+ expr.get_receiver_expr ().get_mappings ().get_hirid (), &receiver))
{
- rust_error_at (expr.get_receiver_expr ()->get_locus (),
+ rust_error_at (expr.get_receiver_expr ().get_locus (),
"unresolved type for receiver");
}
rust_assert (ok);
if (index >= variant->num_fields ())
{
- rust_error_at (expr.get_receiver_expr ()->get_locus (),
+ rust_error_at (expr.get_receiver_expr ().get_locus (),
"cannot access struct %s by index: %lu",
adt->get_name ().c_str (), (unsigned long) index);
return;
MarkLive::visit (HIR::TupleIndexExpr &expr)
{
// TODO: unused tuple field detection
- expr.get_tuple_expr ()->accept_vis (*this);
+ expr.get_tuple_expr ().accept_vis (*this);
}
void
= Resolver2_0::ImmutableNameResolutionContext::get ().resolver ();
if (auto id = nr_ctx.lookup (
- alias.get_type_aliased ()->get_mappings ().get_nodeid ()))
+ alias.get_type_aliased ().get_mappings ().get_nodeid ()))
ast_node_id = *id;
}
else
{
resolver->lookup_resolved_type (
- alias.get_type_aliased ()->get_mappings ().get_nodeid (), &ast_node_id);
+ alias.get_type_aliased ().get_mappings ().get_nodeid (), &ast_node_id);
}
if (auto hid = mappings.lookup_node_to_hir (ast_node_id))
void visit (HIR::BorrowExpr &expr) override
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void visit (HIR::DereferenceExpr &expr) override
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void visit (HIR::NegationExpr &expr) override
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void visit (HIR::LazyBooleanExpr &expr) override
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void visit (HIR::TypeCastExpr &expr) override
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void visit (HIR::GroupedExpr &expr) override
{
- expr.get_expr_in_parens ()->accept_vis (*this);
+ expr.get_expr_in_parens ().accept_vis (*this);
}
void visit (HIR::ArrayExpr &expr) override
{
- expr.get_internal_elements ()->accept_vis (*this);
+ expr.get_internal_elements ().accept_vis (*this);
}
void visit (HIR::ArrayIndexExpr &expr) override
{
- expr.get_array_expr ()->accept_vis (*this);
- expr.get_index_expr ()->accept_vis (*this);
+ expr.get_array_expr ().accept_vis (*this);
+ expr.get_index_expr ().accept_vis (*this);
}
void visit (HIR::ArrayElemsValues &expr) override
}
if (expr.has_expr ())
{
- expr.get_final_expr ()->accept_vis (*this);
+ expr.get_final_expr ().accept_vis (*this);
}
}
void visit (HIR::UnsafeBlockExpr &expr) override
{
- expr.get_block_expr ()->accept_vis (*this);
+ expr.get_block_expr ().accept_vis (*this);
}
void visit (HIR::LoopExpr &expr) override
{
- expr.get_loop_block ()->accept_vis (*this);
+ expr.get_loop_block ().accept_vis (*this);
}
void visit (HIR::BreakExpr &expr) override
{
if (expr.has_break_expr ())
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void visit (HIR::WhileLoopExpr &expr) override
{
- expr.get_loop_block ()->accept_vis (*this);
- expr.get_predicate_expr ()->accept_vis (*this);
+ expr.get_loop_block ().accept_vis (*this);
+ expr.get_predicate_expr ().accept_vis (*this);
}
void visit (HIR::Function &function) override
{
- function.get_definition ()->accept_vis (*this);
+ function.get_definition ().accept_vis (*this);
}
void visit (HIR::ReturnExpr &expr) override
{
if (expr.has_return_expr ())
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
void visit (HIR::WhileLetLoopExpr &expr) override
{
- expr.get_loop_block ()->accept_vis (*this);
- expr.get_cond ()->accept_vis (*this);
+ expr.get_loop_block ().accept_vis (*this);
+ expr.get_cond ().accept_vis (*this);
}
void visit (HIR::ExprStmt &stmt) override
{
- stmt.get_expr ()->accept_vis (*this);
+ stmt.get_expr ().accept_vis (*this);
}
void visit (HIR::CallExpr &expr) override
{
- expr.get_fnexpr ()->accept_vis (*this);
+ expr.get_fnexpr ().accept_vis (*this);
for (auto &argument : expr.get_arguments ())
argument->accept_vis (*this);
}
}
void visit (HIR::ComparisonExpr &expr) override
{
- expr.get_lhs ()->accept_vis (*this);
- expr.get_rhs ()->accept_vis (*this);
+ expr.get_lhs ().accept_vis (*this);
+ expr.get_rhs ().accept_vis (*this);
}
void visit (HIR::AssignmentExpr &expr) override
void visit (HIR::IfExpr &expr) override
{
- expr.get_if_condition ()->accept_vis (*this);
- expr.get_if_block ()->accept_vis (*this);
+ expr.get_if_condition ().accept_vis (*this);
+ expr.get_if_block ().accept_vis (*this);
}
void visit (HIR::IfExprConseqElse &expr) override
{
- expr.get_if_condition ()->accept_vis (*this);
- expr.get_if_block ()->accept_vis (*this);
- expr.get_else_block ()->accept_vis (*this);
+ expr.get_if_condition ().accept_vis (*this);
+ expr.get_if_block ().accept_vis (*this);
+ expr.get_else_block ().accept_vis (*this);
}
void visit (HIR::MatchExpr &expr) override
{
- expr.get_scrutinee_expr ()->accept_vis (*this);
+ expr.get_scrutinee_expr ().accept_vis (*this);
std::vector<HIR::MatchCase> &cases = expr.get_match_cases ();
for (auto &&caz : cases)
{
auto case_arm = caz.get_arm ();
if (case_arm.has_match_arm_guard ())
- case_arm.get_guard_expr ()->accept_vis (*this);
- caz.get_expr ()->accept_vis (*this);
+ case_arm.get_guard_expr ().accept_vis (*this);
+ caz.get_expr ().accept_vis (*this);
}
}
void visit (HIR::TraitItemFunc &item) override
{
- item.get_block_expr ()->accept_vis (*this);
+ item.get_block_expr ().accept_vis (*this);
}
void visit (HIR::ImplBlock &impl) override
{
if (stmt.has_init_expr ())
{
- stmt.get_init_expr ()->accept_vis (*this);
+ stmt.get_init_expr ().accept_vis (*this);
}
}
virtual void visit (HIR::StructExprFieldIdentifierValue &field) override
{
- field.get_value ()->accept_vis (*this);
+ field.get_value ().accept_vis (*this);
}
void visit (HIR::StructExprStructBase &stct) override
void visit (HIR::ClosureExpr &expr) override
{
- expr.get_expr ()->accept_vis (*this);
+ expr.get_expr ().accept_vis (*this);
}
private:
end_field ("path_type");
begin_field ("associated_segment");
- do_typepathsegment (*e.get_associated_segment ());
+ do_typepathsegment (e.get_associated_segment ());
end_field ("associated_segment");
visit_collection ("segments", e.get_segments ());
}
put_field ("expr_type", str);
do_operatorexpr (e);
- visit_field ("right_expr", *e.get_rhs ());
+ visit_field ("right_expr", e.get_rhs ());
end ("ArithmeticOrLogicalExpr");
}
}
put_field ("expr_type", str);
do_operatorexpr (e);
- visit_field ("right_expr", *e.get_rhs ());
+ visit_field ("right_expr", e.get_rhs ());
end ("ComparisonExpr");
}
}
do_operatorexpr (e);
- visit_field ("right_expr", *e.get_rhs ());
+ visit_field ("right_expr", e.get_rhs ());
end ("LazyBooleanExpr");
}
{
begin ("AssignmentExpr");
do_operatorexpr (e);
- visit_field ("right_expr", *e.get_rhs ());
+ visit_field ("right_expr", e.get_rhs ());
end ("AssignmentExpr");
}
begin ("CompoundAssignmentExpr");
do_operatorexpr (e);
- visit_field ("right_expr", *e.get_rhs ());
+ visit_field ("right_expr", e.get_rhs ());
std::string str;
else
put_field ("where clause", e.get_where_clause ().as_string ());
- put_field ("type", e.get_type_aliased ()->as_string ());
+ put_field ("type", e.get_type_aliased ().as_string ());
end ("TypeAlias");
}
put_field ("mut", std::to_string (e.is_mut ()));
if (e.has_pattern_to_bind ())
- put_field ("to_bind", e.get_to_bind ()->as_string ());
+ put_field ("to_bind", e.get_to_bind ().as_string ());
else
put_field ("to_bind", "none");
{
begin ("RangePattern");
do_mappings (e.get_mappings ());
- put_field ("lower", e.get_lower_bound ()->as_string ());
- put_field ("upper", e.get_upper_bound ()->as_string ());
+ put_field ("lower", e.get_lower_bound ().as_string ());
+ put_field ("upper", e.get_upper_bound ().as_string ());
put_field ("has_ellipsis_syntax",
std::to_string (e.get_has_ellipsis_syntax ()));
end ("RangePattern");
begin ("ReferencePattern");
do_mappings (e.get_mappings ());
put_field ("mut", std::to_string (e.is_mut ()));
- put_field ("pattern", e.get_referenced_pattern ()->as_string ());
+ put_field ("pattern", e.get_referenced_pattern ().as_string ());
end ("ReferencePattern");
}
auto oa = e.get_outer_attrs ();
do_outer_attrs (oa);
put_field ("index", std::to_string (e.get_index ()));
- put_field ("tuple_pattern", e.get_tuple_pattern ()->as_string ());
+ put_field ("tuple_pattern", e.get_tuple_pattern ().as_string ());
end ("StructPatternFieldTuplePat");
}
auto oa = e.get_outer_attrs ();
do_outer_attrs (oa);
put_field ("ident", e.get_identifier ().as_string ());
- put_field ("ident_pattern", e.get_pattern ()->as_string ());
+ put_field ("ident_pattern", e.get_pattern ().as_string ());
end ("StructPatternFieldIdentPat");
}
auto oa = e.get_outer_attrs ();
do_outer_attrs (oa);
- put_field ("variable_pattern", e.get_pattern ()->as_string ());
+ put_field ("variable_pattern", e.get_pattern ().as_string ());
visit_field ("type", e.get_type ());
visit_field ("init_expr", e.get_init_expr ());
{
begin ("ParenthesisedType");
do_type (e);
- put_field ("type_in_parens", e.get_type_in_parens ()->as_string ());
+ put_field ("type_in_parens", e.get_type_in_parens ().as_string ());
end ("ParenthesisedType");
}
begin ("RawPointerType");
do_type (e);
put_field ("mut", Rust::enum_to_str (e.get_mut ()));
- put_field ("type", e.get_type ()->as_string ());
+ put_field ("type", e.get_type ().as_string ());
end ("RawPointerType");
}
do_type (e);
put_field ("lifetime", e.get_lifetime ().as_string ());
put_field ("mut", enum_to_str (e.get_mut ()));
- put_field ("type", e.get_base_type ()->as_string ());
+ put_field ("type", e.get_base_type ().as_string ());
end ("ReferenceType");
}
public:
location_t get_locus () const override final { return locus; }
- std::unique_ptr<Expr> &get_expr () { return main_or_left_expr; }
+ Expr &get_expr () { return *main_or_left_expr; }
ExprType get_expression_type () const override final
{
void visit_lhs (HIRFullVisitor &vis) { main_or_left_expr->accept_vis (vis); }
void visit_rhs (HIRFullVisitor &vis) { right_expr->accept_vis (vis); }
- std::unique_ptr<Expr> &get_lhs () { return main_or_left_expr; }
- std::unique_ptr<Expr> &get_rhs () { return right_expr; }
+ Expr &get_lhs () { return *main_or_left_expr; }
+ Expr &get_rhs () { return *right_expr; }
std::string get_operator_str () const;
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_lhs () { return main_or_left_expr; }
- std::unique_ptr<Expr> &get_rhs () { return right_expr; }
+ Expr &get_lhs () { return *main_or_left_expr; }
+ Expr &get_rhs () { return *right_expr; }
ExprType get_kind () { return expr_type; }
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_lhs () { return main_or_left_expr; }
- std::unique_ptr<Expr> &get_rhs () { return right_expr; }
+ Expr &get_lhs () { return *main_or_left_expr; }
+ Expr &get_rhs () { return *right_expr; }
protected:
/* Use covariance to implement clone function as returning this object rather
void accept_vis (HIRExpressionVisitor &vis) override;
// FIXME: isn't it the same as get_expr() from parent?
- std::unique_ptr<Expr> &get_casted_expr () { return main_or_left_expr; }
+ Expr &get_casted_expr () { return *main_or_left_expr; }
- std::unique_ptr<Type> &get_type_to_convert_to ()
- {
- return type_to_convert_to;
- }
+ Type &get_type_to_convert_to () { return *type_to_convert_to; }
protected:
/* Use covariance to implement clone function as returning this object rather
void visit_lhs (HIRFullVisitor &vis) { main_or_left_expr->accept_vis (vis); }
void visit_rhs (HIRFullVisitor &vis) { right_expr->accept_vis (vis); }
- std::unique_ptr<Expr> &get_lhs () { return main_or_left_expr; }
- std::unique_ptr<Expr> &get_rhs () { return right_expr; }
+ Expr &get_lhs () { return *main_or_left_expr; }
+ Expr &get_rhs () { return *right_expr; }
protected:
/* Use covariance to implement clone function as returning this object rather
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_lhs () { return main_or_left_expr; }
+ Expr &get_lhs () { return *main_or_left_expr; }
- std::unique_ptr<Expr> &get_rhs () { return right_expr; }
+ Expr &get_rhs () { return *right_expr; }
void visit_lhs (HIRFullVisitor &vis) { main_or_left_expr->accept_vis (vis); }
void visit_rhs (HIRFullVisitor &vis) { right_expr->accept_vis (vis); }
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_expr_in_parens () { return expr_in_parens; }
+ Expr &get_expr_in_parens () { return *expr_in_parens; }
ExprType get_expression_type () const override final
{
void accept_vis (HIRFullVisitor &vis) override;
- std::unique_ptr<Expr> &get_elem_to_copy () { return elem_to_copy; }
+ Expr &get_elem_to_copy () { return *elem_to_copy; }
- std::unique_ptr<Expr> &get_num_copies_expr () { return num_copies; }
+ Expr &get_num_copies_expr () { return *num_copies; }
ArrayElems::ArrayExprType get_array_expr_type () const override final
{
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<ArrayElems> &get_internal_elements ()
- {
- return internal_elements;
- };
+ ArrayElems &get_internal_elements () { return *internal_elements; };
ExprType get_expression_type () const override final
{
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_array_expr () { return array_expr; }
- std::unique_ptr<Expr> &get_index_expr () { return index_expr; }
+ Expr &get_array_expr () { return *array_expr; }
+ Expr &get_index_expr () { return *index_expr; }
ExprType get_expression_type () const override final
{
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_tuple_expr () { return tuple_expr; }
+ Expr &get_tuple_expr () { return *tuple_expr; }
ExprType get_expression_type () const override final
{
public:
std::string as_string () const override;
- std::unique_ptr<Expr> &get_value () { return value; }
+ Expr &get_value () { return *value; }
};
// Identifier and value variant of StructExprField HIR node
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_fnexpr () { return function; }
+ bool has_fnexpr () const { return function != nullptr; }
+ Expr &get_fnexpr () { return *function; }
size_t num_params () const { return params.size (); }
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_receiver () { return receiver; }
+ Expr &get_receiver () { return *receiver; }
PathExprSegment &get_method_name () { return method_name; };
const PathExprSegment &get_method_name () const { return method_name; };
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_receiver_expr () { return receiver; }
+ Expr &get_receiver_expr () { return *receiver; }
Identifier get_field_name () const { return field; }
}
std::vector<AST::Attribute> &get_outer_attrs () { return outer_attrs; }
- std::unique_ptr<Pattern> &get_pattern () { return pattern; }
+ Pattern &get_pattern () { return *pattern; }
- std::unique_ptr<Type> &get_type () { return type; }
+ Type &get_type () { return *type; }
location_t get_locus () const { return locus; }
};
bool has_return_type () const { return return_type != nullptr; }
- std::unique_ptr<Type> &get_return_type () { return return_type; };
- std::unique_ptr<Expr> &get_expr () { return expr; }
+ Type &get_return_type () { return *return_type; };
+ Expr &get_expr () { return *expr; }
bool has_params () const { return !params.empty (); }
std::vector<ClosureParam> &get_params () { return params; }
bool is_final_stmt (Stmt *stmt) { return statements.back ().get () == stmt; }
- std::unique_ptr<Expr> &get_final_expr () { return expr; }
+ Expr &get_final_expr () { return *expr; }
std::vector<std::unique_ptr<Stmt> > &get_statements () { return statements; }
Lifetime &get_label () { return label; }
- std::unique_ptr<Expr> &get_expr () { return break_expr; }
+ Expr &get_expr () { return *break_expr; }
ExprType get_expression_type () const override final
{
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_from_expr () { return from; }
- std::unique_ptr<Expr> &get_to_expr () { return to; }
+ Expr &get_from_expr () { return *from; }
+ Expr &get_to_expr () { return *to; }
protected:
/* Use covariance to implement clone function as returning this object rather
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_from_expr () { return from; }
+ Expr &get_from_expr () { return *from; }
protected:
/* Use covariance to implement clone function as returning this object rather
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_to_expr () { return to; }
+ Expr &get_to_expr () { return *to; }
protected:
/* Use covariance to implement clone function as returning this object rather
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_from_expr () { return from; }
- std::unique_ptr<Expr> &get_to_expr () { return to; }
+ Expr &get_from_expr () { return *from; }
+ Expr &get_to_expr () { return *to; }
protected:
/* Use covariance to implement clone function as returning this object rather
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_to_expr () { return to; };
+ Expr &get_to_expr () { return *to; };
protected:
/* Use covariance to implement clone function as returning this object rather
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_expr () { return return_expr; }
+ Expr &get_expr () { return *return_expr; }
ExprType get_expression_type () const override final
{
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<BlockExpr> &get_block_expr () { return expr; }
+ BlockExpr &get_block_expr () { return *expr; }
ExprType get_expression_type () const override final
{
location_t get_locus () const override final { return locus; }
- std::unique_ptr<HIR::BlockExpr> &get_loop_block () { return loop_block; };
+ HIR::BlockExpr &get_loop_block () { return *loop_block; };
LoopLabel &get_loop_label () { return loop_label; }
};
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_predicate_expr () { return condition; }
+ Expr &get_predicate_expr () { return *condition; }
protected:
/* Use covariance to implement clone function as returning this object rather
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_cond () { return condition; }
+ Expr &get_cond () { return *condition; }
std::vector<std::unique_ptr<Pattern> > &get_patterns ()
{
return match_arm_patterns;
void vis_if_condition (HIRFullVisitor &vis) { condition->accept_vis (vis); }
void vis_if_block (HIRFullVisitor &vis) { if_block->accept_vis (vis); }
- std::unique_ptr<Expr> &get_if_condition () { return condition; }
- std::unique_ptr<BlockExpr> &get_if_block () { return if_block; }
+ Expr &get_if_condition () { return *condition; }
+ BlockExpr &get_if_block () { return *if_block; }
ExprType get_expression_type () const final override { return ExprType::If; }
void vis_else_block (HIRFullVisitor &vis) { else_block->accept_vis (vis); }
- std::unique_ptr<ExprWithBlock> &get_else_block () { return else_block; }
+ ExprWithBlock &get_else_block () { return *else_block; }
protected:
/* Use covariance to implement clone function as returning this object rather
return match_arm_patterns;
}
- std::unique_ptr<Expr> &get_guard_expr () { return guard_expr; }
+ Expr &get_guard_expr () { return *guard_expr; }
location_t get_locus () const { return locus; }
};
Analysis::NodeMapping get_mappings () const { return mappings; }
MatchArm &get_arm () { return arm; }
- std::unique_ptr<Expr> &get_expr () { return expr; }
+ Expr &get_expr () { return *expr; }
};
// Match expression HIR node
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_scrutinee_expr () { return branch_value; }
+ Expr &get_scrutinee_expr () { return *branch_value; }
AST::AttrVec get_inner_attrs () const { return inner_attrs; }
const std::vector<MatchCase> &get_match_cases () const { return match_arms; }
std::vector<MatchCase> &get_match_cases () { return match_arms; }
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
- std::unique_ptr<Expr> &get_awaited_expr () { return awaited_expr; }
+ Expr &get_awaited_expr () { return *awaited_expr; }
ExprType get_expression_type () const final override
{
location_t get_locus () const override final { return locus; }
bool get_has_move () const { return has_move; }
- std::unique_ptr<BlockExpr> &get_block_expr () { return block_expr; }
+ BlockExpr &get_block_expr () { return *block_expr; }
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRExpressionVisitor &vis) override;
public:
OperatorExprMeta (HIR::CompoundAssignmentExpr &expr)
: node_mappings (expr.get_mappings ()),
- lvalue_mappings (expr.get_expr ()->get_mappings ()),
+ lvalue_mappings (expr.get_expr ().get_mappings ()),
locus (expr.get_locus ())
{}
OperatorExprMeta (HIR::ArithmeticOrLogicalExpr &expr)
: node_mappings (expr.get_mappings ()),
- lvalue_mappings (expr.get_expr ()->get_mappings ()),
+ lvalue_mappings (expr.get_expr ().get_mappings ()),
locus (expr.get_locus ())
{}
OperatorExprMeta (HIR::NegationExpr &expr)
: node_mappings (expr.get_mappings ()),
- lvalue_mappings (expr.get_expr ()->get_mappings ()),
+ lvalue_mappings (expr.get_expr ().get_mappings ()),
locus (expr.get_locus ())
{}
OperatorExprMeta (HIR::DereferenceExpr &expr)
: node_mappings (expr.get_mappings ()),
- lvalue_mappings (expr.get_expr ()->get_mappings ()),
+ lvalue_mappings (expr.get_expr ().get_mappings ()),
locus (expr.get_locus ())
{}
OperatorExprMeta (HIR::ArrayIndexExpr &expr)
: node_mappings (expr.get_mappings ()),
- lvalue_mappings (expr.get_array_expr ()->get_mappings ()),
+ lvalue_mappings (expr.get_array_expr ().get_mappings ()),
locus (expr.get_locus ())
{}
Identifier get_type_representation () const { return type_representation; }
- std::unique_ptr<Type> &get_type () { return type; }
+ Type &get_type () { return *type; }
Analysis::NodeMapping get_type_mappings () const
{
std::vector<LifetimeParam> &get_for_lifetimes () { return for_lifetimes; }
- std::unique_ptr<Type> &get_bound_type () { return bound_type; }
+ Type &get_bound_type () { return *bound_type; }
std::vector<std::unique_ptr<TypeParamBound>> &get_type_param_bounds ()
{
ImplicitSelfKind get_self_kind () const { return self_kind; }
- std::unique_ptr<Type> &get_type () { return type; }
+ Type &get_type () { return *type; }
Analysis::NodeMapping get_mappings () { return mappings; }
location_t get_locus () const { return locus; }
- std::unique_ptr<Pattern> &get_param_name () { return param_name; }
+ Pattern &get_param_name () { return *param_name; }
- std::unique_ptr<Type> &get_type () { return type; }
+ std::unique_ptr<Pattern> take_param_name () { return std::move (param_name); }
+
+ Type &get_type () { return *type; }
const Analysis::NodeMapping &get_mappings () const { return mappings; }
};
location_t get_locus () const override final { return locus; }
ItemKind get_item_kind () const override { return ItemKind::UseDeclaration; }
- std::unique_ptr<UseTree> &get_use_tree () { return use_tree; }
+ UseTree &get_use_tree () { return *use_tree; }
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRStmtVisitor &vis) override;
void accept_vis (HIRVisItemVisitor &vis) override;
}
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<BlockExpr> &get_definition () { return function_body; }
+ BlockExpr &get_definition () { return *function_body; }
const FunctionQualifiers &get_qualifiers () const { return qualifiers; }
bool has_return_type () const { return return_type != nullptr; }
// TODO: is this better? Or is a "vis_block" better?
- std::unique_ptr<Type> &get_return_type () { return return_type; }
+ Type &get_return_type () { return *return_type; }
bool is_method () const { return !self.is_error (); }
WhereClause &get_where_clause () { return where_clause; }
- std::unique_ptr<Type> &get_type_aliased () { return existing_type; }
+ Type &get_type_aliased () { return *existing_type; }
Identifier get_new_type_name () const { return new_type_name; }
Identifier get_field_name () const { return field_name; }
- std::unique_ptr<Type> &get_field_type () { return field_type; }
+ Type &get_field_type () { return *field_type; }
Analysis::NodeMapping get_mappings () const { return mappings; }
location_t get_locus () const { return locus; }
AST::AttrVec &get_outer_attrs () { return outer_attrs; }
- std::unique_ptr<HIR::Type> &get_field_type () { return field_type; }
+ HIR::Type &get_field_type () { return *field_type; }
};
// Rust tuple declared using struct keyword HIR node
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRStmtVisitor &vis) override;
- std::unique_ptr<Expr> &get_discriminant_expression () { return expression; }
+ Expr &get_discriminant_expression () { return *expression; }
+
+ std::unique_ptr<Expr> take_discriminant_expression ()
+ {
+ return std::move (expression);
+ }
protected:
// Clone function implementation as (not pure) virtual method
void accept_vis (HIRImplVisitor &vis) override;
void accept_vis (HIRVisItemVisitor &vis) override;
- std::unique_ptr<Type> &get_type () { return type; }
+ Type &get_type () { return *type; }
- std::unique_ptr<Expr> &get_expr () { return const_expr; }
+ Expr &get_expr () { return *const_expr; }
Identifier get_identifier () const { return identifier; }
bool is_mut () const { return mut == Mutability::Mut; }
- std::unique_ptr<Expr> &get_expr () { return expr; }
+ Expr &get_expr () { return *expr; }
- std::unique_ptr<Type> &get_type () { return type; }
+ Type &get_type () { return *type; }
ItemKind get_item_kind () const override { return ItemKind::Static; }
return generic_params;
}
- std::unique_ptr<Type> &get_return_type () { return return_type; }
+ Type &get_return_type () { return *return_type; }
std::vector<FunctionParam> &get_function_params () { return function_params; }
bool has_block_defined () const { return block_expr != nullptr; }
- std::unique_ptr<BlockExpr> &get_block_expr () { return block_expr; }
+ BlockExpr &get_block_expr () { return *block_expr; }
const std::string trait_identifier () const override final
{
bool has_expr () const { return expr != nullptr; }
- std::unique_ptr<Type> &get_type () { return type; }
+ Type &get_type () { return *type; }
- std::unique_ptr<Expr> &get_expr () { return expr; }
+ Expr &get_expr () { return *expr; }
const std::string trait_identifier () const override final
{
location_t get_locus () const override final { return locus; }
- std::unique_ptr<Type> &get_type () { return impl_type; };
+ Type &get_type () { return *impl_type; };
+
+ bool has_type () { return impl_type == nullptr; }
std::vector<std::unique_ptr<GenericParam>> &get_generic_params ()
{
bool has_trait_ref () const { return trait_ref != nullptr; }
- std::unique_ptr<TypePath> &get_trait_ref () { return trait_ref; }
+ TypePath &get_trait_ref () { return *trait_ref; }
WhereClause &get_where_clause () { return where_clause; }
Mutability get_mut () { return mut; }
- std::unique_ptr<Type> &get_item_type () { return item_type; }
+ Type &get_item_type () { return *item_type; }
ExternKind get_extern_kind () override { return ExternKind::Static; }
Identifier get_param_name () const { return name; }
- std::unique_ptr<Type> &get_type () { return param_type; }
+ Type &get_type () { return *param_type; }
Analysis::NodeMapping get_mappings () const { return mappings; }
};
return generic_params;
}
- std::unique_ptr<Type> &get_return_type () { return return_type; }
+ Type &get_return_type () { return *return_type; }
std::vector<NamedFunctionParam> &get_function_params ()
{
Identifier &get_identifier () { return identifier; }
const Identifier &get_identifier () const { return identifier; }
- std::unique_ptr<Type> &get_type () { return type; }
- const std::unique_ptr<Type> &get_type () const { return type; }
+ Type &get_type () { return *type; }
+ const Type &get_type () const { return *type; }
location_t get_locus () const { return locus; }
};
TypePathFunction (TypePathFunction const &other)
{
return_type = other.has_return_type ()
- ? other.get_return_type ()->clone_type ()
+ ? other.get_return_type ().clone_type ()
: nullptr;
inputs.reserve (other.inputs.size ());
TypePathFunction &operator= (TypePathFunction const &other)
{
return_type = other.has_return_type ()
- ? other.get_return_type ()->clone_type ()
+ ? other.get_return_type ().clone_type ()
: nullptr;
inputs.reserve (other.inputs.size ());
};
std::vector<std::unique_ptr<Type> > &get_params () { return inputs; };
- const std::unique_ptr<Type> &get_return_type () const { return return_type; };
- std::unique_ptr<Type> &get_return_type () { return return_type; };
+ const Type &get_return_type () const { return *return_type; };
+ Type &get_return_type () { return *return_type; };
};
// Segment used in type path with a function argument
Analysis::NodeMapping get_mappings () const { return mappings; }
- std::unique_ptr<Type> &get_type () { return type; }
+ Type &get_type () { return *type; }
- std::unique_ptr<TypePath> &get_trait () { return trait; }
+ TypePath &get_trait () { return *trait; }
bool trait_has_generic_args () const
{
QualifiedPathType &get_path_type () { return path_type; }
- std::unique_ptr<TypePathSegment> &get_associated_segment ()
- {
- return associated_segment;
- }
+ TypePathSegment &get_associated_segment () { return *associated_segment; }
std::vector<std::unique_ptr<TypePathSegment> > &get_segments ()
{
bool is_mut () const { return mut == Mutability::Mut; }
bool get_is_ref () const { return is_ref; }
- std::unique_ptr<Pattern> &get_to_bind () { return to_bind; }
+ Pattern &get_to_bind () { return *to_bind; }
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRPatternVisitor &vis) override;
return PatternType::RANGE;
}
- std::unique_ptr<RangePatternBound> &get_lower_bound () { return lower; }
+ RangePatternBound &get_lower_bound () { return *lower; }
- std::unique_ptr<RangePatternBound> &get_upper_bound () { return upper; }
+ RangePatternBound &get_upper_bound () { return *upper; }
protected:
/* Use covariance to implement clone function as returning this object rather
return PatternType::REFERENCE;
}
- std::unique_ptr<Pattern> &get_referenced_pattern () { return pattern; }
+ Pattern &get_referenced_pattern () { return *pattern; }
protected:
/* Use covariance to implement clone function as returning this object rather
void accept_vis (HIRFullVisitor &vis) override;
TupleIndex get_index () { return index; }
- std::unique_ptr<Pattern> &get_tuple_pattern () { return tuple_pattern; }
+ Pattern &get_tuple_pattern () { return *tuple_pattern; }
ItemType get_item_type () const override final { return ItemType::TUPLE_PAT; }
Identifier get_identifier () const { return ident; }
- std::unique_ptr<Pattern> &get_pattern () { return ident_pattern; }
+ Pattern &get_pattern () { return *ident_pattern; }
protected:
/* Use covariance to implement clone function as returning this object rather
PathInExpression &get_path () { return path; }
- std::unique_ptr<TupleStructItems> &get_items () { return items; }
+ TupleStructItems &get_items () { return *items; }
const Analysis::NodeMapping &get_mappings () const override final
{
return PatternType::TUPLE;
}
- std::unique_ptr<TuplePatternItems> &get_items () { return items; }
- const std::unique_ptr<TuplePatternItems> &get_items () const { return items; }
+ TuplePatternItems &get_items () { return *items; }
+ const TuplePatternItems &get_items () const { return *items; }
protected:
/* Use covariance to implement clone function as returning this object rather
}
std::vector<AST::Attribute> &get_outer_attrs () { return outer_attrs; }
- std::unique_ptr<HIR::Type> &get_type () { return type; }
+ HIR::Type &get_type () { return *type; }
- std::unique_ptr<HIR::Expr> &get_init_expr () { return init_expr; }
+ HIR::Expr &get_init_expr () { return *init_expr; }
- std::unique_ptr<HIR::Pattern> &get_pattern () { return variables_pattern; }
+ HIR::Pattern &get_pattern () { return *variables_pattern; }
bool is_item () const override final { return false; }
bool is_item () const override final { return false; }
- std::unique_ptr<Expr> &get_expr () { return expr; }
+ Expr &get_expr () { return *expr; }
// Copy constructor with clone
ExprStmt (ExprStmt const &other)
* parenthesised type, it must be in parentheses. */
return type_in_parens->to_trait_bound (true);
}
- std::unique_ptr<Type> &get_type_in_parens () { return type_in_parens; }
+ Type &get_type_in_parens () { return *type_in_parens; }
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRTypeVisitor &vis) override;
};
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRTypeVisitor &vis) override;
- std::unique_ptr<Type> &get_type () { return type; }
+ Type &get_type () { return *type; }
Mutability get_mut () const { return mut; }
bool is_const () const { return mut == Mutability::Imm; }
- std::unique_ptr<Type> &get_base_type () { return type; }
+ Type &get_base_type () { return *type; }
protected:
/* Use covariance to implement clone function as returning this object rather
Mutability get_mut () const { return mut; }
- std::unique_ptr<Type> &get_base_type () { return type; }
+ Type &get_base_type () { return *type; }
protected:
/* Use covariance to implement clone function as returning this object rather
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRTypeVisitor &vis) override;
- std::unique_ptr<Type> &get_element_type () { return elem_type; }
+ Type &get_element_type () { return *elem_type; }
- std::unique_ptr<Expr> &get_size_expr () { return size; }
+ Expr &get_size_expr () { return *size; }
protected:
/* Use covariance to implement clone function as returning this object rather
void accept_vis (HIRFullVisitor &vis) override;
void accept_vis (HIRTypeVisitor &vis) override;
- std::unique_ptr<Type> &get_element_type () { return elem_type; }
+ Type &get_element_type () { return *elem_type; }
protected:
/* Use covariance to implement clone function as returning this object rather
location_t get_locus () const { return locus; }
- std::unique_ptr<Type> &get_type () { return param_type; }
+ Type &get_type () { return *param_type; }
ParamKind get_param_kind () const { return param_kind; }
}
// TODO: would a "vis_type" be better?
- std::unique_ptr<Type> &get_return_type () { return return_type; }
+ Type &get_return_type () { return *return_type; }
protected:
/* Use covariance to implement clone function as returning this object rather
bool has_default_expression () { return default_expression != nullptr; }
std::string get_name () { return name; }
- std::unique_ptr<Type> &get_type () { return type; }
- std::unique_ptr<Expr> &get_default_expression ()
- {
- return default_expression;
- }
+ Type &get_type () { return *type; }
+ Expr &get_default_expression () { return *default_expression; }
protected:
/* Use covariance to implement clone function as returning this object rather
== 0)
{
TraitReference *trait_reference
- = TraitResolver::Lookup (*parent->get_trait_ref ().get ());
+ = TraitResolver::Lookup (parent->get_trait_ref ());
if (!trait_reference->is_error ())
{
TyTy::BaseType *lookup = nullptr;
};
std::vector<trait_item_candidate> trait_fns;
- mappings.iterate_impl_blocks (
- [&] (HirId id, HIR::ImplBlock *impl) mutable -> bool {
- bool is_trait_impl = impl->has_trait_ref ();
- if (!is_trait_impl)
- return true;
-
- // look for impl implementation else lookup the associated trait item
- for (auto &impl_item : impl->get_impl_items ())
- {
- bool is_fn = impl_item->get_impl_item_type ()
- == HIR::ImplItem::ImplItemType::FUNCTION;
- if (!is_fn)
- continue;
-
- HIR::Function *func = static_cast<HIR::Function *> (impl_item.get ());
- if (!func->is_method ())
- continue;
-
- bool name_matches = func->get_function_name ().as_string ().compare (
- segment_name.as_string ())
- == 0;
- if (!name_matches)
- continue;
-
- TyTy::BaseType *ty = nullptr;
- if (!query_type (func->get_mappings ().get_hirid (), &ty))
- continue;
- if (ty->get_kind () == TyTy::TypeKind::ERROR)
- continue;
-
- rust_assert (ty->get_kind () == TyTy::TypeKind::FNDEF);
- TyTy::FnType *fnty = static_cast<TyTy::FnType *> (ty);
- const TyTy::BaseType *impl_self
- = TypeCheckItem::ResolveImplBlockSelf (*impl);
-
- // see:
- // https://gcc-rust.zulipchat.com/#narrow/stream/266897-general/topic/Method.20Resolution/near/338646280
- // https://github.com/rust-lang/rust/blob/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/compiler/rustc_typeck/src/check/method/probe.rs#L650-L660
- bool impl_self_is_ptr
- = impl_self->get_kind () == TyTy::TypeKind::POINTER;
- bool impl_self_is_ref = impl_self->get_kind () == TyTy::TypeKind::REF;
- if (receiver_is_raw_ptr && impl_self_is_ptr)
- {
- const TyTy::PointerType &sptr
- = *static_cast<const TyTy::PointerType *> (impl_self);
- const TyTy::PointerType &ptr
- = *static_cast<const TyTy::PointerType *> (raw);
-
- // we could do this via lang-item assemblies if we refactor this
- bool mut_match = sptr.mutability () == ptr.mutability ();
- if (!mut_match)
- continue;
- }
- else if (receiver_is_ref && impl_self_is_ref)
- {
- const TyTy::ReferenceType &sptr
- = *static_cast<const TyTy::ReferenceType *> (impl_self);
- const TyTy::ReferenceType &ptr
- = *static_cast<const TyTy::ReferenceType *> (raw);
-
- // we could do this via lang-item assemblies if we refactor this
- bool mut_match = sptr.mutability () == ptr.mutability ();
- if (!mut_match)
- continue;
- }
+ mappings.iterate_impl_blocks ([&] (HirId id,
+ HIR::ImplBlock *impl) mutable -> bool {
+ bool is_trait_impl = impl->has_trait_ref ();
+ if (!is_trait_impl)
+ return true;
- inherent_impl_fns.push_back ({func, impl, fnty});
- return true;
- }
+ // look for impl implementation else lookup the associated trait item
+ for (auto &impl_item : impl->get_impl_items ())
+ {
+ bool is_fn = impl_item->get_impl_item_type ()
+ == HIR::ImplItem::ImplItemType::FUNCTION;
+ if (!is_fn)
+ continue;
+
+ HIR::Function *func = static_cast<HIR::Function *> (impl_item.get ());
+ if (!func->is_method ())
+ continue;
+
+ bool name_matches = func->get_function_name ().as_string ().compare (
+ segment_name.as_string ())
+ == 0;
+ if (!name_matches)
+ continue;
+
+ TyTy::BaseType *ty = nullptr;
+ if (!query_type (func->get_mappings ().get_hirid (), &ty))
+ continue;
+ if (ty->get_kind () == TyTy::TypeKind::ERROR)
+ continue;
+
+ rust_assert (ty->get_kind () == TyTy::TypeKind::FNDEF);
+ TyTy::FnType *fnty = static_cast<TyTy::FnType *> (ty);
+ const TyTy::BaseType *impl_self
+ = TypeCheckItem::ResolveImplBlockSelf (*impl);
+
+ // see:
+ // https://gcc-rust.zulipchat.com/#narrow/stream/266897-general/topic/Method.20Resolution/near/338646280
+ // https://github.com/rust-lang/rust/blob/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/compiler/rustc_typeck/src/check/method/probe.rs#L650-L660
+ bool impl_self_is_ptr
+ = impl_self->get_kind () == TyTy::TypeKind::POINTER;
+ bool impl_self_is_ref = impl_self->get_kind () == TyTy::TypeKind::REF;
+ if (receiver_is_raw_ptr && impl_self_is_ptr)
+ {
+ const TyTy::PointerType &sptr
+ = *static_cast<const TyTy::PointerType *> (impl_self);
+ const TyTy::PointerType &ptr
+ = *static_cast<const TyTy::PointerType *> (raw);
+
+ // we could do this via lang-item assemblies if we refactor this
+ bool mut_match = sptr.mutability () == ptr.mutability ();
+ if (!mut_match)
+ continue;
+ }
+ else if (receiver_is_ref && impl_self_is_ref)
+ {
+ const TyTy::ReferenceType &sptr
+ = *static_cast<const TyTy::ReferenceType *> (impl_self);
+ const TyTy::ReferenceType &ptr
+ = *static_cast<const TyTy::ReferenceType *> (raw);
+
+ // we could do this via lang-item assemblies if we refactor this
+ bool mut_match = sptr.mutability () == ptr.mutability ();
+ if (!mut_match)
+ continue;
+ }
+
+ inherent_impl_fns.push_back ({func, impl, fnty});
+ return true;
+ }
- TraitReference *trait_ref
- = TraitResolver::Resolve (*impl->get_trait_ref ().get ());
- rust_assert (!trait_ref->is_error ());
+ TraitReference *trait_ref = TraitResolver::Resolve (impl->get_trait_ref ());
+ rust_assert (!trait_ref->is_error ());
- auto item_ref
- = trait_ref->lookup_trait_item (segment_name.as_string (),
- TraitItemReference::TraitItemType::FN);
- if (item_ref->is_error ())
- return true;
+ auto item_ref
+ = trait_ref->lookup_trait_item (segment_name.as_string (),
+ TraitItemReference::TraitItemType::FN);
+ if (item_ref->is_error ())
+ return true;
- const HIR::Trait *trait = trait_ref->get_hir_trait_ref ();
- HIR::TraitItem *item = item_ref->get_hir_trait_item ();
- if (item->get_item_kind () != HIR::TraitItem::TraitItemKind::FUNC)
- return true;
+ const HIR::Trait *trait = trait_ref->get_hir_trait_ref ();
+ HIR::TraitItem *item = item_ref->get_hir_trait_item ();
+ if (item->get_item_kind () != HIR::TraitItem::TraitItemKind::FUNC)
+ return true;
- HIR::TraitItemFunc *func = static_cast<HIR::TraitItemFunc *> (item);
- if (!func->get_decl ().is_method ())
- return true;
+ HIR::TraitItemFunc *func = static_cast<HIR::TraitItemFunc *> (item);
+ if (!func->get_decl ().is_method ())
+ return true;
- TyTy::BaseType *ty = item_ref->get_tyty ();
- rust_assert (ty->get_kind () == TyTy::TypeKind::FNDEF);
- TyTy::FnType *fnty = static_cast<TyTy::FnType *> (ty);
+ TyTy::BaseType *ty = item_ref->get_tyty ();
+ rust_assert (ty->get_kind () == TyTy::TypeKind::FNDEF);
+ TyTy::FnType *fnty = static_cast<TyTy::FnType *> (ty);
- trait_item_candidate candidate{func, trait, fnty, trait_ref, item_ref};
- trait_fns.push_back (candidate);
+ trait_item_candidate candidate{func, trait, fnty, trait_ref, item_ref};
+ trait_fns.push_back (candidate);
- return true;
- });
+ return true;
+ });
// lookup specified bounds for an associated item
struct precdicate_candidate
// impl-type -> [ (item, name), ... ]
// }
- HirId impl_type_id = impl->get_type ()->get_mappings ().get_hirid ();
+ HirId impl_type_id = impl->get_type ().get_mappings ().get_hirid ();
TyTy::BaseType *impl_type = nullptr;
bool ok = query_type (impl_type_id, &impl_type);
if (!ok)
HIR::ImplBlock *impl)
{
current_impl = impl;
- HirId impl_ty_id = impl->get_type ()->get_mappings ().get_hirid ();
+ HirId impl_ty_id = impl->get_type ().get_mappings ().get_hirid ();
TyTy::BaseType *impl_block_ty = nullptr;
if (!query_type (impl_ty_id, &impl_block_ty))
return;
if (!impl->has_trait_ref ())
return true;
- TraitReference *resolved
- = TraitResolver::Lookup (*(impl->get_trait_ref ().get ()));
+ TraitReference *resolved = TraitResolver::Lookup (impl->get_trait_ref ());
if (!trait_reference->is_equal (*resolved))
return true;
// The one exception is the implicit Self type of a trait
bool apply_sized = !is_self;
auto param_type
- = TypeResolveGenericParam::Resolve (generic_param.get (),
- apply_sized);
+ = TypeResolveGenericParam::Resolve (*generic_param, apply_sized);
context->insert_type (generic_param->get_mappings (), param_type);
substitutions.push_back (
TyTy::SubstitutionParamMapping (typaram, param_type));
auto predicate = get_predicate_from_bound (
b->get_path (),
- nullptr /*this will setup a PLACEHOLDER for self*/);
+ tl::nullopt /*this will setup a PLACEHOLDER for self*/);
if (predicate.is_error ())
return &TraitReference::error_node ();
auto expected_ret_tyty = resolved_fn_type->get_return_type ();
context->push_return_type (TypeCheckContextItem (&func), expected_ret_tyty);
- auto block_expr_ty = TypeCheckExpr::Resolve (func.get_block_expr ().get ());
+ auto block_expr_ty = TypeCheckExpr::Resolve (func.get_block_expr ());
location_t fn_return_locus
= func.get_decl ().has_return_type ()
- ? func.get_decl ().get_return_type ()->get_locus ()
+ ? func.get_decl ().get_return_type ().get_locus ()
: func.get_locus ();
coercion_site (func.get_mappings ().get_hirid (),
break;
case HIR::GenericParam::GenericKind::CONST: {
- auto param
- = static_cast<HIR::ConstGenericParam *> (generic_param.get ());
- auto specified_type
- = TypeCheckType::Resolve (param->get_type ().get ());
+ auto ¶m
+ = static_cast<HIR::ConstGenericParam &> (*generic_param);
+ auto specified_type = TypeCheckType::Resolve (param.get_type ());
- if (param->has_default_expression ())
+ if (param.has_default_expression ())
{
- auto expr_type = TypeCheckExpr::Resolve (
- param->get_default_expression ().get ());
-
- coercion_site (
- param->get_mappings ().get_hirid (),
- TyTy::TyWithLocation (specified_type),
- TyTy::TyWithLocation (
- expr_type, param->get_default_expression ()->get_locus ()),
- param->get_locus ());
+ auto expr_type
+ = TypeCheckExpr::Resolve (param.get_default_expression ());
+
+ coercion_site (param.get_mappings ().get_hirid (),
+ TyTy::TyWithLocation (specified_type),
+ TyTy::TyWithLocation (
+ expr_type,
+ param.get_default_expression ().get_locus ()),
+ param.get_locus ());
}
context->insert_type (generic_param->get_mappings (),
break;
case HIR::GenericParam::GenericKind::TYPE: {
- auto param_type
- = TypeResolveGenericParam::Resolve (generic_param.get ());
+ auto param_type = TypeResolveGenericParam::Resolve (*generic_param);
context->insert_type (generic_param->get_mappings (), param_type);
substitutions.push_back (TyTy::SubstitutionParamMapping (
TraitReference *resolve_trait_path (HIR::TypePath &);
- TyTy::TypeBoundPredicate
- get_predicate_from_bound (HIR::TypePath &path, HIR::Type *associated_self,
- BoundPolarity polarity
- = BoundPolarity::RegularBound);
+ TyTy::TypeBoundPredicate get_predicate_from_bound (
+ HIR::TypePath &path,
+ tl::optional<std::reference_wrapper<HIR::Type>> associated_self,
+ BoundPolarity polarity = BoundPolarity::RegularBound);
bool check_for_unconstrained (
const std::vector<TyTy::SubstitutionParamMapping> ¶ms_to_constrain,
location_t locus);
void resolve_generic_params (
- const std::vector<std::unique_ptr<HIR::GenericParam> > &generic_params,
+ const std::vector<std::unique_ptr<HIR::GenericParam>> &generic_params,
std::vector<TyTy::SubstitutionParamMapping> &substitutions);
TyTy::TypeBoundPredicate get_marker_predicate (LangItem::Kind item_type,
// along with GCC; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
+#include "rust-hir-expr.h"
#include "rust-hir-type-check-type.h"
#include "rust-hir-type-check-expr.h"
#include "rust-hir-type-check-enumitem.h"
namespace Resolver {
TyTy::VariantDef *
-TypeCheckEnumItem::Resolve (HIR::EnumItem *item, int64_t last_discriminant)
+TypeCheckEnumItem::Resolve (HIR::EnumItem &item, int64_t last_discriminant)
{
TypeCheckEnumItem resolver (last_discriminant);
- switch (item->get_enum_item_kind ())
+ switch (item.get_enum_item_kind ())
{
case HIR::EnumItem::EnumItemKind::Named:
- resolver.visit (static_cast<HIR::EnumItem &> (*item));
+ resolver.visit (static_cast<HIR::EnumItem &> (item));
break;
case HIR::EnumItem::EnumItemKind::Tuple:
- resolver.visit (static_cast<HIR::EnumItemTuple &> (*item));
+ resolver.visit (static_cast<HIR::EnumItemTuple &> (item));
break;
case HIR::EnumItem::EnumItemKind::Struct:
- resolver.visit (static_cast<HIR::EnumItemStruct &> (*item));
+ resolver.visit (static_cast<HIR::EnumItemStruct &> (item));
break;
case HIR::EnumItem::EnumItemKind::Discriminant:
- resolver.visit (static_cast<HIR::EnumItemDiscriminant &> (*item));
+ resolver.visit (static_cast<HIR::EnumItemDiscriminant &> (item));
break;
}
return resolver.variant;
mappings.get_next_hir_id (
item.get_mappings ().get_crate_num ()),
item.get_mappings ().get_local_defid ());
- HIR::LiteralExpr *discim_expr
- = new HIR::LiteralExpr (mapping, std::to_string (last_discriminant),
- HIR::Literal::LitType::INT,
- PrimitiveCoreType::CORETYPE_I64, item.get_locus (),
- {});
+ auto discim_expr = Rust::make_unique<HIR::LiteralExpr> (
+ HIR::LiteralExpr (mapping, std::to_string (last_discriminant),
+ HIR::Literal::LitType::INT,
+ PrimitiveCoreType::CORETYPE_I64, item.get_locus (), {}));
TyTy::BaseType *isize = nullptr;
bool ok = context->lookup_builtin ("isize", &isize);
variant = new TyTy::VariantDef (item.get_mappings ().get_hirid (),
item.get_mappings ().get_defid (),
item.get_identifier ().as_string (), ident,
- discim_expr);
+ std::move (discim_expr));
}
void
rust_error_at (item.get_locus (), "discriminant too big");
auto &discriminant = item.get_discriminant_expression ();
- auto capacity_type = TypeCheckExpr::Resolve (discriminant.get ());
+ auto capacity_type = TypeCheckExpr::Resolve (discriminant);
if (capacity_type->get_kind () == TyTy::TypeKind::ERROR)
return;
TyTy::ISizeType *expected_ty
- = new TyTy::ISizeType (discriminant->get_mappings ().get_hirid ());
- context->insert_type (discriminant->get_mappings (), expected_ty);
+ = new TyTy::ISizeType (discriminant.get_mappings ().get_hirid ());
+ context->insert_type (discriminant.get_mappings (), expected_ty);
unify_site (item.get_mappings ().get_hirid (),
TyTy::TyWithLocation (expected_ty),
variant = new TyTy::VariantDef (item.get_mappings ().get_hirid (),
item.get_mappings ().get_defid (),
item.get_identifier ().as_string (), ident,
- item.get_discriminant_expression ().get ());
+ item.take_discriminant_expression ());
}
void
for (auto &field : item.get_tuple_fields ())
{
TyTy::BaseType *field_type
- = TypeCheckType::Resolve (field.get_field_type ().get ());
+ = TypeCheckType::Resolve (field.get_field_type ());
TyTy::StructFieldType *ty_field
= new TyTy::StructFieldType (field.get_mappings ().get_hirid (),
std::to_string (idx), field_type,
mappings.get_next_hir_id (
item.get_mappings ().get_crate_num ()),
item.get_mappings ().get_local_defid ());
- HIR::LiteralExpr *discim_expr
- = new HIR::LiteralExpr (mapping, std::to_string (last_discriminant),
- HIR::Literal::LitType::INT,
- PrimitiveCoreType::CORETYPE_I64, item.get_locus (),
- {});
+ auto discim_expr = Rust::make_unique<HIR::LiteralExpr> (
+ HIR::LiteralExpr (mapping, std::to_string (last_discriminant),
+ HIR::Literal::LitType::INT,
+ PrimitiveCoreType::CORETYPE_I64, item.get_locus (), {}));
TyTy::BaseType *isize = nullptr;
bool ok = context->lookup_builtin ("isize", &isize);
item.get_mappings ().get_defid (),
item.get_identifier ().as_string (), ident,
TyTy::VariantDef::VariantType::TUPLE,
- discim_expr, fields);
+ std::move (discim_expr), fields);
}
void
for (auto &field : item.get_struct_fields ())
{
TyTy::BaseType *field_type
- = TypeCheckType::Resolve (field.get_field_type ().get ());
+ = TypeCheckType::Resolve (field.get_field_type ());
TyTy::StructFieldType *ty_field
= new TyTy::StructFieldType (field.get_mappings ().get_hirid (),
field.get_field_name ().as_string (),
mappings.get_next_hir_id (
item.get_mappings ().get_crate_num ()),
item.get_mappings ().get_local_defid ());
- HIR::LiteralExpr *discrim_expr
- = new HIR::LiteralExpr (mapping, std::to_string (last_discriminant),
- HIR::Literal::LitType::INT,
- PrimitiveCoreType::CORETYPE_I64, item.get_locus (),
- {});
+ auto discrim_expr = Rust::make_unique<HIR::LiteralExpr> (
+ HIR::LiteralExpr (mapping, std::to_string (last_discriminant),
+ HIR::Literal::LitType::INT,
+ PrimitiveCoreType::CORETYPE_I64, item.get_locus (), {}));
TyTy::BaseType *isize = nullptr;
bool ok = context->lookup_builtin ("isize", &isize);
item.get_mappings ().get_defid (),
item.get_identifier ().as_string (), ident,
TyTy::VariantDef::VariantType::STRUCT,
- discrim_expr, fields);
+ std::move (discrim_expr), fields);
}
} // namespace Resolver
class TypeCheckEnumItem : public TypeCheckBase
{
public:
- static TyTy::VariantDef *Resolve (HIR::EnumItem *item,
+ static TyTy::VariantDef *Resolve (HIR::EnumItem &item,
int64_t last_discriminant);
protected:
// Perform type checking on expr. Also runs type unification algorithm.
// Returns the unified type of expr
TyTy::BaseType *
-TypeCheckExpr::Resolve (HIR::Expr *expr)
+TypeCheckExpr::Resolve (HIR::Expr &expr)
{
TypeCheckExpr resolver;
- expr->accept_vis (resolver);
+ expr.accept_vis (resolver);
if (resolver.infered == nullptr)
- return new TyTy::ErrorType (expr->get_mappings ().get_hirid ());
+ return new TyTy::ErrorType (expr.get_mappings ().get_hirid ());
- auto ref = expr->get_mappings ().get_hirid ();
+ auto ref = expr.get_mappings ().get_hirid ();
resolver.infered->set_ref (ref);
- resolver.context->insert_type (expr->get_mappings (), resolver.infered);
+ resolver.context->insert_type (expr.get_mappings (), resolver.infered);
return resolver.infered;
}
void
TypeCheckExpr::visit (HIR::TupleIndexExpr &expr)
{
- auto resolved = TypeCheckExpr::Resolve (expr.get_tuple_expr ().get ());
+ auto resolved = TypeCheckExpr::Resolve (expr.get_tuple_expr ());
if (resolved->get_kind () == TyTy::TypeKind::ERROR)
{
- rust_error_at (expr.get_tuple_expr ()->get_locus (),
+ rust_error_at (expr.get_tuple_expr ().get_locus (),
"failed to resolve TupleIndexExpr receiver");
return;
}
|| resolved->get_kind () == TyTy::TypeKind::TUPLE;
if (!is_valid_type)
{
- rust_error_at (expr.get_tuple_expr ()->get_locus (),
+ rust_error_at (expr.get_tuple_expr ().get_locus (),
"Expected Tuple or ADT got: %s",
resolved->as_string ().c_str ());
return;
std::vector<TyTy::TyVar> fields;
for (auto &elem : expr.get_tuple_elems ())
{
- auto field_ty = TypeCheckExpr::Resolve (elem.get ());
+ auto field_ty = TypeCheckExpr::Resolve (*elem);
fields.push_back (TyTy::TyVar (field_ty->get_ref ()));
}
infered = new TyTy::TupleType (expr.get_mappings ().get_hirid (),
auto fn_return_tyty = context->peek_return_type ();
location_t expr_locus = expr.has_return_expr ()
- ? expr.get_expr ()->get_locus ()
+ ? expr.get_expr ().get_locus ()
: expr.get_locus ();
+
TyTy::BaseType *expr_ty = expr.has_return_expr ()
- ? TypeCheckExpr::Resolve (expr.get_expr ().get ())
+ ? TypeCheckExpr::Resolve (expr.get_expr ())
: TyTy::TupleType::get_unit_type ();
coercion_site (expr.get_mappings ().get_hirid (),
void
TypeCheckExpr::visit (HIR::CallExpr &expr)
{
- TyTy::BaseType *function_tyty
- = TypeCheckExpr::Resolve (expr.get_fnexpr ().get ());
+ TyTy::BaseType *function_tyty = TypeCheckExpr::Resolve (expr.get_fnexpr ());
rust_debug_loc (expr.get_locus (), "resolved_call_expr to: {%s}",
function_tyty->get_name ().c_str ());
// lookup variant id
HirId variant_id;
bool ok = context->lookup_variant_definition (
- expr.get_fnexpr ()->get_mappings ().get_hirid (), &variant_id);
+ expr.get_fnexpr ().get_mappings ().get_hirid (), &variant_id);
if (!ok)
{
ok = adt->lookup_variant_by_id (variant_id, &lookup_variant);
rust_assert (ok);
- variant = *lookup_variant;
+ variant = std::move (*lookup_variant);
}
else
{
rust_assert (adt->number_of_variants () == 1);
- variant = *adt->get_variants ().at (0);
+ variant = std::move (*adt->get_variants ().at (0));
}
infered
{
infered = TyTy::TupleType::get_unit_type ();
- auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ().get ());
- auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ().get ());
+ auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ());
+ auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ());
coercion_site (expr.get_mappings ().get_hirid (),
- TyTy::TyWithLocation (lhs, expr.get_lhs ()->get_locus ()),
- TyTy::TyWithLocation (rhs, expr.get_rhs ()->get_locus ()),
+ TyTy::TyWithLocation (lhs, expr.get_lhs ().get_locus ()),
+ TyTy::TyWithLocation (rhs, expr.get_rhs ().get_locus ()),
expr.get_locus ());
}
{
infered = TyTy::TupleType::get_unit_type ();
- auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ().get ());
- auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ().get ());
+ auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ());
+ auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ());
// we dont care about the result of the unify from a compound assignment
// since this is a unit-type expr
coercion_site (expr.get_mappings ().get_hirid (),
- TyTy::TyWithLocation (lhs, expr.get_lhs ()->get_locus ()),
- TyTy::TyWithLocation (rhs, expr.get_rhs ()->get_locus ()),
+ TyTy::TyWithLocation (lhs, expr.get_lhs ().get_locus ()),
+ TyTy::TyWithLocation (rhs, expr.get_rhs ().get_locus ()),
expr.get_locus ());
auto lang_item_type
void
TypeCheckExpr::visit (HIR::ArithmeticOrLogicalExpr &expr)
{
- auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ().get ());
- auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ().get ());
+ auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ());
+ auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ());
auto lang_item_type = LangItem::OperatorToLangItem (expr.get_expr_type ());
bool operator_overloaded
{
case ArithmeticOrLogicalOperator::LEFT_SHIFT:
case ArithmeticOrLogicalOperator::RIGHT_SHIFT: {
- TyTy::TyWithLocation from (rhs, expr.get_rhs ()->get_locus ());
- TyTy::TyWithLocation to (lhs, expr.get_lhs ()->get_locus ());
+ TyTy::TyWithLocation from (rhs, expr.get_rhs ().get_locus ());
+ TyTy::TyWithLocation to (lhs, expr.get_lhs ().get_locus ());
infered = cast_site (expr.get_mappings ().get_hirid (), from, to,
expr.get_locus ());
}
default: {
infered = unify_site (
expr.get_mappings ().get_hirid (),
- TyTy::TyWithLocation (lhs, expr.get_lhs ()->get_locus ()),
- TyTy::TyWithLocation (rhs, expr.get_rhs ()->get_locus ()),
+ TyTy::TyWithLocation (lhs, expr.get_lhs ().get_locus ()),
+ TyTy::TyWithLocation (rhs, expr.get_rhs ().get_locus ()),
expr.get_locus ());
}
break;
void
TypeCheckExpr::visit (HIR::ComparisonExpr &expr)
{
- auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ().get ());
- auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ().get ());
+ auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ());
+ auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ());
unify_site (expr.get_mappings ().get_hirid (),
- TyTy::TyWithLocation (lhs, expr.get_lhs ()->get_locus ()),
- TyTy::TyWithLocation (rhs, expr.get_rhs ()->get_locus ()),
+ TyTy::TyWithLocation (lhs, expr.get_lhs ().get_locus ()),
+ TyTy::TyWithLocation (rhs, expr.get_rhs ().get_locus ()),
expr.get_locus ());
bool ok = context->lookup_builtin ("bool", &infered);
void
TypeCheckExpr::visit (HIR::LazyBooleanExpr &expr)
{
- auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ().get ());
- auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ().get ());
+ auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ());
+ auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ());
// we expect the lhs and rhs must be bools at this point
TyTy::BaseType *boolean_node = nullptr;
// verify the lhs and rhs before unifying together
lhs = unify_site (expr.get_mappings ().get_hirid (),
TyTy::TyWithLocation (boolean_node,
- expr.get_lhs ()->get_locus ()),
- TyTy::TyWithLocation (lhs, expr.get_lhs ()->get_locus ()),
+ expr.get_lhs ().get_locus ()),
+ TyTy::TyWithLocation (lhs, expr.get_lhs ().get_locus ()),
expr.get_locus ());
rhs = unify_site (expr.get_mappings ().get_hirid (),
TyTy::TyWithLocation (boolean_node,
- expr.get_rhs ()->get_locus ()),
- TyTy::TyWithLocation (rhs, expr.get_rhs ()->get_locus ()),
+ expr.get_rhs ().get_locus ()),
+ TyTy::TyWithLocation (rhs, expr.get_rhs ().get_locus ()),
expr.get_locus ());
infered
= unify_site (expr.get_mappings ().get_hirid (),
- TyTy::TyWithLocation (lhs, expr.get_lhs ()->get_locus ()),
- TyTy::TyWithLocation (rhs, expr.get_rhs ()->get_locus ()),
+ TyTy::TyWithLocation (lhs, expr.get_lhs ().get_locus ()),
+ TyTy::TyWithLocation (rhs, expr.get_rhs ().get_locus ()),
expr.get_locus ());
}
void
TypeCheckExpr::visit (HIR::NegationExpr &expr)
{
- auto negated_expr_ty = TypeCheckExpr::Resolve (expr.get_expr ().get ());
+ auto negated_expr_ty = TypeCheckExpr::Resolve (expr.get_expr ());
// check for operator overload
auto lang_item_type
bool ok = context->lookup_builtin ("bool", &bool_ty);
rust_assert (ok);
- TyTy::BaseType *cond_type
- = TypeCheckExpr::Resolve (expr.get_if_condition ().get ());
+ TyTy::BaseType *cond_type = TypeCheckExpr::Resolve (expr.get_if_condition ());
unify_site (expr.get_mappings ().get_hirid (), TyTy::TyWithLocation (bool_ty),
TyTy::TyWithLocation (cond_type,
- expr.get_if_condition ()->get_locus ()),
+ expr.get_if_condition ().get_locus ()),
expr.get_locus ());
- TypeCheckExpr::Resolve (expr.get_if_block ().get ());
+ TypeCheckExpr::Resolve (expr.get_if_block ());
infered = TyTy::TupleType::get_unit_type ();
}
bool ok = context->lookup_builtin ("bool", &bool_ty);
rust_assert (ok);
- TyTy::BaseType *cond_type
- = TypeCheckExpr::Resolve (expr.get_if_condition ().get ());
+ TyTy::BaseType *cond_type = TypeCheckExpr::Resolve (expr.get_if_condition ());
unify_site (expr.get_mappings ().get_hirid (), TyTy::TyWithLocation (bool_ty),
TyTy::TyWithLocation (cond_type,
- expr.get_if_condition ()->get_locus ()),
+ expr.get_if_condition ().get_locus ()),
expr.get_locus ());
- auto if_blk_resolved = TypeCheckExpr::Resolve (expr.get_if_block ().get ());
- auto else_blk_resolved
- = TypeCheckExpr::Resolve (expr.get_else_block ().get ());
+ auto if_blk_resolved = TypeCheckExpr::Resolve (expr.get_if_block ());
+ auto else_blk_resolved = TypeCheckExpr::Resolve (expr.get_else_block ());
if (if_blk_resolved->get_kind () == TyTy::NEVER)
infered = else_blk_resolved;
infered = if_blk_resolved;
else
{
- infered = unify_site (
- expr.get_mappings ().get_hirid (),
- TyTy::TyWithLocation (if_blk_resolved,
- expr.get_if_block ()->get_locus ()),
- TyTy::TyWithLocation (else_blk_resolved,
- expr.get_else_block ()->get_locus ()),
- expr.get_locus ());
+ infered
+ = unify_site (expr.get_mappings ().get_hirid (),
+ TyTy::TyWithLocation (if_blk_resolved,
+ expr.get_if_block ().get_locus ()),
+ TyTy::TyWithLocation (
+ else_blk_resolved, expr.get_else_block ().get_locus ()),
+ expr.get_locus ());
}
}
void
TypeCheckExpr::visit (HIR::UnsafeBlockExpr &expr)
{
- infered = TypeCheckExpr::Resolve (expr.get_block_expr ().get ());
+ infered = TypeCheckExpr::Resolve (expr.get_block_expr ());
}
void
if (!s->is_item ())
continue;
- TypeCheckStmt::Resolve (s.get ());
+ TypeCheckStmt::Resolve (*s);
}
for (auto &s : expr.get_statements ())
if (s->is_item ())
continue;
- auto resolved = TypeCheckStmt::Resolve (s.get ());
+ auto resolved = TypeCheckStmt::Resolve (*s);
if (resolved == nullptr)
{
rust_error_at (s->get_locus (), "failure to resolve type");
}
if (expr.has_expr ())
- infered = TypeCheckExpr::Resolve (expr.get_final_expr ().get ())->clone ();
+ infered = TypeCheckExpr::Resolve (expr.get_final_expr ())->clone ();
else if (expr.is_tail_reachable ())
infered = TyTy::TupleType::get_unit_type ();
else if (expr.has_label ())
// resolve the range expressions and these types must unify then we use that
// type to substitute into the ADT
- TyTy::BaseType *from_ty
- = TypeCheckExpr::Resolve (expr.get_from_expr ().get ());
- TyTy::BaseType *to_ty = TypeCheckExpr::Resolve (expr.get_to_expr ().get ());
+ TyTy::BaseType *from_ty = TypeCheckExpr::Resolve (expr.get_from_expr ());
+ TyTy::BaseType *to_ty = TypeCheckExpr::Resolve (expr.get_to_expr ());
TyTy::BaseType *unified = unify_site (
expr.get_mappings ().get_hirid (),
- TyTy::TyWithLocation (from_ty, expr.get_from_expr ()->get_locus ()),
- TyTy::TyWithLocation (to_ty, expr.get_to_expr ()->get_locus ()),
+ TyTy::TyWithLocation (from_ty, expr.get_from_expr ().get_locus ()),
+ TyTy::TyWithLocation (to_ty, expr.get_to_expr ().get_locus ()),
expr.get_locus ());
// substitute it in
// resolve the range expressions and these types must unify then we use that
// type to substitute into the ADT
- TyTy::BaseType *from_ty
- = TypeCheckExpr::Resolve (expr.get_from_expr ().get ());
+ TyTy::BaseType *from_ty = TypeCheckExpr::Resolve (expr.get_from_expr ());
// substitute it in
std::vector<TyTy::SubstitutionArg> subst_mappings;
// resolve the range expressions and these types must unify then we use that
// type to substitute into the ADT
- TyTy::BaseType *from_ty = TypeCheckExpr::Resolve (expr.get_to_expr ().get ());
+ TyTy::BaseType *from_ty = TypeCheckExpr::Resolve (expr.get_to_expr ());
// substitute it in
std::vector<TyTy::SubstitutionArg> subst_mappings;
{
case RegisterType::In: {
auto in = operand.get_in ();
- TypeCheckExpr::Resolve (in.expr.get ());
+ TypeCheckExpr::Resolve (*in.expr);
break;
}
case RegisterType::Out: {
auto out = operand.get_out ();
- TypeCheckExpr::Resolve (out.expr.get ());
+ TypeCheckExpr::Resolve (*out.expr);
break;
}
case RegisterType::InOut: {
auto in_out = operand.get_in_out ();
- TypeCheckExpr::Resolve (in_out.expr.get ());
+ TypeCheckExpr::Resolve (*in_out.expr);
break;
}
case RegisterType::SplitInOut: {
auto split_in_out = operand.get_split_in_out ();
- TypeCheckExpr::Resolve (split_in_out.in_expr.get ());
- TypeCheckExpr::Resolve (split_in_out.out_expr.get ());
+ TypeCheckExpr::Resolve (*split_in_out.in_expr);
+ TypeCheckExpr::Resolve (*split_in_out.out_expr);
break;
}
case RegisterType::Const: {
auto anon_const = operand.get_const ().anon_const;
- TypeCheckExpr::Resolve (anon_const.expr.get ());
+ TypeCheckExpr::Resolve (*anon_const.expr);
break;
}
case RegisterType::Sym: {
auto sym = operand.get_sym ();
- TypeCheckExpr::Resolve (sym.expr.get ());
+ TypeCheckExpr::Resolve (*sym.expr);
break;
}
case RegisterType::Label: {
auto label = operand.get_label ();
- TypeCheckExpr::Resolve (label.expr.get ());
+ TypeCheckExpr::Resolve (*label.expr);
break;
}
}
// resolve the range expressions and these types must unify then we use that
// type to substitute into the ADT
- TyTy::BaseType *from_ty
- = TypeCheckExpr::Resolve (expr.get_from_expr ().get ());
- TyTy::BaseType *to_ty = TypeCheckExpr::Resolve (expr.get_to_expr ().get ());
+ TyTy::BaseType *from_ty = TypeCheckExpr::Resolve (expr.get_from_expr ());
+ TyTy::BaseType *to_ty = TypeCheckExpr::Resolve (expr.get_to_expr ());
TyTy::BaseType *unified = unify_site (
expr.get_mappings ().get_hirid (),
- TyTy::TyWithLocation (from_ty, expr.get_from_expr ()->get_locus ()),
- TyTy::TyWithLocation (to_ty, expr.get_to_expr ()->get_locus ()),
+ TyTy::TyWithLocation (from_ty, expr.get_from_expr ().get_locus ()),
+ TyTy::TyWithLocation (to_ty, expr.get_to_expr ().get_locus ()),
expr.get_locus ());
// substitute it in
void
TypeCheckExpr::visit (HIR::ArrayIndexExpr &expr)
{
- auto array_expr_ty = TypeCheckExpr::Resolve (expr.get_array_expr ().get ());
+ auto array_expr_ty = TypeCheckExpr::Resolve (expr.get_array_expr ());
if (array_expr_ty->get_kind () == TyTy::TypeKind::ERROR)
return;
- auto index_expr_ty = TypeCheckExpr::Resolve (expr.get_index_expr ().get ());
+ auto index_expr_ty = TypeCheckExpr::Resolve (expr.get_index_expr ());
if (index_expr_ty->get_kind () == TyTy::TypeKind::ERROR)
return;
if (maybe_simple_array_access
&& direct_array_expr_ty->get_kind () == TyTy::TypeKind::ARRAY)
{
- unify_site (expr.get_index_expr ()->get_mappings ().get_hirid (),
+ unify_site (expr.get_index_expr ().get_mappings ().get_hirid (),
TyTy::TyWithLocation (size_ty),
TyTy::TyWithLocation (index_expr_ty,
- expr.get_index_expr ()->get_locus ()),
+ expr.get_index_expr ().get_locus ()),
expr.get_locus ());
TyTy::ArrayType *array_type
// error[E0277]: the type `[{integer}]` cannot be indexed by `u32`
rich_location r (line_table, expr.get_locus ());
- r.add_range (expr.get_array_expr ()->get_locus ());
- r.add_range (expr.get_index_expr ()->get_locus ());
+ r.add_range (expr.get_array_expr ().get_locus ());
+ r.add_range (expr.get_index_expr ().get_locus ());
rust_error_at (r, ErrorCode::E0277,
"the type %qs cannot be indexed by %qs",
array_expr_ty->get_name ().c_str (),
void
TypeCheckExpr::visit (HIR::ArrayExpr &expr)
{
- HIR::ArrayElems &elements = *expr.get_internal_elements ();
+ auto &elements = expr.get_internal_elements ();
HIR::Expr *capacity_expr = nullptr;
TyTy::BaseType *element_type = nullptr;
case HIR::ArrayElems::ArrayExprType::COPIED: {
HIR::ArrayElemsCopied &elems
= static_cast<HIR::ArrayElemsCopied &> (elements);
- element_type
- = TypeCheckExpr::Resolve (elems.get_elem_to_copy ().get ());
+ element_type = TypeCheckExpr::Resolve (elems.get_elem_to_copy ());
auto capacity_type
- = TypeCheckExpr::Resolve (elems.get_num_copies_expr ().get ());
+ = TypeCheckExpr::Resolve (elems.get_num_copies_expr ());
TyTy::BaseType *expected_ty = nullptr;
bool ok = context->lookup_builtin ("usize", &expected_ty);
rust_assert (ok);
- context->insert_type (elems.get_num_copies_expr ()->get_mappings (),
+ context->insert_type (elems.get_num_copies_expr ().get_mappings (),
expected_ty);
- unify_site (
- expr.get_mappings ().get_hirid (), TyTy::TyWithLocation (expected_ty),
- TyTy::TyWithLocation (capacity_type,
- elems.get_num_copies_expr ()->get_locus ()),
- expr.get_locus ());
+ unify_site (expr.get_mappings ().get_hirid (),
+ TyTy::TyWithLocation (expected_ty),
+ TyTy::TyWithLocation (
+ capacity_type, elems.get_num_copies_expr ().get_locus ()),
+ expr.get_locus ());
- capacity_expr = elems.get_num_copies_expr ().get ();
+ capacity_expr = &elems.get_num_copies_expr ();
}
break;
std::vector<TyTy::BaseType *> types;
for (auto &elem : elems.get_values ())
{
- types.push_back (TypeCheckExpr::Resolve (elem.get ()));
+ types.push_back (TypeCheckExpr::Resolve (*elem));
}
// this is a LUB
TypeCheckExpr::visit (HIR::StructExprStruct &struct_expr)
{
TyTy::BaseType *struct_path_ty
- = TypeCheckExpr::Resolve (&struct_expr.get_struct_name ());
+ = TypeCheckExpr::Resolve (struct_expr.get_struct_name ());
if (struct_path_ty->get_kind () != TyTy::TypeKind::ADT)
{
rust_error_at (struct_expr.get_struct_name ().get_locus (),
void
TypeCheckExpr::visit (HIR::StructExprStructFields &struct_expr)
{
- infered = TypeCheckStructExpr::Resolve (&struct_expr);
+ infered = TypeCheckStructExpr::Resolve (struct_expr);
}
void
TypeCheckExpr::visit (HIR::GroupedExpr &expr)
{
- infered = TypeCheckExpr::Resolve (expr.get_expr_in_parens ().get ());
+ infered = TypeCheckExpr::Resolve (expr.get_expr_in_parens ());
}
void
TypeCheckExpr::visit (HIR::FieldAccessExpr &expr)
{
- auto struct_base = TypeCheckExpr::Resolve (expr.get_receiver_expr ().get ());
+ auto struct_base = TypeCheckExpr::Resolve (expr.get_receiver_expr ());
// FIXME does this require autoderef here?
if (struct_base->get_kind () == TyTy::TypeKind::REF)
void
TypeCheckExpr::visit (HIR::MethodCallExpr &expr)
{
- auto receiver_tyty = TypeCheckExpr::Resolve (expr.get_receiver ().get ());
+ auto receiver_tyty = TypeCheckExpr::Resolve (expr.get_receiver ());
if (receiver_tyty->get_kind () == TyTy::TypeKind::ERROR)
{
- rust_error_at (expr.get_receiver ()->get_locus (),
+ rust_error_at (expr.get_receiver ().get_locus (),
"failed to resolve receiver in MethodCallExpr");
return;
}
// stored onto the receiver to so as we don't trigger duplicate deref mappings
// ICE when an argument is a method call
HirId autoderef_mappings_id
- = expr.get_receiver ()->get_mappings ().get_hirid ();
+ = expr.get_receiver ().get_mappings ().get_hirid ();
context->insert_autoderef_mappings (autoderef_mappings_id,
std::move (candidate.adjustments));
if (impl_self_infer->get_kind () == TyTy::TypeKind::ERROR)
{
rich_location r (line_table, expr.get_locus ());
- r.add_range (impl.get_type ()->get_locus ());
+ r.add_range (impl.get_type ().get_locus ());
rust_error_at (
r, "failed to resolve impl type for method call resolution");
return;
{
context->push_new_loop_context (expr.get_mappings ().get_hirid (),
expr.get_locus ());
- TyTy::BaseType *block_expr
- = TypeCheckExpr::Resolve (expr.get_loop_block ().get ());
+ TyTy::BaseType *block_expr = TypeCheckExpr::Resolve (expr.get_loop_block ());
if (!block_expr->is_unit ())
{
- rust_error_at (expr.get_loop_block ()->get_locus (),
+ rust_error_at (expr.get_loop_block ().get_locus (),
"expected %<()%> got %s",
block_expr->as_string ().c_str ());
return;
{
context->push_new_while_loop_context (expr.get_mappings ().get_hirid ());
- TypeCheckExpr::Resolve (expr.get_predicate_expr ().get ());
- TyTy::BaseType *block_expr
- = TypeCheckExpr::Resolve (expr.get_loop_block ().get ());
+ TypeCheckExpr::Resolve (expr.get_predicate_expr ());
+ TyTy::BaseType *block_expr = TypeCheckExpr::Resolve (expr.get_loop_block ());
if (!block_expr->is_unit ())
{
- rust_error_at (expr.get_loop_block ()->get_locus (),
+ rust_error_at (expr.get_loop_block ().get_locus (),
"expected %<()%> got %s",
block_expr->as_string ().c_str ());
return;
if (expr.has_break_expr ())
{
TyTy::BaseType *break_expr_tyty
- = TypeCheckExpr::Resolve (expr.get_expr ().get ());
+ = TypeCheckExpr::Resolve (expr.get_expr ());
TyTy::BaseType *loop_context = context->peek_loop_context ();
if (loop_context->get_kind () == TyTy::TypeKind::ERROR)
= unify_site (expr.get_mappings ().get_hirid (),
TyTy::TyWithLocation (loop_context),
TyTy::TyWithLocation (break_expr_tyty,
- expr.get_expr ()->get_locus ()),
+ expr.get_expr ().get_locus ()),
expr.get_locus ());
context->swap_head_loop_context (unified_ty);
}
void
TypeCheckExpr::visit (HIR::BorrowExpr &expr)
{
- TyTy::BaseType *resolved_base
- = TypeCheckExpr::Resolve (expr.get_expr ().get ());
+ TyTy::BaseType *resolved_base = TypeCheckExpr::Resolve (expr.get_expr ());
// In Rust this is valid because of DST's
//
void
TypeCheckExpr::visit (HIR::DereferenceExpr &expr)
{
- TyTy::BaseType *resolved_base
- = TypeCheckExpr::Resolve (expr.get_expr ().get ());
+ TyTy::BaseType *resolved_base = TypeCheckExpr::Resolve (expr.get_expr ());
rust_debug_loc (expr.get_locus (), "attempting deref operator overload");
auto lang_item_type = LangItem::Kind::DEREF;
TypeCheckExpr::visit (HIR::TypeCastExpr &expr)
{
TyTy::BaseType *expr_to_convert
- = TypeCheckExpr::Resolve (expr.get_casted_expr ().get ());
+ = TypeCheckExpr::Resolve (expr.get_casted_expr ());
TyTy::BaseType *tyty_to_convert_to
- = TypeCheckType::Resolve (expr.get_type_to_convert_to ().get ());
+ = TypeCheckType::Resolve (expr.get_type_to_convert_to ());
TyTy::TyWithLocation from (expr_to_convert,
- expr.get_casted_expr ()->get_locus ());
+ expr.get_casted_expr ().get_locus ());
TyTy::TyWithLocation to (tyty_to_convert_to,
- expr.get_type_to_convert_to ()->get_locus ());
+ expr.get_type_to_convert_to ().get_locus ());
infered = cast_site (expr.get_mappings ().get_hirid (), from, to,
expr.get_locus ());
}
// this needs to perform a least upper bound coercion on the blocks and then
// unify the scruintee and arms
TyTy::BaseType *scrutinee_tyty
- = TypeCheckExpr::Resolve (expr.get_scrutinee_expr ().get ());
+ = TypeCheckExpr::Resolve (expr.get_scrutinee_expr ());
bool saw_error = false;
std::vector<TyTy::BaseType *> kase_block_tys;
for (auto &pattern : kase_arm.get_patterns ())
{
TyTy::BaseType *kase_arm_ty
- = TypeCheckPattern::Resolve (pattern.get (), scrutinee_tyty);
+ = TypeCheckPattern::Resolve (*pattern, scrutinee_tyty);
if (kase_arm_ty->get_kind () == TyTy ::TypeKind::ERROR)
{
saw_error = true;
TyTy::BaseType *checked_kase = unify_site (
expr.get_mappings ().get_hirid (),
TyTy::TyWithLocation (scrutinee_tyty,
- expr.get_scrutinee_expr ()->get_locus ()),
+ expr.get_scrutinee_expr ().get_locus ()),
TyTy::TyWithLocation (kase_arm_ty, pattern->get_locus ()),
expr.get_locus ());
if (checked_kase->get_kind () == TyTy::TypeKind::ERROR)
}
// check the kase type
- TyTy::BaseType *kase_block_ty
- = TypeCheckExpr::Resolve (kase.get_expr ().get ());
+ TyTy::BaseType *kase_block_ty = TypeCheckExpr::Resolve (kase.get_expr ());
kase_block_tys.push_back (kase_block_ty);
}
if (saw_error)
TyTy::BaseType *param_tyty = nullptr;
if (p.has_type_given ())
{
- param_tyty = TypeCheckType::Resolve (p.get_type ().get ());
+ param_tyty = TypeCheckType::Resolve (p.get_type ());
}
else
{
- param_tyty = ClosureParamInfer::Resolve (p.get_pattern ().get ());
+ param_tyty = ClosureParamInfer::Resolve (p.get_pattern ());
}
TyTy::TyVar param_ty (param_tyty->get_ref ());
parameter_types.push_back (param_ty);
- TypeCheckPattern::Resolve (p.get_pattern ().get (), param_ty.get_tyty ());
+ TypeCheckPattern::Resolve (p.get_pattern (), param_ty.get_tyty ());
}
// we generate an implicit hirid for the closure args
context->insert_implicit_type (closure_args);
location_t result_type_locus = expr.has_return_type ()
- ? expr.get_return_type ()->get_locus ()
+ ? expr.get_return_type ().get_locus ()
: expr.get_locus ();
TyTy::TyVar result_type
= expr.has_return_type ()
? TyTy::TyVar (
- TypeCheckType::Resolve (expr.get_return_type ().get ())->get_ref ())
+ TypeCheckType::Resolve (expr.get_return_type ())->get_ref ())
: TyTy::TyVar::get_implicit_infer_var (expr.get_locus ());
// resolve the block
- location_t closure_expr_locus = expr.get_expr ()->get_locus ();
- TyTy::BaseType *closure_expr_ty
- = TypeCheckExpr::Resolve (expr.get_expr ().get ());
+ location_t closure_expr_locus = expr.get_expr ().get_locus ();
+ TyTy::BaseType *closure_expr_ty = TypeCheckExpr::Resolve (expr.get_expr ());
coercion_site (expr.get_mappings ().get_hirid (),
TyTy::TyWithLocation (result_type.get_tyty (),
result_type_locus),
if (parent->has_trait_ref () && is_recursive_op)
{
TraitReference *trait_reference
- = TraitResolver::Lookup (*parent->get_trait_ref ().get ());
+ = TraitResolver::Lookup (parent->get_trait_ref ());
if (!trait_reference->is_error ())
{
TyTy::BaseType *lookup = nullptr;
// type check the arguments if required
TyTy::FnType *type = static_cast<TyTy::FnType *> (lookup);
rust_assert (type->num_params () > 0);
- auto fnparam = type->param_at (0);
+ auto &fnparam = type->param_at (0);
// typecheck the self
unify_site (expr.get_mappings ().get_hirid (),
else
{
rust_assert (type->num_params () == 2);
- auto fnparam = type->param_at (1);
+ auto &fnparam = type->param_at (1);
unify_site (expr.get_mappings ().get_hirid (),
TyTy::TyWithLocation (fnparam.second),
TyTy::TyWithLocation (rhs), expr.get_locus ());
// store the adjustments for code-generation to know what to do which must be
// stored onto the receiver to so as we don't trigger duplicate deref mappings
// ICE when an argument is a method call
- HIR::Expr *fnexpr = expr.get_fnexpr ().get ();
- HirId autoderef_mappings_id = fnexpr->get_mappings ().get_hirid ();
+ HIR::Expr &fnexpr = expr.get_fnexpr ();
+ HirId autoderef_mappings_id = fnexpr.get_mappings ().get_hirid ();
context->insert_autoderef_mappings (autoderef_mappings_id,
std::move (candidate.adjustments));
context->insert_receiver (expr.get_mappings ().get_hirid (), receiver_tyty);
std::vector<TyTy::TyVar> call_args;
for (auto &arg : expr.get_arguments ())
{
- TyTy::BaseType *a = TypeCheckExpr::Resolve (arg.get ());
+ TyTy::BaseType *a = TypeCheckExpr::Resolve (*arg);
call_args.push_back (TyTy::TyVar (a->get_ref ()));
}
class TypeCheckExpr : private TypeCheckBase, private HIR::HIRExpressionVisitor
{
public:
- static TyTy::BaseType *Resolve (HIR::Expr *expr);
+ static TyTy::BaseType *Resolve (HIR::Expr &expr);
void visit (HIR::TupleIndexExpr &expr) override;
void visit (HIR::TupleExpr &expr) override;
#include "rust-hir-type-check-implitem.h"
#include "rust-diagnostics.h"
+#include "rust-hir-full-decls.h"
+#include "rust-hir-pattern.h"
#include "rust-hir-type-check-base.h"
#include "rust-hir-type-check-type.h"
#include "rust-hir-type-check-expr.h"
{}
TyTy::BaseType *
-TypeCheckTopLevelExternItem::Resolve (HIR::ExternalItem *item,
+TypeCheckTopLevelExternItem::Resolve (HIR::ExternalItem &item,
const HIR::ExternBlock &parent)
{
// is it already resolved?
auto context = TypeCheckContext::get ();
TyTy::BaseType *resolved = nullptr;
bool already_resolved
- = context->lookup_type (item->get_mappings ().get_hirid (), &resolved);
+ = context->lookup_type (item.get_mappings ().get_hirid (), &resolved);
if (already_resolved)
return resolved;
TypeCheckTopLevelExternItem resolver (parent);
- item->accept_vis (resolver);
+ item.accept_vis (resolver);
return resolver.resolved;
}
void
TypeCheckTopLevelExternItem::visit (HIR::ExternalStaticItem &item)
{
- TyTy::BaseType *actual_type
- = TypeCheckType::Resolve (item.get_item_type ().get ());
+ TyTy::BaseType *actual_type = TypeCheckType::Resolve (item.get_item_type ());
context->insert_type (item.get_mappings (), actual_type);
resolved = actual_type;
case HIR::GenericParam::GenericKind::TYPE: {
auto param_type
- = TypeResolveGenericParam::Resolve (generic_param.get ());
+ = TypeResolveGenericParam::Resolve (*generic_param);
context->insert_type (generic_param->get_mappings (),
param_type);
{
for (auto &where_clause_item : function.get_where_clause ().get_items ())
{
- ResolveWhereClauseItem::Resolve (*where_clause_item.get (),
+ ResolveWhereClauseItem::Resolve (*where_clause_item,
region_constraints);
}
}
ret_type = TyTy::TupleType::get_unit_type ();
else
{
- auto resolved
- = TypeCheckType::Resolve (function.get_return_type ().get ());
+ auto resolved = TypeCheckType::Resolve (function.get_return_type ());
if (resolved == nullptr)
{
rust_error_at (function.get_locus (),
ret_type = resolved->clone ();
ret_type->set_ref (
- function.get_return_type ()->get_mappings ().get_hirid ());
+ function.get_return_type ().get_mappings ().get_hirid ());
}
std::vector<std::pair<HIR::Pattern *, TyTy::BaseType *> > params;
+ std::unique_ptr<HIR::IdentifierPattern> param_pattern = nullptr;
for (auto ¶m : function.get_function_params ())
{
// get the name as well required for later on
- auto param_tyty = TypeCheckType::Resolve (param.get_type ().get ());
+ auto param_tyty = TypeCheckType::Resolve (param.get_type ());
// these are implicit mappings and not used
auto crate_num = mappings.get_current_crate ();
mappings.get_next_hir_id (crate_num),
UNKNOWN_LOCAL_DEFID);
- HIR::IdentifierPattern *param_pattern
- = new HIR::IdentifierPattern (mapping, param.get_param_name (),
- UNDEF_LOCATION, false, Mutability::Imm,
- std::unique_ptr<HIR::Pattern> (nullptr));
+ param_pattern = Rust::make_unique<HIR::IdentifierPattern> (
+ HIR::IdentifierPattern (mapping, param.get_param_name (),
+ UNDEF_LOCATION, false, Mutability::Imm,
+ std::unique_ptr<HIR::Pattern> (nullptr)));
params.push_back (
- std::pair<HIR::Pattern *, TyTy::BaseType *> (param_pattern,
+ std::pair<HIR::Pattern *, TyTy::BaseType *> (param_pattern.get (),
param_tyty));
context->insert_type (param.get_mappings (), param_tyty);
}
TypeCheckImplItem::TypeCheckImplItem (
- HIR::ImplBlock *parent, TyTy::BaseType *self,
+ HIR::ImplBlock &parent, TyTy::BaseType *self,
std::vector<TyTy::SubstitutionParamMapping> substitutions)
: TypeCheckBase (), parent (parent), self (self),
substitutions (substitutions)
TyTy::BaseType *
TypeCheckImplItem::Resolve (
- HIR::ImplBlock *parent, HIR::ImplItem *item, TyTy::BaseType *self,
+ HIR::ImplBlock &parent, HIR::ImplItem &item, TyTy::BaseType *self,
std::vector<TyTy::SubstitutionParamMapping> substitutions)
{
// is it already resolved?
auto context = TypeCheckContext::get ();
TyTy::BaseType *resolved = nullptr;
bool already_resolved
- = context->lookup_type (item->get_impl_mappings ().get_hirid (), &resolved);
+ = context->lookup_type (item.get_impl_mappings ().get_hirid (), &resolved);
if (already_resolved)
return resolved;
// resolve
TypeCheckImplItem resolver (parent, self, substitutions);
- item->accept_vis (resolver);
+ item.accept_vis (resolver);
return resolver.result;
}
ret_type = TyTy::TupleType::get_unit_type ();
else
{
- auto resolved
- = TypeCheckType::Resolve (function.get_return_type ().get ());
+ auto resolved = TypeCheckType::Resolve (function.get_return_type ());
if (resolved == nullptr)
{
rust_error_at (function.get_locus (),
ret_type = resolved->clone ();
ret_type->set_ref (
- function.get_return_type ()->get_mappings ().get_hirid ());
+ function.get_return_type ().get_mappings ().get_hirid ());
}
std::vector<std::pair<HIR::Pattern *, TyTy::BaseType *> > params;
+ std::unique_ptr<HIR::IdentifierPattern> self_pattern = nullptr;
if (function.is_method ())
{
// these are implicit mappings and not used
// reuse the HIR identifier pattern which requires it
HIR::SelfParam &self_param = function.get_self_param ();
// FIXME: which location should be used for Rust::Identifier for `self`?
- HIR::IdentifierPattern *self_pattern = new HIR::IdentifierPattern (
- mapping, {"self"}, self_param.get_locus (), self_param.is_ref (),
- self_param.get_mut (), std::unique_ptr<HIR::Pattern> (nullptr));
+ self_pattern = Rust::make_unique<HIR::IdentifierPattern> (
+ HIR::IdentifierPattern (mapping, {"self"}, self_param.get_locus (),
+ self_param.is_ref (), self_param.get_mut (),
+ std::unique_ptr<HIR::Pattern> (nullptr)));
// might have a specified type
TyTy::BaseType *self_type = nullptr;
if (self_param.has_type ())
{
- std::unique_ptr<HIR::Type> &specified_type = self_param.get_type ();
- self_type = TypeCheckType::Resolve (specified_type.get ());
+ auto &specified_type = self_param.get_type ();
+ self_type = TypeCheckType::Resolve (specified_type);
}
else
{
context->insert_type (self_param.get_mappings (), self_type);
params.push_back (
- std::pair<HIR::Pattern *, TyTy::BaseType *> (self_pattern, self_type));
+ std::pair<HIR::Pattern *, TyTy::BaseType *> (self_pattern.get (),
+ self_type));
}
for (auto ¶m : function.get_function_params ())
{
// get the name as well required for later on
- auto param_tyty = TypeCheckType::Resolve (param.get_type ().get ());
- params.push_back (std::pair<HIR::Pattern *, TyTy::BaseType *> (
- param.get_param_name ().get (), param_tyty));
+ auto param_tyty = TypeCheckType::Resolve (param.get_type ());
context->insert_type (param.get_mappings (), param_tyty);
- TypeCheckPattern::Resolve (param.get_param_name ().get (), param_tyty);
+ TypeCheckPattern::Resolve (param.get_param_name (), param_tyty);
+
+ params.push_back (
+ std::pair<HIR::Pattern *, TyTy::BaseType *> (¶m.get_param_name (),
+ param_tyty));
}
tl::optional<CanonicalPath> canonical_path;
context->push_return_type (TypeCheckContextItem (parent, &function),
expected_ret_tyty);
- auto block_expr_ty
- = TypeCheckExpr::Resolve (function.get_definition ().get ());
+ auto block_expr_ty = TypeCheckExpr::Resolve (function.get_definition ());
location_t fn_return_locus = function.has_function_return_type ()
- ? function.get_return_type ()->get_locus ()
+ ? function.get_return_type ().get_locus ()
: function.get_locus ();
- coercion_site (function.get_definition ()->get_mappings ().get_hirid (),
+ coercion_site (function.get_definition ().get_mappings ().get_hirid (),
TyTy::TyWithLocation (expected_ret_tyty, fn_return_locus),
TyTy::TyWithLocation (block_expr_ty),
- function.get_definition ()->get_locus ());
+ function.get_definition ().get_locus ());
context->pop_return_type ();
}
void
TypeCheckImplItem::visit (HIR::ConstantItem &constant)
{
- TyTy::BaseType *type = TypeCheckType::Resolve (constant.get_type ().get ());
- TyTy::BaseType *expr_type
- = TypeCheckExpr::Resolve (constant.get_expr ().get ());
+ TyTy::BaseType *type = TypeCheckType::Resolve (constant.get_type ());
+ TyTy::BaseType *expr_type = TypeCheckExpr::Resolve (constant.get_expr ());
TyTy::BaseType *unified = unify_site (
constant.get_mappings ().get_hirid (),
- TyTy::TyWithLocation (type, constant.get_type ()->get_locus ()),
- TyTy::TyWithLocation (expr_type, constant.get_expr ()->get_locus ()),
+ TyTy::TyWithLocation (type, constant.get_type ().get_locus ()),
+ TyTy::TyWithLocation (expr_type, constant.get_expr ().get_locus ()),
constant.get_locus ());
context->insert_type (constant.get_mappings (), unified);
result = unified;
resolve_generic_params (alias.get_generic_params (), substitutions);
TyTy::BaseType *actual_type
- = TypeCheckType::Resolve (alias.get_type_aliased ().get ());
+ = TypeCheckType::Resolve (alias.get_type_aliased ());
context->insert_type (alias.get_mappings (), actual_type);
result = actual_type;
}
TypeCheckImplItemWithTrait::TypeCheckImplItemWithTrait (
- HIR::ImplBlock *parent, TyTy::BaseType *self,
+ HIR::ImplBlock &parent, TyTy::BaseType *self,
TyTy::TypeBoundPredicate &trait_reference,
std::vector<TyTy::SubstitutionParamMapping> substitutions)
: TypeCheckBase (), trait_reference (trait_reference),
TyTy::TypeBoundPredicateItem
TypeCheckImplItemWithTrait::Resolve (
- HIR::ImplBlock *parent, HIR::ImplItem *item, TyTy::BaseType *self,
+ HIR::ImplBlock &parent, HIR::ImplItem &item, TyTy::BaseType *self,
TyTy::TypeBoundPredicate &trait_reference,
std::vector<TyTy::SubstitutionParamMapping> substitutions)
{
TypeCheckImplItemWithTrait resolver (parent, self, trait_reference,
substitutions);
- item->accept_vis (resolver);
+ item.accept_vis (resolver);
return resolver.resolved_trait_item;
}
{
// normal resolution of the item
TyTy::BaseType *lookup
- = TypeCheckImplItem::Resolve (parent, &constant, self, substitutions);
+ = TypeCheckImplItem::Resolve (parent, constant, self, substitutions);
// map the impl item to the associated trait item
const auto tref = trait_reference.get ();
{
// normal resolution of the item
TyTy::BaseType *lookup
- = TypeCheckImplItem::Resolve (parent, &type, self, substitutions);
+ = TypeCheckImplItem::Resolve (parent, type, self, substitutions);
// map the impl item to the associated trait item
const auto tref = trait_reference.get ();
{
// normal resolution of the item
TyTy::BaseType *lookup
- = TypeCheckImplItem::Resolve (parent, &function, self, substitutions);
+ = TypeCheckImplItem::Resolve (parent, function, self, substitutions);
// map the impl item to the associated trait item
const auto tref = trait_reference.get ();
public HIR::HIRExternalItemVisitor
{
public:
- static TyTy::BaseType *Resolve (HIR::ExternalItem *item,
+ static TyTy::BaseType *Resolve (HIR::ExternalItem &item,
const HIR::ExternBlock &parent);
void visit (HIR::ExternalStaticItem &item) override;
{
public:
static TyTy::BaseType *
- Resolve (HIR::ImplBlock *parent, HIR::ImplItem *item, TyTy::BaseType *self,
+ Resolve (HIR::ImplBlock &parent, HIR::ImplItem &item, TyTy::BaseType *self,
std::vector<TyTy::SubstitutionParamMapping> substitutions);
void visit (HIR::Function &function) override;
void visit (HIR::TypeAlias &type_alias) override;
protected:
- TypeCheckImplItem (HIR::ImplBlock *parent, TyTy::BaseType *self,
+ TypeCheckImplItem (HIR::ImplBlock &parent, TyTy::BaseType *self,
std::vector<TyTy::SubstitutionParamMapping> substitutions);
- HIR::ImplBlock *parent;
+ HIR::ImplBlock &parent;
TyTy::BaseType *self;
std::vector<TyTy::SubstitutionParamMapping> substitutions;
{
public:
static TyTy::TypeBoundPredicateItem
- Resolve (HIR::ImplBlock *parent, HIR::ImplItem *item, TyTy::BaseType *self,
+ Resolve (HIR::ImplBlock &parent, HIR::ImplItem &item, TyTy::BaseType *self,
TyTy::TypeBoundPredicate &trait_reference,
std::vector<TyTy::SubstitutionParamMapping> substitutions);
private:
TypeCheckImplItemWithTrait (
- HIR::ImplBlock *parent, TyTy::BaseType *self,
+ HIR::ImplBlock &parent, TyTy::BaseType *self,
TyTy::TypeBoundPredicate &trait_reference,
std::vector<TyTy::SubstitutionParamMapping> substitutions);
TyTy::TypeBoundPredicate &trait_reference;
TyTy::TypeBoundPredicateItem resolved_trait_item;
- HIR::ImplBlock *parent;
+ HIR::ImplBlock &parent;
TyTy::BaseType *self;
std::vector<TyTy::SubstitutionParamMapping> substitutions;
TyTy::RegionConstraints region_constraints;
TypeCheckItem::visit (HIR::TypeAlias &alias)
{
TyTy::BaseType *actual_type
- = TypeCheckType::Resolve (alias.get_type_aliased ().get ());
+ = TypeCheckType::Resolve (alias.get_type_aliased ());
context->insert_type (alias.get_mappings (), actual_type);
for (auto &field : struct_decl.get_fields ())
{
TyTy::BaseType *field_type
- = TypeCheckType::Resolve (field.get_field_type ().get ());
+ = TypeCheckType::Resolve (field.get_field_type ());
auto *ty_field
= new TyTy::StructFieldType (field.get_mappings ().get_hirid (),
std::to_string (idx), field_type,
for (auto &field : struct_decl.get_fields ())
{
TyTy::BaseType *field_type
- = TypeCheckType::Resolve (field.get_field_type ().get ());
+ = TypeCheckType::Resolve (field.get_field_type ());
auto *ty_field
= new TyTy::StructFieldType (field.get_mappings ().get_hirid (),
field.get_field_name ().as_string (),
for (auto &variant : enum_decl.get_variants ())
{
TyTy::VariantDef *field_type
- = TypeCheckEnumItem::Resolve (variant.get (), discriminant_value);
+ = TypeCheckEnumItem::Resolve (*variant, discriminant_value);
discriminant_value++;
variants.push_back (field_type);
for (auto &variant : union_decl.get_variants ())
{
TyTy::BaseType *variant_type
- = TypeCheckType::Resolve (variant.get_field_type ().get ());
+ = TypeCheckType::Resolve (variant.get_field_type ());
auto *ty_variant
= new TyTy::StructFieldType (variant.get_mappings ().get_hirid (),
variant.get_field_name ().as_string (),
void
TypeCheckItem::visit (HIR::StaticItem &var)
{
- TyTy::BaseType *type = TypeCheckType::Resolve (var.get_type ().get ());
- TyTy::BaseType *expr_type = TypeCheckExpr::Resolve (var.get_expr ().get ());
+ TyTy::BaseType *type = TypeCheckType::Resolve (var.get_type ());
+ TyTy::BaseType *expr_type = TypeCheckExpr::Resolve (var.get_expr ());
TyTy::BaseType *unified
= coercion_site (var.get_mappings ().get_hirid (),
- TyTy::TyWithLocation (type, var.get_type ()->get_locus ()),
+ TyTy::TyWithLocation (type, var.get_type ().get_locus ()),
TyTy::TyWithLocation (expr_type,
- var.get_expr ()->get_locus ()),
+ var.get_expr ().get_locus ()),
var.get_locus ());
context->insert_type (var.get_mappings (), unified);
infered = unified;
void
TypeCheckItem::visit (HIR::ConstantItem &constant)
{
- TyTy::BaseType *type = TypeCheckType::Resolve (constant.get_type ().get ());
- TyTy::BaseType *expr_type
- = TypeCheckExpr::Resolve (constant.get_expr ().get ());
+ TyTy::BaseType *type = TypeCheckType::Resolve (constant.get_type ());
+ TyTy::BaseType *expr_type = TypeCheckExpr::Resolve (constant.get_expr ());
TyTy::BaseType *unified = unify_site (
constant.get_mappings ().get_hirid (),
- TyTy::TyWithLocation (type, constant.get_type ()->get_locus ()),
- TyTy::TyWithLocation (expr_type, constant.get_expr ()->get_locus ()),
+ TyTy::TyWithLocation (type, constant.get_type ().get_locus ()),
+ TyTy::TyWithLocation (expr_type, constant.get_expr ().get_locus ()),
constant.get_locus ());
context->insert_type (constant.get_mappings (), unified);
infered = unified;
TraitReference *trait_reference = &TraitReference::error_node ();
if (impl_block.has_trait_ref ())
{
- std::unique_ptr<HIR::TypePath> &ref = impl_block.get_trait_ref ();
- trait_reference = TraitResolver::Resolve (*ref);
+ HIR::TypePath &ref = impl_block.get_trait_ref ();
+ trait_reference = TraitResolver::Resolve (ref);
if (trait_reference->is_error ())
return;
}
// resolve each impl_item
for (auto &impl_item : impl_block.get_impl_items ())
{
- TypeCheckImplItem::Resolve (&impl_block, impl_item.get (), self,
- substitutions);
+ TypeCheckImplItem::Resolve (impl_block, *impl_item, self, substitutions);
}
// validate the impl items
TyTy::BaseType *self = resolve_impl_block_self (impl_block);
- return TypeCheckImplItem::Resolve (&impl_block, &item, self, substitutions);
+ return TypeCheckImplItem::Resolve (impl_block, item, self, substitutions);
}
void
ret_type = TyTy::TupleType::get_unit_type ();
else
{
- auto resolved
- = TypeCheckType::Resolve (function.get_return_type ().get ());
+ auto resolved = TypeCheckType::Resolve (function.get_return_type ());
if (resolved->get_kind () == TyTy::TypeKind::ERROR)
{
rust_error_at (function.get_locus (),
ret_type = resolved->clone ();
ret_type->set_ref (
- function.get_return_type ()->get_mappings ().get_hirid ());
+ function.get_return_type ().get_mappings ().get_hirid ());
}
std::vector<std::pair<HIR::Pattern *, TyTy::BaseType *>> params;
for (auto ¶m : function.get_function_params ())
{
// get the name as well required for later on
- auto param_tyty = TypeCheckType::Resolve (param.get_type ().get ());
- params.emplace_back (param.get_param_name ().get (), param_tyty);
+ auto param_tyty = TypeCheckType::Resolve (param.get_type ());
+ params.emplace_back (¶m.get_param_name (), param_tyty);
context->insert_type (param.get_mappings (), param_tyty);
- TypeCheckPattern::Resolve (param.get_param_name ().get (), param_tyty);
+ TypeCheckPattern::Resolve (param.get_param_name (), param_tyty);
}
auto path = CanonicalPath::create_empty ();
expected_ret_tyty);
context->switch_to_fn_body ();
- auto block_expr_ty
- = TypeCheckExpr::Resolve (function.get_definition ().get ());
+ auto block_expr_ty = TypeCheckExpr::Resolve (function.get_definition ());
location_t fn_return_locus = function.has_function_return_type ()
- ? function.get_return_type ()->get_locus ()
+ ? function.get_return_type ().get_locus ()
: function.get_locus ();
- coercion_site (function.get_definition ()->get_mappings ().get_hirid (),
+ coercion_site (function.get_definition ().get_mappings ().get_hirid (),
TyTy::TyWithLocation (expected_ret_tyty, fn_return_locus),
TyTy::TyWithLocation (block_expr_ty),
- function.get_definition ()->get_locus ());
+ function.get_definition ().get_locus ());
context->pop_return_type ();
{
for (auto &item : extern_block.get_extern_items ())
{
- TypeCheckTopLevelExternItem::Resolve (item.get (), extern_block);
+ TypeCheckTopLevelExternItem::Resolve (*item, extern_block);
}
}
TraitReference *trait_reference = &TraitReference::error_node ();
if (impl_block.has_trait_ref ())
{
- std::unique_ptr<HIR::TypePath> &ref = impl_block.get_trait_ref ();
- trait_reference = TraitResolver::Resolve (*ref);
+ auto &ref = impl_block.get_trait_ref ();
+ trait_reference = TraitResolver::Resolve (ref);
rust_assert (!trait_reference->is_error ());
// we don't error out here see: gcc/testsuite/rust/compile/traits2.rs
// for example
- specified_bound
- = get_predicate_from_bound (*ref, impl_block.get_type ().get ());
+ specified_bound = get_predicate_from_bound (ref, impl_block.get_type ());
}
- TyTy::BaseType *self = TypeCheckType::Resolve (impl_block.get_type ().get ());
+ TyTy::BaseType *self = TypeCheckType::Resolve (impl_block.get_type ());
+
if (self->is<TyTy::ErrorType> ())
{
// we cannot check for unconstrained type arguments when the Self type is
auto specified_bound = TyTy::TypeBoundPredicate::error ();
if (impl_block.has_trait_ref ())
{
- std::unique_ptr<HIR::TypePath> &ref = impl_block.get_trait_ref ();
+ auto &ref = impl_block.get_trait_ref ();
+ trait_reference = TraitResolver::Resolve (ref);
if (trait_reference->is_error ())
return;
// we don't error out here see: gcc/testsuite/rust/compile/traits2.rs
// for example
- specified_bound
- = get_predicate_from_bound (*ref, impl_block.get_type ().get ());
+ specified_bound = get_predicate_from_bound (ref, impl_block.get_type ());
}
bool is_trait_impl_block = !trait_reference->is_error ();
if (!specified_bound.is_error ())
{
auto trait_item_ref
- = TypeCheckImplItemWithTrait::Resolve (&impl_block,
- impl_item.get (), self,
+ = TypeCheckImplItemWithTrait::Resolve (impl_block, *impl_item, self,
specified_bound,
substitutions);
if (!trait_item_ref.is_error ())
TyTy::BaseType *
TypeCheckItem::resolve_impl_block_self (HIR::ImplBlock &impl_block)
{
- return TypeCheckType::Resolve (impl_block.get_type ().get ());
+ return TypeCheckType::Resolve (impl_block.get_type ());
}
} // namespace Resolver
TypeCheckExpr::visit (HIR::QualifiedPathInExpression &expr)
{
HIR::QualifiedPathType qual_path_type = expr.get_path_type ();
- TyTy::BaseType *root
- = TypeCheckType::Resolve (qual_path_type.get_type ().get ());
+ TyTy::BaseType *root = TypeCheckType::Resolve (qual_path_type.get_type ());
if (root->get_kind () == TyTy::TypeKind::ERROR)
return;
}
// Resolve the trait now
- std::unique_ptr<HIR::TypePath> &trait_path_ref = qual_path_type.get_trait ();
- TraitReference *trait_ref = TraitResolver::Resolve (*trait_path_ref.get ());
+ HIR::TypePath &trait_path_ref = qual_path_type.get_trait ();
+ TraitReference *trait_ref = TraitResolver::Resolve (trait_path_ref);
if (trait_ref->is_error ())
return;
// get the predicate for the bound
auto specified_bound
- = get_predicate_from_bound (*trait_path_ref.get (),
- qual_path_type.get_type ().get ());
+ = get_predicate_from_bound (trait_path_ref, qual_path_type.get_type ());
if (specified_bound.is_error ())
return;
{
// we need to setup with apropriate bounds
HIR::TypePath &bound_path
- = *associated->get_impl_block ()->get_trait_ref ().get ();
+ = associated->get_impl_block ()->get_trait_ref ();
const auto &trait_ref = *TraitResolver::Resolve (bound_path);
rust_assert (!trait_ref.is_error ());
{}
TyTy::BaseType *
-TypeCheckPattern::Resolve (HIR::Pattern *pattern, TyTy::BaseType *parent)
+TypeCheckPattern::Resolve (HIR::Pattern &pattern, TyTy::BaseType *parent)
{
TypeCheckPattern resolver (parent);
- pattern->accept_vis (resolver);
+ pattern.accept_vis (resolver);
if (resolver.infered == nullptr)
- return new TyTy::ErrorType (pattern->get_mappings ().get_hirid ());
+ return new TyTy::ErrorType (pattern.get_mappings ().get_hirid ());
- resolver.context->insert_type (pattern->get_mappings (), resolver.infered);
+ resolver.context->insert_type (pattern.get_mappings (), resolver.infered);
return resolver.infered;
}
TypeCheckPattern::visit (HIR::PathInExpression &pattern)
{
// Pattern must be enum variants, sturcts, constants, or associated constansts
- TyTy::BaseType *pattern_ty = TypeCheckExpr::Resolve (&pattern);
+ TyTy::BaseType *pattern_ty = TypeCheckExpr::Resolve (pattern);
NodeId ref_node_id = UNKNOWN_NODEID;
bool maybe_item = false;
void
TypeCheckPattern::visit (HIR::TupleStructPattern &pattern)
{
- TyTy::BaseType *pattern_ty = TypeCheckExpr::Resolve (&pattern.get_path ());
+ TyTy::BaseType *pattern_ty = TypeCheckExpr::Resolve (pattern.get_path ());
if (pattern_ty->get_kind () != TyTy::TypeKind::ADT)
{
rust_error_at (
// error[E0023]: this pattern has 0 fields, but the corresponding tuple
// variant has 1 field
- std::unique_ptr<HIR::TupleStructItems> &items = pattern.get_items ();
- switch (items->get_item_type ())
+ auto &items = pattern.get_items ();
+ switch (items.get_item_type ())
{
case HIR::TupleStructItems::RANGED: {
// TODO
case HIR::TupleStructItems::MULTIPLE: {
HIR::TupleStructItemsNoRange &items_no_range
- = static_cast<HIR::TupleStructItemsNoRange &> (*items.get ());
+ = static_cast<HIR::TupleStructItemsNoRange &> (items);
if (items_no_range.get_patterns ().size () != variant->num_fields ())
{
// setup the type on this pattern type
context->insert_type (pattern->get_mappings (), fty);
- TypeCheckPattern::Resolve (pattern.get (), fty);
+ TypeCheckPattern::Resolve (*pattern, fty);
}
}
break;
void
TypeCheckPattern::visit (HIR::StructPattern &pattern)
{
- TyTy::BaseType *pattern_ty = TypeCheckExpr::Resolve (&pattern.get_path ());
+ TyTy::BaseType *pattern_ty = TypeCheckExpr::Resolve (pattern.get_path ());
if (pattern_ty->get_kind () != TyTy::TypeKind::ADT)
{
rust_error_at (pattern.get_locus (),
case HIR::StructPatternField::ItemType::IDENT_PAT: {
HIR::StructPatternFieldIdentPat &ident
- = static_cast<HIR::StructPatternFieldIdentPat &> (*field.get ());
+ = static_cast<HIR::StructPatternFieldIdentPat &> (*field);
TyTy::StructFieldType *field = nullptr;
if (!variant->lookup_field (ident.get_identifier ().as_string (),
named_fields.push_back (ident.get_identifier ().as_string ());
TyTy::BaseType *fty = field->get_field_type ();
- TypeCheckPattern::Resolve (ident.get_pattern ().get (), fty);
+ TypeCheckPattern::Resolve (ident.get_pattern (), fty);
}
break;
case HIR::StructPatternField::ItemType::IDENT: {
HIR::StructPatternFieldIdent &ident
- = static_cast<HIR::StructPatternFieldIdent &> (*field.get ());
+ = static_cast<HIR::StructPatternFieldIdent &> (*field);
TyTy::StructFieldType *field = nullptr;
if (!variant->lookup_field (ident.get_identifier ().as_string (),
TypeCheckPattern::visit (HIR::TuplePattern &pattern)
{
std::unique_ptr<HIR::TuplePatternItems> items;
- switch (pattern.get_items ()->get_item_type ())
+ switch (pattern.get_items ().get_item_type ())
{
case HIR::TuplePatternItems::ItemType::MULTIPLE: {
- HIR::TuplePatternItemsMultiple &ref
- = *static_cast<HIR::TuplePatternItemsMultiple *> (
- pattern.get_items ().get ());
+ auto &ref = static_cast<HIR::TuplePatternItemsMultiple &> (
+ pattern.get_items ());
auto resolved_parent = parent->destructure ();
if (resolved_parent->get_kind () != TyTy::TUPLE)
auto &p = patterns[i];
TyTy::BaseType *par_type = par.get_field (i);
- TyTy::BaseType *elem
- = TypeCheckPattern::Resolve (p.get (), par_type);
+ TyTy::BaseType *elem = TypeCheckPattern::Resolve (*p, par_type);
pattern_elems.push_back (TyTy::TyVar (elem->get_ref ()));
}
infered = new TyTy::TupleType (pattern.get_mappings ().get_hirid (),
return;
}
- TyTy::ReferenceType *ref_ty_ty = static_cast<TyTy::ReferenceType *> (parent);
+ auto &ref_ty_ty = static_cast<TyTy::ReferenceType &> (*parent);
TyTy::BaseType *infered_base
- = TypeCheckPattern::Resolve (pattern.get_referenced_pattern ().get (),
- ref_ty_ty->get_base ());
+ = TypeCheckPattern::Resolve (pattern.get_referenced_pattern (),
+ ref_ty_ty.get_base ());
infered = new TyTy::ReferenceType (pattern.get_mappings ().get_hirid (),
TyTy::TyVar (infered_base->get_ref ()),
pattern.is_mut () ? Mutability::Mut
TyTy::BaseType *
TypeCheckPattern::typecheck_range_pattern_bound (
- std::unique_ptr<Rust::HIR::RangePatternBound> &bound,
- Analysis::NodeMapping mappings, location_t locus)
+ Rust::HIR::RangePatternBound &bound, Analysis::NodeMapping mappings,
+ location_t locus)
{
TyTy::BaseType *resolved_bound = nullptr;
- switch (bound->get_bound_type ())
+ switch (bound.get_bound_type ())
{
case HIR::RangePatternBound::RangePatternBoundType::LITERAL: {
- HIR::RangePatternBoundLiteral &ref
- = *static_cast<HIR::RangePatternBoundLiteral *> (bound.get ());
+ auto &ref = static_cast<HIR::RangePatternBoundLiteral &> (bound);
HIR::Literal lit = ref.get_literal ();
break;
case HIR::RangePatternBound::RangePatternBoundType::PATH: {
- HIR::RangePatternBoundPath &ref
- = *static_cast<HIR::RangePatternBoundPath *> (bound.get ());
+ auto &ref = static_cast<HIR::RangePatternBoundPath &> (bound);
- resolved_bound = TypeCheckExpr::Resolve (&ref.get_path ());
+ resolved_bound = TypeCheckExpr::Resolve (ref.get_path ());
}
break;
case HIR::RangePatternBound::RangePatternBoundType::QUALPATH: {
- HIR::RangePatternBoundQualPath &ref
- = *static_cast<HIR::RangePatternBoundQualPath *> (bound.get ());
+ auto &ref = static_cast<HIR::RangePatternBoundQualPath &> (bound);
- resolved_bound = TypeCheckExpr::Resolve (&ref.get_qualified_path ());
+ resolved_bound = TypeCheckExpr::Resolve (ref.get_qualified_path ());
}
break;
}
std::vector<TyTy::BaseType *> types;
for (auto &alt_pattern : alts)
{
- types.push_back (TypeCheckPattern::Resolve (alt_pattern.get (), parent));
+ types.push_back (TypeCheckPattern::Resolve (*alt_pattern, parent));
}
TyTy::BaseType *alt_pattern_type
}
TyTy::BaseType *
-ClosureParamInfer::Resolve (HIR::Pattern *pattern)
+ClosureParamInfer::Resolve (HIR::Pattern &pattern)
{
ClosureParamInfer resolver;
- pattern->accept_vis (resolver);
+ pattern.accept_vis (resolver);
if (resolver.infered->get_kind () != TyTy::TypeKind::ERROR)
{
resolver.context->insert_implicit_type (resolver.infered);
resolver.mappings.insert_location (resolver.infered->get_ref (),
- pattern->get_locus ());
+ pattern.get_locus ());
}
return resolver.infered;
}
ClosureParamInfer::visit (HIR::ReferencePattern &pattern)
{
TyTy::BaseType *element
- = ClosureParamInfer::Resolve (pattern.get_referenced_pattern ().get ());
+ = ClosureParamInfer::Resolve (pattern.get_referenced_pattern ());
HirId id = pattern.get_mappings ().get_hirid ();
infered = new TyTy::ReferenceType (id, TyTy::TyVar (element->get_ref ()),
class TypeCheckPattern : public TypeCheckBase, public HIR::HIRPatternVisitor
{
public:
- static TyTy::BaseType *Resolve (HIR::Pattern *pattern,
+ static TyTy::BaseType *Resolve (HIR::Pattern &pattern,
TyTy::BaseType *parent);
void visit (HIR::PathInExpression &pattern) override;
private:
TypeCheckPattern (TyTy::BaseType *parent);
- TyTy::BaseType *typecheck_range_pattern_bound (
- std::unique_ptr<Rust::HIR::RangePatternBound> &bound,
- Analysis::NodeMapping mappings, location_t locus);
+ TyTy::BaseType *
+ typecheck_range_pattern_bound (Rust::HIR::RangePatternBound &bound,
+ Analysis::NodeMapping mappings,
+ location_t locus);
void emit_pattern_size_error (const HIR::Pattern &pattern,
size_t expected_field_count,
class ClosureParamInfer : private TypeCheckBase, private HIR::HIRPatternVisitor
{
public:
- static TyTy::BaseType *Resolve (HIR::Pattern *pattern);
+ static TyTy::BaseType *Resolve (HIR::Pattern &pattern);
void visit (HIR::PathInExpression &pattern) override;
void visit (HIR::StructPattern &pattern) override;
namespace Resolver {
TyTy::BaseType *
-TypeCheckStmt::Resolve (HIR::Stmt *stmt)
+TypeCheckStmt::Resolve (HIR::Stmt &stmt)
{
TypeCheckStmt resolver;
- stmt->accept_vis (resolver);
+ stmt.accept_vis (resolver);
return resolver.infered;
}
void
TypeCheckStmt::visit (HIR::ExprStmt &stmt)
{
- infered = TypeCheckExpr::Resolve (stmt.get_expr ().get ());
+ infered = TypeCheckExpr::Resolve (stmt.get_expr ());
}
void
{
for (auto &item : extern_block.get_extern_items ())
{
- TypeCheckTopLevelExternItem::Resolve (item.get (), extern_block);
+ TypeCheckTopLevelExternItem::Resolve (*item, extern_block);
}
}
void
TypeCheckStmt::visit (HIR::ConstantItem &constant)
{
- TyTy::BaseType *type = TypeCheckType::Resolve (constant.get_type ().get ());
- TyTy::BaseType *expr_type
- = TypeCheckExpr::Resolve (constant.get_expr ().get ());
+ TyTy::BaseType *type = TypeCheckType::Resolve (constant.get_type ());
+ TyTy::BaseType *expr_type = TypeCheckExpr::Resolve (constant.get_expr ());
infered = coercion_site (
constant.get_mappings ().get_hirid (),
- TyTy::TyWithLocation (type, constant.get_type ()->get_locus ()),
- TyTy::TyWithLocation (expr_type, constant.get_expr ()->get_locus ()),
+ TyTy::TyWithLocation (type, constant.get_type ().get_locus ()),
+ TyTy::TyWithLocation (expr_type, constant.get_expr ().get_locus ()),
constant.get_locus ());
context->insert_type (constant.get_mappings (), infered);
}
{
infered = TyTy::TupleType::get_unit_type ();
- HIR::Pattern &stmt_pattern = *stmt.get_pattern ();
+ auto &stmt_pattern = stmt.get_pattern ();
TyTy::BaseType *init_expr_ty = nullptr;
location_t init_expr_locus = UNKNOWN_LOCATION;
if (stmt.has_init_expr ())
{
- init_expr_locus = stmt.get_init_expr ()->get_locus ();
- init_expr_ty = TypeCheckExpr::Resolve (stmt.get_init_expr ().get ());
+ init_expr_locus = stmt.get_init_expr ().get_locus ();
+ init_expr_ty = TypeCheckExpr::Resolve (stmt.get_init_expr ());
if (init_expr_ty->get_kind () == TyTy::TypeKind::ERROR)
return;
location_t specified_ty_locus;
if (stmt.has_type ())
{
- specified_ty = TypeCheckType::Resolve (stmt.get_type ().get ());
- specified_ty_locus = stmt.get_type ()->get_locus ();
+ specified_ty = TypeCheckType::Resolve (stmt.get_type ());
+ specified_ty_locus = stmt.get_type ().get_locus ();
}
// let x:i32 = 123;
TyTy::TyWithLocation (specified_ty, specified_ty_locus),
TyTy::TyWithLocation (init_expr_ty, init_expr_locus),
stmt.get_locus ());
- TypeCheckPattern::Resolve (&stmt_pattern, specified_ty);
+ TypeCheckPattern::Resolve (stmt_pattern, specified_ty);
}
else
{
// let x:i32;
if (specified_ty != nullptr)
{
- TypeCheckPattern::Resolve (&stmt_pattern, specified_ty);
+ TypeCheckPattern::Resolve (stmt_pattern, specified_ty);
}
// let x = 123;
else if (init_expr_ty != nullptr)
{
- TypeCheckPattern::Resolve (&stmt_pattern, init_expr_ty);
+ TypeCheckPattern::Resolve (stmt_pattern, init_expr_ty);
}
// let x;
else
TyTy::InferType::InferTypeKind::GENERAL,
TyTy::InferType::TypeHint::Default (),
stmt.get_locus ());
- TypeCheckPattern::Resolve (&stmt_pattern, infer);
+ TypeCheckPattern::Resolve (stmt_pattern, infer);
}
}
}
void
TypeCheckStmt::visit (HIR::TypePath &path)
{
- infered = TypeCheckType::Resolve (&path);
+ infered = TypeCheckType::Resolve (path);
}
void
TypeCheckStmt::visit (HIR::QualifiedPathInType &path)
{
- infered = TypeCheckType::Resolve (&path);
+ infered = TypeCheckType::Resolve (path);
}
void
class TypeCheckStmt : private TypeCheckBase, private HIR::HIRStmtVisitor
{
public:
- static TyTy::BaseType *Resolve (HIR::Stmt *stmt);
+ static TyTy::BaseType *Resolve (HIR::Stmt &stmt);
void visit (HIR::ExprStmt &stmt) override;
void visit (HIR::EmptyStmt &stmt) override;
class TypeCheckStructExpr : public TypeCheckBase
{
public:
- static TyTy::BaseType *Resolve (HIR::StructExprStructFields *expr);
+ static TyTy::BaseType *Resolve (HIR::StructExprStructFields &expr);
// Helper for making any errors
static Error
bool visit (HIR::StructExprFieldIdentifier &field);
private:
- TypeCheckStructExpr (HIR::Expr *e);
+ TypeCheckStructExpr (HIR::Expr &e);
// result
TyTy::BaseType *resolved;
namespace Rust {
namespace Resolver {
-TypeCheckStructExpr::TypeCheckStructExpr (HIR::Expr *e)
+TypeCheckStructExpr::TypeCheckStructExpr (HIR::Expr &e)
: TypeCheckBase (),
- resolved (new TyTy::ErrorType (e->get_mappings ().get_hirid ())),
+ resolved (new TyTy::ErrorType (e.get_mappings ().get_hirid ())),
struct_path_resolved (nullptr),
variant (&TyTy::VariantDef::get_error_node ())
{}
TyTy::BaseType *
-TypeCheckStructExpr::Resolve (HIR::StructExprStructFields *expr)
+TypeCheckStructExpr::Resolve (HIR::StructExprStructFields &expr)
{
TypeCheckStructExpr resolver (expr);
- resolver.resolve (*expr);
+ resolver.resolve (expr);
return resolver.resolved;
}
TypeCheckStructExpr::resolve (HIR::StructExprStructFields &struct_expr)
{
TyTy::BaseType *struct_path_ty
- = TypeCheckExpr::Resolve (&struct_expr.get_struct_name ());
+ = TypeCheckExpr::Resolve (struct_expr.get_struct_name ());
if (struct_path_ty->get_kind () != TyTy::TypeKind::ADT)
{
rust_error_at (struct_expr.get_struct_name ().get_locus (),
if (struct_expr.has_struct_base ())
{
TyTy::BaseType *base_resolved
- = TypeCheckExpr::Resolve (struct_expr.struct_base->base_struct.get ());
+ = TypeCheckExpr::Resolve (*struct_expr.struct_base->base_struct);
TyTy::BaseType *base_unify = unify_site (
struct_expr.struct_base->base_struct->get_mappings ().get_hirid (),
TyTy::TyWithLocation (struct_path_resolved),
return false;
}
- TyTy::BaseType *value = TypeCheckExpr::Resolve (field.get_value ().get ());
- location_t value_locus = field.get_value ()->get_locus ();
+ TyTy::BaseType *value = TypeCheckExpr::Resolve (field.get_value ());
+ location_t value_locus = field.get_value ().get_locus ();
HirId coercion_site_id = field.get_mappings ().get_hirid ();
resolved_field_value_expr
return false;
}
- TyTy::BaseType *value = TypeCheckExpr::Resolve (field.get_value ().get ());
- location_t value_locus = field.get_value ()->get_locus ();
+ TyTy::BaseType *value = TypeCheckExpr::Resolve (field.get_value ());
+ location_t value_locus = field.get_value ().get_locus ();
HirId coercion_site_id = field.get_mappings ().get_hirid ();
resolved_field_value_expr
HIR::GenericArgs::create_empty ());
HIR::PathInExpression expr (mappings_copy2, {seg}, field.get_locus (), false,
{});
- TyTy::BaseType *value = TypeCheckExpr::Resolve (&expr);
+ TyTy::BaseType *value = TypeCheckExpr::Resolve (expr);
location_t value_locus = expr.get_locus ();
HirId coercion_site_id = field.get_mappings ().get_hirid ();
#include "rust-hir-type-check-type.h"
#include "options.h"
+#include "optional.h"
#include "rust-hir-trait-resolve.h"
#include "rust-hir-type-check-expr.h"
#include "rust-hir-path-probe.h"
#include "rust-mapping-common.h"
#include "rust-substitution-mapper.h"
#include "rust-type-util.h"
+#include <functional>
namespace Rust {
namespace Resolver {
HIR::GenericArgs
-TypeCheckResolveGenericArguments::resolve (HIR::TypePathSegment *segment)
+TypeCheckResolveGenericArguments::resolve (HIR::TypePathSegment &segment)
{
- TypeCheckResolveGenericArguments resolver (segment->get_locus ());
- switch (segment->get_type ())
+ TypeCheckResolveGenericArguments resolver (segment.get_locus ());
+ switch (segment.get_type ())
{
case HIR::TypePathSegment::SegmentType::GENERIC:
- resolver.visit (static_cast<HIR::TypePathSegmentGeneric &> (*segment));
+ resolver.visit (static_cast<HIR::TypePathSegmentGeneric &> (segment));
break;
default:
}
TyTy::BaseType *
-TypeCheckType::Resolve (HIR::Type *type)
+TypeCheckType::Resolve (HIR::Type &type)
{
// is it already resolved?
auto context = TypeCheckContext::get ();
TyTy::BaseType *resolved = nullptr;
bool already_resolved
- = context->lookup_type (type->get_mappings ().get_hirid (), &resolved);
+ = context->lookup_type (type.get_mappings ().get_hirid (), &resolved);
if (already_resolved)
return resolved;
- TypeCheckType resolver (type->get_mappings ().get_hirid ());
- type->accept_vis (resolver);
+ TypeCheckType resolver (type.get_mappings ().get_hirid ());
+ type.accept_vis (resolver);
rust_assert (resolver.translated != nullptr);
- resolver.context->insert_type (type->get_mappings (), resolver.translated);
+ resolver.context->insert_type (type.get_mappings (), resolver.translated);
return resolver.translated;
}
TyTy::BaseType *return_type;
if (fntype.has_return_type ())
{
- return_type = TypeCheckType::Resolve (fntype.get_return_type ().get ());
+ return_type = TypeCheckType::Resolve (fntype.get_return_type ());
}
else
{
std::vector<TyTy::TyVar> params;
for (auto ¶m : fntype.get_function_params ())
{
- TyTy::BaseType *ptype = TypeCheckType::Resolve (param.get_type ().get ());
+ TyTy::BaseType *ptype = TypeCheckType::Resolve (param.get_type ());
params.push_back (TyTy::TyVar (ptype->get_ref ()));
}
std::vector<TyTy::TyVar> fields;
for (auto &elem : tuple.get_elems ())
{
- auto field_ty = TypeCheckType::Resolve (elem.get ());
+ auto field_ty = TypeCheckType::Resolve (*elem);
fields.push_back (TyTy::TyVar (field_ty->get_ref ()));
}
TypeCheckType::visit (HIR::QualifiedPathInType &path)
{
HIR::QualifiedPathType qual_path_type = path.get_path_type ();
- TyTy::BaseType *root
- = TypeCheckType::Resolve (qual_path_type.get_type ().get ());
+ TyTy::BaseType *root = TypeCheckType::Resolve (qual_path_type.get_type ());
if (root->get_kind () == TyTy::TypeKind::ERROR)
{
rust_debug_loc (path.get_locus (), "failed to resolve the root");
// then this is just a normal path-in-expression
NodeId root_resolved_node_id = UNKNOWN_NODEID;
bool ok = resolver->lookup_resolved_type (
- qual_path_type.get_type ()->get_mappings ().get_nodeid (),
+ qual_path_type.get_type ().get_mappings ().get_nodeid (),
&root_resolved_node_id);
rust_assert (ok);
}
// Resolve the trait now
- std::unique_ptr<HIR::TypePath> &trait_path_ref = qual_path_type.get_trait ();
- TraitReference *trait_ref = TraitResolver::Resolve (*trait_path_ref.get ());
+ auto &trait_path_ref = qual_path_type.get_trait ();
+ TraitReference *trait_ref = TraitResolver::Resolve (trait_path_ref);
if (trait_ref->is_error ())
return;
}
// get the predicate for the bound
- auto specified_bound
- = get_predicate_from_bound (*qual_path_type.get_trait ().get (),
- qual_path_type.get_type ().get ());
+ auto specified_bound = get_predicate_from_bound (qual_path_type.get_trait (),
+ qual_path_type.get_type ());
if (specified_bound.is_error ())
return;
root->inherit_bounds ({specified_bound});
// lookup the associated item from the specified bound
- std::unique_ptr<HIR::TypePathSegment> &item_seg
- = path.get_associated_segment ();
- HIR::PathIdentSegment item_seg_identifier = item_seg->get_ident_segment ();
+ HIR::TypePathSegment &item_seg = path.get_associated_segment ();
+ HIR::PathIdentSegment item_seg_identifier = item_seg.get_ident_segment ();
TyTy::TypeBoundPredicateItem item
= specified_bound.lookup_associated_item (item_seg_identifier.as_string ());
if (item.is_error ())
{
std::string item_seg_ident_name, rich_msg;
- item_seg_ident_name = qual_path_type.get_trait ()->as_string ();
+ item_seg_ident_name = qual_path_type.get_trait ().as_string ();
rich_msg = "not found in `" + item_seg_ident_name + "`";
- rich_location richloc (line_table, item_seg->get_locus ());
+ rich_location richloc (line_table, item_seg.get_locus ());
richloc.add_fixit_replace (rich_msg.c_str ());
rust_error_at (richloc, ErrorCode::E0576,
}
// turbo-fish segment path::<ty>
- if (item_seg->get_type () == HIR::TypePathSegment::SegmentType::GENERIC)
+ if (item_seg.get_type () == HIR::TypePathSegment::SegmentType::GENERIC)
{
- HIR::TypePathSegmentGeneric &generic_seg
- = static_cast<HIR::TypePathSegmentGeneric &> (*item_seg.get ());
+ auto &generic_seg = static_cast<HIR::TypePathSegmentGeneric &> (item_seg);
// turbo-fish segment path::<ty>
if (generic_seg.has_generic_args ())
{
if (!translated->has_substitutions_defined ())
{
- rust_error_at (item_seg->get_locus (),
+ rust_error_at (item_seg.get_locus (),
"substitutions not supported for %s",
translated->as_string ().c_str ());
translated
// turbo-fish segment path::<ty>
if (seg->is_generic_segment ())
{
- HIR::TypePathSegmentGeneric *generic_segment
- = static_cast<HIR::TypePathSegmentGeneric *> (seg.get ());
+ auto &generic_segment
+ = static_cast<HIR::TypePathSegmentGeneric &> (*seg);
auto regions = context->regions_from_generic_args (
- generic_segment->get_generic_args ());
+ generic_segment.get_generic_args ());
lookup = SubstMapper::Resolve (lookup, path.get_locus (),
- &generic_segment->get_generic_args (),
+ &generic_segment.get_generic_args (),
regions);
if (lookup->get_kind () == TyTy::TypeKind::ERROR)
return new TyTy::ErrorType (seg->get_mappings ().get_hirid ());
if (seg->is_generic_segment ())
{
- auto *generic_segment
- = static_cast<HIR::TypePathSegmentGeneric *> (seg.get ());
+ auto &generic_segment
+ = static_cast<HIR::TypePathSegmentGeneric &> (*seg);
std::vector<TyTy::Region> regions;
for (auto &lifetime :
- generic_segment->get_generic_args ().get_lifetime_args ())
+ generic_segment.get_generic_args ().get_lifetime_args ())
{
auto region = context->lookup_and_resolve_lifetime (lifetime);
if (!region.has_value ())
}
tyseg = SubstMapper::Resolve (tyseg, expr_locus,
- &generic_segment->get_generic_args (),
+ &generic_segment.get_generic_args (),
regions);
if (tyseg->get_kind () == TyTy::TypeKind::ERROR)
return new TyTy::ErrorType (expr_id);
TyTy::TypeBoundPredicate predicate = get_predicate_from_bound (
trait_bound.get_path (),
- nullptr /*this will setup a PLACEHOLDER for self*/);
+ tl::nullopt /*this will setup a PLACEHOLDER for self*/);
if (!predicate.is_error ()
&& predicate.is_object_safe (true, type.get_locus ()))
void
TypeCheckType::visit (HIR::ArrayType &type)
{
- auto capacity_type = TypeCheckExpr::Resolve (type.get_size_expr ().get ());
+ auto capacity_type = TypeCheckExpr::Resolve (type.get_size_expr ());
if (capacity_type->get_kind () == TyTy::TypeKind::ERROR)
return;
TyTy::BaseType *expected_ty = nullptr;
bool ok = context->lookup_builtin ("usize", &expected_ty);
rust_assert (ok);
- context->insert_type (type.get_size_expr ()->get_mappings (), expected_ty);
+ context->insert_type (type.get_size_expr ().get_mappings (), expected_ty);
- unify_site (type.get_size_expr ()->get_mappings ().get_hirid (),
+ unify_site (type.get_size_expr ().get_mappings ().get_hirid (),
TyTy::TyWithLocation (expected_ty),
TyTy::TyWithLocation (capacity_type,
- type.get_size_expr ()->get_locus ()),
- type.get_size_expr ()->get_locus ());
+ type.get_size_expr ().get_locus ()),
+ type.get_size_expr ().get_locus ());
- TyTy::BaseType *base
- = TypeCheckType::Resolve (type.get_element_type ().get ());
+ TyTy::BaseType *base = TypeCheckType::Resolve (type.get_element_type ());
translated = new TyTy::ArrayType (type.get_mappings ().get_hirid (),
- type.get_locus (), *type.get_size_expr (),
+ type.get_locus (), type.get_size_expr (),
TyTy::TyVar (base->get_ref ()));
}
void
TypeCheckType::visit (HIR::SliceType &type)
{
- TyTy::BaseType *base
- = TypeCheckType::Resolve (type.get_element_type ().get ());
+ TyTy::BaseType *base = TypeCheckType::Resolve (type.get_element_type ());
translated
= new TyTy::SliceType (type.get_mappings ().get_hirid (), type.get_locus (),
TyTy::TyVar (base->get_ref ()));
void
TypeCheckType::visit (HIR::ReferenceType &type)
{
- TyTy::BaseType *base = TypeCheckType::Resolve (type.get_base_type ().get ());
+ TyTy::BaseType *base = TypeCheckType::Resolve (type.get_base_type ());
rust_assert (type.has_lifetime ());
auto region = context->lookup_and_resolve_lifetime (type.get_lifetime ());
if (!region.has_value ())
void
TypeCheckType::visit (HIR::RawPointerType &type)
{
- TyTy::BaseType *base = TypeCheckType::Resolve (type.get_base_type ().get ());
+ TyTy::BaseType *base = TypeCheckType::Resolve (type.get_base_type ());
translated
= new TyTy::PointerType (type.get_mappings ().get_hirid (),
TyTy::TyVar (base->get_ref ()), type.get_mut ());
}
TyTy::ParamType *
-TypeResolveGenericParam::Resolve (HIR::GenericParam *param, bool apply_sized)
+TypeResolveGenericParam::Resolve (HIR::GenericParam ¶m, bool apply_sized)
{
TypeResolveGenericParam resolver (apply_sized);
- switch (param->get_kind ())
+ switch (param.get_kind ())
{
case HIR::GenericParam::GenericKind::TYPE:
- resolver.visit (static_cast<HIR::TypeParam &> (*param));
+ resolver.visit (static_cast<HIR::TypeParam &> (param));
break;
case HIR::GenericParam::GenericKind::CONST:
- resolver.visit (static_cast<HIR::ConstGenericParam &> (*param));
+ resolver.visit (static_cast<HIR::ConstGenericParam &> (param));
break;
case HIR::GenericParam::GenericKind::LIFETIME:
- resolver.visit (static_cast<HIR::LifetimeParam &> (*param));
+ resolver.visit (static_cast<HIR::LifetimeParam &> (param));
break;
}
return resolver.resolved;
TypeResolveGenericParam::visit (HIR::TypeParam ¶m)
{
if (param.has_type ())
- TypeCheckType::Resolve (param.get_type ().get ());
+ TypeCheckType::Resolve (param.get_type ());
- HIR::Type *implicit_self_bound = nullptr;
+ std::unique_ptr<HIR::Type> implicit_self_bound = nullptr;
if (param.has_type_param_bounds ())
{
// We need two possible parameter types. One with no Bounds and one with
param.get_mappings ().get_nodeid (),
implicit_id,
param.get_mappings ().get_local_defid ());
- implicit_self_bound
- = new HIR::TypePath (mappings, {}, BUILTINS_LOCATION, false);
+ implicit_self_bound = Rust::make_unique<HIR::TypePath> (
+ HIR::TypePath (mappings, {}, BUILTINS_LOCATION, false));
}
std::map<DefId, std::vector<TyTy::TypeBoundPredicate>> predicates;
switch (bound->get_bound_type ())
{
case HIR::TypeParamBound::BoundType::TRAITBOUND: {
- HIR::TraitBound *b
- = static_cast<HIR::TraitBound *> (bound.get ());
+ HIR::TraitBound &b = static_cast<HIR::TraitBound &> (*bound);
- TyTy::TypeBoundPredicate predicate
- = get_predicate_from_bound (b->get_path (),
- implicit_self_bound,
- b->get_polarity ());
+ TyTy::TypeBoundPredicate predicate = get_predicate_from_bound (
+ b.get_path (), tl::optional (std::ref (*implicit_self_bound)),
+ b.get_polarity ());
if (!predicate.is_error ())
{
switch (predicate.get_polarity ())
else
{
// emit error message
- rich_location r (line_table, b->get_locus ());
+ rich_location r (line_table, b.get_locus ());
r.add_range (predicate.get ()->get_locus ());
rust_error_at (
r, "antibound for %s is not applied here",
}
auto &binding_type_path = item.get_bound_type ();
- TyTy::BaseType *binding = TypeCheckType::Resolve (binding_type_path.get ());
+ TyTy::BaseType *binding = TypeCheckType::Resolve (binding_type_path);
// FIXME double check there might be a trait cycle here see TypeParam handling
auto *b = static_cast<HIR::TraitBound *> (bound.get ());
TyTy::TypeBoundPredicate predicate
- = get_predicate_from_bound (b->get_path (),
- binding_type_path.get ());
+ = get_predicate_from_bound (b->get_path (), binding_type_path);
if (!predicate.is_error ())
specified_bounds.push_back (std::move (predicate));
}
// When we apply these bounds we must lookup which type this binding
// resolves to, as this is the type which will be used during resolution
// of the block.
- NodeId ast_node_id = binding_type_path->get_mappings ().get_nodeid ();
+ NodeId ast_node_id = binding_type_path.get_mappings ().get_nodeid ();
// then lookup the reference_node_id
NodeId ref_node_id = UNKNOWN_NODEID;
// FIXME
rust_error_at (UNDEF_LOCATION,
"Failed to lookup type reference for node: %s",
- binding_type_path->as_string ().c_str ());
+ binding_type_path.as_string ().c_str ());
return;
}
{
rust_error_at (mappings.lookup_location (*hid),
"Failed to resolve where-clause binding type: %s",
- binding_type_path->as_string ().c_str ());
+ binding_type_path.as_string ().c_str ());
return;
}
class TypeCheckResolveGenericArguments : public TypeCheckBase
{
public:
- static HIR::GenericArgs resolve (HIR::TypePathSegment *segment);
+ static HIR::GenericArgs resolve (HIR::TypePathSegment &segment);
void visit (HIR::TypePathSegmentGeneric &generic);
class TypeCheckType : public TypeCheckBase, public HIR::HIRTypeVisitor
{
public:
- static TyTy::BaseType *Resolve (HIR::Type *type);
+ static TyTy::BaseType *Resolve (HIR::Type &type);
void visit (HIR::BareFunctionType &fntype) override;
void visit (HIR::TupleType &tuple) override;
class TypeResolveGenericParam : public TypeCheckBase
{
public:
- static TyTy::ParamType *Resolve (HIR::GenericParam *param,
+ static TyTy::ParamType *Resolve (HIR::GenericParam ¶m,
bool apply_sized = true);
protected:
#include "rust-hir-type-check.h"
#include "rust-hir-full.h"
#include "rust-hir-inherent-impl-overlap.h"
+#include "rust-hir-pattern.h"
#include "rust-hir-type-check-expr.h"
#include "rust-hir-type-check-item.h"
#include "rust-hir-type-check-pattern.h"
#include "rust-hir-type-check-struct-field.h"
+#include "rust-make-unique.h"
#include "rust-immutable-name-resolution-context.h"
// for flag_name_resolution_2_0
TraitItemReference::get_type_from_constant (
/*const*/ HIR::TraitItemConst &constant) const
{
- TyTy::BaseType *type = TypeCheckType::Resolve (constant.get_type ().get ());
+ TyTy::BaseType *type = TypeCheckType::Resolve (constant.get_type ());
if (constant.has_expr ())
{
- TyTy::BaseType *expr
- = TypeCheckExpr::Resolve (constant.get_expr ().get ());
+ TyTy::BaseType *expr = TypeCheckExpr::Resolve (constant.get_expr ());
return unify_site (constant.get_mappings ().get_hirid (),
TyTy::TyWithLocation (type),
case HIR::GenericParam::GenericKind::TYPE: {
auto param_type
- = TypeResolveGenericParam::Resolve (generic_param.get ());
+ = TypeResolveGenericParam::Resolve (*generic_param);
context->insert_type (generic_param->get_mappings (),
param_type);
ret_type = TyTy::TupleType::get_unit_type ();
else
{
- auto resolved
- = TypeCheckType::Resolve (function.get_return_type ().get ());
+ auto resolved = TypeCheckType::Resolve (function.get_return_type ());
if (resolved->get_kind () == TyTy::TypeKind::ERROR)
{
rust_error_at (fn.get_locus (), "failed to resolve return type");
ret_type = resolved->clone ();
ret_type->set_ref (
- function.get_return_type ()->get_mappings ().get_hirid ());
+ function.get_return_type ().get_mappings ().get_hirid ());
}
std::vector<std::pair<HIR::Pattern *, TyTy::BaseType *> > params;
+
+ std::unique_ptr<HIR::IdentifierPattern> self_pattern = nullptr;
if (function.is_method ())
{
// these are implicit mappings and not used
// for compilation to know parameter names. The types are ignored
// but we reuse the HIR identifier pattern which requires it
HIR::SelfParam &self_param = function.get_self ();
- HIR::IdentifierPattern *self_pattern = new HIR::IdentifierPattern (
- mapping, {"self"}, self_param.get_locus (), self_param.is_ref (),
- self_param.is_mut () ? Mutability::Mut : Mutability::Imm,
- std::unique_ptr<HIR::Pattern> (nullptr));
+ self_pattern
+ = Rust::make_unique<HIR::IdentifierPattern> (HIR::IdentifierPattern (
+ mapping, {"self"}, self_param.get_locus (), self_param.is_ref (),
+ self_param.is_mut () ? Mutability::Mut : Mutability::Imm,
+ std::unique_ptr<HIR::Pattern> (nullptr)));
// might have a specified type
TyTy::BaseType *self_type = nullptr;
if (self_param.has_type ())
{
- std::unique_ptr<HIR::Type> &specified_type = self_param.get_type ();
- self_type = TypeCheckType::Resolve (specified_type.get ());
+ HIR::Type &specified_type = self_param.get_type ();
+ self_type = TypeCheckType::Resolve (specified_type);
}
else
{
context->insert_type (self_param.get_mappings (), self_type);
params.push_back (
- std::pair<HIR::Pattern *, TyTy::BaseType *> (self_pattern, self_type));
+ std::pair<HIR::Pattern *, TyTy::BaseType *> (self_pattern.get (),
+ self_type));
}
for (auto ¶m : function.get_function_params ())
{
// get the name as well required for later on
- auto param_tyty = TypeCheckType::Resolve (param.get_type ().get ());
- params.push_back (std::pair<HIR::Pattern *, TyTy::BaseType *> (
- param.get_param_name ().get (), param_tyty));
+ auto param_tyty = TypeCheckType::Resolve (param.get_type ());
+ params.push_back (
+ std::pair<HIR::Pattern *, TyTy::BaseType *> (¶m.get_param_name (),
+ param_tyty));
context->insert_type (param.get_mappings (), param_tyty);
- TypeCheckPattern::Resolve (param.get_param_name ().get (), param_tyty);
+ TypeCheckPattern::Resolve (param.get_param_name (), param_tyty);
}
auto &mappings = Analysis::Mappings::get ();
function.get_function_name ().as_string (), ident,
function.is_method () ? TyTy::FnType::FNTYPE_IS_METHOD_FLAG
: TyTy::FnType::FNTYPE_DEFAULT_FLAGS,
- ABI::RUST, std::move (params), ret_type, substitutions,
+ ABI::RUST, params, ret_type, substitutions,
TyTy::SubstitutionArgumentMappings::empty (
context->get_lifetime_resolver ().get_num_bound_regions ()),
region_constraints);
};
TypeCheckContextItem (HIR::Function *item);
- TypeCheckContextItem (HIR::ImplBlock *impl_block, HIR::Function *item);
+ TypeCheckContextItem (HIR::ImplBlock &impl_block, HIR::Function *item);
TypeCheckContextItem (HIR::TraitItemFunc *trait_item);
TypeCheckContextItem (const TypeCheckContextItem &other);
auto block = mappings.lookup_hir_extern_block (extern_item->second);
rust_assert (block.has_value ());
- *result = TypeCheckTopLevelExternItem::Resolve (extern_item->first,
- *block.value ());
+ *result
+ = TypeCheckTopLevelExternItem::Resolve (*extern_item.value ().first,
+ *block.value ());
context->query_completed (reference);
return true;
}
: type (ItemType::ITEM), item (item)
{}
-TypeCheckContextItem::TypeCheckContextItem (HIR::ImplBlock *impl_block,
+TypeCheckContextItem::TypeCheckContextItem (HIR::ImplBlock &impl_block,
HIR::Function *item)
- : type (ItemType::IMPL_ITEM), item (impl_block, item)
+ : type (ItemType::IMPL_ITEM), item (&impl_block, item)
{}
TypeCheckContextItem::TypeCheckContextItem (HIR::TraitItemFunc *trait_item)
if (!impl->has_trait_ref ())
return true;
- HirId impl_ty_id = impl->get_type ()->get_mappings ().get_hirid ();
+ HirId impl_ty_id = impl->get_type ().get_mappings ().get_hirid ();
TyTy::BaseType *impl_type = nullptr;
if (!query_type (impl_ty_id, &impl_type))
return true;
return true;
}
- possible_trait_paths.push_back ({impl->get_trait_ref ().get (), impl});
+ possible_trait_paths.push_back ({&impl->get_trait_ref (), impl});
return true;
});
}
TyTy::TypeBoundPredicate
-TypeCheckBase::get_predicate_from_bound (HIR::TypePath &type_path,
- HIR::Type *associated_self,
- BoundPolarity polarity)
+TypeCheckBase::get_predicate_from_bound (
+ HIR::TypePath &type_path,
+ tl::optional<std::reference_wrapper<HIR::Type>> associated_self,
+ BoundPolarity polarity)
{
TyTy::TypeBoundPredicate lookup = TyTy::TypeBoundPredicate::error ();
bool already_resolved
break;
case HIR::TypePathSegment::SegmentType::FUNCTION: {
- auto final_function_seg
- = static_cast<HIR::TypePathSegmentFunction *> (final_seg.get ());
- auto &fn = final_function_seg->get_function_path ();
+ auto &final_function_seg
+ = static_cast<HIR::TypePathSegmentFunction &> (*final_seg);
+ auto &fn = final_function_seg.get_function_path ();
// we need to make implicit generic args which must be an implicit
// Tuple
// resolve the fn_once_output type which assumes there must be an output
// set
rust_assert (fn.has_return_type ());
- TypeCheckType::Resolve (fn.get_return_type ().get ());
+ TypeCheckType::Resolve (fn.get_return_type ());
HIR::TraitItem *trait_item
= mappings
.value ();
std::vector<HIR::GenericArgsBinding> bindings;
- location_t output_locus = fn.get_return_type ()->get_locus ();
+ location_t output_locus = fn.get_return_type ().get_locus ();
HIR::GenericArgsBinding binding (Identifier (
trait_item->trait_identifier ()),
- fn.get_return_type ()->clone_type (),
+ fn.get_return_type ().clone_type (),
output_locus);
bindings.push_back (std::move (binding));
break;
}
- if (associated_self != nullptr)
+ if (associated_self.has_value ())
{
std::vector<std::unique_ptr<HIR::Type>> type_args;
- type_args.push_back (
- std::unique_ptr<HIR::Type> (associated_self->clone_type ()));
+ type_args.push_back (std::unique_ptr<HIR::Type> (
+ associated_self.value ().get ().clone_type ()));
for (auto &arg : args.get_type_args ())
{
type_args.push_back (std::unique_ptr<HIR::Type> (arg->clone_type ()));
if (!args.is_empty () || predicate.requires_generic_args ())
{
// this is applying generic arguments to a trait reference
- predicate.apply_generic_arguments (&args, associated_self != nullptr);
+ predicate.apply_generic_arguments (&args, associated_self.has_value ());
}
context->insert_resolved_predicate (type_path.get_mappings ().get_hirid (),
BaseType *field_tyty = field->get_field_type ();
location_t arg_locus = argument->get_locus ();
- BaseType *arg = Resolver::TypeCheckExpr::Resolve (argument.get ());
+ BaseType *arg = Resolver::TypeCheckExpr::Resolve (*argument);
if (arg->get_kind () == TyTy::TypeKind::ERROR)
{
rust_error_at (argument->get_locus (),
for (auto &argument : call.get_arguments ())
{
location_t arg_locus = argument->get_locus ();
- auto argument_expr_tyty
- = Resolver::TypeCheckExpr::Resolve (argument.get ());
+ auto argument_expr_tyty = Resolver::TypeCheckExpr::Resolve (*argument);
if (argument_expr_tyty->get_kind () == TyTy::TypeKind::ERROR)
{
rust_error_at (
// it might be a variadic function
if (i < type.num_params ())
{
- auto fnparam = type.param_at (i);
- HIR::Pattern *fn_param_pattern = fnparam.first;
+ auto &fnparam = type.param_at (i);
+ auto &fn_param_pattern = fnparam.first;
BaseType *param_ty = fnparam.second;
location_t param_locus
= fn_param_pattern == nullptr
{
location_t arg_locus = argument->get_locus ();
BaseType *fnparam = type.get_param_type_at (i);
- auto argument_expr_tyty
- = Resolver::TypeCheckExpr::Resolve (argument.get ());
+ auto argument_expr_tyty = Resolver::TypeCheckExpr::Resolve (*argument);
if (argument_expr_tyty->get_kind () == TyTy::TypeKind::ERROR)
{
rust_error_at (
std::vector<Argument> args;
for (auto &arg : call.get_arguments ())
{
- BaseType *argument_expr_tyty
- = Resolver::TypeCheckExpr::Resolve (arg.get ());
+ BaseType *argument_expr_tyty = Resolver::TypeCheckExpr::Resolve (*arg);
if (argument_expr_tyty->get_kind () == TyTy::TypeKind::ERROR)
{
rust_error_at (arg->get_locus (),
TypeCheckMethodCallExpr checker (call.get_mappings (), args,
call.get_locus (),
- call.get_receiver ()->get_locus (),
+ call.get_receiver ().get_locus (),
adjusted_self, context);
return checker.check (*ref);
}
{
location_t arg_locus = argument.get_locus ();
- auto fnparam = type.param_at (i);
+ auto &fnparam = type.param_at (i);
HIR::Pattern *fn_param_pattern = fnparam.first;
BaseType *param_ty = fnparam.second;
location_t param_locus
for (auto &binding : args.get_binding_args ())
{
BaseType *resolved
- = Resolver::TypeCheckType::Resolve (binding.get_type ().get ());
+ = Resolver::TypeCheckType::Resolve (binding.get_type ());
if (resolved == nullptr
|| resolved->get_kind () == TyTy::TypeKind::ERROR)
{
std::vector<SubstitutionArg> mappings = used_arguments.get_mappings ();
for (auto &arg : args.get_type_args ())
{
- BaseType *resolved = Resolver::TypeCheckType::Resolve (arg.get ());
+ BaseType *resolved = Resolver::TypeCheckType::Resolve (*arg);
if (resolved == nullptr || resolved->get_kind () == TyTy::TypeKind::ERROR)
{
return SubstitutionArgumentMappings::error ();
#include "rust-hir-type-bounds.h"
#include "options.h"
+#include <functional>
namespace Rust {
namespace TyTy {
{
std::vector<std::pair<HIR::Pattern *, BaseType *>> cloned_params;
for (auto &p : fn->get_params ())
- cloned_params.push_back ({p.first, p.second->monomorphized_clone ()});
+ cloned_params.push_back (std::pair<HIR::Pattern *, BaseType *> (
+ p.first, p.second->monomorphized_clone ()));
BaseType *retty = fn->get_return_type ()->monomorphized_clone ();
return new FnType (fn->get_ref (), fn->get_ty_ref (), fn->get_id (),
}
VariantDef::VariantDef (HirId id, DefId defid, std::string identifier,
- RustIdent ident, HIR::Expr *discriminant)
+ RustIdent ident,
+ std::unique_ptr<HIR::Expr> &&discriminant)
: id (id), defid (defid), identifier (identifier), ident (ident),
- discriminant (discriminant)
+ discriminant (std::move (discriminant))
{
type = VariantType::NUM;
VariantDef::VariantDef (HirId id, DefId defid, std::string identifier,
RustIdent ident, VariantType type,
- HIR::Expr *discriminant,
+ std::unique_ptr<HIR::Expr> &&discriminant,
std::vector<StructFieldType *> fields)
: id (id), defid (defid), identifier (identifier), ident (ident), type (type),
- discriminant (discriminant), fields (fields)
+ discriminant (std::move (discriminant)), fields (fields)
{
rust_assert ((type == VariantType::NUM && fields.empty ())
|| (type == VariantType::TUPLE || type == VariantType::STRUCT));
}
-VariantDef::VariantDef (const VariantDef &other)
- : id (other.id), defid (other.defid), identifier (other.identifier),
- ident (other.ident), type (other.type), discriminant (other.discriminant),
- fields (other.fields)
-{}
-
-VariantDef &
-VariantDef::operator= (const VariantDef &other)
-{
- id = other.id;
- identifier = other.identifier;
- type = other.type;
- discriminant = other.discriminant;
- fields = other.fields;
- ident = other.ident;
-
- return *this;
-}
-
VariantDef &
VariantDef::get_error_node ()
{
return false;
}
-HIR::Expr *
-VariantDef::get_discriminant () const
+HIR::Expr &
+VariantDef::get_discriminant ()
{
rust_assert (discriminant != nullptr);
- return discriminant;
+ return *discriminant;
}
std::string
for (auto &f : fields)
cloned_fields.push_back ((StructFieldType *) f->clone ());
- return new VariantDef (id, defid, identifier, ident, type, discriminant,
- cloned_fields);
+ return new VariantDef (id, defid, identifier, ident, type,
+ discriminant->clone_expr (), cloned_fields);
}
VariantDef *
for (auto &f : fields)
cloned_fields.push_back ((StructFieldType *) f->monomorphized_clone ());
- return new VariantDef (id, defid, identifier, ident, type, discriminant,
- cloned_fields);
+ return new VariantDef (id, defid, identifier, ident, type,
+ discriminant->clone_expr (), cloned_fields);
}
const RustIdent &
std::string params_str = "";
for (auto ¶m : params)
{
- auto pattern = param.first;
+ auto &pattern = param.first;
auto ty = param.second;
params_str += pattern->as_string () + " " + ty->as_string ();
params_str += ",";
{
std::vector<std::pair<HIR::Pattern *, BaseType *>> cloned_params;
for (auto &p : params)
- cloned_params.push_back ({p.first, p.second->clone ()});
+ cloned_params.push_back (
+ std::pair<HIR::Pattern *, BaseType *> (p.first, p.second->clone ()));
return new FnType (get_ref (), get_ty_ref (), get_id (), get_identifier (),
ident, flags, abi, std::move (cloned_params),
#include "rust-tyty-subst.h"
#include "rust-tyty-region.h"
#include "rust-system.h"
+#include "rust-hir.h"
+
+#include <limits>
namespace Rust {
static std::string variant_type_string (VariantType type);
VariantDef (HirId id, DefId defid, std::string identifier, RustIdent ident,
- HIR::Expr *discriminant);
+ std::unique_ptr<HIR::Expr> &&discriminant);
VariantDef (HirId id, DefId defid, std::string identifier, RustIdent ident,
- VariantType type, HIR::Expr *discriminant,
+ VariantType type, std::unique_ptr<HIR::Expr> &&discriminant,
std::vector<StructFieldType *> fields);
- VariantDef (const VariantDef &other);
-
- VariantDef &operator= (const VariantDef &other);
-
static VariantDef &get_error_node ();
bool is_error () const;
bool lookup_field (const std::string &lookup, StructFieldType **field_lookup,
size_t *index) const;
- HIR::Expr *get_discriminant () const;
+ HIR::Expr &get_discriminant ();
std::string as_string () const;
RustIdent ident;
VariantType type;
// can either be a structure or a discriminant value
- HIR::Expr *discriminant;
+ std::unique_ptr<HIR::Expr> discriminant;
std::vector<StructFieldType *> fields;
};
: CallableTypeInterface (ref, ref, TypeKind::FNDEF, ident, refs),
SubstitutionRef (std::move (subst_refs), substitution_argument_mappings,
region_constraints),
- params (std::move (params)), type (type), flags (flags),
- identifier (identifier), id (id), abi (abi)
+ params (params), type (type), flags (flags), identifier (identifier),
+ id (id), abi (abi)
{
LocalDefId local_def_id = id.localDefId;
rust_assert (local_def_id != UNKNOWN_LOCAL_DEFID);
: CallableTypeInterface (ref, ty_ref, TypeKind::FNDEF, ident, refs),
SubstitutionRef (std::move (subst_refs), substitution_argument_mappings,
region_constraints),
- params (params), type (type), flags (flags), identifier (identifier),
- id (id), abi (abi)
+ params (std::move (params)), type (type), flags (flags),
+ identifier (identifier), id (id), abi (abi)
{
LocalDefId local_def_id = id.localDefId;
rust_assert (local_def_id != UNKNOWN_LOCAL_DEFID);
auto id = item->get_mappings ().get_hirid ();
rust_assert (!lookup_hir_impl_block (id));
- HirId impl_type_id = item->get_type ()->get_mappings ().get_hirid ();
+ HirId impl_type_id = item->get_type ().get_mappings ().get_hirid ();
hirImplBlockMappings[id] = item;
hirImplBlockTypeMappings[impl_type_id] = item;
insert_node_to_hir (item->get_mappings ().get_nodeid (), id);
projects / thirdparty / gcc.git / commitdiff
