Fix #19745 type alias anonymous class instantiation

When creating anonymous classes with `new T {}` where T is a type alias
like `type T[X] = SomeClass[X]`, the compiler was failing to infer type
parameters, resulting in "is not a class type" errors.

The fix adds special handling for HKTypeLambda types in both Typer and
Namer to create synthetic constructor applications for type parameter
inference, similar to how class parents are handled.

Author: neko-kai

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -1629,9 +1629,22 @@ class Namer { typer: Typer =>
         def typedParentType(tree: untpd.Tree): tpd.Tree =
           val parentTpt = typer.typedType(parent, AnyTypeConstructorProto)
           val ptpe = parentTpt.tpe.dealias.etaCollapse
-          if ptpe.typeParams.nonEmpty
-              && ptpe.underlyingClassRef(refinementOK = false).exists
-          then
+          // Check if type params need to be inferred. This applies when:
+          // 1. The type has type params AND
+          // 2. Either it directly underlies a class (for class/trait refs), OR
+          //    it's a HKTypeLambda whose result is a class application and params appear in result
+          //    (the latter handles type aliases like `type Foo[T] = Bar[T]` but not
+          //    type-lambda-as-result cases like `type Foo[X] = [Z] =>> Bar[X]`)
+          val needsTypeParamInference = ptpe.typeParams.nonEmpty && (
+            ptpe.underlyingClassRef(refinementOK = false).exists
+            || (ptpe match
+                case tl: HKTypeLambda =>
+                  tl.paramRefs.exists(pref => tl.resType.existsPart(_ == pref))
+                  && !tl.resType.isInstanceOf[TypeLambda]
+                  && tl.resType.underlyingClassRef(refinementOK = false).exists
+                case _ => false)
+          )
+          if needsTypeParamInference then
             // Try to infer type parameters from a synthetic application.
             // This might yield new info if implicit parameters are resolved.
             // A test case is i16778.scala.

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1232,6 +1232,30 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     else tree1
   }
 
+  /** Type a parent type reference in `new T { ... }` expressions.
+   *  This handles type aliases that need type parameter inference
+   *  by creating a synthetic constructor application, similar to
+   *  how class parents are handled in Namer.
+   */
+  def typedNewTemplateParent(tree: untpd.Tree, pt: Type)(using Context): Tree =
+    // First type with AnyTypeConstructorProto to check if it's a HKTypeLambda
+    val parentTpt = typedType(tree, AnyTypeConstructorProto)
+    val ptpe = parentTpt.tpe.dealias
+
+    ptpe match
+      case tl: HKTypeLambda
+          // Only handle type aliases where params appear in result (not type-lambda-as-result cases)
+          if tl.paramRefs.exists(pref => tl.resType.existsPart(_ == pref))
+             && !tl.resType.isInstanceOf[TypeLambda]
+             && tl.resType.underlyingClassRef(refinementOK = false).exists =>
+        // Found a type alias with type params whose result underlies a class.
+        // Create a synthetic constructor application to infer type arguments.
+        val app = untpd.Apply(untpd.Select(untpd.New(parentTpt), nme.CONSTRUCTOR), Nil)
+        val typedApp = typedExpr(app, pt)
+        TypeTree(typedApp.tpe).withSpan(tree.span)
+      case _ =>
+        inferTypeParams(typedType(tree), pt)
+
   def typedNew(tree: untpd.New, pt: Type)(using Context): Tree =
     tree.tpt match {
       case templ: untpd.Template =>
@@ -1248,7 +1272,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         then
           templ1 = cpy.Template(templ)(parents = untpd.TypeTree(pt) :: Nil)
         for case parent: RefTree <- templ1.parents do
-          typedAhead(parent, tree => inferTypeParams(typedType(tree), pt))
+          typedAhead(parent, typedNewTemplateParent(_, pt))
         val anon = tpnme.ANON_CLASS
         val clsDef = TypeDef(anon, templ1).withFlags(Final | Synthetic)
         typed(

tests/pos/i19745.scala

@@ -0,0 +1,15 @@
+final abstract class ForcedRecompilationToken[T]
+object ForcedRecompilationToken {
+  implicit def default: ForcedRecompilationToken["abc"] = null
+}
+
+object x {
+  abstract class GoodNoParens[T](implicit ev: ForcedRecompilationToken[T])
+}
+type BadNoParens[T] = x.GoodNoParens[T]
+
+object App extends App {
+  new BadNoParens {}
+  new BadNoParens() {}
+  new x.GoodNoParens {}
+}

tests/pos/i19745b.scala

@@ -0,0 +1,10 @@
+object x {
+  trait GoodNoParens[T]
+}
+export x.GoodNoParens as BadNoParens
+
+object App extends App {
+  new BadNoParens {}
+  new BadNoParens() {}
+  new x.GoodNoParens {}
+}