go/types, types2: introduce _Alias type node

[gostls13.git] / src / go / types / lookup.go

diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go
index a2f7e7ea50e274c7fafded5ff65d66d6bb7792b3..e6ad72843743ab2a856006e36bedf34904cb1fbf 100644 (file)
--- a/src/go/types/lookup.go
+++ b/src/go/types/lookup.go
@@ -10,6 +10,7 @@ package types
 
 import (
        "bytes"
+       "go/token"
        "strings"
 )
 
@@ -55,7 +56,7 @@ func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o
        // Thus, if we have a named pointer type, proceed with the underlying
        // pointer type but discard the result if it is a method since we would
        // not have found it for T (see also go.dev/issue/8590).
-       if t, _ := T.(*Named); t != nil {
+       if t := asNamed(T); t != nil {
                if p, _ := t.Underlying().(*Pointer); p != nil {
                        obj, index, indirect = lookupFieldOrMethodImpl(p, false, pkg, name, false)
                        if _, ok := obj.(*Func); ok {
@@ -139,7 +140,7 @@ func lookupFieldOrMethodImpl(T Type, addressable bool, pkg *Package, name string
 
                        // If we have a named type, we may have associated methods.
                        // Look for those first.
-                       if named, _ := typ.(*Named); named != nil {
+                       if named := asNamed(typ); named != nil {
                                if alt := seen.lookup(named); alt != nil {
                                        // We have seen this type before, at a more shallow depth
                                        // (note that multiples of this type at the current depth
@@ -345,6 +346,7 @@ func (check *Checker) missingMethod(V, T Type, static bool, equivalent func(x, y
                notFound
                wrongName
                wrongSig
+               ambigSel
                ptrRecv
                field
        )
@@ -373,21 +375,23 @@ func (check *Checker) missingMethod(V, T Type, static bool, equivalent func(x, y
                }
        } else {
                for _, m = range methods {
-                       obj, _, indirect := lookupFieldOrMethodImpl(V, false, m.pkg, m.name, false)
+                       obj, index, indirect := lookupFieldOrMethodImpl(V, false, m.pkg, m.name, false)
 
-                       // check if m is on *V, or on V with case-folding
+                       // check if m is ambiguous, on *V, or on V with case-folding
                        if obj == nil {
-                               if indirect {
+                               switch {
+                               case index != nil:
+                                       state = ambigSel
+                               case indirect:
                                        state = ptrRecv
-                                       break
-                               }
-                               obj, _, _ = lookupFieldOrMethodImpl(V, false, m.pkg, m.name, true /* fold case */)
-                               f, _ = obj.(*Func)
-                               if f != nil {
-                                       state = wrongName
-                                       break
+                               default:
+                                       state = notFound
+                                       obj, _, _ = lookupFieldOrMethodImpl(V, false, m.pkg, m.name, true /* fold case */)
+                                       f, _ = obj.(*Func)
+                                       if f != nil {
+                                               state = wrongName
+                                       }
                                }
-                               state = notFound
                                break
                        }
 
@@ -415,6 +419,13 @@ func (check *Checker) missingMethod(V, T Type, static bool, equivalent func(x, y
        }
 
        if cause != nil {
+               if f != nil {
+                       // This method may be formatted in funcString below, so must have a fully
+                       // set up signature.
+                       if check != nil {
+                               check.objDecl(f, nil)
+                       }
+               }
                switch state {
                case notFound:
                        switch {
@@ -438,6 +449,8 @@ func (check *Checker) missingMethod(V, T Type, static bool, equivalent func(x, y
                        }
                        *cause = check.sprintf("(wrong type for method %s)\n\t\thave %s\n\t\twant %s",
                                m.Name(), fs, ms)
+               case ambigSel:
+                       *cause = check.sprintf("(ambiguous selector %s.%s)", V, m.Name())
                case ptrRecv:
                        *cause = check.sprintf("(method %s has pointer receiver)", m.Name())
                case field:
@@ -502,21 +515,21 @@ func (check *Checker) assertableTo(V, T Type, cause *string) bool {
 // in constraint position (we have not yet defined that behavior in the spec).
 // The underlying type of V must be an interface.
 // If the result is false and cause is not nil, *cause is set to the error cause.
-func (check *Checker) newAssertableTo(V, T Type, cause *string) bool {
+func (check *Checker) newAssertableTo(pos token.Pos, V, T Type, cause *string) bool {
        // no static check is required if T is an interface
        // spec: "If T is an interface type, x.(T) asserts that the
        //        dynamic type of x implements the interface T."
        if IsInterface(T) {
                return true
        }
-       return check.implements(T, V, false, cause)
+       return check.implements(pos, T, V, false, cause)
 }
 
 // deref dereferences typ if it is a *Pointer (but not a *Named type
 // with an underlying pointer type!) and returns its base and true.
 // Otherwise it returns (typ, false).
 func deref(typ Type) (Type, bool) {
-       if p, _ := typ.(*Pointer); p != nil {
+       if p, _ := _Unalias(typ).(*Pointer); p != nil {
                // p.base should never be nil, but be conservative
                if p.base == nil {
                        if debug {