1// Copyright 2018 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 5package source 6 7import ( 8 "context" 9 "fmt" 10 "go/ast" 11 "go/token" 12 "go/types" 13 "sort" 14 "strconv" 15 16 "golang.org/x/tools/internal/event" 17 "golang.org/x/tools/internal/lsp/protocol" 18 errors "golang.org/x/xerrors" 19) 20 21// IdentifierInfo holds information about an identifier in Go source. 22type IdentifierInfo struct { 23 Name string 24 Snapshot Snapshot 25 MappedRange 26 27 Type struct { 28 MappedRange 29 Object types.Object 30 } 31 32 Declaration Declaration 33 34 ident *ast.Ident 35 36 // enclosing is an expression used to determine the link anchor for an 37 // identifier. If it's a named type, it should be exported. 38 enclosing types.Type 39 40 pkg Package 41 qf types.Qualifier 42} 43 44type Declaration struct { 45 MappedRange []MappedRange 46 node ast.Node 47 obj types.Object 48 49 // typeSwitchImplicit indicates that the declaration is in an implicit 50 // type switch. Its type is the type of the variable on the right-hand 51 // side of the type switch. 52 typeSwitchImplicit types.Type 53} 54 55// Identifier returns identifier information for a position 56// in a file, accounting for a potentially incomplete selector. 57func Identifier(ctx context.Context, snapshot Snapshot, fh FileHandle, pos protocol.Position) (*IdentifierInfo, error) { 58 ctx, done := event.Start(ctx, "source.Identifier") 59 defer done() 60 61 pkgs, err := snapshot.PackagesForFile(ctx, fh.URI(), TypecheckAll) 62 if err != nil { 63 return nil, err 64 } 65 if len(pkgs) == 0 { 66 return nil, fmt.Errorf("no packages for file %v", fh.URI()) 67 } 68 sort.Slice(pkgs, func(i, j int) bool { 69 return len(pkgs[i].CompiledGoFiles()) < len(pkgs[j].CompiledGoFiles()) 70 }) 71 var findErr error 72 for _, pkg := range pkgs { 73 pgf, err := pkg.File(fh.URI()) 74 if err != nil { 75 return nil, err 76 } 77 spn, err := pgf.Mapper.PointSpan(pos) 78 if err != nil { 79 return nil, err 80 } 81 rng, err := spn.Range(pgf.Mapper.Converter) 82 if err != nil { 83 return nil, err 84 } 85 var ident *IdentifierInfo 86 ident, findErr = findIdentifier(ctx, snapshot, pkg, pgf.File, rng.Start) 87 if findErr == nil { 88 return ident, nil 89 } 90 } 91 return nil, findErr 92} 93 94// ErrNoIdentFound is error returned when no identifer is found at a particular position 95var ErrNoIdentFound = errors.New("no identifier found") 96 97func findIdentifier(ctx context.Context, snapshot Snapshot, pkg Package, file *ast.File, pos token.Pos) (*IdentifierInfo, error) { 98 // Handle import specs separately, as there is no formal position for a 99 // package declaration. 100 if result, err := importSpec(snapshot, pkg, file, pos); result != nil || err != nil { 101 if snapshot.View().Options().ImportShortcut.ShowDefinition() { 102 return result, err 103 } 104 return nil, nil 105 } 106 path := pathEnclosingObjNode(file, pos) 107 if path == nil { 108 return nil, ErrNoIdentFound 109 } 110 111 qf := Qualifier(file, pkg.GetTypes(), pkg.GetTypesInfo()) 112 113 ident, _ := path[0].(*ast.Ident) 114 if ident == nil { 115 return nil, ErrNoIdentFound 116 } 117 // Special case for package declarations, since they have no 118 // corresponding types.Object. 119 if ident == file.Name { 120 rng, err := posToMappedRange(snapshot, pkg, file.Name.Pos(), file.Name.End()) 121 if err != nil { 122 return nil, err 123 } 124 var declAST *ast.File 125 for _, pgf := range pkg.CompiledGoFiles() { 126 if pgf.File.Doc != nil { 127 declAST = pgf.File 128 } 129 } 130 // If there's no package documentation, just use current file. 131 if declAST == nil { 132 declAST = file 133 } 134 declRng, err := posToMappedRange(snapshot, pkg, declAST.Name.Pos(), declAST.Name.End()) 135 if err != nil { 136 return nil, err 137 } 138 return &IdentifierInfo{ 139 Name: file.Name.Name, 140 ident: file.Name, 141 MappedRange: rng, 142 pkg: pkg, 143 qf: qf, 144 Snapshot: snapshot, 145 Declaration: Declaration{ 146 node: declAST.Name, 147 MappedRange: []MappedRange{declRng}, 148 }, 149 }, nil 150 } 151 152 result := &IdentifierInfo{ 153 Snapshot: snapshot, 154 qf: qf, 155 pkg: pkg, 156 ident: ident, 157 enclosing: searchForEnclosing(pkg.GetTypesInfo(), path), 158 } 159 160 result.Name = result.ident.Name 161 var err error 162 if result.MappedRange, err = posToMappedRange(snapshot, pkg, result.ident.Pos(), result.ident.End()); err != nil { 163 return nil, err 164 } 165 166 result.Declaration.obj = pkg.GetTypesInfo().ObjectOf(result.ident) 167 if result.Declaration.obj == nil { 168 // If there was no types.Object for the declaration, there might be an 169 // implicit local variable declaration in a type switch. 170 if objs, typ := typeSwitchImplicits(pkg, path); len(objs) > 0 { 171 // There is no types.Object for the declaration of an implicit local variable, 172 // but all of the types.Objects associated with the usages of this variable can be 173 // used to connect it back to the declaration. 174 // Preserve the first of these objects and treat it as if it were the declaring object. 175 result.Declaration.obj = objs[0] 176 result.Declaration.typeSwitchImplicit = typ 177 } else { 178 // Probably a type error. 179 return nil, errors.Errorf("%w for ident %v", errNoObjectFound, result.Name) 180 } 181 } 182 183 // Handle builtins separately. 184 if result.Declaration.obj.Parent() == types.Universe { 185 builtin, err := snapshot.BuiltinPackage(ctx) 186 if err != nil { 187 return nil, err 188 } 189 builtinObj := builtin.Package.Scope.Lookup(result.Name) 190 if builtinObj == nil { 191 return nil, fmt.Errorf("no builtin object for %s", result.Name) 192 } 193 decl, ok := builtinObj.Decl.(ast.Node) 194 if !ok { 195 return nil, errors.Errorf("no declaration for %s", result.Name) 196 } 197 result.Declaration.node = decl 198 199 // The builtin package isn't in the dependency graph, so the usual 200 // utilities won't work here. 201 rng := NewMappedRange(snapshot.FileSet(), builtin.ParsedFile.Mapper, decl.Pos(), decl.Pos()+token.Pos(len(result.Name))) 202 result.Declaration.MappedRange = append(result.Declaration.MappedRange, rng) 203 return result, nil 204 } 205 206 // (error).Error is a special case of builtin. Lots of checks to confirm 207 // that this is the builtin Error. 208 if obj := result.Declaration.obj; obj.Parent() == nil && obj.Pkg() == nil && obj.Name() == "Error" { 209 if _, ok := obj.Type().(*types.Signature); ok { 210 builtin, err := snapshot.BuiltinPackage(ctx) 211 if err != nil { 212 return nil, err 213 } 214 // Look up "error" and then navigate to its only method. 215 // The Error method does not appear in the builtin package's scope.log.Pri 216 const errorName = "error" 217 builtinObj := builtin.Package.Scope.Lookup(errorName) 218 if builtinObj == nil { 219 return nil, fmt.Errorf("no builtin object for %s", errorName) 220 } 221 decl, ok := builtinObj.Decl.(ast.Node) 222 if !ok { 223 return nil, errors.Errorf("no declaration for %s", errorName) 224 } 225 spec, ok := decl.(*ast.TypeSpec) 226 if !ok { 227 return nil, fmt.Errorf("no type spec for %s", errorName) 228 } 229 iface, ok := spec.Type.(*ast.InterfaceType) 230 if !ok { 231 return nil, fmt.Errorf("%s is not an interface", errorName) 232 } 233 if iface.Methods.NumFields() != 1 { 234 return nil, fmt.Errorf("expected 1 method for %s, got %v", errorName, iface.Methods.NumFields()) 235 } 236 method := iface.Methods.List[0] 237 if len(method.Names) != 1 { 238 return nil, fmt.Errorf("expected 1 name for %v, got %v", method, len(method.Names)) 239 } 240 name := method.Names[0].Name 241 result.Declaration.node = method 242 rng := NewMappedRange(snapshot.FileSet(), builtin.ParsedFile.Mapper, method.Pos(), method.Pos()+token.Pos(len(name))) 243 result.Declaration.MappedRange = append(result.Declaration.MappedRange, rng) 244 return result, nil 245 } 246 } 247 248 // If the original position was an embedded field, we want to jump 249 // to the field's type definition, not the field's definition. 250 if v, ok := result.Declaration.obj.(*types.Var); ok && v.Embedded() { 251 // types.Info.Uses contains the embedded field's *types.TypeName. 252 if typeName := pkg.GetTypesInfo().Uses[ident]; typeName != nil { 253 result.Declaration.obj = typeName 254 } 255 } 256 257 rng, err := objToMappedRange(snapshot, pkg, result.Declaration.obj) 258 if err != nil { 259 return nil, err 260 } 261 result.Declaration.MappedRange = append(result.Declaration.MappedRange, rng) 262 263 if result.Declaration.node, err = objToDecl(ctx, snapshot, pkg, result.Declaration.obj); err != nil { 264 return nil, err 265 } 266 typ := pkg.GetTypesInfo().TypeOf(result.ident) 267 if typ == nil { 268 return result, nil 269 } 270 271 result.Type.Object = typeToObject(typ) 272 if result.Type.Object != nil { 273 // Identifiers with the type "error" are a special case with no position. 274 if hasErrorType(result.Type.Object) { 275 return result, nil 276 } 277 if result.Type.MappedRange, err = objToMappedRange(snapshot, pkg, result.Type.Object); err != nil { 278 return nil, err 279 } 280 } 281 return result, nil 282} 283 284func searchForEnclosing(info *types.Info, path []ast.Node) types.Type { 285 for _, n := range path { 286 switch n := n.(type) { 287 case *ast.SelectorExpr: 288 if sel, ok := info.Selections[n]; ok { 289 recv := Deref(sel.Recv()) 290 291 // Keep track of the last exported type seen. 292 var exported types.Type 293 if named, ok := recv.(*types.Named); ok && named.Obj().Exported() { 294 exported = named 295 } 296 // We don't want the last element, as that's the field or 297 // method itself. 298 for _, index := range sel.Index()[:len(sel.Index())-1] { 299 if r, ok := recv.Underlying().(*types.Struct); ok { 300 recv = Deref(r.Field(index).Type()) 301 if named, ok := recv.(*types.Named); ok && named.Obj().Exported() { 302 exported = named 303 } 304 } 305 } 306 return exported 307 } 308 case *ast.CompositeLit: 309 if t, ok := info.Types[n]; ok { 310 return t.Type 311 } 312 case *ast.TypeSpec: 313 if _, ok := n.Type.(*ast.StructType); ok { 314 if t, ok := info.Defs[n.Name]; ok { 315 return t.Type() 316 } 317 } 318 } 319 } 320 return nil 321} 322 323func typeToObject(typ types.Type) types.Object { 324 switch typ := typ.(type) { 325 case *types.Named: 326 return typ.Obj() 327 case *types.Pointer: 328 return typeToObject(typ.Elem()) 329 default: 330 return nil 331 } 332} 333 334func hasErrorType(obj types.Object) bool { 335 return types.IsInterface(obj.Type()) && obj.Pkg() == nil && obj.Name() == "error" 336} 337 338func objToDecl(ctx context.Context, snapshot Snapshot, srcPkg Package, obj types.Object) (ast.Decl, error) { 339 pgf, _, err := FindPosInPackage(snapshot, srcPkg, obj.Pos()) 340 if err != nil { 341 return nil, err 342 } 343 posToDecl, err := snapshot.PosToDecl(ctx, pgf) 344 if err != nil { 345 return nil, err 346 } 347 return posToDecl[obj.Pos()], nil 348} 349 350// importSpec handles positions inside of an *ast.ImportSpec. 351func importSpec(snapshot Snapshot, pkg Package, file *ast.File, pos token.Pos) (*IdentifierInfo, error) { 352 var imp *ast.ImportSpec 353 for _, spec := range file.Imports { 354 if spec.Path.Pos() <= pos && pos < spec.Path.End() { 355 imp = spec 356 } 357 } 358 if imp == nil { 359 return nil, nil 360 } 361 importPath, err := strconv.Unquote(imp.Path.Value) 362 if err != nil { 363 return nil, errors.Errorf("import path not quoted: %s (%v)", imp.Path.Value, err) 364 } 365 result := &IdentifierInfo{ 366 Snapshot: snapshot, 367 Name: importPath, 368 pkg: pkg, 369 } 370 if result.MappedRange, err = posToMappedRange(snapshot, pkg, imp.Path.Pos(), imp.Path.End()); err != nil { 371 return nil, err 372 } 373 // Consider the "declaration" of an import spec to be the imported package. 374 importedPkg, err := pkg.GetImport(importPath) 375 if err != nil { 376 return nil, err 377 } 378 // Return all of the files in the package as the definition of the import spec. 379 for _, dst := range importedPkg.GetSyntax() { 380 rng, err := posToMappedRange(snapshot, pkg, dst.Pos(), dst.End()) 381 if err != nil { 382 return nil, err 383 } 384 result.Declaration.MappedRange = append(result.Declaration.MappedRange, rng) 385 } 386 387 result.Declaration.node = imp 388 return result, nil 389} 390 391// typeSwitchImplicits returns all the implicit type switch objects that 392// correspond to the leaf *ast.Ident. It also returns the original type 393// associated with the identifier (outside of a case clause). 394func typeSwitchImplicits(pkg Package, path []ast.Node) ([]types.Object, types.Type) { 395 ident, _ := path[0].(*ast.Ident) 396 if ident == nil { 397 return nil, nil 398 } 399 400 var ( 401 ts *ast.TypeSwitchStmt 402 assign *ast.AssignStmt 403 cc *ast.CaseClause 404 obj = pkg.GetTypesInfo().ObjectOf(ident) 405 ) 406 407 // Walk our ancestors to determine if our leaf ident refers to a 408 // type switch variable, e.g. the "a" from "switch a := b.(type)". 409Outer: 410 for i := 1; i < len(path); i++ { 411 switch n := path[i].(type) { 412 case *ast.AssignStmt: 413 // Check if ident is the "a" in "a := foo.(type)". The "a" in 414 // this case has no types.Object, so check for ident equality. 415 if len(n.Lhs) == 1 && n.Lhs[0] == ident { 416 assign = n 417 } 418 case *ast.CaseClause: 419 // Check if ident is a use of "a" within a case clause. Each 420 // case clause implicitly maps "a" to a different types.Object, 421 // so check if ident's object is the case clause's implicit 422 // object. 423 if obj != nil && pkg.GetTypesInfo().Implicits[n] == obj { 424 cc = n 425 } 426 case *ast.TypeSwitchStmt: 427 // Look for the type switch that owns our previously found 428 // *ast.AssignStmt or *ast.CaseClause. 429 if n.Assign == assign { 430 ts = n 431 break Outer 432 } 433 434 for _, stmt := range n.Body.List { 435 if stmt == cc { 436 ts = n 437 break Outer 438 } 439 } 440 } 441 } 442 if ts == nil { 443 return nil, nil 444 } 445 // Our leaf ident refers to a type switch variable. Fan out to the 446 // type switch's implicit case clause objects. 447 var objs []types.Object 448 for _, cc := range ts.Body.List { 449 if ccObj := pkg.GetTypesInfo().Implicits[cc]; ccObj != nil { 450 objs = append(objs, ccObj) 451 } 452 } 453 // The right-hand side of a type switch should only have one 454 // element, and we need to track its type in order to generate 455 // hover information for implicit type switch variables. 456 var typ types.Type 457 if assign, ok := ts.Assign.(*ast.AssignStmt); ok && len(assign.Rhs) == 1 { 458 if rhs := assign.Rhs[0].(*ast.TypeAssertExpr); ok { 459 typ = pkg.GetTypesInfo().TypeOf(rhs.X) 460 } 461 } 462 return objs, typ 463} 464