Print vars, protected and private

Author: nicolasstucki

library/src/scala/tasty/util/ShowSourceCode.scala

@@ -190,6 +190,8 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
         if (flags.isImplicit) this += "implicit "
         if (flags.isOverride) this += "override "
 
+        printProtectedOrPrivate(vdef)
+
         if (flags.isLazy) this += "lazy "
         if (vdef.flags.isMutable) this += "var "
         else this += "val "
@@ -220,12 +222,14 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
       case ddef @ DefDef(name, targs, argss, tpt, rhs) =>
         printDefAnnotations(ddef)
 
+        val isConstructor = name == "<init>"
+
         val flags = ddef.flags
         if (flags.isImplicit) this += "implicit "
         if (flags.isInline) this += "inline "
         if (flags.isOverride) this += "override "
 
-        val isConstructor = name == "<init>"
+        printProtectedOrPrivate(ddef)
 
         this += "def " += (if (isConstructor) "this" else name)
         printTargsDefs(targs)
@@ -595,9 +599,9 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
 
       def printSeparated(list: List[ValDef]): Unit = list match {
         case Nil =>
-        case x :: Nil => printArgDef(x)
+        case x :: Nil => printParamDef(x)
         case x :: xs =>
-          printArgDef(x)
+          printParamDef(x)
           this += ", "
           printSeparated(xs)
       }
@@ -619,15 +623,24 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
       this
     }
 
-    def printArgDef(arg: ValDef): Unit = {
+    def printParamDef(arg: ValDef): Unit = {
       val ValDef(name, tpt, rhs) = arg
       arg.owner match {
         case DefDef("<init>", _, _, _, _) =>
           val ClassDef(_, _, _, _, body) = arg.owner.owner
           body.collectFirst {
             case vdef @ ValDef(`name`, _, _) if vdef.flags.isParamAccessor =>
-              if (!vdef.flags.isLocal && !vdef.flags.isCaseAcessor)
-                this += "val " // TODO `var`s
+              if (!vdef.flags.isLocal) {
+                var printedPrefix = false
+                if (vdef.flags.isOverride) {
+                  this += "override "
+                  printedPrefix = true
+                }
+                printedPrefix  |= printProtectedOrPrivate(vdef)
+                if (vdef.flags.isMutable) this += "var "
+                else if (!printedPrefix && vdef.flags.isCaseAcessor) this // val not explicitly needed
+                else this += "val "
+              }
           }
         case _ =>
       }
@@ -896,15 +909,8 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
 
       case Type.ThisType(tp) =>
         tp match {
-          case Type.SymRef(cdef @ ClassDef(name, _, _, _, _), prefix) if !cdef.flags.isObject =>
-            def printPrefix(prefix: TypeOrBounds): Unit = prefix match {
-              case Type.SymRef(ClassDef(name, _, _, _, _), prefix2) =>
-                printPrefix(prefix2)
-                this += name += "."
-              case _ =>
-            }
-            printPrefix(prefix)
-            this += name
+          case Type.SymRef(cdef @ ClassDef(_, _, _, _, _), _) if !cdef.flags.isObject =>
+            printFullClassName(tp)
             this += ".this"
           case _ => printType(tp)
         }
@@ -1053,6 +1059,48 @@ class ShowSourceCode[T <: Tasty with Singleton](tasty0: T) extends Show[T](tasty
       printType(hi)
     }
 
+    def printProtectedOrPrivate(definition: Definition): Boolean = {
+      var printedPrefix = false
+      def printWithin(within: Type) = within match {
+        case Type.SymRef(PackageDef(name, _), _) => this += name
+        case _ => printFullClassName(within)
+      }
+      if (definition.flags.isProtected) {
+        this += "protected"
+        definition.protectedWithin match {
+          case Some(within) =>
+            this += "["
+            printWithin(within)
+            this += "] "
+          case _ =>
+            this += " "
+        }
+        printedPrefix = true
+      } else {
+        definition.privateWithin match {
+          case Some(within) =>
+            this += "private["
+            printWithin(within)
+            this += "] "
+            printedPrefix = true
+          case _ =>
+        }
+      }
+      printedPrefix
+    }
+
+    def printFullClassName(tp: TypeOrBounds): Unit = {
+      def printClassPrefix(prefix: TypeOrBounds): Unit = prefix match {
+        case Type.SymRef(ClassDef(name, _, _, _, _), prefix2) =>
+          printClassPrefix(prefix2)
+          this += name += "."
+        case _ =>
+      }
+      val Type.SymRef(ClassDef(name, _, _, _, _), prefix) = tp
+      printClassPrefix(prefix)
+      this += name
+    }
+
     def +=(x: Boolean): this.type = { sb.append(x); this }
     def +=(x: Byte): this.type = { sb.append(x); this }
     def +=(x: Short): this.type = { sb.append(x); this }

tests/pos/simpleConstructor.decompiled

@@ -0,0 +1,4 @@
+/** Decompiled from out/posTestFromTasty/pos/simpleConstructor/A.class */
+class A(a: scala.Int, val b: scala.Int, var c: scala.Int)
+/** Decompiled from out/posTestFromTasty/pos/simpleConstructor/B.class */
+class B(protected val x: scala.Int, protected[B] val y: scala.Int, private[B] val z: scala.Int)

tests/pos/simpleConstructor.scala

@@ -0,0 +1,4 @@
+
+class A(a: Int, val b: Int, var c: Int)
+
+class B(protected val x: Int, protected[B] val y: Int, private[B] val z: Int)