Subversion Repositories openrisc

// 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. ANY AND ALL PARTS MAY CHANGE.
// Package types declares the types used to represent Go types.
//
package types

import (
        "go/ast"
        "sort"
)

// 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 Bad type is a non-nil placeholder type when we don't know a type.
type Bad struct {
        ImplementsType
        Msg string // for better error reporting/debugging
}

// A Basic represents a (unnamed) basic 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.
type Slice struct {
        ImplementsType
        Elt Type
}

// A Struct represents a struct type struct{...}.
// Anonymous fields are represented by objects with empty names.
type Struct struct {
        ImplementsType
        Fields ObjList  // struct fields; or nil
        Tags   []string // corresponding tags; or nil
        // TODO(gri) This type needs some rethinking:
        // - at the moment anonymous fields are marked with "" object names,
        //   and their names have to be reconstructed
        // - there is no scope for fast lookup (but the parser creates one)
}

// A Pointer represents a pointer type *Base.
type Pointer struct {
        ImplementsType
        Base Type
}

// A Func represents a function type func(...) (...).
// Unnamed parameters are represented by objects with empty names.
type Func struct {
        ImplementsType
        Recv       *ast.Object // nil if not a method
        Params     ObjList     // (incoming) parameters from left to right; or nil
        Results    ObjList     // (outgoing) results from left to right; or nil
        IsVariadic bool        // true if the last parameter's type is of the form ...T
}

// An Interface represents an interface type interface{...}.
type Interface struct {
        ImplementsType
        Methods ObjList // interface methods sorted by name; or nil
}

// 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
        // 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, ok := typ.(*Name); ok {
                utyp := typ.Underlying
                if _, ok := utyp.(*Basic); !ok {
                        return utyp
                }
                // the underlying type of a type name referring
                // to an (untyped) basic type is the basic type
                // name
        }
        return typ
}

// An ObjList represents an ordered (in some fashion) list of objects.
type ObjList []*ast.Object

// ObjList implements sort.Interface.
func (list ObjList) Len() int           { return len(list) }
func (list ObjList) Less(i, j int) bool { return list[i].Name < list[j].Name }
func (list ObjList) Swap(i, j int)      { list[i], list[j] = list[j], list[i] }

// Sort sorts an object list by object name.
func (list ObjList) Sort() { sort.Sort(list) }

// identicalTypes returns true if both lists a and b have the
// same length and corresponding objects have identical types.
func identicalTypes(a, b ObjList) bool {
        if len(a) == len(b) {
                for i, x := range a {
                        y := b[i]
                        if !Identical(x.Type.(Type), y.Type.(Type)) {
                                return false
                        }
                }
                return true
        }
        return false
}

// Identical returns true if two types are identical.
func Identical(x, y Type) bool {
        if x == y {
                return true
        }

        switch x := x.(type) {
        case *Bad:
                // A Bad type is always identical to any other type
                // (to avoid spurious follow-up errors).
                return true

        case *Basic:
                if y, ok := y.(*Basic); ok {
                        panic("unimplemented")
                        _ = y
                }

        case *Array:
                // Two array types are identical if they have identical element types
                // and the same array length.
                if y, ok := y.(*Array); ok {
                        return x.Len == y.Len && Identical(x.Elt, y.Elt)
                }

        case *Slice:
                // Two slice types are identical if they have identical element types.
                if y, ok := y.(*Slice); ok {
                        return Identical(x.Elt, y.Elt)
                }

        case *Struct:
                // Two struct types are identical if they have the same sequence of fields,
                // and if corresponding fields have the same names, and identical types,
                // and identical tags. Two anonymous fields are considered to have the same
                // name. Lower-case field names from different packages are always different.
                if y, ok := y.(*Struct); ok {
                        // TODO(gri) handle structs from different packages
                        if identicalTypes(x.Fields, y.Fields) {
                                for i, f := range x.Fields {
                                        g := y.Fields[i]
                                        if f.Name != g.Name || x.Tags[i] != y.Tags[i] {
                                                return false
                                        }
                                }
                                return true
                        }
                }

        case *Pointer:
                // Two pointer types are identical if they have identical base types.
                if y, ok := y.(*Pointer); ok {
                        return Identical(x.Base, y.Base)
                }

        case *Func:
                // Two function types are identical if they have the same number of parameters
                // and result values, corresponding parameter and result types are identical,
                // and either both functions are variadic or neither is. Parameter and result
                // names are not required to match.
                if y, ok := y.(*Func); ok {
                        return identicalTypes(x.Params, y.Params) &&
                                identicalTypes(x.Results, y.Results) &&
                                x.IsVariadic == y.IsVariadic
                }

        case *Interface:
                // Two interface types are identical if they have the same set of methods with
                // the same names and identical function types. Lower-case method names from
                // different packages are always different. The order of the methods is irrelevant.
                if y, ok := y.(*Interface); ok {
                        return identicalTypes(x.Methods, y.Methods) // methods are sorted
                }

        case *Map:
                // Two map types are identical if they have identical key and value types.
                if y, ok := y.(*Map); ok {
                        return Identical(x.Key, y.Key) && Identical(x.Elt, y.Elt)
                }

        case *Chan:
                // Two channel types are identical if they have identical value types
                // and the same direction.
                if y, ok := y.(*Chan); ok {
                        return x.Dir == y.Dir && Identical(x.Elt, y.Elt)
                }

        case *Name:
                // Two named types are identical if their type names originate
                // in the same type declaration.
                if y, ok := y.(*Name); ok {
                        return x.Obj == y.Obj ||
                                // permit bad objects to be equal to avoid
                                // follow up errors
                                x.Obj != nil && x.Obj.Kind == ast.Bad ||
                                y.Obj != nil && y.Obj.Kind == ast.Bad
                }
        }

        return false
}