Fix #1503: try select when encountering MethodType in simpleApply

Author: felixmulder

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

@@ -574,11 +574,19 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
                 new ApplyToUntyped(tree, fun1, funRef, proto, pt)(argCtx(tree))
             convertNewGenericArray(ConstFold(app.result))
           case mt: MethodType =>
-            val applyVal = untpd.ValDef(ctx.freshName("applyVal").toTermName, untpd.TypeTree(), tree.fun)
-            val valBlock =
-              untpd.Block(applyVal :: Nil, untpd.Apply(untpd.Ident(applyVal.name), tree.args))
-
-            typed(valBlock, pt)
+            /**
+             *  Fixes i1503:
+             *  {{{
+             *  (new Function0[Unit] {
+             *    def apply() = println("hello")
+             *  })()
+             *  }}}
+             *
+             *  Will get a weird shape that results in a MethodType being
+             *  inferred instead of a TermRef, to solve this we'll try to type
+             *  it as an Apply with a Select.
+             */
+            typedApply(untpd.Apply(untpd.Select(tree.fun, nme.apply), tree.args), pt)
           case _ =>
             handleUnexpectedFunType(tree, fun1)
         }
@@ -607,16 +615,16 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         case _ =>
           tryEither {
             implicit ctx => simpleApply(fun1, proto)
-          } {
-            (failedVal, failedState) =>
-              def fail = { failedState.commit(); failedVal }
-              // Try once with original prototype and once (if different) with tupled one.
-              // The reason we need to try both is that the decision whether to use tupled
-              // or not was already taken but might have to be revised when an implicit
-              // is inserted on the qualifier.
-              tryWithImplicitOnQualifier(fun1, originalProto).getOrElse(
-                if (proto eq originalProto) fail
-                else tryWithImplicitOnQualifier(fun1, proto).getOrElse(fail))
+          } { (failedVal, failedState) =>
+            def fail = { failedState.commit(); failedVal }
+            // Try once with original prototype and once (if different) with tupled one.
+            // The reason we need to try both is that the decision whether to use tupled
+            // or not was already taken but might have to be revised when an implicit
+            // is inserted on the qualifier.
+            tryWithImplicitOnQualifier(fun1, originalProto) getOrElse {
+              if (proto eq originalProto) fail
+              else tryWithImplicitOnQualifier(fun1, proto).getOrElse(fail)
+            }
           }
       }
     }