Class constructor parameter undercompilation

[sake92]

Compiler version

3.3.1

Minimized code

// Hello.scala
object Hello extends App {
  val service = MyService("fssdfs")
  println("Works!")
}

// MyService.scala
class MyService(str: String)

compiles and runs fine.

But when you add a parameter to MyService constructor, it still compiles but fails at runtime with NoSuchMethodError.

Output

Exception in thread "main" java.lang.NoSuchMethodError: 'void example.MyService.<init>(java.lang.String)'
        at example.Hello$.<clinit>(Hello.scala:5)
        at example.Hello.main(Hello.scala)

Expectation

Code fails to compile.

[sake92]

Relevant issues:
sbt/zinc#1334
scalameta/metals#6112

Repro repo:
https://github.com/sake92/metals-mill-scala3-class-params-repro

[eed3si9n]

Likely the relevant code is around here where Scala 3 compiler builds up the dependency graph:

scala3/compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala

Lines 172 to 211 in a9bb881

	override def traverse(tree: Tree)(using Context): Unit = try {
	tree match {
	case Match(selector, _) =>
	addPatMatDependency(selector.tpe)
	case Import(expr, selectors) =>
	def lookupImported(name: Name) =
	expr.tpe.member(name).symbol
	def addImported(name: Name) = {
	// importing a name means importing both a term and a type (if they exist)
	addMemberRefDependency(lookupImported(name.toTermName))
	addMemberRefDependency(lookupImported(name.toTypeName))
	}
	for sel <- selectors if !sel.isWildcard do
	addImported(sel.name)
	if sel.rename != sel.name then
	rec.addUsedRawName(sel.rename)
	case exp @ Export(expr, selectors) =>
	val dep = expr.tpe.classSymbol
	if dep.exists && selectors.exists(_.isWildcard) then
	// If an export is a wildcard, that means that the enclosing class
	// has forwarders to all the applicable signatures in `dep`,
	// those forwarders will cause member/type ref dependencies to be
	// recorded. However, if `dep` adds more members with new names,
	// there has been no record that the enclosing class needs to
	// recompile to capture the new members. We add an
	// inheritance dependency in the presence of wildcard exports
	// to ensure all new members of `dep` are forwarded to.
	val depContext = depContextOf(ctx.owner.lexicallyEnclosingClass)
	rec.addClassDependency(dep, depContext)
	case t: TypeTree =>
	addTypeDependency(t.tpe)
	case ref: RefTree =>
	addMemberRefDependency(ref.symbol)
	addTypeDependency(ref.tpe)
	case t: Closure =>
	addInheritanceDependencies(t)
	case t: Template =>
	addInheritanceDependencies(t)
	case _ =>
	}

And here's how you can see the AST after parser phase:

$ mkdir /tmp/hello
$ scalac scalaHelloWorld/src/main/scala/example/*.scala -d /tmp/hello -Xprint:parser -Yplain-printer
[[syntax trees at end of                    parser]] // scalaHelloWorld/src/main/scala/example/Hello.scala
PackageDef(Ident(example), List(
  ModuleDef(Hello,
    Template(DefDef(<init>, List(), TypeTree(), Thicket(List())),
      List(Ident(App)), ValDef(_, Thicket(List()), Thicket(List())), List(
      ValDef(service, TypeTree(),
        Apply(Select(New(Ident(MyService)), <init>), List(Literal("fssdfs")))),
      Apply(Ident(println), List(Literal("Works!")))))
  )
))

[[syntax trees at end of                    parser]] // scalaHelloWorld/src/main/scala/example/MyService.scala
PackageDef(Ident(example), List(
  TypeDef(MyService,
    Template(
      DefDef(<init>, List(List(ValDef(str, Ident(String), Thicket(List())))),
        TypeTree(), Thicket(List())),
    List(), ValDef(_, Thicket(List()), Thicket(List())), List())
  )
))

In particular Apply(Select(New(Ident(MyService)), <init>), List(Literal("fssdfs")))).

[eed3si9n]

Here's my PR for this - #19911

[bishabosha]

Thank you @sake92 for reporting and @eed3si9n for the investigation and PR!