sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: material-ui
Issue: [material-ui][Avatar] Stop insisting on using an icon for an empty avatar
Labels: discussion,component: avatar,package: material-ui

### Steps to reproduce

Link to live example: https://mui.com/material-ui/react-avatar/

Steps:
1. Have any `Avatar` component without any content.

### Current behavior

In Material UI v5.15.7, a change was made that forces any `Avatar` component that does not have content to fallback to the Material Design "person" icon. This seems to me like a **breaking change**, and incredibly annoying behavior at that too since there is no way to disable this.

### Expected behavior

When I define an `Avatar` without content, I expect it to not have content.

### Context

_No response_

### Your environment

_No response_

**Search keywords**: avatar fallback
Repository: go
Issue: proposal: x/oauth2: support pushed authorization requests (PAR) 
Labels: Proposal

Feature request https://github.com/golang/oauth2/issues/653

We propose adding support to PAR ([RFC 9126](https://datatracker.ietf.org/doc/html/rfc9126)).

Motivation: PAR uses HTTP POST to directly send the authorization request parameters to the authorization server instead of being sent as URI query parameters via redirection in the user agent. This change would make it easier to write more secure OAuth clients by adding confidentiality and integrity to the authorization requests, reducing exposure to tampering and data leakage, and addressing the limitations of URL lengths that can prevent complex requests as when using JWT-Secured Authorization Request (JAR) or requests with fine-grained authorization. 

PAR is already supported by many IAM solutions such as [Okta](https://developer.okta.com/docs/reference/api/oidc/#par), [Auth0](https://auth0.com/docs/get-started/applications/configure-par), [Curity](https://curity.io/resources/learn/pushed-authorization-requests/),  [Identity Server](https://docs.duendesoftware.com/identityserver/v7/tokens/par/), and [Keycloak](https://www.keycloak.org/server/features) 

Proposed API:
```Go
// PushAuthRequest sends a back-channel authorization request to the PAR endpoint and returns a URL
// to OAuth 2.0 provider's consent page which contains a reference to the request made.
//
// The state parameter is used to prevent CSRF attacks. opts may include any authorization
// request parameters as defined in RFC 6749, or any extension like PKCE (RFC 7636) or JAR (RFC 9101).
//
// Recommended to use over AuthCodeURL when the authorization server supports it.
// See https://datatracker.ietf.org/doc/html/rfc9126
func (c *Config) PushAuthRequest(ctx context.Context, state string, opts ...AuthCodeOption) (string, error) 
```
Additionally, we update the `Endpoint` struct to include a `PARURL` field
```Go
type Endpoint struct {
    AuthURL       string
    DeviceAuthURL string
    TokenURL      string
    PARURL        string // New field for the PAR endpoint URL

    AuthStyle AuthStyle
}
```
Prototype implementation: https://go-review.googlesource.com/c/oauth2/+/567315
Repository: tensorflow
Issue: Support for Quantized ELU is missing in TFLite MLIR converter
Labels: type:feature,comp:lite,TFLiteConverter,awaiting PR merge,TF 2.16

**System information**
- OS Platform and Distribution (e.g., Linux Ubuntu 16.04): WSL2 Ubuntu
- TensorFlow installed from (source or binary): pip
- TensorFlow version (or github SHA if from source): Latest

Unlike ReLU for example, currently ELU isn't supported for 8 bit quantization in TFLite:
![image](https://github.com/tensorflow/tensorflow/assets/45564681/55ac6736-2e5a-421e-aedf-f41e541e870d)
I think we can confirm this by looking at ELU's definition in [tfl_ops.td](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/compiler/mlir/lite/ir/tfl_ops.td) , it doesn't have the quantizable trait.

While researching upon this issue, I stumbled upon an [old stackoverflow issue ](https://stackoverflow.com/questions/67774808/is-elu-int8-quantisation-working-on-tensorflow-lite) implying that quantized ELU was once supported. Maybe it was skipped after the move to MLIR?

Are there plans to support it? If not, will it be straightforward to implement it by my own?
Repository: tensorflow
Issue: C++ API `SparseFillEmptyRows` can lead to `std::length_error`
Labels: awaiting review,type:bug,comp:ops,TF 2.15

### Issue type

Bug

### Have you reproduced the bug with TensorFlow Nightly?

Yes

### Source

source

### TensorFlow version

tf 2.17

### Custom code

Yes

### OS platform and distribution

Linux Ubuntu 22.04 LTS

### Mobile device

_No response_

### Python version

_No response_

### Bazel version

6.5.0

### GCC/compiler version

_No response_

### CUDA/cuDNN version

_No response_

### GPU model and memory

_No response_

### Current behavior?

C++ API `SparseFillEmptyRows` can lead to `std::length_error`.
Error location is [here](https://github.com/tensorflow/tensorflow/blob/9da417e3f63215efe995b83e7b9f9b34115a424e/tensorflow/core/kernels/fill_empty_rows_functor.h#L114C36-L114C46):
```C++
    std::vector<Tindex> csr_offset(dense_rows, 0);
```
Because lack of checking negativity, negative value of `dense_rows` is fed to the constructor of `std::vector`. By integer underflow, the value is converted to extremely large number and it ends up with `std::length_error`.

### Standalone code to reproduce the issue

```C++
#include "tensorflow/cc/framework/scope.h"
#include "tensorflow/core/graph/graph.h"
#include "tensorflow/core/public/session.h"
#include "tensorflow/cc/ops/array_ops.h"
#include "tensorflow/cc/ops/standard_ops.h"

using namespace tensorflow;

int main() {
  SessionOptions options;
  std::unique_ptr<tensorflow::Session>
    session(tensorflow::NewSession(options));
  Scope scope = Scope::NewRootScope();

  Input indices = {{1l}};
  Input values = {1};
  Input dense_shape = {-1l};
  Input default_value = 1;
  auto target = ops::SparseFillEmptyRows(scope.WithOpName("target"), indices, values, dense_shape, default_value);

  Status status;
  GraphDef graph_def;
  status = scope.ToGraphDef(&graph_def);
  if (!status.ok()) {
    LOG(WARNING) << "Could not build graph: " << status.message();
  }

  status = session->Create(graph_def);
  if (!status.ok()) {
    LOG(WARNING) << "Could not create session: " << status.message();
  }

  std::vector<Tensor> outputs;
  status = session->Run({}, {"target"}, {"target"}, &outputs);
  if (!status.ok()) {
    LOG(WARNING) << "Could not run session: " << status.message();
  }

  return 0;
}
```


### Relevant log output

```shell
terminate called after throwing an instance of 'std::length_error'
  what():  cannot create std::vector larger than max_size()
Aborted (core dumped)
```
Repository: tensorflow
Issue: `tf.raw_ops.ExtractImagePatches`: Assertion failure in shape inference step
Labels: awaiting review,type:bug,comp:ops,comp:core,TF 2.15

### Issue type

Bug

### Have you reproduced the bug with TensorFlow Nightly?

Yes

### Source

source

### TensorFlow version

tf 2.17

### Custom code

Yes

### OS platform and distribution

Linux Ubuntu 22.04 LTS

### Mobile device

_No response_

### Python version

3.11.7

### Bazel version

6.5.0

### GCC/compiler version

clang 16

### CUDA/cuDNN version

_No response_

### GPU model and memory

_No response_

### Current behavior?

`tf.raw_ops.ExtractImagePatches` can lead to assertion failure in shape inference step.
Error location is [here](https://github.com/tensorflow/tensorflow/blob/f5daeae21404e8d672c785cc0c4c469ddc1b1a8a/tensorflow/core/ops/array_ops.cc#L2686-L2687):
```C++
      TF_RETURN_IF_ERROR(c->Multiply(
          c->Dim(input_shape, 3), ksize_rows * ksize_cols, &output_depth_dim));
```
Because it does not check validity of `ksize_rows * ksize_cols`, the negative value of it is fed to [`Multiply`](https://github.com/tensorflow/tensorflow/blob/83f1804f3427ae888e62b26b5bcba8afc9e24ef7/tensorflow/core/framework/shape_inference.cc#L1096C1-L1098C56):
```C++
Status InferenceContext::Multiply(DimensionHandle first,
                                  DimensionOrConstant second,
                                  DimensionHandle* out)
```
And it ends up with assertion failure at [a constructor of `DimensionOrConstant`](https://github.com/tensorflow/tensorflow/blob/daea84aad67d1fcc8d58c648e1da58ee576445f9/tensorflow/core/framework/shape_inference.h#L891-L896).

### Standalone code to reproduce the issue

```Python
import tensorflow as tf

tf.compat.v1.disable_eager_execution()

tf.raw_ops.ExtractImagePatches(
    images=tf.random.normal([1,1,1,1]),
    ksizes=[1,-1,2,1],
    strides=[1,1,1,1],
    rates=[1,1,1,1],
    padding="VALID",
    name=None
)
```


### Relevant log output

Release build: Outputs nothing

Debug build:
```shell
2024-02-27 20:05:58.701202: F ./tensorflow/core/framework/shape_inference.h:891] Check failed: val >= 0 || val == InferenceContext::kUnknownDim Dimension must be non-negative or equal to InferenceContext::kUnknownDim but got -2
Aborted (core dumped)
```
Repository: rust
Issue: `large_assignments`: Unactionable diagnostics with `-Zinline-mir`
Labels: A-lints,A-diagnostics,T-compiler,C-bug,requires-nightly,D-confusing,A-mir-opt-inlining,L-large_assignments

Tracking issue https://github.com/rust-lang/rust/issues/83518.

Doing `cargo build --release` will activate `-Zinline-mir` under the hood ([through](https://github.com/rust-lang/rust/blob/0f4925e436abba349e8f70502c6911c62c6a7276/compiler/rustc_mir_transform/src/inline.rs#L41-L55) `-Copt-level=3`). But it makes `large_assignments` diagnostics unhelpful, because it can make diagnostics point to library code that the user can't change.

## How to reproduce

**src/main.rs**
```rs
#![feature(large_assignments)]
#![deny(large_assignments)]
#![move_size_limit = "1000"]

pub fn main() {
    let data = [10u8; 9999];
    let cell = std::cell::UnsafeCell::new(data);
    std::hint::black_box(cell);
}
```

```sh
# One of:
cargo +nightly build --release
cargo +nightly rustc -- -Zmir-opt-level=1 -Zinline-mir
```

### Actual

```txt
   Compiling minimal v0.1.0 (/home/martin/src/bin)
error: moving 9999 bytes
    --> /home/martin/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/cell.rs:2054:9
     |
2054 |         UnsafeCell { value }
     |         ^^^^^^^^^^^^^^^^^^^^ value moved from here
     |
```

### Expected

```txt
   Compiling minimal v0.1.0 (/home/martin/src/bin)
error: moving 9999 bytes
 --> src/main.rs:7:43
  |
7 |     let cell = std::cell::UnsafeCell::new(data);
  |                                           ^^^^ value moved from here
  |
```

### Remarks

The expected diagnostics is given with these commands. Note how `-Zinline-mir` is deactivated in both cases:

```sh
# One of:
cargo +nightly build
cargo +nightly rustc -- -Zmir-opt-level=1
```

The above test case is ui-testified [here](https://github.com/Enselic/rust/commit/812ebcaebf7ad06d4ccb93ef1fe247c525897cc0). 

CC E-mentor @oli-obk who maybe have an idea on how to fix this? (I currently don't.)
Repository: pytorch
Issue: Trying doing static_quantization with Pytorch 2.1.0 torch.ao.quantization
Labels: oncall: quantization


## Issue description

Using torch.ao.quantization to do Post-training Static Quantization , didn't show error but it's not change the model layer to quantized layer(ex:  nn.Conv2d is still Conv2d after running my code)
Please Help Me with this problem!!!!!   Thank you!

############# Code example

def static_quantize(weight_path, qconfig_mapping):
    weights, imgsz = opt.weights, opt.img_size

    # load Pruned_model
    # 
    device = select_device(opt.device)
    device = torch.device("cpu")
    # Load model
    pruned_model = attempt_load(weights, map_location=device)  # load FP32 model (after pruning from other code)
    
    stride = int(pruned_model.stride.max())  # model stride
    imgsz = check_img_size(imgsz, s=stride)  # check img_size
    pruned_model.eval()
    if weight_path != '1234':  # get pruned_model's weights if path is not default string"1234" 
        pruned_model.load_state_dict(torch.load(weight_path),False)   #load pruned_model.pt


    #  "input"  "output":  Add  QuantStub , DeQuantStub
    
    pruned_model = QuantStub()(pruned_model)
    pruned_model = DeQuantStub()(pruned_model)


    # 
    pruned_model = prepare(pruned_model, qconfig_mapping)
    quantized_model = convert(pruned_model, inplace=False)

    # save model's weights
    torch.save(pruned_model.state_dict(), "static_quantized_original.pt") 
    print("Static Quantization Success!!!!")    
    
    return quantized_model

if __name__ == "__main__":
    device = select_device(opt.device)
    
    
    # create static_quantization_config
    qconfig = torch.ao.quantization.get_default_qconfig('fbgemm')
    qconfig_dict = {'': qconfig}
    qconfig_mapping = QConfigMapping.from_dict(qconfig_dict)

    # operate quantization_function
    quantized_model = static_quantize(weight_path, qconfig_mapping)
    static_quant_weights_path = 'static_quantized_weights.pt'
    torch.save({'model': quantized_model.state_dict()}, static_quant_weights_path)

```

- PyTorch or Caffe2: Pytorch
- How you installed PyTorch (conda, pip, source): conda
- Build command you used (if compiling from source):
- OS: Ubuntu18.04
- PyTorch version:2.1.0
- Python version:3.8.13
- CUDA/cuDNN version:11.6
- GPU models and configuration:
- GCC version (if compiling from source):GCC 7.5.0
- CMake version:
- Versions of any other relevant libraries:


cc @jerryzh168 @jianyuh @raghuramank100 @jamesr66a @vkuzo @jgong5 @Xia-Weiwen @leslie-fang-intel
Repository: rust
Issue: Inefficient code generation for u8 -> boolean conversion if bounds check already applied
Labels: A-LLVM,T-compiler,C-bug,S-has-mcve,C-optimization

This occurs both on the latest stable and nightly with both `-C opt-level=2` and `-C opt-level=3`, and looking back some versions this has been going on for quite a while, so this is not a regression AFAIK. Consider the following piece of code:

```rust
#[no_mangle]
pub fn test(x: &u8) -> bool {
    let load = *x;
    if load <= 1 {
        return load == 1;
    }

    // Just some nonsense to keep the above branch.
    something_dynamic()
}

#[inline(never)]
#[cold]
fn something_dynamic() -> bool {
    std::env::var("dynamic").is_ok()
}
```

I would expect that in a release build, the above code loads the u8, checks if it is a legal value for a bool, and if so return it, otherwise going to `something_dynamic()`. The motivation for this piece of code is something similar to a `OnceLock<bool>` in an incredibly hot piece of code. Ideally the hot path only consists of a single `mov`, `cmp` and `jmp`. Compiled [we see the following](https://rust.godbolt.org/z/oKjvMMovT):

```asm
test:
        movzx   eax, byte ptr [rdi]
        cmp     al, 2
        jae     example::something_dynamic
        cmp     al, 1
        sete    al
        ret

example::something_dynamic:
        <omitted>
```

It appears that Rust always emits code for turning an `u8` into a `bool` (`cmp al, 1` followed by `sete al`), regardless of whether this is necessary. In this case, since we checked that the `u8` is `<= 1`, this is not necessary at all. The same problem occurs on ARM:

```asm
_test:
        ldrb    w8, [x0]
        cmp     w8, #2
        b.hs    LBB0_2
        cmp     w8, #1
        cset    w0, eq
        ret
       
LBB0_2:
        b       example::something_dynamic
```

The problem even persists if we try to use transmute, or pointer casts to bypass the problem. All the following variants still cause a superfluous value test:

```rust
    if load <= 1 {
        return load == 1;
        // return unsafe { *(&load as *const u8 as *const bool) };
        // return unsafe { std::mem::transmute(load) };
        // return unsafe { std::mem::transmute_copy(&load) };
    }
```

The weirdest thing is that this pessimization only occurs when there is a bounds check already applied. The following function avoids a test, directly loading the byte:

```rust
#[no_mangle]
unsafe fn maybe_load(x: &u8, should_load: bool) -> bool {
    if should_load {
        return unsafe { std::mem::transmute_copy(x) };
    }

    something_dynamic()
}
```

```asm
maybe_load:
        test    esi, esi
        je      example::something_dynamic
        movzx   eax, byte ptr [rdi]
        ret
```

However, if you try to implement `test` in terms of `maybe_load`, it gets inlined and the useless `cmp, sete` is back.
Repository: godot
Issue: Power operator's sequence should be performed right-to-left rather than left-to-right?
Labels: discussion,topic:core,topic:gdscript,breaks compat

### Tested versions

a586e860e5fc382dec4ad9a0bec72f7c6684f020

### System information

Windows 11

### Issue description

The power operator seems to be executed in not the common order of that operation. In the Python the order of this operation follows right-to-left: 1 ** (2 ** 3) while in Godot currently it's executed left-to-right like (1 ** 2) ** 3. The fix should be performed both in GDScript and the expression parser.

### Steps to reproduce

Executing the following code line will emit error
```
assert(2 ** 2 ** 3 == 256)
```
In Python that code will be evaluated to true, while in Godot the result is 64, which is incorrect.

### Minimal reproduction project (MRP)

Too easy to reproduce
Repository: PowerToys
Issue: Choosing zone on the wide display does not work as expected
Labels: Issue-Bug,Product-FancyZones,Needs-Triage

### Microsoft PowerToys version

0.78.0

### Installation method

Microsoft Store

### Running as admin

None

### Area(s) with issue?

FancyZones

### Steps to reproduce

I extend my laptop with Samsung Odyssey G9 (5120 × 1440 px) and the splitting into zones stopped working correctly. When I use "Allow zones to span across monitors", everything works good.

https://github.com/microsoft/PowerToys/assets/76998187/a1c65d8a-45de-454d-a195-0e34f40334e4


### ✔️ Expected Behavior

_No response_

### ❌ Actual Behavior

_No response_

### Other Software

_No response_
Repository: rust
Issue: building dynamic libraries on mac sets id/name for linker to something questionable
Labels: A-linkage,O-macos,T-compiler

If I build a "cdylib", it tells the linker that the library is located in the `target/release` directory.

Here is the output for `otool -l`:

```
Load command 4
          cmd LC_ID_DYLIB
      cmdsize 96
         name /Users/vanessa/dev/rust/forks/regex/target/release/deps/librure.dylib (offset 24)
   time stamp 1 Wed Dec 31 19:00:01 1969
      current version 0.0.0
compatibility version 0.0.0
````

This means I can't install the shared library by copying the `.dylib` to `/usr/local/lib`; I have to run `install_name_tool` on the build result before distributing.

I think building a library should set the name to something like `@rpath/librure.dylib`
Repository: ant-design
Issue: 目录树在React18的并发模式情况下，更新数据和展开文件夹时，发生闪烁。非并发模式没有问题。
Labels: Inactive,improvement

### Reproduction link

[![Edit on CodeSandbox](https://codesandbox.io/static/img/play-codesandbox.svg)](https://codesandbox.io/p/sandbox/mu-lu-antd-5-14-1-forked-68hv4q?file=%2Findex.tsx%3A16%2C1)

### Steps to reproduce

在index.tsx中，
使用并发模式，每隔0.5秒，点击操作按钮30次左右，可以看到树在切换过程中目录树发生闪烁，有问题。
注释掉并发模式代码，开启非并发模式，每隔0.5秒，点击操作按钮30次左右，切换过程中树不闪烁，没有问题。

### What is expected?

不论是否开启并发模式，切换树的过程，不应该发生闪烁

### What is actually happening?

使用并发模式，每隔0.5秒，点击操作按钮30次左右，可以看到树在切换过程中目录树发生闪烁。

| Environment | Info |
| --- | --- |
| antd | 5.14.2 |
| React | 18.2.0 |
| System | mac 14.1.2 (23B92) |
| Browser | 121.0.6167.184 |

<!-- generated by ant-design-issue-helper. DO NOT REMOVE -->
Repository: rust
Issue: Tracking Issue for the `Freeze` trait
Labels: T-lang,T-libs-api,C-tracking-issue,B-experimental,F-freeze

Feature gate: `#![feature(freeze)]`

This is a tracking issue for the `core::marker::Freeze` trait

This trait allows generic code to restrict generic parameters to types without interior mutability.

### Public API


```rust
use std::marker::Freeze;

trait Trait<T: Freeze + 'static> {
    const VALUE: T;
    const VALUE_REF: &'static T = &Self::VALUE;
}
```

### Steps / History

- [ ] Implementation: #121840
- [ ] Final comment period (FCP)[^1]
- [ ] Stabilization PR

### Unresolved Questions

- naming the trait differently (see [#121501 (comment)](https://github.com/rust-lang/rust/pull/121501#issuecomment-1962900148))

[^1]: https://std-dev-guide.rust-lang.org/feature-lifecycle/stabilization.html
Repository: godot
Issue: Consistent Forward+ crash - RenderingDeviceDriverVulkan
Labels: bug,platform:windows,topic:rendering,topic:porting,crash

### Tested versions

v4.3.dev.custom_build [a586e860e]

### System information

Windows 10 - Vulkan (Forward+) - dedicated NVIDIA GeForce GTX 970 (NVIDIA; 31.0.15.4633)

### Issue description

Godot consistently crashes when coming from hibernate on W10, as per described steps. The stacktrace is always the same:
```
================================================================
CrashHandlerException: Program crashed
Engine version: Godot Engine v4.3.dev.custom_build (a586e860e5fc382dec4ad9a0bec72f7c6684f020)
Dumping the backtrace. Please include this when reporting the bug to the project developer.
[0] <couldn't map PC to fn name>
[1-23] <couldn't map PC to fn name>
[24] RenderingDeviceDriverVulkan::_swap_chain_release (Godot\drivers\vulkan\rendering_device_driver_vulkan.cpp:2441)
[25] RenderingDeviceDriverVulkan::swap_chain_resize (Godot\drivers\vulkan\rendering_device_driver_vulkan.cpp:2544)
[26] RenderingDevice::screen_prepare_for_drawing (Godot\servers\rendering\rendering_device.cpp:3191)
[27] RendererCompositorRD::blit_render_targets_to_screen (Godot\servers\rendering\renderer_rd\renderer_compositor_rd.cpp:38)
[28] RendererViewport::draw_viewports (Godot\servers\rendering\renderer_viewport.cpp:819)
[29] RenderingServerDefault::_draw (Godot\servers\rendering\rendering_server_default.cpp:92)
[30] RenderingServerDefault::draw (Godot\servers\rendering\rendering_server_default.cpp:388)
[31] Main::iteration (Godot\main\main.cpp:4008)
[32] OS_Windows::run (Godot\platform\windows\os_windows.cpp:1476)
[33] widechar_main (Godot\platform\windows\godot_windows.cpp:182)
[34] _main (Godot\platform\windows\godot_windows.cpp:206)[35] main (Godot\platform\windows\godot_windows.cpp:218)
[36] __scrt_common_main_seh (D:\a\_work\1\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:288)
[37] <couldn't map PC to fn name>
-- END OF BACKTRACE --
================================================================
```

### Steps to reproduce

1. Have Godot open in the 3D editor view
2. Press (or mouse click) Windows Key
3. Right click Power options, Hibernate
4. Turn PC back on, Godot will have crashed on these specs

![image](https://github.com/godotengine/godot/assets/115422160/5844e9be-32cc-4ec2-a8a4-f8df02a2fe80)


### Minimal reproduction project (MRP)

Reproducible on an empty project, which I include here:
[Empty Proj.zip](https://github.com/godotengine/godot/files/14419864/Empty.Proj.zip)