Merge pull request scala#4784 from lrytz/merge-2.11-to-2.12-oct-5

Merge 2.11 to 2.12 oct 5

Author: lrytz

.gitattributes

@@ -2,20 +2,24 @@
 # this must be first so later entries will override it
 * text=auto
 
+# check out text files with lf, not crlf, on Windows.  (especially
+# important for Scala source files, since """ preserves line endings)
+text eol=lf
+
 # These files are text and should be normalized (convert crlf => lf)
-*.c       text
-*.check   text
-*.css     text
-*.flags   text
-*.html    text
-*.java    text
-*.js      text
-*.policy  text
-*.sbt     text
-*.scala   text
-*.sh      text
-*.txt     text
-*.xml     text
+*.c       eol=lf
+*.check   eol=lf
+*.css     eol=lf
+*.flags   eol=lf
+*.html    eol=lf
+*.java    eol=lf
+*.js      eol=lf
+*.policy  eol=lf
+*.sbt     eol=lf
+*.scala   eol=lf
+*.sh      eol=lf
+*.txt     eol=lf
+*.xml     eol=lf
 
 # Windows-specific files get windows endings
 *.bat     eol=crlf

README.md

@@ -154,6 +154,10 @@ ideas and coordinate your effort with others.
 
 NOTE: we are working on migrating the build to sbt.
 
+If you are behind a HTTP proxy, include
+[`ANT_ARGS=-autoproxy`](https://ant.apache.org/manual/proxy.html) in
+your environment.
+
 Run `ant build-opt` to build an optimized version of the compiler.
 Verify your build using `ant test-opt`.
 

spec/08-pattern-matching.md

@@ -507,7 +507,7 @@ def f[B](t: Term[B]): B = t match {
 The expected type of the pattern `y: Number` is
 `Term[B]`.  The type `Number` does not conform to
 `Term[B]`; hence Case 2 of the rules above
-applies. This means that `b` is treated as another type
+applies. This means that `B` is treated as another type
 variable for which subtype constraints are inferred. In our case the
 applicable constraint is `Number <: Term[B]`, which
 entails `B = Int`.  Hence, `B` is treated in

src/compiler/scala/tools/ant/templates/tool-unix.tmpl

@@ -67,6 +67,11 @@ if uname | grep -q ^MINGW; then
   mingw="$(uname)"
 fi
 
+unset msys
+if uname | grep -q ^MSYS; then
+  msys="$(uname)"
+fi
+
 # Finding the root folder for this Scala distribution
 SCALA_HOME="$(findScalaHome)"
 SEP=":"
@@ -111,9 +116,9 @@ if [[ -n "$cygwin" ]]; then
     TOOL_CLASSPATH="$(cygpath --path --$format "$TOOL_CLASSPATH")"
 fi
 
-if [[ -n "$cygwin$mingw" ]]; then
+if [[ -n "$cygwin$mingw$msys" ]]; then
     case "$TERM" in
-        rxvt* | xterm*)
+        rxvt* | xterm* | cygwin*)
             stty -icanon min 1 -echo
             WINDOWS_OPT="-Djline.terminal=unix"
         ;;
@@ -182,10 +187,10 @@ fi
 
 declare -a classpath_args
 
-# default to the boot classpath for speed, except on cygwin/mingw because
+# default to the boot classpath for speed, except on cygwin/mingw/msys because
 # JLine on Windows requires a custom DLL to be loaded.
 unset usebootcp
-if [[ -z "$cygwin$mingw" ]]; then
+if [[ -z "$cygwin$mingw$msys" ]]; then
   usebootcp="true"
 fi
 

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

@@ -1690,7 +1690,10 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
       try {
         val stream = new FileOutputStream(file)
         printer.setWriter(new PrintWriter(stream, true))
-        printer.printClass(cls)
+        try
+          printer.printClass(cls)
+        finally
+          stream.close()
         informProgress(s"wrote $file")
       } catch {
         case e: IOException =>

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

@@ -2692,7 +2692,10 @@ self =>
           case t if t == SUPERTYPE || t == SUBTYPE || t == COMMA || t == RBRACE || isStatSep(t) =>
             TypeDef(mods | Flags.DEFERRED, name, tparams, typeBounds())
           case _ =>
-            syntaxErrorOrIncompleteAnd("`=', `>:', or `<:' expected", skipIt = true)(EmptyTree)
+            syntaxErrorOrIncompleteAnd("`=', `>:', or `<:' expected", skipIt = true)(
+              // assume a dummy type def so as to have somewhere to stash the annotations
+              TypeDef(mods, tpnme.ERROR, Nil, EmptyTree)
+            )
         }
       }
     }
@@ -2725,7 +2728,10 @@ self =>
         case CASEOBJECT =>
           objectDef(pos, (mods | Flags.CASE) withPosition (Flags.CASE, tokenRange(in.prev /*scanner skips on 'case' to 'object', thus take prev*/)))
         case _ =>
-          syntaxErrorOrIncompleteAnd("expected start of definition", skipIt = true)(EmptyTree)
+          syntaxErrorOrIncompleteAnd("expected start of definition", skipIt = true)(
+            // assume a class definition so as to have somewhere to stash the annotations
+            atPos(pos)(gen.mkClassDef(mods, tpnme.ERROR, Nil, Template(Nil, noSelfType, Nil)))
+          )
       }
     }
 

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

@@ -459,4 +459,4 @@ class InitialProducerSourceInterpreter extends SourceInterpreter {
   override def newExceptionValue(tryCatchBlockNode: TryCatchBlockNode, handlerFrame: Frame[_ <: Value], exceptionType: Type): SourceValue = {
     new SourceValue(1, ExceptionProducer(handlerFrame))
   }
-}
+}

src/compiler/scala/tools/nsc/transform/UnCurry.scala

@@ -475,13 +475,6 @@ abstract class UnCurry extends InfoTransform
               withNeedLift(needLift = true) { super.transform(tree) }
             else
               super.transform(tree)
-          case UnApply(fn, args) =>
-            val fn1   = transform(fn)
-            val args1 = fn.symbol.name match {
-              case nme.unapplySeq => transformArgs(tree.pos, fn.symbol, args, patmat.alignPatterns(global.typer.context, tree).expectedTypes)
-              case _              => args
-            }
-            treeCopy.UnApply(tree, fn1, args1)
 
           case Apply(fn, args) =>
             val needLift = needTryLift || !fn.symbol.isLabel // SI-6749, no need to lift in args to label jumps.

src/compiler/scala/tools/nsc/transform/patmat/PatternExpander.scala

@@ -86,9 +86,25 @@ trait PatternExpander[Pattern, Type] {
    *  @param  fixed     The non-sequence types which are extracted
    *  @param  repeated  The sequence type which is extracted
    */
-  final case class Extractor(whole: Type, fixed: List[Type], repeated: Repeated) {
+  final case class Extractor(whole: Type, fixed: List[Type], repeated: Repeated, typeOfSinglePattern: Type) {
     require(whole != NoType, s"expandTypes($whole, $fixed, $repeated)")
 
+    /** A pattern with arity-1 that doesn't match the arity of the Product-like result of the `get` method,
+      * will match that result in its entirety. Example:
+      *
+      * {{{
+      * warning: there was one deprecation warning; re-run with -deprecation for details
+      * scala> object Extractor { def unapply(a: Any): Option[(Int, String)] = Some((1, "2")) }
+      * defined object Extractor
+      *
+      * scala> "" match { case Extractor(x: Int, y: String) => }
+      *
+      * scala> "" match { case Extractor(xy : (Int, String)) => }
+      * warning: there was one deprecation warning; re-run with -deprecation for details
+      * }}}
+      * */
+    def asSinglePattern: Extractor = copy(fixed = List(typeOfSinglePattern))
+
     def productArity = fixed.length
     def hasSeq       = repeated.exists
     def elementType  = repeated.elementType

src/compiler/scala/tools/nsc/transform/patmat/ScalacPatternExpanders.scala

@@ -43,8 +43,9 @@ trait ScalacPatternExpanders {
           orElse definitions.elementType(ArrayClass, seq)
       )
     }
-    def newExtractor(whole: Type, fixed: List[Type], repeated: Repeated): Extractor =
-      logResult(s"newExtractor($whole, $fixed, $repeated")(Extractor(whole, fixed, repeated))
+    def newExtractor(whole: Type, fixed: List[Type], repeated: Repeated, typeOfSinglePattern: Type): Extractor =
+      logResult(s"newExtractor($whole, $fixed, $repeated, $typeOfSinglePattern")(Extractor(whole, fixed, repeated, typeOfSinglePattern))
+    def newExtractor(whole: Type, fixed: List[Type], repeated: Repeated): Extractor = newExtractor(whole, fixed, repeated, tupleType(fixed))
 
     // Turn Seq[A] into Repeated(Seq[A], A, A*)
     def repeatedFromSeq(seqType: Type): Repeated = {
@@ -73,26 +74,27 @@ trait ScalacPatternExpanders {
      *  Unfortunately the MethodType does not carry the information of whether
      *  it was unapplySeq, so we have to funnel that information in separately.
      */
-    def unapplyMethodTypes(whole: Type, result: Type, isSeq: Boolean): Extractor = {
-      val expanded = (
-        if (result =:= BooleanTpe) Nil
-        else typeOfMemberNamedGet(result) match {
+    def unapplyMethodTypes(context: Context, whole: Type, result: Type, isSeq: Boolean): Extractor = {
+      if (result =:= BooleanTpe) newExtractor(whole, Nil, NoRepeated)
+      else {
+        val getResult = typeOfMemberNamedGet(result)
+        def noGetError() = {
+          val name = "unapply" + (if (isSeq) "Seq" else "")
+          context.error(context.tree.pos, s"The result type of an $name method must contain a member `get` to be used as an extractor pattern, no such member exists in ${result}")
+        }
+        val expanded = getResult match {
+          case global.NoType => noGetError(); Nil
           case rawGet if !hasSelectors(rawGet) => rawGet :: Nil
           case rawGet                          => typesOfSelectors(rawGet)
         }
-      )
-      expanded match {
-        case init :+ last if isSeq => newExtractor(whole, init, repeatedFromSeq(last))
-        case tps                   => newExtractor(whole, tps, NoRepeated)
+        expanded match {
+          case init :+ last if isSeq => newExtractor(whole, init, repeatedFromSeq(last), getResult)
+          case tps                   => newExtractor(whole, tps, NoRepeated, getResult)
+        }
       }
     }
   }
   object alignPatterns extends ScalacPatternExpander {
-    /** Converts a T => (A, B, C) extractor to a T => ((A, B, CC)) extractor.
-     */
-    def tupleExtractor(extractor: Extractor): Extractor =
-      extractor.copy(fixed = tupleType(extractor.fixed) :: Nil)
-
     private def validateAligned(context: Context, tree: Tree, aligned: Aligned): Aligned = {
       import aligned._
 
@@ -129,8 +131,8 @@ trait ScalacPatternExpanders {
       val isUnapply = sel.symbol.name == nme.unapply
 
       val extractor = sel.symbol.name match {
-        case nme.unapply    => unapplyMethodTypes(firstParamType(fn.tpe), sel.tpe, isSeq = false)
-        case nme.unapplySeq => unapplyMethodTypes(firstParamType(fn.tpe), sel.tpe, isSeq = true)
+        case nme.unapply    => unapplyMethodTypes(context, firstParamType(fn.tpe), sel.tpe, isSeq = false)
+        case nme.unapplySeq => unapplyMethodTypes(context, firstParamType(fn.tpe), sel.tpe, isSeq = true)
         case _              => applyMethodTypes(fn.tpe)
       }
 
@@ -142,12 +144,14 @@ trait ScalacPatternExpanders {
       def acceptMessage   = if (extractor.isErroneous) "" else s" to hold ${extractor.offeringString}"
       val requiresTupling = isUnapply && patterns.totalArity == 1 && productArity > 1
 
-      if (requiresTupling && effectivePatternArity(args) == 1) {
-        val sym = sel.symbol.owner
-        currentRun.reporting.deprecationWarning(sel.pos, sym, s"${sym} expects $productArity patterns$acceptMessage but crushing into $productArity-tuple to fit single pattern (SI-6675)")
-      }
-
-      val normalizedExtractor = if (requiresTupling) tupleExtractor(extractor) else extractor
+      val normalizedExtractor = if (requiresTupling) {
+        val tupled = extractor.asSinglePattern
+        if (effectivePatternArity(args) == 1 && isTupleType(extractor.typeOfSinglePattern)) {
+          val sym = sel.symbol.owner
+          currentRun.reporting.deprecationWarning(sel.pos, sym, s"${sym} expects $productArity patterns$acceptMessage but crushing into $productArity-tuple to fit single pattern (SI-6675)")
+        }
+        tupled
+      } else extractor
       validateAligned(context, fn, Aligned(patterns, normalizedExtractor))
     }