Make desugarIdent return a Tree

Author: allanrenucci

compiler/sjs/backend/sjs/JSCodeGen.scala

@@ -793,7 +793,7 @@ class JSCodeGen()(implicit ctx: Context) {
           throw new FatalError(s"Assignment to static member ${sym.fullName} not supported")
         val genRhs = genExpr(rhs)
         val lhs = lhs0 match {
-          case lhs: Ident => desugarIdent(lhs).getOrElse(lhs)
+          case lhs: Ident => desugarIdent(lhs)
           case lhs => lhs
         }
         lhs match {
@@ -892,7 +892,7 @@ class JSCodeGen()(implicit ctx: Context) {
     val sym = tree.fun.symbol
 
     val fun = tree.fun match {
-      case fun: Ident => desugarIdent(fun).getOrElse(fun)
+      case fun: Ident => desugarIdent(fun)
       case fun => fun
     }
 
@@ -1556,7 +1556,7 @@ class JSCodeGen()(implicit ctx: Context) {
     implicit val pos = tree.pos
 
     val fun = tree.fun match {
-      case fun: Ident => desugarIdent(fun).get
+      case fun: Ident => desugarIdent(fun).asInstanceOf[Select]
       case fun: Select => fun
     }
     val receiver = fun.qualifier

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -444,8 +444,12 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   def desugarIdent(i: Ident): Option[tpd.Select] = {
     var found = desugared.get(i.tpe)
     if (found == null) {
-      found = tpd.desugarIdent(i).orNull
-      if (found != null) desugared.put(i.tpe, found)
+      tpd.desugarIdent(i) match {
+        case sel: tpd.Select =>
+          desugared.put(i.tpe, sel)
+          found = sel
+        case _ =>
+      }
     }
     if (found == null) None else Some(found)
   }

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

@@ -1012,14 +1012,15 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     if (file != null && file.exists) new SourceFile(file, Codec(encoding)) else NoSource
   }
 
-  /** Desugar identifier into a select node. Return None if not possible */
-  def desugarIdent(tree: Ident)(implicit ctx: Context): Option[Select] = {
+  /** Desugar identifier into a select node. Return the tree itself if not possible */
+  def desugarIdent(tree: Ident)(implicit ctx: Context): Tree = {
     val qual = desugarIdentPrefix(tree)
-    if (qual.isEmpty) None
-    else Some(qual.select(tree.symbol))
+    if (qual.isEmpty) tree
+    else qual.select(tree.symbol)
   }
 
-  private def desugarIdentPrefix(tree: Ident)(implicit ctx: Context): Tree = tree.tpe match {
+  /** Recover identifier prefix (e.g. this) if it exists */
+  def desugarIdentPrefix(tree: Ident)(implicit ctx: Context): Tree = tree.tpe match {
     case TermRef(prefix: TermRef, _) =>
       ref(prefix)
     case TermRef(prefix: ThisType, _) =>

compiler/src/dotty/tools/dotc/transform/localopt/ConstantFold.scala

@@ -181,22 +181,19 @@ import ast.Trees._
         case _ => false
       }
     case t1: Ident =>
-      desugarIdent(t1) match {
-        case Some(t) =>
-          val t2i = t2 match {
-            case t2: Ident => desugarIdent(t2).getOrElse(t2)
-            case _ => t2
-          }
-          isSimilar(t, t2i)
-        case None => t1.symbol eq t2.symbol
+      t2 match {
+        case t2: Ident =>
+          t1.symbol eq t2.symbol
+        case _ => // Select
+          isSimilar(t2, t1)
       }
     case t1: Select => t2 match {
       case t2: Select =>
         (t1.symbol eq t2.symbol) &&
         isSimilar(t1.qualifier, t2.qualifier)
       case t2: Ident => desugarIdent(t2) match {
-        case Some(t2) => isSimilar(t1, t2)
-        case None => false
+        case t2: Select => isSimilar(t1, t2)
+        case _ => false
       }
       case _ => false
     }

compiler/src/dotty/tools/dotc/transform/localopt/Devalify.scala

@@ -194,7 +194,7 @@ class Devalify extends Optimisation {
       readingOnlyVals(qual)
 
     case t: Ident if !t.symbol.is(Mutable | Method) && !t.symbol.info.dealias.isInstanceOf[ExprType] =>
-      desugarIdent(t).forall(readingOnlyVals)
+      desugarIdent(t) match { case s: Select => readingOnlyVals(s); case _ => true }
 
     case t: This => true
     // null => false, or the following fails devalify:

compiler/src/dotty/tools/dotc/transform/localopt/DropNoEffects.scala

@@ -100,10 +100,9 @@ class DropNoEffects(val simplifyPhase: Simplify) extends Optimisation {
       cpy.Block(bl)(stats2, expr2)
 
     case t: Ident if !t.symbol.is(Method | Lazy) && !t.symbol.info.isInstanceOf[ExprType] || effectsDontEscape(t) =>
-      desugarIdent(t) match {
-        case Some(t) if !(t.qualifier.symbol.is(JavaDefined) && t.qualifier.symbol.is(Package)) => t
-        case _ => EmptyTree
-      }
+      val prefix = desugarIdentPrefix(t)
+      if (!prefix.isEmpty && !prefix.symbol.is(allOf(JavaDefined, Package))) t
+      else EmptyTree
 
     case app: Apply if app.fun.symbol.is(Label) && !app.tpe.finalResultType.derivesFrom(defn.UnitClass) =>
       // This is "the scary hack". It changes the return type to Unit, then

compiler/src/dotty/tools/dotc/transform/localopt/InlineCaseIntrinsics.scala

@@ -108,10 +108,9 @@ class InlineCaseIntrinsics(val simplifyPhase: Simplify) extends Optimisation {
       def receiver(t: Tree): Type = t match {
         case t: Apply     => receiver(t.fun)
         case t: TypeApply => receiver(t.fun)
-        case t: Ident     => desugarIdent(t) match {
-          case Some(t) => receiver(t)
-          case _ => NoType
-        }
+        case t: Ident     =>
+          val prefix = desugarIdentPrefix(t)
+          prefix.tpe.widenDealias
         case t: Select => t.qualifier.tpe.widenDealias
       }
 

compiler/src/dotty/tools/dotc/transform/localopt/Simplify.scala

@@ -154,14 +154,10 @@ object Simplify {
    *  System members are the only static final fields that are mutable.
    *  See https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.5.4
    */
-  @tailrec def isEffectivelyMutable(t: Tree)(implicit ctx: Context): Boolean = t match {
+  def isEffectivelyMutable(t: Tree)(implicit ctx: Context): Boolean = t match {
     case _ if t.symbol.is(Mutable) => true
-    case s: Select => s.symbol.owner == defn.SystemModule
-    case i: Ident  =>
-      desugarIdent(i) match {
-        case Some(ident) => isEffectivelyMutable(ident)
-        case None => false
-      }
+    case _: Select | _: Ident =>
+      t.symbol.owner == defn.SystemModule
     case _ => false
   }