sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: vscode
Issue: VSCode automatically scrolls to top of cell output when scrolling up
Labels: bug,polish,notebook-output

### Applies To

- [X] Notebooks (.ipynb files)
- [ ] Interactive Window and\/or Cell Scripts (.py files with \#%% markers)

### What happened?

When scrolling up, the window jumps up when it hits the bottom of a cell output. This happens for matplotlib output but not text output. This is very annoying with large cell outputs.

From the settings it seems like this is a "feature": "...the window will only automatically scroll if the bottom of the prior cell is visible." But there is no way to change this behavior. 

https://user-images.githubusercontent.com/1147498/152693312-6756009f-ce17-4c44-8a9a-98610d59ea26.mp4




### VS Code Version

Version: 1.64.0 (user setup) Commit: 5554b12acf27056905806867f251c859323ff7e9 Date: 2022-02-03T04:22:20.678Z Electron: 13.5.2 Chromium: 91.0.4472.164 Node.js: 14.16.0 V8: 9.1.269.39-electron.0 OS: Windows_NT x64 10.0.19043

### Jupyter Extension Version

Jupyter v2022.1.1001775990

### Jupyter logs

_No response_

### Coding Language and Runtime Version

Python 3.9.10 64-bit

### Language Extension Version (if applicable)

_No response_

### Anaconda Version (if applicable)

_No response_

### Running Jupyter locally or remotely?

Local
Repository: react
Issue: Mechanism to customize rendering of state/props data types
Labels: Type: Feature Request,Component: Developer Tools

When using React from transpiled languages, the way KeyValue.js renders state/props entries is pretty unusable for non-primitive types (int/string).  

I was hoping dev-tools could check for existence of a function on Props/State (or some other mechanism, maybe toStringTag) that would allow app developer to provide a custom display for each entry in the Props/State.  If you provide a custom formatter, you give up the ability to edit those fields.
Repository: godot
Issue: Print an error message when trying to set an `user://` path with `FileDialog.current_dir`/`current_path` and the access mode isn't `ACCESS_USERDATA`
Labels: enhancement,topic:gui

### Godot version

v3.4.2.stable.official [45eaa2daf]

### System information

Mac OSX (any export)

### Issue description

When creating a directory at runtime, and having the `FileDialog` specify that subdirectory, the `FileDialog` fails and instead lists the users home directory.

### Steps to reproduce

```gdscript
func ensure_directory():
	var dir = Directory.new()
	dir.open("user://")
	dir.make_dir("somedirectory")

func _ready():
        ensure_directory()
```

While also having the `FileDialog` point to the `somedirectory`

### Minimal reproduction project

_No response_
Repository: go
Issue: x/tools/gopls: allowModfileModifications when using tempModFile or go.work
Labels: NeedsInvestigation,gopls,Tools,gopls/workspace

govim uses an internal gopls setting: `tempModFile`, along with allowModfileModifications. This appears to be recently broken, perhaps by https://go.dev/cl/382241.

Reported in slack, from their CI:
```
&protocol.LogMessageParams{Type:1, Message:"2022/02/07 17:40:55 imports fixes: AllImportsFixes: -modfile is unsupported for this Go version\n\tfile=\"/tmp/go-test-script3721705982/script-initial_open_go/main.go\"\n"}
```

To begin with, this error message is incorrect, as `-modfile` _is_ supported.

Needs investigation, and should block gopls@v0.8.0

CC @myitcv @leitzler
Repository: flutter
Issue: Feature to customize the alignment of `BottomSheet`s
Labels: c: new feature,framework,f: material design,c: proposal,team-design,triaged-design

<!-- Thank you for using Flutter!

     If you are looking for support, please check out our documentation
     or consider asking a question on Stack Overflow:
      * https://flutter.dev/
      * https://api.flutter.dev/
      * https://stackoverflow.com/questions/tagged/flutter?sort=frequent

     If you have found a bug or if our documentation doesn't have an answer
     to what you're looking for, then fill out the template below. Please read
     our guide to filing a bug first: https://flutter.dev/docs/resources/bug-reports
-->

## Use case

<!--
     Please tell us the problem you are running into that led to you wanting
     a new feature.

     Is your feature request related to a problem? Please give a clear and
     concise description of what the problem is.

     Describe the alternative solutions you've considered. Is there a package
     on pub.dev/flutter that already solves this?
-->

### ModalBottomSheet

The ModalBottomSheet in flutter currently has a fixed alignment of `Alignment.bottomCenter` and no way to customize it through the API `showModalBottomSheet`.

## Proposal

<!--
     Briefly but precisely describe what you would like Flutter to be able to do.

     Consider attaching something showing what you are imagining:
      * images
      * videos
      * code samples

     Does this have to be provided by Flutter directly, or can it be provided
     by a package on pub.dev/flutter? If so, maybe consider implementing and
     publishing such a package rather than filing a bug.
-->


I would like to propose that we add a new optional `AlignmentGeometry` parameter to showModalBottomSheet. This way it would be possible for the user to customize this aspect.
Repository: go
Issue: x/build/cmd/coordinator: mind combined memory usage when concurrently processing large payloads
Labels: Builders,NeedsInvestigation

As part of WriteTgz/PutTar operations, the coordinator handles payloads that may be large (for example, a Go tree tarball is 23 MB, and the x/website tree is even [larger](https://github.com/golang/go/issues/46379)). If the entire payload size is read into memory during the processing of these operations, then multiple operations made in parallel can lead to coordinator using up much more memory than it does under a more average workload, and exceeding its current 8 GB memory limit.

For now, we can double that limit to give it more room to handle workloads that may happen as part of normal Go development and debugging, without getting killed due to OOM.

Keeping this issue open to see what else we may need to do. There are various opportunities to investigate and consider:

- see if these operations can be optimized to stream data rather than hold all bytes in memory during processing
- limit concurrency of these requests
- use disk when processing large tarballs
- keep a larger memory allocation

CC @golang/release, @thanm, @aclements.
Repository: deno
Issue: lsp: issue diagnostic and quick fix for import maps
Labels: feat,lsp

We should issue a diagnostic which determines if a specifier can be re-written to a specifier as an import map, and there is a quick fix which re-writes the specifier.
Repository: flutter
Issue: ImageFilterLayer for simple matrix transforms leads to unnecessary render target switches
Labels: engine,c: performance,perf: speed,P3,team-engine,triaged-engine

Due to Skia's implementation of SkMatrixImageFilter, the filterQuality parameter on the Transform widget is actually very inefficient. This can be verified by taking a capture of a Flutter application with RenderDoc.

https://github.com/google/skia/blob/main/src/core/SkMatrixImageFilter.cpp#L65

Skia's implementation creates an offscreen surface to render the transformed image into. This can be simplified greatly, especially since the source image comes from the raster cache.

In the worst case scenario, Flutter rasterizer caches the child layer, then takes the rasterizer cached image and draws it onto a new SkSurface with the transform, and then draws it to the final canvas during compositing. In the best case scenario, the child layer is already cached.

This extra copy makes the transform extremely expensive, even for static content. ImageFilterLayer is supposed to be a way to efficiently transform and scale static content without tons of raster cache misses, but it unfortunately isn't worthwhile as it doesn't scale due to this issue. It also forcefully caches itself if the filter doesn't change, which is terrible for animations because the raster cache drops the child content if the animation is still for a certain number of frames.

When using a lot of layers, performance suffers compared to using a canvas with transforms & drawImage. The only reason why the canvas solution isn't viable is because Picture.toImage is async, which gives a frame of delay before the image can be used for drawing. The raster cache doesn't have this issue.

I would love to be able to tell TransformLayer to rasterize it's child with one matrix (to add a scale factor to the cache entry's resolution) and then draw the raster cached content with another matrix. This would also be very helpful for ScaleTransition, as you could avoid thrashing the raster cache when scaling something up or down.

cc @flar
Repository: deno
Issue: lsp: provides hover info for import maps
Labels: feat,lsp

When hovering over a specifier that resolves via an import map, there is information available about the import map resolution.
Repository: rust
Issue: Ambiguous error reporting when trying to infer const generic type
Labels: A-diagnostics,T-compiler,A-const-generics,requires-nightly,F-generic_const_exprs,requires-incomplete-features

<!--
Thank you for filing a bug report! 🐛 Please provide a short summary of the bug,
along with any information you feel relevant to replicating the bug.

If you cannot produce a minimal reproduction case (something that would work in
isolation), please provide the steps or even link to a repository that causes
the problematic output to occur.
-->

Given the following code: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=659888b8e5f59352118b3c7b39187f29

```rust
#![feature(adt_const_params)]
#![feature(generic_const_exprs)]
#![feature(generic_arg_infer)]

#[derive(PartialEq, Eq)]
#[allow(dead_code)]
enum Colour {
    R,
    G,
    B,
    W,
}

struct Led<const C: Colour> {}

impl<const C: Colour> Led<C> {
    pub fn new() -> Led<{ Colour::W }> {
        Led::<{ Colour::W }> {}
    }
}

fn main() {
    let l = Led::<_>::new();
}

```

The current output is:

```
error[E0284]: type annotations needed: cannot satisfy `the constant `Led::<{_: Colour}>::new::{constant#0}` can be evaluated`
  --> src\main.rs:24:13
   |
24 |     let l = Led::<_>::new();
   |             ^^^^^^^^^^^^^ cannot satisfy `the constant `Led::<{_: Colour}>::new::{constant#0}` can be evaluated`
   |
note: required by a bound in `Led::<C>::new`
  --> src\main.rs:18:25
   |
18 |     pub fn new() -> Led<{ Colour::Off }> {
   |                         ^^^^^^^^^^^^^^^ required by this bound in `Led::<C>::new`

For more information about this error, try `rustc --explain E0284`.
```

The error message being `cannot satisfy 'the constant 'Led::<{_: Colour}>::new::{constant#0}' can be evaluated'` doesn't explain the error at all, and is confusing in the way it is reported. I'm not entirely sure what is going on internally, but getting the compiler to emit a proper error message  explaining that the const generic type cannot be inferred would be useful.
Repository: flutter
Issue: Many devicelab benchmarks duplicate work that could be batched for one run
Labels: team,engine,c: performance,team: benchmark,P2,team-engine,triaged-engine

Taking, as an example, just the "opacity peephole" benchmarks in the flutter tree, we have specified a few (4 or 5) tasks to run the individual benchmarks in this group. Each task takes the following steps (with times taken from [this sample run](https://ci.chromium.org/ui/p/flutter/builders/prod/Linux_android%20opacity_peephole_fade_transition_text_perf__e2e_summary/311/overview) of one of the opacity peephole benchmarks):

1. `491s` Prepares an environment with access to commit NNNN of the Flutter repo and all dependencies
2. `200s` Builds the `dev/benchmarks/macrobenchmarks` app in the Flutter repo
3. ` 14s` Installs that app on the phone
4. ` 4s` Runs the macrobenchmarks app on the phone.
5. `21s` Uses a test driver to navigate to a specific page in the app and run the animation there
6. `1.4s` Removes the app from the phone
5. ` 18s` When the driver exits, the test harness will forward the results to our tracking facilities (such as Skia perf)
7. `<1s` Exits the test harness which reports the success status to the overall task manager

Because there are 4 or 5 of these tasks (and more maybe coming), we end up with 4 or 5 stations in the devicelab running these benchmarks, each doing those same steps. But, only step 5 differs between the tasks, and it is the step that takes the least amount of time out of any of those steps (21 out of 750s or less than 3%). 5 of those tasks would take 3750s or 62.5 minutes of lab resources (but in parallel so only around 12.5m wall time but using 5 machines to do the work).

If we could package these benchmarks to instead do the following, we could save a lot of time and resources:

1. `491s` Prepares an environment with access to commit NNNN of the Flutter repo and all dependencies
2. `200s` Builds the `dev/benchmarks/macrobenchmarks` app in the Flutter repo
3. `14s` Installs that app on the phone
4. Iterates through a list of benchmark definitions each of which involves:
     1. `4s` Runs the macrobenchmarks app
     2. `21s` Drives the app using the appropriate driver for the benchmark task
     3. `18s` When the driver exits, the test harness will forward the results to our tracking facilities (such as Skia perf)
5. `1.4s` Removes the app from the phone?
6. `<1s` Exits the test harness which reports the success status to the overall task manager

Note that the 4th step could try running the new driver in the already running instance of the app, but for cleaner measurements it would probably be best to exit the app and restart it for the next benchmark spec as the stopping and starting of the app is fairly quick compared to all of the other steps. The total time taken would be around 921.4 seconds or 15.4 minutes. The wall clock time would be longer by a few minutes, but only one device would be used leaving 12.5 * 4 or 50 machine minutes available for other tasks. As the list of benchmarks grow, the total device-minutes saved would grow even larger.
Repository: flutter
Issue: Platform/Network Images will begin loading in the current animation frame on the web
Labels: c: performance,platform-web,good first issue,P2,team-web,triaged-web

Flutter Web uses XHR to load both network and asset images. While the actual load happens asynchronously, constructing and sending the XHR is surprisingly expensive and is currently performed in the animation frame. This can potentially delay the frame end and subsequent animation fames if the app is under heavy load - a common circumstance if the image load is triggered by something like a route navigation.

In the following example from the new gallery, we can see the xhr events are responsible for about ~6.5 ms in a single frame

![image](https://user-images.githubusercontent.com/8975114/152890612-385cff4e-5a43-44e1-ab7c-8428dbad5de3.png)

On the other hand, if we defer them to a separate event loop (using Future.delayed), then they have no impact on the frame workload:

![image](https://user-images.githubusercontent.com/8975114/152890745-7121de75-a6e9-42d4-bb27-2446683f44c5.png)


This has the advantage of not blocking animations under heavy load. This _may_ impact Flutter on mobile and desktop as well, but since the initialization of image loading seems less expensive it may not be worth it to further defer image loads.
Repository: electron
Issue: [Bug]: Can't Create BrowserWindow Larger Than Screen Width
Labels: platform/windows,platform/macOS,bug :beetle:,status/confirmed,component/BrowserWindow,has-repro-gist,17-x-y

### Preflight Checklist

- [X] I have read the [Contributing Guidelines](https://github.com/electron/electron/blob/main/CONTRIBUTING.md) for this project.
- [X] I agree to follow the [Code of Conduct](https://github.com/electron/electron/blob/main/CODE_OF_CONDUCT.md) that this project adheres to.
- [X] I have searched the [issue tracker](https://www.github.com/electron/electron/issues) for a bug report that matches the one I want to file, without success.

### Electron Version

17.0.0

### What operating system are you using?

Windows

### Operating System Version

Windows 10

### What arch are you using?

x64

### Last Known Working Electron version

_No response_

### Expected Behavior

Creating a `BrowserWindow` with width larger than the screen creates a window with the requested width.

### Actual Behavior

Creating a `BrowserWindow` with width larger than the screen creates a window where the width is clipped to the screen width.

### Testcase Gist URL

https://gist.github.com/dsanders11/dbeb5222566ebe7f01dc72b93884202f

### Additional Information

Setting the width to larger than the screen width after creating the window, using `BrowserWindow.setSize`, does work. It should either also work from the `BrowserWindow` constructor, or the documentation should mention that it doesn't.
Repository: flutter
Issue: RouterDeleagete should provide RouteInformationReportingType to Router
Labels: framework,f: routes,c: proposal,P3,team-framework,triaged-framework

## Use case

User wants to open `/messages/123` url, however if user isn't logged in then user is navigated to signup page `'/signup?dest=%2Fmessages%2F123'` when login/signup was succesful then user will be navigated to the original destination `/messages/123`.

This is so far so good however what should happen if user presses browser's backward button? The browser history stack is popped so [RouteInformationParser.parseRouteInformation](https://api.flutter.dev/flutter/widgets/RouteInformationParser/parseRouteInformation.html) gets `'/signup?dest=%2Fmessages%2F123'` input where I can detect the user is already logged in so he/she will be navigated back to `/messages/123`, which is **causing infinity loop**.

Currently `Router` collects only the [RouterDelegate.currentConfiguration which is parsed by RouteInformationParser.restoreRouteInformation](https://github.com/flutter/flutter/blob/2.10.0/packages/flutter/lib/src/widgets/router.dart#L543-L548). Router by default passes `RouteInformationReportingType.none` to `RouteInformationProvider.routerReportsNewRouteInformation` in this case there won't be any replace since the old and the new url aren't the same.

This is how stack is currently filled:

1. User opens `/messages/123`. historystack = `['/messages/123']`
2. `currentConfiguration` reports different location which causes `history.pushState(state, title, '/signup?dest=%2Fmessages%2F123')`. historystack = `['/messages/123', '/signup?dest=%2Fmessages%2F123']`
3. user logs in and `currentConfiguration` reports different location which causes `history.pushState(state, title, '/messages/123')`. historystack = `['/messages/123', '/signup?dest=%2Fmessages%2F123', '/messages/123']`

## Proposal

Router should query `currentReportingType` alongside `currentConfiguration`. `currentReportingType` by default should return `null` so if anyone overrides make sure to return `null` when explicit strategy is not necessary (_for example: replace_) and in that case let `Router` deceide what is the best strategy.

This is how stack should be filled:

1. User opens `/messages/123`. historystack = `['/messages/123']`
2. `currentConfiguration` reports different location and `currentReportingType` reports `neglect` which causes `history.replaceState(state, title, '/signup?dest=%2Fmessages%2F123')`. historystack = `['/signup?dest=%2Fmessages%2F123']`
3. user logs in and `currentConfiguration` reports different location and `currentReportingType` reports `neglect` which causes `history.replaceState(state, title, '/messages/123')`. historystack = `['/messages/123']`

I know [Router.neglect](https://api.flutter.dev/flutter/widgets/Router/neglect.html) can be directly called, so in theory `currentConfiguration` could return always `null` to bypass `Router` auto navigation when it assumes some state changes. However the rest of Navigation requires manual navigation and `Router.neglect` also relies on `currentConfiguration` and if it's `null` then nothing will happen.
Repository: vscode
Issue: Inconsistent keyboard shortcuts between Windows and Linux
Labels: keybindings,under-discussion

<!-- ⚠️⚠️ Do Not Delete This! feature_request_template ⚠️⚠️ -->
<!-- Please read our Rules of Conduct: https://opensource.microsoft.com/codeofconduct/ -->
<!-- Please search existing issues to avoid creating duplicates. -->

<!-- Describe the feature you'd like. -->
I recently switched from windows to Linux and I noticed my favorite keyboard shortcut bindings are all changed!  For example formatting a document ALT-SHIFT-F does not work in Linux.  

I see some push back from contributors saying it's different but as I change them back, like the format document I am not seeing any issues and would like the option to have to memorize just one set of key bindings for the 2 OSs.

Another super common key binding is copy down/up with ALT-SHIFT- UP/DOWN ARROW and I see no side affects changing back to mirror windows kb shortcuts.
Repository: pytorch
Issue: Improve torch::deploy documentation
Labels: module: deploy,oncall: package/deploy,imported

### 📚 The doc issue

We should specify the semantics of sharing ReplicatedObj across interpreters. E.g. walk through the typical case of multithreaded model inference: the weights' memory is shared across, but the intermediate assignments to the attributes (some models do that) are isolated. Another gotcha might be that bulky python data structured (e.g. vocab dict) will be replicated too.

### Suggest a potential alternative/fix

_No response_

cc @wconstab
Repository: rust
Issue: Tracking Issue for control-flow enforcement technology (CET)
Labels: C-tracking-issue,PG-exploit-mitigations

<!--
NOTE: For library features, please use the "Library Tracking Issue" template instead.

Thank you for creating a tracking issue! 📜 Tracking issues are for tracking a
feature from implementation to stabilisation. Make sure to include the relevant
RFC for the feature if it has one. Otherwise provide a short summary of the
feature and link any relevant PRs or issues, and remove any sections that are
not relevant to the feature.

Remember to add team labels to the tracking issue.
For a language team feature, this would e.g., be `T-lang`.
Such a feature should also be labeled with e.g., `F-my_feature`.
This label is used to associate issues (e.g., bugs and design questions) to the feature.
-->

This is a tracking issue for standardizing the control-flow enforcement technology (CET) flag, `cf-protection`.

### About tracking issues

Tracking issues are used to record the overall progress of implementation.
They are also used as hubs connecting to other relevant issues, e.g., bugs or open design questions.
A tracking issue is however *not* meant for large scale discussion, questions, or bug reports about a feature.
Instead, open a dedicated issue for the specific matter and add the relevant feature gate label.

### Steps
<!--
Include each step required to complete the feature. Typically this is a PR
implementing a feature, followed by a PR that stabilises the feature. However
for larger features an implementation could be broken up into multiple PRs.
-->

- [x] Implement the unstable flag for `cf-protection`
- [ ] Standardize the `cf-protection` flag as a `-C` codegen flag

### Unresolved Questions

- [ ] Decide whether it is necessary/advisable to merge similar compilation flags (e.g. `cf-guard`, `cf-protection`, `branch-protection`) under a common flag interface
- [ ] Decide whether to build the standard libraries with `cf-protection` by default

If we do build the standard libraries with `cf-protection` enabled, any assembly code in the libraries will need to be manually checked to see to it that when this flag is set, ENDBR* instructions are inserted in the right places.

### Implementation history

See #93439.