Fix bug in colon seeker for multiline docstrings in Py < 3.8

Multiline docstrings in Python versions prior to 3.8 require rewinding through the body to seek the opening of the multiline docstring, which is the line after the close of the function def. The previous logic contained an indexing bug where it rewound prematurely at the beginning. This wasn't a problem for multiline docstrings with more than one line of content, but if the multiline docstring is empty or contained only one file then this jumped over the opening of the docstring and just keeps rewinding until an unrelated triple quote is found (or even all the way around to the starting point).

This indexing has been adjusted & the comments changed to better explain the flow of the seeker.

Off-by-one errors, you'll never be safe.

Author: sco1

CHANGELOG.md

@@ -6,6 +6,9 @@ Versions follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html) (`<ma
 * #98 Add `--dispatch-decorators` to support suppression of all errors from functions decorated by decorators such as `functools.singledispatch` and `functools.singledispatchmethod`.
 * #99 Add `--overload-decorators` to support generic aliasing of the `typing.overload` decorator.
 
+### Fixed
+* #106 Fix incorrect parsing of multiline docstrings with less than two lines of content, causing incorrect line numbers for yielded errors in Python versions prior to 3.8
+
 ## [v2.5.0]
 ### Added
 * #103 Add `--allow-untyped-nested` to suppress all errors from dynamically typted nested functions. A function is considered dynamically typed if it does not contain any type hints.

flake8_annotations/__init__.py

@@ -329,25 +329,25 @@ def colon_seeker(node: AST_FUNCTION_TYPES, lines: List[str]) -> Tuple[int, int]:
         if node.lineno == node.body[0].lineno:
             return Function._single_line_colon_seeker(node, lines[node.lineno - 1])
 
-        def_end_lineno = node.body[0].lineno - 1
-
         # With Python < 3.8, the function node includes the docstring & the body does not, so
         # we have rewind through any docstrings, if present, before looking for the def colon
+        # We should end up with lines[def_end_lineno - 1] having the colon
+        def_end_lineno = node.body[0].lineno
         if not PY_GTE_38:
-            # This list index is a little funky, since we've already subtracted 1 outside of this
-            # context, we can leave it as-is since it will index the list to the line prior to where
-            # the function node's body begins.
             # If the docstring is on one line then no rewinding is necessary.
-            n_triple_quotes = lines[def_end_lineno].count('"""')
+            n_triple_quotes = lines[def_end_lineno - 1].count('"""')
             if n_triple_quotes == 1:  # pragma: no branch
                 # Docstring closure, rewind until the opening is found & take the line prior
                 while True:
                     def_end_lineno -= 1
                     if '"""' in lines[def_end_lineno - 1]:
                         # Docstring has closed
-                        def_end_lineno -= 1
                         break
 
+        # Once we've gotten here, we've found the line where the docstring begins, so we have
+        # to step up one more line to get to the close of the def
+        def_end_lineno -= 1
+
         # Use str.rfind() to account for annotations on the same line, definition closure should
         # be the last : on the line
         def_end_col_offset = lines[def_end_lineno - 1].rfind(":") + 1

testing/test_cases/column_line_numbers_test_cases.py

@@ -139,7 +139,7 @@ def foo():  # 1
         ),
         error_locations=((1, 10),),
     ),
-    "multiline_docstring_only_summary": ParserTestCase(
+    "multiline_docstring_summary_at_open": ParserTestCase(
         src=dedent(
             """\
             def foo():                 # 1
@@ -150,4 +150,16 @@ def foo():                 # 1
         ),
         error_locations=((1, 10),),
     ),
+    "multiline_docstring_single_line_summary": ParserTestCase(
+        src=dedent(
+            """\
+            def foo():           # 1
+                \"\"\"           # 2
+                Some docstring.  # 3
+                \"\"\"           # 4
+                ...              # 5
+            """
+        ),
+        error_locations=((1, 10),),
+    ),
 }