Merge remote-tracking branch 'upstream/master' into batch-files

Author: michelou

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -220,7 +220,7 @@ class CompilationTests extends ParallelTesting {
       Array("-Ycheck-reentrant", "-Yemit-tasty-in-class")
     )
 
-    val libraryDirs = List(Paths.get("library/src"), Paths.get("library/src-scala3"))
+    val libraryDirs = List(Paths.get("library/src"), Paths.get("library/src-bootstrapped"))
     val librarySources = libraryDirs.flatMap(d => sources(Files.walk(d)))
 
     val lib =

doc-tool/src/dotty/tools/dottydoc/staticsite/Site.scala

@@ -127,7 +127,9 @@ case class Site(
   }
 
   /** Copy static files to `outDir` */
-  def copyStaticFiles(outDir: JFile = new JFile(root.getAbsolutePath + "/_site"))(implicit ctx: Context): this.type =
+  private[this] val defaultOutDir = new JFile(root.getAbsolutePath + JFile.separator + "_site")
+
+  def copyStaticFiles(outDir: JFile = defaultOutDir)(implicit ctx: Context): this.type =
     createOutput (outDir) {
       // Copy user-defined static assets
       staticAssets.foreach { asset =>
@@ -188,7 +190,7 @@ case class Site(
   }
 
   /** Generate HTML for the API documentation */
-  def generateApiDocs(outDir: JFile = new JFile(root.getAbsolutePath + "/_site"))(implicit ctx: Context): this.type =
+  def generateApiDocs(outDir: JFile = defaultOutDir)(implicit ctx: Context): this.type =
     createOutput(outDir) {
       def genDoc(e: model.Entity): Unit = {
         ctx.docbase.echo(s"Generating doc page for: ${e.path.mkString(".")}")
@@ -198,7 +200,11 @@ case class Site(
           if (e.kind == "package") ("/index.html", -1)
           else (".html", 0)
 
-        val target = mkdirs(fs.getPath(outDir.getAbsolutePath +  "/api/" + e.path.mkString("/") + suffix))
+        val path = if (scala.util.Properties.isWin)
+          e.path.map(_.replace("<", "_").replace(">", "_"))
+        else 
+          e.path
+        val target = mkdirs(fs.getPath(outDir.getAbsolutePath +  "/api/" + path.mkString("/") + suffix))
         val params = defaultParams(target.toFile, -1).withPosts(blogInfo).withEntity(Some(e)).toMap
         val page = new HtmlPage("_layouts/api-page.html", layouts("api-page").content, params, includes)
 
@@ -230,7 +236,7 @@ case class Site(
     }
 
   /** Generate HTML files from markdown and .html sources */
-  def generateHtmlFiles(outDir: JFile = new JFile(root.getAbsolutePath + "/_site"))(implicit ctx: Context): this.type =
+  def generateHtmlFiles(outDir: JFile = defaultOutDir)(implicit ctx: Context): this.type =
     createOutput(outDir) {
       compilableFiles.foreach { asset =>
         val pathFromRoot = stripRoot(asset)
@@ -250,7 +256,7 @@ case class Site(
     }
 
   /** Generate blog from files in `blog/_posts` and output in `outDir` */
-  def generateBlog(outDir: JFile = new JFile(root.getAbsolutePath + "/_site"))(implicit ctx: Context): this.type =
+  def generateBlog(outDir: JFile = defaultOutDir)(implicit ctx: Context): this.type =
     createOutput(outDir) {
       blogposts.foreach { file =>
         val BlogPost.extract(year, month, day, name, ext) = file.getName

docs/docs/reference/principled-meta-programming.md

@@ -29,8 +29,13 @@ prints it again in an error message if it evaluates to `false`.
     inline def assert(expr: => Boolean): Unit =
       ~ assertImpl('(expr))
 
-    def assertImpl(expr: Expr[Boolean]) =
-      '{ if !(~expr) then throw new AssertionError(s"failed assertion: ${~showExpr(expr)}") }
+    def assertImpl(expr: Expr[Boolean]) = '{
+      if !(~expr) then
+        throw new AssertionError(s"failed assertion: ${~showExpr(expr)}")
+    }
+
+    def showExpr(expr: Expr[Boolean]): Expr[String] =
+      '("<some source code>") // Better implementation later in this document
 
 If `e` is an expression, then `'(e)` or `'{e}` represent the typed
 abstract syntax tree representing `e`. If `T` is a type, then `'[T]`
@@ -587,9 +592,12 @@ analogue of lifting.
 
 Using lifting, we can now give the missing definition of `showExpr` in the introductory example:
 
-    def showExpr[T](expr: Expr[T]): Expr[String] = expr.toString
+    def showExpr[T](expr: Expr[T]): Expr[String] = {
+      val code = expr.show
+      code.toExpr
+    }
 
-That is, the `showExpr` method converts its `Expr` argument to a string, and lifts
+That is, the `showExpr` method converts its `Expr` argument to a string (`code`), and lifts
 the result back to an `Expr[String]` using the implicit `toExpr` conversion.
 
 ## Implementation

library/src-scala3/scala/StagedTuple.scala renamed to library/src-bootstrapped/scala/StagedTuple.scala

@@ -0,0 +1,18 @@
+package scala
+
+package object quoted {
+
+  implicit class LiftExprOps[T](val x: T) extends AnyVal {
+    def toExpr(implicit ev: Liftable[T]): Expr[T] = ev.toExpr(x)
+  }
+
+  implicit class ListOfExprOps[T](val list: List[Expr[T]]) extends AnyVal {
+    def toExprOfList(implicit ev: Type[T]): Expr[List[T]] = {
+      def rec(list: List[Expr[T]]): Expr[List[T]] = list match {
+        case x :: xs  => '{ (~x) :: (~rec(xs)) }
+        case Nil => '(Nil)
+      }
+      rec(list)
+    }
+  }
+}

library/src-scala3/scala/Tuple.scala renamed to library/src-bootstrapped/scala/Tuple.scala

@@ -775,14 +775,14 @@ object Build {
   lazy val dottyLibrarySettings = Seq(
     libraryDependencies += "org.scala-lang" % "scala-library" % scalacVersion,
     // Add version-specific source directories:
-    // - files in src-scala3 will only be compiled by dotty
-    // - files in src-scala2 will only be compiled by scalac
+    // - files in src-non-bootstrapped will only be compiled by the reference compiler (scalac)
+    // - files in src-bootstrapped will only be compiled by the current dotty compiler (non-bootstrapped and bootstrapped)
     unmanagedSourceDirectories in Compile += {
       val baseDir = baseDirectory.value
       if (isDotty.value)
-        baseDir / "src-scala3"
+        baseDir / "src-bootstrapped"
       else
-        baseDir / "src-scala2"
+        baseDir / "src-non-bootstrapped"
     }
   )
 

library/src-bootstrapped/scala/quoted/package.scala

@@ -0,0 +1,58 @@
+import scala.quoted._
+import scala.tasty.Reflection
+
+import scala.language.implicitConversions
+
+object FQuote {
+
+  implicit class SCOps(ctx: StringContext) {
+    inline def ff(args: => Any*): String = ~impl('(this), '(args))
+  }
+
+  /*private*/ def impl(receiver: Expr[SCOps], args: Expr[Seq[Any]])(implicit reflect: Reflection): Expr[String] = {
+    import reflect._
+
+    def liftListOfAny(lst: List[Term]): Expr[List[Any]] = lst match {
+      case x :: xs  =>
+        val head = x.seal[Any]
+        val tail = liftListOfAny(xs)
+        '{ ~head :: ~tail }
+      case Nil => '(Nil)
+    }
+
+    def isStringConstant(tree: Term) = tree match {
+      case Term.Literal(_) => true
+      case _ => false
+    }
+
+    def isSCOpsConversion(tree: Term) =
+      tree.symbol.fullName == "FQuote$.SCOps"
+
+    def isStringContextApply(tree: Term) =
+      tree.symbol.fullName == "scala.StringContext$.apply"
+
+    // FQuote.SCOps(StringContext.apply([p0, ...]: String*)
+    val parts = receiver.unseal.underlyingArgument match {
+      case Term.Apply(conv, List(Term.Apply(fun, List(Term.Typed(Term.Repeated(values), _)))))
+          if isSCOpsConversion(conv) &&
+             isStringContextApply(fun) &&
+             values.forall(isStringConstant) =>
+        values.collect { case Term.Literal(Constant.String(value)) => value }
+      case tree =>
+        throw new QuoteError(s"String literal expected, but ${tree.show} found")
+    }
+
+    // [a0, ...]: Any*
+    val Term.Typed(Term.Repeated(allArgs), _) = args.unseal.underlyingArgument
+
+    for ((arg, part) <- allArgs.zip(parts.tail)) {
+      if (part.startsWith("%d") && !(arg.tpe <:< definitions.IntType)) {
+        return '(s"`${~arg.showCode.toExpr}` is not of type Int")
+      }
+
+    }
+
+    val string = parts.mkString("")
+    '{ new collection.immutable.StringOps(~string.toExpr).format(~args: _*) }
+  }
+}

library/src-scala3/scala/typelevel/package.scala renamed to library/src-bootstrapped/scala/typelevel/package.scala

@@ -0,0 +1,10 @@
+import FQuote._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val one: Int = 1
+    assert(ff"Hello $one%d!" == "Hello 1!")
+    val world: String = "world"
+    assert(ff"Hello $world%d!" == "`world` is not of type Int")
+  }
+}

library/src-scala2/scala/Tuple.scala renamed to library/src-non-bootstrapped/scala/Tuple.scala

@@ -56,11 +56,7 @@ object XmlQuote {
     // [a0, ...]: Any*
     val args2: Expr[List[Any]] = args.unseal.underlyingArgument match {
       case Typed(Repeated(args0), _) => // statically known args, make list directly
-        def liftListOfAny(lst: List[Expr[Any]]): Expr[List[Any]] = lst match {
-          case x :: xs  => '{ ~x :: ~liftListOfAny(xs) }
-          case Nil => '(Nil)
-        }
-        liftListOfAny(args0.map(_.seal[Any]))
+        args0.map(_.seal[Any]).toExprOfList
       case _ =>
         '((~args).toList)