1 files changed, 79 insertions, 4 deletions
diff --git a/gcc/rust/resolve/rust-name-resolution-context.h b/gcc/rust/resolve/rust-name-resolution-context.h
index cd6fa93..84c0800 100644
--- a/gcc/rust/resolve/rust-name-resolution-context.h
+++ b/gcc/rust/resolve/rust-name-resolution-context.h
@@ -172,6 +172,9 @@ public:
   tl::expected<NodeId, DuplicateNameError> insert (Identifier name, NodeId id,
 						   Namespace ns);
 
+  tl::expected<NodeId, DuplicateNameError> insert_variant (Identifier name,
+							   NodeId id);
+
   tl::expected<NodeId, DuplicateNameError>
   insert_shadowable (Identifier name, NodeId id, Namespace ns);
 
@@ -185,8 +188,8 @@ public:
    * function. This variant of the function enters a new scope in *all*
    * namespaces, while the second variant enters a scope in *one* namespace.
    *
-   * @param rib New `Rib` to create when entering this scope. A function `Rib`,
-   *        or an item `Rib`... etc
+   * @param rib_kind New `Rib` to create when entering this scope. A function
+   *        `Rib`, or an item `Rib`... etc
    * @param scope_id node ID of the scope we are entering, e.g the block's
    *        `NodeId`.
    * @param lambda Function to run within that scope
@@ -196,9 +199,10 @@ public:
    */
   // FIXME: Do we want to handle something in particular for expected within the
   // scoped lambda?
-  void scoped (Rib rib, NodeId scope_id, std::function<void (void)> lambda,
+  void scoped (Rib::Kind rib_kind, NodeId scope_id,
+	       std::function<void (void)> lambda,
 	       tl::optional<Identifier> path = {});
-  void scoped (Rib rib, Namespace ns, NodeId scope_id,
+  void scoped (Rib::Kind rib_kind, Namespace ns, NodeId scope_id,
 	       std::function<void (void)> lambda,
 	       tl::optional<Identifier> path = {});
 
@@ -215,6 +219,77 @@ public:
 
   tl::optional<NodeId> lookup (NodeId usage) const;
 
+  template <typename S>
+  tl::optional<Rib::Definition> resolve_path (const std::vector<S> &segments,
+					      bool has_opening_scope_resolution,
+					      Namespace ns)
+  {
+    std::function<void (const S &, NodeId)> insert_segment_resolution
+      = [this] (const S &seg, NodeId id) {
+	  auto seg_id = unwrap_segment_node_id (seg);
+	  if (resolved_nodes.find (Usage (seg_id)) == resolved_nodes.end ())
+	    map_usage (Usage (seg_id), Definition (id));
+	};
+    switch (ns)
+      {
+      case Namespace::Values:
+	return values.resolve_path (segments, has_opening_scope_resolution,
+				    insert_segment_resolution);
+      case Namespace::Types:
+	return types.resolve_path (segments, has_opening_scope_resolution,
+				   insert_segment_resolution);
+      case Namespace::Macros:
+	return macros.resolve_path (segments, has_opening_scope_resolution,
+				    insert_segment_resolution);
+      case Namespace::Labels:
+	return labels.resolve_path (segments, has_opening_scope_resolution,
+				    insert_segment_resolution);
+      default:
+	rust_unreachable ();
+      }
+  }
+
+  template <typename S, typename... Args>
+  tl::optional<Rib::Definition> resolve_path (const std::vector<S> &segments,
+					      bool has_opening_scope_resolution,
+					      Args... ns_args)
+  {
+    std::initializer_list<Namespace> namespaces = {ns_args...};
+
+    for (auto ns : namespaces)
+      {
+	if (auto ret
+	    = resolve_path (segments, has_opening_scope_resolution, ns))
+	  return ret;
+      }
+
+    return tl::nullopt;
+  }
+
+  template <typename... Args>
+  tl::optional<Rib::Definition> resolve_path (const AST::SimplePath &path,
+					      Args... ns_args)
+  {
+    return resolve_path (path.get_segments (),
+			 path.has_opening_scope_resolution (), ns_args...);
+  }
+
+  template <typename... Args>
+  tl::optional<Rib::Definition> resolve_path (const AST::PathInExpression &path,
+					      Args... ns_args)
+  {
+    return resolve_path (path.get_segments (), path.opening_scope_resolution (),
+			 ns_args...);
+  }
+
+  template <typename... Args>
+  tl::optional<Rib::Definition> resolve_path (const AST::TypePath &path,
+					      Args... ns_args)
+  {
+    return resolve_path (path.get_segments (),
+			 path.has_opening_scope_resolution_op (), ns_args...);
+  }
+
 private:
   /* Map of "usage" nodes which have been resolved to a "definition" node */
   std::map<Usage, Definition> resolved_nodes;