Merge remote-tracking branch 'upstream/master' into dotty-explicit-nulls-only

Author: noti0na1

.gitmodules

@@ -56,3 +56,6 @@
 [submodule "community-build/community-projects/intent"]
 	path = community-build/community-projects/intent
 	url = https://github.com/dotty-staging/intent
+[submodule "community-build/community-projects/utest"]
+	path = community-build/community-projects/utest
+	url = https://github.com/dotty-staging/utest.git

community-build/community-projects/ScalaPB

@@ -16,6 +16,32 @@ class CommunityBuildTest {
     new String(Files.readAllBytes(file), UTF_8)
   }
 
+  def testSbt(project: String, testCommand: String, updateCommand: String, extraSbtArgs: Seq[String] = Nil) = {
+    // Workaround for https://github.com/sbt/sbt/issues/4395
+    new File(sys.props("user.home") + "/.sbt/1.0/plugins").mkdirs()
+    val pluginFilePath = communitybuildDir.resolve("sbt-dotty-sbt").toAbsolutePath().toString()
+
+    // Run the sbt command with the compiler version and sbt plugin set in the build
+    val arguments = {
+      val sbtProps = Option(System.getProperty("sbt.ivy.home")) match {
+        case Some(ivyHome) =>
+          Seq(s"-Dsbt.ivy.home=$ivyHome")
+        case _ =>
+          Seq()
+      }
+      extraSbtArgs ++ sbtProps ++ Seq(
+        "-sbt-version", "1.2.7",
+        s"--addPluginSbtFile=$pluginFilePath",
+        s";clean ;set updateOptions in Global ~= (_.withLatestSnapshots(false)) ;++$compilerVersion! $testCommand"
+      )
+    }
+
+    test(project, "sbt", arguments)
+  }
+
+  def testMill(project: String, testCommand: String, extraMillArgs: Seq[String] = Nil) =
+    test(project, "./mill", extraMillArgs :+ testCommand)
+
   /** Build the given project with the published local compiler and sbt plugin.
    *
    *  This test reads the compiler version from community-build/dotty-bootstrapped.version
@@ -26,7 +52,7 @@ class CommunityBuildTest {
    *  @param updateCommand  The sbt command used to update the project
    *  @param extraSbtArgs   Extra arguments to pass to sbt
    */
-  def test(project: String, testCommand: String, updateCommand: String, extraSbtArgs: Seq[String] = Nil): Unit = {
+  def test(project: String, command: String, arguments: Seq[String]): Unit = {
     def log(msg: String) = println(Console.GREEN + msg + Console.RESET)
 
     log(s"Building $project with dotty-bootstrapped $compilerVersion...")
@@ -53,149 +79,135 @@ class CommunityBuildTest {
       exitCode
     }
 
-    // Workaround for https://github.com/sbt/sbt/issues/4395
-    new File(sys.props("user.home") + "/.sbt/1.0/plugins").mkdirs()
-    val pluginFilePath = communitybuildDir.resolve("sbt-dotty-sbt").toAbsolutePath().toString()
-
-    // Run the sbt command with the compiler version and sbt plugin set in the build
-    val arguments = {
-      val sbtProps = Option(System.getProperty("sbt.ivy.home")) match {
-        case Some(ivyHome) =>
-          Seq(s"-Dsbt.ivy.home=$ivyHome")
-        case _ =>
-          Seq()
-      }
-      extraSbtArgs ++ sbtProps ++ Seq(
-        "-sbt-version", "1.2.7",
-        s"--addPluginSbtFile=$pluginFilePath",
-        s";clean ;set updateOptions in Global ~= (_.withLatestSnapshots(false)) ;++$compilerVersion! $testCommand"
-      )
-    }
-
-    val exitCode = exec("sbt", arguments: _*)
+    val exitCode = exec(command, arguments: _*)
 
     if (exitCode != 0) {
       fail(s"""
           |
-          |sbt exited with an error code. To reproduce without JUnit, use:
+          |$command exited with an error code. To reproduce without JUnit, use:
           |
           |    sbt community-build/prepareCommunityBuild
           |    cd community-build/community-projects/$project
-          |    sbt ${arguments.init.mkString(" ")} "${arguments.last}"
+          |    $command ${arguments.init.mkString(" ")} "${arguments.last}"
           |
-          |For a faster feedback loop, one can try to extract a direct call to dotc
+          |For a faster feedback loop on SBT projects, one can try to extract a direct call to dotc
           |using the sbt export command. For instance, for scalacheck, use
           |    sbt export jvm/test:compileIncremental
           |
           |""".stripMargin)
     }
   }
 
-  @Test def intent = test(
+  @Test def utest = testMill(
+    project = "utest",
+    testCommand = s"utest.jvm[$compilerVersion].test",
+    extraMillArgs = List("-i", "-D", s"dottyVersion=$compilerVersion")
+  )
+
+  @Test def intent = testSbt(
     project       = "intent",
     testCommand   = "test",
     updateCommand = "update"
   )
 
-  @Test def algebra = test(
+  @Test def algebra = testSbt(
     project       = "algebra",
     testCommand   = "coreJVM/compile",
     updateCommand = "coreJVM/update"
   )
 
-  @Test def scalacheck = test(
+  @Test def scalacheck = testSbt(
     project       = "scalacheck",
     testCommand   = "jvm/test:compile",
     updateCommand = "jvm/test:update"
   )
 
-  @Test def scalatest = test(
+  @Test def scalatest = testSbt(
     project       = "scalatest",
     testCommand   = ";scalacticDotty/clean;scalacticTestDotty/test;scalatestTestDotty/test",
     updateCommand = "scalatest/update"
   )
 
-  @Test def scalaXml = test(
+  @Test def scalaXml = testSbt(
     project       = "scala-xml",
     testCommand   = "xml/test",
     updateCommand = "xml/update"
   )
 
-  @Test def scopt = test(
+  @Test def scopt = testSbt(
     project       = "scopt",
     testCommand   = "scoptJVM/compile",
     updateCommand = "scoptJVM/update"
   )
 
-  @Test def scalap = test(
+  @Test def scalap = testSbt(
     project       = "scalap",
     testCommand   = "scalap/compile",
     updateCommand = "scalap/update"
   )
 
-  @Test def squants = test(
+  @Test def squants = testSbt(
     project       = "squants",
     testCommand   = "squantsJVM/compile",
     updateCommand = "squantsJVM/update"
   )
 
-  @Test def betterfiles = test(
+  @Test def betterfiles = testSbt(
     project       = "betterfiles",
     testCommand   = "dotty-community-build/compile",
     updateCommand = "dotty-community-build/update"
   )
 
-  @Test def ScalaPB = test(
+  @Test def ScalaPB = testSbt(
     project       = "ScalaPB",
     testCommand   = "dotty-community-build/compile",
     updateCommand = "dotty-community-build/update"
   )
 
-  @Test def minitest = test(
+  @Test def minitest = testSbt(
     project       = "minitest",
     testCommand   = "dotty-community-build/compile",
     updateCommand = "dotty-community-build/update"
   )
 
-  @Test def fastparse = test(
+  @Test def fastparse = testSbt(
     project       = "fastparse",
     testCommand   = "dotty-community-build/compile;dotty-community-build/test:compile",
     updateCommand = "dotty-community-build/update"
   )
 
-  // TODO: revert to sourcecodeJVM/test
-  @Test def sourcecode = test(
-    project       = "sourcecode",
-    testCommand   = "sourcecode/compile;sourcecode/test:compile",
-    updateCommand = "sourcecode/update"
+  @Test def sourcecode = testMill(
+    project = "sourcecode",
+    testCommand = s"sourcecode.jvm[$compilerVersion].test",
+    extraMillArgs = List("-i", "-D", s"dottyVersion=$compilerVersion")
   )
 
-  @Test def stdLib213 = test(
+  @Test def stdLib213 = testSbt(
     project       = "stdLib213",
     testCommand   = "library/compile",
     updateCommand = "library/update",
     extraSbtArgs  = Seq("-Dscala.build.compileWithDotty=true")
   )
 
-  @Test def shapeless = test(
+  @Test def shapeless = testSbt(
     project       = "shapeless",
     testCommand   = "test",
     updateCommand = "update"
   )
 
-  @Test def xmlInterpolator = test(
+  @Test def xmlInterpolator = testSbt(
     project       = "xml-interpolator",
     testCommand   = "test",
     updateCommand = "update"
   )
 
-  @Test def semanticdb = test(
+  @Test def semanticdb = testSbt(
     project       = "semanticdb",
     testCommand   = "test:compile",
     updateCommand = "update"
   )
 
-  @Test def effpi = test(
+  @Test def effpi = testSbt(
     project       = "effpi",
     // We set `useEffpiPlugin := false` because we don't want to run their
     // compiler plugin since it relies on external binaries (from the model
@@ -225,6 +237,6 @@ class UpdateCategory
 
 @Category(Array(classOf[UpdateCategory]))
 class CommunityBuildUpdate extends CommunityBuildTest {
-  override def test(project: String, testCommand: String, updateCommand: String, extraSbtArgs: Seq[String]): Unit =
-    super.test(project, updateCommand, null, extraSbtArgs)
+  override def testSbt(project: String, testCommand: String, updateCommand: String, extraSbtArgs: Seq[String]): Unit =
+    super.testSbt(project, updateCommand, null, extraSbtArgs)
 }

community-build/community-projects/algebra

@@ -830,14 +830,14 @@ object desugar {
     val impl = mdef.impl
     val mods = mdef.mods
     impl.constr match {
-      case DefDef(_, tparams, (vparams @ (vparam :: Nil)) :: _, _, _) =>
+      case DefDef(_, tparams, (vparams @ (vparam :: Nil)) :: givenParamss, _, _) =>
         assert(mods.is(Given))
         return moduleDef(
           cpy.ModuleDef(mdef)(
             mdef.name,
             cpy.Template(impl)(
               constr = emptyConstructor,
-              body = impl.body.map(makeExtensionDef(_, tparams, vparams)))))
+              body = impl.body.map(makeExtensionDef(_, tparams, vparams, givenParamss)))))
       case _ =>
     }
 
@@ -892,16 +892,19 @@ object desugar {
    *  If the given member `mdef` is not of this form, flag it as an error.
    */
 
-  def makeExtensionDef(mdef: Tree, tparams: List[TypeDef], leadingParams: List[ValDef])(given ctx: Context): Tree = {
+  def makeExtensionDef(mdef: Tree, tparams: List[TypeDef], leadingParams: List[ValDef],
+                       givenParamss: List[List[ValDef]])(given ctx: Context): Tree = {
     val allowed = "allowed here, since collective parameters are given"
     mdef match {
       case mdef: DefDef =>
         if (mdef.mods.is(Extension)) {
           ctx.error(em"No extension method $allowed", mdef.sourcePos)
           mdef
         }
-        else cpy.DefDef(mdef)(tparams = tparams ++ mdef.tparams, vparamss = leadingParams :: mdef.vparamss)
-          .withFlags(Extension)
+        else cpy.DefDef(mdef)(
+          tparams = tparams ++ mdef.tparams,
+          vparamss = leadingParams :: givenParamss ::: mdef.vparamss
+        ).withMods(mdef.mods | Extension)
       case mdef: Import =>
         mdef
       case mdef =>
@@ -1095,7 +1098,10 @@ object desugar {
           val firstDef =
             ValDef(tmpName, TypeTree(), matchExpr)
               .withSpan(pat.span.union(rhs.span)).withMods(patMods)
-          def selector(n: Int) = Select(Ident(tmpName), nme.selectorName(n))
+          val useSelectors = vars.length <= 22
+          def selector(n: Int) =
+            if useSelectors then Select(Ident(tmpName), nme.selectorName(n))
+            else Apply(Select(Ident(tmpName), nme.apply), Literal(Constant(n)) :: Nil)
           val restDefs =
             for (((named, tpt), n) <- vars.zipWithIndex if named.name != nme.WILDCARD)
             yield
@@ -1737,7 +1743,8 @@ object desugar {
         new TreeTraverser {
           def traverse(tree: untpd.Tree)(implicit ctx: Context): Unit = tree match {
             case Splice(expr) => collect(expr)
-            case TypSplice(expr) => collect(expr)
+            case TypSplice(expr) =>
+              ctx.error("Type splices cannot be used in val patterns. Consider using `match` instead.", tree.sourcePos)
             case _ => traverseChildren(tree)
           }
         }.traverse(expr)

community-build/community-projects/betterfiles

@@ -99,7 +99,7 @@ object DesugarEnums {
     val privateValuesDef =
       ValDef(nme.DOLLAR_VALUES, TypeTree(),
         New(TypeTree(defn.EnumValuesClass.typeRef.appliedTo(enumClass.typeRef :: Nil)), ListOfNil))
-        .withFlags(Private)
+        .withFlags(Private | Synthetic)
 
     val valuesOfExnMessage = Apply(
       Select(Literal(Constant("key not found: ")), "concat".toTermName),

community-build/community-projects/fastparse

@@ -876,6 +876,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def appliedToArgs(args: List[Tree])(implicit ctx: Context): Apply =
       Apply(tree, args)
 
+    /** An applied node that accepts only varargs as arguments */
+    def appliedToVarargs(args: List[Tree], tpt: Tree)(given Context): Tree =
+      appliedTo(repeated(args, tpt))
+
     /** The current tree applied to given argument lists:
      *  `tree (argss(0)) ... (argss(argss.length -1))`
      */
@@ -893,6 +897,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def appliedToTypes(targs: List[Type])(implicit ctx: Context): Tree =
       appliedToTypeTrees(targs map (TypeTree(_)))
 
+    /** The current tree applied to given type argument: `tree[targ]` */
+    def appliedToTypeTree(targ: Tree)(implicit ctx: Context): Tree =
+      appliedToTypeTrees(targ :: Nil)
+
     /** The current tree applied to given type argument list: `tree[targs(0), ..., targs(targs.length - 1)]` */
     def appliedToTypeTrees(targs: List[Tree])(implicit ctx: Context): Tree =
       if (targs.isEmpty) tree else TypeApply(tree, targs)
@@ -1365,5 +1373,24 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     val targs = atp.argTypes
     tpd.applyOverloaded(New(atp.typeConstructor), nme.CONSTRUCTOR, args, targs, atp)
   }
-}
 
+  /** Convert a list of trees to a vararg-compatible tree.
+   *  Used to make arguments for methods that accept varargs.
+   */
+  def repeated(trees: List[Tree], tpt: Tree)(given ctx: Context): Tree =
+    ctx.typeAssigner.arrayToRepeated(JavaSeqLiteral(trees, tpt))
+
+  /** Create a tree representing a list containing all
+   *  the elements of the argument list. A "list of tree to
+   *  tree of list" conversion.
+   *
+   *  @param trees  the elements the list represented by
+   *                the resulting tree should contain.
+   *  @param tpe    the type of the elements of the resulting list.
+   *
+   */
+  def mkList(trees: List[Tree], tpe: Tree)(given Context): Tree =
+    ref(defn.ListModule).select(nme.apply)
+      .appliedToTypeTree(tpe)
+      .appliedToVarargs(trees, tpe)
+}