Avoid indexing and tuple unpacking of LinePart instances

sebastinas · sebastinas · commit 95539ccdf8cc · 2022-01-09T16:11:20.000+01:00
diff --git a/bpython/autocomplete.py b/bpython/autocomplete.py
@@ -481,7 +481,7 @@ def matches(
         if current_dict_parts is None:
             return None
 
-        _, _, dexpr = current_dict_parts
+        dexpr = current_dict_parts.word
         try:
             obj = safe_eval(dexpr, locals_)
         except EvaluationError:
diff --git a/bpython/importcompletion.py b/bpython/importcompletion.py
@@ -135,22 +135,22 @@ def complete(self, cursor_offset: int, line: str) -> Optional[Set[str]]:
             if import_import is not None:
                 # `from a import <b|>` completion
                 matches = self.module_matches(
-                    import_import[2], from_import_from[2]
+                    import_import.word, from_import_from.word
                 )
                 matches.update(
-                    self.attr_matches(import_import[2], from_import_from[2])
+                    self.attr_matches(import_import.word, from_import_from.word)
                 )
             else:
                 # `from <a|>` completion
-                matches = self.module_attr_matches(from_import_from[2])
-                matches.update(self.module_matches(from_import_from[2]))
+                matches = self.module_attr_matches(from_import_from.word)
+                matches.update(self.module_matches(from_import_from.word))
             return matches
 
         cur_import = current_import(cursor_offset, line)
         if cur_import is not None:
             # `import <a|>` completion
-            matches = self.module_matches(cur_import[2])
-            matches.update(self.module_attr_matches(cur_import[2]))
+            matches = self.module_matches(cur_import.word)
+            matches.update(self.module_attr_matches(cur_import.word))
             return matches
         else:
             return None
diff --git a/bpython/line.py b/bpython/line.py
@@ -130,15 +130,14 @@ def current_object(cursor_offset: int, line: str) -> Optional[LinePart]:
     match = current_word(cursor_offset, line)
     if match is None:
         return None
-    start, end, word = match
     s = ".".join(
         m.group(1)
-        for m in _current_object_re.finditer(word)
-        if m.end(1) + start < cursor_offset
+        for m in _current_object_re.finditer(match.word)
+        if m.end(1) + match.start < cursor_offset
     )
     if not s:
         return None
-    return LinePart(start, start + len(s), s)
+    return LinePart(match.start, match.start + len(s), s)
 
 
 _current_object_attribute_re = LazyReCompile(r"([\w_][\w0-9_]*)[.]?")
@@ -152,12 +151,13 @@ def current_object_attribute(
     match = current_word(cursor_offset, line)
     if match is None:
         return None
-    start, end, word = match
-    matches = _current_object_attribute_re.finditer(word)
+    matches = _current_object_attribute_re.finditer(match.word)
     next(matches)
     for m in matches:
-        if m.start(1) + start <= cursor_offset <= m.end(1) + start:
-            return LinePart(m.start(1) + start, m.end(1) + start, m.group(1))
+        if m.start(1) + match.start <= cursor_offset <= m.end(1) + match.start:
+            return LinePart(
+                m.start(1) + match.start, m.end(1) + match.start, m.group(1)
+            )
     return None
 
 
@@ -266,11 +266,8 @@ def current_dotted_attribute(
 ) -> Optional[LinePart]:
     """The dotted attribute-object pair before the cursor"""
     match = current_word(cursor_offset, line)
-    if match is None:
-        return None
-    start, end, word = match
-    if "." in word[1:]:
-        return LinePart(start, end, word)
+    if match is not None and "." in match.word[1:]:
+        return match
     return None
 
 
diff --git a/bpython/repl.py b/bpython/repl.py
@@ -239,6 +239,8 @@ def __init__(self) -> None:
         self.orig_line = ""
         # class describing the current type of completion
         self.completer: Optional[autocomplete.BaseCompletionType] = None
+        self.start: Optional[int] = None
+        self.end: Optional[int] = None
 
     def __nonzero__(self) -> bool:
         """MatchesIterator is False when word hasn't been replaced yet"""
@@ -277,16 +279,15 @@ def cur_line(self) -> Tuple[int, str]:
         made"""
         return self.substitute(self.current())
 
-    def substitute(self, match) -> Tuple[int, str]:
+    def substitute(self, match: str) -> Tuple[int, str]:
         """Returns a cursor offset and line with match substituted in"""
         assert self.completer is not None
 
-        start, end, _ = self.completer.locate(
-            self.orig_cursor_offset, self.orig_line
-        )  # type: ignore
+        lp = self.completer.locate(self.orig_cursor_offset, self.orig_line)
+        assert lp is not None
         return (
-            start + len(match),
-            self.orig_line[:start] + match + self.orig_line[end:],
+            lp.start + len(match),
+            self.orig_line[: lp.start] + match + self.orig_line[lp.stop :],
         )
 
     def is_cseq(self) -> bool:
@@ -331,9 +332,11 @@ def update(
         self.matches = matches
         self.completer = completer
         self.index = -1
-        self.start, self.end, self.current_word = self.completer.locate(
-            self.orig_cursor_offset, self.orig_line
-        )  # type: ignore
+        lp = self.completer.locate(self.orig_cursor_offset, self.orig_line)
+        assert lp is not None
+        self.start = lp.start
+        self.end = lp.stop
+        self.current_word = lp.word
 
     def clear(self) -> None:
         self.matches = []
diff --git a/bpython/test/test_autocomplete.py b/bpython/test/test_autocomplete.py
@@ -12,6 +12,7 @@
     has_jedi = False
 
 from bpython import autocomplete
+from bpython.line import LinePart
 
 glob_function = "glob.iglob"
 
@@ -114,7 +115,9 @@ def test_locate_fails_when_not_in_string(self):
         self.assertEqual(self.completer.locate(4, "abcd"), None)
 
     def test_locate_succeeds_when_in_string(self):
-        self.assertEqual(self.completer.locate(4, "a'bc'd"), (2, 4, "bc"))
+        self.assertEqual(
+            self.completer.locate(4, "a'bc'd"), LinePart(2, 4, "bc")
+        )
 
     def test_issue_491(self):
         self.assertNotEqual(self.completer.matches(9, '"a[a.l-1]'), None)
diff --git a/bpython/test/test_line_properties.py b/bpython/test/test_line_properties.py
@@ -1,7 +1,9 @@
 import re
+from typing import Optional, Tuple
 import unittest
 
 from bpython.line import (
+    LinePart,
     current_word,
     current_dict_key,
     current_dict,
@@ -25,7 +27,7 @@ def cursor(s):
     return cursor_offset, line
 
 
-def decode(s):
+def decode(s: str) -> Tuple[Tuple[int, str], Optional[LinePart]]:
     """'a<bd|c>d' -> ((3, 'abcd'), (1, 3, 'bdc'))"""
 
     if not s.count("|") == 1:
@@ -41,24 +43,26 @@ def decode(s):
     assert len(d) in [1, 3], "need all the parts just once! %r" % d
 
     if "<" in d:
-        return (d["|"], s), (d["<"], d[">"], s[d["<"] : d[">"]])
+        return (d["|"], s), LinePart(d["<"], d[">"], s[d["<"] : d[">"]])
     else:
         return (d["|"], s), None
 
 
-def line_with_cursor(cursor_offset, line):
+def line_with_cursor(cursor_offset: int, line: str) -> str:
     return line[:cursor_offset] + "|" + line[cursor_offset:]
 
 
-def encode(cursor_offset, line, result):
+def encode(cursor_offset: int, line: str, result: Optional[LinePart]) -> str:
     """encode(3, 'abdcd', (1, 3, 'bdc')) -> a<bd|c>d'
 
     Written for prettier assert error messages
     """
     encoded_line = line_with_cursor(cursor_offset, line)
     if result is None:
         return encoded_line
-    start, end, value = result
+    start = result.start
+    end = result.stop
+    value = result.word
     assert line[start:end] == value
     if start < cursor_offset:
         encoded_line = encoded_line[:start] + "<" + encoded_line[start:]
@@ -107,19 +111,25 @@ def test_I(self):
         self.assertEqual(cursor("asd|fgh"), (3, "asdfgh"))
 
     def test_decode(self):
-        self.assertEqual(decode("a<bd|c>d"), ((3, "abdcd"), (1, 4, "bdc")))
-        self.assertEqual(decode("a|<bdc>d"), ((1, "abdcd"), (1, 4, "bdc")))
-        self.assertEqual(decode("a<bdc>d|"), ((5, "abdcd"), (1, 4, "bdc")))
+        self.assertEqual(
+            decode("a<bd|c>d"), ((3, "abdcd"), LinePart(1, 4, "bdc"))
+        )
+        self.assertEqual(
+            decode("a|<bdc>d"), ((1, "abdcd"), LinePart(1, 4, "bdc"))
+        )
+        self.assertEqual(
+            decode("a<bdc>d|"), ((5, "abdcd"), LinePart(1, 4, "bdc"))
+        )
 
     def test_encode(self):
-        self.assertEqual(encode(3, "abdcd", (1, 4, "bdc")), "a<bd|c>d")
-        self.assertEqual(encode(1, "abdcd", (1, 4, "bdc")), "a|<bdc>d")
-        self.assertEqual(encode(4, "abdcd", (1, 4, "bdc")), "a<bdc|>d")
-        self.assertEqual(encode(5, "abdcd", (1, 4, "bdc")), "a<bdc>d|")
+        self.assertEqual(encode(3, "abdcd", LinePart(1, 4, "bdc")), "a<bd|c>d")
+        self.assertEqual(encode(1, "abdcd", LinePart(1, 4, "bdc")), "a|<bdc>d")
+        self.assertEqual(encode(4, "abdcd", LinePart(1, 4, "bdc")), "a<bdc|>d")
+        self.assertEqual(encode(5, "abdcd", LinePart(1, 4, "bdc")), "a<bdc>d|")
 
     def test_assert_access(self):
         def dumb_func(cursor_offset, line):
-            return (0, 2, "ab")
+            return LinePart(0, 2, "ab")
 
         self.func = dumb_func
         self.assertAccess("<a|b>d")
diff --git a/bpython/test/test_repl.py b/bpython/test/test_repl.py
@@ -10,8 +10,12 @@
 from unittest import mock
 
 from bpython import config, repl, cli, autocomplete
-from bpython.test import MagicIterMock, FixLanguageTestCase as TestCase
-from bpython.test import TEST_CONFIG
+from bpython.line import LinePart
+from bpython.test import (
+    MagicIterMock,
+    FixLanguageTestCase as TestCase,
+    TEST_CONFIG,
+)
 
 
 pypy = "PyPy" in sys.version
@@ -99,7 +103,7 @@ def test_update(self):
 
         newmatches = ["string", "str", "set"]
         completer = mock.Mock()
-        completer.locate.return_value = (0, 1, "s")
+        completer.locate.return_value = LinePart(0, 1, "s")
         self.matches_iterator.update(1, "s", newmatches, completer)
 
         newslice = islice(newmatches, 0, 3)
@@ -108,7 +112,7 @@ def test_update(self):
 
     def test_cur_line(self):
         completer = mock.Mock()
-        completer.locate.return_value = (
+        completer.locate.return_value = LinePart(
             0,
             self.matches_iterator.orig_cursor_offset,
             self.matches_iterator.orig_line,
