fix/finish s/rule/node/g rename

grammar/expressions.go

@@ -12,14 +12,14 @@ type TestlistStarExpression struct {
 }
 
 func NewTestListStarExpression() *TestlistStarExpression {
-	rule := &TestlistStarExpression{}
-	rule.initBaseNode(symbol.TESTLIST_STAR_EXPR)
-	return rule
+	node := &TestlistStarExpression{}
+	node.initBaseNode(symbol.TESTLIST_STAR_EXPR)
+	return node
 }
 
-func (rule *TestlistStarExpression) expressionStatementChild() {}
-func (rule *TestlistStarExpression) SetChild(n TestlistStarExpressionChild) {
-	rule.ParentNode.SetChild(n)
+func (node *TestlistStarExpression) expressionStatementChild() {}
+func (node *TestlistStarExpression) SetChild(n TestlistStarExpressionChild) {
+	node.ParentNode.SetChild(n)
 }
 
 type ComparisonChild interface {
@@ -32,14 +32,14 @@ type Comparison struct {
 }
 
 func NewComparison() *Comparison {
-	rule := &Comparison{}
-	rule.initBaseNode(symbol.COMPARISON)
-	rule.initListNode()
-	return rule
+	node := &Comparison{}
+	node.initBaseNode(symbol.COMPARISON)
+	node.initListNode()
+	return node
 }
 
-func (rule *Comparison) notTestChild()            {}
-func (rule *Comparison) Append(n ComparisonChild) { rule.ListNode.Append(n) }
+func (node *Comparison) notTestChild()            {}
+func (node *Comparison) Append(n ComparisonChild) { node.ListNode.Append(n) }
 
 type ExpressionChild interface {
 	Node
@@ -51,14 +51,14 @@ type Expression struct {
 }
 
 func NewExpression() *Expression {
-	rule := &Expression{}
-	rule.initBaseNode(symbol.EXPR)
-	rule.initListNode()
-	return rule
+	node := &Expression{}
+	node.initBaseNode(symbol.EXPR)
+	node.initListNode()
+	return node
 }
 
-func (rule *Expression) comparisonChild()         {}
-func (rule *Expression) Append(n ExpressionChild) { rule.ListNode.Append(n) }
+func (node *Expression) comparisonChild()         {}
+func (node *Expression) Append(n ExpressionChild) { node.ListNode.Append(n) }
 
 type XorExpressionChild interface {
 	Node
@@ -70,14 +70,14 @@ type XorExpression struct {
 }
 
 func NewXorExpression() *XorExpression {
-	rule := &XorExpression{}
-	rule.initBaseNode(symbol.XOR_EXPR)
-	rule.initListNode()
-	return rule
+	node := &XorExpression{}
+	node.initBaseNode(symbol.XOR_EXPR)
+	node.initListNode()
+	return node
 }
 
-func (rule *XorExpression) expressionChild()            {}
-func (rule *XorExpression) Append(n XorExpressionChild) { rule.ListNode.Append(n) }
+func (node *XorExpression) expressionChild()            {}
+func (node *XorExpression) Append(n XorExpressionChild) { node.ListNode.Append(n) }
 
 type AndExpressionChild interface {
 	Node
@@ -89,14 +89,14 @@ type AndExpression struct {
 }
 
 func NewAndExpression() *AndExpression {
-	rule := &AndExpression{}
-	rule.initBaseNode(symbol.AND_EXPR)
-	rule.initListNode()
-	return rule
+	node := &AndExpression{}
+	node.initBaseNode(symbol.AND_EXPR)
+	node.initListNode()
+	return node
 }
 
-func (rule *AndExpression) xorExpressionChild()         {}
-func (rule *AndExpression) Append(n AndExpressionChild) { rule.ListNode.Append(n) }
+func (node *AndExpression) xorExpressionChild()         {}
+func (node *AndExpression) Append(n AndExpressionChild) { node.ListNode.Append(n) }
 
 type ShiftExpressionChild interface {
 	Node
@@ -108,14 +108,14 @@ type ShiftExpression struct {
 }
 
 func NewShiftExpression() *ShiftExpression {
-	rule := &ShiftExpression{}
-	rule.initBaseNode(symbol.SHIFT_EXPR)
-	rule.initListNode()
-	return rule
+	node := &ShiftExpression{}
+	node.initBaseNode(symbol.SHIFT_EXPR)
+	node.initListNode()
+	return node
 }
 
-func (rule *ShiftExpression) andExpressionChild()           {}
-func (rule *ShiftExpression) Append(n ShiftExpressionChild) { rule.ListNode.Append(n) }
+func (node *ShiftExpression) andExpressionChild()           {}
+func (node *ShiftExpression) Append(n ShiftExpressionChild) { node.ListNode.Append(n) }
 
 type ArithmeticExpressionChild interface {
 	Node
@@ -127,14 +127,14 @@ type ArithmeticExpression struct {
 }
 
 func NewArithmeticExpression() *ArithmeticExpression {
-	rule := &ArithmeticExpression{}
-	rule.initBaseNode(symbol.ARITH_EXPR)
-	rule.initListNode()
-	return rule
+	node := &ArithmeticExpression{}
+	node.initBaseNode(symbol.ARITH_EXPR)
+	node.initListNode()
+	return node
 }
 
-func (rule *ArithmeticExpression) shiftExpressionChild()              {}
-func (rule *ArithmeticExpression) Append(n ArithmeticExpressionChild) { rule.ListNode.Append(n) }
+func (node *ArithmeticExpression) shiftExpressionChild()              {}
+func (node *ArithmeticExpression) Append(n ArithmeticExpressionChild) { node.ListNode.Append(n) }
 
 type TermChild interface {
 	Node
@@ -146,14 +146,14 @@ type Term struct {
 }
 
 func NewTerm() *Term {
-	rule := &Term{}
-	rule.initBaseNode(symbol.TERM)
-	rule.initListNode()
-	return rule
+	node := &Term{}
+	node.initBaseNode(symbol.TERM)
+	node.initListNode()
+	return node
 }
 
-func (rule *Term) arithmeticExpressionChild() {}
-func (rule *Term) Append(n TermChild)         { rule.ListNode.Append(n) }
+func (node *Term) arithmeticExpressionChild() {}
+func (node *Term) Append(n TermChild)         { node.ListNode.Append(n) }
 
 type FactorChild interface {
 	Node
@@ -165,16 +165,16 @@ type Factor struct {
 }
 
 func NewFactor() *Factor {
-	rule := &Factor{}
-	rule.initBaseNode(symbol.FACTOR)
-	rule.initListNode()
-	return rule
+	node := &Factor{}
+	node.initBaseNode(symbol.FACTOR)
+	node.initListNode()
+	return node
 }
 
-func (rule *Factor) factorChild()         {}
-func (rule *Factor) powerChild()          {}
-func (rule *Factor) termChild()           {}
-func (rule *Factor) Append(n FactorChild) { rule.ListNode.Append(n) }
+func (node *Factor) factorChild()         {}
+func (node *Factor) powerChild()          {}
+func (node *Factor) termChild()           {}
+func (node *Factor) Append(n FactorChild) { node.ListNode.Append(n) }
 
 type PowerChild interface {
 	Node
@@ -186,14 +186,14 @@ type Power struct {
 }
 
 func NewPower() *Power {
-	rule := &Power{}
-	rule.initBaseNode(symbol.POWER)
-	rule.initListNode()
-	return rule
+	node := &Power{}
+	node.initBaseNode(symbol.POWER)
+	node.initListNode()
+	return node
 }
 
-func (rule *Power) factorChild()        {}
-func (rule *Power) Append(n PowerChild) { rule.ListNode.Append(n) }
+func (node *Power) factorChild()        {}
+func (node *Power) Append(n PowerChild) { node.ListNode.Append(n) }
 
 type AtomExpressionChild interface {
 	Node
@@ -205,14 +205,14 @@ type AtomExpression struct {
 }
 
 func NewAtomExpression() *AtomExpression {
-	rule := &AtomExpression{}
-	rule.initBaseNode(symbol.ATOM_EXPR)
-	rule.initListNode()
-	return rule
+	node := &AtomExpression{}
+	node.initBaseNode(symbol.ATOM_EXPR)
+	node.initListNode()
+	return node
 }
 
-func (rule *AtomExpression) powerChild()                  {}
-func (rule *AtomExpression) Append(n AtomExpressionChild) { rule.ListNode.Append(n) }
+func (node *AtomExpression) powerChild()                  {}
+func (node *AtomExpression) Append(n AtomExpressionChild) { node.ListNode.Append(n) }
 
 type AtomChild interface {
 	Node
@@ -224,14 +224,14 @@ type Atom struct {
 }
 
 func NewAtom() *Atom {
-	rule := &Atom{}
-	rule.initBaseNode(symbol.ATOM)
-	rule.initListNode()
-	return rule
+	node := &Atom{}
+	node.initBaseNode(symbol.ATOM)
+	node.initListNode()
+	return node
 }
 
-func (rule *Atom) atomExpressionChild() {}
-func (rule *Atom) Append(n AtomChild)   { rule.ListNode.Append(n) }
+func (node *Atom) atomExpressionChild() {}
+func (node *Atom) Append(n AtomChild)   { node.ListNode.Append(n) }
 
 type TrailerChild interface {
 	Node
@@ -243,11 +243,11 @@ type Trailer struct {
 }
 
 func NewTrailer() *Trailer {
-	rule := &Trailer{}
-	rule.initBaseNode(symbol.TRAILER)
-	rule.initListNode()
-	return rule
+	node := &Trailer{}
+	node.initBaseNode(symbol.TRAILER)
+	node.initListNode()
+	return node
 }
 
-func (rule *Trailer) atomExpressionChild()  {}
-func (rule *Trailer) Append(n TrailerChild) { rule.ListNode.Append(n) }
+func (node *Trailer) atomExpressionChild()  {}
+func (node *Trailer) Append(n TrailerChild) { node.ListNode.Append(n) }

grammar/nodes.go

@@ -21,20 +21,20 @@ func NewTokenNode(tok *token.Token) *TokenNode {
 		Token: tok,
 	}
 }
-func (rule *TokenNode) atomChild()                {}
-func (rule *TokenNode) atomExpressionChild()      {}
-func (rule *TokenNode) comparisonChild()          {}
-func (rule *TokenNode) expressionStatementChild() {}
-func (rule *TokenNode) factorChild()              {}
-func (rule *TokenNode) fileInputChild()           {}
-func (rule *TokenNode) shiftExpressionChild()     {}
-func (rule *TokenNode) simpleStatementChild()     {}
-func (rule *TokenNode) trailerChild()             {}
-func (rule *TokenNode) Name() string              { return token.TokenNames[rule.Token.ID] }
-func (rule *TokenNode) Repr() []interface{} {
+func (node *TokenNode) atomChild()                {}
+func (node *TokenNode) atomExpressionChild()      {}
+func (node *TokenNode) comparisonChild()          {}
+func (node *TokenNode) expressionStatementChild() {}
+func (node *TokenNode) factorChild()              {}
+func (node *TokenNode) fileInputChild()           {}
+func (node *TokenNode) shiftExpressionChild()     {}
+func (node *TokenNode) simpleStatementChild()     {}
+func (node *TokenNode) trailerChild()             {}
+func (node *TokenNode) Name() string              { return token.TokenNames[node.Token.ID] }
+func (node *TokenNode) Repr() []interface{} {
 	parts := make([]interface{}, 0)
-	parts = append(parts, rule.Name())
-	literal := fmt.Sprintf("%#v", rule.Token.Literal)
+	parts = append(parts, node.Name())
+	literal := fmt.Sprintf("%#v", node.Token.Literal)
 	return append(parts, literal)
 }
 
@@ -43,20 +43,20 @@ type BaseNode struct {
 	child Node
 }
 
-func (rule *BaseNode) initBaseNode(id symbol.SymbolID) { rule.ID = id }
-func (rule *BaseNode) Name() string                    { return symbol.SymbolNames[rule.ID] }
-func (rule *BaseNode) Repr() (parts []interface{})     { return append(parts, rule.Name()) }
+func (node *BaseNode) initBaseNode(id symbol.SymbolID) { node.ID = id }
+func (node *BaseNode) Name() string                    { return symbol.SymbolNames[node.ID] }
+func (node *BaseNode) Repr() (parts []interface{})     { return append(parts, node.Name()) }
 
 type ParentNode struct {
 	BaseNode
 	child Node
 }
 
-func (rule *ParentNode) SetChild(n Node) { rule.child = n }
-func (rule *ParentNode) Child() Node     { return rule.child }
-func (rule *ParentNode) Repr() (parts []interface{}) {
-	parts = rule.BaseNode.Repr()
-	child := rule.Child()
+func (node *ParentNode) SetChild(n Node) { node.child = n }
+func (node *ParentNode) Child() Node     { return node.child }
+func (node *ParentNode) Repr() (parts []interface{}) {
+	parts = node.BaseNode.Repr()
+	child := node.Child()
 	if child != nil {
 		parts = append(parts, child.Repr())
 	}
@@ -68,13 +68,13 @@ type ListNode struct {
 	children []Node
 }
 
-func (rule *ListNode) initListNode()    { rule.children = make([]Node, 0) }
-func (rule *ListNode) Length() int      { return len(rule.children) }
-func (rule *ListNode) Children() []Node { return rule.children }
-func (rule *ListNode) Append(n Node)    { rule.children = append(rule.children, n) }
-func (rule *ListNode) Repr() (parts []interface{}) {
-	parts = rule.BaseNode.Repr()
-	children := rule.Children()
+func (node *ListNode) initListNode()    { node.children = make([]Node, 0) }
+func (node *ListNode) Length() int      { return len(node.children) }
+func (node *ListNode) Children() []Node { return node.children }
+func (node *ListNode) Append(n Node)    { node.children = append(node.children, n) }
+func (node *ListNode) Repr() (parts []interface{}) {
+	parts = node.BaseNode.Repr()
+	children := node.Children()
 	for _, child := range children {
 		parts = append(parts, child.Repr())
 	}

grammar/start.go

@@ -12,10 +12,10 @@ type FileInput struct {
 }
 
 func NewFileInput() *FileInput {
-	rule := &FileInput{}
-	rule.initBaseNode(symbol.FILE_INPUT)
-	rule.initListNode()
-	return rule
+	node := &FileInput{}
+	node.initBaseNode(symbol.FILE_INPUT)
+	node.initListNode()
+	return node
 }
 
-func (rule *FileInput) Append(n FileInputChild) { rule.ListNode.Append(n) }
+func (node *FileInput) Append(n FileInputChild) { node.ListNode.Append(n) }

grammar/statements.go

@@ -12,13 +12,13 @@ type Statement struct {
 }
 
 func NewStatement() *Statement {
-	rule := &Statement{}
-	rule.initBaseNode(symbol.STMT)
-	return rule
+	node := &Statement{}
+	node.initBaseNode(symbol.STMT)
+	return node
 }
 
-func (rule *Statement) fileInputChild()           {}
-func (rule *Statement) SetChild(n StatementChild) { rule.ParentNode.SetChild(n) }
+func (node *Statement) fileInputChild()           {}
+func (node *Statement) SetChild(n StatementChild) { node.ParentNode.SetChild(n) }
 
 type SimpleStatementChild interface {
 	Node
@@ -30,25 +30,25 @@ type SimpleStatement struct {
 }
 
 func NewSimpleStatement() *SimpleStatement {
-	rule := &SimpleStatement{}
-	rule.initBaseNode(symbol.SIMPLE_STMT)
-	rule.initListNode()
-	return rule
+	node := &SimpleStatement{}
+	node.initBaseNode(symbol.SIMPLE_STMT)
+	node.initListNode()
+	return node
 }
 
-func (rule *SimpleStatement) stmtChild()                    {}
-func (rule *SimpleStatement) Append(n SimpleStatementChild) { rule.ListNode.Append(n) }
+func (node *SimpleStatement) stmtChild()                    {}
+func (node *SimpleStatement) Append(n SimpleStatementChild) { node.ListNode.Append(n) }
 
 type CompoundStatement struct {
 	BaseNode
 }
 
 func NewCompoundStatement() *CompoundStatement {
-	rule := &CompoundStatement{}
-	rule.initBaseNode(symbol.COMPOUND_STMT)
-	return rule
+	node := &CompoundStatement{}
+	node.initBaseNode(symbol.COMPOUND_STMT)
+	return node
 }
-func (rule *CompoundStatement) stmtChild() {}
+func (node *CompoundStatement) stmtChild() {}
 
 type SmallStatementChild interface {
 	Node
@@ -60,13 +60,13 @@ type SmallStatement struct {
 }
 
 func NewSmallStatement() *SmallStatement {
-	rule := &SmallStatement{}
-	rule.initBaseNode(symbol.SMALL_STMT)
-	return rule
+	node := &SmallStatement{}
+	node.initBaseNode(symbol.SMALL_STMT)
+	return node
 }
 
-func (rule *SmallStatement) simpleStatementChild()          {}
-func (rule *SmallStatement) SetChild(n SmallStatementChild) { rule.ParentNode.SetChild(n) }
+func (node *SmallStatement) simpleStatementChild()          {}
+func (node *SmallStatement) SetChild(n SmallStatementChild) { node.ParentNode.SetChild(n) }
 
 type ExpressionStatementChild interface {
 	Node
@@ -79,11 +79,11 @@ type ExpressionStatement struct {
 }
 
 func NewExpressionStatement() *ExpressionStatement {
-	rule := &ExpressionStatement{}
-	rule.initBaseNode(symbol.EXPR_STMT)
-	rule.initListNode()
-	return rule
+	node := &ExpressionStatement{}
+	node.initBaseNode(symbol.EXPR_STMT)
+	node.initListNode()
+	return node
 }
 
-func (rule *ExpressionStatement) smallStmtChild()                   {}
-func (rule *ExpressionStatement) Append(n ExpressionStatementChild) { rule.ListNode.Append(n) }
+func (node *ExpressionStatement) smallStmtChild()                   {}
+func (node *ExpressionStatement) Append(n ExpressionStatementChild) { node.ListNode.Append(n) }

grammar/tests.go

@@ -12,14 +12,14 @@ type Test struct {
 }
 
 func NewTest() *Test {
-	rule := &Test{}
-	rule.initBaseNode(symbol.TEST)
-	return rule
+	node := &Test{}
+	node.initBaseNode(symbol.TEST)
+	return node
 }
 
-func (rule *Test) testlistStarExpressionChild() {}
-func (rule *Test) testChild()                   {}
-func (rule *Test) Append(n TestChild)           { rule.ListNode.Append(n) }
+func (node *Test) testlistStarExpressionChild() {}
+func (node *Test) testChild()                   {}
+func (node *Test) Append(n TestChild)           { node.ListNode.Append(n) }
 
 type OrTestChild interface {
 	Node
@@ -31,13 +31,13 @@ type OrTest struct {
 }
 
 func NewOrTest() *OrTest {
-	rule := &OrTest{}
-	rule.initBaseNode(symbol.OR_TEST)
-	return rule
+	node := &OrTest{}
+	node.initBaseNode(symbol.OR_TEST)
+	return node
 }
 
-func (rule *OrTest) testChild()           {}
-func (rule *OrTest) Append(n OrTestChild) { rule.ListNode.Append(n) }
+func (node *OrTest) testChild()           {}
+func (node *OrTest) Append(n OrTestChild) { node.ListNode.Append(n) }
 
 type AndTestChild interface {
 	Node
@@ -49,13 +49,13 @@ type AndTest struct {
 }
 
 func NewAndTest() *AndTest {
-	rule := &AndTest{}
-	rule.initBaseNode(symbol.AND_TEST)
-	return rule
+	node := &AndTest{}
+	node.initBaseNode(symbol.AND_TEST)
+	return node
 }
 
-func (rule *AndTest) orTestChild()          {}
-func (rule *AndTest) Append(n AndTestChild) { rule.ListNode.Append(n) }
+func (node *AndTest) orTestChild()          {}
+func (node *AndTest) Append(n AndTestChild) { node.ListNode.Append(n) }
 
 type NotTestChild interface {
 	Node
@@ -67,11 +67,11 @@ type NotTest struct {
 }
 
 func NewNotTest() *NotTest {
-	rule := &NotTest{}
-	rule.initBaseNode(symbol.NOT_TEST)
-	return rule
+	node := &NotTest{}
+	node.initBaseNode(symbol.NOT_TEST)
+	return node
 }
 
-func (rule *NotTest) notTestChild()           {}
-func (rule *NotTest) andTestChild()           {}
-func (rule *NotTest) SetChild(n NotTestChild) { rule.ParentNode.SetChild(n) }
+func (node *NotTest) notTestChild()           {}
+func (node *NotTest) andTestChild()           {}
+func (node *NotTest) SetChild(n NotTestChild) { node.ParentNode.SetChild(n) }