Merge branch 'master' of https://github.com/lampepfl/dotty into summonInline

� Conflicts:
�	docs/docs/reference/metaprogramming/compiletime-ops.md

Author: soronpo

.github/workflows/scaladoc.yaml

@@ -70,3 +70,25 @@ jobs:
             echo uplading docs to https://scala3doc.virtuslab.com/$DOC_DEST
             az storage container create --name $DOC_DEST --account-name scala3docstorage --public-access container
             az storage blob upload-batch -s scaladoc/output -d $DOC_DEST --account-name scala3docstorage
+
+  stdlib-sourcelinks-test:
+    runs-on: ubuntu-latest
+    if: "(    github.event_name == 'pull_request'
+           && !contains(github.event.pull_request.body, '[skip ci]')
+           && !contains(github.event.pull_request.body, '[skip docs]')
+         )
+         || contains(github.event.ref, 'scaladoc')
+         || contains(github.event.ref, 'scala3doc')
+         || contains(github.event.ref, 'master')"
+
+    steps:
+      - name: Git Checkout
+        uses: actions/checkout@v2
+
+      - name: Set up JDK 8
+        uses: actions/setup-java@v1
+        with:
+          java-version: 8
+
+      - name: Test sourcelinks to stdlib
+        run: ./project/scripts/sbt scaladoc/sourceLinksIntegrationTest:test

bench/profiles/exhaustivity.yml

@@ -41,6 +41,12 @@ charts:
         - key: exhaustivity-i12241
           label: bootstrapped
 
+    - name: "exhaustivity i12358"
+      url: https://github.com/lampepfl/dotty/blob/master/tests/patmat/i12358.scala
+      lines:
+        - key: exhaustivity-i12358
+          label: bootstrapped
+
 scripts:
 
     patmatexhaust:
@@ -64,5 +70,8 @@ scripts:
     exhaustivity-i12241:
         - measure 20 40 3 $PROG_HOME/dotty/tests/patmat/i12241.scala
 
+    exhaustivity-i12358:
+        - measure 20 40 3 $PROG_HOME/dotty/tests/patmat/i12358.scala
+
 config:
     pr_base_url: "https://github.com/lampepfl/dotty/pull/"

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

@@ -228,7 +228,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
       resKind
     }
 
-    def genPrimitiveOp(tree: Apply, expectedType: BType): BType = tree match {
+    def genPrimitiveOp(tree: Apply, expectedType: BType): BType = (tree: @unchecked) match {
       case Apply(fun @ DesugaredSelect(receiver, _), _) =>
       val sym = tree.symbol
 
@@ -610,7 +610,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
       }
     }
 
-    def genTypeApply(t: TypeApply): BType = t match {
+    def genTypeApply(t: TypeApply): BType = (t: @unchecked) match {
       case TypeApply(fun@DesugaredSelect(obj, _), targs) =>
 
         val sym = fun.symbol

compiler/src/dotty/tools/backend/jvm/BCodeSyncAndTry.scala

@@ -27,7 +27,7 @@ trait BCodeSyncAndTry extends BCodeBodyBuilder {
    */
   abstract class SyncAndTryBuilder(cunit: CompilationUnit) extends PlainBodyBuilder(cunit) {
 
-    def genSynchronized(tree: Apply, expectedType: BType): BType = tree match {
+    def genSynchronized(tree: Apply, expectedType: BType): BType = (tree: @unchecked) match {
       case Apply(TypeApply(fun, _), args) =>
       val monitor = locals.makeLocal(ObjectReference, "monitor", defn.ObjectType, tree.span)
       val monCleanup = new asm.Label

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

@@ -131,10 +131,10 @@ object GenericSignatures {
      */
     def splitIntersection(parents: List[Type])(using Context): (List[Type], List[Type]) =
       val erasedParents = parents.map(erasure)
-      val erasedCls = erasedGlb(erasedParents).classSymbol
+      val erasedTp = erasedGlb(erasedParents)
       parents.zip(erasedParents)
         .partitionMap((parent, erasedParent) =>
-          if erasedParent.classSymbol eq erasedCls then
+          if erasedParent =:= erasedTp then
             Left(parent)
           else
             Right(parent))

compiler/src/dotty/tools/dotc/transform/localopt/StringInterpolatorOpt.scala

@@ -121,7 +121,7 @@ class StringInterpolatorOpt extends MiniPhase {
       (sym.name == nme.f && sym.eq(defn.StringContext_f)) ||
       (sym.name == nme.s && sym.eq(defn.StringContext_s))
     if (isInterpolatedMethod)
-      tree match {
+      (tree: @unchecked) match {
         case StringContextIntrinsic(strs: List[Literal], elems: List[Tree]) =>
           val stri = strs.iterator
           val elemi = elems.iterator

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -113,16 +113,17 @@ trait SpaceLogic {
   /** Display space in string format */
   def show(sp: Space): String
 
-  /** Simplify space using the laws, there's no nested union after simplify */
+  /** Simplify space such that a space equal to `Empty` becomes `Empty` */
   def simplify(space: Space)(using Context): Space = trace(s"simplify ${show(space)} --> ", debug, x => show(x.asInstanceOf[Space]))(space match {
     case Prod(tp, fun, spaces) =>
-      val sp = Prod(tp, fun, spaces.map(simplify(_)))
-      if (sp.params.contains(Empty)) Empty
+      val sps = spaces.map(simplify(_))
+      if (sps.contains(Empty)) Empty
       else if (canDecompose(tp) && decompose(tp).isEmpty) Empty
-      else sp
+      else Prod(tp, fun, sps)
     case Or(spaces) =>
       val spaces2 = spaces.map(simplify(_)).filter(_ != Empty)
       if spaces2.isEmpty then Empty
+      else if spaces2.lengthCompare(1) == 0 then spaces2.head
       else Or(spaces2)
     case Typ(tp, _) =>
       if (canDecompose(tp) && decompose(tp).isEmpty) Empty
@@ -243,10 +244,10 @@ trait SpaceLogic {
           tryDecompose1(tp1)
         else
           a
-      case (_, Or(ss)) =>
-        ss.foldLeft(a)(minus)
       case (Or(ss), _) =>
         Or(ss.map(minus(_, b)))
+      case (_, Or(ss)) =>
+        ss.foldLeft(a)(minus)
       case (Prod(tp1, fun, ss), Typ(tp2, _)) =>
         // uncovered corner case: tp2 :< tp1, may happen when inheriting case class
         if (isSubType(tp1, tp2))
@@ -272,7 +273,10 @@ trait SpaceLogic {
         else if cache.forall(sub => isSubspace(sub, Empty)) then Empty
         else
           // `(_, _, _) - (Some, None, _)` becomes `(None, _, _) | (_, Some, _) | (_, _, Empty)`
-          Or(LazyList(range: _*).map { i => Prod(tp1, fun1, ss1.updated(i, sub(i))) })
+          val spaces = LazyList(range: _*).flatMap { i =>
+            flatten(sub(i)).map(s => Prod(tp1, fun1, ss1.updated(i, s)))
+          }
+          Or(spaces)
     }
   }
 }
@@ -771,7 +775,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
         if (ctx.definitions.isTupleType(tp))
           "(" + params.map(doShow(_)).mkString(", ") + ")"
         else if (tp.isRef(scalaConsType.symbol))
-          if (flattenList) params.map(doShow(_, flattenList)).mkString(", ")
+          if (flattenList) params.map(doShow(_, flattenList)).filter(_.nonEmpty).mkString(", ")
           else params.map(doShow(_, flattenList = true)).filter(!_.isEmpty).mkString("List(", ", ", ")")
         else {
           val sym = fun.symbol
@@ -791,16 +795,18 @@ class SpaceEngine(using Context) extends SpaceLogic {
     def isCheckable(tp: Type): Boolean =
       !tp.hasAnnotation(defn.UncheckedAnnot) && {
         val tpw = tp.widen.dealias
+        val classSym = tpw.classSymbol
         ctx.settings.YcheckAllPatmat.value ||
-        tpw.typeSymbol.is(Sealed) ||
+        classSym.is(Sealed) ||
         tpw.isInstanceOf[OrType] ||
         (tpw.isInstanceOf[AndType] && {
           val and = tpw.asInstanceOf[AndType]
           isCheckable(and.tp1) || isCheckable(and.tp2)
         }) ||
         tpw.isRef(defn.BooleanClass) ||
-        tpw.typeSymbol.isAllOf(JavaEnumTrait) ||
-        (defn.isTupleType(tpw) && tpw.argInfos.exists(isCheckable(_)))
+        classSym.isAllOf(JavaEnumTrait) ||
+        (defn.isProductSubType(tpw) && classSym.is(Case)
+           && productSelectorTypes(tpw, sel.srcPos).exists(isCheckable(_)))
       }
 
     val res = isCheckable(sel.tpe)

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

@@ -990,7 +990,7 @@ trait Applications extends Compatibility {
      *     { val xs = es; e' = e' + args }
      */
     def typedOpAssign(using Context): Tree = {
-      val (lhs1, name, rhss) = tree match
+      val (lhs1, name, rhss) = (tree: @unchecked) match
         case Apply(Select(lhs, name), rhss) => (typedExpr(lhs), name, rhss)
         case Apply(untpd.TypedSplice(Select(lhs1, name)), rhss) => (lhs1, name, rhss)
       val liftedDefs = new mutable.ListBuffer[Tree]

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

@@ -167,12 +167,15 @@ trait ImportSuggestions:
       allCandidates.map(_.implicitRef.underlyingRef.symbol).toSet
     }
 
+    def testContext(): Context =
+      ctx.fresh.retractMode(Mode.ImplicitsEnabled).setExploreTyperState()
+
     /** Test whether the head of a given instance matches the expected type `pt`,
      *  ignoring any dependent implicit arguments.
      */
     def shallowTest(ref: TermRef): Boolean =
       System.currentTimeMillis < deadLine
-      && inContext(ctx.fresh.setExploreTyperState()) {
+      && inContext(testContext()) {
         def test(pt: Type): Boolean = pt match
           case ViewProto(argType, OrType(rt1, rt2)) =>
             // Union types do not constrain results, since comparison with a union
@@ -209,7 +212,7 @@ trait ImportSuggestions:
         try
           timer.schedule(task, testOneImplicitTimeOut)
           typedImplicit(candidate, expectedType, argument, span)(
-            using ctx.fresh.setExploreTyperState()).isSuccess
+            using testContext()).isSuccess
         finally
           if task.cancel() then // timer task has not run yet
             assert(!ctx.run.isCancelled)

dist/bin/common

@@ -159,8 +159,9 @@ SBT_INTF=$(find_lib "*compiler-interface*")
 JLINE_READER=$(find_lib "*jline-reader-3*")
 JLINE_TERMINAL=$(find_lib "*jline-terminal-3*")
 JLINE_TERMINAL_JNA=$(find_lib "*jline-terminal-jna-3*")
-[[ ${conemu-} ]] || JNA=$(find_lib "*jna-5*")
 
+# jna-5 only appropriate for some combinations
+[[ ${conemu-} && ${msys-} ]] || JNA=$(find_lib "*jna-5*")
 
 compilerJavaClasspathArgs () {
   # echo "dotty-compiler: $DOTTY_COMP"

dist/bin/scalac

@@ -67,8 +67,10 @@ if [ "$PROG_NAME" == "$ScriptingMain" ]; then
   scripting_string="-script $target_script ${scripting_args[@]}"
 fi
 
-# exec here would prevent onExit from being called, leaving terminal in unusable state
 [ -n "$script_trace" ] && set -x
+[ -z "${ConEmuPID-}" -o -n "${cygwin-}" ] && export MSYSTEM= PWD= # workaround for #12405
+
+# exec here would prevent onExit from being called, leaving terminal in unusable state
 eval "\"$JAVACMD\"" \
    ${JAVA_OPTS:-$default_java_opts} \
    "${java_args[@]}" \

docs/docs/reference/changed-features/compiler-plugins.md

@@ -63,28 +63,28 @@ import dotty.tools.dotc.plugins.{PluginPhase, StandardPlugin}
 import dotty.tools.dotc.transform.{Pickler, Staging}
 
 class DivideZero extends StandardPlugin:
-   val name: String = "divideZero"
-   override val description: String = "divide zero check"
+  val name: String = "divideZero"
+  override val description: String = "divide zero check"
 
-   def init(options: List[String]): List[PluginPhase] =
-      (new DivideZeroPhase) :: Nil
+  def init(options: List[String]): List[PluginPhase] =
+    (new DivideZeroPhase) :: Nil
 
 class DivideZeroPhase extends PluginPhase:
-   import tpd.*
+  import tpd.*
 
-   val phaseName = "divideZero"
+  val phaseName = "divideZero"
 
-   override val runsAfter = Set(Pickler.name)
-   override val runsBefore = Set(Staging.name)
+  override val runsAfter = Set(Pickler.name)
+  override val runsBefore = Set(Staging.name)
 
-   override def transformApply(tree: Apply)(implicit ctx: Context): Tree =
-      tree match
-         case Apply(Select(rcvr, nme.DIV), List(Literal(Constant(0))))
-         if rcvr.tpe <:< defn.IntType =>
-            report.error("dividing by zero", tree.pos)
-         case _ =>
-            ()
-      tree
+  override def transformApply(tree: Apply)(implicit ctx: Context): Tree =
+    tree match
+      case Apply(Select(rcvr, nme.DIV), List(Literal(Constant(0))))
+      if rcvr.tpe <:< defn.IntType =>
+        report.error("dividing by zero", tree.pos)
+      case _ =>
+        ()
+    tree
 end DivideZeroPhase
 ```
 
@@ -109,11 +109,11 @@ import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.plugins.ResearchPlugin
 
 class DummyResearchPlugin extends ResearchPlugin:
-   val name: String = "dummy"
-   override val description: String = "dummy research plugin"
+  val name: String = "dummy"
+  override val description: String = "dummy research plugin"
 
-   def init(options: List[String], phases: List[List[Phase]])(implicit ctx: Context): List[List[Phase]] =
-      phases
+  def init(options: List[String], phases: List[List[Phase]])(implicit ctx: Context): List[List[Phase]] =
+    phases
 end DummyResearchPlugin
 ```
 

docs/docs/reference/changed-features/implicit-conversions-spec.md

@@ -17,7 +17,7 @@ The standard library defines an abstract class `Conversion`:
 package scala
 @java.lang.FunctionalInterface
 abstract class Conversion[-T, +U] extends Function1[T, U]:
-   def apply(x: T): U
+  def apply(x: T): U
 ```
 
 Function literals are automatically converted to `Conversion` values.

docs/docs/reference/changed-features/implicit-conversions.md

@@ -34,7 +34,7 @@ method that expects a `java.lang.Integer`
 ```scala
 import scala.language.implicitConversions
 implicit def int2Integer(x: Int): java.lang.Integer =
-   x.asInstanceOf[java.lang.Integer]
+  x.asInstanceOf[java.lang.Integer]
 ```
 
 The second example shows how to use `Conversion` to define an
@@ -44,11 +44,11 @@ types:
 ```scala
 import scala.language.implicitConversions
 implicit def ordT[T, S](
-      implicit conv: Conversion[T, S],
-               ordS: Ordering[S]
+    implicit conv: Conversion[T, S],
+             ordS: Ordering[S]
    ): Ordering[T] =
-    // `ordS` compares values of type `S`, but we can convert from `T` to `S`
-   (x: T, y: T) => ordS.compare(x, y)
+   // `ordS` compares values of type `S`, but we can convert from `T` to `S`
+  (x: T, y: T) => ordS.compare(x, y)
 
 class A(val x: Int) // The type for which we want an `Ordering`
 

docs/docs/reference/changed-features/implicit-resolution.md

@@ -13,23 +13,23 @@ where the type may still be inferred:
 ```scala
   class C {
 
-     val ctx: Context = ...        // ok
+    val ctx: Context = ...        // ok
 
-     /*!*/ implicit val x = ...    // error: type must be given explicitly
+    /*!*/ implicit val x = ...    // error: type must be given explicitly
 
-     /*!*/ implicit def y = ...    // error: type must be given explicitly
+    /*!*/ implicit def y = ...    // error: type must be given explicitly
   }
   val y = {
-     implicit val ctx = this.ctx // ok
-     ...
+    implicit val ctx = this.ctx // ok
+    ...
   }
 ```
 **2.** Nesting is now taken into account for selecting an implicit. Consider for instance the following scenario:
 ```scala
   def f(implicit i: C) = {
-     def g(implicit j: C) = {
-        implicitly[C]
-     }
+    def g(implicit j: C) = {
+      implicitly[C]
+    }
   }
 ```
 This will now resolve the `implicitly` call to `j`, because `j` is nested
@@ -45,8 +45,8 @@ no longer applies.
   given a: A = A()
 
   object o:
-     given b: B = B()
-     type C
+    given b: B = B()
+    type C
 ```
 Both `a` and `b` are visible as implicits at the point of the definition
 of `type C`. However, a reference to `p.o.C` outside of package `p` will

docs/docs/reference/changed-features/imports.md

@@ -16,8 +16,8 @@ If you want to import a member named `*` specifically, you can use backticks aro
 
 ```scala
 object A:
-   def * = ...
-   def min = ...
+  def * = ...
+  def min = ...
 
 object B:
   import A.`*`   // imports just `*`