Handle implicits with default parameters

Fixes #576.

run/pending/Meter now compiles; crashes at runtime

Author: odersky

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

@@ -1435,29 +1435,33 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         wtp.paramTypes.foreach(instantiateSelected(_, tvarsToInstantiate))
         val constr = ctx.typerState.constraint
         def addImplicitArgs = {
-          def implicitArgError(msg: => String): Tree = {
-            ctx.error(msg, tree.pos.endPos)
-            EmptyTree
-          }
-          val args = (wtp.paramNames, wtp.paramTypes).zipped map { (pname, formal) =>
-            def where = d"parameter $pname of $methodStr"
-            inferImplicit(formal, EmptyTree, tree.pos.endPos) match {
-              case SearchSuccess(arg, _, _) =>
-                arg
-              case ambi: AmbiguousImplicits =>
-                implicitArgError(s"ambiguous implicits: ${ambi.explanation} of $where")
-              case failure: SearchFailure =>
-                implicitArgError(d"no implicit argument of type $formal found for $where" + failure.postscript)
-            }
+          def argsOrError(pnames: List[TermName], ptypes: List[Type], acc: mutable.ListBuffer[Tree])
+            : AnyRef /* List[Tree] | () => String */ = (pnames, ptypes) match {
+            case (pname :: pnames1, ptype :: ptypes1) =>
+              def where = d"parameter $pname of $methodStr"
+              inferImplicit(ptype, EmptyTree, tree.pos.endPos) match {
+                case SearchSuccess(arg, _, _) =>
+                  acc += arg
+                  argsOrError(pnames1, ptypes1, acc)
+                case ambi: AmbiguousImplicits =>
+                  () => s"ambiguous implicits: ${ambi.explanation} of $where"
+                case failure: SearchFailure =>
+                  () => d"no implicit argument of type $ptype found for $where" + failure.postscript
+              }
+            case (Nil, Nil) =>
+              acc.toList
           }
-          if (args.exists(_.isEmpty)) {
-            // If there are several arguments, some arguments might already
-            // have influenced the context, binfing variables, but later ones
-            // might fail. In that case the constraint needs to be reset.
-            ctx.typerState.constraint = constr
-            tree
+          argsOrError(wtp.paramNames, wtp.paramTypes, new mutable.ListBuffer[Tree]) match {
+            case args: List[Tree] => adapt(tpd.Apply(tree, args), pt)
+            case failure: (() => String) =>
+              // If there are several arguments, some arguments might already
+              // have influenced the context, binding variables, but later ones
+              // might fail. In that case the constraint needs to be reset.
+              ctx.typerState.constraint = constr
+              tryEither
+                { implicit ctx => typed(untpd.Apply(untpd.TypedSplice(tree), Nil), pt) }
+                { (_, _) => ctx.error(failure(), tree.pos.endPos); tree }
           }
-          else adapt(tpd.Apply(tree, args), pt)
         }
         if ((pt eq WildcardType) || original.isEmpty) addImplicitArgs
         else