Handle member access on Type[Any], fix #3098 (#3246)

* Handle member access on Type[Any], fix #3098

* Add test on member assignment

* Fallback to builtin.type attributes if possible when accessing members of Type[Any]

* Add type.pyi fixture to make test pass

Author: dmoisset

mypy/checkmember.py

@@ -176,6 +176,13 @@ def analyze_member_access(name: str,
         item = None
         if isinstance(typ.item, Instance):
             item = typ.item
+        elif isinstance(typ.item, AnyType):
+            fallback = builtin_type('builtins.type')
+            ignore_messages = msg.copy()
+            ignore_messages.disable_errors()
+            return analyze_member_access(name, fallback, node, is_lvalue, is_super,
+                                     is_operator, builtin_type, not_ready_callback,
+                                     ignore_messages, original_type=original_type, chk=chk)
         elif isinstance(typ.item, TypeVarType):
             if isinstance(typ.item.upper_bound, Instance):
                 item = typ.item.upper_bound

test-data/unit/check-classes.test

@@ -2051,6 +2051,25 @@ class X: pass
 foo(X)
 [out]
 
+[case testTypeUsingTypeCTypeAnyMember]
+from typing import Type, Any
+def foo(arg: Type[Any]):
+    x = arg.member_name
+    arg.new_member_name = 42
+    # Member access is ok and types as Any
+    reveal_type(x)  # E: Revealed type is 'Any'
+    # But Type[Any] is distinct from Any
+    y: int = arg  # E: Incompatible types in assignment (expression has type Type[Any], variable has type "int")
+[out]
+
+[case testTypeUsingTypeCTypeAnyMemberFallback]
+from typing import Type, Any
+def foo(arg: Type[Any]):
+    reveal_type(arg.__str__)  # E: Revealed type is 'def () -> builtins.str'
+    reveal_type(arg.mro())  # E: Revealed type is 'builtins.list[builtins.type]'
+[builtins fixtures/type.pyi]
+[out]
+
 [case testTypeUsingTypeCTypeNoArg]
 from typing import Type
 def foo(arg: Type):

test-data/unit/fixtures/type.pyi

@@ -0,0 +1,22 @@
+# builtins stub used in type-related test cases.
+
+from typing import builtinclass, Generic, TypeVar, List
+
+T = TypeVar('T')
+
+@builtinclass
+class object:
+    def __init__(self) -> None: pass
+    def __str__(self) -> 'str': pass
+
+class list(Generic[T]): pass
+
+class type:
+    def mro(self) -> List['type']: pass
+
+class tuple: pass
+class function: pass
+class bool: pass
+class int: pass
+class str: pass
+class unicode: pass