scope.go

Documentation: go/ast

		 1  // Copyright 2009 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  // This file implements scopes and the objects they contain.
		 6  
		 7  package ast
		 8  
		 9  import (
		10  	"bytes"
		11  	"fmt"
		12  	"go/token"
		13  )
		14  
		15  // A Scope maintains the set of named language entities declared
		16  // in the scope and a link to the immediately surrounding (outer)
		17  // scope.
		18  //
		19  type Scope struct {
		20  	Outer	 *Scope
		21  	Objects map[string]*Object
		22  }
		23  
		24  // NewScope creates a new scope nested in the outer scope.
		25  func NewScope(outer *Scope) *Scope {
		26  	const n = 4 // initial scope capacity
		27  	return &Scope{outer, make(map[string]*Object, n)}
		28  }
		29  
		30  // Lookup returns the object with the given name if it is
		31  // found in scope s, otherwise it returns nil. Outer scopes
		32  // are ignored.
		33  //
		34  func (s *Scope) Lookup(name string) *Object {
		35  	return s.Objects[name]
		36  }
		37  
		38  // Insert attempts to insert a named object obj into the scope s.
		39  // If the scope already contains an object alt with the same name,
		40  // Insert leaves the scope unchanged and returns alt. Otherwise
		41  // it inserts obj and returns nil.
		42  //
		43  func (s *Scope) Insert(obj *Object) (alt *Object) {
		44  	if alt = s.Objects[obj.Name]; alt == nil {
		45  		s.Objects[obj.Name] = obj
		46  	}
		47  	return
		48  }
		49  
		50  // Debugging support
		51  func (s *Scope) String() string {
		52  	var buf bytes.Buffer
		53  	fmt.Fprintf(&buf, "scope %p {", s)
		54  	if s != nil && len(s.Objects) > 0 {
		55  		fmt.Fprintln(&buf)
		56  		for _, obj := range s.Objects {
		57  			fmt.Fprintf(&buf, "\t%s %s\n", obj.Kind, obj.Name)
		58  		}
		59  	}
		60  	fmt.Fprintf(&buf, "}\n")
		61  	return buf.String()
		62  }
		63  
		64  // ----------------------------------------------------------------------------
		65  // Objects
		66  
		67  // An Object describes a named language entity such as a package,
		68  // constant, type, variable, function (incl. methods), or label.
		69  //
		70  // The Data fields contains object-specific data:
		71  //
		72  //	Kind		Data type				 Data value
		73  //	Pkg		 *Scope						package scope
		74  //	Con		 int							 iota for the respective declaration
		75  //
		76  type Object struct {
		77  	Kind ObjKind
		78  	Name string			// declared name
		79  	Decl interface{} // corresponding Field, XxxSpec, FuncDecl, LabeledStmt, AssignStmt, Scope; or nil
		80  	Data interface{} // object-specific data; or nil
		81  	Type interface{} // placeholder for type information; may be nil
		82  }
		83  
		84  // NewObj creates a new object of a given kind and name.
		85  func NewObj(kind ObjKind, name string) *Object {
		86  	return &Object{Kind: kind, Name: name}
		87  }
		88  
		89  // Pos computes the source position of the declaration of an object name.
		90  // The result may be an invalid position if it cannot be computed
		91  // (obj.Decl may be nil or not correct).
		92  func (obj *Object) Pos() token.Pos {
		93  	name := obj.Name
		94  	switch d := obj.Decl.(type) {
		95  	case *Field:
		96  		for _, n := range d.Names {
		97  			if n.Name == name {
		98  				return n.Pos()
		99  			}
	 100  		}
	 101  	case *ImportSpec:
	 102  		if d.Name != nil && d.Name.Name == name {
	 103  			return d.Name.Pos()
	 104  		}
	 105  		return d.Path.Pos()
	 106  	case *ValueSpec:
	 107  		for _, n := range d.Names {
	 108  			if n.Name == name {
	 109  				return n.Pos()
	 110  			}
	 111  		}
	 112  	case *TypeSpec:
	 113  		if d.Name.Name == name {
	 114  			return d.Name.Pos()
	 115  		}
	 116  	case *FuncDecl:
	 117  		if d.Name.Name == name {
	 118  			return d.Name.Pos()
	 119  		}
	 120  	case *LabeledStmt:
	 121  		if d.Label.Name == name {
	 122  			return d.Label.Pos()
	 123  		}
	 124  	case *AssignStmt:
	 125  		for _, x := range d.Lhs {
	 126  			if ident, isIdent := x.(*Ident); isIdent && ident.Name == name {
	 127  				return ident.Pos()
	 128  			}
	 129  		}
	 130  	case *Scope:
	 131  		// predeclared object - nothing to do for now
	 132  	}
	 133  	return token.NoPos
	 134  }
	 135  
	 136  // ObjKind describes what an object represents.
	 137  type ObjKind int
	 138  
	 139  // The list of possible Object kinds.
	 140  const (
	 141  	Bad ObjKind = iota // for error handling
	 142  	Pkg								// package
	 143  	Con								// constant
	 144  	Typ								// type
	 145  	Var								// variable
	 146  	Fun								// function or method
	 147  	Lbl								// label
	 148  )
	 149  
	 150  var objKindStrings = [...]string{
	 151  	Bad: "bad",
	 152  	Pkg: "package",
	 153  	Con: "const",
	 154  	Typ: "type",
	 155  	Var: "var",
	 156  	Fun: "func",
	 157  	Lbl: "label",
	 158  }
	 159  
	 160  func (kind ObjKind) String() string { return objKindStrings[kind] }
	 161
View as plain text