Merge branch 'master' into fix_abs_path

Author: noobCodec

mypy-requirements.txt

@@ -4,4 +4,4 @@ typing_extensions>=4.6.0
 mypy_extensions>=1.0.0
 pathspec>=0.9.0
 tomli>=1.1.0; python_version<'3.11'
-librt>=0.6.0
+librt>=0.6.2

mypy/checker.py

@@ -3424,7 +3424,11 @@ def check_assignment(
                             and lvalue_type is not None
                         ):
                             lvalue.node.type = remove_instance_last_known_values(lvalue_type)
-                elif self.options.allow_redefinition_new and lvalue_type is not None:
+                elif (
+                    self.options.allow_redefinition_new
+                    and lvalue_type is not None
+                    and not isinstance(lvalue_type, PartialType)
+                ):
                     # TODO: Can we use put() here?
                     self.binder.assign_type(lvalue, lvalue_type, lvalue_type)
 

mypy/semanal.py

@@ -2455,7 +2455,7 @@ def tvar_defs_from_tvars(
                 self.fail(
                     message_registry.TYPE_VAR_REDECLARED_IN_NESTED_CLASS.format(name), context
                 )
-            tvar_def = self.tvar_scope.bind_new(name, tvar_expr)
+            tvar_def = self.tvar_scope.bind_new(name, tvar_expr, self.fail, context)
             if last_tvar_name_with_default is not None and not tvar_def.has_default():
                 self.msg.tvar_without_default_type(
                     tvar_def.name, last_tvar_name_with_default, context
@@ -2473,19 +2473,18 @@ def get_and_bind_all_tvars(self, type_exprs: list[Expression]) -> list[TypeVarLi
         a simplified version of the logic we use for ClassDef bases. We duplicate
         some amount of code, because it is hard to refactor common pieces.
         """
-        tvars = []
+        tvars: dict[str, tuple[TypeVarLikeExpr, Expression]] = {}
         for base_expr in type_exprs:
             try:
                 base = self.expr_to_unanalyzed_type(base_expr)
             except TypeTranslationError:
                 # This error will be caught later.
                 continue
-            base_tvars = self.find_type_var_likes(base)
-            tvars.extend(base_tvars)
-        tvars = remove_dups(tvars)  # Variables are defined in order of textual appearance.
+            for name, expr in self.find_type_var_likes(base):
+                tvars.setdefault(name, (expr, base_expr))
         tvar_defs = []
-        for name, tvar_expr in tvars:
-            tvar_def = self.tvar_scope.bind_new(name, tvar_expr)
+        for name, (tvar_expr, context) in tvars.items():
+            tvar_def = self.tvar_scope.bind_new(name, tvar_expr, self.fail, context)
             tvar_defs.append(tvar_def)
         return tvar_defs
 

mypy/server/update.py

@@ -631,6 +631,8 @@ def restore(ids: list[str]) -> None:
 
     # Find any other modules brought in by imports.
     changed_modules = [(st.id, st.xpath) for st in new_modules]
+    for m in new_modules:
+        manager.import_map[m.id] = set(m.dependencies + m.suppressed)
 
     # If there are multiple modules to process, only process one of them and return
     # the remaining ones to the caller.

mypy/tvar_scope.py

@@ -1,40 +1,79 @@
 from __future__ import annotations
 
+from collections.abc import Callable
+from typing_extensions import TypeAlias as _TypeAlias
+
 from mypy.nodes import (
+    Context,
     ParamSpecExpr,
     SymbolTableNode,
     TypeVarExpr,
     TypeVarLikeExpr,
     TypeVarTupleExpr,
 )
 from mypy.types import (
+    AnyType,
     ParamSpecFlavor,
     ParamSpecType,
+    TrivialSyntheticTypeTranslator,
+    Type,
+    TypeAliasType,
+    TypeOfAny,
     TypeVarId,
     TypeVarLikeType,
     TypeVarTupleType,
     TypeVarType,
 )
-from mypy.typetraverser import TypeTraverserVisitor
-
-
-class TypeVarLikeNamespaceSetter(TypeTraverserVisitor):
-    """Set namespace for all TypeVarLikeTypes types."""
 
-    def __init__(self, namespace: str) -> None:
-        self.namespace = namespace
+FailFunc: _TypeAlias = Callable[[str, Context], None]
 
-    def visit_type_var(self, t: TypeVarType) -> None:
-        t.id.namespace = self.namespace
-        super().visit_type_var(t)
 
-    def visit_param_spec(self, t: ParamSpecType) -> None:
-        t.id.namespace = self.namespace
-        return super().visit_param_spec(t)
+class TypeVarLikeDefaultFixer(TrivialSyntheticTypeTranslator):
+    """Set namespace for all TypeVarLikeTypes types."""
 
-    def visit_type_var_tuple(self, t: TypeVarTupleType) -> None:
-        t.id.namespace = self.namespace
-        super().visit_type_var_tuple(t)
+    def __init__(
+        self,
+        scope: TypeVarLikeScope,
+        fail_func: FailFunc,
+        source_tv: TypeVarLikeExpr,
+        context: Context,
+    ) -> None:
+        self.scope = scope
+        self.fail_func = fail_func
+        self.source_tv = source_tv
+        self.context = context
+        super().__init__()
+
+    def visit_type_var(self, t: TypeVarType) -> Type:
+        existing = self.scope.get_binding(t.fullname)
+        if existing is None:
+            self._report_unbound_tvar(t)
+            return AnyType(TypeOfAny.from_error)
+        return existing
+
+    def visit_param_spec(self, t: ParamSpecType) -> Type:
+        existing = self.scope.get_binding(t.fullname)
+        if existing is None:
+            self._report_unbound_tvar(t)
+            return AnyType(TypeOfAny.from_error)
+        return existing
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> Type:
+        existing = self.scope.get_binding(t.fullname)
+        if existing is None:
+            self._report_unbound_tvar(t)
+            return AnyType(TypeOfAny.from_error)
+        return existing
+
+    def visit_type_alias_type(self, t: TypeAliasType) -> Type:
+        return t
+
+    def _report_unbound_tvar(self, tvar: TypeVarLikeType) -> None:
+        self.fail_func(
+            f"Type variable {tvar.name} referenced in the default"
+            f" of {self.source_tv.name} is unbound",
+            self.context,
+        )
 
 
 class TypeVarLikeScope:
@@ -98,15 +137,25 @@ def new_unique_func_id(self) -> TypeVarId:
         self.func_id -= 1
         return TypeVarId(self.func_id)
 
-    def bind_new(self, name: str, tvar_expr: TypeVarLikeExpr) -> TypeVarLikeType:
+    def bind_new(
+        self, name: str, tvar_expr: TypeVarLikeExpr, fail_func: FailFunc, context: Context
+    ) -> TypeVarLikeType:
         if self.is_class_scope:
             self.class_id += 1
             i = self.class_id
         else:
             self.func_id -= 1
             i = self.func_id
         namespace = self.namespace
-        tvar_expr.default.accept(TypeVarLikeNamespaceSetter(namespace))
+
+        # Defaults may reference other type variables. That is only valid when the
+        # referenced variable is already in scope (textually precedes the definition we're
+        # processing now).
+        default = tvar_expr.default.accept(
+            TypeVarLikeDefaultFixer(
+                self, fail_func=fail_func, source_tv=tvar_expr, context=context
+            )
+        )
 
         if isinstance(tvar_expr, TypeVarExpr):
             tvar_def: TypeVarLikeType = TypeVarType(
@@ -115,7 +164,7 @@ def bind_new(self, name: str, tvar_expr: TypeVarLikeExpr) -> TypeVarLikeType:
                 id=TypeVarId(i, namespace=namespace),
                 values=tvar_expr.values,
                 upper_bound=tvar_expr.upper_bound,
-                default=tvar_expr.default,
+                default=default,
                 variance=tvar_expr.variance,
                 line=tvar_expr.line,
                 column=tvar_expr.column,
@@ -127,7 +176,7 @@ def bind_new(self, name: str, tvar_expr: TypeVarLikeExpr) -> TypeVarLikeType:
                 id=TypeVarId(i, namespace=namespace),
                 flavor=ParamSpecFlavor.BARE,
                 upper_bound=tvar_expr.upper_bound,
-                default=tvar_expr.default,
+                default=default,
                 line=tvar_expr.line,
                 column=tvar_expr.column,
             )
@@ -138,7 +187,7 @@ def bind_new(self, name: str, tvar_expr: TypeVarLikeExpr) -> TypeVarLikeType:
                 id=TypeVarId(i, namespace=namespace),
                 upper_bound=tvar_expr.upper_bound,
                 tuple_fallback=tvar_expr.tuple_fallback,
-                default=tvar_expr.default,
+                default=default,
                 line=tvar_expr.line,
                 column=tvar_expr.column,
             )

mypy/typeanal.py

@@ -1580,7 +1580,9 @@ def analyze_callable_type(self, t: UnboundType) -> Type:
                     # below happens at very early stage.
                     variables = []
                     for name, tvar_expr in self.find_type_var_likes(callable_args):
-                        variables.append(self.tvar_scope.bind_new(name, tvar_expr))
+                        variables.append(
+                            self.tvar_scope.bind_new(name, tvar_expr, self.fail_func, t)
+                        )
                     maybe_ret = self.analyze_callable_args_for_paramspec(
                         callable_args, ret_type, fallback
                     ) or self.analyze_callable_args_for_concatenate(
@@ -1852,7 +1854,7 @@ def bind_function_type_variables(
                 assert var_node, "Binding for function type variable not found within function"
                 var_expr = var_node.node
                 assert isinstance(var_expr, TypeVarLikeExpr)
-                binding = self.tvar_scope.bind_new(var.name, var_expr)
+                binding = self.tvar_scope.bind_new(var.name, var_expr, self.fail_func, fun_type)
                 defs.append(binding)
             return tuple(defs), has_self_type
         typevars, has_self_type = self.infer_type_variables(fun_type)
@@ -1865,7 +1867,7 @@ def bind_function_type_variables(
             if not self.tvar_scope.allow_binding(tvar.fullname):
                 err_msg = message_registry.TYPE_VAR_REDECLARED_IN_NESTED_CLASS.format(name)
                 self.fail(err_msg.value, defn, code=err_msg.code)
-            binding = self.tvar_scope.bind_new(name, tvar)
+            binding = self.tvar_scope.bind_new(name, tvar, self.fail_func, fun_type)
             defs.append(binding)
 
         return tuple(defs), has_self_type

mypy/typeshed/stubs/librt/librt/base64.pyi

@@ -1 +1,4 @@
 def b64encode(s: bytes) -> bytes: ...
+def b64decode(s: bytes | str) -> bytes: ...
+def urlsafe_b64encode(s: bytes) -> bytes: ...
+def urlsafe_b64decode(s: bytes | str) -> bytes: ...

mypyc/irbuild/expression.py

@@ -504,12 +504,12 @@ def translate_super_method_call(builder: IRBuilder, expr: CallExpr, callee: Supe
         if decl.kind == FUNC_CLASSMETHOD:
             vself = builder.primitive_op(type_op, [vself], expr.line)
         elif builder.fn_info.is_generator:
-            # For generator classes, the self target is the 6th value
+            # For generator classes, the self target is the 7th value
             # in the symbol table (which is an ordered dict). This is sort
             # of ugly, but we can't search by name since the 'self' parameter
             # could be named anything, and it doesn't get added to the
             # environment indexes.
-            self_targ = list(builder.symtables[-1].values())[6]
+            self_targ = list(builder.symtables[-1].values())[7]
             vself = builder.read(self_targ, builder.fn_info.fitem.line)
         arg_values.insert(0, vself)
         arg_kinds.insert(0, ARG_POS)

mypyc/irbuild/prepare.py

@@ -842,6 +842,10 @@ def adjust_generator_classes_of_methods(mapper: Mapper) -> None:
                     if subcls is None:
                         # Override could be of a different type, so we can't make assumptions.
                         precise_ret_type = False
+                    elif class_ir.is_trait:
+                        # Give up on traits. We could possibly have an abstract base class
+                        # for generator return types to make this use precise types.
+                        precise_ret_type = False
                     else:
                         for s in subcls:
                             if name in s.method_decls:

mypyc/irbuild/targets.py

@@ -20,6 +20,9 @@ def __init__(self, register: Register) -> None:
         self.register = register
         self.type = register.type
 
+    def __repr__(self) -> str:
+        return f"AssignmentTargetRegister({self.register.name})"
+
 
 class AssignmentTargetIndex(AssignmentTarget):
     """base[index] as assignment target"""
@@ -31,6 +34,9 @@ def __init__(self, base: Value, index: Value) -> None:
         #       lvalue type in mypy and use a better type to avoid unneeded boxing.
         self.type = object_rprimitive
 
+    def __repr__(self) -> str:
+        return f"AssignmentTargetIndex({self.base!r}, {self.index!r})"
+
 
 class AssignmentTargetAttr(AssignmentTarget):
     """obj.attr as assignment target"""
@@ -48,10 +54,17 @@ def __init__(self, obj: Value, attr: str, can_borrow: bool = False) -> None:
             self.obj_type = object_rprimitive
             self.type = object_rprimitive
 
+    def __repr__(self) -> str:
+        can_borrow_str = ", can_borrow=True" if self.can_borrow else ""
+        return f"AssignmentTargetAttr({self.obj!r}.{self.attr}{can_borrow_str})"
+
 
 class AssignmentTargetTuple(AssignmentTarget):
     """x, ..., y as assignment target"""
 
     def __init__(self, items: list[AssignmentTarget], star_idx: int | None = None) -> None:
         self.items = items
         self.star_idx = star_idx
+
+    def __repr__(self) -> str:
+        return f"AssignmentTargetTuple({self.items}, {self.star_idx})"