[Git][java-team/scala][master] 5 commits: Add 0017-trimTrailingSpace.patch and fix the FTBFS in StringOps.scala.
Markus Koschany
gitlab at salsa.debian.org
Sat Nov 10 19:11:52 GMT 2018
Markus Koschany pushed to branch master at Debian Java Maintainers / scala
Commits:
c5097346 by Markus Koschany at 2018-11-10T15:13:44Z
Add 0017-trimTrailingSpace.patch and fix the FTBFS in StringOps.scala.
Closes: #912393
- - - - -
34a3d094 by Markus Koschany at 2018-11-10T15:14:29Z
Declare compliance with Debian Policy 4.2.1.
- - - - -
01d2f603 by Markus Koschany at 2018-11-10T15:14:51Z
Update changelog
- - - - -
23917d3f by Markus Koschany at 2018-11-10T18:27:32Z
Rename 0017-trimTrailingSpace.patch to 0017-bug912393.patch.
Fix more compilation errors.
- - - - -
46da5d4c by Markus Koschany at 2018-11-10T19:09:43Z
Update changelog
- - - - -
4 changed files:
- debian/changelog
- debian/control
- + debian/patches/0017-bug912393.patch
- debian/patches/series
Changes:
=====================================
debian/changelog
=====================================
@@ -1,9 +1,16 @@
-scala (2.11.12-3) UNRELEASED; urgency=medium
+scala (2.11.12-3) unstable; urgency=medium
* Team upload.
+
+ [ Markus Koschany ]
+ * Add 0017-bug912393.patch and fix several compilation errors.
+ (Closes: #912393)
+ * Declare compliance with Debian Policy 4.2.1.
+
+ [ Emmanuel Bourg ]
* Depend on scala (>= 2.11.12) to build with Java 9
- -- Emmanuel Bourg <ebourg at apache.org> Mon, 30 Apr 2018 08:59:30 +0200
+ -- Markus Koschany <apo at debian.org> Sat, 10 Nov 2018 16:14:38 +0100
scala (2.11.12-2) unstable; urgency=medium
=====================================
debian/control
=====================================
@@ -21,7 +21,7 @@ Build-Depends:
scala-asm (>= 5.2.0-scala-2),
scala-parser-combinators,
scala-xml
-Standards-Version: 4.1.4
+Standards-Version: 4.2.1
Vcs-Git: https://anonscm.debian.org/git/pkg-java/scala.git
Vcs-Browser: https://anonscm.debian.org/cgit/pkg-java/scala.git
Homepage: http://www.scala-lang.org/
=====================================
debian/patches/0017-bug912393.patch
=====================================
@@ -0,0 +1,740 @@
+From: Markus Koschany <apo at debian.org>
+Date: Sat, 10 Nov 2018 16:11:46 +0100
+Subject: 0017-bug912393
+
+Bug-Debian: https://bugs.debian.org/912393
+Forwarded: not-needed
+---
+ src/compiler/scala/tools/cmd/gen/AnyVals.scala | 484 ---------------------
+ src/compiler/scala/tools/cmd/gen/Codegen.scala | 4 +-
+ .../scala/tools/nsc/typechecker/Contexts.scala | 2 +-
+ .../scala/tools/nsc/typechecker/Typers.scala | 2 +-
+ src/compiler/scala/tools/util/PathResolver.scala | 2 +-
+ .../tests/InteractiveTestSettings.scala | 2 +-
+ .../scala/reflect/internal/util/StringOps.scala | 2 +-
+ .../tools/nsc/interpreter/jline/JLineHistory.scala | 2 +-
+ .../scala/tools/nsc/interpreter/Formatting.scala | 4 +-
+ src/repl/scala/tools/nsc/interpreter/ILoop.scala | 4 +-
+ src/repl/scala/tools/nsc/interpreter/IMain.scala | 4 +-
+ src/repl/scala/tools/nsc/interpreter/Pasted.scala | 2 +-
+ src/repl/scala/tools/nsc/interpreter/Power.scala | 4 -
+ .../scala/tools/nsc/interpreter/ReplProps.scala | 2 +-
+ .../tools/nsc/doc/base/CommentFactoryBase.scala | 2 +-
+ 15 files changed, 17 insertions(+), 505 deletions(-)
+ delete mode 100644 src/compiler/scala/tools/cmd/gen/AnyVals.scala
+
+diff --git a/src/compiler/scala/tools/cmd/gen/AnyVals.scala b/src/compiler/scala/tools/cmd/gen/AnyVals.scala
+deleted file mode 100644
+index e785899..0000000
+--- a/src/compiler/scala/tools/cmd/gen/AnyVals.scala
++++ /dev/null
+@@ -1,484 +0,0 @@
+-/* NSC -- new Scala compiler
+- * Copyright 2007-2013 LAMP/EPFL
+- * @author Paul Phillips
+- */
+-
+-package scala.tools.cmd
+-package gen
+-
+-/** Code generation of the AnyVal types and their companions. */
+-trait AnyValReps {
+- self: AnyVals =>
+-
+- sealed abstract class AnyValNum(name: String, repr: Option[String], javaEquiv: String)
+- extends AnyValRep(name,repr,javaEquiv) {
+-
+- case class Op(op : String, doc : String)
+-
+- private def companionCoercions(tos: AnyValRep*) = {
+- tos.toList map (to =>
+- s"implicit def @javaequiv at 2${to.javaEquiv}(x: @name@): ${to.name} = x.to${to.name}"
+- )
+- }
+- def coercionComment =
+-"""/** Language mandated coercions from @name@ to "wider" types. */
+-import scala.language.implicitConversions"""
+-
+- def implicitCoercions: List[String] = {
+- val coercions = this match {
+- case B => companionCoercions(S, I, L, F, D)
+- case S | C => companionCoercions(I, L, F, D)
+- case I => companionCoercions(L, F, D)
+- case L => companionCoercions(F, D)
+- case F => companionCoercions(D)
+- case _ => Nil
+- }
+- if (coercions.isEmpty) Nil
+- else coercionComment.lines.toList ++ coercions
+- }
+-
+- def isCardinal: Boolean = isIntegerType(this)
+- def unaryOps = {
+- val ops = List(
+- Op("+", "/** Returns this value, unmodified. */"),
+- Op("-", "/** Returns the negation of this value. */"))
+-
+- if(isCardinal)
+- Op("~", "/**\n" +
+- " * Returns the bitwise negation of this value.\n" +
+- " * @example {{{\n" +
+- " * ~5 == -6\n" +
+- " * // in binary: ~00000101 ==\n" +
+- " * // 11111010\n" +
+- " * }}}\n" +
+- " */") :: ops
+- else ops
+- }
+-
+- def bitwiseOps =
+- if (isCardinal)
+- List(
+- Op("|", "/**\n" +
+- " * Returns the bitwise OR of this value and `x`.\n" +
+- " * @example {{{\n" +
+- " * (0xf0 | 0xaa) == 0xfa\n" +
+- " * // in binary: 11110000\n" +
+- " * // | 10101010\n" +
+- " * // --------\n" +
+- " * // 11111010\n" +
+- " * }}}\n" +
+- " */"),
+- Op("&", "/**\n" +
+- " * Returns the bitwise AND of this value and `x`.\n" +
+- " * @example {{{\n" +
+- " * (0xf0 & 0xaa) == 0xa0\n" +
+- " * // in binary: 11110000\n" +
+- " * // & 10101010\n" +
+- " * // --------\n" +
+- " * // 10100000\n" +
+- " * }}}\n" +
+- " */"),
+- Op("^", "/**\n" +
+- " * Returns the bitwise XOR of this value and `x`.\n" +
+- " * @example {{{\n" +
+- " * (0xf0 ^ 0xaa) == 0x5a\n" +
+- " * // in binary: 11110000\n" +
+- " * // ^ 10101010\n" +
+- " * // --------\n" +
+- " * // 01011010\n" +
+- " * }}}\n" +
+- " */"))
+- else Nil
+-
+- def shiftOps =
+- if (isCardinal)
+- List(
+- Op("<<", "/**\n" +
+- " * Returns this value bit-shifted left by the specified number of bits,\n" +
+- " * filling in the new right bits with zeroes.\n" +
+- " * @example {{{ 6 << 3 == 48 // in binary: 0110 << 3 == 0110000 }}}\n" +
+- " */"),
+-
+- Op(">>>", "/**\n" +
+- " * Returns this value bit-shifted right by the specified number of bits,\n" +
+- " * filling the new left bits with zeroes.\n" +
+- " * @example {{{ 21 >>> 3 == 2 // in binary: 010101 >>> 3 == 010 }}}\n" +
+- " * @example {{{\n" +
+- " * -21 >>> 3 == 536870909\n" +
+- " * // in binary: 11111111 11111111 11111111 11101011 >>> 3 ==\n" +
+- " * // 00011111 11111111 11111111 11111101\n" +
+- " * }}}\n" +
+- " */"),
+-
+- Op(">>", "/**\n" +
+- " * Returns this value bit-shifted right by the specified number of bits,\n" +
+- " * filling in the left bits with the same value as the left-most bit of this.\n" +
+- " * The effect of this is to retain the sign of the value.\n" +
+- " * @example {{{\n" +
+- " * -21 >> 3 == -3\n" +
+- " * // in binary: 11111111 11111111 11111111 11101011 >> 3 ==\n" +
+- " * // 11111111 11111111 11111111 11111101\n" +
+- " * }}}\n" +
+- " */"))
+- else Nil
+-
+- def comparisonOps = List(
+- Op("==", "/** Returns `true` if this value is equal to x, `false` otherwise. */"),
+- Op("!=", "/** Returns `true` if this value is not equal to x, `false` otherwise. */"),
+- Op("<", "/** Returns `true` if this value is less than x, `false` otherwise. */"),
+- Op("<=", "/** Returns `true` if this value is less than or equal to x, `false` otherwise. */"),
+- Op(">", "/** Returns `true` if this value is greater than x, `false` otherwise. */"),
+- Op(">=", "/** Returns `true` if this value is greater than or equal to x, `false` otherwise. */"))
+-
+- def otherOps = List(
+- Op("+", "/** Returns the sum of this value and `x`. */"),
+- Op("-", "/** Returns the difference of this value and `x`. */"),
+- Op("*", "/** Returns the product of this value and `x`. */"),
+- Op("/", "/** Returns the quotient of this value and `x`. */"),
+- Op("%", "/** Returns the remainder of the division of this value by `x`. */"))
+-
+- // Given two numeric value types S and T , the operation type of S and T is defined as follows:
+- // If both S and T are subrange types then the operation type of S and T is Int.
+- // Otherwise the operation type of S and T is the larger of the two types wrt ranking.
+- // Given two numeric values v and w the operation type of v and w is the operation type
+- // of their run-time types.
+- def opType(that: AnyValNum): AnyValNum = {
+- val rank = IndexedSeq(I, L, F, D)
+- (rank indexOf this, rank indexOf that) match {
+- case (-1, -1) => I
+- case (r1, r2) => rank apply (r1 max r2)
+- }
+- }
+-
+- def mkCoercions = numeric map (x => "def to%s: %s".format(x, x))
+- def mkUnaryOps = unaryOps map (x => "%s\n def unary_%s : %s".format(x.doc, x.op, this opType I))
+- def mkStringOps = List("def +(x: String): String")
+- def mkShiftOps = (
+- for (op <- shiftOps ; arg <- List(I, L)) yield
+- "%s\n def %s(x: %s): %s".format(op.doc, op.op, arg, this opType I)
+- )
+-
+- def clumps: List[List[String]] = {
+- val xs1 = List(mkCoercions, mkUnaryOps, mkStringOps, mkShiftOps) map (xs => if (xs.isEmpty) xs else xs :+ "")
+- val xs2 = List(
+- mkBinOpsGroup(comparisonOps, numeric, _ => Z),
+- mkBinOpsGroup(bitwiseOps, cardinal, this opType _),
+- mkBinOpsGroup(otherOps, numeric, this opType _)
+- )
+- xs1 ++ xs2
+- }
+- def classLines = (clumps :+ commonClassLines).foldLeft(List[String]()) {
+- case (res, Nil) => res
+- case (res, lines) =>
+- val xs = lines map {
+- case "" => ""
+- case s => interpolate(s)
+- }
+- res ++ xs
+- }
+- def objectLines = {
+- val comp = if (isCardinal) cardinalCompanion else floatingCompanion
+- interpolate(comp + allCompanions + "\n" + nonUnitCompanions).trim.lines.toList ++ (implicitCoercions map interpolate)
+- }
+-
+- /** Makes a set of binary operations based on the given set of ops, args, and resultFn.
+- *
+- * @param ops list of function names e.g. List(">>", "%")
+- * @param args list of types which should appear as arguments
+- * @param resultFn function which calculates return type based on arg type
+- * @return list of function definitions
+- */
+- def mkBinOpsGroup(ops: List[Op], args: List[AnyValNum], resultFn: AnyValNum => AnyValRep): List[String] = (
+- ops flatMap (op =>
+- args.map(arg =>
+- "%s\n def %s(x: %s): %s".format(op.doc, op.op, arg, resultFn(arg))) :+ ""
+- )
+- ).toList
+- }
+-
+- sealed abstract class AnyValRep(val name: String, val repr: Option[String], val javaEquiv: String) {
+- def classLines: List[String]
+- def objectLines: List[String]
+- def commonClassLines = List(
+- "override def getClass(): Class[@name@] = null"
+- )
+-
+- def lcname = name.toLowerCase
+- def boxedSimpleName = this match {
+- case C => "Character"
+- case I => "Integer"
+- case _ => name
+- }
+- def boxedName = this match {
+- case U => "scala.runtime.BoxedUnit"
+- case _ => "java.lang." + boxedSimpleName
+- }
+- def zeroRep = this match {
+- case L => "0L"
+- case F => "0.0f"
+- case D => "0.0d"
+- case _ => "0"
+- }
+-
+- def representation = repr.map(", a " + _).getOrElse("")
+-
+- def indent(s: String) = if (s == "") "" else " " + s
+- def indentN(s: String) = s.lines map indent mkString "\n"
+-
+- def boxUnboxImpls = Map(
+- "@boxRunTimeDoc@" -> """
+- * Runtime implementation determined by `scala.runtime.BoxesRunTime.boxTo%s`. See [[https://github.com/scala/scala src/library/scala/runtime/BoxesRunTime.java]].
+- *""".format(boxedSimpleName),
+- "@boxImpl@" -> "%s.valueOf(x)".format(boxedName),
+- "@unboxRunTimeDoc@" -> """
+- * Runtime implementation determined by `scala.runtime.BoxesRunTime.unboxTo%s`. See [[https://github.com/scala/scala src/library/scala/runtime/BoxesRunTime.java]].
+- *""".format(name),
+- "@unboxImpl@" -> "x.asInstanceOf[%s].%sValue()".format(boxedName, lcname),
+- "@unboxDoc@" -> "the %s resulting from calling %sValue() on `x`".format(name, lcname)
+- )
+- def interpolations = Map(
+- "@name@" -> name,
+- "@representation@" -> representation,
+- "@javaequiv@" -> javaEquiv,
+- "@boxed@" -> boxedName,
+- "@lcname@" -> lcname,
+- "@zero@" -> zeroRep
+- ) ++ boxUnboxImpls
+-
+- def interpolate(s: String): String = interpolations.foldLeft(s) {
+- case (str, (key, value)) => str.replaceAll(key, value)
+- }
+- def classDoc = interpolate(classDocTemplate)
+- def objectDoc = ""
+- def mkImports = ""
+-
+- def mkClass = assemble("final abstract class " + name + " private extends AnyVal", classLines)
+- def mkObject = assemble("object " + name + " extends AnyValCompanion", objectLines)
+- def make() = List[String](
+- headerTemplate,
+- mkImports,
+- classDoc,
+- mkClass,
+- objectDoc,
+- mkObject
+- ) mkString ""
+-
+- def assemble(decl: String, lines: List[String]): String = {
+- val body = if (lines.isEmpty) " { }\n\n" else lines map indent mkString (" {\n", "\n", "\n}\n")
+-
+- decl + body + "\n"
+- }
+- override def toString = name
+- }
+-}
+-
+-trait AnyValTemplates {
+- def headerTemplate = """/* __ *\
+-** ________ ___ / / ___ Scala API **
+-** / __/ __// _ | / / / _ | (c) 2002-2013, LAMP/EPFL **
+-** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
+-** /____/\___/_/ |_/____/_/ | | **
+-** |/ **
+-\* */
+-
+-// DO NOT EDIT, CHANGES WILL BE LOST
+-// This auto-generated code can be modified in scala.tools.cmd.gen.
+-// Afterwards, running tools/codegen-anyvals regenerates this source file.
+-
+-package scala
+-
+-"""
+-
+- def classDocTemplate = ("""
+-/** `@name@`@representation@ (equivalent to Java's `@javaequiv@` primitive type) is a
+- * subtype of [[scala.AnyVal]]. Instances of `@name@` are not
+- * represented by an object in the underlying runtime system.
+- *
+- * There is an implicit conversion from [[scala. at name@]] => [[scala.runtime.Rich at name@]]
+- * which provides useful non-primitive operations.
+- */
+-""".trim + "\n")
+-
+- def allCompanions = """
+-/** Transform a value type into a boxed reference type.
+- *@boxRunTimeDoc@
+- * @param x the @name@ to be boxed
+- * @return a @boxed@ offering `x` as its underlying value.
+- */
+-def box(x: @name@): @boxed@ = @boxImpl@
+-
+-/** Transform a boxed type into a value type. Note that this
+- * method is not typesafe: it accepts any Object, but will throw
+- * an exception if the argument is not a @boxed at .
+- *@unboxRunTimeDoc@
+- * @param x the @boxed@ to be unboxed.
+- * @throws ClassCastException if the argument is not a @boxed@
+- * @return @unboxDoc@
+- */
+-def unbox(x: java.lang.Object): @name@ = @unboxImpl@
+-
+-/** The String representation of the scala. at name@ companion object. */
+-override def toString = "object scala. at name@"
+-"""
+-
+- def nonUnitCompanions = "" // todo
+-
+- def cardinalCompanion = """
+-/** The smallest value representable as a @name at . */
+-final val MinValue = @boxed at .MIN_VALUE
+-
+-/** The largest value representable as a @name at . */
+-final val MaxValue = @boxed at .MAX_VALUE
+-"""
+-
+- def floatingCompanion = """
+-/** The smallest positive value greater than @zero@ which is
+- * representable as a @name at .
+- */
+-final val MinPositiveValue = @boxed at .MIN_VALUE
+-final val NaN = @boxed at .NaN
+-final val PositiveInfinity = @boxed at .POSITIVE_INFINITY
+-final val NegativeInfinity = @boxed at .NEGATIVE_INFINITY
+-
+-/** The negative number with the greatest (finite) absolute value which is representable
+- * by a @name at . Note that it differs from [[java.lang. at name@.MIN_VALUE]], which
+- * is the smallest positive value representable by a @name at . In Scala that number
+- * is called @name at .MinPositiveValue.
+- */
+-final val MinValue = - at boxed@.MAX_VALUE
+-
+-/** The largest finite positive number representable as a @name at . */
+-final val MaxValue = @boxed at .MAX_VALUE
+-"""
+-}
+-
+-class AnyVals extends AnyValReps with AnyValTemplates {
+- object B extends AnyValNum("Byte", Some("8-bit signed integer"), "byte")
+- object S extends AnyValNum("Short", Some("16-bit signed integer"), "short")
+- object C extends AnyValNum("Char", Some("16-bit unsigned integer"), "char")
+- object I extends AnyValNum("Int", Some("32-bit signed integer"), "int")
+- object L extends AnyValNum("Long", Some("64-bit signed integer"), "long")
+- object F extends AnyValNum("Float", Some("32-bit IEEE-754 floating point number"), "float")
+- object D extends AnyValNum("Double", Some("64-bit IEEE-754 floating point number"), "double")
+- object Z extends AnyValRep("Boolean", None, "boolean") {
+- def classLines = """
+-/** Negates a Boolean expression.
+- *
+- * - `!a` results in `false` if and only if `a` evaluates to `true` and
+- * - `!a` results in `true` if and only if `a` evaluates to `false`.
+- *
+- * @return the negated expression
+- */
+-def unary_! : Boolean
+-
+-/** Compares two Boolean expressions and returns `true` if they evaluate to the same value.
+- *
+- * `a == b` returns `true` if and only if
+- * - `a` and `b` are `true` or
+- * - `a` and `b` are `false`.
+- */
+-def ==(x: Boolean): Boolean
+-
+-/**
+- * Compares two Boolean expressions and returns `true` if they evaluate to a different value.
+- *
+- * `a != b` returns `true` if and only if
+- * - `a` is `true` and `b` is `false` or
+- * - `a` is `false` and `b` is `true`.
+- */
+-def !=(x: Boolean): Boolean
+-
+-/** Compares two Boolean expressions and returns `true` if one or both of them evaluate to true.
+- *
+- * `a || b` returns `true` if and only if
+- * - `a` is `true` or
+- * - `b` is `true` or
+- * - `a` and `b` are `true`.
+- *
+- * @note This method uses 'short-circuit' evaluation and
+- * behaves as if it was declared as `def ||(x: => Boolean): Boolean`.
+- * If `a` evaluates to `true`, `true` is returned without evaluating `b`.
+- */
+-def ||(x: Boolean): Boolean
+-
+-/** Compares two Boolean expressions and returns `true` if both of them evaluate to true.
+- *
+- * `a && b` returns `true` if and only if
+- * - `a` and `b` are `true`.
+- *
+- * @note This method uses 'short-circuit' evaluation and
+- * behaves as if it was declared as `def &&(x: => Boolean): Boolean`.
+- * If `a` evaluates to `false`, `false` is returned without evaluating `b`.
+- */
+-def &&(x: Boolean): Boolean
+-
+-// Compiler won't build with these seemingly more accurate signatures
+-// def ||(x: => Boolean): Boolean
+-// def &&(x: => Boolean): Boolean
+-
+-/** Compares two Boolean expressions and returns `true` if one or both of them evaluate to true.
+- *
+- * `a | b` returns `true` if and only if
+- * - `a` is `true` or
+- * - `b` is `true` or
+- * - `a` and `b` are `true`.
+- *
+- * @note This method evaluates both `a` and `b`, even if the result is already determined after evaluating `a`.
+- */
+-def |(x: Boolean): Boolean
+-
+-/** Compares two Boolean expressions and returns `true` if both of them evaluate to true.
+- *
+- * `a & b` returns `true` if and only if
+- * - `a` and `b` are `true`.
+- *
+- * @note This method evaluates both `a` and `b`, even if the result is already determined after evaluating `a`.
+- */
+-def &(x: Boolean): Boolean
+-
+-/** Compares two Boolean expressions and returns `true` if they evaluate to a different value.
+- *
+- * `a ^ b` returns `true` if and only if
+- * - `a` is `true` and `b` is `false` or
+- * - `a` is `false` and `b` is `true`.
+- */
+-def ^(x: Boolean): Boolean
+-
+-override def getClass(): Class[Boolean] = null
+- """.trim.lines.toList
+-
+- def objectLines = interpolate(allCompanions + "\n" + nonUnitCompanions).lines.toList
+- }
+- object U extends AnyValRep("Unit", None, "void") {
+- override def classDoc = """
+-/** `Unit` is a subtype of [[scala.AnyVal]]. There is only one value of type
+- * `Unit`, `()`, and it is not represented by any object in the underlying
+- * runtime system. A method with return type `Unit` is analogous to a Java
+- * method which is declared `void`.
+- */
+-"""
+- def classLines = List(
+- """override def getClass(): Class[Unit] = null"""
+- )
+- def objectLines = interpolate(allCompanions).lines.toList
+-
+- override def boxUnboxImpls = Map(
+- "@boxRunTimeDoc@" -> "",
+- "@boxImpl@" -> "scala.runtime.BoxedUnit.UNIT",
+- "@unboxRunTimeDoc@" -> "",
+- "@unboxImpl@" -> "()",
+- "@unboxDoc@" -> "the Unit value ()"
+- )
+- }
+-
+- def isSubrangeType = Set(B, S, C)
+- def isIntegerType = Set(B, S, C, I, L)
+- def isFloatingType = Set(F, D)
+- def isWideType = Set(L, D)
+-
+- def cardinal = numeric filter isIntegerType
+- def numeric = List(B, S, C, I, L, F, D)
+- def values = List(U, Z) ++ numeric
+-
+- def make() = values map (x => (x.name, x.make()))
+-}
+diff --git a/src/compiler/scala/tools/cmd/gen/Codegen.scala b/src/compiler/scala/tools/cmd/gen/Codegen.scala
+index c3aa527..d699eb9 100644
+--- a/src/compiler/scala/tools/cmd/gen/Codegen.scala
++++ b/src/compiler/scala/tools/cmd/gen/Codegen.scala
+@@ -25,7 +25,7 @@ object Codegen {
+
+ echo("Generating sources into " + out)
+
+- if (anyvals || all) {
++ /*if (anyvals || all) {
+ val av = new AnyVals { }
+
+ av.make() foreach { case (name, code ) =>
+@@ -33,7 +33,7 @@ object Codegen {
+ echo("Writing: " + file)
+ file writeAll code
+ }
+- }
++ }*/
+ }
+ }
+
+diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
+index 5ec16e8..61f02e7 100644
+--- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
++++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
+@@ -617,7 +617,7 @@ trait Contexts { self: Analyzer =>
+
+ def enclosingContextChain: List[Context] = this :: outer.enclosingContextChain
+
+- private def treeTruncated = tree.toString.replaceAll("\\s+", " ").lines.mkString("\\n").take(70)
++ private def treeTruncated = tree.toString.replaceAll("\\s+", " ").linesIterator.mkString("\\n").take(70)
+ private def treeIdString = if (settings.uniqid.value) "#" + System.identityHashCode(tree).toString.takeRight(3) else ""
+ private def treeString = tree match {
+ case x: Import => "" + x
+diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+index ac0a653..7aa801d 100644
+--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
++++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+@@ -4519,7 +4519,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
+ if (e.errPos == tree.pos) {
+ val header = f"${e.errMsg}%n Expression does not convert to assignment because:%n "
+ val expansion = f"%n expansion: ${show(convo)}"
+- NormalTypeError(tree, err.errors.flatMap(_.errMsg.lines.toList).mkString(header, f"%n ", expansion))
++ NormalTypeError(tree, err.errors.flatMap(_.errMsg.linesIterator.toList).mkString(header, f"%n ", expansion))
+ } else e
+ }
+ def advice2(errors: List[AbsTypeError]): List[AbsTypeError] =
+diff --git a/src/compiler/scala/tools/util/PathResolver.scala b/src/compiler/scala/tools/util/PathResolver.scala
+index 88b29c0..d28be41 100644
+--- a/src/compiler/scala/tools/util/PathResolver.scala
++++ b/src/compiler/scala/tools/util/PathResolver.scala
+@@ -39,7 +39,7 @@ object PathResolver {
+ }
+ implicit class AsLines(val s: String) extends AnyVal {
+ // sm"""...""" could do this in one pass
+- def asLines = s.trim.stripMargin.lines.mkLines
++ def asLines = s.trim.stripMargin.linesIterator.mkLines
+ }
+
+ /** pretty print class path */
+diff --git a/src/interactive/scala/tools/nsc/interactive/tests/InteractiveTestSettings.scala b/src/interactive/scala/tools/nsc/interactive/tests/InteractiveTestSettings.scala
+index ad5c61b..5c2588d 100644
+--- a/src/interactive/scala/tools/nsc/interactive/tests/InteractiveTestSettings.scala
++++ b/src/interactive/scala/tools/nsc/interactive/tests/InteractiveTestSettings.scala
+@@ -57,7 +57,7 @@ trait InteractiveTestSettings extends TestSettings with PresentationCompilerInst
+ val str = try File(optsFile).slurp() catch {
+ case e: java.io.IOException => ""
+ }
+- str.lines.filter(!_.startsWith(CommentStartDelimiter)).mkString(" ")
++ str.linesIterator.filter(!_.startsWith(CommentStartDelimiter)).mkString(" ")
+ }
+
+ override protected def printClassPath(implicit reporter: Reporter) {
+diff --git a/src/reflect/scala/reflect/internal/util/StringOps.scala b/src/reflect/scala/reflect/internal/util/StringOps.scala
+index efb8126..229b35c 100644
+--- a/src/reflect/scala/reflect/internal/util/StringOps.scala
++++ b/src/reflect/scala/reflect/internal/util/StringOps.scala
+@@ -45,7 +45,7 @@ trait StringOps {
+ else s.substring(0, end)
+ }
+ /** Breaks the string into lines and strips each line before reassembling. */
+- def trimAllTrailingSpace(s: String): String = s.lines map trimTrailingSpace mkString EOL
++ def trimAllTrailingSpace(s: String): String = s.linesIterator.map(trimTrailingSpace).mkString(EOL)
+
+ def decompose(str: String, sep: Char): List[String] = {
+ def ws(start: Int): List[String] =
+diff --git a/src/repl-jline/scala/tools/nsc/interpreter/jline/JLineHistory.scala b/src/repl-jline/scala/tools/nsc/interpreter/jline/JLineHistory.scala
+index 3bc2592..5f4bedf 100644
+--- a/src/repl-jline/scala/tools/nsc/interpreter/jline/JLineHistory.scala
++++ b/src/repl-jline/scala/tools/nsc/interpreter/jline/JLineHistory.scala
+@@ -40,7 +40,7 @@ trait JLineHistory extends JHistory with History {
+ def moveToEnd(): Unit
+
+ override def historicize(text: String): Boolean = {
+- text.lines foreach add
++ text.linesIterator foreach add
+ moveToEnd()
+ true
+ }
+diff --git a/src/repl/scala/tools/nsc/interpreter/Formatting.scala b/src/repl/scala/tools/nsc/interpreter/Formatting.scala
+index 4a95487..a2b5801 100644
+--- a/src/repl/scala/tools/nsc/interpreter/Formatting.scala
++++ b/src/repl/scala/tools/nsc/interpreter/Formatting.scala
+@@ -23,7 +23,7 @@ class Formatting(indent: Int) {
+ * This way, compiler error messages read better.
+ */
+ def indentCode(code: String) = stringFromWriter(str =>
+- for (line <- code.lines) {
++ for (line <- code.linesIterator) {
+ if (indenting(code)) str print indentation
+ str println line
+ str.flush()
+@@ -31,5 +31,5 @@ class Formatting(indent: Int) {
+ )
+ }
+ object Formatting {
+- def forPrompt(prompt: String) = new Formatting(prompt.lines.toList.last.length)
++ def forPrompt(prompt: String) = new Formatting(prompt.linesIterator.toList.last.length)
+ }
+diff --git a/src/repl/scala/tools/nsc/interpreter/ILoop.scala b/src/repl/scala/tools/nsc/interpreter/ILoop.scala
+index b086b21..d0aac3f 100644
+--- a/src/repl/scala/tools/nsc/interpreter/ILoop.scala
++++ b/src/repl/scala/tools/nsc/interpreter/ILoop.scala
+@@ -509,7 +509,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
+ tmp.safeSlurp() match {
+ case Some(edited) if edited.trim.isEmpty => echo("Edited text is empty.")
+ case Some(edited) =>
+- echo(edited.lines map ("+" + _) mkString "\n")
++ echo(edited.linesIterator map ("+" + _) mkString "\n")
+ val res = intp interpret edited
+ if (res == IR.Incomplete) diagnose(edited)
+ else {
+@@ -750,7 +750,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
+ val input = readWhile(s => delimiter.isEmpty || delimiter.get != s) mkString "\n"
+ val text = (
+ margin filter (_.nonEmpty) map {
+- case "-" => input.lines map (_.trim) mkString "\n"
++ case "-" => input.linesIterator map (_.trim) mkString "\n"
+ case m => input stripMargin m.head // ignore excess chars in "<<||"
+ } getOrElse input
+ ).trim
+diff --git a/src/repl/scala/tools/nsc/interpreter/IMain.scala b/src/repl/scala/tools/nsc/interpreter/IMain.scala
+index dc8b620..7809576 100644
+--- a/src/repl/scala/tools/nsc/interpreter/IMain.scala
++++ b/src/repl/scala/tools/nsc/interpreter/IMain.scala
+@@ -652,7 +652,7 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set
+ if (printResults && result != "")
+ printMessage(result stripSuffix "\n")
+ else if (isReplDebug) // show quiet-mode activity
+- printMessage(result.trim.lines map ("[quiet] " + _) mkString "\n")
++ printMessage(result.trim.linesIterator map ("[quiet] " + _) mkString "\n")
+
+ // Book-keeping. Have to record synthetic requests too,
+ // as they may have been issued for information, e.g. :type
+@@ -1258,7 +1258,7 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set
+ /** Secret bookcase entrance for repl debuggers: end the line
+ * with "// show" and see what's going on.
+ */
+- def isShow = code.lines exists (_.trim endsWith "// show")
++ def isShow = code.linesIterator exists (_.trim endsWith "// show")
+ if (isReplDebug || isShow) {
+ beSilentDuring(parse(code)) match {
+ case parse.Success(ts) =>
+diff --git a/src/repl/scala/tools/nsc/interpreter/Pasted.scala b/src/repl/scala/tools/nsc/interpreter/Pasted.scala
+index 3a7eda1..479dc96 100644
+--- a/src/repl/scala/tools/nsc/interpreter/Pasted.scala
++++ b/src/repl/scala/tools/nsc/interpreter/Pasted.scala
+@@ -19,7 +19,7 @@ abstract class Pasted(prompt: String) {
+ def interpret(line: String): IR.Result
+ def echo(message: String): Unit
+
+- val PromptString = prompt.lines.toList.last
++ val PromptString = prompt.linesIterator.toList.last
+ val AltPromptString = "scala> "
+ val ContinuePrompt = replProps.continuePrompt
+ val ContinueString = replProps.continueText // " | "
+diff --git a/src/repl/scala/tools/nsc/interpreter/Power.scala b/src/repl/scala/tools/nsc/interpreter/Power.scala
+index a14a60d..b14aef6 100644
+--- a/src/repl/scala/tools/nsc/interpreter/Power.scala
++++ b/src/repl/scala/tools/nsc/interpreter/Power.scala
+@@ -142,8 +142,6 @@ class Power[ReplValsImpl <: ReplVals : ru.TypeTag: ClassTag](val intp: IMain, re
+ |replImplicits._
+ |treedsl.CODE._""".stripMargin.lines
+
+- def init = customInit getOrElse initImports.mkString("import ", ", ", "")
+-
+ /** Quietly starts up power mode and runs whatever is in init.
+ */
+ def unleash(): Unit = beQuietDuring {
+@@ -151,8 +149,6 @@ class Power[ReplValsImpl <: ReplVals : ru.TypeTag: ClassTag](val intp: IMain, re
+ intp.bind("$r", replVals)
+ // Then we import everything from $r.
+ intp interpret s"import ${ intp.originalPath("$r") }._"
+- // And whatever else there is to do.
+- init.lines foreach (intp interpret _)
+ }
+
+ trait LowPriorityInternalInfo {
+diff --git a/src/repl/scala/tools/nsc/interpreter/ReplProps.scala b/src/repl/scala/tools/nsc/interpreter/ReplProps.scala
+index f3115d9..0726dce 100644
+--- a/src/repl/scala/tools/nsc/interpreter/ReplProps.scala
++++ b/src/repl/scala/tools/nsc/interpreter/ReplProps.scala
+@@ -52,7 +52,7 @@ class ReplProps {
+ val continueString = Prop[String]("scala.repl.continue").option getOrElse "| "
+ val continueText = {
+ val text = enversion(continueString)
+- val margin = promptText.lines.toList.last.length - text.length
++ val margin = promptText.linesIterator.toList.last.length - text.length
+ if (margin > 0) " " * margin + text else text
+ }
+ val continuePrompt = encolor(continueText)
+diff --git a/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala b/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala
+index f1c9663..82b20bc 100644
+--- a/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala
++++ b/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala
+@@ -203,7 +203,7 @@ trait CommentFactoryBase { this: MemberLookupBase =>
+ SafeTags.replaceAllIn(javadoclessComment, { mtch =>
+ java.util.regex.Matcher.quoteReplacement(safeTagMarker + mtch.matched + safeTagMarker)
+ })
+- markedTagComment.lines.toList map (cleanLine(_))
++ markedTagComment.linesIterator.toList map (cleanLine(_))
+ }
+
+ /** Parses a comment (in the form of a list of lines) to a `Comment`
=====================================
debian/patches/series
=====================================
@@ -8,3 +8,4 @@
0014-disable-jdk-check.patch
0015-java9-compatibility.patch
0016-nobootcp-by-default.patch
+0017-bug912393.patch
View it on GitLab: https://salsa.debian.org/java-team/scala/compare/e0e351530708d587c0da73b2335c02ba358d2b91...46da5d4c94c5aed0c158bf066365ce73add1db37
--
View it on GitLab: https://salsa.debian.org/java-team/scala/compare/e0e351530708d587c0da73b2335c02ba358d2b91...46da5d4c94c5aed0c158bf066365ce73add1db37
You're receiving this email because of your account on salsa.debian.org.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://alioth-lists.debian.net/pipermail/pkg-java-commits/attachments/20181110/a42e8e2a/attachment.html>
More information about the pkg-java-commits
mailing list