Merge branch 'master' into disallow-interpreation-of-arbitrary-calls-in-paramteres

Author: nicolasstucki

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

@@ -376,8 +376,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         else if (name.isTypeName) typeText(txt)
         else txt
       case tree @ Select(qual, name) =>
-        if (!printDebug && tree.hasType && tree.symbol.isTypeSplice) typeText("${") ~ toTextLocal(qual) ~ typeText("}")
-        else if (qual.isType) toTextLocal(qual) ~ "#" ~ typeText(toText(name))
+        if (qual.isType) toTextLocal(qual) ~ "#" ~ typeText(toText(name))
         else toTextLocal(qual) ~ ("." ~ nameIdText(tree) provided (name != nme.CONSTRUCTOR || printDebug))
       case tree: This =>
         optDotPrefix(tree) ~ keywordStr("this") ~ idText(tree)

compiler/src/dotty/tools/io/ZipArchive.scala

@@ -108,6 +108,8 @@ abstract class ZipArchive(override val jpath: JPath) extends AbstractFile with E
     if (entry.isDirectory) ensureDir(dirs, entry.getName)
     else ensureDir(dirs, dirName(entry.getName))
   }
+
+  def close(): Unit
 }
 /** ''Note:  This library is considered experimental and should not be used unless you know what you are doing.'' */
 final class FileZipArchive(jpath: JPath) extends ZipArchive(jpath) {
@@ -176,6 +178,7 @@ final class FileZipArchive(jpath: JPath) extends ZipArchive(jpath) {
       }
     } finally {
       if (ZipArchive.closeZipFile) zipFile.close()
+      else closeables ::= zipFile
     }
     (root, dirs)
   }
@@ -194,15 +197,24 @@ final class FileZipArchive(jpath: JPath) extends ZipArchive(jpath) {
     case x: FileZipArchive => jpath.toAbsolutePath == x.jpath.toAbsolutePath
     case _                 => false
   }
+
+  private[this] var closeables: List[java.io.Closeable] = Nil
+  override def close(): Unit = {
+    closeables.foreach(_.close)
+    closeables = Nil
+  }
 }
 
 final class ManifestResources(val url: URL) extends ZipArchive(null) {
   def iterator(): Iterator[AbstractFile] = {
     val root     = new DirEntry("/", null)
     val dirs     = mutable.HashMap[String, DirEntry]("/" -> root)
-    val manifest = new Manifest(input)
+    val stream   = input
+    val manifest = new Manifest(stream)
     val iter     = manifest.getEntries().keySet().iterator().asScala.filter(_.endsWith(".class")).map(new ZipEntry(_))
 
+    closeables ::= stream
+
     for (zipEntry <- iter) {
       val dir = getDir(dirs, zipEntry)
       if (!zipEntry.isDirectory) {
@@ -251,4 +263,10 @@ final class ManifestResources(val url: URL) extends ZipArchive(null) {
       }
     }
   }
+
+  private[this] var closeables: List[java.io.Closeable] = Nil
+  override def close(): Unit = {
+    closeables.foreach(_.close())
+    closeables = Nil
+  }
 }

compiler/test/dotty/tools/io/ZipArchiveTest.scala

@@ -0,0 +1,137 @@
+package dotty.tools.io
+
+import java.io.IOException
+import java.net.{URI, URL, URLClassLoader}
+import java.nio.file.{Files, Path, Paths}
+import java.util.jar.{Attributes, Manifest, JarEntry, JarOutputStream}
+import java.lang.invoke.{MethodHandles, MethodType}
+
+import org.junit.Assert._
+import org.junit.Test
+
+import scala.util.chaining._
+import scala.util.Using
+
+class ZipArchiveTest {
+
+  @Test
+  def corruptZip(): Unit = {
+    val f = Files.createTempFile("test", ".jar")
+    val fza = new FileZipArchive(f)
+    try {
+      fza.iterator
+      assert(false)
+    }
+    catch {
+      case ex: IOException =>
+    }
+    finally {
+      Files.delete(f)
+    }
+  }
+
+  @Test
+  def missingFile(): Unit = {
+    val f = Paths.get("xxx.does.not.exist")
+    val fza = new FileZipArchive(f)
+    try {
+      fza.iterator
+      assert(false)
+    }
+    catch {
+      case ex: IOException =>
+    }
+  }
+
+  private val bootClassLoader: ClassLoader = {
+    if (!util.Properties.isJavaAtLeast("9")) null
+    else {
+      try {
+        MethodHandles
+          .lookup()
+          .findStatic(
+            classOf[ClassLoader],
+            "getPlatformClassLoader",
+            MethodType.methodType(classOf[ClassLoader])
+          )
+          .invoke()
+          .asInstanceOf[ClassLoader]
+      } catch {
+        case _: Throwable =>
+          null
+      }
+    }
+  }
+
+  private def classLoader(location: URI): ClassLoader =
+    new URLClassLoader(Array(location.toURL), bootClassLoader)
+
+  private def manifestAt(location: URI): URL = classLoader(location).getResource("META-INF/MANIFEST.MF")
+
+
+  // ZipArchive.fromManifestURL(URL)
+  @Test def `manifest resources just works`(): Unit = {
+    val jar = createTestJar()
+    val archive = new ManifestResources(manifestAt(jar.toUri))
+    try {
+      val it = archive.iterator
+      assertTrue(it.hasNext)
+      val f = it.next()
+      assertFalse(it.hasNext)
+      assertEquals("foo.class", f.name)
+    }
+    finally {
+      archive.close()
+      // The following results in IOException on Windows (file in use by another process).
+      // As jar created with Files.createTempFile, it will be deleted automatically.
+      try Files.delete(jar) catch case _: IOException => ()
+    }
+  }
+
+  private def createTestJar(): Path = Files.createTempFile("junit", ".jar").tap { f =>
+    val man = new Manifest()
+    man.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0")
+    man.getEntries().put("foo.class", new Attributes(0))
+    Using.resource(new JarOutputStream(Files.newOutputStream(f), man)) { jout =>
+      jout.putNextEntry(new JarEntry("foo.class"))
+      val bytes = "hello, world".getBytes
+      jout.write(bytes, 0, bytes.length)
+      ()
+    }
+  }
+
+  private def createTestZip(): Path = Files.createTempFile("junit", ".zip").tap { f =>
+    import java.util.zip._
+    Using.resource(new ZipOutputStream(Files.newOutputStream(f))) { zout =>
+      zout.setLevel(Deflater.NO_COMPRESSION)
+      zout.setMethod(ZipOutputStream.STORED)
+      val entry = new ZipEntry("foo.class")
+      val bytes = "hello, world".getBytes
+      entry.setSize(bytes.length)
+      entry.setCompressedSize(bytes.length)
+      entry.setCrc(new CRC32().tap(_.update(bytes, 0, bytes.length)).getValue)
+      zout.putNextEntry(entry)
+      zout.write(bytes, 0, bytes.length)
+      zout.closeEntry()
+      ()
+    }
+  }
+  /* zipfs doesn't write size field in file header as required by URLZipArchive
+  private def createTestZip2(): Path = {
+    import java.nio.file.FileSystems
+    import java.net.URI
+    import scala.util.chaining._
+    import scala.jdk.CollectionConverters._
+    val f = Files.createTempFile("junit", ".zip")
+    Files.delete(f)
+    val uri = URI.create(s"jar:${f.toUri}")
+    val env = Map("create" -> "true").asJava
+    Using.resource(FileSystems.newFileSystem(uri, env)) { fs =>
+      val path = fs.getPath("foo.class")
+      val bytes = "hello, world".getBytes
+      Files.write(path, bytes)
+    }
+    f.tap(println(_))
+  }
+   */
+}

stdlib-bootstrapped-tasty-tests/test/BootstrappedStdLibTASYyTest.scala

@@ -108,7 +108,7 @@ object BootstrappedStdLibTASYyTest:
         ()
     }
     val classNames = scalaLibJarTastyClassNames.filterNot(blacklisted)
-    val hasErrors = inspector.inspect(scalaLibJarPath, classNames)
+    val hasErrors = inspector.inspectTastyFilesInJar(scalaLibJarPath)
     assert(!hasErrors, "Errors reported while loading from TASTy")
 
   def compileFromTasty(blacklisted: String => Boolean): Unit = {

tasty-inspector/src/scala/tasty/inspector/TastyInspector.scala

@@ -22,11 +22,37 @@ trait TastyInspector:
 
   /** Load and process TASTy files using TASTy reflect
    *
-   *  @param classpath Classpath where the classes are located
-   *  @param classes classes to be inspected
-   *  @return if an error was reported
+   *  @param tastyFiles List of paths of `.tasty` files
    */
-  def inspect(classpath: String, classes: List[String]): Boolean =
+  def inspectTastyFiles(tastyFiles: List[String]): Boolean =
+    inspectAllTastyFiles(tastyFiles, Nil, Nil)
+
+  /** Load and process TASTy files in a `jar` file using TASTy reflect
+   *
+   *  @param jars Path of `.jar` file
+   */
+  def inspectTastyFilesInJar(jar: String): Boolean =
+    inspectAllTastyFiles(Nil, List(jar), Nil)
+
+  /** Load and process TASTy files using TASTy reflect
+   *
+   *  @param tastyFiles List of paths of `.tasty` files
+   *  @param jars List of path of `.jar` files
+   *  @param dependenciesClasspath Classpath with extra dependencies needed to load class in the `.tasty` files
+   */
+  def inspectAllTastyFiles(tastyFiles: List[String], jars: List[String], dependenciesClasspath: List[String]): Boolean =
+    def checkFile(fileName: String, ext: String): Unit =
+      val file = dotty.tools.io.Path(fileName)
+      if file.extension != ext then
+        throw new IllegalArgumentException(s"File extension is not `.$ext`: $file")
+      else if !file.exists then
+        throw new IllegalArgumentException(s"File not found: ${file.toAbsolute}")
+    tastyFiles.foreach(checkFile(_, "tasty"))
+    jars.foreach(checkFile(_, "jar"))
+    val files = tastyFiles ::: jars
+    files.nonEmpty && inspectFiles(dependenciesClasspath, files)
+
+  private def inspectFiles(classpath: List[String], classes: List[String]): Boolean =
     if (classes.isEmpty)
       throw new IllegalArgumentException("Parameter classes should no be empty")
 
@@ -64,11 +90,12 @@ trait TastyInspector:
     end TastyInspectorPhase
 
     val currentClasspath = ClasspathFromClassloader(getClass.getClassLoader)
-    val args = "-from-tasty" :: "-Yretain-trees" :: "-classpath" :: s"$classpath$pathSeparator$currentClasspath" :: classes
+    val fullClasspath = (classpath :+ currentClasspath).mkString(pathSeparator)
+    val args = "-from-tasty" :: "-Yretain-trees" :: "-classpath" :: fullClasspath :: classes
     val reporter = (new InspectorDriver).process(args.toArray)
     reporter.hasErrors
 
-  end inspect
+  end inspectFiles
 
 
 end TastyInspector

tests/neg-macros/delegate-match-1/Macro_1.scala

@@ -5,7 +5,7 @@ inline def f: Any = ${ fImpl }
 
 private def fImpl(using qctx: QuoteContext): Expr[Unit] = {
   import qctx.reflect._
-  Implicits.search(('[A]).unseal.tpe) match {
+  Implicits.search((Type[A]).unseal.tpe) match {
     case x: ImplicitSearchSuccess =>
       '{}
     case x: DivergingImplicit => '{}

tests/neg-macros/delegate-match-2/Macro_1.scala

@@ -5,7 +5,7 @@ inline def f: Any = ${ fImpl }
 
 private def fImpl (using qctx: QuoteContext) : Expr[Unit] = {
   import qctx.reflect._
-  Implicits.search(('[A]).unseal.tpe) match {
+  Implicits.search((Type[A]).unseal.tpe) match {
     case x: ImplicitSearchSuccess =>
       '{}
     case x: DivergingImplicit => '{}

tests/neg-macros/delegate-match-3/Macro_1.scala

@@ -5,7 +5,7 @@ inline def f: Any = ${ fImpl }
 
 private def fImpl(using qctx: QuoteContext) : Expr[Unit] = {
   import qctx.reflect._
-  Implicits.search(('[A]).unseal.tpe) match {
+  Implicits.search((Type[A]).unseal.tpe) match {
     case x: ImplicitSearchSuccess =>
       '{}
     case x: DivergingImplicit => '{}

tests/neg-macros/i4493-b.scala

@@ -1,7 +1,7 @@
 class Index[K]
 object Index {
   inline def succ[K](x: K): Unit = ${
-    implicit val t: quoted.Type[K] = '[K] // error
+    implicit val t: quoted.Type[K] = Type[K] // error
     '{new Index[K]} // error
   }
 }

tests/neg-macros/i4493.scala

@@ -1,7 +1,7 @@
 class Index[K]
 object Index {
   inline def succ[K]: Unit = ${
-    implicit val t: quoted.Type[K] = '[K] // error
+    implicit val t: quoted.Type[K] = Type[K] // error
     '{new Index[K]} // error
   }
 }

tests/neg-macros/i6530.scala

@@ -1,4 +1,4 @@
 object Macros {
-  inline def q : Int = ${ '[ Int ] } // error
+  inline def q : Int = ${ Type[ Int ] } // error
   val x : Int = 1 + q
 }

tests/neg-macros/i6530b.scala

@@ -4,9 +4,9 @@ object Foo {
     val tpe: quoted.Type[Int] = ???
     val expr: quoted.Expr[Int] = ???
 
-    val a: quoted.Expr[Int] = ${ '[Int] } // error
+    val a: quoted.Expr[Int] = ${ Type[Int] } // error
     val b: quoted.Expr[Int] = '{ $tpe } // error
     val c: ${ '{ 43 } } = ???  // error
-    val d: quoted.Type[Int] = '[ $expr ] // error
+    val d: quoted.Type[Int] = Type[ $expr ] // error
   }
 }

tests/neg-macros/i7013.scala

@@ -2,5 +2,5 @@ import quoted._
 
 def foo()(using QuoteContext) = {
   class C
-  '[C] // error
+  Type[C] // error
 }

tests/neg-macros/i7013b.scala

@@ -3,6 +3,6 @@ import quoted._
 class Foo {
   class Bar
   def foo()(using QuoteContext) = {
-    '[Bar] // error
+    Type[Bar] // error
   }
 }

tests/neg-macros/i7013c.scala

@@ -2,5 +2,5 @@ import quoted._
 
 def foo()(using QuoteContext) = {
   type C
-  '[C] // error
+  Type[C] // error
 }

tests/neg-macros/i7121.scala

@@ -7,7 +7,7 @@ class Test()(implicit qtx: QuoteContext) {
   @annot1('{4}) // error
   def foo(str: String) = ()
 
-  @annot2(4)(using '[Int]) // error
+  @annot2(4)(using Type[Int]) // error
   def foo2(str: String) = ()
 
 }

tests/pos-macros/i4023c/Macro_1.scala

@@ -1,5 +1,5 @@
 import scala.quoted._
 object Macro {
   inline def ff[T](x: T): T = ${ impl('x) }
-  def impl[T](x: Expr[T])(implicit t: Type[T], qctx: QuoteContext): Expr[T] = '{ $x: $t }
+  def impl[T](x: Expr[T])(implicit t: Type[T], qctx: QuoteContext): Expr[T] = '{ $x: T }
 }

tests/pos-macros/i4539.scala

@@ -1,5 +1,5 @@
 import scala.quoted._
 def test(using QuoteContext) = {
-  val q = '[String]
-  '[String]
+  val q = Type[String]
+  Type[String]
 }