scope.go

     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 { return resolve(name, s.elems[name]) }
    74  
    75  // lookupIgnoringCase returns the objects in scope s whose names match
    76  // the given name ignoring case. If exported is set, only exported names
    77  // are returned.
    78  func (s *Scope) lookupIgnoringCase(name string, exported bool) []Object {
    79  	var matches []Object
    80  	for _, n := range s.Names() {
    81  		if (!exported || isExported(n)) && strings.EqualFold(n, name) {
    82  			matches = append(matches, s.Lookup(n))
    83  		}
    84  	}
    85  	return matches
    86  }
    87  
    88  // Insert attempts to insert an object obj into scope s.
    89  // If s already contains an alternative object alt with
    90  // the same name, Insert leaves s unchanged and returns alt.
    91  // Otherwise it inserts obj, sets the object's parent scope
    92  // if not already set, and returns nil.
    93  func (s *Scope) Insert(obj Object) Object {
    94  	name := obj.Name()
    95  	if alt := s.Lookup(name); alt != nil {
    96  		return alt
    97  	}
    98  	s.insert(name, obj)
    99  	// TODO(gri) Can we always set the parent to s (or is there
   100  	// a need to keep the original parent or some race condition)?
   101  	// If we can, than we may not need environment.lookupScope
   102  	// which is only there so that we get the correct scope for
   103  	// marking "used" dot-imported packages.
   104  	if obj.Parent() == nil {
   105  		obj.setParent(s)
   106  	}
   107  	return nil
   108  }
   109  
   110  // InsertLazy is like Insert, but allows deferring construction of the
   111  // inserted object until it's accessed with Lookup. The Object
   112  // returned by resolve must have the same name as given to InsertLazy.
   113  // If s already contains an alternative object with the same name,
   114  // InsertLazy leaves s unchanged and returns false. Otherwise it
   115  // records the binding and returns true. The object's parent scope
   116  // will be set to s after resolve is called.
   117  func (s *Scope) _InsertLazy(name string, resolve func() Object) bool {
   118  	if s.elems[name] != nil {
   119  		return false
   120  	}
   121  	s.insert(name, &lazyObject{parent: s, resolve: resolve})
   122  	return true
   123  }
   124  
   125  func (s *Scope) insert(name string, obj Object) {
   126  	if s.elems == nil {
   127  		s.elems = make(map[string]Object)
   128  	}
   129  	s.elems[name] = obj
   130  }
   131  
   132  // WriteTo writes a string representation of the scope to w,
   133  // with the scope elements sorted by name.
   134  // The level of indentation is controlled by n >= 0, with
   135  // n == 0 for no indentation.
   136  // If recurse is set, it also writes nested (children) scopes.
   137  func (s *Scope) WriteTo(w io.Writer, n int, recurse bool) {
   138  	const ind = ".  "
   139  	indn := strings.Repeat(ind, n)
   140  
   141  	fmt.Fprintf(w, "%s%s scope %p {\n", indn, s.comment, s)
   142  
   143  	indn1 := indn + ind
   144  	for _, name := range s.Names() {
   145  		fmt.Fprintf(w, "%s%s\n", indn1, s.Lookup(name))
   146  	}
   147  
   148  	if recurse {
   149  		for _, s := range s.children {
   150  			s.WriteTo(w, n+1, recurse)
   151  		}
   152  	}
   153  
   154  	fmt.Fprintf(w, "%s}\n", indn)
   155  }
   156  
   157  // String returns a string representation of the scope, for debugging.
   158  func (s *Scope) String() string {
   159  	var buf strings.Builder
   160  	s.WriteTo(&buf, 0, false)
   161  	return buf.String()
   162  }
   163  
   164  // A lazyObject represents an imported Object that has not been fully
   165  // resolved yet by its importer.
   166  type lazyObject struct {
   167  	parent  *Scope
   168  	resolve func() Object
   169  	obj     Object
   170  	once    sync.Once
   171  }
   172  
   173  // resolve returns the Object represented by obj, resolving lazy
   174  // objects as appropriate.
   175  func resolve(name string, obj Object) Object {
   176  	if lazy, ok := obj.(*lazyObject); ok {
   177  		lazy.once.Do(func() {
   178  			obj := lazy.resolve()
   179  
   180  			if _, ok := obj.(*lazyObject); ok {
   181  				panic("recursive lazy object")
   182  			}
   183  			if obj.Name() != name {
   184  				panic("lazy object has unexpected name")
   185  			}
   186  
   187  			if obj.Parent() == nil {
   188  				obj.setParent(lazy.parent)
   189  			}
   190  			lazy.obj = obj
   191  		})
   192  
   193  		obj = lazy.obj
   194  	}
   195  	return obj
   196  }
   197  
   198  // stub implementations so *lazyObject implements Object and we can
   199  // store them directly into Scope.elems.
   200  func (*lazyObject) Parent() *Scope                     { panic("unreachable") }
   201  func (*lazyObject) Pos() token.Pos                     { panic("unreachable") }
   202  func (*lazyObject) Pkg() *Package                      { panic("unreachable") }
   203  func (*lazyObject) Name() string                       { panic("unreachable") }
   204  func (*lazyObject) Type() Type                         { panic("unreachable") }
   205  func (*lazyObject) Exported() bool                     { panic("unreachable") }
   206  func (*lazyObject) Id() string                         { panic("unreachable") }
   207  func (*lazyObject) String() string                     { panic("unreachable") }
   208  func (*lazyObject) order() uint32                      { panic("unreachable") }
   209  func (*lazyObject) setType(Type)                       { panic("unreachable") }
   210  func (*lazyObject) setOrder(uint32)                    { panic("unreachable") }
   211  func (*lazyObject) setParent(*Scope)                   { panic("unreachable") }
   212  func (*lazyObject) sameId(*Package, string, bool) bool { panic("unreachable") }
   213  func (*lazyObject) scopePos() token.Pos                { panic("unreachable") }
   214  func (*lazyObject) setScopePos(token.Pos)              { panic("unreachable") }
   215
View as plain text