[conflict] Allow assignment of types with Nones without explicit annotation

mypy/checker.py

@@ -2698,22 +2698,46 @@ def infer_operator_assignment_method(type: Type, operator: str) -> Tuple[bool, s
 def is_valid_inferred_type(typ: Type) -> bool:
     """Is an inferred type valid?
 
-    Examples of invalid types include the None type or a type with a None component.
+    Examples of invalid types include the None type or List[None].
+
+    When not doing strict Optional checking, all types containing None are
+    invalid.  When doing strict Optional checking, only types that are
+    incompletely defined (i.e. contain UninhabitedType) or can be turned into
+    PartialTypes are invalid.
     """
     if is_same_type(typ, NoneTyp()):
         # With strict Optional checking, we *may* eventually infer NoneTyp, but
         # we only do that if we can't infer a specific Optional type.  This
         # resolution happens in leave_partial_types when we pop a partial types
         # scope.
         return False
+    return is_valid_inferred_type_component(typ)
+
+
+def is_valid_inferred_type_component(typ: Type) -> bool:
+    """Is this part of a type a valid inferred type?
+
+    In strict Optional mode this excludes bare None types, as otherwise every
+    type containing None would be invalid.
+    """
+    if not experiments.STRICT_OPTIONAL:
+        if is_same_type(typ, NoneTyp()):
+            return False
     if is_same_type(typ, UninhabitedType()):
         return False
     elif isinstance(typ, Instance):
-        for arg in typ.args:
-            if not is_valid_inferred_type(arg):
-                return False
+        fullname = typ.type.fullname()
+        if ((fullname == 'builtins.list' or
+             fullname == 'builtins.set' or
+             fullname == 'builtins.dict') and
+                all(isinstance(t, (NoneTyp, UninhabitedType)) for t in typ.args)):
+            return False
+        else:
+            for arg in typ.args:
+                if not is_valid_inferred_type_component(arg):
+                    return False
     elif isinstance(typ, TupleType):
         for item in typ.items:
-            if not is_valid_inferred_type(item):
+            if not is_valid_inferred_type_component(item):
                 return False
     return True

test-data/unit/check-optional.test

@@ -428,3 +428,10 @@ x + 1
 [out]
 main:2: note: In module imported here:
 tmp/a.py:3: error: Unsupported left operand type for + (some union)
+
+[case testOptionalNonPartialTypeWithNone]
+from typing import Generator
+def f() -> Generator[str, None, None]: pass
+x = f()
+l = [f()]
+[builtins fixtures/list.pyi]