...
Run Format

Source file src/go/types/scope.go

Documentation: go/types

  // 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 (
  	"bytes"
  	"fmt"
  	"go/token"
  	"io"
  	"sort"
  	"strings"
  )
  
  // TODO(gri) Provide scopes with a name or other mechanism so that
  //           objects can use that information for better printing.
  
  // 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
  	elems    map[string]Object // lazily allocated
  	pos, end token.Pos         // scope extent; may be invalid
  	comment  string            // for debugging 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, nil, pos, end, comment}
  	// don't add children to Universe scope!
  	if parent != nil && parent != Universe {
  		parent.children = append(parent.children, s)
  	}
  	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 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, below). 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.elems[name]; obj != nil && (!pos.IsValid() || obj.scopePos() <= pos) {
  			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.elems[name]; alt != nil {
  		return alt
  	}
  	if s.elems == nil {
  		s.elems = make(map[string]Object)
  	}
  	s.elems[name] = obj
  	if obj.Parent() == nil {
  		obj.setParent(s)
  	}
  	return 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 returns true if 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 s.pos <= pos && pos < s.end
  }
  
  // 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 {", indn, s.comment, s)
  	if len(s.elems) == 0 {
  		fmt.Fprintf(w, "}\n")
  		return
  	}
  
  	fmt.Fprintln(w)
  	indn1 := indn + ind
  	for _, name := range s.Names() {
  		fmt.Fprintf(w, "%s%s\n", indn1, s.elems[name])
  	}
  
  	if recurse {
  		for _, s := range s.children {
  			fmt.Fprintln(w)
  			s.WriteTo(w, n+1, recurse)
  		}
  	}
  
  	fmt.Fprintf(w, "%s}", 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()
  }
  

View as plain text