Add language to code blocks in spec (scala#5502)

* Add "scala" language code to pure-Scala code blocks.
* Add "java" language code to Java code block.
* Add "scala" language code to almost-pure-Scala code blocks.

Add "scala" language code to two code blocks whose content was Scala except
for containing ellipses (\ldots).

* Add "scala" language code to non-literal-Scala code blocks.

Add "scala" language code to code blocks that contain Scala but also special
elements, such as identifiers that are italicized or have prime marks (e.g., e′,
e′′), ellipses (\ldots), etc.

Author: dsbos

spec/03-types.md

@@ -587,7 +587,7 @@ corresponding function type.
 
 The declarations
 
-```
+```scala
 def a: Int
 def b (x: Int): Boolean
 def c (x: Int) (y: String, z: String): String
@@ -642,7 +642,7 @@ the corresponding type parameter clause.
 
 Consider this fragment of the `Iterable[+X]` class:
 
-```
+```scala
 trait Iterable[+X] {
   def flatMap[newType[+X] <: Iterable[X], S](f: X => newType[S]): newType[S]
 }
@@ -660,7 +660,7 @@ same name, we model
 An overloaded type consisting of type alternatives $T_1 \commadots T_n (n \geq 2)$ is denoted internally $T_1 \overload \ldots \overload T_n$.
 
 ###### Example
-```
+```scala
 def println: Unit
 def println(s: String): Unit = $\ldots$
 def println(x: Float): Unit = $\ldots$
@@ -678,7 +678,7 @@ println:  => Unit $\overload$
 ```
 
 ###### Example
-```
+```scala
 def f(x: T): T = $\ldots$
 val f = 0
 ```
@@ -979,7 +979,7 @@ after applying [eta-expansion](06-expressions.html#eta-expansion). If $T$ is a m
 
 Given the definitions
 
-```
+```scala
 def foo(x: Int => String): Unit
 def foo(x: ToString): Unit
 

spec/04-basic-declarations-and-definitions.md

@@ -88,7 +88,7 @@ The class definition `case class X(), Y(n: Int) extends Z` expands to
 `case class X extends Z; case class Y(n: Int) extends Z`.
 - The object definition `case object Red, Green, Blue extends Color`~
 expands to
-```
+```scala
 case object Red extends Color
 case object Green extends Color
 case object Blue extends Color .

spec/05-classes-and-objects.md

@@ -725,7 +725,7 @@ Here,
 
   - $t$ is a [template](#templates) of the form
 
-    ```
+    ```scala
     $sc$ with $mt_1$ with $\ldots$ with $mt_m$ { $\mathit{stats}$ } // $m \geq 0$
     ```
 

spec/06-expressions.md

@@ -945,29 +945,29 @@ comprehensions have been eliminated.
     `$e$.foreach { case $p$ => $e'$ }`.
   - A for comprehension
 
-    ```
+    ```scala
     for ($p$ <- $e$; $p'$ <- $e'; \ldots$) yield $e''$
     ```
 
     where `$\ldots$` is a (possibly empty)
     sequence of generators, definitions, or guards,
     is translated to
 
-    ```
+    ```scala
     $e$.flatMap { case $p$ => for ($p'$ <- $e'; \ldots$) yield $e''$ }
     ```
 
   - A for loop
 
-    ```
+    ```scala
     for ($p$ <- $e$; $p'$ <- $e'; \ldots$) $e''$
     ```
 
     where `$\ldots$` is a (possibly empty)
     sequence of generators, definitions, or guards,
     is translated to
 
-    ```
+    ```scala
     $e$.foreach { case $p$ => for ($p'$ <- $e'; \ldots$) $e''$ }
     ```
 
@@ -980,7 +980,7 @@ comprehensions have been eliminated.
     `$p'$ = $e'$` is translated to the following generator of pairs of values, where
     $x$ and $x'$ are fresh names:
 
-    ```
+    ```scala
     ($p$, $p'$) <- for ($x @ p$ <- $e$) yield { val $x' @ p'$ = $e'$; ($x$, $x'$) }
     ```
 

spec/11-annotations.md

@@ -56,7 +56,7 @@ Java platform, the following annotations have a standard meaning.
     This is equivalent to a the following field
     definition in Java:
 
-    ```
+    ```java
     private final static SerialVersionUID = <longlit>
     ```
 
@@ -103,7 +103,7 @@ Java platform, the following annotations have a standard meaning.
     matches which would otherwise be emitted. For instance, no warnings
     would be produced for the method definition below.
 
-    ```
+    ```scala
     def f(x: Option[Int]) = (x: @unchecked) match {
     case Some(y) => y
     }
@@ -117,7 +117,7 @@ Java platform, the following annotations have a standard meaning.
     value to appear in a path, even if its type is [volatile](03-types.html#volatile-types).
     For instance, the following member definitions are legal:
 
-    ```
+    ```scala
     type A { type T }
     type B
     @uncheckedStable val x: A with B // volatile type
@@ -140,7 +140,7 @@ Java platform, the following annotations have a standard meaning.
     For instance, the following code would generate specialized traits for
     `Unit`, `Int` and `Double`
 
-    ```
+    ```scala
     trait Function0[@specialized(Unit, Int, Double) T] {
       def apply: T
     }

spec/12-the-scala-standard-library.md

@@ -777,7 +777,7 @@ The available high-priority implicits include definitions falling into the follo
   * An implicit wrapper that adds `ensuring` methods
     with the following overloaded variants to type `Any`.
 
-    ```
+    ```scala
     def ensuring(cond: Boolean): A = { assert(cond); x }
     def ensuring(cond: Boolean, msg: Any): A = { assert(cond, msg); x }
     def ensuring(cond: A => Boolean): A = { assert(cond(x)); x }
@@ -787,7 +787,7 @@ The available high-priority implicits include definitions falling into the follo
   * An implicit wrapper that adds a `->` method with the following implementation
     to type `Any`.
 
-    ```
+    ```scala
     def -> [B](y: B): (A, B) = (x, y)
     ```
 
@@ -801,7 +801,7 @@ The available high-priority implicits include definitions falling into the follo
   * An implicit wrapper that adds `+` and `formatted` method with the following
     implementations to type `Any`.
 
-    ```
+    ```scala
     def +(other: String) = String.valueOf(self) + other
     def formatted(fmtstr: String): String = fmtstr format self
     ```
@@ -835,7 +835,7 @@ The available high-priority implicits include definitions falling into the follo
   * An implicit definition that generates instances of type `T <:< T`, for
     any type `T`. Here, `<:<` is a class defined as follows.
 
-    ```
+    ```scala
     sealed abstract class <:<[-From, +To] extends (From => To)
     ```