Auto-generate .Equals(), .GetHashCode() and friends

AstGenerator.cs

@@ -4,12 +4,13 @@ public static class AstGenerator {
   public static void Main() {
     Generate(
       "AstGenerated.cs",
+      "",
       "namespace Ast {",
       "}",
       "Ast.",
       Types(
         Variant("Expr",
-          Case("Int", "int"),
+          Case("int", "Int"),
-          Case("String", "string"))));
+          Case("string", "String"))));
   }
 }

Lexer.cs

@@ -8,22 +8,6 @@ using C = System.Globalization.UnicodeCategory;
 using static Global;
 
 public static partial class Lexer {
-  public class Rule {
-    public readonly S oldState;
-    public readonly string description;
-    public readonly Func<GraphemeCluster, bool> test;
-    public readonly S throughState;
-    public readonly S newState;
-
-    public Rule(S oldState, string description, Func<GraphemeCluster, bool> test, S throughState, S newState) {
-      this.oldState = oldState;
-      this.description = description;
-      this.test = test;
-      this.throughState = throughState;
-      this.newState = newState;
-    }
-  }
-
   public sealed class EOF { }
 
   public static class Rules {

LexerGenerator.cs

@@ -4,6 +4,7 @@ public static class LexerGenerator {
   public static void Main() {
     Generator.Generate(
       "LexerGenerated.cs",
+      "",
       "public static partial class Lexer {",
       "}",
       "Lexer.",
@@ -15,6 +16,12 @@ public static class LexerGenerator {
           Case("Decimal"),
           Case("String"),
           Case("StringOpen"),
-          Case("StringClose"))));
+          Case("StringClose")),
+        Record("Rule",
+          Field("S", "oldState"),
+          Field("string", "description"),
+          Field("Func<GraphemeCluster, bool>", "test"),
+          Field("S", "throughState"),
+          Field("S", "newState"))));
   }
 }

T4/Generator.cs

@@ -20,7 +20,7 @@ public static class Generator {
     o.WriteLine($"     )");
     o.WriteLine($"  */");
 
-    o.WriteLine($"  public abstract class {name} {{");
+    o.WriteLine($"  public abstract class {name} : IEquatable<{name}> {{");
     o.WriteLine($"    public abstract T Match_<T>(Visitor<T> c);");
     foreach (var @case in variant) {
       var C = @case.Key;
@@ -40,18 +40,10 @@ public static class Generator {
                 $"        {@case.Key}: {@case.Value == null ? "()" : "value"} => \"{@case.Key}\"")));
     o.WriteLine($"      );");
     o.WriteLine($"    }}");
-
+    o.WriteLine("");
-/*
+    o.WriteLine($"    public abstract bool Equals(Object other);");
-    public abstract override bool Equals(object other) {
+    o.WriteLine($"    public abstract bool Equals({name} other);");
-      if (object.ReferenceEquals(other, null) || !this.GetType().Equals(other.GetType())) {
+    o.WriteLine("");
-        return false;
-      } else {
-        var cast = (S)other;
-        return    String.Equal(this.GetTag(), other.GetTag)
-               && 
-    }
-*/
-
     o.WriteLine($"  }}");
     o.WriteLine("");
 
@@ -72,25 +64,24 @@ public static class Generator {
       o.WriteLine($"    public {C}({Ty == null ? "" : $"{Ty} value"}) {{ {Ty == null ? "" : $"this.value = value; "}}}");
       o.WriteLine($"    public override T Match_<T>(Visitor<T> c) => c.{C}({Ty == null ? "" : "value"});");
       o.WriteLine($"    public override Immutable.Option<{C}> As{C}() => Immutable.Option.Some<{C}>(this);");
-      o.WriteLine($"    public override bool Equals(object other) {{");
+      o.WriteLine($"    public static bool operator ==({C} a, {C} b)");
+      o.WriteLine($"      => Equality.Operator(a, b);");
+      o.WriteLine($"    public static bool operator !=({C} a, {C} b)");
+      o.WriteLine($"      => !(a == b);");
+      o.WriteLine($"    public override bool Equals(object other)");
       if (Ty == null) {
-        o.WriteLine($"        return (other is {C});");
+        o.WriteLine($"      => Equality.Untyped<{C}>(this, other, x => x as {C});");
       } else {
-        o.WriteLine($"      var cast = other as {C};");
+        o.WriteLine($"      => Equality.Untyped<{C}>(this, other, x => x as {C}, x => x.value);");
-        o.WriteLine($"      if (Object.ReferenceEquals(cast, null)) {{");
-        o.WriteLine($"        return false;");
-        o.WriteLine($"      }} else {{");
-        o.WriteLine($"        return Equality.Field<{C}, {Ty}>(this, cast, x => x.value, (x, y) => ((Object)x).Equals(y));");
-        o.WriteLine($"      }}");
       }
-      o.WriteLine($"    }}");
+      o.WriteLine($"    public override bool Equals({name} other)");
-      o.WriteLine($"    public override int GetHashCode() {{");
+      o.WriteLine($"      => Equality.Equatable<{name}>(this, other);");
+      o.WriteLine($"    public override int GetHashCode()");
       if (Ty == null) {
-        o.WriteLine($"        return \"C\".GetHashCode();");
+        o.WriteLine($"      => HashCode.Combine(\"{C}\");");
       } else {
-        o.WriteLine($"        return HashCode.Combine(\"{C}\", this.value);");
+        o.WriteLine($"      => HashCode.Combine(\"{C}\", this.value);");
       }
-      o.WriteLine($"    }}");
       o.WriteLine("");
       o.WriteLine($"    public override string ToString() => \"{C}\";");
       o.WriteLine($"  }}");
@@ -116,7 +107,7 @@ public static class Generator {
   public static void WriteRecord(this System.IO.StreamWriter o, string header, string footer, string qualifier, string name, Dictionary<string, string> record) {
     o.WriteLine($"{header}");
     o.WriteLine("");
-    o.WriteLine($"  public class {name} {{");
+    o.WriteLine($"  public class {name} : IEquatable<{name}> {{");
     foreach (var @field in record) {
       var F = @field.Key;
       var Ty = @field.Value;
@@ -132,16 +123,34 @@ public static class Generator {
       o.WriteLine($"    this.{F} = {F};");
     }
     o.WriteLine($"    }}");
+    o.WriteLine($"");
+    o.WriteLine($"    public static bool operator ==({name} a, {name} b)");
+    o.WriteLine($"      => Equality.Operator(a, b);");
+    o.WriteLine($"    public static bool operator !=({name} a, {name} b)");
+    o.WriteLine($"      => !(a == b);");
+    o.WriteLine($"    public override bool Equals(object other)");
+    o.WriteLine($"      => Equality.Untyped<{name}>(this, other, x => x as {name},");
+    o.WriteLine(String.Join(",\n", record.Select(@field =>
+                $"          x => x.{@field.Key}")));
+    o.WriteLine($"        );");
+    o.WriteLine($"    public bool Equals({name} other)");
+    o.WriteLine($"      => Equality.Equatable<{name}>(this, other);");
+    o.WriteLine($"    public override int GetHashCode()");
+    o.WriteLine($"      => HashCode.Combine(\"{name}\",");
+    o.WriteLine(String.Join(",\n", record.Select(@field =>
+                $"          this.{@field.Key}")));
+    o.WriteLine($"        );");
     o.WriteLine($"  }}");
     o.WriteLine($"{footer}");
   }
 
-  public static void Generate(string outputFile, string header, string footer, string qualifier, Dictionary<string, Tuple<Kind, Dictionary<string, string>>> types) {
+  public static void Generate(string outputFile, string singleHeader, string header, string footer, string qualifier, Dictionary<string, Tuple<Kind, Dictionary<string, string>>> types) {
     using (var o = new System.IO.StreamWriter(outputFile)) {
       o.WriteLine("// This file was generated by Generator.cs");
       o.WriteLine("");
 
       o.WriteLine("using System;");
+      o.WriteLine($"{singleHeader}");
       o.WriteLine("");
       foreach (var type in types) {
         var name = type.Key;
@@ -155,6 +164,7 @@ public static class Generator {
             o.WriteVariant(header, footer, qualifier, name, @components);
             break;
         }
+        o.WriteLine("");
       }
     }
   }
@@ -177,10 +187,10 @@ public static class Generator {
            Kind.Variant,
            cases.ToDictionary(t => t.Item1, t => t.Item2)));
 
-  public static Tuple<string, string> Field(string name, string type)
+  public static Tuple<string, string> Field(string type, string name)
     => new Tuple<string, string>(name, type);
 
-  public static Tuple<string, string> Case(string name, string type)
+  public static Tuple<string, string> Case(string type, string name)
     => new Tuple<string, string>(name, type);
 
   public static Tuple<string, string> Case(string name)

Utils/Equality.cs

@@ -2,20 +2,58 @@ using System;
 using System.Linq;
 
 public static class Equality {
-  public static bool Test<T>(T a, T b, Func<T, T, bool> compare) {
+  // TODO: values returned by fieldAccessors should implement IEquatable.
+
+  // T can be any supertype of the instances passed to the == operator.
+  public static bool Operator(Object a, Object b) {
     if (Object.ReferenceEquals(a, null)) {
       return Object.ReferenceEquals(b, null);
+    } else if (Object.ReferenceEquals(b, null)) {
+      return false;
     } else {
-      return compare(a, b);
+      return ((Object)a).Equals(b);
     }
   }
 
-
+  // T must be the exact type of the receiver object whose
-  public static bool Field<T, U>(T a, T b, Func<T, U> getField, Func<U, U, bool> compareField) {
+  // Object.Equals(Object other) method is invoking
+  // Untyped(this, other).
+  public static bool Untyped<T>(T a, Object b, Func<Object, T> cast, params Func<T, Object>[] fieldAccessors) {
     if (Object.ReferenceEquals(a, null)) {
       return Object.ReferenceEquals(b, null);
+    } else if (Object.ReferenceEquals(b, null)) {
+      return false;
     } else {
-      return compareField(getField(a), getField(b));
+      var castB = cast(b);
+      if (Object.ReferenceEquals(castB, null)) {
+        return false;
+      } else {
+        foreach (var accessor in fieldAccessors) {
+          var aFieldValue = accessor(a);
+          var bFieldValue = accessor(castB);
+          if (Object.ReferenceEquals(aFieldValue, null)) {
+            return Object.ReferenceEquals(bFieldValue, null);
+          } else if (Object.ReferenceEquals(bFieldValue, null)) {
+            return false;
+          } else {
+            return aFieldValue.Equals(bFieldValue);
+          }
+        }
+        return true;
+      }
+    }
+  }
+
+  // T must be the exact type of the receiver object whose
+  // IEquatable<U>.Equals(U other) method is invoking
+  // Equatable(this, other).
+  public static bool Equatable<T>(T a, Object b) where T : IEquatable<T> {
+    if (Object.ReferenceEquals(a, null)) {
+      return Object.ReferenceEquals(b, null);
+    } else if (Object.ReferenceEquals(b, null)) {
+      return false;
+    } else {
+      return ((Object)a).Equals(b);
     }
   }
 }