Parsing content for notices

This plugin provides some helpers for parsing content for notices.

Parsing Mypy output

Parsing input content

It can be tedious to create test content with expected notices that keep track of which line number notices should be on. Especially when changing a test such that all the line numbers suddenly change.

To make this easier, the plugin provides the ability to parse a file to find extra comments that indicate where notices are expected.

To make this happen requires doing something like the following:

from pytest_typing_runner import parse, protocols

file_notices: protocols.FileNotices = ...
original: str = ...

transformed, file_notices = parse.FileContent().parse(original, into=file_notices)

The idea being that when creating the files, the transformed is used to write to the file, and when creating expectations, the file_notices are used to say what notices are expected. And raise an error if the second parse creates more transformations.

There are two forms this can take (both active in the default FileParser) as follows:

Per line instructions

For example:

a: int = 1
model: type[Leader] = Follow1
# ^ REVEAL[one] ^ wat
# ^ ERROR(arg-type) ^ an error
# ^ ERROR(arg-type) ^ more
# ^ ERROR(assignment) ^ another

a: int = "asdf"
# ^ ERROR(assignment) ^ other
# ^ REVEAL ^ stuff
# ^ NOTE ^ one
# ^ NOTE ^ two
# ^ NOTE ^ three
# ^ ERROR(assignment) ^ another
# ^ NOTE ^ four

def other() -> None:
    return 1
    # ^ ERROR(var-annotated)<regex> ^ Need type Blah for "Stuff".+
    # ^ NAME[hi] ^

if True:
    reveal_type(found)
    # ^ ERROR(arg-type)[other] ^ hi
    # ^ REVEAL[other] ^ asdf
    # ^ REVEAL ^ asdf2
    # ^ ERROR(arg-type)[other] ^ hi

In this example, we are using NAME, ERROR, WARNING, REVEAL and NOTE instructions.

These match the form of:

# ^ INSTRUCTION(error-type)[name]<match> ^ msg

Where INSTRUCTION is one of:

NAME
REVEAL
ERROR
NOTE
WARNING

And error-type is only valid for ERROR instructions.

The name is a way of registered a name for that line.

And match says how to compare msg in this notice to the msg in the notice that was received for this file and line.

The default match options are plain, regex and glob.

Where REVEAL notes are extra special in that they will change the line such that it becomes a reveal_type(...)

If the line is already a reveal_type then it is not changed
If the line is an assignment, a line is added that does a reveal_type on the assigned variable
Otherwise the line is wrapped in a reveal_type(...) call at the appropriate level of indentation

So after transformation the above file becomes

a: int = 1
model: type[Leader] = Follow1
reveal_type(model)
# ^ REVEAL[one] ^ wat
# ^ ERROR(arg-type) ^ an error
# ^ ERROR(arg-type) ^ more
# ^ ERROR(assignment) ^ another

a: int = "asdf"
# ^ ERROR(assignment) ^ other
reveal_type(a)
# ^ REVEAL ^ stuff
# ^ NOTE ^ one
# ^ NOTE ^ two
# ^ NOTE ^ three
# ^ ERROR(assignment) ^ another
# ^ NOTE ^ four

def other() -> None:
    return 1
    # ^ ERROR(var-annotated) ^ Need type Blah for "Stuff".+
    # ^ NAME[hi] ^

if True:
    reveal_type(found)
    # ^ ERROR(arg-type)[other] ^ hi
    # ^ REVEAL[other] ^ asdf
    # ^ REVEAL ^ asdf2
    # ^ ERROR(arg-type)[other] ^ hi

And the following notices are expected:

severity=note:: Revealed type is "wat"
severity=error[arg-type]:: an error
severity=error[arg-type]:: more
severity=error[assignment]:: another
severity=error[assignment]:: other
severity=note:: Revealed type is "stuff"
severity=note:: one
severity=note:: two
severity=note:: three
severity=error[assignment]:: another
severity=note:: four
severity=error[var-annotated]:: Need type Blah for "Stuff".+
severity=error[arg-type]:: hi
severity=note:: Revealed type is "asdf"
severity=note:: Revealed type is "asdf2"
severity=error[arg-type]:: hi

Mypy stubtest style

For example:

a: int = 1
model: type[Leader] = Follow1
reveal_type(model) # N: Revealed type is "one" # E: an error  [arg-type] # E: more  [arg-type] # E: another  [assignment]

a: int = "asdf" # E: other  [assignment]
reveal_type(a) # N: Revealed type is "stuff" # N: one # N: two # N: three # E: another  [assignment] # N: four

def other() -> None:
    return 1 # E<regex>: Need type Blah for "Stuff".+  [var-annotated]

if True:
    reveal_type(found) # E: hi  [arg-type] # N: Revealed type is "asdf" # N: Revealed type is "asdf2" # E: hi  [arg-type]

Comments found on lines with preceding code will be split by un-escaped hashes and be interpreted as a command if starts with # N:, # E: or # W: In this example, we are using NAME, ERROR, REVEAL and NOTE

An optional column number may also be provided after the action. For example # E:20.

There may also be a <match> after the instruction. For example: # N<regex>: Revealed type is "[^"]+" where the string within the brackets may be plain for plain equality check, regex for using the msg as a regular expression, or glob for using the msg as a glob.

The rest of the comment till the next un-escaped hash will be considered the message for the notice. The E instruction will also look for the [error-type] at the end of the message.