Fixes to allow for generic transparent type devfinitions

Author: odersky

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -578,6 +578,8 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
           loop(fn, targss, args :: argss)
         case TypeApply(fn, targs) =>
           loop(fn, targs ::: targss, argss)
+        case AppliedTypeTree(fn, targs) =>
+          loop(fn, targs ::: targss, argss)
         case _ =>
           (tree, targss, argss)
       }

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -995,7 +995,7 @@ object Types {
 
     /** If this type is a typeref with a type lambda as alias or upper bound, widen to the lambda */
     final def toLambda(implicit ctx: Context): Type = widen match {
-      case tp: TypeRef if tp.info.hiBound.isInstanceOf[LambdaType] => tp.info.hiBound
+      case tp: TypeProxy if tp.superType.isInstanceOf[LambdaType] => tp.superType
       case tp => tp
     }
 

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

@@ -255,7 +255,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         matchArgs(orderedArgs, methType.paramInfos, 0)
       case _ =>
         if (methType.isError) ok = false
-        else fail(s"$methString does not take parameters?")
+        else fail(s"$methString does not take parameters")
     }
 
     /** The application was successful */
@@ -691,7 +691,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
 
     def realApply(implicit ctx: Context): Tree = track("realApply") {
       val originalProto = new FunProto(tree.args, IgnoredProto(pt), this)(argCtx(tree))
-      val fun1 = typedExpr(tree.fun, originalProto)
+      val fun1 = typed(tree.fun, originalProto)(ctx.retractMode(Mode.Pattern))
 
       // Warning: The following lines are dirty and fragile. We record that auto-tupling was demanded as
       // a side effect in adapt. If it was, we assume the tupled proto-type in the rest of the application,

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

@@ -147,9 +147,13 @@ trait NamerContextOps { this: Context =>
         }
         else HKTermLambda.fromParams(params, resultType)
       }
-    if (typeParams.nonEmpty) PolyType.fromParams(typeParams, monotpe)
-    else if (valueParamss.isEmpty) ExprType(monotpe)
-    else monotpe
+    if (sym.isTerm)
+      if (typeParams.nonEmpty) PolyType.fromParams(typeParams, monotpe)
+      else if (valueParamss.isEmpty) ExprType(monotpe)
+      else monotpe
+    else
+      if (typeParams.nonEmpty) HKTypeLambda.fromParams(typeParams, monotpe)
+      else monotpe
   }
 
   /** Add moduleClass or sourceModule functionality to completer

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

@@ -2158,14 +2158,12 @@ class Typer extends Namer
           false
       }
 
-      def adaptToArgs(wtp: Type, pt: FunProto): Tree = wtp match {
-        case _: MethodOrPoly =>
+      def adaptToArgs(wtp: Type, pt: FunProto): Tree = wtp.toLambda match {
+        case _: LambdaType =>
           if (pt.args.lengthCompare(1) > 0 && isUnary(wtp) && ctx.canAutoTuple)
             adapt(tree, pt.tupled, locked)
           else
             tree
-        case wtp: TypeRef if wtp.underlying.hiBound.isInstanceOf[HKLambda] =>
-          tree
         case _ => tryInsertApplyOrImplicit(tree, pt, locked) {
           errorTree(tree, MethodDoesNotTakeParameters(tree))
         }
@@ -2489,8 +2487,9 @@ class Typer extends Namer
     }
 
     def adaptType(tp: Type): Tree = {
+      val isApplied = pt `eq` AnyTypeConstructorProto
       val tree1 =
-        if ((pt eq AnyTypeConstructorProto) || tp.typeParamSymbols.isEmpty) tree
+        if (isApplied || tp.typeParamSymbols.isEmpty) tree
         else {
           val tp1 =
             if (ctx.compilationUnit.isJava)
@@ -2507,7 +2506,7 @@ class Typer extends Namer
           case pt: TypeBounds if ctx.mode `is` Mode.Type => pt `contains` tree1.tpe
           case _ => tree1.tpe <:< pt
         }
-      if (Inliner.isInlineable(tree.symbol))
+      if (!isApplied && Inliner.isInlineable(tree.symbol))
         readaptSimplified {
           Inliner.inlineCall(tree, pt) match {
             case inlined: Inlined => TypeTree(inlined.tpe).withPos(tree.pos)

tests/run/typelevel2.scala

@@ -34,4 +34,15 @@ object Test extends App {
   def ii: Int = 2
   def nn: ToNat(ii) = S(S(Z)) // no expansion possible, since `ii` is of type `Int`.
   val ii1: Int = nn.toInt
+
+  type nth[F[_], T](n: Int) =
+    if n == 0 then T
+    else F[nth[F, T](n - 1)]
+
+  val nth0: nth[List, Int](0) = 2
+  val nth1: nth[Option, String](1) = Some("hi")
+  val nth3: nth[Seq, Boolean](3) = Seq(Seq(Seq(true, false)))
+  val nth0a: Int = nth0
+  val nth1a: Option[String] = nth1
+  val nth3a: Seq[Seq[Seq[Boolean]]] = nth3
 }