File Manager

X7ROOT File Manager

Current Path: /opt/golang/1.19.4/src/cmd/compile/internal/types2

opt / golang / 1.19.4 / src / cmd / compile / internal / types2 /

📁 ..
📄 api.go(17.37 KB)
📄 api_test.go(79.44 KB)
📄 array.go(803 B)
📄 assignments.go(13.89 KB)
📄 basic.go(1.48 KB)
📄 builtins.go(23.73 KB)
📄 builtins_test.go(9.89 KB)
📄 call.go(19.08 KB)
📄 chan.go(910 B)
📄 check.go(17.12 KB)
📄 check_test.go(8.96 KB)
📄 compilersupport.go(1.05 KB)
📄 context.go(4.34 KB)
📄 context_test.go(2.3 KB)
📄 conversions.go(8.27 KB)
📄 decl.go(27.86 KB)
📄 errorcalls_test.go(1.15 KB)
📄 errors.go(7.62 KB)
📄 errors_test.go(1.01 KB)
📄 example_test.go(7.41 KB)
📄 expr.go(54.01 KB)
📄 gccgosizes.go(1017 B)
📄 hilbert_test.go(3.63 KB)
📄 importer_test.go(913 B)
📄 index.go(11.13 KB)
📄 infer.go(24.86 KB)
📄 initorder.go(9.55 KB)
📄 instantiate.go(9.93 KB)
📄 instantiate_test.go(5.98 KB)
📄 interface.go(6.04 KB)
📄 issues_test.go(17.4 KB)
📄 labels.go(7.05 KB)
📄 lookup.go(17.01 KB)
📄 main_test.go(336 B)
📄 map.go(659 B)
📄 mono.go(9.03 KB)
📄 mono_test.go(2.65 KB)
📄 named.go(22.4 KB)
📄 named_test.go(2.35 KB)
📄 object.go(18.8 KB)
📄 object_test.go(5.13 KB)
📄 objset.go(928 B)
📄 operand.go(10.62 KB)
📄 package.go(2.67 KB)
📄 pointer.go(635 B)
📄 predicates.go(14.64 KB)
📄 resolver.go(24.88 KB)
📄 resolver_test.go(4.81 KB)
📄 return.go(4.34 KB)
📄 scope.go(9.38 KB)
📄 selection.go(3.99 KB)
📄 self_test.go(2.58 KB)
📄 signature.go(12.1 KB)
📄 sizeof_test.go(1.28 KB)
📄 sizes.go(7.56 KB)
📄 sizes_test.go(3.25 KB)
📄 slice.go(577 B)
📄 stdlib_test.go(8.8 KB)
📄 stmt.go(25.66 KB)
📄 struct.go(6.24 KB)
📄 subst.go(10.78 KB)
📄 termlist.go(3.68 KB)
📄 termlist_test.go(7.18 KB)
📁 testdata
📄 tuple.go(929 B)
📄 type.go(2.92 KB)
📄 typelists.go(1.84 KB)
📄 typeparam.go(4.75 KB)
📄 typeset.go(13.87 KB)
📄 typeset_test.go(2.41 KB)
📄 typestring.go(10.61 KB)
📄 typestring_test.go(4.11 KB)
📄 typeterm.go(3.52 KB)
📄 typeterm_test.go(5.08 KB)
📄 typexpr.go(14.8 KB)
📄 unify.go(18.34 KB)
📄 union.go(6.1 KB)
📄 universe.go(7.58 KB)
📄 validtype.go(7.77 KB)
📄 version.go(2.13 KB)

Editing: 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 types2

import (
	"bytes"
	"cmd/compile/internal/syntax"
	"fmt"
	"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 syntax.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 syntax.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 {
	return resolve(name, 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). 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 syntax.Pos) (*Scope, Object) {
	for ; s != nil; s = s.parent {
		if obj := s.Lookup(name); obj != nil && (!pos.IsKnown() || obj.scopePos().Cmp(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() syntax.Pos { return s.pos }
func (s *Scope) End() syntax.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 syntax.Pos) bool {
	return s.pos.Cmp(pos) <= 0 && pos.Cmp(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 syntax.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 bytes.Buffer
	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() syntax.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(pkg *Package, name string) bool { panic("unreachable") }
func (*lazyObject) scopePos() syntax.Pos                  { panic("unreachable") }
func (*lazyObject) setScopePos(pos syntax.Pos)            { panic("unreachable") }

X7ROOT File Manager

Editing: scope.go

Upload File

Create Folder