gopls/internal/folding_range: display closing parentheses

After this CL, closing braces (or parentheses or brackets) at the end
of a folding range will be displayed, so that users can easily add things
at the end of the range.

Closing string quotes have never been displayed.

Fixes: golang/go#75229
Change-Id: I73f45d6b157f6da8e988b0fc6ec63186d4fea408
Reviewed-on: https://go-review.googlesource.com/c/tools/+/704695
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Madeline Kalil <[email protected]>

Author: pjweinbgo

gopls/internal/golang/folding_range.go

@@ -56,15 +56,13 @@ func FoldingRange(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle,
 		(*ast.GenDecl)(nil),
 	}
 	for cur := range pgf.Cursor.Preorder(filter...) {
-		// TODO(suzmue): include trailing empty lines before the closing
-		// parenthesis/brace.
 		var kind protocol.FoldingRangeKind
 		// start and end define the range of content to fold away.
 		var start, end token.Pos
 		switch n := cur.Node().(type) {
 		case *ast.BlockStmt:
 			// Fold between positions of or lines between "{" and "}".
-			start, end = bracketedFoldingRange(n.Lbrace, n.Rbrace)
+			start, end = bracketedFoldingRange(pgf, n.Lbrace, n.Rbrace, lineFoldingOnly)
 
 		case *ast.CaseClause:
 			// Fold from position of ":" to end.
@@ -76,19 +74,19 @@ func FoldingRange(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle,
 
 		case *ast.CallExpr:
 			// Fold between positions of or lines between "(" and ")".
-			start, end = bracketedFoldingRange(n.Lparen, n.Rparen)
+			start, end = bracketedFoldingRange(pgf, n.Lparen, n.Rparen, lineFoldingOnly)
 
 		case *ast.FieldList:
 			// Fold between positions of or lines between opening parenthesis/brace and closing parenthesis/brace.
-			start, end = bracketedFoldingRange(n.Opening, n.Closing)
+			start, end = bracketedFoldingRange(pgf, n.Opening, n.Closing, lineFoldingOnly)
 
 		case *ast.GenDecl:
 			// If this is an import declaration, set the kind to be protocol.Imports.
 			if n.Tok == token.IMPORT {
 				kind = protocol.Imports
 			}
 			// Fold between positions of or lines between "(" and ")".
-			start, end = bracketedFoldingRange(n.Lparen, n.Rparen)
+			start, end = bracketedFoldingRange(pgf, n.Lparen, n.Rparen, lineFoldingOnly)
 
 		case *ast.BasicLit:
 			// Fold raw string literals from position of "`" to position of "`".
@@ -98,7 +96,7 @@ func FoldingRange(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle,
 
 		case *ast.CompositeLit:
 			// Fold between positions of or lines between "{" and "}".
-			start, end = bracketedFoldingRange(n.Lbrace, n.Rbrace)
+			start, end = bracketedFoldingRange(pgf, n.Lbrace, n.Rbrace, lineFoldingOnly)
 
 		default:
 			panic(n)
@@ -137,7 +135,7 @@ func FoldingRange(ctx context.Context, snapshot *cache.Snapshot, fh file.Handle,
 
 // bracketedFoldingRange returns the folding range for nodes with parentheses/braces/brackets
 // that potentially can take up multiple lines.
-func bracketedFoldingRange(open, close token.Pos) (token.Pos, token.Pos) {
+func bracketedFoldingRange(pgf *parsego.File, open, close token.Pos, lineFoldingOnly bool) (token.Pos, token.Pos) {
 	if !open.IsValid() || !close.IsValid() {
 		return token.NoPos, token.NoPos
 	}
@@ -146,8 +144,12 @@ func bracketedFoldingRange(open, close token.Pos) (token.Pos, token.Pos) {
 		return token.NoPos, token.NoPos
 	}
 
+	if !lineFoldingOnly {
+		return open + 1, close
+	}
+
 	// Clients with "LineFoldingOnly" set to true can fold only full lines.
-	// This is checked in the caller.
+	// This is also checked in the caller.
 	//
 	// Clients that support folding ranges can display them in various ways
 	// (e.g., how are folding ranges marked? is the final line displayed?).
@@ -169,15 +171,14 @@ func bracketedFoldingRange(open, close token.Pos) (token.Pos, token.Pos) {
 	//	var x = []string{"a", ...
 	//	"c" }
 	//
-	// This is a change in behavior. The old code would not fold this example,
-	// nor would it have folded
-	//
-	// func foo() { // a non-godoc comment
-	//  ...
-	// }
-	// which seems wrong.
+	// This code displays the final line containing ),},], but not the closing quote
+	// of a multi-line string
 
-	return open + 1, close
+	prevLineEnd := pgf.Tok.LineStart(safetoken.Line(pgf.Tok, close)) - 1 // there was a previous line
+	if prevLineEnd <= open {                                             // all the same line
+		return token.NoPos, token.NoPos
+	}
+	return open + 1, prevLineEnd
 }
 
 // commentsFoldingRange returns the folding ranges for all comment blocks in file.

gopls/internal/test/marker/testdata/foldingrange/a_lineonly.txt

@@ -145,8 +145,8 @@ import (<0 kind="imports">
 	"fmt"
 	_ "log"
 	"sort"
-	"time"
-</0>)
+	"time"</0>
+)
 
 import _ "os"
 
@@ -157,15 +157,15 @@ func Bar() string {<2 kind="">
 	switch {<3 kind="">
 	case true:<4 kind="">
 		if true {<5 kind="">
-			fmt.Println("true")
-		</5>} else {<6 kind="">
-			fmt.Println("false")
-		</6>}</4>
+			fmt.Println("true")</5>
+		} else {<6 kind="">
+			fmt.Println("false")</6>
+		}</4>
 	case false:<7 kind="">
 		fmt.Println("false")</7>
 	default:<8 kind="">
-		fmt.Println("default")</8>
-	</3>}
+		fmt.Println("default")</3></8>
+	}
 	/* This is a multiline<9 kind="comment">
 	block
 	comment */</9>
@@ -177,93 +177,93 @@ func Bar() string {<2 kind="">
 	_ = []int{<11 kind="">
 		1,
 		2,
-		3,
-	</11>}
+		3,</11>
+	}
 	_ = [2]string{<12 kind="">"d",
-		"e",
-	</12>}
+		"e",</12>
+	}
 	_ = map[string]int{<13 kind="">
 		"a": 1,
 		"b": 2,
-		"c": 3,
-	</13>}
+		"c": 3,</13>
+	}
 	type T struct {<14 kind="">
 		f string
 		g int
-		h string
-	</14>}
+		h string</14>
+	}
 	_ = T{<15 kind="">
 		f: "j",
 		g: 4,
-		h: "i",
-	</15>}
+		h: "i",</15>
+	}
 	x, y := make(chan bool), make(chan bool)
 	select {<16 kind="">
 	case val := <-x:<17 kind="">
 		if val {<18 kind="">
-			fmt.Println("true from x")
-		</18>} else {<19 kind="">
-			fmt.Println("false from x")
-		</19>}</17>
+			fmt.Println("true from x")</18>
+		} else {<19 kind="">
+			fmt.Println("false from x")</19>
+		}</17>
 	case <-y:<20 kind="">
 		fmt.Println("y")</20>
 	default:<21 kind="">
-		fmt.Println("default")</21>
-	</16>}
+		fmt.Println("default")</16></21>
+	}
 	// This is a multiline comment<22 kind="comment">
 	// that is not a doc comment.</22>
 	return <23 kind="">`
 this string
-is not indented`</23>
-</2>}
+is not indented`</2></23>
+}
 
 func _() {<24 kind="">
 	slice := []int{1, 2, 3}
 	sort.Slice(<25 kind="">slice, func(i, j int) bool {<26 kind="">
 		a, b := slice[i], slice[j]
-		return a > b
-	</26>}</25>)
+		return a > b</25></26>
+	})
 
 	sort.Slice(slice, func(i, j int) bool { return slice[i] > slice[j] })
 
 	sort.Slice(<27 kind="">
 		slice,
 		func(i, j int) bool {<28 kind="">
-			return slice[i] > slice[j]
-		</28>},
-	</27>)
+			return slice[i] > slice[j]</28>
+		},</27>
+	)
 
 	fmt.Println(<29 kind="">
 		1, 2, 3,
-		4,
-	</29>)
+		4,</29>
+	)
 
 	fmt.Println(<30 kind="">1, 2, 3,
 		4, 5, 6,
-		7, 8, 9,
-		10</30>)
+		7, 8, 9,</30>
+		10)
 
 	// Call with ellipsis.
 	_ = fmt.Errorf(<31 kind="">
 		"test %d %d",
-		[]any{1, 2, 3}...,
-	</31>)
+		[]any{1, 2, 3}...,</31>
+	)
 
 	// Check multiline string.
 	fmt.Println(<32 kind="">
 		<33 kind="">`multi
 		line
 		string
 		`</33>,
-		1, 2, 3,
-	</32>)
+		1, 2, 3,</32>
+	)
 
 	// Call without arguments.
-	_ = time.Now()
-</24>}
+	_ = time.Now()</24>
+}
 
 func _(<34 kind="">
 	a int, b int,
-	c int,
-</34>) {<35 kind="">
-</35>}
+	c int,</34>
+) {
+}