Move function definition out of header file

gcc/rust/ChangeLog:

	* resolve/rust-name-resolution-context.cc (BindingLayer::BindingLayer):
  Add new constructor for binding layer.
	(BindingLayer::bind_test): Add a function to test a binding constraint.
	(BindingLayer::push): Push a new binding group.
	(BindingLayer::and_binded): Add function to test and-binding
	constraint.
	(BindingLayer::or_binded): Add function to test or-binding constraints.
	(BindingLayer::insert_ident): Insert a new identifier in the current
	binding group.
	(BindingLayer::merge): Merge current binding group with it's parent.
	(BindingLayer::get_source): Get the source of the current binding
	group.
	(BindingContext::and_binded): Add function to test and-binding for
	current layer.
	(BindingContext::or_binded): Add function to test or-binding for
	current layer.
	(BindingContext::merge): Add function to apply merge on current layer.
	(BindingContext::push): Add function to apply push on current layer.
	(BindingContext::insert_ident): Add function to apply insert_ident on
	current layer.
	(BindingContext::new_binding): Push new binding over the stack of
	layers.
	(BindingContext::clear): Remove last binding layer from the stack.
	(BindingContext::get_source): Get the source of current binding layer.
	* resolve/rust-name-resolution-context.h (enum class): Remove function
  definition.

Signed-off-by: Pierre-Emmanuel Patry <[email protected]>

Author: P-E-P

gcc/rust/resolve/rust-name-resolution-context.cc

@@ -23,6 +23,113 @@
 namespace Rust {
 namespace Resolver2_0 {
 
+BindingLayer::BindingLayer (BindingSource source) : source (source)
+{
+  push (Binding::Kind::Product);
+}
+
+bool
+BindingLayer::bind_test (Identifier ident, Binding::Kind kind)
+{
+  for (auto &bind : bindings)
+    {
+      if (bind.set.find (ident) != bind.set.cend () && bind.kind == kind)
+	{
+	  return true;
+	}
+    }
+  return false;
+}
+
+void
+BindingLayer::push (Binding::Kind kind)
+{
+  bindings.push_back (Binding (kind));
+}
+
+bool
+BindingLayer::and_binded (Identifier ident)
+{
+  return bind_test (ident, Binding::Kind::Product);
+}
+
+bool
+BindingLayer::or_binded (Identifier ident)
+{
+  return bind_test (ident, Binding::Kind::Or);
+}
+
+void
+BindingLayer::insert_ident (Identifier ident)
+{
+  bindings.back ().set.insert (ident);
+}
+
+void
+BindingLayer::merge ()
+{
+  auto last_binding = bindings.back ();
+  bindings.pop_back ();
+  for (auto &value : last_binding.set)
+    {
+      bindings.back ().set.insert (value);
+    }
+}
+
+BindingSource
+BindingLayer::get_source () const
+{
+  return source;
+}
+
+bool
+BindingContext::and_binded (Identifier ident)
+{
+  return bindings.back ().and_binded (ident);
+}
+
+bool
+BindingContext::or_binded (Identifier ident)
+{
+  return bindings.back ().or_binded (ident);
+}
+
+void
+BindingContext::merge ()
+{
+  bindings.back ().merge ();
+}
+
+void
+BindingContext::push (Binding::Kind kind)
+{
+  bindings.back ().push (kind);
+}
+
+void
+BindingContext::insert_ident (Identifier ident)
+{
+  bindings.back ().insert_ident (ident);
+}
+
+void
+BindingContext::new_binding (BindingSource source)
+{
+  bindings.emplace_back (source);
+}
+
+void
+BindingContext::clear ()
+{
+  bindings.pop_back ();
+}
+
+BindingSource
+BindingContext::get_source () const
+{
+  return bindings.back ().get_source ();
+}
+
 NameResolutionContext::NameResolutionContext ()
   : mappings (Analysis::Mappings::get ())
 {}

gcc/rust/resolve/rust-name-resolution-context.h

@@ -169,11 +169,15 @@ struct Binding
   Binding (Binding::Kind kind) : kind (kind) {}
 };
 
+/**
+ * Used to identify the source of a binding, and emit the correct error message.
+ */
 enum class BindingSource
 {
   Match,
   Let,
   For,
+  /* Closure param or function param */
   Param
 };
 
@@ -182,79 +186,76 @@ class BindingLayer
   BindingSource source;
   std::vector<Binding> bindings;
 
-  bool bind_test (Identifier ident, Binding::Kind kind)
-  {
-    for (auto &bind : bindings)
-      {
-	if (bind.set.find (ident) != bind.set.cend () && bind.kind == kind)
-	  {
-	    return true;
-	  }
-      }
-    return false;
-  }
+  bool bind_test (Identifier ident, Binding::Kind kind);
 
 public:
-  void push (Binding::Kind kind) { bindings.push_back (Binding (kind)); }
+  void push (Binding::Kind kind);
 
-  BindingLayer (BindingSource source) : source (source)
-  {
-    push (Binding::Kind::Product);
-  }
-  bool and_binded (Identifier ident)
-  {
-    return bind_test (ident, Binding::Kind::Product);
-  }
+  BindingLayer (BindingSource source);
 
-  bool or_binded (Identifier ident)
-  {
-    return bind_test (ident, Binding::Kind::Or);
-  }
+  /**
+   * Identifies if the identifier has been used in a product binding context.
+   * eg. `let (a, a) = test();`
+   */
+  bool and_binded (Identifier ident);
 
-  void insert_ident (Identifier ident) { bindings.back ().set.insert (ident); }
+  /**
+   * Identifies if the identifier has been used in a or context.
+   * eg. `let (a, 1) | (a, 2) = test()`
+   */
+  bool or_binded (Identifier ident);
 
-  void merge ()
-  {
-    auto last_binding = bindings.back ();
-    bindings.pop_back ();
-    for (auto &value : last_binding.set)
-      {
-	bindings.back ().set.insert (value);
-      }
-  }
+  void insert_ident (Identifier ident);
 
-  BindingSource get_source () const { return source; }
+  void merge ();
+
+  BindingSource get_source () const;
 };
 
 class BindingContext
 {
   std::vector<BindingLayer> bindings;
 
 public:
-  bool and_binded (Identifier ident)
-  {
-    return bindings.back ().and_binded (ident);
-  }
+  /**
+   * Identifies if the identifier is and-binded in the current layer's bindings.
+   */
+  bool and_binded (Identifier ident);
 
-  bool or_binded (Identifier ident)
-  {
-    return bindings.back ().or_binded (ident);
-  }
+  /**
+   * Identifies if the identifier is or-binded in the current layer's bindings.
+   */
+  bool or_binded (Identifier ident);
 
-  void merge () { bindings.back ().merge (); }
+  /**
+   * Remove current layer's last binding level and merge it with it's parent.
+   */
+  void merge ();
 
-  void push (Binding::Kind kind) { bindings.back ().push (kind); }
+  /**
+   * Push a new binding level in the current binding layer.
+   */
+  void push (Binding::Kind kind);
 
-  void insert_ident (Identifier ident)
-  {
-    bindings.back ().insert_ident (ident);
-  }
+  /**
+   * Insert a new identifier in the current binding layer.
+   */
+  void insert_ident (Identifier ident);
 
-  void new_binding (BindingSource source) { bindings.emplace_back (source); }
+  /**
+   * Get current layer's binding source.
+   */
+  BindingSource get_source () const;
 
-  void clear () { bindings.pop_back (); }
+  /**
+   * Create a new binding layer.
+   */
+  void new_binding (BindingSource source);
 
-  BindingSource get_source () const { return bindings.back ().get_source (); }
+  /**
+   * Remove current binding layer.
+   */
+  void clear ();
 };
 
 // Now our resolver, which keeps track of all the `ForeverStack`s we could want