| -- 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` |
| } |
| |
