gcc/rust/hir/tree/rust-hir-path.cc - gcc.git - Git at Google

 // 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
	// 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