Use defTrees in ExpandPrivate where possible

* In the inliner set defTrees for newly created inlined symbols.
* In ensurePrivateAccessible take sources from defTrees where possible.

Author: milessabin

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

@@ -12,7 +12,7 @@ import Decorators._
 import ast.Trees._
 import MegaPhase._
 import java.io.File.separatorChar
-import util.SourceFile
+import util.{ NoSource, SourceFile }
 
 import ValueClasses._
 
@@ -85,13 +85,29 @@ class ExpandPrivate extends MiniPhase with IdentityDenotTransformer { thisPhase
         (j < 0 || p1(j) == separatorChar)
       }
 
-      lazy val dPath = d.symbol.source.path
+      def findSource(sym: Symbol): SourceFile = {
+        def valid(src: SourceFile): Boolean = src.exists && src.file.extension != "class"
+
+        if(sym eq NoSymbol) NoSource
+        else {
+          val dTree = sym.defTree
+          if(valid(dTree.source)) dTree.source
+          else {
+            val oSrc = findSource(sym.owner)
+            if(oSrc.exists) oSrc
+            else if(valid(sym.source))
+              sym.source
+            else NoSource
+          }
+        }
+      }
+
+      val dSrc = findSource(d.symbol)
+      val cSrc = findSource(ctx.owner)
 
-      def check(src: SourceFile): Boolean =
-        src.exists && isSimilar(dPath, src.path)
+      assert(dSrc.exists && cSrc.exists && isSimilar(dSrc.path, cSrc.path),
+          s"private ${d.symbol.showLocated} in ${dSrc} accessed from ${ctx.owner.showLocated} in ${cSrc}")
 
-      assert(d.symbol.source.exists && (check(ctx.owner.source) || check(ctx.compilationUnit.source)),
-          s"private ${d.symbol.showLocated} in ${d.symbol.source} accessed from ${ctx.owner.showLocated} in ${ctx.owner.source}")
       d.ensureNotPrivate.installAfter(thisPhase)
     }
 

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

@@ -165,6 +165,7 @@ object Inliner {
           case tree: SeqLiteral => finalize(tree, untpd.SeqLiteral(transform(tree.elems), transform(tree.elemtpt))(curSource))
           case tree: TypeTree => tpd.TypeTree(tree.tpe)(ctx.withSource(curSource)).withSpan(tree.span)
           case tree: Bind => finalize(tree, untpd.Bind(tree.name, transform(tree.body))(curSource))
+          case tree: DefTree => super.transform(tree).setDefTree
           case _ => super.transform(tree)
         })
         assert(transformed.isInstanceOf[EmptyTree[_]] || transformed.isInstanceOf[EmptyValDef[_]] || transformed.source == curSource)