Add missing scala doc

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -391,12 +391,11 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    *  @DarkDimius: need to make sure that lazy accessor methods have Lazy and Stable
    *               flags set.
    */
-  private def refPurity(tree: Tree)(implicit ctx: Context): PurityLevel = {
-    if (tree.symbol.is(Unused) || !tree.tpe.widen.isParameterless) Pure
+  private def refPurity(tree: Tree)(implicit ctx: Context): PurityLevel =
+    if (!tree.tpe.widen.isParameterless || tree.symbol.is(Unused)) Pure
     else if (!tree.symbol.isStable) Impure
     else if (tree.symbol.is(Lazy)) Idempotent // TODO add Module flag, sinxce Module vals or not Lazy from the start.
     else Pure
-  }
 
   def isPureRef(tree: Tree)(implicit ctx: Context) =
     refPurity(tree) == Pure

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -837,6 +837,8 @@ class Definitions {
    *    - FunctionN for 22 > N >= 0 remains as FunctionN
    *    - ImplicitFunctionN for N > 22 becomes FunctionXXL
    *    - ImplicitFunctionN for 22 > N >= 0 becomes FunctionN
+   *    - UnusedFunctionN becomes Function0
+   *    - ImplicitUnusedFunctionN becomes Function0
    *    - anything else becomes a NoSymbol
    */
   def erasedFunctionClass(cls: Symbol): Symbol = {
@@ -852,6 +854,8 @@ class Definitions {
    *    - FunctionN for 22 > N >= 0 remains as FunctionN
    *    - ImplicitFunctionN for N > 22 becomes FunctionXXL
    *    - ImplicitFunctionN for 22 > N >= 0 becomes FunctionN
+   *    - UnusedFunctionN becomes Function0
+   *    - ImplicitUnusedFunctionN becomes Function0
    *    - anything else becomes a NoType
    */
   def erasedFunctionType(cls: Symbol): Type = {

compiler/src/dotty/tools/dotc/core/NameOps.scala

@@ -180,19 +180,27 @@ object NameOps {
     /** Is a function name
      *    - FunctionN for N >= 0
      *    - ImplicitFunctionN for N >= 1
+     *    - UnusedFunctionN for N >= 1
+     *    - UnusedImplicitFunctionN for N >= 1
      *    - false otherwise
      */
     def isFunction: Boolean = functionArity >= 0
 
     /** Is a implicit function name
      *    - ImplicitFunctionN for N >= 1
+     *    - UnusedImplicitFunctionN for N >= 1
      *    - false otherwise
      */
     def isImplicitFunction: Boolean = {
       functionArityFor(str.ImplicitFunction) >= 1 ||
       functionArityFor(str.UnusedImplicitFunction) >= 1
     }
 
+    /** Is a implicit function name
+      *    - UnusedFunctionN for N >= 1
+      *    - UnusedImplicitFunctionN for N >= 1
+      *    - false otherwise
+      */
     def isUnusedFunction: Boolean = {
       functionArityFor(str.UnusedFunction) >= 1 ||
       functionArityFor(str.UnusedImplicitFunction) >= 1
@@ -201,6 +209,8 @@ object NameOps {
     /** Is a synthetic function name
      *    - FunctionN for N > 22
      *    - ImplicitFunctionN for N >= 1
+     *    - UnusedFunctionN for N >= 1
+     *    - UnusedImplicitFunctionN for N >= 1
      *    - false otherwise
      */
     def isSyntheticFunction: Boolean = {

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -2502,7 +2502,7 @@ object Parsers {
           stats ++= importClause()
         else if (isExprIntro)
           stats += expr(Location.InBlock)
-        else if (isDefIntro(localModifierTokens)) {
+        else if (isDefIntro(localModifierTokens))
           if (in.token == IMPLICIT || in.token == UNUSED) {
             val start = in.offset
             var imods = EmptyModifiers
@@ -2513,7 +2513,7 @@ object Parsers {
           } else {
             stats +++= localDef(in.offset)
           }
-        } else if (!isStatSep && (in.token != CASE)) {
+        else if (!isStatSep && (in.token != CASE)) {
           exitOnError = mustStartStat
           val addendum = if (isModifier) " (no modifiers allowed here)" else ""
           syntaxErrorOrIncomplete("illegal start of statement" + addendum)

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -666,7 +666,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     else if (sym.isClass && flags.is(Case)) "case class"
     else if (flags is Module) "object"
     else if (sym.isTerm && !flags.is(Param) && flags.is(Implicit)) "implicit val"
-    else if (sym.isTerm && !flags.is(Param) && sym.is(Unused)) "unused val"
+    else if (sym.isTerm && !flags.is(Param) && flags.is(Unused)) "unused val"
     else super.keyString(sym)
   }
 

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -1710,14 +1710,14 @@ object messages {
 
   case class FunctionTypeNeedsNonEmptyParameterList(isImplicit: Boolean = true, isUnused: Boolean = true)(implicit ctx: Context)
     extends Message(FunctionTypeNeedsNonEmptyParameterListID) {
-    // TODO use isImplicit and isUnused
     val kind = "Syntax"
-    val msg = "implicit function type needs non-empty parameter list"
+    val mods = ((isImplicit, "implicit") :: (isUnused, "unused") :: Nil).filter(_._1).mkString(" ")
+    val msg = mods + " function type needs non-empty parameter list"
     val explanation = {
-      val code1 = "type Transactional[T] = implicit Transaction => T"
+      val code1 = s"type Transactional[T] = $mods Transaction => T"
       val code2 = "val cl: implicit A => B"
-      hl"""It is not allowed to leave implicit function parameter list empty.
-         |Possible ways to define implicit function type:
+      hl"""It is not allowed to leave $mods function parameter list empty.
+         |Possible ways to define $mods function type:
          |
          |$code1
          |

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

@@ -8,8 +8,13 @@ import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo}
 
-// TODO
-/** THis phase ...
+/** This phase checks that unused `def`s, `val`s and parameters are only used in valid place.
+ *  It also checks that the `unused` keyword is only used on `def`, `val` and parameters lists
+ *
+ *  Unused values can be used:
+ *    - As parameters to an unused function
+ *    - In statement position
+ *    - Anywhere in the RHS of an `unused def` or `unused val`
  */
 class UnusedChecks extends MiniPhaseTransform {
   import tpd._
@@ -61,11 +66,13 @@ class UnusedChecks extends MiniPhaseTransform {
 
   /* private methods */
 
+  /** Check that unused values are not of type Nothing */
   private def checkUnusedNothing(tree: Tree)(implicit ctx: Context): Unit = {
     if (tree.symbol.is(Unused) && tree.tpe.widen.finalResultType.isBottomType)
       ctx.error("unused " + tree.symbol.showKind + " cannot have type Nothing", tree.pos)
   }
 
+  /** Check that the expression is not a reference to an unused value */
   private def checkedValOrDefDefRHS(tree: ValOrDefDef)(implicit ctx: Context): tree.type =
     if (tree.symbol.is(Unused)) tree
     else checked(tree)(tree.rhs, "Cannot return `unused` value in a def without `unused`")
@@ -90,6 +97,6 @@ class UnusedChecks extends MiniPhaseTransform {
     tree0
   }
 
-  def isUnusedContext(implicit ctx: Context): Boolean =
+  private def isUnusedContext(implicit ctx: Context): Boolean =
     ctx.owner.ownersIterator.exists(_.is(Unused)) // TODO make context mode?
 }

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

@@ -51,5 +51,4 @@ class UnusedDecls extends MiniPhaseTransform with InfoTransformer {
       else tp.derivedClassInfo(decls = tp.decls.filteredScope(!_.is(Unused)))
     case _ => tp
   }
-
 }

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

@@ -4,12 +4,8 @@ import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.DenotTransformers.InfoTransformer
-import dotty.tools.dotc.core.Designators._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Types._
-import dotty.tools.dotc.core.Names._
-import dotty.tools.dotc.core.NameOps._
-import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo}

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

@@ -17,6 +17,7 @@ import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, Transforme
  *
  *   if   `unused val x: T = ...` including parameters
  *   then `x` --> `(default value for T)`
+ *        `x.Y`  -->  `T#Y`
  */
 class UnusedRefs extends MiniPhaseTransform with InfoTransformer {
   import tpd._
@@ -48,17 +49,17 @@ class UnusedRefs extends MiniPhaseTransform with InfoTransformer {
 
   /* Tree transform */
 
-  override def transformApply(tree: tpd.Apply)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = transformUnused(tree)
-  override def transformIdent(tree: tpd.Ident)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = transformUnused(tree)
-  override def transformSelect(tree: tpd.Select)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = transformUnused(tree)
+  override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree = transformUnused(tree)
+  override def transformIdent(tree: Ident)(implicit ctx: Context, info: TransformerInfo): Tree = transformUnused(tree)
+  override def transformSelect(tree: Select)(implicit ctx: Context, info: TransformerInfo): Tree = transformUnused(tree)
 
-  private def transformUnused(tree: tpd.Tree)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
+  private def transformUnused(tree: Tree)(implicit ctx: Context, info: TransformerInfo): Tree = {
     if (!tree.symbol.is(Unused)) tree
     else {
       tree.tpe.widen match {
         case _: MethodType => tree // Do the transformation higher in the tree if needed
         case _ =>
-          val result = tpd.defaultValue(tree.tpe) match {
+          val result = defaultValue(tree.tpe) match {
             case t @ TypeApply(fun, args) => cpy.TypeApply(t)(fun = fun, args = args.map(transform)) // asInstanceOf inserted by defaultValue
             case t => t
           }
@@ -70,7 +71,7 @@ class UnusedRefs extends MiniPhaseTransform with InfoTransformer {
     }
   }
 
-  override def transformTypeTree(tree: tpd.TypeTree)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
+  override def transformTypeTree(tree: TypeTree)(implicit ctx: Context, info: TransformerInfo): Tree = {
     val newType = removeUnusedPaths(tree.tpe)
     if (tree.tpe == newType) tree
     else TypeTree(newType)
@@ -79,8 +80,7 @@ class UnusedRefs extends MiniPhaseTransform with InfoTransformer {
 
   /* Tree info */
 
-  override def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type =
-    removeUnusedPaths(tp)
+  override def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = removeUnusedPaths(tp)
 
   private def removeUnusedPaths(tp: Type)(implicit ctx: Context): Type = {
     // TODO: handle variance