sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: TypeScript
Issue: Contextual intellisense in Visual Studio
Labels: Suggestion,Help Wanted,API

Hi,

The most obvious case is for enums:

``` typescript
enum Foo {
    bar,
    allBarOne
}

function f(foo: Foo) {

    foo === // list Foo members here
}
```

Should also work for `boolean` (although such comparisons are not very common).

Another case is for `typeof` in the context of union types:

``` typescript
function f(foo: string|number) {

    typeof foo === // 'string', 'number'
}
```

One problem with this case is that an option for single vs double quotes would need to be provided.

And also `instanceof`

``` typescript
class Foo {}

function f(foo: Foo|Array<number>) {

    foo instanceof // Foo, Array<number>
}

```
Repository: neovim
Issue: configure ";" and "," to repeat more motions 
Labels: enhancement,needs:design

The ";" key is real nice to repeat f,t and T,F motions and save keystrokes.
### Problematic

In real life, us english is not the only spoken language and in many keyboard layouts, you have to leave aside keys like "[", "]", "`" and even sometimes ";" in favor of direct acces to dead keys or accentuated characters such as "é", "ç","à" and so on.
Part of the solution to this is to reclaim the accuented characters in normal mode by remaping them to the much useful bracket operators.

After doing this, your are still missing direct-one-keystroke-action keys because of the dead keys (vim registers nothing as nothing is sent to vim untill you type a second key).
### Solutions

Here comes the idea of key overloading. We could add a configuration option to overload the ";" and "," with more movements.
### What i have tried before

I tried a few plugins before but i found there are no elegant solutions; as soon as the users remaps one of the motion keys everything is screwed up. As far as i know, you have to implement a kind of proxy to register the last pressed motion key.
### Benefits and usage scenario

A user would add in his .vimrc something like:

_set motion_repeat_overload_options+=<C-D>,<C-U>,<C-E>,<C-Y>,"[[","]]", <PageUp>,<PageDown>,...._

and then any of those motions could be repeat by ";" and reversed by ","
### How does this help with the above problematic and why is it cool?
- More 2 keystrokes motion are replaced by a single keystroke.
- You can remap <Space> to ";" (IMHO the space key is the biggest and dumbest by default in normal mode. Maybe you use it in some clever way i have not thought of). Anyway, with this scheme you can even simulate a browser behavior. Say You hit the distant <PageDown> or <C-D> once and then you can read down by hitting <Space> again assuming 3+ pages.
- You can remap the ";" to something else (if you had direct acces to it) or simply make good use of the extra power of that key.
### Going a step further

Let's say you remap "," to <S-Space>, one could reverse the "cruising" direction by hitting the <S-Space> once, and then continue moving in that direction simply hitting <Space> again. Here you would save a second key on a normal layout. This direction toggling would of course be the subject of another vim option.

Any thoughts on this?

Best regards,
Repository: You-Dont-Know-JS
Issue: "async & performance": keep an eye on SharedArrayBuffer proposals
Labels: for second edition

May solidify into something that the second edition of "async & performance" should cover.

https://blog.mozilla.org/javascript/2015/02/26/the-path-to-parallel-javascript/

+@dherman
Repository: rust
Issue: Comparison operators have higher precedence than range operator `..`
Labels: E-hard,A-parser,P-low,I-needs-decision,T-lang,C-feature-request

 This has the effect of causing parse errors and other weirdness when trying to use a range literal in a comparison.

``` rust
1..2 == 1..2
```

gives us

> ```
> <input>:1:10: 1:12 error: expected one of `.`, `;`, `<eof>`, or an operator, found `..`
> <input>:1 1..2 == 1..2
> ```

Huh?  Okay, what about this?

``` rust
1..2 == 1
```

> ```
> <anon>:13:20: 13:31 error: start and end of range have incompatible types: expected `_`, found `bool` (expected integral variable, found bool) [E0308]
> <anon>:13 println!("{:?}", { 1..2 == 1 });
>                              ^~~~~~~~~~~
> ```

So it looks as though the comparison is being reduced before the range.

More fun:

``` rust
1..2 < (3..4)
```

> ```
> <anon>:13:27: 13:35 error: mismatched types:
> expected `_`,
>    found `core::ops::Range<_>`
> (expected integral variable,
>    found struct `core::ops::Range`) [E0308]
> <anon>:13 println!("{:?}", { 1..2 < (3..4) });
>                                    ^~~~~~~~
> ```

Never mind the fact that ranges don't implement (Partial)Ord -- the precedence is still wrong here, too.  Placing the parentheses on the first range instead of the second properly tells us

> ```
> <anon>:13:20: 13:30 error: binary operation `<` cannot be applied to type `core::ops::Range<_>`
> <anon>:13 println!("{:?}", { (1..2) < 3..4 });
>                             ^~~~~~~~~~
> ```

(although i'd argue that it should _also_ complain about mismatched types here, as well. ;)
Repository: go
Issue: liblink, cmd/ld: don't encode the instruction being relocated in Reloc.add
Labels: NeedsInvestigation

When I first implemented cgo for ARM, I made the wrong precedence to encode
the instruction itself in the relocation's addend field. It makes everything harder:

liblink must stuff the real addend into the instruction, put it in reloc.add, and then
in the linker, it must get the real addend out from the instruction, calculate the
real value, and stuff the value back into the instruction.

Additionally, it makes -S output unreadable.

```
rel 20+4 t=6 runtime.morestack_noctxt+9bfffffe
rel 40+4 t=6 runtime.duffzero+eb00005e
```

(Note: the 2nd line is calling into the middle of duffzero, but you can't tell
anything from the addend without some shifts and masks to figure out the
offset)
Compare this to the 6g -S output:

```
rel 16+4 t=4 runtime.morestack_noctxt+0
rel 37+4 t=4 runtime.duffzero+228
```

I suspect this is because in cmd/ld/lib.c, we always pass a zero val (the variable o)
to archreloc, instead, it really should pass the original value read from the symbol.

Should we correct this? so that archreloc is passed the real instrutions/data being
relocated in *val argument, and we place the real addend in Reloc.add field?
Repository: rust
Issue: Consider using `llvm.invariant.*` intrinsics for immutable memory
Labels: A-LLVM,I-slow,C-enhancement,A-codegen,T-compiler

Non-mutable memory that doesn't contain `UnsafeCell` can be marked `invariant`: http://llvm.org/docs/LangRef.html#llvm-invariant-start-intrinsic

http://llvm.org/docs/Frontend/PerformanceTips.html
Repository: youtube-dl
Issue: Add support for yahoo sub domains
Labels: site-support-request

Pls. add support for following yahoo sub domains.
https://hk.movies.yahoo.net/
https://tw.movies.yahoo.com
http://special.movies.yahoo.co.jp/detail/20150303380294/
http://movies.yahoo.co.jp/movie/%E3%82%B7%E3%82%A7%E3%83%95%E3%80%80%E4%B8%89%E3%83%84%E6%98%9F%E3%83%95%E3%83%BC%E3%83%89%E3%83%88%E3%83%A9%E3%83%83%E3%82%AF%E5%A7%8B%E3%82%81%E3%81%BE%E3%81%97%E3%81%9F/350453/trailer/?vid=26280
Repository: go
Issue: runtime: GC behavior in non-steady mode
Labels: compiler/runtime

Currently GC allows heap to grow to 2x of live memory during the previous GC. This can play badly with spiky memory usage. Consider that in steady state program has live set X. GC will allow heap to grow to 2X and then collect it back to X, and so on. Now consider that there is a 1.5X spike in memory usage. If GC happens _after_ the spike (when live set is again X), then GC will collect X memory (garbage generated during the spike) and set heap limit to 2X as before. Now if GC happens to happen _during_ the spike (when live set is 1.5X), then GC will collect only 0.5X and set heap limit to 3X.

Basically bad timing can increase maximum heap (RSS) by up to 2x.

Memory-constrained environments, like browsers, pay a great deal of attention to this problem. The idea is to set smarter GC threshold when heap grows/shrinks.

I did not work out a solution. But what I have in mind is: if heap grows, and especially if the next threshold (next_gc) will be larger than the current RSS (heap_sys - heap_released), then set next_gc to, say, heap_inuse \* (1 + GOGC/100) \* 0.75.
Since heap cannot grow all the time, this throttling is only temporal.

@rsc @RLH @aclements @randall77
Repository: nvm
Issue: sha1sum surprise
Labels: installing node: checksums,shell alias clobbering,pull request wanted

Unmet dependency on OSX.

```
-bash: sha1sum: command not found
```

Easy solve in the usual way.

```
brew install md5sha1sum
```

Perhaps a note in the readme?
Repository: go
Issue: syscall: Syscall9 for darwin/{arm,arm64} actually grubs up to 7 arguments
Labels: OS-Darwin

But a few system calls require 8 or 9 arguments.

```
// Actually Syscall7.
TEXT    ·Syscall9(SB),NOSPLIT,$0-52
```
Repository: rust
Issue: Incorrect / Inconsistent behavior of deref coercion with {}
Labels: A-type-system,T-compiler,C-bug,T-types

In this code, the commented-out lines fail to compile.

``` rust
struct Foo;

fn f(_: &Foo) {}

fn g(_: &&Foo) {}

fn main() {
    let x: &Foo = &Box::new(Foo);
    f(x);
    f(&Box::new(Foo));
    f(&(Box::new(Foo)));
    //f(&{Box::new(Foo)});
    let y: &Foo = &Box::new(Foo);
    g(&y);
    //g(&&Box::new(Foo));
    //g(&(&Box::new(Foo)));
    g(&{&Box::new(Foo)});
}
```

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

I believe that, among other things, `f(&{Box::new(Foo)});` should compile since `&{Box::new(Foo)}` has type `&Box<Foo>`, which is deref-coercible to `&Foo`.

Additionally, the behavior is so inconsistent that it is basically impossible to predict whether the other lines will compile without trying them.
Repository: go
Issue: x/build: trybot status shouldn't show FAIL for temp failures
Labels: Builders

The trybot status page shows "FAIL" even for temporary failures, like going over the quota.

It should have a different state, or just show idle instead.

Example screenshot:

![fail-quota](https://cloud.githubusercontent.com/assets/2621/6487003/87c77e3c-c243-11e4-9d40-d34f1767bd96.png)

/cc @adg
Repository: TypeScript
Issue: Assignment of string literal indexed enum member passes compilation but results in invalid javascript
Labels: Bug,Help Wanted

The following TypeScript:

```
const enum MyEnum {This,That};
MyEnum["That"] = 1;
```

compiles down to the following javascript:

```
;
1 /* "That" */ = 1;
```

This holds true for standard `enum`s as well, a `const enum` was just a more succinct example.
While I'm not sure why anyone would want to do this, it does seem that valid TypeScript should compile to valid javascript, and this will obviously cause a runtime error.
Repository: TypeScript
Issue: Allow different syntactic elements have different indentation
Labels: Suggestion,Help Wanted

Original issue: [[st3] keeps indenting by 4 ws when typing](https://github.com/Microsoft/ngconf2015demo/issues/2)
Repository: go
Issue: cmd/pprof: duplicate listings in weblist report
Labels: compiler/runtime

When using the interactive "weblist" command, pprof generates multiple reports, one per source file, even though each report contains the same data accumulated across all sources.

E.g.,

```
go build -gcflags="-cpuprofile=$PWD/cpuprofile.1" -a runtime
cp cpuprofile.1 cpuprofile.2
go tool pprof $(go env GOTOOLDIR)/6g cpuprofile.1 cpuprofile.2
```

Then try running "list main.main" and "weblist main.main".  Notice that weblist shows the same data, but twice because of the two source files.

When you have a lot of source files (e.g., 2000+ from repeatedly building the entire standard library), this makes using weblist impractical, because it constructs the entire report in memory first.  (Currently I'm resorting to an ad hoc tool to concatenate CPU profile data.)
Repository: youtube-dl
Issue: Ustream not download
Labels: bug

C:\Distribute\Soft\youtube-d>youtube-dl -o test.flv "http://www.ustream.tv/
embed/18742830?v=3&wmode=direct" --verbose
[debug] System config: []
[debug] User config: []
[debug] Command-line args: ['-o', 'test.flv', 'http://www.ustream.tv/embed/
18742830?v=3&wmode=direct', '--verbose']
[debug] Encodings: locale cp1251, fs mbcs, out cp866, pref cp1251
[debug] youtube-dl version 2015.03.03.1
[debug] Python version 2.7.8 - Windows-7-6.1.7601-SP1
[debug] exe versions: none
[debug] Proxy map: {}
[ustream] 18742830: Downloading webpage
ERROR: Unable to extract desktop_video_id; please report this issue on http
s://yt-dl.org/bug . Make sure you are using the latest version; type  youtu
be-dl -U  to update. Be sure to call youtube-dl with the --verbose flag and
 include its complete output.
Traceback (most recent call last):
  File "youtube_dl\YoutubeDL.pyo", line 648, in extract_info
  File "youtube_dl\extractor\common.pyo", line 275, in extract
  File "youtube_dl\extractor\ustream.pyo", line 38, in _real_extract
  File "youtube_dl\extractor\common.pyo", line 557, in _html_search_regex
  File "youtube_dl\extractor\common.pyo", line 547, in _search_regex
RegexNotFoundError: Unable to extract desktop_video_id; please report this
issue on https://yt-dl.org/bug . Make sure you are using the latest version
; type  youtube-dl -U  to update. Be sure to call youtube-dl with the --ver
bose flag and include its complete output.
Repository: go
Issue: cmd/internal/obj/arm64: moves that use C_BITCON and C_ADDCON don't work
Labels: NeedsInvestigation

Replaces 4ad/go#68.

Issue #10108 is related.
Repository: go
Issue: cmd/internal/obj/arm64: floating point immediates are loaded through indirection
Labels: NeedsInvestigation

ARM64 is 64 bit, we gain nothing by coalescing float immediates as addresses are 64-bit.

Related to issue #10108 and issue #10112.
Replaces 4ad/go#49.
Repository: neovim
Issue: suspend/resume: check changed files
Labels: bug

In vim, when I suspend with ctrl+z, change something, and then come back, vim will offer me options about reloading files. Neovim simply does not; I have to do :e to reload a file. Is this a bug?
Repository: go
Issue: x/mobile: font.Default cannot be parsed by freetype-go
Labels: mobile

font.Default loads kCTFontSystemFontType, which does not parse with the error:

```
    freetype: unsupported TrueType feature: cmap encoding
```

The Monospace font (kCTFontUserFixedPitchFontType) works.
Repository: TypeScript
Issue: Support for tabs in language service formatter.
Labels: Suggestion,Help Wanted,API

The formatter described in the link below currently doesn't seem to offer a way to indent by using tabs. 
https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#pretty-printer-using-the-ls-formatter

Could that be added?
Thanks!
Repository: You-Dont-Know-JS
Issue: "async & performance": slim down general explanations of iterators/generators
Labels: for second edition

Now that "ES6 & Beyond" is going to fully cover iterators and generators, perhaps it'd be appropriate to slim down ch4 a fair bit.

For example, we could strip out some of the nuances around `yield *`, error propagation, etc.These are all interesting and useful details, but they're not entirely needed to understand using generators for async flow control. I can just point to the "ES6 & Beyond" title for more info.
Repository: go
Issue: x/tools/cmd/eg: support ... package expansion
Labels: NeedsInvestigation

``` bash
$ eg -w -t t.go cmd/...
cannot find package "cmd/..." in any of:
```

It'd be nice if eg supported `...` the way that the `go` tool does.

I'm happy to do the legwork if desired.
Repository: go
Issue: x/tools/cmd/eg: allow multiple refactorings in a single template
Labels: NeedsInvestigation

While working on `Node` refactoring leading up to [CL 7360](https://go.dev/cl/7360), I found myself applying 8 different templates (one per relevant field) sequentially. It would be nicer to use--and I think faster to execute--to apply them all in a single pass.

The template could look like a sequence of alternating pairs of `before` and `after`:

```go
package P

func before(s string) error { return fmt.Errorf("%s", s) }
func after(s string)  error { return errors.New(s) }

func before(msg string) { log.Fatalf("%s", msg) }
func after(msg string)  { log.Fatal(msg) }
```

The semantics would be that the output would be equivalent to applying each of the pairs sequentially as a template.

Thoughts? I'm happy to help with implementation.
Repository: youtube-dl
Issue: https://www.tvnz.co.nz/worlds-worst/s1-ep1-video-6251831 fails to download
Labels: site-support-request

I'm happy to run more tests if need be. Would be nice to have tvnz.co.nz videos work with ytdl :)

$ TZ="NZST" youtube-dl 'https://www.tvnz.co.nz/worlds-worst/s1-ep1-video-6251831' --verbose
[debug] System config: []
[debug] User config: []
[debug] Command-line args: ['https://www.tvnz.co.nz/worlds-worst/s1-ep1-video-6251831', '--verbose']
[debug] Encodings: locale UTF-8, fs UTF-8, out UTF-8, pref UTF-8
[debug] youtube-dl version 2015.03.09
[debug] Python version 2.7.9 - Linux-3.16.0-4-amd64-x86_64-with-debian-8.0
[debug] exe versions: rtmpdump 2.4
[debug] Proxy map: {}
[generic] s1-ep1-video-6251831: Requesting header
WARNING: Falling back on generic information extractor.
[generic] s1-ep1-video-6251831: Downloading webpage
[generic] s1-ep1-video-6251831: Extracting information
ERROR: Unsupported URL: https://www.tvnz.co.nz/worlds-worst/s1-ep1-video-6251831
Traceback (most recent call last):
  File "/home/justa/bin/youtube-dl/youtube_dl/extractor/generic.py", line 814, in _real_extract
    doc = parse_xml(webpage)
  File "/home/justa/bin/youtube-dl/youtube_dl/utils.py", line 1521, 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: mismatched tag: line 96, column 2
Traceback (most recent call last):
  File "/home/justa/bin/youtube-dl/youtube_dl/YoutubeDL.py", line 649, in extract_info
    ie_result = ie.extract(url)
  File "/home/justa/bin/youtube-dl/youtube_dl/extractor/common.py", line 275, in extract
    return self._real_extract(url)
  File "/home/justa/bin/youtube-dl/youtube_dl/extractor/generic.py", line 1283, in _real_extract
    raise UnsupportedError(url)
UnsupportedError: Unsupported URL: https://www.tvnz.co.nz/worlds-worst/s1-ep1-video-6251831

In Firefox, this site requires the timezone to be correctly set, or an error along the lines "incorrect timezone" is displayed where the video player would normally appear.
Repository: youtube-dl
Issue: Please add support for godvine.com
Labels: site-support-request

Can not download this video:
http://www.godvine.com/Return-Of-Lost-Love-Letter-Brings-Tears-For-WWII-Vet-6931.html
Repository: youtube-dl
Issue: Unable to download gamingcx.com's streaming videos.
Labels: site-support-request

From http://www.gamingcx.com/ ...

Example:
$ youtube-dl -v http://www.gamingcx.com/2015/03/gamecenter-cx-episode-126-super-spy.html
[debug] System config: []
[debug] User config: []
[debug] Command-line args: ['-v', 'http://www.gamingcx.com/2015/03/gamecenter-cx-episode-126-super-spy.html']
[debug] Encodings: locale UTF-8, fs UTF-8, out UTF-8, pref UTF-8
[debug] youtube-dl version 2015.03.09
[debug] Python version 2.7.3 - Linux-3.2.0-4-amd64-x86_64-with-debian-7.8
[debug] exe versions: avconv 1.0.10, avprobe 1.0.10, ffmpeg 1.0.10, ffprobe 1.0.10, rtmpdump 2.4
[debug] Proxy map: {}
[generic] gamecenter-cx-episode-126-super-spy: Requesting header
WARNING: Falling back on generic information extractor.
[generic] gamecenter-cx-episode-126-super-spy: Downloading webpage
[generic] gamecenter-cx-episode-126-super-spy: Extracting information
ERROR: Unsupported URL: http://www.gamingcx.com/2015/03/gamecenter-cx-episode-126-super-spy.html
Traceback (most recent call last):
  File "/usr/bin/youtube-dl/youtube_dl/extractor/generic.py", line 814, in _real_extract
    doc = parse_xml(webpage)
  File "/usr/bin/youtube-dl/youtube_dl/utils.py", line 1521, in parse_xml
    tree = xml.etree.ElementTree.XML(s.encode('utf-8'), **kwargs)
  File "/usr/lib/python2.7/xml/etree/ElementTree.py", line 1301, in XML
    parser.feed(text)
  File "/usr/lib/python2.7/xml/etree/ElementTree.py", line 1643, in feed
    self._raiseerror(v)
  File "/usr/lib/python2.7/xml/etree/ElementTree.py", line 1507, in _raiseerror
    raise err
ParseError: not well-formed (invalid token): line 13, column 130
Traceback (most recent call last):
  File "/usr/bin/youtube-dl/youtube_dl/YoutubeDL.py", line 649, in extract_info
    ie_result = ie.extract(url)
  File "/usr/bin/youtube-dl/youtube_dl/extractor/common.py", line 275, in extract
    return self._real_extract(url)
  File "/usr/bin/youtube-dl/youtube_dl/extractor/generic.py", line 1283, in _real_extract
    raise UnsupportedError(url)
UnsupportedError: Unsupported URL: http://www.gamingcx.com/2015/03/gamecenter-cx-episode-126-super-spy.html

Thank you in advance. :)
Repository: rust
Issue: Move metadata out of dylibs
Labels: C-enhancement,A-metadata

Crate metadata constitute [a significant proportion](https://github.com/rust-lang/rust/issues/21482) of Rust dylibs.   It's only needed for compilation; otherwise it just bloats up the size of Rust programs, and, unlike debug info, can't even be easily stripped.
In the case of dylibs, we could move metadata out into a companion file (say, `<library>.rsmd`), which developers may choose to not distribute if linking to the library is not expected (for example, Rust's own stage0 binaries).
I think this approach would be very congruent with Rust's philosophy of zero cost abstractions.  The only downside I can see, is that distribution of dylibs as _libraries_ would become slightly less convenient as there would be two files instead of one.
Repository: TypeScript
Issue: Allow wrapped values to be used in place of primitives.
Labels: Suggestion,Needs Proposal

``` ts
class NumberWrapper {
    constructor(private value: number) {}
    valueOf(): number { return this.value; }
}

var x = new NumberWrapper(1);

// The right-hand side of an arithmetic operation 
// must be of type 'any', 'number' or an enum type.
console.log(2 + x);
```

It would be nice if an arithmetic operation could allow using the wrapped number because it's `valueOf()` method returns the expected primitive type.

This can be generalized to: if type `T` is expected, then a value that implements the following interface can be used.

``` ts
interface Wrapped<T> {
    valueOf(): T;
}
```