Line data    Source code

       1              : // Copyright (C) 2020-2026 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        10266 : CompileFnParam::CompileFnParam (Context *ctx, tree fndecl, tree decl_type,
      28              :                                 location_t locus)
      29        10266 :   : HIRCompileBase (ctx), fndecl (fndecl), decl_type (decl_type), locus (locus),
      30        10266 :     compiled_param (Bvariable::error_variable ())
      31        10266 : {}
      32              : 
      33              : Bvariable *
      34         6377 : CompileFnParam::compile (Context *ctx, tree fndecl, HIR::FunctionParam &param,
      35              :                          tree decl_type, location_t locus)
      36              : {
      37         6377 :   CompileFnParam compiler (ctx, fndecl, decl_type, locus);
      38         6377 :   param.get_param_name ().accept_vis (compiler);
      39         6376 :   return compiler.compiled_param;
      40         6376 : }
      41              : 
      42              : Bvariable *
      43         3889 : CompileFnParam::compile (Context *ctx, tree fndecl, HIR::Pattern &param,
      44              :                          tree decl_type, location_t locus)
      45              : {
      46         3889 :   CompileFnParam compiler (ctx, fndecl, decl_type, locus);
      47         3889 :   param.accept_vis (compiler);
      48         3889 :   return compiler.compiled_param;
      49         3889 : }
      50              : 
      51              : void
      52        10206 : CompileFnParam::visit (HIR::IdentifierPattern &pattern)
      53              : {
      54        10206 :   if (!pattern.is_mut ())
      55        10175 :     decl_type = Backend::immutable_type (decl_type);
      56              : 
      57        10206 :   compiled_param
      58        20412 :     = Backend::parameter_variable (fndecl,
      59        10206 :                                    pattern.get_identifier ().as_string (),
      60              :                                    decl_type, locus);
      61        10206 : }
      62              : 
      63              : void
      64           28 : CompileFnParam::visit (HIR::WildcardPattern &pattern)
      65              : {
      66           28 :   decl_type = Backend::immutable_type (decl_type);
      67              : 
      68           28 :   compiled_param = Backend::parameter_variable (fndecl, "_", decl_type, locus);
      69           28 : }
      70              : 
      71              : void
      72            8 : CompileFnParam::visit (HIR::TuplePattern &pattern)
      73              : {
      74            8 :   compiled_param = create_tmp_param_var (decl_type);
      75            8 :   CompilePatternBindings::Compile (
      76              :     pattern, Backend::var_expression (compiled_param, locus), ctx);
      77            8 : }
      78              : 
      79              : void
      80            3 : CompileFnParam::visit (HIR::StructPattern &pattern)
      81              : {
      82            3 :   compiled_param = create_tmp_param_var (decl_type);
      83            3 :   CompilePatternBindings::Compile (
      84              :     pattern, Backend::var_expression (compiled_param, locus), ctx);
      85            3 : }
      86              : 
      87              : void
      88           10 : CompileFnParam::visit (HIR::TupleStructPattern &pattern)
      89              : {
      90           10 :   compiled_param = create_tmp_param_var (decl_type);
      91           10 :   CompilePatternBindings::Compile (
      92              :     pattern, Backend::var_expression (compiled_param, locus), ctx);
      93            9 : }
      94              : 
      95              : void
      96           10 : CompileFnParam::visit (HIR::ReferencePattern &pattern)
      97              : {
      98           10 :   compiled_param = create_tmp_param_var (decl_type);
      99           10 :   CompilePatternBindings::Compile (
     100              :     pattern, Backend::var_expression (compiled_param, locus), ctx);
     101           10 : }
     102              : 
     103              : Bvariable *
     104         5511 : CompileSelfParam::compile (Context *ctx, tree fndecl, HIR::SelfParam &self,
     105              :                            tree decl_type, location_t locus)
     106              : {
     107         5511 :   bool is_immutable
     108         5511 :     = self.get_self_kind () == HIR::SelfParam::ImplicitSelfKind::IMM
     109         5511 :       || self.get_self_kind () == HIR::SelfParam::ImplicitSelfKind::IMM_REF;
     110              :   if (is_immutable)
     111         5335 :     decl_type = Backend::immutable_type (decl_type);
     112              : 
     113         5511 :   return Backend::parameter_variable (fndecl, "self", decl_type, locus);
     114              : }
     115              : 
     116              : Bvariable *
     117           31 : CompileFnParam::create_tmp_param_var (tree decl_type)
     118              : {
     119              :   // generate the anon param
     120           31 :   tree tmp_ident = create_tmp_var_name ("RSTPRM");
     121           31 :   std::string cpp_str_identifier = std::string (IDENTIFIER_POINTER (tmp_ident));
     122              : 
     123           31 :   decl_type = Backend::immutable_type (decl_type);
     124           31 :   return Backend::parameter_variable (fndecl, cpp_str_identifier, decl_type,
     125           31 :                                       locus);
     126           31 : }
     127              : 
     128              : } // namespace Compile
     129              : } // namespace Rust