mirror of https://go.googlesource.com/go
308 lines
9.9 KiB
Go
308 lines
9.9 KiB
Go
// Code generated by "go test -run=Generate -write=all"; DO NOT EDIT.
|
|
// Source: ../../cmd/compile/internal/types2/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 (
|
|
"fmt"
|
|
"go/token"
|
|
"io"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
)
|
|
|
|
// 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
|
|
number int // parent.children[number-1] is this scope; 0 if there is no parent
|
|
elems map[string]Object // lazily allocated
|
|
pos, end token.Pos // scope extent; may be invalid
|
|
comment string // for debugging only
|
|
isFunc bool // set if this is a function scope (internal use 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, 0, nil, pos, end, comment, false}
|
|
// don't add children to Universe scope!
|
|
if parent != nil && parent != Universe {
|
|
parent.children = append(parent.children, s)
|
|
s.number = len(parent.children)
|
|
}
|
|
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 {
|
|
obj := resolve(name, s.elems[name])
|
|
// Hijack Lookup for "any": with gotypesalias=1, we want the Universe to
|
|
// return an Alias for "any", and with gotypesalias=0 we want to return
|
|
// the legacy representation of aliases.
|
|
//
|
|
// This is rather tricky, but works out after auditing of the usage of
|
|
// s.elems. The only external API to access scope elements is Lookup.
|
|
//
|
|
// TODO: remove this once gotypesalias=0 is no longer supported.
|
|
if obj == universeAnyAlias && !aliasAny() {
|
|
return universeAnyNoAlias
|
|
}
|
|
return obj
|
|
}
|
|
|
|
// 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). 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.Lookup(name); obj != nil && (!pos.IsValid() || cmpPos(obj.scopePos(), pos) <= 0) {
|
|
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.Lookup(name); alt != nil {
|
|
return alt
|
|
}
|
|
s.insert(name, obj)
|
|
if obj.Parent() == nil {
|
|
obj.setParent(s)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// InsertLazy is like Insert, but allows deferring construction of the
|
|
// inserted object until it's accessed with Lookup. The Object
|
|
// returned by resolve must have the same name as given to InsertLazy.
|
|
// If s already contains an alternative object with the same name,
|
|
// InsertLazy leaves s unchanged and returns false. Otherwise it
|
|
// records the binding and returns true. The object's parent scope
|
|
// will be set to s after resolve is called.
|
|
func (s *Scope) _InsertLazy(name string, resolve func() Object) bool {
|
|
if s.elems[name] != nil {
|
|
return false
|
|
}
|
|
s.insert(name, &lazyObject{parent: s, resolve: resolve})
|
|
return true
|
|
}
|
|
|
|
func (s *Scope) insert(name string, obj Object) {
|
|
if s.elems == nil {
|
|
s.elems = make(map[string]Object)
|
|
}
|
|
s.elems[name] = obj
|
|
}
|
|
|
|
// Squash merges s with its parent scope p by adding all
|
|
// objects of s to p, adding all children of s to the
|
|
// children of p, and removing s from p's children.
|
|
// The function f is called for each object obj in s which
|
|
// has an object alt in p. s should be discarded after
|
|
// having been squashed.
|
|
func (s *Scope) squash(err func(obj, alt Object)) {
|
|
p := s.parent
|
|
assert(p != nil)
|
|
for name, obj := range s.elems {
|
|
obj = resolve(name, obj)
|
|
obj.setParent(nil)
|
|
if alt := p.Insert(obj); alt != nil {
|
|
err(obj, alt)
|
|
}
|
|
}
|
|
|
|
j := -1 // index of s in p.children
|
|
for i, ch := range p.children {
|
|
if ch == s {
|
|
j = i
|
|
break
|
|
}
|
|
}
|
|
assert(j >= 0)
|
|
k := len(p.children) - 1
|
|
p.children[j] = p.children[k]
|
|
p.children = p.children[:k]
|
|
|
|
p.children = append(p.children, s.children...)
|
|
|
|
s.children = nil
|
|
s.elems = 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 reports whether 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 cmpPos(s.pos, pos) <= 0 && cmpPos(pos, s.end) < 0
|
|
}
|
|
|
|
// 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 {\n", indn, s.comment, s)
|
|
|
|
indn1 := indn + ind
|
|
for _, name := range s.Names() {
|
|
fmt.Fprintf(w, "%s%s\n", indn1, s.Lookup(name))
|
|
}
|
|
|
|
if recurse {
|
|
for _, s := range s.children {
|
|
s.WriteTo(w, n+1, recurse)
|
|
}
|
|
}
|
|
|
|
fmt.Fprintf(w, "%s}\n", indn)
|
|
}
|
|
|
|
// String returns a string representation of the scope, for debugging.
|
|
func (s *Scope) String() string {
|
|
var buf strings.Builder
|
|
s.WriteTo(&buf, 0, false)
|
|
return buf.String()
|
|
}
|
|
|
|
// A lazyObject represents an imported Object that has not been fully
|
|
// resolved yet by its importer.
|
|
type lazyObject struct {
|
|
parent *Scope
|
|
resolve func() Object
|
|
obj Object
|
|
once sync.Once
|
|
}
|
|
|
|
// resolve returns the Object represented by obj, resolving lazy
|
|
// objects as appropriate.
|
|
func resolve(name string, obj Object) Object {
|
|
if lazy, ok := obj.(*lazyObject); ok {
|
|
lazy.once.Do(func() {
|
|
obj := lazy.resolve()
|
|
|
|
if _, ok := obj.(*lazyObject); ok {
|
|
panic("recursive lazy object")
|
|
}
|
|
if obj.Name() != name {
|
|
panic("lazy object has unexpected name")
|
|
}
|
|
|
|
if obj.Parent() == nil {
|
|
obj.setParent(lazy.parent)
|
|
}
|
|
lazy.obj = obj
|
|
})
|
|
|
|
obj = lazy.obj
|
|
}
|
|
return obj
|
|
}
|
|
|
|
// stub implementations so *lazyObject implements Object and we can
|
|
// store them directly into Scope.elems.
|
|
func (*lazyObject) Parent() *Scope { panic("unreachable") }
|
|
func (*lazyObject) Pos() token.Pos { panic("unreachable") }
|
|
func (*lazyObject) Pkg() *Package { panic("unreachable") }
|
|
func (*lazyObject) Name() string { panic("unreachable") }
|
|
func (*lazyObject) Type() Type { panic("unreachable") }
|
|
func (*lazyObject) Exported() bool { panic("unreachable") }
|
|
func (*lazyObject) Id() string { panic("unreachable") }
|
|
func (*lazyObject) String() string { panic("unreachable") }
|
|
func (*lazyObject) order() uint32 { panic("unreachable") }
|
|
func (*lazyObject) color() color { panic("unreachable") }
|
|
func (*lazyObject) setType(Type) { panic("unreachable") }
|
|
func (*lazyObject) setOrder(uint32) { panic("unreachable") }
|
|
func (*lazyObject) setColor(color color) { panic("unreachable") }
|
|
func (*lazyObject) setParent(*Scope) { panic("unreachable") }
|
|
func (*lazyObject) sameId(*Package, string, bool) bool { panic("unreachable") }
|
|
func (*lazyObject) scopePos() token.Pos { panic("unreachable") }
|
|
func (*lazyObject) setScopePos(token.Pos) { panic("unreachable") }
|