sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: next.js
Issue: Dynamic routes ignore segment revalidation settings
Labels: bug

### Verify canary release

- [X] I verified that the issue exists in the latest Next.js canary release

### Provide environment information

```bash
Operating System:
      Platform: darwin
      Arch: arm64
      Version: Darwin Kernel Version 21.6.0: Sat Jun 18 17:05:47 PDT 2022; root:xnu-8020.140.41~1/RELEASE_ARM64_T8101
    Binaries:
      Node: 16.14.0
      npm: 8.5.0
      Yarn: 1.22.19
      pnpm: 6.11.0
    Relevant packages:
      next: 13.2.4-canary.9
      eslint-config-next: N/A
      react: 18.2.0
      react-dom: 18.2.0
```


### Which area(s) of Next.js are affected? (leave empty if unsure)

App directory (appDir: true)

### Link to the code that reproduces this issue

https://stackblitz.com/edit/vercel-next-js-ssxpmi?file=app/pages/[slug]/page.tsx

### To Reproduce

1. Build and start the project that reproduces the issue: https://stackblitz.com/edit/vercel-next-js-ssxpmi?file=app/pages/[slug]/page.tsx
2. Navigate to any of the pages (page1, page2 or page3) via the links on the home page.
3. Refresh the page
4. Observe the log in the terminal saying the page is re-rendered on each page fetch (SSR).

### Describe the Bug

**TL;DR**
Dynamic route segment rendering ignores the segment configuration settings when decides whether the page should be rendered dynamically or statically.

**Details**

Presence of `generateStaticParams` dictates whether the segment is dynamically or statically rendered, which is neither documented nor intuitive.

The segment configuration in the provided repo exports `export const revalidate = false` but the page is still re-rendered on each request.
And the expectation is that the page is generated on a first request and kept forever.

If I define `generateStaticParams()` function that returns empty array, then I get the expected behaviour: nothing is generated at build time and all my routes are generated and cached forever on the first visit.
 





### Expected Behavior

Segment configuration settings should be decoupled.

1. Presence of `generateStaticParams` should only control if there is any build-time pre-generation of dynamic segments should happen. Nothing more than that.

If the function is defined, NextJS should call it to get the list of segments for pre-generation at build time. No more extra logic assigned to it. If the list is empty -> nothing is pre-generated. If the function is not defined -> nothing is pre-generated.

2. What happens when there is visit of a dynamic segment that does not exist should be dictated by the `[dynamicParams](https://beta.nextjs.org/docs/api-reference/segment-config#dynamicparams)`. If it says "true" then the page is generated upon request.

3. What happens to the generated page on subsequent requests is controlled by the cache and revalidation settings or already defined heuristics around use of dynamic functions. (presence or absence of the `generateStaticParams` should not impact this).




### Which browser are you using? (if relevant)

chrome

### How are you deploying your application? (if relevant)

vercel
Repository: neovim
Issue: window-local option indicating it should be implicitly closed
Labels: enhancement,options

### Problem

My usecase is that:
I have an asyncrun like plugin that executes the content of a buffer meanwhile shows the result in a split window, so ideally I want to set the buffer of the result window to buftype=terminal, not `buftype=help` to have correct highlight for the terminal escape sequence string.
And I dont want these buffers block `:quit` when there are two windows in a tabpage: one for the source file, one for the result.

Currently there is no such option for buffers so that nvim can treat a buffer as help when it performans `:quit`.

### Expected behavior

> we would want a settable property of the window indicating it should be implicitly closed if that helps closing a tab/all of vim. This often comes up as an expected behavior of floats, but is something which should be opt-in to by plugins for any kind of window (split/float).

source: https://github.com/neovim/neovim/issues/22063#issuecomment-1410727791
that's what I want too.

### more contexts
I used to open a related issue: https://github.com/neovim/neovim/issues/22063, and I'm currently using a [hack way](https://github.com/haolian9/zongzi/blob/master/nvim/.config/nvim/natives/lua/windmill/engine.lua#L101) to achieve the goal: open the buffer as terminal, when the process exited, set the buffer type to help via `ffi::prepare_help_buffer()`
Repository: godot
Issue: Exported Curve fails to update with Project Running (live scene editing bug)
Labels: bug,topic:editor

### Godot version

v4.0.stable.official [92bee43ad]

### System information

Windows 10 64-bit operating Intel(R) Core(TM) i7-6700K CPU @ 4.00GHz   4.01 GHz, Installed RAM	32.0 GB (31.9 GB usable)system, x64-based  Vulkan API 1.3.205 - Forward Mobile - Using Vulkan Device #0: NVIDIA - NVIDIA GeForce GTX 980 Ti

### Issue description

Adjusting an exported Curve with the project running produces the following error:

E 0:00:22:0443   parse_message: Condition "p_args.size() < 10" is true. Returning: ERR_INVALID_DATA
  <C++ Source>   scene/debugger/scene_debugger.cpp:174 @ parse_message()

https://github.com/godotengine/godot/blob/92bee43adba8d2401ef40e2480e53087bcb1eaf1/scene/debugger/scene_debugger.cpp#L174

The console output indicates the curve is not changing, and this is my experience with my game.

This type of feature seems to really need real-time behavior, and appeared to have it in 3.5 per this video: https://www.youtube.com/watch?v=gHT3jsCEiyA&t=241s

I am an extreme novice to GODOT programming. If I am misunderstanding the documentation here, then perhaps it needs to be updated:
https://docs.godotengine.org/en/latest/classes/class_curve.html

### Steps to reproduce

1. Launch MRP (attached below)
2. Run Project
3. Adjust Curve

Note a Debug error occurs and the Console Output fails to change

### Minimal reproduction project

[CurvesFail.zip](https://github.com/godotengine/godot/files/10937878/CurvesFail.zip)
Repository: rust
Issue: rustc sometimes constant-folds math method calls but still emits a call anyway
Labels: A-LLVM,I-slow,A-codegen,T-compiler,C-bug

In <https://users.rust-lang.org/t/math-result-varies-in-debug-vs-release-builds/90612>, jonh discovered that this code 
([Godbolt](https://godbolt.org/z/ddnrPGsrz), [playground](https://play.rust-lang.org/?version=nightly&mode=release&edition=2021&gist=f0dabcb9596b56a48463648c722480cd))

```rust
pub fn t() -> f32 {
    0.7f32.tanh()
}
```

produces this, when compiled on Linux with `opt-level` 1 or greater:

```
.LCPI0_0:
        .long   0x3f333333
.LCPI0_1:
        .long   0x3f1ab7d9
example::t:
        push    rax
        movss   xmm0, dword ptr [rip + .LCPI0_0]
        call    qword ptr [rip + tanhf@GOTPCREL]
        movss   xmm0, dword ptr [rip + .LCPI0_1]
        pop     rax
        ret
```

I was surprised to see that **the asm output contains a precomputed answer, but it calls `tanhf` anyway,** ignoring the return value.

The corresponding code for `0.7f32.exp()` simply loads the precomputed answer and returns. No call to `expf` is emitted. That makes more sense.

Nightly emits the same code.
Repository: PowerToys
Issue: Modify the system Fonts settings, change the fonts style what i want
Labels: Needs-Triage

### Description of the new feature / enhancement

Modify the system Fonts settings, change the fonts style what i want

### Scenario when this would be used?

All

### Supporting information

_No response_
Repository: material-ui
Issue: [Fab] Add Shadow Color Prop
Labels: component: Fab,enhancement

### Duplicates

- [X] I have searched the existing issues

### Latest version

- [X] I have tested the latest version

### Summary 💡

Without monkeying with the theming or without overwriting the entire themed shadow, there isn't a direct way to modify the Fab component shadow. Implementing a shadowColor prop would be a beneficial API choice which would be useful with Dark Mode themes or other scenarios where there is a dark background to enable the "floating" effect.

### Examples 🌈

_No response_

### Motivation 🔦

Enhance design against dark backgrounds. Enable a consistent "floating" effect against dark backgrounds, even or especially in the case that the dark background exists isolated from a theme.

Beyond my use, exposing this as a prop could better enable other creative uses of the full color palette for Fab shadows.
Repository: rust
Issue: Tracking Issue for decoupling from github actions environment variables in bootstrap
Labels: T-bootstrap,C-tracking-issue

This is a tracking issue for the decoupling from github actions environment variables in bootstrap.

### 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.

### Steps

- [ ] Implement the decoupling (cc @rust-lang/bootstrap -- can anyone write up mentoring
      instructions?)

### The problem

See #108959, https://github.com/rust-lang/rust/pull/102428#issuecomment-1264496065 and https://github.com/rust-lang/rust/pull/102428#issuecomment-1264526170 for informations and what to do.

### Unresolved Questions

- [ ] None at this time

### Implementation history

- A first try in #102428, but got inactive
Repository: stable-diffusion-webui
Issue: [Feature Request]: Save interstitial image during generation
Labels: enhancement

### Is there an existing issue for this?

- [X] I have searched the existing issues and checked the recent builds/commits

### What would your feature do ?

Oftentimes the 'developing' images are better than the final image, or at least are more suitable fodder for further development than the final image. It would be great in there was a Save button that could save the currently-visualized image to the default generation folder.

### Proposed workflow

1. You start generating the image, either txt2img or Img2Img, whatever
2. Visualizations roll by as the noise evolves
3. You see a really great mid-development image you'd like to save (i.e., without saving the entire roll of interstitial images)
4. You press the dedicated Save button that appears during the corner of the results window during generation.

### Additional information

_No response_
Repository: godot
Issue: Asset library not loading
Labels: bug,topic:editor

### Godot version

v4.0.stable.official [92bee43ad]

### System information

macOS Ventura 13.2.1

### Issue description

The Asset Library fails to load when accessed via the "Please Confirm..." dialog that pops up on the first launch of Godot.

https://user-images.githubusercontent.com/41659980/224256230-8beb3cbc-7b39-4362-98f2-385b996a83c8.mov

Nonetheless, the Asset Library loads successfully if you cancel the dialog and navigate to the "Asset Library Projects" tab.

https://user-images.githubusercontent.com/41659980/224257041-6d40820d-8e17-459d-9fa2-9bb61ccec4b5.mov

### Steps to reproduce

1. Open up Godot for the first time.
2. A dialog titled "Please Confirm..." will appear. Click the "Open Asset Library" button on that dialog.

### Minimal reproduction project

"N/A"
Repository: rust
Issue: Always inline functions don't have correct source line information under the VS debugger
Labels: A-debuginfo,T-compiler,O-windows-msvc,C-bug

I tried this code:

```rust
#[inline]
fn f() {
    println!("f");
}
#[inline(always)]
fn g() {
    println!("g");
}

fn main() {
    f();
    g();
}
```

I expected to see this happen: being able to debug `g` under Visual Studio.

Instead, this happened: the source line information for `g` is attributed to the `g` call in main, not to the lines in `g`.

### Meta
<!--
If you're using the stable version of the compiler, you should also check if the
bug also exists in the beta or nightly versions.
-->

`rustc --version --verbose`:
```
rustc 1.68.0 (2c8cc3432 2023-03-06)
binary: rustc
commit-hash: 2c8cc343237b8f7d5a3c3703e3a87f2eb2c54a74
commit-date: 2023-03-06
host: x86_64-pc-windows-msvc
release: 1.68.0
LLVM version: 15.0.6
```

![image](https://user-images.githubusercontent.com/16454588/224264851-090850f1-a115-4325-a12e-dc5b15abc4ce.png)

This also means that it loses the debug info for variables, making the function not debuggable at all.

Update: It also doesn't work if I set `-Zinline-mir=no` under nightly.
Repository: godot
Issue: Unable to Exporting Typed Arrays of Inner Classes
Labels: bug,topic:editor

### Godot version

4.0.stable

### System information

Kubuntu 22.10, GLES 3, Intel HD Graphics 2000

### Issue description

When trying to export typed arrays of a inner class, the type declaration in the resource file becomes `Array[Object]`.

### Steps to reproduce

```
# res://test.gd
class_name test
extends Resource

class example_class:
	extends Resource

@export var example_array: Array[example_class] = [example_class.new()]
```

Create a new "test.gd" resource in the editor and add an empty example_class to the example_array.
Save the resource file to a file with a `.tres` extension.
Open the file and you can see `example_array = Array[Object]([null])`.

### Minimal reproduction project

N/A
Repository: angular
Issue: Improve DomSanitizer API with a method that returns a SafeValue. 
Labels: area: core,core: sanitization

### Which @angular/* package(s) are relevant/related to the feature request?

@angular/core
@angular/platform-browser

### Description

Currently, in the source as well as the [Docs](https://angular.io/api/platform-browser/DomSanitizer), the DomSanitizer class contains:
- bypassSecurityTrust* methods used to bypass sanitization checks which return a SafeValue subtype.
- a single 'sanitize' method which can receive a SafeValue and will unwrap it into a simple string. (I believe also this method was originally intended to only be used by the framework internally and was made public later)

The problem with this approach, is that consumers have no clear way of opting into the sanitization, and receiving a safe type back.
The only way to achieve this is to call both methods. The documentation does not exemplify concretely how and *if* these methods should be used together. Feel free to correct me if this approach is not the one considered best practice.
```
const sanitizedUrl: string = this.domSanitizer.sanitize(SecurityContext.URL, url)
const safeUrl: SafeUrl = this.domSanitizer.bypassSecurityTrustUrl(sanitizedUrl)
```

In practice this proves to be quite unintuitive, as the sanitize method can receives as a parameter a SafeValue, which can only be obtained by calling a bypassSecurityTrust* method, leading users to believe perhaps they need to call a bypass method first, or that they shouldn't call the sanitize method at all.

### Proposed solution

Create a new method, that performs the same sanitization logic as in the currently existing 'sanitize' method, whilst returning the corresponding SafeValue subtype and instruct users to use this one by default, and to only use the bypassSecurityTrust* method when providing their own sanitization or method to verify the source of the value.

See PR for this here: **PR LINK TO BE ADDED LATER**

### Alternatives considered

An alternative would be to update the documentation with a better sample showing how to use the 'sanitize' and 'bypassSecurityTrust*' methods together, and recommend this approach as the go-to when facing typing issues due to sanitization.
Repository: rust
Issue: Tracking Issue for `fs_native_path`
Labels: T-libs-api,C-tracking-issue

Feature gate: `#![feature(fs_native_path)]`

This is a tracking issue for a new `NativePath` type that allows users to pass paths more directly to system APIs. This will enable third party crates to implement and experiment with their own path types without having to go through `std::path::Path` encoding.

### Public API

```rust
// std::path
pub struct NativePath(_)
pub trait AsPath: Sealed { }

impl<P: AsRef<Path>> AsPath for P { }
impl AsPath for &NativePath { }

// std::os::unix::ffi
pub trait NativePathExt: Sealed {
    fn from_cstr(cstr: &CStr) -> &NativePath;
    fn into_cstr(&self) -> &CStr;
}

// std::os::windows::ffi
// This currently uses a bare `u16` slice but in the future this could perhaps be a `WStr`.
pub trait NativePathExt: Sealed {
    fn from_wide(wide: &[u16]) -> &NativePath;
    unsafe fn from_wide_unchecked(wide: &[u16]) -> &NativePath;
    fn into_wide(&self) -> &[u16];
}

// This also changed the public signature of fs functions.
// Before:
pub fn create_dir<P: AsRef<Path>>(path: P) -> Result<()>
// After:
pub fn create_dir<P: AsPath>(path: P) -> Result<()>
```

### Steps / History

<!--
For larger features, more steps might be involved.
If the feature is changed later, please add those PRs here as well.
-->

- [ ] Implementation: #108981
- [ ] Final comment period (FCP)[^1]
- [ ] Stabilization PR

<!--
Once the feature has gone through a few release cycles and there are no
unresolved questions left, the feature might be ready for stabilization.

If this feature didn't go through the RFC process, a final comment period
(FCP) is always needed before stabilization. This works as follows:

A library API team member can kick off the stabilization process, at which point
the rfcbot will ask all the team members to verify they agree with
stabilization. Once enough members agree and there are no concerns, the final
comment period begins: this issue will be marked as such and will be listed
in the next This Week in Rust newsletter. If no blocking concerns are raised in
that period of 10 days, a stabilzation PR can be opened by anyone.
-->

### Unresolved Questions

- The possibility of a Windows equivalent for `CStr`.

[^1]: https://std-dev-guide.rust-lang.org/feature-lifecycle/stabilization.html
Repository: tauri
Issue: [bug] Update bundling/signing of large bundles doesn't work
Labels: type: bug,status: needs triage

### Describe the bug

(This is at least on Windows with MSI, potentially other platforms/bundles too looking at it)

If the update package is larger than 4GB, Tauri bundler fails to bundle/sign it due to the package being too large to function with standard zip.

This seems to arise [here](https://github.com/tauri-apps/tauri/blob/e513b69d98415d1df33ce78368cd3450979d4c8d/tooling/bundler/src/bundle/updater_bundle.rs#L241-L243) where the ZipWriter FileOptions are set, but there's no inclusion of the [large file marker](https://docs.rs/zip/latest/zip/write/struct.FileOptions.html#method.large_file) and there's no way to manually set this.

Ideally the bundler should either (a) try to use zip64 where needed for larger files (presumably both here and on the update unpacking side) or (b) provide a mechanism to set this option explicitly.

### Reproduction

_No response_

### Expected behavior

_No response_

### Platform and versions

```text
Environment
  › OS: Windows 10.0.22621 X64
  › Webview2: 110.0.1587.63
  › MSVC:
      - Visual Studio Build Tools 2022
  › Node.js: 16.17.1
  › npm: 8.19.2
  › pnpm: Not installed!
  › yarn: 3.4.0
  › rustup: 1.25.1
  › rustc: 1.66.1
  › cargo: 1.66.1
  › Rust toolchain: stable-x86_64-pc-windows-msvc

Packages
WARNING: no lock files found, defaulting to npm
  › @tauri-apps/cli [NPM]: 1.2.2 (outdated, latest: 1.2.3)
  › @tauri-apps/api [NPM]: 1.2.0
  › tauri [RUST]: 1.2.3,
  › tauri-build [RUST]: 1.2.1,
  › tao [RUST]: 0.15.8,
  › wry [RUST]: 0.23.4,

App
  › framework: React (Next.js)
  › bundler: Webpack
```


### Stack trace

_No response_

### Additional context

_No response_
Repository: angular
Issue: Wrong typings in AbstractControl.getRawValue()
Labels: area: forms,forms: strictly typed

### Which @angular/* package(s) are the source of the bug?

forms

### Is this a regression?

No

### Description

In the AbstractControl class definition, you have generics
`AbstractControl<TValue = any, TRawValue extends TValue = TValue>`
(https://github.com/angular/angular/blob/15.2.x/packages/forms/src/model/abstract_model.ts#L346)

But in getRawValue method you return **any**
`getRawValue(): any`
(https://github.com/angular/angular/blob/15.2.x/packages/forms/src/model/abstract_model.ts#L1025)

I think here should be **TRawValue** instead of **any**


I can't use generics in the async validators without type casting

```typescript
@Injectable({ providedIn: 'root' })
export class UniqueAlterEgoValidator implements AsyncValidator {
  constructor(private heroesService: HeroesService) {}

  validate(
    control: AbstractControl<string>
  ): Observable<ValidationErrors | null> {
    const value = control.getRawValue(); // any instead of string
    return this.heroesService.isAlterEgoTaken(value).pipe(
      map(isTaken => (isTaken ? { uniqueAlterEgo: true } : null)),
      catchError(() => of(null))
    );
  }
}
```

### Please provide a link to a minimal reproduction of the bug

_No response_

### Please provide the exception or error you saw

_No response_

### Please provide the environment you discovered this bug in (run `ng version`)

_No response_

### Anything else?

_No response_