sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: go
Issue: x/build: automate testing "toolstash -cmp" with trybots
Labels: Builders,FeatureRequest

For cleanup CLs like https://go-review.googlesource.com/#/c/8762, it would be nice if the trybots could take care of building a toolchain at HEAD, toolstash saving it, rebuilding at HEAD+CL, and then running an appropriate "toolstash -cmp" build.

Using toolstash/buildall, this only needs to be run once on a fast/cheap trybot type (e.g., linux/amd64) to avoid wasting more expensive trybot resources (e.g., OS X and/or ARM).

Obviously this would only be on an opt-in basis.  Perhaps just a new dedicated trybot type that doesn't run by default, is configured with a different testing script than running all.bash, and is selected via whatever +trybot mechanism is implemented.

Maybe too niche a use case, but some rationale:
- Now that the toolchain is in Go, it seems like cleanup CLs to make the code more idiomatic are going to be increasingly common.
- It's easy to misuse toolstash; e.g., accidentally build the stashed toolchain at HEAD+CL rather than HEAD, negating the testing benefits.
- As a reviewer, you need to trust that developers who say "Passes toolstash -cmp" actually tested it correctly.
Repository: youtube-dl
Issue: Progress for --dump-json
Labels: request

Would it be possible to add a progress bar when fetching the data for a channel- or a playlist-json-dump (--dump-json)?
Repository: youtube-dl
Issue: Automatically embed subtitles in mkv files
Labels: request,postprocessors

Since it's possible to embed subtitles in mp4 (in a hard coded way probably), is there a way to embed subtitles files with mkvmerge or with ffmpeg in the post-processing option ?

(Maybe use the `--exec` command)
Repository: neovim
Issue: TagSearchPre/TagSearchPost Auto Commands
Labels: enhancement,events

Commands and maps that require the presence of a tag file should emit TagSearchPre/TagSearchPost events. This would include:

```
:[count]ta[g][!] {ident}
g<LeftMouse>
<C-LeftMouse>
CTRL-]
{Visual}CTRL-]
:ts[elect][!] [ident]
:sts[elect][!] [ident]
g]
{Visual}g]
:tj[ump][!] [ident]
:stj[ump][!] [ident]
g CTRL-]
{Visual}g CTRL-]
:[count]tn[ext][!]
:[count]tp[revious][!]
:[count]tN[ext][!]
:[count]tr[ewind][!]
:[count]tf[irst][!]
:tl[ast][!]
:lt[ag][!] [ident]
:pts[elect][!] [ident]
:ptj[ump][!] [ident]
:[count]ptn[ext][!]
:[count]ptp[revious][!]
:[count]ptN[ext][!]
:[count]ptr[ewind][!]
:[count]ptf[irst][!]
:ptl[ast][!]
```

But not:

```
g<RightMouse>
<C-RightMouse>
CTRL-T
:[count]po[p][!]
:[count]ta[g][!]
:tags
```

Plug-ins can hook into these events to (for example):
- Set the 'tags' option by
  - searching recursively upwards for matching files
  - searching for current file in vim-specific tag-file database
- Automatically generate the tag file if none found by 
  - Prompting the user for the location of the tag file (the "project root")

This complements plug-ins that use the BufWritePost/FileWritePost events to update tags.
Repository: youtube-dl
Issue: [Request] Would a %if(playlist)s tag be possible?
Labels: request

It would be very handy when used in a config.txt file:
-o "D:\%(uploader)s-%(upload_date)s-(%if(playlist)s_%(playlist_index)s) - %(title)s.%(ext)s"

Or even simplier, YDL could detect if the video is part of a playlist and automatically add which number the videos are in the playlist. Like:

-o "D:\%(uploader)s-%(upload_date)s>-(%(playlist)s_%(playlist_index)s)< - %(title)s.%(ext)s"

> < indicating that those file name tags should only be used if the tags are applicable to the video/URL. I'm guessing URL would be easier to do.
Repository: go
Issue: cmd/compile: inefficient increment of global array 
Labels: compiler/runtime

go version devel +a02d925 Sun Apr 12 12:14:36 2015 +0300 linux/amd64

Program is:

``` go
var tab *[256]byte

func foo(i int) {
    tab[i&255]++
}
```

Currently it is compiled to:

```
0000000000400c30 <main.foo>:
  400c30:       64 48 8b 0c 25 f8 ff    mov    %fs:0xfffffffffffffff8,%rcx
  400c37:       ff ff 
  400c39:       48 3b 61 10             cmp    0x10(%rcx),%rsp
  400c3d:       77 07                   ja     400c46 <main.foo+0x16>
  400c3f:       e8 cc 24 04 00          callq  443110 <runtime.morestack_noctxt>
  400c44:       eb ea                   jmp    400c30 <main.foo>
  400c46:       48 8b 44 24 08          mov    0x8(%rsp),%rax
  400c4b:       48 8b 1d 36 a0 0a 00    mov    0xaa036(%rip),%rbx        # 4aac88 <main.tab>
  400c52:       48 25 ff 00 00 00       and    $0xff,%rax
  400c58:       48 83 fb 00             cmp    $0x0,%rbx
  400c5c:       74 41                   je     400c9f <main.foo+0x6f>
  400c5e:       48 3d 00 01 00 00       cmp    $0x100,%rax
  400c64:       73 32                   jae    400c98 <main.foo+0x68>
  400c66:       48 8d 1c 03             lea    (%rbx,%rax,1),%rbx
  400c6a:       0f b6 2b                movzbl (%rbx),%ebp
  400c6d:       48 8b 1d 14 a0 0a 00    mov    0xaa014(%rip),%rbx        # 4aac88 <main.tab>
  400c74:       48 83 fb 00             cmp    $0x0,%rbx
  400c78:       74 1a                   je     400c94 <main.foo+0x64>
  400c7a:       48 3d 00 01 00 00       cmp    $0x100,%rax
  400c80:       73 0b                   jae    400c8d <main.foo+0x5d>
  400c82:       48 8d 1c 03             lea    (%rbx,%rax,1),%rbx
  400c86:       48 ff c5                inc    %rbp
  400c89:       40 88 2b                mov    %bpl,(%rbx)
  400c8c:       c3                      retq   
  400c8d:       e8 be a3 01 00          callq  41b050 <runtime.panicindex>
  400c92:       0f 0b                   ud2    
  400c94:       89 03                   mov    %eax,(%rbx)
  400c96:       eb e2                   jmp    400c7a <main.foo+0x4a>
  400c98:       e8 b3 a3 01 00          callq  41b050 <runtime.panicindex>
  400c9d:       0f 0b                   ud2    
  400c9f:       89 03                   mov    %eax,(%rbx)
  400ca1:       eb bb                   jmp    400c5e <main.foo+0x2e>
```

While it could be compiled to something along the lines of:

```
0000000000400c30 <main.foo>:
    mov 0x8(%rsp),%rax
    mov 0xaa036(%rip),%rbx        # 4aac88 <main.tab>
    add $1, (%rbx, %rax)
    ret
```

Here are several issues:
1. Address calculation, bounds check and nil check are done twice.
2. Nil check is not necessary here, as the increment itself will trigger paging fault if tab is nil.
3. Bounds check is not necessary as i&255 is guaranteed to be <256.
Repository: go
Issue: x/mobile: update the basic example with a viewport
Labels: mobile

The basic example is not reacting device orientation changes well. Use a clipping viewport and update its width and height as the device returns or the screen size alters.
Repository: go
Issue: misc/ios: go_darwin_arm_exec copies too much
Labels: OS-Darwin,mobile

When run from iostest.bash, go_darwin_arm_exec copies the src directory, which includes e.g. run.rc. It'd be good to make it more selective in what it copies.

I may try to fix at some point, but I'm still fighting codesigning.

/cc @crawshaw @minux
Repository: go
Issue: image/jpeg: add options to partially decode or tolerantly decode invalid images?
Labels: NeedsDecision,FeatureRequest

`go version devel +ce43e1f Mon Apr 13 23:27:35 2015 +0000 linux/amd64`

Attempted to use `jpeg.Decode` on the below image:
https://streamcoimg-a.akamaihd.net/000/340/810/9ae536dd97d2d92fc17a6590509a51c0.jpg

Expected the image to decode successfully, as it displays in a browser.

Actual result:
`invalid JPEG format: short Huffman data`
Repository: go
Issue: x/mobile/event: touch events should be timestamped
Labels: mobile

Touch events should be timestamped to determine the order. Order is critical to determine the direction and the speed of the gesture.

cc/ @crawshaw @hyangah
Repository: go
Issue: spec: panicking corner-case semantics
Labels: NeedsInvestigation

A few corner-cases regarding panicking that I noticed in the Go spec:

**1)** What happens if a panic occurs while a goroutine is already panicking?

Gc/gccgo seem to allow recursive panicking and recovering: http://play.golang.org/p/tBkwgyzmuT

But if a deferred function panics without any recovery, then the original panic is lost: http://play.golang.org/p/KqwGiWGMAx

**2)** The Go spec says "The return value of recover is nil if any of the following conditions holds: [...] recover was not called directly by a deferred function."

Gc/gccgo though seem to also have recover return nil in deferred functions if they were executed because of normal (i.e., non-panicking) function return: http://play.golang.org/p/a-fl_9Gga0

**3)** The Go spec says "Suppose a function G defers a function D that calls recover and a panic occurs in a function on the same goroutine in which G is executing. [...] If D returns normally, without starting a new panic, the panicking sequence stops."

Nit: I think the intention here is understood, but the wording could probably be improved somewhat.  As quoted in item 2 above, the spec later explicitly refers to deferred functions that "directly" call recover.  Omitting "directly" here suggests that indirect calls to recover should still stop the panicking sequence, but they'll return nil instead of the panic value.
Repository: youtube-dl
Issue: Support for NYU videos
Labels: site-support-request,account-needed

My university uses Mediasite player to host video lectures. The videos can be manually downloaded by pulling a link from a javascript file that is referenced in the HTML in script tags.

The system is set up exactly as with the existing Sandia extractor, with the exception that one must login via [Shibboleth](https://www.internet2.edu/products-services/trust-identity-middleware/shibboleth/) before accessing the videos, and some minor case stuff (lowercase v uppercase of certain strings).

I modified the Sandia extractor to match the NYU videos, and tried various methods of authentication, including: -u/-pw; adding in the AUTH string from the cookie to the extractor file, and; importing the cookie with --cookies. 

Interestingly enough, the error I get is with regexp and not authentication. 

Here's the output I get:

```
[debug] System config: []
[debug] User config: []
[debug] Command-line args: ['-u', 'PRIVATE', '-p', 'PRIVATE', '--verbose', 'http
://nyulaw.mediasite.com/mediasite/Play/197180ea8f5c448e9ccf3290c5d855411d']
[debug] Encodings: locale cp1252, fs mbcs, out cp437, pref cp1252
[debug] youtube-dl version 2015.04.09
[debug] Python version 3.4.3 - Windows-8-6.2.9200
[debug] exe versions: none
[debug] Proxy map: {}
[Sandia] 197180ea8f5c448e9ccf3290c5d855411d: Downloading webpage
ERROR: Unable to extract JS code URL; please report this issue on https://yt-dl.
org/bug . Make sure you are using the latest version; see  https://yt-dl.org/upd
ate  on how to update. Be sure to call youtube-dl with the --verbose flag and in
clude its complete output.
Traceback (most recent call last):
  File "D:\Knowledge\NYU Lectures\youtube-dl-master\youtube_dl\YoutubeDL.py", li
ne 651, in extract_info
    ie_result = ie.extract(url)
  File "D:\Knowledge\NYU Lectures\youtube-dl-master\youtube_dl\extractor\common.
py", line 275, in extract
    return self._real_extract(url)
  File "D:\Knowledge\NYU Lectures\youtube-dl-master\youtube_dl\extractor\sandia.
py", line 33, in _real_extract
    r'<script type="text/javascript" src="(/mediasite/FileServer/Presentation/[^
"]+)"', webpage, 'JS code URL')
  File "D:\Knowledge\NYU Lectures\youtube-dl-master\youtube_dl\extractor\common.
py", line 549, in _search_regex
    raise RegexNotFoundError('Unable to extract %s' % _name)
youtube_dl.utils.RegexNotFoundError: Unable to extract JS code URL; please repor
t this issue on https://yt-dl.org/bug . Make sure you are using the latest versi
on; see  https://yt-dl.org/update  on how to update. Be sure to call youtube-dl
with the --verbose flag and include its complete output.'
```
Repository: neovim
Issue: ZB: command to delete buffer without closing the window
Labels: enhancement

All other solutions I know of are hacks that kinda work (usually by creating a new split and then deleting the buffer in that window, and attempting to cover all possible cases for this), but intrinsic support for this would be greatly appreciated.
Repository: go
Issue: gdb: Stack pointer is 0 for goroutine 1
Labels: NeedsInvestigation

I noted this while writing 53840ad6f19b0c1b27a0731a37341d6159625355, so here is a proper bug report.

This only occurs for goroutine #1, and causes a Python exception. As far as I can tell, it is because for goroutine 1, `pc` is valid but `sp` is 0x0, in `runtime.allgs.sched`. I am not familiar enough with the runtime to discern more currently - i.e. whether it should be fixed in the runtime, or the Python script. I have reproduced on both Linux and FreeBSD. Details are below.

Operating System:

```
FreeBSD bb-nas.bb-router 10.1-RELEASE-p9 FreeBSD 10.1-RELEASE-p9 #0: Tue Apr  7 01:09:46 UTC 2015     root@amd64-builder.daemonology.net:/usr/obj/usr/src/sys/GENERIC  amd64`
```

But it is reproducible on Debian Unstable with vanilla packages as well.

GDB Version: `GNU gdb (GDB) 7.8.2 [GDB v7.8.2 for FreeBSD]`
Go version: `go version devel +888d44d Wed Apr 15 12:26:24 2015 +0000 freebsd/amd64`

How to reproduce:

```
daemon404@bb-nas:~/test$ cat test.go
package main
import "fmt"
func main() {
        mapvar := make(map[string]string,5)
        mapvar["abc"] = "def"
        mapvar["ghi"] = "jkl"
        strvar := "abc"
        ptrvar := &strvar
        fmt.Println("hi") // line 10
        _ = ptrvar
}
daemon404@bb-nas:~/test$ gdb782 ./test
GNU gdb (GDB) 7.8.2 [GDB v7.8.2 for FreeBSD]
Copyright (C) 2014 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-portbld-freebsd10.1".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
<http://www.gnu.org/software/gdb/documentation/>.
For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from ./test...done.
Loading Go Runtime support.
(gdb) br test.go:9
Breakpoint 1 at 0x400d5c: file /home/daemon404/test/test.go, line 9.
(gdb) r
Starting program: /usr/home/daemon404/test/test

Breakpoint 1, main.main () at /home/daemon404/test/test.go:9
9               fmt.Println("hi") // line 10
(gdb) info goroutine
* 1 running  runtime.systemstack_switch
  2 waiting  runtime.gopark
  3 waiting  runtime.gopark
  4 runnable runtime.runfinq
(gdb) goroutine 1 bt
#0  runtime.systemstack_switch () at /home/daemon404/go/src/runtime/asm_amd64.s:216
Backtrace stopped: Cannot access memory at address 0x0
```
Repository: rust
Issue: TLS dtor panics abort the process
Labels: A-destructors,T-libs-api,A-thread-locals,C-bug

Today a destructor in TLS which panics will abort the process:

``` rust
struct Foo;

impl Drop for Foo {
    fn drop(&mut self) { panic!() }
}

thread_local!(static FOO: Foo = Foo);

pub fn main() {
    FOO.with(|_| {});
}
```

When compiled and run (note that it must be run on a recent system due to #19776):

```
thread '<main>' panicked at 'explicit panic', foo.rs:4
fatal runtime error: Could not unwind stack, error = 5
zsh: illegal hardware instruction  ./foo
```

The reason behind this is that the context in which TLS destructors are running is different than the execution of the main thread itself (e.g. there is no try/catch block).

Is this (a) desirable and (b) should we change it?
Repository: youtube-dl
Issue: [walla] extractor is not used for "nick.walla.co.il"
Labels: site-support-request

Trying to download "The Legend of Korra" from "http://nick.walla.co.il/" fails (running verbosely):

youtube-dl -v http://nick.walla.co.il/?w=//2578863
[debug] System config: []
[debug] User config: []
[debug] Command-line args: [u'-v', u'http://nick.walla.co.il/?w=//2578863']
[debug] Encodings: locale UTF-8, fs UTF-8, out UTF-8, pref UTF-8
[debug] youtube-dl version 2015.04.09
[debug] Python version 2.7.9 - Linux-3.16.0-4-686-pae-i686-with-debian-8.0
[debug] exe versions: avconv 2.6.2, avprobe 2.6.2, ffmpeg 2.6.2, ffprobe 2.6.2, rtmpdump 2.4
[debug] Proxy map: {}
[generic] 2578863: Requesting header
WARNING: Falling back on generic information extractor.
[generic] 2578863: Downloading webpage
[generic] 2578863: Extracting information
ERROR: Unsupported URL: http://nick.walla.co.il/?w=//2578863
Traceback (most recent call last):
  File "/usr/local/lib/python2.7/dist-packages/youtube_dl/extractor/generic.py", line 858, in _real_extract
    doc = parse_xml(webpage)
  File "/usr/local/lib/python2.7/dist-packages/youtube_dl/utils.py", line 1531, in parse_xml
    tree = xml.etree.ElementTree.XML(s.encode('utf-8'), **kwargs)
  File "/usr/lib/python2.7/xml/etree/ElementTree.py", line 1300, in XML
    parser.feed(text)
  File "/usr/lib/python2.7/xml/etree/ElementTree.py", line 1642, in feed
    self._raiseerror(v)
  File "/usr/lib/python2.7/xml/etree/ElementTree.py", line 1506, in _raiseerror
    raise err
ParseError: syntax error: line 1, column 62
Traceback (most recent call last):
  File "/usr/local/lib/python2.7/dist-packages/youtube_dl/YoutubeDL.py", line 651, in extract_info
    ie_result = ie.extract(url)
  File "/usr/local/lib/python2.7/dist-packages/youtube_dl/extractor/common.py", line 275, in extract
    return self._real_extract(url)
  File "/usr/local/lib/python2.7/dist-packages/youtube_dl/extractor/generic.py", line 1364, in _real_extract
    raise UnsupportedError(url)
UnsupportedError: Unsupported URL: http://nick.walla.co.il/?w=//2578863
Repository: youtube-dl
Issue: Use file extension from --merge-output-format= when remuxing
Labels: request

When --add-metadata  or --embed-subs options are used file extension from --merge-output-format= should be used like it is used for muxing DASH videos.
Repository: go
Issue: x/tools/cmd/eg: panic
Labels: Tools,Refactoring

```
% cd $GOROOT/src/cmd

% cat t.go
package template

func before() string {
        return "foo"
}
func after() string {
        return "bar"
}

% eg -t t.go cmd/internal/gc
panic: runtime error: invalid memory address or nil pointer dereference
[signal 0xb code=0x1 addr=0x0 pc=0x4c7a9d]

goroutine 1 [running]:
golang.org/x/tools/refactor/eg.(*Transformer).matchExpr(0xc20e579000, 0x7f7ce0da9b28, 0xc210222a60, 0x7f7ce0da9b28, 0x0, 0xc2080f3f30)
        /usr/local/google/home/adonovan/got3/src/golang.org/x/tools/refactor/eg/match.go:68 +0x17fd
golang.org/x/tools/refactor/eg.(*Transformer).Transform.func1(0x6a7c80, 0xc2080f3f30, 0xd6, 0x0, 0x0, 0x0)
...
```
Repository: youtube-dl
Issue: Support for thegnomonworkshop
Labels: site-support-request

Can you please add support for http://www.thegnomonworkshop.com/
Repository: go
Issue: go/build: add the ability to list packages
Labels: NeedsInvestigation

This arose in the context of [CL 9001](https://go.dev/cl/9001), which @mdempsky wrote:

> Lastly, an alternative approach I was considering was looking into moving cmd/go's package list resolving into go/build (or an internal helper package).  Then cmd/api and deps_test.go could simply do something like ctxt.List("std") without needing to run cmd/go.

I have wanted this myself. I have a couple of (private) tools that shell out to `go list std` to get a listing of the stdlib's packages. It'd be nice not to have to do that.
Repository: rust
Issue: docs for Traits get duplicated because of different types
Labels: T-rustdoc,A-trait-system,C-feature-request,A-rustdoc-ui

[f32](http://doc.rust-lang.org/nightly/std/primitive.f32.html#) for example essentially supports traits like `Add` which have multiple copies which aren't duplicates but seem repetitive because they are essentially very similar:
#### Currently:

``` rust
impl Add<f32> for f32
    type Output = f32

    fn add(self, other: f32) -> f32

impl<'a> Add<f32> for &'a f32
    type Output = f32::Output

    fn add(self, other: f32) -> f32::Output

impl<'a> Add<&'a f32> for f32
    type Output = f32::Output

    fn add(self, other: &'a f32) -> f32::Output

impl<'a, 'b> Add<&'a f32> for &'b f32
    type Output = f32::Output

    fn add(self, other: &'a f32) -> f32::Output
```

It would be very nice if these could be combined so the repetition is less drastic. I've only come up with 2 options so far but maybe there are more.
#### Option A:

This is tricky to improve because all are different. One course would be to collapse all but the last by default which would make it look like the following block. This would also aid https://github.com/rust-lang/rust/issues/21660 . This makes all the types clear but only shows one method because all the methods will be the same.

``` rust
+impl Add<f32> for f32
+impl<'a> Add<f32> for &'a f32
+impl<'a> Add<&'a f32> for f32
-impl<'a, 'b> Add<&'a f32> for &'b f32
    type Output = f32::Output

    fn add(self, other: &'a f32) -> f32::Output
```
#### Option B:

Use some type of shorthand to include all options (like globbing). This should expand to specifics if desired I suppose.

``` rust
impl<.*> Add<.* f32> for .* f32
    type Output = f32.*

    fn add(self, other: .* f32) -> f32::Output
```

---

Option A looks the most practical. I'm trying to think of a better way to include only one but still allow the specifics to be examined but haven't come up with any better ideas.
Repository: rust
Issue: dead code (+ unused assignment, etc) warnings in macros do more harm than good
Labels: A-lints,P-low,A-macros,T-lang,C-bug

(imported from improperly closed bug #17427)

Consider the following code:

``` rust
fn g(x: u8) -> u8 {
    1 - x
}

fn main() {
    let mut x = 1u8;
    macro_rules! m {
        () => {{ x = g(x);
                 if x == 0 { x = 1; }
        }}
    }

    m!();
    g(1/x);
    m!();
}
```

[playpen](http://is.gd/tUWPua)

The `unused_assignments` lint fires from the expansion of the second occurrence of `m!()`. But if you follow the advice of the lint and remove the assignment, you discover that the assignment was in fact significant, because when you remove the assignment, the side effect from the _first_ occurrence of `m!()` is lost, and so the call to `g` divides by zero.

There are a number of different ways to handle this.
- This simplest would be to disable such lints for code with spans that are inside macro definitions, as was essentially the original suggestion of #17427 
- Another option would be to revise our strategy for such lints, and to warn about an unused assignment (or other dead code) for a given span _only if_ _ALL_ such occurrences trigger the warning.  I.e. as soon as one expansion proves that that code in the macro is useful, then you do not get any warning about it.
Repository: rust
Issue: Missing docs lint ineffectual in test builds
Labels: A-lints,C-bug

The `missing_docs` lint does not do anything in test builds. Minimal code example:

``` rust
#![cfg_attr(test, deny(missing_docs))]
```

To reproduce, make a new crate, replace `src/lib.rs` with the above code, and run `cargo test`. The command will run successfully. I would expect the command to report a “missing documentation for crate” compile error.

As for the cause, my wild guess is some sort of interaction between `cfg(test)` and which items are detected as public.
Repository: neovim
Issue: api/ui: externalize window layout
Labels: enhancement,api,ui,channels-rpc,ui-extensibility

In order to build a GUI client that does its own window management, we need Neovim to provide changes per window. It seems like today the server assumes the client has one big window/canvas and it tells what text to put where. This is not ideal if we want to create native windows. For e.g., let's say we have neovim.app (GUI for OSX) and user creates a vertical split to show the navigation tree on the left side. Today, the window edges are created using symbols like "|" because that's what the server is sending. Correct me if I am wrong. If we want to draw the window border ourselves using OSX frames, then we really need to know the text to place inside each window.

Here is the reference issue I had raised in neovim.app: https://github.com/rogual/neovim-dot-app/issues/73