Eliminate MethodOrPoly

Replace with LambdaType

Author: odersky

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

@@ -2331,16 +2331,14 @@ object Types {
     }
   }
 
-  trait MethodOrPoly extends MethodicType
-
   /** The lambda type square:
    *
    *    LambdaType  |   TermLambda      |   TypeLambda
    *    ------------+-------------------+------------------
    *    HKLambda    |   HKTermLambda    |   HKTypeLambda
    *    StarLambda  |   MethodType	    |   PolyType
    */
-  trait LambdaType extends BindingType with MethodOrPoly { self =>
+  trait LambdaType extends BindingType with MethodicType { self =>
     type ThisName <: Name
     type PInfo <: Type
     type This <: LambdaType{type PInfo = self.PInfo}

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

@@ -86,7 +86,7 @@ class VCInlineMethods extends MiniPhaseTransform with IdentityDenotTransformer {
    *  by a call to the corresponding extension method, otherwise return it as is.
    */
   private def rewireIfNeeded(tree: Tree)(implicit ctx: Context) = tree.tpe.widen match {
-    case tp: MethodOrPoly =>
+    case tp: LambdaType =>
       tree // The rewiring will be handled by a fully-applied parent node
     case _ =>
       if (isMethodWithExtension(tree.symbol))

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

@@ -1052,7 +1052,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           if (tp1.isVarArgsMethod && tp2.isVarArgsMethod) tp1.paramInfos map repeatedToSingle
           else tp1.paramInfos
         isApplicable(alt2, formals1, WildcardType) ||
-        tp1.paramInfos.isEmpty && tp2.isInstanceOf[MethodOrPoly]
+        tp1.paramInfos.isEmpty && tp2.isInstanceOf[LambdaType]
       case tp1: PolyType => // (2)
         val tparams = ctx.newTypeParams(alt1.symbol, tp1.paramNames, EmptyFlags, tp1.instantiateBounds)
         isAsSpecific(alt1, tp1.instantiate(tparams map (_.typeRef)), alt2, tp2)

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

@@ -1741,7 +1741,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   def adapt(tree: Tree, pt: Type, original: untpd.Tree = untpd.EmptyTree)(implicit ctx: Context): Tree = /*>|>*/ track("adapt") /*<|<*/ {
     /*>|>*/ ctx.traceIndented(i"adapting $tree of type ${tree.tpe} to $pt", typr, show = true) /*<|<*/ {
       if (tree.isDef) interpolateUndetVars(tree, tree.symbol)
-      else if (!tree.tpe.widen.isInstanceOf[MethodOrPoly]) interpolateUndetVars(tree, NoSymbol)
+      else if (!tree.tpe.widen.isInstanceOf[LambdaType]) interpolateUndetVars(tree, NoSymbol)
       tree.overwriteType(tree.tpe.simplified)
       adaptInterpolated(tree, pt, original)
     }