Blamed location is wrong when return type annotation is violated

[skogsbaer]

Given the following example:

def foo(flag: bool) -> int:
    print('Hello World')
    if flag:
        return 1
    else:
        return 'you stupid'

foo(False)

we get this error:

untypy.error.UntypyTypeError
given:    'you stupid'
expected: value of type int

context: foo(flag: bool) -> int
                            ^^^
declared at: test.py:1
  1 | def foo(flag: bool) -> int:
  2 |     print('Hello World')
  3 |     if flag:
  4 |         return 1
  5 |     else:    | ...

caused by: test.py:1
  1 | def foo(flag: bool) -> int:
  2 |     print('Hello World')
  3 |     if flag:
  4 |         return 1
  5 |     else:    | ...

I would expect that the line with return 'you stupid' is blamed for the error and therefor mentioned in the "caused by" part.

[skogsbaer]

I'm reopening thisn issue because an important case ist not covered: if the function's result type is declared as t (with t not being equal to None) and the function does not return a value, then the function declaration is blamed.

I think in this case, the last line of the function should be blamed. If this turns out to be too difficult, than we should at least cover the situation where the whole function body is implemented by a single pass, as shown in the following example:

def billigStrom(kwh: float) -> float:
    pass

This example is important in the lecture because students first write the function with pass as the body, then add tests, and then implement the function properly. If they hit the RUN button after adding tests but before implementing the function, they should get a meaningful error message.

[CodeSteak]

Should be doable. The (line-) span of the function should be easy to retrieve.