Reformat scaladoc in SyntheticMethods

Author: OlivierBlanvillain

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

@@ -17,6 +17,7 @@ import scala.language.postfixOps
 
 /** Synthetic method implementations for case classes, case objects,
  *  and value classes.
+ *
  *  Selectively added to case classes/objects, unless a non-default
  *  implementation already exists:
  *    def equals(other: Any): Boolean
@@ -26,12 +27,12 @@ import scala.language.postfixOps
  *    def productElement(i: Int): Any
  *    def productArity: Int
  *    def productPrefix: String
+ *
  *  Special handling:
  *    protected def readResolve(): AnyRef
  *
  *  Selectively added to value classes, unless a non-default
  *  implementation already exists:
- *
  *    def equals(other: Any): Boolean
  *    def hashCode(): Int
  */
@@ -51,8 +52,7 @@ class SyntheticMethods(thisTransformer: DenotTransformer) {
   def valueSymbols(implicit ctx: Context) = { initSymbols; myValueSymbols }
   def caseSymbols(implicit ctx: Context) = { initSymbols; myCaseSymbols }
 
-  /** The synthetic methods of the case or value class `clazz`.
-   */
+  /** The synthetic methods of the case or value class `clazz`. */
   def syntheticMethods(clazz: ClassSymbol)(implicit ctx: Context): List[Tree] = {
     val clazzType = clazz.typeRef
     lazy val accessors =
@@ -135,18 +135,22 @@ class SyntheticMethods(thisTransformer: DenotTransformer) {
 
     /** The class
      *
-     *      case class C(x: T, y: U)
+     *  ```
+     *  case class C(x: T, y: U)
+     *  ```
      *
-     *  gets the equals method:
+     *  gets the `equals` method:
      *
-     *      def equals(that: Any): Boolean =
-     *        (this eq that) || {
-     *          that match {
-     *            case x$0 @ (_: C) => this.x == this$0.x && this.y == x$0.y
-     *            case _ => false
-     *         }
+     *  ```
+     *  def equals(that: Any): Boolean =
+     *    (this eq that) || {
+     *      that match {
+     *        case x$0 @ (_: C) => this.x == this$0.x && this.y == x$0.y
+     *        case _ => false
+     *     }
+     *  ```
      *
-     *  If C is a value class the initial `eq` test is omitted.
+     *  If `C` is a value class the initial `eq` test is omitted.
      */
     def equalsBody(that: Tree)(implicit ctx: Context): Tree = {
       val thatAsClazz = ctx.newSymbol(ctx.owner, nme.x_0, Synthetic, clazzType, coord = ctx.owner.pos) // x$0
@@ -168,11 +172,15 @@ class SyntheticMethods(thisTransformer: DenotTransformer) {
 
     /** The class
      *
+     *  ```
      *  class C(x: T) extends AnyVal
+     *  ```
      *
-     *  gets the hashCode method:
+     *  gets the `hashCode` method:
      *
-     *    def hashCode: Int = x.hashCode()
+     *  ```
+     *  def hashCode: Int = x.hashCode()
+     *  ```
      */
     def valueHashCodeBody(implicit ctx: Context): Tree = {
       assert(accessors.length == 1)
@@ -181,17 +189,21 @@ class SyntheticMethods(thisTransformer: DenotTransformer) {
 
     /** The class
      *
-     *   package p
-     *    case class C(x: T, y: T)
+     *  ```
+     *  package p
+     *  case class C(x: T, y: T)
+     *  ```
      *
-     *  gets the hashCode method:
+     *  gets the `hashCode` method:
      *
-     *    def hashCode: Int = {
-     *      <synthetic> var acc: Int = "p.C".hashCode // constant folded
-     *      acc = Statics.mix(acc, x);
-     *      acc = Statics.mix(acc, Statics.this.anyHash(y));
-     *      Statics.finalizeHash(acc, 2)
-     *    }
+     *  ```
+     *  def hashCode: Int = {
+     *    <synthetic> var acc: Int = "p.C".hashCode // constant folded
+     *    acc = Statics.mix(acc, x);
+     *    acc = Statics.mix(acc, Statics.this.anyHash(y));
+     *    Statics.finalizeHash(acc, 2)
+     *  }
+     *  ```
      */
     def caseHashCodeBody(implicit ctx: Context): Tree = {
       val acc = ctx.newSymbol(ctx.owner, "acc".toTermName, Mutable | Synthetic, defn.IntType, coord = ctx.owner.pos)
@@ -202,7 +214,7 @@ class SyntheticMethods(thisTransformer: DenotTransformer) {
       Block(accDef :: mixes, finish)
     }
 
-    /** The hashCode implementation for given symbol `sym`. */
+    /** The `hashCode` implementation for given symbol `sym`. */
     def hashImpl(sym: Symbol)(implicit ctx: Context): Tree =
       defn.scalaClassName(sym.info.finalResultType) match {
         case tpnme.Unit | tpnme.Null               => Literal(Constant(0))
@@ -217,11 +229,15 @@ class SyntheticMethods(thisTransformer: DenotTransformer) {
 
     /** The class
      *
-     *    case class C(...)
+     *  ```
+     *  case class C(...)
+     *  ```
      *
-     *  gets the canEqual method
+     *  gets the `canEqual` method
      *
-     *    def canEqual(that: Any) = that.isInstanceOf[C]
+     *  ```
+     *  def canEqual(that: Any) = that.isInstanceOf[C]
+     *  ```
      */
     def canEqualBody(that: Tree): Tree = that.isInstance(clazzType)