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_TYPE
      20  #define RUST_HIR_TYPE_CHECK_TYPE
      21  
      22  #include "rust-hir-type-check-base.h"
      23  #include "rust-hir-full.h"
      24  #include "rust-substitution-mapper.h"
      25  #include "rust-hir-path-probe.h"
      26  
      27  namespace Rust {
      28  namespace Resolver {
      29  
      30  // FIXME
      31  // This simply fetches the HIR:::GenericArgs from the base class. Check to see
      32  // if we can get rid of this class
      33  class TypeCheckResolveGenericArguments : public TypeCheckBase
      34  {
      35  public:
      36    static HIR::GenericArgs resolve (HIR::TypePathSegment *segment);
      37  
      38    void visit (HIR::TypePathSegmentGeneric &generic);
      39  
      40  private:
      41    TypeCheckResolveGenericArguments (Location locus)
      42      : TypeCheckBase (), args (HIR::GenericArgs::create_empty (locus))
      43    {}
      44  
      45    HIR::GenericArgs args;
      46  };
      47  
      48  class TypeCheckType : public TypeCheckBase, public HIR::HIRTypeVisitor
      49  {
      50  public:
      51    static TyTy::BaseType *Resolve (HIR::Type *type);
      52  
      53    void visit (HIR::BareFunctionType &fntype) override;
      54    void visit (HIR::TupleType &tuple) override;
      55    void visit (HIR::TypePath &path) override;
      56    void visit (HIR::QualifiedPathInType &path) override;
      57    void visit (HIR::ArrayType &type) override;
      58    void visit (HIR::SliceType &type) override;
      59    void visit (HIR::ReferenceType &type) override;
      60    void visit (HIR::RawPointerType &type) override;
      61    void visit (HIR::InferredType &type) override;
      62    void visit (HIR::NeverType &type) override;
      63    void visit (HIR::TraitObjectType &type) override;
      64  
      65    void visit (HIR::TypePathSegmentFunction &segment) override
      66    { /* TODO */
      67    }
      68    void visit (HIR::TraitBound &bound) override
      69    { /* TODO */
      70    }
      71    void visit (HIR::ImplTraitType &type) override
      72    { /* TODO */
      73    }
      74    void visit (HIR::ParenthesisedType &type) override
      75    { /* TODO */
      76    }
      77    void visit (HIR::ImplTraitTypeOneBound &type) override
      78    { /* TODO */
      79    }
      80  
      81  private:
      82    TypeCheckType (HirId id)
      83      : TypeCheckBase (), translated (new TyTy::ErrorType (id))
      84    {}
      85  
      86    TyTy::BaseType *resolve_root_path (HIR::TypePath &path, size_t *offset,
      87  				     NodeId *root_resolved_node_id);
      88  
      89    TyTy::BaseType *resolve_segments (
      90      NodeId root_resolved_node_id, HirId expr_id,
      91      std::vector<std::unique_ptr<HIR::TypePathSegment>> &segments, size_t offset,
      92      TyTy::BaseType *tyseg, const Analysis::NodeMapping &expr_mappings,
      93      Location expr_locus);
      94  
      95    TyTy::BaseType *translated;
      96  };
      97  
      98  class TypeResolveGenericParam : public TypeCheckBase
      99  {
     100  public:
     101    static TyTy::ParamType *Resolve (HIR::GenericParam *param);
     102  
     103  protected:
     104    void visit (HIR::TypeParam &param);
     105    void visit (HIR::LifetimeParam &param);
     106    void visit (HIR::ConstGenericParam &param);
     107  
     108  private:
     109    TypeResolveGenericParam () : TypeCheckBase (), resolved (nullptr) {}
     110  
     111    TyTy::ParamType *resolved;
     112  };
     113  
     114  class ResolveWhereClauseItem : public TypeCheckBase
     115  {
     116  public:
     117    static void Resolve (HIR::WhereClauseItem &item);
     118  
     119  protected:
     120    void visit (HIR::LifetimeWhereClauseItem &item);
     121    void visit (HIR::TypeBoundWhereClauseItem &item);
     122  
     123  private:
     124    ResolveWhereClauseItem () : TypeCheckBase () {}
     125  };
     126  
     127  } // namespace Resolver
     128  } // namespace Rust
     129  
     130  #endif // RUST_HIR_TYPE_CHECK_TYPE