Merge branch 'with-lvalue'

Author: JukkaL

mypy/checker.py

@@ -1638,12 +1638,12 @@ def visit_decorator(self, e: Decorator) -> Type:
 
     def visit_with_stmt(self, s: WithStmt) -> Type:
         echk = self.expr_checker
-        for expr, name in zip(s.expr, s.name):
+        for expr, target in zip(s.expr, s.target):
             ctx = self.accept(expr)
             enter = echk.analyse_external_member_access('__enter__', ctx, expr)
             obj = echk.check_call(enter, [], [], expr)[0]
-            if name:
-                self.check_assignment(name, self.temp_node(obj, expr))
+            if target:
+                self.check_assignment(target, self.temp_node(obj, expr))
             exit = echk.analyse_external_member_access('__exit__', ctx, expr)
             arg = self.temp_node(AnyType(), expr)
             echk.check_call(exit, [arg] * 3, [nodes.ARG_POS] * 3, expr)

mypy/nodes.py

@@ -701,13 +701,13 @@ def accept(self, visitor: NodeVisitor[T]) -> T:
 
 class WithStmt(Node):
     expr = Undefined(List[Node])
-    name = Undefined(List['NameExpr'])
+    target = Undefined(List[Node])
     body = Undefined(Block)
 
-    def __init__(self, expr: List[Node], name: List['NameExpr'],
+    def __init__(self, expr: List[Node], target: List[Node],
                  body: Block) -> None:
         self.expr = expr
-        self.name = name
+        self.target = target
         self.body = body
 
     def accept(self, visitor: NodeVisitor[T]) -> T:

mypy/parse.py

@@ -967,23 +967,22 @@ def parse_try_stmt(self) -> Node:
 
     def parse_with_stmt(self) -> WithStmt:
         self.expect('with')
-        expr = List[Node]()
-        name = List[NameExpr]()
+        exprs = List[Node]()
+        targets = List[Node]()
         while True:
-            e = self.parse_expression(precedence[','])
+            expr = self.parse_expression(precedence[','])
             if self.current_str() == 'as':
                 self.expect('as')
-                n = self.parse_name_expr()
+                target = self.parse_expression(precedence[','])
             else:
-                n = None
-            expr.append(e)
-            name.append(n)
+                target = None
+            exprs.append(expr)
+            targets.append(target)
             if self.current_str() != ',':
                 break
             self.expect(',')
         body, _ = self.parse_block()
-        node = WithStmt(expr, name, body)
-        return node
+        return WithStmt(exprs, targets, body)
 
     def parse_print_stmt(self) -> PrintStmt:
         self.expect('print')

mypy/semanal.py

@@ -1310,7 +1310,7 @@ def analyze_try_stmt(self, s: TryStmt, visitor: NodeVisitor,
     def visit_with_stmt(self, s: WithStmt) -> None:
         for e in s.expr:
             e.accept(self)
-        for n in s.name:
+        for n in s.target:
             if n:
                 self.analyse_lvalue(n)
         self.visit_block(s.body)
@@ -1876,7 +1876,7 @@ def visit_for_stmt(self, s: ForStmt) -> None:
         self.sem.analyse_lvalue(s.index, add_global=True)
 
     def visit_with_stmt(self, s: WithStmt) -> None:
-        for n in s.name:
+        for n in s.target:
             if n:
                 self.sem.analyse_lvalue(n, add_global=True)
 

mypy/strconv.py

@@ -266,8 +266,8 @@ def visit_with_stmt(self, o):
         a = []
         for i in range(len(o.expr)):
             a.append(('Expr', [o.expr[i]]))
-            if o.name[i]:
-                a.append(('Name', [o.name[i]]))
+            if o.target[i]:
+                a.append(('Target', [o.target[i]]))
         return self.dump(a + [o.body], o)
 
     def visit_print_stmt(self, o):

mypy/test/data/check-statements.test

@@ -804,6 +804,17 @@ with A[B]() as b, A[C]() as c:
     b = c # E: Incompatible types in assignment (expression has type "C", variable has type "B")
     c = b # E: Incompatible types in assignment (expression has type "B", variable has type "C")
 
+[case testWithStmtAndComplexTarget]
+from typing import Tuple
+class A:
+    def __enter__(self) -> Tuple[int, str]: pass
+    def __exit__(self, x, y, z): pass
+with A() as (a, b):
+    a = 1
+    b = ''
+    a = b # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+[builtins fixtures/tuple.py]
+
 
 -- Chained assignment
 -- ------------------

mypy/test/data/parse.test

@@ -1630,7 +1630,7 @@ MypyFile:1(
         NameExpr(open)
         Args(
           StrExpr(foo))))
-    Name(
+    Target(
       NameExpr(f))
     Block:1(
       PassStmt:2())))
@@ -2154,11 +2154,11 @@ MypyFile:1(
   WithStmt:1(
     Expr(
       NameExpr(x))
-    Name(
+    Target(
       NameExpr(y))
     Expr(
       NameExpr(a))
-    Name(
+    Target(
       NameExpr(b))
     Block:1(
       PassStmt:2()))
@@ -3117,3 +3117,17 @@ MypyFile:1(
           IntExpr(2))
         NameExpr(x)
         NameExpr(y)))))
+
+[case testComplexWithLvalue]
+with x as y.z: pass
+[out]
+MypyFile:1(
+  WithStmt:1(
+    Expr(
+      NameExpr(x))
+    Target(
+      MemberExpr:1(
+        NameExpr(y)
+        z))
+    Block:1(
+      PassStmt:1())))

mypy/test/data/semanal-errors.test

@@ -1306,3 +1306,8 @@ x = Undefined(Function[[], None])
 [out]
 main, line 2: Name 'Function' is not defined
 main, line 2: (Did you mean 'typing.Callable'?)
+
+[case testInvalidWithTarget]
+def f(): pass
+with f() as 1: pass  # E: Invalid assignment target
+[out]

mypy/test/data/semanal-statements.test

@@ -630,7 +630,7 @@ MypyFile:1(
   WithStmt:1(
     Expr(
       NameExpr(object [builtins.object]))
-    Name(
+    Target(
       NameExpr(x* [__main__.x]))
     Block:1(
       ExpressionStmt:2(
@@ -648,7 +648,7 @@ MypyFile:1(
       WithStmt:2(
         Expr(
           NameExpr(f [__main__.f]))
-        Name(
+        Target(
           NameExpr(x* [l]))
         Block:2(
           ExpressionStmt:3(
@@ -671,11 +671,11 @@ MypyFile:1(
   WithStmt:3(
     Expr(
       NameExpr(object [builtins.object]))
-    Name(
+    Target(
       NameExpr(a* [__main__.a]))
     Expr(
       NameExpr(object [builtins.object]))
-    Name(
+    Target(
       NameExpr(b* [__main__.b]))
     Block:3(
       PassStmt:4())))

mypy/traverser.py

@@ -139,8 +139,8 @@ def visit_try_stmt(self, o: TryStmt) -> T:
     def visit_with_stmt(self, o: WithStmt) -> T:
         for i in range(len(o.expr)):
             o.expr[i].accept(self)
-            if o.name[i] is not None:
-                o.name[i].accept(self)
+            if o.target[i] is not None:
+                o.target[i].accept(self)
         o.body.accept(self)
 
     def visit_member_expr(self, o: MemberExpr) -> T:

mypy/treetransform.py

@@ -259,7 +259,7 @@ def visit_try_stmt(self, node: TryStmt) -> Node:
 
     def visit_with_stmt(self, node: WithStmt) -> Node:
         return WithStmt(self.nodes(node.expr),
-                        self.optional_names(node.name),
+                        self.optional_nodes(node.target),
                         self.block(node.body))
 
     def visit_print_stmt(self, node: PrintStmt) -> Node: