code review 4314054: go/types: New Go type hierarchy implementation for AST.

src/pkg/go/types/types.go

 // Copyright 2011 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 UNDER CONSTRUCTION.
+// PACKAGE UNDER CONSTRUCTION. ANY AND ALL PARTS MAY CHANGE.
 // The types package declares the types used to represent Go types.
 //
 package types
 
 import "go/ast"
 
 
 // All types implement the Type interface.
 type Type interface {
         isType()
 }
 
 
 // All concrete types embed ImplementsType which
 // ensures that all types implement the Type interface.
 type ImplementsType struct{}
 
 func (t *ImplementsType) isType() {}
 
 
 // A Basic represents a (unnamed) basic type.
-// Predeclared types have a basic type as underlying type.
 type Basic struct {
         ImplementsType
         // TODO(gri) need a field specifying the exact basic type
 }
 
 
 // An Array represents an array type [Len]Elt.
 type Array struct {
         ImplementsType
         Len uint64
         Elt Type
 }
 
 
-// A Slice represents a slice type []Elt or ...Elt.
+// A Slice represents a slice type []Elt.
 type Slice struct {
         ImplementsType
-        Ellipsis bool // true for "...Elt" types
-        Elt      Type
+        Elt Type
 }
 
 
 // A Struct represents a struct type struct{...}.
 type Struct struct {
         ImplementsType
-        Fields *ast.Scope // always present
+        // TODO(gri) need to remember fields.
 }
 
 
 // A Pointer represents a pointer type *Base.
 type Pointer struct {
         ImplementsType
         Base Type
 }
 
 
 // A Func represents a function type func(...) (...).
 type Func struct {
         ImplementsType
-        Params *ast.Scope // always present
+        IsVariadic bool
+        // TODO(gri) need to remember parameters.
 }
 
 
 // An Interface represents an interface type interface{...}.
 type Interface struct {
         ImplementsType
-        Methods *ast.Scope // always present
+        // TODO(gri) need to remember methods.
 }
 
 
 // A Map represents a map type map[Key]Elt.
 type Map struct {
         ImplementsType
         Key, Elt Type
 }
 
 
 // A Chan represents a channel type chan Elt, <-chan Elt, or chan<-Elt.
 type Chan struct {
         ImplementsType
         Dir ast.ChanDir
         Elt Type
 }
 
 
 // A Name represents a named type as declared in a type declaration.
 type Name struct {
         ImplementsType
         Underlying Type        // nil if not fully declared
         Obj        *ast.Object // corresponding declared object
-        Scope      *ast.Scope  // associated methods (and fields, if any); or nil
+        // TODO(gri) need to remember fields and methods.
+}
+
+
+// If typ is a pointer type, Deref returns the pointer's base type;
+// otherwise it returns typ.
+func Deref(typ Type) Type {
+        if typ, ok := typ.(*Pointer); ok {
+                return typ.Base
+        }
+        return typ
 }
 
 
 // Underlying returns the underlying type of a type.
 func Underlying(typ Type) Type {
-        if typ, isName := typ.(*Name); isName {
-                return typ.Underlying
+        if typ, ok := typ.(*Name); ok {
+                utyp := typ.Underlying
+                if _, ok := utyp.(*Basic); ok {
+                        return typ
+                }
+                return utyp
+
         }
         return typ
 }