Fix spacing and add return types

Author: OlivierBlanvillain

compiler/src/dotty/tools/dotc/typer/Deriving.scala

@@ -32,7 +32,7 @@ trait Deriving { this: Typer =>
     private var synthetics = new mutable.ListBuffer[Symbol]
 
     /** the children of `cls` ordered by textual occurrence */
-    lazy val children = cls.children
+    lazy val children: List[Symbol] = cls.children
 
     private def shapeError(explanation: => String): Unit =
       ctx.error(i"cannot take shape of $cls\n$explanation", codePos)
@@ -115,7 +115,7 @@ trait Deriving { this: Typer =>
     /** Create a synthetic symbol owned by current owner */
     private def newSymbol(name: Name, info: Type,
                           pos: Position = ctx.owner.pos,
-                          flags: FlagSet = EmptyFlags)(implicit ctx: Context) =
+                          flags: FlagSet = EmptyFlags)(implicit ctx: Context): Symbol =
       ctx.newSymbol(ctx.owner, name, flags | Synthetic, info, coord = pos)
 
     /** Create a synthetic method owned by current owner */
@@ -145,24 +145,24 @@ trait Deriving { this: Typer =>
       else add(newMethod(instanceName, info, pos, Implicit))
     }
 
-    /* Check derived type tree `derived` for the following well-formedness conditions:
-      * (1) It must be a class type with a stable prefix (@see checkClassTypeWithStablePrefix)
-      * (2) It must have exactly one type parameter
-      * If it passes the checks, enter a typeclass instance for it in the current scope.
-      * Given
-      *
-      *    class C[Ts] .... derives ... D ...
-      *
-      * where `T_1, ..., T_n` are the first-kinded type parameters in `Ts`,
-      * the typeclass instance has the form
-      *
-      *     implicit def derived$D(implicit ev_1: D[T1], ..., ev_n: D[T_n]): D[C[Ts]] = D.derived
-      *
-      * See test run/typeclass-derivation2 for examples that spell out what would be generated.
-      * Note that the name of the derived method containd the name in the derives clause, not
-      * the underlying class name. This allows one to disambiguate derivations of type classes
-      * that have the same name but different prefixes through selective aliasing.
-      */
+    /** Check derived type tree `derived` for the following well-formedness conditions:
+     *  (1) It must be a class type with a stable prefix (@see checkClassTypeWithStablePrefix)
+     *  (2) It must have exactly one type parameter
+     *  If it passes the checks, enter a typeclass instance for it in the current scope.
+     *  Given
+     *
+     *     class C[Ts] .... derives ... D ...
+     *
+     *  where `T_1, ..., T_n` are the first-kinded type parameters in `Ts`,
+     *  the typeclass instance has the form
+     *
+     *      implicit def derived$D(implicit ev_1: D[T_1], ..., ev_n: D[T_n]): D[C[Ts]] = D.derived
+     *
+     *  See test run/typeclass-derivation2 for examples that spell out what would be generated.
+     *  Note that the name of the derived method containd the name in the derives clause, not
+     *  the underlying class name. This allows one to disambiguate derivations of type classes
+     *  that have the same name but different prefixes through selective aliasing.
+     */
     private def processDerivedInstance(derived: untpd.Tree): Unit = {
       val originalType = typedAheadType(derived, AnyTypeConstructorProto).tpe
       val underlyingType = underlyingClassRef(originalType)
@@ -237,7 +237,7 @@ trait Deriving { this: Typer =>
     }
 
     /** Extractor for the `pattern` and `elements` in a `Shaped.Case(pattern, elements)` shape */
-    private object ShapeCase  {
+    private object ShapeCase {
       def unapply(shape: Type): Option[(Type, List[Type])] = shape match {
         case AppliedType(fn, pat :: elems :: Nil) if fn.classSymbol == defn.ShapeCaseClass =>
           Some((pat, tupleElems(elems)))
@@ -383,7 +383,7 @@ trait Deriving { this: Typer =>
       }
 
       /** The type class instance definition with symbol `sym` */
-      private def typeclassInstance(sym: Symbol)(implicit ctx: Context) =
+      private def typeclassInstance(sym: Symbol)(implicit ctx: Context): List[Type] => (List[List[tpd.Tree]] => tpd.Tree) =
         (tparamRefs: List[Type]) => (paramRefss: List[List[tpd.Tree]]) => {
           val tparams = tparamRefs.map(_.typeSymbol.asType)
           val params = if (paramRefss.isEmpty) Nil else paramRefss.head.map(_.symbol.asTerm)

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -155,7 +155,7 @@ object Implicits {
 
         def valueTypeCandidateKind(tpw: Type): Candidate.Kind = tpw.stripPoly match {
           case tpw: MethodType =>
-          	if (tpw.isImplicitMethod) Candidate.Value else Candidate.None
+            if (tpw.isImplicitMethod) Candidate.Value else Candidate.None
           case _ =>
             Candidate.Value
         }
@@ -195,7 +195,7 @@ object Implicits {
             else ref
           val refNorm = normalize(refAdjusted, pt)
           if (!NoViewsAllowed.isCompatible(refNorm, ptNorm))
-          	ckind = Candidate.None
+            ckind = Candidate.None
         }
         ckind
       }
@@ -384,10 +384,10 @@ object Implicits {
 
   class NoMatchingImplicits(val expectedType: Type, val argument: Tree, constraint: Constraint = OrderingConstraint.empty) extends SearchFailureType {
 
-  	/** Replace all type parameters in constraint by their bounds, to make it clearer
-  	 *  what was expected
-  	 */
-    override def clarify(tp: Type)(implicit ctx: Context) = {
+    /** Replace all type parameters in constraint by their bounds, to make it clearer
+     *  what was expected
+     */
+    override def clarify(tp: Type)(implicit ctx: Context): Type = {
       val map = new TypeMap {
         def apply(t: Type): Type = t match {
           case t: TypeParamRef =>

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

@@ -841,7 +841,7 @@ class Namer { typer: Typer =>
           else if (!cls.is(ChildrenQueried))
             addChild(cls, child)
           else
-            ctx.error(em"""children of ${cls} were already queried before $sym was discovered.
+            ctx.error(em"""children of $cls were already queried before $sym was discovered.
                           |As a remedy, you could move $sym on the same nesting level as $cls.""",
                       child.pos)
         }
@@ -947,11 +947,11 @@ class Namer { typer: Typer =>
           }
         }
 
-      /* Check parent type tree `parent` for the following well-formedness conditions:
-       * (1) It must be a class type with a stable prefix (@see checkClassTypeWithStablePrefix)
-       * (2) If may not derive from itself
-       * (3) The class is not final
-       * (4) If the class is sealed, it is defined in the same compilation unit as the current class
+      /** Check parent type tree `parent` for the following well-formedness conditions:
+       *  (1) It must be a class type with a stable prefix (@see checkClassTypeWithStablePrefix)
+       *  (2) If may not derive from itself
+       *  (3) The class is not final
+       *  (4) If the class is sealed, it is defined in the same compilation unit as the current class
        */
       def checkedParentType(parent: untpd.Tree): Type = {
         val ptype = parentType(parent)(ctx.superCallContext).dealiasKeepAnnots

docs/docs/internals/syntax.md

@@ -101,8 +101,10 @@ true      try       type      val       var       while     with      yield
 
 ### Soft keywords
 
+```
 derives   inline    opaque
 ~         *         |         &         +         -
+```
 
 ## Context-free Syntax
 

library/src-bootstrapped/scala/Tuple.scala

@@ -473,7 +473,7 @@ object NonEmptyTuple {
 }
 
 @showAsInfix
-sealed class *:[+H, +T <: Tuple] extends Object with NonEmptyTuple
+sealed class *:[+H, +T <: Tuple] extends Object with  NonEmptyTuple
 
 object *: {
   inline def unapply[H, T <: Tuple](x: H *: T) = (x.head, x.tail)

library/src-bootstrapped/scala/reflect/Generic.scala

@@ -1,8 +1,8 @@
 package scala.reflect
 
 /** A class for mapping between an ADT value and
-  *  the case mirror that represents the value.
-  */
+ *  the case mirror that represents the value.
+ */
 abstract class Generic[T] {
 
   type Shape <: scala.compiletime.Shape

library/src-bootstrapped/scala/reflect/Mirror.scala

@@ -1,7 +1,7 @@
 package scala.reflect
 
 /** A generic representation of a case in an ADT
-  *  @param  reflected  The common class-speficic part of this mirror
+  *  @param  reflected  The common class-specific part of this mirror
   *  @param  ordinal    The ordinal value of the case in the list of the ADT's cases
   *  @param  elems      The elements of the case
   */
@@ -14,5 +14,5 @@ class Mirror(val adtClass: GenericClass, val ordinal: Int, val elems: Product) {
   def caseLabel: String = adtClass.label(ordinal)(0)
 
   /** The label of the `n`'th element of the case reflected by this mirror */
-  def elementLabel(n: Int) = adtClass.label(ordinal)(n + 1)
+  def elementLabel(n: Int): String = adtClass.label(ordinal)(n + 1)
 }