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 void visit (HIR::ClosureExpr &expr) override;
71
72 // TODO
73 void visit (HIR::ErrorPropagationExpr &) override {}
74 void visit (HIR::RangeToInclExpr &) override {}
75 void visit (HIR::ForLoopExpr &) override {}
76
77 // TODO
78 // these need to be sugared in the HIR to if statements and a match
79 void visit (HIR::WhileLetLoopExpr &) override {}
80 void visit (HIR::IfExprConseqIfLet &) override {}
81 void visit (HIR::IfLetExpr &) override {}
82 void visit (HIR::IfLetExprConseqElse &) override {}
83 void visit (HIR::IfLetExprConseqIf &) override {}
84 void visit (HIR::IfLetExprConseqIfLet &) override {}
85
86 // lets not worry about async yet....
87 void visit (HIR::AwaitExpr &) override {}
88 void visit (HIR::AsyncBlockExpr &) override {}
89
90 // nothing to do for these
91 void visit (HIR::StructExprFieldIdentifier &) override {}
92 void visit (HIR::StructExprFieldIdentifierValue &) override {}
93 void visit (HIR::StructExprFieldIndexValue &) override {}
94
95 protected:
96 tree get_fn_addr_from_dyn (const TyTy::DynamicObjectType *dyn,
97 TyTy::BaseType *receiver, TyTy::FnType *fntype,
98 tree receiver_ref, Location expr_locus);
99
100 tree get_receiver_from_dyn (const TyTy::DynamicObjectType *dyn,
101 TyTy::BaseType *receiver, TyTy::FnType *fntype,
102 tree receiver_ref, Location expr_locus);
103
104 tree resolve_method_address (TyTy::FnType *fntype, HirId ref,
105 TyTy::BaseType *receiver,
106 HIR::PathIdentSegment &segment,
107 Analysis::NodeMapping expr_mappings,
108 Location expr_locus);
109
110 tree
111 resolve_operator_overload (Analysis::RustLangItem::ItemType lang_item_type,
112 HIR::OperatorExprMeta expr, tree lhs, tree rhs,
113 HIR::Expr *lhs_expr, HIR::Expr *rhs_expr);
114
115 tree compile_bool_literal (const HIR::LiteralExpr &expr,
116 const TyTy::BaseType *tyty);
117
118 tree compile_integer_literal (const HIR::LiteralExpr &expr,
119 const TyTy::BaseType *tyty);
120
121 tree compile_float_literal (const HIR::LiteralExpr &expr,
122 const TyTy::BaseType *tyty);
123
124 tree compile_char_literal (const HIR::LiteralExpr &expr,
125 const TyTy::BaseType *tyty);
126
127 tree compile_byte_literal (const HIR::LiteralExpr &expr,
128 const TyTy::BaseType *tyty);
129
130 tree compile_string_literal (const HIR::LiteralExpr &expr,
131 const TyTy::BaseType *tyty);
132
133 tree compile_byte_string_literal (const HIR::LiteralExpr &expr,
134 const TyTy::BaseType *tyty);
135
136 tree type_cast_expression (tree type_to_cast_to, tree expr, Location locus);
137
138 tree array_value_expr (Location expr_locus, const TyTy::ArrayType &array_tyty,
139 tree array_type, HIR::ArrayElemsValues &elems);
140
141 tree array_copied_expr (Location expr_locus,
142 const TyTy::ArrayType &array_tyty, tree array_type,
143 HIR::ArrayElemsCopied &elems);
144
145 protected:
146 tree generate_closure_function (HIR::ClosureExpr &expr,
147 TyTy::ClosureType &closure_tyty,
148 tree compiled_closure_tyty);
149
150 tree generate_closure_fntype (HIR::ClosureExpr &expr,
151 const TyTy::ClosureType &closure_tyty,
152 tree compiled_closure_tyty,
153 TyTy::FnType **fn_tyty);
154
155 bool generate_possible_fn_trait_call (HIR::CallExpr &expr, tree receiver,
156 tree *result);
157
158 private:
159 CompileExpr (Context *ctx);
160
161 tree translated;
162 };
163
164 } // namespace Compile
165 } // namespace Rust
166
167 #endif // RUST_COMPILE_EXPR