sliceop: ':' [test]

exprlist: (expr|star_expr) (',' (expr|star_expr))* [',']

testlist: test (',' test)* [',']

dictorsetmaker: ( (test ':' test (comp_for | (',' test ':' test)* [','])) |

(test (comp_for | (',' test)* [','])) )

dictorsetmaker: ( ((test ':' test | '**' expr)

(comp_for | (',' (test ':' test | '**' expr))* [','])) |

((test | star_expr)

(comp_for | (',' (test | star_expr))* [','])) )

classdef: 'class' NAME ['(' [arglist] ')'] ':' suite

arglist: (argument ',')* (argument [',']

|'*' test (',' argument)* [',' '**' test]

|'**' test)

arglist: argument (',' argument)* [',']

# The reason that keywords are test nodes instead of NAME is that using NAME

# results in an ambiguity. ast.c makes sure it's a NAME.

argument: test [comp_for] | test '=' test # Really [keyword '='] test

# "test '=' test" is really "keyword '=' test", but we have no such token.

# These need to be in a single rule to avoid grammar that is ambiguous

# to our LL(1) parser. Even though 'test' includes '*expr' in star_expr,

# we explicitly match '*' here, too, to give it proper precedence.

# Illegal combinations and orderings are blocked in ast.c:

# multiple (test comp_for) arguements are blocked; keyword unpackings

# that precede iterable unpackings are blocked; etc.

argument: ( test [comp_for] |

test '=' test |

'**' expr |

star_expr )

comp_iter: comp_for | comp_if

comp_for: 'for' exprlist 'in' or_test [comp_iter]

comp_if: 'if' test_nocond [comp_iter]

identifiername;

asdl_seq*bases;

asdl_seq*keywords;

expr_tystarargs;

expr_tykwargs;

asdl_seq*body;

asdl_seq*decorator_list;

}ClassDef;

expr_tyfunc;

asdl_seq*args;

asdl_seq*keywords;

expr_tystarargs;

expr_tykwargs;

}Call;

struct {

stmt_ty_Py_FunctionDef(identifiername,arguments_tyargs,asdl_seq*body,

asdl_seq*decorator_list,expr_tyreturns,intlineno,

intcol_offset,PyArena*arena);

#defineClassDef(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9) _Py_ClassDef(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)

#defineClassDef(a0,a1,a2,a3,a4,a5,a6,a7) _Py_ClassDef(a0, a1, a2, a3, a4, a5, a6, a7)

stmt_ty_Py_ClassDef(identifiername,asdl_seq*bases,asdl_seq*keywords,

expr_tystarargs,expr_tykwargs,asdl_seq*body,

asdl_seq*decorator_list,intlineno,intcol_offset,

PyArena*arena);

asdl_seq*body,asdl_seq*decorator_list,intlineno,

intcol_offset,PyArena*arena);

#defineReturn(a0,a1,a2,a3) _Py_Return(a0, a1, a2, a3)

stmt_ty_Py_Return(expr_tyvalue,intlineno,intcol_offset,PyArena*arena);

#defineDelete(a0,a1,a2,a3) _Py_Delete(a0, a1, a2, a3)

#defineCompare(a0,a1,a2,a3,a4,a5) _Py_Compare(a0, a1, a2, a3, a4, a5)

expr_ty_Py_Compare(expr_tyleft,asdl_int_seq*ops,asdl_seq*comparators,

intlineno,intcol_offset,PyArena*arena);

#defineCall(a0,a1,a2,a3,a4,a5,a6,a7) _Py_Call(a0, a1, a2, a3, a4, a5, a6, a7)

expr_ty_Py_Call(expr_tyfunc,asdl_seq*args,asdl_seq*keywords,expr_ty

starargs,expr_tykwargs,intlineno,intcol_offset,PyArena

*arena);

#defineCall(a0,a1,a2,a3,a4,a5) _Py_Call(a0, a1, a2, a3, a4, a5)

expr_ty_Py_Call(expr_tyfunc,asdl_seq*args,asdl_seq*keywords,int

lineno,intcol_offset,PyArena*arena);

#defineNum(a0,a1,a2,a3) _Py_Num(a0, a1, a2, a3)

expr_ty_Py_Num(objectn,intlineno,intcol_offset,PyArena*arena);

#defineStr(a0,a1,a2,a3) _Py_Str(a0, a1, a2, a3)

PyObject*other,

intoverride);

PyAPI_FUNC(PyObject*)_PyDictView_Intersect(PyObject*self,PyObject*other);

#defineSET_ADD 146

#defineMAP_ADD 147

#defineLOAD_CLASSDEREF 148

#defineBUILD_LIST_UNPACK 149

#defineBUILD_MAP_UNPACK 150

#defineBUILD_MAP_UNPACK_WITH_CALL151

#defineBUILD_TUPLE_UNPACK 152

#defineBUILD_SET_UNPACK 153

MAGIC_NUMBER= (3320).to_bytes(2,'little')+b'\r\n'

MAGIC_NUMBER= (3330).to_bytes(2,'little')+b'\r\n'

_RAW_MAGIC_NUMBER=int.from_bytes(MAGIC_NUMBER,'little')# For import.c

def_op('EXTENDED_ARG',144)

def_op('BUILD_LIST_UNPACK',149)

def_op('BUILD_MAP_UNPACK',150)

def_op('BUILD_MAP_UNPACK_WITH_CALL',151)

def_op('BUILD_TUPLE_UNPACK',152)

def_op('BUILD_SET_UNPACK',153)

deldef_op,name_op,jrel_op,jabs_op

self.assertEqual(ast.dump(node),

)

self.assertEqual(ast.dump(node,annotate_fields=False),

)

self.assertEqual(ast.dump(node,include_attributes=True),

)

deftest_fix_missing_locations(self):

src=ast.parse('write("spam")')

src.body.append(ast.Expr(ast.Call(ast.Name('spam',ast.Load()),

[ast.Str('eggs')], [],None,None)))

[ast.Str('eggs')], [])))

self.assertEqual(src,ast.fix_missing_locations(src))

self.assertEqual(ast.dump(src,include_attributes=True),

)

node=ast.parse('foo()',mode='eval')

d=dict(ast.iter_fields(node.body))

self.assertEqual(d.pop('func').id,'foo')

self.assertEqual(d, {'keywords': [],'kwargs':None,

'args': [],'starargs':None})

self.assertEqual(d, {'keywords': [],'args': []})

deftest_iter_child_nodes(self):

node=ast.parse("spam(23, 42, eggs='leek')",mode='eval')

self._check_arguments(fac,self.stmt)

deftest_classdef(self):

defcls(bases=None,keywords=None,starargs=None,kwargs=None,

body=None,decorator_list=None):

defcls(bases=None,keywords=None,body=None,decorator_list=None):

ifbasesisNone:

bases= []

ifkeywordsisNone:

body= [ast.Pass()]

ifdecorator_listisNone:

decorator_list= []

returnast.ClassDef("myclass",bases,keywords,starargs,

kwargs,body,decorator_list)

returnast.ClassDef("myclass",bases,keywords,

body,decorator_list)

self.stmt(cls(bases=[ast.Name("x",ast.Store())]),

"must have Load context")

self.stmt(cls(keywords=[ast.keyword("x",ast.Name("x",ast.Store()))]),

"must have Load context")

self.stmt(cls(starargs=ast.Name("x",ast.Store())),

"must have Load context")

self.stmt(cls(kwargs=ast.Name("x",ast.Store())),

"must have Load context")

self.stmt(cls(body=[]),"empty body on ClassDef")

self.stmt(cls(body=[None]),"None disallowed")

self.stmt(cls(decorator_list=[ast.Name("x",ast.Store())]),

func=ast.Name("x",ast.Load())

args= [ast.Name("y",ast.Load())]

keywords= [ast.keyword("w",ast.Name("z",ast.Load()))]

stararg=ast.Name("p",ast.Load())

kwarg=ast.Name("q",ast.Load())

call=ast.Call(ast.Name("x",ast.Store()),args,keywords,stararg,

kwarg)

call=ast.Call(ast.Name("x",ast.Store()),args,keywords)

self.expr(call,"must have Load context")

call=ast.Call(func, [None],keywords,stararg,kwarg)

call=ast.Call(func, [None],keywords)

self.expr(call,"None disallowed")

bad_keywords= [ast.keyword("w",ast.Name("z",ast.Store()))]

call=ast.Call(func,args,bad_keywords,stararg,kwarg)

self.expr(call,"must have Load context")

call=ast.Call(func,args,keywords,ast.Name("z",ast.Store()),kwarg)

self.expr(call,"must have Load context")

call=ast.Call(func,args,keywords,stararg,

ast.Name("w",ast.Store()))

call=ast.Call(func,args,bad_keywords)

self.expr(call,"must have Load context")

deftest_num(self):

('Module', [('FunctionDef', (1,0),'f', ('arguments', [], ('arg', (1,7),'args',None), [], [],None, []), [('Pass', (1,14))], [],None)]),

('Module', [('FunctionDef', (1,0),'f', ('arguments', [],None, [], [], ('arg', (1,8),'kwargs',None), []), [('Pass', (1,17))], [],None)]),

('Module', [('FunctionDef', (1,0),'f', ('arguments', [('arg', (1,6),'a',None), ('arg', (1,9),'b',None), ('arg', (1,14),'c',None), ('arg', (1,22),'d',None), ('arg', (1,28),'e',None)], ('arg', (1,35),'args',None), [('arg', (1,41),'f',None)], [('Num', (1,43),42)], ('arg', (1,49),'kwargs',None), [('Num', (1,11),1), ('NameConstant', (1,16),None), ('List', (1,24), [], ('Load',)), ('Dict', (1,30), [], [])]), [('Pass', (1,58))], [],None)]),

('Module', [('ClassDef', (1,0),'C', [], [],None,None,[('Pass', (1,8))], [])]),

('Module', [('ClassDef', (1,0),'C', [('Name', (1,8),'object', ('Load',))], [],None,None,[('Pass', (1,17))], [])]),

('Module', [('ClassDef', (1,0),'C', [], [], [('Pass', (1,8))], [])]),

('Module', [('ClassDef', (1,0),'C', [('Name', (1,8),'object', ('Load',))], [], [('Pass', (1,17))], [])]),

('Module', [('FunctionDef', (1,0),'f', ('arguments', [],None, [], [],None, []), [('Return', (1,8), ('Num', (1,15),1))], [],None)]),

('Module', [('Delete', (1,0), [('Name', (1,4),'v', ('Del',))])]),

('Module', [('Assign', (1,0), [('Name', (1,0),'v', ('Store',))], ('Num', (1,4),1))]),

('Module', [('If', (1,0), ('Name', (1,3),'v', ('Load',)), [('Pass', (1,5))], [])]),

('Module', [('With', (1,0), [('withitem', ('Name', (1,5),'x', ('Load',)), ('Name', (1,10),'y', ('Store',)))], [('Pass', (1,13))])]),

('Module', [('With', (1,0), [('withitem', ('Name', (1,5),'x', ('Load',)), ('Name', (1,10),'y', ('Store',))), ('withitem', ('Name', (1,13),'z', ('Load',)), ('Name', (1,18),'q', ('Store',)))], [('Pass', (1,21))])]),

('Module', [('Raise', (1,0), ('Call', (1,6), ('Name', (1,6),'Exception', ('Load',)), [('Str', (1,16),'string')], [],None,None),None)]),

('Module', [('Raise', (1,0), ('Call', (1,6), ('Name', (1,6),'Exception', ('Load',)), [('Str', (1,16),'string')], []),None)]),

('Module', [('Try', (1,0), [('Pass', (2,2))], [('ExceptHandler', (3,0), ('Name', (3,7),'Exception', ('Load',)),None, [('Pass', (4,2))])], [], [])]),

('Module', [('Try', (1,0), [('Pass', (2,2))], [], [], [('Pass', (4,2))])]),

('Module', [('Assert', (1,0), ('Name', (1,7),'v', ('Load',)),None)]),

('Expression', ('BinOp', (1,0), ('Name', (1,0),'a', ('Load',)), ('Add',), ('Name', (1,4),'b', ('Load',)))),

('Expression', ('UnaryOp', (1,0), ('Not',), ('Name', (1,4),'v', ('Load',)))),

('Expression', ('Lambda', (1,0), ('arguments', [],None, [], [],None, []), ('NameConstant', (1,7),None))),

('Expression', ('Dict', (1,0), [('Num', (1,2),1)], [('Num', (1,4),2)])),

('Expression', ('Dict', (1,2), [('Num', (1,2),1)], [('Num', (1,4),2)])),

('Expression', ('Dict', (1,0), [], [])),

('Expression', ('Set', (1,0), [('NameConstant', (1,1),None)])),

('Expression', ('Dict', (1,0), [('Num', (2,6),1)], [('Num', (4,10),2)])),

('Expression', ('Set', (1,1), [('NameConstant', (1,1),None)])),

('Expression', ('Dict', (2,6), [('Num', (2,6),1)], [('Num', (4,10),2)])),

('Expression', ('ListComp', (1,1), ('Name', (1,1),'a', ('Load',)), [('comprehension', ('Name', (1,7),'b', ('Store',)), ('Name', (1,12),'c', ('Load',)), [('Name', (1,17),'d', ('Load',))])])),

('Expression', ('GeneratorExp', (1,1), ('Name', (1,1),'a', ('Load',)), [('comprehension', ('Name', (1,7),'b', ('Store',)), ('Name', (1,12),'c', ('Load',)), [('Name', (1,17),'d', ('Load',))])])),

('Expression', ('Compare', (1,0), ('Num', (1,0),1), [('Lt',), ('Lt',)], [('Num', (1,4),2), ('Num', (1,8),3)])),

('Expression', ('Call', (1,0), ('Name', (1,0),'f', ('Load',)), [('Num', (1,2),1), ('Num', (1,4),2)], [('keyword','c', ('Num', (1,8),3))],('Name',(1,11),'d', ('Load',)), ('Name', (1,15),'e', ('Load',)))),

('Expression', ('Call', (1,0), ('Name', (1,0),'f', ('Load',)), [('Num', (1,2),1), ('Num', (1,4),2), ('Starred',(1,10), ('Name', (1,11),'d', ('Load',)), ('Load',))],[('keyword','c', ('Num', (1,8),3)), ('keyword',None, ('Name', (1,15),'e', ('Load',)))])),

('Expression', ('Num', (1,0),10)),

('Expression', ('Str', (1,0),'string')),

('Expression', ('Attribute', (1,0), ('Name', (1,0),'a', ('Load',)),'b', ('Load',))),

('Expression', ('Tuple', (1,0), [('Num', (1,0),1), ('Num', (1,2),2), ('Num', (1,4),3)], ('Load',))),

('Expression', ('Tuple', (1,1), [('Num', (1,1),1), ('Num', (1,3),2), ('Num', (1,5),3)], ('Load',))),

('Expression', ('Tuple', (1,0), [], ('Load',))),

('Expression', ('Call', (1,0), ('Attribute', (1,0), ('Attribute', (1,0), ('Attribute', (1,0), ('Name', (1,0),'a', ('Load',)),'b', ('Load',)),'c', ('Load',)),'d', ('Load',)), [('Subscript', (1,8), ('Attribute', (1,8), ('Name', (1,8),'a', ('Load',)),'b', ('Load',)), ('Slice', ('Num', (1,12),1), ('Num', (1,14),2),None), ('Load',))], [],None,None)),

('Expression', ('Call', (1,0), ('Attribute', (1,0), ('Attribute', (1,0), ('Attribute', (1,0), ('Name', (1,0),'a', ('Load',)),'b', ('Load',)),'c', ('Load',)),'d', ('Load',)), [('Subscript', (1,8), ('Attribute', (1,8), ('Name', (1,8),'a', ('Load',)),'b', ('Load',)), ('Slice', ('Num', (1,12),1), ('Num', (1,14),2),None), ('Load',))], [])),

]

main()

returnargs,kwargs

self.assertEqual(f(1,x=2,*[3,4],y=5), ((1,3,4),

{'x':2,'y':5}))

self.assertRaises(SyntaxError,eval,"f(1, *(2,3), 4)")

self.assertEqual(f(1,*(2,3),4), ((1,2,3,4), {}))

self.assertRaises(SyntaxError,eval,"f(1, x=2, *(3,4), x=5)")

self.assertEqual(f(**{'eggs':'scrambled','spam':'fried'}),

((), {'eggs':'scrambled','spam':'fried'}))

self.assertEqual(f(spam='fried',**{'eggs':'scrambled'}),

((), {'eggs':'scrambled','spam':'fried'}))

deff(x)->list:pass