1 files changed, 420 insertions, 0 deletions
diff --git a/gcc/rust/hir/tree/rust-hir-path.cc b/gcc/rust/hir/tree/rust-hir-path.cc
new file mode 100644
index 0000000..ee4a572
--- /dev/null
+++ b/gcc/rust/hir/tree/rust-hir-path.cc
@@ -0,0 +1,420 @@
+// Copyright (C) 2020-2024 Free Software Foundation, Inc.
+
+// This file is part of GCC.
+
+// GCC is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 3, or (at your option) any later
+// version.
+
+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GCC; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include "rust-hir-path.h"
+#include "optional.h"
+#include "rust-hir-bound.h"
+
+namespace Rust {
+namespace HIR {
+
+GenericArgsBinding::GenericArgsBinding (Identifier ident,
+					std::unique_ptr<Type> type_ptr,
+					location_t locus)
+  : identifier (std::move (ident)), type (std::move (type_ptr)), locus (locus)
+{}
+
+GenericArgsBinding::GenericArgsBinding (GenericArgsBinding const &other)
+  : identifier (other.identifier), type (other.type->clone_type ()),
+    locus (other.locus)
+{}
+
+GenericArgsBinding &
+GenericArgsBinding::operator= (GenericArgsBinding const &other)
+{
+  identifier = other.identifier;
+  type = other.type->clone_type ();
+  locus = other.locus;
+  return *this;
+}
+
+ConstGenericArg::ConstGenericArg (std::unique_ptr<Expr> expression,
+				  location_t locus)
+  : expression (std::move (expression)), locus (locus)
+{}
+
+ConstGenericArg::ConstGenericArg (const ConstGenericArg &other)
+  : locus (other.locus)
+{
+  expression = other.expression->clone_expr ();
+}
+
+ConstGenericArg
+ConstGenericArg::operator= (const ConstGenericArg &other)
+{
+  expression = other.expression->clone_expr ();
+  locus = other.locus;
+
+  return *this;
+}
+
+GenericArgs &
+GenericArgs::operator= (GenericArgs const &other)
+{
+  lifetime_args = other.lifetime_args;
+  binding_args = other.binding_args;
+  const_args = other.const_args;
+  locus = other.locus;
+
+  type_args.clear ();
+  type_args.reserve (other.type_args.size ());
+  for (const auto &e : other.type_args)
+    type_args.push_back (e->clone_type ());
+
+  return *this;
+}
+
+GenericArgs::GenericArgs (std::vector<Lifetime> lifetime_args,
+			  std::vector<std::unique_ptr<Type> > type_args,
+			  std::vector<GenericArgsBinding> binding_args,
+			  std::vector<ConstGenericArg> const_args,
+			  location_t locus)
+  : lifetime_args (std::move (lifetime_args)),
+    type_args (std::move (type_args)), binding_args (std::move (binding_args)),
+    const_args (std::move (const_args)), locus (locus)
+{}
+
+GenericArgs::GenericArgs (GenericArgs const &other)
+  : lifetime_args (other.lifetime_args), binding_args (other.binding_args),
+    const_args (other.const_args), locus (other.locus)
+{
+  type_args.clear ();
+  type_args.reserve (other.type_args.size ());
+
+  for (const auto &e : other.type_args)
+    type_args.push_back (e->clone_type ());
+}
+
+bool
+GenericArgs::is_empty () const
+{
+  return lifetime_args.size () == 0 && type_args.size () == 0
+	 && binding_args.size () == 0;
+}
+
+PathExprSegment::PathExprSegment (Analysis::NodeMapping mappings,
+				  PathIdentSegment segment_name,
+				  location_t locus, GenericArgs generic_args)
+  : mappings (std::move (mappings)), segment_name (std::move (segment_name)),
+    generic_args (std::move (generic_args)), locus (locus)
+{}
+
+PathExprSegment::PathExprSegment (PathExprSegment const &other)
+  : mappings (other.mappings), segment_name (other.segment_name),
+    generic_args (other.generic_args), locus (other.locus)
+{}
+
+PathExprSegment &
+PathExprSegment::operator= (PathExprSegment const &other)
+{
+  mappings = other.mappings;
+  segment_name = other.segment_name;
+  generic_args = other.generic_args;
+  locus = other.locus;
+
+  return *this;
+}
+
+void
+PathPattern::iterate_path_segments (std::function<bool (PathExprSegment &)> cb)
+{
+  rust_assert (kind == Kind::Segmented);
+
+  for (auto it = segments.begin (); it != segments.end (); it++)
+    {
+      if (!cb (*it))
+	return;
+    }
+}
+
+PathInExpression::PathInExpression (Analysis::NodeMapping mappings,
+				    std::vector<PathExprSegment> path_segments,
+				    location_t locus,
+				    bool has_opening_scope_resolution,
+				    std::vector<AST::Attribute> outer_attrs)
+  : PathPattern (std::move (path_segments)),
+    PathExpr (std::move (mappings), std::move (outer_attrs)),
+    has_opening_scope_resolution (has_opening_scope_resolution), locus (locus)
+{}
+
+PathInExpression::PathInExpression (Analysis::NodeMapping mappings,
+				    LangItem::Kind lang_item, location_t locus,
+				    bool has_opening_scope_resolution,
+				    std::vector<AST::Attribute> outer_attrs)
+  : PathPattern (lang_item),
+    PathExpr (std::move (mappings), std::move (outer_attrs)),
+    has_opening_scope_resolution (has_opening_scope_resolution), locus (locus)
+{}
+
+bool
+PathInExpression::is_self () const
+
+{
+  if (!is_single_segment ())
+    return false;
+
+  return get_final_segment ().get_segment ().as_string ().compare ("self") == 0;
+}
+
+TypePathSegment::TypePathSegment (Analysis::NodeMapping mappings,
+				  PathIdentSegment ident_segment,
+				  bool has_separating_scope_resolution,
+				  location_t locus)
+  : mappings (std::move (mappings)), ident_segment (std::move (ident_segment)),
+    lang_item (tl::nullopt), locus (locus),
+    has_separating_scope_resolution (has_separating_scope_resolution),
+    type (SegmentType::REG)
+{}
+
+TypePathSegment::TypePathSegment (Analysis::NodeMapping mappings,
+				  LangItem::Kind lang_item, location_t locus)
+  : mappings (std::move (mappings)), ident_segment (tl::nullopt),
+    lang_item (lang_item), locus (locus),
+    has_separating_scope_resolution (false), type (SegmentType::REG)
+{}
+
+TypePathSegment::TypePathSegment (Analysis::NodeMapping mappings,
+				  std::string segment_name,
+				  bool has_separating_scope_resolution,
+				  location_t locus)
+  : mappings (std::move (mappings)),
+    ident_segment (PathIdentSegment (std::move (segment_name))),
+    lang_item (tl::nullopt), locus (locus),
+    has_separating_scope_resolution (has_separating_scope_resolution),
+    type (SegmentType::REG)
+{}
+
+TypePathSegmentGeneric::TypePathSegmentGeneric (
+  Analysis::NodeMapping mappings, PathIdentSegment ident_segment,
+  bool has_separating_scope_resolution, GenericArgs generic_args,
+  location_t locus)
+  : TypePathSegment (std::move (mappings), std::move (ident_segment),
+		     has_separating_scope_resolution, locus),
+    generic_args (std::move (generic_args))
+{}
+
+TypePathSegmentGeneric::TypePathSegmentGeneric (Analysis::NodeMapping mappings,
+						LangItem::Kind lang_item,
+						GenericArgs generic_args,
+						location_t locus)
+  : TypePathSegment (std::move (mappings), lang_item, locus),
+    generic_args (std::move (generic_args))
+{}
+
+TypePathSegmentGeneric::TypePathSegmentGeneric (
+  Analysis::NodeMapping mappings, std::string segment_name,
+  bool has_separating_scope_resolution, std::vector<Lifetime> lifetime_args,
+  std::vector<std::unique_ptr<Type> > type_args,
+  std::vector<GenericArgsBinding> binding_args,
+  std::vector<ConstGenericArg> const_args, location_t locus)
+  : TypePathSegment (std::move (mappings), std::move (segment_name),
+		     has_separating_scope_resolution, locus),
+    generic_args (GenericArgs (std::move (lifetime_args), std::move (type_args),
+			       std::move (binding_args), std::move (const_args),
+			       locus))
+{}
+
+TypePathFunction::TypePathFunction (std::vector<std::unique_ptr<Type> > inputs,
+				    std::unique_ptr<Type> type)
+  : inputs (std::move (inputs)), return_type (std::move (type))
+{}
+
+TypePathFunction::TypePathFunction (TypePathFunction const &other)
+{
+  return_type = other.has_return_type ()
+		  ? other.get_return_type ().clone_type ()
+		  : nullptr;
+
+  inputs.reserve (other.inputs.size ());
+  for (const auto &e : other.inputs)
+    inputs.push_back (e->clone_type ());
+}
+
+TypePathFunction &
+TypePathFunction::operator= (TypePathFunction const &other)
+{
+  return_type = other.has_return_type ()
+		  ? other.get_return_type ().clone_type ()
+		  : nullptr;
+
+  inputs.reserve (other.inputs.size ());
+  for (const auto &e : other.inputs)
+    inputs.push_back (e->clone_type ());
+
+  return *this;
+}
+
+TypePathSegmentFunction::TypePathSegmentFunction (
+  Analysis::NodeMapping mappings, PathIdentSegment ident_segment,
+  bool has_separating_scope_resolution, TypePathFunction function_path,
+  location_t locus)
+  : TypePathSegment (std::move (mappings), std::move (ident_segment),
+		     has_separating_scope_resolution, locus),
+    function_path (std::move (function_path))
+{}
+
+TypePathSegmentFunction::TypePathSegmentFunction (
+  Analysis::NodeMapping mappings, std::string segment_name,
+  bool has_separating_scope_resolution, TypePathFunction function_path,
+  location_t locus)
+  : TypePathSegment (std::move (mappings), std::move (segment_name),
+		     has_separating_scope_resolution, locus),
+    function_path (std::move (function_path))
+{}
+
+TypePath::TypePath (Analysis::NodeMapping mappings,
+		    std::vector<std::unique_ptr<TypePathSegment> > segments,
+		    location_t locus, bool has_opening_scope_resolution)
+  : TypeNoBounds (mappings, locus),
+    has_opening_scope_resolution (has_opening_scope_resolution),
+    segments (std::move (segments))
+{}
+
+TypePath::TypePath (TypePath const &other)
+  : TypeNoBounds (other.mappings, other.locus),
+    has_opening_scope_resolution (other.has_opening_scope_resolution)
+{
+  segments.reserve (other.segments.size ());
+  for (const auto &e : other.segments)
+    segments.push_back (e->clone_type_path_segment ());
+}
+
+TypePath &
+TypePath::operator= (TypePath const &other)
+{
+  has_opening_scope_resolution = other.has_opening_scope_resolution;
+  locus = other.locus;
+  mappings = other.mappings;
+
+  segments.reserve (other.segments.size ());
+  for (const auto &e : other.segments)
+    segments.push_back (e->clone_type_path_segment ());
+
+  return *this;
+}
+
+QualifiedPathType::QualifiedPathType (Analysis::NodeMapping mappings,
+				      std::unique_ptr<Type> type,
+				      std::unique_ptr<TypePath> trait,
+				      location_t locus)
+  : type (std::move (type)), trait (std::move (trait)), locus (locus),
+    mappings (mappings)
+{}
+
+QualifiedPathType::QualifiedPathType (QualifiedPathType const &other)
+  : type (other.type->clone_type ()),
+    trait (other.has_as_clause ()
+	     ? std::unique_ptr<HIR::TypePath> (new HIR::TypePath (*other.trait))
+	     : nullptr),
+    locus (other.locus), mappings (other.mappings)
+{}
+
+QualifiedPathType &
+QualifiedPathType::operator= (QualifiedPathType const &other)
+{
+  type = other.type->clone_type ();
+  locus = other.locus;
+  mappings = other.mappings;
+  trait = other.has_as_clause ()
+	    ? std::unique_ptr<HIR::TypePath> (new HIR::TypePath (*other.trait))
+	    : nullptr;
+
+  return *this;
+}
+
+bool
+QualifiedPathType::trait_has_generic_args () const
+{
+  rust_assert (has_as_clause ());
+  bool is_generic_seg = trait->get_final_segment ().get_type ()
+			== TypePathSegment::SegmentType::GENERIC;
+  if (!is_generic_seg)
+    return false;
+
+  auto &seg
+    = static_cast<TypePathSegmentGeneric &> (trait->get_final_segment ());
+  return seg.has_generic_args ();
+}
+
+GenericArgs &
+QualifiedPathType::get_trait_generic_args ()
+{
+  rust_assert (trait_has_generic_args ());
+  auto &seg
+    = static_cast<TypePathSegmentGeneric &> (trait->get_final_segment ());
+  return seg.get_generic_args ();
+}
+
+QualifiedPathInExpression::QualifiedPathInExpression (
+  Analysis::NodeMapping mappings, QualifiedPathType qual_path_type,
+  std::vector<PathExprSegment> path_segments, location_t locus,
+  std::vector<AST::Attribute> outer_attrs)
+  : PathPattern (std::move (path_segments)),
+    PathExpr (std::move (mappings), std::move (outer_attrs)),
+    path_type (std::move (qual_path_type)), locus (locus)
+{}
+
+QualifiedPathInExpression::QualifiedPathInExpression (
+  Analysis::NodeMapping mappings, QualifiedPathType qual_path_type,
+  LangItem::Kind lang_item, location_t locus,
+  std::vector<AST::Attribute> outer_attrs)
+  : PathPattern (lang_item),
+    PathExpr (std::move (mappings), std::move (outer_attrs)),
+    path_type (std::move (qual_path_type)), locus (locus)
+{}
+
+QualifiedPathInType::QualifiedPathInType (
+  Analysis::NodeMapping mappings, QualifiedPathType qual_path_type,
+  std::unique_ptr<TypePathSegment> associated_segment,
+  std::vector<std::unique_ptr<TypePathSegment> > path_segments,
+  location_t locus)
+  : TypeNoBounds (mappings, locus), path_type (std::move (qual_path_type)),
+    associated_segment (std::move (associated_segment)),
+    segments (std::move (path_segments))
+{}
+
+QualifiedPathInType::QualifiedPathInType (QualifiedPathInType const &other)
+  : TypeNoBounds (other.mappings, other.locus), path_type (other.path_type)
+{
+  auto seg = other.associated_segment->clone_type_path_segment_impl ();
+  associated_segment = std::unique_ptr<TypePathSegment> (seg);
+
+  segments.reserve (other.segments.size ());
+  for (const auto &e : other.segments)
+    segments.push_back (e->clone_type_path_segment ());
+}
+
+QualifiedPathInType &
+QualifiedPathInType::operator= (QualifiedPathInType const &other)
+{
+  auto seg = other.associated_segment->clone_type_path_segment_impl ();
+  associated_segment = std::unique_ptr<TypePathSegment> (seg);
+
+  path_type = other.path_type;
+  locus = other.locus;
+  mappings = other.mappings;
+
+  segments.reserve (other.segments.size ());
+  for (const auto &e : other.segments)
+    segments.push_back (e->clone_type_path_segment ());
+
+  return *this;
+}
+
+} // namespace HIR
+} // namespace Rust