Merge branch 'master' of github.com:lampepfl/dotty into dotty-scopt

Author: dotbg

compiler/src/dotty/tools/dotc/core/PatternTypeConstrainer.scala

@@ -189,16 +189,14 @@ trait PatternTypeConstrainer { self: TypeComparer =>
       case _ => false
     }
 
-    def widenVariantParams = new TypeMap {
-      def apply(tp: Type) = mapOver(tp) match {
-        case tp @ AppliedType(tycon, args) =>
-          val args1 = args.zipWithConserve(tycon.typeParams)((arg, tparam) =>
-            if (tparam.paramVarianceSign != 0) TypeBounds.empty else arg
-          )
-          tp.derivedAppliedType(tycon, args1)
-        case tp =>
-          tp
-      }
+    def widenVariantParams(tp: Type) = tp match {
+      case tp @ AppliedType(tycon, args) =>
+        val args1 = args.zipWithConserve(tycon.typeParams)((arg, tparam) =>
+          if (tparam.paramVarianceSign != 0) TypeBounds.empty else arg
+        )
+        tp.derivedAppliedType(tycon, args1)
+      case tp =>
+        tp
     }
 
     val widePt =

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -531,6 +531,8 @@ class PlainPrinter(_ctx: Context) extends Printer {
     case ClazzTag => "classOf[" ~ toText(const.typeValue) ~ "]"
     case CharTag => literalText(s"'${escapedChar(const.charValue)}'")
     case LongTag => literalText(const.longValue.toString + "L")
+    case DoubleTag => literalText(const.doubleValue.toString + "d")
+    case FloatTag => literalText(const.floatValue.toString + "f")
     case _ => literalText(String.valueOf(const.value))
   }
 

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -1998,10 +1998,9 @@ import transform.SymUtils._
           |whose behavior may have changed since version change."""
   }
 
-  class UnableToEmitSwitch(tooFewCases: Boolean)(using Context)
+  class UnableToEmitSwitch()(using Context)
   extends SyntaxMsg(UnableToEmitSwitchID) {
-    def tooFewStr: String = if (tooFewCases) " since there are not enough cases" else ""
-    def msg = em"Could not emit switch for ${hl("@switch")} annotated match$tooFewStr"
+    def msg = em"Could not emit switch for ${hl("@switch")} annotated match"
     def explain = {
       val codeExample =
         """val ConstantB = 'B'

compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala

@@ -977,30 +977,32 @@ object PatternMatcher {
     /** If match is switch annotated, check that it translates to a switch
      *  with at least as many cases as the original match.
      */
-    private def checkSwitch(original: Match, result: Tree) = original.selector match {
+    private def checkSwitch(original: Match, result: Tree) = original.selector match
       case Typed(_, tpt) if tpt.tpe.hasAnnotation(defn.SwitchAnnot) =>
-        val resultCases = result match {
+        val resultCases = result match
           case Match(_, cases) => cases
           case Block(_, Match(_, cases)) => cases
+          case Block((_: ValDef) :: Block(_, Match(_, cases)) :: Nil, _) => cases
           case _ => Nil
-        }
-        def typesInPattern(pat: Tree): List[Type] = pat match {
+        val caseThreshold =
+          if ValueClasses.isDerivedValueClass(tpt.tpe.typeSymbol) then 1
+          else MinSwitchCases
+        def typesInPattern(pat: Tree): List[Type] = pat match
           case Alternative(pats) => pats.flatMap(typesInPattern)
           case _ => pat.tpe :: Nil
-        }
         def typesInCases(cdefs: List[CaseDef]): List[Type] =
           cdefs.flatMap(cdef => typesInPattern(cdef.pat))
         def numTypes(cdefs: List[CaseDef]): Int =
           typesInCases(cdefs).toSet.size: Int // without the type ascription, testPickling fails because of #2840.
-        if (numTypes(resultCases) < numTypes(original.cases)) {
+        val numTypesInOriginal = numTypes(original.cases)
+        if numTypesInOriginal >= caseThreshold && numTypes(resultCases) < numTypesInOriginal then
           patmatch.println(i"switch warning for ${ctx.compilationUnit}")
           patmatch.println(i"original types: ${typesInCases(original.cases)}%, %")
           patmatch.println(i"switch types  : ${typesInCases(resultCases)}%, %")
           patmatch.println(i"tree = $result")
-          report.warning(UnableToEmitSwitch(numTypes(original.cases) < MinSwitchCases), original.srcPos)
-        }
+          report.warning(UnableToEmitSwitch(), original.srcPos)
       case _ =>
-    }
+    end checkSwitch
 
     val optimizations: List[(String, Plan => Plan)] = List(
       "mergeTests" -> mergeTests,

compiler/src/dotty/tools/dotc/typer/RefChecks.scala

@@ -1,4 +1,5 @@
-package dotty.tools.dotc
+package dotty.tools
+package dotc
 package typer
 
 import transform._
@@ -800,7 +801,34 @@ object RefChecks {
         report.error(problem(), clazz.srcPos)
       }
 
+      // check that basetype and subtype agree on types of trait parameters
+      //
+      // I.e. trait and class parameters not only need to conform to the expected
+      // type of the corresponding base-trait, but also to the type as seen by the
+      // inheriting subtype.
+      def checkTraitParametersOK() = for {
+        parent <- clazz.info.parents
+        parentSym = parent.classSymbol
+        if parentSym.isClass
+        cls = parentSym.asClass
+        if cls.paramAccessors.nonEmpty
+        param <- cls.paramAccessors
+      } {
+        val tpeFromParent = parent.memberInfo(param)
+        val tpeFromClazz = clazz.thisType.memberInfo(param)
+        if (!(tpeFromParent <:< tpeFromClazz)) {
+          val msg =
+            em"""illegal parameter: The types of $param do not match.
+                |
+                |  $param in $cls has type: $tpeFromParent
+                |  but $clazz expects $param to have type: $tpeFromClazz"""
+
+          report.error(msg, clazz.srcPos)
+        }
+      }
+
       checkParameterizedTraitsOK()
+      checkTraitParametersOK()
     }
 
     /** Check that `site` does not inherit conflicting generic instances of `baseCls`,

docs/docs/reference/changed-features/eta-expansion.md

@@ -28,7 +28,7 @@ def next(): T
 ```
 
 Given a simple reference to `next` does not auto-convert to a function.
-One has to write explicitly `() => next()` to achieve that
+One has to write explicitly `() => next()` to achieve that.
 Once again since the `_` is going to be deprecated it's better to write it this way
 rather than `next _`.
 

docs/docs/reference/dropped-features/limit22.md

@@ -7,10 +7,10 @@ The limits of 22 for the maximal number of parameters of function types and the
 maximal number of fields in tuple types have been dropped.
 
 * Functions can now have an arbitrary number of parameters. Functions beyond
-  `Function22` are erased to a new trait `scala.FunctionXXL`
+  [`scala.Function22`](https://www.scala-lang.org/api/current/scala/Function22.html) are erased to a new trait [`scala.runtime.FunctionXXL`](https://dotty.epfl.ch/api/scala/runtime/FunctionXXL.html).
 
-* Tuples can also have an arbitrary number of fields. Tuples beyond `Tuple22`
-  are erased to a new trait `scala.TupleXXL`. Furthermore, they support generic
+* Tuples can also have an arbitrary number of fields. Tuples beyond [`scala.Tuple22`](https://www.scala-lang.org/api/current/scala/Tuple22.html)
+  are erased to a new class [`scala.runtime.TupleXXL`](https://dotty.epfl.ch/api/scala/runtime/TupleXXL.html) (which extends the trait [`scala.Product`](https://dotty.epfl.ch/api/scala/Product.html)). Furthermore, they support generic
   operation such as concatenation and indexing.
 
 Both of these are implemented using arrays.

docs/docs/reference/dropped-features/xml.md

@@ -4,7 +4,35 @@ title: "Dropped: XML Literals"
 ---
 
 XML Literals are still supported, but will be dropped in the near future, to
-be replaced with XML string interpolation:
+be replaced with [XML string interpolation](https://github.com/lampepfl/xml-interpolator):
+
 ```scala
-xml""" ... """
+import dotty.xml.interpolator.*
+
+case class Person(name: String) { override def toString = name }
+
+@main def test: Unit =
+  val bill = Person("Bill")
+  val john = Person("John")
+  val mike = Person("Mike")
+  val todoList = List(
+    (bill, john, "Meeting", "Room 203, 11:00am"),
+    (john, mike, "Holiday", "March 22-24")
+  )
+  // XML literals (to be dropped)
+  val mails1 = for (from, to, heading, body) <- todoList yield
+    <message>
+      <from>{from}</from><to>{to}</to>
+      <heading>{heading}</heading><body>{body}</body>
+    </message>
+  println(mails1)
+  // XML string interpolation
+  val mails2 = for (from, to, heading, body) <- todoList yield xml"""
+    <message>
+      <from>${from}</from><to>${to}</to>
+      <heading>${heading}</heading><body>${body}</body>
+    </message>"""
+  println(mails2)
 ```
+
+For more information, see the semester project [XML String Interpolator for Dotty](https://infoscience.epfl.ch/record/267527) by Yassin Kammoun (2019).

docs/docs/reference/metaprogramming/inline.md

@@ -181,11 +181,12 @@ Inline methods can override other non-inline methods. The rules are as follows:
 
 ### Relationship to `@inline`
 
-Scala 2 also defines a `@inline` annotation which is used as a hint
-for the backend to inline code. The `inline` modifier is a more powerful
-option: Expansion is guaranteed instead of best effort,
-it happens in the frontend instead of in the backend, and it also applies
-to recursive methods.
+Scala 2 also defines a `@inline` annotation which is used as a hint for the
+backend to inline code. The `inline` modifier is a more powerful option:
+
+- expansion is guaranteed instead of best effort,
+- expansion happens in the frontend instead of in the backend and
+- expansion also applies to recursive methods.
 
 To cross compile between both Scala 3 and Scala 2, we introduce a new `@forceInline`
 annotation which is equivalent to the new `inline` modifier. Note that
@@ -379,7 +380,7 @@ val intTwo: 2 = natTwo
 
 ## The `scala.compiletime` Package
 
-The `scala.compiletime` package contains helper definitions that provide support for compile time operations over values. They are described in the following.
+The [`scala.compiletime`](https://dotty.epfl.ch/api/scala/compiletime.html) package contains helper definitions that provide support for compile time operations over values. They are described in the following.
 
 ### `constValue`, `constValueOpt`, and the `S` combinator
 
@@ -499,7 +500,7 @@ fail(identity("foo")) // error: failed on: identity("foo")
 
 ### The `scala.compiletime.ops` package
 
-The `scala.compiletime.ops` package contains types that provide support for
+The [`scala.compiletime.ops`](https://dotty.epfl.ch/api/scala/compiletime/ops.html) package contains types that provide support for
 primitive operations on singleton types. For example,
 `scala.compiletime.ops.int.*` provides support for multiplying two singleton
 `Int` types, and `scala.compiletime.ops.boolean.&&` for the conjunction of two

docs/docs/reference/other-new-features/explicit-nulls.md

@@ -62,7 +62,7 @@ So far, we have found the following useful:
 
   When imported, `T | Null` can be used as `T`, similar to regular Scala (without explicit nulls).
 
-  See [UnsafeNulls](#UnsafeNulls) section for more details.
+  See [UnsafeNulls](#unsafenulls) section for more details.
 
 ## Unsoundness
 
@@ -425,7 +425,7 @@ When dealing with local mutable variables, there are two questions:
       x = null
    ```
 
-See [more examples](../../../../tests/explicit-nulls/neg/flow-varref-in-closure.scala).
+See [more examples](https://github.com/lampepfl/dotty/blob/master/tests/explicit-nulls/neg/flow-varref-in-closure.scala).
 
 Currently, we are unable to track paths with a mutable variable prefix.
 For example, `x.a` if `x` is mutable.

docs/docs/reference/other-new-features/opaques.md

@@ -6,7 +6,7 @@ title: "Opaque Type Aliases"
 Opaque types aliases provide type abstraction without any overhead. Example:
 
 ```scala
-object Logarithms:
+object MyMath:
 
    opaque type Logarithm = Double
 
@@ -27,21 +27,21 @@ object Logarithms:
       def + (y: Logarithm): Logarithm = Logarithm(math.exp(x) + math.exp(y))
       def * (y: Logarithm): Logarithm = x + y
 
-end Logarithms
+end MyMath
 ```
 
 This introduces `Logarithm` as a new abstract type, which is implemented as `Double`.
 The fact that `Logarithm` is the same as `Double` is only known in the scope where
-`Logarithm` is defined which in the above example corresponds to the object `Logarithms`.
+`Logarithm` is defined which in the above example corresponds to the object `MyMath`.
 Or in other words, within the scope it is treated as type alias, but this is opaque to the outside world
 where in consequence `Logarithm` is seen as an abstract type and has nothing to do with `Double`.
 
 The public API of `Logarithm` consists of the `apply` and `safe` methods defined in the companion object.
 They convert from `Double`s to `Logarithm` values. Moreover, an operation `toDouble` that converts the other way, and operations `+` and `*` are defined as extension methods on `Logarithm` values.
-The following operations would be valid because they use functionality implemented in the `Logarithms` object.
+The following operations would be valid because they use functionality implemented in the `MyMath` object.
 
 ```scala
-import Logarithms.Logarithm
+import MyMath.Logarithm
 
 val l = Logarithm(1.0)
 val l2 = Logarithm(2.0)

docs/docs/reference/overview.md

@@ -2,7 +2,7 @@
 layout: doc-page
 title: "Overview"
 ---
-The forthcoming Scala 3 implements many language changes and improvements over Scala 2.
+Scala 3 implements many language changes and improvements over Scala 2.
 In this reference, we discuss design decisions and present important differences compared to Scala 2.
 
 ## Goals
@@ -18,7 +18,7 @@ The language redesign was guided by three main goals:
 - Further improve the consistency and expressiveness of Scala's language constructs.
 
 Corresponding to these goals, the language changes fall into seven categories:
-(1) Core constructs to strengthen foundations, (2) simplifications and (3) [restrictions](#restrictions), to make the language easier and safer to use, (4) dropped constructs to make the language smaller and more regular, (5) [changed constructs](#changes) to remove warts, and increase consistency and usability, (6) [new constructs](#new-constructs) to fill gaps and increase expressiveness, (7) a new, principled approach to metaprogramming that replaces [Scala 2 experimental macros](https://docs.scala-lang.org/overviews/macros/overview.html).
+(1) Core constructs to strengthen foundations, (2) simplifications and (3) [restrictions](#restrictions), to make the language easier and safer to use, (4) [dropped constructs](#dropped-constructs) to make the language smaller and more regular, (5) [changed constructs](#changes) to remove warts, and increase consistency and usability, (6) [new constructs](#new-constructs) to fill gaps and increase expressiveness, (7) a new, principled approach to metaprogramming that replaces [Scala 2 experimental macros](https://docs.scala-lang.org/overviews/macros/overview.html).
 
 ## Essential Foundations
 

project/Build.scala

@@ -415,9 +415,9 @@ object Build {
       libraryDependencies ++= Seq(
         "org.scala-lang.modules" % "scala-asm" % "9.1.0-scala-1", // used by the backend
         Dependencies.oldCompilerInterface, // we stick to the old version to avoid deprecation warnings
-        "org.jline" % "jline-reader" % "3.15.0",   // used by the REPL
-        "org.jline" % "jline-terminal" % "3.15.0",
-        "org.jline" % "jline-terminal-jna" % "3.15.0" // needed for Windows
+        "org.jline" % "jline-reader" % "3.19.0",   // used by the REPL
+        "org.jline" % "jline-terminal" % "3.19.0",
+        "org.jline" % "jline-terminal-jna" % "3.19.0" // needed for Windows
       ),
 
       // For convenience, change the baseDirectory when running the compiler

scaladoc-testcases/src/tests/genericMethods.scala

@@ -9,7 +9,7 @@ class Types:
   def mixedAndAndOr(base: Int & String, nested: List[Int | Double] & Seq[String]): Unit
   = ???
 
-  def literal(i: 1, d: 3.3, c: 'c'): 34
+  def literal(i: 1, d: 3.3d, c: 'c'): 34
   = 34
 
   def byName(a: => Int, b: => String | Int): Unit

tests/neg-custom-args/fatal-warnings/i3561.scala

@@ -13,10 +13,4 @@ class Test {
     case '5' | Constant => 3
     case '4' => 4
   }
-
-  def test3(x: Any) = (x: @annotation.switch) match { // error: could not emit switch - too few cases
-    case 1 => 1
-    case 2 => 2
-    case x: String => 4
-  }
 }

tests/neg-custom-args/fatal-warnings/i9776.scala

@@ -0,0 +1,59 @@
+import scala.annotation.switch
+
+sealed trait Fruit
+
+object Fruit {
+  case object Apple extends Fruit
+  case object Banana extends Fruit
+  case object Lemon extends Fruit
+  case object Lime extends Fruit
+  case object Orange extends Fruit
+
+  def isCitrus(fruit: Fruit): Boolean =
+    (fruit: @switch) match {  // error Could not emit switch for @switch annotated match
+      case Orange => true
+      case Lemon  => true
+      case Lime   => true
+      case _      => false
+    }
+}
+
+
+sealed trait TaggedFruit {
+  def tag: Int
+}
+
+object TaggedFruit {
+  case object Apple extends TaggedFruit {
+    val tag = 1
+  }
+  case object Banana extends TaggedFruit {
+    val tag = 2
+  }
+  case object Orange extends TaggedFruit {
+    val tag = 3
+  }
+
+  def isCitrus(fruit: TaggedFruit): Boolean =
+    (fruit.tag: @switch) match {  // error Could not emit switch for @switch annotated match
+      case Apple.tag => true
+      case 2         => true
+      case 3         => true
+      case _         => false
+  }
+
+  // fewer than four cases, so no warning
+  def succ1(fruit: TaggedFruit): Boolean =
+    (fruit.tag: @switch) match {
+      case 3             => false
+      case 2 | Apple.tag => true
+    }
+
+  // fewer than four cases, so no warning
+  def succ2(fruit: TaggedFruit): Boolean =
+    (fruit.tag: @switch) match {
+      case 3          => false
+      case 2          => true
+      case Apple.tag  => true
+  }
+}