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
