code review 7363054: go/types: fix sizeof computations

src/pkg/go/types/operand.go

 // Copyright 2012 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.
 
 // This file defines operands and associated operations.
 
 package types
 
 import (
         "bytes"
@@ skipping 285 matching lines @@
                                         // Collect embedded struct fields for searching the next
                                         // lower level, but only if we have not seen a match yet
                                         // (if we have a match it is either the desired field or
                                         // we have a name collision on the same level; in either
                                         // case we don't need to look further).
                                         // Embedded fields are always of the form T or *T where
                                         // T is a named type. If typ appeared multiple times at
                                         // this level, f.Type appears multiple times at the next
                                         // level.
                                         if f.IsAnonymous && res.mode == invalid {
-                                                var index []int
-                                                index = append(index, e.index...) // copy e.index
-                                                index = append(index, i)
-                                                next = append(next, embeddedType{deref(f.Type).(*NamedType), index, e.multiples})
+                                                // Ignore embedded basic types - only user-defined
+                                                // named types can have methods or have struct fields.
+                                                if t, _ := deref(f.Type).(*NamedType); t != nil {
+                                                        var index []int
+                                                        index = append(index, e.index...) // copy e.index
+                                                        index = append(index, i)
+                                                        next = append(next, embeddedType{t, index, e.multiples})
+                                                }
                                         }
                                 }
 
                         case *Interface:
                                 // look for a matching method
                                 for _, m := range t.Methods {
                                         if name.IsSame(m.QualifiedName) {
                                                 assert(m.Type != nil)
                                                 if !potentialMatch(e.multiples, value, m.Type) {
                                                         return // name collision
@@ skipping 56 matching lines @@
         case *Struct:
                 var next []embeddedType
                 for i, f := range t.Fields {
                         if name.IsSame(f.QualifiedName) {
                                 return lookupResult{variable, f.Type, []int{i}}
                         }
                         if f.IsAnonymous {
                                 // Possible optimization: If the embedded type
                                 // is a pointer to the current type we could
                                 // ignore it.
-                                next = append(next, embeddedType{deref(f.Type).(*NamedType), []int{i}, false})
+                                // Ignore embedded basic types - only user-defined
+                                // named types can have methods or have struct fields.
+                                if t, _ := deref(f.Type).(*NamedType); t != nil {
+                                        next = append(next, embeddedType{t, []int{i}, false})
+                                }
                         }
                 }
                 if len(next) > 0 {
                         return lookupFieldBreadthFirst(next, name)
                 }
 
         case *Interface:
                 for _, m := range t.Methods {
                         if name.IsSame(m.QualifiedName) {
                                 return lookupResult{value, m.Type, nil}
                         }
                 }
         }
 
         // not found
         return lookupResult{mode: invalid}
 }