id
int64 393k
2.82B
| repo
stringclasses 68
values | title
stringlengths 1
936
| body
stringlengths 0
256k
⌀ | labels
stringlengths 2
508
| priority
stringclasses 3
values | severity
stringclasses 3
values |
|---|---|---|---|---|---|---|
53,080,009 | nvm | .nvmrc should override default in new shells | I'd like to use the stable node version as the default, but use a specific version automatically if I open a shell in a directory with a `.nvmrc`.
Currently, if I specify a default alias, that default overrides `.nvmrc` until I manually run `nvm use`.
| feature requests | medium | Major |
53,221,982 | rust | Can't write non-overlapping blanket impls that involve associated type bindings | ### STR
Example from libcore:
``` rust
#![crate_type = "lib"]
#![feature(associated_types)]
#![no_implicit_prelude]
trait Iterator {
type Item;
}
trait AdditiveIterator {
type Sum;
fn sum(self) -> Self::Sum;
}
impl<I> AdditiveIterator for I where I: Iterator<Item=u8> { //~error conflicting implementation
type Sum = u8;
fn sum(self) -> u8 { loop {} }
}
impl<I> AdditiveIterator for I where I: Iterator<Item=u16> { //~note conflicting implementation here
type Sum = u16;
fn sum(self) -> u16 { loop {} }
}
```
### Version
7d4f487
No type can implement _both_ `Iterator<Item=u8>` and `Iterator<Item=u16>`, therefore these blanket impls are non overlapping and should be accepted.
cc @nikomatsakis
| A-trait-system,A-associated-items,T-lang,C-bug,needs-rfc | high | Critical |
53,296,882 | go | x/build: tracking bug for macOS virtualization | I'd like to get OS X builders running in VMs too.
(Related to #9492 and https://golang.org/s/builderplan)
Looks like virtualizing OS X 10.7+ is legal (but not 10.6) as long as it's only 1 copy, and on official Apple hardware. Considering that we already run Go builders on official Mac hardware in the office, we can continue to do so, but with a VM solution.
And looks like VMWare Fusion has the "vmrun" command, documented at http://www.vmware.com/pdf/vix162_vmrun_command.pdf , so we can write a little API server that runs on the OS X host and calls vmrun.
/cc @adg
| OS-Darwin,Builders | medium | Critical |
53,312,747 | neovim | "set lines=999 columns=999" causes layout issues | I just built a fresh version of neovim to confirm this. I can reproduce with TERM=screen-256color and TERM=xterm and with both terminator and xterm. When I run nvim I see a console like this:
[<img src="http://i.imgur.com/NkGDiya.png" />](http://i.imgur.com/NkGDiya.png)
Vim looks fine:
[<img src="http://i.imgur.com/n6lfmXC.png" />](http://i.imgur.com/n6lfmXC.png)
**UPDATE**: It turns out that it's caused by the following lines in my .nvimrc:
```
function! FontNormal()
if has("gui_win32")
set guifont=Consolas:h11
else
set guifont=Terminus\ 8
endif
set lines=999 columns=999 " Maximize the window
endfunction
call FontNormal()
```
I'll wrap it in a conditional, but the fact that this causes problems in nvim and not vim seems like a regression to me.
| ui,bug-vim,display,startup | low | Minor |
53,336,809 | youtube-dl | [NRKTV] When playing with VLC the audio is corrupted | Reported on IRC:
For example the test url http://tv.nrk.no/serie/20-spoersmaal-tv/MUHH48000314/23-05-2014 or http://tv.nrk.no/serie/bare-en-mann-bjoern-eidsvaag/MUHU20002114/02-01-2015, after a few seconds the audio doesn't play correctly, if you download the video with AdobeHDS.php it plays fine.
| bug | low | Minor |
53,357,098 | youtube-dl | Add support for apple.com | Hello,
Could you please add support for videos on apple.com?
Here are some examples:
http://www.apple.com/apple-events/2014-oct-event/
http://www.apple.com/ipad-air-2/change/
The video on the second link is slightly different, it only shows up after the "Watch the film" button is clicked. (Most of the non-event videos are like this.)
```
$ youtube-dl --verbose http://www.apple.com/apple-events/2014-oct-event/
[debug] System config: []
[debug] User config: []
[debug] Command-line args: ['--verbose', 'http://www.apple.com/apple-events/2014-oct-event/']
[debug] Encodings: locale UTF-8, fs utf-8, out UTF-8, pref UTF-8
[debug] youtube-dl version 2015.01.04
[debug] Python version 2.7.6 - Darwin-14.0.0-x86_64-i386-64bit
[debug] exe versions: rtmpdump 2.4
[debug] Proxy map: {}
[generic] 2014-oct-event: Requesting header
WARNING: Falling back on generic information extractor.
[generic] 2014-oct-event: Downloading webpage
[generic] 2014-oct-event: Extracting information
ERROR: Unsupported URL: http://www.apple.com/apple-events/2014-oct-event/
Traceback (most recent call last):
File "/usr/local/bin/youtube-dl/youtube_dl/extractor/generic.py", line 669, in _real_extract
doc = parse_xml(webpage)
File "/usr/local/bin/youtube-dl/youtube_dl/utils.py", line 1451, in parse_xml
tree = xml.etree.ElementTree.XML(s.encode('utf-8'), **kwargs)
File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/xml/etree/ElementTree.py", line 1300, in XML
parser.feed(text)
File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/xml/etree/ElementTree.py", line 1642, in feed
self._raiseerror(v)
File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/xml/etree/ElementTree.py", line 1506, in _raiseerror
raise err
ParseError: not well-formed (invalid token): line 7, column 1232
Traceback (most recent call last):
File "/usr/local/bin/youtube-dl/youtube_dl/YoutubeDL.py", line 592, in extract_info
ie_result = ie.extract(url)
File "/usr/local/bin/youtube-dl/youtube_dl/extractor/common.py", line 245, in extract
return self._real_extract(url)
File "/usr/local/bin/youtube-dl/youtube_dl/extractor/generic.py", line 1074, in _real_extract
raise UnsupportedError(url)
UnsupportedError: Unsupported URL: http://www.apple.com/apple-events/2014-oct-event/
$
```
| site-support-request | low | Critical |
53,359,491 | go | net: add support for FileConn, FilePacketConn, FileListener on windows | Issue for discussion.
FileListener is useful to implement graceful-restart server. ex: https://github.com/lestrrat/go-server-starter
I know windows doesn't have a way to pass FDs to external process like UNIX OSs.
But it's not impossible. WSADuplicateSocket can export intormation of file descriptor as WSAPROTOCOL_INFO to specified process. This structure is possible to be written to a file as byte array.
http://msdn.microsoft.com/ja-jp/library/windows/desktop/ms741565(v=vs.85).aspx
How about implementation of os.File.dup, os.FileListener on windows?
https://codereview.appspot.com/177590043/
| help wanted,OS-Windows,FeatureRequest | low | Major |
53,363,554 | go | x/build/dashboard: add an Arch Linux builder | Noticing the build failure in #9437 on Arch Linux, perhaps we should have an Arch builder.
Looks like it wouldn't be too hard, since an official Arch Linux Docker template exists: https://registry.hub.docker.com/u/base/archlinux/
| Builders,new-builder | low | Critical |
53,430,521 | youtube-dl | Unsupported URL: http://www.lemouv.fr/rone-apache-binaural | ```
[debug] System config: []
[debug] User config: []
[debug] Command-line args: ['http://www.lemouv.fr/rone-apache-binaural', '-v']
[debug] Encodings: locale UTF-8, fs UTF-8, out UTF-8, pref UTF-8
[debug] youtube-dl version 2015.01.05
[debug] Python version 2.7.3 - Linux-3.2.0-4-amd64-x86_64-with-debian-7.7
[debug] exe versions: avconv 0.8.16-6, avprobe 0.8.16-6, ffmpeg 0.8.16-6, ffprobe 0.8.16-6, rtmpdump 2.4
[debug] Proxy map: {}
[generic] rone-apache-binaural: Requesting header
WARNING: Falling back on generic information extractor.
[generic] rone-apache-binaural: Downloading webpage
[generic] rone-apache-binaural: Extracting information
ERROR: Unsupported URL: http://www.lemouv.fr/rone-apache-binaural
Traceback (most recent call last):
File "/usr/local/lib/python2.7/dist-packages/youtube_dl/extractor/generic.py", line 670, in _real_extract
doc = parse_xml(webpage)
File "/usr/local/lib/python2.7/dist-packages/youtube_dl/utils.py", line 1451, 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 20, column 65
Traceback (most recent call last):
File "/usr/local/lib/python2.7/dist-packages/youtube_dl/YoutubeDL.py", line 592, in extract_info
ie_result = ie.extract(url)
File "/usr/local/lib/python2.7/dist-packages/youtube_dl/extractor/common.py", line 245, in extract
return self._real_extract(url)
File "/usr/local/lib/python2.7/dist-packages/youtube_dl/extractor/generic.py", line 1075, in _real_extract
raise UnsupportedError(url)
UnsupportedError: Unsupported URL: http://www.lemouv.fr/rone-apache-binaural
```
| site-support-request | low | Critical |
53,504,910 | rust | Package debug libstd with binaries | For debugging it's useful to have a debug build of std. Figuring out how to make the debugger actually locate the source in all scenarios could be complicated.
| A-debuginfo,P-low,T-bootstrap,T-infra,C-feature-request | low | Critical |
53,559,076 | go | encoding/xml: support for XML namespace prefixes | Marshal-ing data back to XML does not seem to support namespace prefixes.. For example:
https://play.golang.org/p/6CY71H7mb4
The input XML is: <stix:STIX_Package>, but when it writes it back out it does <STIX_Package xmlns="stix">
Also, there does not appear to be any data elements like xml.Name for adding namespaces to a struct.... Something maybe like xml.NS????
| NeedsFix,early-in-cycle | medium | Critical |
53,582,955 | rust | where clauses are only elaborated for supertraits, and not other things | The following example:
``` rust
trait Foo<T> {
fn foo(&self) -> &T;
}
trait Bar<A> where A: Foo<Self> {}
fn foobar<A, B: Bar<A>>(a: &A) -> &B {
a.foo()
}
```
fails with "error: type `&A` does not implement any method in scope named `foo`".
This UFCS variant
``` rust
trait Foo<T> {
fn foo(&self) -> &T;
}
trait Bar<A> where A: Foo<Self> {}
fn foobar<A, B: Bar<A>>(a: &A) -> &B {
Foo::foo(a)
}
```
fails with "error: the trait `Foo<_>` is not implemented for the type `A`".
| A-type-system,A-trait-system,T-compiler,C-bug,T-types | high | Critical |
53,806,104 | rust | Normalization of projections in trait bounds on associated types | Related to #20765 we should do more normalization in order for this test to pass:
``` 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.
// Test where the bounds in the trait use projections rather than the
// canonical form.
trait Foo
{
type T;
}
trait Bar<A:Foo<T=B>,B>
{
type F : Baz<A::T>;
}
trait Baz<A> { }
fn foo<I:Bar<J,K>,J,K>()
{
// Based on trait, we can conclude that
// I::F : Baz<J::T>
// and
// J::T == K
// hence
// I::F : Baz<K>
// which is what `bar` expects.
bar::<I::F,K>()
}
fn bar<IF, K>()
where IF : Baz<K>
{
}
fn main ()
{
}
```
| A-associated-items,T-compiler,C-bug | low | Minor |
53,835,256 | neovim | autoread ALL files (avoid W13 warning) | What I mean by newly created file is when a buffer that doesn't have a corresponding file on disk (think BufNewFile) suddenly does (triggering W13). I'll sometimes have buffers open for files that don't exist in a session either because they are on an external drive that isn't mounted or in an encrypted volume that isn't mounted. When files suddenly exist, vim gives a warning (W13) and prompts for every single file whether to load or ignore.
I think a setting like autoread but specifically for this case would be nice. Having it set would mean that no W13 messages would pop up, and it would be as if the user had chosen to load every file. That or some autocommand that could be used to prevent a W13 from happening. FileChangedShell is similar idea (though for all buffers) but doesn't execute when a W13 does.
| enhancement,complexity:low,events,filesystem | low | Minor |
53,892,783 | go | cmd/vet: warn about assembly functions using fully qualified name | See golang.org/cl/2588 for a full description.
cc @minux
| Analysis | low | Minor |
53,932,929 | rust | Cannot infer closure type with higher-ranked lifetimes inside Box::new | In the code below, type inference works in the first line of `main()`, but fails in the second one. Note also that the "kind" of the closure has to be given with explicit syntax when inside `Box::new()`.
``` rust
fn do_async<F>(_cb: Box<F>) where F: FnOnce(&i32) {
}
fn do_async_unboxed<F>(cb: F) where F: FnOnce(&i32) {
do_async(Box::new(cb))
}
fn main() {
do_async_unboxed(|x| { println!("{}", *x); });
do_async(Box::new(|: x| { println!("{}", *x); }));
}
```
| A-type-system,C-enhancement,P-low,A-closures,T-lang,T-compiler,E-medium,T-types | medium | Major |
53,939,158 | TypeScript | QuickInfo shows icon and name of item type | 
We're showing the purple cube that means method but also the text (method). It should be unnecessary to show both. Likewise:
We're showing the interface icon and the word interface.
| Suggestion,Help Wanted,API | low | Minor |
54,002,277 | rust | Improve docs rendering performance by addressing PageSpeed Insights issues | [Results from PageSpeed](https://developers.google.com/speed/pagespeed/insights/?url=http%3A%2F%2Fdoc.rust-lang.org%2Fnightly%2Fbook%2Fownership.html&tab=desktop).
The easy ones are setting up cache expiration times for the font & css files and minifying the CSS. Eliminating render-blocking JavaScript and CSS in above-the-fold content is a bit harder, but shouldn't be too much work for a static site.
| T-rustdoc,C-enhancement,E-help-wanted | low | Major |
54,008,316 | go | cmd/cgo: generates far too many //line pragmas | ```
// Created by cgo - DO NOT EDIT
//line issue9557.go:1
package main
//line issue9557.go:4
//line issue9557.go:3
import (
"fmt"
)
//line issue9557.go:21
//line issue9557.go:20
type bar struct {
a int
}
//line issue9557.go:25
//line issue9557.go:24
var buzz *bar
//line issue9557.go:27
//line issue9557.go:26
func init() {
buzz = &bar{}
}
//line issue9557.go:31
```
| NeedsInvestigation | low | Minor |
54,088,602 | nvm | Add Changelog | Hey, first off thank you so much for the amazing tool! It's proven to be indispensable for me and my team.
I know it's been mentioned that plans are to add an automatic changelog generator but I thought I'd add an official request here. A changelog (CHANGELOG.md) would really be helpful in updating my nvm's so I didn't need to read commit messages.
| pull request wanted | low | Major |
54,102,741 | go | x/mobile: create a package for the Mobile Ads SDK | See https://github.com/googleads/googleads-mobile-plugins for a similar Unity plugin.
| NeedsDecision,mobile | low | Minor |
54,219,710 | rust | GDB should break on panic | Expected behavior:
- when I use gdb, gdb should catch the panic and I should be able to use `bt` to analyze the stack.
- when I use RUST_BACKTRACE=1 I should see source files and line numbers in the backtrace.
Actual behavior:
```
andy@andy-bx:~/dev/hackerrank/angry-children$ rustc --version
rustc 1.0.0-nightly (3d0d9bb6f 2015-01-12 22:56:20 +0000)
andy@andy-bx:~/dev/hackerrank/angry-children$ uname -a
Linux andy-bx 3.16.0-25-generic #33-Ubuntu SMP Tue Nov 4 12:06:54 UTC 2014 x86_64 x86_64 x86_64 GNU/Linux
andy@andy-bx:~/dev/hackerrank/angry-children$ rustc -g main.rs
main.rs:20:17: 20:18 warning: unused variable: `e`, #[warn(unused_variables)] on by default
main.rs:20 Err(e) => break
^
main.rs:9:5: 9:23 warning: unused result which must be used, #[warn(unused_must_use)] on by default
main.rs:9 stdin.read_line();
^~~~~~~~~~~~~~~~~~
andy@andy-bx:~/dev/hackerrank/angry-children$ gdb ./main -ex run
GNU gdb (Ubuntu 7.8-1ubuntu4) 7.8.0.20141001-cvs
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-linux-gnu".
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 ./main...done.
warning: Missing auto-load scripts referenced in section .debug_gdb_scripts
of file /home/andy/dev/hackerrank/angry-children/main
Use `info auto-load python-scripts [REGEXP]' to list them.
Starting program: /home/andy/dev/hackerrank/angry-children/main
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
7
3
thread '<main>' panicked at 'called `Option::unwrap()` on a `None` value', /home/rustbuild/src/rust-buildbot/slave/nightly-dist-rustc-linux/build/src/libcore/option.rs:362
[Inferior 1 (process 32760) exited with code 0145]
(gdb) bt
No stack.
(gdb) quit
andy@andy-bx:~/dev/hackerrank/angry-children$ RUST_BACKTRACE=1 ./main
7
3
thread '<main>' panicked at 'called `Option::unwrap()` on a `None` value', /home/rustbuild/src/rust-buildbot/slave/nightly-dist-rustc-linux/build/src/libcore/option.rs:362
stack backtrace:
1: 0x7ff274f5f430 - sys::backtrace::write::hb7fa0f4f6b33ee3a8Rt
2: 0x7ff274f62930 - failure::on_fail::h4388493538a5ad8ck8z
3: 0x7ff274f566a0 - rt::unwind::begin_unwind_inner::h644ddf1c409df284cNz
4: 0x7ff274f571d0 - rt::unwind::begin_unwind_fmt::h872fa98dc2f66468JLz
5: 0x7ff274f62850 - rust_begin_unwind
6: 0x7ff274f8e4b0 - panicking::panic_fmt::h4359f3a82e34f47bvym
7: 0x7ff274f8e3c0 - panicking::panic::hcce94ca6d802605cywm
8: 0x7ff274f4dd80 - option::Option<T>::unwrap::h861535042075806935
9: 0x7ff274f4bb10 - main::h957fc2428efe99eefaa
10: 0x7ff274f67140 - rust_try_inner
11: 0x7ff274f67130 - rust_try
12: 0x7ff274f644f0 - rt::lang_start::h46417f3fa3eb30a5w2z
13: 0x7ff274f4c220 - main
14: 0x7ff27413cdd0 - __libc_start_main
15: 0x7ff274f4b9e0 - <unknown>
16: 0x0 - <unknown>
```
[main.rs](https://gist.github.com/andrewrk/43b3a766e85865dcb066)
| A-debuginfo,T-compiler,C-feature-request | medium | Critical |
54,428,957 | go | x/review/git-codereview: query both remote.origin.pushurl and remote.origin.url to determine the gerrit URL? | remote.origin.pushurl should override remote.origin.url in
this case.
It's reasonable to set only the pushurl to a Gerrit instance,
and still pull from github.
| NeedsInvestigation | low | Minor |
54,453,609 | go | cmd/cgo: macros for C field names not recognized by cgo | The linux manpage ipv6(7) states that in6_addr is a C struct containing an unsigned char array[16] with name s6_addr. When compiling a C program, this works:
``` C
#include <stdio.h>
#include <netinet/in.h>
int main() {
struct in6_addr addr;
printf("%s\n", addr.s6_addr);
}
```
However, the following Go program does not compile with the error `addr.s6_addr undefined (type C.struct_in6_addr has no field or method s6_addr)`:
``` Go
package main
// #include <netinet/in.h>
// #include <sys/socket.h>
import "C"
import "fmt"
func main() {
// See man 7 ipv6
var addr C.struct_in6_addr
fmt.Printf("%v", addr.s6_addr)
}
```
Testing with `go tool cgo` reveals that the struct used is defined in in.h, and thus using `addr.__in6_u` works with go.
When the include file `linux/in6.h` is included, and `go tool cgo -- -D__USE_KERNEL_IPV6_DEFS test.go` is run, the correct (man page) definition of `struct in6_addr` shows up in `_obj/_cgo_gotypes.go`. I do not know how to get go to compile this correctly however.
Go version used is go version go1.3.3 linux/amd64. Contact me if you need any more information.
| NeedsInvestigation | low | Critical |
54,486,963 | rust | deny(warnings) doesn't affect all warnings, only those generated through the lint system | null | A-lints,A-diagnostics,P-low,T-compiler,C-bug | medium | Major |
54,521,964 | go | test: comprehensive testing of narrowing binary operations | #9604 highlighted that more testing of narrowing binary operations is required.
| NeedsInvestigation | low | Minor |
54,634,152 | go | runtime: support partial object collection in GC | It recycles well here (http://play.golang.org/p/qaQaETyZvQ), which appends 1000 elements and not use the slice anymore.
But it doesn't recycle the slice if I make a 1000-element slice first and not use it anymore. (http://play.golang.org/p/CQXs3Rpjae)
If I set some elements in the slice to nil, they can be recycled then. (http://play.golang.org/p/qvYLLZPY74)
I think it should be recycled in all these cases.
| GarbageCollector | low | Major |
54,675,983 | rust | Consider making std::thread::Builder reusable | Consider making `std::thread::Builder` reusable or have a reusable variant. This would be a helpful construct to use as part of a thread pool or any other abstraction that spawns threads.
| T-libs-api,C-feature-request | low | Major |
54,686,145 | kubernetes | rlimit support | https://github.com/docker/docker/issues/4717#issuecomment-70373299
Now that this is in, we should define how we want to use it.
| priority/important-soon,area/isolation,sig/node,kind/feature | high | Critical |
54,691,679 | youtube-dl | Add Support for Royal Institute Christmas Lectures (1825 - ): richannel.org | The Royal Institute Christmas Lectures ... it's been a thing since 1825.
A good example page is the first of the 1991 Richard Dawkins Lectures:
http://www.richannel.org/christmas-lectures-1991-richard-dawkins--waking-up-in-the-universe
the proper steam appears to be is embedded in
<object type="application/x-shockwave-flash" ..
with a <param name="flashvars" value="netstreambasepath= ...
however the page is littered with other video addresses as references or footnotes ( youtube links and wikipedia articles ).
It'd be much appreciated .. cheers :)
| site-support-request | low | Minor |
54,729,527 | go | x/review/git-codereview: 'git sync' should say what happened | When `git sync` does a fast forward or rebase, it would be nice to know what it did.
Something like this:
```
$ git sync
Synced local branch 'foo' HEAD to d34db33f (17 new commits)
$ git sync
Local branch 'foo' HEAD at d34db33f (no new commits)
```
| help wanted,NeedsFix | low | Minor |
54,736,132 | youtube-dl | [NDTV] Support live streams | Example url : http://www.ndtv.com/video/live/channel/ndtv24x7
youtube-dl --verbose -g http://www.ndtv.com/video/live/channel/ndtv24x7
[debug] System config: []
[debug] User config: []
[debug] Command-line args: ['--verbose', '-g', 'http://www.ndtv.com/video/live/channel/ndtv24x7']
[debug] Encodings: locale UTF-8, fs UTF-8, out UTF-8, pref UTF-8
[debug] youtube-dl version 2015.01.16
[debug] Python version 2.7.9 - Linux-3.10.0-123.13.2.el7.x86_64-x86_64-with-centos-7.0.1406-Core
[debug] exe versions: none
[debug] Proxy map: {}
WARNING: Falling back on generic information extractor.
ERROR: Unsupported URL: http://www.ndtv.com/video/live/channel/ndtv24x7
Traceback (most recent call last):
File "/usr/local/bin/youtube-dl/youtube_dl/extractor/generic.py", line 670, in _real_extract
doc = parse_xml(webpage)
File "/usr/local/bin/youtube-dl/youtube_dl/utils.py", line 1504, in parse_xml
tree = xml.etree.ElementTree.XML(s.encode('utf-8'), **kwargs)
File "/usr/local/lib/python2.7/xml/etree/ElementTree.py", line 1300, in XML
parser.feed(text)
File "/usr/local/lib/python2.7/xml/etree/ElementTree.py", line 1642, in feed
self._raiseerror(v)
File "/usr/local/lib/python2.7/xml/etree/ElementTree.py", line 1506, in _raiseerror
raise err
ParseError: not well-formed (invalid token): line 49, column 81
Traceback (most recent call last):
File "/usr/local/bin/youtube-dl/youtube_dl/YoutubeDL.py", line 600, in extract_info
ie_result = ie.extract(url)
File "/usr/local/bin/youtube-dl/youtube_dl/extractor/common.py", line 260, in extract
return self._real_extract(url)
File "/usr/local/bin/youtube-dl/youtube_dl/extractor/generic.py", line 1075, in _real_extract
raise UnsupportedError(url)
UnsupportedError: Unsupported URL: http://www.ndtv.com/video/live/channel/ndtv24x7
| request | low | Critical |
54,801,766 | nvm | When NVM_DIR is a symlink, `nvm_ls` breaks | Per some of the discussion on here: https://github.com/creationix/nvm/pull/616#issuecomment-70540684 as reported by @patrick-steele-idem
Solution is to add `-L` to the `find` command inside `nvm_ls`. The tricky part is writing a test for it :-)
| testing,bugs,pull request wanted | low | Minor |
55,058,708 | go | proposal: net/v2: Addr, LocalAddr, RemoteAddr must return established endpoint addresses | Example here: http://play.golang.org/p/0zfs2UZ7ZY
I don't know if this is intended, but it feels weird.
| v2,Proposal | low | Major |
55,079,319 | go | cmd/compile: better error message when attempting to use a shadowed type name | The compiler will emit a confusing error when a type is shadowed within a function. It should somehow try and make clear that the inner type shadows the global type.
```
prog.go:13: cannot use Range literal (type Range) as type Range in assignment
```
[Link to play.golang.org example](http://play.golang.org/p/ljMvbQf_WC)
[Link to golang-nuts thread](https://groups.google.com/d/topic/golang-nuts/F_awVFRD2mo/discussion)
``` go
package main
type Range struct{ Start, End int }
type Foo struct{ rng Range }
func main() {
type Range struct{ Start, End int }
foos := []Foo{}
for i, foo := range foos {
foos[i].rng = Range{}
}
}
```
See also #8853.
Edit: I incorrectly referred to "shadowing" as "aliasing".
| NeedsInvestigation | low | Critical |
55,202,080 | neovim | Dockerfile | Would you all be open to a Dockerfile for using neovim and as a neovim official image? I can make the pull request. Or would you rather wait until development was more stable.
| distribution | medium | Critical |
55,230,176 | go | net: implement multicast network interface API on DragonFly BSD | See https://github.com/golang/go/blob/master/src/net/interface_dragonfly.go.
| help wanted,OS-Dragonfly | low | Minor |
55,230,287 | go | net: implement multicast network interface API on OpenBSD | See https://github.com/golang/go/blob/master/src/net/interface_openbsd.go.
| help wanted,OS-OpenBSD | low | Minor |
55,230,348 | go | net: implement multicast network interface API on NetBSD | See https://github.com/golang/go/blob/master/src/net/interface_netbsd.go.
| help wanted,OS-NetBSD,NeedsFix | low | Minor |
55,234,993 | youtube-dl | Add support for soundcloud tags | it advised me to report this:
```
$ youtube-dl https://soundcloud.com/tags/folk
[soundcloud] tags/folk: Resolving id
[soundcloud] tags/folk: Downloading info JSON
ERROR: Unable to download JSON metadata: HTTP Error 404: Not Found (caused by HTTPError()); 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 --verbose flag and include its complete output.
$ youtube-dl --verbose https://soundcloud.com/tags/folk
[debug] System config: []
[debug] User config: []
[debug] Command-line args: ['--verbose', 'https://soundcloud.com/tags/folk']
[debug] Encodings: locale UTF-8, fs UTF-8, out UTF-8, pref UTF-8
[debug] youtube-dl version 2015.01.16
[debug] Python version 2.7.8 - Linux-3.16-3-amd64-x86_64-with-debian-8.0
[debug] exe versions: avconv 2.4.3, avprobe 2.4.3, ffmpeg 2.4.3, ffprobe 2.4.3, rtmpdump 2.4
[debug] Proxy map: {}
[soundcloud] tags/folk: Resolving id
[soundcloud] tags/folk: Downloading info JSON
ERROR: Unable to download JSON metadata: HTTP Error 404: Not Found (caused by HTTPError()); 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 --verbose flag and include its complete output.
File "/usr/local/bin/youtube-dl/youtube_dl/extractor/common.py", line 293, in _request_webpage
return self._downloader.urlopen(url_or_request)
File "/usr/local/bin/youtube-dl/youtube_dl/YoutubeDL.py", line 1412, in urlopen
return self._opener.open(req, timeout=self._socket_timeout)
File "/usr/lib/python2.7/urllib2.py", line 410, in open
response = meth(req, response)
File "/usr/lib/python2.7/urllib2.py", line 523, in http_response
'http', request, response, code, msg, hdrs)
File "/usr/lib/python2.7/urllib2.py", line 448, in error
return self._call_chain(*args)
File "/usr/lib/python2.7/urllib2.py", line 382, in _call_chain
result = func(*args)
File "/usr/lib/python2.7/urllib2.py", line 531, in http_error_default
raise HTTPError(req.get_full_url(), code, msg, hdrs, fp)
```
| site-support-request | low | Critical |
55,335,337 | youtube-dl | Add support for www.be-at.tv | example url (shortened): http://www.be-at.tv/i3wCAA
example url (full): http://www.be-at.tv/brands/shelborne-hotel/dj-mag-recession-sessions/solomun
| site-support-request | low | Minor |
55,359,090 | go | x/pkgsite: don't show un-runnable examples as runnable | The example for exec.Command won't run in the playground sandbox because it depends on 'tr'.
http://golang.org/pkg/os/exec/#Command
There are other such examples. We should probably detect (somehow) that they won't run, and not display them as runnable examples on golang.org.
| help wanted,NeedsFix,pkgsite | low | Major |
55,488,241 | youtube-dl | unable to extract facebook video in private group, user with two-factor auth | ```
[debug] System config: []
[debug] User config: []
[debug] Command-line args: ['https://www.facebook.com/video.php?v=PRIVATE', '--username', u'PRIVATE', '--password', u'PRIVATE', '--twofactor', 'PRIVATE', '--verbose']
[debug] Encodings: locale UTF-8, fs UTF-8, out UTF-8, pref UTF-8
[debug] youtube-dl version 2015.01.25
[debug] Python version 2.7.8 - Linux-3.18.2-2-ARCH-x86_64-with-glibc2.2.5
[debug] exe versions: ffmpeg 2.5.2, ffprobe 2.5.2, rtmpdump 2.4
[debug] Proxy map: {}
[facebook] Downloading login page
[facebook] Logging in
ERROR: Unable to extract h; 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 --verbose flag and include its complete output.
Traceback (most recent call last):
File "/home/jakutis/.bin/youtube-dl/youtube_dl/YoutubeDL.py", line 613, in extract_info
ie_result = ie.extract(url)
File "/home/jakutis/.bin/youtube-dl/youtube_dl/extractor/common.py", line 265, in extract
self.initialize()
File "/home/jakutis/.bin/youtube-dl/youtube_dl/extractor/common.py", line 260, in initialize
self._real_initialize()
File "/home/jakutis/.bin/youtube-dl/youtube_dl/extractor/facebook.py", line 107, in _real_initialize
self._login()
File "/home/jakutis/.bin/youtube-dl/youtube_dl/extractor/facebook.py", line 93, in _login
r'name="h"\s+(?:\w+="[^"]+"\s+)*?value="([^"]+)"', login_results, 'h'),
File "/home/jakutis/.bin/youtube-dl/youtube_dl/extractor/common.py", line 522, in _search_regex
raise RegexNotFoundError('Unable to extract %s' % _name)
RegexNotFoundError: Unable to extract h; 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 --verbose flag and include its complete output.
```
| request | low | Critical |
55,622,401 | rust | Imprecise floating point operations (fast-math) | There should be a way to use imprecise floating point operations like GCC's and Clang's `-ffast-math`. The simplest way to do this would be to do like GCC and Clang and implement a command line flag, but I think a better way to do this would be to create a `f32fast` and `f64fast` type that would then call the fast LLVM math functions. This way you can easily mix fast and "slow" floating point operations.
I think this could be implemented as a library if LLVM assembly could be used in the `asm` macro.
| A-LLVM,I-slow,C-enhancement,T-lang,C-feature-request,A-floating-point | high | Major |
55,696,657 | go | runtime: cgo performance tracking bug | Running this stupid microbenchmark on linux/amd64, with different version of Go.
http://play.golang.org/p/5U0i26sA8U
```
package main
// int rand() { return 42; }
import "C"
import "testing"
func BenchmarkCgo(b *testing.B) {
for i := 0; i < b.N; i++ {
C.rand()
}
}
func main() {
testing.Main(func(string, string) (bool, error) {
return true, nil
}, nil, []testing.InternalBenchmark{
{"BenchmarkCgo", BenchmarkCgo},
}, nil)
}
```
```
$ go1 run cgobench.go -test.bench=.
testing: warning: no tests to run
PASS
BenchmarkCgo 50000000 30.8 ns/op
$ go112 run cgobench.go -test.bench=.
testing: warning: no tests to run
PASS
BenchmarkCgo 50000000 40.9 ns/op
$ go121 run cgobench.go -test.bench=.
testing: warning: no tests to run
PASS
BenchmarkCgo 50000000 46.1 ns/op
$ go133 run cgobench.go -test.bench=.
testing: warning: no tests to run
PASS
BenchmarkCgo 50000000 48.3 ns/op
$ go141 run cgobench.go -test.bench=.
testing: warning: no tests to run
PASS
BenchmarkCgo 10000000 160 ns/op
$ go run cgobench.go -test.bench=. # today's Go tip, f4a2617
testing: warning: no tests to run
PASS
BenchmarkCgo 10000000 203 ns/op
```
Why? Go 1.4 is much worse than any of the previous releases.
And Go tip is even worse than Go 1.4. This might be understandable,
but I wonder why Go 1.4 is that much slower than 1.3.3?
| Performance | low | Critical |
55,835,768 | nvm | git `autocrlf` setting causes syntax errors after install | I'm getting the following error when opening a new shell after installing nvm:
``` bash
: command not found
: command not found
'ash: /Users/jtelford/.nvm/nvm.sh: line 12: syntax error near unexpected token `{
'ash: /Users/jtelford/.nvm/nvm.sh: line 12: `nvm_has() {
```
I successfully installed nvm with the following command:
``` bash
$ curl https://raw.githubusercontent.com/creationix/nvm/v0.23.2/install.sh | bash
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 5226 100 5226 0 0 8682 0 --:--:-- --:--:-- --:--:-- 8681
=> Downloading nvm from git to '/Users/jtelford/.nvm'
=> Cloning into '/Users/jtelford/.nvm'...
remote: Counting objects: 3230, done.
remote: Total 3230 (delta 0), reused 0 (delta 0)
Receiving objects: 100% (3230/3230), 608.11 KiB | 128.00 KiB/s, done.
Resolving deltas: 100% (1827/1827), done.
Checking connectivity... done.
=> Source string already in /Users/jtelford/.bash_profile
=> Close and reopen your terminal to start using nvm
```
I am running OSX 10.10.1, and my shell is iTerm2 v2.0
Is there something I am doing wrong?
Thanks for your help :)
| installing node,bugs | low | Critical |
55,850,799 | youtube-dl | site support campus.codeschool | Please support http://campus.codeschool.com/courses/shaping-up-with-angular-js/
| site-support-request,account-needed | low | Major |
55,949,058 | TypeScript | findReferences doesn't give results in the right order | Search for "globalTemplateStringsArrayType" in checker.ts. The results are not in the right order (the order of the text spans).
| Bug,Visual Studio,Help Wanted | low | Major |
55,962,696 | kubernetes | Pod lifecycle checkpointing | Filing this issue for discussion and tracking, since it has come up a number of times.
Starting with background:
Pods are scheduled, started, and eventually terminate. They are replaced with new pods by replication controller (or some other controller, once we add more controllers). That's both reality and the model. Today pods are replaced reactively, but eventually it will replace pods proactively for planned moves. We currently do not preempt pods in order to schedule other pods, and likely won't for some time.
Currently, new pods have no obvious relationship to the pods they replace. They have different names, different uids, different IP addresses, different hostnames (since we set the pod hostname to pod name), and newly initialized volumes.
Replication controllers themselves are not durable objects. They are tied to deployments. New deployments create new replication controllers. This simplifies sophisticated deployment and rollout strategies without making simple scenarios complex. Both rollout tools/components and auto-scaling will deal with groups of replication controllers.
Naming/discovery is addressed using services, DNS, and the Endpoints API. The evolution of these mechanisms is being discussed in #2585.
This is a flexible model that facilitates transparency, simplifies handling of inevitable distributed-systems scenarios, facilitates high availability, and facilitates dynamic deployment and scaling.
But the model is not without issues. The main ones are:
1. Data durability
2. Self-discovery
3. Work/role assignment
Data durability is being discussed in the persistent storage proposal #3318. We will also need to address it for local storage, but local storage is less relevant to "migration", anyway, since it's not feasible to migrate. For remote storage, it will be possible to detach and reattach the devices to new pods/hosts.
Self-discovery: Pods know their IP addresses, but currently do not know the names nor IPs of services targeting them. This will be solved by the service redesign #2585 and downward API #386.
Work/role assignment: We encourage dynamic role assignment: master election, fine-grain locking, sharding, task queues, pubsub, etc. That said, some servers are "pet-like", particularly those requiring large amounts of persistent storage. Many of these are replicated and/or sharded, with application-specific clustering implementations that tie together names/addresses and persistent data. We've discussed a concept tentatively called "nominal services" #260 to stably assign names and IP addresses to individual pods, and we aim to address that in the service redesign #2585.
So, do we need "pod migration", and, if so, what should it mean? I think it minimally should mean that the replacement pod has the same hostname, IP address, and storage.
We should aim to minimize disruption for high-availability servers. We could we do, besides the things planned above?
- Don't use the pod name as the host name. Associate a name with the IP address instead (e.g., by hashing the address). Pods created by replication controllers aren't currently predictable, so this wouldn't be a regression.
- Migrate the pod IP address. Currently pod IP addresses are statically partitioned among hosts and are not migratable. This would likely be problematic on some cloud providers with the way we're currently configuring routing, but could be done with an overlay network.
- Lifecycle hooks pre- and post-migration.
- Actual live state transfer via [CRIU](http://criu.org/Docker)
With respect to Kubernetes objects, the "migrated" pod would still be a new pod with a new name and uid. The orchestration of the migration would be performed by a controller -- possibly an enhanced replication controller, perhaps in collaboration with a network controller to move the address, similar to the separation of concerns in the persistent storage proposal. During the migration process, the old and new pods would coexist, and that coexistence would be visible to clients of the Kubernetes API, but the application being migrated and its clients would not need to be aware of the migration.
/cc @smarterclayton @thockin @alex-mohr
| sig/node,kind/feature,lifecycle/frozen,triage/needs-information,needs-triage,area/pod-lifecycle | medium | Critical |
55,979,892 | TypeScript | Make the Compiler and Language Service API Asynchronous | It makes very little sense that IO-bound operations (e.g. readFile, writeFile) are synchronous when we run on a platform whose touted strength is in writing IO-bound applications through asynchronous non-blocking APIs.
Compile times could probably be shaved down by a bit, especially for large projects with many files. Additionally, tooling experience should be as responsive as possible and avoid blocking in the event that IO takes place, enabling several optimizations to free memory on the managed side.
With #1664, this should be significantly easier.
This means that at the very least, the following would change to have asynchronous counterparts.
- `createSourceFile` (because of `/// <reference ... />` comments)
- `createProgram`
- all of the language service API
| Suggestion,Needs More Info | high | Critical |
56,066,185 | go | x/tools/cmd/oracle: provide element documentation for the "describe" operation. | Hello. Recently [Goclipse](https://github.com/GoClipse/goclipse) has added integration with the Go Oracle tool within Eclipse, for a Open Definition functionality. There's a few things Go Oracle could improve upon, to further improve the integration.
- Namely, could the "describe" operation be modified to include a field with the documentation of the underlying element (if the element is a definition)?
That would be very useful: it would allow documentation popups in the editor (similar to what is being done here: https://raw.githubusercontent.com/bruno-medeiros/DDT/master/documentation/screenshots/sample_ddocView.png). It could even be used to complement tools such as https://github.com/nsf/gocode, to provide documentation info during during Content Assist: http://i.imgur.com/IQnyP2l.png
| NeedsInvestigation | low | Minor |
56,070,580 | rust | Revise usage of LLVM lifetime intrinsics | Currently, rustc emits lifetime intrinsics to declare the shortest possible lifetime for allocas. Unfortunately, this stops some optimizations from happening. For example, @eddyb came up with the following example:
``` rust
#![crate_type="lib"]
extern crate test;
#[derive(Copy)]
struct Big {
large: [u64; 100000],
}
pub fn test_func() {
let x = Big {
large: [0; 100000],
};
test::black_box(x);
}
```
This currently results in the following optimized IR:
``` llvm
define void @_ZN9test_func20hef205289cff69060raaE() unnamed_addr #0 {
entry-block:
%x = alloca %struct.Big, align 8
%0 = bitcast %struct.Big* %x to i8*
%arg = alloca %struct.Big, align 8
call void @llvm.lifetime.start(i64 800000, i8* %0)
call void @llvm.memset.p0i8.i64(i8* %0, i8 0, i64 800000, i32 8, i1 false)
%1 = bitcast %struct.Big* %arg to i8*
call void @llvm.lifetime.start(i64 800000, i8* %1)
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* %0, i64 800000, i32 8, i1 false)
call void asm "", "r,~{dirflag},~{fpsr},~{flags}"(%struct.Big* %arg) #2, !noalias !0, !srcloc !3
call void @llvm.lifetime.end(i64 800000, i8* %1) #2, !alias.scope !4, !noalias !0
call void @llvm.lifetime.end(i64 800000, i8* %1)
call void @llvm.lifetime.end(i64 800000, i8* %0)
ret void
}
```
As you can see, there are still two allocas, one for `x` and one copy of it in `%arg`, which is used for the function call. Since `x` is unused otherwise, we could directly call `memset` on `%arg` and drop `%x` altogether. But the lifetime of `%arg` only start _after_ the `memset` call, so the optimization doesn't happen. Moving the call to `llvm.lifetime.start` up makes the optimization possible.
Now, the lifetime intrinsics only buy us anything if the ranges don't overlap. If the ranges overlap, we may as well make them all start at the same point. One way might be to insert start/end calls at positions that match up with scopes in the language, using an insertion marker like we do for allocas to insert the start calls and a cleanup scope for the end calls. This should also make things more robust than it currently is. We had a few misoptimization problems due to missing calls to `llvm.lifetime.end`. :-/
| C-cleanup,A-LLVM,I-slow,I-needs-decision,T-compiler | low | Major |
56,358,461 | angular | Support UTF in Angular expressions | Currently the lexer in change detection uses `StringWrapper.charCodeAt()`
- in Dart it returns `s.codeUnitAt()` which supports UTF
- in JS it returns `str.charCodeAt()` which does not support UTF
| type: bug/fix,effort2: days,freq1: low,area: core,area: compiler,state: confirmed,core: binding & interpolation,P3,compiler: parser,canonical | medium | Critical |
56,417,228 | rust | Trait bounds are not yet enforced in type definitions | Opening an issue since I could not find any information on when/if this will be enforced. Would be really useful for some generalizing I am trying for parser-combinators which I can't do currently without complicating the API.
Specifically I'd like to use a trait bound in a type definition to access an associated type to avoid passing it seperately but due to this issue I simply get a compiler error.
Simplified code which exhibits the error:
``` rust
trait Stream {
type Item;
}
trait Parser {
type Input: Stream;
}
fn test<T>(u: T) -> T
where T: Parser {
panic!()
}
type Res<I: Stream> = (I, <I as Stream>::Item);
impl <'a> Stream for &'a str { type Item = char; }
impl <I> Parser for fn (I) -> Res<I> where I: Stream { type Input = I; }
//Works
//fn f(_: &str) -> (&str, char) {
//Errors
fn f(_: &str) -> Res<&str> {
panic!()
}
fn main() {
let _ = test(f as fn (_) -> _);
}
```
| A-type-system,E-hard,A-trait-system,P-medium,I-needs-decision,T-compiler,C-future-incompatibility,T-types | medium | Critical |
56,422,779 | rust | Stability checker doesn't recurse down reexports properly | stability.rs:
```rs
#![crate_type="lib"]
#![feature(staged_api)]
#![staged_api]
#![stable(feature = "stability", since = "1.0.0")]
mod foo {
#[derive(Copy)]
pub struct Bar;
}
#[unstable(feature="foobar")]
pub mod foobar {
pub use super::foo::*;
}
```
test.rs:
```rs
extern crate stability;
use stability::foobar::Bar;
fn main(){
let x = Bar; //~ ERROR use of unmarked library feature
}
```
`#[unstable]` is inherited through mods (only `#[stable]` isn't inherited). However, in this particular case, the inheritance doesn't cross the reexport.
A more concrete example is the `hash_state` module. Chris fixed the stability of its items in [this PR](https://github.com/rust-lang/rust/pull/21745/files#diff-796e83d7a4e724593264d6bbf50a3e22R27), however the module itself was [private](https://github.com/rust-lang/rust/blob/9836742d6a5bd610074d2d944d472b0dfed3991b/src/libstd/collections/mod.rs#L374) and [reexported as an `#[unstable]` module](https://github.com/rust-lang/rust/blob/9836742d6a5bd610074d2d944d472b0dfed3991b/src/libstd/collections/mod.rs#L390) before the PR. Yet, usage of items within the `hash_state` module [were broken](https://github.com/rust-lang/rust/issues/21883) before the PR.
This seems wrong, `#[unstable]` (and the others, except `#[stable]`) should be inherited down `pub use`s.
cc @brson
| A-stability,T-libs-api,C-bug,F-staged_api | low | Critical |
56,427,206 | youtube-dl | Write playlist index number into the id3v2 "track" field (and playlist title into the "album" field) | Many YouTube video playlist with screencasts (video tutorials) has a very specific order, if you watch them on the web page all of them will play in the intended order, but once all of them are downloaded locally you will notice that that order is gone, because the video titles (and the filename) has not index number correlative on it (no even in the id3v2 track field), so the order is now alphabetic.
There's two approaches to solve this issue:
1. Rename all the files putting the play-list index correlative in the filename.
2. Write the play-list correlative into the id3v2 track field (then sort them by the respective column in the video player).
The first approach could be ok, except if you want re-download the same file in order to get missing metadata. The second will avoid the prior issue, but no all the video player (specially in Android) has that feature), but it will be a piece of cake to rename them in batch using a tag editor (I use kid3 and sometimes EasyTag) having the track number.
So, my suggestion is: write the playlist index number in the id3v2 track field using the `--add-metadata` but only when the `playlist` variable is in the URL query string. Even better: in that case it would retrieve too the playlist title and write it into the id3v2 album field.
| request | low | Minor |
56,430,063 | rust | &mut self borrow conflicting with itself. | I don't know why this happens but rovar and XMPPwocky on IRC believed it to be a compiler bug.
``` rust
struct A {
a: i32
}
impl A {
fn one(&mut self) -> &i32{
self.a = 10;
&self.a
}
fn two(&mut self) -> &i32 {
loop {
let k = self.one();
if *k > 10i32 {
return k;
}
}
}
}
```
...gives the following error...
```
<anon>:12:21: 12:25 error: cannot borrow `*self` as mutable more than once at a time
<anon>:12 let k = self.one();
^~~~
<anon>:12:21: 12:25 note: previous borrow of `*self` occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `*self` until the borrow ends
<anon>:12 let k = self.one();
^~~~
<anon>:17:6: 17:6 note: previous borrow ends here
<anon>:10 fn two(&mut self) -> &i32 {
...
<anon>:17 }
^
error: aborting due to previous error
playpen: application terminated with error code 101
```
Interestingly, if the second method is changed to...
``` rust
fn two(&mut self) -> &i32 {
loop {
let k = self.one();
return k;
}
}
```
This will compile fine.
playpen: http://is.gd/mTkfw5
| A-type-system,A-borrow-checker,T-compiler,A-NLL,C-bug,T-types,fixed-by-polonius | medium | Critical |
56,443,457 | go | os/signal: No access to the siginfo_t struct | The siginfo_t struct that is delivered with signals contains various useful information about the signal. In some cases, this information is necessary to implement the kernel API of various features. For example, fcntl(F_SETLEASE) requires that your process receive a SIGIO when the lock is broken, and the si_fd field in the siginfo_t struct tells you what filehandle the kernel is notifying your process about.
Please provide an interface that will allow Go code to access the information in the siginfo_t struct.
| help wanted,FeatureRequest,compiler/runtime | medium | Critical |
56,464,092 | TypeScript | Report error if code precedes /// reference | a.ts:
``` ts
'use strict'
/// <reference path='b.d.ts'/>
var x: Foo;
```
b.d.ts:
``` ts
interface Foo { x: string; }
declare module "b" {
export = Foo;
}
```
```
D:\test\refs\a> tsc a.ts
a.ts(4,8): error TS2304: Cannot find name 'Foo'.
```
There's no mention in section 11.1.1 of the spec that /// references must be the first thing in a file in order to work, although I do remember us deciding that was the case at one point. If that is the rule we should update the spec appropriately. We should also add an error to the compiler or else you may spend awhile trying to figure this out since we don't provide much (read: anything) in the way of diagnostics for debugging reference resolution.
| Bug,Help Wanted | low | Critical |
56,528,041 | You-Dont-Know-JS | "this & object prototypes": update appendix A `class` syntax to spec | - `super.foo()` instead of just `super()` in non-constructors.
- `toMethod(..)` has gone away entirely, so no way to rebind `[[HomeObject]]`
| for second edition | medium | Minor |
56,546,657 | rust | The compiler should report publicly exported type names if possible | If a private type is reexported at some public location, the Rust compiler will report the private location when referring to the type. It'd be more helpful if the compiler reported the public alias for it.
This was reported by Coda Hale on Twitter.
----
Update by pnkfelix: here is a standalone bit of code illustrating the problem. ([play](https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=ba6fa8cd0b3b03f756ebc8cbd95597a4)):
```rust
mod a {
mod m { pub struct PrivateName; }
pub use m::PrivateName as PublicName;
}
fn main() {
// a::m::PrivateName; // would error, "module `m` is private"
a::PublicName;
a::PublicName.clone();
}
```
As of nightly 2019-06-17, this issues the diagnostic:
```
> error[E0599]: no method named `clone` found for type `a::m::PrivateName` [...]
^^^^^^^^^^^^^^^^^
|
(author of `fn main` wants to see `a::PublicName` here)
``` | E-hard,C-enhancement,A-diagnostics,A-resolve,P-medium,T-compiler,D-newcomer-roadblock | medium | Critical |
56,560,630 | youtube-dl | Failed for flash video from `erlang-factory.com` | Complete log:
```
[debug] System config: []
[debug] User config: []
[debug] Command-line args: ['-twci', '--console-title', '--verbose', 'http://www.erlang-factory.com/conference/London2009/speakers/SimonPeytonJones']
[debug] Encodings: locale UTF-8, fs utf-8, out None, pref UTF-8
[debug] youtube-dl version 2014.11.21
[debug] Python version 2.7.6 - Darwin-14.1.0-x86_64-i386-64bit
[debug] exe versions: none
[debug] Proxy map: {}
WARNING: Falling back on generic information extractor.
ERROR: Unsupported URL: http://www.erlang-factory.com/conference/London2009/speakers/SimonPeytonJones; 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 --verbose flag and include its complete output.
Traceback (most recent call last):
File "/usr/local/bin/youtube-dl/youtube_dl/extractor/generic.py", line 609, in _real_extract
doc = parse_xml(webpage)
File "/usr/local/bin/youtube-dl/youtube_dl/utils.py", line 1339, in parse_xml
tree = xml.etree.ElementTree.XML(s.encode('utf-8'), **kwargs)
File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/xml/etree/ElementTree.py", line 1300, in XML
parser.feed(text)
File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/xml/etree/ElementTree.py", line 1642, in feed
self._raiseerror(v)
File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/xml/etree/ElementTree.py", line 1506, in _raiseerror
raise err
ParseError: mismatched tag: line 280, column 139
Traceback (most recent call last):
File "/usr/local/bin/youtube-dl/youtube_dl/YoutubeDL.py", line 536, in extract_info
ie_result = ie.extract(url)
File "/usr/local/bin/youtube-dl/youtube_dl/extractor/common.py", line 240, in extract
return self._real_extract(url)
File "/usr/local/bin/youtube-dl/youtube_dl/extractor/generic.py", line 996, in _real_extract
raise ExtractorError('Unsupported URL: %s' % url)
ExtractorError: Unsupported URL: http://www.erlang-factory.com/conference/London2009/speakers/SimonPeytonJones; 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 --verbose flag and include its complete output.
```
| site-support-request | low | Critical |
56,609,452 | go | encoding/xml: Unmarshal does not properly handle NCName in XML namespaces | Example:
type A struct {
XMLName xml.Name `xml:"a:B"`
}
Struct A is marshaled to "<a:B></a:B>", as expected.
However if we run
a := A{}
xml.Unmarshal([]byte("<a:B></a:B>"), &a)
It results in an error saying "unexpected error: expected element type <a:B> but have <B>"
| NeedsFix,early-in-cycle | low | Critical |
56,613,672 | TypeScript | Go to definition includes results from other entity spaces | ``` ts
Symbol.for("foo");
```
Go to definition on `Symbol`.
Expected: Only the var in lib.es6.d.ts is found.
Actual: Both the var and the interface are found
This is bad because Visual Studio only goes to the definition if there exactly one definition. By saying there are two definitions, VS does not navigate accordingly.
| Bug,Help Wanted,Domain: Symbol Navigation | low | Minor |
56,695,504 | You-Dont-Know-JS | "this & object prototypes": cover `__proto__` in object literals | ES6 now allows:
``` js
var Foo = { .. };
var Bar = {
__proto__: Foo,
..
};
```
This is obviously now much preferable in OLOO style, though of course it is ES6 only and requires some sort of transpilation to work backwards.
| for second edition | low | Minor |
56,710,533 | rust | Treatment of regions in trait matching is perhaps too simplistic | Not sure why I didn't see this coming. Until now, the treatment of regions in trait matching has intentionally ignored lifetimes (in the sense of, it did not consider lifetime constraints when deciding what impl to apply -- once an impl is selected, the constraints that appear on it naturally are enforced). The reason for this is that lifetime inference is a second pass that uses a much more flexible constraint-graph solving algorithm, in contrast to the bulk of type inference which uses something much closer to unification. A side-effect of this is that you cannot easily get a "yes or no" answer to the question "does `'x : 'y` hold?" One must see wait until all the constraints have been gathered to know.
However, this leads to problems when you have multiple predicates in the environment that reference lifetimes. This is easy to see in the following example, but one does not need where clauses to get into this situation:
``` rust
trait Foo {
fn foo(self);
}
fn foo<'a,'b,T>(x: &'a T, y: &'b T)
where &'a T : Foo,
&'b T : Foo
{
x.foo();
y.foo();
}
fn main() { }
```
this winds up failing to compile because it can't really distinguish the two predicates here, since they are identical but for the specific lifetimes involved. This doesn't arise much in practice because it's unusual to have two requirements like that, usually you either have a more universal requirement (e.g., `for<'a> &'a T : Foo`), or just one particular lifetime you are interested in. I observed this problem however when experimenting with [implied bounds](http://smallcultfollowing.com/babysteps/blog/2014/07/06/implied-bounds/), because it is common for multiple indistinguishable bounds of this kind to be generated as part of that proposal.
I'm not really sure how best to solve this at the moment.
| C-enhancement,A-lifetimes,A-trait-system,T-lang,T-compiler,T-types | low | Major |
56,932,679 | go | x/build: detect leftover temporary files? | Could the builders detect that there isn't any leftover temporary
files in $TMPDIR after testing each repo? (We need to whitelist
a few, for example gopath-api-*)
Ideally this should be treated a build failure and reported back
to the CL that triggered this.
Each time I logged into the netbsd-386 builder, I find a lot
temporary files in /tmp. However, as I don't know which build
generated them, I have to manually check if the bug is still
there.
| Builders,FeatureRequest | low | Critical |
56,943,603 | rust | Rustdoc links to std library types can bypass the facade | As an example, generate documentation for this:
``` rust
#![crate_type="lib"]
pub trait Trait { }
impl<T> Trait for Vec<T> { }
```
On the docs for the `Trait` trait, there will be an Implementors section like this:
<ul class="item-list" id="implementors-list">
<li><a class="stability Unmarked" title="No stability level"></a><code>impl<T> <a class="trait" href="../foo/trait.Trait.html" title="foo::Trait">Trait</a> for <a class="struct" href="http://doc.rust-lang.org/nightly/collections/vec/struct.Vec.html" title="collections::vec::Vec">Vec</a><T></code></li>
</ul>
Note that the `Vec` link goes to docs for the _`collections`_ crate and not to docs for `std`. Since the 1.0 release will not host documentation for crates behind the facade, this will lead to broken documentation links for third-party crates.
| T-rustdoc,C-bug,A-cross-crate-reexports | low | Critical |
56,989,139 | nvm | default install method didn't patch my bashrc/bash_profile files | `curl https://raw.githubusercontent.com/creationix/nvm/v0.23.3/install.sh | bash`
```
$ echo $HOME
/home/username
$ uname -a
Linux ashes 3.2.0-4-amd64 #1 SMP Debian 3.2.63-2+deb7u2 x86_64 GNU/Linux
$ bash --version
GNU bash, version 4.2.37(1)-release (x86_64-pc-linux-gnu)
$ echo $PROFILE
(empty)
```
| installing node,needs followup,installing nvm: profile detection | low | Minor |
56,995,870 | rust | Rustdoc should indicate variance on lifetime/type parameters | This has come up a few times in IRC and I think it's a nice idea. It's already important for lifetime parameters, where variance is important today, and could be useful for type parameters as well if rust-lang/rfcs#738 is accepted.
<!-- TRIAGEBOT_START -->
<!-- TRIAGEBOT_ASSIGN_START -->
<!-- TRIAGEBOT_ASSIGN_DATA_START$${"user":"danielhenrymantilla"}$$TRIAGEBOT_ASSIGN_DATA_END -->
<!-- TRIAGEBOT_ASSIGN_END -->
<!-- TRIAGEBOT_END --> | T-rustdoc,C-feature-request,A-variance | low | Major |
57,071,673 | TypeScript | Support column limit in formatter | Currently, running the formatter
(eg via the compiler API: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#pretty-printer-using-the-ls-formatter)
produces code which is arbitrarily wide, for statements which are nested, complex, etc.
Our style guide requires a maximum columns, which means the formatter should take a configuration for how wide this is.
Line breaks should probably be added at the highest point in the AST on the long line.
| Suggestion,Help Wanted | low | Major |
57,100,597 | TypeScript | Formatter: allow continuation indent different from nested indent | The Google style guide
http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml#Code_formatting
requires indenting by two spaces for nested code, but by 4 spaces when continuing a statement or declaration on the next line.
This configuration doesn't seem to be possible.
| Suggestion,Help Wanted | low | Minor |
57,112,711 | go | runtime: TestGdbLoadRuntimeSupport fails on non intel platforms | `runtime.TestGdbLoadRuntimeSupport` does not pass on linux/arm or linux/ppc64le. In both cases the error is the same
```
--- FAIL: TestGdbLoadRuntimeSupport (1.98s)
runtime-gdb_test.go:59: warning: Missing auto-load scripts referenced in section .debug_gdb_scripts
of file /tmp/go-build302202449/a.exe
Use `info auto-load python-scripts [REGEXP]' to list them.
FAIL
FAIL runtime 64.538s
```
| NeedsInvestigation | low | Critical |
57,120,791 | nvm | Use package.json engines version? | Run `nvm use` will read local package.json's engines.node and change version accordingly.
Or anyway that auto switch the version.
| feature requests | high | Critical |
57,185,887 | go | x/tools/imports: fill in missing type information in composite literals | Idea from campoy + discussions with crawshaw.
The spec now permits some types to be elided from composite literals: "Within a composite literal of array, slice, or map type T, elements that are themselves composite literals may elide the respective literal type if it is identical to the element type of T. Similarly, elements that are addresses of composite literals may elide the &T when the element type is *T."
Struct literals must still specify the types for each element, since without them the literals are difficult to understand. But these types are fully determined by the outermost type of the literal expression and the field names. So it should be possible to fill them in automatically. Since goimports is already processing the AST and adding missing imports, let's see whether it can also fill in these missing types.
For example:
```
goimports <<EOF
func main() {
fmt.Println(image.Rectangle{Min: {X: 2}})
}
EOF
should output:
package main
import (
"fmt"
"image"
)
func main() {
fmt.Println(image.Rectangle{Min: image.Point{X: 2}})
}
```
| NeedsInvestigation | low | Major |
57,244,135 | youtube-dl | --sleep-interval not working without video download | For example, downloading just the subs from a playlist.
This is the type of situation where sleeping is actually useful because downloading a video takes time anyway.
| bug | low | Major |
57,255,857 | kubernetes | Scheduler input should be taken when reducing replicas | When the replica count is increased, the new pod(s) are assigned to hosts by the scheduler based on policies defined by the selected predicates/priorities. However, during scale-down (reducing the replica count), the scheduler does not come into the picture potentially resulting in a violation of the scheduling policies. It is irrelevant whether the scale-down is automatic or manual.
Consider the case that there are 5 pods being spread across 3 machines, with 2 pods on each of the two machines and 1 pod on the third machine. If the replica count is reduced to 4, we shouldn't remove the single pod from the third machine (assuming the scheduler policy is to achieve greatest possible spread). To address this, we need to involve the scheduler in the workflow to figure out which pod(s) to get rid of.
Also, see https://github.com/GoogleCloudPlatform/kubernetes/issues/3948 for some other concerns related to determining which pods are removed when the replica count is reduced.
I do not have a proposed solution for this would like to invite some discussion and feedback on this issue.
| priority/backlog,sig/scheduling,area/controller-manager,kind/feature,sig/apps,lifecycle/frozen | high | Critical |
57,271,353 | rust | assoc types: type inference works with UFCS but not with method calls | ### STR
``` rust
#![crate_type = "lib"]
trait Tuple {
type Array: Toa<Item=Self>;
}
trait Toa {
type Item;
fn push(&mut self, Self::Item);
fn with_capacity(usize) -> Self;
}
#[cfg(not(works))]
fn f<T: Tuple>(t: T) -> T::Array {
let mut toa = Toa::with_capacity(1);
toa.push(t); //~ error: the type of this value must be known in this context
toa
}
#[cfg(works)]
fn g<T: Tuple>(t: T) -> T::Array {
let mut toa = Toa::with_capacity(1);
Toa::push(&mut toa, t);
toa
}
```
### Version
```
rustc 1.0.0-nightly (134e00be7 2015-02-09 19:01:37 +0000)
```
cc @nikomatsakis
(Deja Vu, I feel like I've reported/seen a similar problem before, but it didn't involve associated types)
| A-type-system,A-associated-items,T-compiler,A-inference,C-bug,T-types | low | Critical |
57,343,279 | rust | Output of independent artefacts might differ depending on unrelated options | Existence or lack of `--crate-type=bin` may influence output of other `crate-type` outputs. In general `libfoo.a` output by `--crate-type=bin,staticlib` and `--crate-type=staticlib` might be completely different.
For example using [this `foo.rs`](https://gist.github.com/nagisa/61edd3b202c6baf5404f#file-foo-rs), [this](https://gist.githubusercontent.com/nagisa/61edd3b202c6baf5404f/raw/1182045434b606ee2fa3362d2c89828c91d4e9de/libfoo-bin.a) is the list of a few first symbols when built with `--crate-type=bin,staticlib` and [this](https://gist.githubusercontent.com/nagisa/61edd3b202c6baf5404f/raw/e3ebb8e32a7c1e8ad8c7e88c95c1fd0cbb656569/libfoo.a), when `bin` crate-type is absent.
This is a quirk in rust’s entry point semantics and how current `middle/entry.rs` is implemented.
| I-needs-decision,T-compiler,C-bug | low | Minor |
57,394,562 | rust | Deref coercion not working for `Box<Trait>` | The following fails to compile:
``` rust
trait Trait {}
fn takes_ref(t: &Trait) {}
fn takes_box(t: Box<Trait>) {
takes_ref(&t)
}
fn main() { }
```
with
```
<anon>:5:15: 5:17 error: the trait `Trait` is not implemented for the type `Box<Trait>` [E0277]
<anon>:5 takes_ref(&t)
^~
```
despite the `Deref` implementation [here](https://github.com/rust-lang/rust/blob/master/src/liballoc/boxed.rs#L284-L288).
I believe this should work based on the [RFC](https://github.com/rust-lang/rfcs/pull/241).
| A-trait-system,T-compiler,C-bug | low | Critical |
57,457,237 | youtube-dl | [rtp] Add support for playlists | It seems not be possible to download from rtp.pt, the videos on one page, as we can do in a youtube playlist.
I tried and get this:
D:\Downloads>youtube-dl -f 22/17/18 --verbose -o ./%(playlist_title)s/%(playlist_index)s-%(title)s.%(ext)s http://www.rtp.pt/play/p831/a-quimica-das-coisas
[debug] System config: []
[debug] User config: []
[debug] Command-line args: ['-f', '22/17/18', '--verbose', '-o', './%(playlist_title)s/%(playlist_index)s-%(title)s.%(ext)s', 'http://www.rtp.pt/play/p831/a-quimica-das-coisas']
[debug] Encodings: locale cp1252, fs mbcs, out cp850, pref cp1252
[debug] youtube-dl version 2015.02.11
[debug] Python version 2.7.8 - Windows-8-6.2.9200
[debug] exe versions: rtmpdump 2.3
[debug] Proxy map: {}
[RTP] a-quimica-das-coisas: Downloading webpage
ERROR: requested format not available
Traceback (most recent call last):
File "youtube_dl\YoutubeDL.pyo", line 644, in extract_info
File "youtube_dl\YoutubeDL.pyo", line 690, in process_ie_result
File "youtube_dl\YoutubeDL.pyo", line 1137, in process_video_result
ExtractorError: requested format not available
| request | low | Critical |
57,499,932 | neovim | undo: collapse identical contiguous edits | When a change is undone, then a new change is made, if the new change is identical to the previously undone change (the next node in the current tree branch), just set the state of the undo history back to that next node instead of creating a new tree branch.
| enhancement | low | Major |
57,521,258 | go | x/build: trybots should rebase when testing | Currently with the trybot code, if Go's master is A and we have pending CLs B and C on A, currently we test B-on-A and C-on-A, but then when B is merged, we're still testing C on A, instead of C-on-B.
We should do:
https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#rebase-change
... which will add a patch set to the change, rebased. It could get spammy, though. Shawn says "don't complain when you have patch set 85 on a trivial one line change". So maybe we want to be careful when we do it. Maybe only for auto-submit.
| Builders,Friction | medium | Major |
57,525,997 | youtube-dl | append 3 on the script name | I don't know but i'm the only one here which wants to user youtube-dl on a machine with 2 python versions: 2 and 3?
So as pip i think it's a good idea to generate a script with a "-3" at the end to indicate we are accessing the bin folder of python 3.
I really don't know if it's trivial or easy, but if not just disregard the request. Thanks for the great app/tool
| request | low | Minor |
57,535,829 | go | proposal: spec: direct reference to embedded fields in struct literals | Consider
```
type E struct {
A int
}
type T struct {
E
}
```
This works:
```
T{E: E{A: 1}}
```
This does not:
```
T{A: 1}
```
Makes some struct literals more verbose than they need be, and makes them asymmetrical to their usage (where you can access the embedded struct's fields directly).
Can we allow it?
(cc @bradfitz)
| LanguageChange,Proposal,LanguageChangeReview | high | Critical |
57,652,721 | go | runtime: dead Gs cause span fragmentation | Once we allocate a G, it is allocated forever. We have no mechanism to free them.
We should free dead Gs if they sit in the global free queue for long enough. Or maybe free all of them at each GC?
I noticed this while debugging #8832. The stacks for dead Gs **are** freed at GC time. This leads to a fragmented heap because spans for G storage and stack storage alternate in the heap. When only the stacks are freed, the resulting free spans won't coalesce because the spans for storing the Gs aren't freed.
| compiler/runtime | medium | Critical |
57,670,179 | rust | Public items re-exported publicly in the same crate could have inlined docs | As an example of what I mean, see this page: http://doc.rust-lang.org/syntax/parse/lexer/index.html
There is a re-exports section:
``` rust
pub use ext::tt::transcribe::{TtReader, new_tt_reader, new_tt_reader_with_doc_flag};
```
All of those items are public and reachable, so they're documented in `ext::tt::transcribe`. But `lexer::new_tt_reader`, for example, does not appear in the search index and (less seriously) it's a little annoying to have to jump through another set of links to another page to read the docs for that function.
When a private item is re-exported publicly in the same crate, or a public item from another crate is re-exported, the docs are inlined and an entry is created in the search index. I think it would be reasonable to do the same for public intra-crate re-exports.
| T-rustdoc,C-feature-request | low | Minor |
57,707,227 | rust | Can’t declare lifetime for closure that returns a reference | When you declare closure argument types, there is no syntax to declare a lifetime parameter. And I guess lifetime elision does not apply to closures. Therefore, there seems to be no way to declare the type of a closure that returns a reference.
It compiles if you avoid declaring the type of the closure and depend on type inference. But then you would not be able to assign the closure to a local variable.
```
fn print_first(list: Vec<String>) {
let x: &str = list
.first()
.map(|s: &String| -> &str &s[]) // ERROR
//.map(|s: &String| &s[]) // ERROR
//.map(|s| -> &str &s[]) // ERROR
//.map(|s| &s[]) // OK
.unwrap_or("");
println!("First element is {}", x);
}
```
It gives a compiler error and a suggestion that does not make sense.
```
src/rusttest.rs:4:29: 4:32 error: cannot infer an appropriate lifetime for lifetime parameter 'a in function call due to conflicting requirements
src/rusttest.rs:4 .map(|s: &String| -> &str &s[])
^~~
src/rusttest.rs:1:1: 10:2 help: consider using an explicit lifetime parameter as shown: fn print_first<'a>(list: Vec<String>)
src/rusttest.rs:1 fn print_first(list: Vec<String>) {
src/rusttest.rs:2 let x: &str = list
src/rusttest.rs:3 .first()
src/rusttest.rs:4 .map(|s: &String| -> &str &s[]) // ERROR
src/rusttest.rs:5 //.map(|s: &String| &s[]) // ERROR
src/rusttest.rs:6 //.map(|s| -> &str &s[]) // ERROR
```
This bug is filed after I asked this [question on stack overflow](http://stackoverflow.com/questions/28512314/how-do-i-get-lifetime-of-reference-to-owned-object-cannot-infer-an-appropriate). It may be related to [Region inference fails for closure parameter #17004](https://github.com/rust-lang/rust/issues/17004).
| A-closures,T-compiler,C-bug | medium | Critical |
57,748,040 | node | vm: references to context inside objects are not === the original context | Failing test case:
``` js
var common = require('../common');
var assert = require('assert');
var vm = require('vm');
var sandbox = {};
sandbox.document = { defaultView: sandbox };
vm.createContext(sandbox);
vm.runInContext('var result = document.defaultView === this', sandbox);
assert.equal(sandbox.result, true);
```
Investigating this in my local build ... this is the only remaining test suite failure after switching jsdom to io.js vm.
| vm | medium | Critical |
57,753,156 | go | cmd/go: build the cgo artifacts for each package in parallel | The lack of parallelization for compilations within a single package doesn't matter too much when building go files, but does affect cgo compilation. I have a package with about 32k lines of (generated) C++. Compiling it serially takes ~10.5s. A small hack to cmd/go/build.go to compile C/C++/Obj-C files in parallel brings this down to ~3.7s.
The patch I hacked together to parallelize cgo compilation work is ~50 lines of deltas and is mostly contained in `builder.cgo()`.
PS The compilation times above were measured using go 1.4.1 on Mac OS X, but this code hasn't changed at head and similar compilation times can be seen there.
| ToolSpeed | medium | Critical |
57,779,816 | rust | rustc need a way to generate versioned libraries | The traditionnal way for a package distribution system (think `dpkg` for Debian, or `ports` under OpenBSD) to copte with upgrade of shared libraries is to have libraries with versioned number like `libfoo.so.MAJOR.MINOR`.
The rational for OpenBSD could be found here: http://www.openbsd.org/faq/ports/specialtopics.html#SharedLibs
It is designed for OpenBSD specifically, but it spots several issues and invalids solutions (like renaming the file after linking).
To resume the problem is (in the example of packaging `rustc` program):
- I want to package rustc under OpenBSD.
- rustc come with shared libs (`libstd-4e7c5e5c.so` for example).
- the library isn't versioned.
- so any futur upgrade of rustc package will break any compiled program that depends of `libstd-4e7c5e5c.so` (the file will change, some functions will changes, or be added or be removed).
Having versioned libraries permit the package distribution system to have, at the same time, multiple version of the same library (`libstd-4e7c5e5c.so.1.0` and `libstd-4e7c5e5c.so.3.1` for example), and having binaries that depend of differents versions.
| O-linux,P-low,T-compiler,T-dev-tools,C-feature-request | low | Minor |
57,817,489 | rust | Could type inference insert coercions to accommodate box desugaring? | The problem here was previously documented as a drawback in https://github.com/rust-lang/rfcs/pull/809 (with similar details provided in Appendix B).
Demonstration code:
``` rust
#![feature(box_syntax)]
// NOTE: Scroll down to "START HERE"
fn main() { }
macro_rules! box_ {
($value:expr) => { {
let mut place = ::BoxPlace::make();
let raw_place = ::Place::pointer(&mut place);
let value = $value;
unsafe { ::std::ptr::write(raw_place, value); ::Boxed::fin(place) }
} }
}
pub trait BoxPlace<Data> : Place<Data> { fn make() -> Self; }
pub trait Place<Data: ?Sized> { fn pointer(&mut self) -> *mut Data; }
pub trait Boxed<CoercedFrom> { type Place; fn fin(filled: Self::Place) -> Self; }
struct BP<T: ?Sized> { _fake_box: Option<Box<T>> }
impl<T> BoxPlace<T> for BP<T> {
fn make() -> BP<T> { make_pl() }
}
impl<T: ?Sized> Place<T> for BP<T> {
fn pointer(&mut self) -> *mut T { pointer(self) }
}
impl<T> Boxed<T> for Box<T> {
type Place = BP<T>;
fn fin(x: BP<T>) -> Self { finaliz(x) }
}
fn make_pl<T>() -> BP<T> { loop { } }
fn finaliz<T: ?Sized, CoercedFrom>(mut _filled: BP<CoercedFrom>) -> Box<T> { loop { } }
fn pointer<T: ?Sized>(_p: &mut BP<T>) -> *mut T { loop { } }
// START HERE
trait D1 { fn duh() -> Self; }
trait D2 { fn duh() -> Self; }
trait D3 { fn duh() -> Self; }
trait D4 { fn duh() -> Self; }
trait D5 { fn duh() -> Self; }
trait D6 { fn duh() -> Self; }
trait D7 { fn duh() -> Self; }
// THIS WORKS TODAY (pre box desugaring).
impl<T> D1 for Box<[T]> { fn duh() -> Box<[T]> { box [] } }
// D2/D3/D4/D5 WORK TOMORROW (they accommodate the box desugaring).
impl<T> D2 for Box<[T]> {
fn duh() -> Box<[T]> { let b: Box<[_; 0]> = box_!( [] ); b }
}
impl<T> D3 for Box<[T]> {
fn duh() -> Box<[T]> { (|b| -> Box<[_; 0]> { b })(box_!( [] )) }
}
impl<T> D4 for Box<[T]> {
fn duh() -> Box<[T]> { (|b: Box<[_; 0]>| { b })(box_!( [] )) }
}
fn the<X>(x:X) -> X { x }
impl<T> D5 for Box<[T]> {
fn duh() -> Box<[T]> { the::<Box<[_; 0]>>(box_!( [] )) }
}
// BUT: D6 and D7 do not work.
impl<T> D6 for Box<[T]> { fn duh() -> Box<[T]> { box_!([]) } }
impl<T> D7 for Box<[T]> {
// fn duh() -> Box<[T]> { box_!( [] ) }
//
// desugars to:
fn duh() -> Box<[T]> {
let mut place = ::BoxPlace::make();
let raw_place = ::Place::pointer(&mut place);
let value = [];
unsafe { ::std::ptr::write(raw_place, value);
::Boxed::fin(place) }
}
}
```
The question posed by this issue is: Could we enhance the type inference and/or the design of this protocol so that, by tracking the sized-ness of the type unification variables, we could determine where coercions need to be inserted.
| A-type-system,T-compiler,A-inference,C-feature-request,T-types | low | Major |
58,022,399 | go | x/tools/cmd/oracle: Support recursive search of packages to include in scope | Oracle takes a list of arguments that [set the analysis scope](https://docs.google.com/document/d/1SLk36YRjjMgKqe490mSRzOPYEDe0Y_WQNRv-EiFYUyw/view#heading=h.nwso96pj07q8). If a given argument (e.g. `github.com/example/project`) does not have any immediate source files, it is excluded from the analysis. However, many projects have sub-packages that do have main or test files, and enumerating these manually to oracle is difficult to manage. The user should have some way of indicating to oracle that a given path should be treated recursively and searched for any sub-packages that may have main or test files. In other words, given `github.com/example/project` which only has two sub-projects `github.com/example/project/subproject-one` and `github.com/example/project/subproject-two` which have main and/or test files, both should be included in the analysis scope.
This could be indicated with a command-line parameter ("includes packages recursively in scope") or as part of the path itself (`github.com/example/project/...`).
| NeedsInvestigation | low | Minor |
58,034,497 | go | runtime/race: eliminate dependency on libc | Race runtime currently depends on libc:
with CGO_ENABLED=0:
runtime/race(.text): __libc_malloc: not defined
runtime/race(.text): getuid: not defined
runtime/race(.text): pthread_self: not defined
...
This has several negative effects:
- don't work with CGO_ENABLED=0
- there is circular dependency between runtime/race and cmd/cgo
- cross-compilation is close to impossible
- external linkage is required
If we eliminate all libc dependencies from race runtime, all these problems go away.
| RaceDetector | medium | Major |
58,103,706 | neovim | Folds in saved session with invalid ranges cause sourcing the session to fail. | For example, if you `mksession` then your session file has something like `99,500fold` in it, but you've made changes to the file that fold applies to elsewhere so your file now has less than 500 lines, then loading the session will fail. Ideal behavior would be that the fold is simply ignored.
| bug-vim | low | Minor |
58,141,050 | go | x/build: coordinator shows trybot successful builds as still active | There's some bug with the interaction of trybots and them succeeding in the build coordinator.
Look at the screenshot: the builds are done, but they're in the "active" section.
Further, down the page it says:
```
*** trybot state
Change-ID: I5f58aa58e74bbe4ec91b2e9b8c81921338053b00 Commit: 160f5ff2a7fad1fafa6cd817d64ebf488bd2d1fd
Remain: 0, fails: []
linux-386: running=false
linux-amd64: running=false
linux-amd64-race: running=false
freebsd-386-gce101: running=false
freebsd-amd64-gce101: running=false
windows-386-gce: running=false
windows-amd64-gce: running=false
openbsd-386-gce56: running=false
openbsd-amd64-gce56: running=false
plan9-386-gcepartial: running=false
```
/cc @adg
| Builders | low | Critical |
58,155,842 | rust | Resolve shorthand projections (`T::A`-style associated type paths) based solely on type, instead of a Def | Right now [`astconv::associated_path_def_to_ty`](https://github.com/rust-lang/rust/blob/dfc5c0f1e8799f47f9033bdcc8a7cd8a217620a5/src/librustc_typeck/astconv.rs#L989-L993) takes a `def::TyParamProvenance` obtained from [either `def::DefTyParam` or `def::DefSelfTy`](https://github.com/rust-lang/rust/blob/dfc5c0f1e8799f47f9033bdcc8a7cd8a217620a5/src/librustc_resolve/lib.rs#L3926-L3937).
This information cannot be easily extracted from the type, and #22172 doesn't change that, which means `<T>::AssocTy` does not work at all (pretends to be ambiguous).
We should be able to make progress after #22172 and #22512 both land, and I believe @nikomatsakis has a solution in mind for dealing with at least _some_ cases.
After this is fixed, the `finish_resolving_def_to_ty` function introduced in #22172 can be split into `def_to_ty` and `resolve_extra_associated_types` and its callers would only need the latter for `<T>::A::B::C`, instead of providing a dummy `Def` to the entire thing.
| A-type-system,E-hard,C-enhancement,A-trait-system,A-associated-items,T-compiler,T-types | low | Major |
58,239,096 | go | cmd/compile: improve generated type equality code | geneq generates a series of if statements, each returning false if they fail. Creating instead a long conjunction would result in shorter, faster generated code.
It might also be worth reordering the tests to place all the ones involving a function call last.
It might also be worth trying to prevent some of the spurious checknils that are currently produced. In some cases know that we are dereferencing fields on a struct (not a pointer to a struct).
We also appear to be generating equality routines when we shouldn't be. The following strike me as possibly spurious:
- `TEXT type..eq.[0]text/tabwriter.cell(SB) text/tabwriter/tabwriter.go`. An array of length zero? Where does it come from? And the equality check should be trivial, not generated.
- `TEXT type..eq.[2]string(SB) golang.org/x/tools/cmd/godoc/blog.go`. I don't see anything resembling `[2]string` in `blog.go`.
- `TEXT type..eq.[1]interface {}(SB) golang.org/x/tools/cmd/godoc/blog.go`. I don't see where this came from in `blog.go`. And an equality check for an array of length 1 should just be a check of the underlying type.
Look into these.
Given all the above, it might be worth also taking a closer look at the generated hash routines as well.
I'll poke at these once the c2go conversion is complete.
| compiler/runtime | low | Major |
58,314,657 | You-Dont-Know-JS | "types & grammar": update ch3 to talk about ES6 change to native's prototypes | This section https://github.com/getify/You-Dont-Know-JS/blob/master/types%20&%20grammar/ch3.md#prototypes-as-defaults and the one before it, should be updated with recent ES6 changes to the native prototypes. See: https://esdiscuss.org/topic/array-prototype-change-was-tostringtag-spoofing-for-null-and-undefined
| for second edition | medium | Minor |
58,389,374 | rust | Error messages are odd for delegating traits | This is a more general version of https://github.com/rust-lang/rust/issues/22478. (i.e. probably should be considered to supersede it)
``` rust
trait A {
fn a(self);
}
trait B {
fn b(self);
}
impl<T: B> A for T {
fn a(self) {
B::b(self)
}
}
struct C;
fn main() {
A::a(C);
}
```
Compiling this will result in
```
t.rs:18:5: 18:9 error: the trait `B` is not implemented for the type `C` [E0277]
t.rs:18 A::a(C);
^~~~
error: aborting due to previous error
```
but `impl<T: B> A for T`, `T = C` and `C` does not implement `B` and therefore the impl in question should not even be taken into consideration, even if it is the only implementation of a trait.
<!-- TRIAGEBOT_START -->
<!-- TRIAGEBOT_ASSIGN_START -->
<!-- TRIAGEBOT_ASSIGN_DATA_START$${"user":"PoignardAzur"}$$TRIAGEBOT_ASSIGN_DATA_END -->
<!-- TRIAGEBOT_ASSIGN_END -->
<!-- TRIAGEBOT_END --> | A-trait-system,P-medium,E-mentor,T-compiler,E-help-wanted,C-bug | medium | Critical |
Subsets and Splits