gopls/internal/golang: definition support break, goto and continue statements

Enables you to use the definition operation on a goto, break, or continue
statement by returning the location of the label, the closing brace
of the relevant block statement, or the start of the relevant loop,
respectively.

Fixes golang/go#70462

Change-Id: Ib8640283e4d80115f76f7c23961ce277bc093b4d
Reviewed-on: https://go-review.googlesource.com/c/tools/+/637818
Reviewed-by: Alan Donovan <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Robert Findley <[email protected]>

Author: madelinekalil

gopls/doc/features/navigation.md

@@ -25,6 +25,9 @@ A definition query also works in these unexpected places:
 - On the declaration of a non-Go function (a `func` with no body),
   it returns the location of the assembly implementation, if any,
 - On a **return statement**, it returns the location of the function's result variables.
+- On a **goto**, **break**, or **continue** statement, it returns the
+  location of the label, the closing brace of the relevant block statement, or the
+  start of the relevant loop, respectively.
 
 <!-- On a built-in symbol such as `append` or `unsafe.Pointer`, `definition` reports
 the location of the declaration in the builtin or unsafe pseudo-packages,

gopls/doc/release/v0.18.0.md

@@ -52,6 +52,9 @@ The Definition query now supports additional locations:
 
 - When invoked on a return statement, it reports the location
   of the function's result variables.
+- When invoked on a break, goto, or continue statement, it reports
+  the location of the label, the closing brace of the relevant
+  block statement, or the start of the relevant loop, respectively.
 
 ## Improvements to "Hover"
 

gopls/internal/golang/definition.go

@@ -85,11 +85,13 @@ func Definition(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle, p
 		return locations, err // may be success or failure
 	}
 
-	// Handle the case where the cursor is on a return statement by jumping to the result variables.
+	// Handle definition requests for various special kinds of syntax node.
 	path, _ := astutil.PathEnclosingInterval(pgf.File, pos, pos)
-	if is[*ast.ReturnStmt](path[0]) {
+	switch node := path[0].(type) {
+	// Handle the case where the cursor is on a return statement by jumping to the result variables.
+	case *ast.ReturnStmt:
 		var funcType *ast.FuncType
-		for _, n := range path {
+		for _, n := range path[1:] {
 			switch n := n.(type) {
 			case *ast.FuncLit:
 				funcType = n.Type
@@ -109,6 +111,61 @@ func Definition(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle, p
 			return nil, err
 		}
 		return []protocol.Location{loc}, nil
+
+	case *ast.BranchStmt:
+		// Handle the case where the cursor is on a goto, break or continue statement by returning the
+		// location of the label, the closing brace of the relevant block statement, or the
+		// start of the relevant loop, respectively.
+		label, isLabeled := pkg.TypesInfo().Uses[node.Label].(*types.Label)
+		switch node.Tok {
+		case token.GOTO:
+			if isLabeled {
+				loc, err := pgf.PosLocation(label.Pos(), label.Pos()+token.Pos(len(label.Name())))
+				if err != nil {
+					return nil, err
+				}
+				return []protocol.Location{loc}, nil
+			} else {
+				// Workaround for #70957.
+				// TODO(madelinekalil): delete when go1.25 fixes it.
+				return nil, nil
+			}
+		case token.BREAK, token.CONTINUE:
+			// Find innermost relevant ancestor for break/continue.
+			for i, n := range path[1:] {
+				if isLabeled {
+					l, ok := path[1:][i+1].(*ast.LabeledStmt)
+					if !(ok && l.Label.Name == label.Name()) {
+						continue
+					}
+				}
+				switch n.(type) {
+				case *ast.ForStmt, *ast.RangeStmt:
+					var start, end token.Pos
+					if node.Tok == token.BREAK {
+						start, end = n.End()-token.Pos(len("}")), n.End()
+					} else { // CONTINUE
+						start, end = n.Pos(), n.Pos()+token.Pos(len("for"))
+					}
+					loc, err := pgf.PosLocation(start, end)
+					if err != nil {
+						return nil, err
+					}
+					return []protocol.Location{loc}, nil
+				case *ast.SwitchStmt, *ast.TypeSwitchStmt, *ast.SelectStmt:
+					if node.Tok == token.BREAK {
+						loc, err := pgf.PosLocation(n.End()-1, n.End())
+						if err != nil {
+							return nil, err
+						}
+						return []protocol.Location{loc}, nil
+					}
+				case *ast.FuncDecl, *ast.FuncLit:
+					// bad syntax; avoid jumping outside the current function
+					return nil, nil
+				}
+			}
+		}
 	}
 
 	// The general case: the cursor is on an identifier.

gopls/internal/test/marker/testdata/definition/branch.txt

@@ -0,0 +1,168 @@
+This test checks definition operations in branch statements break, goto and continue.
+
+-- go.mod --
+module mod.com
+
+go 1.18
+
+-- a/a.go --
+package a
+
+import "log"
+
+func breakLoop() {
+	for i := 0; i < 10; i++ {
+		if i > 6 {
+			break //@def("break", rbrace1)
+		}
+	} //@loc(rbrace1, `}`)
+}
+
+func breakNestedLoop() {
+	for i := 0; i < 10; i++ {
+		for j := 0; j < 5; j++ {
+			if j > 1 {
+				break //@def("break", rbrace2)
+			}
+		} //@loc(rbrace2, `}`)
+	}
+}
+
+func breakNestedLoopWithLabel() {
+	Outer:
+	for i := 0; i < 10; i++ {
+		for j := 0; j < 5; j++ {
+			if j > 1 {
+				break Outer//@def("break", outerparen)
+			}
+		}
+	} //@loc(outerparen, `}`)
+}
+
+func breakSwitch(i int) {
+	switch i {
+		case 1:
+			break //@def("break", rbrace4)
+		case 2:
+			log.Printf("2")
+		case 3:
+			log.Printf("3")
+	} //@loc(rbrace4, `}`)
+}
+
+func breakSwitchLabel(i int) {
+loop:
+	for {
+		switch i {
+		case 1:
+			break loop //@def("break", loopparen)
+		case 2:
+			log.Printf("2")
+		case 3:
+			continue loop
+		}
+	} //@loc(loopparen, `}`)
+}
+
+func breakSelect(c, quit chan int) {
+	x, y := 0, 1
+	for {
+		select {
+		case c <- x:
+			x, y = y, x+y
+		break //@def("break", rbrace5)
+		case <-quit:
+			log.Println("quit")
+			return
+		} //@loc(rbrace5, `}`)
+	}
+}
+
+func breakWithContinue() {
+	for j := 0; j < 5; j++ {
+		if (j < 4) {
+			continue
+		}
+		break //@def("break", rbrace6)
+	} //@loc(rbrace6, `}`)
+}
+
+func gotoNestedLoop() {
+	Outer: //@loc(outer, "Outer")
+	for i := 0; i < 10; i++ {
+		for j := 0; j < 5; j++ {
+			if (j > 1) {
+				goto Outer//@def("goto", outer)
+			}
+		}
+	}
+}
+
+func continueLoop() {
+	for j := 0; j < 5; j++ { //@loc(for3, `for`)
+		if (j < 4) {
+			continue //@def("continue", for3)
+		}
+		break
+	}
+}
+
+func continueDoubleLoop() {
+	for i := 0; i < 10; i++ { //@loc(for4, `for`)
+		for j := 0; j < 5; j++ {
+			if (j > 1) {
+				break
+			}
+		}
+		if (i > 7) {
+			continue//@def("continue", for4)
+		}
+	}
+}
+
+func breakInBlockStmt() {
+	for {
+		if 0 < 10 {
+			{
+				break //@def("break", rbrace9)
+			}
+		}
+	} //@loc(rbrace9, `}`)
+}
+
+func breakInLabeledStmt() {
+	outer:
+	for {
+		goto inner
+	inner:
+		break outer //@def("break", for5)
+	} //@loc(for5, `}`)
+}
+
+func breakToLabel(n int) {
+	outer1:
+		switch n {
+			case 1:
+				print("1")
+				for i := 0; i < 10; i++ {
+				if i > 3 {
+					break outer1 //@def("break", outer1)
+				}
+			}
+		} //@loc(outer1, "}")
+}
+
+func continueToLabel(n int) {
+	outer1:
+		for { //@loc(outer2, "for")
+			switch n {
+			case 1:
+				print("1")
+				for i := 0; i < 10; i++ {
+					if i > 3 {
+						continue outer1 //@def("continue", outer2)
+					}
+				}
+			}
+		}
+}