sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: opencv
Issue: app crashes due to igd11dxva64 (msmf backend)
Labels: category: videoio(camera),platform: win32

<!--
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).

Please:

* Read the documentation to test with the latest developer build.
* Check if other person has already created the same issue to avoid duplicates. You can comment on it if there already is an issue.
* Try to be as detailed as possible in your report.
* Report only one problem per created issue.


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 => 4.1.1
- Operating System / Platform => Win10 64
- Compiler => vc15

##### Detailed description

My app which uses opencv and its msmf backend to access webcam crashes sometimes without no error message silently. the crashpad handler send minidump with online one method in the active thread. 
"igd11dxva64"
For what I could find or assume it would be something with directx, maybe the dxva hardware accelaration for msmf. but this bug also happens when I disable the msmf dxva. So I am quite confused. I also tried to disable build with directx. Maybe there is a bug in cmake script and the flag is not used while cmake generates the project with dxva support. Maybe it is a bug in msmf itself. It happens while opening a camera or receiving a frame, this I am not sure. It happens like one in a thousand camera use. Not so often, but still not pleasant for users.

##### 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
-->
Repository: vscode
Issue: Turn off RTL for syntactical characters in bidi lines
Labels: feature-request,editor-RTL

I am editing a document that has English, Hebrew, and Arabic in it.  The cursor movement is based on the language the cursor is on so it jumps in different directions.  Inserting and appending text is also unpredictable.

For example, if a line is:
`Peace | שלום | `
and I paste at the end of the line :
`سلام` 
It will become:
`Peace | שלום | سلام`
I want it to be:
`Peace | سلام | שלום `
Editing the line is also difficult.

Here is a similar request on SO:
https://stackoverflow.com/questions/54538844/disable-right-to-left-editing-in-vscode-in-mixed-language-files

I'd like the ability to easily turn on and off RTL while I'm editing or have the ability to override RTL for the entire document.
Repository: godot
Issue: Particles editor plugin generate emission point from mesh file broken
Labels: bug,topic:editor,topic:particles

**Godot version:** 3.1.0

**OS/device including version:** Windows 10 (Irrelevant)

**Issue description:** When creating emission points from a mesh they won't get generated and this error will appear: "core/object.cpp:1238 - Error calling method from signal 'file_selected': 'ParticlesEditor::_resource_seleted': Method not found." besides the method not being spelled correctly, from reading the source it looks like it doesn't even exist?

**Steps to reproduce:** Create Particle node, select it, click on Create Emission Points From Mesh,
select the mesh file and the error will appear.
**Minimal reproduction project:** (Reproducing its simple and such is irrelevant)

And yes, generating from a MeshInstance node works fine. So it would be a really low priority issue.
Repository: rust
Issue: Re-land early syntax feature gating (was: Some features can no longer be controlled by conditional compilation)
Labels: T-lang,T-compiler,A-ast

https://github.com/rust-lang/rust/pull/66004 fixed the original issue; now this tracks re-landing those checks (possibly after some transition period).

### Original issue

At https://github.com/RalfJung/miri-test-libstd/, I have set things up such that one can run the libcore and liballoc test suite against Miri. The basic idea is to have a `Cargo.toml` file like this (very close to the normal one for libcore):
```

[package]
authors = ["The Rust Project Developers"]
name = "core_miri_test"
version = "0.0.0"
autotests = false
autobenches = false
edition = "2018"

[lib]
name = "core_miri_test"
path = "../libcore/lib.rs"
test = false
bench = false

[[test]]
name = "coretests"
path = "../libcore/tests/lib.rs"

[dev-dependencies]
rand = "0.7"
```
Then I make `../libcore` a symlink to the actual libcore sources, cd into the dir with the above `Cargo.toml`, and run `cargo miri test`. This worked fine until recently (until nightly-2019-10-17, to be precise).

But since then something broke, and now [I get lots of build failures](https://travis-ci.org/RalfJung/miri-test-libstd/builds/603417659?utm_medium=notification&utm_source=email):
```
error[E0658]: associated type bounds are unstable
   --> core_miri_test/../libcore/pin.rs:445:15
    |
445 | impl<P: Deref<Target: Unpin>> Pin<P> {
    |               ^^^^^^^^^^^^^
    |
    = note: for more information, see https://github.com/rust-lang/rust/issues/52662
    = help: add `#![feature(associated_type_bounds)]` to the crate attributes to enable

error[E0658]: associated type bounds are unstable
   --> core_miri_test/../libcore/pin.rs:754:18
    |
754 | impl<P: DerefMut<Target: Unpin>> DerefMut for Pin<P> {
    |                  ^^^^^^^^^^^^^
    |
    = note: for more information, see https://github.com/rust-lang/rust/issues/52662
    = help: add `#![feature(associated_type_bounds)]` to the crate attributes to enable
```
I tried adding these feature gates to every crate root I could think of (the `lib.rs` of both libcore and its test crate), but the errors are sticking. Unfortunately the error doesn't tell me which file *it* thinks is the crate root.

Any idea what this could be caused by? Until this is fixed, we won't have Miri coverage of the libcore and liballoc test suite.
Repository: rust
Issue: Allow unused_must_use on result with never type
Labels: C-enhancement,A-lints,T-lang,F-never_type

```rust
#![feature(never_type)]

fn will_not_fail() -> Result<i32, !> {
    Ok(5)
}

pub fn main() {
    will_not_fail();
}
```
This code yields a warning:

```
warning: unused `std::result::Result` that must be used
 --> main.rs:8:5
  |
8 |     will_not_fail();
  |     ^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_must_use)]` on by default
  = note: this `Result` may be an `Err` variant, which should be handled
```

However since a `Result<T, !>` can never have the `Err` branch, having to handle the resulting error seems kind of pointless. Would it be possible to disable the `unused_must_use` lint for this particular case?
Repository: youtube-dl
Issue: Hi Appreciate if you help download videos from the site -https://olympus.greatlearning.in/courses/4971/pages/unstructured-data-course-introduction?module_item_id=250532
Labels: site-support-request

<!--

######################################################################
  WARNING!
  IGNORING THE FOLLOWING TEMPLATE WILL RESULT IN ISSUE CLOSED AS INCOMPLETE
######################################################################

-->


## Checklist

<!--
Carefully read and work through this check list in order to prevent the most common mistakes and misuse of youtube-dl:
- First of, make sure you are using the latest version of youtube-dl. Run `youtube-dl --version` and ensure your version is 2019.10.22. If it's not, see https://yt-dl.org/update on how to update. Issues with outdated version will be REJECTED.
- Make sure that all provided video/audio/playlist URLs (if any) are alive and playable in a browser.
- Make sure that site you are requesting is not dedicated to copyright infringement, see https://yt-dl.org/copyright-infringement. youtube-dl does not support such sites. In order for site support request to be accepted all provided example URLs should not violate any copyrights.
- Search the bugtracker for similar site support requests: http://yt-dl.org/search-issues. DO NOT post duplicates.
- Finally, put x into all relevant boxes (like this [x])
-->

- [x ] I'm reporting a new site support request
- [x ] I've verified that I'm running youtube-dl version **2019.10.22**
- [x ] I've checked that all provided URLs are alive and playable in a browser
- [x ] I've checked that none of provided URLs violate any copyrights
- [x ] I've searched the bugtracker for similar site support requests including closed ones


## Example URLs

<!--
Provide all kinds of example URLs support for which should be included. Replace following example URLs by yours.
-->

- Single video: https://www.youtube.com/watch?v=BaW_jenozKc
- Single video: https://youtu.be/BaW_jenozKc
- Playlist: https://www.youtube.com/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc


## Description

<!--
Hi i am trying to download videos for a course to watch these offline. the course site is :
https://olympus.greatlearning.in/courses/4971/pages/unstructured-data-course-introduction?module_item_id=250532
userid : reddybharath.k@gmail.com
password - Bharath@1

The video is a blob and streams as multiple .ts files generated from a java script. 
Is this possible using this software ?
-->

Hi i am trying to download videos for a course to watch these offline. the course site is :
https://olympus.greatlearning.in/courses/4971/pages/unstructured-data-course-introduction?module_item_id=250532
userid : reddybharath.k@gmail.com
password - Bharath@1

The video is a blob and streams as multiple .ts files generated from a java script. 
Is this possible using this software ?
Repository: tensorflow
Issue: What is the right way to use coverage.py with Tensorflow?
Labels: stat:awaiting tensorflower,type:feature,comp:core

I apologize if this is the wrong way to ask this question. I'm the maintainer of coverage.py, for measuring code coverage in Python projects.  A user wrote an issue for me: https://github.com/nedbat/coveragepy/issues/856

After digging into it, I see that his tf.keras.Model.call() function is not executed directly, but is transformed into a temporary file, and executed there.  So coverage.py reports that his code is unexecuted, even though he can see the effects of its execution.

I also see that the transformed code has an `ag_source_map__` parameter which can be used to map back from the transformed code to the original code.  A coverage.py plugin could use that information to report coverage usefully.

My questions are:
1. Is there a reason people haven't reported this to coverage.py before? Is there a existing known way to get coverage reports on this kind of code?
2. What is a stable public API for getting the transformation mapping?
3. Would TensorFlow be interested in maintaining a coverage.py plugin to make this work properly?
Repository: rust
Issue: Confusing "cannot infer an appropriate lifetime" error message
Labels: C-enhancement,A-diagnostics,A-lifetimes,T-compiler,A-inference

Consider example:

```rust
trait Bar {
    fn bar(&self, r: &mut Re);
}

struct Re<'a> {
    data: &'a u16,
}

struct Foo;

impl Bar for Foo {
    fn bar<'a, 'b>(&'a self, r: &'b mut Re<'a>){}
}
```

([Playground](https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=5bd6ac9f31500a89c9f1fcf98b5ffa30))

Errors:

```
   Compiling playground v0.0.1 (/playground)
error[E0495]: cannot infer an appropriate lifetime for lifetime parameter 'a in generic type due to conflicting requirements
  --> src/lib.rs:12:5
   |
12 |     fn bar<'a, 'b>(&'a self, r: &'b mut Re<'a>){}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the method body at 12:5...
  --> src/lib.rs:12:5
   |
12 |     fn bar<'a, 'b>(&'a self, r: &'b mut Re<'a>){}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: ...but the lifetime must also be valid for the anonymous lifetime #3 defined on the method body at 12:5...
  --> src/lib.rs:12:5
   |
12 |     fn bar<'a, 'b>(&'a self, r: &'b mut Re<'a>){}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   = note: ...so that the method type is compatible with trait:
           expected fn(&Foo, &mut Re<'_>)
              found fn(&Foo, &mut Re<'_>)

error: aborting due to previous error

For more information about this error, try `rustc --explain E0495`.
error: could not compile `playground`.

To learn more, run the command again with --verbose.

```

All 3 notes of this error message is confusing:

note1, note2: Message not point where are the anonymous lifetime #1 and the anonymous lifetime #3. Also it's not obviously why there are two different anonymous lifetimes at one place (at 12:5).

=note3: Expected result looks totally equal to founded. So it's not obviously why it considered as different.

It is difficult to figure out what was going on.
May be some change of this message needed.
Repository: rust
Issue: Slightly confusing grammar in pinning docs.
Labels: C-enhancement,T-libs-api,A-docs

Hi, I've just read the `std::pin` docs as part of learning `std::future::Future` and attempting to write my own combinator. This section is pretty dense for my first read, and only at the very end, when it mentioned `Future` combinators did I realize I had a misunderstanding through the entire reading due to [this phrase](https://github.com/rust-lang/rust/blob/625451e376bb2e5283fc4741caa0a3e8a2ca4d54/src/libcore/pin.rs#L211) in the projections section ([link to rendered docs](https://doc.rust-lang.org/std/pin/#projections-and-structural-pinning)):

> every field can be either projected to a pinned reference, or have pinning removed as part of the projection

At the end, the sentence that made me realize I had a misunderstanding [is here](https://github.com/rust-lang/rust/blob/625451e376bb2e5283fc4741caa0a3e8a2ca4d54/src/libcore/pin.rs#L338-L341):

> But if your combinator contains any other data that does not need to be pinned, you can make those fields not structural and hence freely access them with a mutable reference even when you just have Pin<&mut Self> (such as in your own poll implementation).

My misunderstanding, on reading the first quote, was to believe that if any field is a pinned projection, then all other fields must also be pinned projections, or if any field is not, all other fields must not be. For me, if the first phrase said this instead, I think it would be clearer:

> each field can either be projected to a pinned reference, or have pinning removed as part of the projection.

I'm a native English speaker, and I'm still not sure if the difference between my suggestion and the current text implies the technical difference I intend here, and I'm not sure if other readers might encounter a similar confusion. (Technical writing is hard!)

To really drive it home, maybe append the following sentence:

> Fields may be projected to pinned or unpinned references independent of other fields.

I hope this helps make it easier for first-time readers to understand the projections and structural pinning section a bit better.

Thanks for your effort!

ps: Rust is awesome, and the core/std docs are excellent. ;-)
Repository: go
Issue: cmd/compile: no closure inlining even in the simple case?
Labels: Performance,NeedsInvestigation,compiler/runtime

I hesitate to call this an issue, since I know it's a complex topic, and I've read about half a dozen issue reports touching this topic, which kind-of sort-of fix some inlining cases, but not all of them.

I'm using a simple pattern for avoiding lock leakage:

```go
// WithRWMutex extends the RWMutex type with convenient .With(func) functions
type WithRWMutex struct {
	sync.RWMutex
}

// WithRLock executes the given function with the mutex rlocked
func (m *WithRWMutex) WithRLock(f func()) {
	m.RWMutex.RLock()
	f()
	m.RWMutex.RUnlock()
}

// WithWLock executes the given function with the mutex wlocked
func (m *WithRWMutex) WithWLock(f func()) {
	m.RWMutex.Lock()
	f()
	m.RWMutex.Unlock()
}
```

in practice it's used like this:

```go
beforeCode()
o.WithWLock(func() {
 doSomething(o)
})
afterCode()
```

Full example here: https://go.godbolt.org/z/mkvMbZ

I'd expect that when the closure passed to `WithWlock()` is simple enough (i.e. no need for a new stack), inlining would collapse all the scaffolding and compile it to something like:

```go
beforeCode()
m.RWMutex.Lock()
doSomething(o)
m.RWMutex.Unlock()
afterCode()
```

But looking at the assembly code (https://go.godbolt.org/z/mkvMbZ), the inner function is compiled once, its address taken, passed to the `WithWLock()` function, i.e. a full closure call is being done.

This is on go 1.13.

It seems that a full closure call is an expensive choice for this particular pattern?
Repository: flutter
Issue: [webview_flutter] Add option to allow mixed-mode content (http in https page)
Labels: c: new feature,customer: dream (g3),customer: crowd,p: webview,package,team-ecosystem,P2,triaged-ecosystem

Internal: b/292548371

webview_flutter how to load https and http mixed content?
Repository: pytorch
Issue: cmake allows both MKL and MKLDNN to be OFF;  aten/src/ATen/CMakeLists.txt then ignores c++ sources
Labels: module: build,triaged

This file has
```
if(AT_MKL_ENABLED)
  set(all_cpu_cpp ${all_cpu_cpp} ${mkl_cpp})
endif()
if(AT_MKLDNN_ENABLED)
  set(all_cpu_cpp ${all_cpu_cpp} ${mkldnn_cpp})
endif()
```

which ignores ```${all_cpu_cpp}``` when none of ```AT_MKL_ENABLED``` and ```AT_MKLDNN_ENABLED``` are defined.

There are two bugs:
1. The above code should be ```if() ... else if() .... else ERROR(no mkll defined) endif```
2. The top-level cmake file should disallow having both ```AT_MKL_ENABLED``` and ```AT_MKLDNN_ENABLED``` be ```OFF```.
Repository: rust
Issue: Missed optimization: fn f(a: &mut i32){ let b = *a; println!("{}", b); }
Labels: I-slow,C-enhancement,T-compiler,C-optimization

This Rust code: https://godbolt.org/z/HeLrx- gives more assembly than this: https://godbolt.org/z/Aji2U3
Repository: rust
Issue: wasm32-unknown-unknown target should not make output executable
Labels: C-enhancement,T-compiler,O-wasm

The wasm32-unknown-unknown target sets the executable bit on the compiled `.wasm` file. Most uses of wasm don't execute the wasm file directly, and without special configuration (such as binfmt-misc on Linux), most operating systems can't directly run wasm files. Furthermore, the executable bit set on the output tends to get checked into git repositories.

For the wasm32-unknown-unknown target, we should not set the executable bit on the output file.
Repository: pytorch
Issue: [feature request] Docs for fuse_conv_bn_eval
Labels: module: docs,triaged

Even if it is internal/experimental, it's quite useful for end users as well.

Curently [`fuse_conv_bn_weights`](https://github.com/pytorch/pytorch/blob/master/torch/nn/utils/fusion.py#L22) assumes 2d convolution and hard-codes 4-dim weights, which is not true for Conv1d/Conv3d. However it's easy to support any dimension:
```python
# conv_w = conv_w * (bn_w * bn_var_rsqrt).reshape([-1, 1, 1, 1])
conv_w = conv_w * (bn_w * bn_var_rsqrt).reshape([-1] + [1] * (len(conv_w.shape) - 1))
```
Repository: pytorch
Issue: torch.tensor() is very slow when it is passed an h5py Dataset.
Labels: module: performance,triaged,module: tensor creation

## 🐛 Bug

`torch.tensor()` is very slow when it is passed an h5py Dataset.

## To Reproduce

Create a new HDF5 file with a 1000x1000 float32 dataset:

```python
import h5py
import numpy as np
import torch

testfile = h5py.File('testfile.h5', 'w')
testfile['data'] = torch.eye(1000)
```

Then load it back into a Tensor:

```
>>> %timeit torch.tensor(testfile['data'])
421 ms ± 28.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
```

It's very slow. However, if the dataset is converted into a NumPy array first, it performs much faster:

```
>>> %timeit torch.tensor(np.array(testfile['data']))
2.84 ms ± 162 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
```

The resulting tensors are equal. Perhaps the manual NumPy array conversion avoids an expensive conversion to a Python nested list of floats.


cc @VitalyFedyunin @ngimel
Repository: go
Issue: text/template: access to methods that are not part of interface
Labels: NeedsInvestigation

### What version of Go are you using (`go version`)?

<pre>
$ go version
go version go1.13.3 linux/amd64
</pre>

### Does this issue reproduce with the latest release?
Yes

### What operating system and processor architecture are you using (`go env`)?

<details><summary><code>go env</code> Output</summary><br><pre>
$ go env
GO111MODULE=""
GOARCH="amd64"
GOBIN=""
GOCACHE="/home/vic/.cache/go-build"
GOENV="/home/vic/.config/go/env"
GOEXE=""
GOFLAGS=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GONOPROXY=""
GONOSUMDB=""
GOOS="linux"
GOPATH="/home/vic/Go"
GOPRIVATE=""
GOPROXY="https://proxy.golang.org,direct"
GOROOT="/usr/lib/go"
GOSUMDB="sum.golang.org"
GOTMPDIR=""
GOTOOLDIR="/usr/lib/go/pkg/tool/linux_amd64"
GCCGO="gccgo"
AR="ar"
CC="gcc"
CXX="g++"
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 -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build611773016=/tmp/go-build -gno-record-gcc-switches"
GOROOT/bin/go version: go version go1.13.3 linux/amd64
GOROOT/bin/go tool compile -V: compile version go1.13.3
uname -sr: Linux 5.3.6-arch1-1-ARCH
LSB Version:	1.4
Distributor ID:	Arch
Description:	Arch Linux
Release:	rolling
Codename:	n/a
/usr/lib/libc.so.6: GNU C Library (GNU libc) stable release version 2.30.
</pre></details>

### What did you do?

I executed a `text/template.Template` with an interface as data.

<details><summary>Example code</summary><br>

```
package main

import (
	"os"
	"text/template"
)

type Foo struct {
	A int
}

func (f Foo) B() int {
	return 2
}

func (f Foo) C() int {
	return 3
}

type Bar interface {
	C() int
}

func main() {
	foo := Foo{A: 1}
	test(foo)
}

func test(bar Bar) {
	tpl := template.Must(template.New("template").Parse("{{ .A }} {{ .B }} {{ .C }}"))
	tpl.Execute(os.Stdout, bar)
}
```

</details>

On play: https://play.golang.org/p/YgMyBPie8kw

### What did you expect to see?

My template is using functions that don't exist in the interface, thus I was expecting an error.

### What did you see instead?

The template is able to execute functions on the underlying type, exposing functionality I don't want to expose.

I believe the `text/template` package actually behaved as I would expect in the past. I think the functionality was changed in 167a7123997c42e91d69de2203fc4c156897f0a2.