[dev.typeparams] cmd/compile/internal/syntax: add Walk node vistor from types2

This moves the Walk visitor from the types2 to the syntax
package. There are no changes but for package name adjustments.
Preparation for a more full-fledged node visitor.

Change-Id: I95217e27ff943ac58a7638fb8d1cd347d0d554b0
Reviewed-on: https://go-review.googlesource.com/c/go/+/282556
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>

diff --git a/src/cmd/compile/internal/types2/walk.go b/src/cmd/compile/internal/syntax/walk.go
similarity index 67%
rename from src/cmd/compile/internal/types2/walk.go
rename to src/cmd/compile/internal/syntax/walk.go
index 18cfb28adeb6b5ec00d129a715cce1034720f115..418b26d674340542bc45f713f5749c7e895dffc1 100644 (file)
--- a/src/cmd/compile/internal/types2/walk.go
+++ b/src/cmd/compile/internal/syntax/walk.go
@@ -1,18 +1,12 @@
-// UNREVIEWED
 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // This file implements syntax tree walking.
-// TODO(gri) A more general API should probably be in
-//           the syntax package.
 
-package types2
+package syntax
 
-import (
-       "cmd/compile/internal/syntax"
-       "fmt"
-)
+import "fmt"
 
 // Walk traverses a syntax in pre-order: It starts by calling f(root);
 // root must not be nil. If f returns false (== "continue"), Walk calls
@@ -23,17 +17,17 @@ import (
 // field lists such as type T in "a, b, c T"). Such shared nodes are
 // walked multiple times.
 // TODO(gri) Revisit this design. It may make sense to walk those nodes
-//           only once. A place where this matters is TestResolveIdents.
-func Walk(root syntax.Node, f func(syntax.Node) bool) {
+//           only once. A place where this matters is types2.TestResolveIdents.
+func Walk(root Node, f func(Node) bool) {
        w := walker{f}
        w.node(root)
 }
 
 type walker struct {
-       f func(syntax.Node) bool
+       f func(Node) bool
 }
 
-func (w *walker) node(n syntax.Node) {
+func (w *walker) node(n Node) {
        if n == nil {
                panic("invalid syntax tree: nil node")
        }
@@ -44,18 +38,18 @@ func (w *walker) node(n syntax.Node) {
 
        switch n := n.(type) {
        // packages
-       case *syntax.File:
+       case *File:
                w.node(n.PkgName)
                w.declList(n.DeclList)
 
        // declarations
-       case *syntax.ImportDecl:
+       case *ImportDecl:
                if n.LocalPkgName != nil {
                        w.node(n.LocalPkgName)
                }
                w.node(n.Path)
 
-       case *syntax.ConstDecl:
+       case *ConstDecl:
                w.nameList(n.NameList)
                if n.Type != nil {
                        w.node(n.Type)
@@ -64,12 +58,12 @@ func (w *walker) node(n syntax.Node) {
                        w.node(n.Values)
                }
 
-       case *syntax.TypeDecl:
+       case *TypeDecl:
                w.node(n.Name)
                w.fieldList(n.TParamList)
                w.node(n.Type)
 
-       case *syntax.VarDecl:
+       case *VarDecl:
                w.nameList(n.NameList)
                if n.Type != nil {
                        w.node(n.Type)
@@ -78,7 +72,7 @@ func (w *walker) node(n syntax.Node) {
                        w.node(n.Values)
                }
 
-       case *syntax.FuncDecl:
+       case *FuncDecl:
                if n.Recv != nil {
                        w.node(n.Recv)
                }
@@ -90,36 +84,36 @@ func (w *walker) node(n syntax.Node) {
                }
 
        // expressions
-       case *syntax.BadExpr: // nothing to do
-       case *syntax.Name:
-       case *syntax.BasicLit: // nothing to do
+       case *BadExpr: // nothing to do
+       case *Name: // nothing to do
+       case *BasicLit: // nothing to do
 
-       case *syntax.CompositeLit:
+       case *CompositeLit:
                if n.Type != nil {
                        w.node(n.Type)
                }
                w.exprList(n.ElemList)
 
-       case *syntax.KeyValueExpr:
+       case *KeyValueExpr:
                w.node(n.Key)
                w.node(n.Value)
 
-       case *syntax.FuncLit:
+       case *FuncLit:
                w.node(n.Type)
                w.node(n.Body)
 
-       case *syntax.ParenExpr:
+       case *ParenExpr:
                w.node(n.X)
 
-       case *syntax.SelectorExpr:
+       case *SelectorExpr:
                w.node(n.X)
                w.node(n.Sel)
 
-       case *syntax.IndexExpr:
+       case *IndexExpr:
                w.node(n.X)
                w.node(n.Index)
 
-       case *syntax.SliceExpr:
+       case *SliceExpr:
                w.node(n.X)
                for _, x := range n.Index {
                        if x != nil {
@@ -127,43 +121,43 @@ func (w *walker) node(n syntax.Node) {
                        }
                }
 
-       case *syntax.AssertExpr:
+       case *AssertExpr:
                w.node(n.X)
                w.node(n.Type)
 
-       case *syntax.TypeSwitchGuard:
+       case *TypeSwitchGuard:
                if n.Lhs != nil {
                        w.node(n.Lhs)
                }
                w.node(n.X)
 
-       case *syntax.Operation:
+       case *Operation:
                w.node(n.X)
                if n.Y != nil {
                        w.node(n.Y)
                }
 
-       case *syntax.CallExpr:
+       case *CallExpr:
                w.node(n.Fun)
                w.exprList(n.ArgList)
 
-       case *syntax.ListExpr:
+       case *ListExpr:
                w.exprList(n.ElemList)
 
        // types
-       case *syntax.ArrayType:
+       case *ArrayType:
                if n.Len != nil {
                        w.node(n.Len)
                }
                w.node(n.Elem)
 
-       case *syntax.SliceType:
+       case *SliceType:
                w.node(n.Elem)
 
-       case *syntax.DotsType:
+       case *DotsType:
                w.node(n.Elem)
 
-       case *syntax.StructType:
+       case *StructType:
                w.fieldList(n.FieldList)
                for _, t := range n.TagList {
                        if t != nil {
@@ -171,65 +165,65 @@ func (w *walker) node(n syntax.Node) {
                        }
                }
 
-       case *syntax.Field:
+       case *Field:
                if n.Name != nil {
                        w.node(n.Name)
                }
                w.node(n.Type)
 
-       case *syntax.InterfaceType:
+       case *InterfaceType:
                w.fieldList(n.MethodList)
 
-       case *syntax.FuncType:
+       case *FuncType:
                w.fieldList(n.ParamList)
                w.fieldList(n.ResultList)
 
-       case *syntax.MapType:
+       case *MapType:
                w.node(n.Key)
                w.node(n.Value)
 
-       case *syntax.ChanType:
+       case *ChanType:
                w.node(n.Elem)
 
        // statements
-       case *syntax.EmptyStmt: // nothing to do
+       case *EmptyStmt: // nothing to do
 
-       case *syntax.LabeledStmt:
+       case *LabeledStmt:
                w.node(n.Label)
                w.node(n.Stmt)
 
-       case *syntax.BlockStmt:
+       case *BlockStmt:
                w.stmtList(n.List)
 
-       case *syntax.ExprStmt:
+       case *ExprStmt:
                w.node(n.X)
 
-       case *syntax.SendStmt:
+       case *SendStmt:
                w.node(n.Chan)
                w.node(n.Value)
 
-       case *syntax.DeclStmt:
+       case *DeclStmt:
                w.declList(n.DeclList)
 
-       case *syntax.AssignStmt:
+       case *AssignStmt:
                w.node(n.Lhs)
                w.node(n.Rhs)
 
-       case *syntax.BranchStmt:
+       case *BranchStmt:
                if n.Label != nil {
                        w.node(n.Label)
                }
                // Target points to nodes elsewhere in the syntax tree
 
-       case *syntax.CallStmt:
+       case *CallStmt:
                w.node(n.Call)
 
-       case *syntax.ReturnStmt:
+       case *ReturnStmt:
                if n.Results != nil {
                        w.node(n.Results)
                }
 
-       case *syntax.IfStmt:
+       case *IfStmt:
                if n.Init != nil {
                        w.node(n.Init)
                }
@@ -239,7 +233,7 @@ func (w *walker) node(n syntax.Node) {
                        w.node(n.Else)
                }
 
-       case *syntax.ForStmt:
+       case *ForStmt:
                if n.Init != nil {
                        w.node(n.Init)
                }
@@ -251,7 +245,7 @@ func (w *walker) node(n syntax.Node) {
                }
                w.node(n.Body)
 
-       case *syntax.SwitchStmt:
+       case *SwitchStmt:
                if n.Init != nil {
                        w.node(n.Init)
                }
@@ -262,25 +256,25 @@ func (w *walker) node(n syntax.Node) {
                        w.node(s)
                }
 
-       case *syntax.SelectStmt:
+       case *SelectStmt:
                for _, s := range n.Body {
                        w.node(s)
                }
 
        // helper nodes
-       case *syntax.RangeClause:
+       case *RangeClause:
                if n.Lhs != nil {
                        w.node(n.Lhs)
                }
                w.node(n.X)
 
-       case *syntax.CaseClause:
+       case *CaseClause:
                if n.Cases != nil {
                        w.node(n.Cases)
                }
                w.stmtList(n.Body)
 
-       case *syntax.CommClause:
+       case *CommClause:
                if n.Comm != nil {
                        w.node(n.Comm)
                }
@@ -291,31 +285,31 @@ func (w *walker) node(n syntax.Node) {
        }
 }
 
-func (w *walker) declList(list []syntax.Decl) {
+func (w *walker) declList(list []Decl) {
        for _, n := range list {
                w.node(n)
        }
 }
 
-func (w *walker) exprList(list []syntax.Expr) {
+func (w *walker) exprList(list []Expr) {
        for _, n := range list {
                w.node(n)
        }
 }
 
-func (w *walker) stmtList(list []syntax.Stmt) {
+func (w *walker) stmtList(list []Stmt) {
        for _, n := range list {
                w.node(n)
        }
 }
 
-func (w *walker) nameList(list []*syntax.Name) {
+func (w *walker) nameList(list []*Name) {
        for _, n := range list {
                w.node(n)
        }
 }
 
-func (w *walker) fieldList(list []*syntax.Field) {
+func (w *walker) fieldList(list []*Field) {
        for _, n := range list {
                w.node(n)
        }

diff --git a/src/cmd/compile/internal/types2/resolver_test.go b/src/cmd/compile/internal/types2/resolver_test.go
index cdfdba6b43d13dce8fbff6bebf6eec54939d07c5..983e8ec4d68180b1bc1ab7e4d015b500dc593377 100644 (file)
--- a/src/cmd/compile/internal/types2/resolver_test.go
+++ b/src/cmd/compile/internal/types2/resolver_test.go
@@ -144,7 +144,7 @@ func TestResolveIdents(t *testing.T) {
 
        // check that qualified identifiers are resolved
        for _, f := range files {
-               Walk(f, func(n syntax.Node) bool {
+               syntax.Walk(f, func(n syntax.Node) bool {
                        if s, ok := n.(*syntax.SelectorExpr); ok {
                                if x, ok := s.X.(*syntax.Name); ok {
                                        obj := uses[x]
@@ -172,13 +172,13 @@ func TestResolveIdents(t *testing.T) {
 
        // Check that each identifier in the source is found in uses or defs or both.
        // We need the foundUses/Defs maps (rather then just deleting the found objects
-       // from the uses and defs maps) because Walk traverses shared nodes multiple
+       // from the uses and defs maps) because syntax.Walk traverses shared nodes multiple
        // times (e.g. types in field lists such as "a, b, c int").
        foundUses := make(map[*syntax.Name]bool)
        foundDefs := make(map[*syntax.Name]bool)
        var both []string
        for _, f := range files {
-               Walk(f, func(n syntax.Node) bool {
+               syntax.Walk(f, func(n syntax.Node) bool {
                        if x, ok := n.(*syntax.Name); ok {
                                var objects int
                                if _, found := uses[x]; found {