chore: switch to substrait antlr grammar

Makefile

@@ -1,2 +1,5 @@
 antlr:
-	java -jar ${ANTLR_JAR} -o src/substrait/gen/antlr -Dlanguage=Python3 SubstraitType.g4
+	cd third_party/substrait/grammar \
+		&& java -jar ${ANTLR_JAR} -o ../../../src/substrait/gen/antlr -Dlanguage=Python3 SubstraitType.g4 \
+		&& rm ../../../src/substrait/gen/antlr/*.tokens \
+		&& rm ../../../src/substrait/gen/antlr/*.interp

src/substrait/derivation_expression.py

@@ -27,9 +27,9 @@ def _evaluate(x, values: dict):
         else:
             raise Exception(f"Unknown binary op {x.op.text}")
     elif type(x) == SubstraitTypeParser.LiteralNumberContext:
-        return int(x.number.text)
-    elif type(x) == SubstraitTypeParser.TypeParamContext:
-        return values[x.identifier.text]
+        return int(x.Number().symbol.text)
+    elif type(x) == SubstraitTypeParser.ParameterNameContext:
+        return values[x.Identifier().symbol.text]
     elif type(x) == SubstraitTypeParser.NumericParameterNameContext:
         return values[x.Identifier().symbol.text]
     elif type(x) == SubstraitTypeParser.ParenExpressionContext:
@@ -43,9 +43,10 @@ def _evaluate(x, values: dict):
             return max(*exprs)
         else:
             raise Exception(f"Unknown function {func}")
-    elif type(x) == SubstraitTypeParser.TypeContext:
+    elif type(x) == SubstraitTypeParser.TypeDefContext:
         scalar_type = x.scalarType()
         parametrized_type = x.parameterizedType()
+        any_type = x.anyType()
         if scalar_type:
             nullability = (
                 Type.NULLABILITY_NULLABLE if x.isnull else Type.NULLABILITY_REQUIRED
@@ -81,8 +82,14 @@ def _evaluate(x, values: dict):
                     )
                 )
             raise Exception(f"Unknown parametrized type {type(parametrized_type)}")
+        elif any_type:
+            any_var = any_type.AnyVar()
+            if any_var:
+                return values[any_var.symbol.text]
+            else:
+                raise Exception()
         else:
-            raise Exception("either scalar_type or parametrized_type is required")
+            raise Exception(f"either scalar_type, parametrized_type or any_type is required")
     elif type(x) == SubstraitTypeParser.NumericExpressionContext:
         return _evaluate(x.expr(), values)
     elif type(x) == SubstraitTypeParser.TernaryContext:
@@ -101,7 +108,7 @@ def _evaluate(x, values: dict):
 
         return _evaluate(x.finalType, values)
     elif type(x) == SubstraitTypeParser.TypeLiteralContext:
-        return _evaluate(x.type_(), values)
+        return _evaluate(x.typeDef(), values)
     elif type(x) == SubstraitTypeParser.NumericLiteralContext:
         return int(str(x.Number()))
     else:

src/substrait/extension_registry.py

@@ -96,25 +96,33 @@ def types_equal(type1: Type, type2: Type, check_nullability=False):
         ).nullability = Type.Nullability.NULLABILITY_UNSPECIFIED
         return x == y
 
+def handle_parameter_cover(covered: Type, parameter_name: str, parameters: dict, check_nullability: bool):
+    if parameter_name in parameters:
+        covering = parameters[parameter_name]
+        return types_equal(covering, covered, check_nullability)
+    else:
+        parameters[parameter_name] = covered
+        return True
 
 def covers(
     covered: Type,
     covering: SubstraitTypeParser.TypeLiteralContext,
     parameters: dict,
     check_nullability=False,
-):
-    if isinstance(covering, SubstraitTypeParser.TypeParamContext):
+):  
+    if isinstance(covering, SubstraitTypeParser.ParameterNameContext):
         parameter_name = str(covering.Identifier())
+        return handle_parameter_cover(covered, parameter_name, parameters, check_nullability)
 
-        if parameter_name in parameters:
-            covering = parameters[parameter_name]
+    covering: SubstraitTypeParser.TypeDefContext = covering.typeDef()
 
-            return types_equal(covering, covered, check_nullability)
+    any_type: SubstraitTypeParser.AnyTypeContext = covering.anyType()
+    if any_type:
+        if any_type.AnyVar():
+            return handle_parameter_cover(covered, any_type.AnyVar().symbol.text, parameters, check_nullability)
         else:
-            parameters[parameter_name] = covered
             return True
 
-    covering = covering.type_()
     scalar_type = covering.scalarType()
     if scalar_type:
         covering = _evaluate(covering, {})
@@ -150,10 +158,6 @@ def covers(
         else:
             raise Exception(f"Unhandled type {type(parameterized_type)}")
 
-    any_type = covering.anyType()
-    if any_type:
-        return True
-
 
 class FunctionEntry:
     def __init__(