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.