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              : #ifndef RUST_HIR_TYPE_CHECK_EXPR
      20              : #define RUST_HIR_TYPE_CHECK_EXPR
      21              : 
      22              : #include "rust-hir-expr.h"
      23              : #include "rust-hir-type-check-base.h"
      24              : #include "rust-hir-visitor.h"
      25              : #include "rust-tyty.h"
      26              : 
      27              : namespace Rust {
      28              : namespace Resolver {
      29              : 
      30       161155 : class TypeCheckExpr : private TypeCheckBase, private HIR::HIRExpressionVisitor
      31              : {
      32              : public:
      33              :   static TyTy::BaseType *Resolve (HIR::Expr &expr);
      34              : 
      35              :   static TyTy::BaseType *
      36              :   ResolveOpOverload (LangItem::Kind lang_item_type, HIR::OperatorExprMeta expr,
      37              :                      TyTy::BaseType *lhs, TyTy::BaseType *rhs,
      38              :                      HIR::PathIdentSegment specified_segment,
      39              :                      TyTy::BaseType *result_type);
      40              : 
      41              :   void visit (HIR::TupleIndexExpr &expr) override;
      42              :   void visit (HIR::TupleExpr &expr) override;
      43              :   void visit (HIR::ReturnExpr &expr) override;
      44              :   void visit (HIR::CallExpr &expr) override;
      45              :   void visit (HIR::MethodCallExpr &expr) override;
      46              :   void visit (HIR::AssignmentExpr &expr) override;
      47              :   void visit (HIR::CompoundAssignmentExpr &expr) override;
      48              :   void visit (HIR::LiteralExpr &expr) override;
      49              :   void visit (HIR::ArithmeticOrLogicalExpr &expr) override;
      50              :   void visit (HIR::ComparisonExpr &expr) override;
      51              :   void visit (HIR::LazyBooleanExpr &expr) override;
      52              :   void visit (HIR::NegationExpr &expr) override;
      53              :   void visit (HIR::IfExpr &expr) override;
      54              :   void visit (HIR::IfExprConseqElse &expr) override;
      55              :   void visit (HIR::BlockExpr &expr) override;
      56              :   void visit (HIR::AnonConst &expr) override;
      57              :   void visit (HIR::ConstBlock &expr) override;
      58              :   void visit (HIR::UnsafeBlockExpr &expr) override;
      59              :   void visit (HIR::ArrayIndexExpr &expr) override;
      60              :   void visit (HIR::ArrayExpr &expr) override;
      61              :   void visit (HIR::StructExprStruct &struct_expr) override;
      62              :   void visit (HIR::StructExprStructFields &struct_expr) override;
      63              :   void visit (HIR::GroupedExpr &expr) override;
      64              :   void visit (HIR::FieldAccessExpr &expr) override;
      65              :   void visit (HIR::QualifiedPathInExpression &expr) override;
      66              :   void visit (HIR::PathInExpression &expr) override;
      67              :   void visit (HIR::LoopExpr &expr) override;
      68              :   void visit (HIR::BreakExpr &expr) override;
      69              :   void visit (HIR::ContinueExpr &expr) override;
      70              :   void visit (HIR::BorrowExpr &expr) override;
      71              :   void visit (HIR::DereferenceExpr &expr) override;
      72              :   void visit (HIR::TypeCastExpr &expr) override;
      73              :   void visit (HIR::MatchExpr &expr) override;
      74              :   void visit (HIR::RangeFromToExpr &expr) override;
      75              :   void visit (HIR::RangeFromExpr &expr) override;
      76              :   void visit (HIR::RangeToExpr &expr) override;
      77              :   void visit (HIR::RangeFullExpr &expr) override;
      78              :   void visit (HIR::WhileLoopExpr &expr) override;
      79              :   void visit (HIR::ClosureExpr &expr) override;
      80              :   void visit (HIR::InlineAsm &expr) override;
      81              :   void visit (HIR::LlvmInlineAsm &expr) override;
      82              :   void visit (HIR::OffsetOf &expr) override;
      83              :   void visit (HIR::BoxExpr &expr) override;
      84              : 
      85              :   // TODO
      86            0 :   void visit (HIR::ErrorPropagationExpr &) override {}
      87            0 :   void visit (HIR::RangeToInclExpr &) override {}
      88            0 :   void visit (HIR::WhileLetLoopExpr &) override {}
      89              : 
      90              :   // lets not worry about async yet....
      91            0 :   void visit (HIR::AwaitExpr &) override {}
      92            0 :   void visit (HIR::AsyncBlockExpr &) override {}
      93              : 
      94              :   // don't need to implement these see rust-hir-type-check-struct-field.h
      95            0 :   void visit (HIR::StructExprFieldIdentifier &) override
      96              :   {
      97            0 :     rust_unreachable ();
      98              :   }
      99            0 :   void visit (HIR::StructExprFieldIndexValue &) override
     100              :   {
     101            0 :     rust_unreachable ();
     102              :   }
     103            0 :   void visit (HIR::StructExprFieldIdentifierValue &) override
     104              :   {
     105            0 :     rust_unreachable ();
     106              :   }
     107              : 
     108              : protected:
     109              :   bool resolve_operator_overload (LangItem::Kind lang_item_type,
     110              :                                   HIR::OperatorExprMeta expr,
     111              :                                   TyTy::BaseType *lhs, TyTy::BaseType *rhs,
     112              :                                   HIR::PathIdentSegment specified_segment
     113              :                                   = HIR::PathIdentSegment::create_error (),
     114              :                                   bool allow_defer = true,
     115              :                                   TyTy::BaseType *result_type = nullptr,
     116              :                                   TyTy::BaseType *probe_lhs = nullptr);
     117              : 
     118              :   bool resolve_fn_trait_call (HIR::CallExpr &expr,
     119              :                               TyTy::BaseType *function_tyty,
     120              :                               TyTy::BaseType **result);
     121              : 
     122              :   HIR::PathIdentSegment resolve_possible_fn_trait_call_method_name (
     123              :     const TyTy::BaseType &receiver,
     124              :     TyTy::TypeBoundPredicate *associated_predicate);
     125              : 
     126              : private:
     127              :   TypeCheckExpr ();
     128              : 
     129              :   TyTy::BaseType *resolve_root_path (HIR::PathInExpression &expr,
     130              :                                      size_t *offset,
     131              :                                      NodeId *root_resolved_node_id);
     132              : 
     133              :   void resolve_segments (NodeId root_resolved_node_id,
     134              :                          std::vector<HIR::PathExprSegment> &segments,
     135              :                          size_t offset, TyTy::BaseType *tyseg,
     136              :                          const Analysis::NodeMapping &expr_mappings,
     137              :                          location_t expr_locus);
     138              : 
     139              :   bool
     140              :   validate_arithmetic_type (const TyTy::BaseType *tyty,
     141              :                             HIR::ArithmeticOrLogicalExpr::ExprType expr_type);
     142              : 
     143              :   /* The return value of TypeCheckExpr::Resolve */
     144              :   TyTy::BaseType *infered;
     145              : };
     146              : 
     147              : } // namespace Resolver
     148              : } // namespace Rust
     149              : 
     150              : #endif // RUST_HIR_TYPE_CHECK_EXPR