Support TypeBounds on Generic functions

TypeBounds are what make generics useful in Rust. They act in some ways
similar to interfaces in modern Java.

Fixes #583

20 files changed, 845 insertions, 128 deletions

diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in
index 794c7a3..f4bc9ea 100644
--- a/gcc/rust/Make-lang.in
+++ b/gcc/rust/Make-lang.in
@@ -79,6 +79,7 @@ GRS_OBJS = \
     rust/rust-hir-type-check.o \
     rust/rust-tyty.o \
     rust/rust-tyctx.o \
+    rust/rust-tyty-bounds.o \
     rust/rust-hir-const-fold.o \
     rust/rust-lint-marklive.o \
     $(END)
diff --git a/gcc/rust/backend/rust-compile-resolve-path.cc b/gcc/rust/backend/rust-compile-resolve-path.cc
index af8d609..c87b477 100644
--- a/gcc/rust/backend/rust-compile-resolve-path.cc
+++ b/gcc/rust/backend/rust-compile-resolve-path.cc
@@ -20,6 +20,8 @@
 #include "rust-backend.h"
 #include "rust-compile-resolve-path.h"
 #include "rust-compile-item.h"
+#include "rust-hir-trait-resolve.h"
+#include "rust-hir-path-probe.h"
 
 namespace Rust {
 namespace Compile {
@@ -94,7 +96,76 @@ ResolvePathRef::visit (HIR::PathInExpression &expr)
 	  HIR::ImplItem *resolved_item
 	    = ctx->get_mappings ()->lookup_hir_implitem (
 	      expr.get_mappings ().get_crate_num (), ref, &parent_impl_id);
-	  if (resolved_item != nullptr)
+
+	  if (resolved_item == nullptr)
+	    {
+	      // it might be resolved to a trait item
+	      HIR::TraitItem *trait_item
+		= ctx->get_mappings ()->lookup_hir_trait_item (
+		  expr.get_mappings ().get_crate_num (), ref);
+	      HIR::Trait *trait
+		= ctx->get_mappings ()->lookup_trait_item_mapping (
+		  trait_item->get_mappings ().get_hirid ());
+
+	      Resolver::TraitReference &trait_ref
+		= Resolver::TraitResolver::error_node ();
+	      bool ok = ctx->get_tyctx ()->lookup_trait_reference (
+		trait->get_mappings ().get_defid (), trait_ref);
+	      rust_assert (ok);
+
+	      TyTy::BaseType *receiver = nullptr;
+	      ok = ctx->get_tyctx ()->lookup_receiver (
+		expr.get_mappings ().get_hirid (), &receiver);
+	      rust_assert (ok);
+
+	      if (receiver->get_kind () == TyTy::TypeKind::PARAM)
+		{
+		  TyTy::ParamType *p
+		    = static_cast<TyTy::ParamType *> (receiver);
+		  receiver = p->resolve ();
+		}
+
+	      // the type resolver can only resolve type bounds to their trait
+	      // item so its up to us to figure out if this path should resolve
+	      // to an trait-impl-block-item or if it can be defaulted to the
+	      // trait-impl-item's definition
+	      std::vector<Resolver::PathProbeCandidate> candidates
+		= Resolver::PathProbeType::Probe (
+		  receiver, expr.get_final_segment ().get_segment (), true,
+		  false, true);
+
+	      if (candidates.size () == 0)
+		{
+		  // this means we are defaulting back to the trait_item if
+		  // possible
+		  // TODO
+		  gcc_unreachable ();
+		}
+	      else
+		{
+		  Resolver::PathProbeCandidate &candidate = candidates.at (0);
+		  rust_assert (candidate.is_impl_candidate ());
+
+		  HIR::ImplBlock *impl = candidate.item.impl.parent;
+		  HIR::ImplItem *impl_item = candidate.item.impl.impl_item;
+
+		  TyTy::BaseType *self = nullptr;
+		  bool ok = ctx->get_tyctx ()->lookup_type (
+		    impl->get_type ()->get_mappings ().get_hirid (), &self);
+		  rust_assert (ok);
+
+		  if (!lookup->has_subsititions_defined ())
+		    CompileInherentImplItem::Compile (self, impl_item, ctx,
+						      true);
+		  else
+		    CompileInherentImplItem::Compile (self, impl_item, ctx,
+						      true, lookup);
+
+		  lookup->set_ty_ref (
+		    impl_item->get_impl_mappings ().get_hirid ());
+		}
+	    }
+	  else
 	    {
 	      rust_assert (parent_impl_id != UNKNOWN_HIRID);
 	      HIR::Item *impl_ref = ctx->get_mappings ()->lookup_hir_item (
@@ -114,18 +185,13 @@ ResolvePathRef::visit (HIR::PathInExpression &expr)
 		CompileInherentImplItem::Compile (self, resolved_item, ctx,
 						  true, lookup);
 	    }
-	  else
-	    {
-	      rust_error_at (expr.get_locus (),
-			     "failed to lookup definition declaration");
-	      return;
-	    }
 	}
 
       if (!ctx->lookup_function_decl (lookup->get_ty_ref (), &fn))
 	{
-	  rust_fatal_error (expr.get_locus (),
-			    "forward declaration was not compiled");
+	  resolved = ctx->get_backend ()->error_expression ();
+	  rust_error_at (expr.get_locus (),
+			 "forward declaration was not compiled");
 	  return;
 	}
     }
diff --git a/gcc/rust/backend/rust-compile.cc b/gcc/rust/backend/rust-compile.cc
index aa9aa2d..f422572 100644
--- a/gcc/rust/backend/rust-compile.cc
+++ b/gcc/rust/backend/rust-compile.cc
@@ -20,6 +20,8 @@
 #include "rust-compile-item.h"
 #include "rust-compile-expr.h"
 #include "rust-compile-struct-field-expr.h"
+#include "rust-hir-trait-resolve.h"
+#include "rust-hir-path-probe.h"
 #include "fnv-hash.h"
 
 namespace Rust {
@@ -141,31 +143,105 @@ CompileExpr::visit (HIR::MethodCallExpr &expr)
 	expr.get_mappings ().get_crate_num (), ref, nullptr);
       if (resolved_item == nullptr)
 	{
-	  rust_error_at (expr.get_locus (),
-			 "failed to lookup forward declaration");
-	  return;
-	}
+	  // it might be resolved to a trait item
+	  HIR::TraitItem *trait_item
+	    = ctx->get_mappings ()->lookup_hir_trait_item (
+	      expr.get_mappings ().get_crate_num (), ref);
+	  HIR::Trait *trait = ctx->get_mappings ()->lookup_trait_item_mapping (
+	    trait_item->get_mappings ().get_hirid ());
+
+	  Resolver::TraitReference &trait_ref
+	    = Resolver::TraitResolver::error_node ();
+	  bool ok = ctx->get_tyctx ()->lookup_trait_reference (
+	    trait->get_mappings ().get_defid (), trait_ref);
+	  rust_assert (ok);
+
+	  TyTy::BaseType *receiver = nullptr;
+	  ok = ctx->get_tyctx ()->lookup_receiver (
+	    expr.get_mappings ().get_hirid (), &receiver);
+	  rust_assert (ok);
+
+	  if (receiver->get_kind () == TyTy::TypeKind::PARAM)
+	    {
+	      TyTy::ParamType *p = static_cast<TyTy::ParamType *> (receiver);
+	      receiver = p->resolve ();
+	    }
 
-      TyTy::BaseType *self_type = nullptr;
-      if (!ctx->get_tyctx ()->lookup_type (
-	    expr.get_receiver ()->get_mappings ().get_hirid (), &self_type))
-	{
-	  rust_error_at (expr.get_locus (),
-			 "failed to resolve type for self param");
-	  return;
-	}
+	  // the type resolver can only resolve type bounds to their trait
+	  // item so its up to us to figure out if this path should resolve
+	  // to an trait-impl-block-item or if it can be defaulted to the
+	  // trait-impl-item's definition
+	  std::vector<Resolver::PathProbeCandidate> candidates
+	    = Resolver::PathProbeType::Probe (
+	      receiver, expr.get_method_name ().get_segment (), true, false,
+	      true);
 
-      if (!fntype->has_subsititions_defined ())
-	CompileInherentImplItem::Compile (self_type, resolved_item, ctx, true);
+	  if (candidates.size () == 0)
+	    {
+	      // this means we are defaulting back to the trait_item if
+	      // possible
+	      // TODO
+	      gcc_unreachable ();
+	    }
+	  else
+	    {
+	      Resolver::PathProbeCandidate &candidate = candidates.at (0);
+	      rust_assert (candidate.is_impl_candidate ());
+
+	      HIR::ImplItem *impl_item = candidate.item.impl.impl_item;
+
+	      TyTy::BaseType *self_type = nullptr;
+	      if (!ctx->get_tyctx ()->lookup_type (
+		    expr.get_receiver ()->get_mappings ().get_hirid (),
+		    &self_type))
+		{
+		  rust_error_at (expr.get_locus (),
+				 "failed to resolve type for self param");
+		  return;
+		}
+
+	      if (!fntype->has_subsititions_defined ())
+		CompileInherentImplItem::Compile (self_type, impl_item, ctx,
+						  true);
+	      else
+		CompileInherentImplItem::Compile (self_type, impl_item, ctx,
+						  true, fntype);
+
+	      if (!ctx->lookup_function_decl (
+		    impl_item->get_impl_mappings ().get_hirid (), &fn))
+		{
+		  translated = ctx->get_backend ()->error_expression ();
+		  rust_error_at (expr.get_locus (),
+				 "forward declaration was not compiled");
+		  return;
+		}
+	    }
+	}
       else
-	CompileInherentImplItem::Compile (self_type, resolved_item, ctx, true,
-					  fntype);
-
-      if (!ctx->lookup_function_decl (fntype->get_ty_ref (), &fn))
 	{
-	  rust_error_at (expr.get_locus (),
-			 "forward declaration was not compiled");
-	  return;
+	  TyTy::BaseType *self_type = nullptr;
+	  if (!ctx->get_tyctx ()->lookup_type (
+		expr.get_receiver ()->get_mappings ().get_hirid (), &self_type))
+	    {
+	      rust_error_at (expr.get_locus (),
+			     "failed to resolve type for self param");
+	      return;
+	    }
+
+	  if (!fntype->has_subsititions_defined ())
+	    CompileInherentImplItem::Compile (self_type, resolved_item, ctx,
+					      true);
+	  else
+	    CompileInherentImplItem::Compile (self_type, resolved_item, ctx,
+					      true, fntype);
+
+	  if (!ctx->lookup_function_decl (fntype->get_ty_ref (), &fn))
+	    {
+	      translated = ctx->get_backend ()->error_expression ();
+	      rust_error_at (expr.get_locus (),
+			     "forward declaration was not compiled");
+	      return;
+	    }
 	}
     }
 
diff --git a/gcc/rust/hir/tree/rust-hir-item.h b/gcc/rust/hir/tree/rust-hir-item.h
index 3ad06c8..ba04339 100644
--- a/gcc/rust/hir/tree/rust-hir-item.h
+++ b/gcc/rust/hir/tree/rust-hir-item.h
@@ -124,6 +124,11 @@ public:
     return type->get_mappings ();
   }
 
+  std::vector<std::unique_ptr<TypeParamBound> > &get_type_param_bounds ()
+  {
+    return type_param_bounds;
+  }
+
 protected:
   // Clone function implementation as (not pure) virtual method
   TypeParam *clone_generic_param_impl () const override
diff --git a/gcc/rust/hir/tree/rust-hir-type.h b/gcc/rust/hir/tree/rust-hir-type.h
index 87dffcf..8d75d02 100644
--- a/gcc/rust/hir/tree/rust-hir-type.h
+++ b/gcc/rust/hir/tree/rust-hir-type.h
@@ -67,6 +67,10 @@ public:
 
   BoundType get_bound_type () const final override { return TRAITBOUND; }
 
+  TypePath &get_path () { return type_path; }
+
+  const TypePath &get_path () const { return type_path; }
+
 protected:
   /* Use covariance to implement clone function as returning this object rather
    * than base */
diff --git a/gcc/rust/typecheck/rust-hir-path-probe.h b/gcc/rust/typecheck/rust-hir-path-probe.h
index 1b7aa4d..8e3ca31 100644
--- a/gcc/rust/typecheck/rust-hir-path-probe.h
+++ b/gcc/rust/typecheck/rust-hir-path-probe.h
@@ -23,6 +23,7 @@
 #include "rust-hir-full.h"
 #include "rust-tyty.h"
 #include "rust-substitution-mapper.h"
+#include "rust-hir-type-bounds.h"
 
 namespace Rust {
 namespace Resolver {
@@ -34,12 +35,80 @@ struct PathProbeCandidate
     IMPL_CONST,
     IMPL_TYPE_ALIAS,
     IMPL_FUNC,
+
+    TRAIT_ITEM_CONST,
+    TRAIT_TYPE_ALIAS,
+    TRAIT_FUNC,
+  };
+
+  struct ImplItemCandidate
+  {
+    HIR::ImplItem *impl_item;
+    HIR::ImplBlock *parent;
+  };
+
+  struct TraitItemCandidate
+  {
+    const TraitReference &trait_ref;
+    const TraitItemReference &item_ref;
   };
 
   CandidateType type;
-  HIR::ImplItem *impl_item;
   TyTy::BaseType *ty;
-  HIR::ImplBlock *parent;
+  Location locus;
+  union Candidate
+  {
+    ImplItemCandidate impl;
+    TraitItemCandidate trait;
+
+    Candidate (ImplItemCandidate impl) : impl (impl) {}
+    Candidate (TraitItemCandidate trait) : trait (trait) {}
+  } item;
+
+  PathProbeCandidate (CandidateType type, TyTy::BaseType *ty, Location locus,
+		      ImplItemCandidate impl)
+    : type (type), ty (ty), item (impl)
+  {}
+
+  PathProbeCandidate (CandidateType type, TyTy::BaseType *ty, Location locus,
+		      TraitItemCandidate trait)
+    : type (type), ty (ty), item (trait)
+  {}
+
+  std::string as_string () const
+  {
+    return "PathProbe candidate TODO - as_string";
+  }
+
+  bool is_impl_candidate () const
+  {
+    switch (type)
+      {
+      case IMPL_CONST:
+      case IMPL_TYPE_ALIAS:
+      case IMPL_FUNC:
+	return true;
+
+      default:
+	return false;
+      }
+    gcc_unreachable ();
+  }
+
+  bool is_trait_candidate () const
+  {
+    switch (type)
+      {
+      case TRAIT_ITEM_CONST:
+      case TRAIT_TYPE_ALIAS:
+      case TRAIT_FUNC:
+	return true;
+
+      default:
+	return false;
+      }
+    gcc_unreachable ();
+  }
 };
 
 class PathProbeType : public TypeCheckBase
@@ -48,32 +117,33 @@ class PathProbeType : public TypeCheckBase
 
 public:
   static std::vector<PathProbeCandidate>
-  Probe (TyTy::BaseType *receiver, const HIR::PathIdentSegment &segment_name)
+  Probe (const TyTy::BaseType *receiver,
+	 const HIR::PathIdentSegment &segment_name, bool probe_impls,
+	 bool probe_bounds, bool ignore_mandatory_trait_items)
   {
     PathProbeType probe (receiver, segment_name);
-    probe.mappings->iterate_impl_items (
-      [&] (HirId id, HIR::ImplItem *item,
-	   HIR::ImplBlock *impl) mutable -> bool {
-	probe.process_candidate (id, item, impl);
-	return true;
-      });
+    if (probe_impls)
+      probe.process_impl_items_for_candidates ();
 
-    return probe.candidates;
-  }
+    if (!probe_bounds)
+      return probe.candidates;
 
-  void process_candidate (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl)
-  {
-    current_impl = impl;
-    HirId impl_ty_id = impl->get_type ()->get_mappings ().get_hirid ();
-    TyTy::BaseType *impl_block_ty = nullptr;
-    bool ok = context->lookup_type (impl_ty_id, &impl_block_ty);
-    rust_assert (ok);
+    std::vector<std::reference_wrapper<TraitReference>> probed_bounds
+      = TypeBoundsProbe::Probe (receiver);
 
-    if (!receiver->can_eq (impl_block_ty, false))
-      return;
+    std::vector<std::reference_wrapper<const TraitReference>> specified_bounds;
+    for (const TyTy::TypeBoundPredicate &predicate :
+	 receiver->get_specified_bounds ())
+      {
+	const TraitReference *trait_item = predicate.get ();
+	specified_bounds.push_back (*trait_item);
+      }
 
-    // lets visit the impl_item
-    item->accept_vis (*this);
+    std::vector<std::reference_wrapper<const TraitReference>> union_type_bounds
+      = probe.union_bounds (probed_bounds, specified_bounds);
+    probe.process_traits_for_candidates (union_type_bounds,
+					 ignore_mandatory_trait_items);
+    return probe.candidates;
   }
 
   void visit (HIR::TypeAlias &alias) override
@@ -86,9 +156,11 @@ public:
 	bool ok = context->lookup_type (tyid, &ty);
 	rust_assert (ok);
 
+	PathProbeCandidate::ImplItemCandidate impl_item_candidate{&alias,
+								  current_impl};
 	PathProbeCandidate candidate{
-	  PathProbeCandidate::CandidateType::IMPL_TYPE_ALIAS, &alias, ty,
-	  current_impl};
+	  PathProbeCandidate::CandidateType::IMPL_TYPE_ALIAS, ty,
+	  alias.get_locus (), impl_item_candidate};
 	candidates.push_back (std::move (candidate));
       }
   }
@@ -103,9 +175,11 @@ public:
 	bool ok = context->lookup_type (tyid, &ty);
 	rust_assert (ok);
 
+	PathProbeCandidate::ImplItemCandidate impl_item_candidate{&constant,
+								  current_impl};
 	PathProbeCandidate candidate{
-	  PathProbeCandidate::CandidateType::IMPL_CONST, &constant, ty,
-	  current_impl};
+	  PathProbeCandidate::CandidateType::IMPL_CONST, ty,
+	  constant.get_locus (), impl_item_candidate};
 	candidates.push_back (std::move (candidate));
       }
   }
@@ -120,20 +194,146 @@ public:
 	bool ok = context->lookup_type (tyid, &ty);
 	rust_assert (ok);
 
+	PathProbeCandidate::ImplItemCandidate impl_item_candidate{&function,
+								  current_impl};
 	PathProbeCandidate candidate{
-	  PathProbeCandidate::CandidateType::IMPL_FUNC, &function, ty,
-	  current_impl};
+	  PathProbeCandidate::CandidateType::IMPL_FUNC, ty,
+	  function.get_locus (), impl_item_candidate};
 	candidates.push_back (std::move (candidate));
       }
   }
 
 private:
-  PathProbeType (TyTy::BaseType *receiver, const HIR::PathIdentSegment &query)
+  void process_impl_items_for_candidates ()
+  {
+    mappings->iterate_impl_items ([&] (HirId id, HIR::ImplItem *item,
+				       HIR::ImplBlock *impl) mutable -> bool {
+      process_impl_item_candidate (id, item, impl);
+      return true;
+    });
+  }
+
+  void process_impl_item_candidate (HirId id, HIR::ImplItem *item,
+				    HIR::ImplBlock *impl)
+  {
+    current_impl = impl;
+    HirId impl_ty_id = impl->get_type ()->get_mappings ().get_hirid ();
+    TyTy::BaseType *impl_block_ty = nullptr;
+    bool ok = context->lookup_type (impl_ty_id, &impl_block_ty);
+    rust_assert (ok);
+
+    if (!receiver->can_eq (impl_block_ty, false))
+      return;
+
+    // lets visit the impl_item
+    item->accept_vis (*this);
+  }
+
+  void process_traits_for_candidates (
+    const std::vector<std::reference_wrapper<const TraitReference>> traits,
+    bool ignore_mandatory_trait_items)
+  {
+    for (const TraitReference &trait_ref : traits)
+      {
+	const TraitItemReference &trait_item_ref
+	  = trait_ref.lookup_trait_item (search.as_string ());
+	if (trait_item_ref.is_error ())
+	  continue;
+
+	bool trait_item_needs_implementation = !trait_item_ref.is_optional ();
+	if (ignore_mandatory_trait_items && trait_item_needs_implementation)
+	  continue;
+
+	PathProbeCandidate::CandidateType candidate_type;
+	switch (trait_item_ref.get_trait_item_type ())
+	  {
+	  case TraitItemReference::TraitItemType::FN:
+	    candidate_type = PathProbeCandidate::CandidateType::TRAIT_FUNC;
+	    break;
+	  case TraitItemReference::TraitItemType::CONST:
+	    candidate_type
+	      = PathProbeCandidate::CandidateType::TRAIT_ITEM_CONST;
+	    break;
+	  case TraitItemReference::TraitItemType::TYPE:
+	    candidate_type
+	      = PathProbeCandidate::CandidateType::TRAIT_TYPE_ALIAS;
+	    break;
+
+	  case TraitItemReference::TraitItemType::ERROR:
+	    gcc_unreachable ();
+	    break;
+	  }
+
+	TyTy::BaseType *trait_item_tyty = trait_item_ref.get_tyty ();
+
+	// we can substitute the Self with the receiver here
+	if (trait_item_tyty->get_kind () == TyTy::TypeKind::FNDEF)
+	  {
+	    TyTy::FnType *fn = static_cast<TyTy::FnType *> (trait_item_tyty);
+	    TyTy::SubstitutionParamMapping *param = nullptr;
+	    for (auto &param_mapping : fn->get_substs ())
+	      {
+		const HIR::TypeParam &type_param
+		  = param_mapping.get_generic_param ();
+		if (type_param.get_type_representation ().compare ("Self") == 0)
+		  {
+		    param = &param_mapping;
+		    break;
+		  }
+	      }
+	    rust_assert (param != nullptr);
+
+	    std::vector<TyTy::SubstitutionArg> mappings;
+	    mappings.push_back (
+	      TyTy::SubstitutionArg (param, receiver->clone ()));
+
+	    Location locus; // FIXME
+	    TyTy::SubstitutionArgumentMappings args (std::move (mappings),
+						     locus);
+	    trait_item_tyty
+	      = SubstMapperInternal::Resolve (trait_item_tyty, args);
+	  }
+
+	PathProbeCandidate::TraitItemCandidate trait_item_candidate{
+	  trait_ref, trait_item_ref};
+	PathProbeCandidate candidate{candidate_type,
+				     trait_item_tyty,
+				     trait_ref.get_locus (),
+				     {trait_item_candidate}};
+	candidates.push_back (std::move (candidate));
+      }
+  }
+
+private:
+  PathProbeType (const TyTy::BaseType *receiver,
+		 const HIR::PathIdentSegment &query)
     : TypeCheckBase (), receiver (receiver), search (query),
       current_impl (nullptr)
   {}
 
-  TyTy::BaseType *receiver;
+  std::vector<std::reference_wrapper<const TraitReference>> union_bounds (
+    const std::vector<std::reference_wrapper</*const*/ TraitReference>> a,
+    const std::vector<std::reference_wrapper<const TraitReference>> b) const
+  {
+    std::map<DefId, std::reference_wrapper<const TraitReference>> mapper;
+    for (const TraitReference &ref : a)
+      {
+	mapper.insert ({ref.get_mappings ().get_defid (), ref});
+      }
+    for (const TraitReference &ref : b)
+      {
+	mapper.insert ({ref.get_mappings ().get_defid (), ref});
+      }
+
+    std::vector<std::reference_wrapper<const TraitReference>> union_set;
+    for (auto it = mapper.begin (); it != mapper.end (); it++)
+      {
+	union_set.push_back (it->second);
+      }
+    return union_set;
+  }
+
+  const TyTy::BaseType *receiver;
   const HIR::PathIdentSegment &search;
   std::vector<PathProbeCandidate> candidates;
   HIR::ImplBlock *current_impl;
@@ -150,7 +350,22 @@ public:
     RichLocation r (query_locus);
     ReportMultipleCandidateError visitor (r);
     for (auto &c : candidates)
-      c.impl_item->accept_vis (visitor);
+      {
+	switch (c.type)
+	  {
+	  case PathProbeCandidate::CandidateType::IMPL_CONST:
+	  case PathProbeCandidate::CandidateType::IMPL_TYPE_ALIAS:
+	  case PathProbeCandidate::CandidateType::IMPL_FUNC:
+	    c.item.impl.impl_item->accept_vis (visitor);
+	    break;
+
+	  case PathProbeCandidate::CandidateType::TRAIT_ITEM_CONST:
+	  case PathProbeCandidate::CandidateType::TRAIT_TYPE_ALIAS:
+	  case PathProbeCandidate::CandidateType::TRAIT_FUNC:
+	    r.add_range (c.item.trait.item_ref.get_locus ());
+	    break;
+	  }
+      }
 
     rust_error_at (r, "multiple applicable items in scope for: %s",
 		   query.as_string ().c_str ());
diff --git a/gcc/rust/typecheck/rust-hir-trait-ref.h b/gcc/rust/typecheck/rust-hir-trait-ref.h
index 35c0fef..b19c38a 100644
--- a/gcc/rust/typecheck/rust-hir-trait-ref.h
+++ b/gcc/rust/typecheck/rust-hir-trait-ref.h
@@ -56,6 +56,7 @@ public:
     locus = other.locus;
     context = other.context;
 
+    inherited_substitutions.clear ();
     inherited_substitutions.reserve (other.inherited_substitutions.size ());
     for (size_t i = 0; i < other.inherited_substitutions.size (); i++)
       inherited_substitutions.push_back (other.inherited_substitutions.at (i));
@@ -221,6 +222,21 @@ public:
 	   + "]";
   }
 
+  const Analysis::NodeMapping &get_mappings () const
+  {
+    return hir_trait_ref->get_mappings ();
+  }
+
+  const TraitItemReference &lookup_trait_item (const std::string &ident) const
+  {
+    for (auto &item : item_refs)
+      {
+	if (ident.compare (item.get_identifier ()) == 0)
+	  return item;
+      }
+    return TraitItemReference::error_node ();
+  }
+
   const TraitItemReference &
   lookup_trait_item (const std::string &ident,
 		     TraitItemReference::TraitItemType type) const
diff --git a/gcc/rust/typecheck/rust-hir-trait-resolve.h b/gcc/rust/typecheck/rust-hir-trait-resolve.h
index 3de68c8..6d7c864 100644
--- a/gcc/rust/typecheck/rust-hir-trait-resolve.h
+++ b/gcc/rust/typecheck/rust-hir-trait-resolve.h
@@ -121,8 +121,7 @@ private:
     if (!resolver->lookup_resolved_type (path.get_mappings ().get_nodeid (),
 					 &ref))
       {
-	rust_fatal_error (path.get_locus (),
-			  "Failed to resolve path to node-id");
+	rust_error_at (path.get_locus (), "Failed to resolve path to node-id");
 	return error_node ();
       }
 
@@ -130,8 +129,7 @@ private:
     if (!mappings->lookup_node_to_hir (mappings->get_current_crate (), ref,
 				       &hir_node))
       {
-	rust_fatal_error (path.get_locus (),
-			  "Failed to resolve path to hir-id");
+	rust_error_at (path.get_locus (), "Failed to resolve path to hir-id");
 	return error_node ();
       }
 
diff --git a/gcc/rust/typecheck/rust-hir-type-bounds.h b/gcc/rust/typecheck/rust-hir-type-bounds.h
new file mode 100644
index 0000000..d97c0f5
--- /dev/null
+++ b/gcc/rust/typecheck/rust-hir-type-bounds.h
@@ -0,0 +1,57 @@
+// Copyright (C) 2021 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/>.
+
+#ifndef RUST_HIR_TYPE_BOUNDS_H
+#define RUST_HIR_TYPE_BOUNDS_H
+
+#include "rust-hir-type-check-base.h"
+#include "rust-hir-full.h"
+#include "rust-tyty.h"
+
+namespace Rust {
+namespace Resolver {
+
+class TypeBoundsProbe : public TypeCheckBase
+{
+  using Rust::Resolver::TypeCheckBase::visit;
+
+public:
+  static std::vector<std::reference_wrapper<TraitReference>>
+  Probe (const TyTy::BaseType *receiver)
+  {
+    TypeBoundsProbe probe (receiver);
+    probe.scan ();
+    return probe.trait_references;
+  }
+
+private:
+  void scan ();
+
+private:
+  TypeBoundsProbe (const TyTy::BaseType *receiver)
+    : TypeCheckBase (), receiver (receiver)
+  {}
+
+  const TyTy::BaseType *receiver;
+  std::vector<std::reference_wrapper<TraitReference>> trait_references;
+};
+
+} // namespace Resolver
+} // namespace Rust
+
+#endif // RUST_HIR_TYPE_BOUNDS_H
diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.h b/gcc/rust/typecheck/rust-hir-type-check-base.h
index ae71611..f05ab86 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-base.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-base.h
@@ -28,6 +28,8 @@
 namespace Rust {
 namespace Resolver {
 
+class TraitReference;
+
 // base class to allow derivatives to overload as needed
 class TypeCheckBase : public HIR::HIRVisitor
 {
@@ -200,6 +202,8 @@ protected:
       context (TypeCheckContext::get ())
   {}
 
+  TraitReference &resolve_trait_path (HIR::TypePath &);
+
   Analysis::Mappings *mappings;
   Resolver *resolver;
   TypeCheckContext *context;
diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.h b/gcc/rust/typecheck/rust-hir-type-check-expr.h
index bd42b4c..7f1a83d 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-expr.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-expr.h
@@ -205,15 +205,25 @@ public:
 	return;
       }
 
+    context->insert_receiver (expr.get_mappings ().get_hirid (), receiver_tyty);
+
     // https://doc.rust-lang.org/reference/expressions/method-call-expr.html
     // method resolution is complex in rust once we start handling generics and
     // traits. For now we only support looking up the valid name in impl blocks
     // which is simple. There will need to be adjustments to ensure we can turn
     // the receiver into borrowed references etc
 
+    bool reciever_is_generic
+      = receiver_tyty->get_kind () == TyTy::TypeKind::PARAM;
+    bool probe_bounds = true;
+    bool probe_impls = !reciever_is_generic;
+    bool ignore_mandatory_trait_items = !reciever_is_generic;
+
     auto candidates
       = PathProbeType::Probe (receiver_tyty,
-			      expr.get_method_name ().get_segment ());
+			      expr.get_method_name ().get_segment (),
+			      probe_impls, probe_bounds,
+			      ignore_mandatory_trait_items);
     if (candidates.size () == 0)
       {
 	rust_error_at (expr.get_locus (),
@@ -229,13 +239,18 @@ public:
       }
 
     auto resolved_candidate = candidates.at (0);
-    HIR::ImplItem *resolved_method = resolved_candidate.impl_item;
     TyTy::BaseType *lookup_tyty = resolved_candidate.ty;
+    NodeId resolved_node_id
+      = resolved_candidate.is_impl_candidate ()
+	  ? resolved_candidate.item.impl.impl_item->get_impl_mappings ()
+	      .get_nodeid ()
+	  : resolved_candidate.item.trait.item_ref.get_mappings ()
+	      .get_nodeid ();
 
     if (lookup_tyty->get_kind () != TyTy::TypeKind::FNDEF)
       {
 	RichLocation r (expr.get_method_name ().get_locus ());
-	r.add_range (resolved_method->get_impl_locus ());
+	r.add_range (resolved_candidate.locus);
 	rust_error_at (r, "associated impl item is not a method");
 	return;
       }
@@ -245,7 +260,7 @@ public:
     if (!fn->is_method ())
       {
 	RichLocation r (expr.get_method_name ().get_locus ());
-	r.add_range (resolved_method->get_impl_locus ());
+	r.add_range (resolved_candidate.locus);
 	rust_error_at (r, "associated function is not a method");
 	return;
       }
@@ -303,20 +318,25 @@ public:
 	  }
       }
 
-    // apply any remaining generic arguments
-    if (expr.get_method_name ().has_generic_args ())
-      {
-	HIR::GenericArgs &args = expr.get_method_name ().get_generic_args ();
-	lookup
-	  = SubstMapper::Resolve (lookup, expr.get_method_name ().get_locus (),
-				  &args);
-	if (lookup->get_kind () == TyTy::TypeKind::ERROR)
-	  return;
-      }
-    else if (lookup->needs_generic_substitutions ())
+    if (!reciever_is_generic)
       {
-	lookup = SubstMapper::InferSubst (lookup,
-					  expr.get_method_name ().get_locus ());
+	// apply any remaining generic arguments
+	if (expr.get_method_name ().has_generic_args ())
+	  {
+	    HIR::GenericArgs &args
+	      = expr.get_method_name ().get_generic_args ();
+	    lookup = SubstMapper::Resolve (lookup,
+					   expr.get_method_name ().get_locus (),
+					   &args);
+	    if (lookup->get_kind () == TyTy::TypeKind::ERROR)
+	      return;
+	  }
+	else if (lookup->needs_generic_substitutions ())
+	  {
+	    lookup
+	      = SubstMapper::InferSubst (lookup,
+					 expr.get_method_name ().get_locus ());
+	  }
       }
 
     TyTy::BaseType *function_ret_tyty
@@ -333,9 +353,8 @@ public:
     context->insert_type (expr.get_method_name ().get_mappings (), lookup);
 
     // set up the resolved name on the path
-    resolver->insert_resolved_name (
-      expr.get_mappings ().get_nodeid (),
-      resolved_method->get_impl_mappings ().get_nodeid ());
+    resolver->insert_resolved_name (expr.get_mappings ().get_nodeid (),
+				    resolved_node_id);
 
     // return the result of the function back
     infered = function_ret_tyty;
@@ -429,7 +448,7 @@ public:
     if (!mappings->lookup_node_to_hir (expr.get_mappings ().get_crate_num (),
 				       ref_node_id, &ref))
       {
-	rust_error_at (expr.get_locus (), "reverse lookup failure");
+	rust_error_at (expr.get_locus (), "123 reverse lookup failure");
 	return;
       }
 
@@ -937,8 +956,16 @@ public:
       {
 	HIR::PathExprSegment &seg = expr.get_segments ().at (i);
 
+	bool reciever_is_generic
+	  = prev_segment->get_kind () == TyTy::TypeKind::PARAM;
+	bool probe_bounds = true;
+	bool probe_impls = !reciever_is_generic;
+	bool ignore_mandatory_trait_items = !reciever_is_generic;
+
 	// probe the path
-	auto candidates = PathProbeType::Probe (tyseg, seg.get_segment ());
+	auto candidates
+	  = PathProbeType::Probe (tyseg, seg.get_segment (), probe_impls,
+				  probe_bounds, ignore_mandatory_trait_items);
 	if (candidates.size () == 0)
 	  {
 	    rust_error_at (
@@ -954,11 +981,21 @@ public:
 	    return;
 	  }
 
-	auto candidate = candidates.at (0);
+	auto &candidate = candidates.at (0);
 	prev_segment = tyseg;
 	tyseg = candidate.ty;
-	resolved_node_id
-	  = candidate.impl_item->get_impl_mappings ().get_nodeid ();
+
+	if (candidate.is_impl_candidate ())
+	  {
+	    resolved_node_id
+	      = candidate.item.impl.impl_item->get_impl_mappings ()
+		  .get_nodeid ();
+	  }
+	else
+	  {
+	    resolved_node_id
+	      = candidate.item.trait.item_ref.get_mappings ().get_nodeid ();
+	  }
 
 	if (seg.has_generic_args ())
 	  {
@@ -977,6 +1014,7 @@ public:
 	  }
       }
 
+    context->insert_receiver (expr.get_mappings ().get_hirid (), prev_segment);
     if (tyseg->needs_generic_substitutions ())
       {
 	Location locus = expr.get_segments ().back ().get_locus ();
@@ -984,8 +1022,9 @@ public:
 	  {
 	    auto used_args_in_prev_segment
 	      = GetUsedSubstArgs::From (prev_segment);
-	    tyseg
-	      = SubstMapperInternal::Resolve (tyseg, used_args_in_prev_segment);
+	    if (!used_args_in_prev_segment.is_error ())
+	      tyseg = SubstMapperInternal::Resolve (tyseg,
+						    used_args_in_prev_segment);
 	  }
 	else
 	  {
@@ -1214,7 +1253,13 @@ private:
 	  {
 	    if (is_root)
 	      {
-		rust_error_at (seg.get_locus (), "reverse lookup failure");
+		rust_error_at (seg.get_locus (), "456 reverse lookup failure");
+		rust_debug_loc (
+		  seg.get_locus (),
+		  "failure with [%s] mappings [%s] ref_node_id [%u]",
+		  seg.as_string ().c_str (),
+		  seg.get_mappings ().as_string ().c_str (), ref_node_id);
+
 		return new TyTy::ErrorType (expr.get_mappings ().get_hirid ());
 	      }
 	    return root_tyty;
diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.h b/gcc/rust/typecheck/rust-hir-type-check-type.h
index 0f75c54..91d9c53 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-type.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-type.h
@@ -215,7 +215,7 @@ private:
   {}
 
   void
-  check_for_unconstrained (std::vector<std::unique_ptr<HIR::Type> > &type_args)
+  check_for_unconstrained (std::vector<std::unique_ptr<HIR::Type>> &type_args)
   {
     std::map<std::string, Location> param_location_map;
     std::set<std::string> param_tys;
@@ -270,8 +270,31 @@ public:
     if (param.has_type ())
       TypeCheckType::Resolve (param.get_type ().get ());
 
+    std::vector<TyTy::TypeBoundPredicate> specified_bounds;
+    if (param.has_type_param_bounds ())
+      {
+	for (auto &bound : param.get_type_param_bounds ())
+	  {
+	    switch (bound->get_bound_type ())
+	      {
+		case HIR::TypeParamBound::BoundType::TRAITBOUND: {
+		  HIR::TraitBound *b
+		    = static_cast<HIR::TraitBound *> (bound.get ());
+		  TyTy::TypeBoundPredicate predicate (
+		    &resolve_trait_path (b->get_path ()));
+		  specified_bounds.push_back (std::move (predicate));
+		}
+		break;
+
+	      default:
+		break;
+	      }
+	  }
+      }
+
     resolved = new TyTy::ParamType (param.get_type_representation (),
-				    param.get_mappings ().get_hirid (), param);
+				    param.get_mappings ().get_hirid (), param,
+				    specified_bounds);
   }
 
 private:
diff --git a/gcc/rust/typecheck/rust-hir-type-check.cc b/gcc/rust/typecheck/rust-hir-type-check.cc
index 66adfcb..4b66fdb 100644
--- a/gcc/rust/typecheck/rust-hir-type-check.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check.cc
@@ -418,6 +418,7 @@ TraitItemReference::TraitItemReference (TraitItemReference const &other)
     type (other.type), hir_trait_item (other.hir_trait_item),
     locus (other.locus), self (other.self), context (TypeCheckContext::get ())
 {
+  inherited_substitutions.clear ();
   inherited_substitutions.reserve (other.inherited_substitutions.size ());
   for (size_t i = 0; i < other.inherited_substitutions.size (); i++)
     inherited_substitutions.push_back (other.inherited_substitutions.at (i));
diff --git a/gcc/rust/typecheck/rust-hir-type-check.h b/gcc/rust/typecheck/rust-hir-type-check.h
index 0298068..b171123 100644
--- a/gcc/rust/typecheck/rust-hir-type-check.h
+++ b/gcc/rust/typecheck/rust-hir-type-check.h
@@ -102,6 +102,21 @@ public:
     return true;
   }
 
+  void insert_receiver (HirId id, TyTy::BaseType *t)
+  {
+    receiver_context[id] = t;
+  }
+
+  bool lookup_receiver (HirId id, TyTy::BaseType **ref)
+  {
+    auto it = receiver_context.find (id);
+    if (it == receiver_context.end ())
+      return false;
+
+    *ref = it->second;
+    return true;
+  }
+
 private:
   TypeCheckContext ();
 
@@ -111,6 +126,7 @@ private:
   std::vector<TyTy::BaseType *> return_type_stack;
   std::vector<TyTy::BaseType *> loop_type_stack;
   std::map<DefId, TraitReference> trait_context;
+  std::map<HirId, TyTy::BaseType *> receiver_context;
 };
 
 class TypeResolution
diff --git a/gcc/rust/typecheck/rust-substitution-mapper.h b/gcc/rust/typecheck/rust-substitution-mapper.h
index 3730faa..a3c00da 100644
--- a/gcc/rust/typecheck/rust-substitution-mapper.h
+++ b/gcc/rust/typecheck/rust-substitution-mapper.h
@@ -280,24 +280,24 @@ public:
     args = type.get_substitution_arguments ();
   }
 
-  void visit (TyTy::InferType &) override { gcc_unreachable (); }
-  void visit (TyTy::TupleType &) override { gcc_unreachable (); }
-  void visit (TyTy::FnPtr &) override { gcc_unreachable (); }
-  void visit (TyTy::ArrayType &) override { gcc_unreachable (); }
-  void visit (TyTy::BoolType &) override { gcc_unreachable (); }
-  void visit (TyTy::IntType &) override { gcc_unreachable (); }
-  void visit (TyTy::UintType &) override { gcc_unreachable (); }
-  void visit (TyTy::FloatType &) override { gcc_unreachable (); }
-  void visit (TyTy::USizeType &) override { gcc_unreachable (); }
-  void visit (TyTy::ISizeType &) override { gcc_unreachable (); }
-  void visit (TyTy::ErrorType &) override { gcc_unreachable (); }
-  void visit (TyTy::CharType &) override { gcc_unreachable (); }
-  void visit (TyTy::ReferenceType &) override { gcc_unreachable (); }
-  void visit (TyTy::PointerType &) override { gcc_unreachable (); }
-  void visit (TyTy::ParamType &) override { gcc_unreachable (); }
-  void visit (TyTy::StrType &) override { gcc_unreachable (); }
-  void visit (TyTy::NeverType &) override { gcc_unreachable (); }
-  void visit (TyTy::PlaceholderType &) override { gcc_unreachable (); }
+  void visit (TyTy::InferType &) override {}
+  void visit (TyTy::TupleType &) override {}
+  void visit (TyTy::FnPtr &) override {}
+  void visit (TyTy::ArrayType &) override {}
+  void visit (TyTy::BoolType &) override {}
+  void visit (TyTy::IntType &) override {}
+  void visit (TyTy::UintType &) override {}
+  void visit (TyTy::FloatType &) override {}
+  void visit (TyTy::USizeType &) override {}
+  void visit (TyTy::ISizeType &) override {}
+  void visit (TyTy::ErrorType &) override {}
+  void visit (TyTy::CharType &) override {}
+  void visit (TyTy::ReferenceType &) override {}
+  void visit (TyTy::PointerType &) override {}
+  void visit (TyTy::ParamType &) override {}
+  void visit (TyTy::StrType &) override {}
+  void visit (TyTy::NeverType &) override {}
+  void visit (TyTy::PlaceholderType &) override {}
 
 private:
   GetUsedSubstArgs () : args (TyTy::SubstitutionArgumentMappings::error ()) {}
diff --git a/gcc/rust/typecheck/rust-tyty-bounds.cc b/gcc/rust/typecheck/rust-tyty-bounds.cc
new file mode 100644
index 0000000..a480155
--- /dev/null
+++ b/gcc/rust/typecheck/rust-tyty-bounds.cc
@@ -0,0 +1,75 @@
+// Copyright (C) 2021 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-type-bounds.h"
+#include "rust-hir-trait-resolve.h"
+
+namespace Rust {
+namespace Resolver {
+
+void
+TypeBoundsProbe::scan ()
+{
+  std::vector<HIR::TypePath *> possible_trait_paths;
+  mappings->iterate_impl_blocks (
+    [&] (HirId id, HIR::ImplBlock *impl) mutable -> bool {
+      // we are filtering for trait-impl-blocks
+      if (!impl->has_trait_ref ())
+	return true;
+
+      TyTy::BaseType *impl_type = nullptr;
+      bool ok
+	= context->lookup_type (impl->get_type ()->get_mappings ().get_hirid (),
+				&impl_type);
+      if (!ok)
+	return true;
+
+      if (!receiver->can_eq (impl_type, false))
+	return true;
+
+      possible_trait_paths.push_back (impl->get_trait_ref ().get ());
+      return true;
+    });
+
+  for (auto &trait_path : possible_trait_paths)
+    {
+      TraitReference &trait_ref = TraitResolver::Resolve (*trait_path);
+
+      if (!trait_ref.is_error ())
+	trait_references.push_back (trait_ref);
+    }
+}
+
+TraitReference &
+TypeCheckBase::resolve_trait_path (HIR::TypePath &path)
+{
+  return TraitResolver::Resolve (path);
+}
+
+} // namespace Resolver
+
+namespace TyTy {
+
+std::string
+TypeBoundPredicate::as_string () const
+{
+  return reference->as_string ();
+}
+
+} // namespace TyTy
+} // namespace Rust
diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc
index a1315fb..a2ae4fa 100644
--- a/gcc/rust/typecheck/rust-tyty.cc
+++ b/gcc/rust/typecheck/rust-tyty.cc
@@ -243,6 +243,7 @@ SubstitutionParamMapping::override_context ()
 
   auto mappings = Analysis::Mappings::get ();
   auto context = Resolver::TypeCheckContext::get ();
+
   context->insert_type (Analysis::NodeMapping (mappings->get_current_crate (),
 					       UNKNOWN_NODEID,
 					       param->get_ref (),
@@ -1768,7 +1769,7 @@ BaseType *
 ParamType::clone () const
 {
   return new ParamType (get_symbol (), get_ref (), get_ty_ref (), param,
-			get_combined_refs ());
+			get_specified_bounds (), get_combined_refs ());
 }
 
 std::string
@@ -1780,8 +1781,6 @@ ParamType::get_symbol () const
 BaseType *
 ParamType::resolve () const
 {
-  rust_assert (can_resolve ());
-
   TyVar var (get_ty_ref ());
   BaseType *r = var.get_tyty ();
 
@@ -1795,7 +1794,10 @@ ParamType::resolve () const
       r = v.get_tyty ();
     }
 
-  return TyVar (r->get_ty_ref ()).get_tyty ();
+  if (r->get_kind () == TypeKind::PARAM && (r->get_ref () == r->get_ty_ref ()))
+    return TyVar (r->get_ty_ref ()).get_tyty ();
+
+  return r;
 }
 
 bool
diff --git a/gcc/rust/typecheck/rust-tyty.h b/gcc/rust/typecheck/rust-tyty.h
index 6abae53..13bab90 100644
--- a/gcc/rust/typecheck/rust-tyty.h
+++ b/gcc/rust/typecheck/rust-tyty.h
@@ -25,6 +25,10 @@
 #include "rust-diagnostics.h"
 
 namespace Rust {
+namespace Resolver {
+class TraitReference;
+}
+
 namespace TyTy {
 
 // https://rustc-dev-guide.rust-lang.org/type-inference.html#inference-variables
@@ -125,9 +129,56 @@ public:
   }
 };
 
+class TypeBoundPredicate
+{
+public:
+  TypeBoundPredicate (Resolver::TraitReference *reference)
+    : reference (reference)
+  {}
+
+  TypeBoundPredicate (const TypeBoundPredicate &other)
+    : reference (other.reference)
+  {}
+
+  TypeBoundPredicate &operator= (const TypeBoundPredicate &other)
+  {
+    reference = other.reference;
+    return *this;
+  }
+
+  std::string as_string () const;
+
+  const Resolver::TraitReference *get () const { return reference; }
+
+private:
+  Resolver::TraitReference *reference;
+};
+
+class TypeBoundsMappings
+{
+protected:
+  TypeBoundsMappings (std::vector<TypeBoundPredicate> specified_bounds)
+    : specified_bounds (specified_bounds)
+  {}
+
+public:
+  std::vector<TypeBoundPredicate> &get_specified_bounds ()
+  {
+    return specified_bounds;
+  }
+
+  const std::vector<TypeBoundPredicate> &get_specified_bounds () const
+  {
+    return specified_bounds;
+  }
+
+protected:
+  std::vector<TypeBoundPredicate> specified_bounds;
+};
+
 class TyVisitor;
 class TyConstVisitor;
-class BaseType
+class BaseType : public TypeBoundsMappings
 {
 public:
   virtual ~BaseType () {}
@@ -240,8 +291,15 @@ public:
 protected:
   BaseType (HirId ref, HirId ty_ref, TypeKind kind,
 	    std::set<HirId> refs = std::set<HirId> ())
-    : kind (kind), ref (ref), ty_ref (ty_ref), combined (refs),
-      mappings (Analysis::Mappings::get ())
+    : TypeBoundsMappings ({}), kind (kind), ref (ref), ty_ref (ty_ref),
+      combined (refs), mappings (Analysis::Mappings::get ())
+  {}
+
+  BaseType (HirId ref, HirId ty_ref, TypeKind kind,
+	    std::vector<TypeBoundPredicate> specified_bounds,
+	    std::set<HirId> refs = std::set<HirId> ())
+    : TypeBoundsMappings (specified_bounds), kind (kind), ref (ref),
+      ty_ref (ty_ref), combined (refs), mappings (Analysis::Mappings::get ())
   {}
 
   TypeKind kind;
@@ -347,15 +405,18 @@ class ParamType : public BaseType
 {
 public:
   ParamType (std::string symbol, HirId ref, HIR::GenericParam &param,
+	     std::vector<TypeBoundPredicate> specified_bounds,
 	     std::set<HirId> refs = std::set<HirId> ())
-    : BaseType (ref, ref, TypeKind::PARAM, refs), symbol (symbol), param (param)
+    : BaseType (ref, ref, TypeKind::PARAM, specified_bounds, refs),
+      symbol (symbol), param (param)
   {}
 
   ParamType (std::string symbol, HirId ref, HirId ty_ref,
 	     HIR::GenericParam &param,
+	     std::vector<TypeBoundPredicate> specified_bounds,
 	     std::set<HirId> refs = std::set<HirId> ())
-    : BaseType (ref, ty_ref, TypeKind::PARAM, refs), symbol (symbol),
-      param (param)
+    : BaseType (ref, ty_ref, TypeKind::PARAM, specified_bounds, refs),
+      symbol (symbol), param (param)
   {}
 
   void accept_vis (TyVisitor &vis) override;
@@ -986,7 +1047,7 @@ public:
 #define FNTYPE_IS_VARADIC_FLAG 0X04
 
   FnType (HirId ref, DefId id, std::string identifier, uint8_t flags,
-	  std::vector<std::pair<HIR::Pattern *, BaseType *> > params,
+	  std::vector<std::pair<HIR::Pattern *, BaseType *>> params,
 	  BaseType *type, std::vector<SubstitutionParamMapping> subst_refs,
 	  std::set<HirId> refs = std::set<HirId> ())
     : BaseType (ref, ref, TypeKind::FNDEF, refs),
@@ -1001,7 +1062,7 @@ public:
 
   FnType (HirId ref, HirId ty_ref, DefId id, std::string identifier,
 	  uint8_t flags,
-	  std::vector<std::pair<HIR::Pattern *, BaseType *> > params,
+	  std::vector<std::pair<HIR::Pattern *, BaseType *>> params,
 	  BaseType *type, std::vector<SubstitutionParamMapping> subst_refs,
 	  std::set<HirId> refs = std::set<HirId> ())
     : BaseType (ref, ty_ref, TypeKind::FNDEF, refs),
@@ -1054,12 +1115,12 @@ public:
     return get_params ().at (0).second;
   }
 
-  std::vector<std::pair<HIR::Pattern *, BaseType *> > &get_params ()
+  std::vector<std::pair<HIR::Pattern *, BaseType *>> &get_params ()
   {
     return params;
   }
 
-  const std::vector<std::pair<HIR::Pattern *, BaseType *> > &get_params () const
+  const std::vector<std::pair<HIR::Pattern *, BaseType *>> &get_params () const
   {
     return params;
   }
@@ -1094,7 +1155,7 @@ public:
   handle_substitions (SubstitutionArgumentMappings mappings) override final;
 
 private:
-  std::vector<std::pair<HIR::Pattern *, BaseType *> > params;
+  std::vector<std::pair<HIR::Pattern *, BaseType *>> params;
   BaseType *type;
   uint8_t flags;
   std::string identifier;
diff --git a/gcc/testsuite/rust/compile/torture/traits8.rs b/gcc/testsuite/rust/compile/torture/traits8.rs
new file mode 100644
index 0000000..0e83a7d
--- /dev/null
+++ b/gcc/testsuite/rust/compile/torture/traits8.rs
@@ -0,0 +1,22 @@
+trait Foo {
+    fn default() -> i32;
+}
+
+struct Bar(i32);
+// { dg-warning "struct is never constructed" "" { target *-*-* } .-1 }
+
+impl Foo for Bar {
+    fn default() -> i32 {
+        // { dg-warning "unused name" "" { target *-*-* } .-1 }
+        123
+    }
+}
+
+fn type_bound_test<T: Foo>() -> i32 {
+    T::default()
+}
+
+fn main() {
+    let a;
+    a = type_bound_test::<Bar>();
+}
diff --git a/gcc/testsuite/rust/compile/torture/traits9.rs b/gcc/testsuite/rust/compile/torture/traits9.rs
new file mode 100644
index 0000000..075a219
--- /dev/null
+++ b/gcc/testsuite/rust/compile/torture/traits9.rs
@@ -0,0 +1,30 @@
+trait Foo {
+    fn default() -> i32;
+    fn get(self) -> i32;
+    // { dg-warning "unused name" "" { target *-*-* } .-1 }
+}
+
+struct Bar(i32);
+impl Foo for Bar {
+    fn default() -> i32 {
+        // { dg-warning "unused name" "" { target *-*-* } .-1 }
+        123
+    }
+
+    fn get(self) -> i32 {
+        // { dg-warning "unused name" "" { target *-*-* } .-1 }
+        self.0
+    }
+}
+
+fn type_bound_test<T: Foo>(a: T) -> i32 {
+    T::default() + a.get()
+}
+
+fn main() {
+    let a;
+    a = Bar(456);
+
+    let b;
+    b = type_bound_test(a);
+}