Remove appliedIfMethod use ensureApplied instead

2 files changed, 10 insertions, 17 deletions

diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index 2a6ec9d78..9b7c9cbae 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -44,9 +44,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Apply(fn: Tree, args: List[Tree])(implicit ctx: Context): Apply =
     ta.assignType(untpd.Apply(fn, args), fn, args)
 
-  def ensureApplied(fn: Tree)(implicit ctx: Context): Tree =
-    if (fn.tpe.widen.isParameterless) fn else Apply(fn, Nil)
-
   def TypeApply(fn: Tree, args: List[Tree])(implicit ctx: Context): TypeApply =
     ta.assignType(untpd.TypeApply(fn, args), fn, args)
 
@@ -566,13 +563,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     def appliedToNone(implicit ctx: Context): Apply = appliedToArgs(Nil)
 
-    def appliedIfMethod(implicit ctx: Context): Tree = {
-      tree.tpe.widen match {
-        case fntpe: MethodType => appliedToArgs(Nil)
-        case _ => tree
-      }
-    }
-
     def appliedToType(targ: Type)(implicit ctx: Context): Tree =
       appliedToTypes(targ :: Nil)
 
@@ -582,6 +572,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def appliedToTypeTrees(targs: List[Tree])(implicit ctx: Context): Tree =
       if (targs.isEmpty) tree else TypeApply(tree, targs)
 
+    def ensureApplied(implicit ctx: Context): Tree =
+      if (tree.tpe.widen.isParameterless) tree else tree.appliedToNone
+
     def isInstance(tp: Type)(implicit ctx: Context): Tree =
       tree.select(defn.Any_isInstanceOf).appliedToType(tp)
 
@@ -638,7 +631,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     val mname      = ("to" + numericCls.name).toTermName
     val conversion = tree.tpe member mname
     if (conversion.symbol.exists)
-      ensureApplied(tree.select(conversion.symbol.termRef))
+      tree.select(conversion.symbol.termRef).ensureApplied
     else if (tree.tpe.widen isRef numericCls)
       tree
     else {
diff --git a/src/dotty/tools/dotc/transform/PatternMatcher.scala b/src/dotty/tools/dotc/transform/PatternMatcher.scala
index 97525e289..9c8e16386 100644
--- a/src/dotty/tools/dotc/transform/PatternMatcher.scala
+++ b/src/dotty/tools/dotc/transform/PatternMatcher.scala
@@ -20,7 +20,7 @@ import typer.ErrorReporting._
 import ast.Trees._
 import Applications._
 import TypeApplications._
-import TypeUtils._
+import SymUtils._, core.NameOps._
 
 import dotty.tools.dotc.util.Positions.Position
 import dotty.tools.dotc.core.Decorators._
@@ -112,7 +112,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
       def tupleSel(binder: Symbol)(i: Int): Tree = ref(binder).select(nme.productAccessorName(i))
       def index(tgt: Tree)(i: Int): Tree         = {
         if (i > 0) tgt.select(defn.Seq_apply).appliedTo(Literal(Constant(i)))
-        else tgt.select(defn.Seq_head).appliedIfMethod
+        else tgt.select(defn.Seq_head).ensureApplied
       }
 
       // Right now this blindly calls drop on the result of the unapplySeq
@@ -237,7 +237,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
         val matchFail = newSynthCaseLabel(ctx.freshName("matchFail"), MethodType(Nil, restpe))
         val catchAllDefBody = DefDef(matchFail, catchAllDef)
 
-        val nextCases = (caseSyms.tail ::: List(matchFail)).map(ref(_).appliedIfMethod)
+        val nextCases = (caseSyms.tail ::: List(matchFail)).map(ref(_).ensureApplied)
         val caseDefs = (cases zip caseSyms zip nextCases).foldRight[Tree](catchAllDefBody) {
           // dotty deviation
           //case (((mkCase, sym), nextCase), acc) =>
@@ -248,7 +248,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
 
             val caseBody = DefDef(sym, _ => Block(List(acc), body))
 
-            Block(List(caseBody),ref(sym).appliedIfMethod)
+            Block(List(caseBody),ref(sym).ensureApplied)
           }}
 
 
@@ -278,7 +278,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
           val isDefined = extractorMemberType(prev.tpe, nme.isDefined)
 
           if ((isDefined isRef defn.BooleanClass) && getTp.exists) {
-            val prevValue = ref(prevSym).select("get".toTermName).appliedIfMethod
+            val prevValue = ref(prevSym).select("get".toTermName).ensureApplied
               Block(
                 List(ValDef(prevSym, prev)),
                 // must be isEmpty and get as we don't control the target of the call (prev is an extractor call)
@@ -1800,7 +1800,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
           if ((extractorMemberType(resultType, nme.isDefined) isRef defn.BooleanClass) && resultOfGet.exists)
             getUnapplySelectors(resultOfGet, args)
           else if (defn.isProductSubType(resultType)) productSelectorTypes(resultType)
-          else if (resultType =:= defn.BooleanType) Nil
+          else if (resultType isRef defn.BooleanClass) Nil
           else {
             ctx.error(i"invalid return type in Unapply node: $resultType")
             Nil