Explicit import to `scala.Predef.assert` can infer typer results for valid code

[WojciechMazur]

There seems to be something strange happening if scala.Predef.assert is explicitlly imported.
Issue spotted by OpenCB in iltotore/iron. Was spotted after applying patch to replace no longer allowed import scala.runtime.stdlibPatches.assert with scala.Predef.assert (required to shadow assert from utest library)

If we'd remove import scala.Predef.assert or use import io.github.iltotore.iron.{*, given} instead of package io.github.iltotore.iron the code would compile (the test code of mentioned library)
Otherwise we get a compile error hinting that implicit conversion was not applied

Issue requires further minimization, I'll try to provide it in the upcoming days

Compiler version

All Scala versions: tested with 3.3.7 and 3.8.0-RC2

Reproducer code

//> using dep "io.github.iltotore::iron-cats:3.2.1"

// import io.github.iltotore.iron.{*, given} // works 
package io.github.iltotore.iron // fails

import _root_.cats.kernel.CommutativeSemigroup
import _root_.cats.instances.all.*
import io.github.iltotore.iron.cats.{*, given}
import io.github.iltotore.iron.constraint.all.*

import scala.Predef.assert // comment it to make it compile

@main def Test = 
    assert(CommutativeSemigroup[Int :| Positive].combine(1, 5) == 6)

Output

error] ./test.scala:14:58
[error] Found:    (1 : Int)
[error] Required: io.github.iltotore.iron.IronType[Int,
[error]   io.github.iltotore.iron.constraint.all.Positive]
[error] 
[error] The following import might fix the problem:
[error] 
[error]   import io.github.iltotore.iron.autoRefine
[error] 
[error]     assert(CommutativeSemigroup[Int :| Positive].combine(1, 5) == 6)
[error]                                                          ^
[error] ./test.scala:14:61
[error] Found:    (5 : Int)
[error] Required: io.github.iltotore.iron.IronType[Int,
[error]   io.github.iltotore.iron.constraint.all.Positive]
[error] 
[error] The following import might fix the problem:
[error] 
[error]   import io.github.iltotore.iron.autoRefine
[error] 
[error]     assert(CommutativeSemigroup[Int :| Positive].combine(1, 5) == 6)
[error]                                                             ^
Error compiling project (Scala 3.3.7, JVM (21))

Expectation

Should compile in every combination

[hamzaremmal]

I think this is the smallest minimization I've ever did. Maybe it is completely different from this one but fixing it will show if it was the same root cause:

def foo(x: String): Boolean = ???

import scala.Predef.assert // or anything from Predef but ???

We get the following with Scala 3.7.4

hamzaremmal@macbook playground % scalac test.scala -Xprint:typer
-- [E006] Not Found Error: test.scala:1:30 -------------------------------------
1 |def foo(x: String): Boolean = ???
  |                              ^^^
  |                              Not found: ???
  |
  | longer explanation available when compiling with `-explain`
[[syntax trees at end of                     typer]] // test.scala
package <empty> {
  import scala.Predef.assert
  final lazy module val test$package: test$package = new test$package()
  final module class test$package() extends Object() {
    this: test$package.type =>
    def foo(x: String): Boolean = ???
  }
}

1 error found

[som-snytt]

importing from Predef turns off the "root import" for the compilation unit. I thought I tried different combinations to see what else it needed here besides assert.

[hamzaremmal]

I have a fix for my minimization, I will try on the other minimization to see if it also works.

[hamzaremmal]

I have a fix for my minimization, I will try on the other minimization to see if it also works.

It works. Hopefully, nothing broke in the test suite.

[hamzaremmal]

I will open a PR in the morning, I need to discuss some semantics with the team to be sure what we actually want to do.