@@ -631,9 +631,10 @@ def parse_arg_list(self, allow_signature: bool = True,
                 elif self.current_str() == '(':
                     arg, extra_stmt, names = self.parse_tuple_arg(len(args))
                     args.append(arg)
-                    extra_stmts.append(extra_stmt)
+                    if extra_stmt is not None:
+                        extra_stmts.append(extra_stmt)
+                        has_tuple_arg = True
                     arg_names.extend(names)
-                    has_tuple_arg = True
                 else:
                     arg, require_named = self.parse_normal_arg(
                         require_named,
@@ -691,6 +692,10 @@ def parse_tuple_arg(self, index: int) -> Tuple[Argument, AssignmentStmt, List[st
         function body (the second return value).
 
         Return tuple (argument, decomposing assignment, list of names defined).
+
+        Special case: if the argument is just (x) then it's not a tuple;
+        we indicate this by returning (argument, None, ['x']).
+        However, if the argument is (x,) then it *is* a (singleton) tuple.
         """
         line = self.current().line
         # Generate a new argument name that is very unlikely to clash with anything.
@@ -700,13 +705,14 @@ def parse_tuple_arg(self, index: int) -> Tuple[Argument, AssignmentStmt, List[st
         paren_arg = self.parse_parentheses()
         self.verify_tuple_arg(paren_arg)
         if isinstance(paren_arg, NameExpr):
-            # This isn't a tuple. Revert to a normal argument. We'll still get a no-op
-            # assignment below but that's benign.
+            # This isn't a tuple. Revert to a normal argument.
             arg_name = paren_arg.name
-        rvalue = NameExpr(arg_name)
-        rvalue.set_line(line)
-        decompose = AssignmentStmt([paren_arg], rvalue)
-        decompose.set_line(line)
+            decompose = None
+        else:
+            rvalue = NameExpr(arg_name)
+            rvalue.set_line(line)
+            decompose = AssignmentStmt([paren_arg], rvalue)
+            decompose.set_line(line)
         kind = nodes.ARG_POS
         initializer = None
         if self.current_str() == '=':
 
@@ -174,5 +174,22 @@ main: note: In function "f":
 main:1: error: Parse error before ): Ellipses cannot accompany other argument types in function type signature.
 
 [case testLambdaTupleArgInPython2]
-lambda (x, y): x + y
+f = lambda (x, y): x + y
+f((0, 0))
+[out]
+
+[case testLambdaSingletonTupleArgInPython2]
+f = lambda (x,): x + 1
+f((0,))
+[out]
+
+[case testLambdaNoTupleArgInPython2]
+f = lambda (x): x + 1
+f(0)
+[out]
+
+[case testDefTupleEdgeCasesPython2]
+def f((x,)): return x
+def g((x)): return x
+f(0) + g(0)
 [out]
@@ -302,6 +302,34 @@ MypyFile:1(
         ReturnStmt:1(
           NameExpr(z))))))
 
+[case testLambdaSingletonTupleArgListInPython2]
+lambda (x,): z
+[out]
+MypyFile:1(
+  ExpressionStmt:1(
+    FuncExpr:1(
+      Args(
+        Var(__tuple_arg_1))
+      Block:1(
+        AssignmentStmt:1(
+          TupleExpr:1(
+            NameExpr(x))
+          NameExpr(__tuple_arg_1))
+        ReturnStmt:1(
+          NameExpr(z))))))
+
+[case testLambdaNoTupleArgListInPython2]
+lambda (x): z
+[out]
+MypyFile:1(
+  ExpressionStmt:1(
+    FuncExpr:1(
+      Args(
+        Var(x))
+      Block:1(
+        ReturnStmt:1(
+          NameExpr(z))))))
+
 [case testInvalidExprInTupleArgListInPython2_1]
 def f(x, ()): pass
 [out]
@@ -343,9 +371,6 @@ MypyFile:1(
       Var(x)
       Var(y))
     Block:1(
-      AssignmentStmt:1(
-        NameExpr(y)
-        NameExpr(y))
       PassStmt:1())))
 
 [case testDuplicateNameInTupleArgList_python2]