12 files changed, 99 insertions, 21 deletions
diff --git a/spec/04-basic-declarations-and-definitions.md b/spec/04-basic-declarations-and-definitions.md
index 7fb5427d36..a8fd4cb60c 100644
--- a/spec/04-basic-declarations-and-definitions.md
+++ b/spec/04-basic-declarations-and-definitions.md
@@ -620,7 +620,11 @@ well as the function body, if it is present.
 
 A value parameter clause $\mathit{ps}$ consists of zero or more formal
 parameter bindings such as `$x$: $T$` or `$x: T = e$`, which bind value
-parameters and associate them with their types. Each value parameter
+parameters and associate them with their types.
+
+### Default Arguments
+
+Each value parameter
 declaration may optionally define a default argument. The default argument
 expression $e$ is type-checked with an expected type $T'$ obtained
 by replacing all occurences of the function's type parameters in $T$ by
@@ -632,13 +636,7 @@ expression. Here, $n$ denotes the parameter's position in the method
 declaration. These methods are parametrized by the type parameter clause
 `[$\mathit{tps}\,$]` and all value parameter clauses
 `($\mathit{ps}_1$)$\ldots$($\mathit{ps}_{i-1}$)` preceding $p_{i,j}$.
-The `$f\$$default$\$$n` methods are inaccessible for
-user programs.
-
-The scope of a formal value parameter name $x$ comprises all subsequent
-parameter clauses, as well as the method return type and the function body, if
-they are given. Both type parameter names and value parameter names must
-be pairwise distinct.
+The `$f\$$default$\$$n` methods are inaccessible for user programs.
 
 ###### Example
 In the method
@@ -657,6 +655,20 @@ def compare$\$$default$\$$1[T]: Int = 0
 def compare$\$$default$\$$2[T](a: T): T = a
 ```
 
+The scope of a formal value parameter name $x$ comprises all subsequent
+parameter clauses, as well as the method return type and the function body, if
+they are given. Both type parameter names and value parameter names must
+be pairwise distinct.
+
+A default value which depends on earlier parameters uses the actual arguments
+if they are provided, not the default arguments.
+
+```scala
+def f(a: Int = 0)(b: Int = a + 1) = b // OK
+// def f(a: Int = 0, b: Int = a + 1)  // "error: not found: value a"
+f(10)()                               // returns 11 (not 1)
+```
+
 ### By-Name Parameters
 
 ```ebnf
diff --git a/spec/05-classes-and-objects.md b/spec/05-classes-and-objects.md
index 28abe6c3bc..8be792d3cb 100644
--- a/spec/05-classes-and-objects.md
+++ b/spec/05-classes-and-objects.md
@@ -395,6 +395,7 @@ class C extends A with B { type T <: C }
 Let $C$ be a class type. The _inheritance closure_ of $C$ is the
 smallest set $\mathscr{S}$ of types such that
 
+- $C$ is in $\mathscr{S}$.
 - If $T$ is in $\mathscr{S}$, then every type $T'$ which forms syntactically
   a part of $T$ is also in $\mathscr{S}$.
 - If $T$ is a class type in $\mathscr{S}$, then all [parents](#templates)
diff --git a/src/library/scala/collection/immutable/List.scala b/src/library/scala/collection/immutable/List.scala
index 254f14f13c..82e38d3549 100644
--- a/src/library/scala/collection/immutable/List.scala
+++ b/src/library/scala/collection/immutable/List.scala
@@ -462,6 +462,7 @@ object List extends SeqFactory[List] {
   private class SerializationProxy[A](@transient private var orig: List[A]) extends Serializable {
 
     private def writeObject(out: ObjectOutputStream) {
+      out.defaultWriteObject()
       var xs: List[A] = orig
       while (!xs.isEmpty) {
         out.writeObject(xs.head)
@@ -473,6 +474,7 @@ object List extends SeqFactory[List] {
     // Java serialization calls this before readResolve during de-serialization.
     // Read the whole list and store it in `orig`.
     private def readObject(in: ObjectInputStream) {
+      in.defaultReadObject()
       val builder = List.newBuilder[A]
       while (true) in.readObject match {
         case ListSerializeEnd =>
diff --git a/src/library/scala/collection/mutable/ListBuffer.scala b/src/library/scala/collection/mutable/ListBuffer.scala
index 8faaf97741..f9bab40a1e 100644
--- a/src/library/scala/collection/mutable/ListBuffer.scala
+++ b/src/library/scala/collection/mutable/ListBuffer.scala
@@ -15,7 +15,7 @@ import immutable.{List, Nil, ::}
 import java.io._
 import scala.annotation.migration
 
-/** A `Buffer` implementation back up by a list. It provides constant time
+/** A `Buffer` implementation backed by a list. It provides constant time
  *  prepend and append. Most other operations are linear.
  *
  *  @author  Matthias Zenger
diff --git a/src/library/scala/math/Numeric.scala b/src/library/scala/math/Numeric.scala
index eafbf96993..9245798c17 100644
--- a/src/library/scala/math/Numeric.scala
+++ b/src/library/scala/math/Numeric.scala
@@ -134,7 +134,7 @@ object Numeric {
     def div(x: Float, y: Float): Float = x / y
   }
   trait FloatAsIfIntegral extends FloatIsConflicted with Integral[Float] {
-    def quot(x: Float, y: Float): Float = (BigDecimal(x) / BigDecimal(y)).floatValue
+    def quot(x: Float, y: Float): Float = (BigDecimal(x) quot BigDecimal(y)).floatValue
     def rem(x: Float, y: Float): Float = (BigDecimal(x) remainder BigDecimal(y)).floatValue
   }
   implicit object FloatIsFractional extends FloatIsFractional with Ordering.FloatOrdering
@@ -158,7 +158,7 @@ object Numeric {
     def div(x: Double, y: Double): Double = x / y
   }
   trait DoubleAsIfIntegral extends DoubleIsConflicted with Integral[Double] {
-    def quot(x: Double, y: Double): Double = (BigDecimal(x) / BigDecimal(y)).doubleValue
+    def quot(x: Double, y: Double): Double = (BigDecimal(x) quot BigDecimal(y)).doubleValue
     def rem(x: Double, y: Double): Double = (BigDecimal(x) remainder BigDecimal(y)).doubleValue
   }
 
@@ -178,7 +178,7 @@ object Numeric {
     def div(x: BigDecimal, y: BigDecimal): BigDecimal = x / y
   }
   trait BigDecimalAsIfIntegral extends BigDecimalIsConflicted with Integral[BigDecimal] {
-    def quot(x: BigDecimal, y: BigDecimal): BigDecimal = x / y
+    def quot(x: BigDecimal, y: BigDecimal): BigDecimal = x quot y
     def rem(x: BigDecimal, y: BigDecimal): BigDecimal = x remainder y
   }
 
diff --git a/src/library/scala/util/Try.scala b/src/library/scala/util/Try.scala
index 0a6a7972c2..b0eae74043 100644
--- a/src/library/scala/util/Try.scala
+++ b/src/library/scala/util/Try.scala
@@ -48,7 +48,7 @@ import scala.language.implicitConversions
  * catching exceptions along the way. The `flatMap` and `map` combinators in the above example each essentially
  * pass off either their successfully completed value, wrapped in the `Success` type for it to be further operated
  * upon by the next combinator in the chain, or the exception wrapped in the `Failure` type usually to be simply
- * passed on down the chain. Combinators such as `rescue` and `recover` are designed to provide some type of
+ * passed on down the chain. Combinators such as `recover` and `recoverWith` are designed to provide some type of
  * default behavior in the case of failure.
  *
  * ''Note'': only non-fatal exceptions are caught by the combinators on `Try` (see [[scala.util.control.NonFatal]]).
diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
index ce60ade9f5..8c32a92ecd 100644
--- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala
+++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
@@ -1184,6 +1184,7 @@ private[scala] trait JavaMirrors extends internal.SymbolTable with api.JavaUnive
       constr setInfo GenPolyType(tparams, MethodType(clazz.newSyntheticValueParams(paramtpes), clazz.tpe))
       propagatePackageBoundary(jconstr.javaFlags, constr)
       copyAnnotations(constr, jconstr)
+      if (jconstr.javaFlags.isVarargs) constr modifyInfo arrayToRepeated
       markAllCompleted(constr)
       constr
     }
diff --git a/test/files/run/range.scala b/test/files/run/range.scala
index 4637ab874d..e50d0ac6a5 100644
--- a/test/files/run/range.scala
+++ b/test/files/run/range.scala
@@ -36,16 +36,19 @@ object Test {
 
     def gr1 = NumericRange(x, x, x)
     def gr2 = NumericRange.inclusive(x, x, x)
-    def gr3 = NumericRange(x, x * fromInt(10), x)
-    def gr4 = NumericRange.inclusive(x, x * fromInt(10), x)
-    def gr5 = gr3.toList ::: negated.gr3.toList
+    def gr3 = NumericRange(x, x * fromInt(4), x * fromInt(2))  // SI-9348
+    def gr4 = NumericRange(x, x * fromInt(-2), x * fromInt(-2))
+    def gr5 = NumericRange(x, x * fromInt(10), x)
+    def gr6 = NumericRange.inclusive(x, x * fromInt(10), x)
+    def gr7 = gr3.toList ::: negated.gr3.toList
 
     def check = {
       assert(gr1.isEmpty && !gr2.isEmpty)
-      assert(gr3.size == 9 && gr4.size == 10)
-      assert(gr5.sum == num.zero, gr5.toString)
-      assert(!(gr3 contains (x * fromInt(10))))
-      assert((gr4 contains (x * fromInt(10))))
+      assert(gr3.size == 2 && gr4.size == 2)
+      assert(gr5.size == 9 && gr6.size == 10)
+      assert(gr7.sum == num.zero, gr7.toString)
+      assert(!(gr5 contains (x * fromInt(10))))
+      assert(gr6 contains (x * fromInt(10)))
     }
   }
 
@@ -55,6 +58,7 @@ object Test {
 
     val _grs = List[GR[_]](
       GR(BigDecimal(5.0)),
+      GR(BigDecimal(0.25)),  // SI-9348
       GR(BigInt(5)),
       GR(5L),
       GR(5.0d),
diff --git a/test/files/run/toolbox-varargs/Test.scala b/test/files/run/toolbox-varargs/Test.scala
new file mode 100644
index 0000000000..be5ab45768
--- /dev/null
+++ b/test/files/run/toolbox-varargs/Test.scala
@@ -0,0 +1,13 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+     import scala.tools.reflect.ToolBox
+     val m = reflect.runtime.currentMirror
+     val u = m.universe
+     import u._
+     val tb = m.mkToolBox();
+     tb.compile(q"new p.Varargs(null, null)")
+     tb.compile(q"p.Varargs.staticMethod(null, null)")
+     tb.compile(q"(null: p.Varargs).instanceMethod(null, null)")
+  }
+}
+
diff --git a/test/files/run/toolbox-varargs/Varargs.java b/test/files/run/toolbox-varargs/Varargs.java
new file mode 100644
index 0000000000..da1dbbacc9
--- /dev/null
+++ b/test/files/run/toolbox-varargs/Varargs.java
@@ -0,0 +1,8 @@
+package p;
+
+public class Varargs {
+	public Varargs(String... args) {}
+	public static void staticMethod(String... args) {}
+
+	public void instanceMethod(String... args) {}
+}
diff --git a/test/junit/scala/collection/immutable/RangeConsistencyTest.scala b/test/junit/scala/collection/immutable/RangeConsistencyTest.scala
index 3980c31577..135796979d 100644
--- a/test/junit/scala/collection/immutable/RangeConsistencyTest.scala
+++ b/test/junit/scala/collection/immutable/RangeConsistencyTest.scala
@@ -137,4 +137,15 @@ class RangeConsistencyTest {
     assert( (-3 to Int.MaxValue).dropWhile(_ <= 0).length == Int.MaxValue )
     assert( (-3 to Int.MaxValue).span(_ <= 0) match { case (a,b) => a.length == 4 && b.length == Int.MaxValue } )
   }
+  
+  @Test
+  def testSI9348() {
+    // Test exclusive range with (end-start) != 0 (mod step)
+    assert( (0.0f until 0.4f by 0.25f) sameElements List(0.0f, 0.25f) )
+    assert( (1.0 until 2.2 by 0.5) sameElements List(1.0, 1.5, 2.0) )
+    
+    def bd(d: Double) = BigDecimal(d)
+    val bdRange = bd(-10.0) until bd(0.0) by bd(4.5)
+    assert( bdRange sameElements List(bd(-10.0), bd(-5.5), bd(-1.0)) )
+  }
 }
diff --git a/test/junit/scala/math/NumericTest.scala b/test/junit/scala/math/NumericTest.scala
index 9bf7d4f1e4..682dcbfd75 100644
--- a/test/junit/scala/math/NumericTest.scala
+++ b/test/junit/scala/math/NumericTest.scala
@@ -5,6 +5,9 @@ import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
 
+import scala.math.Numeric.FloatAsIfIntegral
+
+
 @RunWith(classOf[JUnit4])
 class NumericTest {
 
@@ -14,5 +17,28 @@ class NumericTest {
     assertTrue(-0.0.abs equals 0.0)
     assertTrue(-0.0f.abs equals 0.0f)
   }
-}
+  
+  /* Test for SI-9348 */
+  @Test
+  def testFloatAsIfIntegral {
+    val num = scala.math.Numeric.FloatAsIfIntegral
+    assertTrue(num.quot(1.0f, 0.5f) equals 2.0f)
+    assertTrue(num.quot(1.0f, 0.3f) equals 3.0f)
+  }
+
+  /* Test for SI-9348 */
+  @Test
+  def testDoubleAsIfIntegral {
+    val num = scala.math.Numeric.DoubleAsIfIntegral
+    assertTrue(num.quot(1.0, 0.25) equals 4.0)
+    assertTrue(num.quot(0.5, 0.15) equals 3.0)
+  }
+
+  /* Test for SI-9348 */
+  @Test
+  def testBigDecimalAsIfIntegral {
+    val num = scala.math.Numeric.BigDecimalAsIfIntegral
+    assertTrue(num.quot(BigDecimal(2.5), BigDecimal(0.5)) equals BigDecimal(5.0))
+    assertTrue(num.quot(BigDecimal(5.0), BigDecimal(2.0)) equals BigDecimal(2.0))
+  }}