[lit] Change regex filter to ignore case

[yln]

Summary

Make regex filter --filter=REGEX option more lenient via
re.IGNORECASE.

[yln]

I am accepting this myself because it is a small and reasonable (to me) change. Please voice your concerns if you have any.

llvm/utils/lit/lit/cl_arguments.py

selection_group.add_argument("--shuffle",
             action="store_true",
             default=False)
     selection_group.add_argument("-i", "--incremental",
             help="Run modified and failing tests first (updates mtimes)",
             action="store_true",
             default=False)
     selection_group.add_argument("--filter",
             metavar="REGEX",
+            type=_case_insensitive_regex,
             help="Only run tests with paths matching the given regular expression",
             default=os.environ.get("LIT_FILTER"))
     selection_group.add_argument("--num-shards",
             dest="numShards",
             metavar="M",
             help="Split testsuite into M pieces and only run one",
             type=_positive_int,
             default=os.environ.get("LIT_NUM_SHARDS"))
if opts.numShards or opts.runShard:
         if not opts.numShards or not opts.runShard:
             parser.error("--num-shards and --run-shard must be used together")
         if opts.runShard > opts.numShards:
             parser.error("--run-shard must be between 1 and --num-shards (inclusive)")
 
     return opts
 
 def _positive_int(arg):
+    desc = "requires positive integer, but found '{}'"
     try:
         n = int(arg)
     except ValueError:
-        raise _arg_error('positive integer', arg)
+        raise _error(desc, arg)
     if n <= 0:
-        raise _arg_error('positive integer', arg)
+        raise _error(desc, arg)
     return n
 
-def _arg_error(desc, arg):
-    msg = "requires %s, but found '%s'" % (desc, arg)
+def _case_insensitive_regex(arg):
+    import re
+    try:
+        return re.compile(arg, re.IGNORECASE)
+    except re.error as reason:
+        raise _error("invalid regular expression: '{}', {}", arg, reason)
+
+def _error(desc, *args):
+    msg = desc.format(*args)
     return argparse.ArgumentTypeError(msg)

llvm/utils/lit/lit/main.py

 #!/usr/bin/env python
 
 """
 lit - LLVM Integrated Tester.
 
 See lit.pod for more information.
 """
 
 from __future__ import absolute_import
 import os
 import platform
 import random
-import re
 import sys
 import time
 import tempfile
 import shutil
 from xml.sax.saxutils import quoteattr
 
 import lit.cl_arguments
 import lit.discovery
def main_with_tmp(builtinParameters):
     if opts.showSuites or opts.showTests:
         print_suites_or_tests(run, opts)
         return
 
     # Select and order the tests.
     numTotalTests = len(run.tests)
 
     if opts.filter:
-        filter_tests(run, opts)
+        run.tests = [t for t in run.tests if opts.filter.search(t.getFullName())]
 
     order_tests(run, opts)
 
     # Then optionally restrict our attention to a shard of the tests.
     if (opts.numShards is not None) or (opts.runShard is not None):
         num_tests = len(run.tests)
         # Note: user views tests and shard numbers counting from 1.
         test_ixs = range(opts.runShard - 1, num_tests, opts.numShards)
if opts.showTests:
         for ts,ts_tests in suitesAndTests:
             ts_tests.sort(key = lambda test: test.path_in_suite)
             for test in ts_tests:
                 print('  %s' % (test.getFullName(),))
 
     # Exit.
     sys.exit(0)
 
-def filter_tests(run, opts):
-    try:
-        rex = re.compile(opts.filter)
-    except:
-        parser.error("invalid regular expression for --filter: %r" % (
-                opts.filter))
-    run.tests = [result_test for result_test in run.tests
-                    if rex.search(result_test.getFullName())]
-
 def order_tests(run, opts):
     if opts.shuffle:
         random.shuffle(run.tests)
     elif opts.incremental:
         run.tests.sort(key = by_mtime, reverse = True)
     else:
         run.tests.sort(key = lambda t: (not t.isEarlyTest(), t.getFullName()))
 

llvm/utils/lit/tests/selecting.py

 # RUN: %{lit} %{inputs}/discovery | FileCheck --check-prefix=CHECK-BASIC %s
 # CHECK-BASIC: Testing: 5 tests
 
-# Check that regex-filtering works
+# Check that regex-filtering works, is case-insensitive, and can be configured via env var.
 #
 # RUN: %{lit} --filter 'o[a-z]e' %{inputs}/discovery | FileCheck --check-prefix=CHECK-FILTER %s
+# RUN: %{lit} --filter 'O[A-Z]E' %{inputs}/discovery | FileCheck --check-prefix=CHECK-FILTER %s
+# RUN: env LIT_FILTER='o[a-z]e' %{lit} %{inputs}/discovery | FileCheck --check-prefix=CHECK-FILTER %s
 # CHECK-FILTER: Testing: 2 of 5 tests
 
-# Check that regex-filtering based on environment variables work.
-#
-# RUN: env LIT_FILTER='o[a-z]e' %{lit} %{inputs}/discovery | FileCheck --check-prefix=CHECK-FILTER-ENV %s
-# CHECK-FILTER-ENV: Testing: 2 of 5 tests
-
-
 # Check that maximum counts work
 #
 # RUN: %{lit} --max-tests 3 %{inputs}/discovery | FileCheck --check-prefix=CHECK-MAX %s
 # CHECK-MAX: Testing: 3 of 5 tests
 
 
 # Check that sharding partitions the testsuite in a way that distributes the
 # rounding error nicely (i.e. 5/3 => 2 2 1, not 1 1 3 or whatever)