mirror
/
go
mirror of https://github.com/golang/go.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
go/internal/lsp/testdata/folding/a.go.golden

760 lines
9.8 KiB
Plaintext
Raw Blame History

-- foldingRange-0 --
package folding //@fold("package")
import (<>)
import _ "os"
// bar is a function.<>
func bar(<>) string {<>}
-- foldingRange-1 --
package folding //@fold("package")
import (
"fmt"
_ "log"
)
import _ "os"
// bar is a function.
// With a multiline doc comment.
func bar() string {
/* This is a single line comment */
switch {<>}
/* This is a multiline<>
/* This is a multiline<>
_ = []int{<>}
_ = [2]string{<>}
_ = map[string]int{<>}
type T struct {<>}
_ = T{<>}
x, y := make(<>), make(<>)
select {<>}
// This is a multiline comment<>
return <>
}
-- foldingRange-2 --
package folding //@fold("package")
import (
"fmt"
_ "log"
)
import _ "os"
// bar is a function.
// With a multiline doc comment.
func bar() string {
/* This is a single line comment */
switch {
case true:<>
case false:<>
default:<>
}
/* This is a multiline
block
comment */
/* This is a multiline
block
comment */
// Followed by another comment.
_ = []int{
1,
2,
3,
}
_ = [2]string{"d",
"e",
}
_ = map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
type T struct {
f string
g int
h string
}
_ = T{
f: "j",
g: 4,
h: "i",
}
x, y := make(chan bool), make(chan bool)
select {
case val := <-x:<>
case <-y:<>
default:<>
}
// This is a multiline comment
// that is not a doc comment.
return `
this string
is not indented`
}
-- foldingRange-3 --
package folding //@fold("package")
import (
"fmt"
_ "log"
)
import _ "os"
// bar is a function.
// With a multiline doc comment.
func bar() string {
/* This is a single line comment */
switch {
case true:
if true {<>} else {<>}
case false:
fmt.Println(<>)
default:
fmt.Println(<>)
}
/* This is a multiline
block
comment */
/* This is a multiline
block
comment */
// Followed by another comment.
_ = []int{
1,
2,
3,
}
_ = [2]string{"d",
"e",
}
_ = map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
type T struct {
f string
g int
h string
}
_ = T{
f: "j",
g: 4,
h: "i",
}
x, y := make(chan bool), make(chan bool)
select {
case val := <-x:
if val {<>} else {<>}
case <-y:
fmt.Println(<>)
default:
fmt.Println(<>)
}
// This is a multiline comment
// that is not a doc comment.
return `
this string
is not indented`
}
-- foldingRange-4 --
package folding //@fold("package")
import (
"fmt"
_ "log"
)
import _ "os"
// bar is a function.
// With a multiline doc comment.
func bar() string {
/* This is a single line comment */
switch {
case true:
if true {
fmt.Println(<>)
} else {
fmt.Println(<>)
}
case false:
fmt.Println("false")
default:
fmt.Println("default")
}
/* This is a multiline
block
comment */
/* This is a multiline
block
comment */
// Followed by another comment.
_ = []int{
1,
2,
3,
}
_ = [2]string{"d",
"e",
}
_ = map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
type T struct {
f string
g int
h string
}
_ = T{
f: "j",
g: 4,
h: "i",
}
x, y := make(chan bool), make(chan bool)
select {
case val := <-x:
if val {
fmt.Println(<>)
} else {
fmt.Println(<>)
}
case <-y:
fmt.Println("y")
default:
fmt.Println("default")
}
// This is a multiline comment
// that is not a doc comment.
return `
this string
is not indented`
}
-- foldingRange-cmd --
3:9-6:0
10:22-11:32
12:10-12:9
12:20-75:0
14:10-25:1
15:12-20:3
16:12-18:2
17:16-17:21
18:11-20:2
19:16-19:22
21:13-22:22
22:15-22:21
23:10-24:24
24:15-24:23
26:24-28:11
30:24-33:32
34:12-38:1
39:16-41:1
42:21-46:1
47:17-51:1
52:8-56:1
57:15-57:23
57:32-57:40
58:10-69:1
59:18-64:3
60:11-62:2
61:16-61:28
62:11-64:2
63:16-63:29
65:11-66:18
66:15-66:17
67:10-68:24
68:15-68:23
70:32-71:30
72:9-74:16
-- foldingRange-comment-0 --
package folding //@fold("package")
import (
"fmt"
_ "log"
)
import _ "os"
// bar is a function.<>
func bar() string {
/* This is a single line comment */
switch {
case true:
if true {
fmt.Println("true")
} else {
fmt.Println("false")
}
case false:
fmt.Println("false")
default:
fmt.Println("default")
}
/* This is a multiline<>
/* This is a multiline<>
_ = []int{
1,
2,
3,
}
_ = [2]string{"d",
"e",
}
_ = map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
type T struct {
f string
g int
h string
}
_ = T{
f: "j",
g: 4,
h: "i",
}
x, y := make(chan bool), make(chan bool)
select {
case val := <-x:
if val {
fmt.Println("true from x")
} else {
fmt.Println("false from x")
}
case <-y:
fmt.Println("y")
default:
fmt.Println("default")
}
// This is a multiline comment<>
return `
this string
is not indented`
}
-- foldingRange-imports-0 --
package folding //@fold("package")
import (<>)
import _ "os"
// bar is a function.
// With a multiline doc comment.
func bar() string {
/* This is a single line comment */
switch {
case true:
if true {
fmt.Println("true")
} else {
fmt.Println("false")
}
case false:
fmt.Println("false")
default:
fmt.Println("default")
}
/* This is a multiline
block
comment */
/* This is a multiline
block
comment */
// Followed by another comment.
_ = []int{
1,
2,
3,
}
_ = [2]string{"d",
"e",
}
_ = map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
type T struct {
f string
g int
h string
}
_ = T{
f: "j",
g: 4,
h: "i",
}
x, y := make(chan bool), make(chan bool)
select {
case val := <-x:
if val {
fmt.Println("true from x")
} else {
fmt.Println("false from x")
}
case <-y:
fmt.Println("y")
default:
fmt.Println("default")
}
// This is a multiline comment
// that is not a doc comment.
return `
this string
is not indented`
}
-- foldingRange-lineFolding-0 --
package folding //@fold("package")
import (<>
)
import _ "os"
// bar is a function.<>
func bar() string {<>
}
-- foldingRange-lineFolding-1 --
package folding //@fold("package")
import (
"fmt"
_ "log"
)
import _ "os"
// bar is a function.
// With a multiline doc comment.
func bar() string {
/* This is a single line comment */
switch {<>
}
/* This is a multiline<>
/* This is a multiline<>
_ = []int{<>,
}
_ = [2]string{"d",
"e",
}
_ = map[string]int{<>,
}
type T struct {<>
}
_ = T{<>,
}
x, y := make(chan bool), make(chan bool)
select {<>
}
// This is a multiline comment<>
return <>
}
-- foldingRange-lineFolding-2 --
package folding //@fold("package")
import (
"fmt"
_ "log"
)
import _ "os"
// bar is a function.
// With a multiline doc comment.
func bar() string {
/* This is a single line comment */
switch {
case true:<>
case false:<>
default:<>
}
/* This is a multiline
block
comment */
/* This is a multiline
block
comment */
// Followed by another comment.
_ = []int{
1,
2,
3,
}
_ = [2]string{"d",
"e",
}
_ = map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
type T struct {
f string
g int
h string
}
_ = T{
f: "j",
g: 4,
h: "i",
}
x, y := make(chan bool), make(chan bool)
select {
case val := <-x:<>
case <-y:<>
default:<>
}
// This is a multiline comment
// that is not a doc comment.
return `
this string
is not indented`
}
-- foldingRange-lineFolding-3 --
package folding //@fold("package")
import (
"fmt"
_ "log"
)
import _ "os"
// bar is a function.
// With a multiline doc comment.
func bar() string {
/* This is a single line comment */
switch {
case true:
if true {<>
} else {<>
}
case false:
fmt.Println("false")
default:
fmt.Println("default")
}
/* This is a multiline
block
comment */
/* This is a multiline
block
comment */
// Followed by another comment.
_ = []int{
1,
2,
3,
}
_ = [2]string{"d",
"e",
}
_ = map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
type T struct {
f string
g int
h string
}
_ = T{
f: "j",
g: 4,
h: "i",
}
x, y := make(chan bool), make(chan bool)
select {
case val := <-x:
if val {<>
} else {<>
}
case <-y:
fmt.Println("y")
default:
fmt.Println("default")
}
// This is a multiline comment
// that is not a doc comment.
return `
this string
is not indented`
}
-- foldingRange-lineFolding-comment-0 --
package folding //@fold("package")
import (
"fmt"
_ "log"
)
import _ "os"
// bar is a function.<>
func bar() string {
/* This is a single line comment */
switch {
case true:
if true {
fmt.Println("true")
} else {
fmt.Println("false")
}
case false:
fmt.Println("false")
default:
fmt.Println("default")
}
/* This is a multiline<>
/* This is a multiline<>
_ = []int{
1,
2,
3,
}
_ = [2]string{"d",
"e",
}
_ = map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
type T struct {
f string
g int
h string
}
_ = T{
f: "j",
g: 4,
h: "i",
}
x, y := make(chan bool), make(chan bool)
select {
case val := <-x:
if val {
fmt.Println("true from x")
} else {
fmt.Println("false from x")
}
case <-y:
fmt.Println("y")
default:
fmt.Println("default")
}
// This is a multiline comment<>
return `
this string
is not indented`
}
-- foldingRange-lineFolding-imports-0 --
package folding //@fold("package")
import (<>
)
import _ "os"
// bar is a function.
// With a multiline doc comment.
func bar() string {
/* This is a single line comment */
switch {
case true:
if true {
fmt.Println("true")
} else {
fmt.Println("false")
}
case false:
fmt.Println("false")
default:
fmt.Println("default")
}
/* This is a multiline
block
comment */
/* This is a multiline
block
comment */
// Followed by another comment.
_ = []int{
1,
2,
3,
}
_ = [2]string{"d",
"e",
}
_ = map[string]int{
"a": 1,
"b": 2,
"c": 3,
}
type T struct {
f string
g int
h string
}
_ = T{
f: "j",
g: 4,
h: "i",
}
x, y := make(chan bool), make(chan bool)
select {
case val := <-x:
if val {
fmt.Println("true from x")
} else {
fmt.Println("false from x")
}
case <-y:
fmt.Println("y")
default:
fmt.Println("default")
}
// This is a multiline comment
// that is not a doc comment.
return `
this string
is not indented`
}
Reference in New Issue View Git Blame Copy Permalink