cmd/guru/whicherrs.go - tools - Git at Google

 // Copyright 2014 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 (
 	"fmt"
 	"go/ast"
 	"go/token"
 	"go/types"
 	"sort"

 	"golang.org/x/tools/cmd/guru/serial"
 	"golang.org/x/tools/go/ast/astutil"
 	"golang.org/x/tools/go/loader"
 	"golang.org/x/tools/go/pointer"
 	"golang.org/x/tools/go/ssa"
 	"golang.org/x/tools/go/ssa/ssautil"
 )

 var builtinErrorType = types.Universe.Lookup("error").Type()

 // whicherrs takes an position to an error and tries to find all types, constants
 // and global value which a given error can point to and which can be checked from the
 // scope where the error lives.
 // In short, it returns a list of things that can be checked against in order to handle
 // an error properly.
 //
 // TODO(dmorsing): figure out if fields in errors like *os.PathError.Err
 // can be queried recursively somehow.
 func whicherrs(q *Query) error {
 	lconf := loader.Config{Build: q.Build}

 	if err := setPTAScope(&lconf, q.Scope); err != nil {
 		return err
 	}

 	// Load/parse/type-check the program.
 	lprog, err := loadWithSoftErrors(&lconf)
 	if err != nil {
 		return err
 	}

 	qpos, err := parseQueryPos(lprog, q.Pos, true) // needs exact pos
 	if err != nil {
 		return err
 	}

 	prog := ssautil.CreateProgram(lprog, ssa.GlobalDebug)

 	ptaConfig, err := setupPTA(prog, lprog, q.PTALog, q.Reflection)
 	if err != nil {
 		return err
 	}

 	path, action := findInterestingNode(qpos.info, qpos.path)
 	if action != actionExpr {
 		return fmt.Errorf("whicherrs wants an expression; got %s",
 			astutil.NodeDescription(qpos.path[0]))
 	}
 	var expr ast.Expr
 	var obj types.Object
 	switch n := path[0].(type) {
 	case *ast.ValueSpec:
 		// ambiguous ValueSpec containing multiple names
 		return fmt.Errorf("multiple value specification")
 	case *ast.Ident:
 		obj = qpos.info.ObjectOf(n)
 		expr = n
 	case ast.Expr:
 		expr = n
 	default:
 		return fmt.Errorf("unexpected AST for expr: %T", n)
 	}

 	typ := qpos.info.TypeOf(expr)
 	if !types.Identical(typ, builtinErrorType) {
 		return fmt.Errorf("selection is not an expression of type 'error'")
 	}
 	// Determine the ssa.Value for the expression.
 	var value ssa.Value
 	if obj != nil {
 		// def/ref of func/var object
 		value, _, err = ssaValueForIdent(prog, qpos.info, obj, path)
 	} else {
 		value, _, err = ssaValueForExpr(prog, qpos.info, path)
 	}
 	if err != nil {
 		return err // e.g. trivially dead code
 	}

 	// Defer SSA construction till after errors are reported.
 	prog.Build()

 	globals := findVisibleErrs(prog, qpos)
 	constants := findVisibleConsts(prog, qpos)

 	res := &whicherrsResult{
 		qpos:   qpos,
 		errpos: expr.Pos(),
 	}

 	// TODO(adonovan): the following code is heavily duplicated
 	// w.r.t.  "pointsto".  Refactor?

 	// Find the instruction which initialized the
 	// global error. If more than one instruction has stored to the global
 	// remove the global from the set of values that we want to query.
 	allFuncs := ssautil.AllFunctions(prog)
 	for fn := range allFuncs {
 		for _, b := range fn.Blocks {
 			for _, instr := range b.Instrs {
 				store, ok := instr.(*ssa.Store)
 				if !ok {
 					continue
 				}
 				gval, ok := store.Addr.(*ssa.Global)
 				if !ok {
 					continue
 				}
 				gbl, ok := globals[gval]
 				if !ok {
 					continue
 				}
 				// we already found a store to this global
 				// The normal error define is just one store in the init
 				// so we just remove this global from the set we want to query
 				if gbl != nil {
 					delete(globals, gval)
 				}
 				globals[gval] = store.Val
 			}
 		}
 	}

 	ptaConfig.AddQuery(value)
 	for _, v := range globals {
 		ptaConfig.AddQuery(v)
 	}

 	ptares := ptrAnalysis(ptaConfig)
 	valueptr := ptares.Queries[value]
 	if valueptr == (pointer.Pointer{}) {
 		return fmt.Errorf("pointer analysis did not find expression (dead code?)")
 	}
 	for g, v := range globals {
 		ptr, ok := ptares.Queries[v]
 		if !ok {
 			continue
 		}
 		if !ptr.MayAlias(valueptr) {
 			continue
 		}
 		res.globals = append(res.globals, g)
 	}
 	pts := valueptr.PointsTo()
 	dedup := make(map[*ssa.NamedConst]bool)
 	for _, label := range pts.Labels() {
 		// These values are either MakeInterfaces or reflect
 		// generated interfaces. For the purposes of this
 		// analysis, we don't care about reflect generated ones
 		makeiface, ok := label.Value().(*ssa.MakeInterface)
 		if !ok {
 			continue
 		}
 		constval, ok := makeiface.X.(*ssa.Const)
 		if !ok {
 			continue
 		}
 		c := constants[*constval]
 		if c != nil && !dedup[c] {
 			dedup[c] = true
 			res.consts = append(res.consts, c)
 		}
 	}
 	concs := pts.DynamicTypes()
 	concs.Iterate(func(conc types.Type, _ interface{}) {
 		// go/types is a bit annoying here.
 		// We want to find all the types that we can
 		// typeswitch or assert to. This means finding out
 		// if the type pointed to can be seen by us.
 		//
 		// For the purposes of this analysis, we care only about
 		// TypeNames of Named or pointer-to-Named types.
 		// We ignore other types (e.g. structs) that implement error.
 		var name *types.TypeName
 		switch t := conc.(type) {
 		case *types.Pointer:
 			named, ok := t.Elem().(*types.Named)
 			if !ok {
 				return
 			}
 			name = named.Obj()
 		case *types.Named:
 			name = t.Obj()
 		default:
 			return
 		}
 		if !isAccessibleFrom(name, qpos.info.Pkg) {
 			return
 		}
 		res.types = append(res.types, &errorType{conc, name})
 	})
 	sort.Sort(membersByPosAndString(res.globals))
 	sort.Sort(membersByPosAndString(res.consts))
 	sort.Sort(sorterrorType(res.types))

 	q.Output(lprog.Fset, res)
 	return nil
 }

 // findVisibleErrs returns a mapping from each package-level variable of type "error" to nil.
 func findVisibleErrs(prog *ssa.Program, qpos *queryPos) map[*ssa.Global]ssa.Value {
 	globals := make(map[*ssa.Global]ssa.Value)
 	for _, pkg := range prog.AllPackages() {
 		for _, mem := range pkg.Members {
 			gbl, ok := mem.(*ssa.Global)
 			if !ok {
 				continue
 			}
 			gbltype := gbl.Type()
 			// globals are always pointers
 			if !types.Identical(deref(gbltype), builtinErrorType) {
 				continue
 			}
 			if !isAccessibleFrom(gbl.Object(), qpos.info.Pkg) {
 				continue
 			}
 			globals[gbl] = nil
 		}
 	}
 	return globals
 }

 // findVisibleConsts returns a mapping from each package-level constant assignable to type "error", to nil.
 func findVisibleConsts(prog *ssa.Program, qpos *queryPos) map[ssa.Const]*ssa.NamedConst {
 	constants := make(map[ssa.Const]*ssa.NamedConst)
 	for _, pkg := range prog.AllPackages() {
 		for _, mem := range pkg.Members {
 			obj, ok := mem.(*ssa.NamedConst)
 			if !ok {
 				continue
 			}
 			consttype := obj.Type()
 			if !types.AssignableTo(consttype, builtinErrorType) {
 				continue
 			}
 			if !isAccessibleFrom(obj.Object(), qpos.info.Pkg) {
 				continue
 			}
 			constants[*obj.Value] = obj
 		}
 	}

 	return constants
 }

 type membersByPosAndString []ssa.Member

 func (a membersByPosAndString) Len() int { return len(a) }
 func (a membersByPosAndString) Less(i, j int) bool {
 	cmp := a[i].Pos() - a[j].Pos()
 	return cmp < 0 || cmp == 0 && a[i].String() < a[j].String()
 }
 func (a membersByPosAndString) Swap(i, j int) { a[i], a[j] = a[j], a[i] }

 type sorterrorType []*errorType

 func (a sorterrorType) Len() int { return len(a) }
 func (a sorterrorType) Less(i, j int) bool {
 	cmp := a[i].obj.Pos() - a[j].obj.Pos()
 	return cmp < 0 || cmp == 0 && a[i].typ.String() < a[j].typ.String()
 }
 func (a sorterrorType) Swap(i, j int) { a[i], a[j] = a[j], a[i] }

 type errorType struct {
 	typ types.Type      // concrete type N or *N that implements error
 	obj *types.TypeName // the named type N
 }

 type whicherrsResult struct {
 	qpos    *queryPos
 	errpos  token.Pos
 	globals []ssa.Member
 	consts  []ssa.Member
 	types   []*errorType
 }

 func (r *whicherrsResult) PrintPlain(printf printfFunc) {
 	if len(r.globals) > 0 {
 		printf(r.qpos, "this error may point to these globals:")
 		for _, g := range r.globals {
 			printf(g.Pos(), "\t%s", g.RelString(r.qpos.info.Pkg))
 		}
 	}
 	if len(r.consts) > 0 {
 		printf(r.qpos, "this error may contain these constants:")
 		for _, c := range r.consts {
 			printf(c.Pos(), "\t%s", c.RelString(r.qpos.info.Pkg))
 		}
 	}
 	if len(r.types) > 0 {
 		printf(r.qpos, "this error may contain these dynamic types:")
 		for _, t := range r.types {
 			printf(t.obj.Pos(), "\t%s", r.qpos.typeString(t.typ))
 		}
 	}
 }

 func (r *whicherrsResult) JSON(fset *token.FileSet) []byte {
 	we := &serial.WhichErrs{}
 	we.ErrPos = fset.Position(r.errpos).String()
 	for _, g := range r.globals {
 		we.Globals = append(we.Globals, fset.Position(g.Pos()).String())
 	}
 	for _, c := range r.consts {
 		we.Constants = append(we.Constants, fset.Position(c.Pos()).String())
 	}
 	for _, t := range r.types {
 		var et serial.WhichErrsType
 		et.Type = r.qpos.typeString(t.typ)
 		et.Position = fset.Position(t.obj.Pos()).String()
 		we.Types = append(we.Types, et)
 	}
 	return toJSON(we)
 }
	// Copyright 2014 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 (
	"fmt"
	"go/ast"
	"go/token"
	"go/types"
	"sort"

	"golang.org/x/tools/cmd/guru/serial"
	"golang.org/x/tools/go/ast/astutil"
	"golang.org/x/tools/go/loader"
	"golang.org/x/tools/go/pointer"
	"golang.org/x/tools/go/ssa"
	"golang.org/x/tools/go/ssa/ssautil"
	)

	var builtinErrorType = types.Universe.Lookup("error").Type()

	// whicherrs takes an position to an error and tries to find all types, constants
	// and global value which a given error can point to and which can be checked from the
	// scope where the error lives.
	// In short, it returns a list of things that can be checked against in order to handle
	// an error properly.
	//
	// TODO(dmorsing): figure out if fields in errors like *os.PathError.Err
	// can be queried recursively somehow.
	func whicherrs(q *Query) error {
	lconf := loader.Config{Build: q.Build}

	if err := setPTAScope(&lconf, q.Scope); err != nil {
	return err
	}

	// Load/parse/type-check the program.
	lprog, err := loadWithSoftErrors(&lconf)
	if err != nil {
	return err
	}

	qpos, err := parseQueryPos(lprog, q.Pos, true) // needs exact pos
	if err != nil {
	return err
	}

	prog := ssautil.CreateProgram(lprog, ssa.GlobalDebug)

	ptaConfig, err := setupPTA(prog, lprog, q.PTALog, q.Reflection)
	if err != nil {
	return err
	}

	path, action := findInterestingNode(qpos.info, qpos.path)
	if action != actionExpr {
	return fmt.Errorf("whicherrs wants an expression; got %s",
	astutil.NodeDescription(qpos.path[0]))
	}
	var expr ast.Expr
	var obj types.Object
	switch n := path[0].(type) {
	case *ast.ValueSpec:
	// ambiguous ValueSpec containing multiple names
	return fmt.Errorf("multiple value specification")
	case *ast.Ident:
	obj = qpos.info.ObjectOf(n)
	expr = n
	case ast.Expr:
	expr = n
	default:
	return fmt.Errorf("unexpected AST for expr: %T", n)
	}

	typ := qpos.info.TypeOf(expr)
	if !types.Identical(typ, builtinErrorType) {
	return fmt.Errorf("selection is not an expression of type 'error'")
	}
	// Determine the ssa.Value for the expression.
	var value ssa.Value
	if obj != nil {
	// def/ref of func/var object
	value, _, err = ssaValueForIdent(prog, qpos.info, obj, path)
	} else {
	value, _, err = ssaValueForExpr(prog, qpos.info, path)
	}
	if err != nil {
	return err // e.g. trivially dead code
	}

	// Defer SSA construction till after errors are reported.
	prog.Build()

	globals := findVisibleErrs(prog, qpos)
	constants := findVisibleConsts(prog, qpos)

	res := &whicherrsResult{
	qpos: qpos,
	errpos: expr.Pos(),
	}

	// TODO(adonovan): the following code is heavily duplicated
	// w.r.t. "pointsto". Refactor?

	// Find the instruction which initialized the
	// global error. If more than one instruction has stored to the global
	// remove the global from the set of values that we want to query.
	allFuncs := ssautil.AllFunctions(prog)
	for fn := range allFuncs {
	for _, b := range fn.Blocks {
	for _, instr := range b.Instrs {
	store, ok := instr.(*ssa.Store)
	if !ok {
	continue
	}
	gval, ok := store.Addr.(*ssa.Global)
	if !ok {
	continue
	}
	gbl, ok := globals[gval]
	if !ok {
	continue
	}
	// we already found a store to this global
	// The normal error define is just one store in the init
	// so we just remove this global from the set we want to query
	if gbl != nil {
	delete(globals, gval)
	}
	globals[gval] = store.Val
	}
	}
	}

	ptaConfig.AddQuery(value)
	for _, v := range globals {
	ptaConfig.AddQuery(v)
	}

	ptares := ptrAnalysis(ptaConfig)
	valueptr := ptares.Queries[value]
	if valueptr == (pointer.Pointer{}) {
	return fmt.Errorf("pointer analysis did not find expression (dead code?)")
	}
	for g, v := range globals {
	ptr, ok := ptares.Queries[v]
	if !ok {
	continue
	}
	if !ptr.MayAlias(valueptr) {
	continue
	}
	res.globals = append(res.globals, g)
	}
	pts := valueptr.PointsTo()
	dedup := make(map[*ssa.NamedConst]bool)
	for _, label := range pts.Labels() {
	// These values are either MakeInterfaces or reflect
	// generated interfaces. For the purposes of this
	// analysis, we don't care about reflect generated ones
	makeiface, ok := label.Value().(*ssa.MakeInterface)
	if !ok {
	continue
	}
	constval, ok := makeiface.X.(*ssa.Const)
	if !ok {
	continue
	}
	c := constants[*constval]
	if c != nil && !dedup[c] {
	dedup[c] = true
	res.consts = append(res.consts, c)
	}
	}
	concs := pts.DynamicTypes()
	concs.Iterate(func(conc types.Type, _ interface{}) {
	// go/types is a bit annoying here.
	// We want to find all the types that we can
	// typeswitch or assert to. This means finding out
	// if the type pointed to can be seen by us.
	//
	// For the purposes of this analysis, we care only about
	// TypeNames of Named or pointer-to-Named types.
	// We ignore other types (e.g. structs) that implement error.
	var name *types.TypeName
	switch t := conc.(type) {
	case *types.Pointer:
	named, ok := t.Elem().(*types.Named)
	if !ok {
	return
	}
	name = named.Obj()
	case *types.Named:
	name = t.Obj()
	default:
	return
	}
	if !isAccessibleFrom(name, qpos.info.Pkg) {
	return
	}
	res.types = append(res.types, &errorType{conc, name})
	})
	sort.Sort(membersByPosAndString(res.globals))
	sort.Sort(membersByPosAndString(res.consts))
	sort.Sort(sorterrorType(res.types))

	q.Output(lprog.Fset, res)
	return nil
	}

	// findVisibleErrs returns a mapping from each package-level variable of type "error" to nil.
	func findVisibleErrs(prog ssa.Program, qpos queryPos) map[*ssa.Global]ssa.Value {
	globals := make(map[*ssa.Global]ssa.Value)
	for _, pkg := range prog.AllPackages() {
	for _, mem := range pkg.Members {
	gbl, ok := mem.(*ssa.Global)
	if !ok {
	continue
	}
	gbltype := gbl.Type()
	// globals are always pointers
	if !types.Identical(deref(gbltype), builtinErrorType) {
	continue
	}
	if !isAccessibleFrom(gbl.Object(), qpos.info.Pkg) {
	continue
	}
	globals[gbl] = nil
	}
	}
	return globals
	}

	// findVisibleConsts returns a mapping from each package-level constant assignable to type "error", to nil.
	func findVisibleConsts(prog ssa.Program, qpos queryPos) map[ssa.Const]*ssa.NamedConst {
	constants := make(map[ssa.Const]*ssa.NamedConst)
	for _, pkg := range prog.AllPackages() {
	for _, mem := range pkg.Members {
	obj, ok := mem.(*ssa.NamedConst)
	if !ok {
	continue
	}
	consttype := obj.Type()
	if !types.AssignableTo(consttype, builtinErrorType) {
	continue
	}
	if !isAccessibleFrom(obj.Object(), qpos.info.Pkg) {
	continue
	}
	constants[*obj.Value] = obj
	}
	}

	return constants
	}

	type membersByPosAndString []ssa.Member

	func (a membersByPosAndString) Len() int { return len(a) }
	func (a membersByPosAndString) Less(i, j int) bool {
	cmp := a[i].Pos() - a[j].Pos()
	return cmp < 0 \|\| cmp == 0 && a[i].String() < a[j].String()
	}
	func (a membersByPosAndString) Swap(i, j int) { a[i], a[j] = a[j], a[i] }

	type sorterrorType []*errorType

	func (a sorterrorType) Len() int { return len(a) }
	func (a sorterrorType) Less(i, j int) bool {
	cmp := a[i].obj.Pos() - a[j].obj.Pos()
	return cmp < 0 \|\| cmp == 0 && a[i].typ.String() < a[j].typ.String()
	}
	func (a sorterrorType) Swap(i, j int) { a[i], a[j] = a[j], a[i] }

	type errorType struct {
	typ types.Type // concrete type N or *N that implements error
	obj *types.TypeName // the named type N
	}

	type whicherrsResult struct {
	qpos *queryPos
	errpos token.Pos
	globals []ssa.Member
	consts []ssa.Member
	types []*errorType
	}

	func (r *whicherrsResult) PrintPlain(printf printfFunc) {
	if len(r.globals) > 0 {
	printf(r.qpos, "this error may point to these globals:")
	for _, g := range r.globals {
	printf(g.Pos(), "\t%s", g.RelString(r.qpos.info.Pkg))
	}
	}
	if len(r.consts) > 0 {
	printf(r.qpos, "this error may contain these constants:")
	for _, c := range r.consts {
	printf(c.Pos(), "\t%s", c.RelString(r.qpos.info.Pkg))
	}
	}
	if len(r.types) > 0 {
	printf(r.qpos, "this error may contain these dynamic types:")
	for _, t := range r.types {
	printf(t.obj.Pos(), "\t%s", r.qpos.typeString(t.typ))
	}
	}
	}

	func (r whicherrsResult) JSON(fset token.FileSet) []byte {
	we := &serial.WhichErrs{}
	we.ErrPos = fset.Position(r.errpos).String()
	for _, g := range r.globals {
	we.Globals = append(we.Globals, fset.Position(g.Pos()).String())
	}
	for _, c := range r.consts {
	we.Constants = append(we.Constants, fset.Position(c.Pos()).String())
	}
	for _, t := range r.types {
	var et serial.WhichErrsType
	et.Type = r.qpos.typeString(t.typ)
	et.Position = fset.Position(t.obj.Pos()).String()
	we.Types = append(we.Types, et)
	}
	return toJSON(we)
	}