parser: fix error on setting someting which can't be set, eg f()=1

ncw · ncw · commit 648fc135e14a · 2015-06-04T22:58:52.000+01:00
diff --git a/compile/compile_data_test.go b/compile/compile_data_test.go
@@ -1540,6 +1540,7 @@ var compileTestData = []struct {
 		Firstlineno:    1,
 		Lnotab:         "",
 	}, nil, ""},
+	{"f() = 1", "exec", nil, py.SyntaxError, "can't assign to function call"},
 	{"a+=1", "exec", &py.Code{
 		Argcount:       0,
 		Kwonlyargcount: 0,
@@ -1761,6 +1762,7 @@ var compileTestData = []struct {
 		Firstlineno:    1,
 		Lnotab:         "",
 	}, nil, ""},
+	{"f() += 1", "exec", nil, py.SyntaxError, "can't assign to function call"},
 	{"del a", "exec", &py.Code{
 		Argcount:       0,
 		Kwonlyargcount: 0,
@@ -1812,6 +1814,7 @@ var compileTestData = []struct {
 		Firstlineno:    1,
 		Lnotab:         "",
 	}, nil, ""},
+	{"del f()", "exec", nil, py.SyntaxError, "can't delete function call"},
 	{"def fn(b):\n global a\n del a\n c = 1\n def nested(d):\n   nonlocal b\n   e = b+c+d+e\n   f(e)\n   del b,c,d,e\n", "exec", &py.Code{
 		Argcount:       0,
 		Kwonlyargcount: 0,
diff --git a/compile/compile_test.go b/compile/compile_test.go
@@ -133,10 +133,7 @@ func TestCompile(t *testing.T) {
 				t.Errorf("%s: Got non python exception %T %v", test.in, err, err)
 				return
 			} else if exc.Type() != test.exceptionType {
-				t.Errorf("%s: want exception type %v got %v", test.in, test.exceptionType, exc.Type())
-				return
-			} else if exc.Type() != test.exceptionType {
-				t.Errorf("%s: want exception type %v got %v", test.in, test.exceptionType, exc.Type())
+				t.Errorf("%s: want exception type %v(%s) got %v(%v)", test.in, test.exceptionType, test.errString, exc.Type(), err)
 				return
 			} else {
 				msg := string(exc.Args.(py.Tuple)[0].(py.String))
diff --git a/compile/make_compile_test.py b/compile/make_compile_test.py
@@ -117,6 +117,7 @@
     ('''a = 1''', "exec"),
     ('''a = b = c = 1''', "exec"),
     ('''a[1] = 1''', "exec"),
+    ('''f() = 1''', "exec", SyntaxError),
     # aug assign
     ('''a+=1''', "exec"),
     ('''a-=1''', "exec"),
@@ -131,10 +132,12 @@
     ('''a&=1''', "exec"),
     ('''a//=1''', "exec"),
     ('''a[1]+=1''', "exec"),
+    ('''f() += 1''', "exec", SyntaxError),
     # delete
     ('''del a''', "exec"),
     ('''del a, b''', "exec"),
     ('''del a[1]''', "exec"),
+    ('''del f()''', "exec", SyntaxError),
     ('''\
 def fn(b):
  global a
diff --git a/notes.txt b/notes.txt
@@ -7,16 +7,11 @@ Code Quality
 Limitations
 ===========
   * string keys only in dictionaries
-  * ints only 64 bit
-
-FIXME interesting crash with compiling `int("42"), sausage=11)`
-Compile error: SystemError: [interface conversion: *ast.Call is not ast.SetCtxer: missing method SetCtx]
-
 
 Todo
 ====
 
-FIXME move the whole of Vm into Frame! perpahs decode the extended args inline.
+FIXME move the whole of Vm into Frame! Perhaps decode the extended args inline.
 
 Speedup
   * Make Object a fat interface so it defines all the M__method__ or at least all the common ones
diff --git a/parser/grammar.y b/parser/grammar.y
@@ -42,10 +42,55 @@ func applyTrailers(expr ast.Expr, trailers []ast.Expr) ast.Expr {
 	return expr
 }
 
+// Set the context for expr
+func setCtx(yylex yyLexer, expr ast.Expr, ctx ast.ExprContext) {
+	setctxer, ok := expr.(ast.SetCtxer)
+	if !ok {
+		expr_name := ""
+		switch expr.(type) {
+		case *ast.Lambda:
+			expr_name = "lambda"
+		case *ast.Call:
+			expr_name = "function call"
+		case *ast.BoolOp, *ast.BinOp, *ast.UnaryOp:
+			expr_name = "operator"
+		case *ast.GeneratorExp:
+			expr_name = "generator expression"
+		case *ast.Yield, *ast.YieldFrom:
+			expr_name = "yield expression"
+		case *ast.ListComp:
+			expr_name = "list comprehension"
+		case *ast.SetComp:
+			expr_name = "set comprehension"
+		case *ast.DictComp:
+			expr_name = "dict comprehension"
+		case *ast.Dict, *ast.Set, *ast.Num, *ast.Str, *ast.Bytes:
+			expr_name = "literal"
+		case *ast.NameConstant:
+			expr_name = "keyword"
+		case *ast.Ellipsis:
+			expr_name = "Ellipsis"
+		case *ast.Compare:
+			expr_name = "comparison"
+		case *ast.IfExp:
+			expr_name = "conditional expression"
+		default:
+			expr_name = fmt.Sprintf("unexpected %T", expr)
+		}
+		action := "assign to"
+		if ctx == ast.Del {
+			action = "delete"
+		}
+		yylex.(*yyLex).SyntaxErrorf("can't %s %s", action, expr_name)
+		return
+	}
+	setctxer.SetCtx(ctx)
+}
+
 // Set the context for all the items in exprs
-func setCtx(exprs []ast.Expr, ctx ast.ExprContext) {
+func setCtxs(yylex yyLexer, exprs []ast.Expr, ctx ast.ExprContext) {
 	for i := range exprs {
-		exprs[i].(ast.SetCtxer).SetCtx(ctx)
+		setCtx(yylex, exprs[i], ctx)
 	}
 }
 
@@ -628,7 +673,7 @@ expr_stmt:
 	testlist_star_expr augassign yield_expr_or_testlist
 	{
 		target := $1
-		target.(ast.SetCtxer).SetCtx(ast.Store)
+		setCtx(yylex, target, ast.Store)
 		$$ = &ast.AugAssign{StmtBase: ast.StmtBase{$<pos>$}, Target: target, Op: $2, Value: $3}
 	}
 |	testlist_star_expr equals_yield_expr_or_testlist_star_expr
@@ -637,7 +682,7 @@ expr_stmt:
 		targets = append(targets, $2...)
 		value := targets[len(targets)-1]
 		targets = targets[:len(targets)-1]
-		setCtx(targets, ast.Store)
+		setCtxs(yylex, targets, ast.Store)
 		$$ = &ast.Assign{StmtBase: ast.StmtBase{$<pos>$}, Targets: targets, Value: value}
 	}
 |	testlist_star_expr
@@ -766,7 +811,7 @@ augassign:
 del_stmt:
 	DEL exprlist
 	{
-		setCtx($2, ast.Del)
+		setCtxs(yylex, $2, ast.Del)
 		$$ = &ast.Delete{StmtBase: ast.StmtBase{$<pos>$}, Targets: $2}
 	}
 
@@ -1101,7 +1146,7 @@ for_stmt:
 	FOR exprlist IN testlist ':' suite optional_else
 	{
 		target := tupleOrExpr($<pos>$, $2, false)
-		target.(ast.SetCtxer).SetCtx(ast.Store)
+		setCtx(yylex, target, ast.Store)
 		$$ = &ast.For{StmtBase: ast.StmtBase{$<pos>$}, Target: target, Iter: $4, Body: $6, Orelse: $7}
 	}
 
@@ -1158,7 +1203,7 @@ with_item:
 |	test AS expr
 	{
 		v := $3
-		v.(ast.SetCtxer).SetCtx(ast.Store)
+		setCtx(yylex, v, ast.Store)
 		$$ = &ast.WithItem{Pos: $<pos>$, ContextExpr: $1, OptionalVars: v}
 	}
 
@@ -1334,8 +1379,7 @@ comp_op:
 	}
 |	LTGT
 	{
-		// panic("FIXME no coverage")
-		yylex.(*yyLex).SyntaxError("Invalid syntax")
+		yylex.(*yyLex).SyntaxError("invalid syntax")
 	}
 |	PLINGEQ
 	{
@@ -1891,7 +1935,7 @@ comp_for:
 			Target: tupleOrExpr($<pos>$, $2, $<comma>2),
 			Iter: $4,
 		}
-		c.Target.(ast.SetCtxer).SetCtx(ast.Store)
+		setCtx(yylex, c.Target, ast.Store)
 		$$ = []ast.Comprehension{c}
 	}
 |	FOR exprlist IN or_test comp_iter
@@ -1901,7 +1945,7 @@ comp_for:
 			Iter: $4,
 			Ifs: $5,
 		}
-		c.Target.(ast.SetCtxer).SetCtx(ast.Store)
+		setCtx(yylex, c.Target, ast.Store)
 		$$ = []ast.Comprehension{c}
 		$$ = append($$, $<comprehensions>5...)
 	}
diff --git a/parser/grammar_data_test.go b/parser/grammar_data_test.go
@@ -135,6 +135,7 @@ var grammarTestData = []struct {
 	{"a(b,c)", "eval", "Expression(body=Call(func=Name(id='a', ctx=Load()), args=[Name(id='b', ctx=Load()), Name(id='c', ctx=Load())], keywords=[], starargs=None, kwargs=None))", nil, ""},
 	{"a(b,*c)", "eval", "Expression(body=Call(func=Name(id='a', ctx=Load()), args=[Name(id='b', ctx=Load())], keywords=[], starargs=Name(id='c', ctx=Load()), kwargs=None))", nil, ""},
 	{"a(*b)", "eval", "Expression(body=Call(func=Name(id='a', ctx=Load()), args=[], keywords=[], starargs=Name(id='b', ctx=Load()), kwargs=None))", nil, ""},
+	{"a(*b,c)", "eval", "", py.SyntaxError, "only named arguments may follow *expression"},
 	{"a(b,*c,**d)", "eval", "Expression(body=Call(func=Name(id='a', ctx=Load()), args=[Name(id='b', ctx=Load())], keywords=[], starargs=Name(id='c', ctx=Load()), kwargs=Name(id='d', ctx=Load())))", nil, ""},
 	{"a(b,**c)", "eval", "Expression(body=Call(func=Name(id='a', ctx=Load()), args=[Name(id='b', ctx=Load())], keywords=[], starargs=None, kwargs=Name(id='c', ctx=Load())))", nil, ""},
 	{"a(a=b)", "eval", "Expression(body=Call(func=Name(id='a', ctx=Load()), args=[], keywords=[keyword(arg='a', value=Name(id='b', ctx=Load()))], starargs=None, kwargs=None))", nil, ""},
@@ -244,6 +245,7 @@ var grammarTestData = []struct {
 	{"a **= b", "exec", "Module(body=[AugAssign(target=Name(id='a', ctx=Store()), op=Pow(), value=Name(id='b', ctx=Load()))])", nil, ""},
 	{"a //= b", "exec", "Module(body=[AugAssign(target=Name(id='a', ctx=Store()), op=FloorDiv(), value=Name(id='b', ctx=Load()))])", nil, ""},
 	{"a //= yield b", "exec", "Module(body=[AugAssign(target=Name(id='a', ctx=Store()), op=FloorDiv(), value=Yield(value=Name(id='b', ctx=Load())))])", nil, ""},
+	{"a <> b", "exec", "", py.SyntaxError, "invalid syntax"},
 	{"a.b += 1", "exec", "Module(body=[AugAssign(target=Attribute(value=Name(id='a', ctx=Load()), attr='b', ctx=Store()), op=Add(), value=Num(n=1))])", nil, ""},
 	{"a = b", "exec", "Module(body=[Assign(targets=[Name(id='a', ctx=Store())], value=Name(id='b', ctx=Load()))])", nil, ""},
 	{"a = 007", "exec", "", py.SyntaxError, "illegal decimal with leading zero"},
@@ -253,6 +255,19 @@ var grammarTestData = []struct {
 	{"a, b = *a", "exec", "Module(body=[Assign(targets=[Tuple(elts=[Name(id='a', ctx=Store()), Name(id='b', ctx=Store())], ctx=Store())], value=Starred(value=Name(id='a', ctx=Load()), ctx=Load()))])", nil, ""},
 	{"a = yield a", "exec", "Module(body=[Assign(targets=[Name(id='a', ctx=Store())], value=Yield(value=Name(id='a', ctx=Load())))])", nil, ""},
 	{"a.b = 1", "exec", "Module(body=[Assign(targets=[Attribute(value=Name(id='a', ctx=Load()), attr='b', ctx=Store())], value=Num(n=1))])", nil, ""},
+	{"f() = 1", "exec", "", py.SyntaxError, "can't assign to function call"},
+	{"lambda: x = 1", "exec", "", py.SyntaxError, "can't assign to lambda"},
+	{"(a + b) = 1", "exec", "", py.SyntaxError, "can't assign to operator"},
+	{"(x for x in xs) = 1", "exec", "", py.SyntaxError, "can't assign to generator expression"},
+	{"(yield x) = 1", "exec", "", py.SyntaxError, "can't assign to yield expression"},
+	{"[x for x in xs] = 1", "exec", "", py.SyntaxError, "can't assign to list comprehension"},
+	{"{x for x in xs} = 1", "exec", "", py.SyntaxError, "can't assign to set comprehension"},
+	{"{x:x for x in xs} = 1", "exec", "", py.SyntaxError, "can't assign to dict comprehension"},
+	{"{} = 1", "exec", "", py.SyntaxError, "can't assign to literal"},
+	{"None = 1", "exec", "", py.SyntaxError, "can't assign to keyword"},
+	{"... = 1", "exec", "", py.SyntaxError, "can't assign to Ellipsis"},
+	{"(a < b) = 1", "exec", "", py.SyntaxError, "can't assign to comparison"},
+	{"(a if b else c) = 1", "exec", "", py.SyntaxError, "can't assign to conditional expression"},
 	{"lambda: a", "eval", "Expression(body=Lambda(args=arguments(args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=Name(id='a', ctx=Load())))", nil, ""},
 	{"lambda: lambda: a", "eval", "Expression(body=Lambda(args=arguments(args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=Lambda(args=arguments(args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=Name(id='a', ctx=Load()))))", nil, ""},
 	{"lambda a: a", "eval", "Expression(body=Lambda(args=arguments(args=[arg(arg='a', annotation=None)], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=Name(id='a', ctx=Load())))", nil, ""},
@@ -284,6 +299,7 @@ var grammarTestData = []struct {
 	{"def fn(**kws): pass", "exec", "Module(body=[FunctionDef(name='fn', args=arguments(args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=arg(arg='kws', annotation=None), defaults=[]), body=[Pass()], decorator_list=[], returns=None)])", nil, ""},
 	{"def fn() -> None: pass", "exec", "Module(body=[FunctionDef(name='fn', args=arguments(args=[], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=NameConstant(value=None))])", nil, ""},
 	{"def fn(a:'potato') -> 'sausage': pass", "exec", "Module(body=[FunctionDef(name='fn', args=arguments(args=[arg(arg='a', annotation=Str(s='potato'))], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]), body=[Pass()], decorator_list=[], returns=Str(s='sausage'))])", nil, ""},
+	{"del f()", "exec", "", py.SyntaxError, "can't delete function call"},
 	{"class A: pass", "exec", "Module(body=[ClassDef(name='A', bases=[], keywords=[], starargs=None, kwargs=None, body=[Pass()], decorator_list=[])])", nil, ""},
 	{"class A(): pass", "exec", "Module(body=[ClassDef(name='A', bases=[], keywords=[], starargs=None, kwargs=None, body=[Pass()], decorator_list=[])])", nil, ""},
 	{"class A(B): pass", "exec", "Module(body=[ClassDef(name='A', bases=[Name(id='B', ctx=Load())], keywords=[], starargs=None, kwargs=None, body=[Pass()], decorator_list=[])])", nil, ""},
diff --git a/parser/make_grammar_test.py b/parser/make_grammar_test.py
@@ -151,7 +151,7 @@
     ("a(b,c)", "eval"),
     ("a(b,*c)", "eval"),
     ("a(*b)", "eval"),
-    #("a(*b,c)", "eval"), -test error
+    ("a(*b,c)", "eval", SyntaxError),
     ("a(b,*c,**d)", "eval"),
     ("a(b,**c)", "eval"),
     ("a(a=b)", "eval"),
@@ -357,7 +357,7 @@
     ("a **= b", "exec"),
     ("a //= b", "exec"),
     ("a //= yield b", "exec"),
-    # FIXME ("a <> b", "exec"),
+    ("a <> b", "exec", SyntaxError),
     ('''a.b += 1''', "exec"),
 
     # Assign
@@ -369,7 +369,19 @@
     ("a, b = *a", "exec"),
     ("a = yield a", "exec"),
     ('''a.b = 1''', "exec"),
-
+    ('''f() = 1''', "exec", SyntaxError),
+    ('''lambda: x = 1''', "exec", SyntaxError),
+    ('''(a + b) = 1''', "exec", SyntaxError),
+    ('''(x for x in xs) = 1''', "exec", SyntaxError),
+    ('''(yield x) = 1''', "exec", SyntaxError),
+    ('''[x for x in xs] = 1''', "exec", SyntaxError),
+    ('''{x for x in xs} = 1''', "exec", SyntaxError),
+    ('''{x:x for x in xs} = 1''', "exec", SyntaxError),
+    ('''{} = 1''', "exec", SyntaxError),
+    ('''None = 1''', "exec", SyntaxError),
+    ('''... = 1''', "exec", SyntaxError),
+    ('''(a < b) = 1''', "exec", SyntaxError),
+    ('''(a if b else c) = 1''', "exec", SyntaxError),
 
     # lambda
     ("lambda: a", "eval"),
@@ -405,6 +417,7 @@
     ("def fn(**kws): pass", "exec"),
     ("def fn() -> None: pass", "exec"),
     ("def fn(a:'potato') -> 'sausage': pass", "exec"),
+    ("del f()", "exec", SyntaxError),
 
     # class
     ("class A: pass", "exec"),
diff --git a/parser/y.go b/parser/y.go
diff --git a/parser/y.output b/parser/y.output
