Add tests, comments, and doctrings

python · gvanrossum · Nov 3, 2016 · Oct 27, 2016 · Oct 28, 2016 · Oct 28, 2016
commit 56b7ae75963caeb45f87e6d44a98e9e76dc6b258
diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
@@ -1376,12 +1376,15 @@ def visit_type_application(self, tapp: TypeApplication) -> Type:
         return AnyType()
 
     def visit_type_alias_expr(self, alias: TypeAliasExpr) -> Type:
+        """ Get type of a type alias (could be generic) in a runtime expression."""
         item = alias.type
         if isinstance(item, (Instance, TupleType, UnionType, CallableType)):
             item = self.replace_tvars_any(item)
         if isinstance(item, Instance):
             tp = type_object_type(item.type, self.named_type)
         else:
+            # TODO: Better error reporting, need to find line for
+            # unsubscribed generic aliases
             if alias.line > 0:
                 self.chk.fail('Invalid type alias in runtime expression: {}'
                               .format(item), alias)
@@ -1393,6 +1396,10 @@ def visit_type_alias_expr(self, alias: TypeAliasExpr) -> Type:
         return AnyType()
 
     def replace_tvars_any(self, tp: Type) -> Type:
+        """ Replace all unbound type variables with Any if an alias is used in
+        a runtime expression. Basically, this function finishes what could not be done
+        in similar funtion from typeanal.py.
+        """
         if not isinstance(tp, (Instance, UnionType, TupleType, CallableType)):
             return tp
         typ_args = (tp.args if isinstance(tp, Instance) else

diff --git a/mypy/typeanal.py b/mypy/typeanal.py
@@ -158,6 +158,8 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
                 if exp_len == 0 and act_len == 0:
                     return override
                 if act_len != exp_len:
+                    # TODO: Detect wrong type variable numer for unused aliases
+                    # (although it could be difficult at this stage, see comment below)
                     self.fail('Bad number of arguments for type alias, expected: %s, given: %s'
                               % (exp_len, act_len), t)
                     return t
@@ -203,6 +205,9 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
             return AnyType()
 
     def get_type_var_names(self, tp: Type) -> List[str]:
+        """ Get all type variable names that are present in a generic type alias
+        in order of textual appearance (recursively, if needed).
+        """
         tvars = []  # type: List[str]
         if not isinstance(tp, (Instance, UnionType, TupleType, CallableType)):
             return tvars
@@ -235,6 +240,9 @@ def get_tvar_name(self, t: Type) -> Optional[str]:
         return None
 
     def replace_alias_tvars(self, tp: Type, vars: List[str], subs: List[Type]) -> Type:
+        """ Replace type variables in a generic type alias tp with substitutions subs.
+        Length of subs should be already checked.
+        """
         if not isinstance(tp, (Instance, UnionType, TupleType, CallableType)) or not subs:
             return tp
         typ_args = (tp.args if isinstance(tp, Instance) else
@@ -244,9 +252,12 @@ def replace_alias_tvars(self, tp: Type, vars: List[str], subs: List[Type]) -> Ty
         for i, arg in enumerate(typ_args):
             tvar = self.get_tvar_name(arg)
             if tvar and tvar in vars:
+                # Perform actual substitution...
                 new_args[i] = subs[vars.index(tvar)]
             else:
+                # ...recursively, if needed.
                 new_args[i] = self.replace_alias_tvars(arg, vars, subs)
+        # Create a copy with type vars replaced.
         if isinstance(tp, Instance):
             return Instance(tp.type, new_args, tp.line)
         if isinstance(tp, TupleType):

diff --git a/test-data/unit/check-generics.test b/test-data/unit/check-generics.test
@@ -794,13 +794,34 @@ fun2([('x', 'x')], 'x') # E: Type argument 1 of "fun2" has incompatible value "s
 [builtins fixtures/list.pyi]
 
 [case testGenericTypeAliasesImporting]
-from typing import TypeVar, Generic
+from typing import TypeVar
+from a import Node, TupledNode
 T = TypeVar('T')
-class Node(Generic[T]):
-    def __init__(self, x: T) -> None:
-        ...
 
-[out]
+n = None # type: TupledNode[int]
+n.x = 1
+n.y = (1, 1)
+n.y = 'x' # E: Bad type
+
+def f(x: Node[T, T]) -> TupledNode[T]:
+    return Node(x.x, (x.x, x.x))
+
+f(1) # E: Argument 1 to "f" has incompatible type "int"; expected Node[None, None]
+f(Node(1, 'x')) # E: Cannot infer type argument 1 of "f"
+reveal_type(Node('x', 'x')) # E: Revealed type is 'a.Node[builtins.str*, builtins.str*]'
+
+[file a.py]
+from typing import TypeVar, Generic, Tuple
+T = TypeVar('T')
+S = TypeVar('S')
+class Node(Generic[T, S]):
+    def __init__(self, x: T, y: S) -> None:
+        self.x = x
+        self.y = y
+
+TupledNode = Node[T, Tuple[T, T]]
+
+[builtins fixtures/list.pyi]
 
 [case testGenericTypeAliasesRuntimeExpressionsInstance]
 from typing import TypeVar, Generic