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 |
|---|---|---|---|---|---|---|
121,776,981 | TypeScript | is there a way to narrow down the amount of information that goes to the member info tooltip of intellisense? | Namely, is there a way to opt out from seeing:
- union/intersection type constituens
- members of a type alias referring to an anonymous product type?
| Suggestion,Help Wanted,Effort: Moderate,Domain: Quick Info | low | Minor |
121,786,458 | rust | Potential optimization: eager nulling of Weak references | [Apparently](https://www.mikeash.com/pyblog/friday-qa-2015-12-11-swift-weak-references.html) Swift does this:
> When a weak reference is loaded, the runtime checks the target's state. If the target is a zombie, then it zeroes the weak reference, decrements the weak reference count, and returns nil.
In our world, this would mean `Weak` would store a `Cell`, which would be `set` to null in `upgrade()` if the strong count was found to be zero. This could allow the allocation to be freed earlier than it otherwise would be. I'm not sure if it would be a significant pessimization in any other respects?
(I just checked what other operations are available on `Weak` - this could also potentially be done in `clone()`.)
| I-slow,C-enhancement,T-libs-api,C-optimization | low | Minor |
121,832,954 | vscode | Support regex in files.exclude => when | I would like to ignore JS files in my project when there's a matching TS _or_ matching TSX file. Right now I have to choose one or the other. Please support making the "when" directive in the "files.exclude" workspace setting use a regex, so I could do this:
``` javascript
{
"files.exclude": {
"**/*.js": { "when": "$(basename).tsx?"},
}
}
```
| feature-request,file-explorer,file-glob | medium | Critical |
121,836,810 | TypeScript | No completion builder present after a '<' | Input `>` key on a following code.
``` ts
<T
```
expected:
``` ts
<T>
```
actual:
``` ts
<TemplateStringsArray>
```
experience:
``` ts
// writing an arrow function with generics
let f = <TemplateStringsArray>
```
| Bug,Help Wanted | low | Major |
121,837,854 | go | x/net/http2: investigate client write buffering | testClientWrite in http2 mode with CL https://go-review.googlesource.com/#/c/17751/1 fails, but the fails aren't that consistent
Run 1:
``` shell
$ go test -cover
--- FAIL: TestClientWrites_h2 (0.00s)
client_test.go:578: Get request did 8 Write calls, want 1
client_test.go:587: Post request did 3 Write calls, want 1
FAIL
coverage: 78.6% of statements
exit status 1
FAIL net/http 23.081s
```
Run 2:
``` shell
$ go test -cover
--- FAIL: TestClientWrites_h2 (0.01s)
client_test.go:578: Get request did 8 Write calls, want 1
FAIL
coverage: 78.5% of statements
exit status 1
```
The diff that produced this is
``` diff
diff --git a/src/net/http/client_test.go b/src/net/http/client_test.go
index e72f3bc..05a543c 100644
--- a/src/net/http/client_test.go
+++ b/src/net/http/client_test.go
@@ -550,11 +550,14 @@ func (c *writeCountingConn) Write(p []byte) (int, error) {
// TestClientWrites verifies that client requests are buffered and we
// don't send a TCP packet per line of the http request + body.
-func TestClientWrites(t *testing.T) {
+func TestClientWrites_h1(t *testing.T) { testClientWrites(t, h1Mode) }
+func TestClientWrites_h2(t *testing.T) { testClientWrites(t, h2Mode) }
+
+func testClientWrites(t *testing.T, h2 bool) {
defer afterTest(t)
- ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
+ cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
}))
- defer ts.Close()
+ defer cst.close()
writes := 0
dialer := func(netz string, addr string) (net.Conn, error) {
@@ -564,9 +567,10 @@ func TestClientWrites(t *testing.T) {
}
return c, err
}
- c := &Client{Transport: &Transport{Dial: dialer}}
+ cst.c.Transport.(*Transport).Dial = dialer
- _, err := c.Get(ts.URL)
+ c := cst.c
+ _, err := c.Get(cst.ts.URL)
if err != nil {
t.Fatal(err)
}
@@ -575,7 +579,7 @@ func TestClientWrites(t *testing.T) {
}
writes = 0
- _, err = c.PostForm(ts.URL, url.Values{"foo": {"bar"}})
+ _, err = c.PostForm(cst.ts.URL, url.Values{"foo": {"bar"}})
if err != nil {
t.Fatal(err)
}
```
| NeedsInvestigation | low | Critical |
121,860,717 | kubernetes | Using dynamic resource usage statistics from heapster for pod scheduling | As per the master branch, a pod's _resource usages_ are taken as its _resource requests_. We have extended it to be the maximum of the pod's _resource requests_ and 95th percentile of its resource usages in past hour(taken from heapster). [Here](https://github.com/nishantsny/kubernetes/tree/dynamicScheduling) is the repository. The significant changes are in _predicates.go_ and _priorities.go_
We need help on the following issues:
1. We do not know how to access the heapster api-endpoint directly. Right now, we have hardcoded it as _https://10.245.1.2/api/v1/proxy/namespaces/kube-system/services/heapster/_ (it is the heapster endpoint for vagrant setup). Some way to get the kubernetes master ip address would also work.
2. We are not sure if maximum of requests and 95th percentile of last hour is a good idea. Please suggest some other statistic.
PS: In our code there is a new resource request parameter named _softRequests_ which is same as _requests_. We will remove it shortly.
| priority/backlog,sig/scheduling,lifecycle/frozen | low | Major |
121,869,635 | neovim | shada: add support for `set shada+=` and `set shada-=` | It would be useful if `+=` and `-=` would be supported with `set shada`.
Currently `set shada+='500` won't replace the existing `'100`.
I've noticed that `set shada+=nfoo` twice won't re-add it, but `set shada+=nbar` would result in `nfoo,nbar` at the end.
This is required for only changing some of the defaults, especially with the `n` option to use a different name, e.g. if you want to use different files for different sessions/workspaces.
| enhancement,options | low | Minor |
121,884,578 | electron | Add FreeBSD support to electron | [](https://www.bountysource.com/issues/29075473-add-freebsd-support-to-electron?utm_source=29075473&utm_medium=shield&utm_campaign=ISSUE_BADGE)
Related: #2452
| enhancement :sparkles: | high | Critical |
121,937,595 | vscode | vscode/releases page missing binaries | Just wondering... why doesn't the [releases](https://github.com/Microsoft/vscode/releases) page have vscode binaries? I only see the source code downloads. [Atom](https://github.com/atom/atom/releases) and [Brackets](https://github.com/adobe/brackets) both use GitHub to publish binaries...
Would be handy in case someone wanted to download an older release or if Microsoft's servers were down.
Inspired by [#1084](https://github.com/Microsoft/vscode/issues/1084)
| feature-request | low | Major |
121,958,287 | godot | -w switch is not in effect when opening projects from the project manager | The new -w switch works properly for opening a scene with "godot -e -w scene.scn", but if opening the project from the project manager, it will try to maximize like if the switch wasn't in effect.
| enhancement,topic:editor | low | Major |
121,983,099 | opencv | Bug in Superres modules | In the supperres(Super resolution) modules, in the btv_l1.cpp, the calcRelativeMotions function is wrong. Its goal is to get the big motions between two far away frames by making use of the small motions between adjacent frames between them. However, the combination way of motions should not be addition. You should remap the whole image iteratively.
| bug,priority: normal,category: superres | low | Critical |
122,012,159 | vscode | Support contributing different keybindings based on keyboard layout | VSCode should ship out of the box with multiple keymaps (based on/optimized for each keyboard layout).
e.g. toggle line comment should be `ctrl+7` on swiss keyboards, etc.
VSCode should detect at runtime the current system keyboard layout and employ different defaults, based on the keyboard layout.
| feature-request,keyboard-layout | high | Critical |
122,125,274 | go | image/jpeg: add a jpeg option to disable chroma subsampling | It seems that golang's jpeg encoder only supports downsampling. It would be nice to be able to fine-tune what kind of subsampling is used when encoding jpegs, or alternatively disable downsampling when using a large quality value.
This is a continuation of:
https://groups.google.com/forum/#!topic/golang-nuts/VJY87VQpgws
| NeedsInvestigation,FeatureRequest | low | Minor |
122,142,745 | go | cmd/internal/obj: -trimpath help text is misleading | Tested with Go 1.5.2.
The -trimpath option is documented as follows:
```
$ go tool asm -help 2>&1|grep -A1 trimpath
-trimpath string
remove prefix from recorded source file paths
...
$ go tool compile -help|grep -A1 trimpath
-trimpath prefix
remove prefix from recorded source file paths
```
However, it would appear that it mistakenly removes the leading '/' from the resulting path:
```
$ export PROTO_DIR=/builds/go-proto-area
$ cd $(PROTO_DIR)/usr/lib/gocode/1.5/src/golang.org/x/crypto/blowfish
$ go install -asmflags -trimpath=$PROTO_DIR -gcflags -trimpath=$PROTO_DIR
$ strings ../../../../../pkg/solaris_amd64/golang.org/x/crypto/blowfish.a | grep 'lib\/'
xusr/lib/gocode/1.5/src/golang.org/x/crypto/blowfish/block.go
xusr/lib/gocode/1.5/src/golang.org/x/crypto/blowfish/block.go
...
```
If I add a terminating slash, then it fails to trim entirely:
```
$ export PROTO_DIR=/builds/go-proto-area/
$ cd $(PROTO_DIR)/usr/lib/gocode/1.5/src/golang.org/x/crypto/blowfish
$ go install -asmflags -trimpath=$PROTO_DIR -gcflags -trimpath=$PROTO_DIR
$ strings ../../../../../pkg/solaris_amd64/golang.org/x/crypto/blowfish.a | grep 'lib\/'
/builds/go-proto-area/usr/lib/gocode/1.5/src/golang.org/x/crypto/blowfish/block.go
/builds/go-proto-area/usr/lib/gocode/1.5/src/golang.org/x/crypto/blowfish/block.go
...
```
This appears to be due to a off-by-one error (or bad assumption) made in src/cmd/internal/obj/obj.go in setFile():
```
// Remove leading TrimPathPrefix, or else rewrite $GOROOT to $GOROOT_FINAL.
if h.TrimPathPrefix != "" && hasPathPrefix(abs, h.TrimPathPrefix) {
if abs == h.TrimPathPrefix {
abs = ""
} else {
abs = abs[len(h.TrimPathPrefix)+1:]
}
```
| Documentation,NeedsInvestigation,compiler/runtime | low | Critical |
122,174,787 | opencv | real_time_pose_estimation tutorial could use new vtk mesh functionality | Right now the [real_time_pose_estimation](https://github.com/Itseez/opencv/tree/master/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation) tutorial takes in a [split of .ply for the mesh only, and .yaml for the textures](https://github.com/Itseez/opencv/blob/master/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/main_detection.cpp#L119). This isn't very useful for any real existing data as far as I'm aware, so I suggest using viz3d to support ply and obj files, especially when the ply can hold textures. Here is what is hopefully the vtk loading test and tutorial: [tests_simple.cpp](https://github.com/Itseez/opencv/blob/master/modules/viz/test/tests_simple.cpp), [test_tutorial3.cpp](https://github.com/Itseez/opencv/blob/master/modules/viz/test/test_tutorial3.cpp).
@edgarriba you may be interested in this issue since it pertains to your changes.
| feature,category: viz | low | Minor |
122,322,419 | TypeScript | Grammar checking errors should be reported during binding phases instead of type-checking phase | _From @StrongRef on December 15, 2015 9:32_
When declaring an octal literal, an error is shown.
However, if another error is introduced, the error for octal literal usage is omitted.
Another strict rule violation, this time both errors are visible.
I could like into this one, just want to make sure this is an actual error.
_Copied from original issue: Microsoft/vscode#1318_
| Suggestion,Committed,VS Code Tracked | low | Critical |
122,343,514 | opencv | grabcut error | I'm getting the following error using grabcut:
`OpenCV/opencv/modules/imgproc/src/grabcut.cpp:216: error: (-215) dtrm > std::numeric_limits<double>::epsilon() in function calcInverseCovAndDeterm`
It seems like [this](http://stackoverflow.com/questions/13007926/opencv-grabcut-cpp-error) issue has either resurfaced or the patch has never made it to the master branch.
| RFC | low | Critical |
122,428,072 | go | cmd/cgo: cgo gets confused by equivalent #defined types | Unfortunately I don't have a simple example for this one. I observed it while working with a .h file that was conditionally including all sorts of other .h files and having its own defines. The problem occurred with __u8 and u8 types. They were both eventually defined as "unsigned char" but cgo considered them different and even got confused in the following case:
- a C call returned a `[16]C.__u8` (checked with a Printf %#v)
- I created a Go function that took a `[16]C.__u8` as the only argument and passed it the value I got above:
`func uuidBytesToString(ub [16]C.__u8) string {...}`
When trying to compile it I got this error message:
`cannot use cHandle.id.b (type [16]C.__u8) as type [16]C.u8 in argument to uuidBytesToString`
It thinks that the func signature is `[16]C.u8` instead of `[16]C.__u8`, but even so these 2 types are eventually `unsigned char`
| compiler/runtime | low | Critical |
122,504,044 | opencv | Unexpected numerical problem in cv::warpAffine | Hi,
we have encountered a small numerical problem in warpAffine which leads to intensity differences of up to 5 pixels, where 0 is expected (and almost everywhere visible).
Normally, I would not mention such an issue, since some problems/differences are to be expected but in this specific case, the error looks systematic.
The issue can be reproduced with OpenCV 3.0.0 (I think we use PPL for parallelization but I would need to double check) and the attached code below:
[main.txt](https://github.com/Itseez/opencv/files/64028/main.txt) (the main.cpp for reproducing this issue)
Regards,
Hauke
| category: imgproc,affected: 2.4,affected: 3.4,RFC | low | Critical |
122,522,622 | go | gccgo, runtime: runtime-gdb.py does not exist for gccgo | I have been working on the runtime-gdb.py script so it can be used with gccgo for use in displaying the goroutine information.
I'd like to include it somewhere in the gccgo install for others to use but not sure where would be best. Possibly under the share directory.
I don't think it needs to be found automatically on gdb startup like it is in golang, just make it available somewhere so it can be used.
| compiler/runtime | low | Minor |
122,569,380 | rust | Avoid type mismatch error where a variable is bound with different ref-ness | e.g.,
```
match x {
opts::a(ref i) | opts::b(i) => {}
//~^ ERROR variable `i` is bound with different mode in pattern #2 than in pattern #1
//~^^ ERROR mismatched types
```
Where the field of `a` and `b` has the same type
cc #30320
| C-enhancement,A-diagnostics,T-compiler,D-verbose | low | Critical |
122,611,622 | kubernetes | Kubelet should enforce access to images after they've already been pulled to a node | # Problem statement
Some images require pull secrets in order to be used by the Kubelet. Pull secrets are per namespace. Imagine the following scenario:
1. If a pod in namespaceA has valid pull secrets for `foo/bar:stable`, when it is scheduled to a given node, the Kubelet uses the pull secrets to pull the image to the node
2. If a pod in namespaceB also refers to `foo/bar:stable` but does not have valid pull secrets for it, if it happens to be scheduled to the same node as the pod in step 1, the Kubelet respects the image pull policy
3. Because the image already exists on the node, if the pull policy is Never or IfNotPresent, the Kubelet runs the pod, even though namespaceB shouldn't be able to use that image.
# Proposed solutions
## Option 1 - Kubelet flag to ignore pull policy and always try to pull
Add a flag to the kubelet, `--always-pull-images` (or something similarly named) that, if true, would force the Kubelet to attempt to pull every image prior to running a pod, regardless of the image's pull policy.
Pros:
- Easy to implement
- Guarantees that a namespace is allowed to use an image
Cons:
- Overrides user-specified intent in image pull policy
- Requires remote registry to be online to check authorization
- Introduces small amount of latency to pod startup time (because of the additional network requests to the registry)
## Option 2 - Keep an in-memory cache of which namespaces are allowed to use which images
After an image has been successfully pulled, record the mapping from namespace to image in an in-memory cache in the Kubelet. Subsequent attempts by pods in the same namespace to use the same image would respect the image pull policy. Any attempts by pods in other namespaces to use this image would ignore the image pull policy and instead force a pull attempt.
Pros:
- Doesn't override user-specified intent in image pull policy
- No added latency to pod startup time
Cons:
- Doesn't handle authorization revocation; if the credentials to pull an image have changed in the remote registry, there is no way to evict an entry from the cache, possibly allowing access to an image that would otherwise fail with option 1. This could be mitigated if the entries in the cache have a TTL.
# Suggested path forward
Looking for feedback from the community on this one. I'd like to implement option 1 in the short term, with the default being false (so image pull policy is respected) to keep the status quo. If we can come to an agreement on option 2, I'd like to move to that eventually.
@kubernetes/goog-node @kubernetes/rh-cluster-infra @kubernetes/sig-node
| priority/backlog,sig/node,kind/feature,sig/auth,help wanted,lifecycle/frozen | medium | Critical |
122,623,932 | rust | Manual does not define "data reached through a shared reference". | The manual uses the expression "data reached through a shared reference" but does not define it. In the following code, is `x` reached through a shared reference?
``` rust
pub unsafe fn a() -> u8 {
let mut x = 11;
b(&x as *const u8 as *mut u8);
x
}
unsafe fn b(x: *mut u8) {
*x = 22;
}
```
| C-enhancement,T-lang | medium | Critical |
122,672,973 | TypeScript | No completion builder present after a '(' | Input `:` key.
``` ts
let f: (val
```
expected:
``` ts
let f: (val:
```
actual:
``` ts
let f: (ValidityState:
```
Divides #6079.
| Bug,Help Wanted | low | Minor |
122,759,813 | go | tour: is there an example about operators? | Context: https://tour.golang.org/basics/11
I couldn't found a talk about operators, it would be good if there was one, specially about the more advanced bitwise ones.
| NeedsInvestigation | low | Minor |
122,813,288 | TypeScript | Why do multiple ES6 imports compile to multiple requires / define() deps with suffixed names? | I didn't find any existing issue for this, but why does
``` typescript
import { foo } from "a";
foo();
import { bar } from "a";
bar();
```
compile to
``` javascript
define(["require", "exports", "a", "a"], function (require, exports, a_1, a_2) {
a_1.foo();
a_2.bar();
});
```
instead of
``` javascript
define(["require", "exports", "a"], function (require, exports, a) {
a.foo();
a.bar();
});
```
and similar for cjs output? The latter is how one would write the JS, and does away with the `_1` `_2` names as well.
---
Of course in this example they can be combined. My original code has a mix of import-from and export-from.
``` typescript
import * as set from "./utility/set";
export { Set } from "./utility/set";
// Do things with set
```
I _could_ change that to
``` typescript
import * as set from "./utility/set";
const Set = set.Set;
export { Set };
// Do things with set
```
but even a single import still has the `_1` name in the generated JS, which is what I'm really curious about.
| Bug,Help Wanted,Effort: Moderate | low | Minor |
122,857,156 | go | net/http: Transport.RoundTrip errors could be more informative | ```
go version go1.5 linux/amd64
```
```
Ubuntu 14.04.3 LTS
```
I made an HTTP request to a server that accepts all TCP connections and then immediately closes them. I was expecting a meaningful error such as "connection closed before request could be sent" but http.RoundTrip returned EOF.
Here are client and server snippets that reproduce this. The client:
```
package main
import (
"fmt"
"net"
"net/http"
)
func main() {
dialer := &net.Dialer{}
transport := &http.Transport{
Dial: dialer.Dial,
}
request, _ := http.NewRequest("GET", "http://127.0.0.1:19870/", nil)
_, err := transport.RoundTrip(request)
fmt.Println(err)
}
```
Output is:
```
EOF
```
And the server:
``` go
package main
import "net"
func main() {
ln, _ := net.Listen("tcp", ":19870")
conn, _ := ln.Accept()
conn.Close()
}
```
Here is a dump of the TCP exchange:
```
17:16:31.017342 IP localhost.52287 > localhost.19870: Flags [S], seq 3991906392, win 43690, options [mss 65495,sackOK,TS val 27880590 ecr 0,nop,wscale 7], length 0
E..<..@[email protected]..........?M....X.........0.........
..l.........
17:16:31.017356 IP localhost.19870 > localhost.52287: Flags [S.], seq 530413255, ack 3991906393, win 43690, options [mss 65495,sackOK,TS val 27880590 ecr 27880590,nop,wscale 7], length 0
E..<..@.@.<.........M..?..v....Y.....0.........
..l...l.....
17:16:31.017367 IP localhost.52287 > localhost.19870: Flags [.], ack 1, win 342, options [nop,nop,TS val 27880590 ecr 27880590], length 0
E..4..@[email protected]..........?M....Y..v....V.(.....
..l...l.
17:16:31.017514 IP localhost.19870 > localhost.52287: Flags [F.], seq 1, ack 1, win 342, options [nop,nop,TS val 27880591 ecr 27880590], length 0
E..4.F@.@."|........M..?..v....Y...V.(.....
..l...l.
17:16:31.019472 IP localhost.52287 > localhost.19870: Flags [F.], seq 1, ack 2, win 342, options [nop,nop,TS val 27880591 ecr 27880591], length 0
E..4..@[email protected]..........?M....Y..v....V.(.....
..l...l.
17:16:31.019493 IP localhost.19870 > localhost.52287: Flags [.], ack 2, win 342, options [nop,nop,TS val 27880591 ecr 27880591], length 0
E..4.G@.@."{........M..?..v....Z...V.(.....
..l...l.
```
| Testing,help wanted,NeedsFix,early-in-cycle | low | Critical |
122,905,238 | go | cmd/cgo: signal arrived during external code execution that calls setjmp on Windows | Processor Intel(R) Core(TM) i7-4790 CPU @ 3.60GHz
OS: Windows 7 64
golang:1.5.2
gcc:mingw-w64 version 5.2.0 x86_64-posix-seh-rt_v4-rev1
When I compile golang with some external c code which using the setjmp and longjmp,the program crash.
My c code is here (It's in a c file in a directory which implements package lua)
```
#include <stdio.h>
#include <setjmp.h>
void Print(){
jmp_buf c;
if(setjmp(c)==0){
longjmp(c,1);
}
else{
printf("receive an exception\n");
}
}
```
My go code
```
package main
import "github.com/redstorm-fyy/go-lua/lua"
func main() {
lua.Print()
}
```
Important!
It crashes when the c code is in an external file.When the c code is just up the .go file's import "C",It does not crash.
Crash information
Exception 0xc0000028 0x0 0x0 0x77b096f8
PC=0x77b096f8
signal arrived during external code execution
github.com/redstorm-fyy/go-lua/lua._Cfunc_Print()
??:0 +0x38
github.com/redstorm-fyy/go-lua/lua.Print()
E:/GolangRoot/src/github.com/redstorm-fyy/go-lua/lua/luago.go:587 +0x1b
main.main()
E:/GolangRoot/src/github.com/redstorm-fyy/go-lua/example/exam.go:6 +0x1b
goroutine 17 [syscall, locked to thread]:
runtime.goexit()
c:/go/src/runtime/asm_amd64.s:1721 +0x1
rax 0xf
rbx 0xc0000028
rcx 0x22ebd0
rdi 0x22c000
rsi 0x22f7b0
rbp 0x22f230
rsp 0x22eb10
r8 0x0
r9 0x400000
r10 0x0
r11 0x22f330
r12 0x22fe60
r13 0x22fdb0
r14 0x4013e8
r15 0x584024
rip 0x77b096f8
rflags 0x202
cs 0x33
fs 0x53
gs 0x2b
| help wanted,OS-Windows,NeedsFix | medium | Critical |
122,944,409 | go | cmd/vet: vet is reporting lock value copying on composite literal assignment | The code is the following:
```
r := hipacheRouter{prefix: "hipache"}
err := r.AddBackend("tip")
c.Assert(err, check.IsNil)
config.Set("hipache:redis-server", "127.0.0.1:6380")
defer config.Unset("hipache:redis-server")
r = hipacheRouter{prefix: "hipache"}
```
go vet is reporting "assignment copies lock value to r: hipache.hipacheRouter" in the last line. The type hipacheRouter indeed contains a lock:
```
type hipacheRouter struct {
sync.Mutex
prefix string
pool *redis.Pool
}
```
But as stated in the code, I'm copying a composite literal to r, so go vet should not complain about that. Changing the variable to `r2` and the attribution to a declaration makes vet happy. I've also tried to make the mutex a named field, and it didn't help.
I tried to reproduce it with a simple Go program and failed to do so. I have the impression that there's another violation going on, and vet is reporting lock copying.
It works on Go 1.5.2, and fails on Go 1.6beta1, both on linux_amd64 and darwin_amd64. Details are available on Travis:
- Go 1.5.2 build: https://travis-ci.org/tsuru/tsuru/jobs/97656688#L234
- Go 1.6beta1 build: https://travis-ci.org/tsuru/tsuru/jobs/97656689#L234
| Analysis | low | Critical |
122,967,496 | go | cmd/link: Support absolute import paths for main packages with -X | ##### What version of Go are you using (go version)?
`go1.5.1`
##### What operating system and processor architecture are you using?
`darwin/amd64`
##### What did you do?
``` console
$ go get -ldflags="-X github.com/tsenart/hello.Version=v0.0.1" github.com/tsenart/hello
$ hello
```
##### What did you expect to see?
``` console
v0.0.1
```
##### What did you see instead?
```
```
| compiler/runtime | low | Minor |
122,994,291 | opencv | OpenCV FileStorage only supports YAML 1.0 which is now deprecated. | Problem: LibYAML explicitly rejects YAML 1.0 files and thus OpenCV YAML files require modification to be read in other programs using LibYAML (e.g. python, R, etc.). Example YAML 1.0:
`%YAML:1.0
data: [ 1., 467389., 1318., 626., 1., 41965]`
Solution: modify FileStorage to write YAML 1.1 files. Example YAML 1.1:
`%YAML 1.1 --- data: [ 1., 467389., 1318., 626., 1., 41965]`
| feature,category: core,affected: 2.4,affected: 3.4 | low | Major |
123,186,973 | go | x/mobile/exp/sensor: geolocation | Add to x/mobile the ability to retrieve current latitude/longitude from e.g. GPS. (Relates to #9330)
| mobile | low | Major |
123,271,700 | opencv | potential bug in VideoCapture_DShow | I work on window 10 and want to capture image from a usb camera using opencv 3.0.
My camera can only work at YUY2_640_480_30FPS or MJPEG_640_480_90FPS.
I prefer MJPEG_640_480_90FPS since it has higher frame rate, however, in defaut, my camera works at YUY2_640_480_30FPS. In order to make it working at MJPEG_640_480_90FPS, I thought I should write some codes like,
```
cv::VideoCapture cap;
cap.open(0);
bool flag = cap.set(CV_CAP_PROP_FOURCC, CV_FOURCC('M', 'J', 'P', 'G'));
cap.set(CV_CAP_PROP_FPS, 90);
cap.set(CV_CAP_PROP_FRAME_HEIGHT, 400);
cap.set(CV_CAP_PROP_FRAME_WIDTH, 640);
```
I tried, but it didn't work. My camera insisted on working at YUY2_640_480_30FPS.
I debuged and found that the failure is due to some strange codes in the following function
```
VideoCapture_DShow::setProperty(int propIdx, double propVal)
```
There you can found
```
if (m_width > 0 && m_height > 0)
{
if (m_width != g_VI.getWidth(m_index) || m_height != g_VI.getHeight(m_index) )
{
int fps = static_cast<int>(g_VI.getFPS(m_index));
g_VI.stopDevice(m_index);
g_VI.setIdealFramerate(m_index, fps);
g_VI.setupDeviceFourcc(m_index, m_width, m_height, m_fourcc);
}
bool success = g_VI.isDeviceSetup(m_index);
if (success)
{
m_widthSet = m_width;
m_heightSet = m_height;
m_width = m_height = m_fourcc = -1;
}
return success;
}
```
The device will only be reseted if m_width != g_VI.getWidth(m_index) || m_height != g_VI.getHeight(m_index).
However, in my case, my camera only has two working modes, in both of which height = 640 and width = 400. So, logically, there is no way to change the working mode of my camera from YUY2_640_480_30FPS to MJPEG_640_480_90FPS.
I modified
```
if (m_width != g_VI.getWidth(m_index) || m_height != g_VI.getHeight(m_index) )
```
to
```
if (m_width != g_VI.getWidth(m_index) || m_height != g_VI.getHeight(m_index) || m_fourcc != g_VI.getFourcc(m_index)) .
```
Now, it works.
So, is
```
if (m_width != g_VI.getWidth(m_index) || m_height != g_VI.getHeight(m_index) || m_fourcc != g_VI.getFourcc(m_index))
```
better?
If i have misunderstood something, can someone suggest a way to make my camera working at MJPEG_640_480_90FPS without modifying OPENCV's codes.
| bug,category: videoio | low | Critical |
123,291,765 | youtube-dl | Site Support request: sproutvideo.com | Example File : (Type can be sd or hd - if no type is specified the video will playback in sd)
SD : http://videos.sproutvideo.com/embed/e89bddb01f1be3cf60/0d7fb4d67f328c8b?type=sd
HD : http://videos.sproutvideo.com/embed/e89bddb01f1be3cf60/0d7fb4d67f328c8b?type=hd
here is the "dump request":
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
| site-support-request | low | Minor |
123,311,150 | react | DataTransfer's dropEffect not working on IE/Edge with not minified version react.js | code exmaple: [Non-minified version](https://jsfiddle.net/sy7eja68/) and [Minified version](https://jsfiddle.net/sy7eja68/1/)
Both have the same code, html and js, the only difference is referenced to different version of react.js files.
There are three boxes. Dragging the "**drag me**" box will show a "**start**" at the top, then show a "**over**" if it is dragged over either "**normal drop**" or "**drop react**" box, and show a "**end**" with a drop to the two drop boxes.
Everything works fine on my Firefox(43.0.1), and the the [Minified version](https://jsfiddle.net/sy7eja68/1/) works fine on my IE 11, and Edge(13).
The only thing dose not work is the [Non-minified version](https://jsfiddle.net/sy7eja68/) on IE/Edge.
When dragging over the "**drop react**" box, there shows **NO** "over". In the F12 console, I can see lines of "`SCRIPT16389: Unspecified error.`". And with `console.log(ev.dataTransfer)`, I get this result:
```
[object DataTransfer] {
dropEffect: <Permission denied>,
effectAllowed: "all",
files: FileList {...},
items: DataTransferItemList {...},
types: DOMStringList {...}
}
```
I thought the `dropEffect` should also be accessible on IE/Edge with non-minified version react.js files?
| Type: Bug,Browser: IE | low | Critical |
123,344,471 | kubernetes | Support for managing revoked certs | Authenticating users via x509 certs is important, but the project seems to be missing a mechanism to revoke certs (without throwing the entire chain away and regenerating ALL certs for all users).
It would be great to be able to declare which certs are invalid, and have the kube-apiserver, kubelets, and all other cert-dependent services deny service for requests with the now-invalid cert.
https://en.wikipedia.org/wiki/OCSP_stapling appears to be one way to solve this.
FYI - this is the same idea as the issue with CoreOS: https://github.com/coreos/etcd/issues/4034
| priority/backlog,sig/api-machinery,kind/feature,sig/auth,lifecycle/frozen | high | Critical |
123,468,428 | vscode | Task and/or Extension Command User Arguments On Entry | I am creating an extension and I want the end user to be able to enter an argument (say string) at the step they select "Run Task". The only current workaround I can think of is informing the user to edit the tasks.json file with the arguments, but what I am asking/requesting is that they could enter a one time use argument at the point they call the task from the command pallet, for instance Run Task, then My Task --My Argument. I am having the same issues with extension commands. To my knowledge there is no way to get a user argument into an extension command at the point of execution from the command pallet.
See my stack overflow on this topic here:
http://stackoverflow.com/questions/34382899/visual-studio-code-user-defined-argument/34385950?noredirect=1#comment56564014_34385950
| feature-request,api | medium | Critical |
123,486,171 | opencv | undefined reference to `glRotated' | ```
[ 97%] Building CXX object samples/gpu/CMakeFiles/example_gpu_opengl.dir/opengl.cpp.o
Linking CXX executable ../../bin/gpu-example-opengl
CMakeFiles/example_gpu_opengl.dir/opengl.cpp.o: In function `draw(void*)':
opengl.cpp:(.text._Z4drawPv+0x21): undefined reference to `glRotated'
CMakeFiles/example_gpu_opengl.dir/opengl.cpp.o: In function `main':
opengl.cpp:(.text.startup.main+0x4ae): undefined reference to `glMatrixMode'
opengl.cpp:(.text.startup.main+0x4b3): undefined reference to `glLoadIdentity'
opengl.cpp:(.text.startup.main+0x4d8): undefined reference to `gluPerspective'
opengl.cpp:(.text.startup.main+0x4e2): undefined reference to `glMatrixMode'
opengl.cpp:(.text.startup.main+0x4e7): undefined reference to `glLoadIdentity'
opengl.cpp:(.text.startup.main+0x519): undefined reference to `gluLookAt'
opengl.cpp:(.text.startup.main+0x523): undefined reference to `glEnable'
opengl.cpp:(.text.startup.main+0x54b): undefined reference to `glTexParameteri'
opengl.cpp:(.text.startup.main+0x55f): undefined reference to `glTexEnvi'
opengl.cpp:(.text.startup.main+0x569): undefined reference to `glDisable'
collect2: error: ld returned 1 exit status
make[2]: *** [bin/gpu-example-opengl] Error 1
make[1]: *** [samples/gpu/CMakeFiles/example_gpu_opengl.dir/all] Error 2
```
| bug,category: gpu/cuda (contrib) | medium | Critical |
123,494,164 | youtube-dl | [Request] [npo] Please support NPO 'channels' | It would be cool if we could download all videos from a channel subsequently, e.g.
```
youtube-dl http://www.npo.nl/de-wereld-draait-door/POMS_S_VARA_059933
```
At the moment, the individually listed videos are supported, it's just not possible yet to download them in batch.
| site-support-request | low | Minor |
123,500,759 | go | tour: show answers to exercises | I couldn't complete exercises because I'm unfamiliar with the syntax.
Could we introduce best-in-class exercise solutions that are available from the exercise?
| NeedsInvestigation | low | Minor |
123,644,145 | TypeScript | Polymorphic `this` and Generics | First, thank you team for polymorphic `this`. It is really handy!
I think I ran into a case though that I am finding challenging, when I need to return a `this`, but the generics might have changed. For example:
``` typescript
class A<T> {
private items: T[] = [];
map<U>(callback: (item: T, idx: number, a: this) => U): this {
// boring implementation details
});
}
```
Where I want to be able to change the generic type for the class with a function, but I will be contracting to return the "current" class, but I want to guard different generics. The following seems logical to me, but doesn't appear to be currently supported:
``` typescript
class A<T> {
private items: T[] = [];
map<U>(callback: (item: T, idx: number, a: this) => U): this<U> {
// boring implementation details
});
}
```
Where if no generics arguments are supplied, it is inferred to be the current ones, where as if they are supplied they are substituted.
| Suggestion,Needs Proposal | medium | Critical |
123,705,921 | go | net/http: support GET-with-body in Transport/Server | RFC 2616 is super vague about whether a GET request with a body is valid, or what to do about it.
We should decide, document, enforce, and test.
I vote reject them.
RFC 2616 says:
> The rules for when a message-body is allowed in a message differ for
> requests and responses.
>
> The presence of a message-body in a request is signaled by the
> inclusion of a Content-Length or Transfer-Encoding header field in
> the request's message-headers. A message-body MUST NOT be included in
> a request if the specification of the request method (section 5.1.1)
> does not allow sending an entity-body in requests. A server SHOULD
> read and forward a message-body on any request; if the request method
> does not include defined semantics for an entity-body, then the
> message-body SHOULD be ignored when handling the request.
But the nothing (even in 5.1.1) about which methods have defined semantics for a body. At least GET and HEAD are not explicitly defined, so maybe that means reject them.
I recall somebody (from CloudFlare?) telling me they'd seen GET+body in the wild, though?
I still vote to reject them.
| NeedsFix,FeatureRequest | low | Major |
123,783,998 | nvm | test/slow overwrite npm | Why do `npm run test/slow` overwrite `npm` ?
``` bash
$ nvm install v5.3.0
Downloading https://nodejs.org/dist/v5.3.0/node-v5.3.0-darwin-x64.tar.xz...
######################################################################## 100.0%
WARNING: checksums are currently disabled for node.js v4.0 and later
Now using node v5.3.0 (npm v3.3.12)
$ nvm current
v5.3.0
$ node --version
v5.3.0
$ npm --version
3.3.12
$ npm run test/slow
# ...
Done, took 169 seconds.
5 tests passed.
12 tests failed.
make: *** [test-zsh] Error 12
npm ERR! Darwin 15.2.0
npm ERR! argv "/Users/kui/.nvm/versions/node/v5.3.0/bin/node" "/Users/kui/.nvm/versions/node/v5.3.0/bin/npm" "run" "test/slow"
npm ERR! node v5.3.0
npm ERR! npm v3.3.12
npm ERR! code ELIFECYCLE
npm ERR! [email protected] test/slow: `shell=$(basename -- $(ps -o comm= $(ps -o ppid= -p $PPID)) | sed 's/^-//'); make TEST_SUITE=slow test-$shell`
npm ERR! Exit status 2
npm ERR!
npm ERR! Failed at the [email protected] test/slow script 'shell=$(basename -- $(ps -o comm= $(ps -o ppid= -p $PPID)) | sed 's/^-//'); make TEST_SUITE=slow test-$shell'.
npm ERR! Make sure you have the latest version of node.js and npm installed.
npm ERR! If you do, this is most likely a problem with the nvm package,
npm ERR! not with npm itself.
npm ERR! Tell the author that this fails on your system:
npm ERR! shell=$(basename -- $(ps -o comm= $(ps -o ppid= -p $PPID)) | sed 's/^-//'); make TEST_SUITE=slow test-$shell
npm ERR! You can get their info via:
npm ERR! npm owner ls nvm
npm ERR! There is likely additional logging output above.
npm ERR! Please include the following file with any support request:
npm ERR! /Users/kui/nvm/npm-debug.log
$ nvm current
v5.3.0
$ node --version
v5.3.0
$ npm --version
1.4.29
```
| testing,needs followup | low | Critical |
123,813,545 | youtube-dl | Detect embedded wat videos | This is a feature request.
Sometimes website A embeds a video from website B, and we have an extractor for B.
The idea is:
- if there is no extractor for A:
- iterate through known extractors, trying them at A
- if none of them worked
- only then say `Unsupported URL`
Example:
- A = `www.wat.tv/video/danse-coup-coeur-loic-nottet-7pf7c_3at0p_.html`
- B = `http://www.wat.tv/video/danse-coup-coeur-loic-nottet-7pf7c_3at0p_.html`
| request | low | Minor |
123,816,650 | youtube-dl | Support for xinhuanet videos. | Hi,
It'd be great if you can add support for videos from xinhuanet! Example URL: http://news.xinhuanet.com/english/video/2015-12/24/c_134947040.htm
```
[generic] c_134947040: Requesting header
WARNING: Falling back on generic information extractor.
[generic] c_134947040: Downloading webpage
[generic] c_134947040: Extracting information
ERROR: Unsupported URL: http://news.xinhuanet.com/english/video/2015-12/24/c_134947040.htm
```
| site-support-request | low | Critical |
123,887,361 | TypeScript | Give better error messages down the line when generic merged interfaces have different type parameters | ``` ts
interface Foo<T> {
n: T;
}
interface Foo<U> {
y: U;
}
interface FooConstructor {
new <T>(): Foo<T>;
}
```
```
TS2314 Generic type 'Foo<T, U>' requires 2 type argument(s).
```
Feedback of https://github.com/DefinitelyTyped/DefinitelyTyped/pull/7321. I searched `Promise<T, R>` interface but I couldn't found it because it does not exist anywhere. Other contributors will may have a same difficulty in supporting of compatibility with es6(lib.es6.d.ts) definitions.
| Bug,Help Wanted,Effort: Moderate | low | Critical |
123,937,925 | youtube-dl | Can't download from myspace | I can't download songs from that page:
https://myspace.com/spiridoo/music/songs
| request | low | Minor |
123,946,183 | youtube-dl | Have a way to cancel the download programatically | this way, it could be done the following:
```
ydl = youtube_dl.YoutubeDL(conf)
ydl.download([self.url])
```
at some point in the middle, from other thread:
```
ydl.cancel()
```
and it would stop downloading.
| request | low | Minor |
123,979,492 | You-Dont-Know-JS | Tilde is one's complement | In Types & Grammar, Chapter 4, you state in passing that ~ computes the two's complement of a number. What it actually computes is the one's complement (flipping the bits), which is why ~42 is -43. Two's complement is the operation performed by unary - and consists of flipping the bits and adding 1 (or equivalently flipping all bits left of the rightmost 1).
| for second edition | low | Minor |
123,981,831 | java-design-patterns | Extract-Transform-Load (ETL) architectural pattern | **Description:**
The Extract-Transform-Load (ETL) design pattern is crucial for data integration and data warehousing processes. It involves extracting data from various sources, transforming it to fit operational needs, and loading it into a target database or data warehouse. This pattern ensures that data is accurately consolidated and structured for analysis and reporting purposes.
**Main Elements of the ETL Design Pattern:**
1. **Extract**: Retrieve data from different sources, which can include databases, APIs, flat files, etc.
2. **Transform**: Cleanse, format, and structure the extracted data to meet the required specifications. This might involve data validation, normalization, aggregation, and other data transformation techniques.
3. **Load**: Insert the transformed data into a target system, such as a database or data warehouse, ensuring it is ready for use in analysis and reporting.
**References:**
1. [ETL Design Pattern - Wikipedia](https://en.wikipedia.org/wiki/Extract,_transform,_load)
2. [What is ETL (Extract Transform Load)?](https://aws.amazon.com/what-is/etl/)
**Acceptance Criteria:**
1. Implement a basic ETL framework that includes modules for data extraction, transformation, and loading.
2. Provide examples demonstrating how to use the ETL framework with different data sources and targets.
3. Ensure the implementation follows the project’s coding standards and includes comprehensive documentation and unit tests.
| info: help wanted,epic: pattern,type: feature | low | Major |
124,021,423 | go | tour: explain the semantics of the main goroutine | Context: http://127.0.0.1:3999/concurrency/1
In concurrency/1 (Goroutines), commenting out line 17 say("hello") also stops the go say("world") from doing anything. The program exits before any worlds are said, yet without commenting out line 17 it seems to wait for all goroutines to finish before exiting.
| Documentation,help wanted,NeedsInvestigation | low | Minor |
124,032,718 | TypeScript | Issue in indentation when formatting consecutive objects | Reposting Microsoft/vscode#1661
There's a very annoying issue when hitting "format code" in a TS file. Here's an example:
``` ts
[{
}, {
}]
// or
fn({
}, {
})
```
becomes:
``` ts
[{
}, {
}]
// or
fn({
}, {
})
```
This gets really annoying when you have large nested objects containing things like functions etc...
| Bug,Help Wanted,Domain: Formatter | low | Minor |
124,135,656 | rust | bad diagnostic when macro tries to use stmt as expr | Given [this macro](http://is.gd/tEPMxF):
``` rust
macro_rules! foo {
($s:stmt) => { $s }
}
```
When called in expression context, for example `println!("{}", foo!(42))`, the error message refers to "unexpected token `42;`", thereby conjuring a semicolon out of the ether. We aren't JS so we shouldn't conjure semicolons out of the ether :)
| A-diagnostics,A-macros,T-compiler,A-suggestion-diagnostics,D-incorrect | low | Critical |
124,170,956 | TypeScript | Indentation failure with unclosed JSX element | ``` ts
var x =
<div>
<input type="text" name="name">
</div>
namespace foo {
/**/
```
Press enter at `/**/`.
```
Description:
getIndentationAtPosition('C:\Users\drosen\AppData\Local\Temp\~vs8E0D.tsx', 94)
StackTrace:
Error: Debug Failure. False expression:
at assert (:1645:17)
at find (:41847:13)
at find (:41843:25)
at find (:41843:25)
at find (:41843:25)
at find (:41843:25)
at find (:41843:25)
at find (:41843:25)
at find (:41843:25)
at find (:41843:25)
at findPrecedingToken (:41808:9)
at getIndentation (:44508:17)
at getIndentationAtPosition (:50435:13)
at Anonymous function (:52193:17)
at simpleForwardCall (:51951:9)
at forwardJSONCall (:51967:13)
at forwardJSONCall (:52013:13)
at getIndentationAtPosition (:52191:13)
```
| Bug,Domain: JSX/TSX | low | Critical |
124,236,352 | angular | Can't explicitly validate ControlGroup | It would be nice to have the possibility to explicitly call a **.validate()** method on a ControlGroup.
Starting with an invalid form just because the user still hasn't entered anything isn't always ideal.
In [your forms guide](https://angular.io/docs/ts/latest/guide/forms.html) it's quite convenient to start out with a populated model, hence you don't need to check !field.dirty or !field.touched in the view.
Please see my [video](https://youtu.be/T__VppOCk04) or check out my [ng2_play repo](https://github.com/ajtowf/ng2_play), it's always easier to show the problem.
| feature,workaround1: obvious,freq2: medium,area: forms,feature: under consideration | high | Critical |
124,243,741 | TypeScript | Reference to own class in static variable initialization to a decorated class references undecorated class instead of decorated class | 
[TypeScript Playground link](http://www.typescriptlang.org/Playground#src=%0A%40ClassWrappingDecorator%0Aclass%20X%20%7B%0A%20%20%20static%20factory%20%3D%20createFactory%28X%29%0A%7D)
| Bug,Domain: Decorators | low | Major |
124,251,657 | neovim | Windows: :edit filename inconsistencies | E.g. try the following
```
:e \s3go.
:w
```
- Vim/Windows - fails on `:write` with `E212: Can't open file for writing`
- Vim/Unix - succeeds, names the buffer on edit as `s3go.` and creates the file `s3go.` instead of `\s3go.`
- Neovim/Unix behaves like Vim/Unix
- Neovim/Windows behaves like Vim/Unix too (#810)
What is the desired behaviour here?
| needs:decision,platform:windows,compatibility,has:plan | low | Major |
124,355,926 | nvm | Unaliased sha1sum, sha1 or shasum not found | > $ nvm install v0.10.29
> Downloading https://nodejs.org/dist/v0.10.29/node-v0.10.29.tar.gz...
> ###### ################################################################## 100.0%
>
> Unaliased sha1sum, sha1, or shasum not found.
> nvm: install v0.10.29 failed!
Not sure what the issue is. I'm using nvm version 0.30.1. I installed it from the curl line in the readme.
I'm using git bash as my cmd console on windows 10.
Here's my .bashrc file
> alias meteor="cmd //c meteor"^M
> export NVM_DIR="/c/Users/Matt/.nvm"
> [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"
When running this code below I get this for the alias.
> $ nvm_is_alias sha1sum ; echo $?
> 1
Let me know if you need anything else.
Thanks.
| needs followup | low | Critical |
124,370,148 | go | spec: clarify imprecise conversions of non-floating-point constant to floating point type | ... or perhaps the spec is does not convey the intention.
The spec says (https://golang.org/ref/spec#Conversions)
> A constant value x can be converted to type T in any of these cases:
> - x is representable by a value of type T.
The Go compiler allows conversion in certain cases, where an integer constant value is not representable as a value of type `float32` as in:
``` go
package main
import "fmt"
func main() {
// bad
const A = 0x01ffffff
const B = float32(A)
fmt.Printf("%d\n%f\n", A, B)
// ok
const C = 0x01fffffe
const D = float32(C)
fmt.Printf("%d\n%f\n", C, D)
// ok
const E = 0x00ffffff
const F = float32(E)
fmt.Printf("%d\n%f\n", E, F)
}
```
I suppose there are similar cases when converting an integer constant into `float64`, `complex64`, or `complex128` type.
| Documentation,NeedsInvestigation | low | Minor |
124,372,215 | rust | Some `std::collections` types are unnecessarily invariant | The following `std::collections` types are unnecessarily invariant in their type parameters:
- ~~`binary_heap::Drain`~~
- ~~`btree_map::{Keys, Values}`~~
- ~~`btree_set::{IntoIter, Iter, Range}`~~
- `btree_set::{Difference, Intersection, SymmetricDifference, Union}`
- ~~`hash_map::{IntoIter, Iter, Keys, Values}`~~
- `hash_map::Drain`
- ~~`hash_set::{Difference, Intersection, IntoIter, Iter, SymmetricDifference, Union}`~~
- `hash_set::Drain`
- ~~`linked_list::{IntoIter, Iter, LinkedList}`~~
- ~~`vec::Drain`~~
- ~~`vec_deque::Drain`~~
Some, like `btree_map::Keys`, are invariant due to the use of `iter::Map` with `fn(T) -> U` being invariant over `T`, while others, like `LinkedList`, are due to the ultimate use of `*mut T`, and the rest are wrappers around other invariant iterators.
Of these, the most important to fix is probably `LinkedList`, as the rest are iterators. Given the issue with `iter::Map`, it is likely that some other iterators in `std` have the same problem.
| C-enhancement,A-collections,T-libs-api | low | Minor |
124,432,496 | rust | Compiler bug with cyclic weak references on Windows | I've tracked down the following bug on 1.5 stable. It only appears to happen on Windows, as I've tried the same program on Linux x64 without problems:
`test.rs`:
```
use std::rc::{Rc, Weak};
struct SDVertex {
start_face: Option<Weak<SDFace>>,
}
impl SDVertex {
fn new() -> SDVertex {
SDVertex {
start_face: None,
}
}
}
struct SDFace {
v: [Option<Weak<SDVertex>>; 3],
}
impl SDFace {
fn new() -> SDFace {
SDFace {
v: [None, None, None],
}
}
}
struct LoopSubdiv;
impl LoopSubdiv {
pub fn test(num_faces: usize) -> Vec<Rc<SDFace>> {
// Allocate vertices and faces
let mut fs = Vec::with_capacity(num_faces);
for _ in 0..num_faces {
fs.push(Rc::new(SDFace::new()));
}
fs
}
}
fn main() {
println!("{:?}", (LoopSubdiv::test(4).len(), 4));
}
```
On Linux, I get the expected result:
```
[~/test]$ rustc --version
rustc 1.4.0 (8ab8581f6 2015-10-27)
[~/test]$ rustc -o test test.rs
test.rs:4:5: 4:37 warning: struct field is never used: `start_face`, #[warn(dead_code)] on by default
test.rs:4 start_face: Option<Weak<SDFace>>,
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test.rs:8:5: 12:6 warning: method is never used: `new`, #[warn(dead_code)] on by default
test.rs: 8 fn new() -> SDVertex {
test.rs: 9 SDVertex {
test.rs:10 start_face: None,
test.rs:11 }
test.rs:12 }
test.rs:16:5: 16:35 warning: struct field is never used: `v`, #[warn(dead_code)] on by default
test.rs:16 v: [Option<Weak<SDVertex>>; 3],
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[~/test]$ ./test
(4, 4)
```
On Windows, this fails during compilation:
```
[~/test]$ rustc --version
rustc 1.5.0 (3d7cd77e4 2015-12-04)
[~/test]$ rustc -o test test.rs
test.rs:4:5: 4:37 warning: struct field is never used: `start_face`, #[warn(dead_code)] on by default
test.rs:4 start_face: Option<Weak<SDFace>>,
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test.rs:8:5: 12:6 warning: method is never used: `new`, #[warn(dead_code)] on by default
test.rs: 8 fn new() -> SDVertex {
test.rs: 9 SDVertex {
test.rs:10 start_face: None,
test.rs:11 }
test.rs:12 }
test.rs:16:5: 16:35 warning: struct field is never used: `v`, #[warn(dead_code)] on by default
test.rs:16 v: [Option<Weak<SDVertex>>; 3],
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: linking with `link.exe` failed: exit code: 1104
note: "D:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC/bin\\amd64\\link.exe" "/LIBPATH:D:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC/lib\\amd64" "/LIBPATH:C:\\Program Files (x86)\\Windows Kits\\10\\Lib\\10.0.10150.0\\ucrt\\x64" "/LIBPATH:C:\\Program Files (x86)\\Windows Kits\\8.1\\Lib\\winv6.3\\um\\x64" "/NOLOGO" "/NXCOMPAT" "/LIBPATH:D:\\Program Files\\Rust stable 1.5\\bin\\rustlib\\x86_64-pc-windows-msvc\\lib" "test.0.o" "/OUT:test" "/OPT:REF,ICF" "/DEBUG" "/LIBPATH:D:\\Program Files\\Rust stable 1.5\\bin\\rustlib\\x86_64-pc-windows-msvc\\lib" "/LIBPATH:D:\\path\\to\\test\\.rust\\bin\\x86_64-pc-windows-msvc" "/LIBPATH:D:\\path\\to\\test\\bin\\x86_64-pc-windows-msvc" "D:\\Program Files\\Rust stable 1.5\\bin\\rustlib\\x86_64-pc-windows-msvc\\lib\\libstd-35c36e89.rlib" "D:\\Program Files\\Rust stable 1.5\\bin\\rustlib\\x86_64-pc-windows-msvc\\lib\\libcollections-35c36e89.rlib" "D:\\Program Files\\Rust stable 1.5\\bin\\rustlib\\x86_64-pc-windows-msvc\\lib\\librustc_unicode-35c36e89.rlib" "D:\\Program Files\\Rust stable 1.5\\bin\\rustlib\\x86_64-pc-windows-msvc\\lib\\librand-35c36e89.rlib" "D:\\Program Files\\Rust stable 1.5\\bin\\rustlib\\x86_64-pc-windows-msvc\\lib\\liballoc-35c36e89.rlib" "D:\\Program Files\\Rust stable 1.5\\bin\\rustlib\\x86_64-pc-windows-msvc\\lib\\liballoc_system-35c36e89.rlib" "D:\\Program Files\\Rust stable 1.5\\bin\\rustlib\\x86_64-pc-windows-msvc\\lib\\liblibc-35c36e89.rlib" "D:\\Program Files\\Rust stable 1.5\\bin\\rustlib\\x86_64-pc-windows-msvc\\lib\\libcore-35c36e89.rlib" "ws2_32.lib" "userenv.lib" "advapi32.lib" "kernel32.lib" "shell32.lib" "msvcrt.lib" "compiler-rt.lib"
note: LINK : fatal error LNK1104: cannot open file 'test'
error: aborting due to previous error
```
I first identified this bug while [writing something as part of my ray tracer](https://github.com/Mokosha/pbrt_rust/blob/3a8692d3e241ada04a970af8947a1298f40bc7b7/src/shape/loopsubdiv.rs#L241). It failed to run a fairly simple unit test using `cargo test`. The result for that was:
```
panicked at 'arithmetic operation overflowed', ../src/liballoc\rc.rs:867
```
However, the weird thing is that this only shows up in the library if I change the definition of `SDFace` to
```
struct SDFace {
v: [Option<Weak<SDVertex>>; 3],
f: [Option<Weak<SDFace>>; 3],
}
impl SDFace {
fn new() -> SDFace {
SDFace {
v: [None, None, None],
f: [None, None, None],
}
}
}
```
This seems like a bug somewhere, but I don't know where -- if I need to analyze anything additionally, please let me know.
| A-linkage,O-windows-msvc,C-bug | low | Critical |
124,484,654 | go | x/mobile/app: faster reshape callback on darwin_amd64 | I write a simple 2d app with gomobile on mac.
I paint one image with fixed position and fixed size.
I found that when I resize the window quickly ,the image size on the screen is bigger or smaller proportionally to the screen size.
Sometimes,the image size remember the windows size in seconds ago.
After I comment out following code,the problem disappear:
src/golang.org/x/mobile/app/darwin_amd64.m:48
It looks like the reshape function is too slow.
May be we can cache same result from the system api.
```
gomobile version +0a85ca5 Fri Dec 25 00:41:33 2015 +0000 (android,ios); androidSDK=/usr/local/AndroidSdk/platforms/android-22
go version go1.5.2 darwin/amd64
```
| mobile | low | Major |
124,491,509 | go | crypto/aes: S-box cache timing leak | The crypto/aes package uses S-boxes and thus leaks cache timing information. Techniques to avoid this [are known](http://shiftleft.org/papers/vector_aes/) and should be used on all platforms Go supports.
If Go does not support the needed vector intrinsics, then support for them should be added.
| Security | low | Major |
124,499,048 | flutter | We should have an offline-friendly and poor-network-friendly network layer | Most network APIs have the opinion that you make a request and it either succeeds, fails, or times out.
We should introduce a network API that never fails or times out. It just keeps retrying. If we encourage this to be used by most authors, then Flutter applications will be much more reliable. You wouldn't get "message send failed, try again", or broken images, or the like. You'd just get "still trying to send message", "still trying to load image", etc.
| c: new feature,framework,would be a good package,P3,team-framework,triaged-framework | low | Critical |
124,511,351 | youtube-dl | Optimize metadata support for OS X | # Metadata functions in youtube-dl
youtube-dl comes with these metadata related arguments: `--add-metadata` and `--xattrs`.
`--add-metadata` writes into the metadata section of the container format where possible/supported whereas `--xattrs` into the filesystem's metadata section.
# Metadata on OS X
Mac users' default search feature Spotlight (and its background process `mds`, the metadata server) to my research seems to index only xattr variables from the namespace com.apple.\* whereas youtube-dl writes into `user.dublincore.*` (contributor | date | description | format | title) and `user.xdg.referrer.url`.
Therefore the `--xattrs` is completely inaccessible to Spotlight, and `--add-metadata` only accessible if youtube-dl can 1) write into the container format and 2) Spotlight supports parsing the container's metadata and 3) Spotlight maps the variables correctly (to a certain degree).
Example: `kMDItemDescription` got filled by Spotlight for a 3gp file with `--add-metadata` but not for a mp4 file with `--add-metadata`.
# Feature request
It would be fine if there would be an option --spotlight which would write the metadata into the appropriate OS X specific metadata locations.
# Implementation hints
I'm no savvy developer, but would like to provide some resources at least:
1) [Apple Developer Documentation on Spotlight Metadata Attributes](https://developer.apple.com/library/archive/documentation/CoreServices/Reference/MetadataAttributesRef/Reference/CommonAttrs.html), i.e.:
`kMDItemWhereFroms` would be the ideal destination for the URL.
`kMDItemDescription` would be the ideal destination for the description.
…
2) Writing metadata seems to be done with:
`xattr -w com.apple.metadata:<properVariable> "<MetadataValueHere>" <file>`
But it [seems to be a bit tricky](http://stackoverflow.com/questions/8530825/mac-os-x-add-a-custom-meta-data-field-to-any-file), as some metadata exists in multiple places (legacy) and must thus be properly synchronized in order to show up in Spotlight as well as showing up in the Finder info windows, and it seems that the value cannot be written as plaintext, but must be encapsulated as PLIST (XML format for Apple property list) or binary PLIST.
| request | medium | Major |
124,548,898 | nvm | FR: Notify on newer version of node. | Say the current default version in the users machine is `v5.1.0` and the remote latest is `v5.2.0`, it would be nice have a notification system in place which would indicate the user that a greater version is available.
We could indicate this when the user invokes `nvm` or `node -v`.
//cc @ljharb
| feature requests | low | Major |
124,559,338 | TypeScript | Incorrect autocomplete suggestion with dots | ``` ts
1;
12;
```
Add a dot.
``` ts
.1;
1.2;
```
Then Visual Studio 2015 suggests global variables.
| Bug,Help Wanted | low | Minor |
124,561,041 | youtube-dl | Add support for cwseed.com show pages | Hi, I'd like to vote to add the following site which does not appear to currently work but does list all videos on one page, etc. so given other supported sites doesn't look like it would be very different:
Site:
http://www.cwseed.com
Example of series page:
http://www.cwseed.com/shows/the-oc
| site-support-request | medium | Major |
124,590,589 | go | net/http: transport MaxIdleConnsPerHost does not work as expected | I recently had an issue which made Go consume all ephemeral ports and start failing to do requests.
The problem was triggered because I was doing 10 concurrent requests with the DefaultMaxIdleConnsPerHost so Transport was only reusing 2 connections and closing the other 8 as soon as a request was finished, just to reestablish a connection again.
This seems a really bad behavior and never happened to me on any other language or http client.
A connection is usually considered idle when it was not used for a period of inactivity, maybe a whole keepalive period or so, not after a request has been sent successfully.
The behavior one would expect is to have 10 established connections and, after say 30 seconds of not issuing any request having only 2 connections established as per DefaultMaxIdleConnsPerHost.
Here is a [gist](https://gist.github.com/sschepens/062c7dbdf29272eea4af) that triggers this behavior.
I'm running go 1.5.2 on Ubuntu Precise 12.04, kernel: Linux e-0000e768 3.8.0-44-generic #66~precise1-Ubuntu SMP Tue Jul 15 04:01:04 UTC 2014 x86_64 x86_64 x86_64 GNU/Linux
| help wanted,NeedsFix | low | Major |
124,605,661 | youtube-dl | --sub-lang shall accept language wildcard syntax | I'd welcome a language wildcard syntax, i.e. "I want 'en_' no matter what dialect" or "I want 'en-uk,en_' as in 'British English first else any English available' ") to spare the user lengthy language code guesswork/generalisation or the need for a manual --list-sub investigation prior downloading, which if resorting to somehow diminuishes youtube-dl as a batch tool.
| request | low | Minor |
124,617,039 | neovim | Abort multikey commands after `timeoutlen` | Over the msgpack-rpc connection it is possible to send `vim_input "<C-w>"` and then to wait forever for the second part of the key sequence. Actually there should be a timeout. It would make sense to use the same value that is already used in vim, namely `timeoutlen`.
| bug-vim | low | Minor |
124,618,458 | neovim | Expose window layout | This issue actually just repeats what is already described by @tarruda as the "[smart UI protocol](http://tarruda.github.io/articles/neovim-smart-ui-protocol/)" but I want to have it as a ticket to get feedback when it is available.
Over the last weeks, I spent a lot of time by implementing a smart UI on the client side by myself, i.e. I implemented a window manager for neovim windows, whose state can be synced with the state of neovims internal window manager. I don't have to say that it took me forever to get to this point but I want to say that I learned that such a sync is actually impossible for all possible use cases. The problem is easily described:
```
-----
| | |
-----
| | |
-----
```
These are four windows but it is ambiguous if there are two columns that each contain a row of two windows or if there are two rows that each contain two columns. It can't be detected but needs to, otherwise the client can't be correctly updated when the user moves between the windows. Instead of a list of windows, the neovim API needs to expose a tree. In Haskell, it could be described in this way:
``` haskell
data WindowTree = Rows [WindowTree] | Columns [WindowTree] | Window Int
```
A window tree is either a row, a column or a window, where the window is represented by a number and the other twos can be arbitrarily nested and contain each a list of further window trees.
I hope the smart UI protocol gets real one day because I really need it to implement my UI correctly.
| enhancement,api,ui | low | Major |
124,635,309 | opencv | calcOpticalFlowPyrLK yields incorrect result when using OpenCL | Visual Studio 2015
OpenCV 3.1.0
WITH_OPENCL enabled
WITH_OPENCL_SVM enabled/disabled (always occur)
Concise sample code:
```
cout << "useOpenCL: " << ocl::useOpenCL() << endl;
// Just the sample video shipped with OpenCV source
VideoCapture cap("D:\\work\\opencv_3.1\\opencv\\sources\\samples\\data\\768x576.avi");
UMat f0, f1, g0, g1;
cap >> f0;
cap >> f1;
cvtColor(f0, g0, COLOR_BGR2GRAY);
cvtColor(f1, g1, COLOR_BGR2GRAY);
Mat p0(8, 1, CV_32FC2), p1, status, err;
theRNG().fill(p0, RNG::UNIFORM, 0, min(f0.rows, f0.cols));
calcOpticalFlowPyrLK(g0, g1, p0, p1, status, err);
cout << "p0: " << p0 << endl;
cout << "p1: " << p1 << endl;
cout << "status: " << status << endl;
cout << "err: " << err << endl;
```
Output when OpenCL is disabled:
```
useOpenCL: 0
p0: [305.4429, 114.7733;
231.01024, 469.08582;
251.78859, 143.30287;
445.30853, 438.966;
177.28961, 404.60065;
275.5856, 456.30145;
49.445633, 43.234711;
94.131866, 172.67282]
p1: [305.45264, 114.76205;
231.08749, 469.09006;
251.80547, 143.31331;
445.29504, 438.96689;
177.42975, 404.54962;
275.69241, 456.32147;
49.464996, 43.233234;
94.185921, 172.67618]
status: [ 1;
1;
1;
1;
1;
1;
1;
1]
err: [1.2229308;
1.2712585;
1.2330641;
1.5741214;
1.2522676;
1.2371032;
1.4520266;
1.9238945]
```
Output when OpenCL is enabled:
```
useOpenCL: 1
p0: [305.4429, 114.7733;
231.01024, 469.08582;
251.78859, 143.30287;
445.30853, 438.966;
177.28961, 404.60065;
275.5856, 456.30145;
49.445633, 43.234711;
94.131866, 172.67282]
p1: [305.45108, 114.7645;
14.43814, 29.317863;
15.736787, 8.9564295;
27.831783, 27.435375;
11.080601, 25.28754;
17.2241, 28.518841;
3.0903521, 2.7021694;
5.8832417, 10.792051]
status: [ 1;
1;
1;
1;
1;
1;
1;
1]
err: [1.2273066;
-4.3160208e+08;
-4.3160208e+08;
-4.3160208e+08;
-4.3160208e+08;
-4.3160208e+08;
-4.3160208e+08;
-4.3160208e+08]
```
This problem occurs only if grayscale images (g0, g1) are passed, and for colored images, i.e. passing f0, f1 instead of g0, g1, it's correct in both cases.
| bug,category: video,affected: 3.4,category: ocl,category: t-api | low | Minor |
124,699,147 | opencv | cv::namedWindow will not spawn a new opengl window if you try to create a window that has been closed. | On windows using the current master branch, msvc2013x64. Qt5.5, OpenGL on.
If you create a window with cv::namedWindow with the OpenGL flag, and then close the window with the [X] button, subsequent calls to cv::namedWindow with the same window name and an OpenGL flag will not create a new window.
Minimal test:
int main()
{
cv::Mat mat(100,100,CV_8UC3);
while(cv::waitKey(1) != 27)
{
cv::namedWindow("test", cv::WINDOW_OPENGL);
cv::imshow("test", mat);
}
}
However removing the cv::WINDOW_OPENGL flag has a different behavior.
| bug,category: highgui-gui | low | Minor |
124,942,746 | vscode | Proposal: Add mnemonics to context menu items | On Windows systems it looks like context menu items don't have accelleration characters assigned to them. Getting used to accessing context menu items by using the keyboard it would be an improvement to see the acceleration character displayed along with the context menu immediately.
So I suggest to display a context menu item's acceleration character along with the context menu.
| feature-request,menus | low | Major |
125,036,412 | go | crypto/tls: Set{Read,Write}Deadline implementation is surprising/ineffective | Bear with me, this is a little long-winded, but I'm not sure how I can explain this more succinctly..
The current implementation of these functions is to pass them directly through to c.conn. Judging by my understanding of how TLS works, I think this is wrong. Picture a TLS listener socket which has just accepted a client (which won't ever complete a handshake, say, telnet or something).
Given:
```
type aClient struct {
conn net.Conn
}
```
On accept of an incoming connection, an aClient instance is created (with conn populated from the TLS listener) & the server is instructed to time out the client after X seconds of not sending anything (through a goroutine, a Timer, and a channel to cancel the goroutine), something like this:
```
func authTimeout(client *aClient, controlChan chan int) {
for {
timer := time.NewTimer(time.Second * 5)
select {
case <-timer.C:
client.Write("You didn't authenticate in time.")
client.conn.Close()
return
case <-controlChan:
return
}
}
}
```
client.Write's implementation looks something like this:
```
func (this *aClient) Write(format string, args ...interface{}) {
// one would expect this to time out...
this.conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
this.conn.Write(fmsg)
// but if the client doesn't handshake, it'll hang!
}
```
authTimeout's timer will successfully fire, Write will be called, and set the Write deadline, and attempt to write. However, because the connection hasn't been read/written previously, it needs a handshake. And as handshaking requires reading from the underlying socket, this write deadline won't ever actually trigger.
This, to me, is incorrect/surprising. I'm not entirely sure what the behaviour of deadlines should be before handshake (maybe take whichever is the lowest? Maybe offer an explicit handshake deadline?) but I'm pretty sure there needs to be _something_ done here even if that something is just a warning in the documentation. This bit me when blindly porting some code over from net/tcp to TLS.
It's worth noting, also, that net/http/transport.go tries to work around this very issue, but at least my own attempts to implement a similar pattern (handshake right after accepting, with a goroutine to time out the handshake and Close() on fail) seemed to suffer similar problems with Close() never returning unless I set both a ReadDeadline and WriteDeadline. I didn't (yet) analyze this problem, though.
| NeedsInvestigation | low | Minor |
125,084,125 | kubernetes | Passing `--cert-dir` to kube-apiserver overwrites existing certs | It seems to actually overwrite existing ones
| priority/backlog,kind/documentation,sig/api-machinery,lifecycle/frozen | medium | Major |
125,084,454 | kubernetes | Passing only `--tls-cert-file` produces cryptic error message | It says: `E0105 14:50:09.165099 10 server.go:633] Unable to listen for secure (open : no such file or directory); will try again.`
I've also had `--cert-dir` set at the time, not sure if that somehow triggered an edge case of sorts. I've only tested this with v1.1.3 binaries.
| priority/backlog,kind/documentation,sig/api-machinery,lifecycle/frozen | low | Critical |
125,144,988 | neovim | Enable Ctrl-U Ctrl-O in completion mode | Vim disables Ctrl-U in user defined completion mode and Ctrl-O in omni completion mode. See https://github.com/Valloric/YouCompleteMe/issues/24 for some detail.
It seems that the these keys are hard coded in vim so that it is impossible to restore their original function through mapping. Ctrl-O is heavily used in a lot of insert mode mapping and Ctrl-U is often used to delete an line. I hope these keys can be mapable in completion mode.
| enhancement | low | Minor |
125,202,044 | go | runtime/pprof: CPU profiles incorrect for kernels with broken setitimer support | As of Go 1.6, pprof's CPU profiles are known to be incorrect on a few systems due to what are arguably kernel bugs. This issue documents those systems.
The text below distinguishes a profile being incomplete (missing profile samples for code that was running) from being incorrect (containing samples for code that wasn't running).
- DragonflyBSD (all known versions): Delivers a profiling signal only when a thread runs continuously for an entire clock tick (20ms). In workloads with high context-switch or garbage collection rates, this may cause profiles to be incomplete.
- Linux (without CONFIG_HIGH_RES_TIMERS=y): Delivers a profiling signal only when a thread runs continuously for an entire clock tick (often 10ms). In workloads with high context-switch or garbage collection rates, this may cause profiles to be incomplete. Most Linux kernels in use today do enable high-resolution timers and therefore do _not_ suffer from this problem.
- NetBSD (all known versions): Delivers signals to the wrong thread. On such systems, profiles are commonly very incorrect.
- OpenBSD (all known versions): Delivers a profiling signal only when a thread runs continuously for an entire clock tick (20ms). In workloads with high context-switch or garbage collection rates, this may cause profiles to be incomplete.
- OS X (fixed in OS X 10.11 El Capitan): Deliver signals to the wrong thread. On such systems, profiles are commonly very incorrect. See rsc.io/pprof_mac_fix for a workaround on those early systems.
- Solaris (fixed in Solaris 8): Delivers a profiling signal only when a thread runs continuously for an entire clock tick (10ms). In workloads with high context-switch or garbage collection rates, this may cause profiles to be incomplete. Solaris 8 fixes the problem on systems with APIC hardware (most x86 systems). On systems that continue to exhibit the problem, adding `set hires_tick = 1` to `/etc/system` can mitigate this problem somewhat by reducing the clock tick to 1ms.
Please comment on this issue only if the text above is incomplete or incorrect; we will keep this top-level comment up to date.
| compiler/runtime | low | Critical |
125,223,845 | vscode | Add some API to support GUI customization | VS Code is a great coding IDE, but developers love to customize their tools to make them feel like home and VS Code lacks those customization abilities.
I love the sublime material theme and I wanted to implement it in VS Code but as far as I can see it's not possible now because only the coding area is customizable. So in my opinion some improvement in ui customization would be welcomed by a lot of us. In the ideal word every pixel and element of VS Code should be customizable with extensions, but for start it would be enough to start with the following things:
- ~customization of the side panel (#123)~ - marked as done in https://github.com/microsoft/vscode/issues/211#issuecomment-244362718
- ~adding support for custom tabs, the possibilities of the quick box is very limited (#710)~ - marked as done in https://github.com/microsoft/vscode/issues/710#issuecomment-385573949
- adding the ability to add and remove ui elements (e.g. a bottom panel for error listing like in Atom)
I have read about the [approach](https://code.visualstudio.com/docs/extensions/our-approach) followed by VS Code. So instead of allowing extensions to create custom ui elements, VS Code itself should provide some API for this, what allows to the developers to set the content, but the styling of the content should be based on the theme of VS Code.
So in a nutshell: VS Code core provide the bones and template of the ui elements, extension developers can set the content but not the style and theme developers can style the content.
| feature-request,api | high | Critical |
125,293,834 | go | strings: optimize WriteTo to use an intermediate buffer for large strings | Using `go1.5`
NOTE: This issue used to be about using an intermediate buffer in io.WriteString, but will instead perform the optimization in strings.Reader.WriteTo instead. The description in this issue still refers to WriteString, but the performance numbers will probably be the same once applied to strings.Reader.WriteTo.
##
Currently WriteString does `w.Write([]byte(s))` if `w` is not a `stringWriter`. This causes a memory allocation proportional to len(s). Instead, we should use an intermediate buffer for large strings.
Using this test code:
``` go
var (
large = strings.Repeat("the quick brown fox jumped over the lazy dog", 1024*1024)
writerOnly = struct{ io.Writer }{ioutil.Discard}
)
// WriteString2 is modified from io.WriteString to use an
// intermediate buffer for large strings.
func WriteString2(w io.Writer, s string) (n int, err error) {
const chunkSize = 32*1024
if sw, ok := w.(interface {WriteString(s string) (n int, err error)}); ok {
return sw.WriteString(s)
}
if len(s) < chunkSize {
return w.Write([]byte(s))
}
buf := make([]byte, chunkSize)
for len(s) > 0 {
cnt := copy(buf, s)
s = s[cnt:]
cnt, err = w.Write(buf[:cnt])
n += cnt
if err != nil {
break
}
}
return n, err
}
func BenchmarkWriteString(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
if _, err := io.WriteString(writerOnly, large); err != nil {
b.Error(err)
}
}
}
func BenchmarkWriteString2(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
if _, err := WriteString2(writerOnly, large); err != nil {
b.Error(err)
}
}
}
```
We can get the number of bytes allocated to be capped at some maximum:
```
BenchmarkWriteString-4 200 6482427 ns/op 46137405 B/op 2 allocs/op
BenchmarkWriteString2-4 500 2437841 ns/op 32784 B/op 2 allocs/op
```
I was pleasantly surprised that the runtime also decreased, but this may be because the small buffer fits entirely in the cache.
| Performance | medium | Critical |
125,425,109 | opencv | CMake find_package across 2.x and 3.x | I have an app that is compatible with OpenCV >=2.4.8 as well as the 3.x branch. Previous to 3.1.0, a
`find_package(OpenCV 2.4.8 REQUIRED core imgproc highgui objdetect)`
would succeed with an installed OpenCV 2.4.8 (or 2.4.11 or whatever) and 3.0.0.
However, 932043fdc2e827f715a71053f9d3de479f8c0c6d broke this by returning `PACKAGE_VERSION_COMPATIBLE False` if the major versions don't match (i.e. if requesting 2.4.8, and 3.1.0 is installed).
It seems like there is no way in CMake to tell it "My app is compatible with either >=2.4.8 or 3.x", to make CMake happy with finding either. I can't find a way to do it so I don't think it's possible.
Do you really want this? I realise it's a trade-off. But I think my use case is not that rare. Do you really want to break everybody that has software that is compatible with 2.4.x as well as 3.x?
Sometimes you just can't fully upgrade to 3.x yet, for example Ubuntu 14.04 LTS is on 2.4.x so I think a lot of people still need to support that, but at the same time a lot of my users are on OpenCV 3.x, so it sucks having them to install 2.4.x. Also there is no pre-built binaries for VS2015 for the latest 2.4.12 release so I either have to provide them by myself or have the user compile it (which is not really an option).
I would just like to open a discussion on this and get some feedback. Thanks! :-)
| category: build/install,affected: 2.4,affected: 3.4,RFC | low | Major |
125,465,456 | three.js | Feature Request - Decals that work with animated meshes | Currently decals (DecalGeometry.js) do not work with animated meshes.
I am peering into the code to see how difficult it would be to implement this. It appears maybe animations are done at the shader level, so I'm getting increasingly discouraged the more I'm trying to analyze this.
I'm sure many would appreciate this enhancement!
Thanks
| Enhancement | medium | Major |
125,467,360 | go | x/mobile/event/touch: cancellation and gestures | As mentioned on golang.org/cl/18180:
iOS cancels a touch when a gesture is detected. We don't currently report touch cancellation, nor do we report gestures.
Is a portable iOS/Android API for gestures possible? If not, should gestures be turned off? If they are, are there any cancelled events any more?
| mobile | low | Minor |
125,535,379 | youtube-dl | Add Bittorent Bundle | https://bundles.bittorrent.com/
For most film the site provide a trailer.
The url is in audio/video tag, you just have to change the end of the url with the filename you want (which are at the end of the page, kindly provided by the site) to retrieve the full film/album.
Example:
```
https://bundles.bittorrent.com/bundles/killswitch
```
Which should give you this url:
```
https://s3.amazonaws.com/content-bundles/production-df0ec56d-0fbb-bc2c-11e7-354ff3af9c4e/445f077458b8583394423c53b88b5019f861ab0c9753b398dbf2396a88df1f66/xcode/Killswitch/Killswitch - Documentary Trailer.mp4
```
This only the trailer, now if you want the full film, just take the name of the file at the bottom of the page and replace it in the url like so:
```
https://s3.amazonaws.com/content-bundles/production-df0ec56d-0fbb-bc2c-11e7-354ff3af9c4e/445f077458b8583394423c53b88b5019f861ab0c9753b398dbf2396a88df1f66/xcode/Killswitch/Killswitch_BT-Launch_20151019-8.5Mbs.mp4
```
| site-support-request | low | Minor |
125,540,753 | go | proposal: net/http: configurable Server.WriteBufferSize | Hi, in our most cases, the http written bytes more than 4<<10, so we need set bufio Read/Write buffer size and connection SNDBUF/RCVBUF ?
Also we think this change is appropriate, does go plan to support this?
| Proposal | low | Major |
125,632,043 | go | runtime/internal/atomic: consider making Xadd panic on underflow | I've sunk a lot of time in to debugging Xadds in the runtime that unintentionally underflow and cause the unsigned number to wrap, leading to some (often subtle) horrible thing happening later. This debugging effort means the runtime is now sprinkled with underflow checks in many places where it calls Xadd.
We should consider making Xadd itself do this check, or introducing another variant that does. One caveat is that we currently don't have a signed version of Xadd, so there are places where we use it on a *uint32, but cast that unsigned value to a signed value everywhere we use it. In this case we definitely don't want to panic on unsigned underflow, so we should introduce a signed Xadd for these that takes a *int32 and doesn't do this check (though it could panic on signed wrap-around).
/cc @michaelmatloob @rsc @dvyukov for any thoughts.
| NeedsFix,compiler/runtime | low | Critical |
125,644,100 | TypeScript | tsc removes comments preceding 'export = ...' unless extra newline follows the comment | The tsc compiler with remove comments set to false (no --removeComments flag and/or "removeComments": false in tsconfig.json) performs unexpectedly **based on whitespace characters surrounding comments before an export statement**. For example,
``` typescript
/* @ngInject */
export = function($scope: any) {
// A comment
$scope.options = {};
}
```
Run the compiler:
``` bash
$ tsc --module commonjs controller.ts
```
The compiler strips /\* @ngInject */ but preserves // A comment
``` typescript
module.exports = function ($scope) {
// A comment
$scope.options = {};
};
```
However, **placing a new line after /\* @ngInject */ keeps it from being removed**:
``` typescript
/* @ngInject */
export = function($scope: any) {
// A comment
$scope.options = {};
}
```
produces
``` typescript
/* @ngInject */
export = function($scope: any) {
// A comment
$scope.options = {};
}
```
Any idea why tsc is sensitive to such contextual whitespace?
``` bash
$ tsc -v
message TS6029: Version 1.7.5
```
| Bug,Help Wanted | low | Minor |
125,663,563 | go | text/template: add more package docs | We can add more comments to text/template package so the readers who use godoc will see somewhat more detailed material in the documentation rather than the sparse documentation which is currently present.
| Documentation,NeedsInvestigation | low | Minor |
125,707,378 | kubernetes | Deprecate cAdvisor flags in kubelet | Currently all cAdvisor flags are exposed through the cAdvisor binary. Many of the flags are irrelevant, or provide more controls than we want to give. Additionally, once we separate most cAdvisor functionality out of kubelet, most of thees flags will no longer make sense.
Open questions about the deprecation:
- Which flags are existing customers using? We should probably send a survey to various kubernetes groups to find out.
- Can we simply make the backwards incompatible change of removing the flags, or do we need to create "dummy" deprecated flags for each one in kubelet?
Prerequisite for https://github.com/kubernetes/kubernetes/issues/18770
@kubernetes/goog-node
| area/kubelet,kind/cleanup,area/cadvisor,sig/node,priority/important-longterm,lifecycle/frozen | medium | Major |
125,751,051 | TypeScript | Leak of `noImplicitAny` checking with private static property | ``` ts
declare class C {
private static implicitAnyTypeProperty;
static inherited: typeof C.implicitAnyTypeProperty;
inherited: typeof C.implicitAnyTypeProperty;
}
```
expected:
```
$ node_modules/.bin/tsc index --noImplicitAny
index.ts(2,3): error TS7008: Member 'implicitAnyTypeProperty' implicitly has an 'any' type.
```
actual:
```
$ node_modules/.bin/tsc index --noImplicitAny
```
| Bug,Help Wanted | low | Critical |
125,767,485 | go | spec: no rule about loops in constant definition | The compiler issues error `constant definition loop` for the following program:
``` go
package main
import "fmt"
const C = len(u)
func f() ([1]int, [C]float64) {
return [...]int{1}, [...]float64{1.1}
}
var u, v = f()
func main() {
fmt.Println(C, v)
}
```
In fact the value if `C` (resp. the type of `u`) does not depend on the type of the second return of `f`.
The same program is compiled successfully by gccgo.
PS. Another test case
``` go
package main
import "fmt"
const C = len(u)
type S struct {
X [1]int
Y [C]int
}
var s S
var u, v = s.X, s.Y
func main() {
fmt.Println(C, v)
}
```
| NeedsInvestigation | low | Critical |
125,785,317 | rust | Fine-tune binary heap sifting logic | There's a fundamental compromise in sifting strategy that optimizes for small/big heaps or elements.
See #30534 for discussion and details, which changed `pop` to optimize for the large case. It's possible a branch on `self.len` could produce better results for small cases.
CC @bluss if you want to chime in
| I-slow,C-enhancement,A-collections,T-libs-api | low | Minor |
125,790,596 | rust | VecDeque's iterator could be optimized | `VecDeque`'s iterator seems to never allow llvm to vectorize loops, this could be improved.
Even an enum where it uses the slice iterator for its contiguous case, and a fallback iterator, would allow vectorization for the contiguous case.
The following simple benchmark shows the massive difference between the deque iterator and using its two slice parts. The results are the same whether the deque is discontinuous or not. The summation in `sum_deque_2` is an order of magnitude faster, because llvm can autovectorize it.
``` rust
/* Results
test sum_deque ... bench: 1,301 ns/iter (+/- 111)
test sum_deque_2 ... bench: 71 ns/iter (+/- 2)
*/
#![feature(test)]
extern crate test;
use test::Bencher;
use test::black_box;
use std::collections::VecDeque;
#[bench]
fn sum_deque(b: &mut Bencher) {
let mut dq: VecDeque<_> = (0..1024).collect();
/*
for _ in 0..128 {
let elt = dq.pop_back().unwrap();
dq.push_front(elt);
}
*/
let dq = black_box(dq);
b.iter(|| {
let mut sum = 0;
for elt in &dq {
sum += *elt;
}
sum
})
}
#[bench]
fn sum_deque_2(b: &mut Bencher) {
let mut dq: VecDeque<_> = (0..1024).collect();
/*
for _ in 0..128 {
let elt = dq.pop_back().unwrap();
dq.push_front(elt);
}
*/
let dq = black_box(dq);
b.iter(|| {
let mut sum = 0;
let (a, b) = dq.as_slices();
for elt in a {
sum += *elt;
}
for elt in b {
sum += *elt;
}
sum
})
}
```
| I-slow,C-enhancement,A-collections,T-libs-api | low | Major |
126,016,855 | rust | Allow deprecating a re-export | This would allow a module to rename an identifier without breaking users, and provide a message that they should change.
Example:
``` rust
mod foo {
#[deprecated(reason = "use Foo instead")]
pub use self::Foo as Bar;
pub struct Foo(pub i32);
}
use self::foo::Bar; // <- deprecrated, use Foo instead
```
| C-enhancement,A-lints,T-lang,E-help-wanted,L-deprecated | medium | Major |
126,047,903 | go | x/mobile/exp/audio/al: add missing generic accessors and setters | Continuing the discussion started at https://github.com/golang/go/issues/11298#issuecomment-168354198...
Source offset setters are missing from the package and the offset must represented in float32 for more precision. Suggested APIs are below.
```
// OffsetSeconds returns the current playback position of the source in seconds.
func (s Source) OffsetSeconds() float32 {
return getSourcef(s, paramSecOffset)
}
// SetOffsetSeconds sets the current playback position of the source in seconds.
func (s Source) SetOffsetSeconds(sec float32){
setSourcef(s, paramSecOffset,sec)
}
// OffsetSample returns the sample offset of the current playback position.
func (s Source) OffsetSample() int32 {
return getSourcei(s, paramSampleOffset)
}
// SetOffsetSample sets the sample offset of the current playback position.
func (s Source) SetOffsetSample(i int32){
setSourcei(s, paramSampleOffset,i)
}
// OffsetByte returns the byte offset of the current playback position.
func (s Source) OffsetByte() int32 {
return getSourcei(s, paramByteOffset)
}
// SetOffsetByte sets the byte offset of the current playback position.
func (s Source) SetOffsetByte(i int32){
setSourcei(s, paramByteOffset,i)
}
```
/cc @splace
| FeatureRequest,mobile | low | Minor |
126,053,672 | go | x/mobile/exp/audio/al: export all constants from AL headers | The al package currently doesn't export some of the constants appear on the the AL headers such as AL_PITCH, AL_POSITION, AL_DIRECTION, AL_LOOPING, etc. The full is provided below, export them all.
```
/**
* Relative source.
* Type: ALboolean
* Range: [AL_TRUE, AL_FALSE]
* Default: AL_FALSE
*
* Specifies if the Source has relative coordinates.
*/
#define AL_SOURCE_RELATIVE 0x202
/**
* Inner cone angle, in degrees.
* Type: ALint, ALfloat
* Range: [0 - 360]
* Default: 360
*
* The angle covered by the inner cone, where the source will not attenuate.
*/
#define AL_CONE_INNER_ANGLE 0x1001
/**
* Outer cone angle, in degrees.
* Range: [0 - 360]
* Default: 360
*
* The angle covered by the outer cone, where the source will be fully
* attenuated.
*/
#define AL_CONE_OUTER_ANGLE 0x1002
/**
* Source pitch.
* Type: ALfloat
* Range: [0.5 - 2.0]
* Default: 1.0
*
* A multiplier for the frequency (sample rate) of the source's buffer.
*/
#define AL_PITCH 0x1003
/**
* Source or listener position.
* Type: ALfloat[3], ALint[3]
* Default: {0, 0, 0}
*
* The source or listener location in three dimensional space.
*
* OpenAL, like OpenGL, uses a right handed coordinate system, where in a
* frontal default view X (thumb) points right, Y points up (index finger), and
* Z points towards the viewer/camera (middle finger).
*
* To switch from a left handed coordinate system, flip the sign on the Z
* coordinate.
*/
#define AL_POSITION 0x1004
/**
* Source direction.
* Type: ALfloat[3], ALint[3]
* Default: {0, 0, 0}
*
* Specifies the current direction in local space.
* A zero-length vector specifies an omni-directional source (cone is ignored).
*/
#define AL_DIRECTION 0x1005
/**
* Source or listener velocity.
* Type: ALfloat[3], ALint[3]
* Default: {0, 0, 0}
*
* Specifies the current velocity in local space.
*/
#define AL_VELOCITY 0x1006
/**
* Source looping.
* Type: ALboolean
* Range: [AL_TRUE, AL_FALSE]
* Default: AL_FALSE
*
* Specifies whether source is looping.
*/
#define AL_LOOPING 0x1007
/**
* Source buffer.
* Type: ALuint
* Range: any valid Buffer.
*
* Specifies the buffer to provide sound samples.
*/
#define AL_BUFFER 0x1009
/**
* Source or listener gain.
* Type: ALfloat
* Range: [0.0 - ]
*
* A value of 1.0 means unattenuated. Each division by 2 equals an attenuation
* of about -6dB. Each multiplicaton by 2 equals an amplification of about
* +6dB.
*
* A value of 0.0 is meaningless with respect to a logarithmic scale; it is
* silent.
*/
#define AL_GAIN 0x100A
/**
* Minimum source gain.
* Type: ALfloat
* Range: [0.0 - 1.0]
*
* The minimum gain allowed for a source, after distance and cone attenation is
* applied (if applicable).
*/
#define AL_MIN_GAIN 0x100D
/**
* Maximum source gain.
* Type: ALfloat
* Range: [0.0 - 1.0]
*
* The maximum gain allowed for a source, after distance and cone attenation is
* applied (if applicable).
*/
#define AL_MAX_GAIN 0x100E
/**
* Listener orientation.
* Type: ALfloat[6]
* Default: {0.0, 0.0, -1.0, 0.0, 1.0, 0.0}
*
* Effectively two three dimensional vectors. The first vector is the front (or
* "at") and the second is the top (or "up").
*
* Both vectors are in local space.
*/
#define AL_ORIENTATION 0x100F
```
| mobile | low | Minor |
126,105,647 | go | tour: use names instead of numbers for page urls | The current system of using paths like /moretypes/12 is problematic. One is that such URLs are not descriptive. The other is that the numbers change whenever we add or remove a page, breaking existing links. (I have two recent CLs that completely renumber the methods section.)
We should change the URLs to use names instead of numbers. For instance, the URL http://tour.golang.org/methods/4 could be http://tour.golang.org/methods/pointer-receivers instead. This adds a new requirement that all pages within a sub-tour must have a unique name, but I think the existing content meets that requirement already, and I don't think it's an onerous burden for future material.
@campoy - how hard would it be to do this? Looking at the code, I'm not sure how to make the change cleanly.
| NeedsInvestigation | low | Minor |
126,291,457 | vscode | Add fuzzy search to commands in palette | As @bpasero suggested, I'm opening an issue to suggest adding fuzzy search in the palette for commands as well.
He had an issue with this though, so it could be enabled with a user setting. But I am unsure about his concern.
> The issue with fuzzy matching is that you also need to do fuzzy sorting: more relevant results to the top. However for the command palette we chose to sort entries by name to keep the result list stable and memorable. Enabling fuzzy for commands would change the sort order for each search you do making it harder to learn the list of available commands.
I don't understand how the sort order is relevant when you are looking for a specific command or set of commands. Let's say I would like to look for all Markdown related commands (which start with `Markdown:`): in Sublime, I would only type `md:`, removing practically all unrelevant commands from the results list. The results however would still be sorted by names. Am I misunderstanding his issue?
Once you're used to search in a fuzzy pattern (often with shortened words like `msg` for message), it is very awkward to go back to typing complete words.
| feature-request,quick-open | medium | Critical |
Subsets and Splits