* tree-ssa-reassoc.c (reassociate_bb): Clarify code slighly.

[official-gcc.git] / libgo / go / go / types / scope.go

// Copyright 2013 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 Scopes.

package types

import (
        "bytes"
        "fmt"
        "go/token"
        "io"
        "sort"
        "strings"
)

// TODO(gri) Provide scopes with a name or other mechanism so that
//           objects can use that information for better printing.

// A Scope maintains a set of objects and links to its containing
// (parent) and contained (children) scopes. Objects may be inserted
// and looked up by name. The zero value for Scope is a ready-to-use
// empty scope.
type Scope struct {
        parent   *Scope
        children []*Scope
        elems    map[string]Object // lazily allocated
        pos, end token.Pos         // scope extent; may be invalid
        comment  string            // for debugging only
}

// NewScope returns a new, empty scope contained in the given parent
// scope, if any. The comment is for debugging only.
func NewScope(parent *Scope, pos, end token.Pos, comment string) *Scope {
        s := &Scope{parent, nil, nil, pos, end, comment}
        // don't add children to Universe scope!
        if parent != nil && parent != Universe {
                parent.children = append(parent.children, s)
        }
        return s
}

// Parent returns the scope's containing (parent) scope.
func (s *Scope) Parent() *Scope { return s.parent }

// Len() returns the number of scope elements.
func (s *Scope) Len() int { return len(s.elems) }

// Names returns the scope's element names in sorted order.
func (s *Scope) Names() []string {
        names := make([]string, len(s.elems))
        i := 0
        for name := range s.elems {
                names[i] = name
                i++
        }
        sort.Strings(names)
        return names
}

// NumChildren() returns the number of scopes nested in s.
func (s *Scope) NumChildren() int { return len(s.children) }

// Child returns the i'th child scope for 0 <= i < NumChildren().
func (s *Scope) Child(i int) *Scope { return s.children[i] }

// Lookup returns the object in scope s with the given name if such an
// object exists; otherwise the result is nil.
func (s *Scope) Lookup(name string) Object {
        return s.elems[name]
}

// LookupParent follows the parent chain of scopes starting with s until
// it finds a scope where Lookup(name) returns a non-nil object, and then
// returns that scope and object. If a valid position pos is provided,
// only objects that were declared at or before pos are considered.
// If no such scope and object exists, the result is (nil, nil).
//
// Note that obj.Parent() may be different from the returned scope if the
// object was inserted into the scope and already had a parent at that
// time (see Insert, below). This can only happen for dot-imported objects
// whose scope is the scope of the package that exported them.
func (s *Scope) LookupParent(name string, pos token.Pos) (*Scope, Object) {
        for ; s != nil; s = s.parent {
                if obj := s.elems[name]; obj != nil && (!pos.IsValid() || obj.scopePos() <= pos) {
                        return s, obj
                }
        }
        return nil, nil
}

// Insert attempts to insert an object obj into scope s.
// If s already contains an alternative object alt with
// the same name, Insert leaves s unchanged and returns alt.
// Otherwise it inserts obj, sets the object's parent scope
// if not already set, and returns nil.
func (s *Scope) Insert(obj Object) Object {
        name := obj.Name()
        if alt := s.elems[name]; alt != nil {
                return alt
        }
        if s.elems == nil {
                s.elems = make(map[string]Object)
        }
        s.elems[name] = obj
        if obj.Parent() == nil {
                obj.setParent(s)
        }
        return nil
}

// Pos and End describe the scope's source code extent [pos, end).
// The results are guaranteed to be valid only if the type-checked
// AST has complete position information. The extent is undefined
// for Universe and package scopes.
func (s *Scope) Pos() token.Pos { return s.pos }
func (s *Scope) End() token.Pos { return s.end }

// Contains returns true if pos is within the scope's extent.
// The result is guaranteed to be valid only if the type-checked
// AST has complete position information.
func (s *Scope) Contains(pos token.Pos) bool {
        return s.pos <= pos && pos < s.end
}

// Innermost returns the innermost (child) scope containing
// pos. If pos is not within any scope, the result is nil.
// The result is also nil for the Universe scope.
// The result is guaranteed to be valid only if the type-checked
// AST has complete position information.
func (s *Scope) Innermost(pos token.Pos) *Scope {
        // Package scopes do not have extents since they may be
        // discontiguous, so iterate over the package's files.
        if s.parent == Universe {
                for _, s := range s.children {
                        if inner := s.Innermost(pos); inner != nil {
                                return inner
                        }
                }
        }

        if s.Contains(pos) {
                for _, s := range s.children {
                        if s.Contains(pos) {
                                return s.Innermost(pos)
                        }
                }
                return s
        }
        return nil
}

// WriteTo writes a string representation of the scope to w,
// with the scope elements sorted by name.
// The level of indentation is controlled by n >= 0, with
// n == 0 for no indentation.
// If recurse is set, it also writes nested (children) scopes.
func (s *Scope) WriteTo(w io.Writer, n int, recurse bool) {
        const ind = ".  "
        indn := strings.Repeat(ind, n)

        fmt.Fprintf(w, "%s%s scope %p {", indn, s.comment, s)
        if len(s.elems) == 0 {
                fmt.Fprintf(w, "}\n")
                return
        }

        fmt.Fprintln(w)
        indn1 := indn + ind
        for _, name := range s.Names() {
                fmt.Fprintf(w, "%s%s\n", indn1, s.elems[name])
        }

        if recurse {
                for _, s := range s.children {
                        fmt.Fprintln(w)
                        s.WriteTo(w, n+1, recurse)
                }
        }

        fmt.Fprintf(w, "%s}", indn)
}

// String returns a string representation of the scope, for debugging.
func (s *Scope) String() string {
        var buf bytes.Buffer
        s.WriteTo(&buf, 0, false)
        return buf.String()
}