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 |
|---|---|---|---|---|---|---|
117,469,958 | flutter | Matrix lerp | If we had a true Matrix lerp(), then we could do things like support Hero animations regardless of how transformed the hero was (instead of now, where the Hero and the Navigator have to be axis-aligned for it to work).
| c: new feature,framework,a: animation,P3,team-framework,triaged-framework | low | Major |
117,490,419 | opencv | Bug in stitching module when applying composePanorama multiple times | Attempting to use composePanorama multiple times from the stitching module, yields very strange results. First time composePanorama is used, the resulting panorama is perfect, however the next time composePanorama, from the same stitch object is used, the resulting panorama is very strange.
The code that triggers the bug, can be boiled down to:
``` cpp
Stitcher stitcher = Stitcher::createDefault(try_use_gpu);
Mat pano; stitcher.composePanorama(pano);
Mat pano2; stitcher.composePanorama(imgs, pano2);
```
this blog post describes and illustrates the problem very well: http://www.scriptscoop.net/t/8d0bf668c48b/opencv-stitcher-class-with-overlapping-stationary-cameras.html
| bug,priority: normal,category: stitching | low | Critical |
117,545,258 | go | x/term: ReadKey() interface | Now that there is x/term (#13104) there should be some user stories.
The story here is that in LXC we have console client and server separated by websocket channel. Client uses os.Stdin to read the input from user. Server interprets what is being sent to it (passes it to pty?) Client most likely uses Read function from https://golang.org/pkg/io/#Reader, for which os.Stdin.Read() returns nothing on Windows.
This interface on Linux is flawed in the first place, because I personally don't understand what it should return on read from os.Stdin if I hit arrow key. What cryptic code it returns/expects on Linux part is a separate mystery to me.
So perhaps there should be a better interface - synchronous ReadKey() and that will return keys in a sequence, and combinations of keys are also tracked.
And if we catch keys, it is better to returns values that are serializable in some cross-platform formats to avoid dependency on certain import and receive ability to switch packages who provide ReadKey() interface easily. I'd use strings like Ctrl-Q etc.
Hopefully that's clear. And I want to use Ctrl-Q in golang programs and Ctrl-V for my own purposes. And I also don't want Linux terminal to hang if I kill go process somewhere in the middle after go already switched terminal to some non-friendly state for its own purpose.
| NeedsInvestigation | low | Minor |
117,711,073 | vscode | Provide option to opt out of line ending normalisation for files | Upon saving a file edited with VS Code, it appears to perform line ending normalisation automatically and without user notification of any sort. Because of this, I've found myself bitten by large diffs in Git (I'm aware you can circumvent this using the `-w` flag) where a trivial fix to a single line of source code appears to affect a significant proportion of the file, which makes pull requests and reviews for such changes on GitHub a pain to sift through. Then again, I guess one could argue why a source file with mixed line endings should stay in version control like that anyway!
Visual Studio Community displays a prompt upon opening a file if it has mixed line endings and lets a user decide whether or not to have it fixed.
**Version:** 0.10.1
(By the way, great work on open sourcing VS Code too, thanks!)
| feature-request,editor-textbuffer | high | Critical |
117,764,660 | go | net: TestDialerDualStack fails with "i/o timeout" or "got 5.81849453s; want <= 95ms" | TestDialerDualStack is commonly flaking on OpenBSD and Windows, albeit with different error messages:
https://www.google.com/search?q=TestDialerDualStack+openbsd+site%3Abuild.golang.org
```
--- FAIL: TestDialerDualStack (14.78s)
dial_test.go:633: got 5.81849453s; want <= 95ms
```
https://www.google.com/search?q=TestDialerDualStack+windows+site%3Abuild.golang.org
```
--- FAIL: TestDialerDualStack (5.30s)
dial_test.go:664: dial tcp 127.0.0.1:2651: i/o timeout
```
| Testing,OS-OpenBSD,OS-Windows,NeedsInvestigation | low | Critical |
117,765,591 | vscode | Better drag and drop / clipboard integration of files across applications | This includes being able to drag files and folders from VS Code into other applications as well as to being able to copy a file or folder to the native clipboard.
**Specifically:**
* [ ] copy files/folders from VS Code file explorer to clipboard and paste into native OS explorer
* [x] copy files/folders from native OS explorer and paste into VS Code file explorer (https://github.com/microsoft/vscode/issues/130036)
* [ ] support the native file data transfer when doing drag and drop (https://github.com/atom/electron/issues/2853)
* [ ] support 3rd party tools such as WinRAR to open files from an archive (https://github.com/microsoft/vscode/issues/90196)
* [x] drop files to the desktop to copy them there (https://github.com/microsoft/vscode/issues/128975) | help wanted,feature-request,upstream,workbench-os-integration,workbench-dnd,upstream-issue-linked | high | Critical |
117,814,442 | vscode | [grammars] provide alternative to TextMate grammars | TextMate isn't sufficient for many languages.
We have been integrating in to the lower level, in the src/vs/languages directory and using Modes.IState and supports.TokenisationSupport. There needs to be a way of writing an extension that can do this, which at least currently there doesn't seem to be,
Thanks.
| feature-request,api,languages-basic | medium | Critical |
117,846,001 | rust | Vec's reallocation strategy needs settling | # Background
Currently, Vec's documentation frequently contains the caveat that "more space may be reserved than requested". This is primarily in response to the fact that jemalloc (or any other allocator) can actually reserve more space than you requested because it relies on fixed size-classes to more effeciently dole out memory. (see the table [here](https://web.archive.org/web/20150529223415/http://www.canonware.com/download/jemalloc/jemalloc-latest/doc/jemalloc.html))
Jemalloc itself exposes a `malloc_usable_size` function which can be used to determine how much capacity was _actually_ allocated for a pointer, as well as `nallocx` which can be used to determine how much capacity _will_ be allocated for a given size and alignment. Vec can in principle query one of these methods and update its capacity field with the result.
The question at hand is: _is this ever worth it to check `usable_capacity`, and is it ever undesirable?_
This issue was kicked off by Firefox devs who have experience doing exactly this optimization, and claim it being profitable. Facebook has also claimed excellent dividends in making its allocation strategy more jemalloc friendly, but to my knowledge do not actually query usable_capacity.
Currently our alloction strategy is almost completely naive. One can see the source [here](http://doc.rust-lang.org/1.4.0/src/alloc/raw_vec.rs.html#191-202), which boils down to:
``` rust
let new_cap = if self.cap == 0 {
4
} else {
2 * self.cap
}
```
To the best of my knowledge, [this](https://github.com/facebook/folly/blob/badc3ebe7ef9d370e0d4b9d110f5dad6f6284d7e/folly/FBVector.h#L1127-L1156) is all the capacity logic for FBVector, which boils down to:
``` rust
let new cap = if self.cap == 0 {
max(64 / size_of_elem, 1) // empty
} else if self.cap < 4096 / size_of_elem) {
self.cap * 2 // small
} else if self.cap > 4096 * 32 / size_of_elem) {
self.cap * 2 // huge
} else {
(self.cap * 3 + 1) / 2 // moderate
}
```
The only major deviation from Rust today being a 1.5 growth factor for "moderate" sized allocations. Note that there _is_ a [path](https://github.com/facebook/folly/blob/26d9f3f3cc34d30f7e73a6f12a3bae5102c7512e/folly/small_vector.h#L636-L644) in their small_vector type that queries malloc_usable_size.
Unfortunately I've been unable to find good information on what Firefox does here. The best I could find is [this discussion](https://bugzilla.mozilla.org/show_bug.cgi?id=419131) which demonstrates big wins -- 6.5% less calls to malloc and 11% less memory usage. However the effort seems to peter out when it is asserted that this is obsoleted by Gecko just using power-of-two capacities. mxr and dxr seem to suggest it's only used for statistics.
Hopefully Firefox and Facebook devs can chime in on any experiences.
# Going Forward
I have several outstanding concerns before we push further on this matter.
Rust is not C++, so I am partially suspicious of any benchmarks that demonstrate value in C++. In particular, the proliferation of `size_hint` and `extend` could completely blast away any need to be clever with capacities for most programs. I would also expect a large Rust application to frob the allocator less in general just because we default to move semantics, and don't have implicit assignment/copy constructors. Also, Rust programs are much more "reckless" with just passing around pointers into buffers because the borrow checker will always catch misuse. Slices in particular make this incredibly ergonomic. We need Rust-specific benchmarks. I'm sure the Hyper, Servo, Glium, Serde, and Rust devs all have some interesting workloads to look at.
Rust's Vec is basically the community's `malloc`/`calloc`, because actual malloc is unstable and unsafe. We explicitly support extracting the Vec's pointer and taking control of the allocation. In that regard I believe it is desirable for it to be maximally well-behaved and performant for "good" cases (knowing exactly the capacity you want, having no use for extra capacity). There's a certain value in requesting a certain capacity, and getting the capacity. Both `nallocx` and `malloc_usable_size` are virtual function calls with non-trivial logic, and may have unacceptable overhead for responsible users of Vec.
Note that anything we do must enable `Vec` and `Box<[T]>` to reliably roundtrip through each other without reallocating in certain cases. If I invoke `shrink_to_fit` or `with_capacity`, it ought to not reallocate when I try to convert to a `Box<[T]>`. As far as I can tell, this should be possible to uphold even when using `malloc_usable_size` because jemalloc is "fuzzy" and only requires that the given size is somewhere between the requested one and the usable one.
Anything we do must also work with allocators that aren't jemalloc. This may be as simple as setting `usable_size = requested_size` for every allocator that isn't jemalloc.
CC @pnkfelix @erickt @reem @seanmonstar @tomaka @SimonSapin @larsberg @pcwalton @Swatinem @nnethercote
CC #29848 #29847 #27627
CC @rust-lang/libs
EDIT(workingjubilee, 2023-05-06): Originally one of the links touched on the master branch of folly instead of a permalink to a specific commit. Linkrot claimed the one to jemalloc's docs. These have been updated with a permalink and a Wayback Machine link, respectively. | C-enhancement,A-allocators,A-collections,T-libs-api,Libs-Tracked | high | Critical |
118,045,131 | vscode | Support workspace extensions | It would be interesting for people working on different projects to have a way to :
1: Set up extensions for the all team to have an uniform configuration
2: Have different extensions on different projects
I think that having a list of extensions in the Workspace configuration could solve this.
Otherwise i'll just have to write an extension for it :-)
| feature-request,plan-item,extensions | high | Critical |
118,055,447 | go | x/exp/shiny: no API to change a window size | it seems there is no way to programmatically change a `screen.Window` size.
currently, a `screen.Window` size can only be changed from outside the program (_e.g._ using the mouse).
I'd propose to extend `screen.Window` as such:
``` go
type Window interface {
// ...
// Resize resizes the window.
Resize(size image.Point)
// Size returns the size of the window.
Size() image.Point
}
```
| NeedsInvestigation | low | Major |
118,077,069 | opencv | Unexpected result in matchTemplate for TM_CCOEFF_NORMED | When the template is flat (all pixels have same value) the result of TM_CCOEFF_NORMED is 0/0 but matchTemplate returns 1.
Looking at [the formula](http://docs.opencv.org/3.0.0/df/dfb/group__imgproc__object.html#ga3a7850640f1fe1f58fe91a2d7583695d), `T` is the template:
`T'(x,y) = T(x,y) - mean(T)`
If T(x,y)=C for each x,y than mean(T)=C and you will have
`T'(x,y) = C - C = 0` for each x,y
the formula will be:
`R = 0 * I / sqrt(0 * I^2)` that is 0/0 !=1
This is true even if the Image patch under running template is constant.
In this case matchTemplate should returns undefined even if 0 has more sense
here is [the issue](https://github.com/opencv/opencv/blob/3.1.0/modules/imgproc/src/templmatch.cpp#L931)
here is simple test code:
``` cpp
Mat img,templ;
Scalar C = Scalar::all(64); //some rand number
img = imread("some_image.png");
templ = C + Mat::zeros(10,10,img.type()); // flat template
int result_cols = img.cols - templ.cols + 1;
int result_rows = img.rows - templ.rows + 1;
resultMatching.create(result_rows, result_cols, CV_32FC1);
// TM_CCOEFF returns all 0 as expected
matchTemplate(img, templ, resultMatching, TM_CCOEFF);
// TM_CCOEFF returns all 1 despite of it has sam numerator as TM_CCOEFF
matchTemplate(img, templ, resultMatching, TM_CCOEFF_NORMED);
```
| bug,priority: normal,category: imgproc | low | Major |
118,109,487 | vscode | [html] intellisense should be more context aware | Currently HTML intellisense will present special attributes that are only related to tags but that's about as smart as it gets. Here are some improvements that could be made:
- Don't suggest attributes that aren't valid on a particular tag (eg. aria widget attributes on a non-widget element)
- Don't suggest tags that are not valid within the parent tag (eg. `<li>` is the only tag valid within `<ol>` and `<ul>`)
| feature-request,html | low | Major |
118,116,525 | go | x/mobile: Permissions are needed in AndroidManifest.xml file | Many native Golang features are not usable without specifying permissions in AndroidManifest.xml. Suggest to put permissions by the time each package is imported, for example:
add the following permission when package "os" is imported:
< uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" / >
and add the following permission when package "net" is imported:
< uses-permission android:name="android.permission.INTERNET" / >
| mobile | low | Minor |
118,205,768 | go | x/mobile: panic when run golang.org/x/mobile/example/sprite on samsung phone. | golang 1.5.1
```
I/GoLog (21453): [kmgAndroidSprite1]
I/GoLog (21453): [kmgAndroidSprite2]
I/DEBUG ( 5150): *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
I/DEBUG ( 5150): Build fingerprint: 'samsung/m0zm/m0cmcc:4.0.4/IMM76D/I9308ZMBMA2:user/release-keys'
I/DEBUG ( 5150): pid: 21453, tid: 21453 >>> org.golang.todo.sprite <<<
I/DEBUG ( 5150): signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 00000014
I/DEBUG ( 5150): r0 00000014 r1 00000042 r2 00000003 r3 0064e0d8
I/DEBUG ( 5150): r4 00000014 r5 00000042 r6 00000000 r7 00000001
I/DEBUG ( 5150): r8 00000000 r9 56d53bd8 10 6beba2a0 fp 00000030
I/DEBUG ( 5150): d0 bf800000bf800000 d1 3f9ca20042220000
I/DEBUG ( 5150): d2 4130000040d00000 d3 000000003f800000
I/DEBUG ( 5150): d4 3f80000000000000 d5 0000000000000000
I/DEBUG ( 5150): d6 0000000000000000 d7 000000003f800000
I/DEBUG ( 5150): d8 0000000000000000 d9 0000000000000000
I/DEBUG ( 5150): d10 0000000000000000 d11 0000000000000000
I/DEBUG ( 5150): d12 0000000000000000 d13 0000000000000000
I/DEBUG ( 5150): d14 0000000000000000 d15 0000000000000000
I/DEBUG ( 5150): d16 0000000000000001 d17 3fe0000000000000
I/DEBUG ( 5150): d18 3ff0000000000000 d19 0000000000000000
I/DEBUG ( 5150): d20 0000000000000000 d21 0000000000000000
I/DEBUG ( 5150): d22 3ff0000000000000 d23 0000000000000000
I/DEBUG ( 5150): d24 3ff0000000000000 d25 0000000000000000
I/DEBUG ( 5150): d26 0000000000000000 d27 0000000000000000
I/DEBUG ( 5150): d28 0000000000000000 d29 0000000000000000
I/DEBUG ( 5150): d30 0000000000000000 d31 0000000000000000
I/DEBUG ( 5150): scr 60000010
I/DEBUG ( 5150):
I/SurfaceFlinger( 1887): id=52 Removed idx=1 Map Size=4
I/SurfaceFlinger( 1887): id=52 Removed idx=-2 Map Size=4
I/DEBUG ( 5150): #00 pc 00012344 /system/lib/libc.so (pthread_mutex_lock)
I/DEBUG ( 5150): #01 pc 00027166 /system/lib/libutils.so (_ZN7android6Looper8removeFdEi)
I/DEBUG ( 5150): #02 pc 0004cdbe /system/lib/libandroid_runtime.so (_ZN11AInputQueue12detachLooperEv)
I/DEBUG ( 5150): #03 pc 000098a8 /system/lib/libandroid.so (AInputQueue_detachLooper)
I/DEBUG ( 5150):
I/DEBUG ( 5150): code around pc:
I/DEBUG ( 5150): 400d3324 e3a02001 ebfffeb8 e1a00005 e8bd87f0 . ..............
I/DEBUG ( 5150): 400d3334 0003710c e92d47f0 e2504000 0a00001a .q...G-..@P.....
I/DEBUG ( 5150): 400d3354 e5945000 e1a02004 e2055a02 e1a00005 .P... ...Z......
I/DEBUG ( 5150): 400d3364 e3851001 ebffecbe e3500000 13856002 ..........P..`..
I/DEBUG ( 5150):
I/DEBUG ( 5150): code around lr:
I/DEBUG ( 5150): 40027148 f7f36809 bd10f87d 00007e56 41f0e92d .h..}...V~..-..A
I/DEBUG ( 5150): 40027158 0414f100 4680b088 460d4620 eb80f7ec .......F F.F....
I/DEBUG ( 5150): 40027168 f108a908 f8410734 46385d14 fbeef7fb ....4.A..]8F....
I/DEBUG ( 5150): 40027178 46062800 2102db21 f8d82300 462a0030 .(.F!..!.#..0.*F
I/DEBUG ( 5150): 40027188 ee1af7ec da0e2800 eb58f7ec 4a10490f .....(....X..I.J
I/DEBUG ( 5150):
I/DEBUG ( 5150): stack:
I/DEBUG ( 5150): bec4c470 00000007
I/DEBUG ( 5150): bec4c474 409679d7 /system/lib/libdvm.so
I/DEBUG ( 5150): bec4c478 bec4c56c [stack]
I/DEBUG ( 5150): bec4c47c 409bcf9c /system/lib/libdvm.so
I/DEBUG ( 5150): bec4c480 14e0001d
I/DEBUG ( 5150): bec4c484 4094dfc5 /system/lib/libdvm.so
I/DEBUG ( 5150): bec4c488 00000007
I/DEBUG ( 5150): bec4c48c 409679d7 /system/lib/libdvm.so
I/DEBUG ( 5150): bec4c490 bec4c584 [stack]
I/DEBUG ( 5150): bec4c494 409bcf9c /system/lib/libdvm.so
I/DEBUG ( 5150): bec4c498 14e0001d
I/DEBUG ( 5150): bec4c49c 4094dfc5 /system/lib/libdvm.so
I/DEBUG ( 5150): bec4c4a0 e9700019
I/DEBUG ( 5150): bec4c4a4 4094dfc5 /system/lib/libdvm.so
I/DEBUG ( 5150): bec4c4a8 4099d4da /system/lib/libdvm.so
I/DEBUG ( 5150): bec4c4ac 005edd48 [heap]
I/DEBUG ( 5150): #00 bec4c4b0 00000014
I/DEBUG ( 5150): bec4c4b4 00000042
I/DEBUG ( 5150): bec4c4b8 00000000
I/DEBUG ( 5150): bec4c4bc 00000001
I/DEBUG ( 5150): bec4c4c0 00000000
I/DEBUG ( 5150): bec4c4c4 56d53bd8
I/DEBUG ( 5150): bec4c4c8 6beba2a0
I/DEBUG ( 5150): bec4c4cc 40027169 /system/lib/libutils.so
I/DEBUG ( 5150): #01 bec4c4d0 5bac7324 /data/data/org.golang.todo.sprite/lib/libsprite.so
I/DEBUG ( 5150): bec4c4d4 5bb0add0 /data/data/org.golang.todo.sprite/lib/libsprite.so
I/DEBUG ( 5150): bec4c4d8 00000001
I/DEBUG ( 5150): bec4c4dc 5babc258 /data/data/org.golang.todo.sprite/lib/libsprite.so
I/DEBUG ( 5150): bec4c4e0 0064e0f8 [heap]
I/DEBUG ( 5150): bec4c4e4 bec4c50c [stack]
I/DEBUG ( 5150): bec4c4e8 0064e0f8 [heap]
I/DEBUG ( 5150): bec4c4ec bec4c50c [stack]
I/DEBUG ( 5150): bec4c4f0 0064e110 [heap]
I/DEBUG ( 5150): bec4c4f4 bec4c50c [stack]
I/DEBUG ( 5150): bec4c4f8 00000000
I/DEBUG ( 5150): bec4c4fc 00000001
I/DEBUG ( 5150): bec4c500 6bed4000
I/DEBUG ( 5150): bec4c504 4021cdc1 /system/lib/libandroid_runtime.so
```
I tried to dig around , it looks like the code panic here:
src/golang.org/x/mobile/example/sprite/main.go:68
| mobile | low | Critical |
118,306,150 | rust | rustc should warn when a (library) crate's name doesn't match its filename | Staring at `libfoo.rlib` while having rustc insist that it can't find crate `foo` is really confusing.
```
$ cat lib.rs
#![crate_type = "rlib"]
pub fn foo() {}
$ cat main.rs
extern crate foo;
fn main() { foo::foo(); }
$ rustc lib.rs -o libfoo.rlib
$ rustc -L. main.rs
main.rs:1:1: 1:18 error: can't find crate for `foo` [E0463]
main.rs:1 extern crate foo;
^~~~~~~~~~~~~~~~~
error: aborting due to previous error
$ ls
lib.rs libfoo.rlib main.rs
$
```
| A-frontend,T-compiler,C-feature-request | low | Critical |
118,311,491 | opencv | program crash in cv::gpu::device::hog::set_up_constants | I'm using hog of the gpu module. I have NVIDA GTX660 and NVIDA GTX550 and my OpenCV version is 2.4.11.
I got an error when I reboot my computer(Centos6.4, Centos 7, Ubuntu14.4) _every time_. The more detail is as follows:
<br/p>
`OpenCV Error: Gpu API call (unknown error) in set_up_constants, file /home/setup/opencv-2.4.11/modules/gpu/src/cuda/hog.cu, line 93
terminate called after throwing an instance of 'terminate called after throwing an instance of 'cv::Exception' what(): /home/setup/opencv-2.4.11/modules/gpu/src/cuda/hog.cu:93: error: (-217) unknown error in function set_up_constants
`
<br/p>
My temporary solution is reinstall OpenCV by make install.
But if I make install before starting the program and making it crash, it won't help.
so the "right" steps may be:
1. reboot my computer
2. start my program and get a crash.
3. make install opencv
4. start my program again.
Why does this happen? It makes me crazy!
| bug,priority: normal,affected: 2.4,category: gpu/cuda (contrib) | low | Critical |
118,398,968 | three.js | Allow post effects to request access to depth and normal passes | Many post effects request specific special passes, normal and depth mostly, to create their effect. Specifically:
DOF: depth
SSAO: depth, normal
SAO: depth, normal
MB: motion, depth?
While it is possible to set up the creation of a normal and depth pass and then coordinate passing that result into another effect, it quickly becomes hard to manage if you can turn on or off the various effects, you may unnecessarily be computing a depth pass when you do not need it.
One alternative solution would be for each pass to state explicitly what passes it requires, so a DOF pass would state it needs a depth buffer. And a SAO pass would state that it needs a depth and a normal buffer.
It would then be the renderer's responsibility to create the buffers that the enabled post effects require. This would simplify creating post effects and it would make it more efficient to use post effects.
Focusing on a request model and encapsulating in the renderer how these buffers are generated would allow us to change how these buffers are generated. So that on Desktop we could use the WebGL DrawBuffers extension to create them in a single pass, while on mobile we can do multiple passes.
This also integrates well into AA systems where the normal or the depth buffer needs to be preprocessed with the same AA system that the beauty pass used for consistent sake -- this is the case with algorithms such as TAA.
(I would love to implement this but I've got other commitments for the next month. I am also not sure of the right design, even though I think the above is a good outline of a general direction to go in.)
/ping @benaadams @erichlof @MasterJames
| Enhancement,Post-processing | low | Minor |
118,403,594 | opencv | FlannBasedMatcher throws exception on large inputs | I'm getting the following exception from the call to knnMatch (see code given below):
`opencv/modules/core/src/ocl.cpp:4585: error: (-215) u->origdata == data in function deallocate`
The exception is only thrown when the descriptor sets are very large (i.e. dense features for two images).
The exception is thrown when the scope of FlannBasedMatcher::add is exited (features2d/src/matchers.cpp), I'm guessing during deallocation of `std::vector<UMat> descriptors`, although not sure.
``` C++
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/xfeatures2d.hpp>
#include <opencv2/flann.hpp>
#include <opencv2/imgcodecs.hpp>
int main(int argc, char* argv[]){
cv::Mat im_l = cv::imread("im_left.png");
cv::Mat im_r = cv::imread("im_right.png");
cv::Ptr<cv::xfeatures2d::DAISY> daisy = cv::xfeatures2d::DAISY::create(30,6);
std::vector<cv::KeyPoint> keypoints_l;
std::vector<cv::KeyPoint> keypoints_r;
cv::Mat descriptors_l;
cv::Mat descriptors_r;
daisy->compute(im_l,descriptors_l);
daisy->compute(im_r,descriptors_r);
std::vector<cv::DMatch> good_matches;
cv::Ptr<cv::flann::KDTreeIndexParams> kdIndParams(new cv::flann::KDTreeIndexParams(5));
cv::Ptr<cv::flann::SearchParams> searchParams(new cv::flann::SearchParams(50));
cv::FlannBasedMatcher matcher( kdIndParams, searchParams);
std::vector<std::vector<cv::DMatch>> matches;
matcher.knnMatch( //OpenCV exception here
descriptors_l,
descriptors_r, matches, 2);
filter_good_matches(matches,good_matches,0.75);
return 0;
}
```
| bug,priority: normal,affected: 3.4,category: t-api | low | Critical |
118,407,946 | rust | thread_local macro stability precludes safe async signal handling | The `thread_local!` macro accepts arbitrary (non-Sync) objects to be put into thread local storage. It is not hard to construct a case where this causes signal handlers to observe inconsistent state:
``` rust
extern {
fn signal(num: i32, handler: extern fn(i32)) -> extern fn(i32);
}
use std::cell::{RefCell};
/// First and second value always the same.
thread_local!(static X: RefCell<(usize,usize)> = RefCell::new((0,0)));
extern fn handler(_: i32) {
X.with(|x| {
let x = x.borrow();
println!("{:?}", *x);
});
}
fn main() {
unsafe { signal(2, handler); }
X.with(|x| {
let mut x = x.borrow_mut();
x.0 += 1;
// raise(2)
x.1 += 1;
});
}
```
`RefCell` is not signal safe. A mutable borrow will not mark the `RefCell` as being borrowed in this case. This can be simulated as follows:
- Compile with `-O -C lto`
- In gdb, step to the instruction that stores the second value.
- `signal 2`
Expected result: panic/abort/segfault or similar. Actual result: `(1, 0)` is printed.
Fixing RefCell by adding a memory barrier does not fix the problem since there might be many other non-Sync types that were not written with signal handling in mind and that use unsafe constructs. For correctness, TLS would have to be restricted to types that are async safe via a new marker trait. With such a trait, signal handling would be safe by default in all rust code and all signals handlers could call arbitrary rust functions (as long as said functions don't call non-rust code which might not be async safe.)
---
This concerns me because adding a signal handler is a safe operation in lrs and all `#[thread_local]` objects that require mutation are wrapped in a single threaded mutex implementation with interior mutability. And if it is decided that async signal handling is never safe in rust, then `#[thread_local]` might be stabilized and might also start to accept arbitrary objects which would practically force me to create a full compiler fork for the sake of safety. The current implementation in lrs is already unsafe because the single threaded mutex implementation has to be marked `Sync` to be placed in a `#[thread_local]`. For correctness, there would have to be the above mentioned marker trait that restricts what can be put in a `#[thread_local]`.
| P-low,I-needs-decision,T-lang,C-bug | low | Major |
118,506,825 | opencv | HoughLine results not ordered when using OpenCL | I have been using HoughLine function with UMat parameters on GPU. When I transfer back the results, they are not ordered according to their accumulator values, as advertised in the documentation.
It works well on CPU.
OpenCV version is 3.0.0
| priority: normal,feature,category: imgproc,category: t-api | low | Minor |
118,507,949 | vscode | Allow to change the font size and font of the workbench | At the moment, we can only change the font size / font of the editor. If we want to change the font size, we need to use a roundabout method of "zooming in / out". It would be nice if this could be adjusted through the preferences.
| feature-request,workbench-fonts | high | Critical |
118,520,263 | go | cmd/internal/obj: implement auto-nosplit for arm64, ppc64 | See #11482 and CL 17165. The fix was to add nosplit tags, but the implication is that arm64 and ppc64 do not have the same "auto-nosplit" optimization that the other architectures do for leaf functions with tiny frames. They should.
| compiler/runtime | low | Minor |
118,569,207 | TypeScript | decorators in object literals not working | _From @pascalopitz on November 19, 2015 11:43_
I am getting a parsing error for decorators on object literal properties. My jsconfig.json looks like this:
```
{
"compilerOptions": {
"target": "ES6",
"module": "commonjs",
"experimentalDecorators": true
}
}
```
This code compiles okay in babel 5.8.12 using the "es7.decorators" extension.
Can I somehow make this work?
_Copied from original issue: Microsoft/vscode#201_
| Suggestion,Committed,Domain: Decorators | medium | Critical |
118,658,107 | go | crypto/tls: Disable CBC Ciphers by default | Per @agl on Twitter, the only way to be safe with Go and TLS if you are worried about Lucky13-style attacks is to disable CBC mode ciphers:
https://twitter.com/agl__/status/669182140244824064
Currently none of the CBC ciphers are marked with `suiteDefaultOff`: https://github.com/golang/go/blob/master/src/crypto/tls/cipher_suites.go#L75-L95
```
TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA
TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA
TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA
TLS_RSA_WITH_AES_128_CBC_SHA
TLS_RSA_WITH_AES_256_CBC_SHA
TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA
TLS_RSA_WITH_3DES_EDE_CBC_SHA
```
It seems wrong for Go to have insecure defaults for a class of attacks that is becoming more well documented. If there is no willingness to implement countermeasures, shouldn't the vulnerable class of ciphers be disabled by default?
| Security | low | Major |
118,660,046 | go | runtime: annotation for sysAlloced types | @randall77 recently found some subtle issues related to write barriers on fields that point from runtime structures allocated from non-GCed (and hence non-scanned) memory to GCed heap memory. I manually audited all non-GCed structures to find any other such pointers, but obviously manual auditing can get out of date.
One possible way to help automate this is to add an annotation on types that are allocated from non-GCed memory. This annotation would disallow pointers to types that do not have this annotation and would disallow calling new on this type (implicit heap allocations are already disallowed in the runtime). It should probably also disallow unsafe.Pointer in annotated types (effectively requiring uintptr instead).
/cc @randall77 @ianlancetaylor @rsc @RLH
| NeedsInvestigation | low | Major |
118,663,224 | java-design-patterns | Backends for Frontends pattern | **Description:**
The Backends for Frontends (BFF) design pattern is intended to create separate backend services for different user interfaces or clients. This pattern is particularly useful when different clients (such as mobile apps, desktop applications, and web applications) have distinct needs and require tailored backend interactions. Implementing BFF helps to ensure that each client gets exactly the data it requires in the optimal format, improving performance and maintainability.
**Main Elements of the Pattern:**
1. **Client-Specific Backend:** Each frontend has a dedicated backend service that caters to its specific needs.
2. **Data Aggregation:** The BFF aggregates data from various sources and formats it appropriately for the frontend.
3. **Decoupling:** This pattern decouples the frontend from the complexities of backend systems, providing a clean API tailored to the frontend's requirements.
4. **Optimized API:** Each backend service provides an optimized API for its respective client, improving performance and user experience.
**References:**
- [Backends for Frontends (BFF) Pattern](https://samnewman.io/patterns/architectural/bff/)
- [Microservices Patterns: With examples in Java](https://www.amazon.com/Microservices-Patterns-examples-Chris-Richardson/dp/1617294543)
- [Github Contribution Guidelines](https://github.com/iluwatar/java-design-patterns/wiki)
**Acceptance Criteria:**
1. **Client-Specific Backend Services:** Implement distinct backend services for at least two different clients (e.g., web and mobile).
2. **Data Aggregation:** Ensure that the BFFs aggregate data from multiple services and format it specifically for their respective clients.
3. **Optimized APIs:** Create clean and optimized APIs for each backend service to improve the performance and user experience of the respective frontends.
| info: help wanted,epic: pattern,type: feature | low | Major |
118,665,468 | java-design-patterns | Elm architectural pattern | **Description:**
The Elm design pattern, originating from the Elm language, is a pattern for building web applications that emphasizes simplicity, maintainability, and robustness. It follows the Model-View-Update (MVU) architecture, making state management predictable by using a single, immutable state.
**Main Elements of the Pattern:**
1. **Model:** Represents the state of the application.
2. **View:** A function of the model that returns the HTML representation.
3. **Update:** A function that takes the current state and a message, returning a new state.
4. **Messages:** Dispatched events that trigger state transitions.
5. **Commands:** Side effects such as HTTP requests that do not change the state directly but might produce messages.
**References:**
1. [The Elm Architecture](https://guide.elm-lang.org/architecture/)
2. [Elm Architecture Tutorial](https://github.com/evancz/elm-architecture-tutorial/)
**Acceptance Criteria:**
1. Implement the Model-View-Update architecture with clear separation of concerns.
2. Ensure immutability of the state and the predictability of state transitions.
3. Provide comprehensive unit tests covering all components (Model, View, Update, Messages, and Commands).
| info: help wanted,epic: pattern,type: feature | low | Minor |
118,676,703 | neovim | Increment and decrement operations truncate big numbers | Clicking Ctrl+a (increment) or Ctrl+x (decrement number) while cursor is under
```
12016012609141909200527091927191118250205120747
```
will truncate it to
```
12555055019999496428
```
and
```
12555055019999496426
```
respectively.
| bug-vim | low | Major |
118,699,968 | vscode | Can I get scope / scopeRange at a position? | _From @billti on November 1, 2015 6:10_
The API call `document.getWordRangeAtPosition(position)` appears to use its own definition of a word. For example, my tmLanguage defines `attrib-name` as a token/scope, yet `getWordRangeAtPosition` appears to break this into 2 words on the `-` character.
How can I get token ranges at a position based on my custom syntax? (And it would be really useful if I could get the scope name that goes along with it too).
_Copied from original issue: Microsoft/vscode-extensionbuilders#76_
| feature-request,api,tokenization | high | Critical |
118,700,066 | vscode | Support autoClosingPairs for strings like `begin` and `end` | _From @Wosi on October 27, 2015 20:23_
I'd like to define `autoClosingPairs` for Pascal like `begin <-> end`, `if <-> then` etc.
Definitions for closing pairs like these seem to be ignored by VSCode. It looks like auto closing is currently supported for character pairs only.
Please add support for longer auto closing pairs.
_Copied from original issue: Microsoft/vscode-extensionbuilders#66_
| feature-request,editor-autoclosing | medium | Critical |
118,700,228 | vscode | Link to a file position in Output Channel | _From @ArtemGovorov on October 19, 2015 2:0_
As mentioned in [this issue](https://github.com/Microsoft/vscode-extensionbuilders/issues/19#issuecomment-148695187), output channel supports link rendering. I'd like to append a link to a workspace file position (by providing a file name, line and column in some form). If it's already possible, could you please paste an example on how to do it?
_Copied from original issue: Microsoft/vscode-extensionbuilders#41_
| feature-request,output | medium | Critical |
118,712,587 | angular | Implement @ObserveChildren or similar API | Previously discussed with @vsavkin and @jeffbcross
Background - programmatically listening to events propagated by children is difficult currently.
Consider:
You have a `<accordion>` component and n `<accordion-item>` components:
```
<accordion>
<accordion-item></accordion-item>
<accordion-item></accordion-item>
<accordion-item></accordion-item>
</accordion>
```
An accordion-item component might emit a `select` event/output, used to set it as the currently active item.
Currently the best way to achieve this is the accordion-item component would inject the parent accordion, and have the accordion-item register itself with the parent, and call a method to close the others
``` typescript
@Component({selector: 'accordion' })
class Accordion {
_items: []AccordionItem = [];
register(item: AccordionItem){
this._items.push(item);
}
toggleActive(selectedItem:AccordionItem){
this._items.forEach(item => {
if(item !== selectedItem){
item.active = false;
}
});
selectedItem.active = true;
}
}
@Component({selector: 'accordion-item' , inputs: ['active'] })
class AccordionItem {
active: boolean;
constructor(private accordion: Accordion){
accordion.register(this);
}
setActive(){
this.accordion.toggleActive(this);
}
}
```
Ideally, a child component would simply expose a 'select' event:
``` typescript
@Component({selector: 'accordion-item' })
class AccordionItem {
@Input() active: boolean;
@Output selected:EventEmitter<AccordionItem> = new EventEmitter();
active: boolean;
setActive(){
this.selected.emit(this);
}
}
```
The parent accordion can currently easily get ahold of the children via `@ViewChildren()` (or whatever) but there is a not a clean way to listen to events emitted from the children.
Proposed Syntax:
Implement a `@ObserveChildren` decorator (or similar) that would enable Observation of events emitted by child components:
``` typescript
@Component({selector: 'accordion' })
class Accordion {
//specify type and desired output to Observe.
@ObserveChildren(AccordionItem, 'select') childSelections: Observable<AccordionItem>
@ViewChildren(AccordionItem) children: Observable<AccordionItem>
afterViewInit(){
this.updates = Observable
.combineLatest(this.children, this.childSelections, (children, selected) => ({children, selected}))
.do(({children, selected) => children.map(child => { //update state }))
.subscribe();
}
onDestroy(){
this.updates.unsubscribe();
}
}
```
cc @pkozlowski-opensource @Foxandxss
| feature,hotlist: components team,area: core,core: queries,design complexity: major,feature: under consideration | medium | Major |
118,715,703 | rust | Mutable references as function arguments generate inefficient code in trivial cases | ``` rust
#![crate_type = "lib"]
#[no_mangle]
pub fn good1(x: &mut bool) {
*x = *x;
}
#[no_mangle]
pub fn good2(x: &mut bool) {
if *x {
*x = *x;
} else {
*x = *x;
}
}
#[no_mangle]
pub fn good3(x: &mut bool) {
let mut y = *x;
if y {
y = y;
}
*x = y;
}
#[no_mangle]
pub fn good4(x: &mut bool) {
let mut y = *x;
if y {
y = false;
y = true;
}
*x = y;
}
#[no_mangle]
pub fn bad1(x: &mut bool) {
if *x {
*x = *x;
}
}
#[no_mangle]
pub fn bad2(x: &mut bool) {
if *x {
*x = false;
*x = true;
}
}
#[no_mangle]
pub fn bad3(x: &mut bool) {
if !*x {
*x = *x;
}
}
```
```
good1:
retq
good2:
retq
good3:
retq
good4:
retq
bad1:
cmpb $0, (%rdi)
je .LBB4_2
movb $1, (%rdi)
.LBB4_2:
retq
bad2:
cmpb $0, (%rdi)
je .LBB5_2
movb $1, (%rdi)
.LBB5_2:
retq
bad3:
cmpb $0, (%rdi)
jne .LBB6_2
movb $0, (%rdi)
.LBB6_2:
retq
```
| A-LLVM,I-slow,C-enhancement,A-codegen,T-compiler | low | Major |
118,721,621 | go | tour: link to more resources throughout all content | Context: https://tour.golang.org/concurrency/5
It would be very useful to have a "Would you like to know more?" link in the description to the documentation, in this case https://golang.org/ref/spec#Select_statements
| NeedsInvestigation | low | Major |
118,761,410 | youtube-dl | Add support for bosrtv.nl | http://bosrtv.nl/televisie/....
youtube-dl http://bosrtv.nl/televisie/in-het-spoor-van-nichiren
[generic] in-het-spoor-van-nichiren: Requesting header
WARNING: Falling back on generic information extractor.
[generic] in-het-spoor-van-nichiren: Downloading webpage
[generic] in-het-spoor-van-nichiren: Extracting information
ERROR: Unsupported URL: http://bosrtv.nl/televisie/in-het-spoor-van-nichiren; please report this issue on https://yt-dl.org/bug .
| site-support-request | low | Critical |
118,776,362 | java-design-patterns | Presentation-Abstraction-Control pattern | ## Description:
The Presentation-Abstraction-Control (PAC) is a design pattern used in software architecture that focuses on the separation of concerns into three interconnected components:
1. **Presentation:** Manages the user interface and user interactions.
2. **Abstraction:** Encapsulates the business logic and data management.
3. **Control:** Mediates the interaction between the presentation and abstraction layers.
### Main Elements of the Pattern:
- **Presentation:** Handles the graphical or textual representation of the application and the user inputs.
- **Abstraction:** Contains the core functionality and business logic.
- **Control:** Acts as an intermediary, coordinating the flow of data and commands between the presentation and abstraction layers.
### References:
- [Presentation-Abstraction-Control Pattern](https://en.wikipedia.org/wiki/Presentation–abstraction–control)
- [MVC vs PAC](http://www.garfieldtech.com/blog/mvc-vs-pac)
### Acceptance Criteria:
1. Implement a basic example of the PAC design pattern with clear separation between Presentation, Abstraction, and Control components.
2. Ensure the code follows the project contribution guidelines as outlined in the [Java Design Patterns Wiki](https://github.com/iluwatar/java-design-patterns/wiki).
3. Provide comprehensive documentation and unit tests for the implemented pattern, demonstrating its functionality and interactions between components.
| info: help wanted,epic: pattern,type: feature | low | Major |
118,866,227 | youtube-dl | --flat-playlist doesn't also work with --get-url or --get-title or other --get- features | Maybe this is a wishlist bug: it would be great if --flat-playlist worked with --get-url or --get-title or other --get- features to allow users to get reports about the content of playlists. Supporting --get-duration for flat-playlists would be cool because then you would know how many hours of video you are about to download.
| request | low | Critical |
118,882,936 | go | encoding/xml: fix name spaces | There are many pending issues related to the handling of xml name spaces. We need to rethink this. One more try and then we're going to give up.
- #7535 encoding/xml: Encoder duplicates namespace tags
- #11496 encoding/xml: Serializing XML with namespace prefix
- #9775 encoding/xml: Unmarshal does not properly handle NCName in XML namespaces
- #12624 encoding/xml: brittle support for matching a namespace by identifier or url
- #8167 encoding/xml: disallow attributes named xmlns:*
- #11735 encoding/xml: empty namespace conventions are badly documented
- #8068 encoding/xml: empty namespace prefix definitions should be illegal
- #8535 encoding/xml: failure to handle conflicting tags in different namespaces
- #11431 encoding/xml: loss of xmlns= in encoding since Go 1.4
- #7113 encoding/xml: missing nested namespace not handled
- #11724 encoding/xml: namespaced and non-namespaced attributes conflict
- #7233 encoding/xml: omit parent tags if value is empty #2
- #12406 encoding/xml: support QName values / expose namespace bindings
- #9519 encoding/xml: support for XML namespace prefixes
| NeedsFix,early-in-cycle | high | Critical |
118,905,802 | youtube-dl | Site request: www.sdarot.pm | This is an Israeli TV streaming site.
Example season URL:
http://www.sdarot.pm/watch/1004-%D7%94%D7%99%D7%A9%D7%A8%D7%93%D7%95%D7%AA-%D7%99%D7%A9%D7%A8%D7%90%D7%9C-survivor-israel/season/7
Normally each episode requires a 30 second wait before viewing link becomes active.
| site-support-request | low | Minor |
118,914,382 | vscode | Native node modules from extensions | I’m looking to build an extension but one of the packages I need to depend on is a native module. When I do an `npm install` it installs the package just fine, I can launch a node shell and interact with it, etc. But when I go to use the package from within my plugin I get an error as it’s trying to load the ia32 build of the native module not the x64 which was compiled by node-gyp.
A quick bit of debugging indicates that the problem stems by `process.arch` returning `ia32` when running in VS Code when my machine is a x64 machine (Win10 x64).
So is there some way to either:
- Have VS Code run an x64 process
- Have VS Code’s ia32 process do my npm restore (and subsequent compile with node-gyp)
Otherwise I fear that my extension might be dead in the water :frowning:
| feature-request,extensions | high | Critical |
118,929,428 | go | go/printer: consider permitting one-line "enum" const decls | A declaration of the form:
```
const (
Do = iota; Re; Mi; Fa; Sol; La; Ti;
)
```
gets formatted as:
```
const (
Do = iota
Re
Mi
Fa
Sol
La
Ti
)
```
The former is close to what in other languages might be achieved with an "enum" declaration. If there's several such simple const decls, the latter form uses undue amount of space w/o much readability benefit.
Consider recognizing this special case and not introduce line-breaks if there were none in the original source.
| NeedsDecision | low | Major |
118,936,297 | You-Dont-Know-JS | Async & Performance - ch6 - Calculation error | In the **Chapter 6**, under **Context Is King** we can read:
> You could claim that Y is 20% slower than X,...
Three paragraphs after, one operation of X is estimated to take 100ns and a Y operation one to 80ns. If a Y operation is slower than a X operation by 20%, it should take 120ns to be done and not 80ns.
``` diff
- If X takes 100ns, and Y takes 80ns, the difference is 20ns…
+ If X takes 100ns, and Y takes 120ns, the difference is 20ns…
```
| for second edition,errata | medium | Critical |
119,114,113 | youtube-dl | Support for Het Nieuwsblad | - **URL:** http://www.nieuwsblad.be/cnt/dmf20151124_01986463
- **Error:** Unsupported URL: http://www.nieuwsblad.be/cnt/dmf20151124_01986463
- **Platform:** openSUSE 13.1, x86_64, XFCE
- **Version:** 2015.11.24
- **Video player:** VRT Player (custom?)
```
sven@linux-etoq:/mnt/storage2/archive> ytdl -v http://www.nieuwsblad.be/cnt/dmf20151124_01986463
[debug] System config: []
[debug] User config: []
[debug] Command-line args: [u'--title', u'--continue', u'--retries', u'4', u'--write-info-json', u'--write-description', u'--write-thumbnail', u'--write-annotations', u'--all-subs', u'--ignore-errors', u'--merge-output-format', u'mkv', u'-f', u'bestvideo+bestaudio/best', u'-v', u'http://www.nieuwsblad.be/cnt/dmf20151124_01986463']
[debug] Encodings: locale ANSI_X3.4-1968, fs ANSI_X3.4-1968, out ANSI_X3.4-1968, pref ANSI_X3.4-1968
[debug] youtube-dl version 2015.11.24
[debug] Python version 2.7.6 - Linux-3.11.10-29-desktop-x86_64-with-SuSE-13.1-x86_64
[debug] exe versions: ffmpeg 2.8.2, ffprobe 2.8.2, rtmpdump 2.4
[debug] Proxy map: {}
[generic] dmf20151124_01986463: Requesting header
WARNING: Falling back on generic information extractor.
[generic] dmf20151124_01986463: Downloading webpage
[generic] dmf20151124_01986463: Extracting information
ERROR: Unsupported URL: http://www.nieuwsblad.be/cnt/dmf20151124_01986463
Traceback (most recent call last):
File "/usr/lib/python2.7/site-packages/youtube_dl/extractor/generic.py", line 1282, in _real_extract
doc = compat_etree_fromstring(webpage.encode('utf-8'))
File "/usr/lib/python2.7/site-packages/youtube_dl/compat.py", line 248, in compat_etree_fromstring
doc = _XML(text, parser=etree.XMLParser(target=etree.TreeBuilder(element_factory=_element_factory)))
File "/usr/lib/python2.7/site-packages/youtube_dl/compat.py", line 237, in _XML
parser.feed(text)
File "/usr/lib64/python2.7/xml/etree/ElementTree.py", line 1642, in feed
self._raiseerror(v)
File "/usr/lib64/python2.7/xml/etree/ElementTree.py", line 1506, in _raiseerror
raise err
ParseError: syntax error: line 3, column 0
Traceback (most recent call last):
File "/usr/lib/python2.7/site-packages/youtube_dl/YoutubeDL.py", line 663, in extract_info
ie_result = ie.extract(url)
File "/usr/lib/python2.7/site-packages/youtube_dl/extractor/common.py", line 290, in extract
return self._real_extract(url)
File "/usr/lib/python2.7/site-packages/youtube_dl/extractor/generic.py", line 1887, in _real_extract
raise UnsupportedError(url)
UnsupportedError: Unsupported URL: http://www.nieuwsblad.be/cnt/dmf20151124_01986463
```
| site-support-request | low | Critical |
119,200,098 | rust | Codegen for a large static array uses a lot of memory | Following 2 lines of Rust code can use more than 200 MB of memory to compile.
``` rust
const L: usize = 1 << 25;
pub static S: [u32; L] = [1; L];
```
```
$ rustc --crate-type lib -Z time-passes test.rs | grep translation
time: 0.710; rss: 209MB translation
```
Reported on [users.rust-lang.org post](https://users.rust-lang.org/t/memory-leak-of-rustc/3781). See also #23600.
| A-LLVM,C-enhancement,T-compiler,I-compilemem | low | Major |
119,239,163 | vscode | Hide empty folders after apply file exclusions (user settings) | I'm a Unity 3D developer. Although I use file exclusions, it would be nice to hide folder that get empty after file exclusions are applied.
| feature-request,file-explorer | medium | Critical |
119,379,845 | neovim | quickfix: Relative/absolute filenames mess | vim/neovim names its file buffers according to the path passed to `:e`. When the passed path is relative the buffer name becomes relative, when it's absolute the buffer name becomes absolute. But then `:cd X` and `:lcd X` rename the buffers to become absolute if outside X, otherwise relative. Even worse: an `:lcd` in any window will also update names for other windows (indeed, this is the reason my hack -see below- works).
This behavior is not consistent and thus confusing: sometimes absolute means outside the current working directory, sometimes not. For quickfix, which parses the output of external command, this often implies that files in the current directory are shown with absolute paths (in case the external command happens to report the full path). I would go to say the behavior is wrong.
This was discussed a time ago in vim mailing list but never really addressed:
https://groups.google.com/forum/#!topic/vim_use/Vq0z2DJH2So
(And see my awful workaround at the end: `0split | lcd . | quit`, I would like to remove it from my config for good!)
There are two issues described there:
- [ ] Consistently set buffer names on creation. The obvious rule is: relative if inside current working directory, otherwise absolute.
- [ ] It would be nice if `getcwd()` could specify whether the desired cwd is the local or the global one.
| bug-vim,quickfix | medium | Major |
119,436,145 | java-design-patterns | Staged Event Driven Architecture (SEDA) | ### Description
The Staged Event-Driven Architecture (SEDA) is a design pattern used to manage the complexity of highly concurrent systems. It divides the processing of events into a series of stages connected by queues, allowing for more manageable concurrency and better isolation of different parts of the system. Each stage can be thought of as a pipeline segment that processes events and then hands them off to the next stage. This pattern improves scalability, fault tolerance, and performance.
**Main Elements of the Pattern:**
1. **Stages:** Individual units of processing that handle specific tasks. Each stage is isolated from others and communicates through events.
2. **Event Queues:** Buffers that connect stages, allowing asynchronous communication between them. These queues help decouple the stages, improving system resilience.
3. **Thread Pools:** Each stage can have its own thread pool to process events concurrently, providing fine-grained control over resource allocation.
4. **Event Flow Control:** Mechanisms to regulate the flow of events through the stages, preventing bottlenecks and ensuring smooth operation.
### References
- [Staged Event-Driven Architecture (SEDA) - Wikipedia](https://en.wikipedia.org/wiki/Staged_event-driven_architecture)
- [What is SEDA (Staged Event Driven Architecture)?](https://stackoverflow.com/questions/3570610/what-is-seda-staged-event-driven-architecture)
### Acceptance Criteria
1. Implement the basic structure of the SEDA pattern, including stages, event queues, and thread pools.
2. Demonstrate a simple use case that showcases how events flow through multiple stages.
3. Ensure the implementation adheres to the project contribution guidelines, including proper documentation and unit tests.
| info: help wanted,epic: pattern,type: feature | low | Major |
119,514,111 | vscode | Provide encoding-related APIs for editor extensions | Currently there are only two fields in the TextEditorOptions API, a few other TextEditor-related APIs, and none of them is able to deal with the text buffer's encoding.
Comparing to [Atom's TextEdit API](https://atom.io/docs/api/v1.2.4/TextEditor), that is far from enough.
Most importantly, the API limitation makes it (seems) impossible for vscode-editorconfig to implement features like `charset` support, which is a crucial need for many people.
| feature-request,api,file-encoding | high | Critical |
119,553,622 | TypeScript | Keep indentation level consistent in a multiline list | Copied from #3436:
> Another example:
>
> ``` typescript
> return (
> h.div({
> className: "view-node-row",
> style: {
> width: width,
> height: rowHeight
> }
> },
> backgroundElement,
> centerElement,
> toolsElement,
> h.div({ className: "nodes" }, items)
> )
> );
> ```
>
> While I expect:
>
> ``` typescript
> return (
> h.div({
> className: "view-node-row",
> style: {
> width: width,
> height: rowHeight
> }
> },
> backgroundElement,
> centerElement,
> toolsElement,
> h.div({ className: "nodes" }, items)
> )
> );
> ```
| Bug,Help Wanted,Domain: Formatter | low | Minor |
119,556,527 | go | cmd/internal/obj: stackGuardMultiplier is wrong for a cross-compiler | This issue is similar to that reported in https://github.com/golang/go/issues/12764 except that GOOS=linux and i'm running on a fairly pristine image of macosx El Capitan.
when cross compiling to GOOS=linux on macosx El Capitan using go 1.5.1 I get a nosplit stack overflow. It happens in the link step, AFAICT from using the -v option to go build.
runtime.cgocallbackg: nosplit stack overflow
504 assumed on entry to runtime.cgocallbackg (nosplit)
416 after runtime.cgocallbackg (nosplit) uses 88
408 on entry to runtime.exitsyscall (nosplit)
288 after runtime.exitsyscall (nosplit) uses 120
280 on entry to runtime.exitsyscallfast (nosplit)
120 after runtime.exitsyscallfast (nosplit) uses 160
112 on entry to runtime.writebarrierptr (nosplit)
64 after runtime.writebarrierptr (nosplit) uses 48
56 on entry to runtime.writebarrierptr_nostore1 (nosplit)
0 after runtime.writebarrierptr_nostore1 (nosplit) uses 56
-8 on entry to runtime.acquirem (nosplit)
reflect.typelinks: nosplit stack overflow
504 assumed on entry to reflect.typelinks (nosplit)
352 after reflect.typelinks (nosplit) uses 152
344 on entry to runtime.typedmemmove (nosplit)
320 after runtime.typedmemmove (nosplit) uses 24
312 on entry to runtime.heapBitsBulkBarrier (nosplit)
192 after runtime.heapBitsBulkBarrier (nosplit) uses 120
184 on entry to runtime.throw (nosplit)
160 after runtime.throw (nosplit) uses 24
152 on entry to runtime.dopanic (nosplit)
72 after runtime.dopanic (nosplit) uses 80
64 on entry to runtime.getcallerpc (nosplit)
56 after runtime.getcallerpc (nosplit) uses 8
48 on entry to runtime.nextBarrierPC (nosplit)
8 after runtime.nextBarrierPC (nosplit) uses 40
0 on entry to runtime.panicindex
-8 on entry to runtime.morestack (nosplit)
runtime.cgocallback_gofunc: nosplit stack overflow
504 assumed on entry to runtime.cgocallback_gofunc (nosplit)
496 after runtime.cgocallback_gofunc (nosplit) uses 8
488 on entry to runtime.cgocallbackg (nosplit)
400 after runtime.cgocallbackg (nosplit) uses 88
392 on entry to runtime.exitsyscall (nosplit)
272 after runtime.exitsyscall (nosplit) uses 120
264 on entry to runtime.exitsyscallfast (nosplit)
104 after runtime.exitsyscallfast (nosplit) uses 160
96 on entry to runtime.writebarrierptr (nosplit)
48 after runtime.writebarrierptr (nosplit) uses 48
40 on entry to runtime.writebarrierptr_nostore1 (nosplit)
-16 after runtime.writebarrierptr_nostore1 (nosplit) uses 56
| compiler/runtime | low | Minor |
119,606,768 | go | x/net/http2: TestServer_RejectsLargeFrames fails with "An existing connection was forcibly closed by the remote host" on windows | From windows-amd64-gce builder http://build.golang.org/log/a0906e4fa3713e6512cdff9af6662d1db0faad0d
```
--- FAIL: TestServer_RejectsLargeFrames (0.31s)
http2_test.go:64: 2015/11/30 20:57:53 127.0.0.1:49238: connection error: PROTOCOL_ERROR
http2_test.go:64: 2015/11/30 20:57:53 127.0.0.1:49238: connection error: PROTOCOL_ERROR
http2_test.go:64: 2015/11/30 20:57:53 127.0.0.1:49238: connection error: PROTOCOL_ERROR
...
http2_test.go:64: 2015/11/30 20:57:53 127.0.0.1:49238: connection error: PROTOCOL_ERROR
http2_test.go:64: 2015/11/30 20:57:53 127.0.0.1:49238: connection error: PROTOCOL_ERROR
http2_test.go:64: 2015/11/30 20:57:53 127.0.0.1:49238: connection error: PROTOCOL_ERROR
server_test.go:413: Error while expecting a GOAWAY frame: read tcp 127.0.0.1:49238->127.0.0.1:49237: wsarecv: An existing connection was forcibly closed by the remote host.
FAIL
FAIL golang.org/x/net/http2 2.668s
```
I can reproduce this here. I don't know what the problem is.
Alex
| OS-Windows | low | Critical |
119,606,913 | rust | Desugared x.index(y) is not equivalent to x[y] | ``` rust
use std::ops::Index;
fn main() {
let _sugar = &"a".to_owned()[..];
let _desugar1 = "a".to_owned().index(..);
let _desugar2 = &*"a".to_owned().index(..);
}
```
```
<anon>:5:21: 5:35 error: borrowed value does not live long enough
<anon>:5 let _desugar1 = "a".to_owned().index(..);
^~~~~~~~~~~~~~
<anon>:5:46: 6:49 note: reference must be valid for the block suffix following statement 1 at 5:45...
<anon>:5 let _desugar1 = "a".to_owned().index(..);
<anon>:6 let _desugar2 = &*"a".to_owned().index(..);}
<anon>:5:5: 5:46 note: ...but borrowed value is only valid for the statement at 5:4
<anon>:5 let _desugar1 = "a".to_owned().index(..);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<anon>:5:5: 5:46 help: consider using a `let` binding to increase its lifetime
<anon>:5 let _desugar1 = "a".to_owned().index(..);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<anon>:6:23: 6:37 error: borrowed value does not live long enough
<anon>:6 let _desugar2 = &*"a".to_owned().index(..);}
^~~~~~~~~~~~~~
<anon>:6:48: 6:49 note: reference must be valid for the block suffix following statement 2 at 6:47...
<anon>:6 let _desugar2 = &*"a".to_owned().index(..);}
^
<anon>:6:5: 6:48 note: ...but borrowed value is only valid for the statement at 6:4
<anon>:6 let _desugar2 = &*"a".to_owned().index(..);}
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<anon>:6:5: 6:48 help: consider using a `let` binding to increase its lifetime
<anon>:6 let _desugar2 = &*"a".to_owned().index(..);}
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```
If the `let _desugar`s are commented out, it compiles fine.
It seems a method call is treated differently to the `[]` syntax. This may be a purposeful consequence of the design of temporary lifetimes, I don't know.
| A-lifetimes,P-medium,I-needs-decision,T-lang,C-bug | medium | Critical |
119,639,470 | go | x/mobile/cmd/gomobile: gomobile bind -n -target=ios fails when attempting to read Info.plist | Using gomobile version +01216d9
The following command fails to complete:
```
$ gomobile bind -n -target=ios golang.org/x/mobile/asset
```
with the following error:
```
mkdir -p Asset.framework/Versions/A/Headers
mkdir -p Asset.framework/Versions/A/Resources
ln -s Versions/Current/Resources Asset.framework/Resources
gomobile: open Asset.framework/Resources/Info.plist: no such file or directory
```
| mobile | low | Critical |
119,711,370 | TypeScript | Opaque types for WebGL | WebGL types are included in the default `lib.d.ts`. However, most types are defined as empty interfaces, which means that the compiler doesn't catch many WebGL errors.
Consider the following code:
``` ts
function foo(gl: WebGLRenderingContext, fbo: WebGLFramebuffer) {
gl.bindFramebuffer(gl.FRAMEBUFFER, fbo); // Correct call
gl.bindFramebuffer(gl.FRAMEBUFFER, "abc"); // This should be a compile error!
fbo = gl.createFramebuffer(); // Correct call
fbo = new WebGLFramebuffer; // This should be a compile error!
}
```
- The second parameter of `gl.bindFramebuffer` should be a `WebGLFramebuffer` object, but passing a `string` does not emit a compile error or warning.
- The type `WebGLFramebuffer` can only be constructed via `WebGLRenderingContext.createFramebuffer`, calling new throws an error at runtime
Ideally, Typescript would know that `WebGLFramebuffer`, even though it has no public properties, cannot be constructed or converted to any other type.
I assume that this is not easy to specify with structural typing, but having such opaque types could be useful for other libraries as well (e.g., for returning handles).
If that is not possible, can we find a workaround that at least helps catching the above mentioned bugs?
For reference, here's how the above types are currently defined in `lib.d.ts`:
``` ts
interface WebGLFramebuffer extends WebGLObject {
}
declare var WebGLFramebuffer: {
prototype: WebGLFramebuffer;
new(): WebGLFramebuffer;
}
interface WebGLRenderingContext {
bindFramebuffer(target: number, framebuffer: WebGLFramebuffer): void;
// + many other methods
}
```
| Bug,Help Wanted,Domain: lib.d.ts | low | Critical |
119,712,437 | youtube-dl | Site support Request: Realm.io Videos | Up till a couple weeks ago, Realm hosted their videos on Youtube, but they've now switched to Wistia. Here's an example page: https://realm.io/news/alexis-gallagher-3d-touch-swift/
```
$ youtube-dl --version
2015.11.27.1
```
```
$ youtube-dl -jv "https://realm.io/news/alexis-gallagher-3d-touch-swift/"
[debug] System config: []
[debug] User config: []
[debug] Command-line args: [u'-jv', u'https://realm.io/news/alexis-gallagher-3d-touch-swift/']
[debug] Encodings: locale UTF-8, fs utf-8, out UTF-8, pref UTF-8
[debug] youtube-dl version 2015.11.27.1
[debug] Python version 2.7.10 - Darwin-15.0.0-x86_64-i386-64bit
[debug] exe versions: none
[debug] Proxy map: {}
WARNING: Falling back on generic information extractor.
ERROR: Unsupported URL: https://realm.io/news/alexis-gallagher-3d-touch-swift/
Traceback (most recent call last):
File "/usr/local/bin/youtube-dl/youtube_dl/extractor/generic.py", line 1282, in _real_extract
doc = compat_etree_fromstring(webpage.encode('utf-8'))
File "/usr/local/bin/youtube-dl/youtube_dl/compat.py", line 248, in compat_etree_fromstring
doc = _XML(text, parser=etree.XMLParser(target=etree.TreeBuilder(element_factory=_element_factory)))
File "/usr/local/bin/youtube-dl/youtube_dl/compat.py", line 237, in _XML
parser.feed(text)
File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/xml/etree/ElementTree.py", line 1642, in feed
self._raiseerror(v)
File "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/xml/etree/ElementTree.py", line 1506, in _raiseerror
raise err
ParseError: not well-formed (invalid token): line 7, column 145
Traceback (most recent call last):
File "/usr/local/bin/youtube-dl/youtube_dl/YoutubeDL.py", line 663, in extract_info
ie_result = ie.extract(url)
File "/usr/local/bin/youtube-dl/youtube_dl/extractor/common.py", line 290, in extract
return self._real_extract(url)
File "/usr/local/bin/youtube-dl/youtube_dl/extractor/generic.py", line 1887, in _real_extract
raise UnsupportedError(url)
UnsupportedError: Unsupported URL: https://realm.io/news/alexis-gallagher-3d-touch-swift/
```
| site-support-request | low | Critical |
119,744,338 | vscode | Exclude all files except for... | The files exclude allows you to set `true/false` values, but it doesn't seem to take them completely into account.
For example, I would like to hide **everything** except for the scripts folder. You might then assume that this would do this:
```
{
"files.exclude":
{
"**/*": true,
"**/Scripts": false
}
}
```
It does not do that, it just hides everything. In order to achieve this, you must list every file and directory except for the **Scripts** directory, and who knows how many directories there are and if a new directory/file gets added you then must edit the list to exclude those.
In the end, their should be a way to hide everything except for xxx.
| feature-request,file-explorer,file-glob | high | Critical |
119,744,454 | youtube-dl | Site request: ispot.tv | URL Example: http://www.ispot.tv/ad/7p_Q/viagra-fishing
Output:
C:>youtube-dl -v http://www.ispot.tv/ad/7p_Q/viagra-fishing
[debug] System config: []
[debug] User config: []
[debug] Command-line args: [u'-v', u'http://www.ispot.tv/ad/7p_Q/viagra-fishing'
]
[debug] Encodings: locale cp1252, fs mbcs, out cp850, pref cp1252
[debug] youtube-dl version 2015.11.27.1
[debug] Python version 2.7.10 - Windows-7-6.1.7601-SP1
[debug] exe versions: ffmpeg N-71346-gdf4fca2
[debug] Proxy map: {}
[generic] viagra-fishing: Requesting header
WARNING: Falling back on generic information extractor.
[generic] viagra-fishing: Downloading webpage
[generic] viagra-fishing: Extracting information
ERROR: Unsupported URL: http://www.ispot.tv/ad/7p_Q/viagra-fishing
Traceback (most recent call last):
File "youtube_dl\extractor\generic.pyo", line 1282, in _real_extract
File "youtube_dl\compat.pyo", line 248, in compat_etree_fromstring
File "youtube_dl\compat.pyo", line 237, in _XML
File "xml\etree\ElementTree.pyo", line 1642, in feed
File "xml\etree\ElementTree.pyo", line 1506, in _raiseerror
ParseError: mismatched tag: line 79, column 6
Traceback (most recent call last):
File "youtube_dl\YoutubeDL.pyo", line 663, in extract_info
File "youtube_dl\extractor\common.pyo", line 290, in extract
File "youtube_dl\extractor\generic.pyo", line 1887, in _real_extract
UnsupportedError: Unsupported URL: http://www.ispot.tv/ad/7p_Q/viagra-fishing
Thanks
Ringo
| site-support-request | low | Critical |
119,749,466 | vscode | Macro like keybindings | When creating keyboard shortcuts, it would be nice if you could pass an array of commands (to execute like a macro) that would run the commands in that order.
So take this for example:
```
{
"key": "ctrl+s",
"command": [
"editor.action.format",
"editor.action.trimTrailingWhitespace",
"workbench.action.files.save"
],
"when": "editorTextFocus"
}
```
It would format the file, remove trailing white space then save the file.
| feature-request,keybindings | high | Critical |
119,771,336 | go | net/rpc: `(*Client).Go` is not asynchronous with respect to outbound traffic | In the event of a network partition, `net/rpc.(*Client).Go` can block, which is surprising given the documented behaviour of this method.
| NeedsInvestigation | low | Minor |
119,800,047 | TypeScript | Polymorphic "this" for static members | When trying to implement a fairly basic, but polymorphic, active record style model system we run into issues with the type system not respecting `this` when used in conjunction with a constructor or template/generic.
I've posted before about this here, #5493, and #5492 appears to mention this behavior also.
And here is an SO post this that I made:
http://stackoverflow.com/questions/33443793/create-a-generic-factory-in-typescript-unsolved
I have recycled my example from #5493 into this ticket for further discussion. I wanted an open ticket representing the desire for such a thing and for discussion but the other two are closed.
Here is an example that outlines a model `Factory` which produces models. If you want to customize the `BaseModel` that comes back from the `Factory` you should be able to override it. However this fails because `this` cannot be used in a static member.
``` typescript
// Typically in a library
export interface InstanceConstructor<T extends BaseModel> {
new(fac: Factory<T>): T;
}
export class Factory<T extends BaseModel> {
constructor(private cls: InstanceConstructor<T>) {}
get() {
return new this.cls(this);
}
}
export class BaseModel {
// NOTE: Does not work....
constructor(private fac: Factory<this>) {}
refresh() {
// get returns a new instance, but it should be of
// type Model, not BaseModel.
return this.fac.get();
}
}
// Application Code
export class Model extends BaseModel {
do() {
return true;
}
}
// Kinda sucks that Factory cannot infer the "Model" type
let f = new Factory<Model>(Model);
let a = f.get();
// b is inferred as any here.
let b = a.refresh();
```
Maybe this issue is silly and there is an easy workaround. I welcome comments regarding how such a pattern can be achieved.
| Suggestion,In Discussion | high | Critical |
119,804,187 | go | x/mobile/bind: support slices of supported structs | Just want to know if it will ever be possible to support slices of supported. I currently have to write a wrapper object around an array to pass it back and forth between IOS and Go.
| mobile | medium | Critical |
119,926,231 | vscode | Don't activate dirty file indicator if the file state matches the previous written state | Vscode show me I have unsaved changes:
Ok, before I saved it, I check md5 for this file.
After save nothing changes.
It happens time to time and it's very annoying.
UPD:
It's about user experience.
Dirty flag means something has changed.
Not ideal, but probably acceptable, if dirty flag is set when editor has history but no actual changes happened, when user input initiated it, for example, after pressing space and then backspace).
No actual changes here, but we still have a history (initiated by user).
And user for sure didn't expect, if dirty flag is set as result of any plugin action (in this case code reformatting), which in result doesn't apply any changes to editor. | feature-request,file-io,keep | high | Critical |
119,954,446 | javascript | Explicitly clarify naming policy for React event handler methods | The [ordering section](https://github.com/airbnb/javascript/tree/master/react#ordering) implies that event handlers should be named `onFoo` rather than `handleFoo` per FB examples. Is this an explicit rule? If so, it would be nice to have it listed in either the "naming" or "methods" sections.
| question | low | Major |
119,986,939 | rust | Debug trait for tuples, array/slices, Vec, String (etc?) do not respect `width` parameter | Consider the following println:
``` rust
let msg = "Hello";
println!("(i,j,k): |{:30}|", msg);
```
This is using the `width` parameter to ensure that the output occupies _at least_ `width` characters. (One can provide other arguments like fill/alignment to adjust the fill character or whether the output is left/right/center- alligned.) See docs here: https://doc.rust-lang.org/std/fmt/#width
In other words, it prints this (note the distance between the two occurrences of `|`):
```
(i,j,k): |Hello |
```
So, the problem:
The `Debug` trait seems to honor `width` for numeric and pointer types, but not for other types.
For example:
``` rust
println!("(i,j,k): |{:30?}|", msg);
```
does not necessarily put at least 30 characters between the two `|` characters that it prints; in the case of `msg` given above, it prints:
```
(i,j,k): |"Hello"|
```
Here is a [playpen](http://is.gd/NGt8cW) illustrating the problem on several inputs.
| T-libs-api,C-bug,A-fmt | low | Critical |
119,990,534 | opencv | BFMatcher SigSegv (OpenCL implementation) | My application very rarely segfaults around BFMatching.knnMatch (OpenCL via transparent API).
After investigation I created sample code that also segfaults:
``` cpp
#include <opencv2/features2d.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/opencv.hpp>
#include <opencv2/core/ocl.hpp>
#include <vector>
#include <iostream>
#include <stdio.h>
#include <tuple>
using namespace std;
using namespace cv;
void print_ocl_device_name() {
vector<ocl::PlatformInfo> platforms;
ocl::getPlatfomsInfo(platforms);
for (size_t i = 0; i < platforms.size(); i++) {
const cv::ocl::PlatformInfo* platform = &platforms[i];
cout << "Platform Name: " << platform->name().c_str() << "\n";
for (int j = 0; j < platform->deviceNumber(); j++) {
cv::ocl::Device current_device;
platform->getDevice(current_device, j);
int deviceType = current_device.type();
cout << "Device " << j << ": " << current_device.name() << "\n";
}
}
ocl::Device default_device = ocl::Device::getDefault();
cout << "Used device: " << default_device.name() << "\n";
}
int main(void) {
print_ocl_device_name();
RNG r(239);
Mat desc1(5100, 64, CV_32F);
Mat desc2(5046, 64, CV_32F);
r.fill(desc1, RNG::UNIFORM, Scalar::all(0.0), Scalar::all(1.0));
r.fill(desc2, RNG::UNIFORM, Scalar::all(0.0), Scalar::all(1.0));
for (int i = 0; i < 1000 * 1000; i++) {
BFMatcher matcher(NORM_L2);
UMat udesc1, udesc2;
desc1.copyTo(udesc1);
desc2.copyTo(udesc2);
vector< vector<DMatch> > nn_matches;
matcher.knnMatch(udesc1, udesc2, nn_matches, 2);
printf("%d\n", i);
}
return 0;
}
```
**Note**: this happens very rare. I see it after tens of thousands of iterations (tens of minutes on fast GPU).
## Environment
OpenCV version: **3.0.0**
I have segfaults on Nvidia GTX 680 (**OpenCL 1.1**):
```
Device name: GeForce GTX 680
Nvidia driver verison: 331.113
Platform Version: OpenCL 1.1 CUDA 6.0.1
```
The same behaivour on Nvidia GTX 580 with 352.30 driver (**OpenCL 1.1**).
On CPU device (not CPU implementation, here I mean CPU as OpenCL device) I was trying - but for now there is no segfaults. But I think this is only because of speed difference between CPU and GPU. (On GPU it takes tens of minutes or even more - CPU slower up to to one or two orders). Or these can be explained driver implementation details, or the reason, that CPU RAM is the same that the Host RAM.
**GDB backtraces**:
```
Thread 7 (Thread 0x7f64ad44a700 (LWP 2212)):
#0 sem_wait () at ../nptl/sysdeps/unix/sysv/linux/x86_64/sem_wait.S:85
#1 0x00007f64b1784a7e in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#2 0x00007f64b0ffe548 in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#3 0x00007f64b17872d9 in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#4 0x00007f64b2dad0a5 in start_thread (arg=0x7f64ad44a700) at pthread_create.c:309
#5 0x00007f64b4943cfd in clone () at ../sysdeps/unix/sysv/linux/x86_64/clone.S:111
Thread 6 (Thread 0x7f64acc49700 (LWP 2213)):
#0 sem_wait () at ../nptl/sysdeps/unix/sysv/linux/x86_64/sem_wait.S:85
#1 0x00007f64b1784a7e in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#2 0x00007f64b0ffe548 in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#3 0x00007f64b17872d9 in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#4 0x00007f64b2dad0a5 in start_thread (arg=0x7f64acc49700) at pthread_create.c:309
#5 0x00007f64b4943cfd in clone () at ../sysdeps/unix/sysv/linux/x86_64/clone.S:111
Thread 5 (Thread 0x7f64adc4b700 (LWP 2211)):
#0 sem_wait () at ../nptl/sysdeps/unix/sysv/linux/x86_64/sem_wait.S:85
#1 0x00007f64b1784a7e in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#2 0x00007f64b0ffe548 in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#3 0x00007f64b17872d9 in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#4 0x00007f64b2dad0a5 in start_thread (arg=0x7f64adc4b700) at pthread_create.c:309
#5 0x00007f64b4943cfd in clone () at ../sysdeps/unix/sysv/linux/x86_64/clone.S:111
Thread 4 (Thread 0x7f64b6209780 (LWP 2208)):
#0 0x00007f64b48cc774 in __GI___libc_malloc (bytes=32) at malloc.c:2903
#1 0x00007f64b4e84688 in operator new(unsigned long) () from /usr/lib/x86_64-linux-gnu/libstdc++.so.6
#2 0x00007f64b5d8b42e in allocate (this=0x26997e0, __n=<error reading variable: Cannot access memory at address 0xfffffffffffffcc8>)
at /usr/include/c++/4.9/ext/new_allocator.h:104
#3 allocate (__a=..., __n=<error reading variable: Cannot access memory at address 0xfffffffffffffcc8>) at /usr/include/c++/4.9/ext/alloc_traits.h:182
#4 _M_allocate (this=0x26997e0, __n=<error reading variable: Cannot access memory at address 0xfffffffffffffcc8>)
at /usr/include/c++/4.9/bits/stl_vector.h:170
#5 _M_allocate_and_copy<cv::DMatch*> (this=0x26997e0, __last=0x0, __first=0x0,
__n=<error reading variable: Cannot access memory at address 0xfffffffffffffcc8>) at /usr/include/c++/4.9/bits/stl_vector.h:1224
#6 std::vector<cv::DMatch, std::allocator<cv::DMatch> >::reserve (this=this@entry=0x26997e0, __n=__n@entry=2) at /usr/include/c++/4.9/bits/vector.tcc:75
#7 0x00007f64b5d913b0 in ocl_knnMatchConvert (compactResult=<optimized out>, matches=std::vector of length 4825, capacity 5100 = {...}, distance=...,
trainIdx=...) at /home/polarnick/libraries/opencv/opencv_3.0.0/modules/features2d/src/matchers.cpp:240
#8 ocl_knnMatchDownload (compactResult=<optimized out>, matches=std::vector of length 4825, capacity 5100 = {...}, distance=..., trainIdx=...)
at /home/polarnick/libraries/opencv/opencv_3.0.0/modules/features2d/src/matchers.cpp:270
#9 cv::ocl_knnMatch (query=..., _train=..., matches=std::vector of length 4825, capacity 5100 = {...}, k=k@entry=2, dstType=<optimized out>,
compactResult=compactResult@entry=false) at /home/polarnick/libraries/opencv/opencv_3.0.0/modules/features2d/src/matchers.cpp:713
#10 0x00007f64b5d938ac in cv::BFMatcher::knnMatchImpl (this=0x262b720, _queryDescriptors=..., matches=std::vector of length 4825, capacity 5100 = {...},
knn=2, _masks=..., compactResult=false) at /home/polarnick/libraries/opencv/opencv_3.0.0/modules/features2d/src/matchers.cpp:786
#11 0x00007f64b5d8bade in cv::DescriptorMatcher::knnMatch (this=0x262b720, queryDescriptors=..., matches=std::vector of length 4825, capacity 5100 = {...},
knn=knn@entry=2, masks=..., compactResult=compactResult@entry=false)
at /home/polarnick/libraries/opencv/opencv_3.0.0/modules/features2d/src/matchers.cpp:630
#12 0x00007f64b5d8c68c in cv::DescriptorMatcher::knnMatch (this=<optimized out>, queryDescriptors=..., trainDescriptors=...,
matches=std::vector of length 4825, capacity 5100 = {...}, knn=2, mask=..., compactResult=false)
at /home/polarnick/libraries/opencv/opencv_3.0.0/modules/features2d/src/matchers.cpp:577
#13 0x0000000000401c13 in main () at bfmatcher_segfault.cpp:50
Thread 3 (Thread 0x7f64af9ee700 (LWP 2209)):
#0 0x00007f64b493984d in poll () at ../sysdeps/unix/syscall-template.S:81
#1 0x00007f64b1785373 in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#2 0x00007f64b1135f15 in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#3 0x00007f64b17872d9 in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#4 0x00007f64b2dad0a5 in start_thread (arg=0x7f64af9ee700) at pthread_create.c:309
#5 0x00007f64b4943cfd in clone () at ../sysdeps/unix/sysv/linux/x86_64/clone.S:111
Thread 2 (Thread 0x7f64ae44c700 (LWP 2210)):
#0 sem_wait () at ../nptl/sysdeps/unix/sysv/linux/x86_64/sem_wait.S:85
#1 0x00007f64b1784a7e in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#2 0x00007f64b0ffe548 in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#3 0x00007f64b17872d9 in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#4 0x00007f64b2dad0a5 in start_thread (arg=0x7f64ae44c700) at pthread_create.c:309
#5 0x00007f64b4943cfd in clone () at ../sysdeps/unix/sysv/linux/x86_64/clone.S:111
Thread 1 (Thread 0x7f64a7fff700 (LWP 2214)):
#0 0x00007f64b0ffdae2 in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#1 0x00007f64b0ffe514 in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#2 0x00007f64b17872d9 in ?? () from /usr/lib/x86_64-linux-gnu/libnvidia-opencl.so.1
#3 0x00007f64b2dad0a5 in start_thread (arg=0x7f64a7fff700) at pthread_create.c:309
#4 0x00007f64b4943cfd in clone () at ../sysdeps/unix/sysv/linux/x86_64/clone.S:111
```
**Valgrind** can't help because of too big slow down.
**AddressSanitizer** just fails on startup with SigSegv, this seems to be bad combination of ASan and OpenCL.
## Workaround
It seems, that explicit sync needed after calculating and before result downloading.
If I change `return k.run(2, globalSize, localSize, false);` to `return k.run(2, globalSize, localSize, true);`, i.e. pass sync=true - I stops encounter SigSegv.
This fix must be applied in:
- ocl_matchSingle: https://github.com/Itseez/opencv/blob/3.0.0/modules/features2d/src/matchers.cpp#L114
- ocl_knnMatchSingle: https://github.com/Itseez/opencv/blob/3.0.0/modules/features2d/src/matchers.cpp#L214
- ocl_radiusMatchSingle: https://github.com/Itseez/opencv/blob/3.0.0/modules/features2d/src/matchers.cpp#L327
## Results
clEnqueueMapBuffer fetches data in concurrent with unfinished kernel, and this is **undefined behaviour**.
May be `sync=false` is just randomly passed param? While line at https://github.com/Itseez/opencv/blob/3.0.0/modules/core/src/ocl.cpp#L3382 should change `sync` to `true`? But this is not so - I checked, this `if` branch does not executes in my scenario. The reason is in https://github.com/Itseez/opencv/blob/3.0.0/modules/core/src/ocl.cpp#L3119 - `m.u->tempUMat()` fails that if-branch. Because UMatData.flags=3 for all Kernel.addUMat(UMat) calls, while TEMP_UMAT=8.
What is TEMP_UMAT? Are those umats should be tempUMat? And even if so - all three Kernel.run in matchers.cpp should be called with sync=true, because there are no async behaviour.
It seems that such bug with OpenCL methods result fetching can be in a lot of places, can you check them please? It is quite dangerous bug. (I checked LKOptFlow - there Kernel.run called with sync=true)
Also, there are no bugfixes bug-porting to 3.0.0 version, because there is no 3.0.0 stable branch. Why so? 3.0.0 branch like 2.4 branch seems to be useful.
| bug,priority: normal,affected: 3.4,category: ocl,category: t-api | low | Critical |
120,038,919 | go | x/tools/cmd/oracle: 'implements' query needs to inspect all packages in the analysis scope | The implements query inspects only the query package and its forward transitive closure, but users expect (and the documentation states) that it will report all related types in the analysis scope. Thus a query at bufio.Reader will report io.Reader, but a query at io.Reader will not report *bufio.Reader.
This is mostly likely a regression due to commit b28839e4 in March.
The implements query should load all necessary packages in the analysis scope. It may be profitable to skip type-checking of all function bodies that do not contain a type declaration.
| Tools | low | Minor |
120,147,416 | go | runtime: additional memory profiler report modes or similar | Memory profiler reports heap contents at the end of one of the previous GCs. This makes profiles "stable" in the sense that it does not dependent on exact point in time it is queried (just after GC, just before GC, somewhere in the middle). It makes sense. However, we see periodic confusion caused by the fact that actual memory consumption is actually 2x of what's reported. The meaning of the reported numbers is not obvious, it is reasonable to assume that if a tool says X MB, then memory consumption should be ~X MB.
While what we report is a useful view of reality, it is not the only view possible and maybe it should not be the default view. I think that all of the following views are useful:
- heap contents at the end of GC cycle (what we report now); shows more-of-less persistent data in heap and allows to understand why my heap is that large
- heap contents at the _beginning_ of GC cycle (total memory consumption should be GOGC times larger than the prvious one); allows to understand memory consumption of the program and shows kind of worst case view of heap; this view can also be appealing to developers with C/C++ background
- difference between the previous two modes (what was collected during a GC cycle); allows to understand why GCs are happening so frequently and optimize performance (identify transient allocs)
Also, if you are presented with several options, it forces you to ask yourself a question regarding the difference between these options. If you understand the difference, you interpret the data correctly.
The proposal is to add these additional modes to memory profiler. Exact set of modes and the default mode is discussable. Degenerate case would be just to switch the default.
From implementation point of view, I think all proposed modes are easy to implement in the current phased design.
| NeedsInvestigation | medium | Major |
120,198,091 | vscode | Explore: Integrated TypeScript building/transpilation | Make it simpler to setup TypeScript compilation.
Can we make this incrementally?
| feature-request,upstream,typescript | medium | Major |
120,217,640 | go | cmd/cgo: make identical C types identical Go types across packages | https://golang.org/cmd/cgo/ says:
> Cgo translates C types into equivalent unexported Go types. Because the translations are unexported, a Go package should not expose C types in its exported API: a C type used in one Go package is different from the same C type used in another.
While that's a convenient workaround for allowing access to struct fields and other names that would otherwise be inaccessible as Go identifiers, it greatly complicates the process of writing Go APIs for export to C callers. The Go code to produce and/or manipulate C values must be essentially confined to a single package.
It would be nice to remove that restriction: instead of treating C types as unexported local types, we should treat them as exported types in the "C" package (and similarly export the lower-case names that would otherwise be unexported).
| compiler/runtime | high | Critical |
120,233,403 | TypeScript | [tsserver] "Error processing request. watch ENOENT" with TypeScript 1.7.3 | I have a problem "Error processing request. watch ENOENT" when I send an open command. To reproduce since I have migrated to 1.7.3 (with 1.6, it worked).
Here steps to reproduce the problem:
- create a folder `C:/sample` which contains 2 files :
- `a.ts` which is empty
- `tsconfig.json` which contains `{}`
- do `cd .C:/sample`
- do `node YOU_TYPESCRIPT_PATH/lib/tsserver.js`
- do `{"seq":0,"type":"request","command":"open","arguments":{"file":"a.ts"}}`
After validate the open command, tsserver throws the following error:
``` json
{"seq":0,"type":"response","command":"open","request_seq":0,"success":false,"mes
sage":"Error processing request. watch ENOENT"}
```
After debugging, it seems that problem comes from https://github.com/Microsoft/TypeScript/blob/master/src/server/editorServices.ts#L1245
``` javascript
project.directoryWatcher = this.host.watchDirectory(
ts.getDirectoryPath(configFilename),
path => this.directoryWatchedForSourceFilesChanged(project, path),
/*recursive*/ true
);
```
The `ts.getDirectoryPath(configFilename)` return empty, and it seems that it's the problem.
Many thanks for your help.
| Bug,Help Wanted | low | Critical |
120,284,625 | kubernetes | "don't require a load balancer between cluster and control plane and still be HA" | Can I connect kube-proxy to multiple api servers like:
`—master=http://master1:8080,http://master2:8080,http://master3:8080` ?
| priority/backlog,sig/network,area/kubelet,area/kube-proxy,area/HA,sig/node,sig/api-machinery,kind/api-change,kind/feature,help wanted,lifecycle/frozen,triage/accepted | high | Critical |
120,299,079 | go | proposal: os/v2: Stdin, Stdout and Stderr should be interfaces | The three variables os.Stdin, os.Stdout, and os.Stderr are all *Files, for historical reasons (they predate the io.Writer interface definition).
They should be of type io.Reader and io.Writer, respectively. This would make it easier to do interesting things with special input or output processors. For instance, one could say
os.Stdout = bufio.NewWriter(os.Stdout)
os.Stderr = bufio.NewWriter(os.Stderr)
and all output, including from log.Printf and fmt.Printf, would be buffered. Much more imaginative things would also be possible.
Also, *File is the root of a large dependency tree that simple programs would be able to avoid.
Can't change it now, but we could in Go 2.
| v2,Proposal | high | Critical |
120,307,006 | kubernetes | Needed: field-level extension mechanism | We don't have a good mechanism for plugging extension fields into objects. That is, suppose we have an Autoscaler type, and we want user on FooCloud to be able to set some extra fields in Autoscaler.FooExtensions for the FooCloudProvider to make use of.
Currently, we do this by letting everyone add a *FooCloudOptions variable into the Autoscaler type. The downside of this is that people have to modify things in our code base, and that these options appear whether or not they actually exist on the cluster.
Another alternative is adding a `CloudProviderOptions RawExtension` (e.g., []byte) and letting people dump whatever options they want there. This has the downside that apiserver can't validate or document the contents of that field, nor can it convert it between versions, etc. Using an annotation is basically the same thing.
So my idea here is to leverage federated API servers. Basically, you'd make a new apiserver (which should be very easy in the future) and drop-in a Autoscaler type. This would be exactly the same as the main Autoscaler type, except for the addition of your custom fields. (We'd have to make some rules so this can work correctly.) Then we point /apis/scale/autoscalers at your apiserver instead of the main apiserver.
The downsides:
- depends on incomplete features.
- Only one such override per resource per cluster would be possible.
- Only possible for resources that don't have custom apiserver logic (which should be everything)
But the good part is that we'd be able to deliver the validation, documentation, conversion features users expect.
| priority/backlog,area/api,area/apiserver,sig/api-machinery,kind/feature,lifecycle/frozen | medium | Major |
120,348,173 | go | cmd/compile: Suggest typo fixes for resolution errors | In case of "cannot find package" or "undefined" errors, perhaps we should suggest typo fix solutions?
The basic idea is to look for all allowed names in that position with the minimum levenshtein distance (perhaps capping it at 3 or something), and suggest those.
[Rust does this](http://is.gd/BYma9H) and it's pretty useful.
| NeedsInvestigation,compiler/runtime | low | Critical |
120,350,459 | rust | Add levenshtein distance based suggestions everywhere | Currently, we suggest typo fixes in case of function calls, locals, and field accesses. So, both the marked lines below will suggest the correct fix:
``` rust
struct A {foo: u8}
fn main() {
let x = A {foo: 1};
x.fob; // here
let aaaaaaa=1;
let z = aaaaaab; // here
}
```
However, this is not the case for [imports](http://is.gd/LSn7rA), [crates](http://is.gd/p6YXoT), and [inline paths](http://is.gd/wGtIEU). We should fix this.
This is probably not an easy bug, but should be fun. Basically you need to look for the source of the "could not find X" error, and do something similar to https://github.com/rust-lang/rust/blob/99925fb562086ff789df95220104f9d8d5fc8b3c/src/librustc_resolve/lib.rs#L3625
@apasel422 @Wafflespeanut want to work on this?
| C-enhancement,A-diagnostics,P-low,E-mentor,T-compiler | medium | Critical |
120,354,711 | TypeScript | [tsserver] documentation "about how to implement tsClient?" | I'm implementing tsClient inside Eclipse, but it's very hard for me, because there are no documentation about protocol. So I study implementation with sublime, vim and vscode, but it's not my language, so it's a little hard.
So, it should be very cool if you could provide a documentation to implement tsClient, I mean request/response protocol.
We could take a simple sample:
- open a document.
- do a completion.
- change the editor content to show how to synchronize editor with tsserver. There are 2 means to do that:
- use "change" (I must study why it doesn't work for me, but if I have a documentation, it will help me a lot).
- use "tmpfile"
- do a completion again with the editor which have changed.
- close the document.
To explain that, you could starts tsserver with Windows cmd, and shows request/response. So any user will able to play with your tsserver.
After that you could speak about advanced topic like validation with event.
Thanks for your help!
| Docs | low | Major |
120,460,978 | rust | UFCS can bypass trait stability | Right now we have a trick in the standard library where sometimes a trait is unstable but the methods are stable. This is primarily used for `SliceConcatExt` to make `join` stable on slices but you can't import the trait or rely on the fact that it's defined through a trait.
There are a few ways to bypass this, however:
``` rust
// foo.rs
#![feature(staged_api)]
#![stable(feature = "foo", since = "1.2.0")]
#[unstable(feature = "bar", issue = "0")]
pub trait Foo {
#[stable(feature = "foo", since = "1.2.0")]
fn foo(&self) {}
}
#[stable(feature = "foo", since = "1.2.0")]
impl Foo for i32 {}
```
``` rust
// bar.rs
#![allow(warnings)]
extern crate foo;
// this is expected to compile and work A-OK
fn test1() {
use foo::*;
1i32.foo();
}
// this is expected to fail to compile (e.g. needs the feature)
fn test2() {
use foo::Foo; //~ ERROR
}
// This should *also* fail to compile, but it does not
fn test3() {
foo::Foo::foo(&1) // no error
}
// Like above, this should also fail to compile, but it does not
fn test4() {
<i32 as foo::Foo>::foo(&1) // no error
}
fn main() {}
```
```
$ multirust run nightly rustc foo.rs --crate-type lib
$ multirust run nightly rustc bar.rs
bar.rs:11:9: 11:17 error: use of unstable library feature 'bar' (see issue #0)
bar.rs:11 use foo::Foo;
^~~~~~~~
bar.rs:11:9: 11:17 help: add #![feature(bar)] to the crate attributes to enable
error: aborting due to previous error
```
I thought that we crawled paths pretty meticulously, but apparently not :(
cc @petrochenkov
cc @rust-lang/libs
| A-stability,T-compiler,C-bug,F-staged_api | low | Critical |
120,501,316 | TypeScript | Cascading errors when incorrectly extending a generic type | Only one error should be reported for `xyz`: "Generic type '{0}' requires {1} types argument(s).". Subsequent uses of `xyz` should not report errors. In the example below, calling `new` does, and previously referring to properties on an instance of `xyz` did too.
Note that this cleanup should not break the language services' ability to tell the user that `xyz` extends `abc` and that it will inherit members from it once a type argument is provided. (We may have to add tests to cover this case.)
From tests/cases/compiler/recursiveBaseConstructorCreation3.ts:
``` ts
declare class base<T> {
}
declare class abc<T> extends base<T> {
foo: xyz;
}
declare class xyz extends abc {
~~~
!!! error TS2314: Generic type 'abc<T>' requires 1 type argument(s).
}
var bar = new xyz(); // Error: Invalid 'new' expression.
~~~~~~~~~
!!! error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
var r: xyz = bar.foo;
```
| Bug,Help Wanted | low | Critical |
120,515,501 | go | runtime: c-shared builds fail with musllibc | Currently, some of the init_array functions provided by a c-shared build expect to be called with (argc, argv, envp) arguments as is done by glibc, but this isn't specified by the ELF gABI for DT_INIT_ARRAY (http://www.sco.com/developers/gabi/latest/ch5.dynamic.html#init_fini), and isn't done with other libc implementations like musllibc.
CC @ianlancetaylor @mwhudson
| compiler/runtime | high | Critical |
120,523,771 | go | cmd/compile: storing pointer of a local value escapes | Using `go.1.5.1`
Consider the following program:
``` go
package main
func foo() {
type node struct{ n0, n1 *node }
var nodeCache [1024]node
var nodePtrs [1024]*node
nodes := nodePtrs[:0]
n := &nodeCache[0]
n.n0 = &nodeCache[1]
n.n1 = &nodeCache[2]
nodes = append(nodes, n)
}
func main() {
}
```
Currently, the compiler thinks that nodeCache escapes:
```
joetsai@zynx: ~ $ go build -gcflags=-m main11.go
# command-line-arguments
./main11.go:16: can inline main
./main11.go:5: moved to heap: nodeCache
./main11.go:10: &nodeCache[1] escapes to heap
./main11.go:11: &nodeCache[2] escapes to heap
./main11.go:9: &nodeCache[0] escapes to heap
./main11.go:7: foo nodePtrs does not escape
```
The compiler should be able to track that pointers to nodeCache leak to nodePtrs and since nodePtrs never escapes, nodeCache never escapes as well.
This would be really useful for operating on trees and graphs (that are bounded in size) without any heap allocations.
| Performance,compiler/runtime | low | Major |
120,547,245 | rust | concurrent rustdoc usage can lead to bad times | I noticed that the documentation generated by `cargo doc` was not exactly the same depending on if I ran `cargo test` or `cargo build` first.
Running:
``` shell
$ cargo clean
$ cargo doc
$ mv target/doc tdoc
$ cargo clean
$ cargo test # or cargo build
$ cargo doc
$ diff -r tdoc target/doc
```
- in `search-index.js`: the indexes for my two targets (a [lib] and a [[bin]]) are swapped. The two lines are identical but since they're swapped git detects a file modification when my script copies the doc over to the gh-pages branch, and the file is commited for nothing.
``` diff
diff -r tdoc/search-index.js target/doc/search-index.js
2d1
< searchIndex['takuzu'] = {"items":[[0,"","takuzu","A Takuzu (a.k.a. Binairo) solving library.",null,null],[3,"Grid","","A container for takuzu grid manipulation.",null,null],[4,"GridError","","An error returned when checking if the grid is well-sized and legal.",null,null],[13,"BadSize","","The grid does not have the right size.",0,null],[13,"Illegal","","The grid is illegal, that is it infringes at least one of the rules.",0,null],[4,"GridParseError","","An error returned when parsing a string to create a grid failed.",null,null],[13,"CreationError","","A `Grid` cannot be created from this `Array`.",1,null],[13,"UnexpectedCharacter","","At least one character other than `0`, `1`, `.` or '\\n'\nwas found in the string.",1,null],[4,"GridSizeError","","An error returned when the grid is not properly sized.",null,null],[13,"Empty","","The grid is empty.",2,null],[13,"NotASquare","","The grid is not a square.\nThe field contains the line number that triggered the error.",2,null],[13,"OddRowNumber","","The grid has an odd number of rows.",2,null],[4,"SourceError","","An error returned by the `source` method when either reading or parsing failed.",null,null],[13,"IO","","Reading from the source failed.",3,null],[13,"Parsing","","Parsing failed.",3,null],[11,"eq","","",0,{"inputs":[{"name":"griderror"},{"name":"griderror"}],"output":{"name":"bool"}}],[11,"ne","","",0,{"inputs":[{"name":"griderror"},{"name":"griderror"}],"output":{"name":"bool"}}],[11,"hash","","",0,null],[11,"fmt","","",0,{"inputs":[{"name":"griderror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",0,{"inputs":[{"name":"griderror"}],"output":{"name":"griderror"}}],[11,"fmt","","",0,{"inputs":[{"name":"griderror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"description","","",0,{"inputs":[{"name":"griderror"}],"output":{"name":"str"}}],[11,"cause","","",0,{"inputs":[{"name":"griderror"}],"output":{"name":"option"}}],[11,"from","","",0,{"inputs":[{"name":"griderror"},{"name":"gridsizeerror"}],"output":{"name":"self"}}],[11,"eq","","",1,{"inputs":[{"name":"gridparseerror"},{"name":"gridparseerror"}],"output":{"name":"bool"}}],[11,"ne","","",1,{"inputs":[{"name":"gridparseerror"},{"name":"gridparseerror"}],"output":{"name":"bool"}}],[11,"hash","","",1,null],[11,"fmt","","",1,{"inputs":[{"name":"gridparseerror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",1,{"inputs":[{"name":"gridparseerror"}],"output":{"name":"gridparseerror"}}],[11,"fmt","","",1,{"inputs":[{"name":"gridparseerror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"description","","",1,{"inputs":[{"name":"gridparseerror"}],"output":{"name":"str"}}],[11,"cause","","",1,{"inputs":[{"name":"gridparseerror"}],"output":{"name":"option"}}],[11,"eq","","",2,{"inputs":[{"name":"gridsizeerror"},{"name":"gridsizeerror"}],"output":{"name":"bool"}}],[11,"ne","","",2,{"inputs":[{"name":"gridsizeerror"},{"name":"gridsizeerror"}],"output":{"name":"bool"}}],[11,"hash","","",2,null],[11,"fmt","","",2,{"inputs":[{"name":"gridsizeerror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",2,{"inputs":[{"name":"gridsizeerror"}],"output":{"name":"gridsizeerror"}}],[11,"fmt","","",2,{"inputs":[{"name":"gridsizeerror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"description","","",2,{"inputs":[{"name":"gridsizeerror"}],"output":{"name":"str"}}],[11,"eq","","",4,{"inputs":[{"name":"grid"},{"name":"grid"}],"output":{"name":"bool"}}],[11,"ne","","",4,{"inputs":[{"name":"grid"},{"name":"grid"}],"output":{"name":"bool"}}],[11,"hash","","",4,null],[11,"fmt","","",4,{"inputs":[{"name":"grid"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",4,{"inputs":[{"name":"grid"}],"output":{"name":"grid"}}],[11,"fmt","","",4,{"inputs":[{"name":"grid"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"from_str","","",4,{"inputs":[{"name":"grid"},{"name":"str"}],"output":{"name":"result"}}],[11,"index","","",4,null],[11,"index_mut","","",4,null],[11,"new","","Creates a `Grid` from a preexisting array.",4,{"inputs":[{"name":"grid"},{"name":"array"}],"output":{"name":"result"}}],[11,"size","","Returns the size of the grid.",4,{"inputs":[{"name":"grid"}],"output":{"name":"usize"}}],[11,"into_inner","","Consumes a `Grid` and returns the underlying array.",4,{"inputs":[{"name":"grid"}],"output":{"name":"array"}}],[11,"is_filled","","Returns `true` if the grid contains no empty cell.",4,{"inputs":[{"name":"grid"}],"output":{"name":"bool"}}],[11,"is_legal","","Verifies that the grid does not currently violate any of the rules.\nReturns `true` if the grid is legal.",4,{"inputs":[{"name":"grid"}],"output":{"name":"bool"}}],[11,"is_cell_legal","","Verifies that a certain cell does not violate any of the rules.\nReturns `true` if the value is legal.",4,{"inputs":[{"name":"grid"},{"name":"usize"},{"name":"usize"}],"output":{"name":"bool"}}],[11,"next_empty","","Returns the index of the first empty cell or None if the grid is filled.",4,{"inputs":[{"name":"grid"}],"output":{"name":"option"}}],[11,"apply_rules","","Skims through the grid once for each rule and fills in the blanks\nwhere the value is unambiguous.\nReturns `true` if the grid was modified.",4,{"inputs":[{"name":"grid"}],"output":{"name":"bool"}}],[11,"solve","","Solves the grid using both rules logic and a backtracking algorithm,\nand returns an array containing the solution(s).\nIf no solution exists, an empty array is returned.",4,{"inputs":[{"name":"grid"}],"output":{"name":"vec"}}],[11,"to_string_diff","","Suitable for terminals.",4,{"inputs":[{"name":"grid"},{"name":"grid"}],"output":{"name":"string"}}],[11,"fmt","","",3,{"inputs":[{"name":"sourceerror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",3,{"inputs":[{"name":"sourceerror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"description","","",3,{"inputs":[{"name":"sourceerror"}],"output":{"name":"str"}}],[11,"cause","","",3,{"inputs":[{"name":"sourceerror"}],"output":{"name":"option"}}],[11,"from","","",3,{"inputs":[{"name":"sourceerror"},{"name":"ioerror"}],"output":{"name":"self"}}],[11,"from","","",3,{"inputs":[{"name":"sourceerror"},{"name":"gridparseerror"}],"output":{"name":"self"}}],[6,"Array","","A raw takuzu grid representation.",null,null],[8,"Source","","The `Source` trait allows to use any implementor of the `Read` trait\nas an input source for the grid string format with no additional effort.",null,null],[11,"source","","Creates a `Grid` from a readable source.\nReads from the source until EOF, parses the data as a string,\nthen checks the array for size and legality and converts it to a `Grid`",5,{"inputs":[{"name":"source"}],"output":{"name":"result"}}],[11,"source","","Creates a `Grid` from a readable source.\nReads from the source until EOF, parses the data as a string,\nthen checks the array for size and legality and converts it to a `Grid`",5,{"inputs":[{"name":"source"}],"output":{"name":"result"}}]],"paths":[[4,"GridError"],[4,"GridParseError"],[4,"GridSizeError"],[4,"SourceError"],[3,"Grid"],[8,"Source"]]};
3a3
> searchIndex['takuzu'] = {"items":[[0,"","takuzu","A Takuzu (a.k.a. Binairo) solving library.",null,null],[3,"Grid","","A container for takuzu grid manipulation.",null,null],[4,"GridError","","An error returned when checking if the grid is well-sized and legal.",null,null],[13,"BadSize","","The grid does not have the right size.",0,null],[13,"Illegal","","The grid is illegal, that is it infringes at least one of the rules.",0,null],[4,"GridParseError","","An error returned when parsing a string to create a grid failed.",null,null],[13,"CreationError","","A `Grid` cannot be created from this `Array`.",1,null],[13,"UnexpectedCharacter","","At least one character other than `0`, `1`, `.` or '\\n'\nwas found in the string.",1,null],[4,"GridSizeError","","An error returned when the grid is not properly sized.",null,null],[13,"Empty","","The grid is empty.",2,null],[13,"NotASquare","","The grid is not a square.\nThe field contains the line number that triggered the error.",2,null],[13,"OddRowNumber","","The grid has an odd number of rows.",2,null],[4,"SourceError","","An error returned by the `source` method when either reading or parsing failed.",null,null],[13,"IO","","Reading from the source failed.",3,null],[13,"Parsing","","Parsing failed.",3,null],[11,"eq","","",0,{"inputs":[{"name":"griderror"},{"name":"griderror"}],"output":{"name":"bool"}}],[11,"ne","","",0,{"inputs":[{"name":"griderror"},{"name":"griderror"}],"output":{"name":"bool"}}],[11,"hash","","",0,null],[11,"fmt","","",0,{"inputs":[{"name":"griderror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",0,{"inputs":[{"name":"griderror"}],"output":{"name":"griderror"}}],[11,"fmt","","",0,{"inputs":[{"name":"griderror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"description","","",0,{"inputs":[{"name":"griderror"}],"output":{"name":"str"}}],[11,"cause","","",0,{"inputs":[{"name":"griderror"}],"output":{"name":"option"}}],[11,"from","","",0,{"inputs":[{"name":"griderror"},{"name":"gridsizeerror"}],"output":{"name":"self"}}],[11,"eq","","",1,{"inputs":[{"name":"gridparseerror"},{"name":"gridparseerror"}],"output":{"name":"bool"}}],[11,"ne","","",1,{"inputs":[{"name":"gridparseerror"},{"name":"gridparseerror"}],"output":{"name":"bool"}}],[11,"hash","","",1,null],[11,"fmt","","",1,{"inputs":[{"name":"gridparseerror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",1,{"inputs":[{"name":"gridparseerror"}],"output":{"name":"gridparseerror"}}],[11,"fmt","","",1,{"inputs":[{"name":"gridparseerror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"description","","",1,{"inputs":[{"name":"gridparseerror"}],"output":{"name":"str"}}],[11,"cause","","",1,{"inputs":[{"name":"gridparseerror"}],"output":{"name":"option"}}],[11,"eq","","",2,{"inputs":[{"name":"gridsizeerror"},{"name":"gridsizeerror"}],"output":{"name":"bool"}}],[11,"ne","","",2,{"inputs":[{"name":"gridsizeerror"},{"name":"gridsizeerror"}],"output":{"name":"bool"}}],[11,"hash","","",2,null],[11,"fmt","","",2,{"inputs":[{"name":"gridsizeerror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",2,{"inputs":[{"name":"gridsizeerror"}],"output":{"name":"gridsizeerror"}}],[11,"fmt","","",2,{"inputs":[{"name":"gridsizeerror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"description","","",2,{"inputs":[{"name":"gridsizeerror"}],"output":{"name":"str"}}],[11,"eq","","",4,{"inputs":[{"name":"grid"},{"name":"grid"}],"output":{"name":"bool"}}],[11,"ne","","",4,{"inputs":[{"name":"grid"},{"name":"grid"}],"output":{"name":"bool"}}],[11,"hash","","",4,null],[11,"fmt","","",4,{"inputs":[{"name":"grid"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"clone","","",4,{"inputs":[{"name":"grid"}],"output":{"name":"grid"}}],[11,"fmt","","",4,{"inputs":[{"name":"grid"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"from_str","","",4,{"inputs":[{"name":"grid"},{"name":"str"}],"output":{"name":"result"}}],[11,"index","","",4,null],[11,"index_mut","","",4,null],[11,"new","","Creates a `Grid` from a preexisting array.",4,{"inputs":[{"name":"grid"},{"name":"array"}],"output":{"name":"result"}}],[11,"size","","Returns the size of the grid.",4,{"inputs":[{"name":"grid"}],"output":{"name":"usize"}}],[11,"into_inner","","Consumes a `Grid` and returns the underlying array.",4,{"inputs":[{"name":"grid"}],"output":{"name":"array"}}],[11,"is_filled","","Returns `true` if the grid contains no empty cell.",4,{"inputs":[{"name":"grid"}],"output":{"name":"bool"}}],[11,"is_legal","","Verifies that the grid does not currently violate any of the rules.\nReturns `true` if the grid is legal.",4,{"inputs":[{"name":"grid"}],"output":{"name":"bool"}}],[11,"is_cell_legal","","Verifies that a certain cell does not violate any of the rules.\nReturns `true` if the value is legal.",4,{"inputs":[{"name":"grid"},{"name":"usize"},{"name":"usize"}],"output":{"name":"bool"}}],[11,"next_empty","","Returns the index of the first empty cell or None if the grid is filled.",4,{"inputs":[{"name":"grid"}],"output":{"name":"option"}}],[11,"apply_rules","","Skims through the grid once for each rule and fills in the blanks\nwhere the value is unambiguous.\nReturns `true` if the grid was modified.",4,{"inputs":[{"name":"grid"}],"output":{"name":"bool"}}],[11,"solve","","Solves the grid using both rules logic and a backtracking algorithm,\nand returns an array containing the solution(s).\nIf no solution exists, an empty array is returned.",4,{"inputs":[{"name":"grid"}],"output":{"name":"vec"}}],[11,"to_string_diff","","Suitable for terminals.",4,{"inputs":[{"name":"grid"},{"name":"grid"}],"output":{"name":"string"}}],[11,"fmt","","",3,{"inputs":[{"name":"sourceerror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"fmt","","",3,{"inputs":[{"name":"sourceerror"},{"name":"formatter"}],"output":{"name":"result"}}],[11,"description","","",3,{"inputs":[{"name":"sourceerror"}],"output":{"name":"str"}}],[11,"cause","","",3,{"inputs":[{"name":"sourceerror"}],"output":{"name":"option"}}],[11,"from","","",3,{"inputs":[{"name":"sourceerror"},{"name":"ioerror"}],"output":{"name":"self"}}],[11,"from","","",3,{"inputs":[{"name":"sourceerror"},{"name":"gridparseerror"}],"output":{"name":"self"}}],[6,"Array","","A raw takuzu grid representation.",null,null],[8,"Source","","The `Source` trait allows to use any implementor of the `Read` trait\nas an input source for the grid string format with no additional effort.",null,null],[11,"source","","Creates a `Grid` from a readable source.\nReads from the source until EOF, parses the data as a string,\nthen checks the array for size and legality and converts it to a `Grid`",5,{"inputs":[{"name":"source"}],"output":{"name":"result"}}],[11,"source","","Creates a `Grid` from a readable source.\nReads from the source until EOF, parses the data as a string,\nthen checks the array for size and legality and converts it to a `Grid`",5,{"inputs":[{"name":"source"}],"output":{"name":"result"}}]],"paths":[[4,"GridError"],[4,"GridParseError"],[4,"GridSizeError"],[4,"SourceError"],[3,"Grid"],[8,"Source"]]};
```
- in `fn.solve_from.html` (which is a public function in the [[bin]] crate): the trait bound on the parametric type does not link over to its own documentation in the [lib] crate any more:
``` diff
diff -r tdoc/tackle/fn.solve_from.html target/doc/tackle/fn.solve_from.html
49c49
< <pre class='rust fn'>pub fn solve_from<T: Source + ?<a class='trait' href='https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html' title='core::marker::Sized'>Sized</a>>(source: &mut T)</pre><div class='docblock'><p>Reads a grid from a source, triggers the solving algorithm
---
> <pre class='rust fn'>pub fn solve_from<T: <a class='trait' href='../takuzu/source/trait.Source.html' title='takuzu::source::Source'>Source</a> + ?<a class='trait' href='https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html' title='core::marker::Sized'>Sized</a>>(source: &mut T)</pre><div class='docblock'><p>Reads a grid from a source, triggers the solving algorithm
```
The first point is not that big of a problem but the second one is clearly a bug.
As suggested by @alexcrichton, using the `--jobs 1` flag on both `cargo doc` and `cargo build/test` solves the problem by making the process deterministic, at the expense of compile/docgen time obviously.
| T-rustdoc,C-bug,E-needs-mcve | low | Critical |
120,566,131 | go | encoding/xml: add generic representation of XML data | It would be helpful to have a more 'natural' data-object for XML data, so that all the information is preserved. Something like the DOM nodes in javascript.
Here is an implementation of what I would expect an XML parser to return:
https://github.com/fluhus/gostuff/tree/master/xmlnode
What do you think? Can we add such a feature to the standard XML parser?
| Proposal,Proposal-Accepted | medium | Critical |
120,600,867 | opencv | viz3d.cpp compiler error with vtk in build | It appears functions are being defined in the [viz3d.cpp](https://github.com/Itseez/opencv/blob/master/modules/viz/src/viz3d.cpp) file which aren't defined in any corresponding class definition or header. There are also a few undeclared identifiers, probably enums, in [types.cpp](https://github.com/Itseez/opencv/blob/master/modules/viz/src/types.cpp).
I have b5d6d7016c66c0701c6de30f01e3be480e5a907f checked out for opencv and ac1e608b8245a8d93b8be904d7f27a5bd0019106 form opencv_contrib. (current master for both at ~8:30pm today)
The problems look like they are most likely due to https://github.com/Itseez/opencv/commit/079ceea6168d80f3c4bfc1d4d0a1581beefa7720
To setup I ran the following on OS X 10.10 with dependencies generally supplied by homebrew:
```
mkdir Itseez
cd Itseez
git clone https://github.com/Itseez/opencv.git
git clone https://github.com/Itseez/opencv_contrib.git
mkdir xcodebuild
cd xcodebuild
cmake ../opencv -G Xcode -DOPENCV_EXTRA_MODULES_PATH=/Users/athundt/source/git/Itseez/opencv_contrib/modules -DCMAKE_BUILD_TYPE=Debug
xcodebuild install
```
The above produced the following compiler errors:
```
/Users/athundt/source/git/Itseez/opencv/modules/viz/src/viz3d.cpp
/Users/athundt/source/git/Itseez/opencv/modules/viz/src/viz3d.cpp:103:22: Out-of-line definition of 'setOffScreenRendering' does not match any declaration in 'cv::viz::Viz3d'
/Users/athundt/source/git/Itseez/opencv/modules/viz/src/viz3d.cpp:104:22: Out-of-line definition of 'removeAllLights' does not match any declaration in 'cv::viz::Viz3d'; did you mean 'removeAllWidgets'?
/Users/athundt/source/git/Itseez/opencv/modules/viz/src/viz3d.cpp:105:22: Out-of-line definition of 'addLight' does not match any declaration in 'cv::viz::Viz3d'
/Users/athundt/source/git/Itseez/opencv/modules/viz/src/viz3d.cpp:119:22: Redefinition of 'removeAllWidgets'
/Users/athundt/source/git/Itseez/opencv/modules/viz/src/viz3d.cpp:141:25: Out-of-line definition of 'getScreenshot' does not match any declaration in 'cv::viz::Viz3d'
/Users/athundt/source/git/Itseez/opencv/modules/viz/src/types.cpp
/Users/athundt/source/git/Itseez/opencv/modules/viz/src/types.cpp:60:30: Out-of-line definition of 'load' does not match any declaration in 'cv::viz::Mesh'
/Users/athundt/source/git/Itseez/opencv/modules/viz/src/types.cpp:64:12: Use of undeclared identifier 'LOAD_AUTO'
/Users/athundt/source/git/Itseez/opencv/modules/viz/src/types.cpp:69:12: Use of undeclared identifier 'LOAD_PLY'
/Users/athundt/source/git/Itseez/opencv/modules/viz/src/types.cpp:77:12: Use of undeclared identifier 'LOAD_OBJ'
```
Here is the cmake config output:
```
○ cmake ../opencv -G Xcode -DOPENCV_EXTRA_MODULES_PATH=/Users/athundt/source/git/Itseez/opencv_contrib/modules -DCMAKE_BUILD_TYPE=Debug
-- Checking for module 'libv4l1'
-- Package 'libv4l1' not found
-- Checking for module 'libv4l2'
-- Package 'libv4l2' not found
-- Looking for linux/videodev.h
-- Looking for linux/videodev.h - not found
-- Looking for linux/videodev2.h
-- Looking for linux/videodev2.h - not found
-- Looking for sys/videoio.h
-- Looking for sys/videoio.h - not found
-- Looking for libavformat/avformat.h
-- Looking for libavformat/avformat.h - not found
-- Looking for ffmpeg/avformat.h
-- Looking for ffmpeg/avformat.h - not found
-- Checking for module 'libgphoto2'
-- Package 'libgphoto2' not found
-- found IPP (ICV version): 9.0.1 [9.0.1]
-- at: /Users/athundt/source/git/Itseez/opencv/3rdparty/ippicv/unpack/ippicv_osx
-- To enable PlantUML support, set PLANTUML_JAR environment variable or pass -DPLANTUML_JAR=<filepath> option to cmake
-- Could NOT find PythonInterp: Found unsuitable version "2.7.10", but required is at least "3.4" (found /usr/local/bin/python)
-- Could NOT find PythonInterp: Found unsuitable version "2.7.10", but required is at least "3.2" (found /usr/local/bin/python)
-- Found apache ant 1.9.6: /usr/local/bin/ant
-- Could NOT find Matlab (missing: MATLAB_MEX_SCRIPT MATLAB_INCLUDE_DIRS MATLAB_ROOT_DIR MATLAB_LIBRARIES MATLAB_LIBRARY_DIRS MATLAB_MEXEXT MATLAB_ARCH MATLAB_BIN)
-- Found VTK ver. 6.3.0 (usefile: /usr/local/Cellar/vtk/6.3.0/lib/cmake/vtk-6.3/UseVTK.cmake)
-- Caffe: NO
-- Protobuf: YES
-- Glog: YES
-- Tesseract: NO
-- Assume that non-module dependency is available: -framework OpenCL (for module opencv_core)
-- Performing Test HAVE_CXX_WNO_MAYBE_UNINITIALIZED
-- Performing Test HAVE_CXX_WNO_MAYBE_UNINITIALIZED - Failed
-- Performing Test HAVE_CXX_WNO_SIGN_PROMO
-- Performing Test HAVE_CXX_WNO_SIGN_PROMO - Success
-- Performing Test HAVE_CXX_WNO_MISSING_PROTOTYPES
-- Performing Test HAVE_CXX_WNO_MISSING_PROTOTYPES - Success
-- Looking for pthread.h
-- Looking for pthread.h - found
-- Looking for pthread_create
-- Looking for pthread_create - found
-- Found Threads: TRUE
-- Found PROTOBUF: /usr/local/lib/libprotobuf.dylib
-- The protocol buffer compiler and libprotobuf were found
-- Tesseract: NO
--
-- General configuration for OpenCV 3.0.0-dev =====================================
-- Version control: 3.0.0-805-gb5d6d70
--
-- Platform:
-- Host: Darwin 14.5.0 x86_64
-- CMake: 3.4.1
-- CMake generator: Xcode
-- CMake build tool: /usr/bin/xcodebuild
-- Xcode: 7.1.1
--
-- C/C++:
-- Built as dynamic libs?: YES
-- C++ Compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang++ (ver 7.0.0.7000176)
-- C++ flags (Release): -fsigned-char -W -Werror=return-type -Werror=non-virtual-dtor -Werror=address -Werror=sequence-point -Wformat -Werror=format-security -Wmissing-declarations -Wmissing-prototypes -Wstrict-prototypes -Wundef -Winit-self -Wpointer-arith -Wshadow -Wsign-promo -Wno-narrowing -Wno-delete-non-virtual-dtor -Wno-unnamed-type-template-args -fdiagnostics-show-option -Wno-long-long -Qunused-arguments -Wno-semicolon-before-method-body -fno-omit-frame-pointer -msse -msse2 -mno-avx -msse3 -mno-ssse3 -mno-sse4.1 -mno-sse4.2 -fvisibility=hidden -fvisibility-inlines-hidden -O3 -DNDEBUG -DNDEBUG
-- C++ flags (Debug): -fsigned-char -W -Werror=return-type -Werror=non-virtual-dtor -Werror=address -Werror=sequence-point -Wformat -Werror=format-security -Wmissing-declarations -Wmissing-prototypes -Wstrict-prototypes -Wundef -Winit-self -Wpointer-arith -Wshadow -Wsign-promo -Wno-narrowing -Wno-delete-non-virtual-dtor -Wno-unnamed-type-template-args -fdiagnostics-show-option -Wno-long-long -Qunused-arguments -Wno-semicolon-before-method-body -fno-omit-frame-pointer -msse -msse2 -mno-avx -msse3 -mno-ssse3 -mno-sse4.1 -mno-sse4.2 -fvisibility=hidden -fvisibility-inlines-hidden -g -O0 -DDEBUG -D_DEBUG
-- C Compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-- C flags (Release): -fsigned-char -W -Werror=return-type -Werror=non-virtual-dtor -Werror=address -Werror=sequence-point -Wformat -Werror=format-security -Wmissing-declarations -Wmissing-prototypes -Wstrict-prototypes -Wundef -Winit-self -Wpointer-arith -Wshadow -Wsign-promo -Wno-narrowing -Wno-delete-non-virtual-dtor -Wno-unnamed-type-template-args -fdiagnostics-show-option -Wno-long-long -Qunused-arguments -Wno-semicolon-before-method-body -fno-omit-frame-pointer -msse -msse2 -mno-avx -msse3 -mno-ssse3 -mno-sse4.1 -mno-sse4.2 -fvisibility=hidden -fvisibility-inlines-hidden -O3 -DNDEBUG -DNDEBUG
-- C flags (Debug): -fsigned-char -W -Werror=return-type -Werror=non-virtual-dtor -Werror=address -Werror=sequence-point -Wformat -Werror=format-security -Wmissing-declarations -Wmissing-prototypes -Wstrict-prototypes -Wundef -Winit-self -Wpointer-arith -Wshadow -Wsign-promo -Wno-narrowing -Wno-delete-non-virtual-dtor -Wno-unnamed-type-template-args -fdiagnostics-show-option -Wno-long-long -Qunused-arguments -Wno-semicolon-before-method-body -fno-omit-frame-pointer -msse -msse2 -mno-avx -msse3 -mno-ssse3 -mno-sse4.1 -mno-sse4.2 -fvisibility=hidden -fvisibility-inlines-hidden -g -O0 -DDEBUG -D_DEBUG
-- Linker flags (Release):
-- Linker flags (Debug):
-- Precompiled headers: NO
-- Extra dependencies: -framework OpenCL /usr/local/lib/libwebp.dylib gstvideo-1.0 gstapp-1.0 gstbase-1.0 gstriff-1.0 gstpbutils-1.0 gstreamer-1.0 gobject-2.0 glib-2.0 intl dc1394 avcodec avformat avutil swscale avresample /usr/lib/libbz2.dylib -framework VideoDecodeAcceleration bz2 -framework QTKit -framework QuartzCore -framework AppKit -framework Cocoa $<$<NOT:$<CONFIG:DEBUG>>:/usr/local/lib/libprotobuf.dylib> $<$<CONFIG:DEBUG>:/usr/local/lib/libprotobuf.dylib> vtkRenderingOpenGL vtkImagingHybrid vtkIOImage vtkCommonDataModel vtkCommonMath vtkCommonCore vtksys vtkCommonMisc vtkCommonSystem vtkCommonTransforms vtkCommonExecutionModel vtkDICOMParser vtkIOCore /usr/lib/libz.dylib vtkmetaio /usr/local/lib/libjpeg.dylib /usr/local/lib/libpng.dylib /usr/local/lib/libtiff.dylib vtkImagingCore vtkRenderingCore vtkCommonColor vtkFiltersExtraction vtkFiltersCore vtkFiltersGeneral vtkCommonComputationalGeometry vtkFiltersStatistics vtkImagingFourier vtkalglib vtkFiltersGeometry vtkFiltersSources vtkInteractionStyle vtkRenderingLOD vtkFiltersModeling vtkIOPLY vtkIOGeometry vtkFiltersTexture vtkRenderingFreeType vtkfreetype vtkftgl vtkIOExport vtkRenderingAnnotation vtkImagingColor vtkRenderingContext2D vtkRenderingGL2PS vtkRenderingContextOpenGL vtkgl2ps vtkRenderingLabel
-- 3rdparty dependencies: libjpeg libpng libtiff libjasper IlmImf zlib ippicv
--
-- OpenCV modules:
-- To be built: hal core flann imgproc ml photo reg surface_matching video viz dnn imgcodecs shape videoio highgui objdetect superres ts xobjdetect xphoto bgsegm bioinspired dpm face features2d line_descriptor saliency text calib3d ccalib datasets java rgbd stereo structured_light tracking videostab xfeatures2d ximgproc aruco optflow stitching python2
-- Disabled: world contrib_world
-- Disabled by dependency: -
-- Unavailable: cudaarithm cudabgsegm cudacodec cudafeatures2d cudafilters cudaimgproc cudalegacy cudaobjdetect cudaoptflow cudastereo cudawarping cudev python3 cvv matlab
--
-- GUI:
-- QT: NO
-- Cocoa: YES
-- OpenGL support: NO
-- VTK support: YES (ver 6.3.0)
--
-- Media I/O:
-- ZLib: build (ver 1.2.8)
-- JPEG: build (ver 90)
-- WEBP: /usr/local/lib/libwebp.dylib (ver encoder: 0x0202)
-- PNG: build (ver 1.5.12)
-- TIFF: build (ver 42 - 4.0.2)
-- JPEG 2000: build (ver 1.900.1)
-- OpenEXR: build (ver 1.7.1)
-- GDAL: NO
--
-- Video I/O:
-- DC1394 1.x: NO
-- DC1394 2.x: YES (ver 2.2.2)
-- FFMPEG: YES
-- codec: YES (ver 56.60.100)
-- format: YES (ver 56.40.101)
-- util: YES (ver 54.31.100)
-- swscale: YES (ver 3.1.101)
-- resample: YES (ver 2.1.0)
-- gentoo-style: YES
-- GStreamer:
-- base: YES (ver 1.6.1)
-- video: YES (ver 1.6.1)
-- app: YES (ver 1.6.1)
-- riff: YES (ver 1.6.1)
-- pbutils: YES (ver 1.6.1)
-- OpenNI: NO
-- OpenNI PrimeSensor Modules: NO
-- OpenNI2: NO
-- PvAPI: NO
-- GigEVisionSDK: NO
-- QuickTime: NO
-- QTKit: YES
-- V4L/V4L2: NO/NO
-- XIMEA: NO
-- gPhoto2: NO
--
-- Parallel framework: GCD
--
-- Other third-party libraries:
-- Use IPP: 9.0.1 [9.0.1]
-- at: /Users/athundt/source/git/Itseez/opencv/3rdparty/ippicv/unpack/ippicv_osx
-- Use IPP Async: NO
-- Use VA: NO
-- Use Intel VA-API/OpenCL: NO
-- Use Eigen: YES (ver 3.2.6)
-- Use Cuda: NO
-- Use OpenCL: YES
--
-- OpenCL:
-- Version: static
-- libraries: -framework OpenCL
-- Use AMDFFT: NO
-- Use AMDBLAS: NO
--
-- Python 2:
-- Interpreter: /usr/local/bin/python2.7 (ver 2.7.10)
-- Libraries: /usr/lib/libpython2.7.dylib (ver 2.7.10)
-- numpy: /usr/local/lib/python2.7/site-packages/numpy/core/include (ver 1.10.1)
-- packages path: lib/python2.7/site-packages
--
-- Python 3:
-- Interpreter: NO
--
-- Python (for build): /usr/local/bin/python2.7
--
-- Java:
-- ant: /usr/local/bin/ant (ver 1.9.6)
-- JNI: /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/System/Library/Frameworks/JavaVM.framework/Headers /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/System/Library/Frameworks/JavaVM.framework/Headers /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/System/Library/Frameworks/JavaVM.framework/Headers
-- Java wrappers: YES
-- Java tests: YES
--
-- Matlab:
-- mex: NO
--
-- Documentation:
-- Doxygen: /usr/local/bin/doxygen (ver 1.8.10)
-- PlantUML: NO
--
-- Tests and samples:
-- Tests: YES
-- Performance tests: YES
-- C/C++ Examples: NO
--
-- Install path: /usr/local
--
-- cvconfig.h is in: /Users/athundt/source/git/Itseez/xcodebuild
-- -----------------------------------------------------------------
--
-- Configuring done
-- Generating done
-- Build files have been written to: /Users/athundt/source/git/Itseez/xcodebuild
```
| bug,priority: normal,category: build/install,affected: 3.4,category: viz | low | Critical |
120,602,276 | TypeScript | Class View in Visual Studio? | TypeScript has some integration with VS, but the it doesn't seem to populate the class view window. Are there plans to implement this?
| Suggestion,Visual Studio | low | Minor |
120,626,631 | go | x/mobile/example: paint event sending is too much on iOS | - Go 1.5.2(OS-X 10.10)
- target device: iPhone5s iOS 9.1
- expected behavior: Just a good paint frequency.
- instead behavior: high CPU load and Irregular paint timing.
iOS device requires following patch
```
diff --git a/example/basic/main.go b/example/basic/main.go
index 2b2e0c9..f826c45 100644
--- a/example/basic/main.go
+++ b/example/basic/main.go
@@ -89,7 +89,7 @@ func main() {
a.Publish()
// Drive the animation by preparing to paint the next frame
// after this one is shown.
- a.Send(paint.Event{})
+ //a.Send(paint.Event{})
case touch.Event:
touchX = e.X
touchY = e.Y
```
| mobile | low | Minor |
120,792,138 | rust | Error messages about lifetimes for mutable Iterator are cryptic. | Example: http://is.gd/8dVXWc
```
<anon>:42:14: 42:33 error: cannot infer an appropriate lifetime for borrow expression due to conflicting requirements
<anon>:42 Some(&mut self.cont.item)
^~~~~~~~~~~~~~~~~~~
<anon>:39:5: 43:6 help: consider using an explicit lifetime parameter as shown: fn next(&'a mut self) -> Option<&'a mut V>
<anon>:39 fn next(&mut self) -> Option<&'a mut V> {
<anon>:40 if self.emitted { return None }
<anon>:41 self.emitted = true;
<anon>:42 Some(&mut self.cont.item)
<anon>:43 }
error: aborting due to previous error
playpen: application terminated with error code 101
Compilation failed.
```
@bluss gave me a [helpful link](http://stackoverflow.com/a/25748645) on IRC, stating that is a classic thing.
I think for every "classic" problem there should be a lint giving a link to some article about the problem.
In this case the link can be emitted for any lifetimes problem when mutable references and `Iterator` trait involved together.
For reference: [link](http://is.gd/uZj9DI) to changed version that does compile.
| C-enhancement,A-diagnostics,A-lifetimes,T-compiler | low | Critical |
120,878,404 | go | net: add support for FileConn, FilePacketConn, FileListener on Plan 9 | A new test reveals that Plan 9 doesn't support File{Conn,Listener,PacketConn}.
```
--- FAIL: TestFileConn (0.00s)
file_test.go:121: write tcp 127.0.0.1:58090: write /net/tcp/26/data: i/o on hungup channel
FAIL
```
Just FYI: https://storage.googleapis.com/go-build-log/b7d5a4b1/plan9-386_d2e48151.log
| OS-Plan9,FeatureRequest | low | Minor |
120,890,642 | angular | Handling of "<" in html | #5657 allows "<" in text nodes so that `<p>{{ a < b ? c : d }}</p>` does not throw.
However this is not valid html - `<` would have to be `<` to have a valid html.
One potential issue with the current approach is that in `<p>{{ a <b && c > d }}</p>` `<b && c >` would be parsed as an html tag and would not be easy for user to debug.
We could solve this by making the lexer aware of angular expression.
/cc @tbosch
edit `{{ "<b>text</b>" }}` could also cause pb
| type: bug/fix,area: compiler,P3,compiler: parser,feature: votes required | low | Critical |
120,899,779 | flutter | Drop downs and popup menus have opposite material bugs | You can't interact with an item on a popup menus before it has finished animating in.
You _can_ interact with an item in a drop down menu, but doing so will draw ink splashes in the air before the material has painted there.
We should come up with a rationalisation that solves both these problems cleanly.
| framework,a: animation,f: material design,a: quality,P3,team-design,triaged-design | low | Critical |
120,906,923 | go | x/net/websocket: ErrBadStatus should include the bad status code | Right now, if a `x/net/websocket` client connects to an HTTP endpoint and receives a response with any status other than 101, it returns an `ErrBadStatus` ([source](https://github.com/golang/net/blob/01256db42e5106196a3473ec1620727a383500e8/websocket/hybi.go#L448)). This error does not include the actual status code received, and so users of this library are unable to distinguish between, for instance, 403 Forbidden and 500 Internal Server Error responses.
One solution would be to add a `websocket.HTTPStatusError` which implements `websocket.ProtocolError` and also includes an exported `Status` field. This way, users could (if they wished) check the type of the error and switch on the `Status` field to determine correct behavior.
| NeedsInvestigation | low | Critical |
120,921,739 | go | tour: better explanation about type declarations? | Context: https://tour.golang.org/moretypes/2
I just decided to look through the Go tour to see how it explains named types and assignability. As far as I can tell, the only explanation is the parenthetical sentence "And a `type` declaration does what you'd expect."
Based on user questions like issue #13529, I suspect that `type` declarations do _not_ necessarily do what users expect, and perhaps it's worth elaborating on this point somehow.
| Documentation,NeedsInvestigation | low | Major |
121,036,397 | neovim | :colorscheme - no syntax highlighting when changing colorscheme | Start with a colorscheme - like monokai, all tags are highlighted, everything works.
Now change to a heavier colorscheme - one which defines more syntax rules (like solarized or PaperColor).
Everything still works.
Now switch back to the 'lighter' colorscheme (in this case monokai) - very few tags are highlighted. Even strings are not highlighted properly.
On further digging, I found an [old stackoverflow link](http://stackoverflow.com/questions/12915797/gvim-remove-syntax-highlighting-groups).
There @xolox gave an explanation to this problem and a possible solution.
Can this problem be solved ?
If not, can :colorscheme be remapped to some function like `xolox#colorscheme_switcher#switch_to()` from [xolox/vim-colorscheme-switcher](https://github.com/xolox/vim-colorscheme-switcher) ?
| bug-vim | low | Major |
121,056,717 | youtube-dl | abort video + audio when --max-filesize reached | ```
youtube-dl -f bestvideo[ext=mp4]+bestaudio[ext=m4a]/best --max-filesize 2G --abort-on-error 'https://www.youtube.com/watch?v=ksWHFG8-gC4'
```
When i exec this command for a youtube video, if the video file is bigger than 2G, video download is aborted, but audio file is still downloaded.
is there any option combination that would abort download totally (video and audio)?
| request | low | Critical |
121,068,362 | TypeScript | Automatically inserting JSX closing element in TypeScript JSX file | Currently, when users type non self-closing JSX tag, they will have to type corresponding closing JSX tag. In this situation, our language service can help the users by automatically insert the corresponding JSX tag. The newly inserted tag should respect existing format and If the matching closing tag exists, the closing tag should not be insert.
``` ts
var x = <div> [insert by language-service] </div>
var y =
<div>
[insert by language-service]</div>
var z =
<div>
[insert by language-service] </div>
```
| Suggestion,Visual Studio | medium | Critical |
121,116,466 | kubernetes | Handle node label updates and deletions | As of now node labels can be updated either via the API server directly or through the kubelet.
Inside of the kubelet, labels can be set directly from inside of kubelet, or by using command line flags and localhost files.
Ownership of labels is not explicit. As of now a label set via the kubelet can be updated through the API server directly. If the kubelet restarts, it will update those labels again.
Kubernetes does not specify any policy around label source precedence.
To begin with we can require users to avoid label key conflicts themselves.
We need to fix label ownership though.
Kubelet should be aware of the labels that it has created. It should not update or delete labels that were not originally created through the kubelet. Kubelet needs to keep track of all the labels it has added and delete any labels that were removed across restarts.
In v1.1, the kubelet did not surface any labels. hence forwards and backwards compatibility should not be an issue.
Related issues & PRs: #17265, #17575, #13524
| sig/node,kind/feature,priority/important-longterm,lifecycle/frozen,needs-triage | medium | Critical |
121,248,055 | TypeScript | Differing user-defined type guard and 'typeof' type guard behaviour when narrowing 'any' | In the below code, using a typeof type guard and an equivalent (I thought) user-defined guard, only one error is produced.
``` typescript
var y: any;
// Built-in type guard
if (typeof y === "string") {
y.hello = true; // Correct error - 'hello' does not exist on type string
}
// Equivalent user-defined type guard
function f(x: any): x is string {
return typeof x === "string";
}
if (f(y)) {
y.hello = true; // No error with user-defined guard
}
```
[Playground demo](http://www.typescriptlang.org/Playground#src=var%20y%3A%20any%3B%0A%0A%2F%2F%20Built-in%20type%20guard%0Aif%20%28typeof%20y%20%3D%3D%3D%20%22string%22%29%20%7B%0A%09y.hello%20%3D%20true%3B%20%2F%2F%20Correct%20error%0A%7D%0A%0A%2F%2F%20Equivalent%20user-defined%20type%20guard%0Afunction%20f%28x%3A%20any%29%3A%20x%20is%20string%20%7B%0A%09return%20typeof%20x%20%3D%3D%3D%20%22string%22%3B%0A%7D%0A%0Aif%20%28f%28y%29%29%20%7B%0A%09y.hello%20%3D%20true%3B%20%2F%2F%20No%20error%20with%20user-defined%20guard%0A%7D). Looks like user-defined type guards won't narrow from `any`, in any circumstances, as far as I can tell.
| Suggestion,Help Wanted,Effort: Moderate | low | Critical |
121,256,418 | go | cmd/compile: escape analysis overconservative for recursive calls | Sample program. Allocation in inner loop of recursive foo does not escape, but conservative assumptions (because escape analysis does not do fixed-pointer iteration) force conclusion that it does.
```
package main
// import "fmt"
type Node struct {
next *Node
name string
}
var sink string
func foo(list *Node, names []string) {
if len(names) > 0 {
name := names[0]
for i := 0; i < len(name); i++ {
foo(&Node{list, name[i : i+1]}, names[1:]) // need not escape
}
} else if list != nil {
// fmt.Printf("%s", list.name) // you don't want to to do this unless you are comparing output.
sink = list.name
foo(list.next, names)
}
}
func main() {
names := []string{"ant", "bat", "cat", "dog", "emu",
"fox", "gnu", "hyena", "iguana", "jaguar"}
foo(nil, names)
}
```
| NeedsFix,compiler/runtime | low | Minor |
121,275,472 | go | archive/tar: add support for writing tar containing sparse files | I've created a [Github Repo](https://github.com/grubernaut/Golang-Tar) with all the needed steps for reproducing this on Ubuntu 12.04 using Go1.5.1. I've also verified that using Go1.5.2 still experiences this error.
Run `vagrant create` then `vagrant provision` from repository root.
```
vagrant create
vagrant provision
```
Expected Output:
```
$ vagrant provision
==> default: Running provisioner: shell...
default: Running: inline script
==> default: stdin: is not a tty
==> default: go version go1.5.2 linux/amd64
==> default: Creating Sparse file
==> default: Proving file is truly sparse
==> default: 0 -rw-r--r-- 1 root root 512M Dec 9 15:26 sparse.img
==> default: Compressing in Go without sparse
==> default: Compressing in Go with sparse
==> default: FileInfo File Size: 536870912
==> default: Proving non-sparse in Go gained size on disk
==> default: 512M -rw-r--r-- 1 root root 512M Dec 9 15:26 non_sparse/sparse.img
==> default: Proving sparse in Go DID keep file size on disk
==> default: 0 -rw-r--r-- 1 root root 0 Dec 9 15:26 sparse/sparse.img
==> default: Compressing via tar w/ Sparse Flag set
==> default: Proving sparse via tar DID keep file size on disk
==> default: 0 -rw-r--r-- 1 root root 512M Dec 9 15:26 tar/sparse.img
```
Actual Output:
```
$ vagrant provision
==> default: Running provisioner: shell...
default: Running: inline script
==> default: stdin: is not a tty
==> default: go version go1.5.2 linux/amd64
==> default: Creating Sparse file
==> default: Proving file is truly sparse
==> default: 0 -rw-r--r-- 1 root root 512M Dec 9 15:35 sparse.img
==> default: Compressing in Go without sparse
==> default: Compressing in Go with sparse
==> default: Proving non-sparse in Go gained size on disk
==> default: 513M -rw-r--r-- 1 root root 512M Dec 9 15:35 non_sparse/sparse.img
==> default: Proving sparse in Go DID NOT keep file size on disk
==> default: 512M -rw-r--r-- 1 root root 512M Dec 9 15:35 sparse/sparse.img
==> default: Compressing via tar w/ Sparse Flag set
==> default: Proving sparse via tar DID keep file size on disk
==> default: 0 -rw-r--r-- 1 root root 512M Dec 9 15:35 tar/sparse.img
```
The Vagrantfile supplied in the repository runs the following shell steps:
- Installs Go
- Creates a sparse file via `truncate -s 512M sparse.img`
- Proves that the file is sparse via `ls -lash sparse.img`
- Runs `compress.go` via `go run compress.go`
- Untars the archives created by `compress.go` via `tar -xf`
- Verifies that the extracted files did not maintain sparse files, both with and without the sparse type set in the tar file's header. `ls -lash sparse.img`
- Uses GNU/Tar to compress the sparse file with the sparse flag set `tar -Scf sparse.tar sparse.img`
- Extracts the archive created by GNU/Tar `tar -xf sparse.tar`
- Proves that GNU/Tar maintained sparse files `ls -lash sparse.img`
This is somewhat related to #12594.
I could also be creating the archive incorrectly, and have tried a few different methods for creating the tar archive, each one however, did not keep the sparse files intact upon extraction of the archive. This also cannot be replicated in OSX as HGFS+ does not have a concept of sparse files, and instantly destroys any file sparseness, hence the need for running and testing the reproduction case in a vagrant vm.
Any thoughts or hints into this would be greatly appreciated, thanks!
| NeedsFix,FeatureRequest | medium | Critical |
121,302,677 | youtube-dl | Site Support Request: serviporno.com | Hi,
Another popular site:
./youtube-dl http://www.serviporno.com/videos/adolescente-cenida-y-su-maquina-de-follar/
[generic] adolescente-cenida-y-su-maquina-de-follar: Requesting header
WARNING: Falling back on generic information extractor.
[generic] adolescente-cenida-y-su-maquina-de-follar: Downloading webpage
[generic] adolescente-cenida-y-su-maquina-de-follar: Extracting information
ERROR: Unsupported URL: http://www.serviporno.com/videos/adolescente-cenida-y-su-maquina-de-follar/
thanks...
| site-support-request | low | Critical |
121,673,963 | kubernetes | Rolling updates should fail early if a pod fails to start | In 1.0.x, rolling update didn't block, so we could check things like a failed pod while waiting for the update to complete.
In 1.1.x, rolling update does block up to the timeout amount. This is great since we had to script it externally before. However it waits the entire timeout even if the update fails immediately. For instance, if you specify a non-existent image the pod will report a `PullImageError`. At that point the rolling update could abort immediately. Instead it blocks for the 5 minute timeout. When frequently developing and deploying this 5 minute timeout becomes painful.
I suggest rolling-update fails immediately if any of the new pods are not in a 'Pending' or 'Running' state. Not sure if there is a set of non-error states we can use.
| priority/backlog,area/app-lifecycle,area/workload-api/deployment,sig/apps,lifecycle/frozen | medium | Critical |
Subsets and Splits