sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: react
Issue: add support for SyntheticKeyboardEvent#isComposing
Labels: Type: Feature Request,Component: DOM

**Do you want to request a *feature* or report a *bug*?**
Bug

**What is the current behavior?**
Synthetic keyboard events do not contain `isComposing`.
They should if the value is true, per the w3 spec 4.7.5: https://www.w3.org/TR/uievents/#events-compositionevents
 
**What is the expected behavior?**
`event.isComposing === event.nativeEvent.isComposing`

SyntheticKeyboardEvent#isComposing is true when a keydown even is fired after compositionstart and before compositionend.

**Which versions of React, and which browser / OS are affected by this issue? Did this work in previous versions of React?**
all versions, up through at least 16.4.1
Repository: pytorch
Issue: Inconsistency in implementation of _LRScheduler 
Labels: module: nn,module: optimizer,triaged,needs research

I've noticed an odd behavior when attempting to write my own scheduler based on `torch.optim.lr_scheduler._LRScheduler`. 

If you write a custom get_lr() to work based on self.last_epoch, its impossible to differentiate the 
0th and the 1st epoch. 

Here is a minimal working example:

```python

def mwe():
    # Assuming optimizer has two groups.
    import torch.optim.lr_scheduler
    import netharn as nh
    model = nh.models.ToyNet2d()
    optimizer = torch.optim.SGD(model.parameters(), lr=10)

    class DummySchedule(torch.optim.lr_scheduler._LRScheduler):
        def get_lr(self):
            print('Set LR based on self.last_epoch = {!r}'.format(self.last_epoch))
            self._current_lr = self.last_epoch
            return [self.last_epoch]

    # Initialize the optimizer with epoch 0's LR
    # self = torch.optim.lr_scheduler.LambdaLR(optimizer, lambda x: x)
    self = DummySchedule(optimizer)
    for epoch in range(3):
        print('------')
        print('Run epoch = {!r}'.format(epoch))
        # Pretend we run epoch 0
        print('Training with self._current_lr = {!r}'.format(self._current_lr))
        # Pretend epoch 0 has finished, so step the scheduler.
        # self.step(epoch=epoch)
        self.step()
```

This results in the output

```
Set LR based on self.last_epoch = 0
------
Run epoch = 0
Training with self._current_lr = 0
Set LR based on self.last_epoch = 0
------
Run epoch = 1
Training with self._current_lr = 0
Set LR based on self.last_epoch = 1
------
Run epoch = 2
Training with self._current_lr = 1
Set LR based on self.last_epoch = 2
```

You can see the last epoch is asked to set the learning rate based on the last epoch being 0 twice. This LRScheduler class takes last_epoch as an argument, so it knows how to set the LR for the previous epoch. By default last_epoch=-1, because the first epoch is 0 and no epoch has run yet. On construction it then calls `step` with `last_epoch + 1`, which means the step function sets the learning rate for epoch 0. Then last_epoch is reset to -1 immediately after, so the next call to step also sets the learning rate for epoch 0. 

A fix would simply remove the + 1 from `self.step(last_epoch + 1)`, but this might break existing implementations of `get_lr()` which wouldn't expect `self.last_epoch` being set to a negative number. 

I think a more intuitive implementation of this class might track the current epoch rather than the previous one. This would be a backwards incompatible change, but I think it would improve the overall quality of torch. I'm willing to give a re-implementation a shot if it sounds like a good idea to the maintainers. 

cc @ezyang @albanD @zou3519 @gqchen @pearu @nikitaved @soulitzer @mruberry @jbschlosser @vincentqb
Repository: vscode
Issue: [HTML] Auto tag-closing doesn't work with undo/redo and programmatic changes
Labels: html,debt,undo-redo

We had a user [report an issue](https://github.com/MicrosoftDocs/live-share/issues/610) with Visual Studio Live Share, where their HTML tag-closing behavior would insert duplicate closing tags as soon as a guest connected to their session.

![doubleaddingendtags](https://user-images.githubusercontent.com/1142313/41826432-7d63e1c0-77f7-11e8-9155-1f2d42fcbc4d.gif)

After looking into it briefly, it appears like the [HTML tag-closing behavior](https://github.com/Microsoft/vscode/blob/master/extensions/html-language-features/client/src/tagClosing.ts) is [listening to the `workspace.onDidChangeTextDocument` event](https://github.com/Microsoft/vscode/blob/master/extensions/html-language-features/client/src/tagClosing.ts#L12:12), and therefore, generating the closing tag on every participants machine, as soon as the `/` or `>` is synchronized across the session. If five guests joined the session, then you'd see six copies of the closing tag.

It isn't immediately clear what the best fix for this is, so I was hoping to get some advice. Initially, I thought we could set the `html.autoClosingTags` setting to `false` in the guest's workspace file. However, since the tag-closing behavior [relies on the `activeEditor`](https://github.com/Microsoft/vscode/blob/master/extensions/html-language-features/client/src/tagClosing.ts#L58), this would break tag-closing for guests if they weren't focused on the same file as the host (maybe that's a better short-term solution?).

At a high-level, it seems like there are two possible ways to address to:

1. **Run the tag-closing logic on the host** - Live Share already takes "exclusive" ownership of language services for `vsls:` documents, but the tag-closing logic runs on the guest's machine since it appears to be [always initialized](https://github.com/Microsoft/vscode/blob/master/extensions/html-language-features/client/src/htmlMain.ts#L90) regardless of the document scheme. We could explore ways to run this logic on the host, however, the reliance on the `activeEditor` would need to be refactored.

2. **Run the tag-closing logic local to each participant** - Since the tag-closing logic could operate entirely on a document buffer, it could technically just run on each guest's machine, without needing file system access. However, since it relies on the `workspace.onDidChangeChangeTextDocument` event, it seems like it would need to identify "local" edits, and only generate closing tags as appropriate. That way, each guest doesn't create the same edit that everyone else is already making.

Any thoughts would be greatly appreciated, since the current behavior is definitely a little wonky. Thanks!
Repository: rust
Issue: ambiguous type-dependent name resolution 
Labels: A-trait-system,A-associated-items,T-lang,C-feature-request,T-types

Currently ([playground](https://play.rust-lang.org/?gist=005ffda13df3190067c4f7189856d22a&version=stable&mode=debug)):

```rust
pub struct A<T>(T);
impl A<u32> {
    fn new(x: u32) -> Self { A(0) }
}
impl A<f32> {
    fn new(x: f32) -> Self { A(0.) }
}
fn main() {
    let _ : A<f32> = A::new(0.);  // ERROR
    // let _ = A::<f32>::new(0.); // OK
}
```

errors with:

```
error[E0034]: multiple applicable items in scope
 --> src/main.rs:9:22
  |
9 |     let _ : A<f32> = A::new(0.);
  |                      ^^^^^^ multiple `new` found
  |
note: candidate #1 is defined in an impl for the type `A<u32>`
 --> src/main.rs:3:5
  |
3 |     fn new(x: u32) -> Self { A(0) }
  |     ^^^^^^^^^^^^^^^^^^^^^^
note: candidate #2 is defined in an impl for the type `A<f32>`
 --> src/main.rs:6:5
  |
6 |     fn new(x: f32) -> Self { A(0.) }
  |     ^^^^^^^^^^^^^^^^^^^^^^

error: aborting due to previous error
```

This is probably a feature request but I'd like the `A<f32>` method to be picked in this case and for the program above to compile.

Solving this might require an RFC but I think this is a problem worth solving. 

---

cc @nikomatsakis @eddyb
Repository: rust
Issue: Mutually exclusive traits still cause conflict in blancket implementation
Labels: A-trait-system,T-lang,C-feature-request

The following code

```rust
#![crate_type="rlib"]
#![feature(optin_builtin_traits)]

trait Simple {}
trait Complicated {}

impl<T : Simple> !Complicated for T {}
impl<T : Complicated> !Simple for T {}

trait MyTrait {}

impl<T : Simple> MyTrait for T {}
impl<T : Complicated> MyTrait for T {}
```

refuses to compile with the following error

```console
error[E0119]: conflicting implementations of trait `MyTrait`:
  --> buggy.rs:13:1
   |
12 | impl<T : Simple> MyTrait for T {}
   | ------------------------------ first implementation here
13 | impl<T : Complicated> MyTrait for T {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation

error: aborting due to previous error

For more information about this error, try `rustc --explain E0119`.
```

It should compile: `Simple` and `Complicated` being explicitly defined as mutually exclusive no type can be both, and as such, the implementations do not conflict.

It should work with more than two traits, as long as they are all mutually exclusive.

Building with the latest nightly.

```console
rustc 1.28.0-nightly (01cc982e9 2018-06-24)
binary: rustc
commit-hash: 01cc982e936120acb0424e41de14e42ba2d88c6f
commit-date: 2018-06-24
host: x86_64-unknown-linux-gnu
release: 1.28.0-nightly
LLVM version: 6.0
```
Repository: vue
Issue: Computed Watchers Not Firing
Labels: browser quirks,help wanted

### Version
2.5.16

### Reproduction link
[https://vuejs.org/v2/guide/computed.html#Watchers](https://vuejs.org/v2/guide/computed.html#Watchers)

### Steps to reproduce
Use the demo for entering a question on the Docs page using a Amazon Kindle 7'' or Android Tablet (I used a Lenovo Tab 3 7'' version)
https://vuejs.org/v2/guide/computed.html#Watchers

### What is expected?
When typing in the field the value is evaluated after each letter is tapped when using a browser on a tablet, as per the demo instructions. 

### What is actually happening?
Nothing is evaluated until the space bar is tapped or a question mark / exclamation mark is selected from the keyboard. 

---
I use this to create a drop down list of options when a user starts typing into a text field using Android tablet specifically Amazon Fire.
The user starts typing and after letters are entered the list is shown..
After updating then the list is only shown if the user taps the space bar or the enter key on the on screen keyboard.
This works as expected when using a browser on a computer.
I have tested my code on Mac using Safari, Chrome and Firefox and no errors are in the console. 
On Amazon Fire and it works as expected when on version 2.5.13
Updating my VueJS to version 2.5.16 and this stops working on the tablet and requires the space key, exclamation mark, question mark or enter key to be tapped for the evaluation to fire/run when using the tablet device.

<!-- generated by vue-issues. DO NOT REMOVE -->
Repository: rust
Issue: Support for running the src/ci/docker/run.sh with user namespace
Labels: T-bootstrap,C-feature-request

Hello

When struggling to run the complete build and tests, I decided to try the bundled docker runner. However, I run docker under user namespace, which disables support for `--privileged`. The run script fails:

```
./src/ci/docker/run.sh x86_64-gnu
... <A lot of output> ...
Successfully built 2a8488e739aa
Successfully tagged rust-ci:latest
docker: Error response from daemon: privileged mode is incompatible with user namespaces.  You must run the container in the host namespace when running privileged mode.
See 'docker run --help'.
```

Would it make sense to have some limited mode of the tests that would skip the parts needing the extra syscalls (mentioned [here](https://github.com/rust-lang/rust/blob/master/src/ci/docker/run.sh#L114)) and conditionally disable the privileged mode? Or would it be too much work with very little benefit?

This is on a yesterday's master (01cc982e936120acb0424e41de14e42ba2d88c6f).
Repository: vscode
Issue: Add settings editor commands to focus next and previous settings
Labels: help wanted,feature-request,settings-editor

Issue Type: <b>Bug</b>

1) When the cursor in the search box, <kbd>DownArrow</kbd> moves the keyboard focus to the list of settings. However, <kbd>UpArrow</kbd> does not bring me back to the search box.

2) When the keyboard focus in the TOC, <kbd>RightArrow</kbd> should move the keyboard focus to the closest item in the list of settings.

3) When the keyboard focus is in the list of settings, <kbd>LeftArrow</kbd> should move the keyboard focus to the highlighted node in the TOC.

4) It seems unusal that the section headers and subheaders in the list of settings can take the keyboard focus. It would feel more natural if the headers and subheaders would be skipped.

5) When a settings cells has the keyboard focus, <kbd>Enter</kbd> should move the keyboard focus to the value editor (same as <kbd>Tab</kbd>. <kbd>Shift+Tab</kbd> and <kbd>ESC</kbd> remain to remove it back to the settings row.

VS Code version: Code - Insiders 1.25.0-insider (5d6156a0f8b68fe7e9429facbcfaa7c061a8b3e3, 2018-06-25T09:32:08.937Z)
OS version: Darwin x64 16.7.0

<details>
<summary>System Info</summary>

|Item|Value|
|---|---|
|CPUs|Intel(R) Core(TM) i7-4870HQ CPU @ 2.50GHz (8 x 2500)|
|GPU Status|2d_canvas: enabled<br>flash_3d: enabled<br>flash_stage3d: enabled<br>flash_stage3d_baseline: enabled<br>gpu_compositing: enabled<br>multiple_raster_threads: enabled_on<br>native_gpu_memory_buffers: enabled<br>rasterization: enabled<br>video_decode: enabled<br>video_encode: enabled<br>vpx_decode: enabled<br>webgl: enabled<br>webgl2: enabled|
|Load (avg)|2, 2, 2|
|Memory (System)|16.00GB (1.06GB free)|
|Process Argv|/Users/kmaetzel/Applications/Visual Studio Code - Insiders.app/Contents/MacOS/Electron -psn_0_17449123|
|Screen Reader|no|
|VM|0%|

</details>
<!-- generated by issue reporter -->
Repository: rust
Issue: Re-export from external crate not documented
Labels: T-rustdoc,C-enhancement

c.f. https://docs.rs/hyper/0.12.2/hyper/index.html and https://docs.rs/hyper/0.12.2/hyper/struct.Response.html

Based on that documentation, it appears that `Response` is part of the `hyper` crate, when it's definition there is https://github.com/hyperium/hyper/blob/master/src/lib.rs#L39-L48 (pub use from `http`).

This was especially confusing to me because I wanted to pass the result of `Response::builder()` between functions in my own code. I was surprised to discover that I'd need to add `http` as a direct dependency in my Cargo.toml.

The `pub use` lines referring to internal modules within `hyper` are reported that way, but the re-exports from `http` are both not listed in the "Re-exports" section, and they're presented as if they were defined in `hyper`.
Repository: rust
Issue: Confusing behavior around unsized return values in traits
Labels: C-enhancement,A-trait-system,A-DSTs,T-lang

The following traits are accepted, ~~but not object safe~~:
```rust
pub trait MyTrait {
    fn deserialize(input: u32) -> Self;
}
pub trait YourTrait {
    type Output: ?Sized;
    fn deserialize(&self, input: u32) -> Self::Output;
}
```
On the other hand, the following traits are rejected saying `the trait bound Self: std::marker::Sized is not satisfied`:
```rust
pub trait MyTrait {
    fn deserialize(input: u32) -> Option<Self>;
}
pub trait YourTrait {
    type Output: ?Sized;
    fn deserialize(&self, input: u32) -> Option<Self::Output>;
}
```
The error makes sense in principle, but

* (a) it is really confusing that it is okay to have unsized return types (where usually the same check would apply!), but not return enums with unsized types inside them. What seems to happen here is that there is a special rule if the return type is unsized to drop object safety (if the type is `Self`) or do nothing (otherwise) instead of complaining.
* (b) The fix is far from obvious: One has to add `Sized` as a supertrait to `MyTrait`. Given that `Sized` is usually added implicitly, people will run into this without ever having dealt with `Sized` before (and in fact, that's what just happened when a friend asked me about this). The error will certainly not help with finding this.

Both of these points would be fixed if that exception for unsized argument/return types would be extended to also cover the above cases.
Repository: go
Issue: proposal: os: API to detect that the read end of a pipe was closed
Labels: Proposal

Currently there is no API in Go to detect that the read end of a pipe was closed without writing to the pipe a non-empty slice. This prevents, for example, to write in a safe Go a version of GNU tail utility that exits immediately when it detects that the read end of its stdout was closed even when it waits for more input like when it is called via `tail -f`. For example, given the following case:

tail -f file-to-follow | grep -q foo

GNU tail exits immediately after the grep finds the word _foo_ and terminates without waiting that the file-to-follow will be extended and trying to write those extra bytes to stdout.

Yet to write such functionality in Go one needs to use unsafe code to call sys.Select or similar and wait for an syscall.EPIPE from the stdout descriptor.

### What version of Go are you using (`go version`)?
go1.10.3

### Does this issue reproduce with the latest release?
Yes

### What operating system and processor architecture are you using (`go env`)?
amd64 linux fedora-28
Repository: pytorch
Issue: Todo functions and autograd supports for Sparse Tensor
Labels: module: sparse,triaged

Here summarizes a list of requested Sparse Tensor functions and autograd supports from previous PRs. Please feel free to comment on functions that should be added also.

## Functions
- [x] `sum()` with autograd https://github.com/pytorch/pytorch/pull/12430
- [ ] `max()` with autograd
- [x] `log1p()` https://github.com/pytorch/pytorch/pull/8969
- [x] `S.copy_(S) with autograd ` https://github.com/pytorch/pytorch/pull/9005
- [ ] indexing (`gather()`, `index_select()`)
- [ ] `mul_(S, D) -> S`, `mul(S, D) -> S` with autograd
- [x] `cuda()`
- [ ] `nn.Linear` with autograd (SxS, SxD, relies on `addmm` and `matmul`)
- [x] `softmax()` with autograd (same as in [TF](https://www.tensorflow.org/api_docs/cc/class/tensorflow/ops/sparse-softmax): Applies softmax() to a region of a densified tensor submatrix; (2) Masks out the zero locations; (3) Renormalizes the remaining elements. SparseTensor result has exactly the same non-zero indices and shape)
- [x] `to_sparse()` #12171
- [x] `narrow_copy()` https://github.com/pytorch/pytorch/pull/11342
- [ ] `sparse_mm(S, D) -> D` with autograd
- [x] `cat()` https://github.com/pytorch/pytorch/pull/13577
- [x] `unsqueeze()`, `stack()` https://github.com/pytorch/pytorch/pull/13760

### Wish list
- `bmm(S, D)` (add an extra sparse dim at `indices` of SparseTensor as batch dim?)
- broadcasting `mul(S, D) -> S`
- `Dataset`, `Dataloader`
- `save`, `load` for sparse tensors

## Existing
- autograd supported for `values()` via https://github.com/pytorch/pytorch/pull/13001 (Thanks to @SsnL!), that means all element-wise ops are supported in sparse now
- norm (cannot take `dim` args)
- pow
- clone
- zero_
- t_ / t
- add_ / add(Sparse, Sparse, Scalar) -> Sparse
- add_ / add(Dense, Sparse, Scalar) -> Dense
- sub_ / sub(Sparse, Sparse, Scalar) -> Sparse
- mul_ / mul(Sparse, Sparse) -> Sparse
- mul_ / mul(Sparse, Scalar) -> Sparse
- div_ / div(Sparse, Scalar) -> Sparse
- addmm(Dense, Sparse, Dense, Scalar, Scalar) -> Dense
- sspaddmm(Sparse, Sparse, Dense, Scalar, Scalar) -> Sparse
- mm(Sparse, Dense) -> Dense
- smm(Sparse, Dense) -> Sparse
- hspmm(Sparse, Dense) -> HybridSparse
- spmm(Sparse, Dense) -> Dense
Repository: go
Issue: x/build: add js/wasm Chrome/Firefox capable trybot
Labels: Builders,NeedsFix,FeatureRequest,arch-wasm,new-builder

Follow on from https://github.com/golang/go/issues/26015#issuecomment-400029578

With a Chrome and/or Firefox capable trybot we'd be able to do more interesting WASM tests in a headless browser-based JS VM, and so have access to the DOM etc.

This issue is to decide whether or not such a trybot would be useful and therefore worth the effort.
Repository: flutter
Issue: SeekControl action support for TalkBack
Labels: c: new feature,platform-android,framework,engine,a: accessibility,P2,team-android,triaged-android

On Android you can select a SeekControl (Slider in Flutter) and open the local context menu to select an exact value.  Unclear currently if we need to support this with our own local context action or with some additional hooks in the accessibility bridge
Repository: pytorch
Issue: Use target_compile_options to set warning flags
Labels: module: build,triaged

They are currently set via `CMAKE_CXX_FLAGS` in root `CMakeList.txt`.

Just opening an issue to track this. It isn't high-pri.

cc @malfet @seemethere @walterddr @goldsborough @orionr
Repository: vscode
Issue: Safe File Delete
Labels: feature-request,api,editor-code-actions

Add a "safe delete" option for files that gives option to check for file usage in comments/strings **and/or** text occurrences. If usages found, it will display an additional warning before deleting the file.

[Feature example](https://www.jetbrains.com/help/phpstorm/safe-delete.html) exists in WebStorm.
Repository: pytorch
Issue: Issues with dynamically created grad_fn for views
Labels: module: autograd,triaged,module: viewing and reshaping

Currently the dynamically created `grad_fn` to point to `base`. When a view is created via 
```py
base = torch.randn(3, requires_grad=True)
view1 = base[:2]
my_view = view1[:]
```
Then, if `base` is modified in-place, the `grad_fn` of `my_view` will be created to just point to `base`. Then the `retain_grad` and backward hooks on `view1` will be wrong.

E.g.,
```py
x = torch.ones(4, requires_grad=True).clone()
xx = x[2:]
y = xx[1]
xx.retain_grad()
#x[0] += 0
y.backward()
xx.grad
```

(Un)comment the line `x[0] += 0` changes the grad of `xx`.

This was previously reported at #8626 , but that also describes another unrelated (now solved) issue. So I'm opening a new one to track this.

cc @ezyang @albanD @zou3519 @gqchen @pearu @nikitaved @soulitzer
Repository: opencv
Issue: make install doesn't create bin/ after platforms/js/build_js.py
Labels: priority: low,category: build/install,RFC,category: javascript (js)

```
git clone https://github.com/opencv/opencv
cd opencv
mkdir build
cd build
pwd
#prints: /Users/username/opencv/build
python ../platforms/js/build_js.py . --build_wasm
DESTDIR=/tmp/build make install
ls /tmp/build/Users/username/opencv/build/install/
include
lib
share
```

error: no bin/ created (that's where opencv.js etc is created), so we have to keep the build around, seems like a bug.
Repository: godot
Issue: Keyboard interrupt no longer stops the command line debugger
Labels: bug,enhancement,topic:editor,topic:porting,confirmed

Godot master ff01fd57bc19d9f4cb3929dbee87cdd9eda578e1
Windows 10 64 bits
Powershell

In Godot 3.0.4, I used to debug my plugin by using the command line debugger (`-e -d command line options`), and using Ctrl+C (keyboard interrupt) to break out of a script error and close Godot straight away. This was fast and also left the terminal open, allowing me to keep track of the logs and easily restart the session without retyping commands.

Now I wanted to debug it using a build I made from master, but I noticed keyboard interruption no longer stops the process. Instead, the debugger just repeats the error. I tried using `q` for quitting, but it didn't quit and stayed blocked on the last script error, so the only way I could close was to close the terminal...
Repository: flutter
Issue: SwitchListTile's constructor's leading element param should be named "leading" to be consistent with ListTile
Labels: framework,f: material design,c: API break,a: quality,P3,team-design,triaged-design

This use case came up in our app and there's no way to accomplish this. We'll use `ListTile` for now.