sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: godot
Issue: `TextEdit.get_caret_draw_pos()` is unreliable altogether
Labels: bug,discussion,documentation,topic:gui

### Tested versions

4.2.1

### System information

Godot v4.2.1.stable - Pop!_OS 22.04 LTS - X11 - Vulkan (Forward+) - integrated Intel(R) Graphics (ADL GT2) () - 12th Gen Intel(R) Core(TM) i5-1235U (12 Threads)

### Issue description

My expectation is that `TextEdit.get_caret_draw_pos()` is a function I can use to consistently predict where a caret should be drawn, and to draw my own things there. But it's entirely unreliable and fails when the draw position is clipped, when the window is resized, and for empty lines, and probably other things I've yet to discover.

https://github.com/godotengine/godot/assets/85438892/17ef3714-5680-4334-8bc7-50c8ada3119d

Related: #65981

### Steps to reproduce

There's a MRP. But basically, add a TextEdit, then add a script to make it draw a circle at the caret pos, then try all the stuff I showed in the video above.

### Minimal reproduction project (MRP)

[TextEdit bug.zip](https://github.com/godotengine/godot/files/14388386/TextEdit.bug.zip)
Repository: rust
Issue: PR CI: check-build the library for more targets
Labels: A-testsuite,T-bootstrap,C-feature-request

@saethlin and @onur-ozkan made it so that `./x.py check library --target=aarch64-pc-windows-msvc` now works on all hosts, without special magic Windows tooling being needed. We should use that in PR CI to catch some more standard library build issues. In particular we are currently not covering
- Windows MSVC (we do check GNU)
- macOS

(Or, well, it turns out we run Miri tests for these targets so we cover them in x86_64-gnu-tools. But that seems to be a bit too accidental. And Miri doesn't complain if there are warnings, only if there are errors. And this sets `cfg(miri)` which changes some codepaths.)

@rust-lang/infra which runner would be the best one to add this to? AFAIK the mingw-check runner exists mostly to give us some test coverage for library builds on a Windows target, so maybe that would be a good one?
Repository: storybook
Issue: [Bug]: JsDocs @deprecated tag does not show description
Labels: bug,help wanted,has workaround,angular,sev:S3

### Discussed in https://github.com/storybookjs/storybook/discussions/26154

<div type='discussions-op-text'>

<sup>Originally posted by **miszol1** February 13, 2024</sup>
### Describe the bug

When @ deprecated tag is used to describe input property, description is not displayed in Docs tab.
![image](https://github.com/storybookjs/storybook/assets/24455637/af2244c6-0dcf-4b49-bbbf-1ef8ace01efb)
![image](https://github.com/storybookjs/storybook/assets/24455637/63fe32b0-50ec-4a53-b9b7-07f3b29042c9)


### To Reproduce

https://stackblitz.com/edit/github-6gtqqv?file=src%2Fstories%2Fbutton.component.ts

### System

```bash
Storybook Environment Info:

  System:
    OS: Linux 5.0 undefined
    CPU: (8) x64 Intel(R) Core(TM) i9-9880H CPU @ 2.30GHz
    Shell: 1.0 - /bin/jsh
  Binaries:
    Node: 18.18.0 - /usr/local/bin/node
    Yarn: 1.22.19 - /usr/local/bin/yarn
    npm: 10.2.3 - /usr/local/bin/npm <----- active
    pnpm: 8.14.0 - /usr/local/bin/pnpm
```


### Additional context

Workaround: put the description before the `@deprecated` line, it shows up in docs.

```
  /**
   * Is this the principal call to action on the page?
   * @deprecated qwe
   */
  @Input()
  primary = false;
```
Repository: transformers
Issue: AutoModel.from_config() should attempt to load model relative to where the config was loaded.
Labels: Feature request

### System Info


Currently if you do an AutoConfig.from_pretrained() and then use that config to try to AutoModel.from_config() it loses the context from where the config.json was loaded.  This wouldn't be a problem if AutoModel.from_config() also took a path_or_model_id style param but it doesn't.

This becomes problematic mainly for situations where you want to write single code for both training and fine tuning models.  In this workflow, the notion of training and fine tuning is largely the same code so creating the model to then train looks something like this:

```
try:
    model = AutoModel.form_pretrained(..., config=conf, ...)
except OSError, ValueError:
    model = AutoModel.from_config(conf)
```

If you're loading models from file like i am, not being able to easily AutoModel.from_config() with a specified path is problematic.  I would like all of my intermediate training steps to be done locally to potentially unrelated directory structures to the source. 

I think that we have two easy options. 
1. Add a field to the PretrainedConfig which is only populated when it's loaded from file which is the path to the config file the config was loaded from.  We can call it something like _loaded_from_file.  It would have to be removed prior to save()
2. allow AutoModel.from_config() to take a path_or_model_id in addition to the config.  so the call would look something like:

```
model = AutoModel.from_config(conf, path_or_model_id='/path/to/dir/containing/model')
```

cc:
@Rocketknight1 

Trying out recommended workflow of issuing bugs before PRs. 


### Who can help?

_No response_

### Information

- [ ] The official example scripts
- [ ] My own modified scripts

### Tasks

- [ ] An officially supported task in the `examples` folder (such as GLUE/SQuAD, ...)
- [ ] My own task or dataset (give details below)

### Reproduction

1. Load a model config specifying custom code in the AutoMap from a path that is not also valid as `$CWD/model-id/model`
2. try to instantiate a version of your model from AutoModel.from_config() using that config.

### Expected behavior

I'd like to have an instance of the model that's of the same type as the model that'd be returned if from_pretrained() were used.
Repository: PowerToys
Issue: Translation of text or video
Labels: Idea-New PowerToy,Needs-Triage

### Description of the new feature / enhancement

The feature can translate the selected text, or use the translation and add it at the bottom of the video or the bottom of the screen. Add the ability to download a language, and it is preferable if the Arabic language is also added.

### Scenario when this would be used?

The feature can be used to translate words or texts or while watching a movie

### Supporting information

_No response_
Repository: flutter
Issue: Android platform view tests should not depend on retired repository
Labels: P2,c: tech-debt,team-android,triaged-android

See

https://github.com/flutter/flutter/blob/bb856079c40139fc732927c73f1e882d77234dc5/dev/integration_tests/android_views/pubspec.yaml#L19-L23

https://github.com/flutter/flutter/blob/bb856079c40139fc732927c73f1e882d77234dc5/dev/integration_tests/hybrid_android_views/pubspec.yaml#L16-L20

The https://github.com/flutter/goldens repository has been retired and was recently (Feb 9, 2024) archived. We should no longer depend on that. (See https://github.com/flutter/flutter/issues/144033 for some context).

Edit: while debugging https://github.com/flutter/flutter/issues/144033 it was unarchived.
Repository: node
Issue: Refactor the WPT test runner to be a python test runner configuration
Labels: test

While working on the flakes I noticed that there are still some drawbacks with the current WPT test runner (common/wpt.js):

1. To enable running tests in parallel the WPT test runner uses workers, which can be harder to debug especially when the use of inspector is needed to look into the JS land. If we just use the python runner, we get the parallelism for free, and debugging individual tests would be easier. We can use a fixture to set up the main context/harness and let the python runner preload that file before running the tests. To debug the test, just `out/Release/node --inspect-brk -r test/common/wpt-fixture.js test/fixtures/wpt/...` and connect to the inspector server with a client.
3. The use of workers for parallelism also mean that we lack coverage of WPT running on the main thread (I've been bitten by this before when adding lazy loading of Web APIs the main context snapshot). If we use the python test runner to run the WPT directly, we can get coverage on both the main thread and the worker thread (via [the custom test suite in the CI that uses the `--worker` switch](https://ci.nodejs.org/job/node-test-commit-custom-suites-freestyle))
4. The status file for the current WPT runner doesn't allow conditions which is important for marking flakes on a specific platform. To add this to the JS-based WPT runner we need to reinvent the wheel again, and as far as I can tell we might as well just integrate the test runner into the existing python one and get a unified handling for flakes.
Repository: rust
Issue: nightly-only types are confusing in error[E0277]: `?` couldn't convert the error to ...
Labels: A-diagnostics,T-compiler,D-confusing,D-newcomer-roadblock,S-has-mcve

### Code

```Rust
struct BarError;

fn bar() -> Result<(), BarError> {
    Ok(())
}

struct FooError;

fn foo() -> Result<(), FooError> {
    bar()?;

    Ok(())
}

fn main() {
    foo();
}
```


### Current output

```Shell
error[E0277]: `?` couldn't convert the error to `FooError`
  --> src/main.rs:11:10
   |
10 | fn foo() -> Result<(), FooError> {
   |             -------------------- expected `FooError` because of this
11 |     bar()?;
   |     -----^ the trait `From<BarError>` is not implemented for `FooError`
   |     |
   |     this can't be annotated with `?` because it has type `Result<_, BarError>`
   |
   = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
   = help: the following other types implement trait `FromResidual<R>`:
             <Result<T, F> as FromResidual<Yeet<E>>>
             <Result<T, F> as FromResidual<Result<Infallible, E>>>
   = note: required for `Result<(), FooError>` to implement `FromResidual<Result<Infallible, BarError>>`
```


### Desired output

```Shell
I'm not sure.
```


### Rationale and extra context

This is a very common error, and it's likely to be encountered by people new to Rust.

The `note` and `help` text mentions two different types that are nightly-only (`Yeet`, `FromResidual`). To someone who is learning the language or only using the stable compiler, this is both confusing and unhelpful.

I think the stable compiler should avoid mentioning internal or nightly-only types, and when possible, the advice given should be understandable and actionable by someone new to the language.

If the last two messages are only going to talk about nightly only types, and they're not actually helpful to someone using the stable compiler, maybe they should just be removed?

### Other cases

_No response_

### Rust Version

```Shell
rustc 1.76.0 (07dca489a 2024-02-04)
binary: rustc
commit-hash: 07dca489ac2d933c78d3c5158e3f43beefeb02ce
commit-date: 2024-02-04
host: x86_64-unknown-linux-gnu
release: 1.76.0
LLVM version: 17.0.6
```


### Anything else?

I filed this bug after a conversation with @estebank on mastodon. :wave:
Repository: flutter
Issue: GeneratedPluginRegistrant.swift violates Swift style
Labels: tool,platform-mac,a: desktop,P2,team-macos,triaged-macos

Per https://www.swift.org/documentation/api-design-guidelines/#general-conventions

> Names of types and protocols are UpperCamelCase. Everything else is lowerCamelCase.

That means the generated function should be called `registerGeneratedPlugins`, not `RegisterGeneratedPlugins` in Swift.

Fixing this will require a project migrator (and will be a breaking change for anyone doing non-standard things, like add-to-app). It's not a high priority, but it is kind of annoying for anyone running a Swift linter on their project that validates naming (like `swift-format lint`) as it's flagged as a warning.
Repository: pytorch
Issue: [C10D] coalesced collectives are not well tested
Labels: oncall: distributed

coalescing_manager in python exposes very different behavior when device=None (default) vs device is provided.  The device provided case is not tested and i think may be broken.

Also, the method of calling start/end manually and calling regular collectives (from python) is not tested

cc @mrshenli @pritamdamania87 @zhaojuanmao @satgera @rohan-varma @gqchen @aazzolini @osalpekar @jiayisuse @H-Huang @kwen2501 @awgu @penguinwu @fegin @XilunWu @wanchaol @fduwjj @wz337 @tianyu-l @yf225
Repository: godot
Issue: [Network] [MultiplayerSpawner] Reparenting node despawns node but don't spawn to new parent
Labels: bug,topic:core,topic:multiplayer

### Tested versions

v4.2.1.stable.mono.official [b09f793f5]

### System information

Windows 10

### Issue description

Why MultiplayerSpawner doesn't work with node parent changing?

I think there should be some logic, which allows to continue node synchronization after reparenting.


### Steps to reproduce

`
player.Reparent(targetWorld);
`
Emits only despawn event to client.

```
player.GetParent().RemoveChild(player);
targetWorld.AddChild(player);
```
Emits only despawn event to client.

```
player.GetParent().RemoveChild(player); 
player = targetWorld.CreatePlayer();
```
Works well. Emits despawn and spawn events.


### Minimal reproduction project (MRP)

Don't have.
Repository: node
Issue: Expose file resolution as a utility
Labels: feature request,esm,loaders-agenda,loaders

### What is the problem this feature will solve?

Tool authors often need to reimplement Node's resolving behaviors in order to ask the question: if *this* file was to import *this* path, which file would Node resolve that to?

This comes up for build tools like Vite, Esbuild, or Webpack. It also comes up for analysis tools like Eslint and Typescript.

For a long time, people were able to get by with the likes of https://www.npmjs.com/package/resolve. But the introduction of the full suite of package.json `exports` features (conditions, subpath imports, etc) and ESM have resulted in a situation where almost no tool actually covers Node's complete spec correctly anymore. It seems wasteful to try to fix all these parallel implementations rather than share node's implementation as a utility.

### What is the feature you are proposing to solve the problem?

A node-provided, importable constructor that takes [conditions](https://nodejs.org/api/packages.html#resolving-user-conditions):

```ts
import { Resolver } from 'node:resolver';
let r = new Resolver({ 
  conditions: ['default', 'node', 'development' ]
});
```

Where the `Resolver` instance offers a method with the signature:

```ts
resolve(requestedPath: string, requestingFile: string): Promise<string | undefined>;
```

The key features provided here that are not provided (AFAIK) by any existing Node API are:
 - you can programmatically ask what would happen under the given [conditions](https://nodejs.org/api/packages.html#resolving-user-conditions). These are distinct from the global `--conditions` that prevail in the current node process (remember -- we're talking about running this inside a tool like a linter. Regardless of what conditions the linter uses for its own implementation, it should follow imports the way the *user's* program is going to do it, using the *user's* conditions.)
 - you can ask on behalf of another file in another package. Critically, this would need to respect rules like [self-referencing](https://nodejs.org/api/packages.html#self-referencing-a-package-using-its-name). This is in contrast with `require.resolve` which, even if you set `paths` to the inside a package [doesn't respect the self-referencing rule](https://github.com/nodejs/node/issues/47681).

Note that I'm definitely **not** asking for access to the state of the current node process's resolver. I don't want its customized loaders, I don't want to share its cache. Rather, this would be asking to set up an entirely separate state that would not interfere with Node's own module loading at all.

### What alternatives have you considered?

There are lots of third-party implementations, maintained at great effort and all with incomplete support for Node's behaviors.  In theory somebody could invest the effort to make one of them perfect and continually invest in making it follow new node features.
Repository: TypeScript
Issue: Allow instantion expression with empty arguments
Labels: Suggestion,In Discussion

### 🔍 Search Terms

instantiation expression, empty, type arguments

### ✅ Viability Checklist

- [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, new syntax sugar for JS, etc.)
- [X] This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
- [X] This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

### ⭐ Suggestion

I would like to be able to instantiate a generic function type with an empty type arguments list.

It would be nice to allow this for generic types, but it's not as necessary, since a generic type is always instantiated in a type context, even if no type arguments list is given. A generic function type needs to be specifically instantiated.

### 📃 Motivating Example

Here is a generic function where a type parameter has a default.  I can get use an instantiation expression to specialize it to a non-generic function.
```ts
declare function find1<T, S extends T=T>(Ar:T[], predicate:(t:T)=>t is S): S | undefined;
type Find1Object = typeof find1<object>;
```

Here is a generic function with only one type parameter. I cannot use an instantiation expression with the default for `S`:
```ts
declare function find2<S extends object = object>(Ar:object[], predicate:(t:object)=>t is S) : S | undefined;
type Find2 = typeof find2<>; // <- this is a syntax error "Type argument list cannot be empty"
```

### 💻 Use Cases

1. What do you want to use this for?
2. What shortcomings exist with current approaches?
3. What workarounds are you using in the meantime?
   - Declare an unused "dummy" type parameter so there's always a non-defaulted type argument.

Originally mentioned here: https://github.com/microsoft/TypeScript/issues/57463#issuecomment-1957739330
Repository: rust
Issue: Add an API to obtain all reachable items of a crate
Labels: T-compiler,E-help-wanted,C-feature-request

`TyCtxt` currently provides an API to get all exported symbols of a crate. Still, there are some items in external crates that are not necessarily exported but are reachable and there is no direct way to get them. For example, some public generic functions provided by a library are like that.

Although it is possible to find them using methods like `module_children`, I want to request an API in `TyCtxt` that returns all reachable `DefId`s, a superset of `exported_symbols`.
```rust
pub fn reachable_symbols(
    self,
    key: CrateNum
) -> &'tcx [DefId]
```

<!-- TRIAGEBOT_START -->

<!-- TRIAGEBOT_ASSIGN_START -->

<!-- TRIAGEBOT_ASSIGN_DATA_START$${"user":"krishpranav"}$$TRIAGEBOT_ASSIGN_DATA_END -->

<!-- TRIAGEBOT_ASSIGN_END -->
<!-- TRIAGEBOT_END -->
Repository: stable-diffusion-webui
Issue: [Bug]: RuntimeError: CUDA error: an illegal memory access was encountered
Labels: bug-report

### Checklist

- [X] The issue exists after disabling all extensions
- [X] The issue exists on a clean installation of webui
- [ ] The issue is caused by an extension, but I believe it is caused by a bug in the webui
- [X] The issue exists in the current version of the webui
- [X] The issue has not been reported before recently
- [ ] The issue has been reported before but has not been fixed yet

### What happened?

When I use more than 1 bacth count or generate images continuously. I'm getting this error.

### Steps to reproduce the problem

1. start web ui
2. text2img
3. generate imgs
4. get error

### What should have happened?

generate imgs normaly

### What browsers do you use to access the UI ?

Microsoft Edge

### Sysinfo

[sysinfo-2024-02-23-19-20.json](https://github.com/AUTOMATIC1111/stable-diffusion-webui/files/14389272/sysinfo-2024-02-23-19-20.json)


### Console logs

```Shell
RuntimeError: CUDA error: an illegal memory access was encountered
CUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.
For debugging consider passing CUDA_LAUNCH_BLOCKING=1.
Compile with `TORCH_USE_CUDA_DSA` to enable device-side assertions.
```


### Additional information

My GPU are a RTX 4060 8GB
Driver 551.61
Python 3.10.6
args web ui : 
--theme dark
--vae-dir J:/SD_Interfaces/stable-diffusion-webui/models/VAE
--reinstall-xformers 
--xformers 
--ckpt-dir J:/SD_Interfaces/stable-diffusion-webui/models/Stable-diffusion 
--hypernetwork-dir J:/SD_Interfaces/stable-diffusion-webui/models/hypernetworks 
--embeddings-dir J:/SD_Interfaces/stable-diffusion-webui/embeddings 
--lora-dir J:/SD_Interfaces/stable-diffusion-webui/models/Lora
Repository: vscode
Issue: $TM_SELECTED_TEXT returns the last selection in multi-cursor selection
Labels: bug,snippets

<!-- ⚠️⚠️ Do Not Delete This! bug_report_template ⚠️⚠️ -->
<!-- Please read our Rules of Conduct: https://opensource.microsoft.com/codeofconduct/ -->
<!-- 🕮 Read our guide about submitting issues: https://github.com/microsoft/vscode/wiki/Submitting-Bugs-and-Suggestions -->
<!-- 🔎 Search existing issues to avoid creating duplicates. -->
<!-- 🧪 Test using the latest Insiders build to see if your issue has already been fixed: https://code.visualstudio.com/insiders/ -->
<!-- 💡 Instead of creating your report here, use 'Report Issue' from the 'Help' menu in VS Code to pre-fill useful information. -->
<!-- 🔧 Launch with `code --disable-extensions` to check. -->
Does this issue occur when all extensions are disabled?: Yes

<!-- 🪓 If you answered No above, use 'Help: Start Extension Bisect' from Command Palette to try to identify the cause. -->
<!-- 📣 Issues caused by an extension need to be reported directly to the extension publisher. The 'Help > Report Issue' dialog can assist with this. -->
- VS Code Version: 1.86.2
- OS Version: Darwin arm64 23.3.0


![Screen Recording 2024-02-23 at 22 23 44](https://github.com/microsoft/vscode/assets/26697004/71f56ae1-7773-4ac4-8a1e-85aae8670662)

As described [in this issue](https://github.com/yatki/vscode-surround/issues/108), I'm calling `activeEditor.insertSnippet` method to insert a snippet. `insertSnippet` method **is** inserting the snippet for each selection, but it is **not** detecting the related selection's content.


Steps to Reproduce:

1. In an empty editor, create a few lines.
2. Create a cursor at the end of every line with [option] + click
3. Select the lines with [shift] + [left arrow]
4. Run the code below:
```ts
    const snippetStr = "if(${1:condition}) {\n\t$TM_SELECTED_TEXT\n}$0"
    await activeEditor.insertSnippet(new SnippetString(snippetStr));
```

Output: 
- Every line will be wrapped with `if` statement but the $TM_SELECTED_TEXT **only** returns the text of **the last** selected block.

Expected:
- `activeEditor.insertSnippet` method should use the correct selection's content.