| // 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) | |
| } |