Lines Matching full:syntax
40 "go.starlark.net/syntax"
328 Pos syntax.Position // position of def or lambda token
355 Pos syntax.Position
372 pos syntax.Position // current position of generated code
404 func (fn *Funcode) Position(pc uint32) syntax.Position {
486 func Expr(expr syntax.Expr, name string, locals []*resolve.Binding) *Program {
487 pos := syntax.Start(expr)
488 stmts := []syntax.Stmt{&syntax.ReturnStmt{Result: expr}}
493 func File(stmts []syntax.Stmt, pos syntax.Position, name string, locals, globals []*resolve.Binding…
507 func (pcomp *pcomp) function(name string, pos syntax.Position, stmts []syntax.Stmt, locals, freevar…
680 func docStringFromBody(body []syntax.Stmt) string {
684 expr, ok := body[0].(*syntax.ExprStmt)
688 lit, ok := expr.X.(*syntax.Literal)
692 if lit.Token != syntax.STRING {
994 func (fcomp *fcomp) setPos(pos syntax.Position) {
1000 func (fcomp *fcomp) set(id *syntax.Ident) {
1015 func (fcomp *fcomp) lookup(id *syntax.Ident) {
1038 func (fcomp *fcomp) stmts(stmts []syntax.Stmt) {
1044 func (fcomp *fcomp) stmt(stmt syntax.Stmt) {
1046 case *syntax.ExprStmt:
1047 if _, ok := stmt.X.(*syntax.Literal); ok {
1054 case *syntax.BranchStmt:
1057 case syntax.PASS:
1059 case syntax.BREAK:
1063 case syntax.CONTINUE:
1069 case *syntax.IfStmt:
1087 case *syntax.AssignStmt:
1089 case syntax.EQ:
1094 case syntax.PLUS_EQ,
1095 syntax.MINUS_EQ,
1096 syntax.STAR_EQ,
1097 syntax.SLASH_EQ,
1098 syntax.SLASHSLASH_EQ,
1099 syntax.PERCENT_EQ,
1100 syntax.AMP_EQ,
1101 syntax.PIPE_EQ,
1102 syntax.CIRCUMFLEX_EQ,
1103 syntax.LTLT_EQ,
1104 syntax.GTGT_EQ:
1111 case *syntax.Ident:
1118 case *syntax.IndexExpr:
1130 case *syntax.DotExpr:
1148 if stmt.Op == syntax.PLUS_EQ {
1153 fcomp.binop(stmt.OpPos, stmt.Op-syntax.PLUS_EQ+syntax.PLUS)
1158 case *syntax.DefStmt:
1162 case *syntax.ForStmt:
1186 case *syntax.WhileStmt:
1203 case *syntax.ReturnStmt:
1212 case *syntax.LoadStmt:
1236 func (fcomp *fcomp) assign(pos syntax.Position, lhs syntax.Expr) {
1238 case *syntax.ParenExpr:
1242 case *syntax.Ident:
1246 case *syntax.TupleExpr:
1250 case *syntax.ListExpr:
1254 case *syntax.IndexExpr:
1263 case *syntax.DotExpr:
1275 func (fcomp *fcomp) assignSequence(pos syntax.Position, lhs []syntax.Expr) {
1283 func (fcomp *fcomp) expr(e syntax.Expr) {
1285 case *syntax.ParenExpr:
1288 case *syntax.Ident:
1291 case *syntax.Literal:
1294 if e.Token == syntax.BYTES {
1299 case *syntax.ListExpr:
1305 case *syntax.CondExpr:
1323 case *syntax.IndexExpr:
1329 case *syntax.SliceExpr:
1349 case *syntax.Comprehension:
1357 case *syntax.TupleExpr:
1360 case *syntax.DictExpr:
1363 entry := entry.(*syntax.DictEntry)
1371 case *syntax.UnaryExpr:
1375 case syntax.MINUS:
1377 case syntax.PLUS:
1379 case syntax.NOT:
1381 case syntax.TILDE:
1387 case *syntax.BinaryExpr:
1391 case syntax.OR:
1407 case syntax.AND:
1423 case syntax.PLUS:
1433 case *syntax.DotExpr:
1438 case *syntax.CallExpr:
1441 case *syntax.LambdaExpr:
1451 x syntax.Expr
1452 plusPos syntax.Position
1458 func (fcomp *fcomp) plus(e *syntax.BinaryExpr) {
1465 x, ok := left.(*syntax.BinaryExpr)
1466 if !ok || x.Op != syntax.PLUS {
1536 func addable(e syntax.Expr) rune {
1538 case *syntax.Literal:
1541 case syntax.STRING:
1543 case syntax.BYTES:
1546 case *syntax.ListExpr:
1548 case *syntax.TupleExpr:
1556 // The resulting syntax is degenerate, lacking position, etc.
1557 func add(code rune, args []summand) syntax.Expr {
1562 buf.WriteString(arg.x.(*syntax.Literal).Value.(string))
1564 tok := syntax.STRING
1566 tok = syntax.BYTES
1568 return &syntax.Literal{Token: tok, Value: buf.String()}
1570 var elems []syntax.Expr
1572 elems = append(elems, arg.x.(*syntax.ListExpr).List...)
1574 return &syntax.ListExpr{List: elems}
1576 var elems []syntax.Expr
1578 elems = append(elems, arg.x.(*syntax.TupleExpr).List...)
1580 return &syntax.TupleExpr{List: elems}
1585 func unparen(e syntax.Expr) syntax.Expr {
1586 if p, ok := e.(*syntax.ParenExpr); ok {
1592 func (fcomp *fcomp) binop(pos syntax.Position, op syntax.Token) {
1593 // TODO(adonovan): simplify by assuming syntax and compiler constants align.
1597 case syntax.PLUS:
1599 case syntax.MINUS:
1601 case syntax.STAR:
1603 case syntax.SLASH:
1605 case syntax.SLASHSLASH:
1607 case syntax.PERCENT:
1609 case syntax.AMP:
1611 case syntax.PIPE:
1613 case syntax.CIRCUMFLEX:
1615 case syntax.LTLT:
1617 case syntax.GTGT:
1619 case syntax.IN:
1621 case syntax.NOT_IN:
1626 case syntax.EQL,
1627 syntax.NEQ,
1628 syntax.GT,
1629 syntax.LT,
1630 syntax.LE,
1631 syntax.GE:
1632 fcomp.emit(Opcode(op-syntax.EQL) + EQL)
1639 func (fcomp *fcomp) call(call *syntax.CallExpr) {
1642 // if dot, ok := call.Fcomp.(*syntax.DotExpr); ok {
1659 func (fcomp *fcomp) args(call *syntax.CallExpr) (op Opcode, arg uint32) {
1663 var varargs, kwargs syntax.Expr
1665 if binary, ok := arg.(*syntax.BinaryExpr); ok && binary.Op == syntax.EQ {
1668 fcomp.string(binary.X.(*syntax.Ident).Name)
1673 if unary, ok := arg.(*syntax.UnaryExpr); ok {
1674 if unary.Op == syntax.STAR {
1678 } else if unary.Op == syntax.STARSTAR {
1727 func (fcomp *fcomp) tuple(elems []syntax.Expr) {
1734 func (fcomp *fcomp) comprehension(comp *syntax.Comprehension, clauseIndex int) {
1742 entry := comp.Body.(*syntax.DictEntry)
1757 case *syntax.IfClause:
1769 case *syntax.ForClause:
1813 case *syntax.BinaryExpr:
1816 case *syntax.UnaryExpr:
1818 case *syntax.Ident:
1865 func (fcomp *fcomp) ifelse(cond syntax.Expr, t, f *block) {
1867 case *syntax.UnaryExpr:
1868 if cond.Op == syntax.NOT {
1876 case *syntax.BinaryExpr:
1878 case syntax.AND:
1890 case syntax.OR:
1901 case syntax.NOT_IN:
1906 copy.Op = syntax.IN