ScalaDoc fixes for compiler

Author: janekdb

src/compiler/scala/tools/nsc/ScriptRunner.scala

@@ -16,24 +16,24 @@ import util.Exceptional.unwrap
 
 /** An object that runs Scala code in script files.
  *
- *  <p>For example, here is a complete Scala script on Unix:</pre>
- *  <pre>
+ *  For example, here is a complete Scala script on Unix:
+ *  {{{
  *    #!/bin/sh
  *    exec scala "$0" "$@"
  *    !#
  *    Console.println("Hello, world!")
  *    args.toList foreach Console.println
- *  </pre>
- *  <p>And here is a batch file example on Windows XP:</p>
- *  <pre>
+ *  }}}
+ *  And here is a batch file example on Windows XP:
+ *  {{{
  *    ::#!
  *    @echo off
  *    call scala %0 %*
  *    goto :eof
  *    ::!#
  *    Console.println("Hello, world!")
  *    args.toList foreach Console.println
- *  </pre>
+ *  }}}
  *
  *  @author  Lex Spoon
  *  @version 1.0, 15/05/2006

src/compiler/scala/tools/nsc/ast/parser/Scanners.scala

@@ -226,7 +226,7 @@ trait Scanners extends ScannersCommon {
      *  RPAREN    if region starts with '('
      *  RBRACKET  if region starts with '['
      *  RBRACE    if region starts with '{'
-     *  ARROW     if region starts with `case'
+     *  ARROW     if region starts with 'case'
      *  STRINGLIT if region is a string interpolation expression starting with '${'
      *            (the STRINGLIT appears twice in succession on the stack iff the
      *             expression is a multiline string literal).

src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala

@@ -495,8 +495,8 @@ abstract class GenASM extends SubComponent with BytecodeWriters { self =>
      *        generic classes or interfaces.
      *
      * @param superName the internal of name of the super class. For interfaces,
-     *        the super class is {@link Object}. May be <tt>null</tt>, but
-     *        only for the {@link Object} class.
+     *        the super class is [[Object]]. May be <tt>null</tt>, but
+     *        only for the [[Object]] class.
      *
      * @param interfaces the internal names of the class's interfaces (see
      *        {@link Type#getInternalName() getInternalName}). May be

src/compiler/scala/tools/nsc/typechecker/Checkable.scala

@@ -44,7 +44,7 @@ import scala.language.postfixOps
  *  which is essentially the intersection of X and |P|, where |P| is
  *  the erasure of P.  If XR <: P, then no warning is emitted.
  *
- *  We evaluate "X with conform to P" by checking `X <: P_wild, where
+ *  We evaluate "X with conform to P" by checking `X <: P_wild`, where
  *  P_wild is the result of substituting wildcard types in place of
  *  pattern type variables. This is intentionally stricter than
  *  (X matchesPattern P), see SI-8597 for motivating test cases.

src/compiler/scala/tools/nsc/typechecker/Implicits.scala

@@ -110,10 +110,10 @@ trait Implicits {
    * Ignore their constr field! The list of type constraints returned along with each tree specifies the constraints that
    * must be met by the corresponding type parameter in `tpars` (for the returned implicit view to be valid).
    *
-   * @arg tp      from-type for the implicit conversion
-   * @arg context search implicits here
-   * @arg tpars   symbols that should be considered free type variables
-   *              (implicit search should not try to solve them, just track their constraints)
+   * @param tp      from-type for the implicit conversion
+   * @param context search implicits here
+   * @param tpars   symbols that should be considered free type variables
+   *                (implicit search should not try to solve them, just track their constraints)
    */
   def allViewsFrom(tp: Type, context: Context, tpars: List[Symbol]): List[(SearchResult, List[TypeConstraint])] = {
     // my untouchable typevars are better than yours (they can't be constrained by them)

src/compiler/scala/tools/nsc/typechecker/Infer.scala

@@ -1375,7 +1375,7 @@ trait Infer extends Checkable {
      *  Otherwise, if there is no best alternative, error.
      *
      *  @param argtpes0 contains the argument types. If an argument is named, as
-     *    "a = 3", the corresponding type is `NamedType("a", Int)'. If the name
+     *    "a = 3", the corresponding type is `NamedType("a", Int)`. If the name
      *    of some NamedType does not exist in an alternative's parameter names,
      *    the type is replaces by `Unit`, i.e. the argument is treated as an
      *    assignment expression.

src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala

@@ -132,7 +132,7 @@ trait StdAttachments {
   /** Marks the tree as a macro impl reference, which is a naked reference to a method.
    *
    *  This is necessary for typechecking macro impl references (see `DefaultMacroCompiler.defaultResolveMacroImpl`),
-   *  because otherwise typing a naked reference will result in the "follow this method with `_' if you want to
+   *  because otherwise typing a naked reference will result in the "follow this method with `_` if you want to
    *  treat it as a partially applied function" errors.
    *
    *  This mark suppresses adapt except for when the annottee is a macro application.

src/compiler/scala/tools/nsc/typechecker/Tags.scala

@@ -36,7 +36,7 @@ trait Tags {
      *  @param   allowMaterialization   If true (default) then the resolver is allowed to launch materialization macros when there's no class tag in scope.
      *                                  If false then materialization macros are prohibited from running.
      *
-     *  @returns Tree that represents an `scala.reflect.ClassTag` for `tp` if everything is okay.
+     *  @return  Tree that represents an `scala.reflect.ClassTag` for `tp` if everything is okay.
      *           EmptyTree if the result contains unresolved (i.e. not spliced) type parameters and abstract type members.
      *           EmptyTree if `allowMaterialization` is false, and there is no class tag in scope.
      */
@@ -57,7 +57,7 @@ trait Tags {
      *  @param   allowMaterialization   If true (default) then the resolver is allowed to launch materialization macros when there's no type tag in scope.
      *                                  If false then materialization macros are prohibited from running.
      *
-     *  @returns Tree that represents a `scala.reflect.TypeTag` for `tp` if everything is okay.
+     *  @return  Tree that represents a `scala.reflect.TypeTag` for `tp` if everything is okay.
      *           EmptyTree if `concrete` is true and the result contains unresolved (i.e. not spliced) type parameters and abstract type members.
      *           EmptyTree if `allowMaterialization` is false, and there is no array tag in scope.
      */

src/compiler/scala/tools/nsc/typechecker/Typers.scala

@@ -2725,7 +2725,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
      *
      * If 'T' is not fully defined, it is inferred by type checking
      * `apply$body` without a result type before type checking the block.
-     * The method's inferred result type is used instead of T`. [See test/files/pos/sammy_poly.scala]
+     * The method's inferred result type is used instead of `T`. [See test/files/pos/sammy_poly.scala]
      *
      * The `apply` method is identified by the argument `sam`; `S` corresponds to the argument `samClassTp`,
      * and `resPt` is derived from `samClassTp` -- it may be fully defined, or not...

src/compiler/scala/tools/nsc/util/DocStrings.scala

@@ -37,7 +37,7 @@ object DocStrings {
   /** Returns index of string `str` after `start` skipping longest
    *  sequence of space and tab characters, possibly also containing
    *  a single `*` character or the `/``**` sequence.
-   *  @pre  start == str.length || str(start) == `\n'
+   *  @pre  start == str.length || str(start) == `\n`
    */
   def skipLineLead(str: String, start: Int): Int =
     if (start == str.length) start
@@ -49,7 +49,7 @@ object DocStrings {
       else idx
     }
 
-  /** Skips to next occurrence of `\n' or to the position after the `/``**` sequence following index `start`.
+  /** Skips to next occurrence of `\n` or to the position after the `/``**` sequence following index `start`.
    */
   def skipToEol(str: String, start: Int): Int =
     if (start + 2 < str.length && (str charAt start) == '/' && (str charAt (start + 1)) == '*' && (str charAt (start + 2)) == '*') start + 3