sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: flutter
Issue: Add the Android applicationId and iOS bundle id to the creation output
Labels: c: new feature,tool,P2,team-tool,triaged-tool

I'd like to suggest adding the Android application and iOS bundle id to the generation console output. I think this would help identify the generated when `--org tld.domain` is used and how that affects the naming of the ids. 

I'm trying to setup the bundle id on the apple developer site after I created the app. For now I'll build and open xcode and go find it in the target runner settings. So there is a way to do this already. I thought this might be handy. 

## Steps to Reproduce
1. use `flutter create --org tld.domain myproject`
2. try to figure out how to setup the app on the apple developer site. 

## Logs

```
Brandons-MacBook-Pro:workspace-idea branflake2267$ flutter create --plugin --org com.gawkat mytestplugin
Creating project mytestplugin...
Running "flutter packages get" in mytestplugin...     2.9s
Wrote 70 files.

Running "flutter packages get" in example...          2.6s

[✓] Flutter is fully installed. (on Mac OS X 10.12.5 16F73, locale en-US, channel master)
[✓] Android toolchain - develop for Android devices is fully installed. (Android SDK 25.0.3)
[✓] iOS toolchain - develop for iOS devices is fully installed. (Xcode 8.3.2)
[✓] Android Studio is fully installed. (version 2.3)
[✓] IntelliJ IDEA Ultimate Edition is fully installed. (version 2017.1.3)
[✓] Connected devices is fully installed.

All done! In order to run your application, type:

  $ cd mytestplugin/example
  $ flutter run

Your main program file is lib/main.dart in the mytestplugin/example directory.
```

```
Brandons-MacBook-Pro:example branflake2267$ flutter doctor
[✓] Flutter (on Mac OS X 10.12.5 16F73, locale en-US, channel master)
    • Flutter at /Users/branflake2267/git/flutter
    • Framework revision 767ab66c25 (6 hours ago), 2017-05-27 00:45:25 -0700
    • Engine revision 75c74dc463
    • Tools Dart version 1.24.0-dev.3.0

[✓] Android toolchain - develop for Android devices (Android SDK 25.0.3)
    • Android SDK at /Users/branflake2267/Library/Android/sdk
    • Platform android-25, build-tools 25.0.3
    • Java binary at: /Applications/Android Studio.app/Contents/jre/jdk/Contents/Home/bin/java
    • Java version: OpenJDK Runtime Environment (build 1.8.0_112-release-b06)

[✓] iOS toolchain - develop for iOS devices (Xcode 8.3.2)
    • Xcode at /Applications/Xcode.app/Contents/Developer
    • Xcode 8.3.2, Build version 8E2002
    • ios-deploy 1.9.1
    • CocoaPods version 1.2.1

[✓] Android Studio (version 2.3)
    • Android Studio at /Applications/Android Studio.app/Contents
    • Gradle version 3.2
    • Java version: OpenJDK Runtime Environment (build 1.8.0_112-release-b06)

[✓] IntelliJ IDEA Ultimate Edition (version 2017.1.3)
    • Dart plugin version 171.4424.63
    • Flutter plugin version 14.0

[✓] Connected devices
    • None
```
Repository: bitcoin
Issue: listreceivedbyaddress incorrectly shows watchonly addresses as empty
Labels: RPC/REST/ZMQ

The arguments are minconf, include_empty, and include_watchonly. If include_empty is true then watchonly addresses are returned as having a 0 balance even if they have a positive balance. Only when include_watchonly is also true do watchonly addresses with a balance return with their correct balance.

When include_empty is true and include_watchonly is false then the watchonly addresses should not be returned at all.

Example:
$ ./bitcoin-cli listreceivedbyaddress 1 true
[
  {
    "address": "watch only",
    "account": "",
    "amount": 0.00000000,
    "confirmations": 0,
    "label": "",
    "txids": [
    ]
  }, 
  {
    "address": "address with privkey",
    "account": "",
    "amount": 0.00000000,
    "confirmations": 0,
    "label": "",
    "txids": [
    ]
  }
]

$ ./bitcoin-cli listreceivedbyaddress 1 true true
[
  {
    "address": "address with privkey",
    "account": "",
    "amount": 0.00000000,
    "confirmations": 0,
    "label": "",
    "txids": [
    ]
  },
  {
    "address": "watch only",
    "account": "",
    "amount": 1.0000000,
    "confirmations": 1234,
    "txids": [
         ...
    ]
  }
]
Repository: vscode
Issue: Feature Request: Zero-latency Typing
Labels: feature-request,editor-core

Following articles goes into length describing the issue in general. 

- https://pavelfatin.com/typing-with-pleasure/
- https://blog.jetbrains.com/idea/2015/08/experimental-zero-latency-typing-in-intellij-idea-15-eap/
- https://news.ycombinator.com/item?id=10787812

The subtle typing lag is observed in VS Code in same machine in which the typing is lag free with sublime text and even eclipse. This feature request is to look into the issue and address it if feasible.
Repository: vscode
Issue: Add option to use windows keymap on MacOS
Labels: feature-request,keybindings

- VSCode Version: 1.12.2
- OS Version: macOS Sierra 

We can write `keybindings` in `package.json` (Extension Manifest File).
```json
"keybindings": [
    {
        "win": "ctrl+y",
        "mac": "cmd+backspace",
        "linux": "ctrl+y",
        "command": "editor.action.deleteLines",
        "when": "editorTextFocus && !editorReadonly"
    }
]
```
I got a request from some developers that they are using macOS but they want to use Windows keybindings. See [Add option to use windows keymap on MacOS](https://github.com/k--kato/vscode-intellij-idea-keybindings/issues/67).

So, I'd like to switch `mac` and `win` in `settings.json` or something. Can I do this?
Repository: flutter
Issue: Text fields should automatically support previous and next buttons in iOS keyboard to tab between fields.
Labels: a: text input,platform-ios,framework,has reproducible steps,P2,found in release: 3.3,found in release: 3.7,team-ios,triaged-ios,fyi-text-input

## Steps to Reproduce

1. Run the Flutter Gallery application on an iPhone.
2. Select the "Text fields" demo.
3. Click on any text field.
4. Notice the keyboard does not show previous and next arrows to tab between field.

## Logs

N/A

## Flutter Doctor
```
[✓] Flutter (on Mac OS X 10.12.4 16E195, locale en-US, channel master)
    • Flutter at /Users/?/Development/flutter
    • Framework revision 767ab66c25 (32 hours ago), 2017-05-27 00:45:25 -0700
    • Engine revision 75c74dc463
    • Tools Dart version 1.24.0-dev.3.0

[✓] Android toolchain - develop for Android devices (Android SDK 25.0.3)
    • Android SDK at /Users/?/Library/Android/sdk
    • Platform android-25, build-tools 25.0.3
    • ANDROID_HOME = /Users/?/Library/Android/sdk
    • Java binary at: /Applications/Android Studio.app/Contents/jre/jdk/Contents/Home/bin/java
    • Java version: OpenJDK Runtime Environment (build 1.8.0_112-release-b06)

[✓] iOS toolchain - develop for iOS devices (Xcode 8.3.2)
    • Xcode at /Applications/Xcode.app/Contents/Developer
    • Xcode 8.3.2, Build version 8E2002
    • ios-deploy 1.9.1
    • CocoaPods version 1.2.1

[✓] Android Studio (version 2.3)
    • Android Studio at /Applications/Android Studio.app/Contents
    • Gradle version 3.2
    • Java version: OpenJDK Runtime Environment (build 1.8.0_112-release-b06)

[✓] IntelliJ IDEA Community Edition (version 2017.1.3)
    • Dart plugin version 171.4424.63
    • Flutter plugin version 13.1
```
Repository: rust
Issue: Provide a way to interpolate crate version in html_root_url
Labels: T-rustdoc,C-feature-request

In Serde we work around this by having a reminder in Cargo.toml to update the html_root_url when releasing a new version. https://github.com/serde-rs/serde/commit/dc7ab2696a14fe5ca219ac09f8496bdc613ff602

```toml
[package]
version = "1.0.8" # remember to update html_root_url
```

```rust
#![doc(html_root_url = "https://docs.rs/serde/1.0.8")]
```

This is annoying and easily falls out of sync. For example mio 0.6.8 docs point to version 0.6.1: https://github.com/carllerche/mio/issues/613.

There should be a way to keep these synchronized automatically.
Repository: rust
Issue: Link no-deps documentation with no html_root_url to docs.rs by default
Labels: T-rustdoc,C-feature-request

As of Rust 1.19.0-nightly, documenting a crate with `cargo doc --no-deps` will link to the html_root_url of any dependencies that have one set, and other dependencies will not be linked.

![selection_056](https://cloud.githubusercontent.com/assets/1940490/26560902/bd1da5f2-446e-11e7-9eff-87dd4ae555fa.png)

In the screenshot, the crate providing `HasHtmlRootUrl` has an html_root_url so the type is linked. The crate providing `NoHtmlRootUrl` does not have an html_root_url so the type is not linked.

Linking `NoHtmlRootUrl` to docs.rs would be a reasonable fallback.
Repository: TypeScript
Issue: No object literal completions for type parameter constrained to mapped type
Labels: Suggestion,Domain: Completion Lists,Experience Enhancement

Isolated from [this StackOverflow issue](https://stackoverflow.com/questions/44252421/how-to-extend-list-all-typescript-class-properties-and-methods-in-constructor)

```ts
interface Foo {
    foo(): void;
}

declare function f<T extends Partial<Foo>>(x: T): T;

f({
    /*$*/
})
```

Request completions at the cursor in the above sample.

**Expected:** `foo` is a completion.
**Actual:** No completions.
Repository: go
Issue: net/http: connection reuse does not work happily with normal use of json package
Labels: NeedsFix

Please answer these questions before submitting your issue. Thanks!

### What version of Go are you using (`go version`)?

go 1.8.1

### What operating system and processor architecture are you using (`go env`)?

```
GOARCH="amd64"
GOBIN=""
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
```

### What did you do?

Used `json.NewDecoder(resp.Body)` to read the body of an http response. The http request was using TLS. This is a [playground app](https://play.golang.org/p/p7edRynwDJ) demonstrating the issue

### What did you expect to see?

I expected the tls connection reused on subsequent requests

### What did you see instead?

The tls connection is discarded and a new connection is opened for every request 

I also started [a thread](https://groups.google.com/d/msg/golang-nuts/m4wtJLnLFTE/pmOXglyvBgAJ) on the mailing list
Repository: TypeScript
Issue: Affine types / ownership system
Labels: Suggestion,Awaiting More Feedback

<!-- SUGGESTIONS: See https://github.com/Microsoft/TypeScript-wiki/blob/master/Writing-Good-Design-Proposals.md -->

It would be amazing if typescript could gain types with an ownership semantics as it could provide a very powerful tool against bugs caused by mutations. Idea is inspired by [Rust's owneship system](https://doc.rust-lang.org/book/ownership.html) and adapted to match ts / js language. Idea is to provide built-in types for which move semantics would be tracked. In the example below I'll refer to that type as `Own<t>` 

Ensures that there is exactly one binding to any given `Own<t>`, if it is assigned to another binding type of the former binding should become `Moved<t>` and type of the new binding should be `Own<t>`. 

```ts
const array:Own<number[]> = [1, 2, 3]
const array2 = array // => <Own<number[]>> [1, 2, 3]
const first = array[0] <- [TS]: `Moved<number[]>` has no index signature.
```

A similar thing should happens if function is passed `Own<t>`, binding in the caller scope will get type `Moved<t>`:


```ts
function take(array: Own<number[]>) {
    // What happens here isn’t important.
}

let array:Own<number[]> = [1, 2, 3];

take(array);

array[0] // <- [TS]: `Moved<number[]>` has no index signature.
```

Rust also has also [borrowing semantics](https://doc.rust-lang.org/book/references-and-borrowing.html#borrowing) which may be also worse pursuing. But for now I'm going to leave it out until I get some initial feedback.

### Why

Typescript already provides tools to deal with the same class of issues using `readonly` feature, which is nice but mostly useful with immutable data structures that do impose an overhead. With an ownership system it would be possible to author performance critical code without an overhead while still maintaining safety guarantees from the type system.
Repository: go
Issue: cmd/compile: improve escape analysis of make([]T, n) where n is non-constant
Labels: Performance,compiler/runtime

```
$ cat a.go
package p

var n = 3

func f() {
        slice := make([]*int, n)
        var i int
        slice[0] = &i
}

$ go tool compile  -m a.go
a.go:5:6: can inline f
a.go:6:15: make([]*int, n) escapes to heap
a.go:8:13: &i escapes to heap
a.go:7:6: moved to heap: i
``` 

In this program, the compiler's escape analysis judges that the array allocated by `make` escapes to the heap, when in fact it does not, presumably because its size is non-constant and thus it cannot be allocated on the stack (without `alloca`).

The lack of this optimization makes it hard to write a good bytecode interpreter in Go because the interpreter's operand stack has a non-constant size, and is thus heap-allocated, even though it is guaranteed by construction not to escape.  Consequently, the interpreter incurs a heap allocation at the start of each function, and then a GC write barrier each time it stores an operand to the stack, which is a common operation.

Perhaps the notions of "escapes to heap" and "requires a write barrier" could be decoupled so that a non-constant-sized non-escaping heap variable could avoid write barriers.  Or perhaps the compiler could use `alloca` to allocate non-constant-size non-escaping variables on the stack.
Repository: pytorch
Issue: Feature Request: load_state_dict should take filenames
Labels: feature,module: nn,triaged

In high memory pressure situations, the following is a common occurrence:

1. create model
2. read state_dict from checkpoint file (loads on GPU)
3. model.load_state_dict(s)

Because of memory pressure, a common workaround is to first do:

```
s = torch.load('my_file.pt', map_location=lambda storage, loc: storage)
```

And then load `s` into `model`.

This is a very common scenario that we should be able to avoid, and this scenario might have some pitfalls: what happens on part-GPU part-CPU models, what happens on multi-GPU models...

if load_state_dict took a filename directly, it can delete it's existing parameter storages and set them to the new one on the fly, thereby requiring no extra memory.
Repository: TypeScript
Issue: Improve Javascript intellisense type inference for cases where Object.assign(this, ...) is used with an object with known type information
Labels: Suggestion,Awaiting More Feedback,VS Code Tracked,Domain: JavaScript

_From @jj101k on May 28, 2017 10:16_

- VSCode Version: 1.12.2 (19222cdc84ce72202478ba1cec5cb557b71163de)
- OS Version: macOS Sierra 10.12.5 (16F73)

Given the Javascript code:

```js
class Foo {
    constructor() {
        Object.assign(
            this,
            {
                bar: "abc",
            }
        );
        this.foo = "def";
    }
}

var f = new Foo();
console.log(f.foo);
console.log(f.bar);
```

If you hover over `f.foo`, it will tell you that it's a string. If you hover over `f.bar`, it will say it's "any". They should both say "string".

Object.assign is a fairly common way of setting several properties with a bit less copy/paste. In cases where an object without known type information is used as the last argument it isn't possible to statically infer appropriate types for the modified object ("this", here) and equivalently the object that Object.assign returns. Where type information of the last argument _is_ known, it is safe and appropriate to import all of that into the type information for the object, as if a series of direct assignments had been done.

Caveats: In Javascript (perhaps not Typescript) it's possible that further unknown properties are present on any given object, so it would be appropriate to void all inferred type information which is not between Object.assign and the end of the constructor. If Object.assign is used outside a constructor (on a named object) it should void all inferred types entirely, because the type information could be entirely different before and after. The same should be true if Object.assign is conditionally called in the constructor. The only exception should be when all arguments after the first have known final type information, eg. an immediate object.

For practical purposes, `Object.assign(foo, bar, {baz: 1})` should be considered equivalent to `for(name in bar) if(bar.hasOwnProperty(name)) foo[name] = bar[name]; foo.baz=1;`.

_Copied from original issue: Microsoft/vscode#27397_
Repository: rust
Issue: In rustdoc, omit trait impls that a user cannot call
Labels: T-rustdoc,A-visibility,C-feature-request

```rust
pub struct Public;
struct Private;

impl From<Private> for Public {
    fn from(_: Private) -> Self {
        unimplemented!()
    }
}
```

The rustdoc of `Public` displays a `From` impl that cannot be invoked by users of the crate.

![selection_057](https://cloud.githubusercontent.com/assets/1940490/26615406/77d6e194-457b-11e7-919c-29d309f8813d.png)

I'm sure there are lots of edge cases to consider, but this is a common pattern especially for error types for use with `?`. It would be nice to hide such impls from rustdoc without requiring the crate author to tag them with `#[doc(hidden)]`.

This came up during the libz blitz evaluation of the reqwest crate. https://github.com/seanmonstar/reqwest/issues/106
Repository: neovim
Issue: Timer behavior is inconsistent with Vim
Labels: needs:decision,compatibility,needs:design,event-loop

This was noticed while merging Vim's timer tests, since the timing windows that are expected differ between Vim and Neovim.  I figured we should discuss the differences and decide whether it's something that should be addressed or just accepted/documented as being different.

## Timer period
Since Neovim uses libuv, the timer is constantly running.  The callback gets queued when the timer fires as long as the event loop isn't busy.
Since Vim manually manages the timer, the timer is rescheduled after a callback finishes executing.

Similarly, a paused timer in Vim that exceeds its timer will execute the callback "immediately" where as in Neovim it can be delayed for close to a full timer period since the callback needs to get queued again.

To make this concrete, pretend there's a 10 ms timer with a callback that takes 5 ms.

### Timing of repeated callbacks

#### 1a. Vim
```
Timer:    ---------|     ---------|     ---------|
Callback:           ----|          ----|
```

#### 1b. Neovim
```
Timer:    ---------|---------|---------|
Callback:           ----|     ----|
```

On the other hand, if the timer is short but the execution is long it looks like this:

#### 2a. Vim
```
Timer:    ----|          ----|          ----|
Callback:      ---------|     ---------|
```

#### 2b. Neovim
```
Timer:    ----|----|----|----|----|----|----|
Callback:      ---------|     ---------|
```

### Timing of repeated callbacks in the presence of pauses

Same timer and callback, but with a 3 ms pause injected with 6 ms between each pause.

#### 3a. Vim
```
Timer:    ----------|       ----------|
Pause:    xxx      xxx      xxx      xxx
Callback:             -----|            -----|
```

#### 3b. Neovim
```
Timer:    ----------|----------|----------|----------|----------|
Pause:    xxx      xxx      xxx      xxx     xxx      xxx      xxx
Callback:                        -----|    ----|
```

On the other hand, if the timer is short but the execution is long it looks like this:

#### 4a. Vim
```
Timer:    ----|          ----|           ----|
Pause:    xxx      xxx      xxx      xxx     xxx
Callback:      ---------|      ---------|       ---------|
```

#### 4b. Neovim
```
Timer:    ----|----|----|----|----|----|----|----|----|
Pause:    xxx      xxx      xxx      xxx     xxx      xxx
Callback:      ---------|---------|---------|   ---------|
```
Repository: vscode
Issue: Align explorer sorting with platform sorting
Labels: feature-request,file-explorer

It looks like our file sorting in the explorer does not match platform beahviour in some cases.

**Windows:**
* a file `foo.ts` is sorted before `foo_test.ts` but we sort it the other way around

**Linux:**
* a file `foo.ts` is sorted before `foo_test.ts` but we sort it the other way around
* a lowercase file seems to be sorted before an upper case file but we seem to mix the sorting independent of the casing (e.g. folders `[out, outb, outd, Outa, Outc]` are showing up as `[out, OutA, outb, Outc, outd]`

**macOS:**
* seems to be OK

We use a JavaScript [`Collator`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Collator) for the comparing [here](https://github.com/Microsoft/vscode/blob/master/src/vs/base/common/comparers.ts#L19). 

Unfortunately I am not able to tweak the Collator options to bring me the desired result...
Repository: electron
Issue: Virtual File Drag & Drop Events
Labels: enhancement :sparkles:,component/drag-and-drop

Many drag and drop operations contain virtual file data. Chrome currently only accepts files on disk. This means that you can't drag images directly from a browser into an Electron app. The same is true for e-mails in Outlook/Mail.app, entries in Calendar apps, etc.

* Electron version: All
* Operating system: macOS, Windows, Linux

### Expected behavior
When a virtual file is dropped on an Electron app, the developer should have some means of retrieving the data.

### Actual behavior
Chrome only handles `CF_HDROP` data (and it seems like that won't change anytime soon), so we might have to help ourselves here. The drop event is received, but all data fields are empty.

### How to reproduce
Load http://html5demos.com/file-api in an electron app. Try to drag an image from Chrome into the upload area. The cursor will change, the image will be "dragged", but no data will be received.
Repository: neovim
Issue: RPC commands always defined using f-args
Labels: enhancement,plugin,channels-rpc

(Subverting issue template as it doesn't seem to apply)

Currently, all commands defined via the RPC interface have to use f-args as the input method for the arguments, see https://github.com/neovim/neovim/blob/fcc9d999670c6fb29ac01e9c8d0a7e787ccfabea/runtime/autoload/remote/define.vim#L58

It could be useful to use the others, e.g. `<args>`, `<q-args>` etc.

It could be made part of the api, and then exposed by the RPC clients for command definition.