gcc/rust/backend/rust-compile-fnparam.cc

   1 // Copyright (C) 2020-2025 Free Software Foundation, Inc.
   2
   3 // This file is part of GCC.
   4
   5 // GCC is free software; you can redistribute it and/or modify it under
   6 // the terms of the GNU General Public License as published by the Free
   7 // Software Foundation; either version 3, or (at your option) any later
   8 // version.
   9
  10 // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  11 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13 // for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with GCC; see the file COPYING3.  If not see
  17 // <http://www.gnu.org/licenses/>.
  18
  19 #include "rust-compile-fnparam.h"
  20 #include "rust-compile-pattern.h"
  21
  22 #include "gimple-expr.h"
  23
  24 namespace Rust {
  25 namespace Compile {
  26
  27 CompileFnParam::CompileFnParam (Context *ctx, tree fndecl, tree decl_type,
  28                                 location_t locus)
  29   : HIRCompileBase (ctx), fndecl (fndecl), decl_type (decl_type), locus (locus),
  30     compiled_param (Bvariable::error_variable ())
  31 {}
  32
  33 Bvariable *
  34 CompileFnParam::compile (Context *ctx, tree fndecl, HIR::FunctionParam &param,
  35                          tree decl_type, location_t locus)
  36 {
  37   CompileFnParam compiler (ctx, fndecl, decl_type, locus);
  38   param.get_param_name ().accept_vis (compiler);
  39   return compiler.compiled_param;
  40 }
  41
  42 Bvariable *
  43 CompileFnParam::compile (Context *ctx, tree fndecl, HIR::Pattern &param,
  44                          tree decl_type, location_t locus)
  45 {
  46   CompileFnParam compiler (ctx, fndecl, decl_type, locus);
  47   param.accept_vis (compiler);
  48   return compiler.compiled_param;
  49 }
  50
  51 void
  52 CompileFnParam::visit (HIR::IdentifierPattern &pattern)
  53 {
  54   if (!pattern.is_mut ())
  55     decl_type = Backend::immutable_type (decl_type);
  56
  57   compiled_param
  58     = Backend::parameter_variable (fndecl,
  59                                    pattern.get_identifier ().as_string (),
  60                                    decl_type, locus);
  61 }
  62
  63 void
  64 CompileFnParam::visit (HIR::WildcardPattern &pattern)
  65 {
  66   decl_type = Backend::immutable_type (decl_type);
  67
  68   compiled_param = Backend::parameter_variable (fndecl, "_", decl_type, locus);
  69 }
  70
  71 void
  72 CompileFnParam::visit (HIR::TuplePattern &pattern)
  73 {
  74   compiled_param = create_tmp_param_var (decl_type);
  75   CompilePatternBindings::Compile (
  76     pattern, Backend::var_expression (compiled_param, locus), ctx);
  77 }
  78
  79 void
  80 CompileFnParam::visit (HIR::StructPattern &pattern)
  81 {
  82   compiled_param = create_tmp_param_var (decl_type);
  83   CompilePatternBindings::Compile (
  84     pattern, Backend::var_expression (compiled_param, locus), ctx);
  85 }
  86
  87 void
  88 CompileFnParam::visit (HIR::TupleStructPattern &pattern)
  89 {
  90   compiled_param = create_tmp_param_var (decl_type);
  91   CompilePatternBindings::Compile (
  92     pattern, Backend::var_expression (compiled_param, locus), ctx);
  93 }
  94
  95 void
  96 CompileFnParam::visit (HIR::ReferencePattern &pattern)
  97 {
  98   compiled_param = create_tmp_param_var (decl_type);
  99   CompilePatternBindings::Compile (
 100     pattern, Backend::var_expression (compiled_param, locus), ctx);
 101 }
 102
 103 Bvariable *
 104 CompileSelfParam::compile (Context *ctx, tree fndecl, HIR::SelfParam &self,
 105                            tree decl_type, location_t locus)
 106 {
 107   bool is_immutable
 108     = self.get_self_kind () == HIR::SelfParam::ImplicitSelfKind::IMM
 109       || self.get_self_kind () == HIR::SelfParam::ImplicitSelfKind::IMM_REF;
 110   if (is_immutable)
 111     decl_type = Backend::immutable_type (decl_type);
 112
 113   return Backend::parameter_variable (fndecl, "self", decl_type, locus);
 114 }
 115
 116 Bvariable *
 117 CompileFnParam::create_tmp_param_var (tree decl_type)
 118 {
 119   // generate the anon param
 120   tree tmp_ident = create_tmp_var_name ("RSTPRM");
 121   std::string cpp_str_identifier = std::string (IDENTIFIER_POINTER (tmp_ident));
 122
 123   decl_type = Backend::immutable_type (decl_type);
 124   return Backend::parameter_variable (fndecl, cpp_str_identifier, decl_type,
 125                                       locus);
 126 }
 127
 128 } // namespace Compile
 129 } // namespace Rust