sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: go
Issue: cmd/compile: constant indexing to private array should be folded
Labels: Performance,NeedsFix,compiler/runtime

Lookup tables are quite common, as in https://golang.org/src/math/bits/bits_tables.go. However none of functions that rely on those tables can be constant folded.

Simplest example is https://go.godbolt.org/z/MhMTqb which compiles to:

```
movblzx math/bits.rev8tab+12(SB), AX
movb    AL, "".~r0+8(SP)
```

The `rev8tab` only contains indexing to that table, so it should be possible to prove that the array is not being modified. Of course that only holds, when assignment, slicing or addressing operator is not used.

If such table is replaced with a string, then the constant folding does work. However, that seems like an ugly hack to have.

Related Issues:
* https://github.com/golang/go/issues/10848
* https://github.com/golang/go/issues/21872
Repository: pytorch
Issue: Support DDP find_unused_parameters=True mode when combined with Pipe
Labels: oncall: distributed,triaged,module: rpc,module: ddp

Currently [`pipe.forward()`](https://github.com/pytorch/pytorch/blob/master/torch/distributed/pipeline/sync/pipe.py#L326) returns `RRef`. However, DDP does not understand RRef, and does not extract Tensors from `RRef`. As a result, DDP cannot traverse the autograd graph from an `RRef` to identify unused parameters. Today, if we combine Pipe with DDP and set `find_unused_parameter=True`, DDP would treat all parameters as unused, and then hit the "cannot mark the same variable as ready twice" error. To fix this, we might need to let DDP check if the input module is a pipe instance and handle it's output accordingly.

cc @pietern @mrshenli @pritamdamania87 @zhaojuanmao @satgera @gqchen @aazzolini @rohan-varma @jjlilley @osalpekar @jiayisuse @agolynski @SciPioneer @H-Huang @mrzzd
Repository: godot
Issue: call_group() does not always call all nodes in the group
Labels: bug,topic:core,confirmed

<!-- Please search existing issues for potential duplicates before filing yours:
https://github.com/godotengine/godot/issues?q=is%3Aissue
-->

3.2.3 stable official
<!-- Specify commit hash if using non-official build. -->


**OS/device including version:**
<!-- Specify GPU model, drivers, and the backend (GLES2, GLES3, Vulkan) if graphics-related. -->

Windows 10 x64
**Issue description:**
<!-- What happened, and what was expected. -->

I have a part in my code, where I want to execute a method on all nodes in a group.  The method which includes the `call_group()` is initiated by a signal from one of the nodes in that group.

In some special circumstance, which I'm not exactly certain about, the `call_group()` will call the method on all nodes **except** the node which sent the original signal. 

However, I can make the `call_group()` work with the following two workarounds:

* Change `call_group()` to `call_group_flags(SceneTree.GROUP_CALL_UNIQUE, ...)`
* Use a for loop like so `for node in cfc.get_tree().get_nodes_in_group("group_name"):`

Both of the above will correctly execute on all nodes, including the one sending the signal. All other flags for `call_group_flags()` also fail to execute on the signaling node.

This also works when I trigger the signal in a slightly different set of behaviours. Please see me reproduction info.
**Steps to reproduce:**

So, this is quite tricky to replicate in a minimal project as it seems to work normally, but I seem to have crafted a situation where I can make it appear only if I trigger the signal with a specific setup.

As I cannot craft a minimal product, I have instead created a branch in my repo which I have prepared so that this bug is immediately reproducible: https://github.com/db0/godot-card-game-framework/tree/GROUP_CALL_UNIQUE-bug

To reproduce: 
1. Clone my git repo and checkout the `GROUP_CALL_UNIQUE-bug` branch
2. Run main scene with F5
1. A hand of 5 blue cards will appear. 
1. Drag  a blue card from the hand anywhere on the board. It will be placed in the PlacementGridDemo and 6 "bio" tokens appear correctly.
1. Drag a blue card from the hand  specifically inside the "PlacementGridDemo" area. You will see only 2 "bio" tokens appear. However the code is setup so that 6 should appear. One via each `call_group_flags()` flag, one via `call_group()` and one via the for loop.

I have replicated this with simple prints as well, so it's not an issue with the "token adding" code. The `execute_scripts()` function is really not called at all on the trigger card. This way is just easier to see visually.

The 6 group calls are defined in [res://src/core/CFControl.gd Line 234](https://github.com/db0/godot-card-game-framework/blob/0de92e21db129a64f20b5bdcb9fb304628afdd18/src/core/CFControl.gd#L234)
You can see that they all originate in the same spot and are called in the same manner. But for some reason, 4 out of 6 fail to execute on

Apologies for the complexity of this report, but I couldn't find a better way to report it.
Repository: flutter
Issue: [web] Add test case for bitmap canvas paint queue
Labels: a: tests,platform-web,P3,c: tech-debt,team-web,triaged-web

See issue https://github.com/flutter/flutter/issues/72171 as example.
Repository: svelte
Issue: Trying to build Web Components for SVG should produce a warning/error
Labels: feature request,stale-bot,temp-stale

Web Components are HTML only and not supported in the SVG namespace.

- [Do Custom Elements / WebComponents work with SVG?](https://stackoverflow.com/questions/40436059/do-custom-elements-webcomponents-work-with-svg) (StackOverflow)
- [Proposal: Allow custom elements to be in any namespace](https://github.com/WICG/webcomponents/issues/634) (WICG/webcomponents)

However, users such as me might not know this, and it would be helpful if the Svelte compiler told us so.


**Describe the bug**
Currently (Dec 2020), Svelte compiles a source with `<svelte:options namespace="svg" tag="svsv-draggable" />` quietly.

The output contains:

```
SvelteElement = class extends HTMLElement {
```

This is enough to convince me that the code tries to make an HTML Web Component, but I haven't fully traced the output.

**Expected behavior**
Give the user a nice message, saying what we're trying to reach is not currently possible. 

**Information about your Svelte project:**

- Svelte version: 3.31.0
- Whether your project uses Webpack or Rollup: Rollup

**Severity**
Not severe. Helpful.

**Additional context**
Add any other context about the problem here.
Repository: go
Issue: net/textproto: missing/incorrect arg in error string.
Labels: NeedsInvestigation

<!--
Please answer these questions before submitting your issue. Thanks!
For questions please use one of our forums: https://github.com/golang/go/wiki/Questions
-->

### What version of Go are you using (`go version`)?

go version go1.15.6 linux/amd64

### Does this issue reproduce with the latest release?

yes, when I ingest/read an SMTP delivered message with net/mail (as a NewMessage())

### What operating system and processor architecture are you using (`go env`)?
$ go env
GO111MODULE=""
GOARCH="amd64"
GOBIN=""
GOCACHE="/home/morrowc/.cache/go-build"
GOENV="/home/morrowc/.config/go/env"
GOEXE=""
GOFLAGS=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOINSECURE=""
GOMODCACHE="/home/morrowc/go/pkg/mod"
GONOPROXY=""
GONOSUMDB=""
GOOS="linux"
GOPATH="/home/morrowc/go"
GOPRIVATE=""
GOPROXY="https://proxy.golang.org,direct"
GOROOT="/usr/lib/<zippy>"
GOSUMDB="sum.golang.org"
GOTMPDIR=""
GOTOOLDIR="/usr/lib/<zippy>/pkg/tool/linux_amd64"
GCCGO="gccgo"
AR="ar"
CC="clang"
CXX="clang++"
CGO_ENABLED="1"
GOMOD=""
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 -fmes

### What did you do?

Read an email message from a named-pipe (file would also work), parse into a NewMessage():
```
   // n == 'server'
   //  pipe here is a pd, err := os.OpenFile(pn, os.O_RDONLY, os.ModeNamedPipe)
   msg, err := mail.ReadMessage(n.pipe)
```

### What did you expect to see?
'not an error' ...


### What did you see instead?

```
E1228 21:55:30.838373   21601 nmsg_smtp.go:94] failed to ReadMailMessage, error: malformed MIME header: missing colon: %!q(MISSING)������Ƽ������˲�����������롢��ۻ�������ۼ�У��ASK��У�����ʼ�У������
```

example message is available at:
  http://docs.as701.net/tmp/golang_issue_example_msg.txt

The process to jam patches in here is .. more than I want to do on vacation, but:

```bash
$ diff --git a/src/net/textproto/reader.go b/src/net/textproto/reader.go
index 5c3084f8a7..f39b9237d4 100644
--- a/src/net/textproto/reader.go
+++ b/src/net/textproto/reader.go
@@ -556,7 +556,7 @@ func noValidation(_ []byte) error { return nil }
 // contain a colon.
 func mustHaveFieldNameColon(line []byte) error {
        if bytes.IndexByte(line, ':') < 0 {
-               return ProtocolError(fmt.Sprintf("malformed MIME header: missing colon: %q", line))
+               return ProtocolError(fmt.Sprintf("malformed MIME header: missing colon: %q", string(line)))
        }
        return nil
 }
```

that would almost certainly fix the error's missing / wrong type of arg.
Repository: pytorch
Issue: Test functionality to detect extra cross device synchronizations
Labels: module: cuda,module: tests,triaged

See https://github.com/pytorch/pytorch/issues/49758 for an example (this particular example turns out to not have extra cross device synchronizations).  But it would be good to give ourselves confidence that this isn't the case generally (outside of operators that require them, like `nonzero`).

This could perhaps also be expanded to catch cases where there are extra dispatches, but not extra cross-device synchronizations, as in the above example.

cc @ngimel @mruberry @VitalyFedyunin @walterddr
Repository: godot
Issue: DebugFlags are used by EditorExportPlugin, but they are not exposed
Labels: bug,discussion,topic:editor,topic:plugin

<!-- Please search existing issues for potential duplicates before filing yours:
https://github.com/godotengine/godot/issues?q=is%3Aissue
-->

**Godot version:**
<!-- Specify commit hash if using non-official build. -->
a04b966

**Issue description:**
<!-- What happened, and what was expected. -->
I noticed that `_export_begin()` in EditorExportPlugin has a mysterious `flags` argument which is an int. After investigation, it's supposed to be `DebugFlags` from `editor_export.h`, but they are nowhere exposed, so the user can't use them. Either we should expose the flags or remove the argument, because it doesn't look useful.
Repository: godot
Issue: Crash on startup when second monitor is connected to a USB dock
Labels: bug,platform:windows,topic:core,crash

**Godot version:**
v3.2.3 (Godot_v3.2.3-stable_win64.exe)

**OS/device including version:**
Windows 10 Version 2004
Intel UHD Graphics 630 / GeForce GTX 1650 (on a laptop)
Dell Universal Dock D6000

**Issue description:**
Godot crashes on startup when a second monitor is connected through a Dell USB-C dock.  Running Godot from the command prompt, it crashes without any errors.

Other things I have tried:

1. Godot launches fine if the second monitor is connected directly to the HDMI port on the laptop.
2. Having the USB hub connected without any monitors connected to it does not cause the issue.
3. On the USB hub, it doesn't matter whether the monitor is connected to a HDMI or DisplayPort (it crashes on either one).
4. If Godot is launched, and the monitor is only then connected to the USB hub, Godot stays open. However, when a project is created, it crashes (without an error).

**Steps to reproduce:**
Have a monitor connected through the USB dock, start Godot.
Repository: pytorch
Issue: [RFC] Speed up python function and arg serialization in RPC APIs
Labels: oncall: distributed,triaged,module: rpc

## 🚀 Feature
In our current RPC APIs (rpc_sync, async, rpc.remote), we first serialize (pickle) the function, argument, and kwargs being sent to the destination worker, and pass this serialized representation as a string in C++ to construct our notion of a `SerializedPyObj`. This is done so that we can send these bytes across the network and reconstruct the needed information on the remote end.

We have noticed some slowness in this python serialization, namely in use cases with a large number of remote trainers being set up as an RRef on a master/parameter server node. In setups like these, the following pattern is quite common:

```
# On parameter server
model = create_model(...)
for trainer_name in trainers:
    trainer_rref = rpc.remote(
        _setup_model_on_trainer,
        model,
        ...additional arguments, expensive to serialize
    )
```

Note that in the loop while the dst worker is different, the function and arguments being serialized are the same. This may mean that caching the serialized representation from call to call could be useful, speeding up the end to end latency. For speeding up individual calls, we can look into parallelizing the serialization, which will be more complex than simple caching as the parallelization would have to be implemented in the C++ layer.

A very basic demo can be found here: https://github.com/pytorch/pytorch/pull/49910, where we test the caching hypothesis on a workload where serialization is quite expensive. We see about a 50% reduction in overall latency in this basic sample case.

## Motivation
In some training workloads, we have noticed serialization taking up a large portion of time when initializing the setup discussed above. Since many of these workloads follow the pattern above, caching/parallelization should be a good candidate to speed this up. 

## Pitch
Implement caching similar to the demo here: https://github.com/pytorch/pytorch/pull/49910 and evaluate its impact on the above described workloads. If parallelization across arguments in individual calls also sounds like it makes sense and is likely to result in a speedup, we can discuss a concrete implementation plan to move the pickling into C++ to take advantage of multiple cores.


cc @pietern @mrshenli @pritamdamania87 @zhaojuanmao @satgera @gqchen @aazzolini @rohan-varma @jjlilley @osalpekar @jiayisuse @agolynski @SciPioneer @H-Huang @mrzzd
Repository: create-react-app
Issue: Output .js under a known name
Labels: issue: proposal,needs triage

### Is your proposal related to a problem?

I can't use the result of an app built with your `build` command from third-party software because the name of the `*.js` file is random. I want to include an `App` as a component in a non-React HTML page, and you made it hard.


### Describe the solution you'd like

Please add an option to output the `.js` file under a fixed name (chosen by the user).

### Describe alternatives you've considered

After building to scan `build/` directory and find out the `.js` file name.
Repository: three.js
Issue: Dispose of loaders
Labels: Enhancement,Loaders

<!-- Ignoring this template may result in your feature request getting deleted -->

**Is your feature request related to a problem? Please describe.**

Often, loaders for various file formats (e.g. GLTFLoader, ImageLoader, etc.) are used early in a site life cycle and then not needed anymore, but sometimes they leave resources in use that could be cleaned up. Specifically, loaders that use web workers will leave those threads running in the background.

**Describe the solution you'd like**

I'd like to see modern and widely used loaders have a `dispose` method that cleans up any existing resources, like running web workers or files cached in memory. Ideally, any downloads in progress will be aborted. I see FileLoader still uses XMLHttpRequest, which has broad support for `.abort`.

**Describe alternatives you've considered**

We could expose underlying resources on the different loader objects, but that would be unwieldy and brittle since each loader would have different resources.

**Additional context**

This seems related to #18234 and possibly dependent upon #19650. I don't see this specific ability mentioned in that issue or in that pull request in progress, so I figured I'd file it separately.

Thank you.
Repository: rust
Issue: Rustdoc does not show blanket impls with negative polarity
Labels: T-rustdoc,C-bug,F-negative_impls

I tried this code:

```rust
#![feature(negative_impls)]
pub struct S {}

pub trait Trait {}
impl<T> !Trait for T {}
```

I expected to see this happen: Rustdoc shows `impl !Trait for S` on the documentation for S, the same way it shows `impl<T> Any for T`.

Instead, this happened: Rustdoc does not show the blanket implementation.

### Meta
<!--
If you're using the stable version of the compiler, you should also check if the
bug also exists in the beta or nightly versions.
-->

`rustdoc --version`: rustdoc 1.50.0-nightly (0edce6f4b 2020-12-24)

<!-- TRIAGEBOT_START -->

<!-- TRIAGEBOT_ASSIGN_START -->

<!-- TRIAGEBOT_ASSIGN_DATA_START$${"user":null}$$TRIAGEBOT_ASSIGN_DATA_END -->

<!-- TRIAGEBOT_ASSIGN_END -->
<!-- TRIAGEBOT_END -->
Repository: ant-design
Issue: Tree 设置虚拟滚动容器高度，设置后拖动内部节点支持竖向滚动
Labels: Inactive

- [ ] I have searched the [issues](https://github.com/ant-design/ant-design/issues) of this repository and believe that this is not a duplicate.

### What problem does this feature solve?
拖动节点至视高外节点时触发竖向滚动，以便实现拖动节点至视高外

### What does the proposed API look like?
拖动和虚拟滚动组合功能，暂无API


<!-- generated by ant-design-issue-helper. DO NOT REMOVE -->
Repository: PowerToys
Issue: [Image Resizer] Compress a picture to a certain file size, such as 1MB
Labels: Idea-Enhancement,Product-Image Resizer

## 📝 Provide a description of the new feature

Image resizer only supports pixels now (such as 854x480 pixels). However, sometimes I want to resize a picture to a certain file size (such as 1MB). For example, some websites only supports uploading pictures less than 1MB. I hope that I can input "1MB" and Image resizer automatically resizes my picture to exactly (or slightly smaller than) 1MB.

---

If you'd like to see this feature implemented, add a 👍 reaction to this post.
Repository: rust
Issue: Wrong diagnostic: `Type` must be annotated `#[derive(PartialEq, Eq)]` to be used as the type of a const parameter
Labels: A-diagnostics,T-compiler,C-bug,A-const-generics,requires-nightly,D-incorrect

I tried [this](https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=59dec1bc6a73dac68eb014bcfaa9f112) code:

```rust
#![feature(const_generics)]

#[derive(PartialEq, Eq)]
enum Nat {
    Z,
    S(Box<Nat>)
}

fn foo<const N: Nat>() {}
```

And got this error:
```
error[E0741]: `Nat` must be annotated with `#[derive(PartialEq, Eq)]` to be used as the type of a const parameter
 --> src/lib.rs:9:17
  |
9 | fn foo<const N: Nat>() {}
  |                 ^^^ `Nat` doesn't derive both `PartialEq` and `Eq`
```

The code without the const parameter compiles, though:
```rust
#![feature(const_generics)]

#[derive(PartialEq, Eq)]
enum Nat {
    Z,
    S(Box<Nat>)
}

// fn foo<const N: Nat>() {}
``` 

### Meta
`rustc +nightly --version --verbose`:
```
rustc 1.50.0-nightly (0edce6f4b 2020-12-24)
binary: rustc
commit-hash: 0edce6f4bbb4514482537f569f0b8ef48e71e0a0
commit-date: 2020-12-24
host: x86_64-apple-darwin
release: 1.50.0-nightly
```
Repository: node
Issue: WebAssembly compiled module cache
Labels: feature request,wasm

**Is your feature request related to a problem? Please describe.**

Large WASM modules take a while to compile, impacting startup times. Browsers solve this problem by caching compiled module data.

WebAssembly is a promising media for software distribution. It makes sense to compile for WebAssembly once, instead of shipping multiple binaries for each supported CPU architecture / OS pair, doesn't it? There's a growing number of tools targeting this particular segment, e.g. https://wasmer.io.

Node.js has unique advantages as a WASM runner:

 * WASI as a standardised interface for interfacing with the OS (e.g. accessing files, etc.) is insufficient for most practical needs. With Node, one can leverage a plethora of high quality battle-tested cross platform libraries.

 * V8 is top notch! It beats competing WASM engines in terms of compile times, resource consumption and the footprint of compiled WASM files (a single data point: V8 produces 160MiB for a 50MiB WASM file, a competitor generates 1+GiB).

 * NPM is super robust. Competitors have their own package managers but not particularly reliable ones.

The only component missing in Node.js is a compiled module cache.

It takes 47s to compile the previously mentioned 50MiB WASM file. With a cache POC, the startup time is reduced to under 1s.

**Describe the solution you'd like**

```js
require('wasm/cache').loadFile('module.wasm')
```

as a cache-enabled moral equivalent of

```js
WebAssembly.compile(require('fs').readFileSync('module.wasm'))
```

Cache files to be stored in OS-mandated cache directory, e.g. `~/.cache/node/wasm-cache` on Linux.

**Describe alternatives you've considered**

It used to be possible to serialise a WebAssembly module to a file explicitly. #18265

It stopped working since Node.js 13 due to changes in V8 and there's no way to make it work again.

Instead of introducing a new API, it is possible to enhance `WebAssembly.compile`/`WebAssembly.compileStreaming`. Unfortunately, it's hard to come up with a good cache key. We could `sha256` the data, but that's inefficient.
Repository: node
Issue: http: OutgoingMessage ERR_STREAM_DESTROYED callback
Labels: http,stream

`OutgoingMessage` should invoke the callback for `_writeRaw` with `ERR_STREAM_DESTROYED` when the it's already been destroyed.

Refs: https://github.com/nodejs/node/pull/29227#issuecomment-752045611
Repository: go
Issue: x/tools/gopls: improve command-line UX when checking files outside of the current module
Labels: gopls,Tools


<pre>
$ go version
go version go1.15.6 darwin/amd64
</pre>

To reproduce, in the `tools` repository:
```
$ cd gopls
$ gopls check ../internal/lsp/cmd/cmd.go
2020/12/29 08:28:38 Error:2020/12/29 08:28:38 warning: diagnose package: no package for golang.org/x/tools/internal/lsp/cmd
	snapshot=1
	package="golang.org/x/tools/internal/lsp/cmd"
```
but it never finishes. Contrast this with
```
$ cd gopls
gopls check main.go
```
which returns immediately.
Repository: ant-design
Issue: Slider loses focus sometimes when mousedown outside of the handle
Labels: Inactive

- [x] I have searched the [issues](https://github.com/ant-design/ant-design/issues) of this repository and believe that this is not a duplicate.

### Reproduction link
[https://ant.design/components/slider/](https://ant.design/components/slider/)

### Steps to reproduce
1. Move the first example Slider to position 80.
2. Now hover your mouse to position ~95
3. Click and hold down the mouse
4. Move mouse side-to-side  (Slider is not moving, but is fixed at the position where mouseDown was triggered)

### What is expected?
Expected to be able to move the slider side-to-side no matter where I trigger mouseDown

### What is actually happening?
It goes to mouseDown position and is losing focus on the slider (if I hover over text it will select the text)

| Environment | Info |
|---|---|
| antd | 4.9.4 |
| React | 17 |
| System | MacOS Catalina 10.15.6 |
| Browser | Google Chrome 87.0.4280.88 |

---
This is happening with a few other positions as well.

Example GIFs
![SliderBug](https://user-images.githubusercontent.com/8721312/103288608-e734b500-49ed-11eb-8b5e-57d2f489d780.gif)



<!-- generated by ant-design-issue-helper. DO NOT REMOVE -->
Repository: PowerToys
Issue: [KBM] Move "+" [adding] button to top versus bottom of list
Labels: Idea-Enhancement,Product-Keyboard Shortcut Manager,Area-User Interface,Cost-Small

When I have lot of shortcuts, and then I add a new one. 
I must turn to the bottom of the page, click the ➕ button.
PLS TAKE THE ➕ BUTTON TO THE TOP. 
THANK YOU!