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_HIR_TYPE_CHECK_EXPR
      20  #define RUST_HIR_TYPE_CHECK_EXPR
      21  
      22  #include "rust-hir-type-check-base.h"
      23  #include "rust-tyty.h"
      24  
      25  namespace Rust {
      26  namespace Resolver {
      27  
      28  class TypeCheckExpr : private TypeCheckBase, private HIR::HIRExpressionVisitor
      29  {
      30  public:
      31    static TyTy::BaseType *Resolve (HIR::Expr *expr);
      32  
      33    void visit (HIR::TupleIndexExpr &expr) override;
      34    void visit (HIR::TupleExpr &expr) override;
      35    void visit (HIR::ReturnExpr &expr) override;
      36    void visit (HIR::CallExpr &expr) override;
      37    void visit (HIR::MethodCallExpr &expr) override;
      38    void visit (HIR::AssignmentExpr &expr) override;
      39    void visit (HIR::CompoundAssignmentExpr &expr) override;
      40    void visit (HIR::LiteralExpr &expr) override;
      41    void visit (HIR::ArithmeticOrLogicalExpr &expr) override;
      42    void visit (HIR::ComparisonExpr &expr) override;
      43    void visit (HIR::LazyBooleanExpr &expr) override;
      44    void visit (HIR::NegationExpr &expr) override;
      45    void visit (HIR::IfExpr &expr) override;
      46    void visit (HIR::IfExprConseqElse &expr) override;
      47    void visit (HIR::IfExprConseqIf &expr) override;
      48    void visit (HIR::IfLetExpr &expr) override;
      49    void visit (HIR::BlockExpr &expr) override;
      50    void visit (HIR::UnsafeBlockExpr &expr) override;
      51    void visit (HIR::ArrayIndexExpr &expr) override;
      52    void visit (HIR::ArrayExpr &expr) override;
      53    void visit (HIR::StructExprStruct &struct_expr) override;
      54    void visit (HIR::StructExprStructFields &struct_expr) override;
      55    void visit (HIR::GroupedExpr &expr) override;
      56    void visit (HIR::FieldAccessExpr &expr) override;
      57    void visit (HIR::QualifiedPathInExpression &expr) override;
      58    void visit (HIR::PathInExpression &expr) override;
      59    void visit (HIR::LoopExpr &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::TypeCastExpr &expr) override;
      65    void visit (HIR::MatchExpr &expr) override;
      66    void visit (HIR::RangeFromToExpr &expr) override;
      67    void visit (HIR::RangeFromExpr &expr) override;
      68    void visit (HIR::RangeToExpr &expr) override;
      69    void visit (HIR::RangeFullExpr &expr) override;
      70    void visit (HIR::RangeFromToInclExpr &expr) override;
      71    void visit (HIR::WhileLoopExpr &expr) override;
      72    void visit (HIR::ClosureExpr &expr) override;
      73  
      74    // TODO
      75    void visit (HIR::ErrorPropagationExpr &) override {}
      76    void visit (HIR::RangeToInclExpr &) override {}
      77    void visit (HIR::WhileLetLoopExpr &) override {}
      78    void visit (HIR::ForLoopExpr &) override {}
      79    void visit (HIR::IfExprConseqIfLet &) override {}
      80    void visit (HIR::IfLetExprConseqElse &) override {}
      81    void visit (HIR::IfLetExprConseqIf &) override {}
      82    void visit (HIR::IfLetExprConseqIfLet &) override {}
      83    void visit (HIR::AwaitExpr &) override {}
      84    void visit (HIR::AsyncBlockExpr &) override {}
      85  
      86    // don't need to implement these see rust-hir-type-check-struct-field.h
      87    void visit (HIR::StructExprFieldIdentifier &) override { gcc_unreachable (); }
      88    void visit (HIR::StructExprFieldIndexValue &) override { gcc_unreachable (); }
      89    void visit (HIR::StructExprFieldIdentifierValue &) override
      90    {
      91      gcc_unreachable ();
      92    }
      93  
      94  protected:
      95    bool
      96    resolve_operator_overload (Analysis::RustLangItem::ItemType lang_item_type,
      97  			     HIR::OperatorExprMeta expr, TyTy::BaseType *lhs,
      98  			     TyTy::BaseType *rhs);
      99  
     100    bool resolve_fn_trait_call (HIR::CallExpr &expr,
     101  			      TyTy::BaseType *function_tyty,
     102  			      TyTy::BaseType **result);
     103  
     104    HIR::PathIdentSegment
     105    resolve_possible_fn_trait_call_method_name (const TyTy::BaseType &receiver);
     106  
     107  private:
     108    TypeCheckExpr ();
     109  
     110    TyTy::BaseType *resolve_root_path (HIR::PathInExpression &expr,
     111  				     size_t *offset,
     112  				     NodeId *root_resolved_node_id);
     113  
     114    void resolve_segments (NodeId root_resolved_node_id,
     115  			 std::vector<HIR::PathExprSegment> &segments,
     116  			 size_t offset, TyTy::BaseType *tyseg,
     117  			 const Analysis::NodeMapping &expr_mappings,
     118  			 Location expr_locus);
     119  
     120    bool
     121    validate_arithmetic_type (const TyTy::BaseType *tyty,
     122  			    HIR::ArithmeticOrLogicalExpr::ExprType expr_type);
     123  
     124    /* The return value of TypeCheckExpr::Resolve */
     125    TyTy::BaseType *infered;
     126  };
     127  
     128  } // namespace Resolver
     129  } // namespace Rust
     130  
     131  #endif // RUST_HIR_TYPE_CHECK_EXPR