Method analyze_static_reference

mypy/checkexpr.py:399–445

This is the version of analyze_ref_expr() that doesn't do any deferrals. This function can be used by member access to "static" attributes. For example, when accessing module attributes in protocol checks, or accessing attributes of special kinds (like TypeAlias, Ty

(
        self,
        node: SymbolNode,
        ctx: Context,
        is_lvalue: bool,
        *,
        include_modules: bool = True,
        suppress_errors: bool = False,
    )

        return result

    def analyze_static_reference(
        self,
        node: SymbolNode,
        ctx: Context,
        is_lvalue: bool,
        *,
        include_modules: bool = True,
        suppress_errors: bool = False,
    ) -> Type:
        """
        This is the version of analyze_ref_expr() that doesn't do any deferrals.

        This function can be used by member access to "static" attributes. For example,
        when accessing module attributes in protocol checks, or accessing attributes of
        special kinds (like TypeAlias, TypeInfo, etc.) on an instance or class object.
        # TODO: merge with analyze_ref_expr() when we are confident about performance.
        """
        if isinstance(node, (Var, Decorator, OverloadedFuncDef)):
            return node.type or AnyType(TypeOfAny.special_form)
        elif isinstance(node, FuncDef):
            return function_type(node, self.named_type("builtins.function"))
        elif isinstance(node, TypeInfo):
            # Reference to a type object.
            if node.typeddict_type:
                # We special-case TypedDict, because they don't define any constructor.
                return self.typeddict_callable(node)
            elif node.fullname == "types.NoneType":
                # We special case NoneType, because its stub definition is not related to None.
                return TypeType(NoneType())
            else:
                return type_object_type(node)
        elif isinstance(node, TypeAlias):
            # Something that refers to a type alias appears in runtime context.
            # Note that we suppress bogus errors for alias redefinitions,
            # they are already reported in semanal.py.
            with self.msg.filter_errors() if suppress_errors else nullcontext():
                return self.alias_type_in_runtime_context(
                    node, ctx=ctx, alias_definition=is_lvalue
                )
        elif isinstance(node, TypeVarExpr):
            return self.named_type("typing.TypeVar")
        elif isinstance(node, (ParamSpecExpr, TypeVarTupleExpr)):
            return self.object_type()
        elif isinstance(node, MypyFile):
            # Reference to a module object.
            return self.module_type(node) if include_modules else AnyType(TypeOfAny.special_form)
        return AnyType(TypeOfAny.from_error)

    def analyze_var_ref(self, var: Var, context: Context) -> Type:
        if var.type: