Add calls on this in erased calls.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/transform/linker/callgraph/CallGraphBuilder.scala

@@ -47,7 +47,7 @@ class CallGraphBuilder(collectedSummaries: Map[Symbol, MethodSummary], mode: Int
     }
     val targs = (0 until targsSize).map(x => new ErazedType()).toList
     val args = ctx.definitions.ArrayOf(ctx.definitions.StringType) :: Nil
-    val call = CallInfoWithContext(tpe, targs, args, OuterTargs.empty, None, None)
+    val call = CallInfoWithContext(tpe, targs, args, OuterTargs.empty, None, None, isErased = false)
     entryPoints(call) = entryPointId
     reachableMethods += call
     val t = ref(s.owner).tpe
@@ -81,10 +81,10 @@ class CallGraphBuilder(collectedSummaries: Map[Symbol, MethodSummary], mode: Int
         }
         if (!clas.is(JavaDefined) && clas.is(Module)) {
           val fields = clas.classInfo.decls.filter(x => !x.is(Method) && !x.isType)
-          val parent = Some(CallInfoWithContext(x.tp.select(clas.primaryConstructor), x.tp.baseArgInfos(clas), Nil, x.outerTargs, None, None))
+          val parent = Some(CallInfoWithContext(x.tp.select(clas.primaryConstructor), x.tp.baseArgInfos(clas), Nil, x.outerTargs, None, None, isErased = false))
           reachableMethods ++= fields.map {
             fieldSym =>
-              CallInfoWithContext(x.tp.select(fieldSym), Nil, Nil, x.outerTargs, parent, None)
+              CallInfoWithContext(x.tp.select(fieldSym), Nil, Nil, x.outerTargs, parent, None, isErased = false)
           }
         }
       }
@@ -189,7 +189,7 @@ class CallGraphBuilder(collectedSummaries: Map[Symbol, MethodSummary], mode: Int
     }.apply(OuterTargs.empty, tp)
   }
 
-  private def instantiateCallSite(caller: CallInfoWithContext, rec: Type, callee: CallInfo, types: Traversable[TypeWithContext]): Traversable[CallInfoWithContext] = {
+  private def instantiateCallSite(caller: CallInfoWithContext, rec: Type, callee: CallInfo, types: Traversable[TypeWithContext], isErased: Boolean = false): Traversable[CallInfoWithContext] = {
 
     lazy val someCaller = Some(caller)
     lazy val someCallee = Some(callee)
@@ -200,6 +200,10 @@ class CallGraphBuilder(collectedSummaries: Map[Symbol, MethodSummary], mode: Int
     val calleeSymbol = callee.call.termSymbol.asTerm
     val callerSymbol = caller.call.termSymbol
 
+    def mkCallInfoWithContext(call: Type, targs: List[Type], args: List[Type], outerTargs: OuterTargs) = {
+      CallInfoWithContext(call, targs, args, outerTargs, someCaller, someCallee, isErased)
+    }
+
     val tpamsOuter = caller.call.widen match {
       case t: PolyType =>
         OuterTargs.empty.addAll(callerSymbol, t.paramNames, caller.targs)
@@ -309,10 +313,10 @@ class CallGraphBuilder(collectedSummaries: Map[Symbol, MethodSummary], mode: Int
             assert(call.exists)
             t.underlying.select(call)
           }
-          CallInfoWithContext(preciseSelectCall, targs, args, outerTargs, someCaller, someCallee) :: Nil
+          mkCallInfoWithContext(preciseSelectCall, targs, args, outerTargs) :: Nil
         case t: ClosureType if calleeSymbol.name eq t.implementedMethod.name =>
           val methodSym = t.meth.meth.symbol.asTerm
-          CallInfoWithContext(TermRef.withFixedSym(t.underlying, methodSym.name,  methodSym), targs, t.meth.env.map(_.tpe) ++ args, outerTargs ++ t.outerTargs, someCaller, someCallee) :: Nil
+          mkCallInfoWithContext(TermRef.withFixedSym(t.underlying, methodSym.name,  methodSym), targs, t.meth.env.map(_.tpe) ++ args, outerTargs ++ t.outerTargs) :: Nil
         case AndType(tp1, tp2) =>
           dispatchCalls(tp1).toSet.intersect(dispatchCalls(tp2).toSet)
         case _ =>
@@ -330,7 +334,7 @@ class CallGraphBuilder(collectedSummaries: Map[Symbol, MethodSummary], mode: Int
               alt <- tp.tp.member(calleeSymbol.name).altsWith(p => p.asSeenFrom(tp.tp).matches(calleeSymbol.asSeenFrom(tp.tp)))
               if alt.exists
             } yield {
-              CallInfoWithContext(tp.tp.select(alt.symbol), targs, args, outerTargs ++ tp.outerTargs, someCaller, someCallee)
+              mkCallInfoWithContext(tp.tp.select(alt.symbol), targs, args, outerTargs ++ tp.outerTargs)
             }
           }
 
@@ -355,7 +359,7 @@ class CallGraphBuilder(collectedSummaries: Map[Symbol, MethodSummary], mode: Int
               (uncastedSig.paramTypess.flatten zip castedSig.paramTypess.flatten) foreach (x => addCast(x._2, x._1))
               addCast(uncastedSig.finalResultType, castedSig.finalResultType)
 
-              CallInfoWithContext(tp.tp.select(alt.symbol), targs, args, outerTargs ++ tp.outerTargs, someCaller, someCallee)
+              mkCallInfoWithContext(tp.tp.select(alt.symbol), targs, args, outerTargs ++ tp.outerTargs)
             }
           }
 
@@ -380,7 +384,7 @@ class CallGraphBuilder(collectedSummaries: Map[Symbol, MethodSummary], mode: Int
         Nil
       case NoPrefix =>  // inner method
         assert(calleeSymbol.is(ParamAccessor) || calleeSymbol.owner.is(Method) || calleeSymbol.owner.isLocalDummy)
-        CallInfoWithContext(TermRef.withFixedSym(caller.call.normalizedPrefix, calleeSymbol.name, calleeSymbol), targs, args, outerTargs, someCaller, someCallee) :: Nil
+        mkCallInfoWithContext(TermRef.withFixedSym(caller.call.normalizedPrefix, calleeSymbol.name, calleeSymbol), targs, args, outerTargs) :: Nil
 
       case t if calleeSymbol.isConstructor =>
 
@@ -418,7 +422,7 @@ class CallGraphBuilder(collectedSummaries: Map[Symbol, MethodSummary], mode: Int
             propagateTargs(receiver).select(calleeSymbol)
         }
 
-        CallInfoWithContext(call, targs, args, outerTargs, someCaller, someCallee) :: Nil
+        mkCallInfoWithContext(call, targs, args, outerTargs) :: Nil
 
       // super call in a class (know target precisely)
       case st: SuperType =>
@@ -430,7 +434,7 @@ class CallGraphBuilder(collectedSummaries: Map[Symbol, MethodSummary], mode: Int
         val thisTpePropagated = propagateTargs(thisTpe)
 
 
-        CallInfoWithContext(TermRef.withFixedSym(thisTpePropagated, targetMethod.name, targetMethod), targs, args, outerTargs, someCaller, someCallee) :: Nil
+        mkCallInfoWithContext(TermRef.withFixedSym(thisTpePropagated, targetMethod.name, targetMethod), targs, args, outerTargs) :: Nil
 
       // super call in a trait
       case t if calleeSymbol.is(SuperAccessor) =>
@@ -452,7 +456,7 @@ class CallGraphBuilder(collectedSummaries: Map[Symbol, MethodSummary], mode: Int
             if (s.nonEmpty) {
               val parentMethod = ResolveSuper.rebindSuper(x.tp.widenDealias.classSymbol, calleeSymbol).asTerm
               // todo: outerTargs are here defined in terms of location of the subclass. Is this correct?
-              CallInfoWithContext(TermRef.withFixedSym(t, parentMethod.name, parentMethod), targs, args, outerTargs, someCaller, someCallee) :: Nil
+              mkCallInfoWithContext(TermRef.withFixedSym(t, parentMethod.name, parentMethod), targs, args, outerTargs) :: Nil
 
             } else Nil
         }
@@ -461,14 +465,16 @@ class CallGraphBuilder(collectedSummaries: Map[Symbol, MethodSummary], mode: Int
         val dropUntil = thisType.tref.classSymbol
         var currentThis = caller.call.normalizedPrefix
         var currentOwner = caller.call.termSymbol.owner
-        while ((currentOwner ne dropUntil) && (currentThis ne NoType)) {
-          if (!currentOwner.is(Method))
-            currentThis = currentThis.normalizedPrefix
-          currentOwner = currentOwner.owner.enclosingClass
+        if (!dropUntil.is(Trait)) {
+          while ((currentOwner ne dropUntil) && (currentThis ne NoType)) {
+            if (!currentOwner.is(Method))
+              currentThis = currentThis.normalizedPrefix
+            currentOwner = currentOwner.owner.enclosingClass
+          }
         }
         if (currentThis.derivesFrom(thisType.cls)) {
           if (calleeSymbol.is(Private)) {
-            CallInfoWithContext(TermRef.withFixedSym(currentThis, calleeSymbol.name, calleeSymbol), targs, args, outerTargs, someCaller, someCallee) :: Nil
+            mkCallInfoWithContext(TermRef.withFixedSym(currentThis, calleeSymbol.name, calleeSymbol), targs, args, outerTargs) :: Nil
           } else {
             val fullThisType = AndType.apply(currentThis, thisType.tref)
             dispatchCalls(propagateTargs(fullThisType))
@@ -548,60 +554,69 @@ class CallGraphBuilder(collectedSummaries: Map[Symbol, MethodSummary], mode: Int
       if (defn.isPrimitiveClass(argType.classSymbol) || isJavaClass(argType.widenDealias.classSymbol)) {
         Set.empty
       } else {
-        def potentialCall(decl: Symbol) = {
-          def paramTypes = decl.info.paramTypess.flatten
-          val call = new TermRefWithFixedSym(argType, decl.name.asTermName, decl.asTerm)
-          val targs = call.widenDealias match {
-            case call: PolyType =>
-              def erasedBounds(tp: TypeBounds): Type = tp.hi match {
-                case RefinedType(parent, refinedName, refinedInfo: TypeBounds) =>
-                  RefinedType(parent, refinedName, erasedBounds(refinedInfo))
-                case t => t
-              }
-              call.paramBounds.map(erasedBounds)
+        def potentialCall(decl: Symbol): Option[CallInfo] = {
+          if (!decl.owner.is(JavaDefined) && decl.isTerm && !decl.isConstructor && decl.name != nme.COMPANION_MODULE_METHOD &&
+              decl.name != nme.isInstanceOf_ && decl.name != nme.asInstanceOf_ && decl.name != nme.synchronized_ && decl.name != nme.getClass_) {
+            None
+          } else {
+            def paramTypes = decl.info.paramTypess.flatten
 
-            case _ => Nil
-          }
+            val call = new TermRefWithFixedSym(argType, decl.name.asTermName, decl.asTerm)
+            val targs = call.widenDealias match {
+              case call: PolyType =>
+                def erasedBounds(tp: TypeBounds): Type = tp.hi match {
+                  case RefinedType(parent, refinedName, refinedInfo: TypeBounds) =>
+                    RefinedType(parent, refinedName, erasedBounds(refinedInfo))
+                  case t => t
+                }
 
-          def isDefinedInJavaClass(sym: Symbol) =
-            sym.owner == defn.AnyClass || sym.owner.is(JavaDefined)
+                call.paramBounds.map(erasedBounds)
 
-          val definedInJavaClass: Boolean =
-            isDefinedInJavaClass(decl) || decl.allOverriddenSymbols.exists(isDefinedInJavaClass)
+              case _ => Nil
+            }
 
-          argType match {
-            case argType: PreciseType =>
-              if (!definedInJavaClass) Nil
-              else List(CallInfo(call, targs, paramTypes))
+            def isDefinedInJavaClass(sym: Symbol) =
+              sym.owner == defn.AnyClass || sym.owner.is(JavaDefined)
 
-            case _ =>
-              val argTypeWiden = argType.widenDealias
-              lazy val sym = argTypeWiden.classSymbol.requiredMethod(decl.name, paramTypes)
-              if (!argTypeWiden.member(decl.name).exists || !definedInJavaClass || (sym.isEffectivelyFinal && isDefinedInJavaClass(decl))) Nil
-              else List(CallInfo(TermRef(argType, sym), targs, paramTypes))
+            val definedInJavaClass: Boolean =
+              isDefinedInJavaClass(decl) || decl.allOverriddenSymbols.exists(isDefinedInJavaClass)
 
+            argType match {
+              case argType: PreciseType =>
+                if (!definedInJavaClass) None
+                else Some(CallInfo(call, targs, paramTypes))
+
+              case _ =>
+                val argTypeWiden = argType.widenDealias
+                lazy val sym = argTypeWiden.classSymbol.requiredMethod(decl.name, paramTypes)
+                if (!argTypeWiden.member(decl.name).exists || !definedInJavaClass || (sym.isEffectivelyFinal && isDefinedInJavaClass(decl))) None
+                else Some(CallInfo(TermRef(argType, sym), targs, paramTypes))
+
+            }
           }
         }
 
-        for {
-          decl <- allDecls(argType)
-          if decl.isTerm && !decl.isConstructor && decl.name != nme.COMPANION_MODULE_METHOD
-          if decl.name != nme.isInstanceOf_ && decl.name != nme.asInstanceOf_ && decl.name != nme.synchronized_
-          callInfo <- potentialCall(decl)
-        } yield callInfo
+        allDecls(argType).flatMap(potentialCall)
       }
     }
 
-    // FIXME java method could potentially call this.xyz()
-    // addAllPotentialCallsFor(method.call.normalizedPrefix)
+    def filterParams(params: List[Type]) = {
+      val parents = method.parents
+      params.distinct.filter(param => !parents.exists(_.call.normalizedPrefix == param))
+    }
+
+    val collapsedMethod =
+      if (method.isErased) method.parent.get else method
+
     for {
-      rec <- method.argumentsPassed.distinct
+      rec <- filterParams(method.call.normalizedPrefix :: method.argumentsPassed.distinct)
+      if !collapsedMethod.addAndHasErasedType(rec.widenDealias)
       potentialCall <- allPotentialCallsFor(rec)
-      if method.getOutEdges(potentialCall).isEmpty
+      if collapsedMethod.getOutEdges(potentialCall).isEmpty
     } {
-      val nw = instantiateCallSite(method, rec, potentialCall, instantiatedTypes)
+      val nw = instantiateCallSite(collapsedMethod, rec, potentialCall, instantiatedTypes, isErased = true)
       reachableMethods ++= nw
-      method.addOutEdges(potentialCall, nw)
+      collapsedMethod.addOutEdges(potentialCall, nw)
     }
   }
 

compiler/src/dotty/tools/dotc/transform/linker/callgraph/CallInfoWithContext.scala

@@ -7,10 +7,14 @@ import dotty.tools.dotc.transform.linker.summaries.{AbstractCallInfo, CallInfo}
 import scala.collection.mutable
 
 case class CallInfoWithContext(call: Type, targs: List[Type], argumentsPassed: List[Type], outerTargs: OuterTargs,
-    parent: Option[CallInfoWithContext], callee: Option[CallInfo])(implicit ctx: Context) extends AbstractCallInfo {
+    parent: Option[CallInfoWithContext], callee: Option[CallInfo], isErased: Boolean)(implicit ctx: Context) extends AbstractCallInfo {
+
+  assert(!isErased || parent.nonEmpty)
 
   private val outEdges = mutable.HashMap[CallInfo, List[CallInfoWithContext]]().withDefault(x => Nil)
 
+  private val erasedTypes = mutable.HashSet.empty[Type]
+
   def outEdgesIterator: Iterator[(CallInfo, List[CallInfoWithContext])] = outEdges.iterator
 
   def getOutEdges(callSite: CallInfo): List[CallInfoWithContext] = outEdges(callSite)
@@ -27,6 +31,15 @@ case class CallInfoWithContext(call: Type, targs: List[Type], argumentsPassed: L
   def edgeCount: Int =
     outEdges.values.foldLeft(0)(_ + _.size)
 
+  def addAndHasErasedType(tp: Type): Boolean = {
+    val res = erasedTypes.contains(tp)
+    if (!res)
+      erasedTypes += tp
+    res
+  }
+
   def source: Option[CallInfo] = callee.flatMap(_.source)
 
+  def parents: List[CallInfoWithContext] =
+    parent.fold(List.empty[CallInfoWithContext])(p => p :: p.parents)
 }

tests/link-dce-stdlib-fail-run/stdlib-link-predef-println-1/MainGenericRunner.java renamed to tests/link-dce-stdlib-fail-run/stdlib-link-array-mkString/MainGenericRunner.java

@@ -2,7 +2,7 @@ import scala.annotation.internal
 import scala.math.Ordering
 
 object Test {
-  @internal.link.CallGraphBounds(reachableClasses = 152, classesWithReachableMethods = 21, reachableMethods = 90)
+  @internal.link.CallGraphBounds(reachableClasses = 154, classesWithReachableMethods = 24, reachableMethods = 93)
   def main(args: Array[String]): Unit = {
     val arr = new Array[Object](1)
     arr(0) = 42

tests/link-dce-stdlib/stdlib-link-array-mkString/Test.scala renamed to tests/link-dce-stdlib-fail-run/stdlib-link-array-mkString/Test.scala

@@ -0,0 +1,14 @@
+import scala.annotation.internal
+
+object Test {
+  @internal.link.CallGraphBounds(reachableClasses = 22, classesWithReachableMethods = 6, reachableMethods = 21)
+  def main(args: Array[String]): Unit = {
+    new BreakControl
+  }
+}
+
+class BreakControl extends NoStackTrace
+
+trait NoStackTrace extends Throwable {
+  override def fillInStackTrace(): Throwable = super.fillInStackTrace()
+}