Merge branch '2.12.x' into merge-2.11.x-to-2.12.x-20170214

Author: SethTisue

bincompat-forward.whitelist.conf

@@ -407,6 +407,14 @@ filter {
     {
         matchName="scala.collection.immutable.$colon$colon"
         problemName=MissingTypesProblem
+    },
+    {
+      matchName="scala.annotation.showAsInfix$"
+      problemName=MissingClassProblem
+    },
+    {
+      matchName="scala.annotation.showAsInfix"
+      problemName=MissingClassProblem
     }
   ]
 }

project/PartestUtil.scala

@@ -90,6 +90,6 @@ object PartestUtil {
     val ScalacOptsParser = (token("-Dpartest.scalac_opts=") ~ token(NotSpace)) map { case opt ~ v => opt + v }
 
     val P = oneOf(knownUnaryOptions.map(x => token(x))) | SrcPath | TestPathParser | Grep | ScalacOptsParser
-    (Space ~> repsep(P, oneOrMore(Space))).map(_.mkString(" ")).?.map(_.getOrElse("")) <~ OptSpace
+    (Space ~> repsep(P, oneOrMore(Space))).map(_.mkString(" ")).?.map(_.getOrElse(""))
   }
 }

scripts/jobs/integrate/bootstrap

@@ -178,8 +178,7 @@ sbtResolve() {
       'show update' >> $baseDir/logs/resolution 2>&1
 }
 
-# Oh boy... can't use scaladoc to document scala-xml/scala-parser-combinators
-# if scaladoc depends on the same version of scala-xml/scala-parser-combinators.
+# Oh boy... can't use scaladoc to document scala-xml if scaladoc depends on the same version of scala-xml.
 # Even if that version is available through the project's resolvers, sbt won't look past this project.
 # SOOOOO, we set the version to a dummy (-DOC), generate documentation,
 # then set the version to the right one and publish (which won't re-gen the docs).
@@ -216,17 +215,6 @@ buildXML() {
   fi
 }
 
-buildParsers() {
-  if [ "$PARSERS_BUILT" != "yes" ] && [ "$forceRebuild" != "yes" ] && ( sbtResolve "org.scala-lang.modules"  "scala-parser-combinators" $PARSERS_VER )
-  then echo "Found scala-parser-combinators $PARSERS_VER; not building."
-  else
-    update scala scala-parser-combinators "$PARSERS_REF" && gfxd
-    doc="$(docTask $PARSERS_BUILT)"
-    sbtBuild 'set version := "'$PARSERS_VER'-DOC"' $clean "$doc" 'set version := "'$PARSERS_VER'"' test "${buildTasks[@]}"
-    PARSERS_BUILT="yes"
-  fi
-}
-
 buildPartest() {
   if [ "$PARTEST_BUILT" != "yes" ] && [ "$forceRebuild" != "yes" ] && ( sbtResolve "org.scala-lang.modules"  "scala-partest" $PARTEST_VER )
   then echo "Found scala-partest $PARTEST_VER; not building."
@@ -238,17 +226,6 @@ buildPartest() {
   fi
 }
 
-buildSwing() {
-  if [ "$SWING_BUILT" != "yes" ] && [ "$forceRebuild" != "yes" ] && ( sbtResolve "org.scala-lang.modules"  "scala-swing" $SWING_VER )
-  then echo "Found scala-swing $SWING_VER; not building."
-  else
-    update scala scala-swing "$SWING_REF" && gfxd
-    doc="$(docTask $SWING_BUILT)"
-    sbtBuild 'set version := "'$SWING_VER'"' $clean "$doc" test "${buildTasks[@]}"
-    SWING_BUILT="yes"
-  fi
-}
-
 # should only be called with publishTasks publishing to private-repo
 buildScalaCheck(){
   if [ "$SCALACHECK_BUILT" != "yes" ] && [ "$forceRebuild" != "yes" ] && ( sbtResolve "org.scalacheck"  "scalacheck" $SCALACHECK_VER )
@@ -266,8 +243,6 @@ buildModules() {
   publishTasks=('set credentials += Credentials(Path.userHome / ".credentials-private-repo")' "set every publishTo := Some(\"private-repo\" at \"$releaseTempRepoUrl\")")
   buildTasks=($publishPrivateTask)
   buildXML
-  buildParsers
-  buildSwing
   # buildScalaCheck
   buildPartest
 }
@@ -276,8 +251,6 @@ buildPublishedModules() {
   publishTasks=('set credentials += Credentials(Path.userHome / ".credentials-sonatype")' "set pgpPassphrase := Some(Array.empty)")
   buildTasks=($publishSonatypeTaskModules)
   buildXML
-  buildParsers
-  buildSwing
   buildPartest
 }
 
@@ -381,36 +354,26 @@ deriveModuleVersions() {
   if [ "$moduleVersioning" == "versions.properties" ]; then
     # use versions.properties as defaults when no version specified on the command line
                   XML_VER=${XML_VER-$scala_xml_version_number}
-              PARSERS_VER=${PARSERS_VER-$scala_parser_combinators_version_number}
-                SWING_VER=${SWING_VER-$scala_swing_version_number}
               PARTEST_VER=${PARTEST_VER-$partest_version_number}
            SCALACHECK_VER=${SCALACHECK_VER-$scalacheck_version_number}
 
                   XML_REF="v$XML_VER"
-              PARSERS_REF="v$PARSERS_VER"
-                SWING_REF="v$SWING_VER"
               PARTEST_REF="v$PARTEST_VER"
            SCALACHECK_REF="$SCALACHECK_VER" # no `v` in their tags
    else
     # use HEAD as default when no revision is specified on the command line
                  XML_REF=${XML_REF-"HEAD"}
-             PARSERS_REF=${PARSERS_REF-"HEAD"}
-               SWING_REF=${SWING_REF-"HEAD"}
              PARTEST_REF=${PARTEST_REF-"HEAD"}
           SCALACHECK_REF=${SCALACHECK_REF-"HEAD"}
 
                  XML_VER=$(deriveVersion scala scala-xml "$XML_REF")
-             PARSERS_VER=$(deriveVersion scala scala-parser-combinators "$PARSERS_REF")
-               SWING_VER=$(deriveVersion scala scala-swing "$SWING_REF")
              PARTEST_VER=$(deriveVersion scala scala-partest "$PARTEST_REF")
           SCALACHECK_VER=$(deriveVersionAnyTag rickynils scalacheck "$SCALACHECK_REF")
   fi
 
   echo "Module versions (versioning strategy: $moduleVersioning):"
-  echo "PARSERS          = $PARSERS_VER at $PARSERS_REF"
   echo "PARTEST          = $PARTEST_VER at $PARTEST_REF"
   # echo "SCALACHECK       = $SCALACHECK_VER at $SCALACHECK_REF"
-  echo "SWING            = $SWING_VER at $SWING_REF"
   echo "XML              = $XML_VER at $XML_REF"
 
 }
@@ -444,8 +407,6 @@ constructUpdatedModuleVersions() {
   # force the new module versions for building the core. these may be different from the values in versions.properties,
   # either because the variables (XML_VER) were provided, or because we're building the modules from HEAD.
   # in the common case, the values are the same as in versions.properties.
-  updatedModuleVersions=("${updatedModuleVersions[@]}" "-Dscala-parser-combinators.version.number=$PARSERS_VER")
-  updatedModuleVersions=("${updatedModuleVersions[@]}" "-Dscala-swing.version.number=$SWING_VER")
   updatedModuleVersions=("${updatedModuleVersions[@]}" "-Dscala-xml.version.number=$XML_VER")
 
   updatedModuleVersions=("${updatedModuleVersions[@]}" "-Dpartest.version.number=$PARTEST_VER")

src/compiler/scala/tools/nsc/Global.scala

@@ -1198,7 +1198,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
       first
     }
 
-    // --------------- Miscellania -------------------------------
+    // --------------- Miscellanea -------------------------------
 
     /** Progress tracking.  Measured in "progress units" which are 1 per
      *  compilation unit per phase completed.

src/compiler/scala/tools/nsc/PhaseAssembly.scala

@@ -17,7 +17,7 @@ trait PhaseAssembly {
   self: Global =>
 
   /**
-   * Aux datastructure for solving the constraint system
+   * Aux data structure for solving the constraint system
    * The dependency graph container with helper methods for node and edge creation
    */
   private class DependencyGraph {

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

@@ -1263,8 +1263,8 @@ self =>
         case CHARLIT                => in.charVal
         case INTLIT                 => in.intVal(isNegated).toInt
         case LONGLIT                => in.intVal(isNegated)
-        case FLOATLIT               => in.floatVal(isNegated).toFloat
-        case DOUBLELIT              => in.floatVal(isNegated)
+        case FLOATLIT               => in.floatVal(isNegated)
+        case DOUBLELIT              => in.doubleVal(isNegated)
         case STRINGLIT | STRINGPART => in.strVal.intern()
         case TRUE                   => true
         case FALSE                  => false

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

@@ -983,23 +983,45 @@ trait Scanners extends ScannersCommon {
 
     def intVal: Long = intVal(negated = false)
 
-    /** Convert current strVal, base to double value
+    /** Convert current strVal, base to float value.
      */
-    def floatVal(negated: Boolean): Double = {
-      val limit: Double = if (token == DOUBLELIT) Double.MaxValue else Float.MaxValue
+    def floatVal(negated: Boolean): Float = {
       try {
-        val value: Double = java.lang.Double.valueOf(strVal).doubleValue()
-        if (value > limit)
+        val value: Float = java.lang.Float.parseFloat(strVal)
+        if (value > Float.MaxValue)
           syntaxError("floating point number too large")
+        val zeroly = "0.fF"
+        if (value == 0.0f && strVal.exists(c => !zeroly.contains(c)))
+          syntaxError("floating point number too small")
         if (negated) -value else value
       } catch {
         case _: NumberFormatException =>
           syntaxError("malformed floating point number")
+          0.0f
+      }
+    }
+
+    def floatVal: Float = floatVal(negated = false)
+
+    /** Convert current strVal, base to double value.
+     */
+    def doubleVal(negated: Boolean): Double = {
+      try {
+        val value: Double = java.lang.Double.parseDouble(strVal)
+        if (value > Double.MaxValue)
+          syntaxError("double precision floating point number too large")
+        val zeroly = "0.dD"
+        if (value == 0.0d && strVal.exists(c => !zeroly.contains(c)))
+          syntaxError("double precision floating point number too small")
+        if (negated) -value else value
+      } catch {
+        case _: NumberFormatException =>
+          syntaxError("malformed double precision floating point number")
           0.0
       }
     }
 
-    def floatVal: Double = floatVal(negated = false)
+    def doubleVal: Double = doubleVal(negated = false)
 
     def checkNoLetter(): Unit = {
       if (isIdentifierPart(ch) && ch >= ' ')

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

@@ -33,7 +33,7 @@ object AsmUtils {
   final val traceClassPattern = ""
 
   /**
-   * Print the bytedcode of classes as they are serialized by the ASM library. The serialization
+   * Print the bytecode of classes as they are serialized by the ASM library. The serialization
    * performed by `asm.ClassWriter` can change the code generated by GenBCode. For example, it
    * introduces stack map frames, it computes the maximal stack sizes, and it replaces dead
    * code by NOPs (see also https://github.com/scala/scala/pull/3726#issuecomment-42861780).

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

@@ -918,7 +918,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
         (args zip params) filterNot isTrivial
       }
 
-      // first push *all* arguments. This makes sure muliple uses of the same labelDef-var will all denote the (previous) value.
+      // first push *all* arguments. This makes sure multiple uses of the same labelDef-var will all denote the (previous) value.
       aps foreach { case (arg, param) => genLoad(arg, locals(param).tk) } // `locals` is known to contain `param` because `genDefDef()` visited `labelDefsAtOrUnder`
 
       // second assign one by one to the LabelDef's variables.

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

@@ -188,7 +188,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
    * Data for emitting an EnclosingMethod attribute. None if `classSym` is a member class (not
    * an anonymous or local class). See doc in BTypes.
    *
-   * The class is parametrized by two functions to obtain a bytecode class descriptor for a class
+   * The class is parameterized by two functions to obtain a bytecode class descriptor for a class
    * symbol, and to obtain a method signature descriptor fro a method symbol. These function depend
    * on the implementation of GenASM / GenBCode, so they need to be passed in.
    */
@@ -332,7 +332,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
             failNoForwarder("companion contains its own main method (implementation restriction: no main is allowed, regardless of signature)")
           else if (companion.isTrait)
             failNoForwarder("companion is a trait")
-          // Now either succeeed, or issue some additional warnings for things which look like
+          // Now either succeed, or issue some additional warnings for things which look like
           // attempts to be java main methods.
         else (possibles exists definitions.isJavaMainMethod) || {
             possibles exists { m =>
@@ -541,9 +541,9 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
      * symbol (sym.annotations) or type (as an AnnotatedType, eliminated by erasure).
      *
      * For Scala annotations this is OK: they are stored in the pickle and ignored by the backend.
-     * Java annoations on the other hand are additionally emitted to the classfile in Java's format.
+     * Java annotations on the other hand are additionally emitted to the classfile in Java's format.
      *
-     * This means that [[Type]] instances within an AnnotaionInfo reach the backend non-erased. Examples:
+     * This means that [[Type]] instances within an AnnotationInfo reach the backend non-erased. Examples:
      *   - @(javax.annotation.Resource @annotation.meta.getter) val x = 0
      *     Here, annotationInfo.atp is an AnnotatedType.
      *   - @SomeAnnotation[T] val x = 0

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

@@ -83,7 +83,7 @@ abstract class BTypes {
   val callsitePositions: concurrent.Map[MethodInsnNode, Position] = recordPerRunCache(TrieMap.empty)
 
   /**
-   * Stores callsite instructions of invocatinos annotated `f(): @inline/noinline`.
+   * Stores callsite instructions of invocations annotated `f(): @inline/noinline`.
    * Instructions are added during code generation (BCodeBodyBuilder). The maps are then queried
    * when building the CallGraph, every Callsite object has an annotated(No)Inline field.
    */
@@ -287,7 +287,7 @@ abstract class BTypes {
     }
 
     // The InlineInfo is built from the classfile (not from the symbol) for all classes that are NOT
-    // being compiled. For those classes, the info is only needed if the inliner is enabled, othewise
+    // being compiled. For those classes, the info is only needed if the inliner is enabled, otherwise
     // we can save the memory.
     if (!compilerSettings.optInlinerEnabled) BTypes.EmptyInlineInfo
     else fromClassfileAttribute getOrElse fromClassfileWithoutAttribute
@@ -653,7 +653,7 @@ abstract class BTypes {
    * Fields in the InnerClass entries:
    *  - inner class: the (nested) class C we are talking about
    *  - outer class: the class of which C is a member. Has to be null for non-members, i.e. for
-   *                 local and anonymous classes. NOTE: this co-incides with the presence of an
+   *                 local and anonymous classes. NOTE: this coincides with the presence of an
    *                 EnclosingMethod attribute (see below)
    *  - inner name:  A string with the simple name of the inner class. Null for anonymous classes.
    *  - flags:       access property flags, details in JVMS, table in 4.7.6. Static flag: see
@@ -702,7 +702,7 @@ abstract class BTypes {
    * local and anonymous classes, no matter if there is an enclosing method or not. Accordingly, the
    * "class" field (see below) must be always defined, while the "method" field may be null.
    *
-   * NOTE: When an EnclosingMethod attribute is requried (local and anonymous classes), the "outer"
+   * NOTE: When an EnclosingMethod attribute is required (local and anonymous classes), the "outer"
    * field in the InnerClass table must be null.
    *
    * Fields:
@@ -1144,7 +1144,7 @@ object BTypes {
   /**
    * Metadata about a ClassBType, used by the inliner.
    *
-   * More information may be added in the future to enable more elaborate inlinine heuristics.
+   * More information may be added in the future to enable more elaborate inline heuristics.
    * Note that this class should contain information that can only be obtained from the ClassSymbol.
    * Information that can be computed from the ClassNode should be added to the call graph instead.
    *

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

@@ -78,7 +78,7 @@ trait BytecodeWriters {
   }
 
   /*
-   * The ASM textual representation for bytecode overcomes disadvantages of javap ouput in three areas:
+   * The ASM textual representation for bytecode overcomes disadvantages of javap output in three areas:
    *    (a) pickle dingbats undecipherable to the naked eye;
    *    (b) two constant pools, while having identical contents, are displayed differently due to physical layout.
    *    (c) stack maps (classfile version 50 and up) are displayed in encoded form by javap,

src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala

@@ -382,7 +382,8 @@ class BackendUtils[BT <: BTypes](val btypes: BT) {
    * but not for writing in the classfile. We let the ClassWriter recompute max's.
    *
    * NOTE 2: the maxStack value computed here may be larger than the smallest correct value
-   * that would allow running an analyzer, see `InstructionStackEffect.forAsmAnalysisConservative`.
+   * that would allow running an analyzer, see `InstructionStackEffect.forAsmAnalysis` and
+   * `InstructionStackEffect.maxStackGrowth`.
    *
    * NOTE 3: the implementation doesn't look at instructions that cannot be reached, it computes
    * the max local / stack size in the reachable code. These max's work just fine for running an

src/compiler/scala/tools/nsc/backend/jvm/analysis/package.scala

@@ -110,7 +110,7 @@ package scala.tools.nsc.backend.jvm
  *  - Use YourKit for finding hotspots (cpu profiling). when it comes to drilling down into the details
  *    of a hotspot, don't pay too much attention to the percentages / time counts.
  *  - Should also try other profilers.
- *  - Use timers. When a method showed up as a hotspot, i added a timer around that method, and a
+ *  - Use timers. When a method showed up as a hotspot, I added a timer around that method, and a
  *    second one within the method to measure specific parts. The timers slow things down, but the
  *    relative numbers show what parts of a method are slow.
  *

src/compiler/scala/tools/nsc/backend/jvm/opt/BoxUnbox.scala

@@ -69,7 +69,7 @@ class BoxUnbox[BT <: BTypes](val btypes: BT) {
    * E1: M1 only works if there's a single boxing operation.
    *   def e1(b: Boolean) = {
    *     val i: Integer = box(10) // 10 is stored into a new local, box operation and i removed
-   *     val j: Integer = box(20) // 20 is stored into a new local, box operation adn j removed
+   *     val j: Integer = box(20) // 20 is stored into a new local, box operation and j removed
    *     val r = if (b) i else j  // loads and stores of the box are eliminated, r no longer exists
    *     unbox(r)                 // cannot rewrite: we don't know which local to load
    *   }
@@ -138,7 +138,7 @@ class BoxUnbox[BT <: BTypes](val btypes: BT) {
    *   - note that the MatchError creation is dead code: local2 is never null. However, our nullness
    *     analysis cannot identify this: it does not track nullness through tuple stores and loads.
    *   - if we re-write the non-escaping consumers of the outer tuple, but keep the tuple allocation
-   *     and the escaping consumer, we get the follwoing:
+   *     and the escaping consumer, we get the following:
    *
    *   load 1, load 2
    *   val newLocal1 = new Tuple2; load newLocal1  // stack: Tuple2
@@ -188,7 +188,7 @@ class BoxUnbox[BT <: BTypes](val btypes: BT) {
 
       var maxStackGrowth = 0
 
-      /** Mehtod M1 for eliminating box-unbox pairs (see doc comment in the beginning of this file) */
+      /** Method M1 for eliminating box-unbox pairs (see doc comment in the beginning of this file) */
       def replaceBoxOperationsSingleCreation(creation: BoxCreation, finalCons: Set[BoxConsumer], boxKind: BoxKind, keepBox: Boolean): Unit = {
         /**
          * If the box is eliminated, all copy operations (loads, stores, others) of the box need to