internal/lsp/source: always look up mapper when building ranges

heschi · heschi · commit 7042ee646e79 · 2020-01-16T01:10:02.000Z
Any file could have //line directives in it, which means that we should never trust a mapper that was looked up for a whole file. Remove the range conversion helpers that accepted a mapper and look it up on the spot. Change-Id: Ic518891fcc1a682b31cbc6d1d4e1e1af1ef21962 Reviewed-on: https://go-review.googlesource.com/c/tools/+/214949 Run-TryBot: Heschi Kreinick <heschi@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Rebecca Stambler <rstambler@golang.org>
diff --git a/internal/lsp/source/highlight.go b/internal/lsp/source/highlight.go
@@ -55,17 +55,17 @@ func Highlight(ctx context.Context, snapshot Snapshot, fh FileHandle, pos protoc
 
 	switch path[0].(type) {
 	case *ast.ReturnStmt, *ast.FuncDecl, *ast.FuncType, *ast.BasicLit:
-		return highlightFuncControlFlow(ctx, snapshot, m, path)
+		return highlightFuncControlFlow(ctx, snapshot, pkg, path)
 	case *ast.Ident:
-		return highlightIdentifiers(ctx, snapshot, m, path, pkg)
+		return highlightIdentifiers(ctx, snapshot, pkg, path)
 	case *ast.BranchStmt, *ast.ForStmt, *ast.RangeStmt:
-		return highlightLoopControlFlow(ctx, snapshot, m, path)
+		return highlightLoopControlFlow(ctx, snapshot, pkg, path)
 	}
 	// If the cursor is in an unidentified area, return empty results.
 	return nil, nil
 }
 
-func highlightFuncControlFlow(ctx context.Context, snapshot Snapshot, m *protocol.ColumnMapper, path []ast.Node) ([]protocol.Range, error) {
+func highlightFuncControlFlow(ctx context.Context, snapshot Snapshot, pkg Package, path []ast.Node) ([]protocol.Range, error) {
 	var enclosingFunc ast.Node
 	var returnStmt *ast.ReturnStmt
 	var resultsList *ast.FieldList
@@ -137,7 +137,7 @@ Outer:
 	result := make(map[protocol.Range]bool)
 	// Highlight the correct argument in the function declaration return types.
 	if resultsList != nil && -1 < index && index < len(resultsList.List) {
-		rng, err := nodeToProtocolRange(snapshot.View(), m, resultsList.List[index])
+		rng, err := nodeToProtocolRange(snapshot.View(), pkg, resultsList.List[index])
 		if err != nil {
 			log.Error(ctx, "Error getting range for node", err)
 		} else {
@@ -146,7 +146,7 @@ Outer:
 	}
 	// Add the "func" part of the func declaration.
 	if highlightAllReturnsAndFunc {
-		funcStmt, err := posToRange(snapshot.View(), m, enclosingFunc.Pos(), enclosingFunc.Pos()+token.Pos(len("func")))
+		funcStmt, err := posToMappedRange(snapshot.View(), pkg, enclosingFunc.Pos(), enclosingFunc.Pos()+token.Pos(len("func")))
 		if err != nil {
 			return nil, err
 		}
@@ -174,7 +174,7 @@ Outer:
 				toAdd = n.Results[index]
 			}
 			if toAdd != nil {
-				rng, err := nodeToProtocolRange(snapshot.View(), m, toAdd)
+				rng, err := nodeToProtocolRange(snapshot.View(), pkg, toAdd)
 				if err != nil {
 					log.Error(ctx, "Error getting range for node", err)
 				} else {
@@ -188,7 +188,7 @@ Outer:
 	return rangeMapToSlice(result), nil
 }
 
-func highlightLoopControlFlow(ctx context.Context, snapshot Snapshot, m *protocol.ColumnMapper, path []ast.Node) ([]protocol.Range, error) {
+func highlightLoopControlFlow(ctx context.Context, snapshot Snapshot, pkg Package, path []ast.Node) ([]protocol.Range, error) {
 	var loop ast.Node
 Outer:
 	// Reverse walk the path till we get to the for loop.
@@ -205,7 +205,7 @@ Outer:
 	}
 	result := make(map[protocol.Range]bool)
 	// Add the for statement.
-	forStmt, err := posToRange(snapshot.View(), m, loop.Pos(), loop.Pos()+token.Pos(len("for")))
+	forStmt, err := posToMappedRange(snapshot.View(), pkg, loop.Pos(), loop.Pos()+token.Pos(len("for")))
 	if err != nil {
 		return nil, err
 	}
@@ -223,7 +223,7 @@ Outer:
 		}
 		// Add all branch statements in same scope as the identified one.
 		if n, ok := n.(*ast.BranchStmt); ok {
-			rng, err := nodeToProtocolRange(snapshot.View(), m, n)
+			rng, err := nodeToProtocolRange(snapshot.View(), pkg, n)
 			if err != nil {
 				log.Error(ctx, "Error getting range for node", err)
 				return false
@@ -235,14 +235,14 @@ Outer:
 	return rangeMapToSlice(result), nil
 }
 
-func highlightIdentifiers(ctx context.Context, snapshot Snapshot, m *protocol.ColumnMapper, path []ast.Node, pkg Package) ([]protocol.Range, error) {
+func highlightIdentifiers(ctx context.Context, snapshot Snapshot, pkg Package, path []ast.Node) ([]protocol.Range, error) {
 	result := make(map[protocol.Range]bool)
 	id, ok := path[0].(*ast.Ident)
 	if !ok {
 		return nil, errors.Errorf("highlightIdentifiers called with an ast.Node of type %T", id)
 	}
 	// Check if ident is inside return or func decl.
-	if toAdd, err := highlightFuncControlFlow(ctx, snapshot, m, path); toAdd != nil && err == nil {
+	if toAdd, err := highlightFuncControlFlow(ctx, snapshot, pkg, path); toAdd != nil && err == nil {
 		for _, r := range toAdd {
 			result[r] = true
 		}
@@ -262,7 +262,7 @@ func highlightIdentifiers(ctx context.Context, snapshot Snapshot, m *protocol.Co
 		if nObj := pkg.GetTypesInfo().ObjectOf(n); nObj != idObj {
 			return false
 		}
-		if rng, err := nodeToProtocolRange(snapshot.View(), m, n); err == nil {
+		if rng, err := nodeToProtocolRange(snapshot.View(), pkg, n); err == nil {
 			result[rng] = true
 		} else {
 			log.Error(ctx, "Error getting range for node", err)
diff --git a/internal/lsp/source/symbols.go b/internal/lsp/source/symbols.go
@@ -22,7 +22,7 @@ func DocumentSymbols(ctx context.Context, snapshot Snapshot, fh FileHandle) ([]p
 	if err != nil {
 		return nil, fmt.Errorf("getting file for DocumentSymbols: %v", err)
 	}
-	file, m, _, err := pgh.Cached()
+	file, _, _, err := pgh.Cached()
 	if err != nil {
 		return nil, err
 	}
@@ -37,7 +37,7 @@ func DocumentSymbols(ctx context.Context, snapshot Snapshot, fh FileHandle) ([]p
 		switch decl := decl.(type) {
 		case *ast.FuncDecl:
 			if obj := info.ObjectOf(decl.Name); obj != nil {
-				fs, err := funcSymbol(ctx, snapshot.View(), m, decl, obj, q)
+				fs, err := funcSymbol(ctx, snapshot.View(), pkg, decl, obj, q)
 				if err != nil {
 					return nil, err
 				}
@@ -55,7 +55,7 @@ func DocumentSymbols(ctx context.Context, snapshot Snapshot, fh FileHandle) ([]p
 				switch spec := spec.(type) {
 				case *ast.TypeSpec:
 					if obj := info.ObjectOf(spec.Name); obj != nil {
-						ts, err := typeSymbol(ctx, snapshot.View(), m, info, spec, obj, q)
+						ts, err := typeSymbol(ctx, snapshot.View(), pkg, info, spec, obj, q)
 						if err != nil {
 							return nil, err
 						}
@@ -65,7 +65,7 @@ func DocumentSymbols(ctx context.Context, snapshot Snapshot, fh FileHandle) ([]p
 				case *ast.ValueSpec:
 					for _, name := range spec.Names {
 						if obj := info.ObjectOf(name); obj != nil {
-							vs, err := varSymbol(ctx, snapshot.View(), m, decl, name, obj, q)
+							vs, err := varSymbol(ctx, snapshot.View(), pkg, decl, name, obj, q)
 							if err != nil {
 								return nil, err
 							}
@@ -93,17 +93,17 @@ func DocumentSymbols(ctx context.Context, snapshot Snapshot, fh FileHandle) ([]p
 	return symbols, nil
 }
 
-func funcSymbol(ctx context.Context, view View, m *protocol.ColumnMapper, decl *ast.FuncDecl, obj types.Object, q types.Qualifier) (protocol.DocumentSymbol, error) {
+func funcSymbol(ctx context.Context, view View, pkg Package, decl *ast.FuncDecl, obj types.Object, q types.Qualifier) (protocol.DocumentSymbol, error) {
 	s := protocol.DocumentSymbol{
 		Name: obj.Name(),
 		Kind: protocol.Function,
 	}
 	var err error
-	s.Range, err = nodeToProtocolRange(view, m, decl)
+	s.Range, err = nodeToProtocolRange(view, pkg, decl)
 	if err != nil {
 		return protocol.DocumentSymbol{}, err
 	}
-	s.SelectionRange, err = nodeToProtocolRange(view, m, decl.Name)
+	s.SelectionRange, err = nodeToProtocolRange(view, pkg, decl.Name)
 	if err != nil {
 		return protocol.DocumentSymbol{}, err
 	}
@@ -157,19 +157,19 @@ func setKind(s *protocol.DocumentSymbol, typ types.Type, q types.Qualifier) {
 	}
 }
 
-func typeSymbol(ctx context.Context, view View, m *protocol.ColumnMapper, info *types.Info, spec *ast.TypeSpec, obj types.Object, q types.Qualifier) (protocol.DocumentSymbol, error) {
+func typeSymbol(ctx context.Context, view View, pkg Package, info *types.Info, spec *ast.TypeSpec, obj types.Object, q types.Qualifier) (protocol.DocumentSymbol, error) {
 	s := protocol.DocumentSymbol{
 		Name: obj.Name(),
 	}
 	s.Detail, _ = formatType(obj.Type(), q)
 	setKind(&s, obj.Type(), q)
 
 	var err error
-	s.Range, err = nodeToProtocolRange(view, m, spec)
+	s.Range, err = nodeToProtocolRange(view, pkg, spec)
 	if err != nil {
 		return protocol.DocumentSymbol{}, err
 	}
-	s.SelectionRange, err = nodeToProtocolRange(view, m, spec.Name)
+	s.SelectionRange, err = nodeToProtocolRange(view, pkg, spec.Name)
 	if err != nil {
 		return protocol.DocumentSymbol{}, err
 	}
@@ -185,10 +185,10 @@ func typeSymbol(ctx context.Context, view View, m *protocol.ColumnMapper, info *
 			child.Detail, _ = formatType(f.Type(), q)
 
 			spanNode, selectionNode := nodesForStructField(i, st)
-			if span, err := nodeToProtocolRange(view, m, spanNode); err == nil {
+			if span, err := nodeToProtocolRange(view, pkg, spanNode); err == nil {
 				child.Range = span
 			}
-			if span, err := nodeToProtocolRange(view, m, selectionNode); err == nil {
+			if span, err := nodeToProtocolRange(view, pkg, selectionNode); err == nil {
 				child.SelectionRange = span
 			}
 			s.Children = append(s.Children, child)
@@ -215,11 +215,11 @@ func typeSymbol(ctx context.Context, view View, m *protocol.ColumnMapper, info *
 					}
 				}
 			}
-			child.Range, err = nodeToProtocolRange(view, m, spanNode)
+			child.Range, err = nodeToProtocolRange(view, pkg, spanNode)
 			if err != nil {
 				return protocol.DocumentSymbol{}, err
 			}
-			child.SelectionRange, err = nodeToProtocolRange(view, m, selectionNode)
+			child.SelectionRange, err = nodeToProtocolRange(view, pkg, selectionNode)
 			if err != nil {
 				return protocol.DocumentSymbol{}, err
 			}
@@ -249,11 +249,11 @@ func typeSymbol(ctx context.Context, view View, m *protocol.ColumnMapper, info *
 					break Embeddeds
 				}
 			}
-			child.Range, err = nodeToProtocolRange(view, m, spanNode)
+			child.Range, err = nodeToProtocolRange(view, pkg, spanNode)
 			if err != nil {
 				return protocol.DocumentSymbol{}, err
 			}
-			child.SelectionRange, err = nodeToProtocolRange(view, m, selectionNode)
+			child.SelectionRange, err = nodeToProtocolRange(view, pkg, selectionNode)
 			if err != nil {
 				return protocol.DocumentSymbol{}, err
 			}
@@ -283,7 +283,7 @@ func nodesForStructField(i int, st *ast.StructType) (span, selection ast.Node) {
 	return nil, nil
 }
 
-func varSymbol(ctx context.Context, view View, m *protocol.ColumnMapper, decl ast.Node, name *ast.Ident, obj types.Object, q types.Qualifier) (protocol.DocumentSymbol, error) {
+func varSymbol(ctx context.Context, view View, pkg Package, decl ast.Node, name *ast.Ident, obj types.Object, q types.Qualifier) (protocol.DocumentSymbol, error) {
 	s := protocol.DocumentSymbol{
 		Name: obj.Name(),
 		Kind: protocol.Variable,
@@ -292,11 +292,11 @@ func varSymbol(ctx context.Context, view View, m *protocol.ColumnMapper, decl as
 		s.Kind = protocol.Constant
 	}
 	var err error
-	s.Range, err = nodeToProtocolRange(view, m, decl)
+	s.Range, err = nodeToProtocolRange(view, pkg, decl)
 	if err != nil {
 		return protocol.DocumentSymbol{}, err
 	}
-	s.SelectionRange, err = nodeToProtocolRange(view, m, name)
+	s.SelectionRange, err = nodeToProtocolRange(view, pkg, name)
 	if err != nil {
 		return protocol.DocumentSymbol{}, err
 	}
diff --git a/internal/lsp/source/util.go b/internal/lsp/source/util.go
@@ -168,8 +168,8 @@ func IsGenerated(ctx context.Context, snapshot Snapshot, uri span.URI) bool {
 	return false
 }
 
-func nodeToProtocolRange(view View, m *protocol.ColumnMapper, n ast.Node) (protocol.Range, error) {
-	mrng, err := nodeToMappedRange(view, m, n)
+func nodeToProtocolRange(view View, pkg Package, n ast.Node) (protocol.Range, error) {
+	mrng, err := posToMappedRange(view, pkg, n.Pos(), n.End())
 	if err != nil {
 		return protocol.Range{}, err
 	}
@@ -199,27 +199,19 @@ func nameToMappedRange(v View, pkg Package, pos token.Pos, name string) (mappedR
 	return posToMappedRange(v, pkg, pos, pos+token.Pos(len(name)))
 }
 
-func nodeToMappedRange(view View, m *protocol.ColumnMapper, n ast.Node) (mappedRange, error) {
-	return posToRange(view, m, n.Pos(), n.End())
-}
-
 func posToMappedRange(v View, pkg Package, pos, end token.Pos) (mappedRange, error) {
 	logicalFilename := v.Session().Cache().FileSet().File(pos).Position(pos).Filename
 	m, err := findMapperInPackage(v, pkg, span.FileURI(logicalFilename))
 	if err != nil {
 		return mappedRange{}, err
 	}
-	return posToRange(v, m, pos, end)
-}
-
-func posToRange(view View, m *protocol.ColumnMapper, pos, end token.Pos) (mappedRange, error) {
 	if !pos.IsValid() {
 		return mappedRange{}, errors.Errorf("invalid position for %v", pos)
 	}
 	if !end.IsValid() {
 		return mappedRange{}, errors.Errorf("invalid position for %v", end)
 	}
-	return newMappedRange(view.Session().Cache().FileSet(), m, pos, end), nil
+	return newMappedRange(v.Session().Cache().FileSet(), m, pos, end), nil
 }
 
 // Matches cgo generated comment as well as the proposed standard:

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ func DocumentSymbols(ctx context.Context, snapshot Snapshot, fh FileHandle) ([]p`
`22`	`22`	`if err != nil {`
`23`	`23`	`return nil, fmt.Errorf("getting file for DocumentSymbols: %v", err)`
`24`	`24`	`}`
`25`		`- file, m, _, err := pgh.Cached()`
	`25`	`+ file, _, _, err := pgh.Cached()`
`26`	`26`	`if err != nil {`
`27`	`27`	`return nil, err`
`28`	`28`	`}`
`@@ -37,7 +37,7 @@ func DocumentSymbols(ctx context.Context, snapshot Snapshot, fh FileHandle) ([]p`
`37`	`37`	`switch decl := decl.(type) {`
`38`	`38`	`case *ast.FuncDecl:`
`39`	`39`	`if obj := info.ObjectOf(decl.Name); obj != nil {`
`40`		`- fs, err := funcSymbol(ctx, snapshot.View(), m, decl, obj, q)`
	`40`	`+ fs, err := funcSymbol(ctx, snapshot.View(), pkg, decl, obj, q)`
`41`	`41`	`if err != nil {`
`42`	`42`	`return nil, err`
`43`	`43`	`}`
`@@ -55,7 +55,7 @@ func DocumentSymbols(ctx context.Context, snapshot Snapshot, fh FileHandle) ([]p`
`55`	`55`	`switch spec := spec.(type) {`
`56`	`56`	`case *ast.TypeSpec:`
`57`	`57`	`if obj := info.ObjectOf(spec.Name); obj != nil {`
`58`		`- ts, err := typeSymbol(ctx, snapshot.View(), m, info, spec, obj, q)`
	`58`	`+ ts, err := typeSymbol(ctx, snapshot.View(), pkg, info, spec, obj, q)`
`59`	`59`	`if err != nil {`
`60`	`60`	`return nil, err`
`61`	`61`	`}`
`@@ -65,7 +65,7 @@ func DocumentSymbols(ctx context.Context, snapshot Snapshot, fh FileHandle) ([]p`
`65`	`65`	`case *ast.ValueSpec:`
`66`	`66`	`for _, name := range spec.Names {`
`67`	`67`	`if obj := info.ObjectOf(name); obj != nil {`
`68`		`- vs, err := varSymbol(ctx, snapshot.View(), m, decl, name, obj, q)`
	`68`	`+ vs, err := varSymbol(ctx, snapshot.View(), pkg, decl, name, obj, q)`
`69`	`69`	`if err != nil {`
`70`	`70`	`return nil, err`
`71`	`71`	`}`
`@@ -93,17 +93,17 @@ func DocumentSymbols(ctx context.Context, snapshot Snapshot, fh FileHandle) ([]p`
`93`	`93`	`return symbols, nil`
`94`	`94`	`}`
`95`	`95`
`96`		`-func funcSymbol(ctx context.Context, view View, m protocol.ColumnMapper, decl ast.FuncDecl, obj types.Object, q types.Qualifier) (protocol.DocumentSymbol, error) {`
	`96`	`+func funcSymbol(ctx context.Context, view View, pkg Package, decl *ast.FuncDecl, obj types.Object, q types.Qualifier) (protocol.DocumentSymbol, error) {`
`97`	`97`	`s := protocol.DocumentSymbol{`
`98`	`98`	`Name: obj.Name(),`
`99`	`99`	`Kind: protocol.Function,`
`100`	`100`	`}`
`101`	`101`	`var err error`
`102`		`- s.Range, err = nodeToProtocolRange(view, m, decl)`
	`102`	`+ s.Range, err = nodeToProtocolRange(view, pkg, decl)`
`103`	`103`	`if err != nil {`
`104`	`104`	`return protocol.DocumentSymbol{}, err`
`105`	`105`	`}`
`106`		`- s.SelectionRange, err = nodeToProtocolRange(view, m, decl.Name)`
	`106`	`+ s.SelectionRange, err = nodeToProtocolRange(view, pkg, decl.Name)`
`107`	`107`	`if err != nil {`
`108`	`108`	`return protocol.DocumentSymbol{}, err`
`109`	`109`	`}`
`@@ -157,19 +157,19 @@ func setKind(s *protocol.DocumentSymbol, typ types.Type, q types.Qualifier) {`
`157`	`157`	`}`
`158`	`158`	`}`
`159`	`159`
`160`		`-func typeSymbol(ctx context.Context, view View, m protocol.ColumnMapper, info types.Info, spec *ast.TypeSpec, obj types.Object, q types.Qualifier) (protocol.DocumentSymbol, error) {`
	`160`	`+func typeSymbol(ctx context.Context, view View, pkg Package, info types.Info, spec ast.TypeSpec, obj types.Object, q types.Qualifier) (protocol.DocumentSymbol, error) {`
`161`	`161`	`s := protocol.DocumentSymbol{`
`162`	`162`	`Name: obj.Name(),`
`163`	`163`	`}`
`164`	`164`	`s.Detail, _ = formatType(obj.Type(), q)`
`165`	`165`	`setKind(&s, obj.Type(), q)`
`166`	`166`
`167`	`167`	`var err error`
`168`		`- s.Range, err = nodeToProtocolRange(view, m, spec)`
	`168`	`+ s.Range, err = nodeToProtocolRange(view, pkg, spec)`
`169`	`169`	`if err != nil {`
`170`	`170`	`return protocol.DocumentSymbol{}, err`
`171`	`171`	`}`
`172`		`- s.SelectionRange, err = nodeToProtocolRange(view, m, spec.Name)`
	`172`	`+ s.SelectionRange, err = nodeToProtocolRange(view, pkg, spec.Name)`
`173`	`173`	`if err != nil {`
`174`	`174`	`return protocol.DocumentSymbol{}, err`
`175`	`175`	`}`
`@@ -185,10 +185,10 @@ func typeSymbol(ctx context.Context, view View, m protocol.ColumnMapper, info `
`185`	`185`	`child.Detail, _ = formatType(f.Type(), q)`
`186`	`186`
`187`	`187`	`spanNode, selectionNode := nodesForStructField(i, st)`
`188`		`- if span, err := nodeToProtocolRange(view, m, spanNode); err == nil {`
	`188`	`+ if span, err := nodeToProtocolRange(view, pkg, spanNode); err == nil {`
`189`	`189`	`child.Range = span`
`190`	`190`	`}`
`191`		`- if span, err := nodeToProtocolRange(view, m, selectionNode); err == nil {`
	`191`	`+ if span, err := nodeToProtocolRange(view, pkg, selectionNode); err == nil {`
`192`	`192`	`child.SelectionRange = span`
`193`	`193`	`}`
`194`	`194`	`s.Children = append(s.Children, child)`
`@@ -215,11 +215,11 @@ func typeSymbol(ctx context.Context, view View, m protocol.ColumnMapper, info `
`215`	`215`	`}`
`216`	`216`	`}`
`217`	`217`	`}`
`218`		`- child.Range, err = nodeToProtocolRange(view, m, spanNode)`
	`218`	`+ child.Range, err = nodeToProtocolRange(view, pkg, spanNode)`
`219`	`219`	`if err != nil {`
`220`	`220`	`return protocol.DocumentSymbol{}, err`
`221`	`221`	`}`
`222`		`- child.SelectionRange, err = nodeToProtocolRange(view, m, selectionNode)`
	`222`	`+ child.SelectionRange, err = nodeToProtocolRange(view, pkg, selectionNode)`
`223`	`223`	`if err != nil {`
`224`	`224`	`return protocol.DocumentSymbol{}, err`
`225`	`225`	`}`
`@@ -249,11 +249,11 @@ func typeSymbol(ctx context.Context, view View, m protocol.ColumnMapper, info `
`249`	`249`	`break Embeddeds`
`250`	`250`	`}`
`251`	`251`	`}`
`252`		`- child.Range, err = nodeToProtocolRange(view, m, spanNode)`
	`252`	`+ child.Range, err = nodeToProtocolRange(view, pkg, spanNode)`
`253`	`253`	`if err != nil {`
`254`	`254`	`return protocol.DocumentSymbol{}, err`
`255`	`255`	`}`
`256`		`- child.SelectionRange, err = nodeToProtocolRange(view, m, selectionNode)`
	`256`	`+ child.SelectionRange, err = nodeToProtocolRange(view, pkg, selectionNode)`
`257`	`257`	`if err != nil {`
`258`	`258`	`return protocol.DocumentSymbol{}, err`
`259`	`259`	`}`
`@@ -283,7 +283,7 @@ func nodesForStructField(i int, st *ast.StructType) (span, selection ast.Node) {`
`283`	`283`	`return nil, nil`
`284`	`284`	`}`
`285`	`285`
`286`		`-func varSymbol(ctx context.Context, view View, m protocol.ColumnMapper, decl ast.Node, name ast.Ident, obj types.Object, q types.Qualifier) (protocol.DocumentSymbol, error) {`
	`286`	`+func varSymbol(ctx context.Context, view View, pkg Package, decl ast.Node, name *ast.Ident, obj types.Object, q types.Qualifier) (protocol.DocumentSymbol, error) {`
`287`	`287`	`s := protocol.DocumentSymbol{`
`288`	`288`	`Name: obj.Name(),`
`289`	`289`	`Kind: protocol.Variable,`
`@@ -292,11 +292,11 @@ func varSymbol(ctx context.Context, view View, m *protocol.ColumnMapper, decl as`
`292`	`292`	`s.Kind = protocol.Constant`
`293`	`293`	`}`
`294`	`294`	`var err error`
`295`		`- s.Range, err = nodeToProtocolRange(view, m, decl)`
	`295`	`+ s.Range, err = nodeToProtocolRange(view, pkg, decl)`
`296`	`296`	`if err != nil {`
`297`	`297`	`return protocol.DocumentSymbol{}, err`
`298`	`298`	`}`
`299`		`- s.SelectionRange, err = nodeToProtocolRange(view, m, name)`
	`299`	`+ s.SelectionRange, err = nodeToProtocolRange(view, pkg, name)`
`300`	`300`	`if err != nil {`
`301`	`301`	`return protocol.DocumentSymbol{}, err`
`302`	`302`	`}`
Original file line number	Diff line number	Diff line change
`@@ -168,8 +168,8 @@ func IsGenerated(ctx context.Context, snapshot Snapshot, uri span.URI) bool {`
`168`	`168`	`return false`
`169`	`169`	`}`
`170`	`170`
`171`		`-func nodeToProtocolRange(view View, m *protocol.ColumnMapper, n ast.Node) (protocol.Range, error) {`
`172`		`- mrng, err := nodeToMappedRange(view, m, n)`
	`171`	`+func nodeToProtocolRange(view View, pkg Package, n ast.Node) (protocol.Range, error) {`
	`172`	`+ mrng, err := posToMappedRange(view, pkg, n.Pos(), n.End())`
`173`	`173`	`if err != nil {`
`174`	`174`	`return protocol.Range{}, err`
`175`	`175`	`}`
`@@ -199,27 +199,19 @@ func nameToMappedRange(v View, pkg Package, pos token.Pos, name string) (mappedR`
`199`	`199`	`return posToMappedRange(v, pkg, pos, pos+token.Pos(len(name)))`
`200`	`200`	`}`
`201`	`201`
`202`		`-func nodeToMappedRange(view View, m *protocol.ColumnMapper, n ast.Node) (mappedRange, error) {`
`203`		`- return posToRange(view, m, n.Pos(), n.End())`
`204`		`-}`
`205`		`-`
`206`	`202`	`func posToMappedRange(v View, pkg Package, pos, end token.Pos) (mappedRange, error) {`
`207`	`203`	`logicalFilename := v.Session().Cache().FileSet().File(pos).Position(pos).Filename`
`208`	`204`	`m, err := findMapperInPackage(v, pkg, span.FileURI(logicalFilename))`
`209`	`205`	`if err != nil {`
`210`	`206`	`return mappedRange{}, err`
`211`	`207`	`}`
`212`		`- return posToRange(v, m, pos, end)`
`213`		`-}`
`214`		`-`
`215`		`-func posToRange(view View, m *protocol.ColumnMapper, pos, end token.Pos) (mappedRange, error) {`
`216`	`208`	`if !pos.IsValid() {`
`217`	`209`	`return mappedRange{}, errors.Errorf("invalid position for %v", pos)`
`218`	`210`	`}`
`219`	`211`	`if !end.IsValid() {`
`220`	`212`	`return mappedRange{}, errors.Errorf("invalid position for %v", end)`
`221`	`213`	`}`
`222`		`- return newMappedRange(view.Session().Cache().FileSet(), m, pos, end), nil`
	`214`	`+ return newMappedRange(v.Session().Cache().FileSet(), m, pos, end), nil`
`223`	`215`	`}`
`224`	`216`
`225`	`217`	`// Matches cgo generated comment as well as the proposed standard:`