1 // Code generated by "go test -run=Generate -write=all"; DO NOT EDIT.
2 // Source: ../../cmd/compile/internal/types2/scope.go
3 4 // Copyright 2013 The Go Authors. All rights reserved.
5 // Use of this source code is governed by a BSD-style
6 // license that can be found in the LICENSE file.
7 8 // This file implements Scopes.
9 10 package types
11 12 import (
13 "fmt"
14 "go/token"
15 "io"
16 "slices"
17 "strings"
18 "sync"
19 )
20 21 // A Scope maintains a set of objects and links to its containing
22 // (parent) and contained (children) scopes. Objects may be inserted
23 // and looked up by name. The zero value for Scope is a ready-to-use
24 // empty scope.
25 type Scope struct {
26 parent *Scope
27 children []*Scope
28 number int // parent.children[number-1] is this scope; 0 if there is no parent
29 elems map[string]Object // lazily allocated
30 pos, end token.Pos // scope extent; may be invalid
31 comment string // for debugging only
32 isFunc bool // set if this is a function scope (internal use only)
33 }
34 35 // NewScope returns a new, empty scope contained in the given parent
36 // scope, if any. The comment is for debugging only.
37 func NewScope(parent *Scope, pos, end token.Pos, comment string) *Scope {
38 s := &Scope{parent, nil, 0, nil, pos, end, comment, false}
39 // don't add children to Universe scope!
40 if parent != nil && parent != Universe {
41 parent.children = append(parent.children, s)
42 s.number = len(parent.children)
43 }
44 return s
45 }
46 47 // Parent returns the scope's containing (parent) scope.
48 func (s *Scope) Parent() *Scope { return s.parent }
49 50 // Len returns the number of scope elements.
51 func (s *Scope) Len() int { return len(s.elems) }
52 53 // Names returns the scope's element names in sorted order.
54 func (s *Scope) Names() []string {
55 names := make([]string, len(s.elems))
56 i := 0
57 for name := range s.elems {
58 names[i] = name
59 i++
60 }
61 slices.Sort(names)
62 return names
63 }
64 65 // NumChildren returns the number of scopes nested in s.
66 func (s *Scope) NumChildren() int { return len(s.children) }
67 68 // Child returns the i'th child scope for 0 <= i < NumChildren().
69 func (s *Scope) Child(i int) *Scope { return s.children[i] }
70 71 // Lookup returns the object in scope s with the given name if such an
72 // object exists; otherwise the result is nil.
73 func (s *Scope) Lookup(name string) Object {
74 obj := resolve(name, s.elems[name])
75 // Hijack Lookup for "any": with gotypesalias=1, we want the Universe to
76 // return an Alias for "any", and with gotypesalias=0 we want to return
77 // the legacy representation of aliases.
78 //
79 // This is rather tricky, but works out after auditing of the usage of
80 // s.elems. The only external API to access scope elements is Lookup.
81 //
82 // TODO: remove this once gotypesalias=0 is no longer supported.
83 if obj == universeAnyAlias && !aliasAny() {
84 return universeAnyNoAlias
85 }
86 return obj
87 }
88 89 // lookupIgnoringCase returns the objects in scope s whose names match
90 // the given name ignoring case. If exported is set, only exported names
91 // are returned.
92 func (s *Scope) lookupIgnoringCase(name string, exported bool) []Object {
93 var matches []Object
94 for _, n := range s.Names() {
95 if (!exported || isExported(n)) && strings.EqualFold(n, name) {
96 matches = append(matches, s.Lookup(n))
97 }
98 }
99 return matches
100 }
101 102 // Insert attempts to insert an object obj into scope s.
103 // If s already contains an alternative object alt with
104 // the same name, Insert leaves s unchanged and returns alt.
105 // Otherwise it inserts obj, sets the object's parent scope
106 // if not already set, and returns nil.
107 func (s *Scope) Insert(obj Object) Object {
108 name := obj.Name()
109 if alt := s.Lookup(name); alt != nil {
110 return alt
111 }
112 s.insert(name, obj)
113 // TODO(gri) Can we always set the parent to s (or is there
114 // a need to keep the original parent or some race condition)?
115 // If we can, than we may not need environment.lookupScope
116 // which is only there so that we get the correct scope for
117 // marking "used" dot-imported packages.
118 if obj.Parent() == nil {
119 obj.setParent(s)
120 }
121 return nil
122 }
123 124 // InsertLazy is like Insert, but allows deferring construction of the
125 // inserted object until it's accessed with Lookup. The Object
126 // returned by resolve must have the same name as given to InsertLazy.
127 // If s already contains an alternative object with the same name,
128 // InsertLazy leaves s unchanged and returns false. Otherwise it
129 // records the binding and returns true. The object's parent scope
130 // will be set to s after resolve is called.
131 func (s *Scope) _InsertLazy(name string, resolve func() Object) bool {
132 if s.elems[name] != nil {
133 return false
134 }
135 s.insert(name, &lazyObject{parent: s, resolve: resolve})
136 return true
137 }
138 139 func (s *Scope) insert(name string, obj Object) {
140 if s.elems == nil {
141 s.elems = make(map[string]Object)
142 }
143 s.elems[name] = obj
144 }
145 146 // WriteTo writes a string representation of the scope to w,
147 // with the scope elements sorted by name.
148 // The level of indentation is controlled by n >= 0, with
149 // n == 0 for no indentation.
150 // If recurse is set, it also writes nested (children) scopes.
151 func (s *Scope) WriteTo(w io.Writer, n int, recurse bool) {
152 const ind = ". "
153 indn := strings.Repeat(ind, n)
154 155 fmt.Fprintf(w, "%s%s scope %p {\n", indn, s.comment, s)
156 157 indn1 := indn + ind
158 for _, name := range s.Names() {
159 fmt.Fprintf(w, "%s%s\n", indn1, s.Lookup(name))
160 }
161 162 if recurse {
163 for _, s := range s.children {
164 s.WriteTo(w, n+1, recurse)
165 }
166 }
167 168 fmt.Fprintf(w, "%s}\n", indn)
169 }
170 171 // String returns a string representation of the scope, for debugging.
172 func (s *Scope) String() string {
173 var buf strings.Builder
174 s.WriteTo(&buf, 0, false)
175 return buf.String()
176 }
177 178 // A lazyObject represents an imported Object that has not been fully
179 // resolved yet by its importer.
180 type lazyObject struct {
181 parent *Scope
182 resolve func() Object
183 obj Object
184 once sync.Once
185 }
186 187 // resolve returns the Object represented by obj, resolving lazy
188 // objects as appropriate.
189 func resolve(name string, obj Object) Object {
190 if lazy, ok := obj.(*lazyObject); ok {
191 lazy.once.Do(func() {
192 obj := lazy.resolve()
193 194 if _, ok := obj.(*lazyObject); ok {
195 panic("recursive lazy object")
196 }
197 if obj.Name() != name {
198 panic("lazy object has unexpected name")
199 }
200 201 if obj.Parent() == nil {
202 obj.setParent(lazy.parent)
203 }
204 lazy.obj = obj
205 })
206 207 obj = lazy.obj
208 }
209 return obj
210 }
211 212 // stub implementations so *lazyObject implements Object and we can
213 // store them directly into Scope.elems.
214 func (*lazyObject) Parent() *Scope { panic("unreachable") }
215 func (*lazyObject) Pos() token.Pos { panic("unreachable") }
216 func (*lazyObject) Pkg() *Package { panic("unreachable") }
217 func (*lazyObject) Name() string { panic("unreachable") }
218 func (*lazyObject) Type() Type { panic("unreachable") }
219 func (*lazyObject) Exported() bool { panic("unreachable") }
220 func (*lazyObject) Id() string { panic("unreachable") }
221 func (*lazyObject) String() string { panic("unreachable") }
222 func (*lazyObject) order() uint32 { panic("unreachable") }
223 func (*lazyObject) color() color { panic("unreachable") }
224 func (*lazyObject) setType(Type) { panic("unreachable") }
225 func (*lazyObject) setOrder(uint32) { panic("unreachable") }
226 func (*lazyObject) setColor(color color) { panic("unreachable") }
227 func (*lazyObject) setParent(*Scope) { panic("unreachable") }
228 func (*lazyObject) sameId(*Package, string, bool) bool { panic("unreachable") }
229 func (*lazyObject) scopePos() token.Pos { panic("unreachable") }
230 func (*lazyObject) setScopePos(token.Pos) { panic("unreachable") }
231