gcc/rust/backend/rust-compile-expr.h

   1 // Copyright (C) 2020-2023 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 #ifndef RUST_COMPILE_EXPR
  20 #define RUST_COMPILE_EXPR
  21
  22 #include "rust-compile-base.h"
  23
  24 namespace Rust {
  25 namespace Compile {
  26
  27 class CompileExpr : private HIRCompileBase, protected HIR::HIRExpressionVisitor
  28 {
  29 public:
  30   static tree Compile (HIR::Expr *expr, Context *ctx);
  31
  32   void visit (HIR::TupleIndexExpr &expr) override;
  33   void visit (HIR::TupleExpr &expr) override;
  34   void visit (HIR::ReturnExpr &expr) override;
  35   void visit (HIR::CallExpr &expr) override;
  36   void visit (HIR::MethodCallExpr &expr) override;
  37   void visit (HIR::LiteralExpr &expr) override;
  38   void visit (HIR::AssignmentExpr &expr) override;
  39   void visit (HIR::CompoundAssignmentExpr &expr) override;
  40   void visit (HIR::ArrayIndexExpr &expr) override;
  41   void visit (HIR::ArrayExpr &expr) override;
  42   void visit (HIR::ArithmeticOrLogicalExpr &expr) override;
  43   void visit (HIR::ComparisonExpr &expr) override;
  44   void visit (HIR::LazyBooleanExpr &expr) override;
  45   void visit (HIR::NegationExpr &expr) override;
  46   void visit (HIR::TypeCastExpr &expr) override;
  47   void visit (HIR::IfExpr &expr) override;
  48   void visit (HIR::IfExprConseqIf &expr) override;
  49   void visit (HIR::IfExprConseqElse &expr) override;
  50   void visit (HIR::BlockExpr &expr) override;
  51   void visit (HIR::UnsafeBlockExpr &expr) override;
  52   void visit (HIR::StructExprStruct &struct_expr) override;
  53   void visit (HIR::StructExprStructFields &struct_expr) override;
  54   void visit (HIR::GroupedExpr &expr) override;
  55   void visit (HIR::FieldAccessExpr &expr) override;
  56   void visit (HIR::QualifiedPathInExpression &expr) override;
  57   void visit (HIR::PathInExpression &expr) override;
  58   void visit (HIR::LoopExpr &expr) override;
  59   void visit (HIR::WhileLoopExpr &expr) override;
  60   void visit (HIR::BreakExpr &expr) override;
  61   void visit (HIR::ContinueExpr &expr) override;
  62   void visit (HIR::BorrowExpr &expr) override;
  63   void visit (HIR::DereferenceExpr &expr) override;
  64   void visit (HIR::MatchExpr &expr) override;
  65   void visit (HIR::RangeFromToExpr &expr) override;
  66   void visit (HIR::RangeFromExpr &expr) override;
  67   void visit (HIR::RangeToExpr &expr) override;
  68   void visit (HIR::RangeFullExpr &expr) override;
  69   void visit (HIR::RangeFromToInclExpr &expr) override;
  70
  71   // Empty visit for unused Expression HIR nodes.
  72   void visit (HIR::ClosureExprInner &) override {}
  73   void visit (HIR::ClosureExprInnerTyped &) override {}
  74   void visit (HIR::StructExprFieldIdentifier &) override {}
  75   void visit (HIR::StructExprFieldIdentifierValue &) override {}
  76   void visit (HIR::StructExprFieldIndexValue &) override {}
  77   void visit (HIR::ErrorPropagationExpr &) override {}
  78   void visit (HIR::RangeToInclExpr &) override {}
  79   void visit (HIR::WhileLetLoopExpr &) override {}
  80   void visit (HIR::ForLoopExpr &) override {}
  81   void visit (HIR::IfExprConseqIfLet &) override {}
  82   void visit (HIR::IfLetExpr &) override {}
  83   void visit (HIR::IfLetExprConseqElse &) override {}
  84   void visit (HIR::IfLetExprConseqIf &) override {}
  85   void visit (HIR::IfLetExprConseqIfLet &) override {}
  86   void visit (HIR::AwaitExpr &) override {}
  87   void visit (HIR::AsyncBlockExpr &) override {}
  88
  89 protected:
  90   tree get_fn_addr_from_dyn (const TyTy::DynamicObjectType *dyn,
  91                              TyTy::BaseType *receiver, TyTy::FnType *fntype,
  92                              tree receiver_ref, Location expr_locus);
  93
  94   tree get_receiver_from_dyn (const TyTy::DynamicObjectType *dyn,
  95                               TyTy::BaseType *receiver, TyTy::FnType *fntype,
  96                               tree receiver_ref, Location expr_locus);
  97
  98   tree resolve_method_address (TyTy::FnType *fntype, HirId ref,
  99                                TyTy::BaseType *receiver,
 100                                HIR::PathIdentSegment &segment,
 101                                Analysis::NodeMapping expr_mappings,
 102                                Location expr_locus);
 103
 104   tree
 105   resolve_operator_overload (Analysis::RustLangItem::ItemType lang_item_type,
 106                              HIR::OperatorExprMeta expr, tree lhs, tree rhs,
 107                              HIR::Expr *lhs_expr, HIR::Expr *rhs_expr);
 108
 109   tree compile_bool_literal (const HIR::LiteralExpr &expr,
 110                              const TyTy::BaseType *tyty);
 111
 112   tree compile_integer_literal (const HIR::LiteralExpr &expr,
 113                                 const TyTy::BaseType *tyty);
 114
 115   tree compile_float_literal (const HIR::LiteralExpr &expr,
 116                               const TyTy::BaseType *tyty);
 117
 118   tree compile_char_literal (const HIR::LiteralExpr &expr,
 119                              const TyTy::BaseType *tyty);
 120
 121   tree compile_byte_literal (const HIR::LiteralExpr &expr,
 122                              const TyTy::BaseType *tyty);
 123
 124   tree compile_string_literal (const HIR::LiteralExpr &expr,
 125                                const TyTy::BaseType *tyty);
 126
 127   tree compile_byte_string_literal (const HIR::LiteralExpr &expr,
 128                                     const TyTy::BaseType *tyty);
 129
 130   tree type_cast_expression (tree type_to_cast_to, tree expr, Location locus);
 131
 132   tree array_value_expr (Location expr_locus, const TyTy::ArrayType &array_tyty,
 133                          tree array_type, HIR::ArrayElemsValues &elems);
 134
 135   tree array_copied_expr (Location expr_locus,
 136                           const TyTy::ArrayType &array_tyty, tree array_type,
 137                           HIR::ArrayElemsCopied &elems);
 138
 139 private:
 140   CompileExpr (Context *ctx);
 141
 142   tree translated;
 143 };
 144
 145 } // namespace Compile
 146 } // namespace Rust
 147
 148 #endif // RUST_COMPILE_EXPR