// findIdentifier looks for an identifier at byte-offset searchpos // inside the parsed source represented by node. // If it is part of a selector expression, it returns // that expression rather than the identifier itself. // // As a special case, if it finds an import // spec, it returns ImportSpec. // func findIdentifier(f *ast.File, searchpos int) ast.Node { ec := make(chan ast.Node) go func() { visit := func(n ast.Node) bool { var startPos token.Pos switch n := n.(type) { case *ast.Ident: startPos = n.NamePos case *ast.SelectorExpr: startPos = n.Sel.NamePos case *ast.ImportSpec: startPos = n.Pos() default: return true } start := types.FileSet.Position(startPos).Offset end := start + int(n.End()-startPos) if start <= searchpos && searchpos <= end { ec <- n runtime.Goexit() } return true } ast.Walk(FVisitor(visit), f) ec <- nil }() ev := <-ec if ev == nil { fail("no identifier found") } return ev }
// findIdentifier looks for an identifier at byte-offset searchpos // inside the parsed source represented by node. // If it is part of a selector expression, it returns // that expression rather than the identifier itself. // // As a special case, if it finds an import // spec, it returns ImportSpec. // func findIdentifier(f *ast.File, searchpos int) ast.Node { ec := make(chan ast.Node) found := func(startPos, endPos token.Pos) bool { start := types.FileSet.Position(startPos).Offset end := start + int(endPos-startPos) return start <= searchpos && searchpos <= end } go func() { var visit func(ast.Node) bool visit = func(n ast.Node) bool { var startPos token.Pos switch n := n.(type) { default: return true case *ast.Ident: startPos = n.NamePos case *ast.SelectorExpr: startPos = n.Sel.NamePos case *ast.ImportSpec: startPos = n.Pos() case *ast.StructType: // If we find an anonymous bare field in a // struct type, its definition points to itself, // but we actually want to go elsewhere, // so assume (dubiously) that the expression // works globally and return a new node for it. for _, field := range n.Fields.List { if field.Names != nil { continue } t := field.Type if pt, ok := field.Type.(*ast.StarExpr); ok { t = pt.X } if id, ok := t.(*ast.Ident); ok { if found(id.NamePos, id.End()) { ec <- parseExpr(f.Scope, id.Name) runtime.Goexit() } } } return true } if found(startPos, n.End()) { ec <- n runtime.Goexit() } return true } ast.Walk(FVisitor(visit), f) ec <- nil }() ev := <-ec if ev == nil { fail("no identifier found") } return ev }
func ScanCmd(args []string) (err error) { ScanAllForImports(LocalRoot) for _, path := range args { pkg := LocalImporter(path) ast.Walk(DepthWalker(0), pkg) } return }
// constainsNode returns true if x is found somewhere // inside node. func containsNode(node, x ast.Node) (found bool) { ast.Walk(funcVisitor(func(n ast.Node) bool { if !found { found = n == x } return !found }), node) return }
func GetUniqueIdent(files []*ast.File, candidate string) (id string) { ic := make(IdentCollector) for _, file := range files { ast.Walk(ic, file) } id = candidate for i := 0; ic[id]; i++ { id = fmt.Sprintf("%s_%d", candidate, i) } return }
func (this *SingleMover) CollectNameObjs(name string) (found bool) { for _, file := range this.pkg.Files { fdl := DeclFinder{oldname: name} ast.Walk(&fdl, file) if fdl.Obj != nil { found = true this.moveNodes[fdl.Node] = fdl.Obj mf := MethodFinder{ Receiver: fdl.Obj, NodeObjs: make(map[ast.Node]*ast.Object), } ast.Walk(&mf, this.pkg) for node, obj := range mf.NodeObjs { this.moveNodes[node] = obj } } } return }
func (this ListImportWalker) Visit(node ast.Node) ast.Visitor { switch n := node.(type) { case *ast.SelectorExpr: ast.Walk(this, n.X) //skip n.Sel, we don't need to import for it return nil case *ast.Ident: obj, typ := types.ExprType(n, LocalImporter) if is, ok := typ.Node.(*ast.ImportSpec); ok { this[obj] = is } } return this }
func TestOneFile(t *testing.T) { code, offsetMap := translateSymbols(testCode) //fmt.Printf("------------------- {%s}\n", code) f, err := parser.ParseFile(FileSet, "xx.go", code, 0, ast.NewScope(parser.Universe)) if err != nil { t.Fatalf("parse failed: %v", err) } v := make(identVisitor) go func() { ast.Walk(v, f) close(v) }() for e := range v { testExpr(t, FileSet, e, offsetMap) } }
func (v identVisitor) Visit(n ast.Node) ast.Visitor { switch n := n.(type) { case *ast.Ident: if strings.HasPrefix(n.Name, prefix) { v <- n } return nil case *ast.SelectorExpr: ast.Walk(v, n.X) if strings.HasPrefix(n.Sel.Name, prefix) { v <- n } return nil } return v }
//Look at the imports, and build up ImportedBy func ScanForImports(path string) (err error) { sourcefiles, _ := filepath.Glob(filepath.Join(path, "*.go")) dirpkgs, err := parser.ParseFiles(AllSourceTops, sourcefiles, parser.ImportsOnly) if err != nil { fmt.Println(err) } //take the first non-main. otherwise, main is ok. var prime *ast.Package for name, pkg := range dirpkgs { prime = pkg if name != "main" { break } } if prime == nil { return } PackageTops[path] = prime is := make(ImportScanner) ast.Walk(is, prime) if v, ok := is["."]; !v && ok { return MakeErr("gorf can not deal with unnamed import in '%s'", path) } for path, _ := range is { if strings.HasPrefix(path, ".") { return MakeErr("gorf can not deal with relative import in '%s'", path) } } for imp := range is { ImportedBy[imp] = append(ImportedBy[imp], path) } return }
func MoveCmd(args []string) (err error) { if len(args) < 2 { return MakeErr("Usage: gorf [flags] move <old path> <new path> [<name>+]") } oldpath, newpath := filepath.Clean(args[0]), filepath.Clean(args[1]) if oldpath == newpath { return MakeErr("Old path and new path are the same") } err = ScanAllForImports(LocalRoot) if err != nil { return } PreloadImportedBy(oldpath) defer func() { if err != nil { UndoCmd([]string{}) } }() if PackageTops[oldpath] == nil { return MakeErr("Old path %s has no local package", oldpath) } if PackageTops[newpath] != nil { return MakeErr("New path %s already has a package (did you mean to merge?)", newpath) } pkg := LocalImporter(oldpath) if len(args) >= 3 { err = MoveSingle(oldpath, newpath, args[2:]) return } os.MkdirAll(filepath.Join(LocalRoot, newpath), 0755) for fpath := range pkg.Files { _, base := filepath.Split(fpath) npath := filepath.Join(LocalRoot, newpath, base) _ = npath err = MoveSource(fpath, npath) if err != nil { return } } for _, ip := range ImportedBy[QuotePath(oldpath)] { ipkg := LocalImporter(ip) for fpath, file := range ipkg.Files { pcw := PathChangeWalker{OldPath: oldpath, NewPath: newpath} ast.Walk(&pcw, file) if pcw.Updated { err = RewriteSource(fpath, file) if err != nil { return } } } } return }
func checkExprs(t *testing.T, pkg *ast.File, importer Importer) { var visit astVisitor stopped := false visit = func(n ast.Node) bool { if stopped { return false } mustResolve := false var e ast.Expr switch n := n.(type) { case *ast.ImportSpec: // If the file imports a package to ".", abort // because we don't support that (yet). if n.Name != nil && n.Name.Name == "." { stopped = true return false } return true case *ast.FuncDecl: // add object for init functions if n.Recv == nil && n.Name.Name == "init" { n.Name.Obj = ast.NewObj(ast.Fun, "init") } return true case *ast.Ident: if n.Name == "_" { return false } e = n mustResolve = true case *ast.KeyValueExpr: // don't try to resolve the key part of a key-value // because it might be a map key which doesn't // need resolving, and we can't tell without being // complicated with types. ast.Walk(visit, n.Value) return false case *ast.SelectorExpr: ast.Walk(visit, n.X) e = n mustResolve = true case *ast.File: for _, d := range n.Decls { ast.Walk(visit, d) } return false case ast.Expr: e = n default: return true } defer func() { if err := recover(); err != nil { t.Fatalf("panic (%v) on %T", err, e) //t.Fatalf("panic (%v) on %v at %v\n", err, e, FileSet.Position(e.Pos())) } }() obj, _ := ExprType(e, importer) if obj == nil && mustResolve { t.Errorf("no object for %v(%p, %T) at %v\n", e, e, e, FileSet.Position(e.Pos())) } return false } ast.Walk(visit, pkg) }
func MoveSingle(oldpath, newpath string, names []string) (err error) { for _, name := range names { if !IsLegalIdentifier(name) { return MakeErr("Name %s is not a legal identifier", name) } } var sm SingleMover pkg := LocalImporter(oldpath) sm.pkg = pkg sm.oldpath = oldpath sm.newpath = newpath moveNodes := make(map[ast.Node]*ast.Object) sm.moveNodes = moveNodes moveObjs := make(map[*ast.Object]ast.Node) sm.moveObjs = moveObjs allObjs := make(AllDeclFinder) sm.allObjs = allObjs //get all top level decl objs ast.Walk(allObjs, pkg) //find the nodes we want to move for _, name := range names { if !sm.CollectNameObjs(name) { return MakeErr("Unable to find %s in '%s'", name, oldpath) } } for node, obj := range moveNodes { moveObjs[obj] = node } //the objs in remainingObjs are not being moved to the new package remainingObjs := make(map[*ast.Object]bool) sm.remainingObjs = remainingObjs for obj := range sm.allObjs { if _, ok := sm.moveObjs[obj]; !ok { sm.remainingObjs[obj] = true } } //get a list of objects that are unexported (and therefore if they //are referenced elsewhere, the move cannot happen) sm.unexportedObjs = make(map[*ast.Object]bool) sm.CollectUnexportedObjs() err = sm.CreateNewSource() if err != nil { return } //identify locations in pkg source files that need to now change err = sm.RemoveUpdatePkg() if err != nil { return } //make changes in packages that import this one err = sm.UpdateOther() if err != nil { return } return }
func PkgCmd(args []string) (err error) { if len(args) != 2 { return MakeErr("Usage: gorf [flags] pkg <path> <new name>") } path, newname := filepath.Clean(args[0]), args[1] if !IsLegalIdentifier(newname) { return MakeErr("New name %s is not a legal identifier", newname) } err = ScanAllForImports(LocalRoot) if err != nil { return } PreloadImportedBy(path) defer func() { if err != nil { UndoCmd([]string{}) } }() if PackageTops[path] == nil { return MakeErr("No local package found in %s", path) } pkg := LocalImporter(path) oldname := pkg.Name for fpath, file := range pkg.Files { file.Name.Name = newname err = RewriteSource(fpath, file) if err != nil { return } } for _, ip := range ImportedBy[QuotePath(path)] { ipkg := LocalImporter(ip) if ipkg == nil { return MakeErr("Problem getting package in %s", ip) } for fpath, file := range ipkg.Files { uniqueName := GetUniqueIdent([]*ast.File{file}, newname) if uniqueName != newname { fmt.Printf("In %s: possible conflict with %s, using %s instead\n", fpath, newname, uniqueName) } pc := PkgChanger{ path: path, oldname: oldname, newname: uniqueName, pkgname: newname, } ast.Walk(&pc, file) if pc.Updated { RewriteSource(fpath, file) } } } return }
func (this *SingleMover) RemoveUpdatePkg() (err error) { for fpath, file := range this.pkg.Files { urw := ReferenceWalker{ UnexportedObjs: this.unexportedObjs, SkipNodes: this.moveNodes, MoveObjs: this.moveObjs, SkipNodeParents: make(map[ast.Node]ast.Node), GoodReferenceParents: make(map[ast.Node]ast.Node), BadReferences: new([]ast.Node), } ast.Walk(&urw, file) if len(*urw.BadReferences) != 0 { fmt.Printf("Cannot move some objects:\n") for node := range this.moveNodes { printer.Fprint(os.Stdout, token.NewFileSet(), node) fmt.Println() } fmt.Println("Unexported objects referenced:") for _, node := range *urw.BadReferences { position := AllSources.Position(node.Pos()) fmt.Printf("At %v ", position) printer.Fprint(os.Stdout, token.NewFileSet(), node) fmt.Println() } return MakeErr("Objects to be moved in '%s' contains unexported objects referenced elsewhere in the package", this.oldpath) } removedStuff := false // remove the old definitions for node, parent := range urw.SkipNodeParents { removedStuff = true //fmt.Printf("%T %v\n", parent, parent) switch pn := parent.(type) { case *ast.File: for i, n := range pn.Decls { if n == node { if len(pn.Decls) > 1 { pn.Decls[i], pn.Decls[len(pn.Decls)-1] = pn.Decls[len(pn.Decls)-1], pn.Decls[i] } pn.Decls = pn.Decls[:len(pn.Decls)-1] break } } case *ast.GenDecl: for i, n := range pn.Specs { if n == node { if pn.Lparen == 0 { pn.Lparen = n.Pos() pn.Rparen = n.End() } if len(pn.Specs) > 1 { pn.Specs[i], pn.Specs[len(pn.Specs)-1] = pn.Specs[len(pn.Specs)-1], pn.Specs[i] } pn.Specs = pn.Specs[:len(pn.Specs)-1] break } } default: return MakeErr("Unanticipated parent type: %T", pn) } } //strip out imports that are unnecessary because things are no longer here if removedStuff { for _, file := range this.pkg.Files { iuc := make(ImportUseCollector) ast.Walk(iuc, file) ast.Walk(ImportFilterWalker(iuc), file) } } //if this file refernces things that are moving, import the new package if len(urw.GoodReferenceParents) != 0 { if this.referenceBack { return MakeErr("Moving objects from %s would create a cycle", this.oldpath) } newpkgname := GetUniqueIdent([]*ast.File{file}, this.pkg.Name) //construct the import is := &ast.ImportSpec{ Name: &ast.Ident{Name: newpkgname}, Path: &ast.BasicLit{ Kind: token.STRING, Value: QuotePath(this.newpath), }, } gd := &ast.GenDecl{ Tok: token.IMPORT, Specs: []ast.Spec{is}, } //stick it in there file.Decls = append([]ast.Decl{gd}, file.Decls...) //change the old references to talk about the new package, using our unique name for node, parent := range urw.GoodReferenceParents { getSel := func(idn *ast.Ident) *ast.SelectorExpr { return &ast.SelectorExpr{ X: &ast.Ident{ Name: newpkgname, NamePos: idn.NamePos, }, Sel: idn, } } switch p := parent.(type) { case *ast.CallExpr: if idn, ok := node.(*ast.Ident); ok { p.Fun = getSel(idn) } else { return MakeErr("CallExpr w/ unexpected type %T\n", node) } case *ast.AssignStmt: for i, x := range p.Lhs { if x == node { if idn, ok := x.(*ast.Ident); ok { p.Lhs[i] = getSel(idn) } } } for i, x := range p.Rhs { if x == node { if idn, ok := x.(*ast.Ident); ok { p.Rhs[i] = getSel(idn) } } } case *ast.StarExpr: if p.X == node { if idn, ok := p.X.(*ast.Ident); ok { p.X = getSel(idn) } } default: return MakeErr("Unexpected local parent %T\n", parent) } } } if removedStuff { err = RewriteSource(fpath, file) if err != nil { return } } } return }
func (this *SingleMover) UpdateOther() (err error) { for _, path := range ImportedBy[QuotePath(this.oldpath)] { opkg := LocalImporter(path) for fpath, file := range opkg.Files { rw := ReferenceWalker{ UnexportedObjs: make(map[*ast.Object]bool), MoveObjs: this.moveObjs, SkipNodes: make(map[ast.Node]*ast.Object), SkipNodeParents: make(map[ast.Node]ast.Node), GoodReferenceParents: make(map[ast.Node]ast.Node), BadReferences: &[]ast.Node{}, } ast.Walk(&rw, file) if len(rw.GoodReferenceParents) == 0 { continue } newpkgname := GetUniqueIdent([]*ast.File{file}, this.pkg.Name) //construct the import nis := &ast.ImportSpec{ Name: &ast.Ident{Name: newpkgname}, Path: &ast.BasicLit{ Kind: token.STRING, Value: QuotePath(this.newpath), }, } ngd := &ast.GenDecl{ Tok: token.IMPORT, Specs: []ast.Spec{nis}, } file.Decls = append([]ast.Decl{ngd}, file.Decls...) for node, parent := range rw.GoodReferenceParents { getSel := func(sel *ast.SelectorExpr) *ast.SelectorExpr { obj, _ := types.ExprType(sel.X, LocalImporter) if obj.Kind == ast.Pkg { return &ast.SelectorExpr{ X: &ast.Ident{ Name: newpkgname, NamePos: sel.X.Pos(), }, Sel: sel.Sel, } } return sel } switch p := parent.(type) { case *ast.CallExpr: if sel, ok := node.(*ast.SelectorExpr); ok { p.Fun = getSel(sel) } else { return MakeErr("CallExpr w/ unexpected type %T\n", node) } case *ast.AssignStmt: for i, x := range p.Lhs { if x == node { if sel, ok := x.(*ast.SelectorExpr); ok { p.Lhs[i] = getSel(sel) } } } for i, x := range p.Rhs { if x == node { if sel, ok := x.(*ast.SelectorExpr); ok { p.Rhs[i] = getSel(sel) } } } case *ast.ValueSpec: if node == p.Type { if sel, ok := p.Type.(*ast.SelectorExpr); ok { p.Type = getSel(sel) } } for i, x := range p.Values { if x == node { if sel, ok := x.(*ast.SelectorExpr); ok { p.Values[i] = getSel(sel) } } } case *ast.StarExpr: if p.X == node { if sel, ok := p.X.(*ast.SelectorExpr); ok { p.X = getSel(sel) } } default: printer.Fprint(os.Stdout, AllSources, parent) return MakeErr("Unexpected remote parent %T\n", parent) } } //now that we've renamed some references, do we still need to import oldpath? oc := ObjChecker{ Objs: this.remainingObjs, } ast.Walk(&oc, file) if !oc.Found { ast.Walk(&ImportRemover{nil, this.oldpath}, file) } err = RewriteSource(fpath, file) if err != nil { return } } } return }
// IterateSyms calls visitf for each identifier in the given file. If // visitf returns false, the iteration stops. If visitf changes // info.Ident.Name, the file is added to ctxt.ChangedFiles. func (ctxt *Context) IterateSyms(f *ast.File, visitf func(info *Info) bool) { var visit astVisitor ok := true local := false // TODO set to true inside function body visit = func(n ast.Node) bool { if !ok { return false } switch n := n.(type) { case *ast.ImportSpec: // If the file imports a package to ".", abort // because we don't support that (yet). if n.Name != nil && n.Name.Name == "." { ctxt.logf(n.Pos(), "import to . not supported") ok = false return false } return true case *ast.FuncDecl: // add object for init functions if n.Recv == nil && n.Name.Name == "init" { n.Name.Obj = ast.NewObj(ast.Fun, "init") } if n.Recv != nil { ast.Walk(visit, n.Recv) } var e ast.Expr = n.Name if n.Recv != nil { // It's a method, so we need to synthesise a // selector expression so that visitExpr doesn't // just see a blank name. if len(n.Recv.List) != 1 { ctxt.logf(n.Pos(), "expected one receiver only!") return true } e = &ast.SelectorExpr{ X: n.Recv.List[0].Type, Sel: n.Name, } } ok = ctxt.visitExpr(f, e, false, visitf) local = true ast.Walk(visit, n.Type) if n.Body != nil { ast.Walk(visit, n.Body) } local = false return false case *ast.Ident: ok = ctxt.visitExpr(f, n, local, visitf) return false case *ast.KeyValueExpr: // don't try to resolve the key part of a key-value // because it might be a map key which doesn't // need resolving, and we can't tell without being // complicated with types. ast.Walk(visit, n.Value) return false case *ast.SelectorExpr: ast.Walk(visit, n.X) ok = ctxt.visitExpr(f, n, local, visitf) return false case *ast.File: for _, d := range n.Decls { ast.Walk(visit, d) } return false } return true } ast.Walk(visit, f) }
func (this *SingleMover) CreateNewSource() (err error) { liw := make(ListImportWalker) for n := range this.moveNodes { ast.Walk(liw, n) } finalImports := make(map[*ast.ImportSpec]bool) for obj, is := range liw { if _, ok := this.moveObjs[obj]; !ok { finalImports[is] = true } } newfile := &ast.File{ Name: &ast.Ident{Name: this.pkg.Name}, } if len(finalImports) != 0 { for is := range finalImports { gdl := &ast.GenDecl{ Tok: token.IMPORT, Specs: []ast.Spec{is}, } newfile.Decls = append(newfile.Decls, gdl) } } var sortedNodes NodeSorter for mn := range this.moveNodes { sortedNodes = append(sortedNodes, mn) } sort.Sort(sortedNodes) for _, mn := range sortedNodes { switch m := mn.(type) { case ast.Decl: newfile.Decls = append(newfile.Decls, m) case *ast.TypeSpec: gdl := &ast.GenDecl{ Tok: token.TYPE, Specs: []ast.Spec{m}, } newfile.Decls = append(newfile.Decls, gdl) } } npf := ExprParentFinder{ ExprParents: make(map[ast.Expr]ast.Node), } for n := range this.moveNodes { ast.Walk(&npf, n) } var pkgfiles []*ast.File for _, pkgfile := range this.pkg.Files { pkgfiles = append(pkgfiles, pkgfile) } oldPkgNewName := GetUniqueIdent(pkgfiles, this.pkg.Name) needOldImport := false this.referenceBack = false for expr, parent := range npf.ExprParents { obj, _ := types.ExprType(expr, LocalImporter) if _, ok := this.moveObjs[obj]; ok { continue } if _, ok := this.allObjs[obj]; !ok { continue } if !unicode.IsUpper([]rune(obj.Name)[0] /*utf8.NewString(obj.Name).At(0)*/) { position := AllSources.Position(expr.Pos()) fmt.Printf("At %v ", position) printer.Fprint(os.Stdout, token.NewFileSet(), expr) fmt.Println() err = MakeErr("Can't move code that references unexported objects") return } needOldImport = true this.referenceBack = true getSel := func(idn *ast.Ident) *ast.SelectorExpr { return &ast.SelectorExpr{ X: &ast.Ident{ Name: oldPkgNewName, NamePos: idn.NamePos, }, Sel: idn, } } switch p := parent.(type) { case *ast.CallExpr: if idn, ok := expr.(*ast.Ident); ok { p.Fun = getSel(idn) } else { err = MakeErr("CallExpr w/ unexpected type %T\n", expr) return } case *ast.AssignStmt: for i, x := range p.Lhs { if x == expr { if idn, ok := x.(*ast.Ident); ok { p.Lhs[i] = getSel(idn) } } } for i, x := range p.Rhs { if x == expr { if idn, ok := x.(*ast.Ident); ok { p.Rhs[i] = getSel(idn) } } } default: err = MakeErr("Unexpected parent %T\n", parent) return } } if needOldImport { is := &ast.ImportSpec{ Name: &ast.Ident{Name: oldPkgNewName}, Path: &ast.BasicLit{Value: QuotePath(this.oldpath)}, } gdl := &ast.GenDecl{ Tok: token.IMPORT, Specs: []ast.Spec{is}, } newfile.Decls = append([]ast.Decl{gdl}, newfile.Decls...) } err = os.MkdirAll(this.newpath, 0755) if err != nil { return } newSourcePath := filepath.Join(this.newpath, this.pkg.Name+".go") containedComments := make(CommentCollector) for node := range this.moveNodes { ast.Walk(containedComments, node) } for _, file := range this.pkg.Files { for i := len(file.Comments) - 1; i >= 0; i-- { cg := file.Comments[i] add := func() { newfile.Comments = append([]*ast.CommentGroup{cg}, newfile.Comments...) file.Comments[i] = file.Comments[len(file.Comments)-1] file.Comments = file.Comments[:len(file.Comments)-1] } if containedComments[cg] { add() } else { for node := range this.moveNodes { if node.Pos() <= cg.Pos() && node.End() >= cg.End() { add() break } } } } } err = NewSource(newSourcePath, newfile) if err != nil { return } return }
func RenameCmd(args []string) (err error) { if len(args) != 3 { return MakeErr("Usage: gorf [flags] rename <path> [<type>.]<old name> <new name>") } path, oldname, newname := filepath.Clean(args[0]), args[1], args[2] if oldnametoks := strings.SplitN(oldname, ".", 2); len(oldnametoks) == 2 { return FieldCmd([]string{path, oldnametoks[0], oldnametoks[1], newname}) } if !IsLegalIdentifier(oldname) { return MakeErr("Old name %s is not a legal identifier", oldname) } if !IsLegalIdentifier(newname) { return MakeErr("New name %s is not a legal identifier", newname) } if oldname == newname { return MakeErr("Old name and new name are the same") } err = ScanAllForImports(LocalRoot) if err != nil { return } PreloadImportedBy(path) defer func() { if err != nil { UndoCmd([]string{}) } }() if PackageTops[path] == nil { return MakeErr("No local package found in %s", path) } pkg := LocalImporter(path) updated := false var Obj *ast.Object for fpath, file := range pkg.Files { fdl := DeclFinder{oldname: oldname, newname: newname} ast.Walk(&fdl, file) if fdl.NameExists { return MakeErr("Name %s already exists", newname) } Obj = fdl.Obj if Obj != nil { updated = true } if updated { RenameInFile(file, newname, Obj) RewriteSource(fpath, file) } } if updated { err = RenameInAll(path, newname, Obj) } return }
func MergeCmd(args []string) (err error) { if len(args) != 2 { return MakeErr("Usage: gorf [flags] merge <old path> <new path>") } oldpath, newpath := filepath.Clean(args[0]), filepath.Clean(args[1]) err = ScanAllForImports(LocalRoot) if err != nil { return } PreloadImportedBy(oldpath) defer func() { if err != nil { UndoCmd([]string{}) } }() if PackageTops[oldpath] == nil { return MakeErr("Old path %s has no local package", oldpath) } if PackageTops[newpath] == nil { return MakeErr("New path %s has no local package", newpath) } oldpkg, newpkg := LocalImporter(oldpath), LocalImporter(newpath) // check for conflicts duplicates := false for name, oldobj := range oldpkg.Scope.Objects { if oldobj.Decl == nil { continue } if newobj, ok := newpkg.Scope.Objects[name]; ok && newobj.Decl != nil { duplicates = true fmt.Printf("Duplicate name %s\n", name) if oldNode, oldOk := oldobj.Decl.(ast.Node); oldOk { fmt.Printf(" %s\n", AllSources.Position(oldNode.Pos())) } else { fmt.Printf("%T\n", oldobj.Decl) } if newNode, newOk := newobj.Decl.(ast.Node); newOk { fmt.Printf(" %s\n", AllSources.Position(newNode.Pos())) } else { fmt.Printf("%T\n", newobj.Decl) } } } if duplicates { return MakeErr("Packages in '%s' and '%s' contain duplicate names", oldpath, newpath) } //move source files for fpath := range oldpkg.Files { _, fname := filepath.Split(fpath) npath := GetUniqueFilename(newpkg, filepath.Join(newpath, fname)) err = MoveSource(fpath, npath) if err != nil { return } } //update imports for _, ipath := range ImportedBy[QuotePath(oldpath)] { pkg := LocalImporter(ipath) for fpath, file := range pkg.Files { ir := ImportRepath{ OldName: oldpkg.Name, OldPath: oldpath, NewPath: newpath, } ast.Walk(&ir, file) if ir.Updated { err = RewriteSource(fpath, file) if err != nil { return } } } } return // MakeErr("not implemented yet") }
func FieldCmd(args []string) (err error) { if len(args) != 4 { return MakeErr("Usage: gorf [flags] field <path> <type name> <old field name> <new field name>") } path, typename, oldname, newname := args[0], args[1], args[2], args[3] if !IsLegalIdentifier(typename) { return MakeErr("Type name %s is not a legal identifier", oldname) } if !IsLegalIdentifier(oldname) { return MakeErr("Old name %s is not a legal identifier", oldname) } if !IsLegalIdentifier(newname) { return MakeErr("New name %s is not a legal identifier", newname) } if oldname == newname { return MakeErr("Old name and new name are the same") } err = ScanAllForImports(LocalRoot) if err != nil { return } defer func() { if err != nil { UndoCmd([]string{}) } }() pkg := LocalImporter(path) if pkg == nil { return MakeErr("No package found in %s", path) } updated := false var Obj *ast.Object for fpath, file := range pkg.Files { vdl := FieldDeclFinder{typename: typename, oldname: oldname, newname: newname} ast.Walk(&vdl, file) if vdl.NameExists { return MakeErr("Name %s already exists", newname) } Obj = vdl.Obj if vdl.Updated { updated = true } if updated { RenameInFile(file, newname, Obj) RewriteSource(fpath, file) } } if updated { err = RenameInAll(path, newname, Obj) } return }
func RenameInFile(file *ast.File, NewName string, Obj *ast.Object) bool { rw := RenameWalker{NewName: NewName, Obj: Obj} ast.Walk(&rw, file) return rw.Updated }