Line data    Source code

       1              : // Copyright (C) 2025-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-derive-debug.h"
      20              : #include "rust-ast.h"
      21              : #include "rust-hir-map.h"
      22              : #include "rust-system.h"
      23              : 
      24              : namespace Rust {
      25              : namespace AST {
      26              : 
      27            3 : DeriveDebug::DeriveDebug (location_t loc)
      28            3 :   : DeriveVisitor (loc), expanded (nullptr)
      29            3 : {}
      30              : 
      31              : std::unique_ptr<Item>
      32            3 : DeriveDebug::go (Item &item)
      33              : {
      34            3 :   item.accept_vis (*this);
      35              : 
      36            3 :   rust_assert (expanded);
      37              : 
      38            3 :   return std::move (expanded);
      39              : }
      40              : 
      41              : std::unique_ptr<AssociatedItem>
      42            3 : DeriveDebug::stub_debug_fn ()
      43              : {
      44            3 :   auto unit_expr = builder.tuple ();
      45            3 :   auto ok_expr
      46            3 :     = ptrify (builder.path_in_expression (LangItem::Kind::RESULT_OK));
      47              : 
      48            6 :   auto stub_return = builder.call (std::move (ok_expr), std::move (unit_expr));
      49              : 
      50              :   // we can't use builder.block() here as it returns a unique_ptr<Expr> and
      51              :   // Function's constructor expects a unique_ptr<BlockExpr>
      52            3 :   auto block = std::unique_ptr<BlockExpr> (
      53            3 :     new BlockExpr ({}, std::move (stub_return), {}, {}, tl::nullopt, loc, loc));
      54              : 
      55            3 :   auto self = builder.self_ref_param ();
      56              : 
      57            3 :   auto return_type
      58            3 :     = ptrify (builder.type_path ({"core", "fmt", "Result"}, true));
      59              : 
      60            3 :   auto mut_fmt_type_inner
      61            3 :     = ptrify (builder.type_path ({"core", "fmt", "Formatter"}, true));
      62              : 
      63            3 :   auto mut_fmt_type
      64            3 :     = builder.reference_type (std::move (mut_fmt_type_inner), true);
      65              : 
      66            6 :   auto fmt = builder.function_param (builder.identifier_pattern ("_fmt"),
      67            3 :                                      std::move (mut_fmt_type));
      68              : 
      69            3 :   auto params = vec (std::move (self), std::move (fmt));
      70              : 
      71            9 :   auto function = builder.function ("fmt", std::move (params),
      72            6 :                                     std::move (return_type), std::move (block));
      73              : 
      74            3 :   return function;
      75            3 : }
      76              : 
      77              : std::unique_ptr<Item>
      78            3 : DeriveDebug::stub_derive_impl (
      79              :   std::string name,
      80              :   const std::vector<std::unique_ptr<GenericParam>> &type_generics)
      81              : {
      82            3 :   auto trait_items = vec (stub_debug_fn ());
      83              : 
      84            6 :   auto debug = [this] () {
      85            3 :     return builder.type_path ({"core", "fmt", "Debug"}, true);
      86            3 :   };
      87            6 :   auto generics = setup_impl_generics (name, type_generics, [&, this] () {
      88            0 :     return builder.trait_bound (debug ());
      89            3 :   });
      90              : 
      91            6 :   return builder.trait_impl (debug (), std::move (generics.self_type),
      92              :                              std::move (trait_items),
      93            6 :                              std::move (generics.impl));
      94            3 : }
      95              : 
      96              : void
      97            1 : DeriveDebug::visit_struct (StructStruct &struct_item)
      98              : {
      99            3 :   expanded = stub_derive_impl (struct_item.get_identifier ().as_string (),
     100            2 :                                struct_item.get_generic_params ());
     101            1 : }
     102              : 
     103              : void
     104            1 : DeriveDebug::visit_tuple (TupleStruct &tuple_item)
     105              : {
     106            3 :   expanded = stub_derive_impl (tuple_item.get_identifier ().as_string (),
     107            2 :                                tuple_item.get_generic_params ());
     108            1 : }
     109              : 
     110              : void
     111            1 : DeriveDebug::visit_enum (Enum &enum_item)
     112              : {
     113            3 :   expanded = stub_derive_impl (enum_item.get_identifier ().as_string (),
     114            2 :                                enum_item.get_generic_params ());
     115            1 : }
     116              : 
     117              : void
     118            0 : DeriveDebug::visit_union (Union &enum_item)
     119              : {
     120            0 :   rust_error_at (loc, "derive(Debug) cannot be derived for unions");
     121            0 : }
     122              : 
     123              : } // namespace AST
     124              : } // namespace Rust