Two more tweaks to make pickling invariant under printing

1) DefDefs with implicit method types generate implicit parameters
2) Super accessors are inserted after class parameters.

With these changes files in core also print the same after pickling,
with the exception of Types and TypeOps which have some spurious differences:
Types are equal but appear in more simplified form after pickling.

Author: odersky

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

@@ -186,8 +186,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     def valueParamss(tp: Type): (List[List[TermSymbol]], Type) = tp match {
       case tp @ MethodType(paramNames, paramTypes) =>
-        def valueParam(name: TermName, info: Type): TermSymbol =
-          ctx.newSymbol(sym, name, TermParam, info)
+        def valueParam(name: TermName, info: Type): TermSymbol = {
+          val maybeImplicit = if (tp.isInstanceOf[ImplicitMethodType]) Implicit else EmptyFlags
+          ctx.newSymbol(sym, name, TermParam | maybeImplicit, info)
+        }
         val params = (paramNames, paramTypes).zipped.map(valueParam)
         val (paramss, rtp) = valueParamss(tp.instantiate(params map (_.termRef)))
         (params :: paramss, rtp)

src/dotty/tools/dotc/transform/SuperAccessors.scala

@@ -76,6 +76,7 @@ class SuperAccessors extends MacroTransform with IdentityDenotTransformer { this
       buf += tree
     }
 
+    /** Turn types which are not methodic into ExprTypes. */
     private def ensureMethodic(tpe: Type)(implicit ctx: Context) = tpe match {
       case tpe: MethodicType => tpe
       case _ => ExprType(tpe)
@@ -293,9 +294,17 @@ class SuperAccessors extends MacroTransform with IdentityDenotTransformer { this
           def transformTemplate = {
             val ownStats = new ListBuffer[Tree]
             accDefs(currentClass) = ownStats
-            val body1 = forwardParamAccessors(transformStats(impl.body, tree.symbol))
+            // write super accessors after parameters and type aliases (so
+            // that order is stable under pickling/unpickling)
+            val (params, rest) = impl.body span {
+              case td: TypeDef => !td.isClassDef
+              case vd: ValOrDefDef => vd.symbol.flags is ParamAccessor
+              case _ => false
+            }
+            ownStats ++= params
+            val rest1 = forwardParamAccessors(transformStats(rest, tree.symbol))
             accDefs -= currentClass
-            ownStats ++= body1
+            ownStats ++= rest1
             cpy.Template(impl)(body = ownStats.toList)
           }
           transformTemplate

src/dotty/tools/dotc/typer/Namer.scala

@@ -476,7 +476,7 @@ class Namer { typer: Typer =>
 
     val (params, rest) = impl.body span {
       case td: TypeDef => td.mods is Param
-      case td: ValDef => td.mods is ParamAccessor
+      case vd: ValDef => vd.mods is ParamAccessor
       case _ => false
     }
 

test/dotc/tests.scala

@@ -37,6 +37,7 @@ class tests extends CompilerTest {
 
   @Test def pickle_pickleOK = compileDir(posDir + "pickleOK/", testPickling)
   @Test def pickle_pickling = compileDir(dotcDir + "tools/dotc/core/pickling/", testPickling)
+  @Test def pickle_core = compileDir(dotcDir + "tools/dotc/core/pickling/", testPickling, xerrors = 2) // two spurious comparison errors in Types and TypeOps
 
   @Test def pos_t2168_pat = compileFile(posDir, "t2168")
   @Test def pos_erasure = compileFile(posDir, "erasure")