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 |
|---|---|---|---|---|---|---|
132,425,810 | opencv | cvUndistortPoints returns imprecise results | cvUndistortPoints calculates the result iteratively. Currently, the number of iterations is five (hardcoded), which is not enough to get the correct result.
| feature,category: imgproc | low | Minor |
132,462,146 | opencv | buildPyramid segfaults with Clang | Following test program segfaults if compiled with Clang:
```
#include <opencv2/opencv.hpp>
#include <vector>
int main() {
cv::Mat I(1000,1000,CV_8UC1);
std::vector<cv::Mat> P;
cv::buildPyramid(I, P, 30);
return P.size();
}
```
clang --version
Ubuntu clang version 3.6.2-1 (tags/RELEASE_362/final)
cat /etc/os-release
NAME="Ubuntu"
VERSION="15.10 (Wily Werewolf)"
OpenCV sources from github at tag 3.1.0
compile config:
cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D BUILD_EXAMPLES=ON -D INSTALL_C_EXAMPLES=ON -D INSTALL_PYTHON_EXAMPLES=ON -D BUILD_NEW_PYTHON_SUPPORT=ON -D WITH_V4L=ON -D WITH_QT=ON -D WITH_OPENGL=ON -D WITH_CUDA=OFF -D WITH_IPP=OFF .
| incomplete | low | Minor |
132,525,250 | rust | Named functions don't implement Debug | Trying to compile (https://play.rust-lang.org/?gist=3b38f384f0f7ddecc142&version=stable):
```
fn foo() {}
fn main() {
println!("{:?}", (foo as fn())); // Works
println!("{:?}", foo); // Fails
}
```
It seem that named functions have to be coerced to anonymous ones in order to implement `Debug`. This means any structs containing functions don't derive `Debug`, which makes unit testing tricky.
| A-type-system,T-lang,C-feature-request,T-types | low | Critical |
132,583,050 | go | go/build: Import seems to require absolute srcDir | While investigating go/types issue https://github.com/golang/go/issues/14215, I noticed that (after fixing the obvious go/types bug), build.Import didn't find the desired package if srcDir was relative. Computing its absolute path (relative to cwd) fixed the problem.
Reminder to investigate behavior. Fix and/or document.
| FrozenDueToAge | low | Critical |
132,651,175 | youtube-dl | Simplify access to multiple audio channels on pluzz | Hello
I might be missing something, but I can't find a straightforward way to get the OST version of a video on pluzz.fr, which of course defaults to the French version.
I'm using the latest youtube-dl version packaged for Debian.
```
$ youtube-dl --version
2015.11.27.1
$ youtube-dl -U
It looks like you installed youtube-dl with a package manager, pip, setup.py or a tarball. Please use that to update.
```
Here's the verbose output when I try to obtain the video:
```
$ youtube-dl -vF http://pluzz.francetv.fr/videos/trapped_saison1_ep1_,135088810.html
[debug] System config: []
[debug] User config: []
[debug] Command-line args: [u'-vF', u'http://pluzz.francetv.fr/videos/trapped_saison1_ep1_,135088810.html']
[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.9 - Linux-2.6.32-042stab111.12-x86_64-with-debian-8.3
[debug] exe versions: avconv 11.4-6, avprobe 11.4-6, ffmpeg 0.8.17-6, rtmpdump 2.4
[debug] Proxy map: {}
[pluzz.francetv.fr] trapped_saison1_ep1_,135088810: Downloading webpage
[pluzz.francetv.fr] 135088810: Downloading video JSON
[pluzz.francetv.fr] 135088810: Downloading geo restriction info
[pluzz.francetv.fr] 135088810: Downloading m3u8 information
[pluzz.francetv.fr] 135088810: Downloading m3u8 information
[info] Available formats for 135088810:
format code extension resolution note
hls_v5_os-meta mp4 multiple Quality selection URL
m3u8-download-meta mp4 multiple Quality selection URL
hls_v5_os-Version Multilingue (AD/VO) mp4 256x144 180k , avc1, mp4a
m3u8-download-180 mp4 256x144 180k , avc1, mp4a
hls_v5_os-189-0 mp4 unknown 189k , mp4a
hls_v5_os-189-1 mp4 unknown 189k , mp4a
hls_v5_os-303 mp4 320x180 303k , avc1, mp4a
m3u8-download-303 mp4 320x180 303k , avc1, mp4a
hls_v5_os-575 mp4 512x288 575k , avc1, mp4a
m3u8-download-575 mp4 512x288 575k , avc1, mp4a
hls_v5_os-831 mp4 704x396 831k , avc1, mp4a
m3u8-download-831 mp4 704x396 831k , avc1, mp4a
hls_v5_os-1466 mp4 1024x576 1466k , avc1, mp4a (best)
```
As you can see from the previous output, it seems there's something about choosing another language than French, but definitely not for the best video quality setting.
Subs are there, no problem with that:
```
$ youtube-dl --list-subs http://pluzz.francetv.fr/videos/trapped_saison1_ep1_,135088810.html
[pluzz.francetv.fr] trapped_saison1_ep1_,135088810: Downloading webpage
[pluzz.francetv.fr] 135088810: Downloading video JSON
[pluzz.francetv.fr] 135088810: Downloading geo restriction info
[pluzz.francetv.fr] 135088810: Downloading m3u8 information
[pluzz.francetv.fr] 135088810: Downloading m3u8 information
Available subtitles for 135088810:
Language formats
fr vtt, ttml, smi
```
The OST is definitely available when streaming (click on the headphones icon in the Flash player to select it, as it is not the default). I have a limited knowledge of how all this works together, but would definitely like to learn how to analyze this, so please do not hesitate if you need technical inputs from me.
The bottom line is that I'd like to understand whether it is a limitation of youtube-dl or if a user action is expected because the software can't be aware that multiple audio possibilities are available. If I have to do something, what path should I have followed to get what I want? The default video that gets downloaded only has the French track. I hope there won't be any geo-related issues.
Thanks for your help
| geo-restricted | low | Critical |
132,693,904 | youtube-dl | Improve regression detection with continous testing | It seems the youtube-dl project has abandoned the idea of using tests with travis-ci to keep all IEs always working (last passed build was 2 years ago, [#2571](https://travis-ci.org/rg3/youtube-dl/builds/99421929)). Not that it's a bad idea, since it's hard to keep up with all those sites. But a side effect of that is that it's harder to detect test fails that are due to a new commit, and not a website change.
What's I'd like to propose, is to keep the current testing infrastructure as a dashboard for working/non-working IEs, and add another "testsuite" that would test each commit for regressions: if a test is failing, the previous commit would be tested as well, and if it fails, it's not considered a regression.
I've made a simple proof of concept https://gist.github.com/anisse/6093f8b5814ab3ce7140 in bash. This could be improved/rewritten, in order to be integrated with travis-ci.
What do you guys think ?
| request | low | Major |
132,712,237 | opencv | LineIterator is missing from Java bindings | Title says it all. I now have to implement my own Bresenham algorithm.
| feature,priority: low,category: java bindings | low | Minor |
132,740,460 | TypeScript | JSX: a way to make all the properties of value-based elements optional | It's not documented, but currently, if the `JSX.ElementAttributesProperty` interface is declared empty,
``` ts
declare namespace JSX { interface ElementAttributesProperty {} }
```
then the _element attributes type_ becomes same as the _element instance type_. However, if the element instance type is a class, this leads to a situation where the compiler requires that all the members of the class be represented as attributes since they're not optional (and even cannot be marked as such as the class syntax doesn't allow optional members).
``` ts
class MyComponent {
myProp: string;
private myMethod(): void;
}
var a = <MyComponent myProp='value'/>;
// error: Property 'myMethod' is missing in type MyComponent
```
This prevents me from using JSX for type-checking Angular 1 templates (you can find my experiments in this area [here](https://github.com/thorn0/babel-plugin-transform-ng1-jsx)).
What if we introduce some way to tell the compiler that not all the properties are required, but only some of them? E.g. those having a certain decorator?
A related issue: #5151
| Suggestion,In Discussion | medium | Critical |
132,760,549 | go | cmd/asm: accepts MOVB (BX)(R8*4), AH incorrectly | `MOVB (BX)(R8*4), AH`
The assembler accepts this instruction but silently misassembles it to:
`MOVB (BX)(R8*4), SP`
This is because we need the RAX prefix for the indexed address, but then the RAX prefix also forces the use of standard register naming instead of the weird *H register naming.
gas rejects this instruction `movb (%rbx,%r8,4),%ah` with `can't encode register '%ah' in an instruction requiring REX prefix.`
@rsc
| NeedsFix,compiler/runtime | low | Minor |
132,821,186 | go | x/exp/shiny/driver/gldriver: deadlock when creating multiple windows on darwin | I am attempting to create multiple windows, to avoid having to write any layout or windowing code myself.
``` go
func main() {
driver.Main(func(s screen.Screen) {
w, err := s.NewWindow(nil)
if err != nil {
log.Fatal(err)
}
w2, err := s.NewWindow(nil)
if err != nil {
log.Fatal(err)
}
_, _ = w, w2
})
}
```
This hangs at the second call to `NewWindow`. Backtrace:
```
SIGQUIT: quit
PC=0x405bacb m=0
signal arrived during cgo execution
goroutine 1 [chan receive, locked to thread]:
runtime.mach_semaphore_wait(0xc800001003, 0x4228e00, 0x4031592, 0x40e1d00, 0x7fff5fbfd480, 0x4228e00, 0x404fb79, 0xffffffffffffffff, 0x419aba0, 0x7fff5fbfd494, ...)
$GOROOT/src/runtime/sys_darwin_amd64.s:411 +0xb fp=0x7fff5fbfd428 sp=0x7fff5fbfd420
runtime.semasleep1(0xffffffffffffffff, 0x419aba0)
$GOROOT/src/runtime/os1_darwin.go:423 +0xdf fp=0x7fff5fbfd460 sp=0x7fff5fbfd428
runtime.semasleep.func1()
$GOROOT/src/runtime/os1_darwin.go:439 +0x29 fp=0x7fff5fbfd480 sp=0x7fff5fbfd460
runtime.systemstack(0x7fff5fbfd498)
$GOROOT/src/runtime/asm_amd64.s:307 +0xab fp=0x7fff5fbfd488 sp=0x7fff5fbfd480
runtime.semasleep(0xffffffffffffffff, 0x0)
$GOROOT/src/runtime/os1_darwin.go:440 +0x36 fp=0x7fff5fbfd4b8 sp=0x7fff5fbfd488
runtime.notesleep(0x4229248)
$GOROOT/src/runtime/lock_sema.go:166 +0xed fp=0x7fff5fbfd4f0 sp=0x7fff5fbfd4b8
runtime.stoplockedm()
$GOROOT/src/runtime/proc.go:1682 +0xae fp=0x7fff5fbfd510 sp=0x7fff5fbfd4f0
runtime.schedule()
$GOROOT/src/runtime/proc.go:2030 +0x6e fp=0x7fff5fbfd548 sp=0x7fff5fbfd510
runtime.park_m(0xc820000180)
$GOROOT/src/runtime/proc.go:2137 +0x18b fp=0x7fff5fbfd570 sp=0x7fff5fbfd548
runtime.mcall(0x4059e1a)
$GOROOT/src/runtime/asm_amd64.s:233 +0x5b fp=0x7fff5fbfd580 sp=0x7fff5fbfd570
goroutine 17 [syscall, locked to thread]:
runtime.goexit()
$GOROOT/src/runtime/asm_amd64.s:1998 +0x1
goroutine 19 [syscall, locked to thread]:
golang.org/x/exp/shiny/driver/gldriver._Cfunc_doNewWindow(0x30000000400, 0x0)
golang.org/x/exp/shiny/driver/gldriver/_obj/_cgo_gotypes.go:200 +0x42
golang.org/x/exp/shiny/driver/gldriver.newWindow(0x0, 0x413f320, 0x0, 0x0)
golang.org/x/exp/shiny/driver/gldriver/cocoa.go:62 +0x63
golang.org/x/exp/shiny/driver/gldriver.(*screenImpl).NewWindow(0x4228a40, 0x0, 0x0, 0x0, 0x0, 0x0)
golang.org/x/exp/shiny/driver/gldriver/screen.go:125 +0x4c
main.main.func1(0x5aab2b8, 0x4228a40)
main.go:35 +0x14f
golang.org/x/exp/shiny/driver/gldriver.driverStarted.func1()
golang.org/x/exp/shiny/driver/gldriver/cocoa.go:102 +0x47
created by golang.org/x/exp/shiny/driver/gldriver.driverStarted
golang.org/x/exp/shiny/driver/gldriver/cocoa.go:104 +0x2b
goroutine 20 [select, locked to thread]:
golang.org/x/exp/shiny/driver/gldriver.drawLoop(0xc820092000, 0x1)
golang.org/x/exp/shiny/driver/gldriver/cocoa.go:147 +0x482
created by golang.org/x/exp/shiny/driver/gldriver.preparedOpenGL
golang.org/x/exp/shiny/driver/gldriver/cocoa.go:80 +0x117
```
The interesting goroutine is goroutine 19, which is blocked in the cgo `doNewWindow` call, at `dispatch_sync(dispatch_get_main_queue(), ...`. I've confirmed that at the time of the call, the current thread and the main thread are different. So either (a) the main thread is blocked somewhere else, (b) the main thread's run loop is stopped, or (c) the main thread's run loop is in the wrong mode.
Workaround suggestions would be very welcome, no matter how hacky.
/cc @nigeltao @crawshaw
| NeedsInvestigation | low | Minor |
132,826,205 | opencv | Some of the features2d algorithms would need a little bit of refactoring | As the title mentions, in the latest version of the "opencv" repository up-to-date (master-2c4ed7f8a5a6a2dce331b2f075f425cfe7ad522b, thus OpenCV3.1.0-dev), I think that some of the algorithms (both CUDA and non) that falls in the category of features detection, descriptors extraction, and features matching need a little bit of refactoring so that they match the current guidelines for implementing a new algorithm (http://docs.opencv.org/master/db/dfa/tutorial_transition_guide.html#tutorial_transition_algorithm) and a user can easily reuse the code using them with different algorithms.
Up to now, I identified the following issues:
- the CUDA version of the BFMatcher does not have a create() function as the non-CUDA counterpart, and as other algorithms, do; but has a specific create function (https://github.com/Itseez/opencv/blob/ddf82d0b154873510802ef75c53e628cd7b2cb13/modules/cudafeatures2d/include/opencv2/cudafeatures2d.hpp#L92).
- the CUDA version of ORB does not allow to use just the descriptor extractor as the non-CUDA counterpart do, because of the assertion on the flag "useProvidedKeypoints" and maybe some missing implementation about how to deal with just the extraction of the descriptors given the keypoints (https://github.com/Itseez/opencv/blob/master/modules/cudafeatures2d/src/orb.cpp#L583).
- I think that there should be consistency on how to create an algorithm, as the case of the features detectors and matchers, which all of them have an implemented create (and not anymore the general create function which took the string of the feature as input), while in the specific descriptors matchers (i.e., BFMatcher and FlannBased) classes there is not such a function (and thus the matcher can be created by calling "create" passing the name of the matcher as parameter).
As I am currently using them for doing research, if I find anything else and if useful, I will update the list (I would like to contribute to the actual process with some pulls, but unfortunately I do not have much free time soon).
Thanks.
| feature,category: features2d,category: gpu/cuda (contrib) | low | Minor |
132,874,000 | TypeScript | Consider re-ordering Array#reduce overloads in lib.d.ts | Example code:
``` typescript
type UnaryFunction = (arg1) => any;
type BinaryFunction = (arg1, arg2) => any;
let binaryFuncs: BinaryFunction[] = [];
let unaryFunc = arg1 => {};
let reduced = binaryFuncs.reduce((prev, next) => prev, unaryFunc);
// ACTUAL:
let f: UnaryFunction = reduced; // ERROR binary not assignable to unary
// EXPECTED:
let f: UnaryFunction = reduced; // OK - both lhs and rhs really are unary
```
The call to `Array#reduce` in the above example definitely returns a unary function, but the type system erroneously infers the return type as a binary function.
This seems to be caused by the declaration order of the two overloads of `Array#reduce` in `lib.d.ts`. If the declaration order is reversed, the problem is solved.
The two overloaded declarations in `lib.d.ts` are as follows:
``` typescript
reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
```
The first overload matches the example with `T=BinaryFunction`, since it satisfies the compiler's assignability checks. So the second overload is never considered, even though it is a strictly better match, with `T=BinaryFunction` and `U=UnaryFunction`.
Would it be possible to swap the overload order for `Array#reduce` (and `Array#reduceRight`) in `lib.d.ts` to resolve this issue?
| Suggestion,Help Wanted,Domain: lib.d.ts,Good First Issue | medium | Critical |
133,056,832 | rust | Can't Unify Super Generic Code | I was trying to verify that the associated-items-based HKT described in the associated items RFC still worked. As best I know, I updated everything to work with today's stable Rust (1.7), but it fails out in unifying in the actual implementation of `Mappable for Vec<T>` (see the FIXME).
``` rust
// The kind * -> *
trait TypeToType<Input> {
type Output;
}
struct Vec_;
impl<T> TypeToType<T> for Vec_ {
type Output = Vec<T>;
}
trait Mappable
where Self: Sized,
{
type E;
type HKT: TypeToType<Self::E, Output=Self>;
fn map<F, O>(self, f: F) -> <Self::HKT as TypeToType<O>>::Output
where F: FnMut(Self::E) -> O,
Self::HKT: TypeToType<O>;
}
impl<T> Mappable for Vec<T> {
type E = T;
type HKT = Vec_;
// FIXME: I won't unify `Vec_::Output = Vec<O>`!
fn map<F, O>(self, mut f: F) -> <Self::HKT as TypeToType<O>>::Output
where F: FnMut(Self::E) -> O,
Self::HKT: TypeToType<O>
{
let r: Vec<O> = self.into_iter().map(&mut f).collect();
r
}
}
fn main() {
let nums: Vec<u32> = vec![1, 2, 3, 4, 5, 6];
let bools: Vec<bool> = nums.map(|x| x < 3);
}
```
| A-type-system,A-associated-items,T-compiler,C-bug,T-types | low | Major |
133,127,799 | TypeScript | Emitted extends clause should come after deatched-comment at the top of the file | ``` typescript
// --------------------------------------------------
// Some Copy Right
// --------------------------------------------------
class B {}
class C extends B {}
```
``` js
"use strict";
var __extends = (this && this.__extends) || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
// --------------------------------------------------
// Some Copy Right
// --------------------------------------------------
var B = (function () {
function B() {
}
return B;
}());
var C = (function (_super) {
__extends(C, _super);
function C() {
_super.apply(this, arguments);
}
return C;
}(B));
```
| Bug,Help Wanted | low | Minor |
133,159,421 | go | x/build: use `go tool dist test -k` on fast builders? | Especially for fast builders, I suggest that we make then use the keepgoing
mode of `go tool dist test` so that even if a test fails, all the remaining tests
are still tested.
This will be especially useful if a flaky tests fails and then masks the real
problem of a given a CL because the affected tests are not run.
As an example, https://golang.org/cl/19455 changes the runtime, but
the openbsd builder fails a unrelated net tests, and the runtime tests are
not run so we don't actually know if the CL catches any problems on
OpenBSD/386.
http://build.golang.org/log/38e92c1c987f7a7eeb4b6bb418c0d95ed706ba80
I don't know if it's worthwhile to also use the -k for the trybots. I can see
arguments from both sides.
/cc @bradfitz @adg
| Builders,Proposal,Proposal-Accepted | low | Major |
133,180,226 | rust | `create_dir_all` can't create directories through a dangling symlink. | Currently `create_dir_all` first does a stat on the file to see if it is a directory, and if not tries to create the parent dirs. This does not take into account that stat can fail if the path is a dangling symlink.
The classic `mkdir -p` just tries to create a directory and see why it fails. This spares a syscall and handles dangling symlinks transparently.
On Windows this method hit two problems:
- When we have to recurse all the way op to the disk letter, `create_dir_all` fails.
You can't mkdir `c:\` or `\\host\share`. But we can just stop recursing in time.
- Windows can't create a directory through a dangling symlink.
We would have to read the symlink (and possibly resolve it if relative), and create the directory
at the target location ourself.
Would it make sense to go trough this trouble?
I think it is best to only fix this for `create_dir_all` and to document the normal `create_dir` can not
create a directory trough a dangling symlink on Windows.
| T-libs-api,C-feature-accepted,A-io | low | Major |
133,189,201 | youtube-dl | please add support for rte.ie/archives | http://www.rte.ie/archives/2016/0210/766882-beat-of-the-feet/
```
$ youtube-dl http://www.rte.ie/archives/2016/0210/766882-beat-of-the-feet/ -v
[debug] System config: []
[debug] User config: []
[debug] Command-line args: [u'http://www.rte.ie/archives/2016/0210/766882-beat-of-the-feet/', u'-v']
[debug] Encodings: locale cp1252, fs mbcs, out None, pref cp1252
[debug] youtube-dl version 2016.02.10
[debug] Python version 2.7.11 - Windows-XP-5.1.2600-SP3
[debug] exe versions: ffmpeg N-78067-g9079e99, ffprobe N-78067-g9079e99, rtmpdump 2.4
[debug] Proxy map: {}
[generic] 766882-beat-of-the-feet: Requesting header
WARNING: Falling back on generic information extractor.
[generic] 766882-beat-of-the-feet: Downloading webpage
[generic] 766882-beat-of-the-feet: Extracting information
ERROR: Unsupported URL: http://www.rte.ie/archives/2016/0210/766882-beat-of-the-feet/
Traceback (most recent call last):
File "c:\python27\lib\site-packages\youtube_dl\extractor\generic.py", line 1294, in _real_extract
doc = compat_etree_fromstring(webpage.encode('utf-8'))
File "c:\python27\lib\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 "c:\python27\lib\site-packages\youtube_dl\compat.py", line 237, in _XML
parser.feed(text)
File "c:\python27\lib\xml\etree\ElementTree.py", line 1642, in feed
self._raiseerror(v)
File "c:\python27\lib\xml\etree\ElementTree.py", line 1506, in _raiseerror
raise err
ParseError: undefined entity: line 8, column 13
Traceback (most recent call last):
File "c:\python27\lib\site-packages\youtube_dl\YoutubeDL.py", line 666, in extract_info
ie_result = ie.extract(url)
File "c:\python27\lib\site-packages\youtube_dl\extractor\common.py", line 315, in extract
return self._real_extract(url)
File "c:\python27\lib\site-packages\youtube_dl\extractor\generic.py", line 1930, in _real_extract
raise UnsupportedError(url)
UnsupportedError: Unsupported URL: http://www.rte.ie/archives/2016/0210/766882-beat-of-the-feet/
```
| site-support-request | low | Critical |
133,215,937 | java-design-patterns | Composition root pattern | ### Description:
The Composition Root design pattern is a method of organizing code to ensure that all dependencies are created in a single location within an application. This helps manage dependencies more effectively, improve testability, and promote a clear separation of concerns. By centralizing the creation of dependencies, the Composition Root pattern ensures that an application's object graph is constructed in a consistent manner.
**Main elements of the pattern:**
1. **Centralized Dependency Creation**: All dependencies are instantiated in a single location, typically at the application's entry point.
2. **Dependency Injection**: Dependencies are injected into classes rather than being created within those classes, supporting Inversion of Control (IoC).
3. **Separation of Concerns**: Ensures that the construction of objects and their usage are separate, enhancing maintainability and testability.
**References:**
- [Composition Root - Mark Seemann](https://blog.ploeh.dk/2011/07/28/CompositionRoot/)
- [Dependency Injection Principles, Practices, and Patterns](https://www.manning.com/books/dependency-injection-principles-practices-patterns) by Mark Seemann and Steven van Deursen
- [Project Contribution Guidelines](https://github.com/iluwatar/java-design-patterns/wiki)
### Acceptance Criteria:
1. Implement the Composition Root pattern in the project, ensuring all dependencies are instantiated in a single location at the application's entry point.
2. Demonstrate the use of dependency injection to provide these dependencies to various components of the application.
3. Ensure that the implemented pattern adheres to the projectโs contribution guidelines and includes relevant documentation and examples.
| info: help wanted,epic: pattern,type: feature | low | Minor |
133,226,751 | go | x/text/currency: position of the ISO code or sign in amounts | ``` go
currencyCode = "PLN"
unit, _ := currency.ParseISO(currencyCode)
p := message.NewPrinter(language.Polish)
amount := float64(100)
p.Print(currency.Symbol(unit.Amount(amount)))
```
The result is `zล 100` but I would expect `100 zล`.
https://en.wikipedia.org/wiki/ISO_4217#Position_of_ISO_4217_code_in_amounts
http://publications.europa.eu/code/en/en-370303.htm#position
I would expect `100 zล` but maybe there is "other" library/func/method that handles order?
Or if this is on TODO list, any idea how could I workaround the problem?
| NeedsInvestigation | low | Major |
133,317,869 | go | cmd/go: decide, document standard benchmark data format | We propose to make the current output of `go test -bench` the defined format for recording all Go benchmark data. Having a defined format allows benchmark measurement programs and benchmark analysis programs to interoperate while evolving independently.
See [golang.org/design/14313-benchmark-format](https://golang.org/design/14313-benchmark-format) for details.
| Documentation,Proposal,Proposal-Accepted,NeedsInvestigation | medium | Critical |
133,354,646 | TypeScript | Permit type alias declarations inside a class | I normally want my class declaration to be the first thing in my file:
``` typescript
module foo {
/** My foo class */
export class MyFoo {
}
}
```
So when I want to declare an alias, I don't like the fact that my class has been pushed down further:
``` typescript
module foo {
type foobar = foo.bar.baz.FooBar;
/** My foo class */
export class MyFoo {
}
}
```
I suggest the following be permitted:
``` typescript
module foo {
/** My foo class */
export class MyFoo {
type foobar = foo.bar.baz.FooBar;
}
}
```
Since `type foobar` is just a compile-time construct, and if people want to write it that way, then they should be permitted to do so. Note that the type `foobar` is private to the class. It should not be permissible to export `foobar`.
| Suggestion,In Discussion | high | Critical |
133,363,486 | flutter | Draggable feedback should animate back to the draggable when the drop fails | Possibly giving me an offset from it's original position.
| c: new feature,framework,a: animation,customer: solaris,P3,team-framework,triaged-framework | medium | Major |
133,404,927 | rust | Compiletest doesn't pass environment variables to emscripten tests | Compiletest sometimes passes environment variables when building the `Command` object. However in the case of emscripten, these values get passed to `node` instead of the program itself.
`node` can't propagate env vars to the javascript code, since javascript has no concept of an environment variable. It is possible to pass environment variables to the "emscripten runtime", but that must be done by manually adding some JS code in the header of the file.
For the moment the tests that rely on env vars are ignored and point to this issue.
| O-wasm,O-emscripten | low | Minor |
133,438,086 | angular | fix(Changedetection): ngAfterViewChecked is called when component is set to OnPush and no input properties changed | Similar to https://github.com/angular/angular/issues/7054 it seems that `ngAfterViewChecked()` is called, when a component is set to `OnPush` and **no input property changed, or event is fired inside that component**.
Here's a plunk that demonstrates the issue: http://plnkr.co/edit/3HEH7AcrQaVUF0PTQBNv?p=preview
You'll see two components. One gets bootstrapped and the second one is set to `OnPush`, so it should only run change detection when either one of its input properties changes, or an event is fired inside that component.
**Expectation**: OnPush Child Component should **not** turn green when the button is clicked, as no input properties are changing and no event is fired from inside the child component.
**UPDATE:** Similar to #7054 `ngAfterViewCheck()` is called, but change detection is **not** performed as we can see in this plunk: http://plnkr.co/edit/picW7fedYGY2PIPxp0Ur?p=preview
The subtree of `OnPush` component is not checked when we trigger CD.
| feature,area: core,core: change detection,feature: under consideration | high | Critical |
133,481,215 | flutter | ui.window.locale should be set on startup | Currently, it's not, which means we waste 16ms in every app with a MaterialApp because we spin an entire frame waiting for the locale to be set.
This requires some redundant pumps in tests, too.
| a: tests,framework,engine,f: material design,c: performance,a: internationalization,d: examples,P2,team-design,triaged-design | low | Minor |
133,552,588 | go | cmd/compile: recognize append loop | Loops with appends are common in Go. And often the loops have a fixed iteration count.
cmd/compile could recognize something of the form:
``` go
for ... := range x {
s = append(s, v)
}
```
And compile it as:
``` go
s = runtime_ensurecapacity(s, len(x))
for ... := range x {
s = append(s, v)
}
```
Likewise with `for i := 0; i < n; i++`.
That would remove the need for the (often premature) optimization of:
``` go
s := make([]T, 0, len(x))
```
And let people just write instead:
``` go
var s []T
for k := range m {
s = append(s, k)
}
```
This would also help eliminating garbage when the number of iterations is very large. (e.g. @campoy's https://news.ycombinator.com/item?id=11098802)
/cc @randall77 @dr2chase @rsc
| Performance,compiler/runtime | low | Major |
133,655,011 | opencv | solvePnP fails with perfect coordinates (and cvPOSIT passes) | I have found a set of parameters for which solvePnP does not give correct results although :
- the image points are perfect coordinates obtained with projectPoints applied to the objectPoints (no error at all in the image points)
- cvPOSIT is perfectly able to reconstruct the pose, when solvePnp seems not to be able to do so
solvePnp leads to a reprojection error of 8.94 pixels using SOLVEPNP_ITERATIVE, about 0.21 using P3P, and about 44 pixel when using other flags (DLS, EPNP and UPNP)
The reprojection error is zero only when using SOLVEPNP_ITERATIVE + useExtrinsicGuess = true (with initial rotation and translation set to zero) .
Please do look at the corresponding thread on the forum : http://answers.opencv.org/question/87546/solvepnp-fails-with-perfect-coordinates-and-cvposit-passes/
Note : as mentionned by Eduardo in the forum, SOLVEPNP_ITERATIVE returns a pose that is behind the camera when useExtrinsicGuess=false
| bug,category: calib3d,affected: 2.4,affected: 3.4 | low | Critical |
133,664,093 | go | x/mobile: gomobile bind unsupported seqType: string Array | when i'm trying to build aar library for undroid i have panic
panic: unsupported seqType: [100][100][2]string / *types.Array
Gomobile version:
gomobile version +002f07f Fri Feb 5 00:56:26 2016 +0000 (android);
androidSDK=/home/user/IDE_Android/adt-bundle-linux-x86_64-20130522/sdk/platforms/android-23
Go version:
go version go1.5.3 linux/amd64
func GetContent(dbPath string, rowCount int, columnCount int, selectedDate string) ([100][100][2]string){
| mobile | low | Minor |
133,754,547 | three.js | Proposal: Lets make EffectComposer "Stereo Aware" to simplify VR post effects | So I was trying my hand at stereo effects in ThreeJS and the first issue I ran into is that they are somewhat incompatible with EffectComposer. The issue is that the "effects" in the examples/js/effects directory are not actually possible to put into the EffectComposer. This was initially a little confusing to me. You can put examples/js/passes into the EffectComposer though (maybe it should have been called PassComposer?) but anyhow....
I think the solution is relatively straight forward. We could convert the examples/js/effects into Passes and push them through the effect composer pipeline. I've actually done this in my private branch of ThreeJS already last fall but I am unsure if is the best way, I did it in an expedient way... I'd like to get this back into ThreeJS proper now if you guys want it....
Here is how I did it:
1. I modified EffectComposer to optionally accept a StereoCamera as the main camera.
2. If the camera passed into EffectComposer is not a StereoCamera it behaves at it current does. Thus it is backwards compatible.
3. If you pass in a StereoCamera, things change, but only for passes that are "stereoAware". This is a flag on each pass that defaults to false if not set. If it is set, if the pass is "stereoAware", then the EffectComposer will call the Pass twice, once for each camera if the stereo rig and with the appropriate viewport settings (only half of the render target is rendered.)
That is it. It is very straight forward but powerful change.
A pass like RenderPass is stereo aware (stereoAware=true), it needs to generate different images for each camera. Other passes like a non-adaptive ToneMap are not stereo aware as it operates on each pixel in a simple matter. The rule generally is any Pass that uses a search area, such as FXAA, SMAA, Botek, SSAO should be stereo aware because otherwise there would be blending across central barrier.
Right now I make the assumption that StereoCamera splits the viewport into two even side-by-side renders. This seems to make sense to me, but maybe it isn't a valid assumption.
I am sure there are ways to further extend this design, but it does achieve what is minimally necessary, to unify Effects and Passes to make it easier to do high quality VR with ThreeJS.
I think this is a generally decent design and it is really simple to implement. I'd also suggest implementing a few new passes for this workflow, such as Lenticular (interleave), and Anagraph, which just engage in pixel re-arrangement. These could take the side-by-side renderings and turn them into new forms for output, thus all stereo effects could use the same pipeline -- thus we'd have simplicity and efficient of code.
This change should mostly gut the existing examples/js/effects in terms of rendering, the main thing we would need to keep is the particular StereoCamera setup code that is particular to each device.
| Suggestion,Post-processing | low | Major |
133,802,531 | java-design-patterns | Service Stub pattern | ### Description
The Service Stub design pattern is used to create a simplified version of a service that mimics the behavior of a real service in a controlled manner. This is especially useful during development and testing phases when the actual service might be unavailable or its usage might be costly or impractical. The stub can return predefined responses and simulate various scenarios to ensure the application behaves as expected.
#### Main Elements of the Pattern:
- **Stub Creation:** Develop a stub that implements the same interface as the real service.
- **Predefined Responses:** Configure the stub to return predefined responses based on input parameters.
- **Behavior Simulation:** Simulate various behaviors such as success, failure, and exceptions.
- **Seamless Replacement:** Ensure the stub can be seamlessly replaced with the real service with minimal changes to the application code.
### References
1. [Service Stub Pattern - Martin Fowler](http://martinfowler.com/eaaCatalog/serviceStub.html)
2. [Mock and Stub in Unit Testing](https://www.baeldung.com/mockito-vs-easymock-vs-jmockit)
3. [Java Design Patterns Wiki - Contribution Guidelines](https://github.com/iluwatar/java-design-patterns/wiki)
### Acceptance Criteria
1. Create a new package `service-stub` under the `patterns` directory.
2. Implement the service stub following the principles of the pattern, including predefined responses and behavior simulation.
3. Provide comprehensive unit tests to validate the stub's behavior in different scenarios.
4. Update the README with an explanation of the Service Stub pattern, including example usage and code snippets.
| info: help wanted,epic: pattern,type: feature,status: stale | low | Critical |
133,932,337 | java-design-patterns | Service Registry pattern | ## Description
The Service Registry design pattern is a central service registry that maintains a database of available services. It acts as a lookup mechanism, allowing services to register themselves and clients to discover services. This pattern is crucial for service-oriented architectures (SOA) and microservices, facilitating dynamic discovery and decoupling of service consumers and providers.
### Main Elements of the Pattern
1. **Service Registry**: A central database that holds the details of available services, such as their network locations and interfaces.
2. **Service Provider**: Registers its service with the service registry, providing metadata such as the service name, version, and network address.
3. **Service Consumer**: Queries the service registry to find services and obtain their metadata for consumption.
4. **Heartbeat Mechanism**: Ensures that the service registry has up-to-date information about the service availability through periodic heartbeat messages from the service providers.
### References
- [Service Registry Pattern - Microservices.io](https://microservices.io/patterns/service-registry.html)
- [Project Contribution Guidelines](https://github.com/iluwatar/java-design-patterns/wiki)
## Acceptance Criteria
1. Implement a basic service registry that can register services and allow querying for service details.
2. Include a heartbeat mechanism for service providers to periodically update their status in the registry.
3. Provide example implementations of a service provider registering itself and a service consumer querying the registry.
| info: help wanted,epic: pattern,type: feature | low | Major |
133,992,388 | youtube-dl | Convert MP4 files to video with chapters? | What is the easiest way to merge all of the downloaded videos into one single video file with chapters? Would there be a max size (duration) for the video? I'm currently pulling down Pluralsight courses and would like to use the name of each file for the chapters. The goal would be to include the video in iTunes and be able to skip backwards or forwards by chapter.
| request | low | Minor |
134,010,774 | TypeScript | Precedence in parsing types | It looks to me like this should parse, but it doesn't:
```
var x: number | (string)=>void;
```
It works with added parens:
```
var x: number | ((string)=>void);
```
But if the parser is not too hacky, then maybe it's easy to make the first work?
(FWIW, I ran into this in a rest argument, where it would be nice to avoid the extra parens in
```
function foo(...xs: (number | ()=>void)[]): void { }
```
)
| Help Wanted,Docs | low | Major |
134,061,264 | rust | HashSet operations against another HashSet should allow for differing hash algorithms | Operations such as `intersection` take a second `HashMap`. It's required that the second `HashMap` implement the same hashing algorithm as the first one:
``` rust
impl<T, S> HashSet<T, S>
where T: Eq + Hash,
S: HashState
{
fn intersection<'a>(&'a self, other: &'a HashSet<T, S>) -> Intersection<'a, T, S>;
}
```
This means that you cannot intersect a `HashMap<u8, SipHash>` against a `HashMap<u8, FnvHash>`. This seems overly restrictive.
/cc @bluss
| C-enhancement,T-libs-api | low | Minor |
134,225,920 | go | encoding/xml: support for xml:lang attribute | xml:lang is a standard attribute defined by the XML specification. Using it is complicated by the fact that an element inherits the nearest xml:lang declaration on itself or an ancestor. For example:
```
<document>
<foo xml:lang="en-GB">
<bar>This is in en-GB</bar>
</foo>
</document>
```
The element bar has an effective xml:lang value of "en-GB".
At the moment, an application wanting access to this information would need to consume an XML document token by token, and maintain its own stack of xml:lang attributes (or include an xml:lang attribute on all parent structs being unmarshalled, and process those). It would be nice if Decoder maintained this stack itself, and exposed it to structs being unmarshaled so that you could easily get the current effective xml:lang attribute.
There is code to do the above here:
https://code.blinkace.com/go/xml/commit/6dbed72bf9bec281c053aee80af76ac542a395c9
| NeedsInvestigation | low | Minor |
134,237,061 | go | x/mobile/exp/f32: LookAt uses column major order, but everything else seems to use row major (e.g. Translate) | I think it should be:
``` go
*m = Mat4{
{s[0], s[1], s[2], -s.Dot(eye)},
{u[0], u[1], u[2], -u.Dot(eye)},
{-f[0], -f[1], -f[2], +f.Dot(eye)},
{0, 0, 0, 1},
}
```
When sending model or projection matrix to shader using UniformMatrix4fv I need to transpose them to column major order. That's not the case for the view matrix created by LookAt.
Also Perspective() and LookAt() multiplication produces incorrect result, because of inconsistent matrix layout.
| mobile | low | Minor |
134,303,170 | youtube-dl | [letv]ERROR: unable to download video | ```
[c:\~]$ youtube-dl -v http://www.letv.com/ptv/vplay/2068007.html
[debug] System config: []
[debug] User config: []
[debug] Command-line args: [u'-v', u'http://www.letv.com/ptv/vplay/2068007.html']
[debug] Encodings: locale cp936, fs mbcs, out None, pref cp936
[debug] youtube-dl version 2016.02.13
[debug] Python version 2.7.11 - Windows-7-6.1.7601-SP1
[debug] exe versions: ffmpeg N-77197-gdf2ce13, ffprobe N-77197-gdf2ce13
[debug] Proxy map: {}
[Letv] 2068007: Downloading webpage
[Letv] 2068007: Downloading playJson data
[Letv] 2068007: Download JSON metadata for format 350
[Letv] 2068007: Downloading m3u8 information for format 350
[Letv] 2068007: Download JSON metadata for format 1000
[Letv] 2068007: Downloading m3u8 information for format 1000
[Letv] 2068007: Download JSON metadata for format 1300
[Letv] 2068007: Downloading m3u8 information for format 1300
[Letv] 2068007: Download JSON metadata for format 720p
[Letv] 2068007: Downloading m3u8 information for format 720p
[Letv] 2068007: Download JSON metadata for format 1080p
[Letv] 2068007: Downloading m3u8 information for format 1080p
[debug] Invoking downloader on u'data:application/vnd.apple.mpegurl;base64,I0VYVE0zVQ0KI0VYVC1YLVZFUlNJT0....(skip)...1FTkRMSVNUDQo='
[download] Destination: ๅนธ็ฆ้ๆฉ้ข02-2068007.mp4
[debug] ffmpeg command line: ffmpeg -y -i 'data:application/vnd.apple.mpegurl;base64,I0VYVE0zVQ0KI0VYVC1YLVZFU...(skip)...tlbj0NCiNFWFQtWC1FTkRMSVNUDQo=' -c copy -f mp4 -bsf:a aac_adtstoasc 'file:ๅนธ็ฆ้ๆฉ้ข02-2068007.mp4.part'
ERROR: unable to download video
Traceback (most recent call last):
File "c:\python27\lib\site-packages\youtube_dl\YoutubeDL.py", line 1692, in download
url, force_generic_extractor=self.params.get('force_generic_extractor', False))
File "c:\python27\lib\site-packages\youtube_dl\YoutubeDL.py", line 677, in extract_info
return self.process_ie_result(ie_result, download, extra_info)
File "c:\python27\lib\site-packages\youtube_dl\YoutubeDL.py", line 722, in process_ie_result
return self.process_video_result(ie_result, download=download)
File "c:\python27\lib\site-packages\youtube_dl\YoutubeDL.py", line 1362, in process_video_result
self.process_info(new_info)
File "c:\python27\lib\site-packages\youtube_dl\YoutubeDL.py", line 1629, in process_info
raise UnavailableVideoError(err)
UnavailableVideoError: [Error 206]
```
| bug,geo-restricted | low | Critical |
134,331,716 | rust | Implementation of traits on functions ignored after function call | In this example, I implement a trait on generic functions. One with mutability and one without. When invoked manually, the proper trait gets called. Instead, if I try to peel off the function's unique tag using another function, the traits are no longer visible.
Checked against: rustc 1.8.0-nightly (57c357d89 2016-02-16)
``` Rust
trait FooFn {
fn foo(&self);
}
impl<T: Sized> FooFn for fn(&mut T)-> T {
fn foo(&self) {
println!("Generic (with mutable) match!");
}
}
impl<T: Sized> FooFn for fn(T)->T {
fn foo(&self) {
println!("Generic match!");
}
}
fn simple_fn(x: i32) -> i32 { 1 }
fn simple_fn2(x: &mut i32) -> i32 { 2 }
fn strip<T, U>(x: fn(T)->U) -> fn(T)->U { x }
fn main() {
//Works
&(simple_fn as fn(i32)->i32).foo();
//Also works
&(simple_fn2 as fn(&mut i32)->i32).foo();
//Works
strip(simple_fn).foo();
//Error: no method named `foo` found for type `fn(&mut i32) -> i32`
strip(simple_fn2).foo();
}
```
| C-enhancement,A-diagnostics,A-trait-system,T-compiler,D-confusing | low | Critical |
134,442,958 | rust | "cannot move out of" error using `==` with `Box<Trait>`, where no move is needed | The following code has a compilation error, but it should be a valid program [(playground)](https://play.rust-lang.org/?gist=f39d36c50f0f54b8c3fd&version=nightly)
([Updated code in 2021 edition](https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=088ae790d8e2c2ce283918a344c8cf31))
``` rust
trait Trait { }
impl<T> Trait for T { }
impl<'a> PartialEq for Trait + 'a {
fn eq(&self, other: &Self) -> bool { false }
}
fn main() {
let x = Box::new(1) as Box<Trait>;
let equal = x == x;
}
```
```
<anon>:10:22: 10:23 error: cannot move out of `x` because it is borrowed [E0505]
<anon>:10 let equal = x == x;
^
<anon>:10:17: 10:18 note: borrow of `x` occurs here
<anon>:10 let equal = x == x;
^
```
- This only occurs for the reflexive (x == x) case.
- It doesn't actually compile into a move in `x == y`.
- Fat boxes like `Box<[T]>` don't behave like this
The error is the same when using this equality impl instead:
``` rust
impl<'a> PartialEq for Box<Trait + 'a> {
fn eq(&self, other: &Self) -> bool { false }
}
```
| A-type-system,A-borrow-checker,T-compiler,A-docs,C-bug,T-types,A-trait-objects | medium | Critical |
134,647,465 | vscode | Allow customization of mouse shortcuts | Some users would like to be able to customize not just pure keyboard shortcuts but also mouse + modifier ones. These are currently hard coded, for example <kbd>alt</kbd>+click to add a selection.
See https://github.com/Microsoft/vscode/issues/3091 for some more context.
| feature-request,keybindings | high | Critical |
134,684,971 | rust | Normalization fails with where clauses on methods | [This code](http://is.gd/nSF2lc) from @jroesch fails to compile:
``` rust
pub enum Mut {}
pub enum Imm {}
trait MutType<'v, T> {
type Output;
}
impl<'v, T: 'v> MutType<'v, T> for Mut {
type Output = &'v mut T;
}
impl<'v, T: 'v> MutType<'v, T> for Imm {
type Output = &'v T;
}
enum Lit {
Int(i32)
}
enum Expr {
Add(Box<Expr>, Box<Expr>),
Lit(Lit),
}
pub trait Visitor<'v, M> : Sized {
fn visit_expr(&mut self, expr: M::Output)
where M : MutType<'v, Expr>;
fn visit_lit(&mut self, lit: M::Output)
where M : MutType<'v, Lit>;
}
struct DummyV;
impl<'v> Visitor<'v, Imm> for DummyV {
fn visit_expr(&mut self, expr: &'v Expr) {
panic!()
}
fn visit_lit(&mut self, lit: &'v Lit) {
panic!()
}
}
fn main() {}
```
with the following error:
```
<anon>:38:5: 40:6 error: method `visit_expr` has an incompatible type for trait:
expected associated type,
found &-ptr [E0053]
<anon>:38 fn visit_expr(&mut self, expr: &'v Expr) {
<anon>:39 panic!()
<anon>:40 }
<anon>:38:5: 40:6 help: see the detailed explanation for E0053
<anon>:42:5: 44:6 error: method `visit_lit` has an incompatible type for trait:
expected associated type,
found &-ptr [E0053]
<anon>:42 fn visit_lit(&mut self, lit: &'v Lit) {
<anon>:43 panic!()
<anon>:44 }
<anon>:42:5: 44:6 help: see the detailed explanation for E0053
error: aborting due to 2 previous errors
playpen: application terminated with error code 101
Compilation failed.
```
but, I think, _ought_ to work. Looks like a problem where we normalize without having all the where clauses from the method available. Lazy normalization would probably fix it.
| A-trait-system,A-associated-items,T-compiler,C-bug,A-lazy-normalization | low | Critical |
134,834,140 | go | encoding/xml: proposed fixes for namespaces | Issue #13400 lists a number of issues related to namespace handling in encoding/xml. It's been noted that this area needs a bit of a rethink. This issue documents a set of proposed fixes to address the problems currently seen. I've grouped the current set of bugs into 7 separate topics to be addressed:
## 1. Lack of control over prefixes
Encoder currently provides no mechanism for the user to specify namespace/prefix bindings. In theory, this shouldn't matter: documents using different prefixes for the same namespaces are equivalent. In practice, people often do care.
For namespaced attributes, Encoder generates namespace prefixes based on the last part of the URI, and for elements, it redeclares the default namespace as required. This results in documents that are technically correct, but not what the user wants, and the generated prefixes may be cumbersome.
This raises the question of how much control we should give over prefixes.
XML allows quite a lot of complexity: prefixes can be rebound to different namespace URIs within a document, and the same namespace URI can simultaneously be bound to multiple prefixes. There's
a very old post on xml-dev that make a plea to produce "sane" documents, that is, ones where a given prefix is only ever used to refer to a single namespace URI, and a given namespace URI is only ever represented by a single prefix:
http://lists.xml.org/archives/xml-dev/200204/msg00170.html
I suggest that it is sufficient that we support the creation of "sane" documents, noting that we should allow a single URI to be represented by both a prefix and the default namespace within a document (this is effectively what Encoder does currently).
I think that the current approach of using the default namespace for elements, and generated prefixes for attributes is a good default: generated prefixes may be ugly, so we should use them only where needed (i.e. attributes), but should provide a mechanism for users to specify their own.
**Proposed approach:**
- Allow users to specify a map of "preferred prefixes" on Encoder, that obeys the "sane" constraints. e.g. Encoder.AddNamespaceBindings(map[string]string])
- When marshaling a namespaced attribute, use a preferred prefix, if available, and a generated one if not.
- When marshaling a namespaced element, use a preferred prefix if available, and the default namespace otherwise.
**Notes/questions:**
- The code changes required for this are pretty simple, although it does mean maintaining a notion of "preferred" and "generated" prefixes.
- We probably want to allow users to specify additional preferred prefixes during the marshaling process (see point 2). This raises a question of whether we want to enforce that the document is "sane" - a user could potentially specify different bindings for the same namespace in different subtrees, e.g.:
```
<foo>
<x:bar xmlns:x="blort" />
<y:baz xmlns:y="blort" />
</foo>
```
- Should preferred prefixes be output as soon as they're defined, or only when used? The former should probably be the default, but we might want to provide an option to control this, as it would allow the user to chuck a big bucket of "preferred prefixes" at the encoder, without bloating the document with unused prefixes
**Issues addressed:**
#11496: Serializing XML with namespace prefix
#9519: support for XML namespace prefixes
I think #9519 is based on a misunderstanding of how the current system works, but it seems likely that the user actually wants control over prefix names. I'm not sure if the reporter realises that a prefix is meaningless (and illegal) without a namespace URI binding.
## 2. Inability to access/set namespace declaration (handling QName values)
Namespace bindings are sometimes used by element and attribute values. For example:
```
<foo xmlns:a="bar">a:blort</foo>
```
In order to correctly understand "a:blort" you need to know the currently effective namespace bindings. The same problem exists in reverse when encoding: you need to make sure that necessary namespace declarations are in place in the document.
**Proposed approach:**
We need to allow Unmarshalers and Marshalers to obtain and insert namespace bindings respectively. This means:
1. A method on Decoder to expose current namespace bindings (trivial - it's already present privately)
2. A change to UnmarshalerXMLAttr, as this does't currently provide the decoder. The safe way to make this change would be to create a new interface (e.g. UnmarshalerXMLAttrWithDecoder).
3. Provide a method for Marshalers to inject namespace bindings. I suggest doing this by providing a method on Encoder to obtain a prefix for a namespace (GetPrefix ?), which will then take care of declaring the namespace if it hasn't yet been used. If the user cares what prefix they get, they should provide a preferred prefix prior to making the call to obtain one.
4. As a convenience, we should make XMLName a MarshalerXML/UnmarshalerXML
**Issues addressed:**
#12406: support QName values / expose namespace bindings
## 3. Specifying namespaces in tags is cumbersome
Currently namespaces for elements may only be specified by including the full namespace URI, e.g.:
```
`xml:"http://www.example.com/some/namespace/v1 foo"`
```
Aside from being verbose and repetitive, it means URIs can't be changed at runtime. It's not uncommon to want to use the same struct for different namespaces, for example, where version number in the namespace has changed, or as per #12624, to cope with documents using a subtlely
wrong namespace.
**Proposed solution:**
Given the mechanism in (1) to allow the user to specify namespaces/prefix mappings, it makes it possible for a struct to unambiguously use prefixes to reference namespaces. The obvious notation
is QName notation:
```
`xml:"nsv1:foo"`
```
Under this proposal it would be an error to use a prefix that hadn't been explicitly specified for the user (i.e. it won't use prefixes picked up from the document when decoding). Users might be surprised that the above wouldn't match the following document _unless_ they'd
explicitly set the prefix "nsv1" on the Decoder:
```
<nsv1:foo xmlns="...">bar</nsv1:foo>
```
but doing so would be inherently fragile, as it wouldn't work with the entirely equivalent:
```
<foo xmlns="...">bar</foo>
```
**Notes:**
This proposal changes the behaviour of Encoder/Decoder for tags with a colon in them, which it's possible that existing code relies on. On the other hand the current behaviour of such tags is clearly a source of confusion and bugs and doesn't work for Decoding anyway (see #11496)
**Issues addressed:**
#9775: Unmarshal does not properly handle NCName in XML namespaces
I think the bug as described is invalid: it's not clear what you'd expect to happen given that the namespace being used is undeclared.
#12624: brittle support for matching a namespace by identifier or url
The exact requirement behind this bug is not totally clear: it appears that the user wants unmarshaled elements that have one of a number of namespaces. I don't understand "Xmlns wasn't defined, but the namespace was used (ie. for mRSS with media namespace)" - that sounds like invalid
XML.
## 4. "No namespace" indistinguishable from "any namespace" in struct tags
When decoding, the tag `xml:"foo"` means element "foo" in any namespace. There's no way to say that you want foo in the null namespace. i.e.
```
<foo xmlns="" />
```
This is a problem if a namespaced sibling of the same localname also exists. #8535 demonstrates this quite clearly.
**Proposed approach:**
Introduce a way of explicitly referencing the null namespace, e.g.
```
`xml:"_ foo"`
```
We could go for the logical, but horribly subtle:
```
`xml:" foo"`
```
(note the space before foo)
**Issues addressed:**
#8535: failure to handle conflicting tags in different namespaces
#11724: namespaced and non-namespaced attributes conflict
## 5. Bug: default namespace not set to null on un-namespaced children
It's not currently possible to produce the following XML:
```
<a xmlns="b">
<c xmlns=""/>
</a>
```
If you produce `<c>` with a tag of:
```
`xml:"c"`
```
No xmlns declaration will be added, so `<c>` will inherit the namespace of it's parent `<a>`. This is related to issue (4): we don't currently distinguish between "any namespace" and "no namespace".
I can see two possible solutions here:
1. Treat `xml:"c"` as meaning "no namespace" and insert xmlns="" as required to make that so.
2. Treat `xml:"c"` as meaning "any namespace" and make it inherit the namespace of its parent. If you really want no namespace, use `xml:"_ c"` (or whatever notation we settle on for (4))
I can see arguments both ways.
**Issues addressed**
#7113: encoding/xml: missing nested namespace not handled
## 6. Bug: xmlns attributes not removed from Token (Decode/Encode not idempotent)
Decoder includes xmlns attributes in start element tokens. For example, an attribute of xmlns:foo="bar" would be included as an attribute with a name of {Space: "xmlns", Local: "foo"}. This is very dubious. xmlns attributes are special, but which ever way you look at it "xmlns" is not
a namespace URI - if anything, it's a prefix.
This creates problems if you feed the output of a Decoder into an Encoder, as it treats "xmlns" as a namespace URI, and introduces namespace declarations for it.
There's no good reason to include these attributes. It's reasonable to expose the current set of namespace bindings (see point 2), but the attributes themselves are not needed. If a user really wants to do their own namespace processing, they should use RawToken.
**Proposed solution:**
- xmlns and xmlns:foo attributes should be stripped from the list of attributes returned by Token. They should be retained on RawToken.
**Issues addressed:**
#7535 Encoder duplicates namespace tags
## 7. Specifying xmlns attributes manually: allow or disallow?
Should we allow users to manually insert xmlns:\* or xmlns="..." attributes?
#8167: disallow attributes named xmlns:*
#11431: encoding/xml: loss of xmlns= in encoding since Go 1.4
I don't think we need to support this, given the mechanism introduced under (1) and (3) above. One of the reasons why you might want to do it, is because namespace URIs are otherwise hard-coded into struct tags. The solution to (3) gives us a mechanism to avoid this.
That said, I'm struggling to see why we couldn't treat this as a call to add a preferred prefix - although there's a question of whether it should force the creation of the xmlns declaration if it's already in
scope.
## 8. Other issues
#11735: empty namespace conventions are badly documented
Yes, this should be clearer.
#8068: encoding/xml: empty namespace prefix definitions should be illegal
It sounds like this should be resolved as invalid.
| NeedsDecision,early-in-cycle | medium | Critical |
134,926,057 | flutter | Formatter for Flutter (or, tree-aware code) | dartfmt is a really great utility, but it doesn't know about code that is trying to represent a tree. Which, is what Flutter does a lot of :)
We would like an automatic formatter that knows that Flutter code has a lot of tree-like structures, and retains a formatting style that makes tree-like structures easy to read.
Ideally, we'd then use this formatter in our CLI and Atom tools.
| c: new feature,tool,P3,team-tool,triaged-tool | medium | Critical |
135,088,916 | rust | Windows paths should not be prefixed with \\?\ when displayed | That just turns this already confusing error into an insult:
```
kernel\std\std.rs:17:1: 17:46 error: found possibly newer version of crate `core` which `core_collections` depends on [E0460]
kernel\std\std.rs:17 extern crate collections as core_collections;
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
kernel\std\std.rs:17:1: 17:46 note: perhaps this crate needs to be recompiled?
kernel\std\std.rs:17 extern crate collections as core_collections;
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
kernel\std\std.rs:17:1: 17:46 note: crate `core` path #1: \\?\B:\Programmering\SandboxOS\AveryRust\build\sysroot\lib\rustlib\x86_64-avery-kernel\lib\libcore.rlib
kernel\std\std.rs:17:1: 17:46 note: crate `core_collections` path #1: \\?\B:\Programmering\SandboxOS\AveryRust\build\sysroot\lib\rustlib\x86_64-avery-kernel\lib\libcollections.rlib
```
| O-windows,I-needs-decision,C-bug,A-io | low | Critical |
135,100,702 | flutter | Support making Android Wear apps | - [ ] run on wear emulator
- [ ] determine if a screen is round or square
- [ ] easily set a wake lock (for Wear prototyping since timeout to ambient is aggressive at 6 seconds and we need more time)
| c: new feature,platform-android,framework,engine,customer: crowd,P3,team-android,triaged-android | high | Critical |
135,105,444 | TypeScript | Decorator Metdata: expose array element type | TSC 175, target ES6, Node 5.6
Sample class with decorated properties:
``` javascript
@sg.DMClass
export class User implements IUser {
@sg.DMProperty
firstName: string;
@sg.DMProperty
lastName: string;
@sg.DMProperty
friends: User[];
}
```
Property decorator:
``` javascript
export function DMProperty(target: any, key: string) {
var type = Reflect.getMetadata("design:type", target, key);
}
```
**Current behaviour:**
When the decorator gets called for property "friends", "type" is "Array" and the captured type ("User") is lost.
**Expected behaviour**
"type" should contain the captured type ("User"), too
Following very dirty work-around does the job: I modified tsc's method "emitSerializedTypeNode":
``` javascript
function emitSerializedTypeNode(node) {
if (node) {
console.log("*** emitSerializedTypeNode: node.kind: ", node.kind);
switch (node.kind) {
...
case 157:
// Begin dirty ---------------------------------------------------------------------------
var _elemType = node.elementType.typeName.text;
write("{name: 'Array<" + _elemType + ">', type:'Array', elemType:'" + _elemType + "'}");
console.log("*** emitSerializedTypeNode: Array, type: ", node.elementType.typeName.text);
// End dirty -----------------------------------------------------------------------------
return;
case 150:
...
```
Best
Mind
| Suggestion,Needs Proposal,Domain: Decorators | high | Critical |
135,113,012 | youtube-dl | [Site Support Request] huya.com | It's a chinese gaming stream website similiar to twitch.tv.
Example stream url: http://www.huya.com/499xiaoyu
livestream directory: http://www.huya.com/g/lol
| site-support-request | low | Minor |
135,135,783 | go | x/image/font: make it easier to measure a string's bounds and draw it in a bounding box | This issue applies to github.com/golang/freetype, if that is still under development.
I want to accomplish the following (superficially) easy tasks:
- Given a string and a fully specified font/context, determine the rendered string's bounds, taking into account ascenders, descenders, etc.; something along the lines of `NSString`'s `-sizeWithAttributes:` method.
- Given an appropriately sized rect, render a string in that rect, compensating for ascenders, descenders, etc; something like `NSString`'s `-drawInRect:withAttributes:` method.
I will use this to render a simple, short string into a texture of just the right size, and then upload that texture onto a window for use as a label at a particular origin.
`MeasureString` looks close, but it only provides the width, not the height. (And I don't see a way to get the line height / leading from a font.) And `DrawString` is close, but the dot's y offset is the baseline of the text, which I don't see a handy way to calculate.
The fact that these are top-level APIs in Cocoa suggests that these are common needs and that they cover a large portion of use cases. Maybe this should be handled with examples, or maybe with new fundamental APIs, or maybe with convenience APIs. I don't know enough to say.
/cc @nigeltao
| NeedsInvestigation | low | Minor |
135,185,953 | go | x/term: ReadPassword not supported on plan9 | x/crypto/ssh/terminal doesn't provide `terminal.ReadPassword` on plan9.
Related #13085
| OS-Plan9 | low | Minor |
135,218,463 | go | proposal: runtime/v2: rationalize runtime.Errors | Package runtime defines an Error interface for runtime errors and exactly one exported type that implements it: TypeAssertionError. But there are about a half dozen other panics in the runtime caused by programmer errors that are detected at runtime; things like "index out of range" and "divide by zero". Currently these are just string panics, which means they're inconsistent with TypeAssertionError and contain no detail about, for example, what the index was or what range it was out of. We should make these panics raise types that implement runtime.Error and carry actual details about the error.
This is a potentially breaking change, albeit a weak one, since programs can check the string returned by the Error() method to detect these panics (and since this is the only way to detect them right now, I suspect this happens in practice). We could introduce exported types for these panics without breaking compatibility, but can't add more information to their Error() message.
| v2,Proposal | low | Critical |
135,226,548 | opencv | OpenCV reduction based algorithms | Are you aware of any particular algorithms that would benefit from the work-group reduce add/min/max ? - maybe something SIMD oriented that would though require moderate thread communication / map-reduce type operation.
I'm working to improve the work-group reduce functions in a Linux OpenCL stack for GPGPUs. The work-group functions are briefly described here [1] - in short they enable add/min/max collaborative work between threads in the same work-group.
I'm looking at OpenCV as a source for real world problems that would benefit from the work-group reduce functions. This could also result in improvements to those algorithms.
Thank you
[1] https://software.intel.com/en-us/articles/using-opencl-20-work-group-functions
| category: ocl,category: t-api,RFC | low | Minor |
135,245,565 | nvm | Shorter URL for install script? | Can you add a gh-pages branch that with the download script? It would be nice to be able to just remember something like `curl -o- http://creationix.githubio/nvm|bash` than having to look up the install command each time. This is similar to [get-pip.py](https://bootstrap.pypa.io/get-pip.py) and other tools.
Since github pages doesn't allow for automatic redirection rules (like grabbing the latestThis script could also probable be made to fetch the [releases list](https://api.github.com/repos/creationix/nvm/releases) and use that to get the latest tag. This way it would never need to be updated. Maybe something like:
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/`curl -o- https://api.github.com/repos/creationix/nvm/releases -s| grep -m 1 tag_name|grep -oP 'v[\d\.]+'`/install.sh | bash
```
| feature requests,installing nvm | low | Major |
135,253,994 | go | cmd/link: support cgo internal linking on linux/mipsx, linux/mips64x | compiler/runtime | low | Minor |
|
135,281,022 | vscode | Custom peek widgets | LightTable and Swift allow for inline evaluation which also places the results in line with the particular line of source which was evaluated.
A new widget would be necessary for this. This widget would be able to hold values or arrays or plots with arrays and plots requiring expansion to be shown fully as to not clutter the editor. The widget would not be dismissed upon losing focus and multiple widgets are possible in the editor.
https://github.com/JunoLab/atom-ink and https://github.com/nteract/hydrogen are two examples of this done in atom.
Below are two example images from Juno which is based on LightTable.
| feature-request,api,webview,editor-insets,editor-api | high | Critical |
135,315,206 | go | x/sys/unix: missing flags support for Setxattr on freebsd. | Currently, flags parameter is ignored.
We can implement XATTR_CREATE and XATTR_REPLACE for this.
| help wanted,OS-FreeBSD,NeedsFix,compiler/runtime | low | Minor |
135,332,557 | rust | Closure return type not deduced from bounds if the type is wrapped. | In a tuple, for example:
``` rust
fn call<R, F: FnOnce() -> R>(f: F) -> R {
f()
}
fn main() {
let _: (&[i32],) = call(|| (&[],));
}
```
AFAICT, we don't deduce that `call::<$R, _>(|| (&[],)) expects (&[i32],)` implies `&[] expects &[i32]`, only `(&[],) expects $R`.
| A-inference,C-bug | low | Minor |
135,339,370 | kubernetes | Replication controller to re-schedule Pod in `ContainerCreating` and `ImageNotReady` status for a long time | I have meet an issue in my cluster described here https://github.com/kubernetes/kubernetes/issues/21656.
My question is, my Pod in a RC was scheduled to a node which docker CIDR already full. So the Pod stay in `ImageNotReady` status. Only after I delete the Pod manually by `kubectl delete pod`, the Pod got rescheduled to another node.
I think from RC perspective, some loop should take the responsibility on Pod status monitoring. If the Pod can not be `Running` for sometime, if the failure reason is not related with Pod itself, the RC should kill the Pod and reschedule to another node.
For example, if the Pod stays in `ContainerCreating` status for a long time which means something wrong with the node's docker, the Pod should be rescheduled.
| kind/bug,priority/important-soon,sig/scheduling,milestone/removed,lifecycle/frozen | low | Critical |
135,394,611 | rust | `-msvc` distribution has unused import libraries | Currently in the binary distributions for the `-msvc` packages, the `bin` folder has import libraries (`.dll.lib`) for all the DLLs there even though they are never linked to and could be removed to save some space.
| C-enhancement,O-windows-msvc,T-infra | low | Minor |
135,472,049 | go | encoding/xml: `,innerxml` makes light of namespaces. | See [the example](http://play.golang.org/p/KjOhmzacUc). The result is obviously not what we wish. We have no way we can obtain and recover the context, namely the prefix-namespace correspondence, where the fragment is extracted. I found xml.go naively accumulating input stream in `saved` while `,innerxml` is effective. The best solution is like the below:
```
buffer := new(bytes.Buffer)
encoder := xml.NewEncoder(buffer)
// ...
for {
token, err := Token()
// ...
encoder.EncodeToken(token)
}
// ...
encoder.Flush()
saveXMLData = buffer.Bytes()
```
Namespace-aware `,innerxml` is rather expensive, so we may as well have a new flag. Millions of extensible guys are eager for a politic decision.
| NeedsInvestigation | low | Minor |
135,486,498 | go | database/sql: common interface for query functions in sql.DB and sql.Tx | Hi,
I'm proposing a interface that implements all functions in `sql.DB` and `sql.Tx` that takes a `query string` as one of its arguments. This could be useful when implementing "dumb" functions that retrieves information but in itself dose not need to be prepared however might be used to verify whether to commit or rollback.
The interface I'm proposing is: (The name can of course be changed)
``` go
type QueryAble interface {
Exec(query string, args ...interface{}) (sql.Result, error)
Prepare(query string) (*sql.Stmt, error)
Query(query string, args ...interface{}) (*sql.Rows, error)
QueryRow(query string, args ...interface{}) *sql.Row
}
```
This is an example function `Get` that can be used with or without transactions.
``` go
func Get (q Queryable)(int){
var test int
res , _ := q.Query("SELECT COUNT(*) FROM table;")
res.Next()
res.Scan(&test)
res.Close()
return test
}
func GetExample(db *sql.DB){
//When you just want to retrieve the information, no need for a transaction
fmt.Printf("Current len of Table %d\n", Get(db))
//Make a change
tx, _ :=db.Begin()
// Add data to table
if Get(tx) > 2 {
fmt.Printf("Table to large: %d robacking to: %d \n", Get(tx) , Get(db))
tx.Rollback()
} else {
fmt.Printf("Table update new len %d\n", Get(tx))
tx.Commit()
}
}
```
| NeedsInvestigation | high | Critical |
135,671,388 | go | tour: Add tests for web crawler task | Context: https://tour.golang.org/concurrency/10
I think web crawler task is harder than it looks. I saw a lot of solutions and all of them are wrong, even the [official one](https://github.com/golang/tour/blob/master/solutions/webcrawler.go).
In order to prove that I have written [some tests](https://github.com/amorgun/go-tour-crawler) and script to run them on multiple solutions. You can see results [here](https://travis-ci.org/amorgun/go-tour-crawler/builds/111213009).
I suggest adding these tests to the task the same way as in the [word count task](https://tour.golang.org/moretypes/20).
| Documentation,help wanted,NeedsInvestigation | low | Major |
135,700,320 | youtube-dl | add support for LCP replay | LCP (aka La Chaรฎne Parlementaire) is the french national assembly TV channel.
It has a replay web site that doesn't seems to be handled by youtube-dl.
e.g. http://www.lcp.fr/emissions/transportez-moi
could youtube-dl support this web site ?
| site-support-request | low | Minor |
135,795,757 | vscode | [folding] Collapse ending brace to the same line | Consider a large JavaScript file
``` js
function a() {
...
}
function b() {
...
}
function c() {
...
}
and so on...
```
Collapsing all currently yields:
``` js
function a() { ...
}
function b() { ...
}
function c() { ...
}
and so on...
```
This would be more readable if the closing brace was on the same line:
``` js
function a() { ... }
function b() { ... }
function c() { ... }
and so on...
```
---
Here is how other prominent editors handle the above:
**Atom**
**Brackets**
**Sublime Text 3**
---
**VS Code**
| feature-request,editor-folding | high | Critical |
135,807,289 | rust | Tracking issue for specialization (RFC 1210) | This is a tracking issue for specialization (rust-lang/rfcs#1210).
Major implementation steps:
- [x] Land https://github.com/rust-lang/rust/pull/30652 =)
- [ ] Restrictions around lifetime dispatch (currently a **soundness hole**)
- [ ] `default impl` (https://github.com/rust-lang/rust/issues/37653)
- [ ] Integration with associated consts
- [ ] Bounds not always properly enforced (https://github.com/rust-lang/rust/issues/33017)
- [ ] Should we permit empty impls if parent has no `default` members? https://github.com/rust-lang/rust/issues/48444
- [ ] implement "always applicable" impls https://github.com/rust-lang/rust/issues/48538
- [ ] describe and test the precise cycle conditions around creating the specialization graph (see e.g. [this comment](https://github.com/rust-lang/rust/pull/70535#discussion_r401685535), which noted that we have some very careful logic here today)
Unresolved questions from the RFC:
- Should associated type be specializable at all?
- When should projection reveal a `default type`? Never during typeck? Or when monomorphic?
- Should default trait items be considered `default` (i.e. specializable)?
- Should we have `default impl` (where all items are `default`) or `partial impl` (where `default` is opt-in); see https://github.com/rust-lang/rust/issues/37653#issuecomment-616116577 for some relevant examples of where `default impl` is limiting.
- How should we deal with lifetime dispatchability?
Note that the `specialization` feature as implemented currently is *unsound*, which means that it can cause Undefined Behavior without `unsafe` code. [`min_specialization` avoids most of the pitfalls](https://github.com/rust-lang/rust/pull/68970).
---
Tracking issues have a tendency to become unmanageable. Please open a dedicated new issue and label it with F-specialization for absolutely any topics you want to discuss or have questions about. See https://github.com/rust-lang/compiler-team/issues/739 for details and discussions on this prospective policy. | A-trait-system,B-RFC-approved,T-lang,B-unstable,I-unsound,A-specialization,B-RFC-implemented,C-tracking-issue,requires-nightly,F-specialization,S-tracking-design-concerns | high | Critical |
135,881,553 | javascript | single return vs multiple returns | I see some examples of multiple returns but don't see any guidelines defined that say it explicitly.
Is there a preference between a single return where a variable is assigned the output value vs just having multiple return statements?
```
function isGood(battery) {
if (battery.charge) {
return true;
}
if (battery.cycles < 10) {
return true;
}
return false;
}
```
vs.
```
function isGood(battery) {
let out = false;
if (battery.charge) {
out = true;
}
if (battery.cycles < 10) {
out = true;
}
return out;
}
```
| question | medium | Major |
135,911,719 | rust | Allow linking against dylibs in LTO mode | I would like to build a binary that links against some crates using LTO and others dynamically. (Why? Because I have a dynamic library that contains all of LLVM and is 30MB, slowing down linking. Note that this is not LLVM's own dynamic library, it's a Rust crate compiled to dylib that itself links LLVM statically. One might imagine more generic use cases, e.g. LTOing small dependencies and dynamically linking large ones.) Here's a model:
`xa.rs`:
``` rust
#![crate_type = "bin"]
extern crate xb;
extern crate xc;
pub fn main() { xb::b(); xc::c(); }
```
`xb.rs`:
``` rust
#![crate_type = "rlib"]
pub fn b() {}
```
`xc.rs`:
``` rust
#![crate_type = "dylib"]
pub fn c() {}
```
This can be built successfully without LTO, albeit only if the dylib links libstd dynamically (otherwise you get "cannot satisfy dependencies so `std` only shows up once"):
```
rustc ../xc.rs -C prefer-dynamic -L. && rustc ../xb.rs -L. && rustc ../xa.rs -L.
```
The binary `xa` contains the code from `xa.rs` and `xb.rs` linked statically (but with a conventional linker rather than LTO), and dynamically links against `libxc.dylib` and libstd.
But if the last command includes `-C lto`, I just get:
```
error: could not find rlib for: `xc`
```
It would be nice if rustc supported this.
In principle support could also be added for combining LTO and non-LTO static linking, but that would require some method to identify which is desired, since both types refer to `.rlib` files.
| A-linkage,C-feature-request,-Cprefer-dynamic | low | Critical |
135,952,761 | go | net: TestCgoLookupIP fails on brillo | Reproducible on Qualcomm Dragonboard 410c, Brillo image built with BDK 7.5.4.
```
go_android_exec: adb shell mkdir -p /mnt/media_rw/tmp/net.test-55266
go_android_exec: adb push /var/folders/00/1b8h8000h01000cxqpysvccm005d21/T/go-build559449628/net/_test/net.test /mnt/media_rw/tmp/net.test-55266/net.test-55266-tmp
1358 KB/s (5223788 bytes in 3.754s)
go_android_exec: adb shell cp '/mnt/media_rw/tmp/net.test-55266/net.test-55266-tmp' '/mnt/media_rw/tmp/net.test-55266/net.test-55266'
go_android_exec: adb shell rm '/mnt/media_rw/tmp/net.test-55266/net.test-55266-tmp'
go_android_exec: adb shell export TMPDIR="/mnt/media_rw/tmp/net.test-55266"; export GOROOT="/mnt/media_rw/goroot/"; export GOPATH="/mnt/media_rw/gopath/"; cd "/mnt/media_rw/goroot/src/net"; '/mnt/media_rw/tmp/net.test-55266/net.test-55266' -test.short=true -test.timeout=6m0s; echo -n exitcode=$?
--- FAIL: TestCgoLookupIP (0.01s)
cgo_unix_test.go:19: lookup localhost: No address associated with hostname
cgo_unix_test.go:22: lookup localhost on [::1]:53: read udp [::1]:58014->[::1]:53: read: connection refused
FAIL
```
| Testing | low | Minor |
135,953,518 | go | syscall: TestLinuxDeathSignal fails on brillo | Reproducible on Qualcomm Dragonboard 410c, Brillo image built with BDK 7.5.4.
```
go_android_exec: adb shell mkdir -p /mnt/media_rw/tmp/syscall.test-55724
go_android_exec: adb push /var/folders/00/1b8h8000h01000cxqpysvccm005d21/T/go-build559449628/syscall/_test/syscall.test /mnt/media_rw/tmp/syscall.test-55724/syscall.test-55724-tmp
2842 KB/s (3472036 bytes in 1.192s)
go_android_exec: adb shell cp '/mnt/media_rw/tmp/syscall.test-55724/syscall.test-55724-tmp' '/mnt/media_rw/tmp/syscall.test-55724/syscall.test-55724'
go_android_exec: adb shell rm '/mnt/media_rw/tmp/syscall.test-55724/syscall.test-55724-tmp'
go_android_exec: adb shell export TMPDIR="/mnt/media_rw/tmp/syscall.test-55724"; export GOROOT="/mnt/media_rw/goroot/"; export GOPATH="/mnt/media_rw/gopath/"; cd "/mnt/media_rw/goroot/src/syscall"; '/mnt/media_rw/tmp/syscall.test-55724/syscall.test-55724' -test.short=true -test.timeout=6m0s; echo -n exitcode=$?
death signal parent error: fork/exec /mnt/media_rw/tmp/syscall.test-55724/TestDeathSignal002741875/syscall.test-55724: permission denied
--- FAIL: TestLinuxDeathSignal (0.12s)
syscall_linux_test.go:98: did not receive start from child, received "", EOF
FAIL
exitcode=1go_android_exec: adb shell rm -rf /mnt/media_rw/tmp/syscall.test-55724
FAIL syscall 2.616s
```
| compiler/runtime | low | Critical |
136,104,178 | TypeScript | noImplicitAny incorrectly permits 'any' when returned via arrow function | _Apologies for the vague title, I can't quite pin down the cause of this, hence the poor wording_
```
$ tsc --version
1.9.0-dev.20160208
```
The problem is best described using the following example:
``` typescript
// using --noImplicitAny
let a = undefined; // OK: error as expected: Variable 'a' implicitly has an 'any' type.
function mine<T>(meth: () => T): T {
return meth();
}
// **Problem**: x has type 'any' below
// Should be a compiler error
let x = mine(() => {
return undefined;
});
```
| Bug,Help Wanted | low | Critical |
136,124,084 | flutter | RenderBlockViewport should override debugAssertDoesMeetConstraints to verify intrinsics match itemExtent | If itemExtent is set, then the totalExtentCallback's return value should be an even multiple of the itemExtent.
| team,framework,P3,team-framework,triaged-framework | low | Critical |
136,144,985 | neovim | Implement :gui in at least a minimal form? | One of the main things keeping me from using neovim is that my workflow centers too heavily around starting with vim in a terminal, then using `:gui` to reclaim the terminal once I've determined whether I want to keep it around.
I was thinking about how one might implement `:gui` without forcing a GUI to be built into neovim and here's the best idea I came up with:
1. `:gui` causes nvim to relinquish the terminal and launch a configurable command with persistence of state achieved via some kind of command-line argument, either representing a socket or serialized into some sort of state identifier as used by the X Session Management Protocol.
2. The command is configured via `init.vim` with the default being something like `xterm -e nvim <state token>`.
(If you wanted to be smarter about it, there's an `xdg-terminal` companion to `xdg-open` which apparently just needs a little maintainership to graduate into being part of the `xdg-utils` tarballs.)
On my system, I'd probably set it to `screen nvim <state token>` since I use GNU screen to implement tabbing in my urxvt_kuake terminal.
If someone wanted a more traditional GUI, they could use something like `urxvt -name neovim -e nvim <state token>` or, with appropriate adjustments to neovim-qt, `nvim-qt <state token>`.
| enhancement,ui,server,ui-extensibility,remote | low | Minor |
136,170,752 | kubernetes | All controllers should raise events when they can't create objects as expected | This is coming from https://github.com/kubernetes/kubernetes/issues/21079#issuecomment-182967854:
All controllers should raise events when they can't create objects as expected (Pods, ReplicaSets, whatever), except when namespace deletion is in progress.
cc @piosz @mwielgus @jszczepkowski @madhusudancs @janetkuo @kargakis @mikedanese @erictune @bgrant0607
| priority/important-soon,area/controller-manager,sig/autoscaling,kind/feature,sig/apps,lifecycle/frozen | low | Major |
136,204,400 | vscode | [themes] Themes don't support background styling | .tmTheme files allow specification of background colors which don't seem to be supported, for example:
``` xml
<dict>
<key>name</key>
<string>Separator</string>
<key>scope</key>
<string>meta.separator</string>
<key>settings</key>
<dict>
<key>background</key>
<string>#E0E0E0</string>
<key>foreground</key>
<string>#373B41</string>
</dict>
</dict>
```
This is especially problematic for themes that attempt to invert background and use a similar foreground to the text view's background color (https://github.com/Microsoft/vscode/issues/2158)
| feature-request,debt,themes | high | Critical |
136,244,712 | kubernetes | Don't schedule all addons on the first node | This used to not happen but it does now. The following pods landed on the first node that became ready on kube-up (jenkins-e2e-minion-50tl):
```
14:28:59 Feb 23 14:28:53.406: INFO: downwardapi-volume-8c06635c-da7c-11e5-b51c-42010af01555 jenkins-e2e-minion-50tl Running [{Ready True 0001-01-01 00:00:00 +0000 UTC 2016-02-23 14:27:11 -0800 PST }]
14:28:59 Feb 23 14:28:53.406: INFO: nettest-fs46h jenkins-e2e-minion-50tl Running [{Ready True 0001-01-01 00:00:00 +0000 UTC 2016-02-23 14:28:51 -0800 PST }]
14:28:59 Feb 23 14:28:53.406: INFO: nodeport-test-mnxrw jenkins-e2e-minion-50tl Running [{Ready True 0001-01-01 00:00:00 +0000 UTC 2016-02-23 14:26:46 -0800 PST }]
14:28:59 Feb 23 14:28:53.406: INFO: service1-tihva jenkins-e2e-minion-50tl Running [{Ready True 0001-01-01 00:00:00 +0000 UTC 2016-02-23 14:27:08 -0800 PST }]
14:28:59 Feb 23 14:28:53.406: INFO: service2-sn40n jenkins-e2e-minion-50tl Running [{Ready True 0001-01-01 00:00:00 +0000 UTC 2016-02-23 14:27:30 -0800 PST }]
14:28:59 Feb 23 14:28:53.406: INFO: elasticsearch-logging-v1-0r22z jenkins-e2e-minion-50tl Running [{Ready True 0001-01-01 00:00:00 +0000 UTC 2016-02-23 14:25:40 -0800 PST }]
14:28:59 Feb 23 14:28:53.406: INFO: elasticsearch-logging-v1-9rbre jenkins-e2e-minion-50tl Running [{Ready True 0001-01-01 00:00:00 +0000 UTC 2016-02-23 14:25:40 -0800 PST }]
14:28:59 Feb 23 14:28:53.406: INFO: fluentd-elasticsearch-jenkins-e2e-minion-50tl jenkins-e2e-minion-50tl Running [{Ready True 0001-01-01 00:00:00 +0000 UTC 2016-02-23 14:25:39 -0800 PST }]
14:28:59 Feb 23 14:28:53.407: INFO: heapster-v14-g6e8b jenkins-e2e-minion-50tl Running [{Ready True 0001-01-01 00:00:00 +0000 UTC 2016-02-23 14:24:51 -0800 PST }]
14:28:59 Feb 23 14:28:53.407: INFO: kibana-logging-v1-omtbg jenkins-e2e-minion-50tl Running [{Ready True 0001-01-01 00:00:00 +0000 UTC 2016-02-23 14:26:02 -0800 PST }]
14:28:59 Feb 23 14:28:53.407: INFO: kube-dns-v10-jq6pf jenkins-e2e-minion-50tl Running [{Ready True 0001-01-01 00:00:00 +0000 UTC 2016-02-23 14:25:56 -0800 PST }]
14:28:59 Feb 23 14:28:53.407: INFO: kube-proxy-jenkins-e2e-minion-50tl jenkins-e2e-minion-50tl Running [{Ready True 0001-01-01 00:00:00 +0000 UTC 2016-02-23 14:24:03 -0800 PST }]
14:28:59 Feb 23 14:28:53.407: INFO: kubernetes-dashboard-v0.1.0-k1hi2 jenkins-e2e-minion-50tl Running [{Ready True 0001-01-01 00:00:00 +0000 UTC 2016-02-23 14:24:25 -0800 PST }]
14:28:59 Feb 23 14:28:53.407: INFO: l7-lb-controller-v0.5.2-cnntu jenkins-e2e-minion-50tl Running [{Ready True 0001-01-01 00:00:00 +0000 UTC 2016-02-23 14:25:47 -0800 PST }]
14:28:59 Feb 23 14:28:53.407: INFO: monitoring-influxdb-grafana-v3-rnb9q jenkins-e2e-minion-50tl Running [{Ready True 0001-01-01 00:00:00 +0000 UTC 2016-02-23 14:25:53 -0800 PST }]
```
Scheduler logs:
https://pantheon.corp.google.com/m/cloudstorage/b/kubernetes-jenkins/o/logs/kubernetes-e2e-gce/12147/artifacts/104.197.127.170%3A22-kube-scheduler.log
Test logs: http://kubekins.dls.corp.google.com/view/Critical%20Builds/job/kubernetes-e2e-gce/12147/consoleFull
I'm marking this kind/flake because it leads to a lot of unpredictablity during e2es from a single pod/node, I suspect some addons are bluffing about their limits (see https://github.com/kubernetes/kubernetes/issues/21820#issuecomment-188546116).
| sig/scheduling,lifecycle/frozen,needs-priority,needs-triage | medium | Critical |
136,291,660 | rust | Error to enable feature gate prevents error from incorrect placement of feature gate | Suppose I'm on nightly and I try to use gated syntax in a module (other than the crate root). As expected, I get an error:
```
feature_gated.rs:3:5: 3:10 error: box expression syntax is experimental; you can call `Box::new` instead. (see issue #27779)
feature_gated.rs:3 box 2;
^~~~~
feature_gated.rs:3:5: 3:10 help: add #![feature(box_syntax)] to the crate attributes to enable
```
An easy mistake to make is to misunderstand "crate attributes" and add the suggested feature attribute to the top of the current file instead. The problem is that if I do so, rustc doesn't tell me what I did wrong: it just seems to silently ignore the attribute.
In fact, there is a lint that triggers on the attribute:
```
feature_gated.rs:1:1: 1:24 warning: crate-level attribute should be in the root module, #[warn(unused_attributes)] on by default
feature_gated.rs:1 #![feature(box_syntax)]
```
...but it only shows up if I remove the gated syntax to allow compilation to proceed to that phase. This doesn't help someone stuck on the original error.
| A-diagnostics,A-stability,T-compiler,C-bug | low | Critical |
136,302,617 | youtube-dl | Support for mixcrate.com | Example url: http://www.mixcrate.com/kanyeasada/kiss-kiss-bang-bang-volume-4-10313280
Starting to play the song the mp3 source file is visible in the network manager so shouldn't be too big a task to parse?
| site-support-request | low | Minor |
136,336,234 | TypeScript | JSDoc property and memberof does not work in salsa | Since we cannot register intellisense by set a value directly. salsa should support `@memberof` or `@property` tag
It also useful for extension method, set a prototype like this cannot registered in intellisense
Which, I think we don't need automatic intellisense in case like this, but please provide some way we could write JSDoc to register custom member on intellisense | Suggestion,In Discussion,Domain: JSDoc,Domain: JavaScript | medium | Major |
136,464,460 | go | regexp: match additional Unicode properties | The [docs](https://golang.org/pkg/regexp/syntax/) (and [the RE2 docs](https://github.com/google/re2/wiki/Syntax)) describe how to match Unicode properties by using `\p{โฆ}` inside a character class:
> [snip]
>
> <table>
> <tr><td><code>[\p{Name}]</code></td><td>named Unicode property inside character class (โก <code>\p{Name}</code>)</td></tr>
> <tr><td><code>[^\p{Name}]</code></td><td>named Unicode property inside negated character class (โก <code>\P{Name}</code>)</td></tr>
> </table>
>
> [snip]
The current implementation doesn't seem to do it, though. The [code which matches `\p`](https://github.com/golang/go/blob/30f93f09944c54147bec9e5c39631f17addd94c7/src/regexp/syntax/parse.go#L1501) uses a single [`unicodeTable()`](https://github.com/golang/go/blob/30f93f09944c54147bec9e5c39631f17addd94c7/src/regexp/syntax/parse.go#L1442-L1454) helper function which only looks at `unicode.Categories` and `unicode.Scripts`. There probably needs to be a separate helper, or a flag passed to this one, which makes it look at properties.
| NeedsDecision,FeatureRequest,early-in-cycle | low | Major |
136,565,382 | go | tour: [confusing description of interfaces] | Context: https://tour.golang.org/methods/9
The text on the left reads
> A value of interface type can hold any value that implements those methods.
I'm not an advanced Go programmer and this is the first time I encounter this expression
> any value that implements those methods
in the Tour.
Because I don't find its semantics obvious, I'm interested in knowing whether I should the first quote along the lines of
> A value of interface type can hold any value whose type appears as the receiver of a method whose signature is listed in the interface type
In any case, could you please consider rephrasing the original expression so that it's clearer?
Thanks!
| NeedsInvestigation | low | Minor |
136,580,539 | go | cmd/link: include declared constants in DWARF | Currently the DWARF information does not include constant symbols (such as `const x = 1`). This can make debugging more difficult, as constants available to the program are not available in the debugger. It also causes problems for debugging helpers. For example, our own runtime-gdb.py GDB helper hard-codes the G status constant values. This list gets out of date and means we can't cull now-unused G statuses.
We should include constants in the DWARF information. DWARF has a DW_TAG_constant for exactly this. The DW_AT_const_value attribute can be a string or any constant form, including DW_FORM_sdata, which is encoded as a LEB128, so in principle it can store arbitrary precision integers (though I don't know how well this is supported in practice). It's not clear to me how to represent floating point constants, though I suspect we'd have to truncate them to 64-bit precision to get them to actually work (despite DWARF's dizzying array of numeric type encodings; scaled packed decimal anyone?).
Doing this would be difficult right now because the compiler would have to emit constants in a way the linker could consume to produce DWARF information. It would probably be relatively straightforward if we switched to producing DWARF directly in the compiler.
/cc @ribrdb @derekparker
| Debugging,compiler/runtime | low | Critical |
136,683,096 | opencv | Bad ORB descriptors match on Mac | I am doing some tests using ORB for both features detection and descriptors extraction on Windows and Mac. I get good results on Windows but the ones on Mac do not make any sense to me.
Here is a simple code snippet to reproduce the problem, I'm loading two example images found in openCV package
```
` // load images
cv::Mat img1 = cv::Mat(imread("./box.png", cv::IMREAD_GRAYSCALE));
cv::Mat img2 = cv::Mat(imread("./box_in_scene.png", cv::IMREAD_GRAYSCALE));
if (!img1.data || !img2.data) {
std::cout << " --(!) Error reading images " << std::endl; return -1;
}
// find key points
cv::Ptr<cv::ORB> orb;
orb = cv::ORB::create();
// img 1
std::vector<cv::KeyPoint> image1KeyPoints;
cv::Mat image1Descriptors;
try {
orb->detectAndCompute(img1, cv::Mat(), image1KeyPoints, image1Descriptors);
}
catch (const cv::Exception &ee) {
std::cout << " --(!) Error finding key points on image 1 " << ee.what() << std::endl; return;
}
std::cout << " --Found " << image1KeyPoints.size() << " key points on image 1 " << std::endl;
// img 2
std::vector<cv::KeyPoint> image2KeyPoints;
cv::Mat image2Descriptors;
try {
orb->detectAndCompute(img2, cv::Mat(), image2KeyPoints, image2Descriptors);
}
catch (const cv::Exception &ee) {
std::cout << " --(!) Error finding key points on image 2 " << ee.what() << std::endl; return;
}
std::cout << " --Found " << image2KeyPoints.size() << " key points on image 2 " << std::endl;
// find matching points
cv::BFMatcher matcher(cv::NORM_HAMMING, true);
std::vector<cv::DMatch> matches;
// return all matches
try {
matcher.match(image1Descriptors, image2Descriptors, matches);
}
catch (const cv::Exception &ee) {
std::cout << " --(!) Error matching points! " << ee.what() << std::endl; return;
}
// sort matches by distance
std::sort(matches.begin(), matches.end());
for(int i = 0; i < 10; i++) {
printf("%d MATCH dist %.4f\n", i, matches[i].distance);
}`
```
The output I get on Windows is
--Found 500 key points on image 1
--Found 500 key points on image 2
0 MATCH dist 18.0000
1 MATCH dist 23.0000
2 MATCH dist 23.0000
3 MATCH dist 28.0000
4 MATCH dist 31.0000
5 MATCH dist 31.0000
6 MATCH dist 33.0000
7 MATCH dist 33.0000
8 MATCH dist 34.0000
9 MATCH dist 34.0000
The output I get on Mac is
--Found 500 key points on image 1
--Found 500 key points on image 2
0 MATCH dist 3.0000
1 MATCH dist 3.0000
2 MATCH dist 7.0000
3 MATCH dist 7.0000
4 MATCH dist 9.0000
5 MATCH dist 9.0000
6 MATCH dist 10.0000
7 MATCH dist 10.0000
8 MATCH dist 11.0000
9 MATCH dist 11.0000
The distance between matches is completly different.
I'm doing this test on a Windows 7 machine with openCV lib compiled in 32 bit and on a Mac OS X 10.10.5 with openCV compiled in 32 bit.
| bug,category: features2d | low | Critical |
136,758,253 | go | gccgo: too many syntax errors for a simple mistake | Reduced from feedback I received from a student taking a class using Go.
The mistake in this program is the `int` in `for int i := 0`.
```
$ cat x.go
package p
func f() {
for int i := 0; i < n; i++ {
println(i)
}
}
```
The gc compiler and the go/parser both print two not terribly helpful syntax errors, but probably good enough:
```
$ go tool compile x.go
x.go:4: syntax error: unexpected name, expecting {
x.go:7: syntax error: unexpected }
$ gofmt x.go
x.go:4:10: expected '{', found 'IDENT' i
x.go:7:3: expected '}', found 'EOF'
```
Gccgo prints lots of errors:
```
$ gccgo x.go
x.go:4:10: error: expected โ{โ
for int i := 0; i < n; i++ {
^
x.go:4:10: error: expected โ;โ or โ}โ or newline
x.go:4:29: error: expected โ;โ or โ}โ or newline
for int i := 0; i < n; i++ {
^
x.go:7:1: error: expected declaration
}
^
x.go:4:18: error: reference to undefined name โiโ
for int i := 0; i < n; i++ {
^
x.go:4:22: error: reference to undefined name โnโ
for int i := 0; i < n; i++ {
^
x.go:4:25: error: reference to undefined name โiโ
for int i := 0; i < n; i++ {
^
x.go:4:6: error: expected boolean expression
for int i := 0; i < n; i++ {
^
x.go:4:6: error: invalid use of type
x.go:4:20: error: value computed is not used
for int i := 0; i < n; i++ {
^
```
It does seem a little excessive. I'm a bit surprised that gccgo tries to type-check a program with syntax errors at all.
/cc @ianlancetaylor @paranoiacblack
| NeedsInvestigation | low | Critical |
136,778,887 | opencv | UMat tests hang on Odroid | On an Ondroid XU4 board using OpenCL via T-API causes the function to never return, the program has to be stopped with Ctrl+C. The behavior is reproduced in the unit tests: if I run `bin/opencv_test_core --gtest_filter=UMat.*`, it gets stuck in `UMat.unmap_in_class` after printing "leave ProcessData()". I found that it only happens if the test is executed after `UMat.async_unmap`. Other tests that get stuck after it are `map_unmap_counting, mat_umat_sync, testTempObjects_Mat, testTempObjects_UMat, testWrongLifetime_Mat, testWrongLifetime_UMat`. The following tests from UMat.\* _don't_ get stuck: `BufferPoolGrowing, CopyToIfDeviceCopyIsObsolete, ReadBufferRect, setOpenCL, Sync, synchronization_map_unmap, SyncTemp`.
The OpenCL API from OpenCV 2.4 works without this problem.
The device is running under Ubuntu 15.04, GCC 4.9.2, this is what's printed before the test runs:
```
CTEST_FULL_OUTPUT
OpenCV version: 3.1.0
OpenCV VCS version: unknown
Build type: release
Parallel framework: tbb
CPU features:
OpenCL Platforms:
ARM Platform
iGPU: Mali-T628 (OpenCL 1.1 )
iGPU: Mali-T628 (OpenCL 1.1 )
Current OpenCL device:
Type = iGPU
Name = Mali-T628
Version = OpenCL 1.1
Compute units = 4
Max work group size = 256
Local memory size = 32 kB
Max memory allocation size = 497 MB 646 kB
Double support = Yes
Host unified memory = Yes
Has AMD Blas = No
Has AMD Fft = No
Preferred vector width char = 16
Preferred vector width short = 8
Preferred vector width int = 4
Preferred vector width long = 2
Preferred vector width float = 4
Preferred vector width double = 2
```
| bug,priority: low,category: ocl,category: t-api | low | Minor |
136,835,295 | opencv | Exception when using CUDA APIs after resume from suspension | With the curent OpenCV on the repository, an error occurs if the laptop is suspended and then resumed while a program using OpenCV is running. This error appears to happen when using CUDA APIs, and specifically in my case happens with the matcher in features2d module. Note that it doesn't happen when using the corresponding CPU function.
Possibly this it not necessarily a bug of OpenCV, but could be related with the suspension manager.
Below some more details about the configuration and error:
**system**
_OS: Ubuntu 14.04.4
OpenCV: from GitHub master fork (i.e., 3.1.0), SHA: 81f21e6e6cec209bffeab77934e5f4fad9cc1c23
built with the following flags_
`cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D WITH_TBB=ON -D BUILD_NEW_PYTHON_SUPPORT=ON -D WITH_V4L=ON -D INSTALL_C_EXAMPLES=ON -D INSTALL_PYTHON_EXAMPLES=ON -D BUILD_EXAMPLES=ON -D WITH_QT=ON -D WITH_OPENGL=ON -D ENABLE_FAST_MATH=1 -D CUDA_FAST_MATH=1 -D WITH_CUBLAS=1`
_Compiler: g++ 4.8.4-2ubuntu1~14.04.1
CUDA: 7.5_
**error thrown**
_OpenCV Error: Gpu API call (an illegal instruction was encountered) in call, file /home/alberto/lib/opencv/modules/cudev/include/opencv2/cudev/grid/detail/transform.hpp, line 273
terminate called after throwing an instance of 'cv::Exception'
what(): /home/alberto/lib/opencv/modules/cudev/include/opencv2/cudev/grid/detail/transform.hpp:273: error: (-217) an illegal instruction was encountered in function call_
| bug,category: gpu/cuda (contrib) | low | Critical |
136,939,693 | opencv | Linux build instructions, ffmpeg or libav | I would like to add to the linux install instructions the option to use ffmpeg instead of libav packages.
I am new to all of this, so please help me avoid doing something the wrong way.
I have my suggested changes to the corresponding doc file already in a forked repo, should I create a pull request?
| feature,category: documentation | low | Minor |
137,046,040 | youtube-dl | No keep audio option? (Target resault: video+audio file, audio only file) | At the moment, the "--keep-video" option saves both the video and audio files after they've been merged.
I would like the ability to save just the audio file with the merged file, producing the followings files:
Video+Audio (Merged) file
Audio file
Or am I blind and have missed the option somewhere?
| request | low | Minor |
137,111,426 | TypeScript | Allow subclass constructors without super() call | **TypeScript Version:**
1.8.0
**Code**
Custom element classes often have constructors that just return `document.createElement()`, since HTMLElement doesn't have a callable constructor, but this generates an error in TypeScript:
``` ts
class MyElement extends HTMLElement {
constructor() {
return document.createElement('my-element');
}
}
```
In general, it is completely valid ES2015 to not call `super()`, as long as you don't access `this`.
| Suggestion,Needs Proposal | medium | Critical |
137,124,713 | go | spec: clarification for the language used in the language specifications | Hi,
I'm not a native English speaker so please bare with me.
While looking at the documentation for https://golang.org/ref/spec#Integer_overflow I've realized that the sentence: `Loosely speaking, these unsigned integer operations discard high bits upon overflow, and programs may rely on "wrap around".` currently leaves room for interpretation.
I can read this as: for now one can assume the `wrap around` will happen but it might be changed in the future. Or I can read this as `wrap around` will always be present (in Go 1.x).
Then based on the discussion I've had on this topic, I've realized that there are other points as well in the language specifications which are ambiguous. For example `Implementation restriction: For compatibility with other tools, a compiler may disallow the NUL character (U+0000) in the source text.` sounds awful when you think of a limitation, `Implementation restriction`, and a `may`, optional, are involved. I've interpreted that as `[..] must disallow [..]` only because the sentence starts with `Implementation restriction` but someone else said `may` is not necessarily equivalent to `must` (and I can understand where that version comes from).
As there are 144 `may`s in the document, I think that some better description of what `may` or `must` or `may not`, in the same style that IETF RFCs always define what `must`, `must not`, `may` and so on represent. This would also help people that are used to RFCs but are not necessarily native English speakers. It would also people that write compilers, static analysis tools and end-users.
Thank you for your consideration.
| Documentation,NeedsInvestigation | low | Major |
137,226,738 | go | cmd/compile: coverage instrumentation for fuzzing | Go-fuzz (https://github.com/dvyukov/go-fuzz) is quite successful at finding bugs in Go code and reasonably widely used in Go community. However there are several problems with the current go-fuzz implementation that hinder wider adoption (in particular internal adoption at Google):
1. go-fuzz mimics go tool build logic, which leads to constant breakages.
2. go-fuzz-build does not handle cgo, and it is hard to implement.
3. coverage instrumentation is source-to-source, which makes it very difficult to integrate with other build systems.
4. source-to-source transformation can't handle all cases and has limited transformation capabilities (e.g. instrumenting && is tough). Some code patterns can be mishandled or lead to build failures.
5. source-to-source transformation produces slow code (lots of closures).
Ideally we have coverage instrumentation in compiler, and corresponding support in go tool. Something similar to -race flag, which triggers compiler instrumentation and adds race build tag.
| NeedsFix,FeatureRequest,compiler/runtime | high | Critical |
137,236,790 | vscode | Get selected file/folder in the explorer view | It would be nice if it was possible to retrieve the selected file/folder in the explorer view. The use case where I want to use it for is my `vscode-yo` extension to be able to run the generator in the selected directory. An API for this would be nice.
| feature-request,api,file-explorer | high | Critical |
137,287,126 | neovim | Consider removing netrw in favor of dirvish | Netrw is not bad but it shouldn't be the default file manager for this reasons:
- adds over 300 tags to help file
- has no sane method of updating when bundled by default (realistically an over 10 000 line plugin should be updateable easily)
- needs some additional plugins to behave reasonably (like vim-vinegar)
- has some (long standing) bugs
- no fresh github mirror for use with plugin managers
- slows down startup
On the plus side of netrw:
- very comprehensive file manager
- has insane nearly 4000 lines documentation file (although intimidating for most i think)
Dirvish:
- is lean
- not buggy
- does most commonly used features netrw + vinegar ootb
On minus sides:
- hooks into netrw commands? ie. doesnt offer its own :H and :Vexplore, etc if netrw isnt installed, although you can use `:e .` or `:sp .` etc.
- doesn't offer gx command
Afaik from my grepping it seems that the only thing that depends on this plugin is some spellchecking in `spell-SpellFileMissing`.
In the same vein vimball plugin should be dropped. From my testing after removing netrw on vanilla vim and cleaning help tags i can't see any breakage.
| runtime | medium | Critical |
137,393,454 | kubernetes | Preemption priority / scheme | We expect Kubelet to make more and more decision on which pods should run on a given node. For example,
- Reject pods on port conflict
- Reject incoming / evict existing pods when node constraints are violated.
- Reject incoming / evict existing pods in response to resource starvation, such as OOD, OOM, etc. (#147, #18724)
- ...
To really do that, Kubelet needs to know preemption priority / scheme, so that Kubelet knows which one(s) should be evicted, so that the most important pods run when resource demand exceeds supply. For example, daemonset pods should have higher priority than rest of pods, and kube-system pods might have a relatively higher priority too.
cc/ @bgrant0607 @davidopp
| priority/important-soon,area/api,sig/scheduling,sig/node,kind/feature,milestone/removed,lifecycle/frozen | high | Critical |
137,401,552 | thefuck | Change way of interaction with shells | I guess it would be nice to:
- put shell aliases in environment variable (`TF_SHELL_ALIASES`) in alias and get it from there, instead of calling shell from app (done for bash and zsh);
- move all writes to history to alias (done for bash and zsh).
It would speedup thefuck, and probably will fix #428, #422 and #402.
| help wanted | low | Minor |
137,447,611 | rust | It should be possible to override the dsymutil path | The compiler currently invokes `dsymutil` directly, but a cross compilation toolchain may have it located under a different name like `x86_64-apple-darwin15-dsymutil`. There should be a compiler flag to override it like there is for the linker.
| A-frontend,C-feature-request | low | Minor |
137,576,793 | You-Dont-Know-JS | "types & grammar": Pre-ES6 Number.isSafeInteger(..) polyfill - Number.MAX_SAFE_INTEGER is also introduced ES6 | In Chapter 2 of "types & grammar", the following polyfill is prescribed for `Number.isSafeInteger(..)`
> To polyfill Number.isSafeInteger(..) in pre-ES6 browsers:
>
> ```
> if (!Number.isSafeInteger) {
> Number.isSafeInteger = function(num) {
> return Number.isInteger( num ) &&
> Math.abs( num ) <= Number.MAX_SAFE_INTEGER;
> };
> }
> ```
Unless I'm mistaken, isn't Number.MAX_SAFE_INTEGER also an ES6 feature? Perhaps the code should rather be:
```
if (!Number.isSafeInteger) {
Number.isSafeInteger = function(num) {
return Number.isInteger( num ) &&
Math.abs( num ) <= (Math.pow( 2, 53 ) - 1)
};
}
```
| for second edition | low | Minor |
137,594,127 | TypeScript | allow decorators for functions | did a quick search, it looks like this hasn't been yet requested
currently decorators can only be added to classes, methods and properties
consider allowing them on functions too
| Suggestion,Domain: Decorators,Waiting for TC39 | high | Critical |
137,660,810 | youtube-dl | Support setproctitle on Mac OS X [was: Question: Any way for a shell script to check if youtube-dl is running?] | Hello, I've created an Applescript for personal use that works as a sort of wrapper around youtube-dl so I can download multiple videos quickly. I'm trying to modify it so that it won't download multiple videos at the same time.
In order to accomplish this, I need to check to see if the youtube-dl process is already running (and if so, wait until it finishes. I'm currently accomplishing this with the following shell script:
`ps -ax -o etime,command -c | grep python`
Which will return the empty string if python is not running. Since youtube-dl uses python, this can be used to approximate whether youtube-dl itself is running.
Of course, however, this causes problems if I run a program other than youtube-dl which depends on Python. Is there any way to check if youtube-dl itself is currently running? Thank you so much!
| request | low | Major |
137,685,779 | neovim | Softwrap at arbitrary boundary | - Neovim version: 0.1.2
- Operating system: Arch Linux
- Terminal emulator: Gnome Terminal
### Actual behaviour
Vim `:set wrap` has always soft-wrapped at the window border. Neovim follows this behavior
### Expected behaviour
I would be able to like to have a `:set wrapwidth=80` and have Neovim softwrap at the 80th column, even if the window is 120 characters wide.
### Steps to reproduce
1. `:set wrap`
2. Type a lot
3. Resize window (the wrap follows the window)
If this could be implemented I'd greatly appreciate it. I've found [this](https://stackoverflow.com/questions/989093/soft-wrap-at-80-characters-in-vim-in-window-of-arbitrary-width) stack overflow question about it but haven't found a solution that works when I have multiple windows open. If it were built into Neovim I think it would be nice.
A way to implement this would be an internal border feature where users could set an internal border for a window. If they could set the internal border such that the window is always 80 characters wide it would achieve the same thing. In my eyes this would work similarly to the Goyo plugin but instead of having a border around the whole view, each window could have it's own local border.
If I'm missing anything let me know. I've been looking to do this or a while but haven't found a way.
| enhancement,complexity:high,core | medium | Critical |
137,696,538 | flutter | Redirect "dart:io" stderr and stdout to adb (Android) and syslog (iOS) | Today we only redirect `print` (see https://github.com/flutter/engine/blob/master/sky/engine/bindings/dart_runtime_hooks.cc). We should also do this for stderr and stdout.
### Steps to Reproduce
- In your app `import 'dart:io';`
- Do `stdout.writeln('message')` or `stderr.writeln('message')`
- Run `flutter logs`
- Run your app using `flutter start` or run a test using `flutter drive`
- Observe that logs do not show any output
### Flutter Version
https://github.com/flutter/flutter/commit/7ee1ee31d16c3bcf0fcefbac283bfb50594b949f
/cc @johnmccutchan
| c: new feature,platform-android,platform-ios,framework,engine,dependency: dart,has reproducible steps,P3,dependency: dart:io,team-engine,triaged-engine,found in release: 3.16,found in release: 3.18 | low | Major |
137,711,441 | go | cmd/compile: SSA, don't re-copy spilled output parameters | ``` go
func f(a []int) (s int) {
for _, x := range a {
s += x
}
runtime.GC()
return
}
```
The SSA-generated code does this after runtime.GC():
```
MOVQ "".s+32(FP), BX
MOVQ BX, "".s+32(FP)
```
We should teach the compiler that it doesn't need to move the result to the output slot if was already spilled to the correct slot.
| Performance,compiler/runtime | low | Minor |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.