Merge branch 'master' into for-filter

Author: BobTheBuidler

docs/source/error_code_list2.rst

@@ -32,7 +32,7 @@ Example:
 
     # mypy: disallow-any-generics
 
-    # Error: Missing type parameters for generic type "list"  [type-arg]
+    # Error: Missing type arguments for generic type "list"  [type-arg]
     def remove_dups(items: list) -> list:
         ...
 

mypy/build.py

@@ -2180,7 +2180,8 @@ def __init__(
             self.dep_hashes = {
                 k: v for (k, v) in zip(self.meta.dependencies, self.meta.dep_hashes)
             }
-            self.error_lines = self.meta.error_lines
+            # Only copy `error_lines` if the module is not silently imported.
+            self.error_lines = [] if self.ignore_all else self.meta.error_lines
             if temporary:
                 self.load_tree(temporary=True)
             if not manager.use_fine_grained_cache():

mypy/checker.py

@@ -8394,43 +8394,42 @@ def conditional_types(
 
     if isinstance(proper_type, AnyType):
         return proposed_type, current_type
-    elif isinstance(proposed_type, AnyType):
+    if isinstance(proposed_type, AnyType):
         # We don't really know much about the proposed type, so we shouldn't
         # attempt to narrow anything. Instead, we broaden the expr to Any to
         # avoid false positives
         return proposed_type, default
-    elif not any(type_range.is_upper_bound for type_range in proposed_type_ranges) and (
-        # concrete subtypes
-        is_proper_subtype(current_type, proposed_type, ignore_promotions=True)
+    if not any(type_range.is_upper_bound for type_range in proposed_type_ranges):
+        # concrete subtype
+        if is_proper_subtype(current_type, proposed_type, ignore_promotions=True):
+            return default, UninhabitedType()
+
         # structural subtypes
-        or (
-            (
-                isinstance(proposed_type, CallableType)
-                or (isinstance(proposed_type, Instance) and proposed_type.type.is_protocol)
+        if (
+            isinstance(proposed_type, CallableType)
+            or (isinstance(proposed_type, Instance) and proposed_type.type.is_protocol)
+        ) and is_subtype(current_type, proposed_type, ignore_promotions=True):
+            # Note: It's possible that current_type=`Any | Proto` while proposed_type=`Proto`
+            #  so we cannot return `Never` for the else branch
+            remainder = restrict_subtype_away(
+                current_type,
+                default if default is not None else proposed_type,
+                consider_runtime_isinstance=consider_runtime_isinstance,
             )
-            and is_subtype(current_type, proposed_type, ignore_promotions=True)
-        )
-    ):
-        # Expression is always of one of the types in proposed_type_ranges
-        return default, UninhabitedType()
-    elif not is_overlapping_types(current_type, proposed_type, ignore_promotions=True):
+            return default, remainder
+    if not is_overlapping_types(current_type, proposed_type, ignore_promotions=True):
         # Expression is never of any type in proposed_type_ranges
         return UninhabitedType(), default
-    else:
-        # we can only restrict when the type is precise, not bounded
-        proposed_precise_type = UnionType.make_union(
-            [
-                type_range.item
-                for type_range in proposed_type_ranges
-                if not type_range.is_upper_bound
-            ]
-        )
-        remaining_type = restrict_subtype_away(
-            current_type,
-            proposed_precise_type,
-            consider_runtime_isinstance=consider_runtime_isinstance,
-        )
-        return proposed_type, remaining_type
+    # we can only restrict when the type is precise, not bounded
+    proposed_precise_type = UnionType.make_union(
+        [type_range.item for type_range in proposed_type_ranges if not type_range.is_upper_bound]
+    )
+    remaining_type = restrict_subtype_away(
+        current_type,
+        proposed_precise_type,
+        consider_runtime_isinstance=consider_runtime_isinstance,
+    )
+    return proposed_type, remaining_type
 
 
 def conditional_types_to_typemaps(

mypy/checkstrformat.py

@@ -145,10 +145,10 @@ def __init__(
         self.key = m_dict.get("key")
 
         # Replace unmatched optional groups with empty matches (for convenience).
-        self.conv_type = m_dict.get("type", "")
-        self.flags = m_dict.get("flags", "")
-        self.width = m_dict.get("width", "")
-        self.precision = m_dict.get("precision", "")
+        self.conv_type = m_dict.get("type") or ""
+        self.flags = m_dict.get("flags") or ""
+        self.width = m_dict.get("width") or ""
+        self.precision = m_dict.get("precision") or ""
 
         # Used only for str.format() calls (it may be custom for types with __format__()).
         self.format_spec = m_dict.get("format_spec")

mypy/constraints.py

@@ -816,7 +816,7 @@ def visit_instance(self, template: Instance) -> list[Constraint]:
         if isinstance(actual, Overloaded) and actual.fallback is not None:
             actual = actual.fallback
         if isinstance(actual, TypedDictType):
-            actual = actual.as_anonymous().fallback
+            actual = actual.create_anonymous_fallback()
         if isinstance(actual, LiteralType):
             actual = actual.fallback
         if isinstance(actual, Instance):

mypy/meet.py

@@ -1263,7 +1263,7 @@ def typed_dict_mapping_overlap(
     key_type, value_type = get_proper_types(other.args)
 
     # TODO: is there a cleaner way to get str_type here?
-    fallback = typed.as_anonymous().fallback
+    fallback = typed.create_anonymous_fallback()
     str_type = fallback.type.bases[0].args[0]  # typing._TypedDict inherits Mapping[str, object]
 
     # Special case: a TypedDict with no required keys overlaps with an empty dict.

mypy/message_registry.py

@@ -176,7 +176,7 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
     "Access to generic instance variables via class is ambiguous"
 )
 GENERIC_CLASS_VAR_ACCESS: Final = "Access to generic class variables is ambiguous"
-BARE_GENERIC: Final = "Missing type parameters for generic type {}"
+BARE_GENERIC: Final = "Missing type arguments for generic type {}"
 IMPLICIT_GENERIC_ANY_BUILTIN: Final = (
     'Implicit generic "Any". Use "{}" and specify generic parameters'
 )

mypy/plugins/default.py

@@ -479,8 +479,9 @@ def typed_dict_update_signature_callback(ctx: MethodSigContext) -> CallableType:
         arg_type = get_proper_type(signature.arg_types[0])
         if not isinstance(arg_type, TypedDictType):
             return signature
-        arg_type = arg_type.as_anonymous()
-        arg_type = arg_type.copy_modified(required_keys=set())
+        arg_type = ctx.type.copy_modified(
+            fallback=arg_type.create_anonymous_fallback(), required_keys=set()
+        )
         if ctx.args and ctx.args[0]:
             if signature.name in _TP_DICT_MUTATING_METHODS:
                 # If we want to mutate this object in place, we need to set this flag,

mypy/semanal.py

@@ -3224,6 +3224,12 @@ def visit_import_all(self, i: ImportAll) -> None:
                     self.add_imported_symbol(
                         name, node, context=i, module_public=True, module_hidden=False
                     )
+                    # This is a (minimalist) copy of the logic in visit_import_from(), we need
+                    # to clean-up any remaining placeholders by replacing them with Var(Any).
+                    if isinstance(node.node, PlaceholderNode) and self.final_iteration:
+                        self.add_unknown_imported_symbol(
+                            name, i, target_name=None, module_public=True, module_hidden=False
+                        )
 
         else:
             # Don't add any dummy symbols for 'from x import *' if 'x' is unknown.

mypy/types.py

@@ -3080,11 +3080,11 @@ def is_final(self) -> bool:
     def is_anonymous(self) -> bool:
         return self.fallback.type.fullname in TPDICT_FB_NAMES
 
-    def as_anonymous(self) -> TypedDictType:
+    def create_anonymous_fallback(self) -> Instance:
         if self.is_anonymous():
-            return self
+            return self.fallback
         assert self.fallback.type.typeddict_type is not None
-        return self.fallback.type.typeddict_type.as_anonymous()
+        return self.fallback.type.typeddict_type.create_anonymous_fallback()
 
     def copy_modified(
         self,
@@ -3110,10 +3110,6 @@ def copy_modified(
             required_keys &= set(item_names)
         return TypedDictType(items, required_keys, readonly_keys, fallback, self.line, self.column)
 
-    def create_anonymous_fallback(self) -> Instance:
-        anonymous = self.as_anonymous()
-        return anonymous.fallback
-
     def names_are_wider_than(self, other: TypedDictType) -> bool:
         return len(other.items.keys() - self.items.keys()) == 0