When an interface has unexported methods, adding a method is minor, not major

testdata/minor/addmethod1.tmpl

@@ -0,0 +1,20 @@
+// -*- mode: go -*-
+
+// {{ define "older" }}
+package addmethod1
+
+type X interface {
+  A() int
+	unexported()
+}
+// {{ end }}
+
+// {{ define "newer" }}
+package addmethod1
+
+type X interface {
+	A() int
+	B() string
+	unexported()
+}
+// {{ end }}

testdata/minor/addmethod2.tmpl

@@ -0,0 +1,34 @@
+// -*- mode: go -*-
+
+// {{ define "older/internal/q.go" }}
+package internal
+
+type Q int
+// {{ end }}
+
+// {{ define "newer/internal/q.go" }}
+package internal
+
+type Q int
+// {{ end }}
+
+// {{ define "older" }}
+package addmethod2
+
+import "addmethod2/internal"
+
+type X interface {
+  A() internal.Q
+}
+// {{ end }}
+
+// {{ define "newer" }}
+package addmethod2
+
+import "addmethod2/internal"
+
+type X interface {
+	A() internal.Q
+	B() string
+}
+// {{ end }}

types.go

@@ -6,6 +6,7 @@ import (
 	"go/types"
 	"reflect"
 	"regexp"
+	"strings"
 
 	"golang.org/x/tools/go/packages"
 )
@@ -237,7 +238,14 @@ func (c *comparer) compareInterfaces(older, newer *types.Interface) Result {
 
 	if c.implements(newer, older) {
 		if !c.implements(older, newer) {
-			res = rwrapf(Major, "new interface %s is a superset of older", newer)
+			switch {
+			case anyUnexportedMethods(older):
+				res = rwrapf(Minor, "new interface %s is a superset of older, with unexported methods", newer)
+			case anyInternalTypes(older):
+				res = rwrapf(Minor, "new interface %s is a superset of older, using internal types", newer)
+			default:
+				res = rwrapf(Major, "new interface %s is a superset of older", newer)
+			}
 		}
 	} else {
 		return rwrapf(Major, "new interface %s does not implement old", newer)
@@ -302,6 +310,59 @@ func (c *comparer) compareInterfaces(older, newer *types.Interface) Result {
 	return rwrapf(Major, "constraint type unions differ")
 }
 
+func anyUnexportedMethods(intf *types.Interface) bool {
+	for i := 0; i < intf.NumMethods(); i++ {
+		if !ast.IsExported(intf.Method(i).Name()) {
+			return true
+		}
+	}
+	return false
+}
+
+// Do any of the types in the method args or results have "internal" in their pkgpaths?
+func anyInternalTypes(intf *types.Interface) bool {
+	for i := 0; i < intf.NumMethods(); i++ {
+		sig, ok := intf.Method(i).Type().(*types.Signature)
+		if !ok {
+			// Should be impossible.
+			continue
+		}
+		if anyInternalTypesInTuple(sig.Params()) || anyInternalTypesInTuple(sig.Results()) {
+			return true
+		}
+		if recv := sig.Recv(); recv != nil && isInternalType(recv.Type()) {
+			return true
+		}
+	}
+	return false
+}
+
+func anyInternalTypesInTuple(tup *types.Tuple) bool {
+	for i := 0; i < tup.Len(); i++ {
+		if isInternalType(tup.At(i).Type()) {
+			return true
+		}
+	}
+	return false
+}
+
+func isInternalType(typ types.Type) bool {
+	s := types.TypeString(typ, nil)
+	if strings.HasPrefix(s, "internal.") {
+		return true
+	}
+	if strings.Contains(s, "/internal.") {
+		return true
+	}
+	if strings.Contains(s, "/internal/") {
+		return true
+	}
+	if strings.HasPrefix(s, "main.") {
+		return true
+	}
+	return strings.Contains(s, "/main.")
+}
+
 // This takes an interface and flattens its typelists by traversing embeds.
 func termsOf(typ types.Type) []*types.Term {
 	var res []*types.Term