Add a NoImplicit return type specifier.

[jakethesnake420]

Feature

Example:

cdef foo(): # Type: Any
  ...
  return ...

def bar() -> Any:
   if bool:
      return foo()
   else:
     var = foo() + 1
     # forgot to return so implicitly return None which is a valid Any type
     

mypy won't flag this as an error

Proposed functionality example:

cdef foo(): # Type: Any
  ...
  return ...

def bar() -> NoImplicit[Any]: # the new function specific NoImplicit type specifier
   if bool:
      return foo()
   else:
     var = foo() + foo()
     # forgot to return
     

mypy flags it. error: Implicit return [None]

sometimes when using cython functions it is difficult to specify the return type and sometimes the exact type is not important. I just want to specify that the return is not implicit for only some functions in a large codebase.

Its possible to cast the return type and specify but it seems overly complex and messy when does this way:

cdef foo():
  ...
  return ...
  
def bar() -> List[Union[int, bytes, float]], List[Union[str, int, bytes]
   if bool:
     return cast(List[Union[int, bytes, float]], List[Union[str, int, bytes], foo())
   else:
     var = foo() + foo()
     # forgot to return. error: Missing return statement  [return]

And then imagine how cluttered it gets after calling foo hundreds of times across the codebase

[KotlinIsland]

@jakethesnake420 here is a bit of a hack that achieves exactly what you want:

from typing import Any, Never

NoImplicitAny = Any | Never  # `Any | Any` would also work

def f() -> NoImplicitAny:  # error: Missing return statement  [return]
    if bool():
        return "amongus"

But I would Never recommend using Any, it's way too dangerous to use in real code. If the issue is that foo isn't typed and you are unable to edit it's definition, then you could wrap it with something that is typed, and use a TypeAlias for shorthand:

from somewhere import foo as real_foo

FooResult = list[int | bytes | float], list[str | int | bytes]
def foo() -> FooResult:
  return real_foo()

def bar() -> FooResult:
   if bool:
     return foo()  # can cast(FooResult, x) if needed
   else:
     var = foo() + foo()
     # forgot to return. error: Missing return statement  [return]

[hauntsaninja]

We can maybe just make this the default behaviour, let's see how #16102 goes

[hauntsaninja]

Closing this as won't fix, see #16102 (comment)

Maybe basedmypy can pick up the patch though ;-)