sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: flutter
Issue: Support text capitalization in TextStyle 
Labels: c: new feature,framework,a: typography,customer: crowd,customer: solaris,P2,team-framework,triaged-framework

Current status:
https://github.com/flutter/flutter/issues/28567#issuecomment-859971394
https://github.com/flutter/flutter/issues/28567#issuecomment-860113239

---

Inspiration taken from [CSS text-transform](https://developer.mozilla.org/en-US/docs/Web/CSS/text-transform), which helps keep the separation between style and structure clean.

It would be nice to be able to specify how text should be capitalized when rendered via TextStyle.

Let's say UX convention is that all buttons in the application should have uppercase text.

In https://docs.flutter.io/flutter/material/TextTheme-class.html
Writing what's button (ALL CAPS) but in TextStyle not this param(

Please fix it! God luck and have a nice day)))
Repository: create-react-app
Issue: Add Jest configuration for snapshotresolver
Labels: issue: proposal

As I understand, right now CRA only supports a handful of Jest configuration overrides, either by adding them to package.json or adding a jest.config.js to your project. 

First question would be, why are you not allowing to just add a jest.config.js and read all of the configuration variables that Jest provides usually, why add just a few of them? 

And the more important suggestion, can you add snapshotresolver to this list of allowed customizations? https://jestjs.io/docs/en/configuration#snapshotresolver-string

It has been added with Jest 24 and would really help clean up the codebase a bit, since I don't think it's necessary to have generated code right next to my .tsx, .scss and .test.ts files.. If not, could you at least explain, how the decision was made to not just check for a jest.config.js and then give it to the test runner, so the dev can decide what they want to override or not.
Repository: thefuck
Issue: rbenv install
Labels: help wanted

The output of `thefuck --version`:

```
The Fuck 3.28 using Python 3.7.2 and Fish Shell 3.0.1
```

Your system (Debian 7, ArchLinux, Windows, etc.):

```
Arch Linux
```

How to reproduce the bug:

```
> rbenv install 2.6.1
ruby-build: definition not found: 2.6.1

See all available versions with `rbenv install --list'.

If the version you need is missing, try upgrading ruby-build:

  cd /home/alex/.rbenv/plugins/ruby-build && git pull && cd -
```

The output of The Fuck with `THEFUCK_DEBUG=true` exported (typically execute `export THEFUCK_DEBUG=true` in your shell before The Fuck):

```
No fucks given
```

(I think, debug is not necessary)

Expected fuck:

```
cd /home/alex/.rbenv/plugins/ruby-build && git pull && cd -
```

(as suggested in the `rbenv` output)
Repository: opencv
Issue: denoise_TVL1 is limited to CV_8U
Labels: feature,category: photo

opencv/modules/photo/src/denoise_tvl1.cpp
line 150:
```
result.create(X.rows,X.cols,CV_8U);
X.convertTo(result, CV_8U, 255);
```
feature request:
denoise_TVL1 should allow different output formats.
Repository: godot
Issue: Importing ESCN files using EditorSceneImporter loses "Import hints"
Labels: topic:core,usability,topic:import

<!-- Please search existing issues for potential duplicates before filing yours:
https://github.com/godotengine/godot/issues?q=is%3Aissue
-->

**Godot version:**
3.1-beta7

**OS/device including version:**
Linux Fedora 28

**Issue description:**
Hey yall, thanks for Godot. 
I'm trying to make an `EditorImportPlugin` that uses `OS.execute` to call the `godot-blender-exporter`, so I end up with an escn file. I was hoping that just having that in the `.import` hidden folder and returing 'PackedScene' from `get_resource_type` would suffice to get live reloading blends. Alas...

I did manage to use `EditorSceneImporter.import_scene_from_another_importer` to get the scene tree. I can creaate a new `PackedScene` from that and use `ResourceSaver` to save it to the `.import` folder. 

This way live reload sort of works, however the scene isn't parsed the same way an `escn` in the visible project folder would be. This means things like `Import Hints` are ignored (and probably some other normalization steps are skipped).

I think there is a special loaders for `escn` files called `EditorSceneImporterESCN`, but I cant seem to use it from gdscript. 

**Steps to reproduce:**
This is the main importer plugin code. Note that the Blender executable path is hard coded and you need to have the godot-blender-exporter plugin installed. I also add a time stamp to the intermediate `escn` filename because otherwise meshes aren't reimported properly.
```
tool
extends EditorImportPlugin

func get_importer_name():
	return "easy_blender_import"
	
func get_visible_name():
	return "Easy Blender Import"
	
func get_recognized_extensions():
	return ["blend"]
	
func get_save_extension():
	return "scn"
	
func get_resource_type():
	return "PackedScene"
	
enum Presets {  }

func get_preset_count():
	return 0
	
func get_import_options(preset):
	return []
	
func import(source_file, save_path, options, r_platform_variants, r_gen_files):
	var path = ProjectSettings.globalize_path(source_file)
	var outpath = ProjectSettings.globalize_path(save_path)
	var t = hash(OS.get_unix_time())
	var script = "import io_scene_godot; io_scene_godot.export('%s_%s.escn')" % [outpath, t]
	var array = ["-b",  path,  "--python-expr", script]
	var args = PoolStringArray(array)
	print(args)
	OS.execute("/opt/blender/blender-2.79-linux-glibc219-x86_64/blender", args, true)	
	var imp = EditorSceneImporter.new()	
	var scene = imp.import_scene_from_other_importer("%s_%s.%s" % [save_path, t, "escn"], 1 , 25 )
	var newScene = PackedScene.new()
	newScene.pack(scene)
	ResourceSaver.save("%s.%s" % [save_path, get_save_extension()], newScene )
```
Repository: vscode
Issue: [json] add commas automatically
Labels: help wanted,feature-request,json

# Test case

![untitledb2](https://user-images.githubusercontent.com/382183/53503469-1b4f8f80-3a7e-11e9-9bf2-2193e8fe4419.gif)

# Expected behavior

* After typing `age` <kbd>TAB</kbd>, the comma should be added to the end of the previous line.
* After typing `"` for the next object property, the comma should be added to the end of the previous line.

# Actual behavior

The autocomplete does not produce valid text.

# Discussion

In general, the autocomplete should strive to produce output that is maximally valid in whatever language grammar it is using.
Repository: vscode
Issue: [json] add colon automatically
Labels: feature-request,json

# Test case

![untitledb2](https://user-images.githubusercontent.com/382183/53503676-8731f800-3a7e-11e9-9d40-09695ccf41e6.gif)

# Expected

After typing `name` <kbd>TAB</kbd>, the editor should correct this to `"name":`.

# Actual

It is corrected to `"name"` (without `:`).
Repository: TypeScript
Issue: spreading generic type disables excess property checking
Labels: Bug

<!-- 🚨 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.3.3333

<!-- Search terms you tried before logging this (so others can find this issue more easily) -->
**Search Terms:** generic spread

**Code**

```ts
function spread<T extends {foo: string}>(p: T): {foo: string} {
    return {...p, bar: ''};
}
```

**Expected behavior:**

Excess property error for `bar`.

**Actual behavior:**

No error.

**Playground Link:** http://www.typescriptlang.org/play/#src=function%20spread%3CT%20extends%20%7Bfoo%3A%20string%7D%3E(p%3A%20T)%3A%20%7Bfoo%3A%20string%7D%20%7B%0D%0A%20%20%20%20return%20%7B...p%2C%20bar%3A%20''%7D%3B%0D%0A%7D
Repository: TypeScript
Issue: Nested classes are not collapsible/expandable in Visual Studio
Labels: Suggestion,Help Wanted,Experience Enhancement

Nested classes are not collapsible/expandable in Visual Studio.

```
export class ClassA{

    private ClassB = class{
        ...
    }

}
```

Code inside classB loses this functionality.
Repository: flutter
Issue: Add traces when the pipeline depth changes.
Labels: engine,P2,team-engine,triaged-engine

Changing pipeline depth in the engine can result in jank. Mark the same clearly with and instant trace in the timeline.
Repository: three.js
Issue: editor freezes for a moment after *every* change in it.
Labels: Enhancement,Editor

##### Description of the problem

I drag'n'drop a 3.2 mb FBX (created in 3ds max 2016), plus some 30 jpg textures with 256-2048 resolution. **Every single time** when I make a change in the scene, the editor freezes for several(tens of) seconds. The heavier the scene, the longer the freeze. 

##### Browser

- [ ] All of them
- [x] Chrome
- [x] Firefox
- [ ] Internet Explorer

##### OS

- [ ] All of them
- [x] Windows
- [ ] macOS
- [ ] Linux
- [ ] Android
- [ ] iOS

##### Hardware Requirements (graphics card, VR Device, ...)
Repository: opencv
Issue: Feature request: Kronecker tensor product
Labels: feature,category: core

A feature request to add the [Kronecker tensor product](https://en.wikipedia.org/wiki/Kronecker_product) ([kron](https://www.mathworks.com/help/matlab/ref/kron.html) in Matlab, [numpy.kron](https://docs.scipy.org/doc/numpy/reference/generated/numpy.kron.html) in Numpy). See also the [tensor product](https://en.wikipedia.org/wiki/Tensor_product).

Expected results (Python Numpy):

```
print('np.kron([[1, 2], [3, 4]], [[0, 5], [6, 7]]):\n', np.kron([[1, 2], [3, 4]], [[0, 5], [6, 7]]))
print('np.kron([1,10,100], [5,6,7]):\n', np.kron([1,10,100], [5,6,7]))
```

Output:

```
np.kron([[1, 2], [3, 4]], [[0, 5], [6, 7]]):
 [[ 0  5  0 10]
 [ 6  7 12 14]
 [ 0 15  0 20]
 [18 21 24 28]]
np.kron([1,10,100], [5,6,7]):
 [  5   6   7  50  60  70 500 600 700]
```

Some available [OpenCV implementation](https://stackoverflow.com/questions/36549057/opencv-tensor-product/36552682#36552682):

```
Mat kron(const Mat& A, const Mat& B)
{
    CV_Assert(A.channels() == 1 && B.channels() == 1);

    Mat1d Ad, Bd;
    A.convertTo(Ad, CV_64F);
    B.convertTo(Bd, CV_64F);

    Mat1d Kd(Ad.rows * Bd.rows, Ad.cols * Bd.cols, 0.0);
    for (int ra = 0; ra < Ad.rows; ++ra)
    {
        for (int ca = 0; ca < Ad.cols; ++ca)
        {
            Kd(Range(ra*Bd.rows, (ra + 1)*Bd.rows), Range(ca*Bd.cols, (ca + 1)*Bd.cols)) = Bd.mul(Ad(ra, ca));
        }
    }
    Mat K;
    Kd.convertTo(K, A.type());
    return K;
}
```

Another [implementation](https://github.com/carriehz/Orthog-Transforms/blob/master/kron_prod.hpp):

```
void kron_prod( InputArray _src1, InputArray _src2, OutputArray _dst){

	Mat A = _src1.getMat();
	Mat B = _src2.getMat();

	int rsz, csz;

	rsz = A.rows*B.rows;
	csz = A.cols*B.cols;

	Mat out = Mat(rsz, csz, CV_32F);
	_dst.create(rsz, csz, CV_32F);
	Mat dst = _dst.getMat();

	Mat temp = Mat::zeros(B.rows,B.cols, CV_32F);
	Mat res1 = Mat::zeros(B.rows,B.cols, CV_32F);
	Mat res2 = Mat::zeros(rsz, csz, CV_32F);
	Mat res3 = Mat::zeros(rsz, csz, CV_32F);

	for( int i = 0; i < A.rows; i++ ){

		Mat res1 = Mat::zeros(B.rows,B.cols, CV_32F);

		for( int j = 0; j < A.cols; j++ ){

			if (j == 0){
				res1 = A.at<float>(i,j)*B;
				res1.copyTo(out);
			}
			else{
				temp = A.at<float>(i,j)*B;
				hconcat(res1, temp, res1);
				res1.copyTo(res2);
			}
		}

		if (i == 0){
			res2.copyTo(res3);
		}
		else{
			vconcat(res3, res2, res3);
			res3.copyTo(out);
		}
	}
	out.copyTo(dst);
}
```
Repository: rust
Issue: Strange interaction between matching and lifetimes
Labels: T-compiler,A-NLL,NLL-polonius

I ran into some baffling issues when matching on a mutable reference and assigning to the mutable reference in the match arms. It seems that the inferred lifetime bound escapes the match. Playpen:

https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=4428e0752f518ba02ed12c77560d8afb

I tried three ways of matching on a borrowed value `list.0`.  The first two work only without the "if true" block (1b, 1c). Should an if-block affect the inferred lifetime of the borrow of `list.0`?

The last method does not work with (3a) or without (3b) the if-block, but I am still confused: why is `list.0` still borrowed after the match? Is this expected behavior?

I would expect all six variants to be accepted by the borrow checker, and I'm confused about why only two of them are.
Repository: pytorch
Issue: Add ASSERT for calling accessor on a GPU tensor
Labels: module: cpp,module: molly-guard,triaged

## 🚀 Feature
Right now it just segfaults.

At an error message so that it is easier to debug.

cc @yf225 @glaringlee
Repository: TypeScript
Issue: Meta-issue: Use Full Unification for Generic Inference?
Labels: Meta-Issue

## 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 -->

unification generic inference

## Suggestion

Today, TypeScript cannot retain or synthesize free type parameters during generic inference. This means code like this doesn't typecheck, when it should:
```ts
function identity<T>(arg: T) { return arg; }
function memoize<F extends (...args: unknown[]) => unknown>(fn: F): F { return fn; }
// memid: unknown => unknown
// desired: memid<T>(T) => T
const memid = memoize(identity);
```

## Use Cases

Many functional programming patterns would greatly benefit from this.

The purpose of this issue is to gather use cases and examine the cost/benefit of using a different inference algorithm.

## Examples

Haven't extensively researched these to validate that they *require* unification, but it's a start:

#9366
#3423
#25092
#26951 (design meeting notes with good examples)
#25826
#10247
Repository: kubernetes
Issue: Reject requests with unsupported options
Labels: area/apiserver,sig/api-machinery,kind/feature,priority/important-longterm,lifecycle/frozen

Today, the apiserver accepts requests with options that are unknown to the server, we just throw those options away and continue with the request as if they hadn't been specified.

I think this decision made some sense, as we don't necessarily want to reject a request asking for pagination made to an old server that doesn't support pagination, but it has also caused issues for us when we wanted to add features like server-side dry-run, and when discussing the possibility of adding a precondition to delete options.

The way we dealt with this for dry-run was to make the api-server reject requests with that field for a few versions, which was safe, but also unnecessarily delayed the feature's release.

**What would you like to be added**:
I think the server should ideally reject all requests with options they don't understand and return some kind of structured/machine-readable error which explains which options are causing the failure. Then clients could use this list to determine whether or not any of these options are critical to the request (like dry-run or a precondition). If any of the unsupported are critical, the client should not retry, and just return the error. If none of the unsupported options are critical, the client should retry the request automatically without those options specified. The client is the only one guaranteed to have the knowledge of whether or not an option is critical, since the apiserver could be from an older version.

This change would be backward compatible as long as no one relies on sending the server options that aren't in any version of k8s (which might not be completely true), and would allow us to safely add both critical and uncritical options in the future without having to worry about the same version skew issue we keep running into.

/kind design
/area apiserver
/sig api-machinery
/priority important-longterm
cc @lavalamp
Repository: flutter
Issue: Stack makes infinite height if only have Positioned children
Labels: framework,d: api docs,P2,team-framework,triaged-framework

I run into a problem where I had a `Stack` with only `Positioned` children and my app was saying the `Stack` was generating an infinite size. I found the solution https://stackoverflow.com/a/54624340/1227166, which is a little hack, to just place an empty `Container` inside the `Stack`, so it will know how to calculate its own size.

I believe the `Stack` documentation should be clearer about this use case and what to do to prevent it. Also `Stack` should have a way (maybe a flag?) to measure itself in case there are only `Positioned` children so we won't have to resort to these kind of hacks.
Repository: godot
Issue: Objects can't use forces while global_transform.basis is being changed
Labels: bug,topic:core


**Godot version:**
Godot 3.1 Beta 8 official


**OS/device including version:**
Windows 10 64 bit (April update); Ryzen7 2700X CPU; GTX 1060 6GB GPU


**Issue description:**
In Beta 3 and before, you can move an object with forces while changing its _global_transform.basis_ property (using functions like slerp()). Now, you can't do that on the same frame, any object movement with forces will stop immediately, even though we're not changing the object's position.


**Steps to reproduce:**
Run the project and watch the cube stop as soon as it starts spinning. The position shouldn't see an override because it's only changing the orientation.

**Minimal reproduction project:**
[Test Project2.zip](https://github.com/godotengine/godot/files/2912662/Test.Project2.zip)
Repository: go
Issue: cmd/compile: unnecessary hash/eq functions for slice literals
Labels: ToolSpeed,NeedsInvestigation,binary-size,compiler/runtime

### What version of Go are you using (`go version`)?

<pre>
$ go version
go version go1.12rc1 linux/amd64
</pre>

Consider this package:

```go
package bloat
var x []interface{}
```

```shell
$ go build -o bloat.a .
$ ls -l bloat.a
-rw-r--r-- 1 dneil primarygroup 778 Feb 27 15:23 bloat.a
```

Now consider the case where we initialize the var `x`:

```go
package bloat
var x = []interface{}{0, 1, 2}
```

```shell
$ go build -o bloat.a .
$ ls -l bloat.a
-rw-r--r-- 1 dneil primarygroup 4030 Feb 27 15:28 bloat.a
```

The object file for the latter package contains `eq` and `hash` functions for `[3]interface{}`, which appear to account for much of the size increase:

```shell
$ go tool pack x bloat.a
$ go tool objdump -S bloat.a | grep ^TEXT
TEXT type..hash.[3]interface {}(SB) gofile..<autogenerated>
TEXT type..eq.[3]interface {}(SB) gofile..<autogenerated>
```

There is no need for these functions, however; the only use of `[3]interface{}` is to initialize a `[]interface{}`, and there is no way to recover the array type from that slice.
Repository: rust
Issue: Suggest `split_at_mut` when trying to use multiple non-overlapping mutable slices to the same array
Labels: C-enhancement,A-diagnostics,P-low,A-borrow-checker,T-compiler,A-suggestion-diagnostics,A-array

[The following code](https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=1947bc965868f90b695a62803f999657) is invalid due to lifetime rules:

```
fn main() {
    let mut foo = [1,2,3,4];
    let mut a = &mut foo[..2];
    let mut b = &mut foo[2..];
    a[0] = 5;
    b[0] = 6;
    println!("{:?} {:?}", a, b);
}
```

```
error[E0499]: cannot borrow `foo` as mutable more than once at a time
 --> src/main.rs:4:22
  |
3 |     let mut a = &mut foo[..2];
  |                      --- first mutable borrow occurs here
4 |     let mut b = &mut foo[2..];
  |                      ^^^ second mutable borrow occurs here
5 |     a[0] = 5;
  |     ---- first borrow later used here
```

The solution is to either use `unsafe` or (more appropriately) use [`split_at_mut`](https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=b789f2e5abc3895158f80a9602e59b6b):

```
fn main() {
    let mut foo = [1,2,3,4];
    let (mut a, mut b) = foo.split_at_mut(2);
    a[0] = 5;
    b[0] = 6;
    println!("{:?} {:?}", a, b);
}
```

The compiler should detect the case of multiple mutable borrows to the same array/slice and hint at the existence of `split_at_mut`. Ideally, we would also verify wether there's a range overlap in order to explain to the user why what they want to do is problematic and disallowed in Rust.

The output should ideally be along the lines of the following (the structured suggestion is not _needed_ to fix this issue, the text would be enough of an improvement):

```
error[E0499]: cannot borrow `foo` as mutable more than once at a time
 --> src/main.rs:4:22
  |
3 |     let mut a = &mut foo[..2];
  |                      --- first mutable borrow occurs here
4 |     let mut b = &mut foo[2..];
  |                      ^^^ second mutable borrow occurs here
5 |     a[0] = 5;
  |     ---- first borrow later used here
  = note: you cannot have multiple mutable borrows to the same piece of memory, as the compiler cannot assure that the different slices you're trying to use are non-overlapping
help: you can instead use `split_at_mut` to get two non-overlapping mutable slices from a single array/slice
  |
3 |     let (mut a, mut b) = foo.split_at_mut(2);
  |         ^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^
```