+++ /dev/null
-// Copyright 2013 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.
-
-package main
-
-import (
- "bytes"
- "go/ast"
- "go/printer"
- "go/token"
- "go/types"
- "sort"
-
- "golang.org/x/tools/cmd/guru/serial"
- "golang.org/x/tools/go/loader"
-)
-
-// freevars displays the lexical (not package-level) free variables of
-// the selection.
-//
-// It treats A.B.C as a separate variable from A to reveal the parts
-// of an aggregate type that are actually needed.
-// This aids refactoring.
-//
-// TODO(adonovan): optionally display the free references to
-// file/package scope objects, and to objects from other packages.
-// Depending on where the resulting function abstraction will go,
-// these might be interesting. Perhaps group the results into three
-// bands.
-//
-func freevars(q *Query) error {
- lconf := loader.Config{Build: q.Build}
- allowErrors(&lconf)
-
- if _, err := importQueryPackage(q.Pos, &lconf); err != nil {
- return err
- }
-
- // Load/parse/type-check the program.
- lprog, err := lconf.Load()
- if err != nil {
- return err
- }
-
- qpos, err := parseQueryPos(lprog, q.Pos, false)
- if err != nil {
- return err
- }
-
- file := qpos.path[len(qpos.path)-1] // the enclosing file
- fileScope := qpos.info.Scopes[file]
- pkgScope := fileScope.Parent()
-
- // The id and sel functions return non-nil if they denote an
- // object o or selection o.x.y that is referenced by the
- // selection but defined neither within the selection nor at
- // file scope, i.e. it is in the lexical environment.
- var id func(n *ast.Ident) types.Object
- var sel func(n *ast.SelectorExpr) types.Object
-
- sel = func(n *ast.SelectorExpr) types.Object {
- switch x := unparen(n.X).(type) {
- case *ast.SelectorExpr:
- return sel(x)
- case *ast.Ident:
- return id(x)
- }
- return nil
- }
-
- id = func(n *ast.Ident) types.Object {
- obj := qpos.info.Uses[n]
- if obj == nil {
- return nil // not a reference
- }
- if _, ok := obj.(*types.PkgName); ok {
- return nil // imported package
- }
- if !(file.Pos() <= obj.Pos() && obj.Pos() <= file.End()) {
- return nil // not defined in this file
- }
- scope := obj.Parent()
- if scope == nil {
- return nil // e.g. interface method, struct field
- }
- if scope == fileScope || scope == pkgScope {
- return nil // defined at file or package scope
- }
- if qpos.start <= obj.Pos() && obj.Pos() <= qpos.end {
- return nil // defined within selection => not free
- }
- return obj
- }
-
- // Maps each reference that is free in the selection
- // to the object it refers to.
- // The map de-duplicates repeated references.
- refsMap := make(map[string]freevarsRef)
-
- // Visit all the identifiers in the selected ASTs.
- ast.Inspect(qpos.path[0], func(n ast.Node) bool {
- if n == nil {
- return true // popping DFS stack
- }
-
- // Is this node contained within the selection?
- // (freevars permits inexact selections,
- // like two stmts in a block.)
- if qpos.start <= n.Pos() && n.End() <= qpos.end {
- var obj types.Object
- var prune bool
- switch n := n.(type) {
- case *ast.Ident:
- obj = id(n)
-
- case *ast.SelectorExpr:
- obj = sel(n)
- prune = true
- }
-
- if obj != nil {
- var kind string
- switch obj.(type) {
- case *types.Var:
- kind = "var"
- case *types.Func:
- kind = "func"
- case *types.TypeName:
- kind = "type"
- case *types.Const:
- kind = "const"
- case *types.Label:
- kind = "label"
- default:
- panic(obj)
- }
-
- typ := qpos.info.TypeOf(n.(ast.Expr))
- ref := freevarsRef{kind, printNode(lprog.Fset, n), typ, obj}
- refsMap[ref.ref] = ref
-
- if prune {
- return false // don't descend
- }
- }
- }
-
- return true // descend
- })
-
- refs := make([]freevarsRef, 0, len(refsMap))
- for _, ref := range refsMap {
- refs = append(refs, ref)
- }
- sort.Sort(byRef(refs))
-
- q.Output(lprog.Fset, &freevarsResult{
- qpos: qpos,
- refs: refs,
- })
- return nil
-}
-
-type freevarsResult struct {
- qpos *queryPos
- refs []freevarsRef
-}
-
-type freevarsRef struct {
- kind string
- ref string
- typ types.Type
- obj types.Object
-}
-
-func (r *freevarsResult) PrintPlain(printf printfFunc) {
- if len(r.refs) == 0 {
- printf(r.qpos, "No free identifiers.")
- } else {
- printf(r.qpos, "Free identifiers:")
- qualifier := types.RelativeTo(r.qpos.info.Pkg)
- for _, ref := range r.refs {
- // Avoid printing "type T T".
- var typstr string
- if ref.kind != "type" && ref.kind != "label" {
- typstr = " " + types.TypeString(ref.typ, qualifier)
- }
- printf(ref.obj, "%s %s%s", ref.kind, ref.ref, typstr)
- }
- }
-}
-
-func (r *freevarsResult) JSON(fset *token.FileSet) []byte {
- var buf bytes.Buffer
- for i, ref := range r.refs {
- if i > 0 {
- buf.WriteByte('\n')
- }
- buf.Write(toJSON(serial.FreeVar{
- Pos: fset.Position(ref.obj.Pos()).String(),
- Kind: ref.kind,
- Ref: ref.ref,
- Type: ref.typ.String(),
- }))
- }
- return buf.Bytes()
-}
-
-// -------- utils --------
-
-type byRef []freevarsRef
-
-func (p byRef) Len() int { return len(p) }
-func (p byRef) Less(i, j int) bool { return p[i].ref < p[j].ref }
-func (p byRef) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
-
-// printNode returns the pretty-printed syntax of n.
-func printNode(fset *token.FileSet, n ast.Node) string {
- var buf bytes.Buffer
- printer.Fprint(&buf, fset, n)
- return buf.String()
-}
projects / dotfiles / .git / blobdiff