Good code is red. Java interop issue with collectors

[SimY4]

Compiler version

Reproducible on 3.4.0-RC4. This code works fine on 3.3.1

Minimized code

import java.util.stream.*
import java.util.function.*

val map: java.util.Map[String, String] = Stream.of("1", "2", "3").collect(Collectors.toMap(
  (s: String) => s,
  Function.identity(),
  {
    case ("1", "1") => "1"
    case (_, l) => l
  }
))

Output

Found:    ("1" : String)
Required: Nothing

Expectation

Should compile

[bishabosha]

workaround:

import java.util.stream.*
import java.util.function.*

val map: java.util.Map[String, String] = Stream.of("1", "2", "3").collect(Collectors.toMap(
  (s: String) => s,
  Function.identity(),
  ((k: String, v: String) => (k, v) match {
    case ("1", "1") => "1"
    case (_, l) => l
  })
))

[bishabosha]

second workaround:

import java.util.stream.*
import java.util.function.*

val map: java.util.Map[String, String] = Stream.of("1", "2", "3").collect(Collectors.toMap(
  (s: String) => s,
  Function.identity(),
  {
    case ("1", "1") => "1"
    case (_, l) => l
  }: java.util.function.BinaryOperator[String]
))

[odersky]

Can we get a bisect on this?

[nicolasstucki]

If we add the test in tests/pos/i19637.scala we can bisect by running the following command:

$ scala-cli project/scripts/bisect.scala -- --releases 3.3.0-RC1-bin-20221124-e25362d-NIGHTLY..  compile tests/pos/i19637.scala

In the logs we see

Last good release: 3.4.0-RC1-bin-20231113-0dfe593-NIGHTLY
First bad release: 3.4.0-RC1-bin-20231114-18ada51-NIGHTLY

6c556aa35a25a9aa785367354f0f96b7a1baa09c is the first bad commit
commit 6c556aa35a25a9aa785367354f0f96b7a1baa09c
Author: odersky <odersky@gmail.com>
Date:   Sat Oct 28 18:14:50 2023 +0200

    Improve type inference for functions like fold
    
    When calling a fold with an accumulator like `Nil` or `List()` one used to have add
    an explicit type ascription. This is now no longer necessary. When instantiating
    type variables that occur invariantly in the expected type of a lambda, we now replace
    covariant occurrences of `Nothing` in the (possibly widened) type of the accumulator
    with fresh type variables.
    
    The idea is that a fresh type variable in such places is always better than Nothing. For
    module values such as `Nil` we widen to `List[<fresh var>]`. This does possibly cause a new
    type error if the fold really wanted a `Nil` instance. But that case seems very rare,
    so it looks like a good bet in general to do the widening.

 .../dotty/tools/dotc/core/ConstraintHandling.scala |  12 +--
 compiler/src/dotty/tools/dotc/core/Types.scala     |  25 +++--
 .../src/dotty/tools/dotc/transform/TypeUtils.scala |  16 +++-
 .../src/dotty/tools/dotc/typer/Inferencing.scala   | 103 +++++++++++++++++----
 compiler/src/dotty/tools/dotc/typer/Typer.scala    |  13 ++-
 tests/pos/folds.scala                              |  34 +++++++

The issue started in 6c556aa