None and non-type value as the type annotation

[dai-akita-7554]

I have never used the type annotation, or typehinting, of python so that I could not understand why this line was run without syntax error:

some_object: some_object.do_something()

At the line, some_object.do_something() is executed depending on where the line is in the code.

It turned out that it seemed to be accidentally modified from

if some_object: some_object.do_something()

which did not make a type annotation but just utilized if statement to check None.

I realized that the modified line was interpreted as a type annotation without assignment. Whether some_object.do_something() is executed depends on where the line is in the code, according to the issue of PEP526. In the section "Capturing the declared types at runtime" of the issue, a (bad) example where a function call is specified as the type is shown:

def side_effect():
    print("Hello world")
def foo():
    a: side_effect()
    a = 12
    return a
foo()

(This results in not printing "Hello world")

PEP526 shows an example in which variables are type-annotated with strings:

alice: 'well done' = 'A+'
bob: 'what a shame' = 'F-'

and says

These stored annotations might be used for other purposes, but with this PEP we explicitly recommend type hinting as the preferred use of annotations.

PEP526 also says that it rejected the proposal "Do not evaluate annotations, treat them as strings". While I guess the feature of the evaluation is necessary for generics or something, I have no idea to use values which are not type as the type annotation. It would be more useful to detect lines like

some_object: some_object.do_something()

ifsome_object: some_object.do_something()

as syntax errors if some_object.do_something() is not a type. It would be also useful to detect errors when some_object.do_something() is None,

I would appreciate it if you posted some comments on None and non-type value as the type annotation.

[Akuli]

detect lines like some_object: some_object.do_something() as syntax errors if some_object.do_something() is not a type

How should the interpreter detect whether something is a type or not? A type hint can look like foo or foo.bar[baz] or even "foo.bar[baz]", for example. Maybe check for parentheses at the end, as function call syntax is currently not used in typing?

This check isn't something that the typing community can do though. It would need to be done at cpython. But my experience with adding checks for common errors in cpython is that:

• They are reluctant to add any additional checks into the compiler, even if the error is very common and potentially hard to debug.
• If one maintainer thinks that something is a bad idea, it's enough to stall the progress.

[Akuli]

I think no matter cpython does, this could break backwards compatibility for someone. Because it is possible to use type annotations for anything you want, and not just for running a type checker, it's possible that someone somewhere uses a type annotation that looks like foo() and evaluates to None.

[dai-akita-7554]

Thank you very much for your comment. I read your post abount warning or with interest and understood the hurdle to pursuade the comunity.

My idea is just to show errors or warnings in runtime if the evaluated type is not type (isinstance(some_object.do_something(), type)). I feel it is not so compilated but it may need more effort than I imagine. I didn't think of usage like "foo.bar[baz]". In addition, the dev teams would regard the profit little as I encountered the case first time in years of using python. The or problem must be more frequent. And yes, this idea has compatibility problem. Raising warnings instead of errors should be better.

[JelleZijlstra]

Valid type annotations aren't necessarily instances of type.

[Gobot1234]

If you want something like this checked I know that pyright reports illegal annotation targets.