2 files changed, 11 insertions, 7 deletions
diff --git a/src/dotty/tools/dotc/core/pickling/TreeUnpickler.scala b/src/dotty/tools/dotc/core/pickling/TreeUnpickler.scala
index e7eec58c3..15b2f6796 100644
--- a/src/dotty/tools/dotc/core/pickling/TreeUnpickler.scala
+++ b/src/dotty/tools/dotc/core/pickling/TreeUnpickler.scala
@@ -515,7 +515,8 @@ class TreeUnpickler(reader: TastyReader, tastyName: TastyName.Table, roots: Set[
           val vparamss = readParamss(localCtx)
           val tpt = readTpt()
           val typeParams = tparams.map(_.symbol)
-          val valueParamss = vparamss.nestedMap(_.symbol)
+          val valueParamss = ctx.normalizeIfConstructor(
+              vparamss.nestedMap(_.symbol), name == nme.CONSTRUCTOR)
           val resType = ctx.effectiveResultType(sym, typeParams, tpt.tpe)
           sym.info = ctx.methodType(typeParams, valueParamss, resType)
           DefDef(tparams, vparamss, tpt)
diff --git a/src/dotty/tools/dotc/typer/Namer.scala b/src/dotty/tools/dotc/typer/Namer.scala
index 708fb06c1..47375ba39 100644
--- a/src/dotty/tools/dotc/typer/Namer.scala
+++ b/src/dotty/tools/dotc/typer/Namer.scala
@@ -87,6 +87,14 @@ trait NamerContextOps { this: Context =>
     if (sym.name == nme.CONSTRUCTOR) sym.owner.typeRef.appliedTo(typeParams map (_.typeRef))
     else given
 
+  /** if isConstructor, make sure it has one non-implicit parameter list */
+  def normalizeIfConstructor(paramSymss: List[List[Symbol]], isConstructor: Boolean) =
+    if (isConstructor &&
+      (paramSymss.isEmpty || paramSymss.head.nonEmpty && (paramSymss.head.head is Implicit)))
+      Nil :: paramSymss
+    else
+      paramSymss
+
   /** The method type corresponding to given parameters and result type */
   def methodType(typeParams: List[Symbol], valueParamss: List[List[Symbol]], resultType: Type, isJava: Boolean = false)(implicit ctx: Context): Type = {
     val monotpe =
@@ -681,12 +689,7 @@ class Namer { typer: Typer =>
     vparamss foreach completeParams
     val isConstructor = name == nme.CONSTRUCTOR
     def typeParams = tparams map symbolOfTree
-    val paramSymss = {
-      val pss = vparamss.nestedMap(symbolOfTree)
-      if (isConstructor &&     // Make sure constructor has one non-implicit parameter list
-        (pss.isEmpty || pss.head.nonEmpty && (pss.head.head is Implicit))) Nil :: pss
-      else pss
-    }
+    val paramSymss = ctx.normalizeIfConstructor(vparamss.nestedMap(symbolOfTree), isConstructor)
     def wrapMethType(restpe: Type): Type = {
       val restpe1 = // try to make anonymous functions non-dependent, so that they can be used in closures
         if (name == nme.ANON_FUN) avoid(restpe, paramSymss.flatten)