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 |
|---|---|---|---|---|---|---|
329,216,085 | flutter | FlutterHeadlessDartRunner should return an error on invalid launches. | Proposed API: `-[FlutterHeadlessDartRunner initWithProject:(FlutterDartProject*) project completion: (LaunchResult) result];`
with `typedef void(^LaunchResult)(NSError*);` | engine,P2,team-engine,triaged-engine | low | Critical |
329,319,911 | pytorch | GRU is implementation of GRU v1 draft rather than final GRU paper algo | GRU is implementation of v1 https://arxiv.org/pdf/1406.1078v1.pdf rather than final v3 https://arxiv.org/pdf/1406.1078.pdf
Concretely, in v1, the reset gate is applied to the result of applying a linear layer to the incoming state, equation 8:
<img width="287" alt="screen shot 2018-06-05 at 1 33 21 pm" src="https://user-images.githubusercontent.com/123560/40958883-108947ac-68c5-11e8-88b4-70ecda354f69.png">
... wheras the final v3 first applies the reset gate, and then passes through a linear layer:
<img width="301" alt="screen shot 2018-06-05 at 1 34 19 pm" src="https://user-images.githubusercontent.com/123560/40958904-2e6eb018-68c5-11e8-9ae3-01fed5319651.png">
A few minutes informal testing gave me better results on final v3 than draft v1. I imagine that pytorch is using v1 partly for execution speed, and partly because that's what cudnn uses:
https://docs.nvidia.com/deeplearning/sdk/cudnn-developer-guide/index.html#cudnnRNNMode_t
<img width="376" alt="screen shot 2018-06-05 at 1 36 22 pm" src="https://user-images.githubusercontent.com/123560/40958992-77e050e4-68c5-11e8-9813-ff9e2582cd34.png">
I'm not sure if that's a good reason though. I think it might be good to at least document that this approximation is being used?
| module: docs,module: rnn,triaged | low | Major |
329,344,276 | rust | to_lowercase only uses unconditional parts of unicode.org's special-casing | https://github.com/rust-lang/rust/blob/f9157f5b869fdb14308eaf6778d01ee3d0e1268a/src/libcore/unicode/unicode.py#L168-169
Since #25800, to_lowercase uses unicode.org's SpecialCasing.txt.
However, it only follows unconditional rules from this file. One "interesting" case is:
1. The main UnicodeData.txt file says that the lowercase of 'İ' (0130, Latin capital letter I with dot above) should be 'i' (0069, good-old boring ASCII Latin small letter i).
2. SpecialCasing.txt adds an unconditional rule that 'İ' (0130) should in fact be lowercased to 'i̇' (0069 Latin small letter i + 0307 combining dot above).
3. SpecialCasing.txt then adds a rule for tr (Turkish) and az (Azerbaijani) where 'İ' (0130) should now be lowercased to just 'i' (0069 Latin small letter i) -- There are other related rules, dotted-i's match and non-dotted-i's match too.
I think that (2) only makes sense when accompanied by (3): They are in the same file, touching the same character; (3) for tr/az and (2) for other languages.
But because only unconditional rules are handled, we end up with something hybrid that was intended for non-tr/az languages in contrast with tr/az, while ignoring the default language-independent specification from UnicodeData.txt.
I realize that it's quite a corner case, and open to interpretation.
Also, SpecialCasing.txt contains other useful unconditional rules that are worth having, so it would be unfortunate to lose those.
And (2) does have the advantage of making lowercasing reversible; though it's not a goal of unicode AFAIK.
So in the end, I'm not sure if&how this should be fixed -- other than implementing conditions, which would require handling languages.
A compromise would be to ignore this one rule, by hard-coding an exception.
This restriction could be made less arbitrary, by saying: Unconditional rules are only accepted for characters that do **not** also have conditional rules.
I understand if this won't be fixed, I at least wanted to bring attention to this case. | C-enhancement,A-Unicode,T-libs-api | low | Minor |
329,444,226 | go | cmd/compile: detect divisions that always result in 0 | Please answer these questions before submitting your issue. Thanks!
### What version of Go are you using (`go version`)?
go version devel +b7f3c178a3 Mon May 14 04:42:45 2018 +0000 darwin/amd64
### Does this issue reproduce with the latest release?
yes
### What operating system and processor architecture are you using (`go env`)?
darwin/amd64
### What did you do?
```
func f(p, q uint) uint {
return p + (q%6)/9
}
go run -gcflags=-S moddiv.go
```
### What did you expect to see?
Something akin to
```
"".f STEXT nosplit size=69 args=0x18 locals=0x0
0x0000 00000 (/Users/dfc/src/moddiv.go:5) TEXT "".f(SB), NOSPLIT, $0-24
0x0000 00000 (/Users/dfc/src/moddiv.go:5) FUNCDATA $0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
0x0000 00000 (/Users/dfc/src/moddiv.go:5) FUNCDATA $1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
0x0000 00000 (/Users/dfc/src/moddiv.go:6) MOVQ $-6148914691236517205, AX
0x000a 00010 (/Users/dfc/src/moddiv.go:6) MOVQ "".q+16(SP), CX
0x003f 00063 (/Users/dfc/src/moddiv.go:6) MOVQ CX, "".~r2+24(SP)
0x0044 00068 (/Users/dfc/src/moddiv.go:6) RET
```
### What did you see instead?
```
"".f STEXT nosplit size=69 args=0x18 locals=0x0
0x0000 00000 (/Users/dfc/src/moddiv.go:5) TEXT "".f(SB), NOSPLIT, $0-24
0x0000 00000 (/Users/dfc/src/moddiv.go:5) FUNCDATA $0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
0x0000 00000 (/Users/dfc/src/moddiv.go:5) FUNCDATA $1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
0x0000 00000 (/Users/dfc/src/moddiv.go:6) MOVQ $-6148914691236517205, AX
0x000a 00010 (/Users/dfc/src/moddiv.go:6) MOVQ "".q+16(SP), CX
0x000f 00015 (/Users/dfc/src/moddiv.go:6) MULQ CX
0x0012 00018 (/Users/dfc/src/moddiv.go:6) SHRQ $2, DX
0x0016 00022 (/Users/dfc/src/moddiv.go:6) LEAQ (DX)(DX*2), DX
0x001a 00026 (/Users/dfc/src/moddiv.go:6) SHLQ $1, DX
0x001d 00029 (/Users/dfc/src/moddiv.go:6) SUBQ DX, CX
0x0020 00032 (/Users/dfc/src/moddiv.go:6) MOVQ $-4099276460824344803, AX
0x002a 00042 (/Users/dfc/src/moddiv.go:6) MULQ CX
0x002d 00045 (/Users/dfc/src/moddiv.go:6) ADDQ DX, CX
0x0030 00048 (/Users/dfc/src/moddiv.go:6) RCRQ $1, CX
0x0033 00051 (/Users/dfc/src/moddiv.go:6) SHRQ $3, CX
0x0037 00055 (/Users/dfc/src/moddiv.go:6) MOVQ "".p+8(SP), DX
0x003c 00060 (/Users/dfc/src/moddiv.go:6) ADDQ DX, CX
0x003f 00063 (/Users/dfc/src/moddiv.go:6) MOVQ CX, "".~r2+24(SP)
0x0044 00068 (/Users/dfc/src/moddiv.go:6) RET
```
The value of q is in the range [0-6) because of the modulo, which divided by 9 is always 0. So the result of `f(x, y)` is always `x`
| Performance,NeedsDecision,compiler/runtime | low | Major |
329,461,314 | material-ui | [Menu] Support cascading / nested menu | Hello,
I wrote some two advanced components, who can handle Submenuitems.
I defined an anchorElement, which will be passed as property to the Mui Menu Component.
Is there a way to define where the Popup Element should be displayed? Because now it will just overlap. Maybe I want to calculate it more left or more right.
Here is an demo: https://codesandbox.io/s/9ywowy18k4
### Benchmark
- https://blueprintjs.com/docs/#core/components/menu
- https://reakit.io/docs/menu/#submenu
- https://www.telerik.com/kendo-react-ui/components/layout/menu/
- https://www.w3.org/TR/wai-aria-practices/examples/menubar/menubar-1/menubar-1.html
- https://ant.design/components/dropdown/#components-dropdown-demo-sub-menu | new feature,waiting for 👍,component: menu | high | Critical |
329,465,025 | TypeScript | Missing error when awaiting dynamic import of module with 'then' export | <!-- 🚨 STOP 🚨 𝗦𝗧𝗢𝗣 🚨 𝑺𝑻𝑶𝑷 🚨
Half of all issues filed here are duplicates, answered in the FAQ, or not appropriate for the bug tracker. Even if you think you've found a *bug*, please read the FAQ first, especially the Common "Bugs" That Aren't Bugs section!
Please help us by doing the following steps before logging an issue:
* Search: https://github.com/Microsoft/TypeScript/search?type=Issues
* Read the FAQ: https://github.com/Microsoft/TypeScript/wiki/FAQ
Please fill in the *entire* template below.
-->
<!-- Please try to reproduce the issue with `typescript@next`. It may have already been fixed. -->
**TypeScript Version:** 3.0.0-dev.20180605
<!-- Search terms you tried before logging this (so others can find this issue more easily) -->
**Search Terms:**
**Code**
```ts
// a.ts
export function then() { return true; }
// b.ts
async function test() {
await import('./a');
}
// c.ts
// this is basically the same as b.ts
import * as ns from './a';
function myImport() {
return Promise.resolve(ns);
}
async function test() {
await myImport();
}
```
**Expected behavior:**
in b.ts: `[ts] Type of 'await' operand must either be a valid promise or must not contain a callable 'then' member.`
This would catch a lot of bugs with dynamic imports of modules that contain a `then` function. The resulting Promise will never resolve: https://github.com/tc39/proposal-dynamic-import/issues/47
**Actual behavior:**
No error in `b.ts`. The resulting type of the `await` is `{}`.
**Playground Link:** <!-- A link to a TypeScript Playground "Share" link which demonstrates this behavior -->
**Related Issues:** <!-- Did you find other bugs that looked similar? -->
| Bug | low | Critical |
329,508,336 | rust | 'static lifetime elision in associated constants should mirror normal non-associated constants | https://play.rust-lang.org/?gist=8fb655fdb61666de91bd38bfedb537b6&version=stable&mode=debug
```rust
const A: &str = "A"; // defaults to 'static
trait Foo {
const S: &str; // should behave the same
}
impl Foo for () {
const S: &str = "bar";
}
fn main() {}
```
```
error[E0106]: missing lifetime specifier
--> src/main.rs:4:11
|
4 | const S: &str; // should behave the same
| ^ expected lifetime parameter
error[E0106]: missing lifetime specifier
--> src/main.rs:8:14
|
8 | const S: &str = "bar";
| ^ expected lifetime parameter
``` | A-lifetimes,A-associated-items,T-lang,C-feature-request,needs-rfc | low | Critical |
329,510,803 | go | proposal: tools for more readable stacktraces | As a Go beginner, I've benefitted a lot from using visual aides to assist reading dense panics and stacktraces. In particular, @maruel's [panicparse](https://github.com/maruel/panicparse) has been helpful for reading panics while I work (even though the information is basically the same). Example from the project's README:
This style of tool/output seems like it could be useful in the Go standard distribution; as a command line tool in the family of debugging tools, as a toggleable flag somewhere to pretty-print panics, or maybe as inspiration for some kind of dense tab-delimited panic format.
| Proposal,Proposal-Hold | medium | Critical |
329,519,978 | flutter | Open the persistent bottom sheet programmatically | Any way to do this? | framework,f: material design,d: api docs,P2,team-design,triaged-design | low | Minor |
329,610,105 | TypeScript | API: incorrect declarations in types.ts | The `--strictNullChecks` PR changed some declarations in `types.ts` to avoid frequent assertions in the compiler's code. Unfortunately these changes make it really unsafe for API users because they no longer contain the actually nullable types: https://github.com/Microsoft/TypeScript/pull/22088#discussion_r184149465 https://github.com/Microsoft/TypeScript/pull/22088#discussion_r184155027
* `ts.Node#parent` is no longer optional (which is definitely wrong for `SourceFile`)
* `ts.Symbol#declarations` and `ts.Symbol.valueDeclaration` are no longer optional, but can still be undefined
* `ts.Type#symbol` is no longer optional, but I guess this comment is still up to date: `// Symbol associated with type (if any)`
These changes should either be reverted or replaced in the published declaration files.
/cc @andy-ms @weswigham | Breaking Change,Help Wanted,Infrastructure | low | Major |
329,667,860 | go | x/build/maintner: new empty milestones are not detected | A new milestone with no issues does not show up in the corpus.
(Also, don't mind me while I use this issue to prime the corpus.) | Builders,NeedsInvestigation | low | Minor |
329,685,067 | TypeScript | Migration refactorings after renaming from `.js` to `.ts` files | At least week's design meeting, @sheetalkamat had the idea that we should consider applying refactorings for when you rename a `.js` file to a `.ts` file.
I think this is definitely worth experimenting with. From the refactoring pipeline, I could imagine things like
* moving from CommonJS to ES Modules
* lifting JSDoc annotations
* moving to classes
* inferring from usages
Then there's project configuration. I could see
* Generating a `tsconfig.json`
* Installing `@types` dependencies for packages that need them.
@mjbvz @amcasey | Suggestion,Needs Proposal,Awaiting More Feedback,Domain: Refactorings | low | Minor |
329,689,779 | TypeScript | Migration suggestions after *introducing* a .ts file | After I brought #24713 up with @chrisdias, he mentioned his thinking was more about the "I'm going to introduce a `.ts` file into a JS project" scenario. I think once you have some `.ts` files around a project, you're going to want to migrate the `.js` files eventually too, so both scenarios are valid.
But things we could do include
* Generating a `tsconfig.json`
* Installing `@types` dependencies for packages that need them.
@mjbvz @amcasey | Suggestion,Needs Proposal,Awaiting More Feedback | low | Minor |
329,691,027 | rust | Can't implement Drop on a type with a higher ranked lifetime as a trait bound. | Example:
```rust
trait Foo<'id> {}
struct Bar<T>(T) where T: for<'id> Foo<'id>;
impl<T> Drop for Bar<T> where T: for<'id> Foo<'id> {
fn drop(&mut self) {
}
}
fn main() {
}
```
We get the following error:
```backtrace
error[E0367]: The requirement `for<'id> T: Foo<'id>` is added only by the Drop impl.
--> src/main.rs:5:1
|
5 | / impl<T> Drop for Bar<T> where T: for<'id> Foo<'id> {
6 | | fn drop(&mut self) {
7 | | }
8 | | }
| |_^
|
note: The same requirement must be part of the struct/enum definition
--> src/main.rs:3:1
|
3 | struct Bar<T>(T) where T: for<'id> Foo<'id>;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
```
If you take the bound away from the `Drop` implementation, you still get an error saying the bound is missing. I don't *think* this should be unsound (you would always have to specialize on some particular lifetime to use any of the associated types, and in the use case I have in mind there's another equality constraint around that would prevent the lifetime from being used in the destructor) so I assume it's a bug, but I wasn't able to find any reported issue about this. | C-enhancement,A-trait-system,A-destructors,T-compiler,T-types,A-higher-ranked | low | Critical |
329,711,298 | pytorch | [Caffe2] Successive in-place operators cause RuntimeError of gradient operator versions | ## Issue description
Errors are reported when running a network with two successive in-place operators, e.g.
```
FC(x, y)-->ReLU(y, y)-->Dropout(y, y)
Conv(x, y)--> ReLU(y, y)-->UserDefinedInplaceOp(y, y)
```
The error (from the `FC-ReLU-Dropout` case) is as follows:
```
...
File "/home/<user_name>/repo/pytorch/build/caffe2/python/model_helper.py", line 335, in AddGradientOperators
self.grad_map = self.net.AddGradientOperators(*args, **kwargs)
File "/home/<user_name>/repo/pytorch/build/caffe2/python/core.py", line 1864, in AddGradientOperators
self._net.op[skip:], ys)
File "/home/<user_name>/repo/pytorch/build/caffe2/python/core.py", line 1126, in GetBackwardPass
return ir.GetBackwardPass(ys)
File "/home/<user_name>/repo/pytorch/build/caffe2/python/core.py", line 1001, in GetBackwardPass
forward_op_idx, all_input_to_grad)
File "/home/<user_name>/repo/pytorch/build/caffe2/python/core.py", line 955, in _GenerateGradientsForForwardOp
forward_op_idx, gradient_ops, g_output, g_input)
File "/home/<user_name>/repo/pytorch/build/caffe2/python/core.py", line 615, in BuildGradientGenerators
s, g_output, fwd_op_idx, locally_generated_blobs)
File "/home/<user_name>/repo/pytorch/build/caffe2/python/core.py", line 558, in CheckGradientOperatorInput
) + versionMismatchInfoOut(grad_op_input)
RuntimeError: Gradient operator needs output "gpu_0/fc6" at version 1, but currently we have version 2.
...
```
The problem can be solved if using a different output name for the last operator, e.g. changing from `y` to `z` as follows:
```
FC(x, y)-->ReLU(y, y)-->Dropout(y, z)
Conv(x, y)--> ReLU(y, y)-->UserDefinedInplaceOp(y, z)
```
But this seems a little weird. Note that in Caffe, it is OK to allow ReLU and Dropout to be both in-place operations.
I noticed that the gradient operator of Dropout does not allow in-place computation due to the trick used in generating a random mask. But for my `UserDefinedInplaceOp`, the gradient operator does support in-place gradient computation, which is also declared with `AllowInplace({{0, 0}})` in `OPERATOR_SCHEMA` for both the operator and the gradient operator. **So why does this problem happen? Does this mean one cannot use two consecutive in-place operators with Caffe2? If so, why? If not, what operators are allowed to use in such cases?**
The problem is also encountered in issue: https://github.com/caffe2/caffe2/issues/1017.
BTW, what is the parameter of `AllowInplace` exactly? I see explanations nowhere.
## Code example
One can try to add an in-place `Dropout` operator after the `FC-ReLU` in VGG-16 network and run it to reproduce the error.
## System Info
- PyTorch or Caffe2: **Caffe2**
- How you installed PyTorch (conda, pip, source): **source**
- Build command you used (if compiling from source):
- OS: **Ubuntu 16.04**
- PyTorch version: **(latest clone)**
- Python version: **Python 2.7.15 :: Anaconda, Inc.**
- CUDA/cuDNN version: **8.0/cudnn-8.0-linux-x64-v7**
- GPU models and configuration: **(Titan Xp)**
- GCC version (if compiling from source): **5.4.0**
- CMake version: **3.11.3**
- Versions of any other relevant libraries:
| caffe2 | low | Critical |
329,714,198 | vue | vdom: warn innerHTML not watch when the string have some escaped chars | ### Version
2.5.17-beta.0
### Reproduction link
[https://codepen.io/cxtom/pen/XYKgde](https://codepen.io/cxtom/pen/XYKgde)
### Steps to reproduce
1. using v-html and the string has \" \'
2. ssr
3. warn not match during hybrating in browser
### What is expected?
not warn The client-side rendered virtual DOM tree is not matching server-rendered content
### What is actually happening?
warn The client-side rendered virtual DOM tree is not matching server-rendered content.
<!-- generated by vue-issues. DO NOT REMOVE --> | improvement | medium | Minor |
329,783,517 | pytorch | error when import caffe2.python.onnx.backend | when i transform onnx to caffe2, i meet this problem <_>
import caffe2.python.onnx.backend
Segmentation fault (core dumped)
can someone help me, thank you very very much | caffe2 | low | Critical |
329,795,969 | rust | aobench hangs when compiled with -C target-cpu=native | I've ported ISPC ambient occlusion benchmark to use `std::simd` portable vector types here: https://github.com/gnzlbg/aobench
Running the binary with
```
cargo run --release -- 800 600 --algo vector
```
works fine. However, using:
```
RUSTFLAGS="-C target-cpu=native" cargo run --release -- 800 600 --algo vector
```
the binary hangs in `std::sys::unix::stack_overflow::imp::signal_handler::ha55d20b1873e8199`:
This happens on a MacBook Air (13-inch, Mid 2012) with a 1.8 GHz Intel Core i5. The following fails to compile
```
RUSTFLAGS="-C target-cpu=hawell" cargo run --release -- 800 600 --algo vector
```
and the following
```
RUSTFLAGS="-C target-cpu=help" cargo run --release -- 800 600 --algo vector
```
fails to compile with:
```
error: malformed cfg value or key/value pair: `Available CPUs for this target:`
```
(no cpus listed) | O-macos,I-hang | low | Critical |
329,828,743 | flutter | Android release build not working with disabled signing | Hi,
We want to disable the signing of the APK because we sign it on the build server.
Therefore we changed the build.gradle (from module app) to
```groovy
release {
signingConfig null
}
```
So far this works and the gradle build produces an unsigned APK. This APK is named _app-release-unsigned.apk_.
And this name is the problem, the flutter build exits then with the message
> Gradle build failed to produce an Android package
As far as we see, this is because the flutter build checks if an APK named _app-release.apk_ is created.
Our workaround is now to have the following build.gradle:
```groovy
release {
signingConfig null
applicationVariants.all { variant ->
variant.outputs.all { output ->
output.outputFileName = "app-release.apk"
}
}
}
```
Would be great when the android build could offer the possibility to produce an unsigned APK. For iOS this is already possible with the flag _--no-codesign_.
Regards,
Florian | c: new feature,tool,t: gradle,P2,team-tool,triaged-tool | low | Critical |
329,919,375 | go | encoding/xml: add support for xml version 1.1 |
### What version of Go are you using (`go version`)?
go 1.10.2
### Does this issue reproduce with the latest release?
n/a
### What operating system and processor architecture are you using (`go env`)?
GOHOSTARCH="amd64"
GOHOSTOS="darwin"
There are any plans to add support for XML version 1.1 in the "encoding/xml" lib?
thanks!
| NeedsInvestigation,FeatureRequest | medium | Critical |
329,929,828 | rust | Custom (synonym) suggestions for nonexistent methods | Currently if the user types a method that does not exist, a suggestion may be provided if what was typed is reasonably close to an existing method.
```rust
let set = ::std::collections::HashSet::new();
set.insrt(0u8); // = help: did you mean `insert`?
```
However, this only catches typos — completely different names aren't considered "close". I think it'd be helpful, especially for people coming from other languages (or switching between them frequently) to be able to specify custom suggestions for potential alternate names, so that something like the following works:
```rust
let set = ::std::collections::HashSet::new();
set.add(0u8); // = help: did you mean `insert`?
set.push(0u8); // = help: did you mean `insert`?
// etc.
``` | C-enhancement,A-diagnostics,T-compiler | low | Minor |
329,946,124 | kubernetes | Validation Tightening is not Generally Possible | I have made this comment on a few PRs so maybe it's time to document and/or build a mechanism.
You cannot generally make validation tighter, because any existing objects that violate the new rule will not be able to be updated, and in many cases, deleted (because deletions involving finalizers require a sequence of updates).
This is because, to validate updates, we validate BOTH the transition, AND the final state of the object. It's this last part that is problematic.
It should be possible to address this by adding a new class of validation function that ONLY gets called on new objects, but then we have these problems:
* When is it safe to promote the logic into the main validation function? There's no way to know.
* This solves the problem for apiserver, but not for any clients that were sending invalid objects. Especially automated clients will suddenly and without recourse be quite broken.
Even at version boundaries it's hard to tighten validation, since objects have to be round-trippable and there are still old objects in the system.
So, new API authors: start out with restrictive validation; it's easier to relax than to tighten.
Existing API authors: prepare to write defensive clients.
/kind bug
/sig api-machinery | kind/bug,sig/api-machinery,priority/important-longterm,lifecycle/frozen,wg/api-expression | medium | Critical |
329,981,537 | react-native | Set polyfill says it is [object Object] but should say [object Set] | ## Environment
Any - you can reproduce the issue using only file
https://github.com/facebook/react-native/blob/master/Libraries/vendor/core/Set.js
and any Javascript encironment.
EDIT: Just for the bot, it is completely irrelevant:
Environment:
OS: Windows 10
Node: 10.3.0
Yarn: Not Found
npm: 6.1.0
Watchman: Not Found
Xcode: N/A
Android Studio: Version 3.1.0.0 AI-173.4720617
Packages: (wanted => installed)
react: 16.3.1 => 16.3.1
react-native: 0.55.4 => 0.55.4
## Description and Steps to Reproduce
Here is code that creates a simple Set object and then uses the spread operator to spread the Set's contents into a new array.
First, using an environment where the above file was executed/loaded (plus its own dependencies), and I also short-circuited the detection at the beginning that determines whether the polyfill is applied:
```js
const s1 = new Set([1,2,3]);
console.log(Object.prototype.toString.call(s1));
```
Result:
```
[object Object]
```
## Expected Behavior
Now for comparison a clean ES6+ environment without anything loaded, so we get a native Set implementation:
```js
const s1 = new Set([1,2,3]);
console.log(Object.prototype.toString.call(s1));
```
Result:
```
[object Set]
```
| JavaScript,Priority: Low,Bug | low | Major |
329,991,967 | go | net/http: provide some Transport knob (bool?) to keep max 1 TLS dial in flight at once when discovering http2 support | Please answer these questions before submitting your issue. Thanks!
### What version of Go are you using (`go version`)?
go version go1.10.2 darwin/amd64
### Does this issue reproduce with the latest release?
Yes
### What operating system and processor architecture are you using (`go env`)?
Container Linux by CoreOS stable (1745.5.0)
### What did you do?
Attached NginX client replicates this issue. It requires some minimal reconfiguration for a test HTTP2 server. The client<->Nginx hop is HTTP2 and the NginX<->Service hop is HTTP1.1. This is a typical config. I've verified NginX is exposing an HTTP2 virtual server endpoint with the h2c utility.
Any HTTP2 client for an NginX HTTP2 reverse proxy should replicated this behavior.
NginX sets http2_max_concurrent_streams to 128 by default so it should accept the 3 concurrent streams in this test.
I've also included an equivalent HTTP2 client for http2.golang.org. httptrace reports this client does one TLS handshake per request; however, all three requests use the same connection.
So, for some reason not visible via httptrace, the client is multiplexing requests to a Go HTTP2 server; but, is not multiplexing requests to an NginX HTTP2 reverse proxy.
### What did you expect to see?
I expected to see the go http client multiplex these concurrent HTTP2 requests on a single HTTP2 connection to the NginX HTTP2 reverse proxy.
I expected that only one TLS handshake would be done.
### What did you see instead?
Instead of multiplexing these requests on one NginX reverse proxy connection, the client sends each request on a separate connection.
The duplicate TLS handshakes reported by httptrace for http2.golang.org don't make sense if all requests are using the same connection.
[nginx.conf.txt](https://github.com/golang/go/files/2077767/nginx.conf.txt)
[simSwitch.go.txt](https://github.com/golang/go/files/2077768/simSwitch.go.txt)
[http2client.go.txt](https://github.com/golang/go/files/2077769/http2client.go.txt)
[simSwitch-httptrace.txt](https://github.com/golang/go/files/2077770/simSwitch-httptrace.txt)
[http2client-httptrace.txt](https://github.com/golang/go/files/2077771/http2client-httptrace.txt)
| NeedsFix,FeatureRequest | low | Major |
330,015,524 | svelte | SVG baseVal | It turns out that this...
```js
rect.x.baseVal.value = 200;
```
...is faster than this:
```js
rect.setAttribute('x', 200);
```
This might be something we can use to our benefit. | feature request,perf,stale-bot,compiler,temp-stale | low | Major |
330,021,724 | rust | Method resolution for trait object types does not prefer inherent methods | Normally, inherent methods are given precedence over all trait methods, so that there is no ambiguity.
However, this behavior does not appear to be implemented for trait object types:
```rust
trait Foo {
fn f(&self) { }
}
impl Foo {
fn f(&self) { }
}
impl Foo for i32 { }
struct Bar;
impl Bar {
fn f(&self) { }
}
impl Foo for Bar { }
fn main() {
let x: &Foo = &42i32;
x.f();
let bar: &Bar = &Bar;
bar.f();
}
```
https://play.rust-lang.org/?gist=7d4534a5d973249c66244b9affa03199&version=stable&mode=debug
What's worse, UFCS does not allow for specifying that you want the inherent method, because `Foo::f(x)` in this code will remain ambiguous. In general, UFCS isn't designed to support disambiguating to inherent methods because inherent methods are supposed to always take precedence. | A-trait-system,T-lang,C-bug,T-types,A-trait-objects | low | Critical |
330,072,986 | rust | Great stack overflow error messages | As a coder
Given I have a fn main() { main() }
Then I expect the following output:
```
Exception in thread "main" java.lang.StackOverflowError
at X.main(X.java:3)
at X.main(X.java:3)
at X.main(X.java:3)
at X.main(X.java:3)
```
Obviously this is an example of how Java handles stack overflows, but you get the idea.
There didn't seem to be a tracking issue for this, so here is one.
(Some discussion here: https://users.rust-lang.org/t/how-to-diagnose-a-stack-overflow-issues-cause/17320/9 )
I've had a little look and I naively think we need to do something like this in sys_common/util.rs
```
#[allow(dead_code)] // stack overflow detection not enabled on all platforms
pub unsafe fn report_overflow() {
dumb_print(format_args!("\nthread '{}' has overflowed its stack\n",
thread::current().name().unwrap_or("<unknown>")));
#[cfg(feature = "backtrace")]
{
let log_backtrace = backtrace::log_enabled();
use sync::atomic::{AtomicBool, Ordering};
static FIRST_PANIC: AtomicBool = AtomicBool::new(true);
if let Some(format) = log_backtrace {
if let Ok(mut stderr) = Stderr::new() {
let _ = backtrace::print(&mut stderr, format);
}
} else if FIRST_PANIC.compare_and_swap(true, false, Ordering::SeqCst) {
dumb_print(format_args!("note: Run with `RUST_BACKTRACE=1` for a backtrace."));
}
}
}
```
Quite possibly one can ditch the first panic checks. I'm sure there's lots of concerns here, e.g. have we got enough stack headroom to report without going pop. | A-debuginfo,T-libs | medium | Critical |
330,078,193 | react | Consider removing Mobile Safari empty onclick hack | See https://github.com/facebook/react/issues/238 and https://github.com/facebook/react/pull/1536 for historical context.
Is that still relevant? The code is here:
https://github.com/facebook/react/blob/52fbe7612e0527b8c86decac519c344626f6bd72/packages/react-dom/src/client/ReactDOMFiberComponent.js#L244-L245
Even if it's relevant, can we just feature test it, and not do this hack on other browsers? Seems like a waste of memory for event handlers (even though the function is the same every time). | Component: DOM,Type: Needs Investigation,React Core Team | medium | Major |
330,099,501 | go | runtime: SIGSEGV when building on freebsd ARM | Trying to build go on freebsd-arm. I've tried both 1.10.2 and master branch from git. Both have the same issue.
I was able to bootstrap with go14 just fine, and the output of go env is
```
GOARCH="arm"
GOBIN=""
GOCHAR="5"
GOEXE=""
GOHOSTARCH="arm"
GOHOSTOS="freebsd"
GOOS="freebsd"
GOPATH=""
GORACE=""
GOROOT="/usr/local/go14"
GOTOOLDIR="/usr/local/go14/pkg/tool/freebsd_arm"
CC="/nxb-bin/usr/bin/cc"
GOGCCFLAGS="-fPIC -marm -pthread -fmessage-length=0"
CXX="g++"
CGO_ENABLED="1"
```
### What did you do?
I built a new jail on my freebsd 11.1 machine as follows
`poudriere jail -c -j 111armv6 -a arm.armv6 -x -m git -U https://github.com/freebsd/freebsd.git -v releng/11.1`
To build go I ran:
`poudriere bulk -j 111armv6 -i -v lang/go`
To further troubleshoot from inside the jail I ran make.bash directly via:
`GOROOT_BOOTSTRAP=/usr/local/go14 ./make.bash`
### What did you expect to see?
I expected it to build. And it does build if everything else is equal and all I do is make the jail amd64 instead of arm, everything is fine.
### What did you see instead?
Build output below. I've been able to reproduce this on both a physical server running freebsd 11.1 bare metal and also on a virtual machine.
```
Building Go cmd/dist using /usr/local/go14.
Building Go toolchain1 using /usr/local/go14.
Building Go bootstrap cmd/go (go_bootstrap) using Go toolchain1.
Building Go toolchain2 using go_bootstrap and Go toolchain1.
fatal error: unexpected signal during runtime execution
[signal SIGSEGV: segmentation violation code=0x0 addr=0x0 pc=0x3714c]
runtime stack:
runtime.throw(0x2ade9a, 0x2a)
/root/go/src/runtime/panic.go:589 +0x4c
runtime.sigpanic()
/root/go/src/runtime/signal_unix.go:374 +0x22c
runtime.netpollunblock(0x0, 0x77, 0x1, 0x0)
/root/go/src/runtime/netpoll.go:377 +0x14
runtime.netpollready(0x83fa10, 0x0, 0x77)
/root/go/src/runtime/netpoll.go:301 +0x74
runtime.netpoll(0x488600, 0x255bfa99)
/root/go/src/runtime/netpoll_kqueue.go:111 +0xc4
runtime.sysmon()
/root/go/src/runtime/proc.go:4375 +0x55c
runtime.mstart1()
/root/go/src/runtime/proc.go:1275 +0xbc
runtime.mstart()
/root/go/src/runtime/proc.go:1241 +0x60
goroutine 1 [semacquire]:
sync.runtime_Semacquire(0x874664)
/root/go/src/runtime/sema.go:56 +0x2c
sync.(*WaitGroup).Wait(0x874664)
/root/go/src/sync/waitgroup.go:130 +0x84
cmd/go/internal/work.(*Builder).Do(0x8ad620, 0xb55810)
/root/go/src/cmd/go/internal/work/exec.go:174 +0x304
cmd/go/internal/work.InstallPackages(0x80e078, 0x4, 0x5, 0x0)
/root/go/src/cmd/go/internal/work/build.go:481 +0x9e0
cmd/go/internal/work.runInstall(0x484f30, 0x80e078, 0x4, 0x5)
/root/go/src/cmd/go/internal/work/build.go:412 +0x38
main.main()
/root/go/src/cmd/go/main.go:140 +0x660
goroutine 4 [syscall]:
os/signal.signal_recv(0x0)
/root/go/src/runtime/sigqueue.go:139 +0x130
os/signal.loop()
/root/go/src/os/signal/signal_unix.go:23 +0x14
created by os/signal.init.0
/root/go/src/os/signal/signal_unix.go:29 +0x30
goroutine 8 [runnable]:
syscall.BytePtrFromString(0xa96030, 0x25, 0x3, 0x9720e0, 0x3)
/root/go/src/syscall/syscall.go:71 +0x80
syscall.SlicePtrFromStrings(0x8e8010, 0x2, 0x2, 0x0, 0x0, 0x4f86c, 0x822008, 0x2)
/root/go/src/syscall/exec_unix.go:87 +0x9c
syscall.forkExec(0xa96030, 0x25, 0x8e8010, 0x2, 0x2, 0xc934b0, 0x10, 0x0, 0x994040)
/root/go/src/syscall/exec_unix.go:155 +0xa4
syscall.StartProcess(0xa96030, 0x25, 0x8e8010, 0x2, 0x2, 0xc934b0, 0x2, 0x4, 0x0, 0x0)
/root/go/src/syscall/exec_unix.go:241 +0x44
os.startProcess(0xa96030, 0x25, 0x8e8010, 0x2, 0x2, 0xc93570, 0x9c0780, 0x2f, 0x2f)
/root/go/src/os/exec_posix.go:46 +0x144
os.StartProcess(0xa96030, 0x25, 0x8e8010, 0x2, 0x2, 0xc93570, 0x0, 0x0, 0x5f814)
/root/go/src/os/exec.go:102 +0x58
os/exec.(*Cmd).Start(0xb51080, 0x29f201, 0x91a060)
/root/go/src/os/exec/exec.go:381 +0x344
os/exec.(*Cmd).Run(0xb51080, 0x91a060, 0x91e000)
/root/go/src/os/exec/exec.go:304 +0x1c
cmd/go/internal/work.(*Builder).toolID(0x8ad620, 0x2a0569, 0x7, 0x2c, 0xbec974)
/root/go/src/cmd/go/internal/work/buildid.go:183 +0x240
cmd/go/internal/work.(*Builder).buildActionID(0x8ad620, 0xc41a20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)
/root/go/src/cmd/go/internal/work/exec.go:220 +0xb80
cmd/go/internal/work.(*Builder).build(0x8ad620, 0xc41a20, 0x0, 0x0)
/root/go/src/cmd/go/internal/work/exec.go:328 +0x37f8
cmd/go/internal/work.(*Builder).Do.func1(0xc41a20)
/root/go/src/cmd/go/internal/work/exec.go:107 +0x58
cmd/go/internal/work.(*Builder).Do.func2(0x874664, 0x8ad620, 0x8e08a0)
/root/go/src/cmd/go/internal/work/exec.go:165 +0x84
created by cmd/go/internal/work.(*Builder).Do
/root/go/src/cmd/go/internal/work/exec.go:152 +0x2e4
goroutine 9 [runnable]:
syscall.forkExecPipe(0xc59420, 0x2, 0x2, 0xb9c000, 0x30)
/root/go/src/syscall/forkpipe2.go:9 +0x50
syscall.forkExec(0xade000, 0x25, 0xb16010, 0x2, 0x2, 0xc594b0, 0x10, 0x0, 0x8e2110)
/root/go/src/syscall/exec_unix.go:189 +0x1b8
syscall.StartProcess(0xade000, 0x25, 0xb16010, 0x2, 0x2, 0xc594b0, 0x2, 0x4, 0x0, 0x0)
/root/go/src/syscall/exec_unix.go:241 +0x44
os.startProcess(0xade000, 0x25, 0xb16010, 0x2, 0x2, 0xc59570, 0x92e480, 0x2f, 0x2f)
/root/go/src/os/exec_posix.go:46 +0x144
os.StartProcess(0xade000, 0x25, 0xb16010, 0x2, 0x2, 0xc59570, 0x0, 0x0, 0x5f814)
/root/go/src/os/exec.go:102 +0x58
os/exec.(*Cmd).Start(0xc40580, 0x29f201, 0xa86060)
/root/go/src/os/exec/exec.go:381 +0x344
os/exec.(*Cmd).Run(0xc40580, 0xa86060, 0x92e180)
/root/go/src/os/exec/exec.go:304 +0x1c
cmd/go/internal/work.(*Builder).toolID(0x8ad620, 0x2a0569, 0x7, 0x2c, 0xb38974)
/root/go/src/cmd/go/internal/work/buildid.go:183 +0x240
cmd/go/internal/work.(*Builder).buildActionID(0x8ad620, 0xc41080, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)
/root/go/src/cmd/go/internal/work/exec.go:220 +0xb80
cmd/go/internal/work.(*Builder).build(0x8ad620, 0xc41080, 0x0, 0x0)
/root/go/src/cmd/go/internal/work/exec.go:328 +0x37f8
cmd/go/internal/work.(*Builder).Do.func1(0xc41080)
/root/go/src/cmd/go/internal/work/exec.go:107 +0x58
cmd/go/internal/work.(*Builder).Do.func2(0x874664, 0x8ad620, 0x8e08a0)
/root/go/src/cmd/go/internal/work/exec.go:165 +0x84
created by cmd/go/internal/work.(*Builder).Do
/root/go/src/cmd/go/internal/work/exec.go:152 +0x2e4
goroutine 10 [runnable]:
os.startProcess(0xa78060, 0x25, 0xc6e010, 0x2, 0x2, 0xa0b570, 0x956480, 0x2f, 0x2f)
/root/go/src/os/exec_posix.go:43 +0xf4
os.StartProcess(0xa78060, 0x25, 0xc6e010, 0x2, 0x2, 0xa0b570, 0x0, 0x0, 0x5f814)
/root/go/src/os/exec.go:102 +0x58
os/exec.(*Cmd).Start(0xbc2e70, 0x29f201, 0x8ac2a0)
/root/go/src/os/exec/exec.go:381 +0x344
os/exec.(*Cmd).Run(0xbc2e70, 0x8ac2a0, 0x956180)
/root/go/src/os/exec/exec.go:304 +0x1c
cmd/go/internal/work.(*Builder).toolID(0x8ad620, 0x2a0569, 0x7, 0x2c, 0xb66974)
/root/go/src/cmd/go/internal/work/buildid.go:183 +0x240
cmd/go/internal/work.(*Builder).buildActionID(0x8ad620, 0xc418c0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)
/root/go/src/cmd/go/internal/work/exec.go:220 +0xb80
cmd/go/internal/work.(*Builder).build(0x8ad620, 0xc418c0, 0x0, 0x0)
/root/go/src/cmd/go/internal/work/exec.go:328 +0x37f8
cmd/go/internal/work.(*Builder).Do.func1(0xc418c0)
/root/go/src/cmd/go/internal/work/exec.go:107 +0x58
cmd/go/internal/work.(*Builder).Do.func2(0x874664, 0x8ad620, 0x8e08a0)
/root/go/src/cmd/go/internal/work/exec.go:165 +0x84
created by cmd/go/internal/work.(*Builder).Do
/root/go/src/cmd/go/internal/work/exec.go:152 +0x2e4
goroutine 11 [runnable]:
syscall.SetNonblock(0x1a, 0x2c3a00, 0x9400c0, 0x4)
/root/go/src/syscall/exec_unix.go:98 +0x98
internal/poll.(*FD).SetBlocking(0x9400c0, 0x0, 0x0)
/root/go/src/internal/poll/fd_unix.go:128 +0x80
os.(*File).Fd(0xbe2050, 0x0)
/root/go/src/os/file_unix.go:70 +0x44
os.startProcess(0xa08030, 0x25, 0xcde010, 0x2, 0x2, 0x899570, 0x94e600, 0x2f, 0x2f)
/root/go/src/os/exec_posix.go:43 +0xb8
os.StartProcess(0xa08030, 0x25, 0xcde010, 0x2, 0x2, 0x899570, 0x0, 0x0, 0x5f814)
/root/go/src/os/exec.go:102 +0x58
os/exec.(*Cmd).Start(0x9ec8f0, 0x29f201, 0x9e8060)
/root/go/src/os/exec/exec.go:381 +0x344
os/exec.(*Cmd).Run(0x9ec8f0, 0x9e8060, 0x94e300)
/root/go/src/os/exec/exec.go:304 +0x1c
cmd/go/internal/work.(*Builder).toolID(0x8ad620, 0x2a0569, 0x7, 0x2c, 0xb3c974)
/root/go/src/cmd/go/internal/work/buildid.go:183 +0x240
cmd/go/internal/work.(*Builder).buildActionID(0x8ad620, 0xb52630, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)
/root/go/src/cmd/go/internal/work/exec.go:220 +0xb80
cmd/go/internal/work.(*Builder).build(0x8ad620, 0xb52630, 0x0, 0x0)
/root/go/src/cmd/go/internal/work/exec.go:328 +0x37f8
cmd/go/internal/work.(*Builder).Do.func1(0xb52630)
/root/go/src/cmd/go/internal/work/exec.go:107 +0x58
cmd/go/internal/work.(*Builder).Do.func2(0x874664, 0x8ad620, 0x8e08a0)
/root/go/src/cmd/go/internal/work/exec.go:165 +0x84
created by cmd/go/internal/work.(*Builder).Do
/root/go/src/cmd/go/internal/work/exec.go:152 +0x2e4
goroutine 12 [runnable]:
sync.runtime_canSpin(0x0, 0x0)
/root/go/src/runtime/proc.go:5050 +0x64
sync.(*Mutex).Lock(0x498678)
/root/go/src/sync/mutex.go:89 +0x2c0
sync.(*RWMutex).Lock(0x498678)
/root/go/src/sync/rwmutex.go:93 +0x20
syscall.forkExec(0x8f42a0, 0x25, 0x972030, 0x2, 0x2, 0xa0f4b0, 0x10, 0x0, 0xb18040)
/root/go/src/syscall/exec_unix.go:186 +0x1a0
syscall.StartProcess(0x8f42a0, 0x25, 0x972030, 0x2, 0x2, 0xa0f4b0, 0x2, 0x4, 0x0, 0x0)
/root/go/src/syscall/exec_unix.go:241 +0x44
os.startProcess(0x8f42a0, 0x25, 0x972030, 0x2, 0x2, 0xa0f570, 0x91ec00, 0x2f, 0x2f)
/root/go/src/os/exec_posix.go:46 +0x144
os.StartProcess(0x8f42a0, 0x25, 0x972030, 0x2, 0x2, 0xa0f570, 0x0, 0x0, 0x5f814)
/root/go/src/os/exec.go:102 +0x58
os/exec.(*Cmd).Start(0xb53d90, 0x29f201, 0xa5e060)
/root/go/src/os/exec/exec.go:381 +0x344
os/exec.(*Cmd).Run(0xb53d90, 0xa5e060, 0x9c0480)
/root/go/src/os/exec/exec.go:304 +0x1c
cmd/go/internal/work.(*Builder).toolID(0x8ad620, 0x2a0569, 0x7, 0x2c, 0xbe8974)
/root/go/src/cmd/go/internal/work/buildid.go:183 +0x240
cmd/go/internal/work.(*Builder).buildActionID(0x8ad620, 0xbc0b00, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)
/root/go/src/cmd/go/internal/work/exec.go:220 +0xb80
cmd/go/internal/work.(*Builder).build(0x8ad620, 0xbc0b00, 0x0, 0x0)
/root/go/src/cmd/go/internal/work/exec.go:328 +0x37f8
cmd/go/internal/work.(*Builder).Do.func1(0xbc0b00)
/root/go/src/cmd/go/internal/work/exec.go:107 +0x58
cmd/go/internal/work.(*Builder).Do.func2(0x874664, 0x8ad620, 0x8e08a0)
/root/go/src/cmd/go/internal/work/exec.go:165 +0x84
created by cmd/go/internal/work.(*Builder).Do
/root/go/src/cmd/go/internal/work/exec.go:152 +0x2e4
goroutine 13 [runnable]:
syscall.BytePtrFromString(0x8f0030, 0x25, 0xca3e5201, 0xb, 0x8015e0)
/root/go/src/syscall/syscall.go:71 +0x80
syscall.forkExec(0x8f0030, 0x25, 0xb88010, 0x2, 0x2, 0xc554b0, 0x10, 0x0, 0xa88040)
/root/go/src/syscall/exec_unix.go:151 +0x70
syscall.StartProcess(0x8f0030, 0x25, 0xb88010, 0x2, 0x2, 0xc554b0, 0x2, 0x4, 0x0, 0x0)
/root/go/src/syscall/exec_unix.go:241 +0x44
os.startProcess(0x8f0030, 0x25, 0xb88010, 0x2, 0x2, 0xc55570, 0x93ea80, 0x2f, 0x2f)
/root/go/src/os/exec_posix.go:46 +0x144
os.StartProcess(0x8f0030, 0x25, 0xb88010, 0x2, 0x2, 0xc55570, 0x0, 0x0, 0x5f814)
/root/go/src/os/exec.go:102 +0x58
os/exec.(*Cmd).Start(0xc088f0, 0x29f201, 0x9fe060)
/root/go/src/os/exec/exec.go:381 +0x344
os/exec.(*Cmd).Run(0xc088f0, 0x9fe060, 0x93e000)
/root/go/src/os/exec/exec.go:304 +0x1c
cmd/go/internal/work.(*Builder).toolID(0x8ad620, 0x2a0569, 0x7, 0x2c, 0xbcc974)
/root/go/src/cmd/go/internal/work/buildid.go:183 +0x240
cmd/go/internal/work.(*Builder).buildActionID(0x8ad620, 0xc40c60, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)
/root/go/src/cmd/go/internal/work/exec.go:220 +0xb80
cmd/go/internal/work.(*Builder).build(0x8ad620, 0xc40c60, 0x0, 0x0)
/root/go/src/cmd/go/internal/work/exec.go:328 +0x37f8
cmd/go/internal/work.(*Builder).Do.func1(0xc40c60)
/root/go/src/cmd/go/internal/work/exec.go:107 +0x58
cmd/go/internal/work.(*Builder).Do.func2(0x874664, 0x8ad620, 0x8e08a0)
/root/go/src/cmd/go/internal/work/exec.go:165 +0x84
created by cmd/go/internal/work.(*Builder).Do
/root/go/src/cmd/go/internal/work/exec.go:152 +0x2e4
goroutine 14 [runnable]:
os.(*File).Fd(0xa6e078, 0x14)
/root/go/src/os/file_unix.go:59 +0x60
os.startProcess(0xb60030, 0x25, 0x8ca020, 0x2, 0x2, 0xcab570, 0x9d6300, 0x2f, 0x2f)
/root/go/src/os/exec_posix.go:43 +0xb8
os.StartProcess(0xb60030, 0x25, 0x8ca020, 0x2, 0x2, 0xcab570, 0x0, 0x0, 0x5f814)
/root/go/src/os/exec.go:102 +0x58
os/exec.(*Cmd).Start(0xb55600, 0x29f201, 0xa70060)
/root/go/src/os/exec/exec.go:381 +0x344
os/exec.(*Cmd).Run(0xb55600, 0xa70060, 0x9d6000)
/root/go/src/os/exec/exec.go:304 +0x1c
cmd/go/internal/work.(*Builder).toolID(0x8ad620, 0x2a0569, 0x7, 0x2c, 0xbd0974)
/root/go/src/cmd/go/internal/work/buildid.go:183 +0x240
cmd/go/internal/work.(*Builder).buildActionID(0x8ad620, 0xc40a50, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)
/root/go/src/cmd/go/internal/work/exec.go:220 +0xb80
cmd/go/internal/work.(*Builder).build(0x8ad620, 0xc40a50, 0x0, 0x0)
/root/go/src/cmd/go/internal/work/exec.go:328 +0x37f8
cmd/go/internal/work.(*Builder).Do.func1(0xc40a50)
/root/go/src/cmd/go/internal/work/exec.go:107 +0x58
cmd/go/internal/work.(*Builder).Do.func2(0x874664, 0x8ad620, 0x8e08a0)
/root/go/src/cmd/go/internal/work/exec.go:165 +0x84
created by cmd/go/internal/work.(*Builder).Do
/root/go/src/cmd/go/internal/work/exec.go:152 +0x2e4
goroutine 15 [runnable]:
syscall.SlicePtrFromStrings(0x938480, 0x2f, 0x2f, 0x8e0930, 0x3, 0x3, 0x0, 0x0)
/root/go/src/syscall/exec_unix.go:85 +0x2c
syscall.forkExec(0xc52360, 0x25, 0x8e08c0, 0x2, 0x2, 0xca54b0, 0x10, 0x0, 0x874820)
/root/go/src/syscall/exec_unix.go:159 +0xec
syscall.StartProcess(0xc52360, 0x25, 0x8e08c0, 0x2, 0x2, 0xca54b0, 0x2, 0x4, 0x0, 0x0)
/root/go/src/syscall/exec_unix.go:241 +0x44
os.startProcess(0xc52360, 0x25, 0x8e08c0, 0x2, 0x2, 0xca5570, 0x938480, 0x2f, 0x2f)
/root/go/src/os/exec_posix.go:46 +0x144
os.StartProcess(0xc52360, 0x25, 0x8e08c0, 0x2, 0x2, 0xca5570, 0x0, 0x0, 0x5f814)
/root/go/src/os/exec.go:102 +0x58
os/exec.(*Cmd).Start(0x9bba20, 0x29f201, 0x946060)
/root/go/src/os/exec/exec.go:381 +0x344
os/exec.(*Cmd).Run(0x9bba20, 0x946060, 0x938000)
/root/go/src/os/exec/exec.go:304 +0x1c
cmd/go/internal/work.(*Builder).toolID(0x8ad620, 0x2a0569, 0x7, 0x2c, 0xb6a974)
/root/go/src/cmd/go/internal/work/buildid.go:183 +0x240
cmd/go/internal/work.(*Builder).buildActionID(0x8ad620, 0xc41340, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0)
/root/go/src/cmd/go/internal/work/exec.go:220 +0xb80
cmd/go/internal/work.(*Builder).build(0x8ad620, 0xc41340, 0x0, 0x0)
/root/go/src/cmd/go/internal/work/exec.go:328 +0x37f8
cmd/go/internal/work.(*Builder).Do.func1(0xc41340)
/root/go/src/cmd/go/internal/work/exec.go:107 +0x58
cmd/go/internal/work.(*Builder).Do.func2(0x874664, 0x8ad620, 0x8e08a0)
/root/go/src/cmd/go/internal/work/exec.go:165 +0x84
created by cmd/go/internal/work.(*Builder).Do
/root/go/src/cmd/go/internal/work/exec.go:152 +0x2e4
go tool dist: FAILED: /root/go/pkg/tool/freebsd_arm/go_bootstrap install -gcflags=all= -ldflags=all= -i cmd/asm cmd/cgo cmd/compile cmd/link: exit status 2
#
```
| OS-FreeBSD,NeedsInvestigation,compiler/runtime | medium | Critical |
330,122,651 | godot | gui events don't propagate to parent control nodes | **Godot version:** 3.0.2
**Issue description:**
From the docs, regarding event propagation:
"Second, it will try to feed the input to the GUI, and see if any control can receive it. If so, the Control will be called via the virtual function Control._gui_input() and the signal “input_event” will be emitted (this function is re-implementable by script by inheriting from it). If the control wants to “consume” the event, it will call Control.accept_event() and the event will not spread any more. **Events that are not consumed will propagate up, to Control’s ancestors.**"
from http://docs.godotengine.org/en/3.0/tutorials/inputs/inputevent.html?highlight=input%20events
I interpreted this to mean that if a Control subclass node does not handle the event, the parent of that node would then be able to accept that event through it's own `_gui_input` method. However, that doesn't seem to be the case. Only the control that has focus will get the `_gui_input` call.
Am I misunderstanding what that line means? | bug,confirmed,topic:gui | low | Major |
330,129,222 | TypeScript | json files should be usable in .d.ts files without breaking things | <!-- 🚨 STOP 🚨 𝗦𝗧𝗢𝗣 🚨 𝑺𝑻𝑶𝑷 🚨
Half of all issues filed here are duplicates, answered in the FAQ, or not appropriate for the bug tracker. Please read the FAQ first, especially the "Common Feature Requests" section.
-->
## Search Terms
<!-- List of keywords you searched for before creating this issue. Write them down here so that others can find this suggestion more easily -->
resolveJsonModule import definition
## Suggestion
<!-- A summary of what you'd like to see added or changed -->
As a .json file is a static resource, it should be able to be referenced in a global.d.ts file for example without that file being automatically treated as a module. The reason for this is that a .json file may be used to simply enforce valid translation keys, and you shouldn't need to suck the whole .json file into the transpilation process to do that.
## Use Cases
<!--
What do you want to use this for?
What shortcomings exist with current approaches?
-->
Example:
```
import translations from "../assets/translations/en-AU.json"
type $translate = {
instant: (translationKey: keyof typeof translations) => string,
use: Function,
proposedLanguage: Function
}
```
The downside of the current method again is that the translations file is output in the transpilation process, which is wasteful if the file is large.
What the above code snippet is trying to achieve, should be allowed in a .d.ts file without breaking global declaration functionality.
## Checklist
My suggestion meets these guidelines:
* [x] This wouldn't be a breaking change in existing TypeScript / JavaScript code
* [x] This wouldn't change the runtime behavior of existing JavaScript code
* [x] This could be implemented without emitting different JS based on the types of the expressions
* [x] This isn't a runtime feature (e.g. new expression-level syntax)
| Suggestion,Awaiting More Feedback | low | Critical |
330,185,181 | TypeScript | JSDoc comment for destructuring param: description text not displayed | **TypeScript Version:**
2.9
**Search Terms:**
JSDoc destructuring param
**Code**
```javascript
/**
* @param {Object} arg
* @param {number} arg.id - This param description won't show up
*/
function foo({ id }) {}
```
**Expected behavior:**
In VSCode 1.24.0, when typing `foo(`, IntelliSense should display the full param description, including its type and text.
**Actual behavior:**
The type is displayed ("number"), but not the text ("This param description won't show up"):
**Related Issues:**
https://github.com/Microsoft/TypeScript/issues/19645
**Additional remark**
When omitting the {Object} line, the param text shows up correctly:
| Bug,Help Wanted,Domain: JSDoc | medium | Critical |
330,237,153 | rust | The run-pass/issue-36856.rs fails on beta for mips{el}-linux-gnu | The test starts failing after revert in #50137. This issue is still present in FastISel which incorrectly sign extends i1 constants to I32 when selecting binary ops [link](https://github.com/llvm-mirror/llvm/blob/master/lib/CodeGen/SelectionDAG/FastISel.cpp#L621). I was able to trigger the issue reliably on mips32 https://godbolt.org/g/b3LBWo while other platforms seem to not use the FastISel consistently. For example for arm it needs to be forced https://godbolt.org/g/yWmPMu. Is it ok to revert the mentioned pull until the proper fix gets landed to LLVM repo @nox ? | O-MIPS,T-compiler | low | Major |
330,263,617 | opencv | imread block resources when it can't read image | <!--
If you have a question rather than reporting a bug please go to http://answers.opencv.org where you get much faster responses.
If you need further assistance please read [How To Contribute](https://github.com/opencv/opencv/wiki/How_to_contribute).
This is a template helping you to create an issue which can be processed as quickly as possible. This is the bug reporting section for the OpenCV library.
-->
##### System information (version)
<!-- Example
- OpenCV =>3.2.0-1
- Operating System / Platform => Windows 64 Bit/CentOs 7
- Compiler => Intelij Idea 2018.1.4
-->
- OpenCV =>3.2.0-1
- Operating System / Platform => Windows 64 Bit/CentOs 7
- Compiler => Intelij Idea 2018.1.4
##### Detailed description
I use opencv library for Java
public void deskew(File imageFile) {
try (ExonarMetrics.MetricTimer timer = exonarMetrics.getMetricTimerForMetricName(ExonarMetrics.OPENCV_PROCESSING_TIME)) {
Mat imageMat = Imgcodecs.imread(imageFile.getAbsolutePath(), Imgcodecs.CV_LOAD_IMAGE_GRAYSCALE);
imread can't read attached image,it throws an exception (it's not a problem for my case)and block them, because of this I can't delete this image because it's in use(it's a big problem for me).
double angle = computeSkewFromImageFile(imageFile);
logger.debug("Computed angle: {}", angle);
imageMat = rotate(imageMat, angle);
Imgcodecs.imwrite(imageFile.getAbsolutePath(), imageMat);
} catch (Exception e) {
exception.createException(OcrExceptionHandler.OPENCV_EXCEPTION_TYPE, e.getMessage());
}
}
##### Steps to reproduce
Try to read this image , and without closing program try to delete this image
[tryIt.zip](https://github.com/opencv/opencv/files/2080423/tryIt.zip)
--> | incomplete | low | Critical |
330,315,970 | create-react-app | Fonts are not loaded in IE11 with built app | <!--
PLEASE READ THE FIRST SECTION :-)
-->
### Is this a bug report?
Yes
<!--
If you answered "Yes":
Please note that your issue will be fixed much faster if you spend about
half an hour preparing it, including the exact reproduction steps and a demo.
If you're in a hurry or don't feel confident, it's fine to report bugs with
less details, but this makes it less likely they'll get fixed soon.
In either case, please fill as many fields below as you can.
If you answered "No":
If this is a question or a discussion, you may delete this template and write in a free form.
Note that we don't provide help for webpack questions after ejecting.
You can find webpack docs at https://webpack.js.org/.
-->
### Did you try recovering your dependencies?
Yes
<!--
Your module tree might be corrupted, and that might be causing the issues.
Let's try to recover it. First, delete these files and folders in your project:
* node_modules
* package-lock.json
* yarn.lock
Then you need to decide which package manager you prefer to use.
We support both npm (https://npmjs.com) and yarn (http://yarnpkg.com/).
However, **they can't be used together in one project** so you need to pick one.
If you decided to use npm, run this in your project directory:
npm install -g npm@latest
npm install
This should fix your project.
If you decided to use yarn, update it first (https://yarnpkg.com/en/docs/install).
Then run in your project directory:
yarn
This should fix your project.
Importantly, **if you decided to use yarn, you should never run `npm install` in the project**.
For example, yarn users should run `yarn add <library>` instead of `npm install <library>`.
Otherwise your project will break again.
Have you done all these steps and still see the issue?
Please paste the output of `npm --version` and/or `yarn --version` to confirm.
-->
### Which terms did you search for in User Guide?
<!--
There are a few common documented problems, such as watcher not detecting changes, or build failing.
They are described in the Troubleshooting section of the User Guide:
https://github.com/facebook/create-react-app/blob/master/packages/react-scripts/template/README.md#troubleshooting
Please scan these few sections for common problems.
Additionally, you can search the User Guide itself for something you're having issues with:
https://github.com/facebook/create-react-app/blob/master/packages/react-scripts/template/README.md
If you didn't find the solution, please share which words you searched for.
This helps us improve documentation for future readers who might encounter the same problem.
-->
_fonts_
### Environment
<!--
To help identify if a problem is specific to a platform, browser, or module version, information about your environment is required.
This enables the maintainers quickly reproduce the issue and give feedback.
Run the following command in your React app's folder in terminal.
Note: The result is copied to your clipboard directly.
`npx create-react-app --info`
Paste the output of the command in the section below.
-->
> Environment:
> OS: macOS High Sierra 10.13.4
> Node: 8.9.4
> Yarn: 1.6.0
> npm: 5.6.0
> Watchman: Not Found
> Xcode: Not Found
> Android Studio: Not Found
>
> Packages: (wanted => installed)
> react: ^16.4.0 => 16.4.0
> react-dom: ^16.4.0 => 16.4.0
> react-scripts: 1.1.4 => 1.1.4
### Steps to Reproduce
<!--
How would you describe your issue to someone who doesn’t know you or your project?
Try to write a sequence of steps that anybody can repeat to see the issue.
-->
1. Create a new project with `create-react-app`
2. Add a font in the `src/font` dir
3. Add the necessary CSS to use this font using `@font-face` in `index.css` like in this example:
```css
@font-face {
font-family: 'OpenSans-Regular';
src: url('./fonts/OpenSans/OpenSans-Regular-webfont.eot?#iefix') format('embedded-opentype'),
url('./fonts/OpenSans/OpenSans-Regular-webfont.woff') format('woff');
font-weight: normal;
font-style: normal;
}
body {
margin: 0;
padding: 0;
font-family: 'OpenSans-Regular', sans-serif;
}
```
4. Run `yarn start` and open http://localhost:3000 in Internet Explorer 11 (using a VM may be a nice idea) and check that your font is used for the text (this is the expected behavior).
5. Stop the process and run `yarn build`
6. Run the built page by running `serve -s build`
7. Open http://localhost:3000 with Chrome, Firefox, etc. You will see that the used font is OpenSans
8. Now open the same URL with Internet Explorer 11.
### Expected Behavior
IE11 should display the text with the OpenSans font when the project is built.
<!--
How did you expect the tool to behave?
It’s fine if you’re not sure your understanding is correct.
Just write down what you thought would happen.
-->
### Actual Behavior
The OpenSans font is not downloaded and the text is shown as sans-serif.
<!--
Did something go wrong?
Is something broken, or not behaving as you expected?
Please attach screenshots if possible! They are extremely helpful for diagnosing issues.
-->
**IE 11 (see how the text is rendered):**
**Chrome:**
<img width="1000" alt="react_app_-_font_test" src="https://user-images.githubusercontent.com/344445/41108272-6ad63868-6a74-11e8-90dd-5f43abdfa026.png">
### Reproducible Demo
<!--
If you can, please share a project that reproduces the issue.
This is the single most effective way to get an issue fixed soon.
There are two ways to do it:
* Create a new app and try to reproduce the issue in it.
This is useful if you roughly know where the problem is, or can’t share the real code.
* Or, copy your app and remove things until you’re left with the minimal reproducible demo.
This is useful for finding the root cause. You may then optionally create a new project.
This is a good guide to creating bug demos: https://stackoverflow.com/help/mcve
Once you’re done, push the project to GitHub and paste the link to it below:
-->
I created a repository to show the problem here: https://github.com/michaelperrin/create-react-app-font-problem.
Steps to reproduce:
1. Clone my demo repo: `git clone https://github.com/michaelperrin/create-react-app-font-problem.git`
2. Run the following commands:
```
yarn global add serve
yarn build
serve -s build
```
3. Open http://localhost:3000 with Chrome, Firefox, etc. You will see that the used font is OpenSans
4. Now open the same URL with Internet Explorer 11 (using a VM may be a nice idea).
<!--
What happens if you skip this step?
We will try to help you, but in many cases it is impossible because crucial
information is missing. In that case we'll tag an issue as having a low priority,
and eventually close it if there is no clear direction.
We still appreciate the report though, as eventually somebody else might
create a reproducible example for it.
Thanks for helping us help you!
-->
**A few notes:**
* This is not due to the fact that you are running the project on localhost (I hosted it on a server and got the same problem).
* This is not due to font formats (IE11 does support EOT files).
* This happens with any font.
* This is not due to security parameters of IE11 (font download is enabled).
* I hope I didn't miss something and that this is an actual bug 😉 | issue: needs investigation | medium | Critical |
330,335,273 | pytorch | Different behavior of LSTM and LSTMCell implementation | ## Issue description
I was testing the difference between LSTM and LSTMCell implementations, ideally for same input they should have same outputs, but the outputs are different, looks like something fishy is going on.
The numbers are different that's still okay, but the problem is I am getting very different performances(accuracy and other metrics, not O(t)) while testing these two models.
Can you please check the issue?
## Code example
import torch
from torch import nn
from torch.autograd import Variable
print torch.__version__
torch.manual_seed(666)
rnn = nn.LSTM(10, 20, 1)
input = Variable(torch.randn(5, 3, 10))
h0 = Variable(torch.zeros(1, 3, 20))
c0 = Variable(torch.zeros(1, 3, 20))
output, (hn, cn) = rnn(input, (h0, c0))
print ("From LSTM")
print hn[0]
rnncell = nn.LSTMCell(10, 20)
hx = Variable(torch.zeros(3, 20))
cx = Variable(torch.zeros(3, 20))
out = []
for i in range(5):
hx, cx = rnncell(input[i], (hx, cx))
out.append(hx)
print ("from LSTM Cell")
print hx
## System Info
- PyTorch or Caffe2: pytorch
- How you installed PyTorch (conda, pip, source): pip
- Build command you used (if compiling from source):
- OS: ubuntu
- PyTorch version: 0.3.1
- Python version: 2.7.12
- CUDA/cuDNN version: NA
- GPU models and configuration: NA
- GCC version (if compiling from source):
- CMake version: NA
- Versions of any other relevant libraries:
cc @zou3519 | module: numerical-stability,module: rnn,triaged,module: numerical-reproducibility | low | Major |
330,367,525 | go | database/sql: *Rows.Err() does not return errors from *Rows.Scan() | I'm not really advocating for the behavior to change, but the usage of the word "iteration" in the current documentation of [`Rows.Err()`](https://golang.org/pkg/database/sql/#Rows.Err) is ambiguous with respect to the behavior of `*Rows.Scan()`. More examples and/or more precise documentation would help.
### What version of Go are you using (`go version`)?
go version go1.10.2 linux/amd64
### Does this issue reproduce with the latest release?
Yes
### What did you do?
https://play.golang.org/p/1xbP8gEMNtb
### What did you expect to see?
(Given a certain reading of the `Rows.Err()` docs:)
```
2018/06/07 10:24:45 Error from Scan(...): sql: Scan error on column index 0: sql/driver: couldn't convert 42 into type bool
2018/06/07 10:24:45 Error from Err(): sql: Scan error on column index 0: sql/driver: couldn't convert 42 into type bool
```
### What did you see instead?
```
2018/06/07 10:24:45 Error from Scan(...): sql: Scan error on column index 0: sql/driver: couldn't convert 42 into type bool
2018/06/07 10:24:45 No error from Err()
``` | Documentation,NeedsInvestigation | low | Critical |
330,456,301 | opencv | cv::Mat::convertTo(…) undesired new behavior | ##### System information (version)
- OpenCV => 3.4 branch (3.4.1-dev)
- Operating System / Platform => macOS (and probably all other platforms)
- Compiler => clang (an probably all other compilers)
##### Detailed description
Among other changes in the following changeset, there are changes to the cv::Mat::convertTo(…) method which I'd like to challenge because I think the new implementation has unexpected behaviour and causes cumulative issues:
https://github.com/opencv/opencv/commit/7d19bd6c19af51be7fd21c313a3b328f4c50cd05#diff-8489f797e941deaa5e77be1f2bf82bc8R1307
This changeset adds the following block at the beginning of the cv::Mat::convertTo(…) method:
```.cpp
if( empty() )
{
_dst.release();
return;
}
```
That means that a call like `m.convertTo(m, CV_32F);`would deallocate the matrix `m` plus not mark it `CV_32F` nor keep its dimensions (which can initially be 0-by-C nor L-by-0) as an information. This is an issue in the following example program:
```.cpp
#include <opencv2/opencv.hpp>
#include <opencv2/features2d.hpp>
using namespace cv;
using namespace std;
int main(int argc, char *argv[])
{
assert(argc == 2);
Mat im1 = imread(argv[1], 1);
if (im1.empty())
{
return -1;
}
vector<KeyPoint> keypoints1, keypoints2;
Mat desc1, desc2;
Ptr<AKAZE> akaze = AKAZE::create(AKAZE::DESCRIPTOR_MLDB);
akaze->detectAndCompute(im1, noArray(), keypoints1, desc1);
if (desc1.type() != CV_32F)
{
desc1.convertTo(desc1, CV_32F);
}
Mat im2 = im1.clone();
akaze->detectAndCompute(im2, noArray(), keypoints2, desc2);
if (desc2.type() != CV_32F)
{
desc2.convertTo(desc2, CV_32F);
}
FlannBasedMatcher descriptorMatcher;
descriptorMatcher.add(desc1);
descriptorMatcher.train();
vector< vector<cv::DMatch> > nnmatches;
descriptorMatcher.knnMatch(desc2, nnmatches, 2);
}
```
When passing as this program's argument the path to an image that has keypoint, no issue, however when no keypoint has been found, for example for a black image, `desc1.convertTo(desc1, CV_32F);` deallocates `desc1` plus does not mark it `CV_32F` nor keep its original dimensions, leading to a raised exception:
```
OpenCV(3.4.1-dev) Error: Unsupported format or combination of formats (> type=0
> ) in buildIndex_, file <XXX>/opencv/modules/flann/src/miniflann.cpp, line 315
libc++abi.dylib: terminating with uncaught exception of type cv::Exception: OpenCV(3.4.1-dev) <XXX>/opencv/modules/flann/src/miniflann.cpp:315: error: (-210:Unsupported format or combination of formats) in function 'buildIndex_'
> type=0
>
(lldb)
```
I understand that this can be workaround-ed with code, however I don't this that it's a desired behaviour as it creates (sometimes hard-to-find) edge cases like the one illustrated in the code above.
If this looks like an issue to you, please also inspect the other changes that have been included in the same changeset. | category: core,RFC | low | Critical |
330,458,601 | godot | Snap scaling to grid | **Godot version:**
3.1.dev.custom_build.c80ac06
**OS/device including version:**
Elementary OS Loki
**Issue description:**
Scaling an object in 3D does not respect the grid, it respects only scaling rate settings.
**Steps to reproduce:**
I create a CSG box, and I want to scale it so that its vertices are directly on the grid. I set
Scale Snap to 50%, and if I scale the box up, it works, the vertices stay on grid. When I scale down, though the vertices fly off grid.
**Minimal reproduction project:**
Just a CSG box | enhancement,topic:editor,usability | low | Minor |
330,506,672 | angular | Service Worker makes show up a "Live Broadcast" message on HTML audio player on Safari | <!--
PLEASE HELP US PROCESS GITHUB ISSUES FASTER BY PROVIDING THE FOLLOWING INFORMATION.
ISSUES MISSING IMPORTANT INFORMATION MAY BE CLOSED WITHOUT INVESTIGATION.
-->
## I'm submitting a...
<!-- Check one of the following options with "x" -->
<pre><code>
[ ] Regression (a behavior that used to work and stopped working in a new release)
[x] Bug report <!-- Please search GitHub for a similar issue or PR before submitting -->
[ ] Performance issue
[ ] Feature request
[ ] Documentation issue or request
[ ] Support request => Please do not submit support request here, instead see https://github.com/angular/angular/blob/master/CONTRIBUTING.md#question
[ ] Other... Please describe:
</code></pre>
## Current behavior
<!-- Describe how the issue manifests. -->
When playing an audio on a Safari browser (Mobile or Desktop) a "Live Broadcast" message appears on the HTML 5 audio player.
## Expected behavior
<!-- Describe what the desired behavior would be. -->
The audio must be played without the "Live Broadcast" message on the audio player.
## Minimal reproduction of the problem with instructions
Clone the example project:
`git clone https://[email protected]/daedmunoz/angular-sw-problem.git`
- Go the the root directory of the project and:
- Run `npm install` and `ng build --prod`
- Create a Firebase Project and deploy to it doing `firebase deploy`
- Make sure to se the Firebase deployment directory as the `dist` directory generated in the angular - - build process (Firebase default deployment directory is `public`).
- Open the site in a Safari browser (on Chrome the issue does not happen).
- After pressing the play button on the audio player you should see the "Live Broadcast" message on the player.
I created a working demo so that you can reproduce see the issue :
[Firebase demo](https://angular-ng-build-safari.firebaseapp.com/)
## What is the motivation / use case for changing the behavior?
<!-- Describe the motivation or the concrete use case. -->
The need to be able to:
- use the audio player and service worker together on Safari without problems, and
- deliver a PWA.
## Environment
Angular version 6
Browser:
- [x] Safari (desktop) latest
- [x] Safari (iOS) version 11.1
For Tooling issues:
- angular/cli version: 6.0.1 (it was on version 5 too)
- Node version: 8.11.1
- npm version: 5.6.0
- Platform: Mac High Sierra 10.13.14
| type: bug/fix,help wanted,freq1: low,area: service-worker,browser: safari,state: needs more investigation,P4 | low | Critical |
330,543,768 | opencv | OpenCV EGL support for none X Server environment offscreen render | <!--
If you have a question rather than reporting a bug please go to http://answers.opencv.org where you get much faster responses.
If you need further assistance please read [How To Contribute](https://github.com/opencv/opencv/wiki/How_to_contribute).
This is a template helping you to create an issue which can be processed as quickly as possible. This is the bug reporting section for the OpenCV library.
-->
##### System information (version)
<!-- Example
- OpenCV => 3.1
- Operating System / Platform => Windows 64 Bit
- Compiler => Visual Studio 2015
-->
- OpenCV => :3.4.1
- Operating System / Platform => :Linux version 4.13.0-43-generic (buildd@lcy01-amd64-029) (gcc version 5.4.0 20160609 (Ubuntu 5.4.0-6ubuntu1~16.04.9))
- Compiler => :gcc 5.4.0
##### Detailed description
With the help of https://devblogs.nvidia.com/egl-eye-opengl-visualization-without-x-server/ , I have write a program do such things:
1. Choose One GPUID(one of 0~3) On My 4 GPU System.
2. Create OpenGL Context Without X Window at specified GPU Device.
3. Create OpenGL Buffer, map it to cuda device ptr.
4. Decode rtsp video stream with nvcodec hardware acceleration, storage decoded frame at maped cuda device memory at step 3.
5. Use decoded frame cuda memory do caffe deep learning inference, get the algorithm result.
6. Unmap cuda device ptr. so now the openGL buffer has the frame data.
7. Use OpenGL FBO to render frame and algorithm result off screen. copy rendered data to PBO.
8. Encode rendered frame data and save to mp4 file with nvcodec hardware acceleration.
Now I want to use OpenCV's `cv::ogl` and `cv::cuda` to simplify some module develop. The `map`,`download` interface are very friendly to use. But I can't create a `cv::ocl::Buffer` object, `gl::GenBuffers()` get a `bufid == 0` assert failed , then I find OpenCV call `glXGetProcAddressARB` to get API.
In page https://devblogs.nvidia.com/linking-opengl-server-side-rendering/ , I found some Information, ref below:
> Linking an OpenGL application was simple: you only needed to link against libGL.so. functions for both OpenGL and glX were bundled into the same library, libGL.so.
>
> But People want to have X11-based display managers on the same system with Wayland, **or to use hardware-accelerated OpenGL on the same system with software-emulated OpenGL.** This requires a cleaner separation between the OpenGL library and OpenGL context-management libraries.
>
> GLVND, the OpenGL Vendor Neutral Dispatch for Linux, was born to meet this requirement. To use glX and OpenGL today, you should link against libOpenGL.so as well as libGLX.so. The first contains the OpenGL symbols, the latter the GLX symbols. **If you want to use EGL context management instead, link against libOpenGL.so and libEGL.so.**
>
> If your application uses OpenGL extension functions, it is your responsibility to use the correct extension function loader mechanism for the initialized context. **A GLX-based context should use glXGetProcAddress, whereas an EGL-based context should use eglGetProcAddress.** Note that the use of a particular loader may be implicit: GLEW, for example, uses the GLEW_EGL C preprocessor macro to choose the loader.
My program depend on libOpenGL.so and libEGL.so. libopencv_core.so link to libGL.so, it seems like there have no official support to choose which type OpenGL context (glx or egl) `ogl::Buffer`,`ogl::Texture`,`ogl::Array` object should use.
How can I use `ogl::Buffer`,`ogl::Texture`,`ogl::Array` in my EGL OpenGL Context thread. Is there some official plan about this issue? If I should do it my self, where should I modify in opencv source code? how many work should I do to achieve the goal?
##### Steps to reproduce
<!-- to add code example fence it with triple backticks and optional file extension
```.cpp
// C++ code example
```
or attach as .txt or .zip file
--> | category: gpu/cuda (contrib),RFC | low | Critical |
330,546,271 | pytorch | [Installation]: Support conda/pip install with ppc64le(power8) | It would be very convenient to have conda/pip supported for installing PyTorch in ppc64le (power8). For now the only possibility is to build from source.
cc @ezyang @seemethere @malfet @walterddr | module: binaries,triaged,enhancement,module: POWER | low | Minor |
330,548,095 | go | x/net/http2: Transport ignores net/http.Transport.Proxy once connected | ### What version of Go are you using (`go version`)?
`go1.10.2 darwin/amd64`
### Does this issue reproduce with the latest release?
Yes
### What operating system and processor architecture are you using (`go env`)?
```
GOARCH="amd64"
GOBIN=""
GOCACHE="..."
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="darwin"
GOOS="darwin"
GOPATH="..."
GORACE=""
GOROOT="/usr/local/Cellar/go/1.10.2/libexec"
GOTMPDIR=""
GOTOOLDIR="/usr/local/Cellar/go/1.10.2/libexec/pkg/tool/darwin_amd64"
GCCGO="gccgo"
CC="clang"
CXX="clang++"
CGO_ENABLED="1"
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"
PKG_CONFIG="pkg-config"
GOGCCFLAGS="-fPIC -m64 -pthread -fno-caret-diagnostics -Qunused-arguments -fmessage-length=0 -fdebug-prefix-map=/var/folders/_j/6wqhr8r57g34l96w0vt17bww0000gp/T/go-build671837991=/tmp/go-build -gno-record-gcc-switches -fno-common"
```
### What did you do?
I've set up an HTTP2 client and server. The client does a few concurrent requests to the sever. The client's http.Transport has a Proxy function set which alters the requests's context. The http.Transport.DisableKeepAlives flag is also set to true.
Upon receiving the response, the contents of the context gets printed out.
My code in playground: https://play.golang.org/p/bx4GvEZ-suw
Can't be run in playground though, because of the HTTP/2 package and needed cert and key.
To get the cert + key run: `openssl req -x509 -newkey rsa:4096 -keyout server.key -out server.pem -days 365 -nodes` in the directory of the file.
### What did you expect to see?
The context of every request altered, like so: (what happens if the http.Transport doesn't get configured for HTTP2)
```
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
context.Background.WithValue("Proxy", 1)
```
### What did you see instead?
Almost none of the requests passed through the http.Transport.Proxy function, even though the no keepalives flag has been set:
```
context.Background.WithValue("Proxy", 1)
context.Background
context.Background.WithValue("Proxy", 1)
context.Background
context.Background
context.Background
context.Background
context.Background
context.Background
context.Background
context.Background
context.Background
context.Background
context.Background
context.Background
context.Background
context.Background
context.Background
context.Background
context.Background
```
Not using HTTP2 on the client side seems to solve the issue completely. Playing with the 10ms processing time on the server and 10ms waiting time between starting goroutines either resolves the issue or make it worse. However this is not something you (should) have control over in a production environment.
This might be related to: https://github.com/golang/go/issues/25620, however that one is on TCP level (where the http.Transport.Proxy is called, but not respected), while here the function isn't called at all.
| NeedsFix | low | Critical |
330,551,582 | rust | Many `From` implementations are undocumented | While `std::convert::From` has [very detailed high level documentation](https://doc.rust-lang.org/std/convert/trait.From.html), the implementations often lack docs on how they work and use the default "performs the conversion" boilerplate.
This at least includes all `String` methods, also, all integer conversions. Both of these can have interesting behaviour, especially in relation to each other. For example, the different allocation behaviour between `From<Box<str>>` and `From<&'a str>` is notable and hard to figure out from the source, as it goes through three layers of indirection. | E-easy,C-enhancement,P-medium,E-mentor,T-libs-api,A-docs | medium | Critical |
330,571,728 | kubernetes | Figure out what's the best path for delivering cloud config in nodes | I feel that similar to how node bootstrapping and dynamic kubelet config work today, it would be nice to provide a similar mechanism for serving cloud provider config from the API server. Or maybe there is a better option.
Today we have the following options:
1. lay the extra config inside the machine (prebaked in the VM image)
2. lay the extra config inside the machine (during startup of the VM)
3. duplicate the mechanism used by bootstrapping
4. ???
None of the above is ideal:
1. the config is tied to the lifecycle of the VM image and in order to rollout an update you need to go through the whole process of image build -> image publish -> rollout. Also, this can be even worse when the cloud config includes credentials.
2. this is still tied to the lifecycle of the VM; in order to update cloud config, the VM needs to be drained, all running workloads are evicted and rescheduled elsewhere.
3. still suboptimal because we have to duplicate existing mechanics (give extra access to bootstrap kubeconfig in order to fetch the extra config, figure out a way to update kubelets when a new change needs to get delivered) but better than 1. and 2. since only a kubelet restart is involved and existing workloads are not disrupted apart from the restart.
@smarterclayton @mtaufen @jim-minter @pweil- @kubernetes/sig-node-feature-requests | sig/node,kind/feature,lifecycle/frozen,sig/cloud-provider,needs-triage | low | Major |
330,613,288 | flutter | Step.state should not be final | Can't seem to find any documentation on how to change the state of a [Step](https://docs.flutter.io/flutter/material/Step-class.html) within a [Stepper](https://docs.flutter.io/flutter/material/Stepper-class.html).
I tried doing a simple solution like:
```dart
class EnhancedStepper extends Step {
set stepState(StepState state) {
this.state = state;
}
}
```
However, because state is final I can't change it (I'm also assuming that because Step isn't a widget itself that it/it's Stepper won't know to redraw itself)
My use case is to have a button within a step that asks the user for a device permission, then greys out the button and sets Step.state to StepState.complete.
Something like:
```dart
class SetupStepper extends StatefulWidget {
bool _granted = false;
List<Step> _steps =[
Step(
title: Text("SMS Permission"),
state: _granted ? StepState.complete : StepState.indexed,
content: RaisedButton(
child: Text("Request Permission")
onPressed: _granted ? null : () async {
bool result = await getPermission("SEND_SMS");
if(result) {
// This doesn't work
setState(() {
_granted = true;
});
}
}
)
),
…
];
…
}
| framework,f: material design,c: proposal,P3,team-design,triaged-design | low | Major |
330,661,423 | angular | html element property and input naming conflict |
## I'm submitting a...
<!-- Check one of the following options with "x" -->
<pre><code>
[ ] Regression (a behavior that used to work and stopped working in a new release)
[ ] Bug report <!-- Please search GitHub for a similar issue or PR before submitting -->
[ ] Performance issue
[x] Feature request
[ ] Documentation issue or request
[ ] Support request => Please do not submit support request here, instead see https://github.com/angular/angular/blob/master/CONTRIBUTING.md#question
[ ] Other... Please describe:
</code></pre>
## Current behavior
I was using an input named title on a component. In the rendered code i had a strange tooltip on my component.
The problem is that title is already defined as a property of the Element (i missed that).
<pre><code>
The HTMLElement.title property represents the title of the element,
the text usually displayed in a 'tool tip' popup when the mouse is
over the displayed node.
</code></pre>
## Expected behavior
Maybe nothing or if possible i compiler waring that i am reusing a html element property with my input name.
## Minimal reproduction of the problem with instructions
The simple example shows my title tooltip effect.
https://stackblitz.com/edit/angular-1wezyh
## What is the motivation / use case for changing the behavior?
As a developer I know a lot but not all possible properties of an html element and a name conflict is possible.
## Environment
<pre><code>
Angular version: 6.0.0
Browser:
- [ x] Chrome (desktop) version XX
- [ x] Chrome (Android) version XX
- [ x] Chrome (iOS) version XX
- [ x] Firefox version XX
- [ x] Safari (desktop) version XX
- [x ] Safari (iOS) version XX
- [ x] IE version XX
- [ x] Edge version XX
For Tooling issues:
- Node version: XX <!-- run `node --version` -->
- Platform: <!-- Mac, Linux, Windows -->
Others:
<!-- Anything else relevant? Operating system version, IDE, package manager, HTTP server, ... -->
</code></pre>
| area: core,core: binding & interpolation,core: inputs / outputs,type: confusing,P4 | low | Critical |
330,720,686 | TypeScript | Object spread incorrectly compiles getter | <!-- 🚨 STOP 🚨 𝗦𝗧𝗢𝗣 🚨 𝑺𝑻𝑶𝑷 🚨
Half of all issues filed here are duplicates, answered in the FAQ, or not appropriate for the bug tracker. Even if you think you've found a *bug*, please read the FAQ first, especially the Common "Bugs" That Aren't Bugs section!
Please help us by doing the following steps before logging an issue:
* Search: https://github.com/Microsoft/TypeScript/search?type=Issues
* Read the FAQ: https://github.com/Microsoft/TypeScript/wiki/FAQ
Please fill in the *entire* template below.
-->
<!-- Please try to reproduce the issue with `typescript@next`. It may have already been fixed. -->
**TypeScript Version:** 2.9.1
<!-- Search terms you tried before logging this (so others can find this issue more easily) -->
**Search Terms:**
object spread getter
**Code**
```ts
const A = { a: 1 };
const X = { ...A, get x() { return this.a } };
const Y = { a: A.a, get x() { return this.a } };
console.log(X.x, Y.x)
```
**Expected behavior:**
1 1
**Actual behavior:**
undefined 1
The [proposal](https://github.com/tc39/proposal-object-rest-spread/blob/master/Spread.md) says that ``get x()`` should not be called (section *Getters on the Object Initializer*).
Executing the code in Chrome (66) console produces the expected behavior.
**Playground Link:** <!-- A link to a TypeScript Playground "Share" link which demonstrates this behavior -->
[link](https://www.typescriptlang.org/play/index.html#src=const%20A%20%3D%20%7B%20a%3A%201%20%7D%3B%0D%0Aconst%20X%20%3D%20%7B%20...A%2C%20get%20x()%20%7B%20return%20this.a%20%7D%20%7D%3B%0D%0Aconst%20Y%20%3D%20%7B%20a%3A%20A.a%2C%20get%20x()%20%7B%20return%20this.a%20%7D%20%7D%3B%0D%0Aconsole.log(X.x%2C%20Y.x)%3B)
| Bug,ES2018 | low | Critical |
330,797,066 | pytorch | [feature request] MPI init_method for torch.distributed | That would be nice to have an init_method that is not socket-based, using MPI for initializing/side-channel communications. I am not talking about MPI backend (or cuda-aware MPI) here, but want to use mpi just for the init part. If we could use a custom `init_method` we could even use `mpi4py`.
## Code example
Ideally something like:
```python
dist.init_process_group(
backend="nccl",
init_method='mpi://',
world_size=self.world_size,
rank=self.rank,
group_name='mtorch'
)
```
discussed [here](https://discuss.pytorch.org/t/nccl-backend-and-init-method-with-mpi/19418).
## System Info
PyTorch version: 0.4.0
Is debug build: No
CUDA used to build PyTorch: 8.0.61
OS: Ubuntu 16.04.3 LTS
GCC version: (Ubuntu 5.4.0-6ubuntu1~16.04.9) 5.4.0 20160609
CMake version: version 3.5.1
Python version: 2.7
Is CUDA available: No
CUDA runtime version: 8.0.61
GPU models and configuration: Could not collect
Nvidia driver version: Could not collect
cuDNN version: Probably one of the following:
/usr/lib/x86_64-linux-gnu/libcudnn.so.6.0.21
/usr/lib/x86_64-linux-gnu/libcudnn_static_v6.a
Versions of relevant libraries:
[pip] numpy (1.14.3)
[pip] numpydoc (0.8.0)
[pip] torch (0.4.0)
[pip] torchvision (0.2.1)
[conda] pytorch 0.4.0 py27_cuda8.0.61_cudnn7.1.2_1 pytorch
[conda] torchvision 0.2.1 py27_1 pytorch | oncall: distributed,triaged | low | Critical |
330,820,503 | rust | Implementations conflict when using associated type across crates | crate bar:
```rust
pub struct Bar;
pub struct BarNext;
pub trait SomeTrait {
type Next;
}
impl SomeTrait for Bar {
type Next = BarNext;
}
```
crate foo:
```rust
extern crate bar;
struct Foo;
struct Baz;
struct BazNext;
pub trait MyTrait<T> {
}
impl MyTrait<BazNext> for Foo {
}
// Why does this conflict with the previous impl? It should resolve to the type BarNext
impl MyTrait<<::bar::Bar as ::bar::SomeTrait>::Next> for Foo {
}
// Using the type BarNext directly does not conflict with the first impl
// impl MyTrait<::bar::BarNext> for Foo {
// }
fn main() {
println!("Hello, world!");
}
```
Output:
```
error[E0119]: conflicting implementations of trait `MyTrait<BazNext>` for type `Foo`:
--> src/main.rs:15:1
|
11 | impl MyTrait<BazNext> for Foo {
| ----------------------------- first implementation here
...
15 | impl MyTrait<<::bar::Bar as ::bar::SomeTrait>::Next> for Foo {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Foo`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0119`.
error: Could not compile `foo`.
```
I can only reproduce this issue when using the `<Bar as SomeTrait>::Next` syntax, and only when Bar is in an external crate. Reproduced in current stable and nightly. | A-diagnostics,A-associated-items,T-lang,T-compiler,C-bug | low | Critical |
330,881,352 | TypeScript | Destructure of function parameters - Refactoring | ```javascript
const calllback = event=> {
let {target} = event;
// code with used target
}
```
to
```javascript
const calllback = ({target})=> {
// code with used target
}
```
Same in the opposite direction and with a more complex and deep destructure and function content. | Suggestion,Needs Proposal,Domain: Refactorings | low | Major |
330,886,653 | rust | std::process:Command blocks with child.wait() and stdout "piped" | Hi,
I have 2 applications that spawn a new process with stdout redirected to `Stdio::piped()`. The command is executed through `spawn()` call.
I'm waiting until process will finish through `child.wait()` interface. If the output of the command is large(several thousands lines) then the process is blocked. If I read the output of the child with some buffer then it works fine and the process doesn't block.
If the output of the command is small then the process doesn't block, I don't have to read the output through a buffer or something similar.
```rust
use std::io::Read;
use std::process::{Command, Stdio};
fn main() {
let mut child = Command::new("ls")
.args(&["-R", "/home/carlos/rust"]) // output of this command is several thousands lines
//.args(&["/home/carlos/rust"]) // output of this command is only few lines
.stdout(Stdio::piped())
.spawn()
.expect("Cannot be executed");
// If I read the output of the child, then it works fine, it doesn't matter if the output is
// big or not.
//{
//let mut buffer: String = String::new();
//child.stdout.as_mut().unwrap().read_to_string(&mut buffer);
//println!(
//"the output is {:?}",
//buffer
//);
//}
child.wait();
println!("Finish");
}
```
These are the number of lines and the execution time of the output command from terminal:
```
⇒ time ls -R /home/carlos/rust | wc -l
15532
ls -G -R /home/carlos/rust 0,04s user 0,03s system 99% cpu 0,074 total
wc -l 0,00s user 0,00s system 3% cpu 0,074 total
⇒ time ls /home/carlos/rust | wc -l
16
ls -G /home/carlos/rust 0,00s user 0,00s system 81% cpu 0,003 total
wc -l 0,00s user 0,00s system 53% cpu 0,003 total
```
I don't know which one should be the right behavior but I guess that it should be the same in both cases, the size of the output shouldn't impact on it.
In my opinion, if the output of the command is stored on the field `stdout` of the variable `child`, then the command should finish and if you want to read the output you can read it through `child.stdout`.
I guess there is a limit on the buffer size of the `child.stdout` so if the output is bigger than its default size then the application blocks until "someone" reads this buffer before fill it again. In this case you avoid to store a lot of information in memory but I don't see any reference to that in the documentation.
```
⇒ rustc --version --verbose
rustc 1.26.0
binary: rustc
commit-hash: unknown
commit-date: unknown
host: x86_64-unknown-freebsd
release: 1.26.0
LLVM version: 6.0
``` | T-libs-api,A-io,A-process | low | Minor |
330,892,481 | godot | Scene containing CollisionShape2D throws errors when added to SceneTree asynchronically | **Godot version:**
Godot_v3.0.3-rc3_mono_win64
**OS/device including version:**
Windows 10
**Issue description:**
Scene containing CollisionShape2D throws errors when added to SceneTree asynchronically.
```
0:00:06:0396 - Index p_index=0 out of size (shapes.size()=0)
----------
Type:Error
Description:
Time: 0:00:06:0396
C Error: Index p_index=0 out of size (shapes.size()=0)
C Source: servers/physics_2d/collision_object_2d_sw.cpp:68
C Function: set_shape_transform
0:00:06:0403 - Index p_shape_idx=0 out of size (body->get_shape_count()=0)
----------
Type:Error
Description:
Time: 0:00:06:0403
C Error: Index p_shape_idx=0 out of size (body->get_shape_count()=0)
C Source: servers/physics_2d/physics_2d_server_sw.cpp:701
C Function: body_set_shape_disabled
0:00:06:0411 - Index p_shape_idx=0 out of size (body->get_shape_count()=0)
----------
Type:Error
Description:
Time: 0:00:06:0411
C Error: Index p_shape_idx=0 out of size (body->get_shape_count()=0)
C Source: servers/physics_2d/physics_2d_server_sw.cpp:710
C Function: body_set_shape_as_one_way_collision
```
When added synchronically or when added asycnchronically, but without CollisionShape2D node, everything works as expected.
**Steps to reproduce:**
Create a Loader scene with with single node containing the following code:
```CS
using System;
using System.Threading.Tasks;
using Godot;
public class Loader : Node
{
public override void _Ready()
{
// Doesn't work
this.LoadSceneAsync();
// Works
//this.LoadScene();
}
private async void LoadSceneAsync()
{
await Task.Run((Action)this.LoadScene);
}
private void LoadScene()
{
var scene = (PackedScene)GD.Load("res://Hero.tscn");
var node = scene.Instance();
this.CallDeferred(nameof(this.AddNode), node);
}
private void AddNode(Node node)
{
this.GetTree().GetRoot().AddChild(node);
}
}
```
Create another scene res://Hero.tscn with KinematicBody2D as a root node and two child nodes Sprite and CollisionShape2D.
**Minimal reproduction project:**
[Test.zip](https://github.com/godotengine/godot/files/2087029/Test.zip)
| discussion,topic:core,documentation | low | Critical |
330,921,466 | go | cmd/go: install/build doesn't remove temporary files when aborted | Go version: go1.10 linux/amd64
I've noticed `go build` and `go install` don't remove temporary files in `/tmp/go-*` when aborted with Ctrl-C.
This is an issue with big programs (binary size ~1GB due to linking with a [huge C/C++ library](https://godoc.org/llvm.org/llvm/bindings/go/llvm)), because late in the linking process an intermediary file is created as big as the output file (probably it's the output file itself) that just stays in `/tmp` on a `tmpfs`. Aborting a few times at this stage in the build will quickly fill the RAM on a regular computer until the next reboot (or until manually removing all temporary files).
It would be nice if the Go toolchain would remove it's own temporary files when aborted. | NeedsInvestigation,GoCommand | low | Major |
330,934,226 | vscode | Emmet too active in files such as JSX, TSX, and PHP | <!-- Please search existing issues to avoid creating duplicates. -->
<!-- Use Help > Report Issue to prefill these. -->
- VSCode Version: Version 1.24.0 (1.24.0)
- OS Version: macOS 10.13.4 (17E199)
Steps to Reproduce:
1. Open a new file, set language to `javascriptreact`.
2. Add the following code:
```js
const arr = [1, 2, 3]
const i = 0
arr[i|]
```
3. The location where the pipe is, after typing the `i`, the suggestions will appear, and the top suggestion is Emmet.
<!-- Launch with `code --disable-extensions` to check. -->
Does this issue occur when all extensions are disabled?: Yes | bug,emmet,emmet-parse | low | Major |
330,971,901 | flutter | Document ListView usage with the Column widget | I use flutter framework with following revisions:
```
Flutter 0.4.4 • channel beta • https://github.com/flutter/flutter.git
Framework • revision f9bb4289e9 (4 weeks ago) • 2018-05-11 21:44:54 -0700
Engine • revision 06afdfe54e
Tools • Dart 2.0.0-dev.54.0.flutter-46ab040e58
```
I cannot use ListView or ListViewBuilder inside Column widget. No list item is shown until I remove Column wrapper. Is it supposed not to work in that way, or is it a bug?
Here it is my test widget.
```dart
new Container(
child: new Column(
children: <Widget>[
new ListView.builder(
itemCount: 3,
padding: const EdgeInsets.only(top: 10.0),
itemBuilder: (context, index) {
return new Text(" asdasd");
})
],
))
```
| framework,f: scrolling,d: api docs,has reproducible steps,P2,found in release: 3.7,found in release: 3.9,team-framework,triaged-framework | low | Critical |
330,986,580 | flutter | SliverAppBar flexibleSpace with height depending on children | I have a SliverAppBar with a flexibleSpace that holds information that will change in height. I simply want my AppBar to determine it's height at runtime rather than the static expandedHeight option. Do I really need to calculate the height of this widget before I pass it to the flexibleSpace? Or is there a built in method to allow the SliverAppBar to determine that on it's own? | c: new feature,framework,f: material design,f: scrolling,customer: crowd,c: proposal,P2,team-design,triaged-design | low | Critical |
331,043,189 | rust | Improper use of closures not detected | The following code gets "overflow evaluating the requirement `[closure@src/main.rs:20:19: 20:28]: std::ops::FnMut<(i32,)>`" if the line in `main` is uncommented.
If the error should exist (which I'm unsure about), it should be detected without needing to call `map`.
If not, that's a bug.
```rust
enum Foo<T> {
A(T),
B(Box<Foo<T>>, Box<Foo<T>>),
}
impl<T> Foo<T> {
fn map<F, T2>(self, mut f: F) -> Foo<T2>
where
F: FnMut(T) -> T2,
{
match self {
Foo::A(x) => Foo::A(f(x)),
Foo::B(x, y) => Foo::B(Box::new(x.map(&mut f)), Box::new(y.map(&mut f))),
}
}
}
fn main() {
// Foo::A(0).map(|x| x + 1);
}
``` | A-diagnostics,A-closures,T-compiler,C-bug | low | Critical |
331,107,273 | pytorch | how can I fetch the result of output's Blobs_namet after I sum two numpy array via brew.sum | for example:
data1=np.random.randint(20,size=(2,3)).astype(np.int32)
data2=np.random.randint(20,size=(2,3)).astype(np.int32)
workspace.FeedBlob('data1',data1)
workspace.FeedBlob('data2',data2)
model=model_helper.ModelHelper(name="sumsum")
data3=brew.sum(model,['data1','data2'],"data3")
when I print the type of data3,it will tell me data3 is the BlobReference.But when I want to find the BlobReference name in the workspace.Blobs(), I don't find the data3 in it.
WHY???and I want to know how can i inspect the result of sum | caffe2 | low | Minor |
331,115,613 | rust | Unchecked array indices with --emit=metadata | This is a spinoff of Issue #51308.
Using:
```
rustc 1.28.0-nightly (a805a2a5e 2018-06-10)
binary: rustc
commit-hash: a805a2a5ebba2802f432d79874e59c24e398f82a
commit-date: 2018-06-10
host: x86_64-pc-windows-gnu
release: 1.28.0-nightly
LLVM version: 6.0
```
On this code:
```
fn main() {
let a: [i32; 1] = [0; 1];
a[1];
}
```
Compiling with:
`rustc test.rs`
I get:
```
error: index out of bounds: the len is 1 but the index is 1
--> test.rs:3:5
|
3 | a[1];
| ^^^^
|
= note: #[deny(const_err)] on by default
```
Compiling with `rustc --emit=metadata test.rs` I get no errors. | A-lints,T-compiler,C-bug | low | Critical |
331,201,375 | rust | Method resolution should obey usual shadowing rules for glob imports & prelude | Today item import take precedence over glob imports which take precedence over prelude imports. This works for traits:
```rust
mod a {
pub trait X {
fn x(&self) { println!("a"); }
}
impl X for () {}
}
mod b {
pub trait X {
fn x(&self) { println!("b"); }
}
impl X for () {}
}
use a::X;
use b::*;
fn main() {
().x(); // Works and prints "a", b/c b is shadowed
}
```
However, this logic does not work for trait *methods*. If we rename `b::X` to `b::Y`, the code fails to compile:
```rust
mod a {
pub trait X {
fn x(&self) { println!("a"); }
}
impl X for () {}
}
mod b {
pub trait Y {
fn x(&self) { println!("b"); }
}
impl Y for () {}
}
use a::X;
use b::*;
fn main() {
().x(); // error: multiple `x` found
}
```
I think this problematic for two reasons:
* it seems inconsistent with how other names work
* it makes adding a trait to prelude in std and other crates a breaking change (see https://github.com/rust-lang/rust/issues/51418)
Could we perhaps fix it?
r? @rust-lang/lang | A-resolve,A-trait-system,T-lang,T-libs-api | low | Critical |
331,271,925 | go | cmd/compile: combine append calls | ```go
// A)
xs = append(xs, v1)
xs = append(xs, v2)
// B)
xs = append(xs, v1, v2)
```
Currently, compiler does not rewrite `A` into `B` and generates 2 `append` sequences for `A` (or, more generally, N append sequences for N consecutive appends to the same slice).
Synthetic benchmarks show quite significant difference between these two forms.
```go
package slices
import "testing"
func BenchmarkAppend(b *testing.B) {
for i := 0; i < b.N; i++ {
var xs []int
xs = append(xs, i)
xs = append(xs, 1)
xs = append(xs, 2)
}
}
func BenchmarkAppendOnce(b *testing.B) {
for i := 0; i < b.N; i++ {
var xs []int
xs = append(xs, i, 1, 2)
}
}
```
```
$ go test -v -benchmem -bench=.
goos: linux
goarch: amd64
BenchmarkAppend-8 10000000 164 ns/op 56 B/op 3 allocs/op
BenchmarkAppendOnce-8 20000000 61.7 ns/op 32 B/op 1 allocs/op
```
There are multiple spots inside Go sources that can use this kind of rewrite:
```
$GOROOT/src/net/http/socks_bundle.go:106:3: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/vet/asmdecl.go:425:4: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/vet/asmdecl.go:430:3: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/vet/asmdecl.go:434:3: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/vet/asmdecl.go:438:3: append-combine: can combine chain of 3 appends into one
$GOROOT/src/cmd/vet/asmdecl.go:443:3: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/vet/asmdecl.go:448:3: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/dist/test.go:605:3: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/dist/test.go:674:4: append-combine: can combine chain of 2 appends into one
$GOROOT/src/net/dnsclient.go:30:3: append-combine: can combine chain of 4 appends into one
$GOROOT/src/net/mac.go:21:3: append-combine: can combine chain of 2 appends into one
$GOROOT/src/net/interface_linux_test.go:19:2: append-combine: can combine chain of 2 appends into one
$GOROOT/src/net/interface_linux_test.go:44:2: append-combine: can combine chain of 2 appends into one
$GOROOT/src/strconv/quote.go:31:4: append-combine: can combine chain of 2 appends into one
$GOROOT/src/strconv/quote.go:54:3: append-combine: can combine chain of 2 appends into one
$GOROOT/src/strconv/quote.go:87:4: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/cgo/util.go:48:3: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/go/internal/envcmd/env.go:93:2: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/compile/internal/ssa/deadcode_test.go:146:4: append-combine: can combine chain of 2 appends into one
$GOROOT/src/archive/tar/writer_test.go:36:4: append-combine: can combine chain of 2 appends into one
$GOROOT/src/crypto/tls/handshake_server_test.go:515:2: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/link/internal/ld/dwarf.go:1397:3: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/link/internal/ld/lib.go:1208:2: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/link/internal/ld/lib.go:1164:3: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/link/internal/ld/lib.go:1312:3: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/nm/nm_test.go:223:3: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/nm/nm_test.go:226:4: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/nm/nm_test.go:229:4: append-combine: can combine chain of 2 appends into one
$GOROOT/src/crypto/x509/name_constraints_test.go:1728:2: append-combine: can combine chain of 2 appends into one
$GOROOT/src/crypto/x509/name_constraints_test.go:1711:3: append-combine: can combine chain of 6 appends into one
$GOROOT/src/cmd/compile/internal/gc/range.go:225:3: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/compile/internal/gc/select.go:338:2: append-combine: can combine chain of 3 appends into one
$GOROOT/src/cmd/compile/internal/gc/walk.go:3325:2: append-combine: can combine chain of 2 appends into one
$GOROOT/src/cmd/compile/internal/gc/inl_test.go:152:3: append-combine: can combine chain of 3 appends into one
```
Most of them are not performance-critical.
I've done some impact measurements for real code:
```
net/dnsclient.go
name old time/op new time/op delta
ReverseAddress-8 4.10µs ± 3% 3.94µs ± 1% -3.81% (p=0.000 n=10+9)
strconv/quote.go
name old time/op new time/op delta
AppendQuoteRune-8 85.5ns ± 0% 83.8ns ± 0% -1.92% (p=0.000 n=9+8)
```
Note that `AppendQuoteRune` needs to be modified in order to see difference because otherwise it does not execute path with appends:
```go
func BenchmarkAppendQuoteRune(b *testing.B) {
for i := 0; i < b.N; i++ {
benchQuoteRuneBuf = AppendQuoteRune(benchQuoteRuneBuf[:0], '\a')
benchQuoteRuneBuf = AppendQuoteRune(benchQuoteRuneBuf[:0], '\'')
benchQuoteRuneBuf = AppendQuoteRune(benchQuoteRuneBuf[:0], '\x00')
}
}
```
The major problem I see is potential hit to things like line info and debugging experience (one append sequence instead of extected N). I also believe that slice expression should be "safe". Arguments may also require this property to avoid panic line info changes where evaluation may lead to it.
I would like to dig into that and provide optimization implementation, as soon as it gets approved.
I've sent [CL117615 - net: combine append calls in reverseaddr](https://go-review.googlesource.com/c/go/+/117615) as it seems beneficial there. In case this optimization is never implemented inside the compiler, we'll get that boost regardless. | Performance,compiler/runtime | low | Critical |
331,317,037 | go | cmd/cgo: undefined reference for C function with -buildmode=c-archive | ### What version of Go are you using (`go version`)?
go version go1.10.3 darwin/amd64
### Does this issue reproduce with the latest release?
Yes
### What operating system and processor architecture are you using (`go env`)?
GOARCH="amd64"
GOBIN=""
GOCACHE="/Users/Andari/Library/Caches/go-build"
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="darwin"
GOOS="darwin"
GOPATH="/Users/Andari/go"
GORACE=""
GOROOT="/usr/local/Cellar/go/1.10.3/libexec"
GOTMPDIR=""
GOTOOLDIR="/usr/local/Cellar/go/1.10.3/libexec/pkg/tool/darwin_amd64"
GCCGO="gccgo"
CC="clang"
CXX="clang++"
CGO_ENABLED="1"
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"
PKG_CONFIG="pkg-config"
GOGCCFLAGS="-fPIC -m64 -pthread -fno-caret-diagnostics -Qunused-arguments -fmessage-length=0 -fdebug-prefix-map=/var/folders/lw/5pzww_8n38g1lv_kqqmqfvqr0000gn/T/go-build228325343=/tmp/go-build -gno-record-gcc-switches -fno-common"
### What did you do?
I was experimenting with C interfacing:
```
// int cadd(int a, int b);
import "C"
...
// using the function somewhere
```
I built it with `go build -buildmode=c-archive GoAdd.go`
### What did you expect to see?
The build to be successful.
### What did you see instead?
Undefined symbols for architecture x86_64:
"_cadd", referenced from:
__cgo_ece3f0761be9_Cfunc_cadd in _x002.o
Why would linking be neccessary, if I am generating an archive which I link together with the cadd implementing object file later? | help wanted,NeedsInvestigation,compiler/runtime | medium | Critical |
331,335,454 | rust | Implementing `Alloc` for mutable references to `Alloc` | I don't see why this shouldn't be implemented. It certainly proves useful when working with generic allocators, without requiring a `Copy` bound on them. For example:
struct AllocWithInternalMutability {
...
}
impl<'a> Alloc for &'a AllocWithInternalMutability { ... }
impl AllocWithInternalMutability {
fn use_self(&self) {
//Ugly code
let mut ref_to_self=self;
use_alloc(&mut ref_to_self);
}
}
fn use_alloc<A: Alloc>(a: &mut A) {
//Multiple usages of `A` in here
a.alloc(...);
a.dealloc(...);
}
While having an `impl<A: Alloc> Alloc for &mut A` generic implementation would allow for this instead:
impl AllocWithInternalMutability {
fn use_self(&self) {
//Much cleaner
use_alloc(self);
}
}
fn use_alloc<A: Alloc>(mut a: A) {
//Multiple usages of `A` in here, thanks to `&mut A` also implementing `Alloc`
a.alloc(...);
a.dealloc(...);
}
The other current option is to require `Copy` on `A`, allowing for multiple uses of `A` without losing ownership. | T-lang,C-feature-request | low | Minor |
331,368,392 | TypeScript | Source code transpiles, but emitted declarations filled with errors | <!-- 🚨 STOP 🚨 𝗦𝗧𝗢𝗣 🚨 𝑺𝑻𝑶𝑷 🚨
Half of all issues filed here are duplicates, answered in the FAQ, or not appropriate for the bug tracker. Even if you think you've found a *bug*, please read the FAQ first, especially the Common "Bugs" That Aren't Bugs section!
Please help us by doing the following steps before logging an issue:
* Search: https://github.com/Microsoft/TypeScript/search?type=Issues
* Read the FAQ: https://github.com/Microsoft/TypeScript/wiki/FAQ
Please fill in the *entire* template below.
-->
I apologize if I shouldn't be opening an issue about this.
I asked about debugging long compile times before in another issue, #24435
This issue right now is related to that but in a different way.
The [`typed-orm`](https://github.com/AnyhowStep/typed-orm) project transpiles quickly now, after an unintuitive solution, but the emitted declarations appear "unusable" by other projects (at least according to `tsc`).
`ts-node` and VS code don't seem to have a problem with the emitted declarations and seem to run just fine.
-----
<!-- Please try to reproduce the issue with `typescript@next`. It may have already been fixed. -->
**TypeScript Version:** 2.9.1
<!-- Search terms you tried before logging this (so others can find this issue more easily) -->
**Search Terms:** emit declarations incorrect
**Code**
```ts
import * as o from "typed-orm";
o;
```
And then run `tsc --noEmit --diagnostics`
A repo that reproduces the problem can be found [here](https://github.com/AnyhowStep/emitted-typed-orm-errors)
**Expected behavior:**
Success after about 17 seconds
**Actual behavior:**
Errors after about 37s
The list of errors is... Rather large.
-----
I have a different project that is using `typed-orm` and `ts-node` seems to run it fine. VS code also seems to do some type checking fine (seems to, maybe it skips some more involved checks, or does incremental checking, I have no idea).
However, when I try to run `tsc` (checking types/transpiling), `node` just runs out of memory, even after giving it 8GB of RAM.
-----
I tried to debug what was wrong. The `typed-orm` project itself transpiles very quickly, now. I figured there must be something wrong with that project. However, after removing a lot of code, I still got out-of-memory exceptions.
In the end, I created an entirely new project, wrote that snippet above, and saw that even though the source code for `typed-orm` transpiles, the transpiled declarations seem to have errors.
-----
**Link to example:** [here](https://github.com/AnyhowStep/emitted-typed-orm-errors)
**Link to `typed-orm`:** [here](https://github.com/AnyhowStep/typed-orm)
**Related Issues:** #24435
| Bug,Domain: Declaration Emit | low | Critical |
331,415,176 | TypeScript | Finding definitions exported by string key does not work | _From @Flamefire on June 9, 2018 12:35_
<!-- Please search existing issues to avoid creating duplicates. -->
<!-- Use Help > Report Issue to prefill these. -->
- VSCode Version: 1.24.0
- OS Version: WIn10 x64
Steps to Reproduce:
1. Export by string key:
```
function parse(){return 1;}
exports["parse"] = parse; // exports.parse = parse;
```
2. Import and try GoTo Def:
require("./foo")
foo.parse(); // Not found
<!-- Launch with `code --disable-extensions` to check. -->
Does this issue occur when all extensions are disabled?: Yes
Both versions (`exports["parse"] = parse; // exports.parse = parse;`) should work exactly the same.
_Copied from original issue: Microsoft/vscode#51520_ | Bug,VS Code Tracked,Domain: JavaScript | low | Minor |
331,445,544 | ant-design | Is there a Listener triggered after Sider component's animation is finished ? | ### What problem does this feature solve?
I want do something AFTER the Sider component's collapse animation is finished . But the listener `onCollapse` triggered when the animation begin . Is there a listener like `onCollapsed` but not `onCollapse` ?
### What does the proposed API look like?
Just the same behavior like `onCollapse` but triggered After the animation finished .
<!-- generated by ant-design-issue-helper. DO NOT REMOVE --> | Inactive | low | Major |
331,543,704 | TypeScript | Inference fails nondeterministic when callback gets a `typeof` in an object | <!-- 🚨 STOP 🚨 𝗦𝗧𝗢𝗣 🚨 𝑺𝑻𝑶𝑷 🚨
Half of all issues filed here are duplicates, answered in the FAQ, or not appropriate for the bug tracker. Even if you think you've found a *bug*, please read the FAQ first, especially the Common "Bugs" That Aren't Bugs section!
Please help us by doing the following steps before logging an issue:
* Search: https://github.com/Microsoft/TypeScript/search?type=Issues
* Read the FAQ: https://github.com/Microsoft/TypeScript/wiki/FAQ
Please fill in the *entire* template below.
-->
<!-- Please try to reproduce the issue with `typescript@next`. It may have already been fixed. -->
**TypeScript Version:** 3.0.0-dev.20180609
<!-- Search terms you tried before logging this (so others can find this issue more easily) -->
**Search Terms:**
inference object keyof typeof deterministic
**Code**
```ts
function select<TFields extends { [_ in string]: string }>(fields: (a: { $: typeof document }) => TFields): keyof TFields {
return null!;
}
function test() {
const y = select((a) => ({
foo: "bar"
}));
y;
}
```
**Expected behavior:**
`TFields` is instantiated to `{ foo: string }`. The type of `y` is `"foo"`.
**Actual behavior:**
The type of `y` depends on the order on which you query the types. If you first hover on the `y` in `const y =` or the `y` in `y;`, you get `string`. However, if you first hover `select`, then one of the following happens (not deterministic!):
- The signature of `select` is instantiated as
```ts
function select<{
[x: string]: string;
}>(fields: (a: {
$: Document;
}) => {
[x: string]: string;
}): string
```
The type of `y` is `string`.
- The signature of `select` is instantiated as
```ts
select<{
foo: string;
}>(fields: (a: {
$: Document;
}) => {
foo: string;
}): "foo"
```
The last case is correct. If you end up in the first case, and hover on `select` for a second time, the signature will be shown as in the second case.
The previous lines describe the behavior of VS Code. If I try it in the online playground, I always get the first case. Hovering again does not change the results, like it does in VS Code.
The problem is really specific to having a `typeof` inside an object. The inference is correct when making one of the following changes:
- Unboxing the `typeof` field, e.g. changing `a: { $: typeof document }` to `a: typeof document`
- Removing the argument from the call (`const y = select(() => ({ ...`)
- Removing the `typeof` type, e.g. changing `typeof document` to `string`
**Playground Link:** <!-- A link to a TypeScript Playground "Share" link which demonstrates this behavior -->
http://www.typescriptlang.org/play/#src=function%20select%3CTFields%20extends%20%7B%20%5B_%20in%20string%5D%3A%20string%20%7D%3E(fields%3A%20(a%3A%20%7B%20%24%3A%20typeof%20document%20%7D)%20%3D%3E%20TFields)%3A%20keyof%20TFields%20%7B%0A%09return%20null!%3B%0A%7D%0A%0Afunction%20test()%20%7B%0A%09const%20y%20%3D%20select((a)%20%3D%3E%20(%7B%0A%09%09foo%3A%20%22bar%22%0A%09%7D))%3B%0A%09y%3B%0A%7D%0A
**Related Issues:** <!-- Did you find other bugs that looked similar? -->
| Bug | low | Critical |
331,546,606 | godot | Refactoring Scene breaks custom properties in inherited scene | **Godot version:**
3.0.3 rc1
**Issue description:**
Refactoring the scene hierarchy in the parent scene makes the inherited scene lose custom property.
If the nodes are just moved around and/or renamed, they should keep the child property.
related to #16650
**Steps to reproduce**
1. Make Scene A, with B as a children
2. Make Scene A' inheriting from A
3. Move B in scene A'
4. Add a node in A and move B as a child node of that node
5. A' has the new hiearchy but lost the custom translation of B. | bug,topic:core,confirmed | low | Major |
331,564,453 | rust | Compiler doesn't suggest missing method that is implemented for different type parameter | Consider the following API that allows us to control some piece of hardware, while providing some compile-time guarantees by tracking the hardware state as a type parameter:
``` rust
pub struct Hardware<State>(State);
impl Hardware<Disabled> {
pub fn new() -> Self {
Hardware(Disabled)
}
pub fn enable(self) -> Hardware<Enabled> {
Hardware(Enabled)
}
}
impl Hardware<Enabled> {
pub fn do_stuff(&mut self) {}
}
pub struct Enabled;
pub struct Disabled;
```
`Hardware` is created in the `Disabled` state and needs to be `enable`d before anything can be done with it.
The following piece of code tries to `do_stuff` without `enable`ing first:
``` rust
let hw = Hardware::new();
hw.do_stuff();
```
It fails with the following error message:
```
error[E0599]: no method named `do_stuff` found for type `Hardware<Disabled>` in the current scope
--> src/main.rs:24:8
|
1 | pub struct Hardware<State>(State);
| ---------------------------------- method `do_stuff` not found for this
...
24 | hw.do_stuff();
| ^^^^^^^^
error: aborting due to previous error
For more information about this error, try `rustc --explain E0599`.
```
I think this error message is misleading, as the method does exist. It's just not available with this specific type parameter. This could be highly confusing to someone who isn't used to this kind of API.
I believe that the compiler should suggest the method, and note that it would be available, if the type parameter were different. Similarly to how it would suggest a trait method for a trait that isn't imported into the current scope. Ideally, I would like the compiler to suggest calling the `enable` method, as that would put the API into a state that would allow `do_stuff` to be called.
I'm aware that method suggestions like this were removed some time ago ([issue](https://github.com/rust-lang/rust/issues/42929), [PR](https://github.com/rust-lang/rust/pull/46461)). Adding an attribute to mark function that should be suggested for state transitions like this [has been suggested before](https://github.com/rust-lang/rust/issues/42929#issuecomment-345792124) (@zackmdavis [seemed interested in working on this](https://github.com/rust-lang/rust/issues/42929#issuecomment-345914556)). From my perspective as an API author, such an attribute would be an excellent way to improve the user experience when using APIs like this.
cc @oli-obk (We talked about this at RustFest. Sorry for taking so long to open this issue.) | C-enhancement,A-diagnostics,T-compiler | low | Critical |
331,585,994 | pytorch | [Feature request] Add torch.multiprocessing.Pipe | It would be convenient to support Pipe in PyTorch wrapper of multiprocessing. Since pipe sometimes much faster than Queue when only two points transmissions needed. | module: bootcamp,module: multiprocessing,triaged,enhancement,small | low | Minor |
331,666,512 | neovim | UI: "fold" events | It would be nice to have an RPC API for manipulating folds directly without switching to a window first. It'd also be nice to get fold update events, but window events deserve their own issue: https://github.com/neovim/neovim/issues/8539
https://github.com/neovim/neovim/blob/77192889f09a118c8993af79b2eaa7f43623b6c2/src/nvim/fold.c#L1046-L1049
```
fold_desc = [top, len, flags, small?]
get all folds: window_get_folds() -> [fold_desc, ...]
set all folds: window_set_folds([fold_desc, ...])
expand all folds touching range: window_expand_folds(start_line, end_line)
collapse all folds touching range: window_collapse_folds(start_line, end_line)
``` | enhancement,api,ui-extensibility,core | low | Minor |
331,689,495 | pytorch | Properly release NCCL resources | Right now we're simply leaking them, because NCCL segfaults if you attempt to destroy them after the driver is unloaded.
One strategy to fix it would be to use an `atexit` handler.
See #8352 for more context. | triaged,module: nccl | low | Minor |
331,740,793 | go | gccgo: internal compiler error for interface with cyclic result types | With
```$ gccgo --version
gccgo (google-gccgo-261288) 9.0.0 20180607 (experimental)
Copyright (C) 2018 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
```
the following program
```Go
$ cat x.go
package main
func main() {
}
type I interface {
M1() interface {
I
}
M2() interface {
I
}
}
type S struct{}
func (S) M1() interface{ I } {
return nil
}
func (S) M2() interface{ I } {
return nil
}
```
crashes the compiler:
```
$ gccgo x.go
gccgo: internal compiler error: Segmentation fault signal terminated program go1
Please submit a full bug report,
with preprocessed source if appropriate.
See <http://go.ext.google.com/go/> for instructions.
```
The program compiles (somewhat surprisingly) without error if the struct definition is absent:
```Go
$ cat x.go
package main
func main() {
}
type I interface {
M1() interface {
I
}
M2() interface {
I
}
}
```
For the reference:
- go/types accepts this code (not clear that it should)
- cmd/compile doesn't terminate (issue #25262)
cc: @thanm | NeedsInvestigation | low | Critical |
331,747,214 | scrcpy | Mouse pointer visibility | Under full screen mode make mouse pointer fade away after some time without mouse activity.
It's specially useful for presentations. | feature request | low | Minor |
331,751,656 | go | proposal: io/v2: remove io.Seeker, SeekStart, etc., change Seek method | Copying @bradfitz's comment https://github.com/golang/go/issues/17920#issuecomment-260542015 into a separate proposal.
For Go 2 we should consider changing the `Seek` method to just take a file position, not a whence argument. We should consider adding `SeekFromCurrent` and `SeekFromEnd`, though I suspect they are unnecessary. We should change `Seeker` similarly. We should remove `io.SeekStart`, `io,SeekCurrent`, and `io.SeekEnd`.
Rationale: the current `Seek` method is copied from C. It presents three different interfaces, and doesn't make much sense as a single method in Go. People who implement the `io.Seeker` interface often only implement it for `io.SeekStart`, and do not correctly handle the other possible values.
See also #17920, which this would replace. | v2,Proposal | low | Major |
331,762,882 | flutter | Provide a way to screenshot an entire ListView.builder | (Coming here from #12994)
`ListView.builder` will only render the items visible on the screen. For widget screenshot tests, however, it would be useful to screenshot the entire contents of the widget -- as if there were no vertical constraints, resulting in all the widgets being built.
Possible ideas to do this:
- Add a debug option to make it display all the widgets?
- Manually scroll the screen down until it won't scroll anymore and determining the height. Place the ListView in a SizedBox of that height. | a: tests,c: new feature,framework,P3,team-framework,triaged-framework | low | Critical |
331,789,401 | rust | NLL no longer figures out non-lexical lifetimes within loop | Minimal useful example:
```rust
#![feature(nll)]
use std::collections::VecDeque;
fn next(queue: &mut VecDeque<u32>, above: u32) -> Option<&u32> {
let result = loop {
{
let next = queue.front()?;
if *next > above {
break next;
}
}
queue.pop_front();
};
Some(result)
}
```
This program compiled in `nightly-2018-03-07`, but does not compile on `nightly-2018-05-27`. Instead, it fails with this error:
```
error[E0502]: cannot borrow `*queue` as mutable because it is also borrowed as immutable
--> src/main.rs:12:9
|
7 | let next = queue.front()?;
| ----- immutable borrow occurs here
...
12 | queue.pop_front();
| ^^^^^^^^^^^^^^^^^ mutable borrow occurs here
|
```
([playground](https://play.rust-lang.org/?gist=403ae9ce2d986ecb264087fa8a927762&version=nightly&mode=debug))
To my understanding, this program is in fact sane. `next` is always dropped by the time `queue.pop_front()` runs, and if it escapes and is returned, `queue.pop_front()` is not run.
The error is the same if `return Some(next);` is used instead of `break next;`. | C-enhancement,T-compiler,A-NLL,NLL-polonius | low | Critical |
331,854,935 | go | proposal: spec: interface literals | Filing this for completeness sake, since it was mentioned in https://github.com/golang/go/issues/21670 that this proposal had been discussed privately prior to Go 1. Just like literals allow the construction of slice, struct, and map values, I propose "interface literals" which specifically construct values that satisfy an interface. The syntax would mirror that of struct literals, where field names would correspond to method names. The original idea is proposed by @Sajmani in https://github.com/golang/go/issues/21670#issuecomment-325739411.
Conceptually, this proposal would transform the following initializer
```Go
f := func(p int) { /* implementation */ }
x := interface{
Name(p int)
}{f}
```
to the following type declaration and struct initializer
```Go
type _impl_Name_int struct {
f func(p int)
}
func(v _impl_Name_int) Name(p int) { v.f(p) }
// … in some other scope
f := func(p int) { /* implementation */ }
var x interface{
Name(p int)
} = _impl_Name_int{f}
```
As an extension to what’s mentioned in #21670, I propose that fields be addressable by both method names and field names, like in this example:
```Go
type ReadWriteSeekCloser interface {
ReadWriteSeeker
Closer
}
f := os.Open("file")
calls := 0
return ReadWriteSeekCloser{
ReadWriteSeeker: f,
Close: func() error {
if calls < 1 {
return f.Close()
}
return nil
},
}
```
The default value for a method is `nil`. Calling a nil method will cause a panic. As a corollary, the interface can be made smaller to be any subset of the original declaration. The value can no longer be converted back to satisfy the original interface. See the following modified example (from @neild in https://github.com/golang/go/issues/21670#issuecomment-329251670):
```Go
type io interface {
Read(p []byte) (n int, err error)
ReadAt(p []byte, off int64) (n int, err error)
WriteTo(w io.Writer) (n int64, err error)
}
// 3 method -> 2^3 = 8 subsets
func fn() io.Reader {
return io{
Read: strings.NewReader(“”),
}
}
```
The nil values for `ReadAt` and `WriteTo` make it so the “downcasted” `io.Reader` can no longer be recast to an `io`. This provides a clean way to promote known methods, with the side effect that the struct transformation described above won't be a valid implementation of this proposal, since casting does not work this way when calling a nil function pointer through a struct.
Although this proposal brings parity between struct and interface initialization and provides easy promotion of known methods, I don’t think this feature would dramatically improve the way Go programs are written.
We may see more usage of closures like in this sorting example (now obviated because of sort.Slice):
```Go
arr := []int{1,2,3,4,5}
sort.Sort(sort.Interface{
Len: func() int { return len(arr) },
Swap: func(i, j int) {
temp := arr[i]
arr[i] = arr[j]
arr[j] = temp
},
Less: func(i, j int) bool { return arr[i] < arr[j] },
})
```
Promotion of known methods also avoids a lot of boilerplate, although I’m not sure that it is a common enough use case to warrant a language feature.
For instance, if I wanted to wrap an `io.Reader`, but also let through implementations of `io.ReaderAt`, `io.WriterTo`, and `io.Seeker`, I would need seven different wrapper types, each of which embeds these types:
```Go
type wrapper1 struct {
io.Reader
io.ReaderAt
}
type wrapper2 struct {
io.Reader
io.WriterTo
}
type wrapper3 struct {
io.Reader
io.Seeker
}
type wrapper4 struct {
io.Reader
io.ReaderAt
io.WriterTo
}
type wrapper5 struct {
io.Reader
io.ReaderAt
io.Seeker
}
type wrapper6 struct {
io.Reader
io.WriterTo
io.Seeker
}
type wrapper7 struct {
io.Reader
io.ReaderAt
io.WriterTo
io.Seeker
}
```
Here is the relevant change to the grammar (under the composite literal section of the spec):
```
LiteralType = StructType | InterfaceType | ArrayType | "[" "..." "]" ElementType |
SliceType | MapType | TypeName .
``` | LanguageChange,Proposal,LanguageChangeReview | high | Critical |
331,882,308 | rust | Nightly version is off by one | This says it all:
```
$ rustc +nightly-2016-06-10 --version
rustc 1.11.0-nightly (7d2f75a95 2016-06-09)
```
The version reported by rustc itself is consistently off by one compared to what I requested from rustup. That's particularly confusing when looking at e.g. Travis CI build logs of of my project with a particular nightly, and trying to reproduce the result by installing the same nightly. | T-infra,C-feature-request | low | Major |
331,914,322 | angular | How do I get my Angular 6 components to inherit it's extended component's styles? | ## I'm submitting a...
<!-- Check one of the following options with "x" -->
<pre><code>
[ ] Regression (a behavior that used to work and stopped working in a new release)
[?] Bug report <!-- Please search GitHub for a similar issue or PR before submitting -->
[ ] Performance issue
[?] Feature request
[ ] Documentation issue or request
[ ] Support request => Please do not submit support request here, instead see https://github.com/angular/angular/blob/master/CONTRIBUTING.md#question
[ ] Other... Please describe:
</code></pre>
## Current behavior
<!-- Describe how the issue manifests. -->
I have a angular library (`ng generate library shared`) with a `BaseComponent` in, I want to be able to extend that component in another project and keep the styles of both the `BaseComponent` and the new component (`AnotherComponent`).
I basically want to extend a component and inherit it's styles, but the `AnotherComponent` is not inheriting the `base-component.css`.
Am I doing something stupid?
It would be cool to be able to add it in the `AnotherComponent` style array but since it's bundled I guess this won't work.
```
styleUrls: BaseComponent.styleUrls.concat(["./another.component.css"])
```
# This is basically what i want to achieve:
```
styleUrls: ['./base/base.component.css', "./another.component.scss"]
```
## or a property
```
inheritStyles: true
```
## or a "super"/import in the files
### `another.component.scss`
```
@import [EXTENDED COMPONENT]
```
but since base is actually in it's own Angular library in another Node module, it's not accessible like this.
Hope this makes sense.
## Expected behavior
<!-- Describe what the desired behavior would be. -->
To be able to extend components and keep the template and styles of the extended component.
## Minimal reproduction of the problem with instructions
### base.component.ts
```
import { Component, OnInit } from '@angular/core';
@Component({
selector: 'app-base',
templateUrl: './base.component.html',
styleUrls: ['./base.component.css']
})
export class BaseComponent implements OnInit {
constructor() { }
ngOnInit() {
}
}
```
### another.component.ts
```
import { Component } from '@angular/core';
import { BaseComponent } from 'shared-library';
@Component({
selector: 'app-another',
templateUrl: './another.component.html'
})
export class AnotherComponent extends BaseComponent {
title = 'app';
}
```
## What is the motivation / use case for changing the behavior?
I have a few websites with the same components ("shared components"), but a few need some extra logic, markup or styles.
## Environment
<pre><code>
Angular version: 6.0.3
Browser:
- [x] Chrome (desktop) Version 66.0.3359.181 (Official Build) (64-bit)
For Tooling issues:
- Node version: v10.2.1
- Platform: Mac OS High Sierra
| feature,area: core,core: stylesheets,core: component extension and customization,feature: under consideration | high | Critical |
331,914,616 | flutter | Support soft hyphenation (line breaks at U+00AD plus rendering a hyphen at the end of the line) | I was surprised not to find a parameter to have automatic hyphenation in Text widgets (and the likes). I think it is a useful feature to get nice designs. Without it, justified text may be filled with ugly blank spaces if there are too many very long words.
Could text hyphenation be implemented in flutter, or does it sound like a bad idea for some reason ?
Thanks and congrats to the flutter team for the great job ! | c: new feature,framework,engine,a: typography,customer: crowd,P2,team-engine,triaged-engine | low | Critical |
331,924,157 | flutter | FlutterDriver does not support to find/read validation errors (errorText) of a form field. | Hi,
I'm writing an integration test for my flutter application. Goal of the integrationtest is to test the form field validation behaviour.
As an example, I want to check if an email field contains a valid email address. If not, an appropriate errorText is displayed below the form field.
As far as I have seen, FlutterDriver currently only supports to read the text of a form field. What I would need for my IntegrationTest case is to read the errorText of the form field.
Would be great if the FlutterDriver could support such cases.
Regards,
Sacha
| a: tests,c: new feature,framework,t: flutter driver,P2,team-framework,triaged-framework | low | Critical |
331,927,203 | vue | VNode.componentInstance is undefined when rendered by a functional component | ### Version
2.5.17-beta.0
2.5.16
### Reproduction link
[https://codepen.io/anon/pen/rKwWXq?editors=1010](https://codepen.io/anon/pen/rKwWXq?editors=1010)
### Steps to reproduce
Open the console
### What is expected?
An instance of `MyComponent` should be logged
### What is actually happening?
`undefined` is logged
---
This worked in 2.5.15
It also works if you change `RootComponent` to be non-functional:
```js
const content = h(MyComponent, {}, this.slots.default)
```
I'm guessing this was caused by 62a922e8, `cloneVNode` doesn't include that property.
<!-- generated by vue-issues. DO NOT REMOVE --> | regression | low | Major |
331,945,781 | go | cmd/compile: teach prove.go that {strings|bytes}.Index* return value in the range [-1 .. len(s)) | ## The issue
Currently [prove.go](https://github.com/golang/go/blob/master/src/cmd/compile/internal/ssa/prove.go) doesn't know that functions like `strings.Index*` always return value in the range `[-1 .. len(s))` where `s` - input string / byte slice. So it emits unnecessary bounds checks in the following code:
```go
func nextSpace(s string) string {
n := strings.IndexByte(s, ' ')
if n >= 0 {
// unnecessary bounds check is generated here
return s[n:]
}
return ""
}
```
go tip compiler generates the following assembly code for `nextSpace`:
```asm
TEXT nextSpace(SB)
func nextSpace(s string) string {
0x50f040 64488b0c25f8ffffff MOVQ FS:0xfffffff8, CX
0x50f049 483b6110 CMPQ 0x10(CX), SP
0x50f04d 0f8684000000 JBE 0x50f0d7
0x50f053 4883ec28 SUBQ $0x28, SP
0x50f057 48896c2420 MOVQ BP, 0x20(SP)
0x50f05c 488d6c2420 LEAQ 0x20(SP), BP
n := strings.IndexByte(s, ' ')
0x50f061 488b442430 MOVQ 0x30(SP), AX
0x50f066 48890424 MOVQ AX, 0(SP)
0x50f06a 488b4c2438 MOVQ 0x38(SP), CX
0x50f06f 48894c2408 MOVQ CX, 0x8(SP)
0x50f074 c644241020 MOVB $0x20, 0x10(SP)
0x50f079 e8d235efff CALL strings.IndexByte(SB)
0x50f07e 488b442418 MOVQ 0x18(SP), AX
if n < 0 {
0x50f083 4885c0 TESTQ AX, AX
0x50f086 7c36 JL 0x50f0be
return s[n:]
0x50f088 488b4c2438 MOVQ 0x38(SP), CX
; The compiler may prove 0 <= n < len(s) on this line,
; so the following 2 lines plus runtime.panicslice on 0x50f0d0
; may be eliminated.
0x50f08d 4839c8 CMPQ CX, AX
0x50f090 773e JA 0x50f0d0
0x50f092 4829c1 SUBQ AX, CX
; Additionally, the following 4 lines assume &s[0] + (len(s) - n) may exceed
; max word value. This is impossible, since &s[0] + len(s) doesn't exceed
; max word value.
; The compiler has enough info to disprove this in order to eliminate these lines.
0x50f095 4889ca MOVQ CX, DX
0x50f098 48f7d9 NEGQ CX
0x50f09b 48c1f93f SARQ $0x3f, CX
0x50f09f 4821c8 ANDQ CX, AX
0x50f0a2 488b4c2430 MOVQ 0x30(SP), CX
0x50f0a7 4801c8 ADDQ CX, AX
0x50f0aa 4889442440 MOVQ AX, 0x40(SP)
0x50f0af 4889542448 MOVQ DX, 0x48(SP)
0x50f0b4 488b6c2420 MOVQ 0x20(SP), BP
0x50f0b9 4883c428 ADDQ $0x28, SP
0x50f0bd c3 RET
return ""
0x50f0be 0f57c0 XORPS X0, X0
0x50f0c1 0f11442440 MOVUPS X0, 0x40(SP)
0x50f0c6 488b6c2420 MOVQ 0x20(SP), BP
0x50f0cb 4883c428 ADDQ $0x28, SP
0x50f0cf c3 RET
return s[n:]
0x50f0d0 e82b9df1ff CALL runtime.panicslice(SB)
0x50f0d5 0f0b UD2
func nextSpace(s string) string {
0x50f0d7 e8347df4ff CALL runtime.morestack_noctxt(SB)
0x50f0dc e95fffffff JMP nextSpace(SB)
```
## The solution
1) Teach the compiler that `{strings|bytes}.Index*` return value in the range `[-1 .. len(s))`
2) Teach the compiler that `&s[0] + len(s) - n` doesn't exceed max word value if `0 <= n < len(s)`
This should improve performance of various parsers for text-based messages (json, xml, html, http, etc.) | Performance,NeedsInvestigation,compiler/runtime | low | Major |
331,975,984 | rust | Compilation for mips64-unknown-linux-gnu | I'm trying to compile the `std` crate using a custom target specification for `mips64-unknown-linux-gnu`. I've got stuck a little and I'd appreciate a little help. My specification is a copy of the built-in specification for `mips64-unknown-linux-gnuabi64` with the following differences:
1. The `data-layout` field has been changed to match the data layout used in clang for the same target.
2. The `is-builtin` field has been set to `false`.
3. The `llvm-target` field has been set to `mips64-unknown-linux-gnu`.
4. The `max-atomic-width` field has been set to `32` (it was `64` before).
5. The `target-pointer-width` field has been set to `32` to match the data layout.
This is the whole target specification:
```
{
"arch": "mips64",
"cpu": "mips64r2",
"data-layout": "E-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128",
"dynamic-linking": true,
"env": "gnu",
"executables": true,
"features": "+mips64r2",
"has-elf-tls": true,
"has-rpath": true,
"is-builtin": false,
"linker-flavor": "gcc",
"linker-is-gnu": true,
"llvm-target": "mips64-unknown-linux-gnu",
"max-atomic-width": 32,
"os": "linux",
"position-independent-executables": true,
"pre-link-args": {
"gcc": [
"-Wl,--as-needed",
"-Wl,-z,noexecstack"
]
},
"relro-level": "full",
"target-c-int-width": "32",
"target-endian": "big",
"target-family": "unix",
"target-pointer-width": "32",
"vendor": "unknown"
}
```
I end up with the following output:
```
Compiling compiler_builtins v0.0.0 (file:///root/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/src/rustc/compiler_builtins_shim)
Compiling std v0.0.0 (file:///root/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/src/libstd)
Running `rustc --crate-name build_script_build /root/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/build.rs --crate-type bin --emit=dep-info,link -C opt-level=3 --cfg 'feature="c"' --cfg 'feature="compiler-builtins"' --cfg 'feature="default"' --cfg 'feature="rustbuild"' -C metadata=90fbb7fd0c7442d5 -C extra-filename=-90fbb7fd0c7442d5 --out-dir /tmp/xargo.606pX8cxT6GH/target/release/build/compiler_builtins-90fbb7fd0c7442d5 -L dependency=/tmp/xargo.606pX8cxT6GH/target/release/deps --extern cc=/tmp/xargo.606pX8cxT6GH/target/release/deps/libcc-786ac8d380309a5a.rlib`
Running `rustc --crate-name build_script_build /root/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/src/libstd/build.rs --crate-type bin --emit=dep-info,link -C opt-level=3 -C metadata=0e769dbdf5eed459 -C extra-filename=-0e769dbdf5eed459 --out-dir /tmp/xargo.606pX8cxT6GH/target/release/build/std-0e769dbdf5eed459 -L dependency=/tmp/xargo.606pX8cxT6GH/target/release/deps --extern build_helper=/tmp/xargo.606pX8cxT6GH/target/release/deps/libbuild_helper-ca4cc909bb4adcb1.rlib --extern cc=/tmp/xargo.606pX8cxT6GH/target/release/deps/libcc-786ac8d380309a5a.rlib`
Running `/tmp/xargo.606pX8cxT6GH/target/release/build/std-0e769dbdf5eed459/build-script-build`
Running `/tmp/xargo.606pX8cxT6GH/target/release/build/compiler_builtins-90fbb7fd0c7442d5/build-script-build`
warning: ../../libcompiler_builtins/compiler-rt/lib/builtins/divdc3.c:21:1: warning: conflicting types for built-in function '__divdc3'
warning: __divdc3(double __a, double __b, double __c, double __d)
warning: ^
warning: ../../libcompiler_builtins/compiler-rt/lib/builtins/divsc3.c:21:1: warning: conflicting types for built-in function '__divsc3'
warning: __divsc3(float __a, float __b, float __c, float __d)
warning: ^
warning: ../../libcompiler_builtins/compiler-rt/lib/builtins/muldc3.c:21:1: warning: conflicting types for built-in function '__muldc3'
warning: __muldc3(double __a, double __b, double __c, double __d)
warning: ^
warning: ../../libcompiler_builtins/compiler-rt/lib/builtins/mulsc3.c:21:1: warning: conflicting types for built-in function '__mulsc3'
warning: __mulsc3(float __a, float __b, float __c, float __d)
warning: ^
LLVM ERROR: Not supported instr: <MCInst 0 <MCOperand Reg:416> <MCOperand Reg:321>>
error: Could not compile `core`.
Caused by:
process didn't exit successfully: `rustc --crate-name core /root/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/src/libcore/lib.rs --crate-type lib --emit=dep-info,link -C opt-level=3 -C panic=abort -C metadata=59ab99930ed6da97 -C extra-filename=-59ab99930ed6da97 --out-dir /tmp/xargo.606pX8cxT6GH/target/mips64-unknown-linux-gnu/release/deps --target mips64-unknown-linux-gnu -C ar=mips64-buildroot-linux-gnu-ar -C linker=mips64-buildroot-linux-gnu-gcc -L dependency=/tmp/xargo.606pX8cxT6GH/target/mips64-unknown-linux-gnu/release/deps -L dependency=/tmp/xargo.606pX8cxT6GH/target/release/deps --sysroot /root/.xargo -Z force-unstable-if-unmarked` (exit code: 1)
error: `"cargo" "build" "--release" "--manifest-path" "/tmp/xargo.606pX8cxT6GH/Cargo.toml" "--target" "mips64-unknown-linux-gnu" "-v" "-p" "std"` failed with exit code: Some(101)
note: run with `RUST_BACKTRACE=1` for a backtrace
```
The reason why I'm trying this is that I have an existing Debian system with this target (it's Ubiquiti EdgeRouter) and I'd like to compile a Rust application for this system. It's a big endian MIPS64 system with n32 ABI. Unfortunately, Rust supports only n64. | A-LLVM,O-MIPS,T-compiler | low | Critical |
331,981,979 | go | cmd/compile: merge sequential memory moves into bigger memory moves | ## The issue
Go tip compiles the following code into the following assembly:
```go
func fff(s string) int {
return strings.IndexByte(s, ' ')
}
```
```asm
EXT fff(SB)
func fff(s string) int {
0x50f060 64488b0c25f8ffffff MOVQ FS:0xfffffff8, CX
0x50f069 483b6110 CMPQ 0x10(CX), SP
0x50f06d 763f JBE 0x50f0ae
0x50f06f 4883ec28 SUBQ $0x28, SP
0x50f073 48896c2420 MOVQ BP, 0x20(SP)
0x50f078 488d6c2420 LEAQ 0x20(SP), BP
return strings.IndexByte(s, ' ')
0x50f07d 488b442430 MOVQ 0x30(SP), AX
0x50f082 48890424 MOVQ AX, 0(SP)
0x50f086 488b442438 MOVQ 0x38(SP), AX
0x50f08b 4889442408 MOVQ AX, 0x8(SP)
0x50f090 c644241020 MOVB $0x20, 0x10(SP)
0x50f095 e8b635efff CALL strings.IndexByte(SB)
0x50f09a 488b442418 MOVQ 0x18(SP), AX
0x50f09f 4889442440 MOVQ AX, 0x40(SP)
0x50f0a4 488b6c2420 MOVQ 0x20(SP), BP
0x50f0a9 4883c428 ADDQ $0x28, SP
0x50f0ad c3 RET
func fff(s string) int {
0x50f0ae e85d7df4ff CALL runtime.morestack_noctxt(SB)
0x50f0b3 ebab JMP fff(SB)
```
The assembly copies sequential stack arguments from `fff` to `IndexByte` using the following instructions:
```asm
0x50f07d 488b442430 MOVQ 0x30(SP), AX
0x50f082 48890424 MOVQ AX, 0(SP)
0x50f086 488b442438 MOVQ 0x38(SP), AX
0x50f08b 4889442408 MOVQ AX, 0x8(SP)
```
These instructions may be substituted by shorter (and, probably, faster) assembly:
```asm
MOVO 0x30(SP), Xn
MOVO Xn, 0(SP)
```
## Solution
Add the corresponding arch-specific rewrite rules for merging sequential memory moves into bigger memory moves
cc'ing @randall77 and @TocarIP . | Performance,NeedsInvestigation,compiler/runtime | low | Minor |
332,033,651 | neovim | Custom text objects (or: syntax group as text object) | Hello,
I know this somewhat planned https://www.reddit.com/r/neovim/comments/2zm7s1/what_neovim_feature_will_do_you_get_the_most/cpl2t36
But I wanted to start discussions and possible design for this.
I am pretty sure this will be hugely inspired by https://github.com/kana/vim-textobj-user and projects based on it.
Design proposed by deleted user https://github.com/wellle/targets.vim/issues/14#issuecomment-68344944
**Here are some useful links**
http://vim.wikia.com/wiki/Creating_new_text_objects
http://vim.wikia.com/wiki/Indent_text_object
https://github.com/inkarkat/vim-CountJump
https://github.com/kana/vim-textobj-user/wiki
**Example of projects that will definitely benefit from unified text objects interface**
https://github.com/tpope/vim-surround
https://github.com/wellle/targets.vim
https://github.com/bkad/CamelCaseMotion
https://github.com/tweekmonster/braceless.vim
What I personally would like to see, is ability to have text-objects based on filetype and very easy interface of defining new ones. | enhancement,needs:design,syntax | low | Major |
332,060,100 | pytorch | batchnorm2d track_running_stats | when I load a pretrained model, Runtime error occurred: Missing key(s) in state_dict: bn.num_batches_tracked in every BatchNorm2d layer | module: serialization,triaged | low | Critical |
332,086,825 | go | cmd/go: allow forcing tags on/off during go mod vendor, tidy | In https://golang.org/cl/117258 the "vendor ALL" was introduced to include all files when walking the source tree, except for ignore build tags. This is great.
In https://golang.org/cl/118317 the command introduces flags for "mod -fix" and "mod -sync" (but waits for another CL to implement them). These flags use the knowledge of complete source tree (when trimming or adding requirements) to operate.
Lastly, it is important to note that the "go.mod" exclude directive only operates on the current module. This is good and to the benefit of this proposal.
This proposal adds two things:
* Add the ability to interpret an exclude directive as a tag.
* Use the list of excluded tags in certain operations, such as "mod -vendor", "mod -sync", and "mod -fix", that operate over the entire source tree. These commands would operate as normal in the "ALL" traversal mode, but also ignore the excluded tags as defined in the previous point.
This would be used when the entire source tree (ALL) contains irrelevant platforms to the direct user of the module (common examples would be "exclude appengine" and "exclude solaris". Because exclude directives are ignored by other modules, they do not define limits of the module's use. In addition, these exclude tags are not used when running "build" or "install".
There are two optional features of this proposal as well, but not intrinsic to the base proposal:
* Allow excluding test as a tag: use "exclude test" to ignore dependencies in "*_test.go" files.
* Allow exclude negation: "exclude !windows".
The implementation in govendor supports these cases here:
https://github.com/kardianos/govendor/blob/master/context/tags.go
Two ways to specify tags would be to call any "exclude" that has no "/" a tag. Another way would be to prefix the tag with a "tag:".
/cc @rsc @dlsniper @bcmills
| NeedsDecision,modules | medium | Major |
332,090,671 | pytorch | Use CMAKE_<LANG>_COMPILER_LAUNCHER | Moving more parts of the build into CMake we should use
- CMAKE_C_COMPILER_LAUNCHER (since CMake 3.4)
- CMAKE_CXX_COMPILER_LAUNCHER (since CMake 3.4)
- CMAKE_CUDA_COMPILER_LAUNCHER (since CMake 3.10)
To transparently use ccache in development. Latest ccache (version 3.4) includes working support for nvcc.
cc @orionr | module: build,triaged | low | Minor |
332,093,730 | kubernetes | Unrecognized internal errors in apiserver when etcd server is restarted | <!-- This form is for bug reports and feature requests ONLY!
If you're looking for help check [Stack Overflow](https://stackoverflow.com/questions/tagged/kubernetes) and the [troubleshooting guide](https://kubernetes.io/docs/tasks/debug-application-cluster/troubleshooting/).
If the matter is security related, please disclose it privately via https://kubernetes.io/security/.
-->
**Is this a BUG REPORT or FEATURE REQUEST?**:
> Uncomment only one, leave it on its own line:
>
/kind bug
> /kind feature
**What happened**:
I have three machines dedicated to running etcd servers (as systemd services), seven machines dedicated to being kubernetes masters, and ten machines dedicated to being kubernetes worker nodes. Additionally I configure the etcd server nodes to also be kube workers, to make it easy to gather Prometheus metrics from the etcd servers. Lately I have been testing reboots of the etcd server machines. See https://docs.google.com/document/d/1eXbdC5Hf-cwsWwCpM1jqTIJBsBOVBsUVqnBsx3vruHw for a run that went well. Then I tried it with a higher load on the system. See https://docs.google.com/document/d/15wh16AhMUpNAL9yORc75Ij0YC9RwXN8rYdhsmblq9UI for full details. The load is generated by a simple client that creates, updates, and deletes ConfigMap objects. In this case I ran it at 1000 Kube API operations per second. During one burst of update operations, the client recorded error responses to 19 out of the 150 updates in that burst (find the client's log in the data archive, find its schema in the Experiment 1 main page). The burst happened just as the etcd machine was going down, and lasted for something under 60 milliseconds. Three sorts of error messages were recorded: `grpc: the client connection is closing`, `rpc error: code = Unavailable desc = transport is closing`, and `rpc error: code = Unavailable desc = the server stops accepting new RPCs`.
**What you expected to happen**:
I expected the kube apiservers would internally handle the complications due to an etcd machine going down, not return an error to the kubenetes clients.
**How to reproduce it (as minimally and precisely as possible)**:
I do not yet have a lot of experience with this scenario, so am not sure what are the critical elements. The most obvious elements are taking an etcd server machine down while the system is under high write load, in a multi-master configuration.
**Anything else we need to know?**:
Here is where to look in the apiserver logs:
```
root@mjstest1:~# egrep -c 'the client connection is closing|transport is closing|the server stops accepting new RPCs' 0613.0940.8148*server*stderr*log
0613.0940.8148-kube-apiserver-mjs-api-dal10s-a-stderr.log:10
0613.0940.8148-kube-apiserver-mjs-api-dal10s-b-stderr.log:0
0613.0940.8148-kube-apiserver-mjs-api-dal10s-c-stderr.log:14
0613.0940.8148-kube-apiserver-mjs-api-dal10s-d-stderr.log:0
0613.0940.8148-kube-apiserver-mjs-api-dal10s-e-stderr.log:0
0613.0940.8148-kube-apiserver-mjs-api-dal10s-f-stderr.log:14
0613.0940.8148-kube-apiserver-mjs-api-dal10s-g-stderr.log:0
```
Intriguingly, that shows 2*19 matches.
**Environment**:
- Kubernetes version (use `kubectl version`):
```
root@mjs-api-dal10s-c:~# kubectl version
Client Version: version.Info{Major:"1", Minor:"10", GitVersion:"v1.10.3", GitCommit:"2bba0127d85d5a46ab4b778548be28623b32d0b0", GitTreeState:"clean", BuildDate:"2018-05-21T09:17:39Z", GoVersion:"go1.9.3", Compiler:"gc", Platform:"linux/amd64"}
Server Version: version.Info{Major:"1", Minor:"10+", GitVersion:"v1.10.4-1+cff305847e8117-dirty", GitCommit:"cff305847e811748a902ffed70cbc505b3667bd4", GitTreeState:"dirty", BuildDate:"2018-06-12T14:47:46Z", GoVersion:"go1.9.3", Compiler:"gc", Platform:"linux/amd64"}
```
The server code is https://github.com/MikeSpreitzer/kubernetes/tree/fix-63608-b-on-1.10.4 , in the Docker container image `mspreitz/hyperkube-amd64:v1.10.4.1`.
- Cloud provider or hardware configuration: no Kube "cloud provider" used; hardware as mentioned above, physical for the etcd servers and kube masters, virtual (xen) for the plain kube workers.
- OS (e.g. from /etc/os-release): Ubuntu 16.04.4 LTS on the etcd and kube servers
- Kernel (e.g. `uname -a`): `Linux mjs-api-dal10s-c 4.4.0-127-generic #153-Ubuntu SMP Sat May 19 10:58:46 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux`
- Install tools: private Ansible playbook that deploys etcd as systemd services and drives kubeadm to deploy Kubernetes
- etcd servers: release 3.3.7
- Others: Follow pointers from earlier pages to more details, including the client that drove the load
| kind/bug,sig/api-machinery,lifecycle/frozen | medium | Critical |
332,097,453 | go | net: SplitHostPort errors if no port is specified, but not if input ends with a trailing ":" | Please answer these questions before submitting your issue. Thanks!
### What version of Go are you using (`go version`)?
All
### Does this issue reproduce with the latest release?
Yes
### What operating system and processor architecture are you using (`go env`)?
All
### What did you do?
Repro case:
https://play.golang.org/p/etsLIZv_Oz8
### What did you expect to see?
An error due to improper "host:port" syntax.
### What did you see instead?
An empty port in the result and no error.
| NeedsInvestigation | low | Critical |
332,112,999 | rust | Tracking issue for the #[alloc_error_handler] attribute (for no_std + liballoc) | This attribute is mandatory when using the `alloc` crate without the `std` crate. It is used like this:
```rust
#[alloc_error_handler]
fn foo(_: core::alloc::Layout) -> ! {
// …
}
```
Implementation PR: https://github.com/rust-lang/rust/pull/52191
## Blocking issues
* [ ] #83430
* [ ] https://github.com/rust-lang/unsafe-code-guidelines/issues/506
* [ ] https://github.com/rust-lang/rust/issues/134225
* [ ] https://github.com/rust-lang/rust/issues/134234
## Original issue:
----
In a `no_std` program or staticlib, linking to the `alloc` crate may cause this error:
```
error: language item required, but not found: `oom`
```
This is fixed by providing the `oom` lang item, which is is normally provided by the `std` crate (where it calls a dynamically-settable hook https://github.com/rust-lang/rust/issues/51245, then aborts). This is called by `alloc::alloc::handle_alloc_error` (which is called by `Vec` and others on memory allocation failure).
```rust
#![feature(lang_items)]
#[lang = "oom"]
extern fn foo(_: core::alloc::Layout) -> ! {
// example implementation based on libc
extern "C" { fn abort() -> !; }
unsafe { abort() }
}
```
However, defining a lang item is an unstable feature.
Possible solutions include:
1. Add and stabilize a dedicated attribute similar to [the `#[panic_implementation]` attribute](https://rust-lang.github.io/rfcs/2070-panic-implementation.html#panic_implementation):
```rust
#[alloc_error_handler]
fn foo(_: core::alloc::Layout) -> ! {
// …
}
```
The downside is that this is one more mandatory hoop to jump through for `no_std` program that would have been fine with a default hook that aborts.
2. ~~Move `std`’s dynamically-settable hook into `alloc`: https://github.com/rust-lang/rust/pull/51607. The downside is some mandatory space overhead.~~ | A-allocators,T-lang,T-libs-api,B-unstable,C-tracking-issue,WG-embedded,finished-final-comment-period,disposition-close,Libs-Tracked,S-tracking-design-concerns,S-tracking-needs-summary | high | Critical |
332,119,834 | node | readline with /dev/tty: echos and doesn't close | * **Version**: v10.2.1
* **Platform**: Linux and macOS
* **Subsystem**: readline
The use case is that a node script is being run from a piped bash script and so `process.stdin` is the pipe and `/dev/tty` must be used explicitly to get user input.
```js
var readline = require('readline');
var input = require('fs').createReadStream('/dev/tty');
var rl = readline.createInterface({
input: input
, output: process.stdout
//, terminal: false
});
rl.question("This is the prompt: ", function (response) {
console.log("This is the response:", response);
rl.close();
// If I don't close the input explicitly, it stays open.
input.close();
});
```
Output:
```
This is the prompt: yay
yay
This is the response: yay
```
Uncommenting `terminal: false` solves the issue of echoing, but creates a new problem in that it no longer treats `stdout` as a proper terminal.
Past issues that appear to be similar: https://github.com/nodejs/node/issues/7965 https://github.com/nodejs/node-v0.x-archive/issues/7101 https://stackoverflow.com/questions/24661774/createinterface-prints-double-in-terminal | readline,tty | low | Major |
332,130,808 | pytorch | [caffe2] Why the GPU memory consumption has no change after enable optimize_gradient_memory? | ## Issue description
When I ran the file of 'resnet50_trainer.py' in caffe2/python/examples, I found that the GPU memory consumption has no change whether I enable the property of 'optimize_gradient_memory'. I would like to ask what is the reason. The input I use 'null'. Other parameters are default. Thanks.
## Code example
optimize_gradient_memory=True
## System Info
- Caffe2,
- How you installed? From source.
- Build command you used (if compiling from source): sudo make install -j32
- OS: Ubuntu 16.04
- CUDA/cuDNN version: 8.0 / 5.1
- GCC version (if compiling from source):5.4
| caffe2 | low | Minor |
332,174,654 | go | crypto: document which cipher.Block implementations are safe for concurrent use | Many of them are, but since it's undocumented it might change from one architecture to the next.
This came up in https://go-review.googlesource.com/c/crypto/+/118535 because x/crypto/xts effectively assumes they all are. | Documentation,help wanted,NeedsFix | low | Major |
332,175,561 | pytorch | [JIT] Generalize checkTrace() to also compare gradients of parameters, not just inputs | Right now `checkTrace()` in test_jit.py only checks gradients for inputs, but does not check gradients for parameters on a traced module. We should generalize this so that we can pass in regular modules and test them | oncall: jit | low | Minor |
332,199,408 | vscode | Add DecorationRangeBehavior.Word | From #50779
**Problem**
Using decorators, a common pattern is that you want an decoration that applies to a given whole word. None of the current `DecorationRangeBehavior` values handle this well. `Open` will always expand the decorator even if you type non-word characters, while `Close` never expands the decorator
**Proposal**
Add a `DecorationRangeBehavior.Word` setting or similar that would expand the decoration if the edit extends the word at the edges of the decoration. Typing a word character would expand the decorator while typing space would not | feature-request,api,editor-textbuffer | low | Minor |
332,238,009 | pytorch | Does the caffe2 have the depthwise separable convolution oprater ? | Rencently, I need depthwise separable convolution for my project in order to reduce the parameters.
Does the caffe2 have the depthwise separable convolution oprater ?
| caffe2 | low | Minor |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.