rule equality and hash codes

[Palatis]

• also hash the Type for various rule classes
  • BooleanRule
  • OnFail
  • AtRule
  • NotAtRule
  • SequenceRule (wasn't able to distinguish between a SequenceRule and a ChoiceRule with same inner Rules by hash)
  • ChoiceRule (wasn't able to distinguish between a SequenceRule and a ChoiceRule with same inner Rules by hash)
  • NamedRule (wasn't able to distinguish between a NamedRule and a NodeRule with same inner Rule by hash)
  • NodeRule (wasn't able to distinguish between a NamedRule and a NodeRule with same inner Rule by hash)
  • StringRule (wasn't able to distinguish between a StringRule and CaseInvariantStringRule with same Pattern by hash)
  • CaseInvariantStringRule (wasn't able to distinguish between a StringRule and CaseInvariantStringRule with same Pattern by hash)
  • CharRule
• hash against the Type instead of name
  • AnyCharRule
  • EndOfInputRule
  • CharSetRule
• hash the charset for CharSetRule (wasn't able to distinguish between two CharSetRules with different charset)
• add Type to the hash for CountedRule and its variants (wasn't able to distinguish between these types with same inner Rules by hash)
  • ZeroOrMoreRule
  • OneOrMoreRule
  • OptionalRule
  • CountedRule
• hash Min and Max for CountedRule (wasn't able to distinguish between two CountedRule with different Min and/or Max but same inner Rules by hash)
• rework GetHashCode() and Equals() for RecursiveRule
  • now it works pretty well as expected, see the tests for more information.

[Palatis]

bigger problems are with the RecursiveRule

due to the nature of .Net handles delegate,

1. two lambda expressions with same expression are different if they're on different location of codes:

var a = () => x;
var b = () => x;
Equals(a, b); // false
a == b; // false

this would become a problem when we're referencing the same rule by lambda expression, for example:

public Rule Identifier => Node(...);
public Rule Term => Node(Identifier | Recursive(() => Term));
public Rule Term2 => Node(Identifier | Recursive(() => Term));
// the two inner `RecursiveRule`s are considered different, even they shares the same lambda expression.

2. lambda expressions returned by another method with same arguments are different:

public Func<int> GetFunc(int n) => () => n;
/* ... */
var a = GetFunc(0);
var b = GetFunc(0);
Equals(a, b); // false
a == b; // false

this would become a problem when we're reference the same rule by it's name, for example:

public Rule Identifier => Node(...);
public Rule Term => Node(Identifier | Recursive(nameof(Term));
public Rule Term2 => Node(Identifier | Recursive(nameof(Term));
// the two inner `RecursiveRule`s are considered different, even though they shares the same lookup method `() => GetRuleFromName(inner)` defined in `Grammar`.
// because `inner` is a captured variable.

thus, we consider the equality of delegate's Method and Target, also calculate the hash against them.

[Palatis]

i had problems working on the optimizer when hash code and equality are not implemented correctly.

we had to put the rules and optimized rules in a LUT to avoid redundant optimization, but because the hash code are weird the LUT dictionary is working weirdly...