Do relaxedTyping everywhere

If all phases run at group end, any phase that adds or removes method parameters
makes all phases run before it in the same group have the wrong number of parameters
when type assigning an Apply or TypeApply. Previously this was allowed only if
relaxedTyping was true. Now it is allowed everywhere. We should still be able to
catch any errors in the transformer logic using Ycheck.

With this change, LinkScala2Impls can now be run at group end.

Author: odersky

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

@@ -298,11 +298,6 @@ object Phases {
      */
     def checkPostCondition(tree: tpd.Tree)(implicit ctx: Context): Unit = ()
 
-    /** If set, allow missing or superfluous arguments in applications
-     *  and type applications.
-     */
-    def relaxedTyping: Boolean = false
-
     /** Is this phase the standard typerphase? True for FrontEnd, but
      *  not for other first phases (such as FromTasty). The predicate
      *  is tested in some places that perform checks and corrections. It's

compiler/src/dotty/tools/dotc/transform/LambdaLift.scala

@@ -64,8 +64,6 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisTransform
   val phaseName: String = "lambdaLift"
   val treeTransform = new LambdaLifter
 
-  override def relaxedTyping = true
-
   override def runsAfterGroupsOf: Set[Class[_ <: Phase]] = Set(classOf[Constructors], classOf[HoistSuperArgs])
     // Constructors has to happen before LambdaLift because the lambda lift logic
     // becomes simpler if it can assume that parameter accessors have already been

compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala

@@ -48,8 +48,8 @@ class LinkScala2Impls extends MiniPhase with IdentityDenotTransformer { thisTran
   class Transform extends TreeTransform {
     def phase = thisTransform
 
-    //override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) =
-    //  groupEndPhase
+    override def treeTransformPhase(implicit ctx: Context, info: TransformerInfo) =
+      groupEndPhase
 
     /** Copy definitions from implementation class to trait itself */
     private def augmentScala_2_12_Trait(mixin: ClassSymbol)(implicit ctx: Context): Unit = {

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

@@ -334,21 +334,23 @@ trait TypeAssigner {
     else tp.substParam(pref, SkolemType(argType.widen))
   }
 
+  /** Substitute types of all arguments `args` for corresponding `params` in `tp`.
+   *  The number of parameters `params` may exceed the number of arguments.
+   *  In this case, only the common prefix is substituted.
+   */
+  def safeSubstParams(tp: Type, params: List[ParamRef], argTypes: List[Type])(implicit ctx: Context): Type = argTypes match {
+    case argType :: argTypes1 =>
+      val tp1 = safeSubstParam(tp, params.head, argType)
+      safeSubstParams(tp1, params.tail, argTypes1)
+    case Nil =>
+      tp
+    }
+
   def assignType(tree: untpd.Apply, fn: Tree, args: List[Tree])(implicit ctx: Context) = {
     val ownType = fn.tpe.widen match {
       case fntpe: MethodType =>
-        def safeSubstParams(tp: Type, params: List[ParamRef], args: List[Tree]): Type = params match {
-          case param :: params1 =>
-            val tp1 = safeSubstParam(tp, param, args.head.tpe)
-            safeSubstParams(tp1, params1, args.tail)
-          case Nil =>
-            tp
-          }
-        if (sameLength(fntpe.paramInfos, args) || ctx.phase.prev.relaxedTyping)
-          if (fntpe.isDependent) safeSubstParams(fntpe.resultType, fntpe.paramRefs, args)
-          else fntpe.resultType
-        else
-          errorType(i"wrong number of arguments for $fntpe: ${fn.tpe}, expected: ${fntpe.paramInfos.length}, found: ${args.length}", tree.pos)
+        if (fntpe.isDependent) safeSubstParams(fntpe.resultType, fntpe.paramRefs, args.tpes)
+        else fntpe.resultType
       case t =>
         errorType(err.takesNoParamsStr(fn, ""), tree.pos)
     }
@@ -404,7 +406,7 @@ trait TypeAssigner {
         }
         else {
           val argTypes = preCheckKinds(args, pt.paramInfos).tpes
-          if (sameLength(argTypes, paramNames) || ctx.phase.prev.relaxedTyping) pt.instantiate(argTypes)
+          if (sameLength(argTypes, paramNames)) pt.instantiate(argTypes)
           else wrongNumberOfTypeArgs(fn.tpe, pt.typeParams, args, tree.pos)
         }
       case _ =>