sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: godot
Issue: AutoExposure flickering wildly when framebuffer allocation = 2D
Labels: bug,topic:rendering,confirmed,topic:2d

**Godot version:**
81292665d5dcc991d3c9341245b269193329ee22 (latest master as of this issue), but occurs since at least 3.1

**OS/device including version:**
Antergos, kernel 5.0.4-arch1-1-ARCH 
NVIDIA GeForce GTX 1080 Ti, proprietary drivers, version 418.56

**Issue description:**
AutoExposure causes screen to flicker like it has a personal vendetta against people with epilepsy when there is a sprite with a normalmap on-screen and the framebuffer allocation is set to 2D. Possibly related to #16224?


**Steps to reproduce:**
- Set Project Settings -> Rendering -> Quality -> Intended Usage -> Framebuffer Allocation to 2D
- Create a Sprite with a normal map texture in a 2D scene
- Add a WorldEnvironment node with Background Mode = Canvas and Auto Exposure enabled

**Minimal reproduction project:**
[bugrepro.tar.gz](https://github.com/godotengine/godot/files/3008629/bugrepro.tar.gz)
Repository: vscode
Issue: Accessibility service not firing onDidChangeAccessibilitySupport
Labels: upstream,accessibility,windows,workbench-launch,upstream-issue-linked,chromium

Found testing https://github.com/Microsoft/vscode/issues/67744

All testing was done in the explorer view.

I turned on NVDA and saw that the list keyboard navigation changed.

When I turned off NVDA, I expected that the list keyboard navigation would go back to the new filtering behavior. It did not.

I reloaded. It still stayed on the simple navigation. 

I had to fully restart VS Code before the navigation went back to the filtering behavior. If VS Code can automatically switch to simple when there is a screen reader (no restart) then it should be able to switch back.
Repository: flutter
Issue: showSearch keyboardType
Labels: c: new feature,framework,f: material design,c: proposal,P3,team-design,triaged-design

You don't always search with text, some times you search with numbers, there should be an option to show a numeric TextInputType on a showSearch screen.
Repository: vscode
Issue: Call hierarchy: use different icons to express semantics of call graph nodes
Labels: feature-request,callhierarchy

testing #71083:

Since all nodes of a call graph are functions, representing them with a function icon does not provide additional information:

![2019-03-26_17-01-15](https://user-images.githubusercontent.com/1898161/55013216-f56bcb00-4fe8-11e9-9a07-97b75f902ad9.png)

Instead we could use different icons to express the following semantics:
- an icon for the "peeked" function (root of the tree). This could be the icon you are using today.
- a strong (bold) up-arrow-like icon (↖) for direct callers
- a dimmed up-arrow-like icon for indirect callers

Another dimension to encode in the icon could be information about the caller being local or external.
Repository: vscode
Issue: File Provider: support symbolic link operations
Labels: feature-request,api,remote,file-io

With the new file service we can support move/copy across file system providers for files and folders. However, if one of the items is a symbolic link, there is currently no way to re-create such a link on the target provider. 

In node.js terms there is a method called [`symlink`](https://nodejs.org/docs/v10.2.0/api/fs.html#fs_fs_symlink_target_path_type_callback). 

I think conceptually we would need new API such as `link(source, target)` and then providers have to deal with the quirks.

On top of that we also need a way to resolve the target of the link, otherwise we cannot make a decision how to restore it.

Bottom line: I think it only makes sense to preserve symlinks if they are self contained in the data that is being moved/copied, not when pointing outside.
Repository: godot
Issue: mesh render problems with concave n-gons
Labels: bug,documentation,topic:import

**Godot version:**
3.1 stable

**OS/device including version:**
Windows 10, GTX 1080, 417.71

**Issue description:**
Imported a self made model, and got a wrong rendering in the preview window.
Model is made with blender. Exported wavefront object is correctly rendered when imported back into an empty blender project. Object also renders corectly with the Unity engine.

(godot)
http://prntscr.com/n39qih

(blender)
http://prntscr.com/n39rjl

(unity)
http://prntscr.com/n39snu

**Steps to reproduce:**
- Use in zip included object (curve.obj)
- Import it into Godot
- Drag it into any scene
- Create a new empty material for the first material slot of the mesh, for better visualisation
- Inspect model

**Minimal reproduction project:**
[ModelBug.zip](https://github.com/godotengine/godot/files/3009668/ModelBug.zip)
Repository: flutter
Issue: "flutter" tool should check for announcements
Labels: c: new feature,tool,from: study,customer: product,P2,team-tool,triaged-tool

We should have a well-defined location where we store announcements, and the flutter tool should check this location regularly and report currently-active announcements when it is run.

Such announcements should also be reported to IDEs using `--machine`.

We would use this relatively rarely. One example of when we would use this is to announce the developer survey.

Announcements should only be shown for a few days before being automatically muted.

There should be a "flutter announcements" command that shows all the announcements (even ones that got muted). Maybe also a "flutter announcements mute" command that mutes all current announcements (in which case "flutter announcements" would be a shorthand for "flutter announcements show" or some such).
Repository: TypeScript
Issue: Incremental --build, then delete generated js file, then another incremental --build does not recreate js file
Labels: Suggestion,Awaiting More Feedback,Domain: --incremental

<!-- Please try to reproduce the issue with `typescript@next`. It may have already been fixed. -->
**TypeScript Version:**  3.4.0-dev.20190326

<!-- Search terms you tried before logging this (so others can find this issue more easily) -->
**Search Terms:**

incremental

**Code**

tsconfig.json:

```json
{
  "compilerOptions": {
    "incremental": true
  }
}
```

x.ts:

```ts
console.log("hello");
```

**Expected behavior:**

* `$ tsc --build`
* `x.js` has been generated
* `$ rm x.js`
* `$ tsc --build`

Expected: x.js has been regenerated

**Actual behavior:**

x.js still does not exist

**Related Issues:**

Did not find any.
Repository: vscode
Issue: http.systemCertificates requires window reload
Labels: bug,proxy

Testing  #71108.

Following the steps in the test item, once I'm in a state at which the extension receives data from the server, unchecking `http.systemCertificates` has no effect. I need to reload the window to make the extension through an error again.
Repository: TypeScript
Issue: Change API for compiler option "target" to use strings instead of numbers
Labels: Needs Investigation

Currently, `ScriptTarget.ESNext` has different values depending on which version of TS you are using.
This makes it very hard for clients of tsserver to resiliently allow users to specify "ESNext" and have it work across changes to `ScriptTarget`.

After discussing with @RyanCavanaugh and @weswigham, it seems to make sense to change this setting to expect strings instead of numbers, so that moving forward, `esnext` is interpreted as the version of ES Next supported by that version of TS (i.e. 2019 for 3.3, "2020" for 3.4).
Repository: flutter
Issue: Platform messages sent before Flutter initializes are lost
Labels: c: new feature,engine,a: fidelity,c: proposal,P3,team-engine,triaged-engine

There are many cases where the platform will respond to lower-level events prior to Flutter fully initializing. For example (on Android):

- Execution via a shortcut
- Push notifications
- Low-level callbacks
- App/Deep links

In these instances, the platform may wish to notify Flutter that these things have happened via a `MethodChannel` (or other mechanism) when it starts. It's fairly trivial to write a plugin to buffer this information and to check for these conditions on start up, but I am guessing that this makes more sense to be part of the engine.

The way I'm thinking of it is that there are two possible scenarios:

1. The platform (developer) can add values to an initialization object that can be queried on startup and flushed at a point (either automatically or manually)
2. Any platform messages sent before Flutter initialization has completed could be buffered / queued and sent when Flutter executes.

Option 2 could create an issue as it could flood the application on initialization and put the app into an unstable state.
Repository: youtube-dl
Issue: Error on litv.tv
Labels: geo-restricted

F:\youtube-dl 2019.03.18>youtube-dl -i https://www.litv.tv/vod/comi
c/content.do?content_id=VOD00142950
[LiTV] VOD00142950: Downloading webpage
[LiTV] VOD00142950: Downloading JSON metadata
ERROR: Unable to download JSON metadata: HTTP Error 405: Method Not Allowed (cau
sed by HTTPError()); please report this issue on https://yt-dl.org/bug . Make su
re you are using the latest version; type  youtube-dl -U  to update. Be sure to
call youtube-dl with the --verbose flag and include its complete output.

litv腳本可以修改嗎
Repository: flutter
Issue: Closing BottomSheet - managing bottomsheet controller is a pain
Labels: framework,f: material design,a: quality,c: proposal,P3,team-design,triaged-design

In order to replace the bottom sheet you need to first close it, if it already exists, then showBottomSheet.

The Scaffold.of(context) method is very useful when showing a bottom sheet, but you have to save the controller returned by Scaffold.showBottomSheet() in order to be able to close it, because you can't just show a new bottom sheet without closing an existing one.

Since a scaffold would only ever show one bottom sheet, IMHO the controller should be stored in the scaffold state for us, so we could simply then do a Scaffold.of(context).closeBottomSheet(), or even better, make the showBottomSheet method clean out an existing sheet on our behalf.

Right now, I have to save the controller and pass it around, or make it available using some other method (Bloc etc).
Repository: three.js
Issue: GLTFExporter: support animations from multiple scenes
Labels: Enhancement

Currently has this:
```javascript
			for ( var i = 0; i < options.animations.length; ++ i ) {

				processAnimation( options.animations[ i ], input[ 0 ] );

			}
```
This should be based on input[j]
Repository: TypeScript
Issue: Pull required references from referenced projects.
Labels: Suggestion,Awaiting More Feedback

## Search Terms

Inherit references from referenced project.
Pull required references from referenced projects.

## Suggestion

I have projects that have references to other projects, but one other project has references to another project it is dependent on.  That seems to be completely ignored, and is causing compiler errors.  It forces me to have to know all the references of the referenced projects and pull those also, which I should not have to do.

## Use Cases

This is pretty obvious.  In a typical C# project in Visual Studio (for example), referencing a project resolves other references from that referenced project, and so on.  It is not good practice to force projects to pull direct dependencies that are referenced indirectly by 3rd parties.

## Examples
_tsconfig.json_
```
{
  "references": [
    { "path": "3rdPartyProject" } // 3rdPartyProjectFile.d.ts
  ],
```
_3rdPartyProject/tsconfig.json_
```
{
  "references": [
    { "path": "Another3rdPartyProject" } // Another3rdPartyProjectFile.d.ts
  ],
```

This setup only outputs `3rdPartyProjectFile.d.ts`, as required by the first referenced projects.  Intellisense fails, however, because the references in `3rdPartyProject/tsconfig.json` are not included, thus `Another3rdPartyProjectFile.d.ts` is missing. This forces me to open all related tsconfig references and pollute my project json with them.  This also may not scale well.

## Checklist

My suggestion meets these guidelines:

* [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
* [x] This wouldn't change the runtime behavior of existing JavaScript code
* [x] This could be implemented without emitting different JS based on the types of the expressions
* [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
* [x] This feature would agree with the rest of [TypeScript's Design Goals](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals).
Repository: TypeScript
Issue: Allow "T extends enum" generic constraint
Labels: Suggestion,Awaiting More Feedback

TypeScript has a discrete `enum` type that allows various compile-time checks and constraints to be enforced when using such types. It would be extremely useful to allow generic constraints to be limited to enum types - currently the only way to do this is via `T extends string | number` which neither conveys the intent of the programmer, nor imposes the requisite type enforcement.

```ts
export enum StandardSortOrder {
    Default,
    Most,
    Least
}

export enum AlternativeSortOrder {
    Default,
    High,
    Medium,
    Low
}

export interface IThingThatUsesASortOrder<T extends enum> { // doesn't compile
    sortOrder: T;
}
```
Repository: TypeScript
Issue: Add support for using declaration
Labels: Suggestion,Awaiting More Feedback

<!-- 🚨 STOP 🚨 𝗦𝗧𝗢𝗣 🚨 𝑺𝑻𝑶𝑷 🚨

Half of all issues filed here are duplicates, answered in the FAQ, or not appropriate for the bug tracker. Please read the FAQ first, especially the "Common Feature Requests" section.

-->

## Search Terms

using-declaration, using, declaration, overload

<!-- List of keywords you searched for before creating this issue. Write them down here so that others can find this suggestion more easily -->

## Suggestion

<!-- A summary of what you'd like to see added or changed -->
Add language support similar to Using-declaration in C++ (https://en.cppreference.com/w/cpp/language/using_declaration) to pull in names from base class.

## Use Cases

<!--
What do you want to use this for?
What shortcomings exist with current approaches?
-->
In derived class a new overload is added to an API. This requires that overloads from base classes are copied to derived class otherwise typescript complains. A keyword like the using-declaration in C++ to pull in names from base class would be handy to avoid duplication.

## Examples

<!-- Show how this would be used and what the behavior would be -->
```ts
class Emitter {
  addListener(event: "foo", cb: (p: string) => void): void;
  addListener(event: "bar", cb: (p: string, e: number) => void): void;
  addListener(event: string, cb: (...arg: any[]) => void): void {}
}

class SpecialEmitter extends Emitter {
  // I would prefer using Emitter.addListener or similar here
  addListener(event: "foo", cb: (p: string) => void): void;
  addListener(event: "bar", cb: (p: string, e: number) => void): void;

  // new overloads supported by SpecialEmitter
  addListener(event: "new", cb: (x: RegExp) => void): void;
  addListener(event: "next", cb: (x: number, b: boolean) => void): void;
  addListener(event: string, cb: (...arg: any[]) => void): void {}
}
```

## Checklist

My suggestion meets these guidelines:

* [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
* [x] This wouldn't change the runtime behavior of existing JavaScript code
* [x] This could be implemented without emitting different JS based on the types of the expressions
* [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
* [x] This feature would agree with the rest of [TypeScript's Design Goals](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals).
Repository: flutter
Issue: UI collapses when writing in TextFormField
Labels: c: new feature,framework,f: material design,d: stackoverflow,c: proposal,P3,team-design,triaged-design

I am trying to make simple UI where there is a column with three elements. The first one is a listview, the second one is a TextFormField and last one is a container. When I try to type in the TextFormField then the bottom container also replaces which I don't understand.

Here is my code to help you understand my problem more clearly.

	class demo extends StatefulWidget {
	  @override
	  _demoState createState() => _demoState();
	}

	class _demoState extends State<demo> {
	  @override
	  Widget build(BuildContext context) {
		return Scaffold(
		  appBar: AppBar(title: Text("demo"),),
		  body: new Column(
			children: <Widget>[
			  Expanded(
				child: new ListView.builder(
				  itemCount:1000,
				  itemBuilder: (context,index){
					return Container(
					  padding: EdgeInsets.all(10.0),
					  height: 25.0,
					  color: Colors.grey,
					  child: Text(index.toString()),
					);
				  }
				),
			  ),
			  new TextFormField(
				decoration: InputDecoration(
				  border: OutlineInputBorder(),
				  hintText: "Enter Demo",
				  hintStyle: TextStyle(color: Colors.grey),
				),
			  ),
			  new Container(
				height: 20.0,
				child: Text("Demo Text"),
			  )
			],
		  ),
		);
	  }
	}
Repository: flutter
Issue: RefreshProgressIndicator looks weird without square constraints
Labels: framework,f: material design,a: fidelity,has reproducible steps,P2,found in release: 3.3,found in release: 3.7,team-design,triaged-design

If I put a `RefreshProgressIndicator` in a `SizedBox` with an unequal `width` and `height`, I end up with an animating elliptical spinner drawn over a circular background.  I don't think that this is intended.

Either the background should also be elliptical or the spinner should be constrained to be circular.  (My preference would be for the latter and to make `CircularProgressIndicator` actually circular:  it'd match the name and documentation, and I doubt anyone really wants elliptical spinners.)

![Screenshot_1553709940](https://user-images.githubusercontent.com/17391434/55101074-86da4c00-5080-11e9-823a-3a8c260ab9ed.png)
```
void main() {
  return runApp(MaterialApp(
    home: Scaffold(
      body: Center(
        child: SizedBox(
          width: 400,
          height: 200,
          child: RefreshProgressIndicator(),
        ),
      ),
    ),
  ));
}

```

Flutter 1.4.2-pre.3 • channel unknown • unknown source                         
Framework • revision bafe7cbbb4 (13 hours ago) • 2019-03-26 21:40:53 -0700     
Engine • revision 0d83a2ecd1
Tools • Dart 2.2.1 (build 2.2.1-dev.2.0 None)
Repository: kubernetes
Issue: Volume operation metrics improvements
Labels: sig/storage,kind/feature,lifecycle/frozen

<!-- Please only use this template for submitting enhancement requests -->

**What would you like to be added**:
* Filter out user configuration errors from system errors
* Separately measure storage plugin time from pure Kubernetes overhead
* Measure total latency from a K8s user's perspective (time from creating a Pod to the volume being attached and/or mounted) instead of the current operation metrics which only measures one retry loop.

**Why is this needed**:
Improve visibility of the user experience with volumes, and be able to better account for Kubernetes overhead.
Repository: flutter
Issue: [Discussion] Scope spanning multiple screens
Labels: framework,customer: crowd,c: proposal,a: error message,P3,team-framework,triaged-framework

Having a way to manage scopes in Flutter.
![image](https://cdn-images-1.medium.com/max/2000/1*_kbcMbCzz-9nouOXvGnI-Q.png)
(From https://proandroiddev.com/dagger-2-part-ii-custom-scopes-component-dependencies-subcomponents-697c1fa1cfc)

_An example:_

The login is implemented using multiple pages (which are managed by the `Navigator`). Each login page wants to access the `LoginBloc`, once the login is completed the `LoginBloc` is no longer needed and should be disposed.

**Possible implementations right now:**

1. Nested navigators

This solves the issue as each `Navigator` can hold the necessary state, though this approach introduces quite a few problems because `Navigators` are not really intedned to be nested this way.


2. Having the Bloc above the `Navigator` and only exposing them to the necessary routes

Two problems with this - nesting these dependencies can become pretty cumbersome because each route needs to be explicitly wrapped in all of the used dependencies (with dependencies I mean some kind of `InheritedWidget` which exposes the actual data).

And, even though other routes have no access to the data, the data is not disposed, which leads to a memory leak and leaves the bloc in an "undifined" state.

_(Bloc in these examples could be replaced with any kind of business logic/ data storage)_

The main problem is that each route is completely separate and there doesn't seem to be an easy way to accomplish this.

I was wondering if this is anything that should be in the framework or should be provided as a separate package.

I've talked to @rrousselGit about this, he had a few ieads how this could be solved but we'd like to hear other thoughts.
Repository: pytorch
Issue: Make it easier to figure out what CuDNN convolution algorithm we actually chose
Labels: module: cudnn,module: logging,triaged

While debugging #12484 I wanted PyTorch to tell me which cuDNN convolution algorithm it selected. But I have no way of getting it to do so, except running nvprof and reading the tea leaves.
Repository: TypeScript
Issue: allow inline intellisense comment on es6 export
Labels: Suggestion,Experience Enhancement


## Search Terms

intellisense  export 

## Suggestion

allow inline intellisense documentation of es6 export, or at least propagate the intellisense comments of the exported package.   currently nothing is exported (other than type definitions)

## Use Cases

allows for index files for large libraries to have better descriptions of the sub-modules it contains.

current (working) approach is to use the old pre-es6 ```/** comment */export import x = requires("x")``` 

## Examples

```typescript
/** promise fs based api and related quality-of-life helper functions */
import * as fs from "./fs";
export { fs };
```

the above intellisense comment doesn't propagate.

## Checklist

My suggestion meets these guidelines:

* [ X] This wouldn't be a breaking change in existing TypeScript/JavaScript code
* [ X] This wouldn't change the runtime behavior of existing JavaScript code
* [ X] This could be implemented without emitting different JS based on the types of the expressions
* [ X] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
* [ X] This feature would agree with the rest of [TypeScript's Design Goals](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals).
Repository: godot
Issue: [3.x] Code completion is not full for custom functions
Labels: bug,topic:gdscript,topic:editor,confirmed

**Godot version:** 3.1

**OS/device including version:** Ubuntu 18.04

**Issue description:**
Code completion does not provide parameter hints for custom functions if they are used from a script other than they are declared in.

```gdscript
# one script
extends Object
class_name KnownClass

func test(param: String):
	pass
```

```gdscript
# another script
extends Node2D

func _ready():
	var kc: KnownClass = KnownClass.new()
	kc.test("here completion does not show parameter list")
```

**Minimal reproduction project:**
[repro_cc_custom_func.tar.gz](https://github.com/godotengine/godot/files/3015179/repro_cc_custom_func.tar.gz)