Add pattern matcher optimizations

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -663,6 +663,37 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     case _ =>
       false
   }
+
+  /** Structural tree comparison (since == on trees is reference equality).
+   *  For the moment, only Ident, Select, Literal, Apply and TypeApply are supported
+   */
+  implicit class StructuralEqDeco(t1: Tree) {
+    def === (t2: Tree)(implicit ctx: Context): Boolean = (t1, t2) match {
+      case (t1: Ident, t2: Ident) =>
+        t1.symbol == t2.symbol
+      case (t1 @ Select(q1, _), t2 @ Select(q2, _)) =>
+        t1.symbol == t2.symbol && q1 === q2
+      case (Literal(c1), Literal(c2)) =>
+        c1 == c2
+      case (Apply(f1, as1), Apply(f2, as2)) =>
+        f1 === f2 && as1.corresponds(as2)(_ === _)
+      case (TypeApply(f1, ts1), TypeApply(f2, ts2)) =>
+        f1 === f2 && ts1.tpes.corresponds(ts2.tpes)(_ =:= _)
+      case _ =>
+        false
+    }
+    def hash(implicit ctx: Context): Int =
+      t1.getClass.hashCode * 37 + {
+        t1 match {
+          case t1: Ident => t1.symbol.hashCode
+          case t1 @ Select(q1, _) => t1.symbol.hashCode * 41 + q1.hash
+          case Literal(c1) => c1.hashCode
+          case Apply(f1, as1) => (f1.hash /: as1)((h, arg) => h * 41 + arg.hash)
+          case TypeApply(f1, ts1) => (f1.hash /: ts1)((h, arg) => h * 41 + arg.tpe.hash)
+          case _ => t1.hashCode
+        }
+      }
+  }
 }
 
 object TreeInfo {

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -12,7 +12,7 @@ import Denotations._, Decorators._, DenotTransformers._
 import collection.mutable
 import util.{Property, SourceFile, NoSource}
 import typer.ErrorReporting._
-import NameKinds.TempResultName
+import NameKinds.{TempResultName, OuterSelectName}
 
 import scala.annotation.tailrec
 import scala.io.Codec
@@ -171,6 +171,13 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def SyntheticValDef(name: TermName, rhs: Tree)(implicit ctx: Context): ValDef =
     ValDef(ctx.newSymbol(ctx.owner, name, Synthetic, rhs.tpe.widen, coord = rhs.pos), rhs)
 
+  def DefDef(sym: TermSymbol, tparams: List[TypeSymbol], vparamss: List[List[TermSymbol]],
+             resultType: Type, rhs: Tree)(implicit ctx: Context): DefDef =
+    ta.assignType(
+      untpd.DefDef(sym.name, tparams map TypeDef, vparamss.nestedMap(ValDef(_)),
+                   TypeTree(resultType), rhs),
+      sym)
+
   def DefDef(sym: TermSymbol, rhs: Tree = EmptyTree)(implicit ctx: Context): DefDef =
     ta.assignType(DefDef(sym, Function.const(rhs) _), sym)
 
@@ -199,14 +206,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     val (vparamss, rtp) = valueParamss(mtp)
     val targs = tparams map (_.typeRef)
     val argss = vparamss.nestedMap(vparam => Ident(vparam.termRef))
-    ta.assignType(
-      untpd.DefDef(
-        sym.name,
-        tparams map TypeDef,
-        vparamss.nestedMap(ValDef(_)),
-        TypeTree(rtp),
-        rhsFn(targs)(argss)),
-      sym)
+    DefDef(sym, tparams, vparamss, rtp, rhsFn(targs)(argss))
   }
 
   def TypeDef(sym: TypeSymbol)(implicit ctx: Context): TypeDef =
@@ -682,6 +682,12 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def select(name: Name)(implicit ctx: Context): Select =
       Select(tree, name)
 
+    /** A select node with the given selector name such that the designated
+     *  member satisfies predicate `p`. Useful for disambiguating overloaded members.
+     */
+    def select(name: Name, p: Symbol => Boolean)(implicit ctx: Context): Select =
+      select(tree.tpe.member(name).suchThat(p).symbol)
+
     /** A select node with the given type */
     def select(tp: NamedType)(implicit ctx: Context): Select =
       untpd.Select(tree, tp.name).withType(tp)
@@ -751,9 +757,20 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def ensureApplied(implicit ctx: Context): Tree =
       if (tree.tpe.widen.isParameterless) tree else tree.appliedToNone
 
-    /** `tree.isInstanceOf[tp]` */
-    def isInstance(tp: Type)(implicit ctx: Context): Tree =
-      tree.select(defn.Any_isInstanceOf).appliedToType(tp)
+    /** `tree == that` */
+    def equal(that: Tree)(implicit ctx: Context) =
+      applyOverloaded(tree, nme.EQ, that :: Nil, Nil, defn.BooleanType)
+
+    /** `tree.isInstanceOf[tp]`, with special treatment of singleton types */
+    def isInstance(tp: Type)(implicit ctx: Context): Tree = tp match {
+      case tp: SingletonType =>
+        if (tp.widen.derivesFrom(defn.ObjectClass))
+          tree.ensureConforms(defn.ObjectType).select(defn.Object_eq).appliedTo(singleton(tp))
+        else
+          singleton(tp).equal(tree)
+      case _ =>
+        tree.select(defn.Any_isInstanceOf).appliedToType(tp)
+    }
 
     /** tree.asInstanceOf[`tp`] */
     def asInstance(tp: Type)(implicit ctx: Context): Tree = {
@@ -771,7 +788,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       else Erasure.Boxing.adaptToType(tree, tp)
 
     /** `tree ne null` (might need a cast to be type correct) */
-     def testNotNull(implicit ctx: Context): Tree =
+    def testNotNull(implicit ctx: Context): Tree =
       tree.ensureConforms(defn.ObjectType)
         .select(defn.Object_ne).appliedTo(Literal(Constant(null)))
 
@@ -805,6 +822,13 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       }
       else Assign(tree, rhs)
 
+    /** A synthetic select with that will be turned into an outer path by ExplicitOuter.
+     *  @param levels  How many outer levels to select
+     *  @param tp      The type of the destination of the outer path.
+     */
+    def outerSelect(levels: Int, tp: Type)(implicit ctx: Context): Tree =
+      untpd.Select(tree, OuterSelectName(EmptyTermName, levels)).withType(tp)
+
     // --- Higher order traversal methods -------------------------------
 
     /** Apply `f` to each subtree of this tree */

compiler/src/dotty/tools/dotc/config/Printers.scala

@@ -32,5 +32,6 @@ object Printers {
   val pickling: Printer = noPrinter
   val inlining: Printer = noPrinter
   val exhaustivity: Printer = noPrinter
+  val patmatch: Printer = noPrinter
   val simplify: Printer = noPrinter
 }

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

@@ -255,7 +255,7 @@ class Definitions {
       // generated by pattern matcher, eliminated by erasure
 
     def AnyMethods = List(Any_==, Any_!=, Any_equals, Any_hashCode,
-      Any_toString, Any_##, Any_getClass, Any_isInstanceOf, Any_asInstanceOf)
+      Any_toString, Any_##, Any_getClass, Any_isInstanceOf, Any_asInstanceOf, Any_typeTest)
 
   lazy val ObjectClass: ClassSymbol = {
     val cls = ctx.requiredClass("java.lang.Object")
@@ -373,6 +373,10 @@ class Definitions {
     def Seq_apply(implicit ctx: Context) = Seq_applyR.symbol
     lazy val Seq_headR = SeqClass.requiredMethodRef(nme.head)
     def Seq_head(implicit ctx: Context) = Seq_headR.symbol
+    lazy val Seq_dropR = SeqClass.requiredMethodRef(nme.drop)
+    def Seq_drop(implicit ctx: Context) = Seq_dropR.symbol
+    lazy val Seq_lengthCompareR = SeqClass.requiredMethodRef(nme.lengthCompare)
+    def Seq_lengthCompare(implicit ctx: Context) = Seq_lengthCompareR.symbol
 
   lazy val ArrayType: TypeRef = ctx.requiredClassRef("scala.Array")
   def ArrayClass(implicit ctx: Context) = ArrayType.symbol.asClass

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

@@ -214,10 +214,7 @@ object Types {
       case _ => NoType
     }
 
-    /** Is this type guaranteed not to have `null` as a value?
-     *  For the moment this is only true for modules, but it could
-     *  be refined later.
-     */
+    /** Is this type guaranteed not to have `null` as a value? */
     final def isNotNull(implicit ctx: Context): Boolean = this match {
       case tp: ConstantType => tp.value.value != null
       case tp: ClassInfo => !tp.cls.isNullableClass && tp.cls != defn.NothingClass
@@ -3753,7 +3750,7 @@ object Types {
           if (underlying1 eq underlying) tp
           else derivedAnnotatedType(tp, underlying1, mapOver(annot))
 
-        case tp @ WildcardType =>
+        case tp: WildcardType =>
           derivedWildcardType(tp, mapOver(tp.optBounds))
 
         case tp: JavaArrayType =>

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

@@ -139,9 +139,9 @@ class Erasure extends Phase with DenotTransformer { thisTransformer =>
         i"The type $tp - ${tp.toString} of class ${tp.getClass} of tree $tree : ${tree.tpe} / ${tree.getClass} is illegal after erasure, phase = ${ctx.phase.prev}")
 }
 
-object Erasure extends TypeTestsCasts{
-
+object Erasure {
   import tpd._
+  import TypeTestsCasts._
 
   object Boxing {