Use any primitive

Not sure if this is faster than a for loop.
Also fix typing.

Uses inplace update of unified var dicts

Author: boriel

src/arch/zx48k/peephole/pattern.py

@@ -69,22 +69,24 @@ class LinePattern(BasicLinePattern):
       push af
     and bounds $1 to 'af'
     Note that $$ matches against the $ sign
+
+    Returns whether the pattern matched (True) or not.
+    If it matched, the vars_ dictionary will be updated with unified vars.
     """
     __slots__ = 'line', 'vars', 're_pattern', 're', 'output'
 
-    def match(self, line: str, vars_: Optional[Dict[str, re.Pattern]] = None) -> Optional[Dict[str, re.Pattern]]:
+    def match(self, line: str, vars_: Dict[str, str]) -> bool:
         match = self.re.match(line)
         if match is None:
-            return None
+            return False
 
-        vars__ = {'_%s' % k[1:]: v for k, v in (vars_ or {}).items()}
-        for k, v in vars__.items():
-            if match.groupdict().get(k, v) != v:
-                return None
+        vars__ = {'_' + k[1:]: v for k, v in (vars_ or {}).items()}
+        mdict = match.groupdict()
+        if any(mdict.get(k, v) != v for k, v in vars__.items()):
+            return False
 
-        result = dict(vars_ or {})
-        result.update({'$' + k[1:]: v for k, v in match.groupdict().items()})
-        return result
+        vars_.update({'$' + k[1:]: v for k, v in match.groupdict().items()})
+        return True
 
     def __repr__(self):
         return repr(self.re)
@@ -104,7 +106,7 @@ def __init__(self, lines: List[str]):
     def __len__(self):
         return len(self.lines)
 
-    def match(self, instructions: List[str], start: int = 0) -> Optional[Dict[str, re.Pattern]]:
+    def match(self, instructions: List[str], start: int = 0) -> Optional[Dict[str, str]]:
         """ Given a list of instructions and a starting point,
         returns whether this pattern matches or not from such point
         onwards.
@@ -121,10 +123,9 @@ def match(self, instructions: List[str], start: int = 0) -> Optional[Dict[str, r
         if len(self) > len(lines):
             return None
 
-        univars: Optional[Dict[str, re.Pattern]] = {}
+        univars: Dict[str, str] = {}
         for patt, line in zip(self.patterns, lines):
-            univars = patt.match(line, vars_=univars)
-            if univars is None:
+            if not patt.match(line, vars_=univars):
                 return None
 
         return univars

tests/arch/zx48k/peephole/test_pattern.py

@@ -2,6 +2,8 @@
 
 import unittest
 
+from typing import Dict
+
 from src.arch.zx48k.peephole import pattern
 
 
@@ -38,35 +40,38 @@ def test_parse_comma_correctly(self):
 
 
 class TestLinePattern(unittest.TestCase):
+    def setUp(self) -> None:
+        self.vars: Dict[str, str] = {}
+
     def test_matches_parsed(self):
         patt = pattern.LinePattern('push $1')
-        match = patt.match('push af')
-        self.assertEqual(match, {'$1': 'af'})
+        self.assertTrue(patt.match('push af', self.vars))
+        self.assertEqual({'$1': 'af'}, self.vars)
 
     def test_no_match(self):
         patt = pattern.LinePattern('push $1')
-        match = patt.match('pop af')
-        self.assertIsNone(match)
+        self.assertFalse(patt.match('pop af', self.vars))
+        self.assertEqual({}, self.vars)
 
     def test_double_match(self):
         patt = pattern.LinePattern('push $1   $1')  # three spaces
-        match = patt.match('push af  af')  # only two spaces
-        self.assertEqual(match, {'$1': 'af'})
+        self.assertTrue(patt.match('push af  af', self.vars))  # only two spaces
+        self.assertEqual({'$1': 'af'}, self.vars)
 
     def test_match_two_patterns(self):
         patt = pattern.LinePattern('$2 $1')
-        match = patt.match('push af')
-        self.assertEqual(match, {'$1': 'af', '$2': 'push'})
+        self.assertTrue(patt.match('push af', self.vars))
+        self.assertEqual({'$1': 'af', '$2': 'push'}, self.vars)
 
     def test_match_two_patterns_twice(self):
         patt = pattern.LinePattern('$2 $1 $2 $1')
-        match = patt.match('push af push af')
-        self.assertEqual(match, {'$1': 'af', '$2': 'push'})
+        self.assertTrue(patt.match('push af push af', self.vars))
+        self.assertEqual({'$1': 'af', '$2': 'push'}, self.vars)
 
     def test_matches_empty_novars(self):
         patt = pattern.LinePattern('push af')
-        match = patt.match('push af')
-        self.assertEqual(match, {})
+        self.assertTrue(patt.match('push af', self.vars))
+        self.assertEqual({}, self.vars)
 
 
 class TestBlockPattern(unittest.TestCase):