qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-19 12:34:47 -07:00
Code Releases Activity
fc4ffaa1ce
go/internal/lsp/testdata/badstmt/badstmt.go.in

26 lines
461 B
Go
Raw Normal View History

internal/lsp: improve completions in go and defer statements Improve the existing fix-the-AST code to better identify the expression following the "go" or "defer" keywords: - Don't slurp the expression start outside the loop since the expression might only have a single token. - Set expression end to the position after the final token, not the position of the final token. - Track curly brace nesting to properly capture an entire "func() {}" expression. - Fix parent node detection to work when BadStmt isn't first statement of block. - Add special case to detect dangling period, e.g. "defer fmt.". We insert phantom "_" selectors like go/parser does to prevent the dangling "." from messing up the AST. - Use reflect in offsetPositions so it updates positions in all node types. This code shouldn't be called often, so I don't think performance is a concern. I also tweaked the function snippet code so it properly expands "defer" and "go" expressions to function calls. It thought it didn't have to expand since there was already a *ast.CallExpr, but the CallExpr was faked by us and the source doesn't actually contain the "()" calling parens. Note that this does not work for nested go/defer statements. For example, completions won't work properly in cases like this: go func() { defer fmt.<> } I think we can fix this as well with some more work. Change-Id: I8f9753fda76909b0e3a83489cdea69ad04ee237a Reviewed-on: https://go-review.googlesource.com/c/tools/+/193997 Reviewed-by: Rebecca Stambler <rstambler@golang.org> Run-TryBot: Rebecca Stambler <rstambler@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2019-09-06 15:22:54 -06:00
package badstmt
import (
"golang.org/x/tools/internal/lsp/foo"
)
func _() {
defer foo.F //@complete(" //", Foo),diag(" //", "LSP", "function must be invoked in defer statement")
y := 1
defer foo.F //@complete(" //", Foo)
}
internal/lsp: fix infinite recursion while fixing AST We were recursing infinitely in cases like this: switch true { case true: go foo.F<> } There were three things that came together to cause this: 1. We recently starting recursively fixing broken go/defer statements. 2. In this case we were failing to swap in the correct ast.Node in for the *ast.BadStmt because we were only looking for *ast.BlockStmt (and *ast.CaseStmt has no block). 3. After 2), we weren't returning an error so the fix() code thought it should recurse. Fix 2) by using reflection to swap AST nodes in a generic way. Perhaps a bit overkill in this case, but I happened to have already written this for an upcoming change, so I just pulled it in to fix this bug. Fix 3) by returning an error if we fail to swap the AST nodes. Fixes golang/go#34353. Change-Id: I17ff1afd52ae165c0ba9de5820dcec4cb7d756cb Reviewed-on: https://go-review.googlesource.com/c/tools/+/196137 Run-TryBot: Rebecca Stambler <rstambler@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Rebecca Stambler <rstambler@golang.org>
2019-09-17 22:20:55 -06:00
func _() {
switch true {
case true:
go foo.F //@complete(" //", Foo)
}
}
internal/lsp: improve completions in go and defer statements Improve the existing fix-the-AST code to better identify the expression following the "go" or "defer" keywords: - Don't slurp the expression start outside the loop since the expression might only have a single token. - Set expression end to the position after the final token, not the position of the final token. - Track curly brace nesting to properly capture an entire "func() {}" expression. - Fix parent node detection to work when BadStmt isn't first statement of block. - Add special case to detect dangling period, e.g. "defer fmt.". We insert phantom "_" selectors like go/parser does to prevent the dangling "." from messing up the AST. - Use reflect in offsetPositions so it updates positions in all node types. This code shouldn't be called often, so I don't think performance is a concern. I also tweaked the function snippet code so it properly expands "defer" and "go" expressions to function calls. It thought it didn't have to expand since there was already a *ast.CallExpr, but the CallExpr was faked by us and the source doesn't actually contain the "()" calling parens. Note that this does not work for nested go/defer statements. For example, completions won't work properly in cases like this: go func() { defer fmt.<> } I think we can fix this as well with some more work. Change-Id: I8f9753fda76909b0e3a83489cdea69ad04ee237a Reviewed-on: https://go-review.googlesource.com/c/tools/+/193997 Reviewed-by: Rebecca Stambler <rstambler@golang.org> Run-TryBot: Rebecca Stambler <rstambler@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2019-09-06 15:22:54 -06:00
func _() {
defer func() {
foo.F //@complete(" //", Foo),snippet(" //", Foo, "Foo()", "Foo()")
foo. //@complete(" //", Foo, IntFoo, StructFoo)
}
}
Copy Permalink