435c0d9fc8
This PR switches the Nomad repository from using govendor to Go modules for managing dependencies. Aspects of the Nomad workflow remain pretty much the same. The usual Makefile targets should continue to work as they always did. The API submodule simply defers to the parent Nomad version on the repository, keeping the semantics of API versioning that currently exists.
362 lines
12 KiB
Go
362 lines
12 KiB
Go
package apidiff
|
|
|
|
import (
|
|
"fmt"
|
|
"go/types"
|
|
"reflect"
|
|
)
|
|
|
|
func (d *differ) checkCompatible(otn *types.TypeName, old, new types.Type) {
|
|
switch old := old.(type) {
|
|
case *types.Interface:
|
|
if new, ok := new.(*types.Interface); ok {
|
|
d.checkCompatibleInterface(otn, old, new)
|
|
return
|
|
}
|
|
|
|
case *types.Struct:
|
|
if new, ok := new.(*types.Struct); ok {
|
|
d.checkCompatibleStruct(otn, old, new)
|
|
return
|
|
}
|
|
|
|
case *types.Chan:
|
|
if new, ok := new.(*types.Chan); ok {
|
|
d.checkCompatibleChan(otn, old, new)
|
|
return
|
|
}
|
|
|
|
case *types.Basic:
|
|
if new, ok := new.(*types.Basic); ok {
|
|
d.checkCompatibleBasic(otn, old, new)
|
|
return
|
|
}
|
|
|
|
case *types.Named:
|
|
panic("unreachable")
|
|
|
|
default:
|
|
d.checkCorrespondence(otn, "", old, new)
|
|
return
|
|
|
|
}
|
|
// Here if old and new are different kinds of types.
|
|
d.typeChanged(otn, "", old, new)
|
|
}
|
|
|
|
func (d *differ) checkCompatibleChan(otn *types.TypeName, old, new *types.Chan) {
|
|
d.checkCorrespondence(otn, ", element type", old.Elem(), new.Elem())
|
|
if old.Dir() != new.Dir() {
|
|
if new.Dir() == types.SendRecv {
|
|
d.compatible(otn, "", "removed direction")
|
|
} else {
|
|
d.incompatible(otn, "", "changed direction")
|
|
}
|
|
}
|
|
}
|
|
|
|
func (d *differ) checkCompatibleBasic(otn *types.TypeName, old, new *types.Basic) {
|
|
// Certain changes to numeric types are compatible. Approximately, the info must
|
|
// be the same, and the new values must be a superset of the old.
|
|
if old.Kind() == new.Kind() {
|
|
// old and new are identical
|
|
return
|
|
}
|
|
if compatibleBasics[[2]types.BasicKind{old.Kind(), new.Kind()}] {
|
|
d.compatible(otn, "", "changed from %s to %s", old, new)
|
|
} else {
|
|
d.typeChanged(otn, "", old, new)
|
|
}
|
|
}
|
|
|
|
// All pairs (old, new) of compatible basic types.
|
|
var compatibleBasics = map[[2]types.BasicKind]bool{
|
|
{types.Uint8, types.Uint16}: true,
|
|
{types.Uint8, types.Uint32}: true,
|
|
{types.Uint8, types.Uint}: true,
|
|
{types.Uint8, types.Uint64}: true,
|
|
{types.Uint16, types.Uint32}: true,
|
|
{types.Uint16, types.Uint}: true,
|
|
{types.Uint16, types.Uint64}: true,
|
|
{types.Uint32, types.Uint}: true,
|
|
{types.Uint32, types.Uint64}: true,
|
|
{types.Uint, types.Uint64}: true,
|
|
{types.Int8, types.Int16}: true,
|
|
{types.Int8, types.Int32}: true,
|
|
{types.Int8, types.Int}: true,
|
|
{types.Int8, types.Int64}: true,
|
|
{types.Int16, types.Int32}: true,
|
|
{types.Int16, types.Int}: true,
|
|
{types.Int16, types.Int64}: true,
|
|
{types.Int32, types.Int}: true,
|
|
{types.Int32, types.Int64}: true,
|
|
{types.Int, types.Int64}: true,
|
|
{types.Float32, types.Float64}: true,
|
|
{types.Complex64, types.Complex128}: true,
|
|
}
|
|
|
|
// Interface compatibility:
|
|
// If the old interface has an unexported method, the new interface is compatible
|
|
// if its exported method set is a superset of the old. (Users could not implement,
|
|
// only embed.)
|
|
//
|
|
// If the old interface did not have an unexported method, the new interface is
|
|
// compatible if its exported method set is the same as the old, and it has no
|
|
// unexported methods. (Adding an unexported method makes the interface
|
|
// unimplementable outside the package.)
|
|
//
|
|
// TODO: must also check that if any methods were added or removed, every exposed
|
|
// type in the package that implemented the interface in old still implements it in
|
|
// new. Otherwise external assignments could fail.
|
|
func (d *differ) checkCompatibleInterface(otn *types.TypeName, old, new *types.Interface) {
|
|
// Method sets are checked in checkCompatibleDefined.
|
|
|
|
// Does the old interface have an unexported method?
|
|
if unexportedMethod(old) != nil {
|
|
d.checkMethodSet(otn, old, new, additionsCompatible)
|
|
} else {
|
|
// Perform an equivalence check, but with more information.
|
|
d.checkMethodSet(otn, old, new, additionsIncompatible)
|
|
if u := unexportedMethod(new); u != nil {
|
|
d.incompatible(otn, u.Name(), "added unexported method")
|
|
}
|
|
}
|
|
}
|
|
|
|
// Return an unexported method from the method set of t, or nil if there are none.
|
|
func unexportedMethod(t *types.Interface) *types.Func {
|
|
for i := 0; i < t.NumMethods(); i++ {
|
|
if m := t.Method(i); !m.Exported() {
|
|
return m
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// We need to check three things for structs:
|
|
// 1. The set of exported fields must be compatible. This ensures that keyed struct
|
|
// literals continue to compile. (There is no compatibility guarantee for unkeyed
|
|
// struct literals.)
|
|
// 2. The set of exported *selectable* fields must be compatible. This includes the exported
|
|
// fields of all embedded structs. This ensures that selections continue to compile.
|
|
// 3. If the old struct is comparable, so must the new one be. This ensures that equality
|
|
// expressions and uses of struct values as map keys continue to compile.
|
|
//
|
|
// An unexported embedded struct can't appear in a struct literal outside the
|
|
// package, so it doesn't have to be present, or have the same name, in the new
|
|
// struct.
|
|
//
|
|
// Field tags are ignored: they have no compile-time implications.
|
|
func (d *differ) checkCompatibleStruct(obj types.Object, old, new *types.Struct) {
|
|
d.checkCompatibleObjectSets(obj, exportedFields(old), exportedFields(new))
|
|
d.checkCompatibleObjectSets(obj, exportedSelectableFields(old), exportedSelectableFields(new))
|
|
// Removing comparability from a struct is an incompatible change.
|
|
if types.Comparable(old) && !types.Comparable(new) {
|
|
d.incompatible(obj, "", "old is comparable, new is not")
|
|
}
|
|
}
|
|
|
|
// exportedFields collects all the immediate fields of the struct that are exported.
|
|
// This is also the set of exported keys for keyed struct literals.
|
|
func exportedFields(s *types.Struct) map[string]types.Object {
|
|
m := map[string]types.Object{}
|
|
for i := 0; i < s.NumFields(); i++ {
|
|
f := s.Field(i)
|
|
if f.Exported() {
|
|
m[f.Name()] = f
|
|
}
|
|
}
|
|
return m
|
|
}
|
|
|
|
// exportedSelectableFields collects all the exported fields of the struct, including
|
|
// exported fields of embedded structs.
|
|
//
|
|
// We traverse the struct breadth-first, because of the rule that a lower-depth field
|
|
// shadows one at a higher depth.
|
|
func exportedSelectableFields(s *types.Struct) map[string]types.Object {
|
|
var (
|
|
m = map[string]types.Object{}
|
|
next []*types.Struct // embedded structs at the next depth
|
|
seen []*types.Struct // to handle recursive embedding
|
|
)
|
|
for cur := []*types.Struct{s}; len(cur) > 0; cur, next = next, nil {
|
|
seen = append(seen, cur...)
|
|
// We only want to consider unambiguous fields. Ambiguous fields (where there
|
|
// is more than one field of the same name at the same level) are legal, but
|
|
// cannot be selected.
|
|
for name, f := range unambiguousFields(cur) {
|
|
// Record an exported field we haven't seen before. If we have seen it,
|
|
// it occurred a lower depth, so it shadows this field.
|
|
if f.Exported() && m[name] == nil {
|
|
m[name] = f
|
|
}
|
|
// Remember embedded structs for processing at the next depth,
|
|
// but only if we haven't seen the struct at this depth or above.
|
|
if !f.Anonymous() {
|
|
continue
|
|
}
|
|
t := f.Type().Underlying()
|
|
if p, ok := t.(*types.Pointer); ok {
|
|
t = p.Elem().Underlying()
|
|
}
|
|
if t, ok := t.(*types.Struct); ok && !contains(seen, t) {
|
|
next = append(next, t)
|
|
}
|
|
}
|
|
}
|
|
return m
|
|
}
|
|
|
|
func contains(ts []*types.Struct, t *types.Struct) bool {
|
|
for _, s := range ts {
|
|
if types.Identical(s, t) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Given a set of structs at the same depth, the unambiguous fields are the ones whose
|
|
// names appear exactly once.
|
|
func unambiguousFields(structs []*types.Struct) map[string]*types.Var {
|
|
fields := map[string]*types.Var{}
|
|
seen := map[string]bool{}
|
|
for _, s := range structs {
|
|
for i := 0; i < s.NumFields(); i++ {
|
|
f := s.Field(i)
|
|
name := f.Name()
|
|
if seen[name] {
|
|
delete(fields, name)
|
|
} else {
|
|
seen[name] = true
|
|
fields[name] = f
|
|
}
|
|
}
|
|
}
|
|
return fields
|
|
}
|
|
|
|
// Anything removed or change from the old set is an incompatible change.
|
|
// Anything added to the new set is a compatible change.
|
|
func (d *differ) checkCompatibleObjectSets(obj types.Object, old, new map[string]types.Object) {
|
|
for name, oldo := range old {
|
|
newo := new[name]
|
|
if newo == nil {
|
|
d.incompatible(obj, name, "removed")
|
|
} else {
|
|
d.checkCorrespondence(obj, name, oldo.Type(), newo.Type())
|
|
}
|
|
}
|
|
for name := range new {
|
|
if old[name] == nil {
|
|
d.compatible(obj, name, "added")
|
|
}
|
|
}
|
|
}
|
|
|
|
func (d *differ) checkCompatibleDefined(otn *types.TypeName, old *types.Named, new types.Type) {
|
|
// We've already checked that old and new correspond.
|
|
d.checkCompatible(otn, old.Underlying(), new.Underlying())
|
|
// If there are different kinds of types (e.g. struct and interface), don't bother checking
|
|
// the method sets.
|
|
if reflect.TypeOf(old.Underlying()) != reflect.TypeOf(new.Underlying()) {
|
|
return
|
|
}
|
|
// Interface method sets are checked in checkCompatibleInterface.
|
|
if _, ok := old.Underlying().(*types.Interface); ok {
|
|
return
|
|
}
|
|
|
|
// A new method set is compatible with an old if the new exported methods are a superset of the old.
|
|
d.checkMethodSet(otn, old, new, additionsCompatible)
|
|
d.checkMethodSet(otn, types.NewPointer(old), types.NewPointer(new), additionsCompatible)
|
|
}
|
|
|
|
const (
|
|
additionsCompatible = true
|
|
additionsIncompatible = false
|
|
)
|
|
|
|
func (d *differ) checkMethodSet(otn *types.TypeName, oldt, newt types.Type, addcompat bool) {
|
|
// TODO: find a way to use checkCompatibleObjectSets for this.
|
|
oldMethodSet := exportedMethods(oldt)
|
|
newMethodSet := exportedMethods(newt)
|
|
msname := otn.Name()
|
|
if _, ok := oldt.(*types.Pointer); ok {
|
|
msname = "*" + msname
|
|
}
|
|
for name, oldMethod := range oldMethodSet {
|
|
newMethod := newMethodSet[name]
|
|
if newMethod == nil {
|
|
var part string
|
|
// Due to embedding, it's possible that the method's receiver type is not
|
|
// the same as the defined type whose method set we're looking at. So for
|
|
// a type T with removed method M that is embedded in some other type U,
|
|
// we will generate two "removed" messages for T.M, one for its own type
|
|
// T and one for the embedded type U. We want both messages to appear,
|
|
// but the messageSet dedup logic will allow only one message for a given
|
|
// object. So use the part string to distinguish them.
|
|
if receiverNamedType(oldMethod).Obj() != otn {
|
|
part = fmt.Sprintf(", method set of %s", msname)
|
|
}
|
|
d.incompatible(oldMethod, part, "removed")
|
|
} else {
|
|
obj := oldMethod
|
|
// If a value method is changed to a pointer method and has a signature
|
|
// change, then we can get two messages for the same method definition: one
|
|
// for the value method set that says it's removed, and another for the
|
|
// pointer method set that says it changed. To keep both messages (since
|
|
// messageSet dedups), use newMethod for the second. (Slight hack.)
|
|
if !hasPointerReceiver(oldMethod) && hasPointerReceiver(newMethod) {
|
|
obj = newMethod
|
|
}
|
|
d.checkCorrespondence(obj, "", oldMethod.Type(), newMethod.Type())
|
|
}
|
|
}
|
|
|
|
// Check for added methods.
|
|
for name, newMethod := range newMethodSet {
|
|
if oldMethodSet[name] == nil {
|
|
if addcompat {
|
|
d.compatible(newMethod, "", "added")
|
|
} else {
|
|
d.incompatible(newMethod, "", "added")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// exportedMethods collects all the exported methods of type's method set.
|
|
func exportedMethods(t types.Type) map[string]types.Object {
|
|
m := map[string]types.Object{}
|
|
ms := types.NewMethodSet(t)
|
|
for i := 0; i < ms.Len(); i++ {
|
|
obj := ms.At(i).Obj()
|
|
if obj.Exported() {
|
|
m[obj.Name()] = obj
|
|
}
|
|
}
|
|
return m
|
|
}
|
|
|
|
func receiverType(method types.Object) types.Type {
|
|
return method.Type().(*types.Signature).Recv().Type()
|
|
}
|
|
|
|
func receiverNamedType(method types.Object) *types.Named {
|
|
switch t := receiverType(method).(type) {
|
|
case *types.Pointer:
|
|
return t.Elem().(*types.Named)
|
|
case *types.Named:
|
|
return t
|
|
default:
|
|
panic("unreachable")
|
|
}
|
|
}
|
|
|
|
func hasPointerReceiver(method types.Object) bool {
|
|
_, ok := receiverType(method).(*types.Pointer)
|
|
return ok
|
|
}
|