sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: youtube-dl
Issue: [REQUEST] --write-single-json argument
Labels: request

I think it would be helpful for there to be a version of --dump-single-json that wrote the progress to the STDOUT like normal downloading operations, but wrote the JSON file to disk like --write-info-json. This would essentially be --write-info-json for playlists and channels. I am currently writing a website that will use youtube-dl for its youtube video downloading, and video/playlist/channel information gathering. Having this option will allow me to monitor the progress of the information updates easily, which i cannot do with --dump-single-json.

Thanks,

John Lage
Repository: rust
Issue: Separate unstable feature errors from other lints in output
Labels: A-lints,T-compiler,C-feature-request

When an unstable feature is used in a crate, and an error is emitted, it will sometimes (always?) be emitted before other lints (e.g. unused_*, dead_code). This causes the compilation error to be functionally lost in the compile output.

Example:

```
warning: ignoring specified output filename because multiple outputs were requested
Core/metadevs/storage.rs:250:32: 250:58 error: use of unstable library feature 'step_by': recent addition
Core/metadevs/storage.rs:250            for (blk,dst) in (first .. ).step_by(block_step as u64).zip( dst.chunks_mut( block_step * block_size ) )
                                                                     ^~~~~~~~~~~~~~~~~~~~~~~~~~
Core/metadevs/storage.rs:250:32: 250:58 help: add #![feature(step_by)] to the crate attributes to enable
Core/lib/mod.rs:9:5: 9:18 warning: unused import, #[warn(unused_imports)] on by default
Core/lib/mod.rs:9 use lib::mem::Box;
                      ^~~~~~~~~~~~~
Core/lib/mem/rc.rs:8:20: 8:31 warning: unused import, #[warn(unused_imports)] on by default
Core/lib/mem/rc.rs:8 use core::atomic::{AtomicUsize,Ordering};
```

(An excerpt from compiling a kernel, there are a lot of warnings due to incomplete/unused APIs)
Repository: youtube-dl
Issue: bestvideo doesn't always select best video
Labels: bug

For this video:
https://www.youtube.com/watch?v=InxwGZ_PgC4
`-f bestvideo[ext=mp4]+bestaudio` downloads 240p version (while there is 1080p available)

```
$ youtube-dl -F https://www.youtube.com/watch?v=InxwGZ_PgC4
[youtube] InxwGZ_PgC4: Downloading webpage
[youtube] InxwGZ_PgC4: Extracting video information
WARNING: video doesn't have subtitles
[youtube] InxwGZ_PgC4: Downloading DASH manifest
[info] Available formats for InxwGZ_PgC4:
format code  extension  resolution note
140          m4a        audio only DASH audio  129k , m4a_dash container, aac  @128k (44100Hz), 4.20MiB
171          webm       audio only DASH audio  138k , audio@128k (44100Hz), 4.19MiB
141          m4a        audio only DASH audio  256k , m4a_dash container, aac  @256k (44100Hz), 8.35MiB
134          mp4        640x360    DASH video   28k , 30fps, video only, 766.85KiB
242          webm       426x240    DASH video   29k , 1fps, video only, 859.75KiB
135          mp4        854x480    DASH video   39k , 30fps, video only, 1.05MiB
243          webm       640x360    DASH video   44k , 1fps, video only, 1.26MiB
136          mp4        1280x720   DASH video   56k , 30fps, video only, 1.59MiB
160          mp4        256x144    DASH video   64k , 15fps, video only, 1.15MiB
244          webm       854x480    DASH video   69k , 1fps, video only, 1.90MiB
137          mp4        1920x1080  DASH video   83k , 30fps, video only, 2.37MiB
133          mp4        426x240    DASH video  111k , 30fps, video only, 2.13MiB
247          webm       1280x720   DASH video  118k , 1fps, video only, 2.98MiB
248          webm       1920x1080  DASH video  176k , 1fps, video only, 4.36MiB
17           3gp        176x144    
36           3gp        320x240    
5            flv        400x240    
43           webm       640x360    
18           mp4        640x360    
22           mp4        1280x720   (best)
```
Repository: TypeScript
Issue: TSServer: 'quickInfo' request should return symbol display parts as completion does
Labels: Suggestion,Help Wanted,Effort: Moderate,VS Code Tracked

That would allow for a nice formatting in the UI and makes the overall API more consistence.
Repository: go
Issue: net: concurrent Accept-Close with no timeout on TCPListener defers closing underlying socket
Labels: NeedsInvestigation

Go version:  go1.4.2
OS: Linux 3.13 x86_64

The following test demonstrates what I consider a bug:

``` go
package foo

import (
    "log"
    "net"
    "testing"
)

const addr = "127.0.0.1:12345"

func TestXxx(t *testing.T) {
    for i := 0; i < 100000; i++ {
        log.Printf("Iteration %d", i+1)
        l, err := net.Listen("tcp4", addr)
        if err != nil {
            t.Fatalf("Failed to listen on %s: %v", addr, err)
        }
        go func(l net.Listener) {
            for {
                _, err := l.Accept()
                if err != nil {
                    return
                }
            }
        }(l)
        if err := l.Close(); err != nil {
            t.Fatalf("Failed to close server: %v", err)
        }
    }
}
```

Briefly, within a loop it Listens on tcp port 12345, invokes a goroutine that calls Accept on the listener, and then Closes the listener. My expectation was that this would always pass regardless of scheduler behavior or number of loop iterations as I expected Close() would only return once the underlying socket is no longer in use. 

Instead what I see is that it will sometimes pass, but often fails on the net.Listen call of subsequent loop iterations with an error that the address is already in use. I believe I understand the cause of the failure. netFD underlies the TCPListener and it's a reference counted object. A goroutine blocked on Accept will increment the reference count. Close() flips a flag on netFD to indicate the socket is considered closed which will make other netFD operations like Accept return errors indicating the socket is closed. The underlying OS socket is only closed once the reference count for the netFD has reached zero.

The end result is that an OS socket is only closed after TCPListener.Close() is invoked AND all goroutines that are blocked in TCPListener.Accept() are scheduled and return the expected error condition. It seems like more intuitive behavior would be for TCPListener.Close() to immediately close the underlying OS socket, and goroutines blocked in TCPListener.Accept() to return errors whenever they were next scheduled/run.
Repository: TypeScript
Issue: Port from old compiler code to emit compilation flags into the source map
Labels: Suggestion,Help Wanted

The 1.0 (or 1.1) compiler emitted the compilation flags into the source map. We added this for hypothetical tooling scenarios, where browser tools could trigger a simple recompilation of a file discovered by a source map, in the case where it was live edited.

This is not a high priority as those scenarios aren't currently planned, but perhaps it would be a simple port of work already done.
Repository: TypeScript
Issue: Port from old compiler code to emit identifier renames into source map
Labels: Bug

The previous (1.0 or 1.1) compiler emitted a table of identifier renames into the source map. Principally this was for renames of "this" into "_this". The IE developer tools used this to make this scenario work
- User is debugging Typescript in the IE tools -- Typescript was discovered by source map
- User hovers over "this" at a point where Typescript had renamed it. In other words, in this context they expect to see the value of "_this" not "this".
- The debugger looks up this source code location in a table in the source map to determine that at this point "this" was renamed and shows a tooltip for the value of "_this" instead. (It also put a red dot in the watches window)

This feature was lost when the compiler was rewritten because the table is no longer emitted into the source map. We'd like it back so that our feature works again..
Repository: rust
Issue: rustdoc: `Methods from Deref<Target = T<U>>` is imprecise (contains false positives)
Labels: T-rustdoc,A-trait-system,C-bug

``` rust
use std::ops::Deref;

pub struct Foo<T>(T);
impl Foo<i32> {
    pub fn get_i32(&self) -> i32 { self.0 }
}
impl Foo<u32> {
    pub fn get_u32(&self) -> u32 { self.0 }
}
pub struct Bar(Foo<i32>);
impl Deref for Bar {
    type Target = Foo<i32>;
    fn deref(&self) -> &Foo<i32> {
        &self.0
    }
}
```

The `Methods from Deref` for `Bar` will contain both `get_i32` and `get_u32`, but should only contain `get_i32`.

[Image](http://i.imgur.com/bUEO5pb.png)
Repository: nvm
Issue: bash --login -c 'nvm list' does not work while it should
Labels: installing nvm: profile detection

I wonder how to run nvm/node/npm in a login shell mode. For some reason `bash --login -c 'nvm list'` does not work, while the same thing with rvm works.

This issue is cross-referenced to https://github.com/rocketeers/rocketeer/issues/507
Here is some additional commands output:

```
user@123:~$ rvm list

rvm rubies

   ruby-2.0.0-p594 [ x86_64 ]
   ruby-2.1.3 [ x86_64 ]
=* ruby-2.1.5 [ x86_64 ]

# => - current
# =* - current && default
#  * - default
```

```
user@123:~$ nvm list
->  v0.10.33
      system
default -> stable (-> v0.10.33)
stable -> 0.10 (-> v0.10.33) (default)
```

```
user@123:~$ bash --login -c 'nvm list'
bash: nvm: command not found
```

```
user@123:~$ bash --login -c 'rvm list'

rvm rubies

   ruby-2.0.0-p594 [ x86_64 ]
   ruby-2.1.3 [ x86_64 ]
=* ruby-2.1.5 [ x86_64 ]

# => - current
# =* - current && default
#  * - default
```

NVM was installed with the following commands:

```
curl https://raw.githubusercontent.com/creationix/nvm/v0.18.0/install.sh | bash

source ~/.nvm/nvm.sh

nvm install stable

nvm use stable

nvm alias default stable
```

ps. the latest version of nvm has the same issue.
Repository: go
Issue: x/net/html: void element <link> has child nodes
Labels: NeedsInvestigation

The following program crashes:

``` go
package main

import (
    "golang.org/x/net/html"
    "io/ioutil"
    "strings"
)

func main() {
    nodes, err := html.ParseFragment(strings.NewReader("<svg ><link >0"), nil)
    if err != nil {
        return
    }
    for _, n := range nodes {
        if err := html.Render(ioutil.Discard, n); err != nil {
            panic(err)
        }
    }
}
```

```
panic: html: void element <link> has child nodes
```

Render must be able handle Parse output. Or otherwise Parse must not accept the input as valid.

On commit 6f62f426de90c0ed6a55207b51476115fcb17237.
Repository: go
Issue: runtime: should traceTickDiv be different for different architectures?
Labels: compiler/runtime

It's documented that "Timestamps in trace are cputicks/traceTickDiv. “ and
that "64 is somewhat arbitrary (one tick is ~20ns on a 3GHz machine)."

That is ok for x86 cpus, where cputicks increment by 1 each cpu clock cycle,
but on ppc64x, the cputicks might be increasing only at bus frequency.
(For example, on PowerPC G5, it's increasing at about 300MHz), so if we're
still using traceTickDiv=64 there, then each trace tick is not ~20ns, but ~200ns.

Will that be a concern?

/cc @dvyukov
Repository: thefuck
Issue: Doesn't handle pipes
Labels: enhancement,help wanted

It looks like `fuck` doesn't handle pipes well. If I try to do this in Bash:

``` bash
$ pss -ef | grep foo
-bash: pss: command not found
$ fuck
ps -ef | grep foo
ps: illegal argument: |
usage: ps [-AaCcEefhjlMmrSTvwXx] [-O fmt | -o fmt] [-G gid[,gid...]]
          [-g grp[,grp...]] [-u [uid,uid...]]
          [-p pid[,pid...]] [-t tty[,tty...]] [-U user[,user...]]
       ps [-L]
```

It looks like the command is executed in the wrong way, it seems like it's trying to execute it as a single command, instead of treating it as a line of input with potentially multiple commands.
Repository: TypeScript
Issue: Add Support for design-time decorators
Labels: Suggestion,In Discussion

Now that decorators are supported in TypeScript (#2249), consider adding support for ambient/design-time-only decorators:

Ambient decorators can be an extensible way to declare properties on or associate special behavior to declarations; design time tools can leverage these associations to produce errors or produce documentation. For example:
#### Use cases:
- Deprecated/Obsolete, to support warning on use of specific API’s:

``` ts
interface JQuery {  
    /**  
     * A selector representing selector passed to jQuery(), if any, when creating the original set.  
     * version deprecated: 1.7, removed: 1.9  
     */  
    @@deprecated("Property is only maintained to the extent needed for supporting .live() in the jQuery Migrate plugin. It may be removed without notice in a future version.", false)  
    selector: string;  
}
```
- Suppress linter warning:

``` ts
@@suppressWarning("disallow-leading-underscore")   
function __init() {  
}
```
#### Proposal

Design-time (Ambient) decorators are:
- ambient functions
- have a special name starting with "@"
- are not emitted in output JS code, but persisted in .d.ts outputs.

Application
- Applying a design-time can only accept constant values. Variables would not be observable by the compiler at compile time. Here is the set of possible values:
  - string literal,
  - number literal,
  - regexp literal,
  - true keyword,
  - false keyword,
  - null keyword,
  - undefined symbol,
  - const enum members,
  - array literals of one of the previous kinds,
  - object literal with only properties with values of one of the previous kinds
Repository: go
Issue: go/printer: force multiline literal to end with } on line by itself
Labels: NeedsInvestigation

- What version of Go are you using (go version)?
  `go version go1.4.1 linux/amd64`
- What operating system and processor architecture are you using?
  `Linux` on `amd64`
  - What did you do?
    running `gofmt -w` on code at http://play.golang.org/p/588xSKFhg1
- What did you expect to see?
  I expect to see  `b: 2` then comma, newline, closing brace/curly bracket as in:

``` go
package main

type A struct {
    a int
    b int
}

func main() {
    x := A{
        a: 1,
        b: 2,
    }
}
```
- What did you see instead?
  I did see a closing curly brace hugging the field value `2` of `A.b` as in:

``` go
package main

type A struct {
    a int
    b int
}

func main() {
    x := A{
        a: 1,
        b: 2}
}
```
Repository: kubernetes
Issue: Create per-object sequence number and report last value seen in status of each object
Labels: priority/backlog,area/api,sig/api-machinery,sig/apps,lifecycle/frozen

It's hard to write race-free clients without knowing whether controllers have observed mutations. Controllers should report the most recent resourceVersion seen in status when they post status. Just returning it in responses (#1184) is not sufficient.

An example problem:
https://github.com/GoogleCloudPlatform/kubernetes/pull/7321/files#r29097446
Repository: go
Issue: go/parse: confusing error message caused by stray comma in struct field
Labels: NeedsInvestigation

Hit "Format" on http://play.golang.org/p/QX0D-qyFwJ

``` go
package main

type T struct {
    a, int
}
```

Result: "prog.go:4:2: expected anonymous field"
Repository: kubernetes
Issue: Make rc manager more responsive to unexpected adds/deletes
Labels: area/controller-manager,priority/awaiting-more-evidence,sig/apps,lifecycle/frozen

Currently the rc manager will not respond to unexpected pod creates/deletes till all the creates/deletes it has sent to the apiserver have been observed by the reflector, or a timeout occurs. There are situations where we could land up with:
- Rc goes to sleep till it sees 1 add
- One pod gets deleted <- we want the rc to wake up here
- One pod is created <- rc really wakes up here

The easy way around this is to use the expectations of the rc to compute how many extra pods to create even when the watch hasn't observed the adds/dels. Eg:

```
observed + (expected add - expected dels) - status.Replicas
```

The tricky bit here is locking, since currently the expectations are incremented/decremented via atomic operations. This will matter more in hostile netwoks with high lag, where the watch may not transmit pod add/dels for a while.
Repository: rust
Issue: Uninhabited-ness isn't propagated through nesting
Labels: A-type-system,T-lang,C-feature-request,T-types

This compiles:

``` rust
enum Void {}

fn foo(v: &Void) -> ! {
    match *v {
    }
}

fn main() {}
```

But this doesn't:

``` rust
enum Void {}

fn foo(v: &Void) -> ! {
    match v {
    }
}

fn main() {}
```

```
<anon>:4:5: 5:6 error: non-exhaustive patterns: type &Void is non-empty [E0002]
<anon>:4     match v {
<anon>:5     }
<anon>:4:5: 5:6 help: pass `--explain E0002` to see a detailed explanation
error: aborting due to previous error
playpen: application terminated with error code 101
```

but an instance of `&Void` can't exist any more than `Void` can.

Same deal with e.g. `struct Foo(Void)`.
Repository: rust
Issue: Rustdoc considers *const T and *mut T different
Labels: T-rustdoc,C-bug

https://doc.rust-lang.org/core/ptr/struct.Unique.html

`is_null`, `offset`, and `as_ref` are listed twice. This is confusing and makes the HTML invalid. I'm not sure what's going on here.
Repository: rust
Issue: Add opensearch support to doc.rust-lang.org 
Labels: T-rustdoc,C-enhancement,A-rustdoc-search

[Opensearch](http://www.opensearch.org/Home) is a common API to query search engine. It is for instanced used to add search engines to the firefox search bar and to chrome.

It would be nice if doc.rust-lang.org supported opensearch to enable doc search directly from firefox.

cc @steveklabnik
Repository: go
Issue: build: move list of builder types mostly into code
Labels: NeedsInvestigation

https://github.com/golang/go/wiki/DashboardBuilders is manually maintained and sometimes goes stale.

I think we should move the descriptions of all new-style coordinator-managed builders into dashboard/builders.go (into a new description field) and then add a new URL like:

   http://farmer.golang.org/buildertypes

... which lists them.

Then the wiki page can link to /buildertypes primarily and have a much smaller augmented list, which will eventually be zero.

/cc @crawshaw
Repository: rust
Issue: Associated const references using UFCS can bypass `check_static_recursion`
Labels: A-type-system,A-associated-items,T-compiler,C-bug,T-types

Currently, `check_static_recursion` is run after `resolve`, but before `typeck`. This made sense before, because after `resolve` it was possible to determine which constants referenced one another, and running before `typeck` ensured that we don't fall into an infinite loop during type checking. However, when referencing an associated constant with some UFCS forms, we can't resolve the constant until `typeck`, meaning that `check_static_recursion` can't always tell when a recursive definition is present. On top of that, this check is not currently working right even for inherent impls, where it should be possible to discover a problem ahead of `typeck` running.

A set of test cases:

``` rust
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

#![feature(associated_consts)]

trait Foo {
    const BAR: u32;
}

// Check for recursion involving references to trait-associated const.

const TRAIT_REF_BAR: u32 = <GlobalTraitRef>::BAR; //~ ERROR E0265

struct GlobalTraitRef;

impl Foo for GlobalTraitRef {
    const BAR: u32 = TRAIT_REF_BAR; //~ ERROR E0265
}

// Check for recursion involving references to impl-associated const.

const IMPL_REF_BAR: u32 = GlobalImplRef::BAR; //~ ERROR E0265

struct GlobalImplRef;

impl GlobalImplRef {
    const BAR: u32 = IMPL_REF_BAR; //~ ERROR E0265
}

// Check for recursion involving references to trait-associated const default.

trait FooDefault {
    const BAR: u32 = DEFAULT_REF_BAR; //~ ERROR E0265
}

const DEFAULT_REF_BAR: u32 = <GlobalDefaultRef>::BAR; //~ ERROR E0265

struct GlobalDefaultRef;

impl FooDefault for GlobalDefaultRef {}

fn main() {}
```

The above cases should all fail in the recursion check, but they all compile successfully! If any of the constants are actually used in a context that requires the compiler to evaluate them, there will be an ICE (specifically, the compiler enters an infinite loop that ends up blowing the stack).

Update
playground link: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=76e9edaf2827806e18a557f37bc930ea

<!-- TRIAGEBOT_START -->

<!-- TRIAGEBOT_ASSIGN_START -->
This issue has been assigned to @Daniel-Worrall via [this comment](https://github.com/rust-lang/rust/issues/24949#issuecomment-620255368).
<!-- TRIAGEBOT_ASSIGN_DATA_START$${"user":"Daniel-Worrall"}$$TRIAGEBOT_ASSIGN_DATA_END -->

<!-- TRIAGEBOT_ASSIGN_END -->
<!-- TRIAGEBOT_END -->
Repository: rust
Issue: method call fails to upcast trait objects, resulting in overlong borrows
Labels: A-type-system,A-lifetimes,P-low,T-lang,C-bug,T-types,A-trait-objects

@SimonSapin encountered an error in servo that I reduced to the following test case http://is.gd/w7HPbJ:

``` rust
pub trait Flow {
    fn foo(&self);
}

pub trait LayoutDamageComputation {
    fn compute_layout_damage(self);
}

impl<'a> LayoutDamageComputation for &'a mut (Flow + 'a) {
    fn compute_layout_damage(self) {
        self.compute_layout_damage();
        self.compute_layout_damage();
    }
}

fn main() { }
```

The errors you get are:

```


<anon>:12:9: 12:13 error: cannot borrow `*self` as mutable more than once at a time
<anon>:12         self.compute_layout_damage();
                  ^~~~
<anon>:11:9: 11:13 note: previous borrow of `*self` occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `*self` until the borrow ends
<anon>:11         self.compute_layout_damage();
                  ^~~~
<anon>:13:6: 13:6 note: previous borrow ends here
<anon>:10     fn compute_layout_damage(self) {
<anon>:11         self.compute_layout_damage();
<anon>:12         self.compute_layout_damage();
<anon>:13     }
              ^
error: aborting due to previous error
playpen: application terminated with error code 101
Program ended.
```

There are various possible workarounds:
1. http://is.gd/frmXsT
2. http://is.gd/FgrEfZ

but the gist (no pun intended, I kill me) is to ensure a coercion from `self` to `&mut Flow`, which allows us to upcast the lifetime in the trait object. The easiest way to do that is to convert the recursive call `self.compute_layout_damage()` to UFCS form `<&mut Flow as ComputeLayoutDamage>::compute_layout_damage(self)`. Method dispatch ought to automatically performing this upcast, I think, must as we auto-reborrow here and there.

cc @pnkfelix who experimented on this with me
Repository: youtube-dl
Issue: Extending DASH Stream Merging Support to "Clients"
Labels: request

To avoid hijacking #2124

Can youtube-dl be implemented to allow DASH manifest "pre-demuxing" of some sort in other applications? I know mpv does this somehow but I'm more interested in the youtube-dl side of things as the mpv side of things is offtopic.
Repository: rust
Issue: Cannot macro_use a macro that uses an internal macro
Labels: A-macros,C-feature-request

For instance, trying to use the [log](https://crates.io/crates/log) crate:

``` rust
#[macro_use(debug)] extern crate log;

fn main() {
    debug!("hello");
}
```

Errors with:

```
<log macros>:4:1: 4:4 error: macro undefined: 'log!'
<log macros>:4 log ! ( $ crate:: LogLevel:: Debug , $ ( $ arg ) * ) ; )
```

If you import the log macro also, all is well. In this case, that's possible. However, a crate that has an internal macro for sanity, and not to be exported, is stuck.
Repository: youtube-dl
Issue: support for ampya?
Labels: site-support-request

here a link to test http://www.ampya.com/Tocotronic/Prelistening-Das-rote-Album