Mypy infers types roughly from top to bottom. This usually makes reasoning about inferred types easier and the implementation is also relatively straightforward. However, there are cases like your example this has undesirable results.

You can add a type annotation to make the error go away:

from typing import Union, Dict, List
def g() -> List[Union[str, int]]:
    x = ['a']  # type: List[Union[str, int]]
    x += [1]
    return x

def f() -> Dict[str, Union[str, int]]:
    d = {'a': 'a'}  # type: Dict[str, Union[str, int]]
    d['b'] = 1
    return d

Modifying type inference to take the return type into consideration in cases like this would be hard and would complicate the relatively simple and predictable (once you understand a few principles) model that mypy currently uses. However, it might be useful to detect some cases like this and give a better error message. Potential better message:

test.py: note: In function "g":
test.py:3: note: Perhaps a type annotation is missing here? Suggestion: List[Union[str, int]]
test.py:4: error: List item 0 has incompatible type "int"
test.py:5: error: Incompatible return value type (got List[str], expected List[Union[str, int]])

As it's unlikely that type inference will change for now, I'll update the title to consider a better error message.

If #2542 and #2543 get merged I've got a not-so-nice PR to make that includes this kind of error message (without the suggestion, though, I'm still working on that)

I will take a look at this.

Should this note only cover the case when the object type conflicts with the return type or should it also cover the following:

from typing import List, Any
def g() -> List[Any]:
    x = ['a']
    x += [1]
    return x

which currently only outputs

test.py:4: error: List item 0 has incompatible type "int"

I am planning on proceeding with only enhancing the message when it conflicts with the return and not cover the above case.