mccurdyc/splitfile

package splitfile

import (
    "errors"
    "go/ast"
    "go/token"
    "go/types"

    "golang.org/x/tools/go/analysis"
    "golang.org/x/tools/go/analysis/passes/inspect"

    "github.com/mccurdyc/splitfile/internal/graph"
)

var Analyzer = &analysis.Analyzer{
    Name:     "splitfile",
    Doc:      "checks for clean splits of files in packages based on objects and their relationships with other objects.",
    Requires: []*analysis.Analyzer{inspect.Analyzer},
    Run:      run,
}

type Poser interface {
    Pos() token.Pos
}

func run(pass *analysis.Pass) (interface{}, error) {
    g := traverse(pass.TypesInfo.Defs)

    nodes := g.Partition() // TODO (Issue#8): right now, this returns every single node in the graph
    for _, n := range nodes {
        p, ok := n.Object.(Poser)
        if !ok {
            continue
        }

        pass.Reportf(p.Pos(), "parition found - %+v", n)
    }

    return nil, nil
}

// traverse traverses the map of definitions and builds a graph based on the
// relationships.
func traverse(defs map[*ast.Ident]types.Object) graph.Graph {
    g := graph.New()

    for _, def := range defs {

        if skip := filter(def); skip {
            continue
        }

        node := graph.NewNode(Id(def), def)
        err := g.AddNode(node)
        if err != nil {
            continue
        }

        err = addRelated(g, node)
        if err != nil {
            continue
        }
    }

    return g
}

// filter returns whether or not a def should be filtered out.
func filter(def types.Object) bool {
    if def == nil {
        return true
    }

    return false
}

type Typer interface {
    Type() types.Type
}

// addRelated given a graph, g, and root node finds relationships
// with other declarations in the same package and adds them to the graph.
//
// TODO (Issue #15): read value from config or use default
// TODO: check other places for related (e.g., funcs, interfaces, etc.)
func addRelated(g graph.Graph, node *graph.Node) error {
    t, ok := node.Object.(Typer)
    if !ok {
        return errors.New("node does not have a Type() method")
    }
    m := checkMethods(types.NewMethodSet(t.Type()))

    for _, r := range m {
        if r.ID == node.ID {
            continue
        }

        err := g.AddNode(r)
        if err != nil {
            continue
        }

        node.AddEdge(r, 5.0) // TODO (Issue #15): read value from config or use default
    }

    // TODO: check other places for related (e.g., funcs, interfaces, etc.)

    return nil
}

// checkMethods checks methods' signatures for related types.
func checkMethods(mset *types.MethodSet) []*graph.Node {
    rel := make([]*graph.Node, 0)

    for i := 0; i < mset.Len(); i++ {
        method := mset.At(i)

        m := graph.NewNode(Id(method.Obj()), method.Obj())
        rel = append(rel, m) // methods themselves are always related

        sig, ok := method.Type().(*types.Signature)
        if !ok {
            continue
        }

        related := checkSignature(sig)
        rel = append(rel, related...)
    }

    return rel
}

// checkSignature checks a function signature, the receiver (if it is a method this
// will be a non-nil value), the parameters and the return types.
func checkSignature(sig *types.Signature) []*graph.Node {
    rel := make([]*graph.Node, 0)

    if v := checkVar(sig.Recv()); v != nil {
        rel = append(rel, v)
    }
    rel = append(rel, checkTuple(sig.Params())...)
    rel = append(rel, checkTuple(sig.Results())...)

    return rel
}

// checkVar validates a variable and if it is valid, it is returned as a valid related.
func checkVar(v *types.Var) *graph.Node {
    if v == nil || v.Type() == types.Type(nil) {
        return nil
    }

    return graph.NewNode(Id(v), v)
}

// checkTuple checks a tuple of variables for related nodes.
func checkTuple(vars *types.Tuple) []*graph.Node {
    rel := make([]*graph.Node, 0)

    for i := 0; i < vars.Len(); i++ {
        v := checkVar(vars.At(i))

        if v == nil {
            continue
        }

        rel = append(rel, v)
    }

    return rel
}