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.

// This file implements the Check function, which typechecks a package.

package types

import (
        "fmt"
        "go/ast"
        "go/scanner"
        "go/token"
        "strconv"
)

const debug = false

type checker struct {
        fset *token.FileSet
        scanner.ErrorVector
        types map[ast.Expr]Type
}

func (c *checker) errorf(pos token.Pos, format string, args ...interface{}) string {
        msg := fmt.Sprintf(format, args...)
        c.Error(c.fset.Position(pos), msg)
        return msg
}

// collectFields collects struct fields tok = token.STRUCT), interface methods
// (tok = token.INTERFACE), and function arguments/results (tok = token.FUNC).
func (c *checker) collectFields(tok token.Token, list *ast.FieldList, cycleOk bool) (fields ObjList, tags []string, isVariadic bool) {
        if list != nil {
                for _, field := range list.List {
                        ftype := field.Type
                        if t, ok := ftype.(*ast.Ellipsis); ok {
                                ftype = t.Elt
                                isVariadic = true
                        }
                        typ := c.makeType(ftype, cycleOk)
                        tag := ""
                        if field.Tag != nil {
                                assert(field.Tag.Kind == token.STRING)
                                tag, _ = strconv.Unquote(field.Tag.Value)
                        }
                        if len(field.Names) > 0 {
                                // named fields
                                for _, name := range field.Names {
                                        obj := name.Obj
                                        obj.Type = typ
                                        fields = append(fields, obj)
                                        if tok == token.STRUCT {
                                                tags = append(tags, tag)
                                        }
                                }
                        } else {
                                // anonymous field
                                switch tok {
                                case token.STRUCT:
                                        tags = append(tags, tag)
                                        fallthrough
                                case token.FUNC:
                                        obj := ast.NewObj(ast.Var, "")
                                        obj.Type = typ
                                        fields = append(fields, obj)
                                case token.INTERFACE:
                                        utyp := Underlying(typ)
                                        if typ, ok := utyp.(*Interface); ok {
                                                // TODO(gri) This is not good enough. Check for double declarations!
                                                fields = append(fields, typ.Methods...)
                                        } else if _, ok := utyp.(*Bad); !ok {
                                                // if utyp is Bad, don't complain (the root cause was reported before)
                                                c.errorf(ftype.Pos(), "interface contains embedded non-interface type")
                                        }
                                default:
                                        panic("unreachable")
                                }
                        }
                }
        }
        return
}

// makeType makes a new type for an AST type specification x or returns
// the type referred to by a type name x. If cycleOk is set, a type may
// refer to itself directly or indirectly; otherwise cycles are errors.
//
func (c *checker) makeType(x ast.Expr, cycleOk bool) (typ Type) {
        if debug {
                fmt.Printf("makeType (cycleOk = %v)\n", cycleOk)
                ast.Print(c.fset, x)
                defer func() {
                        fmt.Printf("-> %T %v\n\n", typ, typ)
                }()
        }

        switch t := x.(type) {
        case *ast.BadExpr:
                return &Bad{}

        case *ast.Ident:
                // type name
                obj := t.Obj
                if obj == nil {
                        // unresolved identifier (error has been reported before)
                        return &Bad{Msg: "unresolved identifier"}
                }
                if obj.Kind != ast.Typ {
                        msg := c.errorf(t.Pos(), "%s is not a type", t.Name)
                        return &Bad{Msg: msg}
                }
                c.checkObj(obj, cycleOk)
                if !cycleOk && obj.Type.(*Name).Underlying == nil {
                        // TODO(gri) Enable this message again once its position
                        // is independent of the underlying map implementation.
                        // msg := c.errorf(obj.Pos(), "illegal cycle in declaration of %s", obj.Name)
                        msg := "illegal cycle"
                        return &Bad{Msg: msg}
                }
                return obj.Type.(Type)

        case *ast.ParenExpr:
                return c.makeType(t.X, cycleOk)

        case *ast.SelectorExpr:
                // qualified identifier
                // TODO (gri) eventually, this code belongs to expression
                //            type checking - here for the time being
                if ident, ok := t.X.(*ast.Ident); ok {
                        if obj := ident.Obj; obj != nil {
                                if obj.Kind != ast.Pkg {
                                        msg := c.errorf(ident.Pos(), "%s is not a package", obj.Name)
                                        return &Bad{Msg: msg}
                                }
                                // TODO(gri) we have a package name but don't
                                // have the mapping from package name to package
                                // scope anymore (created in ast.NewPackage).
                                return &Bad{} // for now
                        }
                }
                // TODO(gri) can this really happen (the parser should have excluded this)?
                msg := c.errorf(t.Pos(), "expected qualified identifier")
                return &Bad{Msg: msg}

        case *ast.StarExpr:
                return &Pointer{Base: c.makeType(t.X, true)}

        case *ast.ArrayType:
                if t.Len != nil {
                        // TODO(gri) compute length
                        return &Array{Elt: c.makeType(t.Elt, cycleOk)}
                }
                return &Slice{Elt: c.makeType(t.Elt, true)}

        case *ast.StructType:
                fields, tags, _ := c.collectFields(token.STRUCT, t.Fields, cycleOk)
                return &Struct{Fields: fields, Tags: tags}

        case *ast.FuncType:
                params, _, _ := c.collectFields(token.FUNC, t.Params, true)
                results, _, isVariadic := c.collectFields(token.FUNC, t.Results, true)
                return &Func{Recv: nil, Params: params, Results: results, IsVariadic: isVariadic}

        case *ast.InterfaceType:
                methods, _, _ := c.collectFields(token.INTERFACE, t.Methods, cycleOk)
                methods.Sort()
                return &Interface{Methods: methods}

        case *ast.MapType:
                return &Map{Key: c.makeType(t.Key, true), Elt: c.makeType(t.Key, true)}

        case *ast.ChanType:
                return &Chan{Dir: t.Dir, Elt: c.makeType(t.Value, true)}
        }

        panic(fmt.Sprintf("unreachable (%T)", x))
}

// checkObj type checks an object.
func (c *checker) checkObj(obj *ast.Object, ref bool) {
        if obj.Type != nil {
                // object has already been type checked
                return
        }

        switch obj.Kind {
        case ast.Bad:
                // ignore

        case ast.Con:
                // TODO(gri) complete this

        case ast.Typ:
                typ := &Name{Obj: obj}
                obj.Type = typ // "mark" object so recursion terminates
                typ.Underlying = Underlying(c.makeType(obj.Decl.(*ast.TypeSpec).Type, ref))

        case ast.Var:
                // TODO(gri) complete this

        case ast.Fun:
                // TODO(gri) complete this

        default:
                panic("unreachable")
        }
}

// Check typechecks a package.
// It augments the AST by assigning types to all ast.Objects and returns a map
// of types for all expression nodes in statements, and a scanner.ErrorList if
// there are errors.
//
func Check(fset *token.FileSet, pkg *ast.Package) (types map[ast.Expr]Type, err error) {
        var c checker
        c.fset = fset
        c.types = make(map[ast.Expr]Type)

        for _, obj := range pkg.Scope.Objects {
                c.checkObj(obj, false)
        }

        return c.types, c.GetError(scanner.NoMultiples)
}