Given leaked in outer scope

[nicolasstucki]

Compiler version

3.5.0-RC1-bin-SNAPSHOT

Minimized code

trait Decoder
object Decoder:
  given foo: Int = ???

type DecoderToInt[Why] >: Int <: Int

def bar[T](using d: DecoderToInt[T]): Any = ???
def test: Unit = bar[Decoder]

Output

Compiles (but should not)

Expectation

Should not compile. foo should not be available in test witouth an import.

[nicolasstucki]

Annother test case

//  decoder_1.scala
trait Decoder
object Decoder:
  given foo: Int = ???

def bar(using d: M[Decoder]): Any = ???

type M[Y] = Y match
  case Decoder => Int

// test_2.scala
// should fail, does when compiling at the same time as decoder_2.scala
def test: Unit = bar

[nicolasstucki]

This is a minimization from tests/pos/i15183 when compiling the two files at the same time.

[odersky]

Bar[Decoder] has type

(using d: DecoderToInt[Decoder]): Any

Decoder appears in that type, so it is in the implicit scope.

I think the issue has rather to do with match types. Sometimes they are resolved sometimes not, and the implicit scope is different for the two versions.

[odersky]

I can confirm, that's excactly what happens. decoder and test are run together, M[Decoder] is simplified to Int, so Decoder does not reduce to the implicit scope. But if we compile test_2 separately, we still see an M[Decoder].

[EugeneFlesselle]

A related minimisation, where inference rather than implicit search, is impacted by whether or not the match type is reduced.

type MyMap[X] <: Any = X match
  case Double => Int

def myMap[T]: MyMap[T] = ???
def derived(d: MyMap[Double]): Any = ???

val der = derived(myMap)

-- [E007] Type Mismatch Error: tests/pos/i15183b.scala:10:18 -----------------------------------------------------------
10 |val der = derived(myMap)
   |                  ^^^^^
   |                  Found:    MyMap[T]
   |                  Required: Int
   |
   |                  where:    T is a type variable
   |
   |
   |                  Note: a match type could not be fully reduced:
   |
   |                    trying to reduce  MyMap[T]
   |                    failed since selector T
   |                    does not match  case Double => Int
   |                    and cannot be shown to be disjoint from it either.
   |
   | longer explanation available when compiling with `-explain`

But the same code is accepted when moving der into a separate file and compiling with a classpath dependency.

[odersky]

Not sure what to do about this second example.

[EugeneFlesselle]

Not sure what to do about this second example.

Yes indeed, contrarily to the implicit scope situation where making both cases consistently fail was good enough.
The same canot be said here, doing compareAppliedTypes only on normalised types not only makes the TypeComparer much slower, but also breaks many use cases relying on the inference of match type scrutinees.

This also might be related to #18261