Allow typing members in annotations without imports

Author: KotlinIsland

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## [Unreleased]
 ### Added
 - Unions in output messages show with new syntax
+- When `__future__.annotations`, all `typing`s are usable without imports 
 
 ## [1.0.0]
 ### Added

mypy/main.py

@@ -500,13 +500,21 @@ def add_invertible_flag(flag: str,
         help="Show program's version number and exit",
         stdout=stdout)
 
-    general_group.add_argument(
+    based_group = parser.add_argument_group(
+        title='Based functionality arguments')
+    based_group.add_argument(
         '--write-baseline', action="store_true",
         help="Create an error baseline from the result of this execution")
-    general_group.add_argument(
+    based_group.add_argument(
         '--baseline-file', action='store',
         help="Use baseline info in the given file"
              "(defaults to '{}')".format(defaults.BASELINE_FILE))
+    based_group.add_argument(
+        '--disable-implicit-typing-globals', action="store_false",
+        dest="implicit_typing_globals",
+        help="Disallow using members from `typing` in annotations without imports."
+    )
+
     config_group = parser.add_argument_group(
         title='Config file',
         description="Use a config file instead of command line arguments. "

mypy/options.py

@@ -103,8 +103,10 @@ def __init__(self) -> None:
         # File names, directory names or subpaths to avoid checking
         self.exclude: List[str] = []
 
+        # Based options
         self.write_baseline = False
         self.baseline_file = defaults.BASELINE_FILE
+        self.implicit_typing_globals = True
 
         # disallow_any options
         self.disallow_any_generics = True

mypy/semanal.py

@@ -2636,7 +2636,7 @@ def check_and_set_up_type_alias(self, s: AssignmentStmt) -> bool:
 
         pep_613 = False
         if s.unanalyzed_type is not None and isinstance(s.unanalyzed_type, UnboundType):
-            lookup = self.lookup(s.unanalyzed_type.name, s, suppress_errors=True)
+            lookup = self.lookup(s.unanalyzed_type.name, s, suppress_errors=True, annotation=True)
             if lookup and lookup.fullname in ("typing.TypeAlias", "typing_extensions.TypeAlias"):
                 pep_613 = True
         if s.unanalyzed_type is not None and not pep_613:
@@ -3351,15 +3351,15 @@ def check_classvar(self, s: AssignmentStmt) -> None:
     def is_classvar(self, typ: Type) -> bool:
         if not isinstance(typ, UnboundType):
             return False
-        sym = self.lookup_qualified(typ.name, typ)
+        sym = self.lookup_qualified(typ.name, typ, annotation=True)
         if not sym or not sym.node:
             return False
         return sym.node.fullname == 'typing.ClassVar'
 
     def is_final_type(self, typ: Optional[Type]) -> bool:
         if not isinstance(typ, UnboundType):
             return False
-        sym = self.lookup_qualified(typ.name, typ)
+        sym = self.lookup_qualified(typ.name, typ, annotation=True)
         if not sym or not sym.node:
             return False
         return sym.node.fullname in ('typing.Final', 'typing_extensions.Final')
@@ -4205,7 +4205,8 @@ def visit_await_expr(self, expr: AwaitExpr) -> None:
     #
 
     def lookup(self, name: str, ctx: Context,
-               suppress_errors: bool = False) -> Optional[SymbolTableNode]:
+               suppress_errors: bool = False,
+               annotation: bool = False) -> Optional[SymbolTableNode]:
         """Look up an unqualified (no dots) name in all active namespaces.
 
         Note that the result may contain a PlaceholderNode. The caller may
@@ -4261,6 +4262,22 @@ def lookup(self, name: str, ctx: Context,
                     return None
                 node = table[name]
                 return node
+        # 6. based
+        if annotation and (
+            self.is_future_flag_set("annotations")
+            or self.options.python_version >= (3, 11)
+        ):
+            # 6a. typing
+            table = self.modules["typing"].names
+            if name in table:
+                node = table[name]
+                return node
+            # 6b. implicit T
+            if name == "T":
+                return SymbolTableNode(
+                    GDEF,
+                    TypeVarExpr("T", "T", [], self.object_type())
+                )
         # Give up.
         if not implicit_name and not suppress_errors:
             self.name_not_defined(name, ctx)
@@ -4329,7 +4346,8 @@ def is_defined_in_current_module(self, fullname: Optional[str]) -> bool:
         return module_prefix(self.modules, fullname) == self.cur_mod_id
 
     def lookup_qualified(self, name: str, ctx: Context,
-                         suppress_errors: bool = False) -> Optional[SymbolTableNode]:
+                         suppress_errors: bool = False,
+                         annotation: bool = False) -> Optional[SymbolTableNode]:
         """Lookup a qualified name in all activate namespaces.
 
         Note that the result may contain a PlaceholderNode. The caller may
@@ -4341,10 +4359,10 @@ def lookup_qualified(self, name: str, ctx: Context,
         """
         if '.' not in name:
             # Simple case: look up a short name.
-            return self.lookup(name, ctx, suppress_errors=suppress_errors)
+            return self.lookup(name, ctx, suppress_errors=suppress_errors, annotation=annotation)
         parts = name.split('.')
         namespace = self.cur_mod_id
-        sym = self.lookup(parts[0], ctx, suppress_errors=suppress_errors)
+        sym = self.lookup(parts[0], ctx, suppress_errors=suppress_errors, annotation=annotation)
         if sym:
             for i in range(1, len(parts)):
                 node = sym.node

mypy/semanal_shared.py

@@ -34,7 +34,8 @@ class SemanticAnalyzerCoreInterface:
 
     @abstractmethod
     def lookup_qualified(self, name: str, ctx: Context,
-                         suppress_errors: bool = False) -> Optional[SymbolTableNode]:
+                         suppress_errors: bool = False
+                         , annotation: bool = False) -> Optional[SymbolTableNode]:
         raise NotImplementedError
 
     @abstractmethod

mypy/typeanal.py

@@ -169,7 +169,7 @@ def visit_unbound_type(self, t: UnboundType, defining_literal: bool = False) ->
         return typ
 
     def visit_unbound_type_nonoptional(self, t: UnboundType, defining_literal: bool) -> Type:
-        sym = self.lookup_qualified(t.name, t)
+        sym = self.lookup_qualified(t.name, t, annotation=True)
         if sym is not None:
             node = sym.node
             if isinstance(node, PlaceholderNode):
@@ -565,7 +565,7 @@ def visit_callable_type(self, t: CallableType, nested: bool = True) -> Type:
 
     def anal_type_guard(self, t: Type) -> Optional[Type]:
         if isinstance(t, UnboundType):
-            sym = self.lookup_qualified(t.name, t)
+            sym = self.lookup_qualified(t.name, t, annotation=True)
             if sym is not None and sym.node is not None:
                 return self.anal_type_guard_arg(t, sym.node.fullname)
         # TODO: What if it's an Instance? Then use t.type.fullname?
@@ -1260,7 +1260,7 @@ def visit_unbound_type(self, t: UnboundType) -> TypeVarLikeList:
                     node = n
                     name = base
         if node is None:
-            node = self.lookup(name, t)
+            node = self.lookup(name, t, annotation=True)
         if node and isinstance(node.node, TypeVarLikeExpr) and (
                 self.include_bound_tvars or self.scope.get_binding(node) is None):
             assert isinstance(node.node, TypeVarLikeExpr)