Raise error for array subscripts

Matching full grammar

Author: jeromekelleher

tests/test_filter.py

@@ -31,13 +31,26 @@ def test_invalid_expressions(self, parser, expression):
     @pytest.mark.parametrize(
         ("expression", "exception_class"),
         [
-            # ('INFO/HAYSTACK ~ "needle"', filter_mod.UnsupportedRegexError),
+            ('INFO/HAYSTACK ~ "needle"', filter_mod.UnsupportedRegexError),
             ("INFO/X[0] == 1", filter_mod.UnsupportedArraySubscriptError),
+            ("INFO/AF[0] > 0.3", filter_mod.UnsupportedArraySubscriptError),
+            ("FORMAT/AD[0:0] > 30", filter_mod.UnsupportedArraySubscriptError),
+            ("DP4[*] == 0", filter_mod.UnsupportedArraySubscriptError),
+            ("FORMAT/DP[1-3] > 10", filter_mod.UnsupportedArraySubscriptError),
+            ("FORMAT/DP[1-] < 7", filter_mod.UnsupportedArraySubscriptError),
+            ("FORMAT/DP[0,2-4] > 20", filter_mod.UnsupportedArraySubscriptError),
+            ("FORMAT/AD[0:*]", filter_mod.UnsupportedArraySubscriptError),
+            ("FORMAT/AD[0:]", filter_mod.UnsupportedArraySubscriptError),
+            ("FORMAT/AD[*:1]", filter_mod.UnsupportedArraySubscriptError),
+            (
+                "(DP4[0]+DP4[1])/(DP4[2]+DP4[3]) > 0.3",
+                filter_mod.UnsupportedArraySubscriptError,
+            ),
         ],
     )
     def test_unsupported_syntax(self, parser, expression, exception_class):
-        # with pytest.raises(exception_class):
-        parser.parse_string(expression, parse_all=True)
+        with pytest.raises(exception_class):
+            parser.parse_string(expression, parse_all=True)
 
 
 class TestFilterExpressionSample:

vcztools/filter.py

@@ -79,6 +79,15 @@ def referenced_fields(self):
         return frozenset([self.field_name])
 
 
+class IndexedIdentifier(Identifier):
+    def __init__(self, mapper, tokens):
+        super().__init__(mapper, tokens[0])
+        # Only literal integers are supported as indexes in bcftools
+        # assert isinstance(self.index, str)
+        self.index = tokens[0][1]
+        raise UnsupportedArraySubscriptError()
+
+
 class RegexOperator(EvaluationNode):
     def __init__(self, tokens):
         raise UnsupportedRegexError()
@@ -186,26 +195,31 @@ def make_bcftools_filter_parser(all_fields=None, map_vcf_identifiers=True):
     vcf_prefixes = pp.Literal("INFO/") | pp.Literal("FORMAT/") | pp.Literal("FMT/")
     vcf_identifier = pp.Combine(vcf_prefixes + identifier) | identifier
 
-    # indexed_identifier = pp.Forward()
-    # indexed_identifier <<= identifier + (
-    #         pp.Literal("[") + pp.common.integer + pp.Literal("]"))
-    # fn_call = (ident + lpar - Group(expr_list) + rpar).setParseAction(
-    #                     insert_fn_argcount_tuple
-    #                             )
-
-    # lbrack, rbrack = map(pp.Suppress, "[]")
-    # indexed_identifier = identifier + lbrack - pp.Group(pp.common.integer) + rbrack
-    # print(indexed_identifier)
+    lbracket, rbracket = map(pp.Suppress, "[]")
+    # TODO we need to define the indexing grammar more carefully, but
+    # this at least let's us match correct strings and raise an informative
+    # error
+    index_expr = pp.OneOrMore(
+        pp.common.number
+        | pp.Literal("*")
+        | pp.Literal(":")
+        | pp.Literal("-")
+        | pp.Literal(",")
+    )
+    indexed_identifier = pp.Group(vcf_identifier + (lbracket + index_expr + rbracket))
 
     name_mapper = _identity
     if map_vcf_identifiers:
         name_mapper = functools.partial(vcf_name_to_vcz_name, all_fields)
     identifier = vcf_identifier.set_parse_action(
         functools.partial(Identifier, name_mapper)
     )
+    indexed_identifier = indexed_identifier.set_parse_action(
+        functools.partial(IndexedIdentifier, name_mapper)
+    )
     comp_op = pp.oneOf("< = == > >= <= !=")
     filter_expression = pp.infix_notation(
-        constant | identifier,
+        constant | indexed_identifier | identifier,
         [
             ("-", 1, pp.OpAssoc.RIGHT, UnaryMinus),
             (pp.one_of("* /"), 2, pp.OpAssoc.LEFT, BinaryOperator),