Make positions fit for meta

In particular:

 - get rid of envelope, it's too complicated and hides too many errors
 - check that everywhere in parsed trees the position range of a parent
   node contains the position ranges of its children.
 - check that all non-empty trees coming from parser have positions.

The commit contains lots of fixes to make these checks pass.
In particular, it changes the scheme how definitions are positioned.
Previously the position of a definition was the token range of the
name defined by it. That does obviously not work with the parent/children
invariant. Now, the position is the whole definition range, with the
point at the defined name (care is taken to not count backticks).
Namer is changed to still use the token range of defined name as the
position of the symbol.

1 files changed, 18 insertions, 14 deletions

diff --git a/src/dotty/tools/dotc/ast/Desugar.scala b/src/dotty/tools/dotc/ast/Desugar.scala
index 7011d13a0..36cae6378 100644
--- a/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/src/dotty/tools/dotc/ast/Desugar.scala
@@ -505,7 +505,7 @@ object desugar {
       val clsTmpl = cpy.Template(tmpl)(self = clsSelf, body = tmpl.body)
       val cls = TypeDef(clsName, clsTmpl)
         .withMods(mods.toTypeFlags & RetainedModuleClassFlags | ModuleClassCreationFlags)
-      Thicket(modul, classDef(cls))
+      Thicket(modul, classDef(cls).withPos(mdef.pos))
     }
   }
 
@@ -516,7 +516,7 @@ object desugar {
   def patDef(pdef: PatDef)(implicit ctx: Context): Tree = {
     val PatDef(mods, pats, tpt, rhs) = pdef
     val pats1 = if (tpt.isEmpty) pats else pats map (Typed(_, tpt))
-    flatTree(pats1 map (makePatDef(mods, _, rhs)))
+    flatTree(pats1 map (makePatDef(pdef, mods, _, rhs)))
   }
 
   /** If `pat` is a variable pattern,
@@ -534,9 +534,9 @@ object desugar {
    *  If the original pattern variable carries a type annotation, so does the corresponding
    *  ValDef or DefDef.
    */
-  def makePatDef(mods: Modifiers, pat: Tree, rhs: Tree)(implicit ctx: Context): Tree = pat match {
+  def makePatDef(original: Tree, mods: Modifiers, pat: Tree, rhs: Tree)(implicit ctx: Context): Tree = pat match {
     case VarPattern(named, tpt) =>
-      derivedValDef(named, tpt, rhs, mods)
+      derivedValDef(original, named, tpt, rhs, mods)
     case _ =>
       val rhsUnchecked = makeAnnotated(defn.UncheckedAnnot, rhs)
       val vars = getVariables(pat)
@@ -553,7 +553,7 @@ object desugar {
         case Nil =>
           matchExpr
         case (named, tpt) :: Nil =>
-          derivedValDef(named, tpt, matchExpr, mods)
+          derivedValDef(original, named, tpt, matchExpr, mods)
         case _ =>
           val tmpName = ctx.freshName().toTermName
           val patMods = mods & (AccessFlags | Lazy) | Synthetic
@@ -564,8 +564,8 @@ object desugar {
           val restDefs =
             for (((named, tpt), n) <- vars.zipWithIndex)
             yield
-              if (mods is Lazy) derivedDefDef(named, tpt, selector(n), mods &~ Lazy)
-              else derivedValDef(named, tpt, selector(n), mods)
+              if (mods is Lazy) derivedDefDef(original, named, tpt, selector(n), mods &~ Lazy)
+              else derivedValDef(original, named, tpt, selector(n), mods)
           flatTree(firstDef :: restDefs)
       }
   }
@@ -663,14 +663,18 @@ object desugar {
   def makeAnnotated(cls: Symbol, tree: Tree)(implicit ctx: Context) =
     Annotated(untpd.New(untpd.TypeTree(cls.typeRef), Nil), tree)
 
-  private def derivedValDef(named: NameTree, tpt: Tree, rhs: Tree, mods: Modifiers)(implicit ctx: Context) = {
-    val vdef = ValDef(named.name.asTermName, tpt, rhs).withMods(mods).withPos(named.pos)
+  private def derivedValDef(original: Tree, named: NameTree, tpt: Tree, rhs: Tree, mods: Modifiers)(implicit ctx: Context) = {
+    val vdef = ValDef(named.name.asTermName, tpt, rhs)
+      .withMods(mods)
+      .withPos(original.pos.withPoint(named.pos.start))
     val mayNeedSetter = valDef(vdef)
     mayNeedSetter
    }
 
-  private def derivedDefDef(named: NameTree, tpt: Tree, rhs: Tree, mods: Modifiers) =
-    DefDef(named.name.asTermName, Nil, Nil, tpt, rhs).withMods(mods).withPos(named.pos)
+  private def derivedDefDef(original: Tree, named: NameTree, tpt: Tree, rhs: Tree, mods: Modifiers) =
+    DefDef(named.name.asTermName, Nil, Nil, tpt, rhs)
+      .withMods(mods)
+      .withPos(original.pos.withPoint(named.pos.start))
 
   /** Main desugaring method */
   def apply(tree: Tree)(implicit ctx: Context): Tree = {
@@ -760,7 +764,7 @@ object desugar {
        */
       def makeLambda(pat: Tree, body: Tree): Tree = pat match {
         case VarPattern(named, tpt) =>
-          Function(derivedValDef(named, tpt, EmptyTree, Modifiers(Param)) :: Nil, body)
+          Function(derivedValDef(pat, named, tpt, EmptyTree, Modifiers(Param)) :: Nil, body)
         case _ =>
           makeCaseLambda(CaseDef(pat, EmptyTree, body) :: Nil, unchecked = false)
       }
@@ -863,7 +867,7 @@ object desugar {
           val rhss = valeqs map { case GenAlias(_, rhs) => rhs }
           val (defpat0, id0) = makeIdPat(pat)
           val (defpats, ids) = (pats map makeIdPat).unzip
-          val pdefs = (defpats, rhss).zipped map (makePatDef(Modifiers(), _, _))
+          val pdefs = (valeqs, defpats, rhss).zipped.map(makePatDef(_, Modifiers(), _, _))
           val rhs1 = makeFor(nme.map, nme.flatMap, GenFrom(defpat0, rhs) :: Nil, Block(pdefs, makeTuple(id0 :: ids)))
           val allpats = pat :: pats
           val vfrom1 = new IrrefutableGenFrom(makeTuple(allpats), rhs1)
@@ -946,7 +950,7 @@ object desugar {
         makeFor(nme.map, nme.flatMap, enums, body) orElse tree
       case PatDef(mods, pats, tpt, rhs) =>
         val pats1 = if (tpt.isEmpty) pats else pats map (Typed(_, tpt))
-        flatTree(pats1 map (makePatDef(mods, _, rhs)))
+        flatTree(pats1 map (makePatDef(tree, mods, _, rhs)))
       case ParsedTry(body, handler, finalizer) =>
         handler match {
           case Match(EmptyTree, cases) => Try(body, cases, finalizer)