// 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") }