sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: flutter
Issue: Incorrect flutter tools output for profile mode web apps
Labels: tool,platform-web,team-tool

DevTools is not available for profile mode web apps, but "Open Flutter DevTools" is still available in the help menu. We should remove this option for profile mode web apps.

It would be nice if the flutter tools output gave an instruction for how to profile this type of app. Something that instructs the user to user their browsers profiler tools (likely chrome devtools) for any debugging and profiling of the app running in this mode.

```
flutter run -d chrome --profile
...
Launching lib/main.dart on Chrome in profile mode...
Compiling lib/main.dart for the Web...                             82.2s
✓ Built build/web

🔥  To hot restart changes while running, press "r" or "R".
For a more detailed help message, press "h". To quit, press "q".
> h

v Open Flutter DevTools.
```
Repository: go
Issue: x/tools/gopls/internal/analysis: add "modernizer" analyzers
Labels: FeatureRequest,gopls,Tools,Analysis,gopls/analysis,Refactoring

Between generics, iterators, min and max, new standard packages such as `slices`, `maps`, and `cmp`, there are a large number of new ways to write Go code more concisely and no less clearly. We should develop "modernizer" analyzer(s) that identify such opportunities and offer suggested fixes.

Many of these are already implemented in `staticcheck` (see [S1000](https://staticcheck.dev/docs/checks/) et seq); we would just need to enable them.

When the appropriate fix is to inline a call to a deprecated function whose body illustrates the recommended approach (e.g. a call to a more modern function, as in the case of the functions in the golang.org/x/exp/maps package), these will be handled by annotating the deprecated function as prescribed by proposal #32816, and letting the [inliner](https://go.dev/cl/634919) take care of it.

Examples:

- [x] b.N → b.Loop in Benchmarks (https://go.dev/cl/638337)
-  [x] interface{} → any (CL 636276)
 - [ ] explicit loops → slices.{Equal,Compare,Index,Contains}{,Func}. The challenge is treating the `return false` and `return true` steps in the slices package as wildcards that match "equal and opposite" actions--not just return statements--in the user code.
 - [x] explicit loops → maps.{Clone,Collect.Insert,Copy} (https://go.dev/cl/638875)
 - ~maps.Keys(m) + slices.Collect (or loop equivalent of Keys+Collect) + sort -> `slices.Sorted(maps.Keys(m))`. Eliminate temporaries when used once in `range _`. Downside: de-optimizes preallocation of correct array size; perhaps best left until resolution of #68598.~
 - [ ] various append + s[::] combinations -> slices.Grow, Clip, Concat & Clone (https://go.dev/cl/637735), etc.
 - [x] `append(s[:i], s[i+k:]...)` -> `slices.Delete(s, i, i+k)`, where k is a non-negative constant
 - [x] exp/{slices,maps} -> std {slices,maps} (see CL 635680 + issue #32816)
 - [x] [exp/maps.Clear](https://github.com/golang/go/issues/70717) → clear etc (https://go.dev/cl/635680)
 - [x] if/else → min/max ([CL 635777](https://go.dev/cl/635777))
 - ~awkward logic in slice.Sort's less function → `if cmp := cmp.Compare(x, y); cmp != 0 { return cmp < 0 }`~
 - [x] sort.Slice -> slices.Sort, avoiding the less func when it is the natural order (https://go.dev/cl/635681)
 - ~sort.Slice -> slices.SortFunc, eliminating the indices~
-  [x] json:omitempty → json:omitzero for basic types
 - ~SetFinalizer → AddCleanup~
 - ~use strings.Lines instead of strings.Split("\n") (but: "\r"?!) or text.scanner(strings.NewReader)/Scan/Text~
 - [x] `[]byte(fmt.Sprintf...)` → `fmt.Appendf(nil, ...)` (https://go.dev/cl/638436)
 - ~implementing {Text,Binary}Appender for types that currently implement {Text,Binary}Marshaler~
 - [x] replacing `ctx, cancel := context.WithCancel(context.Background()); defer cancel()` in tests with `ctx := t.Context()`.

They should of course respect the effective version of Go determined by go.mod and build tags.

@aclements
Repository: react
Issue: [React 19] [SUGGESTION]  Consistency: Rename useFormStatus().pending to useFormStatus().isPending
Labels: React 19

This isn’t a bug report or a question, apologies if this isn’t the right place to post.

Throughout the documentation, conventions like adding prefixes to booleans (e.g., isPending for startTransition, useActionState, etc.) are consistently followed.

To keep things consistent, could useFormStatus().pending be renamed to useFormStatus().isPending?

To prevent a breaking change, you could deprecate pending and introduce isPending as an alternative.
Repository: go
Issue: x/build: set a maintenance window for the kubernetes instance
Labels: Builders,NeedsFix

The Kubernetes instance we have on GKE should have a maintenance window set. The Go 1.24 RC1 release was interrupted by a Kubernetes upgrade. We should decide when an optimal window is and set it.

@golang/release
Repository: ui
Issue: [bug]: 'SidebarContext' is already defined  @typescript-eslint/no-redeclare
Labels: bug

### Describe the bug

great work with the sidebar component. it works very well!

when i cleanup my project and reduce all warnings, i found that the sidebar component contains one.
of course i can eslint ignore the line, but i think its worth revisiting to avoid that others need to do this as well:

https://github.com/shadcn-ui/ui/blob/704991247c748ea0ecf37f946482b9fdb04d4acd/apps/www/registry/default/ui/sidebar.tsx#L29
https://github.com/shadcn-ui/ui/blob/704991247c748ea0ecf37f946482b9fdb04d4acd/apps/www/registry/default/ui/sidebar.tsx#L39

### Affected component/components

Sidebar

### How to reproduce

1. cra typescript  (yarn create react-app my-app --template typescript)
2. run lint -> no warnings (./node_modules/.bin/eslint .)
3. manual install shadcn (components.json from docs)
4. add sidebar npx shadcn@latest add sidebar
5. run lint
   expect: no warnings (./node_modules/.bin/eslint .)
   actual: 
```
shadcn-app/@/components/ui/sidebar.tsx
  37:7  warning  'SidebarContext' is already defined  @typescript-eslint/no-redeclare

✖ 1 problem (0 errors, 1 warning)
```

### Codesandbox/StackBlitz link

_No response_

### Logs

_No response_

### System Info

```bash
node 20/alpine, not really relevant
```


### Before submitting

- [X] I've made research efforts and searched the documentation
- [X] I've searched for existing issues
Repository: ollama
Issue: Add support for setting models to private on `ollama push`
Labels: feature request

Currently, while it's possible to create private repositories through the ollama.com web interface, there's no way to initialize a new private repository directly through the ollama push CLI command. This creates friction in automated workflows and requires context switching between CLI and web interface when working with private models.

# Proposed Solution

Extend the ollama push command to support creating private repositories on initialization. This would allow users to create and push to private repos in a single command.

Example usage:
```bash
ollama push username/my-model:latest --private
```

# Justification

Enables fully automated workflows for private model management
Maintains consistency with other CLI tools (like GitHub CLI) that support private repo creation
Reduces context switching between CLI and web interface
Important for organizations that want to automate private model deployment pipelines

# Alternative Solutions

1. Status Quo: Continue requiring web interface for private repo creation
Pro: Simpler CLI interface
Con: Breaks automation workflows

2. A user-level setting on ollama.com that can set new repos to automatically be private for the user.
Repository: rust
Issue: The combination of alloc_error_handler and target_features_11 is unsound
Labels: T-compiler,I-unsound,C-bug,requires-nightly,F-target_feature_11

The following code compiles:


```
#![feature(target_feature_11, alloc_error_handler)]

#[target_feature(enable = "avx")]
#[alloc_error_handler]
fn f(_: std::alloc::Layout) -> ! {
    panic!()
}
```

However, this is unsound if the allocation error handler is invoked on a machine that does not support `avx`.

The alloc_error_handler feature is still unstable, tracking issue: https://github.com/rust-lang/rust/issues/51540

This issue emerged during the stabilization PR for target_features_11: https://github.com/rust-lang/rust/pull/134090
Repository: go
Issue: runtime: panic in runtime.mapiterinit (loong64)
Labels: help wanted,NeedsInvestigation,Tools,arch-loong64,compiler/runtime

```
#!watchflakes
default <- pkg == "golang.org/x/tools/gopls/internal/test/integration/misc" && test == "TestIssue38815/default"
```

Issue created automatically to collect these failures.

Example ([log](https://ci.chromium.org/b/8728815051462899121)):

    === RUN   TestIssue38815/default
    panic: runtime error: invalid memory address or nil pointer dereference
    	panic: invalid handle
    [signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x12007eee8]
    
    goroutine 45720 [running]:
    golang.org/x/tools/gopls/internal/cache.assert(...)
    	/home/swarming/.swarming/w/ir/x/w/targetrepo40136824/gopls/internal/cache/debug.go:10
    golang.org/x/tools/gopls/internal/cache.(*packageHandleBuilder).evaluatePackageHandle.func1()
    	/home/swarming/.swarming/w/ir/x/w/targetrepo40136824/gopls/internal/cache/check.go:1074 +0x2e8
    panic({0x120bd6e40?, 0x12170d4a0?})
    	/home/swarming/.swarming/w/ir/x/w/goroot/src/runtime/panic.go:785 +0x13c
    golang.org/x/tools/gopls/internal/cache/typerefs.(*PackageSet).Union(...)
    	/home/swarming/.swarming/w/ir/x/w/targetrepo40136824/gopls/internal/cache/typerefs/packageset.go:111
    golang.org/x/tools/gopls/internal/cache.(*packageHandleBuilder).evaluatePackageHandle(0xc00c63cb00, {0x121038b40, 0xc006aa0960}, 0xc00cdefe00)
    	/home/swarming/.swarming/w/ir/x/w/targetrepo40136824/gopls/internal/cache/check.go:1199 +0xcbc
    golang.org/x/tools/gopls/internal/cache.(*Snapshot).getPackageHandles.func2.1()
    	/home/swarming/.swarming/w/ir/x/w/targetrepo40136824/gopls/internal/cache/check.go:896 +0xc8
    golang.org/x/sync/errgroup.(*Group).Go.func1()
    	/home/swarming/.swarming/w/ir/x/w/gopath/pkg/mod/golang.org/x/sync@v0.10.0/errgroup/errgroup.go:78 +0x64
    created by golang.org/x/sync/errgroup.(*Group).Go in goroutine 45718
    	/home/swarming/.swarming/w/ir/x/w/gopath/pkg/mod/golang.org/x/sync@v0.10.0/errgroup/errgroup.go:75 +0xb4


— [watchflakes](https://go.dev/wiki/Watchflakes)
Repository: angular
Issue: Incorrect parsing of complex selectors inside `:host-context`
Labels: area: compiler,compiler: styles

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

compiler

### Is this a regression?

No

### Description

Basically the expectation is:
```
    expect(shim(':host-context(:where(.foo:not(.bar))) {}', 'contenta', 'hosta')).toEqualCss(
      ':where(.foo:not(.bar))[hosta], :where(.foo:not(.bar)) [hosta] {}',
    );
```

But it returns `([hosta]:where(.foo:not(.bar))) {}`. It looks like the regular expression which is used here doesn't parse nested selectors with parenthesis (i.e. `:not()` within ':where()`) correctly.

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

Run the tests with `yarn test packages/compiler/test:test`, adding the test case above to the list.

### Please provide the exception or error you saw

```true

```

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

```true
Reproducible among different versions.
```

### Anything else?

I tried it with and without recent changes to the compiler, that changed the way `:where` and `:host-context` are being parsed, the result is identical between the versions.
Repository: godot
Issue: TileMap Pixel Snapping Precision - Black Lines
Labels: bug,topic:2d

### Tested versions

4.3
4.4-dev6

### System information

Windows 11 - Godot 4.3

### Issue description

TileMap pixel snapping loses precision the further away from the origin you get. Near (0,0) coordinates the TileMap behaves perfectly, for the sake of exaggerating the effect, I've attached a minimal project at ~20,000 tiles from the origin in both x, y direction and the black lines become far more frequent both horizontally and vertically.

In my personal project the issue occurs at ~1,000 tiles from origin (I'm guessing due to the amount of layers/other sprites?, not sure).

The issue is still present even with pixel snapping enabled.

Pictures: Make sure you open at full resolution

![Image](https://github.com/user-attachments/assets/352b5bdb-b23b-45ce-81e4-3fd1d996a1d4)
![Image](https://github.com/user-attachments/assets/88f34439-150e-4f03-bf56-9c8b4d7b4063)
![Image](https://github.com/user-attachments/assets/df925760-c465-49e3-9fbf-7962d2460585)

[![Video](https://www.youtube.com/watch?v=H72fgI7LFZY)](https://www.youtube.com/watch?v=H72fgI7LFZY)

### Steps to reproduce

Make a TileMap
Make a Camera2D
Draw some tiles ~20,000 tiles away from the origin
Set camera position to those tiles
Add some WASD/Arrow key movement and camera zoom functions
Start project and move around and test different zoom functions

### Minimal reproduction project (MRP)

[tilemap.zip](https://github.com/user-attachments/files/18118781/tilemap.zip)
Repository: pytorch
Issue: is it desirable to assume complex expressions in torch._check to be true
Labels: oncall: pt2,module: dynamic shapes,oncall: export

### 🚀 The feature, motivation and pitch

For the following code,
```python
import torch
torch._dynamo.config.capture_scalar_outputs = True
def f(x):
    c = x.item()
    return torch.ones(c*2)

out = torch.compile(f, fullgraph=True)(torch.tensor(3, dtype=torch.int64))
```

I'm getting an data dependent error: 
```
GuardOnDataDependentSymNode: Could not guard on data-dependent expression Eq(2*u0, 0) (unhinted: Eq(2*u0, 0)).  (Size-like symbols: none)
```

So ideally I could just add a torch._check to unblock myself:
```python
import torch
torch._dynamo.config.capture_scalar_outputs = True
class Mod(torch.nn.Module):
    def forward(self, x):
        c = x.item()
        torch._check(c > 0)
        #  torch._check(c*2 > 0) also doesn't work.
        return torch.ones(c*2)

out = torch.compile(Mod(), fullgraph=True)(torch.tensor(3, dtype=torch.int64))
```
The above doesn't work due to `Could not guard on data-dependent expression Eq(2*u0, 0)`.
Then I try:
```python
import torch
torch._dynamo.config.capture_scalar_outputs = True
def f(x):
    c = x.item()
    torch._check(not (c*2 == 0))
    return torch.ones(c*2)

out = torch.compile(f, fullgraph=True)(torch.tensor(3, dtype=torch.int64))
```
But the error is still there. After talking to @pianpwk, it seems that it's difficult to reason the range of`not equal` operator and more complicated  ones like %, etc.

So I'm wondering if it's desirable that we can assume the information we get from users e.g. via torch._check is correct. This would be mostly useful in draft mode export i think, where correctness doesn't matter that much.

### Alternatives

_No response_

### Additional context

_No response_

cc @chauhang @penguinwu @ezyang @bobrenjc93 @avikchaudhuri @gmagogsfm @zhxchen17 @tugsbayasgalan @angelayi @suo @pianpwk
Repository: rust
Issue: Trivial bounds with associated types regression
Labels: A-trait-system,P-low,regression-from-stable-to-stable,C-bug,T-types,fixed-by-next-solver

### Code

I tried writing some macro code that in some cases generates code similar to:

```rust
pub trait A {
    type X;
}

pub trait B: A<X = Self::Y> {
    type Y: C;
}

impl<L> A for L {
    type X = L;
}

pub trait C {}

impl C for () {}

impl<T> B for T 
where
    T: A,
    T::X: C,
{
    type Y = T::X;
}

fn demo() where for<'a> (): B {}
```

I expected to see this happen: The code should compile without error.

Instead, this happened: The following compile error happens.

```rust
error[E0284]: type annotations needed
  --> <source>:25:1
   |
25 | fn demo() where for<'a> (): B {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type
   |
   = note: cannot satisfy `<() as B>::Y == _`

error[E0284]: type annotations needed
  --> <source>:25:29
   |
25 | fn demo() where for<'a> (): B {}
   |                             ^ cannot infer type
   |
   = note: cannot satisfy `<() as B>::Y == _`
```

Discussing with @compiler-errors some it would appear https://github.com/rust-lang/rust/pull/122791 is the cause of the change. The above code does compile if it isn't a trivial bound. For example when you do this instead:
```rust
fn demo<T>() where T: B {}

fn other() {
    demo::<()>();
}
```

For more context on 1.78.0 and before if you remove the `for<'a>` you get the following.
```rust
error[E0271]: type mismatch resolving `<() as A>::X == <() as B>::Y`
  --> <source>:25:17
   |
25 | fn demo() where (): B {}
   |                 ^^^^^ type mismatch resolving `<() as A>::X == <() as B>::Y`
   |
note: expected this to be `()`
  --> <source>:10:14
   |
10 |     type X = L;
   |              ^
   = note:    expected unit type `()`
           found associated type `<() as B>::Y`
   = help: consider constraining the associated type `<() as B>::Y` to `()`
   = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
   = help: see issue #48214
```

### Version it worked on

It most recently worked on: 1.78.0

### Version with regression

All versions including 1.79.0 and after. Specifically starting with nightly-2024-04-04 (found with a bisection).

@rustbot modify labels: +regression-from-stable-to-stable -regression-untriaged
Repository: PowerToys
Issue: Keep Awake - option for 'until another program is not busy'
Labels: Idea-Enhancement,Needs-Triage,Needs-Team-Response,Product-Awake

### Description of the new feature / enhancement

I would like to be able to select another option on the Keep Awake tray icon context menu for 'keep awake until program finishes'

Then, I choose the process from a list or maybe just select an active window on the screen like a terminal window.

Once the selected program exits or its cpu utilization drops near zero for a consistent amount of time then the pc can go to sleep as normal.


### Scenario when this would be used?

My most common reason for using Keep Awake is I need my pc to stay awake while some process like a large file copy operation is in progress or a media transcoding process. Currently I will chose 'indefinitely' however then my computer will just be left on, sometimes for day or so. Or I go for the max of 2 hours and the pc sleeps before the long running operation finishes.

### Supporting information

_No response_
Repository: kubernetes
Issue: store more event in watch cache when apiserver restart to avoid watch request trigger relist
Labels: sig/api-machinery,kind/feature,triage/accepted

### What would you like to be added?

Due to the existence of the bookmark mechanism, the difference between the resource version that the client carries when rewatching and the resource version that the apiserver gets from the list in etcd when it starts up is not too big.

It would be nice to be able to cache more events in the watch cache instead of starting from the list resource version returned by etcd to start the cache. The result would be that a client rewatch would not trigger a “too old resource version”.


### Why is this needed?

In a stable k8s cluster, when the apiserver of a node is restarted, the clients that list-watched the apiserver before will trigger a relist operation when they re-watch it, and the relist will cause a big burden to the apiserver.
Repository: react
Issue: Bug: Replace md5 with sha256 in createFastHash().
Labels: Status: Unconfirmed

1.MD5 has potential collision risks.
2.Even for speed considerations, MD5 is slower than SHA256, so replacing MD5 with SHA256 is worthwhile.
code at:https://github.com/facebook/react/blob/e06c72fcf4632ad3117add713a25f6354631f037/packages/react-server/src/ReactServerStreamConfigNode.js#L234-L238
Below are the speed test results(:
#### String Length: 16
MD5 Average Time: 0.0148 ms
SHA256 Average Time: 0.0131 ms

#### String Length: 256
MD5 Average Time: 0.0193 ms
SHA256 Average Time: 0.0175 ms

#### String Length: 10000
MD5 Average Time: 0.5830 ms
SHA256 Average Time: 0.4030 ms

#### String Length: 100000
MD5 Average Time: 6.2866 ms
SHA256 Average Time: 4.6130 ms

code is
```
<!DOCTYPE html>
<html>
<head>
    <title>Hash Function Test</title>
    <!-- Include the CryptoJS library -->
    <script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.1.1/crypto-js.min.js"></script>
</head>
<body>
    <h1>Hash Function Performance Test</h1>
    <div id="results"></div>

    <script>
        const md5 = (str) => CryptoJS.MD5(str).toString();
        const sha256 = (str) => CryptoJS.SHA256(str).toString();

        // Generate a random string of specified length
        function getRandomString(length) {
            let result = '';
            const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
            for (let i = 0; i < length; i++) {
                result += characters.charAt(Math.floor(Math.random() * characters.length));
            }
            return result;
        }

        // Test the performance of the hash function
        function testHashFunction(func, length, iterations = 1000) {
            let total = 0;
            const data = getRandomString(length); // Generate data once outside the loop
            const startTime = performance.now();

            for (let i = 0; i < iterations; i++) {
                func(data); // Reuse the same data for all iterations
            }

            const endTime = performance.now();
            total = endTime - startTime; // Calculate total time once
            const average = total / iterations;
            return average;
        }

        // Test different string lengths
        const lengths = [16, 256, 10000, 100000];
        const resultsElement = document.getElementById('results');

        lengths.forEach(length => {
            const md5Avg = testHashFunction(md5, length);
            const sha256Avg = testHashFunction(sha256, length);

            resultsElement.innerHTML += `
                <h2>String Length: ${length}</h2>
                <p>MD5 Average Time: ${md5Avg.toFixed(4)} ms</p>
                <p>SHA256 Average Time: ${sha256Avg.toFixed(4)} ms</p>
                <hr>
            `;
        });
    </script>
</body>
</html>
```