Block struct;
Expr interface;
Decl interface;
+ ExprVisitor interface;
+ Signature struct;
)
-// ----------------------------------------------------------------------------
-// Support
-
-func assert(pred bool) {
- if !pred {
- panic("assertion failed");
- }
-}
+// TODO rename scanner.Location to scanner.Position, possibly factor out
+type Position scanner.Location
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
-// Expressions
+// Expressions and types
-const /* channel mode */ (
- FULL = iota;
- SEND;
- RECV;
-)
+
+// All expression nodes implement the Expr interface.
+type Expr interface {
+ // For a (dynamic) node type X, calling Visit with an expression
+ // visitor v invokes the node-specific DoX function of the visitor.
+ //
+ Visit(v ExprVisitor);
+
+ // Pos returns the (beginning) position of the expression.
+ Pos() Position;
+};
+// An expression is represented by a tree consisting of one
+// or several of the following concrete expression nodes.
+//
type (
- ExprVisitor interface;
- Signature struct;
-
- Expr interface {
- Loc() scanner.Location;
- Visit(v ExprVisitor);
- };
-
+ // A BadExpr node is a placeholder node for expressions containing
+ // syntax errors for which not correct expression tree can be created.
+ //
BadExpr struct {
- Loc_ scanner.Location;
+ Pos_ Position; // bad expression position
};
+
+ // An Ident node represents an identifier (identifier).
Ident struct {
- Loc_ scanner.Location;
- Str string;
+ Str string; // identifier string (e.g. foobar)
+ Pos_ Position; // identifier position
};
- BinaryExpr struct {
- Loc_ scanner.Location;
- Tok int;
- X, Y Expr;
- };
- UnaryExpr struct {
- Loc_ scanner.Location;
- Tok int;
- X Expr;
+ // An basic literal is represented by a BasicLit node.
+ BasicLit struct {
+ Tok int; // literal token
+ Lit []byte; // literal string
+ Pos_ Position; // literal string position
};
- // TODO this should probably just be a list instead
- ConcatExpr struct {
- X, Y Expr;
- };
- BasicLit struct {
- Loc_ scanner.Location;
- Tok int;
- Val []byte;
+ // A sequence of string literals (StringLit) is represented
+ // by a StringLit node.
+ //
+ StringLit struct {
+ Strings []*BasicLit; // sequence of strings
};
+
+ // A function literal (FunctionLit) is represented by a FunctionLit node.
FunctionLit struct {
- Loc_ scanner.Location; // location of "func"
- Typ *Signature;
- Body *Block;
+ Typ *Signature; // function signature
+ Body *Block; // function body
+ Func Position; // position of "func" keyword
};
-
+
+
+ // A composite literal (CompositeLit) is represented by a CompositeLit node.
+ CompositeLit struct {
+ Typ Expr; // literal type
+ Elts []Expr; // list of composite elements
+ Lbrace, Rbrace Position; // positions of "{" and "}"
+ };
+
+
+ // A parenthesized expression is represented by a Group node.
Group struct {
- Loc_ scanner.Location; // location of "("
- X Expr;
+ X Expr; // parenthesized expression
+ Lparen, Rparen Position; // positions of "(" and ")"
};
+
+ // A primary expression followed by a selector is represented
+ // by a Selector node.
+ //
Selector struct {
- Loc_ scanner.Location; // location of "."
- X Expr;
- Sel *Ident;
+ X Expr; // primary expression
+ Sel *Ident; // field selector
+ Period Position; // position of "."
};
- TypeGuard struct {
- Loc_ scanner.Location; // location of "."
- X Expr;
- Typ Expr;
- };
+ // A primary expression followed by an index is represented
+ // by an Index node.
+ //
Index struct {
- Loc_ scanner.Location; // location of "["
- X, I Expr;
+ X Expr; // primary expression
+ Index Expr; // index expression
+ Lbrack, Rbrack Position; // positions of "[" and "]"
};
-
+
+
+ // A primary expression followed by a slice is represented
+ // by a Slice node.
+ //
+ Slice struct {
+ X Expr; // primary expression
+ Beg, End Expr; // slice range
+ Lbrack, Colon, Rbrack Position; // positions of "[", ":", and "]"
+ };
+
+
+ // A primary expression followed by a type assertion is represented
+ // by a TypeAssertion node.
+ //
+ TypeAssertion struct {
+ X Expr; // primary expression
+ Typ Expr; // asserted type
+ Period, Lparen, Rparen Position; // positions of ".", "(", and ")"
+ };
+
+
+ // A primary expression followed by an argument list is represented
+ // by a Call node.
+ //
Call struct {
- Loc_ scanner.Location; // location of "(" or "{"
- Tok int;
- F, Args Expr
+ Fun Expr; // function expression
+ Args []Expr; // function arguments
+ Lparen, Rparen Position; // positions of "(" and ")"
+ };
+
+
+ // A unary expression (UnaryExpr) is represented by a UnaryExpr node.
+ UnaryExpr struct {
+ Op int; // operator token
+ X Expr; // operand
+ Pos_ Position; // operator position
+ };
+
+
+ // A binary expression (BinaryExpr) is represented by a BinaryExpr node.
+ BinaryExpr struct {
+ Op int; // operator token
+ X, Y Expr; // left and right operand
+ Pos_ Position; // operator position
};
+)
+
+// The direction of a channel type is indicated by one
+// of the following constants.
+//
+const /* channel direction */ (
+ FULL = iota;
+ SEND;
+ RECV;
+)
+
+
+type (
// Type literals are treated like expressions.
Ellipsis struct { // neither a type nor an expression
Loc_ scanner.Location;
ChannelType struct {
Loc_ scanner.Location; // location of "chan" or "<-"
- Mode int;
+ Dir int;
Val Expr;
};
)
type ExprVisitor interface {
+ // Expressions
DoBadExpr(x *BadExpr);
DoIdent(x *Ident);
- DoBinaryExpr(x *BinaryExpr);
- DoUnaryExpr(x *UnaryExpr);
- DoConcatExpr(x *ConcatExpr);
DoBasicLit(x *BasicLit);
+ DoStringLit(x *StringLit);
DoFunctionLit(x *FunctionLit);
+ DoCompositeLit(x *CompositeLit);
DoGroup(x *Group);
DoSelector(x *Selector);
- DoTypeGuard(x *TypeGuard);
DoIndex(x *Index);
+ DoSlice(x *Slice);
+ DoTypeAssertion(x *TypeAssertion);
DoCall(x *Call);
-
+ DoUnaryExpr(x *UnaryExpr);
+ DoBinaryExpr(x *BinaryExpr);
+
+ // Types
DoEllipsis(x *Ellipsis);
DoTypeType(x *TypeType);
DoArrayType(x *ArrayType);
}
-// TODO replace these with an embedded field
-func (x *BadExpr) Loc() scanner.Location { return x.Loc_; }
-func (x *Ident) Loc() scanner.Location { return x.Loc_; }
-func (x *BinaryExpr) Loc() scanner.Location { return x.Loc_; }
-func (x *UnaryExpr) Loc() scanner.Location { return x.Loc_; }
-func (x *ConcatExpr) Loc() scanner.Location { return x.X.Loc(); }
-func (x *BasicLit) Loc() scanner.Location { return x.Loc_; }
-func (x *FunctionLit) Loc() scanner.Location { return x.Loc_; }
-func (x *Group) Loc() scanner.Location { return x.Loc_; }
-func (x *Selector) Loc() scanner.Location { return x.Loc_; }
-func (x *TypeGuard) Loc() scanner.Location { return x.Loc_; }
-func (x *Index) Loc() scanner.Location { return x.Loc_; }
-func (x *Call) Loc() scanner.Location { return x.Loc_; }
-
-func (x *Ellipsis) Loc() scanner.Location { return x.Loc_; }
-func (x *TypeType) Loc() scanner.Location { return x.Loc_; }
-func (x *ArrayType) Loc() scanner.Location { return x.Loc_; }
-func (x *StructType) Loc() scanner.Location { return x.Loc_; }
-func (x *PointerType) Loc() scanner.Location { return x.Loc_; }
-func (x *FunctionType) Loc() scanner.Location { return x.Loc_; }
-func (x *InterfaceType) Loc() scanner.Location { return x.Loc_; }
-func (x *SliceType) Loc() scanner.Location { return x.Loc_; }
-func (x *MapType) Loc() scanner.Location { return x.Loc_; }
-func (x *ChannelType) Loc() scanner.Location { return x.Loc_; }
+func (x *BadExpr) Pos() Position { return x.Pos_; }
+func (x *Ident) Pos() Position { return x.Pos_; }
+func (x *BasicLit) Pos() Position { return x.Pos_; }
+func (x *StringLit) Pos() Position { return x.Strings[0].Pos(); }
+func (x *FunctionLit) Pos() Position { return x.Func; }
+func (x *CompositeLit) Pos() Position { return x.Typ.Pos(); }
+func (x *Group) Pos() Position { return x.Lparen; }
+func (x *Selector) Pos() Position { return x.X.Pos(); }
+func (x *Index) Pos() Position { return x.X.Pos(); }
+func (x *Slice) Pos() Position { return x.X.Pos(); }
+func (x *TypeAssertion) Pos() Position { return x.X.Pos(); }
+func (x *Call) Pos() Position { return x.Fun.Pos(); }
+func (x *UnaryExpr) Pos() Position { return x.Pos_; }
+func (x *BinaryExpr) Pos() Position { return x.X.Pos(); }
+
+func (x *Ellipsis) Pos() Position { return x.Loc_; }
+func (x *TypeType) Pos() Position { return x.Loc_; }
+func (x *ArrayType) Pos() Position { return x.Loc_; }
+func (x *StructType) Pos() Position { return x.Loc_; }
+func (x *PointerType) Pos() Position { return x.Loc_; }
+func (x *FunctionType) Pos() Position { return x.Loc_; }
+func (x *InterfaceType) Pos() Position { return x.Loc_; }
+func (x *SliceType) Pos() Position { return x.Loc_; }
+func (x *MapType) Pos() Position { return x.Loc_; }
+func (x *ChannelType) Pos() Position { return x.Loc_; }
func (x *BadExpr) Visit(v ExprVisitor) { v.DoBadExpr(x); }
func (x *Ident) Visit(v ExprVisitor) { v.DoIdent(x); }
-func (x *BinaryExpr) Visit(v ExprVisitor) { v.DoBinaryExpr(x); }
-func (x *UnaryExpr) Visit(v ExprVisitor) { v.DoUnaryExpr(x); }
-func (x *ConcatExpr) Visit(v ExprVisitor) { v.DoConcatExpr(x); }
func (x *BasicLit) Visit(v ExprVisitor) { v.DoBasicLit(x); }
+func (x *StringLit) Visit(v ExprVisitor) { v.DoStringLit(x); }
func (x *FunctionLit) Visit(v ExprVisitor) { v.DoFunctionLit(x); }
+func (x *CompositeLit) Visit(v ExprVisitor) { v.DoCompositeLit(x); }
func (x *Group) Visit(v ExprVisitor) { v.DoGroup(x); }
func (x *Selector) Visit(v ExprVisitor) { v.DoSelector(x); }
-func (x *TypeGuard) Visit(v ExprVisitor) { v.DoTypeGuard(x); }
func (x *Index) Visit(v ExprVisitor) { v.DoIndex(x); }
+func (x *Slice) Visit(v ExprVisitor) { v.DoSlice(x); }
+func (x *TypeAssertion) Visit(v ExprVisitor) { v.DoTypeAssertion(x); }
func (x *Call) Visit(v ExprVisitor) { v.DoCall(x); }
+func (x *UnaryExpr) Visit(v ExprVisitor) { v.DoUnaryExpr(x); }
+func (x *BinaryExpr) Visit(v ExprVisitor) { v.DoBinaryExpr(x); }
func (x *Ellipsis) Visit(v ExprVisitor) { v.DoEllipsis(x); }
func (x *TypeType) Visit(v ExprVisitor) { v.DoTypeType(x); }
func NewBlock(loc scanner.Location, tok int) *Block {
- assert(tok == token.LBRACE || tok == token.COLON);
+ if tok != token.LBRACE && tok != token.COLON {
+ panic();
+ }
var end scanner.Location;
return &Block{loc, tok, vector.New(0), end};
}
ExpressionStat struct {
Loc scanner.Location; // location of Tok
- Tok int; // INC, DEC, RETURN, GO, DEFER
+ Tok int; // GO, DEFER
Expr Expr;
};
)
+// TODO rename Position to scanner.Position, possibly factor out
+type Position scanner.Location
+
+
// A Parser holds the parser's internal state while processing
// a given text. It can be allocated as part of another data
// structure but must be initialized via Init before use.
last_comment ast.CommentGroup;
// The next token
- loc scanner.Location; // token location
+ loc Position; // token location
tok int; // one token look-ahead
val []byte; // token value
// When we don't have a location use noloc.
// TODO make sure we always have a location.
-var noloc scanner.Location;
+var noloc Position;
// ----------------------------------------------------------------------------
}
-func (P *Parser) error(loc scanner.Location, msg string) {
+func (P *Parser) error(loc Position, msg string) {
P.err.Error(loc, msg);
}
-func (P *Parser) expect(tok int) {
+func (P *Parser) expect(tok int) Position {
if P.tok != tok {
msg := "expected '" + token.TokenString(tok) + "', found '" + token.TokenString(P.tok) + "'";
if token.IsLiteral(P.tok) {
}
P.error(P.loc, msg);
}
+ loc := P.loc;
P.next(); // make progress in any case
+ return loc;
}
}
if P.tok == token.IDENT {
- x := &ast.Ident{P.loc, string(P.val)};
+ x := &ast.Ident{string(P.val), P.loc};
P.next();
return x;
}
P.expect(token.IDENT); // use expect() error handling
- return &ast.Ident{P.loc, ""};
+ return &ast.Ident{"", P.loc};
}
}
list := vector.New(0);
- list.Push(P.parseExpression(1)); // TODO should use a const instead of 1
+ list.Push(P.parseExpression(1));
for P.tok == token.COMMA {
P.next();
- list.Push(P.parseExpression(1)); // TODO should use a const instead of 1
+ list.Push(P.parseExpression(1));
}
- // convert vector
+ // convert list
exprs := make([]ast.Expr, list.Len());
for i := 0; i < list.Len(); i++ {
exprs[i] = list.At(i).(ast.Expr);
var x ast.Expr = P.parseIdent();
for P.tok == token.PERIOD {
- loc := P.loc;
+ pos := P.loc;
P.next();
- y := P.parseIdent();
- x = &ast.Selector{loc, x, y};
+ sel := P.parseIdent();
+ x = &ast.Selector{x, sel, pos};
}
return x;
}
loc := P.loc;
- var end scanner.Location;
+ var end Position;
var methods []*ast.Field;
P.expect(token.INTERFACE);
if ident, is_ident := list.At(i).(*ast.Ident); is_ident {
idents[i] = ident;
} else {
- P.error(list.At(i).(ast.Expr).Loc(), "identifier expected");
+ P.error(list.At(i).(ast.Expr).Pos(), "identifier expected");
}
}
} else {
}
loc := P.loc;
- var end scanner.Location;
+ var end Position;
var fields []*ast.Field;
P.expect(token.STRUCT);
case token.STRUCT: return P.parseStructType();
case token.MUL: return P.parsePointerType();
case token.LPAREN:
- loc := P.loc;
+ lparen := P.loc;
P.next();
- t := P.parseType();
- P.expect(token.RPAREN);
- return &ast.Group{loc, t};
+ x := P.parseType();
+ rparen := P.expect(token.RPAREN);
+ return &ast.Group{x, lparen, rparen};
}
// no type found
defer un(trace(P, "FunctionLit"));
}
- loc := P.loc;
+ pos := P.loc;
P.expect(token.FUNC);
typ := P.parseSignature();
P.expr_lev++;
body := P.parseBlock(token.LBRACE);
P.expr_lev--;
- return &ast.FunctionLit{loc, typ, body};
+ return &ast.FunctionLit{typ, body, pos};
}
defer un(trace(P, "StringLit"));
}
- var x ast.Expr = &ast.BasicLit{P.loc, P.tok, P.val};
- P.expect(token.STRING); // always satisfied
+ if P.tok != token.STRING {
+ panic();
+ }
+ list := vector.New(0);
for P.tok == token.STRING {
- y := &ast.BasicLit{P.loc, P.tok, P.val};
+ list.Push(&ast.BasicLit{token.STRING, P.val, P.loc});
P.next();
- x = &ast.ConcatExpr{x, y};
}
- return x;
+ // convert list
+ strings := make([]*ast.BasicLit, list.Len());
+ for i := 0; i < list.Len(); i++ {
+ strings[i] = list.At(i).(*ast.BasicLit);
+ }
+
+ return &ast.StringLit{strings};
}
return P.parseIdent();
case token.INT, token.FLOAT, token.CHAR:
- x := &ast.BasicLit{P.loc, P.tok, P.val};
+ x := &ast.BasicLit{P.tok, P.val, P.loc};
P.next();
return x;
return P.parseStringLit();
case token.LPAREN:
- loc := P.loc;
+ lparen := P.loc;
P.next();
P.expr_lev++;
x := P.parseExpression(1);
P.expr_lev--;
- P.expect(token.RPAREN);
- return &ast.Group{loc, x};
+ rparen := P.expect(token.RPAREN);
+ return &ast.Group{x, lparen, rparen};
case token.FUNC:
return P.parseFunctionLit();
}
-func (P *Parser) parseSelectorOrTypeGuard(x ast.Expr) ast.Expr {
+func (P *Parser) parseSelectorOrTypeAssertion(x ast.Expr) ast.Expr {
if P.trace {
- defer un(trace(P, "SelectorOrTypeGuard"));
+ defer un(trace(P, "SelectorOrTypeAssertion"));
}
- loc := P.loc;
- P.expect(token.PERIOD);
+ period := P.expect(token.PERIOD);
if P.tok == token.IDENT {
- x = &ast.Selector{loc, x, P.parseIdent()};
-
+ // selector
+ sel := P.parseIdent();
+ return &ast.Selector{x, sel, period};
+ }
+
+ // type assertion
+ lparen := P.expect(token.LPAREN);
+ var typ ast.Expr;
+ if P.tok == token.TYPE {
+ typ = &ast.TypeType{P.loc};
+ P.next();
} else {
- P.expect(token.LPAREN);
- var typ ast.Expr;
- if P.tok == token.TYPE {
- typ = &ast.TypeType{P.loc};
- P.next();
- } else {
- typ = P.parseType();
- }
- x = &ast.TypeGuard{loc, x, typ};
- P.expect(token.RPAREN);
+ typ = P.parseType();
}
-
- return x;
+ rparen := P.expect(token.RPAREN);
+ return &ast.TypeAssertion{x, typ, period, lparen, rparen};
}
-func (P *Parser) parseIndex(x ast.Expr) ast.Expr {
+func (P *Parser) parseIndexOrSlice(x ast.Expr) ast.Expr {
if P.trace {
defer un(trace(P, "IndexOrSlice"));
}
- loc := P.loc;
- P.expect(token.LBRACK);
+ lbrack := P.expect(token.LBRACK);
P.expr_lev++;
- i := P.parseExpression(0);
+ index := P.parseExpression(1);
P.expr_lev--;
- P.expect(token.RBRACK);
- return &ast.Index{loc, x, i};
+ if P.tok == token.RBRACK {
+ // index
+ rbrack := P.loc;
+ P.next();
+ return &ast.Index{x, index, lbrack, rbrack};
+ }
+
+ // slice
+ colon := P.expect(token.COLON);
+ P.expr_lev++;
+ end := P.parseExpression(1);
+ P.expr_lev--;
+ rbrack := P.expect(token.RBRACK);
+ return &ast.Slice{x, index, end, lbrack, colon, rbrack};
}
-func (P *Parser) parseBinaryExpr(prec1 int) ast.Expr
+func (P *Parser) parseCall(fun ast.Expr) *ast.Call {
+ if P.trace {
+ defer un(trace(P, "Call"));
+ }
+
+ lparen := P.expect(token.LPAREN);
+ var args []ast.Expr;
+ if P.tok != token.RPAREN {
+ args = P.parseExpressionList();
+ }
+ rparen := P.expect(token.RPAREN);
+ return &ast.Call{fun, args, lparen, rparen};
+}
+
func (P *Parser) parseCompositeElements(close int) ast.Expr {
x := P.parseExpression(0);
// first element determines mode
singles := true;
- if t, is_binary := x.(*ast.BinaryExpr); is_binary && t.Tok == token.COLON {
+ if t, is_binary := x.(*ast.BinaryExpr); is_binary && t.Op == token.COLON {
singles = false;
}
y := P.parseExpression(0);
if singles {
- if t, is_binary := y.(*ast.BinaryExpr); is_binary && t.Tok == token.COLON {
- P.error(t.X.Loc(), "single value expected; found pair");
+ if t, is_binary := y.(*ast.BinaryExpr); is_binary && t.Op == token.COLON {
+ P.error(t.X.Pos(), "single value expected; found pair");
}
} else {
- if t, is_binary := y.(*ast.BinaryExpr); !is_binary || t.Tok != token.COLON {
- P.error(y.Loc(), "key:value pair expected; found single value");
+ if t, is_binary := y.(*ast.BinaryExpr); !is_binary || t.Op != token.COLON {
+ P.error(y.Pos(), "key:value pair expected; found single value");
}
}
if last == nil {
- last = &ast.BinaryExpr{loc, token.COMMA, x, y};
+ last = &ast.BinaryExpr{token.COMMA, x, y, loc};
x = last;
} else {
- last.Y = &ast.BinaryExpr{loc, token.COMMA, last.Y, y};
+ last.Y = &ast.BinaryExpr{token.COMMA, last.Y, y, loc};
last = last.Y.(*ast.BinaryExpr);
}
}
-func (P *Parser) parseCallOrCompositeLit(f ast.Expr, open, close int) ast.Expr {
+func (P *Parser) parseElementList() []ast.Expr {
if P.trace {
- defer un(trace(P, "CallOrCompositeLit"));
+ defer un(trace(P, "ElementList"));
}
- loc := P.loc;
- P.expect(open);
- var args ast.Expr;
- if P.tok != close {
- args = P.parseCompositeElements(close);
+ list := vector.New(0);
+ singles := true;
+ for P.tok != token.RBRACE {
+ x := P.parseExpression(0);
+ if list.Len() == 0 {
+ // first element determines syntax for remaining elements
+ if t, is_binary := x.(*ast.BinaryExpr); is_binary && t.Op == token.COLON {
+ singles = false;
+ }
+ } else {
+ // not the first element - check syntax
+ if singles {
+ if t, is_binary := x.(*ast.BinaryExpr); is_binary && t.Op == token.COLON {
+ P.error(t.X.Pos(), "single value expected; found pair");
+ }
+ } else {
+ if t, is_binary := x.(*ast.BinaryExpr); !is_binary || t.Op != token.COLON {
+ P.error(x.Pos(), "key:value pair expected; found single value");
+ }
+ }
+ }
+
+ list.Push(x);
+
+ if P.tok == token.COMMA {
+ P.next();
+ } else {
+ break;
+ }
+ }
+
+ // convert list
+ elts := make([]ast.Expr, list.Len());
+ for i := 0; i < list.Len(); i++ {
+ elts[i] = list.At(i).(ast.Expr);
+ }
+
+ return elts;
+}
+
+
+func (P *Parser) parseCompositeLit(typ ast.Expr) ast.Expr {
+ if P.trace {
+ defer un(trace(P, "CompositeLit"));
}
- P.expect(close);
- return &ast.Call{loc, open, f, args};
+ lbrace := P.expect(token.LBRACE);
+ var elts []ast.Expr;
+ if P.tok != token.RBRACE {
+ elts = P.parseElementList();
+ }
+ rbrace := P.expect(token.RBRACE);
+ return &ast.CompositeLit{typ, elts, lbrace, rbrace};
}
x := P.parseOperand();
for {
switch P.tok {
- case token.PERIOD: x = P.parseSelectorOrTypeGuard(x);
- case token.LBRACK: x = P.parseIndex(x);
- // TODO fix once we have decided on literal/conversion syntax
- case token.LPAREN: x = P.parseCallOrCompositeLit(x, token.LPAREN, token.RPAREN);
+ case token.PERIOD: x = P.parseSelectorOrTypeAssertion(x);
+ case token.LBRACK: x = P.parseIndexOrSlice(x);
+ case token.LPAREN: x = P.parseCall(x);
case token.LBRACE:
if P.expr_lev >= 0 {
- x = P.parseCallOrCompositeLit(x, token.LBRACE, token.RBRACE);
+ x = P.parseCompositeLit(x);
} else {
return x;
}
loc, tok := P.loc, P.tok;
P.next();
y := P.parseUnaryExpr();
- return &ast.UnaryExpr{loc, tok, y};
- /*
- if lit, ok := y.(*ast.TypeLit); ok && tok == token.MUL {
- // pointer type
- t := ast.NewType(pos, ast.POINTER);
- t.Elt = lit.Typ;
- return &ast.TypeLit{t};
- } else {
- return &ast.UnaryExpr{loc, tok, y};
- }
- */
+ return &ast.UnaryExpr{tok, y, loc};
}
return P.parsePrimaryExpr();
loc, tok := P.loc, P.tok;
P.next();
y := P.parseBinaryExpr(prec + 1);
- x = &ast.BinaryExpr{loc, tok, x, y};
+ x = &ast.BinaryExpr{tok, x, y, loc};
}
}
defer un(trace(P, "SimpleStat"));
}
- loc := P.loc;
x := P.parseExpressionList();
switch P.tok {
}
default:
- if len(x) != 1 {
- P.error(loc, "only one expression allowed");
+ if len(x) > 1 {
+ P.error(x[0].Pos(), "only one expression allowed");
}
if P.tok == token.INC || P.tok == token.DEC {
}
// TODO change ILLEGAL -> NONE
- return &ast.ExpressionStat{loc, token.ILLEGAL, x[0]};
+ return &ast.ExpressionStat{x[0].Pos(), token.ILLEGAL, x[0]};
}
unreachable();
if name, ok := x.(*ast.Ident); ok {
return name;
}
- P.error(x.Loc(), "identifier expected");
- return &ast.Ident{noloc, "BAD"};
+ P.error(x.Pos(), "identifier expected");
+ return &ast.Ident{"BAD", noloc};
}
func (P *Parser) isTypeSwitch(init ast.Stat) (lhs *ast.Ident, rhs ast.Expr) {
if assign, ok := init.(*ast.AssignmentStat); ok {
- if guard, ok := assign.Rhs.(*ast.TypeGuard); ok {
+ if guard, ok := assign.Rhs.(*ast.TypeAssertion); ok {
if tmp, ok := guard.Typ.(*ast.TypeType); ok {
// we appear to have a type switch
// TODO various error checks
// ----------------------------------------------------------------------------
// Declarations
-func (P *Parser) parseImportSpec(loc scanner.Location) *ast.ImportDecl {
+func (P *Parser) parseImportSpec(loc Position) *ast.ImportDecl {
if P.trace {
defer un(trace(P, "ImportSpec"));
}
}
-func (P *Parser) parseConstSpec(loc scanner.Location, comment ast.CommentGroup) *ast.ConstDecl {
+func (P *Parser) parseConstSpec(loc Position, comment ast.CommentGroup) *ast.ConstDecl {
if P.trace {
defer un(trace(P, "ConstSpec"));
}
}
-func (P *Parser) parseTypeSpec(loc scanner.Location, comment ast.CommentGroup) *ast.TypeDecl {
+func (P *Parser) parseTypeSpec(loc Position, comment ast.CommentGroup) *ast.TypeDecl {
if P.trace {
defer un(trace(P, "TypeSpec"));
}
}
-func (P *Parser) parseVarSpec(loc scanner.Location, comment ast.CommentGroup) *ast.VarDecl {
+func (P *Parser) parseVarSpec(loc Position, comment ast.CommentGroup) *ast.VarDecl {
if P.trace {
defer un(trace(P, "VarSpec"));
}
}
-func (P *Parser) parseSpec(loc scanner.Location, comment ast.CommentGroup, keyword int) ast.Decl {
+func (P *Parser) parseSpec(loc Position, comment ast.CommentGroup, keyword int) ast.Decl {
switch keyword {
case token.IMPORT: return P.parseImportSpec(loc);
case token.CONST: return P.parseConstSpec(loc, comment);
// HTML support
func (P *Printer) HtmlIdentifier(x *ast.Ident) {
- P.String(x.Loc_, x.Str);
+ P.String(x.Pos_, x.Str);
/*
obj := x.Obj;
if P.html && obj.Kind != symbolTable.NONE {
func (P *Printer) DoBinaryExpr(x *ast.BinaryExpr) {
- if x.Tok == token.COMMA {
- // (don't use binary expression printing because of different spacing)
- P.Expr(x.X);
- P.Token(x.Loc_, token.COMMA);
- P.separator = blank;
- P.state = inside_list;
- P.Expr(x.Y);
- } else {
- prec := token.Precedence(x.Tok);
- if prec < P.prec {
- P.Token(noloc, token.LPAREN);
- }
- P.Expr1(x.X, prec);
- P.separator = blank;
- P.Token(x.Loc_, x.Tok);
- P.separator = blank;
- P.Expr1(x.Y, prec);
- if prec < P.prec {
- P.Token(noloc, token.RPAREN);
- }
+ prec := token.Precedence(x.Op);
+ if prec < P.prec {
+ P.Token(noloc, token.LPAREN);
+ }
+ P.Expr1(x.X, prec);
+ P.separator = blank;
+ P.Token(x.Pos_, x.Op);
+ P.separator = blank;
+ P.Expr1(x.Y, prec);
+ if prec < P.prec {
+ P.Token(noloc, token.RPAREN);
}
}
if prec < P.prec {
P.Token(noloc, token.LPAREN);
}
- P.Token(x.Loc_, x.Tok);
- if x.Tok == token.RANGE {
- P.separator = blank;
- }
+ P.Token(x.Pos_, x.Op);
P.Expr1(x.X, prec);
if prec < P.prec {
P.Token(noloc, token.RPAREN);
}
-func (P *Printer) DoConcatExpr(x *ast.ConcatExpr) {
- P.Expr1(x.X, token.HighestPrec);
- P.separator = blank;
- P.Expr1(x.Y, token.HighestPrec);
+func (P *Printer) DoBasicLit(x *ast.BasicLit) {
+ // TODO get rid of string conversion here
+ P.String(x.Pos_, string(x.Lit));
}
-func (P *Printer) DoBasicLit(x *ast.BasicLit) {
- // TODO get rid of string conversion here
- P.String(x.Loc_, string(x.Val));
+func (P *Printer) DoStringLit(x *ast.StringLit) {
+ for i, x := range x.Strings {
+ if i > 0 {
+ P.separator = blank;
+ }
+ P.DoBasicLit(x);
+ }
}
func (P *Printer) DoFunctionLit(x *ast.FunctionLit) {
- P.Token(x.Loc_, token.FUNC);
+ P.Token(x.Func, token.FUNC);
P.Signature(x.Typ);
P.separator = blank;
P.Block(x.Body, true);
func (P *Printer) DoGroup(x *ast.Group) {
- P.Token(x.Loc_, token.LPAREN);
+ P.Token(x.Lparen, token.LPAREN);
P.Expr(x.X);
- P.Token(noloc, token.RPAREN);
+ P.Token(x.Rparen, token.RPAREN);
}
func (P *Printer) DoSelector(x *ast.Selector) {
P.Expr1(x.X, token.HighestPrec);
- P.Token(x.Loc_, token.PERIOD);
+ P.Token(x.Period, token.PERIOD);
P.Expr1(x.Sel, token.HighestPrec);
}
-func (P *Printer) DoTypeGuard(x *ast.TypeGuard) {
+func (P *Printer) DoTypeAssertion(x *ast.TypeAssertion) {
P.Expr1(x.X, token.HighestPrec);
- P.Token(x.Loc_, token.PERIOD);
- P.Token(noloc, token.LPAREN);
+ P.Token(x.Period, token.PERIOD);
+ P.Token(x.Lparen, token.LPAREN);
P.Expr(x.Typ);
- P.Token(noloc, token.RPAREN);
+ P.Token(x.Rparen, token.RPAREN);
}
func (P *Printer) DoIndex(x *ast.Index) {
P.Expr1(x.X, token.HighestPrec);
- P.Token(x.Loc_, token.LBRACK);
- P.Expr1(x.I, 0);
- P.Token(noloc, token.RBRACK);
+ P.Token(x.Lbrack, token.LBRACK);
+ P.Expr(x.Index);
+ P.Token(x.Rbrack, token.RBRACK);
+}
+
+
+func (P *Printer) DoSlice(x *ast.Slice) {
+ P.Expr1(x.X, token.HighestPrec);
+ P.Token(x.Lbrack, token.LBRACK);
+ P.Expr(x.Beg);
+ P.Token(x.Colon, token.COLON);
+ P.Expr(x.End);
+ P.Token(x.Rbrack, token.RBRACK);
}
func (P *Printer) DoCall(x *ast.Call) {
- P.Expr1(x.F, token.HighestPrec);
- P.Token(x.Loc_, x.Tok);
- P.Expr(x.Args);
- switch x.Tok {
- case token.LPAREN: P.Token(noloc, token.RPAREN);
- case token.LBRACE: P.Token(noloc, token.RBRACE);
- }
+ P.Expr1(x.Fun, token.HighestPrec);
+ P.Token(x.Lparen, token.LPAREN);
+ P.Exprs(x.Args);
+ P.Token(x.Rparen, token.RPAREN);
+}
+
+
+func (P *Printer) DoCompositeLit(x *ast.CompositeLit) {
+ P.Expr1(x.Typ, token.HighestPrec);
+ P.Token(x.Lbrace, token.LBRACE);
+ P.Exprs(x.Elts);
+ P.Token(x.Rbrace, token.RBRACE);
}
func (P *Printer) DoChannelType(x *ast.ChannelType) {
- switch x.Mode {
+ switch x.Dir {
case ast.FULL:
P.Token(x.Loc_, token.CHAN);
case ast.RECV:
if d.Name != nil {
P.Expr(d.Name);
} else {
- P.String(d.Path.Loc(), ""); // flush pending ';' separator/newlines
+ P.String(d.Path.Pos(), ""); // flush pending ';' separator/newlines
}
P.separator = tab;
- if lit, is_lit := d.Path.(*ast.BasicLit); is_lit && lit.Tok == token.STRING {
- P.HtmlPackageName(lit.Loc_, string(lit.Val));
+ if lit, is_lit := d.Path.(*ast.StringLit); is_lit {
+ // TODO incorrect (string lit could be a list of strings)
+ P.HtmlPackageName(lit.Pos(), string(lit.Strings[0].Lit));
} else {
// we should only reach here for strange imports
// import "foo" "bar"