From d96b7af9b71a3a649470f2a632db04de0ad97d07 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Tue, 5 Sep 2023 13:38:25 +0200 Subject: [PATCH 01/51] Towards 0.4.16 --- .github/workflows/publish.yml | 2 +- docs/conf.py | 4 ++-- nir/src/main/scala/scala/scalanative/nir/Versions.scala | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 53646aa3f6..fa3108e6d6 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -38,4 +38,4 @@ jobs: MAVEN_USER: "${{ secrets.SONATYPE_USER }}" MAVEN_PASSWORD: "${{ secrets.SONATYPE_PASSWORD }}" PGP_PASSPHRASE: "${{ secrets.PGP_PASSWORD }}" - run: sbt "-v" "-no-colors" "-J-Xmx5G" "publishRelease" + run: sbt "-v" "-no-colors" "-J-Xmx5G" "clean; ++3.1.3; publishRelease" diff --git a/docs/conf.py b/docs/conf.py index 4dd866427d..d0ba15ee84 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -69,9 +69,9 @@ def generateScalaNativeCurrentYear(): # built documents. # # The short X.Y version. -version = u'0.4.15' +version = u'0.4.16-SNAPSHOT' # The full version, including alpha/beta/rc tags. -release = u'0.4.15' +release = u'0.4.16-SNAPSHOT' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. diff --git a/nir/src/main/scala/scala/scalanative/nir/Versions.scala b/nir/src/main/scala/scala/scalanative/nir/Versions.scala index 0c9bcef008..6e105942ff 100644 --- a/nir/src/main/scala/scala/scalanative/nir/Versions.scala +++ b/nir/src/main/scala/scala/scalanative/nir/Versions.scala @@ -25,7 +25,7 @@ object Versions { final val revision: Int = 9 // a.k.a. MINOR version /* Current public release version of Scala Native. */ - final val current: String = "0.4.15" + final val current: String = "0.4.16-SNAPSHOT" final val currentBinaryVersion: String = binaryVersion(current) private object FullVersion { From aa9358858ce4bf9da95b9c78eadc5ab55f483578 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Tue, 5 Sep 2023 13:49:40 +0200 Subject: [PATCH 02/51] Add .readthedocs config file --- .readthedocs.yaml | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 .readthedocs.yaml diff --git a/.readthedocs.yaml b/.readthedocs.yaml new file mode 100644 index 0000000000..7f28580630 --- /dev/null +++ b/.readthedocs.yaml @@ -0,0 +1,13 @@ +# Read the Docs configuration file for Sphinx projects +# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details + +version: 2 + +build: + os: ubuntu-22.04 + tools: + python: "3.11" + +# Build documentation in the "docs/" directory with Sphinx +sphinx: + configuration: docs/conf.py From 8c9996de022ca862100828f51834a61b476a60db Mon Sep 17 00:00:00 2001 From: Lorenzo Gabriele Date: Mon, 25 Sep 2023 01:03:31 +0200 Subject: [PATCH 03/51] Restore heap size environment variables (#3491) * Restore heap size environment variables The environment variables used to set minimum and maximum heap size were not consistent in error messages, docs and actual behavior. Some wrong backports from the `main` branch changed some places to the new names used in Scala Native 0.5 --- docs/user/runtime.rst | 16 ++++++++-------- .../main/resources/scala-native/gc/boehm/gc.c | 4 ++-- .../resources/scala-native/gc/commix/CommixGC.c | 8 ++++---- .../main/resources/scala-native/gc/commix/Heap.c | 8 ++++---- .../resources/scala-native/gc/immix/ImmixGC.c | 6 +++--- .../src/main/resources/scala-native/gc/none/gc.c | 8 ++++---- 6 files changed, 25 insertions(+), 25 deletions(-) diff --git a/docs/user/runtime.rst b/docs/user/runtime.rst index 17c4d754d9..389bf69024 100644 --- a/docs/user/runtime.rst +++ b/docs/user/runtime.rst @@ -21,8 +21,8 @@ The following environment variables will be used for all GCs. They can go from 1 the system memory maximum or up to about 512 GB. The size is in bytes, kilobytes(k or K), megabytes(m or M), or gigabytes(g or G). Examples: 1024k, 1M, or 1G etc. -* GC_INITIAL_HEAP_SIZE changes the minimum heap size. -* GC_MAXIMUM_MAX_HEAP_SIZE changes the maximum heap size. +* SCALANATIVE_MIN_SIZE changes the minimum heap size. +* SCALANATIVE_MAX_SIZE changes the maximum heap size. The plan is to add more GC settings in the future using the Boehm setting names where applicable. @@ -42,8 +42,8 @@ Immix GC The following variables have not been changed to match the standard variables in Immix yet. -* SCALANATIVE_MIN_HEAP_SIZE changes the minimum heap size. -* SCALANATIVE_MAX_HEAP_SIZE changes the maximum heap size. +* SCALANATIVE_MIN_SIZE changes the minimum heap size. +* SCALANATIVE_MAX_SIZE changes the maximum heap size. Commix GC --------- @@ -64,11 +64,11 @@ your executable as needed: .. code-block:: shell - $ export SCALANATIVE_MIN_SIZE=64k; export SCALANATIVE_MAX_SIZE=512k; sandbox/.2.13/target/scala-2.13/sandbox-out - SCALANATIVE_MAX_HEAP_SIZE too small to initialize heap. + $ SCALANATIVE_MIN_SIZE=64k SCALANATIVE_MAX_SIZE=512k sandbox/.2.13/target/scala-2.13/sandbox-out + SCALANATIVE_MAX_SIZE too small to initialize heap. Minimum required: 1m - $ export SCALANATIVE_MIN_SIZE=2m; export SCALANATIVE_MAX_SIZE=1m; sandbox/.2.13/target/scala-2.13/sandbox-out - SCALANATIVE_MAX_HEAP_SIZE should be at least SCALANATIVE_MIN_HEAP_SIZE + $ SCALANATIVE_MIN_SIZE=2m SCALANATIVE_MAX_SIZE=1m sandbox/.2.13/target/scala-2.13/sandbox-out + SCALANATIVE_MAX_SIZE should be at least SCALANATIVE_MIN_SIZE Continue to :ref:`lib`. diff --git a/nativelib/src/main/resources/scala-native/gc/boehm/gc.c b/nativelib/src/main/resources/scala-native/gc/boehm/gc.c index 6f9fb8d0d7..56a608230f 100644 --- a/nativelib/src/main/resources/scala-native/gc/boehm/gc.c +++ b/nativelib/src/main/resources/scala-native/gc/boehm/gc.c @@ -40,7 +40,7 @@ void *scalanative_alloc_atomic(void *info, size_t size) { } size_t scalanative_get_init_heapsize() { - return Parse_Env_Or_Default("GC_INITIAL_HEAP_SIZE", 0L); + return Parse_Env_Or_Default("SCALANATIVE_MIN_SIZE", 0L); } size_t scalanative_get_max_heapsize() { @@ -49,7 +49,7 @@ size_t scalanative_get_max_heapsize() { GC_get_prof_stats(stats, sizeof(struct GC_prof_stats_s)); size_t heap_sz = stats->heapsize_full; free(stats); - return Parse_Env_Or_Default("GC_MAXIMUM_HEAP_SIZE", heap_sz); + return Parse_Env_Or_Default("SCALANATIVE_MAX_SIZE", heap_sz); } void scalanative_collect() { GC_gcollect(); } diff --git a/nativelib/src/main/resources/scala-native/gc/commix/CommixGC.c b/nativelib/src/main/resources/scala-native/gc/commix/CommixGC.c index dbd48b461a..89f6ebc3b2 100644 --- a/nativelib/src/main/resources/scala-native/gc/commix/CommixGC.c +++ b/nativelib/src/main/resources/scala-native/gc/commix/CommixGC.c @@ -87,17 +87,17 @@ INLINE void scalanative_register_weak_reference_handler(void *handler) { } /* Get the minimum heap size */ -/* If the user has set a minimum heap size using the GC_INITIAL_HEAP_SIZE +/* If the user has set a minimum heap size using the SCALANATIVE_MIN_SIZE * environment variable, */ /* then this size will be returned. */ /* Otherwise, the default minimum heap size will be returned.*/ size_t scalanative_get_init_heapsize() { return Settings_MinHeapSize(); } /* Get the maximum heap size */ -/* If the user has set a maximum heap size using the GC_MAXIMUM_HEAP_SIZE */ +/* If the user has set a maximum heap size using the SCALANATIVE_MAX_SIZE */ /* environment variable,*/ /* then this size will be returned.*/ /* Otherwise, the total size of the physical memory (guarded) will be returned*/ size_t scalanative_get_max_heapsize() { - return Parse_Env_Or_Default("GC_MAXIMUM_HEAP_SIZE", Heap_getMemoryLimit()); -} \ No newline at end of file + return Parse_Env_Or_Default("SCALANATIVE_MAX_SIZE", Heap_getMemoryLimit()); +} diff --git a/nativelib/src/main/resources/scala-native/gc/commix/Heap.c b/nativelib/src/main/resources/scala-native/gc/commix/Heap.c index 7a23af5eb7..1099d95d97 100644 --- a/nativelib/src/main/resources/scala-native/gc/commix/Heap.c +++ b/nativelib/src/main/resources/scala-native/gc/commix/Heap.c @@ -89,7 +89,7 @@ void Heap_Init(Heap *heap, size_t minHeapSize, size_t maxHeapSize) { size_t memoryLimit = Heap_getMemoryLimit(); if (maxHeapSize < MIN_HEAP_SIZE) { - fprintf(stderr, "GC_MAXIMUM_HEAP_SIZE too small to initialize heap.\n"); + fprintf(stderr, "SCALANATIVE_MAX_SIZE too small to initialize heap.\n"); fprintf(stderr, "Minimum required: %zum \n", (size_t)(MIN_HEAP_SIZE / 1024 / 1024)); fflush(stderr); @@ -97,7 +97,7 @@ void Heap_Init(Heap *heap, size_t minHeapSize, size_t maxHeapSize) { } if (minHeapSize > memoryLimit) { - fprintf(stderr, "GC_INITIAL_HEAP_SIZE is too large.\n"); + fprintf(stderr, "SCALANATIVE_MIN_SIZE is too large.\n"); fprintf(stderr, "Maximum possible: %zug \n", memoryLimit / 1024 / 1024 / 1024); fflush(stderr); @@ -105,8 +105,8 @@ void Heap_Init(Heap *heap, size_t minHeapSize, size_t maxHeapSize) { } if (maxHeapSize < minHeapSize) { - fprintf(stderr, "GC_MAXIMUM_HEAP_SIZE should be at least " - "GC_INITIAL_HEAP_SIZE\n"); + fprintf(stderr, "SCALANATIVE_MAX_SIZE should be at least " + "SCALANATIVE_MIN_SIZE\n"); fflush(stderr); exit(1); } diff --git a/nativelib/src/main/resources/scala-native/gc/immix/ImmixGC.c b/nativelib/src/main/resources/scala-native/gc/immix/ImmixGC.c index 4277bda93d..3886847c5c 100644 --- a/nativelib/src/main/resources/scala-native/gc/immix/ImmixGC.c +++ b/nativelib/src/main/resources/scala-native/gc/immix/ImmixGC.c @@ -63,17 +63,17 @@ INLINE void scalanative_register_weak_reference_handler(void *handler) { } /* Get the minimum heap size */ -/* If the user has set a minimum heap size using the GC_INITIAL_HEAP_SIZE +/* If the user has set a minimum heap size using the SCALANATIVE_MIN_SIZE * environment variable, */ /* then this size will be returned. */ /* Otherwise, the default minimum heap size will be returned.*/ size_t scalanative_get_init_heapsize() { return Settings_MinHeapSize(); } /* Get the maximum heap size */ -/* If the user has set a maximum heap size using the GC_MAXIMUM_HEAP_SIZE +/* If the user has set a maximum heap size using the SCALANATIVE_MAX_SIZE * environment variable,*/ /* then this size will be returned.*/ /* Otherwise, the total size of the physical memory (guarded) will be returned*/ size_t scalanative_get_max_heapsize() { - return Parse_Env_Or_Default("GC_MAXIMUM_HEAP_SIZE", Heap_getMemoryLimit()); + return Parse_Env_Or_Default("SCALANATIVE_MAX_SIZE", Heap_getMemoryLimit()); } diff --git a/nativelib/src/main/resources/scala-native/gc/none/gc.c b/nativelib/src/main/resources/scala-native/gc/none/gc.c index e4a9af1fdc..f85715d6d3 100644 --- a/nativelib/src/main/resources/scala-native/gc/none/gc.c +++ b/nativelib/src/main/resources/scala-native/gc/none/gc.c @@ -35,11 +35,11 @@ void exitWithOutOfMemory() { } size_t scalanative_get_init_heapsize() { - return Parse_Env_Or_Default("GC_INITIAL_HEAP_SIZE", 0L); + return Parse_Env_Or_Default("SCALANATIVE_MIN_SIZE", 0L); } size_t scalanative_get_max_heapsize() { - return Parse_Env_Or_Default("GC_MAXIMUM_HEAP_SIZE", getMemorySize()); + return Parse_Env_Or_Default("SCALANATIVE_MAX_SIZE", getMemorySize()); } void Prealloc_Or_Default() { @@ -49,12 +49,12 @@ void Prealloc_Or_Default() { size_t memorySize = getMemorySize(); DEFAULT_CHUNK = // Default Maximum allocation Map 4GB - Choose_IF(Parse_Env_Or_Default_String("GC_MAXIMUM_HEAP_SIZE", + Choose_IF(Parse_Env_Or_Default_String("SCALANATIVE_MAX_SIZE", DEFAULT_CHUNK_SIZE), Less_OR_Equal, memorySize); PREALLOC_CHUNK = // Preallocation - Choose_IF(Parse_Env_Or_Default("GC_INITIAL_HEAP_SIZE", 0L), + Choose_IF(Parse_Env_Or_Default("SCALANATIVE_MIN_SIZE", 0L), Less_OR_Equal, DEFAULT_CHUNK); if (PREALLOC_CHUNK == 0L) { // no prealloc settings. From 1345d0bedd478ada64dc8ed4134be81a02d30b0b Mon Sep 17 00:00:00 2001 From: Rikito Taniguchi Date: Wed, 6 Sep 2023 17:51:09 +0900 Subject: [PATCH 04/51] Fix String.offsetByCodePoints for unpaired surrogates (#3471) Previously, String.offsetByCodePoints had an error when the offsetByCodePoints ends with the unpaired higher surrogate. This commit fix the bound check in the offsetByCodePoints not to check the next index is the lower surrogate after the higher surrogate. (cherry picked from commit e51e4e77f109d7655f640761ee4de5158f12068f) --- .../src/main/scala/java/lang/Character.scala | 4 +-- .../testsuite/javalib/lang/StringTest.scala | 26 +++++++++++++++++++ 2 files changed, 28 insertions(+), 2 deletions(-) diff --git a/javalib/src/main/scala/java/lang/Character.scala b/javalib/src/main/scala/java/lang/Character.scala index 7c8d1cc179..fb5937212c 100644 --- a/javalib/src/main/scala/java/lang/Character.scala +++ b/javalib/src/main/scala/java/lang/Character.scala @@ -378,7 +378,7 @@ object Character { } if (isHighSurrogate(seq(i))) { val next = i + 1 - if (next <= end && isLowSurrogate(seq(next))) { + if (next < end && isLowSurrogate(seq(next))) { i += 1 } } @@ -396,7 +396,7 @@ object Character { } if (isLowSurrogate(seq(i))) { val prev = i - 1 - if (prev >= start && isHighSurrogate(seq(prev))) { + if (prev > start && isHighSurrogate(seq(prev))) { i -= 1 } } diff --git a/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/lang/StringTest.scala b/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/lang/StringTest.scala index 6e501d4bb2..eb5ae8137d 100644 --- a/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/lang/StringTest.scala +++ b/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/lang/StringTest.scala @@ -127,6 +127,32 @@ class StringTest { ) } + @Test def offsetByCodePoints(): Unit = { + assertTrue("abc".offsetByCodePoints(0, 3) == 3) + assertTrue("abc".offsetByCodePoints(1, 2) == 3) + + assertTrue("abc".offsetByCodePoints(3, -3) == 0) + assertTrue("abc".offsetByCodePoints(3, -2) == 1) + + assertTrue("\uD800\uDC00".offsetByCodePoints(0, 1) == 2) + assertTrue("\uD800\uDC00".offsetByCodePoints(1, -1) == 0) + } + + @Test def offsetByCodePointsUnpairedSurrogates(): Unit = { + assertTrue("\uD800".offsetByCodePoints(0, 1) == 1) + assertTrue("\uDBFF".offsetByCodePoints(0, 1) == 1) + assertTrue("\uDC00".offsetByCodePoints(0, 1) == 1) + assertTrue("\uDFFF".offsetByCodePoints(0, 1) == 1) + + assertTrue("\uD800".offsetByCodePoints(1, -1) == 0) + assertTrue("\uDBFF".offsetByCodePoints(1, -1) == 0) + assertTrue("\uDC00".offsetByCodePoints(1, -1) == 0) + assertTrue("\uDFFF".offsetByCodePoints(1, -1) == 0) + + assertTrue("\uD800x".offsetByCodePoints(0, 2) == 2) + assertTrue("x\uD800".offsetByCodePoints(0, 2) == 2) + } + @Test def compareTo(): Unit = { assertTrue("test".compareTo("utest") < 0) assertTrue("test".compareTo("test") == 0) From 6b5be7a9567b3193b00e6d945ef118d1f29297cd Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Thu, 7 Sep 2023 00:00:36 +0200 Subject: [PATCH 05/51] Add Scala 2.13.12 to the build (cherry picked from commit f5b1d571707a3d924f8805cdec9de8be5899129e) --- project/ScalaVersions.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/project/ScalaVersions.scala b/project/ScalaVersions.scala index 5d8e8a1397..79b93c7f77 100644 --- a/project/ScalaVersions.scala +++ b/project/ScalaVersions.scala @@ -19,7 +19,7 @@ package build object ScalaVersions { // Versions of Scala used for publishing compiler plugins val crossScala212 = (13 to 18).map(v => s"2.12.$v") - val crossScala213 = (4 to 11).map(v => s"2.13.$v") + val crossScala213 = (4 to 12).map(v => s"2.13.$v") val crossScala3 = List( (0 to 3).map(v => s"3.1.$v"), (0 to 2).map(v => s"3.2.$v"), From 27bffde8ac4f34b2ffcf6074a199731b80864662 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Thu, 7 Sep 2023 00:36:24 +0200 Subject: [PATCH 06/51] Fix scalalib patches, remove optimization of ClassTag inlines (cherry picked from commit d030d2ca5e2145b24554b96cdddcced4c7522ef2) --- .../scala/reflect/Manifest.scala.patch | 249 ++++++++++++++++++ .../scala/reflect/Manifest.scala.patch | 249 ++++++++++++++++++ .../scala/reflect/Manifest.scala.patch | 249 ++++++++++++++++++ .../scala/reflect/ClassTag.scala.patch | 38 +-- .../scala/reflect/Manifest.scala.patch | 36 +-- 5 files changed, 772 insertions(+), 49 deletions(-) create mode 100644 scalalib/overrides-2.13.10/scala/reflect/Manifest.scala.patch create mode 100644 scalalib/overrides-2.13.11/scala/reflect/Manifest.scala.patch create mode 100644 scalalib/overrides-2.13.9/scala/reflect/Manifest.scala.patch diff --git a/scalalib/overrides-2.13.10/scala/reflect/Manifest.scala.patch b/scalalib/overrides-2.13.10/scala/reflect/Manifest.scala.patch new file mode 100644 index 0000000000..47aceec51c --- /dev/null +++ b/scalalib/overrides-2.13.10/scala/reflect/Manifest.scala.patch @@ -0,0 +1,249 @@ +--- 2.13.6/scala/reflect/Manifest.scala ++++ overrides-2.13/scala/reflect/Manifest.scala +@@ -82,22 +82,22 @@ + def valueManifests: List[AnyValManifest[_]] = + ManifestFactory.valueManifests + +- val Byte: ManifestFactory.ByteManifest = ManifestFactory.Byte +- val Short: ManifestFactory.ShortManifest = ManifestFactory.Short +- val Char: ManifestFactory.CharManifest = ManifestFactory.Char +- val Int: ManifestFactory.IntManifest = ManifestFactory.Int +- val Long: ManifestFactory.LongManifest = ManifestFactory.Long +- val Float: ManifestFactory.FloatManifest = ManifestFactory.Float +- val Double: ManifestFactory.DoubleManifest = ManifestFactory.Double +- val Boolean: ManifestFactory.BooleanManifest = ManifestFactory.Boolean +- val Unit: ManifestFactory.UnitManifest = ManifestFactory.Unit ++ @inline def Byte: ManifestFactory.ByteManifest = ManifestFactory.Byte ++ @inline def Short: ManifestFactory.ShortManifest = ManifestFactory.Short ++ @inline def Char: ManifestFactory.CharManifest = ManifestFactory.Char ++ @inline def Int: ManifestFactory.IntManifest = ManifestFactory.Int ++ @inline def Long: ManifestFactory.LongManifest = ManifestFactory.Long ++ @inline def Float: ManifestFactory.FloatManifest = ManifestFactory.Float ++ @inline def Double: ManifestFactory.DoubleManifest = ManifestFactory.Double ++ @inline def Boolean: ManifestFactory.BooleanManifest = ManifestFactory.Boolean ++ @inline def Unit: ManifestFactory.UnitManifest = ManifestFactory.Unit + +- val Any: Manifest[scala.Any] = ManifestFactory.Any +- val Object: Manifest[java.lang.Object] = ManifestFactory.Object +- val AnyRef: Manifest[scala.AnyRef] = ManifestFactory.AnyRef +- val AnyVal: Manifest[scala.AnyVal] = ManifestFactory.AnyVal +- val Null: Manifest[scala.Null] = ManifestFactory.Null +- val Nothing: Manifest[scala.Nothing] = ManifestFactory.Nothing ++ @inline def Any: Manifest[scala.Any] = ManifestFactory.Any ++ @inline def Object: Manifest[java.lang.Object] = ManifestFactory.Object ++ @inline def AnyRef: Manifest[scala.AnyRef] = ManifestFactory.AnyRef ++ @inline def AnyVal: Manifest[scala.AnyVal] = ManifestFactory.AnyVal ++ @inline def Null: Manifest[scala.Null] = ManifestFactory.Null ++ @inline def Nothing: Manifest[scala.Nothing] = ManifestFactory.Nothing + + /** Manifest for the singleton type `value.type`. */ + def singleType[T <: AnyRef](value: AnyRef): Manifest[T] = +@@ -172,7 +172,7 @@ + List(Byte, Short, Char, Int, Long, Float, Double, Boolean, Unit) + + @SerialVersionUID(1L) +- final private[reflect] class ByteManifest extends AnyValManifest[scala.Byte]("Byte") { ++ private[reflect] class ByteManifest extends AnyValManifest[scala.Byte]("Byte") { + def runtimeClass = java.lang.Byte.TYPE + @inline override def newArray(len: Int): Array[Byte] = new Array[Byte](len) + override def newWrappedArray(len: Int): ArraySeq[Byte] = new ArraySeq.ofByte(new Array[Byte](len)) +@@ -185,10 +185,11 @@ + } + private def readResolve(): Any = Manifest.Byte + } +- val Byte: ByteManifest = new ByteManifest ++ private object ByteManifest extends ByteManifest ++ def Byte: ByteManifest = ByteManifest + + @SerialVersionUID(1L) +- final private[reflect] class ShortManifest extends AnyValManifest[scala.Short]("Short") { ++ private[reflect] class ShortManifest extends AnyValManifest[scala.Short]("Short") { + def runtimeClass = java.lang.Short.TYPE + @inline override def newArray(len: Int): Array[Short] = new Array[Short](len) + override def newWrappedArray(len: Int): ArraySeq[Short] = new ArraySeq.ofShort(new Array[Short](len)) +@@ -201,10 +202,11 @@ + } + private def readResolve(): Any = Manifest.Short + } +- val Short: ShortManifest = new ShortManifest ++ private object ShortManifest extends ShortManifest ++ def Short: ShortManifest = ShortManifest + + @SerialVersionUID(1L) +- final private[reflect] class CharManifest extends AnyValManifest[scala.Char]("Char") { ++ private[reflect] class CharManifest extends AnyValManifest[scala.Char]("Char") { + def runtimeClass = java.lang.Character.TYPE + @inline override def newArray(len: Int): Array[Char] = new Array[Char](len) + override def newWrappedArray(len: Int): ArraySeq[Char] = new ArraySeq.ofChar(new Array[Char](len)) +@@ -217,10 +219,11 @@ + } + private def readResolve(): Any = Manifest.Char + } +- val Char: CharManifest = new CharManifest ++ private object CharManifest extends CharManifest ++ def Char: CharManifest = CharManifest + + @SerialVersionUID(1L) +- final private[reflect] class IntManifest extends AnyValManifest[scala.Int]("Int") { ++ private[reflect] class IntManifest extends AnyValManifest[scala.Int]("Int") { + def runtimeClass = java.lang.Integer.TYPE + @inline override def newArray(len: Int): Array[Int] = new Array[Int](len) + override def newWrappedArray(len: Int): ArraySeq[Int] = new ArraySeq.ofInt(new Array[Int](len)) +@@ -233,10 +236,11 @@ + } + private def readResolve(): Any = Manifest.Int + } +- val Int: IntManifest = new IntManifest ++ private object IntManifest extends IntManifest ++ def Int: IntManifest = IntManifest + + @SerialVersionUID(1L) +- final private[reflect] class LongManifest extends AnyValManifest[scala.Long]("Long") { ++ private[reflect] class LongManifest extends AnyValManifest[scala.Long]("Long") { + def runtimeClass = java.lang.Long.TYPE + @inline override def newArray(len: Int): Array[Long] = new Array[Long](len) + override def newWrappedArray(len: Int): ArraySeq[Long] = new ArraySeq.ofLong(new Array[Long](len)) +@@ -249,10 +253,11 @@ + } + private def readResolve(): Any = Manifest.Long + } +- val Long: LongManifest = new LongManifest ++ private object LongManifest extends LongManifest ++ def Long: LongManifest = LongManifest + + @SerialVersionUID(1L) +- final private[reflect] class FloatManifest extends AnyValManifest[scala.Float]("Float") { ++ private[reflect] class FloatManifest extends AnyValManifest[scala.Float]("Float") { + def runtimeClass = java.lang.Float.TYPE + @inline override def newArray(len: Int): Array[Float] = new Array[Float](len) + override def newWrappedArray(len: Int): ArraySeq[Float] = new ArraySeq.ofFloat(new Array[Float](len)) +@@ -265,10 +270,11 @@ + } + private def readResolve(): Any = Manifest.Float + } +- val Float: FloatManifest = new FloatManifest ++ private object FloatManifest extends FloatManifest ++ def Float: FloatManifest = FloatManifest + + @SerialVersionUID(1L) +- final private[reflect] class DoubleManifest extends AnyValManifest[scala.Double]("Double") { ++ private[reflect] class DoubleManifest extends AnyValManifest[scala.Double]("Double") { + def runtimeClass = java.lang.Double.TYPE + @inline override def newArray(len: Int): Array[Double] = new Array[Double](len) + override def newWrappedArray(len: Int): ArraySeq[Double] = new ArraySeq.ofDouble(new Array[Double](len)) +@@ -282,10 +288,11 @@ + } + private def readResolve(): Any = Manifest.Double + } +- val Double: DoubleManifest = new DoubleManifest ++ private object DoubleManifest extends DoubleManifest ++ def Double: DoubleManifest = DoubleManifest + + @SerialVersionUID(1L) +- final private[reflect] class BooleanManifest extends AnyValManifest[scala.Boolean]("Boolean") { ++ private[reflect] class BooleanManifest extends AnyValManifest[scala.Boolean]("Boolean") { + def runtimeClass = java.lang.Boolean.TYPE + @inline override def newArray(len: Int): Array[Boolean] = new Array[Boolean](len) + override def newWrappedArray(len: Int): ArraySeq[Boolean] = new ArraySeq.ofBoolean(new Array[Boolean](len)) +@@ -298,10 +305,11 @@ + } + private def readResolve(): Any = Manifest.Boolean + } +- val Boolean: BooleanManifest = new BooleanManifest ++ private object BooleanManifest extends BooleanManifest ++ def Boolean: BooleanManifest = BooleanManifest + + @SerialVersionUID(1L) +- final private[reflect] class UnitManifest extends AnyValManifest[scala.Unit]("Unit") { ++ private[reflect] class UnitManifest extends AnyValManifest[scala.Unit]("Unit") { + def runtimeClass = java.lang.Void.TYPE + @inline override def newArray(len: Int): Array[Unit] = new Array[Unit](len) + override def newWrappedArray(len: Int): ArraySeq[Unit] = new ArraySeq.ofUnit(new Array[Unit](len)) +@@ -317,57 +325,54 @@ + } + private def readResolve(): Any = Manifest.Unit + } +- val Unit: UnitManifest = new UnitManifest ++ private object UnitManifest extends UnitManifest ++ def Unit: UnitManifest = UnitManifest + +- private[this] val ObjectTYPE = classOf[java.lang.Object] +- private[this] val NothingTYPE = classOf[scala.runtime.Nothing$] +- private[this] val NullTYPE = classOf[scala.runtime.Null$] +- +- @SerialVersionUID(1L) +- final private class AnyManifest extends PhantomManifest[scala.Any](ObjectTYPE, "Any") { ++ private object AnyManifest extends PhantomManifest[scala.Any](classOf[java.lang.Object], "Any") { ++ override def runtimeClass = classOf[java.lang.Object] + override def newArray(len: Int) = new Array[scala.Any](len) + override def <:<(that: ClassManifest[_]): Boolean = (that eq this) + private def readResolve(): Any = Manifest.Any + } +- val Any: Manifest[scala.Any] = new AnyManifest ++ def Any: Manifest[scala.Any] = AnyManifest + +- @SerialVersionUID(1L) +- final private class ObjectManifest extends PhantomManifest[java.lang.Object](ObjectTYPE, "Object") { ++ private object ObjectManifest extends PhantomManifest[java.lang.Object](classOf[java.lang.Object], "Object") { ++ override def runtimeClass = classOf[java.lang.Object] + override def newArray(len: Int) = new Array[java.lang.Object](len) + override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any) + private def readResolve(): Any = Manifest.Object + } +- val Object: Manifest[java.lang.Object] = new ObjectManifest ++ def Object: Manifest[java.lang.Object] = ObjectManifest + +- val AnyRef: Manifest[scala.AnyRef] = Object.asInstanceOf[Manifest[scala.AnyRef]] ++ def AnyRef: Manifest[scala.AnyRef] = Object.asInstanceOf[Manifest[scala.AnyRef]] + +- @SerialVersionUID(1L) +- final private class AnyValPhantomManifest extends PhantomManifest[scala.AnyVal](ObjectTYPE, "AnyVal") { ++ private object AnyValManifest extends PhantomManifest[scala.AnyVal](classOf[java.lang.Object], "AnyVal") { ++ override def runtimeClass = classOf[java.lang.Object] + override def newArray(len: Int) = new Array[scala.AnyVal](len) + override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any) + private def readResolve(): Any = Manifest.AnyVal + } +- val AnyVal: Manifest[scala.AnyVal] = new AnyValPhantomManifest ++ def AnyVal: Manifest[scala.AnyVal] = AnyValManifest + +- @SerialVersionUID(1L) +- final private class NullManifest extends PhantomManifest[scala.Null](NullTYPE, "Null") { ++ private object NullManifest extends PhantomManifest[scala.Null](classOf[scala.runtime.Null$], "Null") { ++ override def runtimeClass = classOf[scala.runtime.Null$] + override def newArray(len: Int) = new Array[scala.Null](len) + override def <:<(that: ClassManifest[_]): Boolean = + (that ne null) && (that ne Nothing) && !(that <:< AnyVal) + private def readResolve(): Any = Manifest.Null + } +- val Null: Manifest[scala.Null] = new NullManifest ++ def Null: Manifest[scala.Null] = NullManifest + +- @SerialVersionUID(1L) +- final private class NothingManifest extends PhantomManifest[scala.Nothing](NothingTYPE, "Nothing") { ++ private object NothingManifest extends PhantomManifest[scala.Nothing](classOf[scala.runtime.Nothing$], "Nothing") { ++ override def runtimeClass = classOf[scala.runtime.Nothing$] + override def newArray(len: Int) = new Array[scala.Nothing](len) + override def <:<(that: ClassManifest[_]): Boolean = (that ne null) + private def readResolve(): Any = Manifest.Nothing + } +- val Nothing: Manifest[scala.Nothing] = new NothingManifest ++ def Nothing: Manifest[scala.Nothing] = NothingManifest + + @SerialVersionUID(1L) +- final private class SingletonTypeManifest[T <: AnyRef](value: AnyRef) extends Manifest[T] { ++ private class SingletonTypeManifest[T <: AnyRef](value: AnyRef) extends Manifest[T] { + lazy val runtimeClass = value.getClass + override lazy val toString = value.toString + ".type" + } +@@ -409,8 +414,9 @@ + * a top-level or static class. */ + @SerialVersionUID(1L) + private class ClassTypeManifest[T](prefix: Option[Manifest[_]], +- val runtimeClass: Predef.Class[_], ++ runtimeClass1: Predef.Class[_], + override val typeArguments: List[Manifest[_]]) extends Manifest[T] { ++ def runtimeClass: Predef.Class[_] = runtimeClass1 + override def toString = + (if (prefix.isEmpty) "" else prefix.get.toString+"#") + + (if (runtimeClass.isArray) "Array" else runtimeClass.getName) + diff --git a/scalalib/overrides-2.13.11/scala/reflect/Manifest.scala.patch b/scalalib/overrides-2.13.11/scala/reflect/Manifest.scala.patch new file mode 100644 index 0000000000..47aceec51c --- /dev/null +++ b/scalalib/overrides-2.13.11/scala/reflect/Manifest.scala.patch @@ -0,0 +1,249 @@ +--- 2.13.6/scala/reflect/Manifest.scala ++++ overrides-2.13/scala/reflect/Manifest.scala +@@ -82,22 +82,22 @@ + def valueManifests: List[AnyValManifest[_]] = + ManifestFactory.valueManifests + +- val Byte: ManifestFactory.ByteManifest = ManifestFactory.Byte +- val Short: ManifestFactory.ShortManifest = ManifestFactory.Short +- val Char: ManifestFactory.CharManifest = ManifestFactory.Char +- val Int: ManifestFactory.IntManifest = ManifestFactory.Int +- val Long: ManifestFactory.LongManifest = ManifestFactory.Long +- val Float: ManifestFactory.FloatManifest = ManifestFactory.Float +- val Double: ManifestFactory.DoubleManifest = ManifestFactory.Double +- val Boolean: ManifestFactory.BooleanManifest = ManifestFactory.Boolean +- val Unit: ManifestFactory.UnitManifest = ManifestFactory.Unit ++ @inline def Byte: ManifestFactory.ByteManifest = ManifestFactory.Byte ++ @inline def Short: ManifestFactory.ShortManifest = ManifestFactory.Short ++ @inline def Char: ManifestFactory.CharManifest = ManifestFactory.Char ++ @inline def Int: ManifestFactory.IntManifest = ManifestFactory.Int ++ @inline def Long: ManifestFactory.LongManifest = ManifestFactory.Long ++ @inline def Float: ManifestFactory.FloatManifest = ManifestFactory.Float ++ @inline def Double: ManifestFactory.DoubleManifest = ManifestFactory.Double ++ @inline def Boolean: ManifestFactory.BooleanManifest = ManifestFactory.Boolean ++ @inline def Unit: ManifestFactory.UnitManifest = ManifestFactory.Unit + +- val Any: Manifest[scala.Any] = ManifestFactory.Any +- val Object: Manifest[java.lang.Object] = ManifestFactory.Object +- val AnyRef: Manifest[scala.AnyRef] = ManifestFactory.AnyRef +- val AnyVal: Manifest[scala.AnyVal] = ManifestFactory.AnyVal +- val Null: Manifest[scala.Null] = ManifestFactory.Null +- val Nothing: Manifest[scala.Nothing] = ManifestFactory.Nothing ++ @inline def Any: Manifest[scala.Any] = ManifestFactory.Any ++ @inline def Object: Manifest[java.lang.Object] = ManifestFactory.Object ++ @inline def AnyRef: Manifest[scala.AnyRef] = ManifestFactory.AnyRef ++ @inline def AnyVal: Manifest[scala.AnyVal] = ManifestFactory.AnyVal ++ @inline def Null: Manifest[scala.Null] = ManifestFactory.Null ++ @inline def Nothing: Manifest[scala.Nothing] = ManifestFactory.Nothing + + /** Manifest for the singleton type `value.type`. */ + def singleType[T <: AnyRef](value: AnyRef): Manifest[T] = +@@ -172,7 +172,7 @@ + List(Byte, Short, Char, Int, Long, Float, Double, Boolean, Unit) + + @SerialVersionUID(1L) +- final private[reflect] class ByteManifest extends AnyValManifest[scala.Byte]("Byte") { ++ private[reflect] class ByteManifest extends AnyValManifest[scala.Byte]("Byte") { + def runtimeClass = java.lang.Byte.TYPE + @inline override def newArray(len: Int): Array[Byte] = new Array[Byte](len) + override def newWrappedArray(len: Int): ArraySeq[Byte] = new ArraySeq.ofByte(new Array[Byte](len)) +@@ -185,10 +185,11 @@ + } + private def readResolve(): Any = Manifest.Byte + } +- val Byte: ByteManifest = new ByteManifest ++ private object ByteManifest extends ByteManifest ++ def Byte: ByteManifest = ByteManifest + + @SerialVersionUID(1L) +- final private[reflect] class ShortManifest extends AnyValManifest[scala.Short]("Short") { ++ private[reflect] class ShortManifest extends AnyValManifest[scala.Short]("Short") { + def runtimeClass = java.lang.Short.TYPE + @inline override def newArray(len: Int): Array[Short] = new Array[Short](len) + override def newWrappedArray(len: Int): ArraySeq[Short] = new ArraySeq.ofShort(new Array[Short](len)) +@@ -201,10 +202,11 @@ + } + private def readResolve(): Any = Manifest.Short + } +- val Short: ShortManifest = new ShortManifest ++ private object ShortManifest extends ShortManifest ++ def Short: ShortManifest = ShortManifest + + @SerialVersionUID(1L) +- final private[reflect] class CharManifest extends AnyValManifest[scala.Char]("Char") { ++ private[reflect] class CharManifest extends AnyValManifest[scala.Char]("Char") { + def runtimeClass = java.lang.Character.TYPE + @inline override def newArray(len: Int): Array[Char] = new Array[Char](len) + override def newWrappedArray(len: Int): ArraySeq[Char] = new ArraySeq.ofChar(new Array[Char](len)) +@@ -217,10 +219,11 @@ + } + private def readResolve(): Any = Manifest.Char + } +- val Char: CharManifest = new CharManifest ++ private object CharManifest extends CharManifest ++ def Char: CharManifest = CharManifest + + @SerialVersionUID(1L) +- final private[reflect] class IntManifest extends AnyValManifest[scala.Int]("Int") { ++ private[reflect] class IntManifest extends AnyValManifest[scala.Int]("Int") { + def runtimeClass = java.lang.Integer.TYPE + @inline override def newArray(len: Int): Array[Int] = new Array[Int](len) + override def newWrappedArray(len: Int): ArraySeq[Int] = new ArraySeq.ofInt(new Array[Int](len)) +@@ -233,10 +236,11 @@ + } + private def readResolve(): Any = Manifest.Int + } +- val Int: IntManifest = new IntManifest ++ private object IntManifest extends IntManifest ++ def Int: IntManifest = IntManifest + + @SerialVersionUID(1L) +- final private[reflect] class LongManifest extends AnyValManifest[scala.Long]("Long") { ++ private[reflect] class LongManifest extends AnyValManifest[scala.Long]("Long") { + def runtimeClass = java.lang.Long.TYPE + @inline override def newArray(len: Int): Array[Long] = new Array[Long](len) + override def newWrappedArray(len: Int): ArraySeq[Long] = new ArraySeq.ofLong(new Array[Long](len)) +@@ -249,10 +253,11 @@ + } + private def readResolve(): Any = Manifest.Long + } +- val Long: LongManifest = new LongManifest ++ private object LongManifest extends LongManifest ++ def Long: LongManifest = LongManifest + + @SerialVersionUID(1L) +- final private[reflect] class FloatManifest extends AnyValManifest[scala.Float]("Float") { ++ private[reflect] class FloatManifest extends AnyValManifest[scala.Float]("Float") { + def runtimeClass = java.lang.Float.TYPE + @inline override def newArray(len: Int): Array[Float] = new Array[Float](len) + override def newWrappedArray(len: Int): ArraySeq[Float] = new ArraySeq.ofFloat(new Array[Float](len)) +@@ -265,10 +270,11 @@ + } + private def readResolve(): Any = Manifest.Float + } +- val Float: FloatManifest = new FloatManifest ++ private object FloatManifest extends FloatManifest ++ def Float: FloatManifest = FloatManifest + + @SerialVersionUID(1L) +- final private[reflect] class DoubleManifest extends AnyValManifest[scala.Double]("Double") { ++ private[reflect] class DoubleManifest extends AnyValManifest[scala.Double]("Double") { + def runtimeClass = java.lang.Double.TYPE + @inline override def newArray(len: Int): Array[Double] = new Array[Double](len) + override def newWrappedArray(len: Int): ArraySeq[Double] = new ArraySeq.ofDouble(new Array[Double](len)) +@@ -282,10 +288,11 @@ + } + private def readResolve(): Any = Manifest.Double + } +- val Double: DoubleManifest = new DoubleManifest ++ private object DoubleManifest extends DoubleManifest ++ def Double: DoubleManifest = DoubleManifest + + @SerialVersionUID(1L) +- final private[reflect] class BooleanManifest extends AnyValManifest[scala.Boolean]("Boolean") { ++ private[reflect] class BooleanManifest extends AnyValManifest[scala.Boolean]("Boolean") { + def runtimeClass = java.lang.Boolean.TYPE + @inline override def newArray(len: Int): Array[Boolean] = new Array[Boolean](len) + override def newWrappedArray(len: Int): ArraySeq[Boolean] = new ArraySeq.ofBoolean(new Array[Boolean](len)) +@@ -298,10 +305,11 @@ + } + private def readResolve(): Any = Manifest.Boolean + } +- val Boolean: BooleanManifest = new BooleanManifest ++ private object BooleanManifest extends BooleanManifest ++ def Boolean: BooleanManifest = BooleanManifest + + @SerialVersionUID(1L) +- final private[reflect] class UnitManifest extends AnyValManifest[scala.Unit]("Unit") { ++ private[reflect] class UnitManifest extends AnyValManifest[scala.Unit]("Unit") { + def runtimeClass = java.lang.Void.TYPE + @inline override def newArray(len: Int): Array[Unit] = new Array[Unit](len) + override def newWrappedArray(len: Int): ArraySeq[Unit] = new ArraySeq.ofUnit(new Array[Unit](len)) +@@ -317,57 +325,54 @@ + } + private def readResolve(): Any = Manifest.Unit + } +- val Unit: UnitManifest = new UnitManifest ++ private object UnitManifest extends UnitManifest ++ def Unit: UnitManifest = UnitManifest + +- private[this] val ObjectTYPE = classOf[java.lang.Object] +- private[this] val NothingTYPE = classOf[scala.runtime.Nothing$] +- private[this] val NullTYPE = classOf[scala.runtime.Null$] +- +- @SerialVersionUID(1L) +- final private class AnyManifest extends PhantomManifest[scala.Any](ObjectTYPE, "Any") { ++ private object AnyManifest extends PhantomManifest[scala.Any](classOf[java.lang.Object], "Any") { ++ override def runtimeClass = classOf[java.lang.Object] + override def newArray(len: Int) = new Array[scala.Any](len) + override def <:<(that: ClassManifest[_]): Boolean = (that eq this) + private def readResolve(): Any = Manifest.Any + } +- val Any: Manifest[scala.Any] = new AnyManifest ++ def Any: Manifest[scala.Any] = AnyManifest + +- @SerialVersionUID(1L) +- final private class ObjectManifest extends PhantomManifest[java.lang.Object](ObjectTYPE, "Object") { ++ private object ObjectManifest extends PhantomManifest[java.lang.Object](classOf[java.lang.Object], "Object") { ++ override def runtimeClass = classOf[java.lang.Object] + override def newArray(len: Int) = new Array[java.lang.Object](len) + override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any) + private def readResolve(): Any = Manifest.Object + } +- val Object: Manifest[java.lang.Object] = new ObjectManifest ++ def Object: Manifest[java.lang.Object] = ObjectManifest + +- val AnyRef: Manifest[scala.AnyRef] = Object.asInstanceOf[Manifest[scala.AnyRef]] ++ def AnyRef: Manifest[scala.AnyRef] = Object.asInstanceOf[Manifest[scala.AnyRef]] + +- @SerialVersionUID(1L) +- final private class AnyValPhantomManifest extends PhantomManifest[scala.AnyVal](ObjectTYPE, "AnyVal") { ++ private object AnyValManifest extends PhantomManifest[scala.AnyVal](classOf[java.lang.Object], "AnyVal") { ++ override def runtimeClass = classOf[java.lang.Object] + override def newArray(len: Int) = new Array[scala.AnyVal](len) + override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any) + private def readResolve(): Any = Manifest.AnyVal + } +- val AnyVal: Manifest[scala.AnyVal] = new AnyValPhantomManifest ++ def AnyVal: Manifest[scala.AnyVal] = AnyValManifest + +- @SerialVersionUID(1L) +- final private class NullManifest extends PhantomManifest[scala.Null](NullTYPE, "Null") { ++ private object NullManifest extends PhantomManifest[scala.Null](classOf[scala.runtime.Null$], "Null") { ++ override def runtimeClass = classOf[scala.runtime.Null$] + override def newArray(len: Int) = new Array[scala.Null](len) + override def <:<(that: ClassManifest[_]): Boolean = + (that ne null) && (that ne Nothing) && !(that <:< AnyVal) + private def readResolve(): Any = Manifest.Null + } +- val Null: Manifest[scala.Null] = new NullManifest ++ def Null: Manifest[scala.Null] = NullManifest + +- @SerialVersionUID(1L) +- final private class NothingManifest extends PhantomManifest[scala.Nothing](NothingTYPE, "Nothing") { ++ private object NothingManifest extends PhantomManifest[scala.Nothing](classOf[scala.runtime.Nothing$], "Nothing") { ++ override def runtimeClass = classOf[scala.runtime.Nothing$] + override def newArray(len: Int) = new Array[scala.Nothing](len) + override def <:<(that: ClassManifest[_]): Boolean = (that ne null) + private def readResolve(): Any = Manifest.Nothing + } +- val Nothing: Manifest[scala.Nothing] = new NothingManifest ++ def Nothing: Manifest[scala.Nothing] = NothingManifest + + @SerialVersionUID(1L) +- final private class SingletonTypeManifest[T <: AnyRef](value: AnyRef) extends Manifest[T] { ++ private class SingletonTypeManifest[T <: AnyRef](value: AnyRef) extends Manifest[T] { + lazy val runtimeClass = value.getClass + override lazy val toString = value.toString + ".type" + } +@@ -409,8 +414,9 @@ + * a top-level or static class. */ + @SerialVersionUID(1L) + private class ClassTypeManifest[T](prefix: Option[Manifest[_]], +- val runtimeClass: Predef.Class[_], ++ runtimeClass1: Predef.Class[_], + override val typeArguments: List[Manifest[_]]) extends Manifest[T] { ++ def runtimeClass: Predef.Class[_] = runtimeClass1 + override def toString = + (if (prefix.isEmpty) "" else prefix.get.toString+"#") + + (if (runtimeClass.isArray) "Array" else runtimeClass.getName) + diff --git a/scalalib/overrides-2.13.9/scala/reflect/Manifest.scala.patch b/scalalib/overrides-2.13.9/scala/reflect/Manifest.scala.patch new file mode 100644 index 0000000000..47aceec51c --- /dev/null +++ b/scalalib/overrides-2.13.9/scala/reflect/Manifest.scala.patch @@ -0,0 +1,249 @@ +--- 2.13.6/scala/reflect/Manifest.scala ++++ overrides-2.13/scala/reflect/Manifest.scala +@@ -82,22 +82,22 @@ + def valueManifests: List[AnyValManifest[_]] = + ManifestFactory.valueManifests + +- val Byte: ManifestFactory.ByteManifest = ManifestFactory.Byte +- val Short: ManifestFactory.ShortManifest = ManifestFactory.Short +- val Char: ManifestFactory.CharManifest = ManifestFactory.Char +- val Int: ManifestFactory.IntManifest = ManifestFactory.Int +- val Long: ManifestFactory.LongManifest = ManifestFactory.Long +- val Float: ManifestFactory.FloatManifest = ManifestFactory.Float +- val Double: ManifestFactory.DoubleManifest = ManifestFactory.Double +- val Boolean: ManifestFactory.BooleanManifest = ManifestFactory.Boolean +- val Unit: ManifestFactory.UnitManifest = ManifestFactory.Unit ++ @inline def Byte: ManifestFactory.ByteManifest = ManifestFactory.Byte ++ @inline def Short: ManifestFactory.ShortManifest = ManifestFactory.Short ++ @inline def Char: ManifestFactory.CharManifest = ManifestFactory.Char ++ @inline def Int: ManifestFactory.IntManifest = ManifestFactory.Int ++ @inline def Long: ManifestFactory.LongManifest = ManifestFactory.Long ++ @inline def Float: ManifestFactory.FloatManifest = ManifestFactory.Float ++ @inline def Double: ManifestFactory.DoubleManifest = ManifestFactory.Double ++ @inline def Boolean: ManifestFactory.BooleanManifest = ManifestFactory.Boolean ++ @inline def Unit: ManifestFactory.UnitManifest = ManifestFactory.Unit + +- val Any: Manifest[scala.Any] = ManifestFactory.Any +- val Object: Manifest[java.lang.Object] = ManifestFactory.Object +- val AnyRef: Manifest[scala.AnyRef] = ManifestFactory.AnyRef +- val AnyVal: Manifest[scala.AnyVal] = ManifestFactory.AnyVal +- val Null: Manifest[scala.Null] = ManifestFactory.Null +- val Nothing: Manifest[scala.Nothing] = ManifestFactory.Nothing ++ @inline def Any: Manifest[scala.Any] = ManifestFactory.Any ++ @inline def Object: Manifest[java.lang.Object] = ManifestFactory.Object ++ @inline def AnyRef: Manifest[scala.AnyRef] = ManifestFactory.AnyRef ++ @inline def AnyVal: Manifest[scala.AnyVal] = ManifestFactory.AnyVal ++ @inline def Null: Manifest[scala.Null] = ManifestFactory.Null ++ @inline def Nothing: Manifest[scala.Nothing] = ManifestFactory.Nothing + + /** Manifest for the singleton type `value.type`. */ + def singleType[T <: AnyRef](value: AnyRef): Manifest[T] = +@@ -172,7 +172,7 @@ + List(Byte, Short, Char, Int, Long, Float, Double, Boolean, Unit) + + @SerialVersionUID(1L) +- final private[reflect] class ByteManifest extends AnyValManifest[scala.Byte]("Byte") { ++ private[reflect] class ByteManifest extends AnyValManifest[scala.Byte]("Byte") { + def runtimeClass = java.lang.Byte.TYPE + @inline override def newArray(len: Int): Array[Byte] = new Array[Byte](len) + override def newWrappedArray(len: Int): ArraySeq[Byte] = new ArraySeq.ofByte(new Array[Byte](len)) +@@ -185,10 +185,11 @@ + } + private def readResolve(): Any = Manifest.Byte + } +- val Byte: ByteManifest = new ByteManifest ++ private object ByteManifest extends ByteManifest ++ def Byte: ByteManifest = ByteManifest + + @SerialVersionUID(1L) +- final private[reflect] class ShortManifest extends AnyValManifest[scala.Short]("Short") { ++ private[reflect] class ShortManifest extends AnyValManifest[scala.Short]("Short") { + def runtimeClass = java.lang.Short.TYPE + @inline override def newArray(len: Int): Array[Short] = new Array[Short](len) + override def newWrappedArray(len: Int): ArraySeq[Short] = new ArraySeq.ofShort(new Array[Short](len)) +@@ -201,10 +202,11 @@ + } + private def readResolve(): Any = Manifest.Short + } +- val Short: ShortManifest = new ShortManifest ++ private object ShortManifest extends ShortManifest ++ def Short: ShortManifest = ShortManifest + + @SerialVersionUID(1L) +- final private[reflect] class CharManifest extends AnyValManifest[scala.Char]("Char") { ++ private[reflect] class CharManifest extends AnyValManifest[scala.Char]("Char") { + def runtimeClass = java.lang.Character.TYPE + @inline override def newArray(len: Int): Array[Char] = new Array[Char](len) + override def newWrappedArray(len: Int): ArraySeq[Char] = new ArraySeq.ofChar(new Array[Char](len)) +@@ -217,10 +219,11 @@ + } + private def readResolve(): Any = Manifest.Char + } +- val Char: CharManifest = new CharManifest ++ private object CharManifest extends CharManifest ++ def Char: CharManifest = CharManifest + + @SerialVersionUID(1L) +- final private[reflect] class IntManifest extends AnyValManifest[scala.Int]("Int") { ++ private[reflect] class IntManifest extends AnyValManifest[scala.Int]("Int") { + def runtimeClass = java.lang.Integer.TYPE + @inline override def newArray(len: Int): Array[Int] = new Array[Int](len) + override def newWrappedArray(len: Int): ArraySeq[Int] = new ArraySeq.ofInt(new Array[Int](len)) +@@ -233,10 +236,11 @@ + } + private def readResolve(): Any = Manifest.Int + } +- val Int: IntManifest = new IntManifest ++ private object IntManifest extends IntManifest ++ def Int: IntManifest = IntManifest + + @SerialVersionUID(1L) +- final private[reflect] class LongManifest extends AnyValManifest[scala.Long]("Long") { ++ private[reflect] class LongManifest extends AnyValManifest[scala.Long]("Long") { + def runtimeClass = java.lang.Long.TYPE + @inline override def newArray(len: Int): Array[Long] = new Array[Long](len) + override def newWrappedArray(len: Int): ArraySeq[Long] = new ArraySeq.ofLong(new Array[Long](len)) +@@ -249,10 +253,11 @@ + } + private def readResolve(): Any = Manifest.Long + } +- val Long: LongManifest = new LongManifest ++ private object LongManifest extends LongManifest ++ def Long: LongManifest = LongManifest + + @SerialVersionUID(1L) +- final private[reflect] class FloatManifest extends AnyValManifest[scala.Float]("Float") { ++ private[reflect] class FloatManifest extends AnyValManifest[scala.Float]("Float") { + def runtimeClass = java.lang.Float.TYPE + @inline override def newArray(len: Int): Array[Float] = new Array[Float](len) + override def newWrappedArray(len: Int): ArraySeq[Float] = new ArraySeq.ofFloat(new Array[Float](len)) +@@ -265,10 +270,11 @@ + } + private def readResolve(): Any = Manifest.Float + } +- val Float: FloatManifest = new FloatManifest ++ private object FloatManifest extends FloatManifest ++ def Float: FloatManifest = FloatManifest + + @SerialVersionUID(1L) +- final private[reflect] class DoubleManifest extends AnyValManifest[scala.Double]("Double") { ++ private[reflect] class DoubleManifest extends AnyValManifest[scala.Double]("Double") { + def runtimeClass = java.lang.Double.TYPE + @inline override def newArray(len: Int): Array[Double] = new Array[Double](len) + override def newWrappedArray(len: Int): ArraySeq[Double] = new ArraySeq.ofDouble(new Array[Double](len)) +@@ -282,10 +288,11 @@ + } + private def readResolve(): Any = Manifest.Double + } +- val Double: DoubleManifest = new DoubleManifest ++ private object DoubleManifest extends DoubleManifest ++ def Double: DoubleManifest = DoubleManifest + + @SerialVersionUID(1L) +- final private[reflect] class BooleanManifest extends AnyValManifest[scala.Boolean]("Boolean") { ++ private[reflect] class BooleanManifest extends AnyValManifest[scala.Boolean]("Boolean") { + def runtimeClass = java.lang.Boolean.TYPE + @inline override def newArray(len: Int): Array[Boolean] = new Array[Boolean](len) + override def newWrappedArray(len: Int): ArraySeq[Boolean] = new ArraySeq.ofBoolean(new Array[Boolean](len)) +@@ -298,10 +305,11 @@ + } + private def readResolve(): Any = Manifest.Boolean + } +- val Boolean: BooleanManifest = new BooleanManifest ++ private object BooleanManifest extends BooleanManifest ++ def Boolean: BooleanManifest = BooleanManifest + + @SerialVersionUID(1L) +- final private[reflect] class UnitManifest extends AnyValManifest[scala.Unit]("Unit") { ++ private[reflect] class UnitManifest extends AnyValManifest[scala.Unit]("Unit") { + def runtimeClass = java.lang.Void.TYPE + @inline override def newArray(len: Int): Array[Unit] = new Array[Unit](len) + override def newWrappedArray(len: Int): ArraySeq[Unit] = new ArraySeq.ofUnit(new Array[Unit](len)) +@@ -317,57 +325,54 @@ + } + private def readResolve(): Any = Manifest.Unit + } +- val Unit: UnitManifest = new UnitManifest ++ private object UnitManifest extends UnitManifest ++ def Unit: UnitManifest = UnitManifest + +- private[this] val ObjectTYPE = classOf[java.lang.Object] +- private[this] val NothingTYPE = classOf[scala.runtime.Nothing$] +- private[this] val NullTYPE = classOf[scala.runtime.Null$] +- +- @SerialVersionUID(1L) +- final private class AnyManifest extends PhantomManifest[scala.Any](ObjectTYPE, "Any") { ++ private object AnyManifest extends PhantomManifest[scala.Any](classOf[java.lang.Object], "Any") { ++ override def runtimeClass = classOf[java.lang.Object] + override def newArray(len: Int) = new Array[scala.Any](len) + override def <:<(that: ClassManifest[_]): Boolean = (that eq this) + private def readResolve(): Any = Manifest.Any + } +- val Any: Manifest[scala.Any] = new AnyManifest ++ def Any: Manifest[scala.Any] = AnyManifest + +- @SerialVersionUID(1L) +- final private class ObjectManifest extends PhantomManifest[java.lang.Object](ObjectTYPE, "Object") { ++ private object ObjectManifest extends PhantomManifest[java.lang.Object](classOf[java.lang.Object], "Object") { ++ override def runtimeClass = classOf[java.lang.Object] + override def newArray(len: Int) = new Array[java.lang.Object](len) + override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any) + private def readResolve(): Any = Manifest.Object + } +- val Object: Manifest[java.lang.Object] = new ObjectManifest ++ def Object: Manifest[java.lang.Object] = ObjectManifest + +- val AnyRef: Manifest[scala.AnyRef] = Object.asInstanceOf[Manifest[scala.AnyRef]] ++ def AnyRef: Manifest[scala.AnyRef] = Object.asInstanceOf[Manifest[scala.AnyRef]] + +- @SerialVersionUID(1L) +- final private class AnyValPhantomManifest extends PhantomManifest[scala.AnyVal](ObjectTYPE, "AnyVal") { ++ private object AnyValManifest extends PhantomManifest[scala.AnyVal](classOf[java.lang.Object], "AnyVal") { ++ override def runtimeClass = classOf[java.lang.Object] + override def newArray(len: Int) = new Array[scala.AnyVal](len) + override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any) + private def readResolve(): Any = Manifest.AnyVal + } +- val AnyVal: Manifest[scala.AnyVal] = new AnyValPhantomManifest ++ def AnyVal: Manifest[scala.AnyVal] = AnyValManifest + +- @SerialVersionUID(1L) +- final private class NullManifest extends PhantomManifest[scala.Null](NullTYPE, "Null") { ++ private object NullManifest extends PhantomManifest[scala.Null](classOf[scala.runtime.Null$], "Null") { ++ override def runtimeClass = classOf[scala.runtime.Null$] + override def newArray(len: Int) = new Array[scala.Null](len) + override def <:<(that: ClassManifest[_]): Boolean = + (that ne null) && (that ne Nothing) && !(that <:< AnyVal) + private def readResolve(): Any = Manifest.Null + } +- val Null: Manifest[scala.Null] = new NullManifest ++ def Null: Manifest[scala.Null] = NullManifest + +- @SerialVersionUID(1L) +- final private class NothingManifest extends PhantomManifest[scala.Nothing](NothingTYPE, "Nothing") { ++ private object NothingManifest extends PhantomManifest[scala.Nothing](classOf[scala.runtime.Nothing$], "Nothing") { ++ override def runtimeClass = classOf[scala.runtime.Nothing$] + override def newArray(len: Int) = new Array[scala.Nothing](len) + override def <:<(that: ClassManifest[_]): Boolean = (that ne null) + private def readResolve(): Any = Manifest.Nothing + } +- val Nothing: Manifest[scala.Nothing] = new NothingManifest ++ def Nothing: Manifest[scala.Nothing] = NothingManifest + + @SerialVersionUID(1L) +- final private class SingletonTypeManifest[T <: AnyRef](value: AnyRef) extends Manifest[T] { ++ private class SingletonTypeManifest[T <: AnyRef](value: AnyRef) extends Manifest[T] { + lazy val runtimeClass = value.getClass + override lazy val toString = value.toString + ".type" + } +@@ -409,8 +414,9 @@ + * a top-level or static class. */ + @SerialVersionUID(1L) + private class ClassTypeManifest[T](prefix: Option[Manifest[_]], +- val runtimeClass: Predef.Class[_], ++ runtimeClass1: Predef.Class[_], + override val typeArguments: List[Manifest[_]]) extends Manifest[T] { ++ def runtimeClass: Predef.Class[_] = runtimeClass1 + override def toString = + (if (prefix.isEmpty) "" else prefix.get.toString+"#") + + (if (runtimeClass.isArray) "Array" else runtimeClass.getName) + diff --git a/scalalib/overrides-2.13/scala/reflect/ClassTag.scala.patch b/scalalib/overrides-2.13/scala/reflect/ClassTag.scala.patch index 863e1d5004..dea88435ee 100644 --- a/scalalib/overrides-2.13/scala/reflect/ClassTag.scala.patch +++ b/scalalib/overrides-2.13/scala/reflect/ClassTag.scala.patch @@ -1,6 +1,6 @@ ---- 2.13.7/scala/reflect/ClassTag.scala +--- 2.13.12/scala/reflect/ClassTag.scala +++ overrides-2.13/scala/reflect/ClassTag.scala -@@ -93,56 +93,24 @@ +@@ -93,10 +93,6 @@ * Class tags corresponding to primitive types and constructor/extractor for ClassTags. */ object ClassTag { @@ -10,36 +10,10 @@ - import ManifestFactory._ -- val Byte : ByteManifest = Manifest.Byte -- val Short : ShortManifest = Manifest.Short -- val Char : CharManifest = Manifest.Char -- val Int : IntManifest = Manifest.Int -- val Long : LongManifest = Manifest.Long -- val Float : FloatManifest = Manifest.Float -- val Double : DoubleManifest = Manifest.Double -- val Boolean : BooleanManifest = Manifest.Boolean -- val Unit : UnitManifest = Manifest.Unit -- val Any : ClassTag[scala.Any] = Manifest.Any -- val Object : ClassTag[java.lang.Object] = Manifest.Object -- val AnyVal : ClassTag[scala.AnyVal] = Manifest.AnyVal -- val AnyRef : ClassTag[scala.AnyRef] = Manifest.AnyRef -- val Nothing : ClassTag[scala.Nothing] = Manifest.Nothing -- val Null : ClassTag[scala.Null] = Manifest.Null -+ @inline def Byte : ByteManifest = Manifest.Byte -+ @inline def Short : ShortManifest = Manifest.Short -+ @inline def Char : CharManifest = Manifest.Char -+ @inline def Int : IntManifest = Manifest.Int -+ @inline def Long : LongManifest = Manifest.Long -+ @inline def Float : FloatManifest = Manifest.Float -+ @inline def Double : DoubleManifest = Manifest.Double -+ @inline def Boolean : BooleanManifest = Manifest.Boolean -+ @inline def Unit : UnitManifest = Manifest.Unit -+ @inline def Any : ClassTag[scala.Any] = Manifest.Any -+ @inline def Object : ClassTag[java.lang.Object] = Manifest.Object -+ @inline def AnyVal : ClassTag[scala.AnyVal] = Manifest.AnyVal -+ @inline def AnyRef : ClassTag[scala.AnyRef] = Manifest.AnyRef -+ @inline def Nothing : ClassTag[scala.Nothing] = Manifest.Nothing -+ @inline def Null : ClassTag[scala.Null] = Manifest.Null + val Byte : ByteManifest = Manifest.Byte +@@ -115,34 +111,6 @@ + val Nothing : ClassTag[scala.Nothing] = Manifest.Nothing + val Null : ClassTag[scala.Null] = Manifest.Null - private val cacheDisabled = java.lang.Boolean.getBoolean("scala.reflect.classtag.cache.disable") - private[this] object cache extends ClassValueCompat[jWeakReference[ClassTag[_]]] { diff --git a/scalalib/overrides-2.13/scala/reflect/Manifest.scala.patch b/scalalib/overrides-2.13/scala/reflect/Manifest.scala.patch index 47aceec51c..b6f63c0abc 100644 --- a/scalalib/overrides-2.13/scala/reflect/Manifest.scala.patch +++ b/scalalib/overrides-2.13/scala/reflect/Manifest.scala.patch @@ -1,4 +1,4 @@ ---- 2.13.6/scala/reflect/Manifest.scala +--- 2.13.12/scala/reflect/Manifest.scala +++ overrides-2.13/scala/reflect/Manifest.scala @@ -82,22 +82,22 @@ def valueManifests: List[AnyValManifest[_]] = @@ -44,7 +44,7 @@ @SerialVersionUID(1L) - final private[reflect] class ByteManifest extends AnyValManifest[scala.Byte]("Byte") { + private[reflect] class ByteManifest extends AnyValManifest[scala.Byte]("Byte") { - def runtimeClass = java.lang.Byte.TYPE + def runtimeClass: Class[java.lang.Byte] = java.lang.Byte.TYPE @inline override def newArray(len: Int): Array[Byte] = new Array[Byte](len) override def newWrappedArray(len: Int): ArraySeq[Byte] = new ArraySeq.ofByte(new Array[Byte](len)) @@ -185,10 +185,11 @@ @@ -58,7 +58,7 @@ @SerialVersionUID(1L) - final private[reflect] class ShortManifest extends AnyValManifest[scala.Short]("Short") { + private[reflect] class ShortManifest extends AnyValManifest[scala.Short]("Short") { - def runtimeClass = java.lang.Short.TYPE + def runtimeClass: Class[java.lang.Short] = java.lang.Short.TYPE @inline override def newArray(len: Int): Array[Short] = new Array[Short](len) override def newWrappedArray(len: Int): ArraySeq[Short] = new ArraySeq.ofShort(new Array[Short](len)) @@ -201,10 +202,11 @@ @@ -72,7 +72,7 @@ @SerialVersionUID(1L) - final private[reflect] class CharManifest extends AnyValManifest[scala.Char]("Char") { + private[reflect] class CharManifest extends AnyValManifest[scala.Char]("Char") { - def runtimeClass = java.lang.Character.TYPE + def runtimeClass: Class[java.lang.Character] = java.lang.Character.TYPE @inline override def newArray(len: Int): Array[Char] = new Array[Char](len) override def newWrappedArray(len: Int): ArraySeq[Char] = new ArraySeq.ofChar(new Array[Char](len)) @@ -217,10 +219,11 @@ @@ -86,10 +86,10 @@ @SerialVersionUID(1L) - final private[reflect] class IntManifest extends AnyValManifest[scala.Int]("Int") { + private[reflect] class IntManifest extends AnyValManifest[scala.Int]("Int") { - def runtimeClass = java.lang.Integer.TYPE + def runtimeClass: Class[java.lang.Integer] = java.lang.Integer.TYPE @inline override def newArray(len: Int): Array[Int] = new Array[Int](len) override def newWrappedArray(len: Int): ArraySeq[Int] = new ArraySeq.ofInt(new Array[Int](len)) -@@ -233,10 +236,11 @@ +@@ -233,11 +236,12 @@ } private def readResolve(): Any = Manifest.Int } @@ -99,10 +99,12 @@ @SerialVersionUID(1L) - final private[reflect] class LongManifest extends AnyValManifest[scala.Long]("Long") { +- def runtimeClass: Class[java.lang.Long] = java.lang.Long.TYPE + private[reflect] class LongManifest extends AnyValManifest[scala.Long]("Long") { - def runtimeClass = java.lang.Long.TYPE ++ def runtimeClass = java.lang.Long.TYPE @inline override def newArray(len: Int): Array[Long] = new Array[Long](len) override def newWrappedArray(len: Int): ArraySeq[Long] = new ArraySeq.ofLong(new Array[Long](len)) + override def newArrayBuilder(): ArrayBuilder[Long] = new ArrayBuilder.ofLong() @@ -249,10 +253,11 @@ } private def readResolve(): Any = Manifest.Long @@ -114,7 +116,7 @@ @SerialVersionUID(1L) - final private[reflect] class FloatManifest extends AnyValManifest[scala.Float]("Float") { + private[reflect] class FloatManifest extends AnyValManifest[scala.Float]("Float") { - def runtimeClass = java.lang.Float.TYPE + def runtimeClass: Class[java.lang.Float] = java.lang.Float.TYPE @inline override def newArray(len: Int): Array[Float] = new Array[Float](len) override def newWrappedArray(len: Int): ArraySeq[Float] = new ArraySeq.ofFloat(new Array[Float](len)) @@ -265,10 +270,11 @@ @@ -128,7 +130,7 @@ @SerialVersionUID(1L) - final private[reflect] class DoubleManifest extends AnyValManifest[scala.Double]("Double") { + private[reflect] class DoubleManifest extends AnyValManifest[scala.Double]("Double") { - def runtimeClass = java.lang.Double.TYPE + def runtimeClass: Class[java.lang.Double] = java.lang.Double.TYPE @inline override def newArray(len: Int): Array[Double] = new Array[Double](len) override def newWrappedArray(len: Int): ArraySeq[Double] = new ArraySeq.ofDouble(new Array[Double](len)) @@ -282,10 +288,11 @@ @@ -142,7 +144,7 @@ @SerialVersionUID(1L) - final private[reflect] class BooleanManifest extends AnyValManifest[scala.Boolean]("Boolean") { + private[reflect] class BooleanManifest extends AnyValManifest[scala.Boolean]("Boolean") { - def runtimeClass = java.lang.Boolean.TYPE + def runtimeClass: Class[java.lang.Boolean] = java.lang.Boolean.TYPE @inline override def newArray(len: Int): Array[Boolean] = new Array[Boolean](len) override def newWrappedArray(len: Int): ArraySeq[Boolean] = new ArraySeq.ofBoolean(new Array[Boolean](len)) @@ -298,10 +305,11 @@ @@ -156,7 +158,7 @@ @SerialVersionUID(1L) - final private[reflect] class UnitManifest extends AnyValManifest[scala.Unit]("Unit") { + private[reflect] class UnitManifest extends AnyValManifest[scala.Unit]("Unit") { - def runtimeClass = java.lang.Void.TYPE + def runtimeClass: Class[java.lang.Void] = java.lang.Void.TYPE @inline override def newArray(len: Int): Array[Unit] = new Array[Unit](len) override def newWrappedArray(len: Int): ArraySeq[Unit] = new ArraySeq.ofUnit(new Array[Unit](len)) @@ -317,57 +325,54 @@ @@ -174,7 +176,7 @@ - @SerialVersionUID(1L) - final private class AnyManifest extends PhantomManifest[scala.Any](ObjectTYPE, "Any") { + private object AnyManifest extends PhantomManifest[scala.Any](classOf[java.lang.Object], "Any") { -+ override def runtimeClass = classOf[java.lang.Object] ++ override def runtimeClass = classOf[java.lang.Object] override def newArray(len: Int) = new Array[scala.Any](len) override def <:<(that: ClassManifest[_]): Boolean = (that eq this) private def readResolve(): Any = Manifest.Any @@ -185,7 +187,7 @@ - @SerialVersionUID(1L) - final private class ObjectManifest extends PhantomManifest[java.lang.Object](ObjectTYPE, "Object") { + private object ObjectManifest extends PhantomManifest[java.lang.Object](classOf[java.lang.Object], "Object") { -+ override def runtimeClass = classOf[java.lang.Object] ++ override def runtimeClass = classOf[java.lang.Object] override def newArray(len: Int) = new Array[java.lang.Object](len) override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any) private def readResolve(): Any = Manifest.Object @@ -199,7 +201,7 @@ - @SerialVersionUID(1L) - final private class AnyValPhantomManifest extends PhantomManifest[scala.AnyVal](ObjectTYPE, "AnyVal") { + private object AnyValManifest extends PhantomManifest[scala.AnyVal](classOf[java.lang.Object], "AnyVal") { -+ override def runtimeClass = classOf[java.lang.Object] ++ override def runtimeClass = classOf[java.lang.Object] override def newArray(len: Int) = new Array[scala.AnyVal](len) override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Any) private def readResolve(): Any = Manifest.AnyVal @@ -210,7 +212,7 @@ - @SerialVersionUID(1L) - final private class NullManifest extends PhantomManifest[scala.Null](NullTYPE, "Null") { + private object NullManifest extends PhantomManifest[scala.Null](classOf[scala.runtime.Null$], "Null") { -+ override def runtimeClass = classOf[scala.runtime.Null$] ++ override def runtimeClass = classOf[scala.runtime.Null$] override def newArray(len: Int) = new Array[scala.Null](len) override def <:<(that: ClassManifest[_]): Boolean = (that ne null) && (that ne Nothing) && !(that <:< AnyVal) @@ -222,7 +224,7 @@ - @SerialVersionUID(1L) - final private class NothingManifest extends PhantomManifest[scala.Nothing](NothingTYPE, "Nothing") { + private object NothingManifest extends PhantomManifest[scala.Nothing](classOf[scala.runtime.Nothing$], "Nothing") { -+ override def runtimeClass = classOf[scala.runtime.Nothing$] ++ override def runtimeClass = classOf[scala.runtime.Nothing$] override def newArray(len: Int) = new Array[scala.Nothing](len) override def <:<(that: ClassManifest[_]): Boolean = (that ne null) private def readResolve(): Any = Manifest.Nothing @@ -233,7 +235,7 @@ @SerialVersionUID(1L) - final private class SingletonTypeManifest[T <: AnyRef](value: AnyRef) extends Manifest[T] { + private class SingletonTypeManifest[T <: AnyRef](value: AnyRef) extends Manifest[T] { - lazy val runtimeClass = value.getClass + lazy val runtimeClass: Class[_ <: AnyRef] = value.getClass override lazy val toString = value.toString + ".type" } @@ -409,8 +414,9 @@ From e7eb8cc93f22eefccb892694fbfba9016abd5443 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Thu, 7 Sep 2023 01:37:06 +0200 Subject: [PATCH 07/51] Add partest configs (cherry picked from commit 25a122b2c1e8da1835b298f8b0aecaca79d95a32) --- .../BlacklistedTests-require-threads.txt | 2 + .../resources/2.13.12/BlacklistedTests.txt | 248 ++++ .../scalanative/2.13.12/BlacklistedTests.txt | 1078 +++++++++++++++++ .../scalanative/2.13.12/neg/t11952b.check | 16 + .../2.13.12/neg/t6446-additional.check | 29 + .../scalanative/2.13.12/neg/t6446-list.check | 2 + .../2.13.12/neg/t6446-missing.check | 29 + .../2.13.12/neg/t6446-show-phases.check | 28 + .../2.13.12/neg/t7494-no-options.check | 30 + .../scalanative/2.13.12/run/classof.check | 22 + .../2.13.12/run/classtags_contextbound.check | 1 + .../2.13.12/run/classtags_multi.check | 5 + .../2.13.12/run/getClassTest-valueClass.check | 2 + ...interop_classtags_are_classmanifests.check | 3 + .../scalanative/2.13.12/run/t4753.check | 1 + .../scalanative/2.13.12/run/t5568.check | 9 + .../scalanative/2.13.12/run/t5923b.check | 3 + .../2.13.12/run/t6318_primitives.check | 54 + 18 files changed, 1562 insertions(+) create mode 100644 scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests-require-threads.txt create mode 100644 scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt create mode 100644 scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/BlacklistedTests.txt create mode 100644 scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t11952b.check create mode 100644 scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t6446-additional.check create mode 100644 scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t6446-list.check create mode 100644 scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t6446-missing.check create mode 100644 scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t6446-show-phases.check create mode 100644 scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t7494-no-options.check create mode 100644 scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/classof.check create mode 100644 scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/classtags_contextbound.check create mode 100644 scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/classtags_multi.check create mode 100644 scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/getClassTest-valueClass.check create mode 100644 scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/interop_classtags_are_classmanifests.check create mode 100644 scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/t4753.check create mode 100644 scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/t5568.check create mode 100644 scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/t5923b.check create mode 100644 scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/t6318_primitives.check diff --git a/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests-require-threads.txt b/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests-require-threads.txt new file mode 100644 index 0000000000..bf57d81f24 --- /dev/null +++ b/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests-require-threads.txt @@ -0,0 +1,2 @@ +scala/collection/convert/MapWrapperTest.scala +scala/collection/concurrent/TrieMapTest.scala \ No newline at end of file diff --git a/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt b/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt new file mode 100644 index 0000000000..ab4f2ad1ee --- /dev/null +++ b/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt @@ -0,0 +1,248 @@ +## Do not compile +scala/ExtractorTest.scala +scala/OptionTest.scala +scala/SerializationStabilityTest.scala +scala/StringTest.scala +scala/collection/FactoriesTest.scala +scala/collection/LazyZipOpsTest.scala +scala/collection/SeqTest.scala +scala/collection/immutable/HashMapTest.scala +scala/collection/immutable/HashSetTest.scala +scala/collection/immutable/IndexedSeqTest.scala +scala/collection/immutable/IntMapTest.scala +scala/collection/immutable/ListMapTest.scala +scala/collection/immutable/LongMapTest.scala +scala/collection/immutable/MapHashcodeTest.scala +scala/collection/immutable/SeqTest.scala +scala/collection/immutable/SmallMapTest.scala +scala/collection/immutable/SortedMapTest.scala +scala/collection/immutable/SortedSetTest.scala +scala/collection/immutable/TreeMapTest.scala +scala/collection/immutable/TreeSetTest.scala +scala/collection/mutable/ArrayBufferTest.scala +scala/lang/annotations/BytecodeTest.scala +scala/lang/annotations/RunTest.scala +scala/lang/traits/BytecodeTest.scala +scala/lang/traits/RunTest.scala +scala/lang/primitives/NaNTest.scala +scala/math/PartialOrderingTest.scala +scala/reflect/ClassOfTest.scala +scala/reflect/FieldAccessTest.scala +scala/reflect/QTest.scala +scala/reflect/io/ZipArchiveTest.scala +scala/reflect/internal/InferTest.scala +scala/reflect/internal/LongNamesTest.scala +scala/reflect/internal/MirrorsTest.scala +scala/reflect/internal/NamesTest.scala +scala/reflect/internal/PositionsTest.scala +scala/reflect/internal/PrintersTest.scala +scala/reflect/internal/ScopeTest.scala +scala/reflect/internal/TreeGenTest.scala +scala/reflect/internal/TypesTest.scala +scala/reflect/internal/util/AbstractFileClassLoaderTest.scala +scala/reflect/internal/util/FileUtilsTest.scala +scala/reflect/internal/util/SourceFileTest.scala +scala/reflect/internal/util/StringOpsTest.scala +scala/reflect/internal/SubstMapTest.scala +scala/reflect/internal/util/WeakHashSetTest.scala +scala/reflect/io/AbstractFileTest.scala +scala/reflect/runtime/ThreadSafetyTest.scala +scala/reflect/runtime/ReflectionUtilsShowTest.scala +scala/tools/nsc/Build.scala +scala/tools/nsc/DeterminismTest.scala +scala/tools/nsc/DeterminismTester.scala +scala/tools/nsc/FileUtils.scala +scala/tools/nsc/GlobalCustomizeClassloaderTest.scala +scala/tools/nsc/PhaseAssemblyTest.scala +scala/tools/nsc/PickleWriteTest.scala +scala/tools/nsc/PipelineMainTest.scala +scala/tools/nsc/ScriptRunnerTest.scala +scala/tools/nsc/MainRunnerTest.scala +scala/tools/nsc/async/AnnotationDrivenAsyncTest.scala +scala/tools/nsc/async/CustomFuture.scala +scala/tools/nsc/backend/jvm/BTypesTest.scala +scala/tools/nsc/backend/jvm/BytecodeTest.scala +scala/tools/nsc/backend/jvm/DefaultMethodTest.scala +scala/tools/nsc/backend/jvm/DirectCompileTest.scala +scala/tools/nsc/backend/jvm/GenericSignaturesTest.scala +scala/tools/nsc/backend/jvm/IndyLambdaTest.scala +scala/tools/nsc/backend/jvm/IndySammyTest.scala +scala/tools/nsc/backend/jvm/InnerClassAttributeTest.scala +scala/tools/nsc/backend/jvm/LineNumberTest.scala +scala/tools/nsc/backend/jvm/NestedClassesCollectorTest.scala +scala/tools/nsc/backend/jvm/OptimizedBytecodeTest.scala +scala/tools/nsc/backend/jvm/PerRunInitTest.scala +scala/tools/nsc/backend/jvm/StringConcatTest.scala +scala/tools/nsc/backend/jvm/analysis/NullnessAnalyzerTest.scala +scala/tools/nsc/backend/jvm/analysis/ProdConsAnalyzerTest.scala +scala/tools/nsc/backend/jvm/analysis/TypeFlowAnalyzerTest.scala +scala/tools/nsc/backend/jvm/opt/AnalyzerTest.scala +scala/tools/nsc/backend/jvm/opt/BTypesFromClassfileTest.scala +scala/tools/nsc/backend/jvm/opt/BoxUnboxTest.scala +scala/tools/nsc/backend/jvm/opt/BoxUnboxAndInlineTest.scala +scala/tools/nsc/backend/jvm/opt/CallGraphTest.scala +scala/tools/nsc/backend/jvm/opt/ClosureOptimizerTest.scala +scala/tools/nsc/backend/jvm/opt/CompactLocalVariablesTest.scala +scala/tools/nsc/backend/jvm/opt/EmptyExceptionHandlersTest.scala +scala/tools/nsc/backend/jvm/opt/EmptyLabelsAndLineNumbersTest.scala +scala/tools/nsc/backend/jvm/opt/InlineInfoTest.scala +scala/tools/nsc/backend/jvm/opt/InlinerIllegalAccessTest.scala +scala/tools/nsc/backend/jvm/opt/InlinerSeparateCompilationTest.scala +scala/tools/nsc/backend/jvm/opt/InlinerTest.scala +scala/tools/nsc/backend/jvm/opt/InlineSourceMatcherTest.scala +scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala +scala/tools/nsc/backend/jvm/opt/MethodLevelOptsTest.scala +scala/tools/nsc/backend/jvm/opt/ScalaInlineInfoTest.scala +scala/tools/nsc/backend/jvm/opt/SimplifyJumpsTest.scala +scala/tools/nsc/backend/jvm/opt/UnreachableCodeTest.scala +scala/tools/nsc/backend/jvm/opt/UnusedLocalVariablesTest.scala +scala/tools/nsc/classpath/AggregateClassPathTest.scala +scala/tools/nsc/classpath/JrtClassPathTest.scala +scala/tools/nsc/classpath/MultiReleaseJarTest.scala +scala/tools/nsc/classpath/PathResolverBaseTest.scala +scala/tools/nsc/classpath/VirtualDirectoryClassPathTest.scala +scala/tools/nsc/classpath/ZipAndJarFileLookupFactoryTest.scala +scala/tools/nsc/doc/html/HtmlDocletTest.scala +scala/tools/nsc/doc/html/StringLiteralTest.scala +scala/tools/nsc/interpreter/CompletionTest.scala +scala/tools/nsc/interpreter/ScriptedTest.scala +scala/tools/nsc/interpreter/TabulatorTest.scala +scala/tools/nsc/parser/ParserTest.scala +scala/tools/nsc/reporters/ConsoleReporterTest.scala +scala/tools/nsc/reporters/PositionFilterTest.scala +scala/tools/nsc/reporters/WConfTest.scala +scala/tools/nsc/settings/ScalaVersionTest.scala +scala/tools/nsc/settings/SettingsTest.scala +scala/tools/nsc/settings/TargetTest.scala +scala/tools/nsc/symtab/CannotHaveAttrsTest.scala +scala/tools/nsc/symtab/FlagsTest.scala +scala/tools/nsc/symtab/FreshNameExtractorTest.scala +scala/tools/nsc/symtab/StdNamesTest.scala +scala/tools/nsc/symtab/SymbolTableForUnitTesting.scala +scala/tools/nsc/symtab/SymbolTableTest.scala +scala/tools/nsc/symtab/classfile/PicklerTest.scala +scala/tools/nsc/transform/ErasureTest.scala +scala/tools/nsc/transform/MixinTest.scala +scala/tools/nsc/transform/ReleaseFenceTest.scala +scala/tools/nsc/transform/SpecializationTest.scala +scala/tools/nsc/transform/ThicketTransformerTest.scala +scala/tools/nsc/transform/UncurryTest.scala +scala/tools/nsc/transform/delambdafy/DelambdafyTest.scala +scala/tools/nsc/transform/patmat/SolvingTest.scala +scala/tools/nsc/transform/patmat/PatmatBytecodeTest.scala +scala/tools/nsc/typechecker/ConstantFolderTest.scala +scala/tools/nsc/typechecker/ImplicitsTest.scala +scala/tools/nsc/typechecker/InferencerTest.scala +scala/tools/nsc/typechecker/NamerTest.scala +scala/tools/nsc/typechecker/OverridingPairsTest.scala +scala/tools/nsc/typechecker/ParamAliasTest.scala +scala/tools/nsc/typechecker/TypedTreeTest.scala +scala/tools/nsc/typechecker/TreeAttachmentTest.scala +scala/tools/nsc/util/StackTraceTest.scala +scala/tools/nsc/QuickfixTest.scala +scala/tools/nsc/reporters/AbstractCodeActionTest.scala +scala/tools/nsc/reporters/CodeActionTest.scala +scala/tools/nsc/reporters/CodeActionXsource3Test.scala +scala/tools/xsbt/BridgeTesting.scala +scala/tools/xsbt/BasicBridgeTest.scala +scala/tools/xsbt/CodeActionTest.scala +scala/tools/xsbt/DependencyTest.scala +scala/tools/xsbt/ExtractUsedNamesTest.scala +scala/tools/xsbt/InteractiveConsoleInterfaceTest.scala +scala/tools/xsbt/TestCallback.scala +scala/tools/xsbt/ClassNameTest.scala +scala/tools/xsbt/ExtractAPITest.scala +scala/tools/xsbt/SameAPI.scala +scala/util/ChainingOpsTest.scala +scala/sys/process/ProcessTest.scala +scala/collection/mutable/OpenHashMapTest.scala +scala/collection/immutable/ListTest.scala +scala/collection/immutable/LazyListTest.scala +scala/collection/Sizes.scala +scala/runtime/BooleanBoxingTest.scala +scala/runtime/ByteBoxingTest.scala +scala/runtime/CharBoxingTest.scala +scala/runtime/ShortBoxingTest.scala +scala/runtime/IntBoxingTest.scala +scala/runtime/LongBoxingTest.scala +scala/runtime/FloatBoxingTest.scala +scala/runtime/DoubleBoxingTest.scala + +## Do not link +scala/jdk/DurationConvertersTest.scala +scala/jdk/OptionConvertersTest.scala +scala/jdk/StreamConvertersTest.scala +scala/jdk/StreamConvertersTypingTest.scala + +# Uses stubs +scala/collection/mutable/AnyRefMapTest.scala +scala/collection/mutable/ListBufferTest.scala +scala/collection/immutable/ChampMapSmokeTest.scala +scala/collection/immutable/ChampSetSmokeTest.scala +scala/sys/process/ProcessBuilderTest.scala + +#j.l.reflect.Modifier / testkit.AssertUtil +scala/reflect/macros/AttachmentsTest.scala +scala/collection/IteratorTest.scala +scala/collection/immutable/StringLikeTest.scala +scala/concurrent/FutureTest.scala +scala/util/SpecVersionTest.scala +scala/tools/testkit/AssertUtilTest.scala +scala/tools/testkit/ReflectUtilTest.scala + +#j.u.stream.* +scala/jdk/StepperConversionTest.scala +scala/jdk/StepperTest.scala + +#j.i.Object{Input,Output}Stream +scala/PartialFunctionSerializationTest.scala +scala/MatchErrorSerializationTest.scala +scala/collection/convert/WrapperSerializationTest.scala +scala/collection/mutable/PriorityQueueTest.scala +scala/collection/mutable/SerializationTest.scala +scala/collection/immutable/SerializationTest.scala +scala/collection/immutable/LazyListLazinessTest.scala +scala/concurrent/duration/SerializationTest.scala +scala/jdk/FunctionConvertersTest.scala + +#j.io.Piped{Input,Output}Stream / j.u.c.LinkedBlockingQueue +scala/sys/process/PipedProcessTest.scala + +#j.u.c.ConcurrentHashMap +scala/collection/convert/NullSafetyToScalaTest.scala +scala/collection/convert/NullSafetyToJavaTest.scala +scala/collection/convert/CollectionConvertersTest.scala +scala/collection/convert/JConcurrentMapWrapperTest.scala + +#j.t.LocalDate +scala/math/OrderingTest.scala + +#j.l.Class.getDeclaredField +scala/collection/immutable/VectorTest.scala + +#j.l.Thread contextClassloader +scala/io/SourceTest.scala +scala/lang/stringinterpol/StringContextTest.scala + +# Needs newer JUnit version +scala/util/matching/RegexTest.scala +scala/collection/immutable/RangeTest.scala +scala/collection/mutable/BitSetTest.scala + +## Tests fail +scala/ArrayTest.scala +scala/collection/ArrayOpsTest.scala +scala/collection/StringParsersTest.scala +scala/collection/StringOpsTest.scala +scala/collection/convert/JSetWrapperTest.scala +scala/collection/immutable/ArraySeqTest.scala +scala/collection/immutable/LazyListGCTest.scala +scala/collection/immutable/StreamTest.scala +scala/collection/immutable/VectorTest.scala +scala/math/EquivTest.scala +scala/sys/process/ParserTest.scala +scala/util/TryTest.scala +# https://github.com/scala-native/scala-native/issues/2897 +scala/math/BigIntTest.scala +### deadlocks maybe needs j.u.c.ConcurrentLinkedQueue +scala/concurrent/impl/DefaultPromiseTest.scala \ No newline at end of file diff --git a/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/BlacklistedTests.txt b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/BlacklistedTests.txt new file mode 100644 index 0000000000..6b3ca95f30 --- /dev/null +++ b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/BlacklistedTests.txt @@ -0,0 +1,1078 @@ +# Ported from Scala.js, might not be exhaustive enough (some blacklisted tests may actually work in SN) + +# +# POS +# + +# Spuriously fails too often, and causes other subsequent tests to fail too +# Note that this test, by design, stress-tests type checking +pos/t6367.scala + +# +# NEG +# + +# Does not create tasty.jar +neg/t12134 + +# +# RUN +# + +# Uses .java files +run/t12195 +run/t9200 +run/t8348 +run/noInlineUnknownIndy +run/specialize-functional-interface + +# Relies on the exact toString() representation of Floats/Doubles +run/t2378.scala + +# Using parts of the javalib we don't plan to support + +run/t5018.scala +run/t2417.scala +run/lazy-concurrent.scala +run/t3667.scala +run/t3038d.scala +run/shutdownhooks.scala +run/t5590.scala +run/t3895b.scala +run/t5974.scala +run/t5262.scala +run/serialize-stream.scala +run/lambda-serialization-gc.scala +run/t9390.scala +run/t9390b.scala +run/t9390c.scala +run/trait-defaults-super.scala +run/t2849.scala +run/t10488.scala +run/various-flat-classpath-types.scala + +# Uses j.l.Class stubs +run/t9437a.scala +run/t12002.scala +run/BoxUnboxTest.scala +run/module-serialization-proxy-class-unload.scala + +# Uses java.math.BigDecimal / BigInteger : but failures not due to them +run/is-valid-num.scala + +# Documented semantic difference on String.split(x: Array[Char]) +run/t0325.scala + +# Using Threads +run/inner-obj-auto.scala +run/predef-cycle.scala +run/synchronized.scala +run/sd409.scala + +# Uses java.security +run/t2318.scala + +# Tries to catch java.lang.StackOverflowError +run/t6154.scala + +# Taking too much time >60sec +run/t10594.scala +run/t3989.scala + +# Using IO + +run/t6488.scala +run/t6988.scala + +# Object{Output|Input}Streams +run/defaults-serizaliable-no-forwarders.scala +run/defaults-serizaliable-with-forwarders.scala +run/t6935.scala +run/t8188.scala +run/t9375.scala +run/t9365.scala +run/inlineAddDeserializeLambda.scala +run/sammy_seriazable.scala +run/lambda-serialization-security.scala +run/t10232.scala +run/t10233.scala +run/t10244.scala +run/t10522.scala +run/t11255 +run/transient-object.scala + +# Using System.getProperties + +run/t4426.scala + +# Using Await + +run/t7336.scala +run/t7775.scala +run/t10513.scala +run/future-flatmap-exec-count.scala + +# Using detailed stack trace + +run/t6308.scala + +# Using reflection + +run/reflection-package-name-conflict +run/sip23-toolbox-eval.scala +run/t6063 +run/t9644.scala +run/t12038a +run/t12038b + +run/mixin-bridge-methods.scala +run/t5125.scala +run/outertest.scala +run/t6223.scala +run/t5652b +run/elidable-opt.scala +run/nullable-lazyvals.scala +run/t4794.scala +run/t5652 +run/t5652c +run/getClassTest-old.scala +run/t8960.scala +run/t7965.scala +run/t8087.scala +run/t8931.scala +run/t8445.scala +run/lambda-serialization.scala + +run/reflection-repl-classes.scala +run/t5256e.scala +run/typetags_core.scala +run/reflection-constructormirror-toplevel-badpath.scala +run/t5276_1b.scala +run/reflection-sorted-decls.scala +run/toolbox_typecheck_implicitsdisabled.scala +run/t5418b.scala +run/toolbox_typecheck_macrosdisabled2.scala +run/abstypetags_serialize.scala +run/all-overridden.scala +run/showraw_tree_kinds.scala +run/showraw_tree_types_ids.scala +run/showraw_tree_types_typed.scala +run/showraw_tree_ids.scala +run/showraw_tree_ultimate.scala +run/t5266_2.scala +run/t5274_1.scala +run/t5224.scala +run/reflection-sanitychecks.scala +run/t6086-vanilla.scala +run/t5277_2.scala +run/reflection-methodsymbol-params.scala +run/reflection-valueclasses-standard.scala +run/t5274_2.scala +run/t5423.scala +run/reflection-modulemirror-toplevel-good.scala +run/t5419.scala +run/t5271_3.scala +run/reflection-enclosed-nested-basic.scala +run/reflection-enclosed-nested-nested-basic.scala +run/fail-non-value-types.scala +run/exprs_serialize.scala +run/t5258a.scala +run/typetags_without_scala_reflect_manifest_lookup.scala +run/t4110-new.scala +run/t5273_2b_newpatmat.scala +run/t6277.scala +run/t5335.scala +run/toolbox_typecheck_macrosdisabled.scala +run/reflection-modulemirror-inner-good.scala +run/t5229_2.scala +run/typetags_multi.scala +run/typetags_without_scala_reflect_typetag_manifest_interop.scala +run/reflection-constructormirror-toplevel-good.scala +run/reflection-magicsymbols-invoke.scala +run/t6392b.scala +run/t5229_1.scala +run/reflection-magicsymbols-vanilla.scala +run/t5225_2.scala +run/runtimeEval1.scala +run/reflection-enclosed-nested-inner-basic.scala +run/reflection-fieldmirror-ctorparam.scala +run/t6181.scala +run/reflection-magicsymbols-repl.scala +run/t5272_2_newpatmat.scala +run/t5270.scala +run/t5418a.scala +run/t5276_2b.scala +run/t5256f.scala +run/reflection-enclosed-basic.scala +run/reflection-constructormirror-inner-badpath.scala +run/interop_typetags_are_manifests.scala +run/newTags.scala +run/t5273_1_newpatmat.scala +run/reflection-constructormirror-nested-good.scala +run/t2236-new.scala +run/existentials3-new.scala +run/t6323b.scala +run/t5943a1.scala +run/reflection-fieldmirror-getsetval.scala +run/t5272_1_oldpatmat.scala +run/t5256h.scala +run/t1195-new.scala +run/t5840.scala +run/reflection-methodsymbol-returntype.scala +run/reflection-fieldmirror-accessorsareokay.scala +run/reflection-sorted-members.scala +run/reflection-allmirrors-tostring.scala +run/valueclasses-typetag-existential.scala +run/toolbox_console_reporter.scala +run/reflection-enclosed-inner-inner-basic.scala +run/t5256b.scala +run/bytecodecs.scala +run/elidable.scala +run/freetypes_false_alarm1.scala +run/freetypes_false_alarm2.scala +run/getClassTest-new.scala +run/idempotency-extractors.scala +run/idempotency-case-classes.scala +run/idempotency-this.scala +run/idempotency-labels.scala +run/idempotency-lazy-vals.scala +run/interop_manifests_are_abstypetags.scala +run/interop_manifests_are_typetags.scala +run/abstypetags_core.scala +run/macro-reify-abstypetag-notypeparams +run/macro-reify-abstypetag-typeparams-tags +run/macro-reify-abstypetag-typeparams-notags +run/macro-reify-abstypetag-usetypetag +run/macro-reify-freevars +run/macro-reify-splice-outside-reify +run/macro-reify-tagless-a +run/macro-reify-type +run/macro-reify-typetag-typeparams-tags +run/macro-reify-typetag-notypeparams +run/macro-undetparams-implicitval +run/manifests-new.scala +run/manifests-old.scala +run/no-pickle-skolems +run/position-val-def.scala +run/reflect-priv-ctor.scala +run/primitive-sigs-2-new.scala +run/primitive-sigs-2-old.scala +run/reflection-enclosed-inner-basic.scala +run/reflection-enclosed-inner-nested-basic.scala +run/reflection-constructormirror-inner-good.scala +run/reflection-constructormirror-nested-badpath.scala +run/reflection-fancy-java-classes +run/reflection-fieldsymbol-navigation.scala +run/reflection-fieldmirror-nmelocalsuffixstring.scala +run/reflection-fieldmirror-getsetvar.scala +run/reflection-fieldmirror-privatethis.scala +run/reflection-implicit.scala +run/reflection-mem-glbs.scala +run/reflection-mem-tags.scala +run/reflection-java-annotations +run/reflection-java-crtp +run/reflection-methodsymbol-typeparams.scala +run/reflection-modulemirror-nested-badpath.scala +run/reflection-modulemirror-inner-badpath.scala +run/reflection-modulemirror-nested-good.scala +run/reflection-modulemirror-toplevel-badpath.scala +run/reflection-sync-subtypes.scala +run/reflinit.scala +run/reflection-valueclasses-derived.scala +run/reflection-valueclasses-magic.scala +run/resetattrs-this.scala +run/runtimeEval2.scala +run/showraw_aliases.scala +run/showraw_mods.scala +run/shortClass.scala +run/showraw_nosymbol.scala +run/showraw_tree.scala +run/showraw_tree_types_untyped.scala +run/t1167.scala +run/t2577.scala +run/t2873.scala +run/t2886.scala +run/t3346j.scala +run/t3507-new.scala +run/t3569.scala +run/t5125b.scala +run/t5225_1.scala +run/t3425b +run/t5256a.scala +run/t5230.scala +run/t5256c.scala +run/t5256g.scala +run/t5266_1.scala +run/t5269.scala +run/t5271_1.scala +run/t5271_2.scala +run/t5271_4.scala +run/t5272_1_newpatmat.scala +run/t5272_2_oldpatmat.scala +run/t5273_1_oldpatmat.scala +run/t5273_2a_newpatmat.scala +run/t5273_2a_oldpatmat.scala +run/t5275.scala +run/t5276_1a.scala +run/t5276_2a.scala +run/t5277_1.scala +run/t5279.scala +run/t5334_1.scala +run/t5334_2.scala +run/t5415.scala +run/t5418.scala +run/t5704.scala +run/t5710-1.scala +run/t5710-2.scala +run/t5770.scala +run/t5894.scala +run/t5816.scala +run/t5824.scala +run/t5912.scala +run/t5942.scala +run/t5943a2.scala +run/t6023.scala +run/t6113.scala +run/t6175.scala +run/t6178.scala +run/t6199-mirror.scala +run/t6199-toolbox.scala +run/t6240-universe-code-gen.scala +run/t6221 +run/t6260b.scala +run/t6259.scala +run/t6287.scala +run/t6344.scala +run/t6392a.scala +run/t6591_1.scala +run/t6591_2.scala +run/t6591_3.scala +run/t6591_5.scala +run/t6591_6.scala +run/t6591_7.scala +run/t6608.scala +run/t6677.scala +run/t6687.scala +run/t6715.scala +run/t6719.scala +run/t6793.scala +run/t6860.scala +run/t6793b.scala +run/t6793c.scala +run/t7045.scala +run/t7046.scala +run/t7008-scala-defined +run/t7120b.scala +run/t7151.scala +run/t7214.scala +run/t7235.scala +run/t7331a.scala +run/t7331b.scala +run/t7331c.scala +run/t7558.scala +run/t7556 +run/t7779.scala +run/t7868b.scala +run/toolbox_current_run_compiles.scala +run/toolbox_default_reporter_is_silent.scala +run/toolbox_parse_package.scala +run/toolbox_silent_reporter.scala +run/toolbox_typecheck_inferimplicitvalue.scala +run/typetags_serialize.scala +run/valueclasses-typetag-basic.scala +run/WeakHashSetTest.scala +run/valueclasses-typetag-generic.scala +run/t4023.scala +run/t4024.scala +run/t6380.scala +run/t5273_2b_oldpatmat.scala +run/t8104 +run/t8047.scala +run/t6992 +run/var-arity-class-symbol.scala +run/typetags_symbolof_x.scala +run/typecheck +run/t8190.scala +run/t8192 +run/t8177f.scala +run/t7932.scala +run/t7700.scala +run/t7570c.scala +run/t7570b.scala +run/t7533.scala +run/t7570a.scala +run/t7044 +run/t7328.scala +run/t6733.scala +run/t6554.scala +run/t6732.scala +run/t6379 +run/t6411b.scala +run/t6411a.scala +run/t6260c.scala +run/t6260-delambdafy.scala +run/showdecl +run/reflection-sync-potpourri.scala +run/reflection-tags.scala +run/reflection-companiontype.scala +run/reflection-scala-annotations.scala +run/reflection-idtc.scala +run/macro-reify-nested-b2 +run/mixin-signatures.scala +run/reflection-companion.scala +run/macro-reify-nested-b1 +run/macro-reify-nested-a2 +run/macro-reify-nested-a1 +run/macro-reify-chained2 +run/macro-reify-chained1 +run/inferred-type-constructors.scala +run/mirror_symbolof_x.scala +run/t8196.scala +run/t8549b.scala +run/t8574.scala +run/t8637.scala +run/t6622.scala +run/toolbox_expand_macro.scala +run/toolbox-varargs +run/t9252.scala +run/t9182.scala +run/t9102.scala +run/t720.scala +run/t9408.scala +run/t10527.scala +run/trait-default-specialize.scala +run/lazy-locals-2.scala +run/t5294.scala +run/trait_fields_final.scala +run/trait_fields_bytecode.scala +run/trait_fields_volatile.scala +run/junitForwarders +run/reflect-java-param-names + +run/reify_ann2b.scala +run/reify_classfileann_a +run/reify_classfileann_b +run/reify_newimpl_29.scala +run/reify_magicsymbols.scala +run/reify_inheritance.scala +run/reify_newimpl_12.scala +run/reify_typerefs_2b.scala +run/reify_csv.scala +run/reify_inner2.scala +run/reify_maps_oldpatmat.scala +run/reify_newimpl_43.scala +run/reify_nested_inner_refers_to_local.scala +run/reify_closure7.scala +run/reify_closure8b.scala +run/reify_typerefs_3b.scala +run/reify_newimpl_44.scala +run/reify_newimpl_06.scala +run/reify_newimpl_05.scala +run/reify_newimpl_20.scala +run/reify_newimpl_23.scala +run/reify_metalevel_breach_-1_refers_to_1.scala +run/reify_newimpl_41.scala +run/reify-repl-fail-gracefully.scala +run/reify_fors_oldpatmat.scala +run/reify_inner3.scala +run/reify_closure8a.scala +run/reify_closures10.scala +run/reify_ann2a.scala +run/reify_newimpl_51.scala +run/reify_newimpl_47.scala +run/reify_extendbuiltins.scala +run/reify_newimpl_30.scala +run/reify_newimpl_38.scala +run/reify_closure2a.scala +run/reify_newimpl_45.scala +run/reify_closure1.scala +run/reify_generic2.scala +run/reify_printf.scala +run/reify_closure6.scala +run/reify_newimpl_37.scala +run/reify_newimpl_35.scala +run/reify_typerefs_3a.scala +run/reify_newimpl_25.scala +run/reify_ann4.scala +run/reify_typerefs_1b.scala +run/reify_newimpl_22.scala +run/reify_this.scala +run/reify_typerefs_2a.scala +run/reify_newimpl_03.scala +run/reify_newimpl_48.scala +run/reify_varargs.scala +run/reify_newimpl_42.scala +run/reify_newimpl_15.scala +run/reify_nested_inner_refers_to_global.scala +run/reify_newimpl_02.scala +run/reify_newimpl_01.scala +run/reify_fors_newpatmat.scala +run/reify_nested_outer_refers_to_local.scala +run/reify_newimpl_13.scala +run/reify_closure5a.scala +run/reify_inner4.scala +run/reify_sort.scala +run/reify_ann1a.scala +run/reify_closure4a.scala +run/reify_newimpl_33.scala +run/reify_sort1.scala +run/reify_properties.scala +run/reify_generic.scala +run/reify_newimpl_27.scala +run/reify-aliases.scala +run/reify_ann3.scala +run/reify-staticXXX.scala +run/reify_ann1b.scala +run/reify_ann5.scala +run/reify_anonymous.scala +run/reify-each-node-type.scala +run/reify_copypaste2.scala +run/reify_closure3a.scala +run/reify_copypaste1.scala +run/reify_complex.scala +run/reify_for1.scala +run/reify_getter.scala +run/reify_implicits-new.scala +run/reify_inner1.scala +run/reify_implicits-old.scala +run/reify_lazyunit.scala +run/reify_lazyevaluation.scala +run/reify_maps_newpatmat.scala +run/reify_metalevel_breach_+0_refers_to_1.scala +run/reify_metalevel_breach_-1_refers_to_0_a.scala +run/reify_metalevel_breach_-1_refers_to_0_b.scala +run/reify_nested_outer_refers_to_global.scala +run/reify_newimpl_04.scala +run/reify_newimpl_14.scala +run/reify_newimpl_11.scala +run/reify_newimpl_18.scala +run/reify_newimpl_19.scala +run/reify_newimpl_31.scala +run/reify_newimpl_21.scala +run/reify_newimpl_36.scala +run/reify_newimpl_39.scala +run/reify_newimpl_40.scala +run/reify_newimpl_49.scala +run/reify_newimpl_50.scala +run/reify_newimpl_52.scala +run/reify_renamed_term_basic.scala +run/reify_renamed_term_local_to_reifee.scala +run/reify_renamed_term_overloaded_method.scala +run/reify_renamed_type_basic.scala +run/reify_renamed_type_local_to_reifee.scala +run/reify_renamed_type_spliceable.scala +run/reify_typerefs_1a.scala +run/reify_timeofday.scala +run/reify_renamed_term_t5841.scala + +run/t7521b.scala +run/t8575b.scala +run/t8575c.scala +run/t8944c.scala +run/t9535.scala +run/t9814.scala +run/t10009.scala +run/t10075.scala +run/t10075b + +run/t8756.scala +run/inferred-type-constructors-hou.scala +run/trait-static-forwarder +run/SD-235.scala +run/t10026.scala +run/checkinit.scala +run/reflection-clinit +run/reflection-clinit-nested +run/t10487.scala + +run/typetags_caching.scala +run/type-tag-leak.scala +run/t10856.scala +run/module-static.scala + +# Uses reflection indirectly through +# scala.runtime.ScalaRunTime.replStringOf +run/t6634.scala + +# Using reflection to invoke macros. These tests actually don't require +# or test reflection, but use it to separate compilation units nicely. +# It's a pity we cannot use them + +run/macro-abort-fresh +run/macro-expand-varargs-explicit-over-nonvarargs-bad +run/macro-invalidret-doesnt-conform-to-def-rettype +run/macro-invalidret-nontypeable +run/macro-invalidusage-badret +run/macro-invalidusage-partialapplication +run/macro-invalidusage-partialapplication-with-tparams +run/macro-reflective-ma-normal-mdmi +run/macro-reflective-mamd-normal-mi + +# Using macros, but indirectly creating calls to reflection +run/macro-reify-unreify + +# Using Enumeration in a way we cannot fix + +run/enums.scala +run/t3719.scala +run/t8611b.scala + +# Expecting exceptions that are linking errors in Scala.js (e.g. NoSuchMethodException) +run/t10334.scala + +# Playing with classfile format + +run/classfile-format-51.scala +run/classfile-format-52.scala + +# Concurrent collections (TrieMap) +# has too much stuff implemented in *.java, so no support +run/triemap-hash.scala + +# Using Swing + +run/t3613.scala + +# Using the REPL + +run/repl-type.scala +run/repl-replay.scala +run/repl-errors.scala +run/repl-any-error.scala +run/repl-paste-error.scala +run/repl-previous-result.scala +run/repl-trace-elided-more.scala +run/t4285.scala +run/constant-type.scala +run/repl-bare-expr.scala +run/repl-parens.scala +run/repl-assign.scala +run/t5583.scala +run/treePrint.scala +run/constrained-types.scala +run/repl-power.scala +run/t4710.scala +run/repl-paste.scala +run/repl-reset.scala +run/repl-paste-3.scala +run/t6329_repl.scala +run/t6273.scala +run/repl-paste-2.scala +run/t5655.scala +run/t5072.scala +run/repl-colon-type.scala +run/repl-trim-stack-trace.scala +run/t4594-repl-settings.scala +run/repl-save.scala +run/repl-paste-raw.scala +run/repl-paste-4.scala +run/t7801.scala +run/repl-backticks.scala +run/t6633.scala +run/repl-inline.scala +run/repl-class-based-term-macros.scala +run/repl-always-use-instance.scala +run/repl-class-based-implicit-import.scala +run/repl-class-based-value-class.scala +run/repl-deadlock.scala +run/repl-class-based-outer-pointers.scala +run/repl-class-based-escaping-reads.scala + +# Using the Repl (scala.tools.partest.ReplTest) +run/t11991.scala +run/t11915.scala +run/t11899.scala +run/t11897.scala +run/t11838.scala +run/t11402.scala +run/t11064.scala +run/t10768.scala +run/class-symbol-contravariant.scala +run/macro-bundle-repl.scala +run/macro-repl-basic.scala +run/macro-repl-dontexpand.scala +run/macro-system-properties.scala +run/reflection-equality.scala +run/reflection-repl-elementary.scala +run/reify_newimpl_26.scala +run/repl-out-dir.scala +run/repl-term-macros.scala +run/repl-transcript.scala +run/repl-type-verbose.scala +run/t3376.scala +run/t4025.scala +run/t4172.scala +run/t4216.scala +run/t4542.scala +run/t4671.scala +run/t5256d.scala +run/t5535.scala +run/t5537.scala +run/t5789.scala +run/t6086-repl.scala +run/t6146b.scala +run/t6187.scala +run/t6320.scala +run/t6381.scala +run/t6434.scala +run/t6439.scala +run/t6507.scala +run/t6549.scala +run/t6937.scala +run/t7185.scala +run/t7319.scala +run/t7482a.scala +run/t7634.scala +run/t7747-repl.scala +run/t7805-repl-i.scala +run/tpeCache-tyconCache.scala +run/repl-empty-package +run/repl-javap-def.scala +run/repl-javap-mem.scala +run/repl-javap-outdir +run/repl-javap.scala +run/t6329_repl_bug.scala +run/t4950.scala +run/xMigration.scala +run/t6541-option.scala +run/repl-serialization.scala +run/t9174.scala +run/repl-paste-5.scala +run/repl-no-uescape.scala +run/repl-no-imports-no-predef-classbased.scala +run/repl-implicits-nopredef.scala +run/repl-classbased.scala +run/repl-no-imports-no-predef-power.scala +run/repl-paste-b.scala +run/repl-paste-6.scala +run/repl-implicits.scala +run/repl-no-imports-no-predef.scala +run/repl-paste-raw-b.scala +run/repl-paste-raw-c.scala +run/t9749-repl-dot.scala +run/trait_fields_repl.scala +run/t7139 +run/t9689 +run/trailing-commas.scala +run/t4700.scala +run/t9880-9881.scala +run/repl-kind.scala +run/t10284.scala +run/t9016.scala +run/repl-completions.scala +run/t10956.scala +run/t11564.scala +run/invalid-lubs.scala +run/constAnnArgs.scala +run/interpolation-repl.scala +run/t12292.scala +run/t12276.scala +run/t10943.scala + +# Using Scala Script (partest.ScriptTest) + +run/t7711-script-args.scala +run/t4625.scala +run/t4625c.scala +run/t4625b.scala + +# Using the compiler API + +run/nowarn.scala +run/t9944.scala +run/t3368.scala +run/t3368-b.scala +run/t2512.scala +run/analyzerPlugins.scala +run/compiler-asSeenFrom.scala +run/t5603.scala +run/t6440.scala +run/t5545.scala +run/existentials-in-compiler.scala +run/global-showdef.scala +run/stream_length.scala +run/annotatedRetyping.scala +run/imain.scala +run/existential-rangepos.scala +run/delambdafy_uncurry_byname_inline.scala +run/delambdafy_uncurry_byname_method.scala +run/delambdafy_uncurry_inline.scala +run/delambdafy_t6555.scala +run/delambdafy_uncurry_method.scala +run/delambdafy_t6028.scala +run/memberpos.scala +run/programmatic-main.scala +run/reflection-names.scala +run/settings-parse.scala +run/sm-interpolator.scala +run/t1501.scala +run/t1500.scala +run/t1618.scala +run/t2464 +run/t4072.scala +run/t5064.scala +run/t5385.scala +run/t5699.scala +run/t5717.scala +run/t5940.scala +run/t6028.scala +run/t6194.scala +run/t6669.scala +run/t6745-2.scala +run/t7096.scala +run/t7271.scala +run/t7337.scala +run/t7569.scala +run/t7852.scala +run/t7817-tree-gen.scala +run/extend-global.scala +run/t12062.scala + + +# partest.DirectTest +run/t12019 +run/t11815.scala +run/t11746.scala +run/t11731.scala +run/t11385.scala +run/t10819.scala +run/t10751.scala +run/t10641.scala +run/t10344.scala +run/t10203.scala +run/string-switch-pos.scala +run/patmat-seq.scala +run/maxerrs.scala +run/t6288.scala +run/t6331.scala +run/t6440b.scala +run/t6555.scala +run/t7876.scala +run/typetags_without_scala_reflect_typetag_lookup.scala +run/dynamic-updateDynamic.scala +run/dynamic-selectDynamic.scala +run/dynamic-applyDynamic.scala +run/dynamic-applyDynamicNamed.scala +run/t4841-isolate-plugins +run/large_code.scala +run/macroPlugins-namerHooks.scala +run/t4841-no-plugin.scala +run/t8029.scala +run/t8046 +run/t5905-features.scala +run/t5905b-features.scala +run/large_class.scala +run/t8708_b +run/icode-reader-dead-code.scala +run/t5938.scala +run/t8502.scala +run/t6502.scala +run/t8907.scala +run/t9097.scala +run/macroPlugins-enterStats.scala +run/sbt-icode-interface.scala +run/t8502b.scala +run/repl-paste-parse.scala +run/t5463.scala +run/t8433.scala +run/sd275.scala +run/sd275-java +run/t10471.scala +run/t6130.scala +run/t9437b.scala +run/t10552 +run/sd187.scala +run/patmat-origtp-switch.scala +run/indyLambdaKinds +run/t11802-pluginsdir +run/literals-parsing.scala +run/patmat-no-inline-isEmpty.scala +run/patmat-no-inline-unapply.scala +run/splain-tree.scala +run/splain-truncrefined.scala +run/splain.scala + +# Using partest.StoreReporterDirectTest +run/t10171 + +# partest.StubErrorMessageTest +run/StubErrorBInheritsFromA.scala +run/StubErrorComplexInnerClass.scala +run/StubErrorHK.scala +run/StubErrorReturnTypeFunction.scala +run/StubErrorReturnTypeFunction2.scala +run/StubErrorReturnTypePolyFunction.scala +run/StubErrorSubclasses.scala +run/StubErrorTypeclass.scala +run/StubErrorTypeDef.scala + +# partest.ASMConverters +run/t9403 + +# partest.BytecodeTest +run/t7106 +run/t7974 +run/t8601-closure-elim.scala +run/t4788 +run/t4788-separate-compilation + +# partest.SessionTest +run/t8843-repl-xlat.scala +run/t9206.scala +run/t9170.scala +run/t8918-unary-ids.scala +run/t1931.scala +run/t8935-class.scala +run/t8935-object.scala + +# partest.JavapTest +run/t8608-no-format.scala + +# Using .java source files + +run/t4317 +run/t4238 +run/t2296c +run/t4119 +run/t4283 +run/t4891 +run/t6168 +run/t6168b +run/t6240a +run/t6240b +run/t6548 +run/t6989 +run/t7008 +run/t7246 +run/t7246b +run/t7359 +run/t7439 +run/t7455 +run/t7510 +run/t7582-private-within +run/t7582 +run/t7582b +run/t3897 +run/t7374 +run/t3452e +run/t3452g +run/t3452d +run/t3452b +run/t3452a +run/t1430 +run/t4729 +run/t8442 +run/t8601e +run/t9298 +run/t9298b +run/t9359 +run/t7741a +run/t7741b +run/bcodeInlinerMixed +run/t9268 +run/t9489 +run/t9915 +run/t10059 +run/t1459 +run/t1459generic +run/t3236 +run/t9013 +run/t10231 +run/t10067 +run/t10249 +run/sd143 +run/t4283b +run/t7936 +run/t7936b +run/t9937 +run/t10368 +run/t10334b +run/sd304 +run/t10450 +run/t10042 +run/t10699 +run/t9529 +run/t9529-types +run/t10490 +run/t10490-2 +run/t10889 +run/t3899 +run/t11373 +run/t8928 + + +# Using partest.Properties (nest.Runner) +run/t4294.scala +run/tailcalls.scala + +# Using scala-script +run/t7791-script-linenums.scala + +# Using scalap +run/scalapInvokedynamic.scala + +# Using Manifests (which use Class.getInterfaces) +run/valueclasses-manifest-existential.scala +run/existentials3-old.scala +run/t2236-old.scala +run/interop_manifests_are_classtags.scala +run/valueclasses-manifest-generic.scala +run/valueclasses-manifest-basic.scala +run/t1195-old.scala +run/t3758-old.scala +run/t4110-old.scala +run/t6246.scala + + +# Using ScalaRunTime.stringOf +run/value-class-extractor-seq.scala +run/t3493.scala + +# Custom invoke dynamic node +run/indy-via-macro +run/indy-via-macro-with-dynamic-args + +### Bugs +## Compiler +run/anyval-box-types.scala +run/structural.scala +run/t8017 +run/t8601b.scala +run/t8601d.scala +run/t10069b.scala + +## JVM compliance +run/t5680.scala +run/try-catch-unify.scala +run/t2755.scala +run/java-erasure.scala + + +## Fails +run/t10290.scala +run/t6827.scala +run/classtags-cached.scala +run/sip23-cast-1.scala + +#OutOfMemoryError +run/stream-gc.scala + +## Check not passing +run/t266.scala +run/t4300.scala +run/t8334.scala +run/t8803.scala +run/t9697.scala + +#Missing symbols +run/t9400.scala + +## LLVM compilation fails +run/t7269.scala + +## Other +run/t10277.scala +run/t10277b.scala + +run/t12380 +run/t7448.scala diff --git a/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t11952b.check b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t11952b.check new file mode 100644 index 0000000000..6043da6279 --- /dev/null +++ b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t11952b.check @@ -0,0 +1,16 @@ +[running phase parser on t11952b.scala] +[running phase namer on t11952b.scala] +[running phase packageobjects on t11952b.scala] +[running phase typer on t11952b.scala] +[running phase nativeinterop on t11952b.scala] +[running phase superaccessors on t11952b.scala] +[running phase extmethods on t11952b.scala] +[running phase pickler on t11952b.scala] +[running phase refchecks on t11952b.scala] +t11952b.scala:9: error: cannot override final member: + final def f: String (defined in class C); + found : scala.this.Int + required: String + override def f: Int = 42 + ^ +1 error diff --git a/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t6446-additional.check b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t6446-additional.check new file mode 100644 index 0000000000..173702fd11 --- /dev/null +++ b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t6446-additional.check @@ -0,0 +1,29 @@ + phase name id description + ---------- -- ----------- + parser 1 parse source into ASTs, perform simple desugaring + namer 2 resolve names, attach symbols to named trees +packageobjects 3 load package objects + typer 4 the meat and potatoes: type the trees + nativeinterop 5 prepare ASTs for Native interop +superaccessors 6 add super accessors in traits and nested classes + extmethods 7 add extension methods for inline classes + pickler 8 serialize symbol tables + refchecks 9 reference/override checking, translate nested objects + patmat 10 translate match expressions + uncurry 11 uncurry, translate function values to anonymous classes + fields 12 synthesize accessors and fields, add bitmaps for lazy vals + tailcalls 13 replace tail calls by jumps + specialize 14 @specialized-driven class and method specialization + explicitouter 15 this refs to outer pointers + erasure 16 erase types, add interfaces for traits + posterasure 17 clean up erased inline classes + lambdalift 18 move nested functions to top level + constructors 19 move field definitions into constructors + flatten 20 eliminate inner classes + mixin 21 mixin composition + nir 22 + cleanup 23 platform-specific cleanups, generate reflective calls + delambdafy 24 remove lambdas + jvm 25 generate JVM bytecode + ploogin 26 A sample phase that does so many things it's kind of hard... + terminal 27 the last phase during a compilation run diff --git a/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t6446-list.check b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t6446-list.check new file mode 100644 index 0000000000..eba706333b --- /dev/null +++ b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t6446-list.check @@ -0,0 +1,2 @@ +ploogin - A sample plugin for testing. +nir - Compile to Scala Native IR (NIR) diff --git a/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t6446-missing.check b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t6446-missing.check new file mode 100644 index 0000000000..c348d55c19 --- /dev/null +++ b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t6446-missing.check @@ -0,0 +1,29 @@ +Error: unable to load class: t6446.Ploogin + phase name id description + ---------- -- ----------- + parser 1 parse source into ASTs, perform simple desugaring + namer 2 resolve names, attach symbols to named trees +packageobjects 3 load package objects + typer 4 the meat and potatoes: type the trees + nativeinterop 5 prepare ASTs for Native interop +superaccessors 6 add super accessors in traits and nested classes + extmethods 7 add extension methods for inline classes + pickler 8 serialize symbol tables + refchecks 9 reference/override checking, translate nested objects + patmat 10 translate match expressions + uncurry 11 uncurry, translate function values to anonymous classes + fields 12 synthesize accessors and fields, add bitmaps for lazy vals + tailcalls 13 replace tail calls by jumps + specialize 14 @specialized-driven class and method specialization + explicitouter 15 this refs to outer pointers + erasure 16 erase types, add interfaces for traits + posterasure 17 clean up erased inline classes + lambdalift 18 move nested functions to top level + constructors 19 move field definitions into constructors + flatten 20 eliminate inner classes + mixin 21 mixin composition + nir 22 + cleanup 23 platform-specific cleanups, generate reflective calls + delambdafy 24 remove lambdas + jvm 25 generate JVM bytecode + terminal 26 the last phase during a compilation run diff --git a/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t6446-show-phases.check b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t6446-show-phases.check new file mode 100644 index 0000000000..244dbec464 --- /dev/null +++ b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t6446-show-phases.check @@ -0,0 +1,28 @@ + phase name id description + ---------- -- ----------- + parser 1 parse source into ASTs, perform simple desugaring + namer 2 resolve names, attach symbols to named trees +packageobjects 3 load package objects + typer 4 the meat and potatoes: type the trees + nativeinterop 5 prepare ASTs for Native interop +superaccessors 6 add super accessors in traits and nested classes + extmethods 7 add extension methods for inline classes + pickler 8 serialize symbol tables + refchecks 9 reference/override checking, translate nested objects + patmat 10 translate match expressions + uncurry 11 uncurry, translate function values to anonymous classes + fields 12 synthesize accessors and fields, add bitmaps for lazy vals + tailcalls 13 replace tail calls by jumps + specialize 14 @specialized-driven class and method specialization + explicitouter 15 this refs to outer pointers + erasure 16 erase types, add interfaces for traits + posterasure 17 clean up erased inline classes + lambdalift 18 move nested functions to top level + constructors 19 move field definitions into constructors + flatten 20 eliminate inner classes + mixin 21 mixin composition + nir 22 + cleanup 23 platform-specific cleanups, generate reflective calls + delambdafy 24 remove lambdas + jvm 25 generate JVM bytecode + terminal 26 the last phase during a compilation run diff --git a/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t7494-no-options.check b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t7494-no-options.check new file mode 100644 index 0000000000..d5c68d8139 --- /dev/null +++ b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/neg/t7494-no-options.check @@ -0,0 +1,30 @@ +error: Error: ploogin takes no options + phase name id description + ---------- -- ----------- + parser 1 parse source into ASTs, perform simple desugaring + namer 2 resolve names, attach symbols to named trees +packageobjects 3 load package objects + typer 4 the meat and potatoes: type the trees + nativeinterop 5 prepare ASTs for Native interop +superaccessors 6 add super accessors in traits and nested classes + extmethods 7 add extension methods for inline classes + pickler 8 serialize symbol tables + refchecks 9 reference/override checking, translate nested objects + patmat 10 translate match expressions + uncurry 11 uncurry, translate function values to anonymous classes + fields 12 synthesize accessors and fields, add bitmaps for lazy vals + tailcalls 13 replace tail calls by jumps + specialize 14 @specialized-driven class and method specialization + explicitouter 15 this refs to outer pointers + erasure 16 erase types, add interfaces for traits + posterasure 17 clean up erased inline classes + lambdalift 18 move nested functions to top level + constructors 19 move field definitions into constructors + flatten 20 eliminate inner classes + mixin 21 mixin composition + nir 22 + cleanup 23 platform-specific cleanups, generate reflective calls + delambdafy 24 remove lambdas + jvm 25 generate JVM bytecode + ploogin 26 A sample phase that does so many things it's kind of hard... + terminal 27 the last phase during a compilation run diff --git a/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/classof.check b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/classof.check new file mode 100644 index 0000000000..21bf4cfb41 --- /dev/null +++ b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/classof.check @@ -0,0 +1,22 @@ +Value types: +class scala.scalanative.runtime.PrimitiveUnit +class scala.scalanative.runtime.PrimitiveBoolean +class scala.scalanative.runtime.PrimitiveByte +class scala.scalanative.runtime.PrimitiveShort +class scala.scalanative.runtime.PrimitiveChar +class scala.scalanative.runtime.PrimitiveInt +class scala.scalanative.runtime.PrimitiveLong +class scala.scalanative.runtime.PrimitiveFloat +class scala.scalanative.runtime.PrimitiveDouble +Class types +class SomeClass +class scala.collection.immutable.List +class scala.Tuple2 +Arrays: +class scala.scalanative.runtime.ObjectArray +class scala.scalanative.runtime.IntArray +class scala.scalanative.runtime.DoubleArray +class scala.scalanative.runtime.ObjectArray +Functions: +interface scala.Function2 +interface scala.Function1 diff --git a/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/classtags_contextbound.check b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/classtags_contextbound.check new file mode 100644 index 0000000000..5d3106c9bc --- /dev/null +++ b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/classtags_contextbound.check @@ -0,0 +1 @@ +class scala.scalanative.runtime.IntArray diff --git a/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/classtags_multi.check b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/classtags_multi.check new file mode 100644 index 0000000000..ab1c14e439 --- /dev/null +++ b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/classtags_multi.check @@ -0,0 +1,5 @@ +Int +Array[scala.scalanative.runtime.PrimitiveInt] +Array[java.lang.Object] +Array[java.lang.Object] +Array[java.lang.Object] diff --git a/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/getClassTest-valueClass.check b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/getClassTest-valueClass.check new file mode 100644 index 0000000000..cee2875fff --- /dev/null +++ b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/getClassTest-valueClass.check @@ -0,0 +1,2 @@ +class scala.scalanative.runtime.PrimitiveInt +class V diff --git a/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/interop_classtags_are_classmanifests.check b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/interop_classtags_are_classmanifests.check new file mode 100644 index 0000000000..5ef5b7138c --- /dev/null +++ b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/interop_classtags_are_classmanifests.check @@ -0,0 +1,3 @@ +Int +java.lang.String +Array[scala.scalanative.runtime.PrimitiveInt] diff --git a/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/t4753.check b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/t4753.check new file mode 100644 index 0000000000..9a020c1ead --- /dev/null +++ b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/t4753.check @@ -0,0 +1 @@ +class scala.scalanative.runtime.PrimitiveBoolean diff --git a/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/t5568.check b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/t5568.check new file mode 100644 index 0000000000..0018046644 --- /dev/null +++ b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/t5568.check @@ -0,0 +1,9 @@ +class scala.scalanative.runtime.PrimitiveUnit +class scala.scalanative.runtime.PrimitiveInt +class scala.runtime.BoxedUnit +class scala.runtime.BoxedUnit +class java.lang.Integer +class java.lang.Integer +5 +5 +5 diff --git a/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/t5923b.check b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/t5923b.check new file mode 100644 index 0000000000..a4885c883f --- /dev/null +++ b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/t5923b.check @@ -0,0 +1,3 @@ +class scala.scalanative.runtime.ObjectArray +class scala.scalanative.runtime.ObjectArray +class scala.scalanative.runtime.ObjectArray diff --git a/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/t6318_primitives.check b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/t6318_primitives.check new file mode 100644 index 0000000000..1b64e046c7 --- /dev/null +++ b/scala-partest-tests/src/test/resources/scala/tools/partest/scalanative/2.13.12/run/t6318_primitives.check @@ -0,0 +1,54 @@ +Checking if class scala.scalanative.runtime.PrimitiveByte matches class scala.scalanative.runtime.PrimitiveByte +Some(1) +Checking if class scala.scalanative.runtime.PrimitiveByte matches class scala.scalanative.runtime.PrimitiveShort +None +Checking if class java.lang.Byte matches class scala.scalanative.runtime.PrimitiveByte +Some(1) +Checking if class scala.scalanative.runtime.PrimitiveShort matches class scala.scalanative.runtime.PrimitiveShort +Some(1) +Checking if class scala.scalanative.runtime.PrimitiveShort matches class scala.scalanative.runtime.PrimitiveChar +None +Checking if class java.lang.Short matches class scala.scalanative.runtime.PrimitiveShort +Some(1) +Checking if class scala.scalanative.runtime.PrimitiveChar matches class scala.scalanative.runtime.PrimitiveChar +Some() +Checking if class scala.scalanative.runtime.PrimitiveChar matches class scala.scalanative.runtime.PrimitiveInt +None +Checking if class java.lang.Character matches class scala.scalanative.runtime.PrimitiveChar +Some() +Checking if class scala.scalanative.runtime.PrimitiveInt matches class scala.scalanative.runtime.PrimitiveInt +Some(1) +Checking if class scala.scalanative.runtime.PrimitiveInt matches class scala.scalanative.runtime.PrimitiveLong +None +Checking if class java.lang.Integer matches class scala.scalanative.runtime.PrimitiveInt +Some(1) +Checking if class scala.scalanative.runtime.PrimitiveLong matches class scala.scalanative.runtime.PrimitiveLong +Some(1) +Checking if class scala.scalanative.runtime.PrimitiveLong matches class scala.scalanative.runtime.PrimitiveFloat +None +Checking if class java.lang.Long matches class scala.scalanative.runtime.PrimitiveLong +Some(1) +Checking if class scala.scalanative.runtime.PrimitiveFloat matches class scala.scalanative.runtime.PrimitiveFloat +Some(1.0) +Checking if class scala.scalanative.runtime.PrimitiveFloat matches class scala.scalanative.runtime.PrimitiveDouble +None +Checking if class java.lang.Float matches class scala.scalanative.runtime.PrimitiveFloat +Some(1.0) +Checking if class scala.scalanative.runtime.PrimitiveDouble matches class scala.scalanative.runtime.PrimitiveDouble +Some(1.0) +Checking if class scala.scalanative.runtime.PrimitiveDouble matches class scala.scalanative.runtime.PrimitiveBoolean +None +Checking if class java.lang.Double matches class scala.scalanative.runtime.PrimitiveDouble +Some(1.0) +Checking if class scala.scalanative.runtime.PrimitiveBoolean matches class scala.scalanative.runtime.PrimitiveBoolean +Some(true) +Checking if class scala.scalanative.runtime.PrimitiveBoolean matches class scala.scalanative.runtime.PrimitiveUnit +None +Checking if class java.lang.Boolean matches class scala.scalanative.runtime.PrimitiveBoolean +Some(true) +Checking if class scala.scalanative.runtime.PrimitiveUnit matches class scala.scalanative.runtime.PrimitiveUnit +Some(()) +Checking if class scala.scalanative.runtime.PrimitiveUnit matches class scala.scalanative.runtime.PrimitiveByte +None +Checking if class scala.scalanative.runtime.BoxedUnit$ matches class scala.scalanative.runtime.PrimitiveUnit +Some(()) From 3006c72d16a4f99ceefd858fbe82949ab62f6490 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Thu, 7 Sep 2023 02:18:21 +0200 Subject: [PATCH 08/51] Temportaly ignore 1 test leading to compiler crash (cherry picked from commit 9473d48e8bcfbfed77a5555c268a031fcc562c8a) --- .../src/test/resources/2.13.12/BlacklistedTests.txt | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt b/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt index ab4f2ad1ee..03528a881b 100644 --- a/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt +++ b/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt @@ -245,4 +245,7 @@ scala/util/TryTest.scala # https://github.com/scala-native/scala-native/issues/2897 scala/math/BigIntTest.scala ### deadlocks maybe needs j.u.c.ConcurrentLinkedQueue -scala/concurrent/impl/DefaultPromiseTest.scala \ No newline at end of file +scala/concurrent/impl/DefaultPromiseTest.scala + +// Bug, cannot find statically ConcurrentMap#computeIfPresent +scala/collection/convert/EqualsTest.scala \ No newline at end of file From 0c8e4bb99b2e1f492dfaf1995ef69b865dab7c62 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Thu, 7 Sep 2023 09:49:15 +0200 Subject: [PATCH 09/51] Allow to compile testing compiler with 2.13.12 (doReport overload was deprecated) (cherry picked from commit b3f96cbe028776f7df0a9d09c540b9ddafd14005) --- .../src/main/compat-new/compiler/CompatReporter.scala | 1 + 1 file changed, 1 insertion(+) diff --git a/testing-compiler/src/main/compat-new/compiler/CompatReporter.scala b/testing-compiler/src/main/compat-new/compiler/CompatReporter.scala index 98f9619be0..c571cd0e2a 100644 --- a/testing-compiler/src/main/compat-new/compiler/CompatReporter.scala +++ b/testing-compiler/src/main/compat-new/compiler/CompatReporter.scala @@ -6,6 +6,7 @@ import scala.reflect.internal.util.Position private[scalanative] trait CompatReporter extends FilteringReporter { def add(pos: Position, msg: String, severity: Severity): Unit + @deprecated override def doReport(pos: Position, msg: String, severity: Severity): Unit = add(pos, msg, severity) } From 8c7860dae3db0cc4ab2c767acd9c14ca917f01c3 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Thu, 7 Sep 2023 10:18:43 +0200 Subject: [PATCH 10/51] Fix typo in junit tests blacklist (cherry picked from commit 5d28d3eb87046d73b6b9888897d38edbf4b7899b) --- .../src/test/resources/2.13.12/BlacklistedTests.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt b/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt index 03528a881b..0abd4fbd53 100644 --- a/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt +++ b/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt @@ -247,5 +247,5 @@ scala/math/BigIntTest.scala ### deadlocks maybe needs j.u.c.ConcurrentLinkedQueue scala/concurrent/impl/DefaultPromiseTest.scala -// Bug, cannot find statically ConcurrentMap#computeIfPresent +# Bug, cannot find statically ConcurrentMap#computeIfPresent scala/collection/convert/EqualsTest.scala \ No newline at end of file From 2738e1bf9b8497413450f4c41fda7a50fa814c71 Mon Sep 17 00:00:00 2001 From: He-Pin Date: Sun, 17 Sep 2023 14:25:37 +0800 Subject: [PATCH 11/51] =fmt Update scalafmt to 3.7.14 (cherry picked from commit 59aa92d0c8e9bf8b2c96459bdce148f20757c2b5) --- .scalafmt.conf | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.scalafmt.conf b/.scalafmt.conf index 1ae3c92fbf..b0551b8183 100644 --- a/.scalafmt.conf +++ b/.scalafmt.conf @@ -3,7 +3,7 @@ # settings is preferred over adding especially as # the Scala language evolves and styles change. # Test upgrades: $ scripts/scalafmt --test 2> diff.txt -version = 3.6.1 +version = 3.7.14 docstrings.style = AsteriskSpace project.git = true project.excludePaths = [ From e4f4769179e10faea0337fd108e48197e7aef54c Mon Sep 17 00:00:00 2001 From: He-Pin Date: Sun, 17 Sep 2023 08:27:50 +0200 Subject: [PATCH 12/51] =fmt fmt with 3.7.14 (cherry picked from commit 8456ecd6e3700f0c9b81616ae04ac80c4f4173dc) --- javalib/src/main/scala/java/math/BigDecimal.scala | 2 +- .../main/scala/java/net/URIEncoderDecoder.scala | 4 ++-- .../scala/scala/scalanative/regex/Parser.scala | 14 +++++++------- .../testsuite/javalib/util/stream/StreamTest.scala | 6 +++--- 4 files changed, 13 insertions(+), 13 deletions(-) diff --git a/javalib/src/main/scala/java/math/BigDecimal.scala b/javalib/src/main/scala/java/math/BigDecimal.scala index e8b1f04ad9..c6bcb3bf84 100644 --- a/javalib/src/main/scala/java/math/BigDecimal.scala +++ b/javalib/src/main/scala/java/math/BigDecimal.scala @@ -1671,7 +1671,7 @@ class BigDecimal() extends Number with Comparable[BigDecimal] { // To test if after discard bits, a new carry is generated if (((bits & 3) == 3) || (((bits & 1) == 1) && (tempBits != 0) && - (lowestSetBit < discardedSize))) { + (lowestSetBit < discardedSize))) { bits += 1 } exponent = 0 diff --git a/javalib/src/main/scala/java/net/URIEncoderDecoder.scala b/javalib/src/main/scala/java/net/URIEncoderDecoder.scala index 2b7ae59e5b..a0b8926fd1 100644 --- a/javalib/src/main/scala/java/net/URIEncoderDecoder.scala +++ b/javalib/src/main/scala/java/net/URIEncoderDecoder.scala @@ -35,7 +35,7 @@ object URIEncoderDecoder { } else if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || legal.indexOf(ch) > -1 || (ch > 127 && !java.lang.Character.isSpaceChar(ch) && - !java.lang.Character.isISOControl(ch)))) { + !java.lang.Character.isISOControl(ch)))) { throw new URISyntaxException(s, "Illegal character", i) } if (!continue) i += 1 @@ -62,7 +62,7 @@ object URIEncoderDecoder { (ch >= '0' && ch <= '9') || legal.indexOf(ch) > -1 || (ch > 127 && !java.lang.Character.isSpaceChar(ch) && - !java.lang.Character.isISOControl(ch))) { + !java.lang.Character.isISOControl(ch))) { buf.append(ch) } else { val bytes: Array[Byte] = new String(Array(ch)).getBytes(encoding) diff --git a/nativelib/src/main/scala/scala/scalanative/regex/Parser.scala b/nativelib/src/main/scala/scala/scalanative/regex/Parser.scala index ed5fc1dc89..84afaccf4a 100644 --- a/nativelib/src/main/scala/scala/scalanative/regex/Parser.scala +++ b/nativelib/src/main/scala/scala/scalanative/regex/Parser.scala @@ -95,10 +95,10 @@ class Parser(wholeRegexp: String, _flags: Int) { Unicode.simpleFold(re.runes(0)) == re.runes(2) && Unicode.simpleFold(re.runes(2)) == re.runes(0)) || (re.op == ROP.CHAR_CLASS && - re.runes.length == 2 && - re.runes(0) + 1 == re.runes(1) && - Unicode.simpleFold(re.runes(0)) == re.runes(1) && - Unicode.simpleFold(re.runes(1)) == re.runes(0))) { + re.runes.length == 2 && + re.runes(0) + 1 == re.runes(1) && + Unicode.simpleFold(re.runes(0)) == re.runes(1) && + Unicode.simpleFold(re.runes(1)) == re.runes(0))) { // Case-insensitive rune like [Aa] or [Δδ]. if (maybeConcat(re.runes(0), flags | RE2.FOLD_CASE)) { returnNull = true @@ -510,8 +510,8 @@ class Parser(wholeRegexp: String, _flags: Int) { if (first != null && first.equals(ifirst) && (isCharClass(first) || - (first.op == ROP.REPEAT && - first.min == first.max && isCharClass(first.subs(0))))) { + (first.op == ROP.REPEAT && + first.min == first.max && isCharClass(first.subs(0))))) { continue = true } } @@ -590,7 +590,7 @@ class Parser(wholeRegexp: String, _flags: Int) { val subJ = array(s + j) if ((subMax.op < subJ.op) || ((subMax.op == subJ.op) && - (subMax.runes.length < subJ.runes.length))) { + (subMax.runes.length < subJ.runes.length))) { max = j } j += 1 diff --git a/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/util/stream/StreamTest.scala b/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/util/stream/StreamTest.scala index 61f1b367d8..183ec56def 100644 --- a/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/util/stream/StreamTest.scala +++ b/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/util/stream/StreamTest.scala @@ -916,9 +916,9 @@ class StreamTest { s"unexpected map element: ${e}", e.startsWith(prefix) && (e.endsWith("_A") || - e.endsWith("_B") || - e.endsWith("_C") || - e.endsWith("_D")) + e.endsWith("_B") || + e.endsWith("_C") || + e.endsWith("_D")) ) ) From 8c7bbdf524e9653674c2c8ba614360d4e314db37 Mon Sep 17 00:00:00 2001 From: He-Pin Date: Mon, 18 Sep 2023 11:15:32 +0800 Subject: [PATCH 13/51] =fmt Add .git-blame-ignore-revs (cherry picked from commit 10a78d3ba5142a9577aaa8dcd4ecf4b6e12ce4cc) --- .git-blame-ignore-revs | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 .git-blame-ignore-revs diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs new file mode 100644 index 0000000000..28479568d3 --- /dev/null +++ b/.git-blame-ignore-revs @@ -0,0 +1,2 @@ +#scalafmt +2bde51a900a0d653fab1ed8224c4773069def77f \ No newline at end of file From d17cdf1cfdaf02eb14864faf7768b7f9a208ffbe Mon Sep 17 00:00:00 2001 From: LeeTibbert Date: Tue, 19 Sep 2023 11:22:03 -0400 Subject: [PATCH 14/51] Fix #3477: javalib Channels.newChannel#read now reports EOF (#3478) * Fix #3477: javalib Channels.newChannel#read now reports EOF * Restart CI; no semantic changes (cherry picked from commit f50d68d5718cbeff91fe09d377ec67594e7c35fb) --- .../main/scala/java/nio/channels/Channels.scala | 17 +++++++++++++---- .../javalib/nio/channels/ChannelsTest.scala | 17 +++++++++++++++++ 2 files changed, 30 insertions(+), 4 deletions(-) diff --git a/javalib/src/main/scala/java/nio/channels/Channels.scala b/javalib/src/main/scala/java/nio/channels/Channels.scala index 974a52b1dd..feac82034b 100644 --- a/javalib/src/main/scala/java/nio/channels/Channels.scala +++ b/javalib/src/main/scala/java/nio/channels/Channels.scala @@ -52,25 +52,34 @@ object Channels { new ReadableByteChannel { var closed = false override def read(dst: ByteBuffer): Int = synchronized { - if (closed) throw new ClosedChannelException() + if (closed) + throw new ClosedChannelException() + var eof = false var written = 0 val capacity = dst.capacity() + while ({ val readByte = in.read() - if (readByte != -1) { + if (readByte == -1) { + eof = true + false + } else { dst.put(readByte.toByte) written += 1 capacity > written - } else false + } }) () - written + if ((written == 0) && eof) -1 + else written } + override def close(): Unit = synchronized { in.close() closed = true } + override def isOpen(): Boolean = synchronized { !closed } } } diff --git a/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/nio/channels/ChannelsTest.scala b/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/nio/channels/ChannelsTest.scala index 29d9410874..ae6e9a9b7d 100644 --- a/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/nio/channels/ChannelsTest.scala +++ b/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/nio/channels/ChannelsTest.scala @@ -25,6 +25,23 @@ class ChannelsTest { assertArrayEquals(expected, byteBuffer.array()) } + // Issue 3477 + @Test def newChannelInputStreamReportsEOF(): Unit = { + val expected = Array[Byte](1, 2, 3) + val in = new ByteArrayInputStream(expected, 0, 3) + val channel = Channels.newChannel(in) + + val byteBuffer = ByteBuffer.allocate(3) + + // Read, check, and then discard expected in order to get to EOF + channel.read(byteBuffer) + assertArrayEquals(expected, byteBuffer.array()) + byteBuffer.rewind() + + val nRead = channel.read(byteBuffer) + assertEquals("Read of channel at EOF)", -1, nRead) + } + @Test def newChannelInputStreamThrows(): Unit = { assumeFalse( "Bug in the JVM, works for later versions than java 8", From 16fb9e770ed10aeb7a3de1d43c58b4d7f65b72a8 Mon Sep 17 00:00:00 2001 From: LeeTibbert Date: Tue, 19 Sep 2023 11:23:36 -0400 Subject: [PATCH 15/51] Implement `java.nio.file.{AccessMode,ReadOnlyFileSystemException}` (#3479) (cherry picked from commit 3d72c1db2b15debf00b36319280abfe4ece00d75) --- .../main/scala/java/nio/file/AccessMode.scala | 21 +++++++++++++++++++ .../file/ReadOnlyFileSystemException.scala | 3 +++ .../ReadOnlyFileSystemExceptionTest.scala | 18 ++++++++++++++++ 3 files changed, 42 insertions(+) create mode 100644 javalib/src/main/scala/java/nio/file/AccessMode.scala create mode 100644 javalib/src/main/scala/java/nio/file/ReadOnlyFileSystemException.scala create mode 100644 unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/nio/file/ReadOnlyFileSystemExceptionTest.scala diff --git a/javalib/src/main/scala/java/nio/file/AccessMode.scala b/javalib/src/main/scala/java/nio/file/AccessMode.scala new file mode 100644 index 0000000000..83ecdb8fd2 --- /dev/null +++ b/javalib/src/main/scala/java/nio/file/AccessMode.scala @@ -0,0 +1,21 @@ +package java.nio.file + +sealed class AccessMode(name: String, ordinal: Int) + extends _Enum[AccessMode](name, ordinal) { + override def toString() = this.name +} + +object AccessMode { + final val EXECUTE = new AccessMode("EXECUTE", 0) + final val READ = new AccessMode("READ", 1) + final val WRITE = new AccessMode("WRITE", 1) + + private[this] val cachedValues = + Array(EXECUTE, READ, WRITE) + def values(): Array[AccessMode] = cachedValues.clone() + def valueOf(name: String): AccessMode = { + cachedValues.find(_.name() == name).getOrElse { + throw new IllegalArgumentException("No enum const AccessMode." + name) + } + } +} diff --git a/javalib/src/main/scala/java/nio/file/ReadOnlyFileSystemException.scala b/javalib/src/main/scala/java/nio/file/ReadOnlyFileSystemException.scala new file mode 100644 index 0000000000..e2851581f3 --- /dev/null +++ b/javalib/src/main/scala/java/nio/file/ReadOnlyFileSystemException.scala @@ -0,0 +1,3 @@ +package java.nio.file + +class ReadOnlyFileSystemException extends UnsupportedOperationException diff --git a/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/nio/file/ReadOnlyFileSystemExceptionTest.scala b/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/nio/file/ReadOnlyFileSystemExceptionTest.scala new file mode 100644 index 0000000000..7dfdafeed0 --- /dev/null +++ b/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/nio/file/ReadOnlyFileSystemExceptionTest.scala @@ -0,0 +1,18 @@ +package org.scalanative.testsuite.javalib.nio.file + +import java.nio.file._ + +import org.junit.Test +import org.junit.Assert._ + +import org.scalanative.testsuite.utils.AssertThrows.assertThrows + +class ReadOnlyFileSystemExceptionTest { + + @Test def readOnlyFileSystemExceptionExists(): Unit = { + assertThrows( + classOf[ReadOnlyFileSystemException], + throw new ReadOnlyFileSystemException() + ) + } +} From 4bfa0ec1aae3d2ea88fc04050ce1db4ff68692d6 Mon Sep 17 00:00:00 2001 From: Natsu Kagami Date: Tue, 19 Sep 2023 15:48:07 +0000 Subject: [PATCH 16/51] Use `/usr/bin/env bash` for shebangs (#3487) (cherry picked from commit b09b7445fc19f79e8122502f3e21479233db55c5) --- scripts/check-cla.sh | 2 +- scripts/check-lint.sh | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/scripts/check-cla.sh b/scripts/check-cla.sh index bc378bf5f5..18ae8760f2 100755 --- a/scripts/check-cla.sh +++ b/scripts/check-cla.sh @@ -1,4 +1,4 @@ -#!/bin/bash +#!/usr/bin/env bash set -e diff --git a/scripts/check-lint.sh b/scripts/check-lint.sh index 0bb68607e6..b8df9ce723 100755 --- a/scripts/check-lint.sh +++ b/scripts/check-lint.sh @@ -1,4 +1,4 @@ -#!/bin/bash +#!/usr/bin/env bash set -e From 730c864dd4a1c1a3e49eeb844d14cd75f8271ed9 Mon Sep 17 00:00:00 2001 From: kerr Date: Tue, 19 Sep 2023 23:49:04 +0800 Subject: [PATCH 17/51] +javalib Add CompletionException to javalib. (#3482) (cherry picked from commit d40d2b59afabeb4575ef0c9d2499fd5797874326) --- .../scala/java/util/concurrent/CompletionException.scala | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 javalib/src/main/scala/java/util/concurrent/CompletionException.scala diff --git a/javalib/src/main/scala/java/util/concurrent/CompletionException.scala b/javalib/src/main/scala/java/util/concurrent/CompletionException.scala new file mode 100644 index 0000000000..3600dd2e34 --- /dev/null +++ b/javalib/src/main/scala/java/util/concurrent/CompletionException.scala @@ -0,0 +1,9 @@ +package java.util.concurrent + +@SerialVersionUID(1L) +class CompletionException(message: String, cause: Throwable) + extends RuntimeException(message, cause) { + protected def this() = this(null, null) + protected def this(message: String) = this(message, null) + def this(cause: Throwable) = this(null, cause) +} From fb6fa8bf7f487ab435cc747db1a74f152b468d13 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Tue, 19 Sep 2023 22:59:15 +0200 Subject: [PATCH 18/51] [ci-skip] Use correct SHA in .git-blame-ignore-revs (cherry picked from commit 958422383fda94bd6d40dae575c751e338fc4a90) --- .git-blame-ignore-revs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs index 28479568d3..0869864918 100644 --- a/.git-blame-ignore-revs +++ b/.git-blame-ignore-revs @@ -1,2 +1,2 @@ #scalafmt -2bde51a900a0d653fab1ed8224c4773069def77f \ No newline at end of file +8456ecd6e3700f0c9b81616ae04ac80c4f4173dc From b793d6caf6c734897b26a1e47c42bb9dea1ad1c5 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Tue, 19 Sep 2023 23:48:10 +0200 Subject: [PATCH 19/51] CI - disable release-fast + none lto build configs - too slow and leads to timeouts (cherry picked from commit ba2307ca8209b9b0ffb81050d5111e87f2f15533) --- .github/workflows/run-tests-linux.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/run-tests-linux.yml b/.github/workflows/run-tests-linux.yml index 7ba514763f..290ab82f2c 100644 --- a/.github/workflows/run-tests-linux.yml +++ b/.github/workflows/run-tests-linux.yml @@ -113,6 +113,9 @@ jobs: - scala: 2.13.11 build-mode: debug gc: immix + # Slow, leads to timeouts + - build-mode: release-fast + lto: none include: - scala: 3.3.0 build-mode: release-size @@ -147,9 +150,6 @@ jobs: matrix: scala: [3.3.0, 2.13.11] build-mode: [debug] - include: - - scala: 2.13.11 - build-mode: release-fast steps: - uses: actions/checkout@v3 - uses: ./.github/actions/linux-setup-env From 279112cde34a71a25c7b4ae52a2e22d9b580bf95 Mon Sep 17 00:00:00 2001 From: Eric K Richardson Date: Wed, 20 Sep 2023 01:07:15 -0700 Subject: [PATCH 20/51] Fix #3006: Add nowarn annotation for long term deprecation (#3490) * Add nowarn annotation for long term deprecation (cherry picked from commit 5d53d3ea794b6e1bce5a5213aa44e45f3815a88d) --- .../scala/scalanative/testinterface/adapter/TestAdapter.scala | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test-runner/src/main/scala/scala/scalanative/testinterface/adapter/TestAdapter.scala b/test-runner/src/main/scala/scala/scalanative/testinterface/adapter/TestAdapter.scala index 602ae1aed8..1e96e22bbc 100644 --- a/test-runner/src/main/scala/scala/scalanative/testinterface/adapter/TestAdapter.scala +++ b/test-runner/src/main/scala/scala/scalanative/testinterface/adapter/TestAdapter.scala @@ -5,6 +5,7 @@ package scala.scalanative.testinterface.adapter import java.io.File import java.nio.file.Paths import sbt.testing.Framework +import scala.annotation.nowarn import scala.collection.concurrent.TrieMap import scala.concurrent._ import scala.scalanative.build.Logger @@ -102,7 +103,7 @@ final class TestAdapter(config: TestAdapter.Config) { } private[adapter] def getRunnerForThread(): ManagedRunner = { - val threadId = Thread.currentThread().getId + val threadId = Thread.currentThread().getId: @nowarn("cat=deprecation") // Note that this is thread safe, since each thread can only operate on // the value associated to its thread id. From e0d799d6562af80eca4f86ec621529fc52751375 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Wed, 20 Sep 2023 10:08:10 +0200 Subject: [PATCH 21/51] Allow to build Scala Native on JDK 21 (#3492) * `Thread.Builder.allowSetThreadLocals` didn't made it to stable release, and is only available in JDK 19-20 until --preview flag. Remove it's implementation and tests referencing this no longer existing API * Update CI to test against JDK 21 instead of JDK 20 with --enable-preview flags * Don't warn when accessing `Thread.getId()` which is deprecated in latest JDK versions * Add stubs for JDK 21 Sequential Collections to allow for linkling when using JDK 21+ * CI - Test JDK 21 only on Scala 2.13, compilation fails in Scala 3 (cherry picked from commit 4eb7261011dc38f9665c6b722c43c15961177d54) --- .../workflows/run-jdk-compliance-tests.yml | 12 ++- javalib/src/main/scala/java/util/Deque.scala | 2 +- .../main/scala/java/util/LinkedHashMap.scala | 3 +- .../main/scala/java/util/LinkedHashSet.scala | 2 +- javalib/src/main/scala/java/util/List.scala | 2 +- .../scala/java/util/SequencedCollection.scala | 27 +++++++ .../main/scala/java/util/SequencedMap.scala | 73 +++++++++++++++++++ .../main/scala/java/util/SequencedSet.scala | 9 +++ .../src/main/scala/java/util/SortedMap.scala | 2 +- .../src/main/scala/java/util/SortedSet.scala | 2 +- .../testinterface/adapter/TestAdapter.scala | 1 + 11 files changed, 126 insertions(+), 9 deletions(-) create mode 100644 javalib/src/main/scala/java/util/SequencedCollection.scala create mode 100644 javalib/src/main/scala/java/util/SequencedMap.scala create mode 100644 javalib/src/main/scala/java/util/SequencedSet.scala diff --git a/.github/workflows/run-jdk-compliance-tests.yml b/.github/workflows/run-jdk-compliance-tests.yml index 45bece0b4d..d900f5608e 100644 --- a/.github/workflows/run-jdk-compliance-tests.yml +++ b/.github/workflows/run-jdk-compliance-tests.yml @@ -20,14 +20,17 @@ jobs: fail-fast: false matrix: os: [ubuntu-20.04, macos-11] - scala: [3.3.0] + scala: [3.3.1] java: [11, 17] include: + # Does not compile with Scala 3 yet + - java: 21 + scala: 2.13.12 - java: 17 - scala: 2.13.11 + scala: 2.13.12 os: ubuntu-20.04 - java: 17 - scala: 2.12.17 + scala: 2.12.18 os: macos-11 steps: - uses: actions/checkout@v3 @@ -53,6 +56,9 @@ jobs: matrix: scala: [3.3.0] java: [11, 17] + # Does not compile with Scala 3 yet + - java: 21 + scala: 2.13.12 steps: # Disable autocrlf setting, otherwise scalalib patches might not be possible to apply - name: Setup git config diff --git a/javalib/src/main/scala/java/util/Deque.scala b/javalib/src/main/scala/java/util/Deque.scala index 74fdc02d5e..bf13ae5869 100644 --- a/javalib/src/main/scala/java/util/Deque.scala +++ b/javalib/src/main/scala/java/util/Deque.scala @@ -1,6 +1,6 @@ package java.util -trait Deque[E] extends Queue[E] { +trait Deque[E] extends Queue[E] with SequencedCollection[E] { def addFirst(e: E): Unit def addLast(e: E): Unit def offerFirst(e: E): Boolean diff --git a/javalib/src/main/scala/java/util/LinkedHashMap.scala b/javalib/src/main/scala/java/util/LinkedHashMap.scala index 97eab55e14..1861331a94 100644 --- a/javalib/src/main/scala/java/util/LinkedHashMap.scala +++ b/javalib/src/main/scala/java/util/LinkedHashMap.scala @@ -9,7 +9,8 @@ class LinkedHashMap[K, V]( initialCapacity: Int, loadFactor: Float, accessOrder: Boolean -) extends HashMap[K, V](initialCapacity, loadFactor) { +) extends HashMap[K, V](initialCapacity, loadFactor) + with SequencedMap[K, V] { self => import LinkedHashMap._ diff --git a/javalib/src/main/scala/java/util/LinkedHashSet.scala b/javalib/src/main/scala/java/util/LinkedHashSet.scala index 2603d4d1db..40e1eae230 100644 --- a/javalib/src/main/scala/java/util/LinkedHashSet.scala +++ b/javalib/src/main/scala/java/util/LinkedHashSet.scala @@ -4,7 +4,7 @@ import scala.collection.mutable class LinkedHashSet[E] extends HashSet[E] - with Set[E] + with SequencedSet[E] with Cloneable with Serializable { def this(initialCapacity: Int, loadFactor: Float) = diff --git a/javalib/src/main/scala/java/util/List.scala b/javalib/src/main/scala/java/util/List.scala index fc7ba3ff04..fca2982bc2 100644 --- a/javalib/src/main/scala/java/util/List.scala +++ b/javalib/src/main/scala/java/util/List.scala @@ -4,7 +4,7 @@ package java.util import java.util.function.UnaryOperator -trait List[E] extends Collection[E] { +trait List[E] extends SequencedCollection[E] { def replaceAll(operator: UnaryOperator[E]): Unit = { val iter = listIterator() while (iter.hasNext()) diff --git a/javalib/src/main/scala/java/util/SequencedCollection.scala b/javalib/src/main/scala/java/util/SequencedCollection.scala new file mode 100644 index 0000000000..2702ff2f96 --- /dev/null +++ b/javalib/src/main/scala/java/util/SequencedCollection.scala @@ -0,0 +1,27 @@ +package java.util + +trait SequencedCollection[E /* <: AnyRef */ ] extends Collection[E] { + /* Commented out until we're able to provide reversed views for collections + def reversed(): SequencedCollection[E] + + def addFirst(elem: E): Unit = throw new UnsupportedOperationException() + def addLast(elem: E): Unit = throw new UnsupportedOperationException() + + def getFirst(): E = this.iterator().next() + def getLast(): E = this.reversed().iterator().next() + + def removeFirst(): E = { + val it = this.iterator() + val elem = it.next() + it.remove() + elem + } + + def removeLast(): E = { + val it = this.reversed().iterator() + val elem = it.next() + it.remove() + elem + } + */ +} diff --git a/javalib/src/main/scala/java/util/SequencedMap.scala b/javalib/src/main/scala/java/util/SequencedMap.scala new file mode 100644 index 0000000000..95587d4827 --- /dev/null +++ b/javalib/src/main/scala/java/util/SequencedMap.scala @@ -0,0 +1,73 @@ +package java.util + +trait SequencedMap[K /* <: AnyRef */, V /* <: AnyRef */ ] extends Map[K, V] { + /* Commented out until we're able to provide reversed views for collections + def reversed(): SequencedMap[K, V] + + def firstEntry(): Map.Entry[K, V] = { + val it = entrySet().iterator() + if (it.hasNext()) SequencedMap.CopyOfEntry(it.next()) else null + } + + def lastEntry(): Map.Entry[K, V] = { + val it = reversed().entrySet().iterator() + if (it.hasNext()) SequencedMap.CopyOfEntry(it.next()) else null + } + + def pollFirstEntry(): Map.Entry[K, V] = { + val it = entrySet().iterator() + if (it.hasNext()) { + val entry = SequencedMap.CopyOfEntry(it.next()) + it.remove() + entry + } else null + } + + def pollLastEntry(): Map.Entry[K, V] = { + val it = this.reversed().entrySet().iterator() + if (it.hasNext()) { + val entry = SequencedMap.CopyOfEntry(it.next()) + it.remove() + entry + } else null + } + + def putFirst(key: K, value: V): V = throw new UnsupportedOperationException() + def putLast(key: K, value: V): V = throw new UnsupportedOperationException() + + def sequencedKeySet(): SequencedSet[K] = ??? + def sequencedValues(): SequencedCollection[V] = ??? + def sequencedEntrySet(): SequencedSet[Map.Entry[K, V]] = ??? +} + +private object SequencedMap { + private object CopyOfEntry { + def apply[K /* <: AnyRef */, V /* <: AnyRef */](entry: Map.Entry[K, V]) = { + Objects.requireNonNull(entry) + new CopyOfEntry( + key = entry.getKey(), + value = entry.getValue() + ) + } + } + private class CopyOfEntry[K /* <: AnyRef */, V /* <: AnyRef */] private (key: K, value: V) + extends Map.Entry[K, V] { + override def getKey(): K = key + override def getValue(): V = value + override def setValue(value: V): V = + throw new UnsupportedOperationException() + + override def equals(o: Any): Boolean = o match { + case entry: Map.Entry[K, V] @unchecked => + Objects.equals(key, entry.getKey()) && + Objects.equals(value, entry.getValue()) + case _ => false + } + override def hashCode(): Int = { + def hash(obj: Any) = if (obj == null) 0 else obj.## + hash(key) ^ hash(value) + } + override def toString(): String = s"$key=$value" + } + */ +} diff --git a/javalib/src/main/scala/java/util/SequencedSet.scala b/javalib/src/main/scala/java/util/SequencedSet.scala new file mode 100644 index 0000000000..fa1010f1ed --- /dev/null +++ b/javalib/src/main/scala/java/util/SequencedSet.scala @@ -0,0 +1,9 @@ +package java.util + +trait SequencedSet[E /* <: AnyRef */ ] + extends SequencedCollection[E] + with Set[E] { + /* Commented out until we're able to provide reversed views for collections + override def reversed(): SequencedSet[E] + */ +} diff --git a/javalib/src/main/scala/java/util/SortedMap.scala b/javalib/src/main/scala/java/util/SortedMap.scala index d473ec27a3..d9958c866d 100644 --- a/javalib/src/main/scala/java/util/SortedMap.scala +++ b/javalib/src/main/scala/java/util/SortedMap.scala @@ -1,6 +1,6 @@ package java.util -trait SortedMap[K, V] extends Map[K, V] { +trait SortedMap[K, V] extends Map[K, V] with SequencedMap[K, V] { def firstKey(): K def comparator(): Comparator[_ >: K] def lastKey(): K diff --git a/javalib/src/main/scala/java/util/SortedSet.scala b/javalib/src/main/scala/java/util/SortedSet.scala index 8dc438f60c..d37be8eb75 100644 --- a/javalib/src/main/scala/java/util/SortedSet.scala +++ b/javalib/src/main/scala/java/util/SortedSet.scala @@ -1,6 +1,6 @@ package java.util -trait SortedSet[E] extends Set[E] { +trait SortedSet[E] extends Set[E] with SequencedSet[E] { def comparator(): Comparator[_ >: E] def subSet(fromElement: E, toElement: E): SortedSet[E] def headSet(toElement: E): SortedSet[E] diff --git a/test-runner/src/main/scala/scala/scalanative/testinterface/adapter/TestAdapter.scala b/test-runner/src/main/scala/scala/scalanative/testinterface/adapter/TestAdapter.scala index 1e96e22bbc..cb84efe745 100644 --- a/test-runner/src/main/scala/scala/scalanative/testinterface/adapter/TestAdapter.scala +++ b/test-runner/src/main/scala/scala/scalanative/testinterface/adapter/TestAdapter.scala @@ -11,6 +11,7 @@ import scala.concurrent._ import scala.scalanative.build.Logger import scala.scalanative.testinterface.NativeRunnerRPC import scala.scalanative.testinterface.common._ +import scala.annotation.nowarn final class TestAdapter(config: TestAdapter.Config) { From fe4f78ee37b22b15df769341be188cb6b7e642e3 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Wed, 20 Sep 2023 12:31:12 +0200 Subject: [PATCH 22/51] Fix JDK compliance job (cherry picked from commit 88e343880e7a1ffd89392537e57b67f830b3976d) --- .github/workflows/run-jdk-compliance-tests.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/run-jdk-compliance-tests.yml b/.github/workflows/run-jdk-compliance-tests.yml index d900f5608e..0a7ef296a7 100644 --- a/.github/workflows/run-jdk-compliance-tests.yml +++ b/.github/workflows/run-jdk-compliance-tests.yml @@ -7,7 +7,7 @@ on: - main - 0.4.x concurrency: - group: jdk-compliance-${{ github.head_ref }}-${{ github.event_name }} + group: jdk-compliance-${{ github.head_ref }}-${{ github.event_name }} cancel-in-progress: true jobs: @@ -57,6 +57,7 @@ jobs: scala: [3.3.0] java: [11, 17] # Does not compile with Scala 3 yet + include: - java: 21 scala: 2.13.12 steps: From 476157a3b3af02e50e5e6de5755a91d579fc4c84 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Fri, 22 Sep 2023 15:24:48 +0200 Subject: [PATCH 23/51] [skip-ci] Temporaly disable JDK compliance test for JDK 21 until it would be available in action/setup-java@v3 (cherry picked from commit 764d23d22d51638d2901b5d74bf81d5302b8ba9c) --- .github/workflows/run-jdk-compliance-tests.yml | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/.github/workflows/run-jdk-compliance-tests.yml b/.github/workflows/run-jdk-compliance-tests.yml index 0a7ef296a7..c69f894733 100644 --- a/.github/workflows/run-jdk-compliance-tests.yml +++ b/.github/workflows/run-jdk-compliance-tests.yml @@ -24,8 +24,9 @@ jobs: java: [11, 17] include: # Does not compile with Scala 3 yet - - java: 21 - scala: 2.13.12 + # - java: 21 + # scala: 2.13.12 + # os: ubuntu-20.04 - java: 17 scala: 2.13.12 os: ubuntu-20.04 @@ -57,9 +58,9 @@ jobs: scala: [3.3.0] java: [11, 17] # Does not compile with Scala 3 yet - include: - - java: 21 - scala: 2.13.12 + # include: + # - java: 21 + # scala: 2.13.12 steps: # Disable autocrlf setting, otherwise scalalib patches might not be possible to apply - name: Setup git config From 68939321f71afb0129aa36e6faa2203e2e55d60f Mon Sep 17 00:00:00 2001 From: kerr Date: Fri, 22 Sep 2023 21:26:16 +0800 Subject: [PATCH 24/51] Build: Update sbt to 1.9.6 (#3495) (cherry picked from commit 42841b8bdd87fc7829980ada41983aa5efd7661b) --- project/build.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/project/build.properties b/project/build.properties index 06969a3771..303541e505 100644 --- a/project/build.properties +++ b/project/build.properties @@ -1 +1 @@ -sbt.version = 1.9.4 +sbt.version = 1.9.6 From 977b7ef63d2b4b962c354acc2d810566d9c75e78 Mon Sep 17 00:00:00 2001 From: LeeTibbert Date: Fri, 22 Sep 2023 10:35:09 -0400 Subject: [PATCH 25/51] Build: fix SN publish-local-dev command (#3498) (cherry picked from commit 2fc7de885ae53dc064460ac7ee48e1c0eee05d2d) --- project/Commands.scala | 2 ++ 1 file changed, 2 insertions(+) diff --git a/project/Commands.scala b/project/Commands.scala index 1c1baee171..024e94835f 100644 --- a/project/Commands.scala +++ b/project/Commands.scala @@ -115,6 +115,8 @@ object Commands { Command.args(name, "") { case (state, args) => val version = args.headOption + .flatMap(MultiScalaProject.scalaVersions.get) + .orElse(state.getSetting(scalaVersion)) .getOrElse( "Used command needs explicit full Scala version as an argument" ) From 5a047d33c9c2f48980b00b208715b8134c88a6e3 Mon Sep 17 00:00:00 2001 From: LeeTibbert Date: Thu, 28 Sep 2023 10:19:44 +0200 Subject: [PATCH 26/51] Fix #3511: Scripted tests with better Java 21 support (#3512) (cherry picked from commit 1fa5e5c414fcfa707004a771e1c8bb88aac33a7c) --- project/ScalaVersions.scala | 10 ++++++++-- .../cross-version-compat/project/build.properties | 6 +++++- 2 files changed, 13 insertions(+), 3 deletions(-) diff --git a/project/ScalaVersions.scala b/project/ScalaVersions.scala index 79b93c7f77..019c61bd83 100644 --- a/project/ScalaVersions.scala +++ b/project/ScalaVersions.scala @@ -35,8 +35,14 @@ object ScalaVersions { val scala213: String = crossScala213.last val scala3: String = "3.1.3" - // minimum version - 1.5 is required for Scala 3 and 1.5.8 has log4j vulnerability fixed - val sbt10Version: String = "1.5.8" + // minimum version rationale: + // 1.5 is required for Scala 3 and + // 1.5.8 has log4j vulnerability fixed + // 1.9.0 is required in order to use Java >= 21 + // 1.9.4 fixes (Common Vulnerabilities and Exposures) CVE-2022-46751 + // 1.9.6 is current + + val sbt10Version: String = "1.9.6" val sbt10ScalaVersion: String = scala212 val libCrossScalaVersions: Seq[String] = diff --git a/scripted-tests/scala3/cross-version-compat/project/build.properties b/scripted-tests/scala3/cross-version-compat/project/build.properties index 4ff6415f22..aa1e50901f 100644 --- a/scripted-tests/scala3/cross-version-compat/project/build.properties +++ b/scripted-tests/scala3/cross-version-compat/project/build.properties @@ -1 +1,5 @@ -sbt.version=1.6.2 \ No newline at end of file +## By having nothing specified here, the sbt10Version from +## project/ScalaVersions.scala is used. That version is carefully chosen +## so that the sbt used itself uses Scala > 2.12.17. Scala 2.12.18 is minimum +## needed to allow working with Java 21. +# sbt.version=1.6.2 \ No newline at end of file From 125f39054cf01dae92b296ea1cb749c241aff1f4 Mon Sep 17 00:00:00 2001 From: Rikito Taniguchi Date: Thu, 28 Sep 2023 17:20:08 +0900 Subject: [PATCH 27/51] Add document build date to index (#3513) This commit adds a description when this ScalaNative doc is built. e.g. `Document built: Sep 28, 2023`. Using `|today|` substitutions by sphinx https://www.sphinx-doc.org/en/master/usage/restructuredtext/roles.html#substitutions (cherry picked from commit 80da979058fa3cbd00d723eb3b083dc4efcab298) --- docs/index.rst | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/index.rst b/docs/index.rst index 2a9291f9fd..c07d607ac3 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -2,7 +2,8 @@ Scala Native ============ -Version |release| +- Version: |release| +- Document built: |today| Scala Native is an optimizing ahead-of-time compiler and lightweight managed runtime designed specifically for Scala. It features: From 1336c3b95b91e2816799437a89d4c880fb471c28 Mon Sep 17 00:00:00 2001 From: LeeTibbert Date: Sun, 1 Oct 2023 11:16:15 -0400 Subject: [PATCH 28/51] Fix #3515: Build test-all command now publishes artifacts only once (#3516) (cherry picked from commit 2e82821456ce350f85a2017c1b1d76f4f92747ac) --- project/Commands.scala | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/project/Commands.scala b/project/Commands.scala index 024e94835f..56182891f2 100644 --- a/project/Commands.scala +++ b/project/Commands.scala @@ -21,8 +21,7 @@ object Commands { "test-tools" :: "test-mima" :: "test-runtime" :: - "test-scripted" :: - "publish-local-dev" :: _ + "test-scripted" :: _ // test-scripted will publish artifacts locally } lazy val testRuntime = projectVersionCommand("test-runtime") { From 5fc5162e4efcf14782a6bda277fdc769bebc926c Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Sun, 1 Oct 2023 17:25:29 +0200 Subject: [PATCH 29/51] Fix `Class.isAssignableFrom` for primitive types (#3510) * Ensure that scala.runtime primitive types are not objects in nir typesystem * Generate RTTI for non-object classes (scala.runtime primitive types). * Add unit tests for issue #3504 * Extended fixed ordering of generated RTTI.ids to optimize checks for Class.{isPrimitive, isArray} * Add scalafmt commit to ignored blame revs * Remove Scala 2.12 only test case (cherry picked from commit 2482c47540790bfc034168aac33e1b57926032da) --- .git-blame-ignore-revs | 1 + .../src/main/scala/java/lang/Class.scala | 38 ++++--------------- .../main/scala/scala/scalanative/nir/Rt.scala | 12 ++++++ .../nscplugin/NirDefinitions.scala | 1 + .../scalanative/nscplugin/NirGenStat.scala | 1 + .../nscplugin/NirDefinitions.scala | 1 + .../scalanative/nscplugin/NirGenStat.scala | 5 ++- .../scala/scalanative/codegen/Lower.scala | 1 + .../scala/scalanative/codegen/Metadata.scala | 32 +++++++++++++--- .../scala/scala/scalanative/IssuesTest.scala | 5 +++ .../testsuite/javalib/lang/ClassTest.scala | 19 ++++++++++ 11 files changed, 80 insertions(+), 36 deletions(-) diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs index 0869864918..ec61ed7897 100644 --- a/.git-blame-ignore-revs +++ b/.git-blame-ignore-revs @@ -1,2 +1,3 @@ #scalafmt 8456ecd6e3700f0c9b81616ae04ac80c4f4173dc +cf6d1a4de1e1a9386fc437119158dc7384b9a58e \ No newline at end of file diff --git a/nativelib/src/main/scala/java/lang/Class.scala b/nativelib/src/main/scala/java/lang/Class.scala index d14acb5d9e..43ea920c93 100644 --- a/nativelib/src/main/scala/java/lang/Class.scala +++ b/nativelib/src/main/scala/java/lang/Class.scala @@ -45,22 +45,16 @@ final class _Class[A] { else classOf[java.lang.Object] } - def getName(): String = - name + def getName(): String = name def getSimpleName(): String = getName().split('.').last.split('$').last - def isArray(): scala.Boolean = - is(classOf[BooleanArray]) || - is(classOf[CharArray]) || - is(classOf[ByteArray]) || - is(classOf[ShortArray]) || - is(classOf[IntArray]) || - is(classOf[LongArray]) || - is(classOf[FloatArray]) || - is(classOf[DoubleArray]) || - is(classOf[ObjectArray]) + // Based on fixed ordering in scala.scalanative.codegen.Metadata.initClassIdsAndRanges + def isInterface(): scala.Boolean = id < 0 + def isPrimitive(): scala.Boolean = id >= 0 && id <= 8 + // id == 9 => java.lang.Object + def isArray(): scala.Boolean = id >= 10 && id <= 19 def isAssignableFrom(that: Class[_]): scala.Boolean = is(that.asInstanceOf[_Class[_]], this) @@ -92,26 +86,10 @@ final class _Class[A] { } } - def isInterface(): scala.Boolean = - id < 0 - - def isPrimitive(): scala.Boolean = - is(classOf[PrimitiveBoolean]) || - is(classOf[PrimitiveChar]) || - is(classOf[PrimitiveByte]) || - is(classOf[PrimitiveShort]) || - is(classOf[PrimitiveInt]) || - is(classOf[PrimitiveLong]) || - is(classOf[PrimitiveFloat]) || - is(classOf[PrimitiveDouble]) || - is(classOf[PrimitiveUnit]) - @inline override def equals(other: Any): scala.Boolean = other match { - case other: _Class[_] => - this eq other - case _ => - false + case other: _Class[_] => this eq other + case _ => false } @inline override def hashCode: Int = diff --git a/nir/src/main/scala/scala/scalanative/nir/Rt.scala b/nir/src/main/scala/scala/scalanative/nir/Rt.scala index b0195c463c..40183f1d16 100644 --- a/nir/src/main/scala/scala/scalanative/nir/Rt.scala +++ b/nir/src/main/scala/scala/scalanative/nir/Rt.scala @@ -52,6 +52,18 @@ object Rt { val StringCountName = StringName member Sig.Field("count") val StringCachedHashCodeName = StringName member Sig.Field("cachedHashCode") + val PrimitiveTypes: Seq[Global.Top] = Seq( + "Byte", + "Short", + "Int", + "Long", + "Char", + "Float", + "Double", + "Boolean", + "Unit" + ).map(name => Global.Top(s"scala.scalanative.runtime.Primitive$name")) + val GenericArray = Ref(Global.Top("scala.scalanative.runtime.Array")) val arrayAlloc: Map[Sig, Global] = Seq( diff --git a/nscplugin/src/main/scala-2/scala/scalanative/nscplugin/NirDefinitions.scala b/nscplugin/src/main/scala-2/scala/scalanative/nscplugin/NirDefinitions.scala index 40a259307b..5ded2159ae 100644 --- a/nscplugin/src/main/scala-2/scala/scalanative/nscplugin/NirDefinitions.scala +++ b/nscplugin/src/main/scala-2/scala/scalanative/nscplugin/NirDefinitions.scala @@ -262,6 +262,7 @@ trait NirDefinitions { 'D' -> getRequiredClass("scala.scalanative.runtime.PrimitiveDouble"), 'U' -> getRequiredClass("scala.scalanative.runtime.PrimitiveUnit") ) + lazy val RuntimePrimitiveTypes: Set[Symbol] = RuntimePrimitive.values.toSet lazy val RuntimeArrayClass: Map[Char, Symbol] = Map( 'B' -> getRequiredClass("scala.scalanative.runtime.BooleanArray"), diff --git a/nscplugin/src/main/scala-2/scala/scalanative/nscplugin/NirGenStat.scala b/nscplugin/src/main/scala-2/scala/scalanative/nscplugin/NirGenStat.scala index 330c231fab..de10fc7936 100644 --- a/nscplugin/src/main/scala-2/scala/scalanative/nscplugin/NirGenStat.scala +++ b/nscplugin/src/main/scala-2/scala/scalanative/nscplugin/NirGenStat.scala @@ -143,6 +143,7 @@ trait NirGenStat[G <: nsc.Global with Singleton] { self: NirGenPhase[G] => } if (sym == NObjectClass) None + else if (RuntimePrimitiveTypes.contains(sym)) None else if (sym.superClass == NoSymbol || sym.superClass == ObjectClass) Some(genTypeName(NObjectClass)) else diff --git a/nscplugin/src/main/scala-3/scala/scalanative/nscplugin/NirDefinitions.scala b/nscplugin/src/main/scala-3/scala/scalanative/nscplugin/NirDefinitions.scala index 4e85fcadfa..35ba7729e4 100644 --- a/nscplugin/src/main/scala-3/scala/scalanative/nscplugin/NirDefinitions.scala +++ b/nscplugin/src/main/scala-3/scala/scalanative/nscplugin/NirDefinitions.scala @@ -267,6 +267,7 @@ final class NirDefinitions()(using ctx: Context) { 'D' -> requiredClass("scala.scalanative.runtime.PrimitiveDouble"), 'U' -> requiredClass("scala.scalanative.runtime.PrimitiveUnit") ) + @tu lazy val RuntimePrimitiveTypes: Set[Symbol] = RuntimePrimitive.values.toSet @tu lazy val RuntimeArrayClass: Map[Char, Symbol] = Map( 'B' -> requiredClass("scala.scalanative.runtime.BooleanArray"), diff --git a/nscplugin/src/main/scala-3/scala/scalanative/nscplugin/NirGenStat.scala b/nscplugin/src/main/scala-3/scala/scalanative/nscplugin/NirGenStat.scala index 72483efbdd..4ddc7502c0 100644 --- a/nscplugin/src/main/scala-3/scala/scalanative/nscplugin/NirGenStat.scala +++ b/nscplugin/src/main/scala-3/scala/scalanative/nscplugin/NirGenStat.scala @@ -84,7 +84,10 @@ trait NirGenStat(using Context) { if sym.isExternType && sym.superClass != defn.ObjectClass then report.error("Extern object can only extend extern traits", sym.sourcePos) - Option.unless(sym == defnNir.NObjectClass) { + Option.unless( + sym == defnNir.NObjectClass || + defnNir.RuntimePrimitiveTypes.contains(sym) + ) { val superClass = sym.superClass if superClass == NoSymbol || superClass == defn.ObjectClass then genTypeName(defnNir.NObjectClass) diff --git a/tools/src/main/scala/scala/scalanative/codegen/Lower.scala b/tools/src/main/scala/scala/scalanative/codegen/Lower.scala index b00975627a..46084f463b 100644 --- a/tools/src/main/scala/scala/scalanative/codegen/Lower.scala +++ b/tools/src/main/scala/scala/scalanative/codegen/Lower.scala @@ -1498,6 +1498,7 @@ object Lower { val depends: Seq[Global] = { val buf = mutable.UnrolledBuffer.empty[Global] + buf ++= Rt.PrimitiveTypes buf += Rt.ClassName buf += Rt.ClassIdName buf += Rt.ClassTraitIdName diff --git a/tools/src/main/scala/scala/scalanative/codegen/Metadata.scala b/tools/src/main/scala/scala/scalanative/codegen/Metadata.scala index 9825ce4471..2906f893c9 100644 --- a/tools/src/main/scala/scala/scalanative/codegen/Metadata.scala +++ b/tools/src/main/scala/scala/scalanative/codegen/Metadata.scala @@ -44,19 +44,41 @@ class Metadata(val linked: linker.Result, proxies: Seq[Defn])(implicit val out = mutable.UnrolledBuffer.empty[Class] var id = 0 - def loop(node: Class): Unit = { + def loop( + node: Class, + topLevelSubclassOrdering: Array[Class] => Array[Class] + ): Unit = { out += node val start = id id += 1 - val directSubclasses = - node.subclasses.filter(_.parent == Some(node)).toArray - directSubclasses.sortBy(_.name.show).foreach { subcls => loop(subcls) } + topLevelSubclassOrdering( + node.subclasses + .filter(_.parent.contains(node)) + .toArray + ).foreach(loop(_, identity)) val end = id - 1 ids(node) = start ranges(node) = start to end } - loop(linked.infos(Rt.Object.name).asInstanceOf[Class]) + def fromRootClass( + symbol: nir.Global.Top, + ordering: Array[Class] => Array[Class] = identity + ) = + loop( + node = linked.infos(symbol).asInstanceOf[Class], + topLevelSubclassOrdering = ordering + ) + + Rt.PrimitiveTypes.foreach(fromRootClass(_)) + fromRootClass( + Rt.Object.name, + ordering = subclasses => { + val (arrays, other) = + subclasses.partition(_.name == Rt.GenericArray.name) + arrays ++ other + } + ) out.toSeq } diff --git a/unit-tests/native/src/test/scala/scala/scalanative/IssuesTest.scala b/unit-tests/native/src/test/scala/scala/scalanative/IssuesTest.scala index 37dd2e752a..7cfc23e820 100644 --- a/unit-tests/native/src/test/scala/scala/scalanative/IssuesTest.scala +++ b/unit-tests/native/src/test/scala/scala/scalanative/IssuesTest.scala @@ -625,6 +625,11 @@ class IssuesTest { println(!ptr2) // segfault } + @Test def issue3504(): Unit = { + val xs: Array[Int] = (0 to 300).toArray + assertNotNull(xs.sortBy(i => -i)) + } + } package issue1090 { diff --git a/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/lang/ClassTest.scala b/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/lang/ClassTest.scala index 922287f83c..39b73d3d4f 100644 --- a/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/lang/ClassTest.scala +++ b/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/lang/ClassTest.scala @@ -134,6 +134,25 @@ class ClassTest { assertTrue(classOf[Z].isAssignableFrom(classOf[Z])) } + @Test def isAssignableFrom2(): Unit = { + assertFalse(classOf[Any].isAssignableFrom(classOf[scala.Byte])) + assertFalse(classOf[Any].isAssignableFrom(classOf[scala.Short])) + assertFalse(classOf[Any].isAssignableFrom(classOf[scala.Int])) + assertFalse(classOf[Any].isAssignableFrom(classOf[scala.Long])) + assertFalse(classOf[Any].isAssignableFrom(classOf[scala.Float])) + assertFalse(classOf[Any].isAssignableFrom(classOf[scala.Double])) + assertFalse(classOf[Any].isAssignableFrom(classOf[scala.Unit])) + assertFalse(classOf[Any].isAssignableFrom(classOf[scala.Boolean])) + assertTrue(classOf[Any].isAssignableFrom(classOf[String])) + assertTrue(classOf[Any].isAssignableFrom(classOf[java.lang.Byte])) + assertTrue(classOf[Any].isAssignableFrom(classOf[java.lang.Short])) + assertTrue(classOf[Any].isAssignableFrom(classOf[java.lang.Integer])) + assertTrue(classOf[Any].isAssignableFrom(classOf[java.lang.Long])) + assertTrue(classOf[Any].isAssignableFrom(classOf[java.lang.Float])) + assertTrue(classOf[Any].isAssignableFrom(classOf[java.lang.Double])) + assertTrue(classOf[Any].isAssignableFrom(classOf[java.lang.Boolean])) + } + @Test def testToString(): Unit = { assertTrue(classOf[java.lang.Class[_]].toString == "class java.lang.Class") assertTrue( From 312600cd3d136367b3a8f39894da7249f50dba8c Mon Sep 17 00:00:00 2001 From: Rikito Taniguchi Date: Tue, 3 Oct 2023 00:49:32 +0200 Subject: [PATCH 30/51] Add contributing quickstart guide (#3496) * Add contributing quickstart guide * Add URL to sbt publish from "publish locally" * Update quick start guide * Remove specific version for LLVM and sbt * Mention MyScalaNativePlugin and scriptedBufferLog * Add built date to quickstart guide (cherry picked from commit 999df0d200164722fb23f37872fd0940253bfeda) --- docs/contrib/build.rst | 97 +------------------------- docs/contrib/ides.rst | 51 ++++++++++++-- docs/contrib/index.rst | 1 + docs/contrib/quickstart.rst | 134 ++++++++++++++++++++++++++++++++++++ 4 files changed, 184 insertions(+), 99 deletions(-) create mode 100644 docs/contrib/quickstart.rst diff --git a/docs/contrib/build.rst b/docs/contrib/build.rst index ec97933f4b..15814dd0a5 100644 --- a/docs/contrib/build.rst +++ b/docs/contrib/build.rst @@ -8,66 +8,8 @@ This section gives some basic information and tips about the build system. The components of Scala Native. The ``build.sbt`` file is at the root of the project along with the sub-projects that make up the system. -Common sbt commands -------------------- -Once you have cloned Scala Native from git, ``cd`` into the base directory and -run ``sbt`` to launch the sbt build. Inside the sbt shell, the most common -commands are the following: - -- ``sandbox/run`` -- run the main method of the `sandbox` project -- ``tests/test`` -- run the unit tests -- ``tools/test`` -- run the unit tests of the tools, aka the linker -- ``sbtScalaNative/scripted`` -- run the integration tests of the sbt plugin - (this takes a while) -- ``clean`` -- delete all generated sources, compiled artifacts, intermediate - products, and generally all build-produced files -- ``reload`` -- reload the build, to take into account changes to the sbt plugin - and its transitive dependencies - -If you want to run all the tests and benchmarks, which takes a while, you can -run the ``test-all`` command, ideally after ``reload`` and ``clean``. - -Normal development workflow ---------------------------- -Let us suppose that you wish to work on the ``javalib`` project to add some code -or fix a bug. Once you make a change to the code, run the following command -at the sbt prompt to compile the code and run the tests: - -.. code-block:: text - - > tests/test - -You can run only the test of interest by using one of the following commands: - -.. code-block:: text - - > tests/testOnly java.lang.StringSuite - > tests/testOnly *StringSuite - -Scripted tests are used when you need to interact with the file system, -networking, or the build system that cannot be done with a unit test. They -are located in the `scripted-tests` directory. - -Run all the scripted tests or just one test using the following examples respectively. -To run an individual test substitute the test to run for `native-code-include`: - -.. code-block:: text - - > sbtScalaNative/scripted - > sbtScalaNative/scripted run/native-code-include - -Some additional tips are as follows. - -- If you modify the ``nscplugin``, you will need to ``clean`` the project that - you want to rebuild with its new version (typically ``sandbox/clean`` or - ``tests/clean``). For a full rebuild, use the global ``clean`` command. - -- If you modify the sbt plugin or any of its transitive dependencies - (``sbt-scala-native``, ``nir``, ``util``, ``tools``, ``test-runner``), you - will need to ``reload`` for your changes to take effect with most test - commands (except with the ``scripted`` tests). - -- For a completely clean build, from scratch, run ``reload`` *and* ``clean``. +- ``project/Build.scala`` defines the sub-projects +- ``project/Commands.scala`` defines the custom commands such as ``test-all`` Build settings via environment variables -------------------------------------------------- @@ -134,22 +76,6 @@ The following shows how to set ``nativeGC`` on all the projects. The same process above will work for setting `nativeMode`. -Locally publish to test in other builds ---------------------------------------- -If you need to test your copy of Scala Native in the larger context of a -separate build, you will need to locally publish all the artifacts of Scala -Native. - -Use the custom sbt command to publish all projects for a specific Scala version (`x,y,z`): - -.. code-block:: text - - > publish-local-dev x.y.z - -Afterwards, set the version of `sbt-scala-native` in the target project's -`project/plugins.sbt` to the current SNAPSHOT version of Scala Native, and use -normally. - Organization of the build ------------------------- The build has roughly five groups of sub-projects as follows: @@ -260,25 +186,6 @@ if it's not the present script will try to use directory with corresponding Scal or it would try to use Scala epoch version or `overrides` directory. If none of these directories exists it will fail. It is also possible to define explicitly overrides directory to use by passing it as the third argument to the script. - -Locally publish docs ---------------------------------------- -Follow the steps after cloning the `scalanative `_ repo and changing to `scala-native` directory. - -1. First time building the docs. This command will setup & build the docs. - -.. code-block:: text - - $ bash scripts/makedocs setup - -2. If setup is already done. This command will only build the docs assuming setup is already done. - -.. code-block:: text - - $ bash scripts/makedocs - -3. Navigate to ``docs/_build/html`` directory and open ``index.html`` file in your browser. - The next section has more build and development information for those wanting to work on :ref:`compiler`. diff --git a/docs/contrib/ides.rst b/docs/contrib/ides.rst index be913c2729..6231e5db9d 100644 --- a/docs/contrib/ides.rst +++ b/docs/contrib/ides.rst @@ -1,7 +1,17 @@ .. _ides: +IDE setup +========= + +Metals +------ +Metals import should work out of the box for most of the modules, it's the recommended IDE. +To speed up indexing and prevent Bloop-related issues by default we export only 1 version of ``MultiScalaProject``, otherwise it would need to cross-compile sources for all binary Scala versions on each source-change. +By default IDE would target Scala 3 projects, to change this behavior modify ``project/MyScalaNativePlugin.scala`` and modify ``ideScalaVersion``. This change would be only required when developing Scala 2 compiler plugins, sbt plugins or Scala 2 specific sources. + + IntelliJ IDEA -============= +------------- * Select "Create project from existing sources" and choose the ``build.sbt`` file. When prompted, select "Open as project". Make sure you select the "Use sbt shell" for both import and build. @@ -13,6 +23,39 @@ IntelliJ IDEA The above is not an exhaustive list, but it is the bare minimum to have the build working. Please keep in mind that you will have to repeat the above steps, in case you reload (re-import) the SBT build. This will need to happen if you change some SBT-related file (e.g. ``build.sbt``). -Metals -====== -Metals import should work out of the box for most of the modules. +Setup for clangd +---------------- + +`clangd` is a Language Server Protocol (LSP) for C and C++. Your IDE of choice can connect to `clangd` to help development using C and C++. + +* VSCode: Add the `clangd` extension from LLVM. Full documentation for `clangd` is `here `_. You can also add the C/C++ extensions + from Microsoft if desired for highlighting and other features. + +A `compile_flags.txt` is needed to get the best setup to work on `nativelib` and the Garbage Collectors. Since we use conditional compilation for +garbage collection selection and the code is in a `gc` directory we need an include for the header relative paths and defines for the different garbage +collectors we have in the project. `clangd` works well as a default but only has defines for your platform and can only work out of the box for +certain simple setups which is probably fine for most other projects. The following is an example file that should be put in the +`nativelib/src/main/resources/scala-native` directory. Change the first include path for your platform. + +.. code-block:: text + + # GC setup + # Boehm header include path on mac arm + -I + /opt/homebrew/include + # GC include path to allow relative paths from gc as the root path + -I + gc/ + # Defines for the garbage collectors which are used for GC selection + -DSCALANATIVE_GC_BOEHM + -DSCALANATIVE_GC_IMMIX + -DSCALANATIVE_GC_COMMIX + -DSCALANATIVE_GC_NONE + -DSCALANATIVE_GC_EXPERIMENTAL + # Other defines to allow analysis of code + -DSCALANATIVE_MULTITHREADING_ENABLED + -DENABLE_GC_STATS + -DENABLE_GC_STATS_SYNC + -DDEBUG_PRINT + -DDEBUG_ASSERT + # end GC diff --git a/docs/contrib/index.rst b/docs/contrib/index.rst index c4f1258c47..48c53e7389 100644 --- a/docs/contrib/index.rst +++ b/docs/contrib/index.rst @@ -6,6 +6,7 @@ Contributor's Guide .. toctree:: :maxdepth: 2 + quickstart contributing build compiler diff --git a/docs/contrib/quickstart.rst b/docs/contrib/quickstart.rst new file mode 100644 index 0000000000..113b8095d4 --- /dev/null +++ b/docs/contrib/quickstart.rst @@ -0,0 +1,134 @@ +.. _quickstart: + +Quick Start Guide +================= + +Document built: |today| + +Requirements +------------ + +- Java 8 or newer +- LLVM/Clang 15 or newer +- sbt + +Project Structure Overview +-------------------------- + +See :ref:`build` + +Project suffix +-------------- + +Most projects in ScalaNative cross-build against Scala ``2.12``, ``2.13`` and ``3``, and these projects have a suffix like ``2_12``, ``2_13`` or ``3`` to differentiate the Scala version. +For example, ``sandbox`` has ``sandbox2_12``, ``sandbox2_13`` and ``sandbox3``. + +In the following we will use suffix ``3``, but remember that you can build and test for different versions using different suffixes. + +Build / Manual Testing on Sandbox +--------------------------------- + +``sandbox3/run`` to compile, link and run the main method of the sandbox project defined in ``sandbox/src/main/scala/Test.scala``. + +It's convenient to run the ``sandbox`` project to verify the build works as expected. + +Test +---- + +**Common Test Commands** + +- ``tests3/test`` - run the unit tests for libraries on native build +- ``tests3/testOnly org.scalanative.testsuite.javalib.util.RandomTest`` - run only the test of interest +- ``tests3/testOnly *.RandomTest`` - run only the test of interest using wildcard +- ``testsExt3/test`` - run the unit tests on native build, this module contains tests that requires dummy javalib implementation defined in ``javalibExtDummies``. +- ``nirJVM3/test`` - run the unit tests for NIR +- ``toolsJVM3/test`` - run the unit tests of the tools: ScalaNative backend +- ``sbtScalaNative/scripted`` - run all `scripted tests `_ of the sbt plugin (this takes a while). +- ``sbtScalaNative/scripted `` - run specific scripted tests of the sbt plugin. e.g. ``sbtScalaNative/scripted run/backtrace`` + - Scripted tests are used when you need to interact with the file system, networking, or the build system that cannot be done with a unit test. + - ``set ThisBuild / scriptedBufferLog := false`` disables buffer log in scripted test and get more verbose output + +**Other Test Commands** + +- ``testsJVM3/test`` - run ``tests3/test`` on JVM +- ``testsExtJVM3/test`` - run ``testsExt3/test`` on JVM +- ``test-all`` - run all tests, ideally after ``reload`` and ``clean`` + +**Some additional tips** + +- If you modify the ``nscplugin``, you will need to ``clean`` the project that + you want to rebuild with its new version (typically ``sandbox/clean`` or + ``tests/clean``). For a full rebuild, use the global ``clean`` command. + +- If you modify the sbt plugin or any of its transitive dependencies + (``sbt-scala-native``, ``nir``, ``util``, ``tools``, ``test-runner``), you + will need to ``reload`` for your changes to take effect with most test + commands (except with the ``scripted`` tests). + +- For a completely clean build, from scratch, run ``reload`` *and* ``clean``. + +Formatting +---------- + +- ``./scripts/scalafmt`` - format all Scala codes +- ``./scripts/clangfmt`` - format all C/C++ codes + +`Publish Locally `_ +----------------------------------------------------------------------- + +``publish-local-dev x.y.z`` publishes the ScalaNative artifact and sbt plugin for specified scala version locally. +For example, ``publish-local-dev 3.3.1``, + +You will see, the log message like the following, which means you have successfully published locally for the version ``0.5.0-SNAPSHOT``. + +.. code-block:: text + + [info] published tools_native0.5.0-SNAPSHOT_3 to ... + [info] published ivy to ...tools_native0.5.0-SNAPSHOT_3/0.5.0-SNAPSHOT/ivys/ivy.xml + +Then you'll be able to use locally published version in other projects. + +.. code-block:: text + + # project/plugins.sbt + addSbtPlugin("org.scala-native" % "sbt-scala-native" % "0.5.0-SNAPSHOT") + + # build.sbt + scalaVersion := "3.3.1" # set to locally published version + enablePlugins(ScalaNativePlugin) + +Locally build docs +-------------------- + +1. First time building the docs. This command will setup & build the docs. + +.. code-block:: text + + $ bash scripts/makedocs setup + +2. If setup is already done. This command will only build the docs assuming setup is already done. + +.. code-block:: text + + $ bash scripts/makedocs + +3. Navigate to ``docs/_build/html`` directory and open ``index.html`` file in your browser. + +Configure Native Build +---------------------- + +To configure the native build in this project, you can edit ``project/MyScalaNativePlugin.scala`` instead of ``project/Build.scala``. + +``MyScalaNativePlugin`` is a custom sbt plugin that extends ``ScalaNativePlugin`` and overrides some of its settings for this project. + + +Further Information +------------------- + +- How to make a commit and PR :ref:`contributing` +- More detailed build setting explanation :ref:`build` +- Scala Native Internal + - :ref:`compiler` + - :ref:`nir` + - :ref:`name_mangling` +- How to setup IDEs :ref:`ides` \ No newline at end of file From 0250712bf06d0208b1dddb7c3d9292f485d72395 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Tue, 3 Oct 2023 08:33:33 +0200 Subject: [PATCH 31/51] Fix performance issue of `MappedByteBuffer`s (#3521) * Optimize `java.nio.ByteArrayBits` to not allocate intermidiete tuples * Hint inlining of ByteArrayBits * Add Character.reverseBytes implementaiton * Sync templates with code generated types in runtime.Arrays , unsafe.Size and unsigned.USize * Handle CFuncPtr.apply when inlined (cherry picked from commit adcad38bfee21fc82f7d2672129d9a02ffe64d2a) --- .../src/main/scala/java/lang/Character.scala | 6 +- .../main/scala/java/nio/ByteArrayBits.scala | 318 +++++------------- .../main/scala/java/nio/HeapByteBuffer.scala | 61 ++-- .../java/nio/HeapByteBufferCharView.scala | 5 +- .../java/nio/HeapByteBufferDoubleView.scala | 5 +- .../java/nio/HeapByteBufferFloatView.scala | 5 +- .../java/nio/HeapByteBufferIntView.scala | 5 +- .../java/nio/HeapByteBufferLongView.scala | 5 +- .../java/nio/HeapByteBufferShortView.scala | 5 +- .../java/nio/MappedByteBufferCharView.scala | 5 +- .../java/nio/MappedByteBufferDoubleView.scala | 7 +- .../java/nio/MappedByteBufferFloatView.scala | 5 +- .../scala/java/nio/MappedByteBufferImpl.scala | 61 ++-- .../java/nio/MappedByteBufferIntView.scala | 5 +- .../java/nio/MappedByteBufferLongView.scala | 5 +- .../java/nio/MappedByteBufferShortView.scala | 5 +- .../scalanative/runtime/Arrays.scala.gyb | 6 +- .../nscplugin/NirDefinitions.scala | 1 + .../nscplugin/NirDefinitions.scala | 12 +- 19 files changed, 215 insertions(+), 312 deletions(-) diff --git a/javalib/src/main/scala/java/lang/Character.scala b/javalib/src/main/scala/java/lang/Character.scala index fb5937212c..17cef56d85 100644 --- a/javalib/src/main/scala/java/lang/Character.scala +++ b/javalib/src/main/scala/java/lang/Character.scala @@ -2,6 +2,7 @@ package java.lang import java.util.Arrays import java.lang.constant.Constable +import scala.scalanative.runtime.LLVMIntrinsics class Character(val _value: scala.Char) extends _Object @@ -2633,11 +2634,14 @@ object Character { null } } + + def reverseBytes(ch: scala.Char): scala.Char = + LLVMIntrinsics.`llvm.bswap.i16`(ch.toShort).toChar + // TODO: // def getDirectionality(c: scala.Char): scala.Byte // def toTitleCase(c: scala.Char): scala.Char // def getNumericValue(c: scala.Char): Int - // def reverseBytes(ch: scala.Char): scala.Char // ... } diff --git a/javalib/src/main/scala/java/nio/ByteArrayBits.scala b/javalib/src/main/scala/java/nio/ByteArrayBits.scala index f9ceec2473..26014f60ac 100644 --- a/javalib/src/main/scala/java/nio/ByteArrayBits.scala +++ b/javalib/src/main/scala/java/nio/ByteArrayBits.scala @@ -1,8 +1,9 @@ package java.nio -import scala.scalanative.unsafe.Ptr +import scala.scalanative.runtime.{Intrinsics, toRawPtr} +import scala.scalanative.runtime.Intrinsics.{elemRawPtr, castIntToRawSize} +import scala.scalanative.unsafe._ -// Ported from Scala.js private[nio] object ByteArrayBits { def apply( array: Ptr[Byte], @@ -21,249 +22,116 @@ private[nio] final class ByteArrayBits( indexMultiplier: Int ) { - /* We use tuples of bytes instead of, say, arrays, because they can be - * completely stack-allocated. - * - * When used in a place where it can be stack-allocated, an "instance" of - * this class has zero overhead. - */ - // API - def loadChar(index: Int): Char = makeChar(load2Bytes(index)) - def loadShort(index: Int): Short = makeShort(load2Bytes(index)) - def loadInt(index: Int): Int = makeInt(load4Bytes(index)) - def loadLong(index: Int): Long = makeLong(load8Bytes(index)) - def loadFloat(index: Int): Float = makeFloat(load4Bytes(index)) - def loadDouble(index: Int): Double = makeDouble(load8Bytes(index)) - - def storeChar(index: Int, v: Char): Unit = store2Bytes(index, unmakeChar(v)) - def storeShort(index: Int, v: Short): Unit = - store2Bytes(index, unmakeShort(v)) - def storeInt(index: Int, v: Int): Unit = store4Bytes(index, unmakeInt(v)) - def storeLong(index: Int, v: Long): Unit = store8Bytes(index, unmakeLong(v)) - def storeFloat(index: Int, v: Float): Unit = - store4Bytes(index, unmakeFloat(v)) - def storeDouble(index: Int, v: Double): Unit = - store8Bytes(index, unmakeDouble(v)) - - // Making and unmaking values - - @inline - private def makeChar(bs: (Byte, Byte)): Char = - makeChar(bs._1, bs._2) - - @inline - private def makeChar(b0: Byte, b1: Byte): Char = - if (isBigEndian) makeCharBE(b0, b1) - else makeCharBE(b1, b0) - - @inline - private def makeCharBE(b0: Byte, b1: Byte): Char = - ((b0 << 8) | (b1 & 0xff)).toChar - - @inline - private def makeShort(bs: (Byte, Byte)): Short = - makeShort(bs._1, bs._2) - - @inline - private def makeShort(b0: Byte, b1: Byte): Short = - if (isBigEndian) makeShortBE(b0, b1) - else makeShortBE(b1, b0) - - @inline - private def makeShortBE(b0: Byte, b1: Byte): Short = - ((b0 << 8) | (b1 & 0xff)).toShort - - @inline - private def makeInt(bs: (Byte, Byte, Byte, Byte)): Int = - makeInt(bs._1, bs._2, bs._3, bs._4) - - @inline - private def makeInt(b0: Byte, b1: Byte, b2: Byte, b3: Byte): Int = - if (isBigEndian) makeIntBE(b0, b1, b2, b3) - else makeIntBE(b3, b2, b1, b0) - - @inline - private def makeIntBE(b0: Byte, b1: Byte, b2: Byte, b3: Byte): Int = - ((b0 << 24) | ((b1 & 0xff) << 16) | ((b2 & 0xff) << 8) | (b3 & 0xff)) - - @inline - private def makeLong( - bs: (Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte) - ): Long = - makeLong(bs._1, bs._2, bs._3, bs._4, bs._5, bs._6, bs._7, bs._8) - - @inline - private def makeLong( - b0: Byte, - b1: Byte, - b2: Byte, - b3: Byte, - b4: Byte, - b5: Byte, - b6: Byte, - b7: Byte - ): Long = - if (isBigEndian) makeLongBE(b0, b1, b2, b3, b4, b5, b6, b7) - else makeLongBE(b7, b6, b5, b4, b3, b2, b1, b0) - - @inline - private def makeLongBE( - b0: Byte, - b1: Byte, - b2: Byte, - b3: Byte, - b4: Byte, - b5: Byte, - b6: Byte, - b7: Byte - ): Long = { - (makeIntBE(b0, b1, b2, b3).toLong << 32) | - (makeIntBE(b4, b5, b6, b7).toLong & 0xffffffffL) + def loadChar(index: Int): Char = { + val idx = indexMultiplier * index + arrayOffset + val loaded = + Intrinsics.loadChar(elemRawPtr(toRawPtr(array), castIntToRawSize(idx))) + if (isBigEndian) java.lang.Character.reverseBytes(loaded) + else loaded } - - @inline - private def makeFloat(bs: (Byte, Byte, Byte, Byte)): Float = - makeFloat(bs._1, bs._2, bs._3, bs._4) - - @inline - private def makeFloat(b0: Byte, b1: Byte, b2: Byte, b3: Byte): Float = - java.lang.Float.intBitsToFloat(makeInt(b0, b1, b2, b3)) - - @inline - private def makeDouble( - bs: (Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte) - ): Double = - makeDouble(bs._1, bs._2, bs._3, bs._4, bs._5, bs._6, bs._7, bs._8) - - @inline - private def makeDouble( - b0: Byte, - b1: Byte, - b2: Byte, - b3: Byte, - b4: Byte, - b5: Byte, - b6: Byte, - b7: Byte - ): Double = - java.lang.Double.longBitsToDouble(makeLong(b0, b1, b2, b3, b4, b5, b6, b7)) - - @inline - private def unmakeChar(c: Char): (Byte, Byte) = { - val bs = unmakeCharBE(c) - if (isBigEndian) bs - else (bs._2, bs._1) + def loadShort(index: Int): Short = { + val idx = indexMultiplier * index + arrayOffset + val loaded = + Intrinsics.loadShort(elemRawPtr(toRawPtr(array), castIntToRawSize(idx))) + if (isBigEndian) java.lang.Short.reverseBytes(loaded) + else loaded } - - @inline - private def unmakeCharBE(c: Char): (Byte, Byte) = - ((c >> 8).toByte, c.toByte) - - @inline - private def unmakeShort(s: Short): (Byte, Byte) = { - val bs = unmakeShortBE(s) - if (isBigEndian) bs - else (bs._2, bs._1) + def loadInt(index: Int): Int = { + val idx = indexMultiplier * index + arrayOffset + val loaded = + Intrinsics.loadInt(elemRawPtr(toRawPtr(array), castIntToRawSize(idx))) + if (isBigEndian) java.lang.Integer.reverseBytes(loaded) + else loaded } - - @inline - private def unmakeShortBE(s: Short): (Byte, Byte) = - ((s >> 8).toByte, s.toByte) - - @inline - private def unmakeInt(i: Int): (Byte, Byte, Byte, Byte) = { - val bs = unmakeIntBE(i) - if (isBigEndian) bs - else (bs._4, bs._3, bs._2, bs._1) + def loadLong(index: Int): Long = { + val idx = indexMultiplier * index + arrayOffset + val loaded = + Intrinsics.loadLong(elemRawPtr(toRawPtr(array), castIntToRawSize(idx))) + if (isBigEndian) java.lang.Long.reverseBytes(loaded) + else loaded } - - @inline - private def unmakeIntBE(i: Int): (Byte, Byte, Byte, Byte) = - ((i >> 24).toByte, (i >> 16).toByte, (i >> 8).toByte, i.toByte) - - @inline - private def unmakeLong( - l: Long - ): (Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte) = { - val bs0 = unmakeIntBE((l >>> 32).toInt) - val bs1 = unmakeIntBE(l.toInt) - if (isBigEndian) - (bs0._1, bs0._2, bs0._3, bs0._4, bs1._1, bs1._2, bs1._3, bs1._4) - else (bs1._4, bs1._3, bs1._2, bs1._1, bs0._4, bs0._3, bs0._2, bs0._1) + def loadFloat(index: Int): Float = { + val idx = indexMultiplier * index + arrayOffset + val loaded = + Intrinsics.loadInt(elemRawPtr(toRawPtr(array), castIntToRawSize(idx))) + val ordered = + if (isBigEndian) java.lang.Integer.reverseBytes(loaded) + else loaded + java.lang.Float.intBitsToFloat(ordered) } - - @inline - private def unmakeFloat(f: Float): (Byte, Byte, Byte, Byte) = - unmakeInt(java.lang.Float.floatToIntBits(f)) - - @inline - private def unmakeDouble( - d: Double - ): (Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte) = - unmakeLong(java.lang.Double.doubleToLongBits(d)) - - // Loading and storing bytes - - @inline - private def load2Bytes(index: Int): (Byte, Byte) = { + def loadDouble(index: Int): Double = { val idx = indexMultiplier * index + arrayOffset - (array(idx), array(idx + 1)) + val loaded = + Intrinsics.loadLong(elemRawPtr(toRawPtr(array), castIntToRawSize(idx))) + val ordered = + if (isBigEndian) java.lang.Long.reverseBytes(loaded) + else loaded + java.lang.Double.longBitsToDouble(ordered) } - @inline - private def load4Bytes(index: Int): (Byte, Byte, Byte, Byte) = { + def storeChar(index: Int, v: Char): Unit = { val idx = indexMultiplier * index + arrayOffset - (array(idx), array(idx + 1), array(idx + 2), array(idx + 3)) + val ordered = + if (isBigEndian) java.lang.Character.reverseBytes(v) + else v + Intrinsics.storeChar( + elemRawPtr(toRawPtr(array), castIntToRawSize(idx)), + ordered + ) } - @inline - private def load8Bytes( - index: Int - ): (Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte) = { + def storeShort(index: Int, v: Short): Unit = { val idx = indexMultiplier * index + arrayOffset - ( - array(idx), - array(idx + 1), - array(idx + 2), - array(idx + 3), - array(idx + 4), - array(idx + 5), - array(idx + 6), - array(idx + 7) + val ordered = + if (isBigEndian) java.lang.Short.reverseBytes(v) + else v + Intrinsics.storeShort( + elemRawPtr(toRawPtr(array), castIntToRawSize(idx)), + ordered ) } - - @inline - private def store2Bytes(index: Int, bs: (Byte, Byte)): Unit = { + def storeInt(index: Int, v: Int): Unit = { val idx = indexMultiplier * index + arrayOffset - array(idx) = bs._1 - array(idx + 1) = bs._2 + val ordered = + if (isBigEndian) java.lang.Integer.reverseBytes(v) + else v + Intrinsics.storeInt( + elemRawPtr(toRawPtr(array), castIntToRawSize(idx)), + ordered + ) } - - @inline - private def store4Bytes(index: Int, bs: (Byte, Byte, Byte, Byte)): Unit = { + def storeLong(index: Int, v: Long): Unit = { val idx = indexMultiplier * index + arrayOffset - array(idx) = bs._1 - array(idx + 1) = bs._2 - array(idx + 2) = bs._3 - array(idx + 3) = bs._4 + val ordered = + if (isBigEndian) java.lang.Long.reverseBytes(v) + else v + Intrinsics.storeLong( + elemRawPtr(toRawPtr(array), castIntToRawSize(idx)), + ordered + ) } - - @inline - private def store8Bytes( - index: Int, - bs: (Byte, Byte, Byte, Byte, Byte, Byte, Byte, Byte) - ): Unit = { + def storeFloat(index: Int, v: Float): Unit = { val idx = indexMultiplier * index + arrayOffset - array(idx) = bs._1 - array(idx + 1) = bs._2 - array(idx + 2) = bs._3 - array(idx + 3) = bs._4 - array(idx + 4) = bs._5 - array(idx + 5) = bs._6 - array(idx + 6) = bs._7 - array(idx + 7) = bs._8 + val asInt = java.lang.Float.floatToIntBits(v) + val ordered = + if (isBigEndian) java.lang.Integer.reverseBytes(asInt) + else asInt + Intrinsics.storeInt( + elemRawPtr(toRawPtr(array), castIntToRawSize(idx)), + ordered + ) + } + def storeDouble(index: Int, v: Double): Unit = { + val idx = indexMultiplier * index + arrayOffset + val asLong = java.lang.Double.doubleToLongBits(v) + val ordered = + if (isBigEndian) java.lang.Long.reverseBytes(asLong) + else asLong + Intrinsics.storeLong( + elemRawPtr(toRawPtr(array), castIntToRawSize(idx)), + ordered + ) } } diff --git a/javalib/src/main/scala/java/nio/HeapByteBuffer.scala b/javalib/src/main/scala/java/nio/HeapByteBuffer.scala index c610a9cb4b..d3a94f018f 100644 --- a/javalib/src/main/scala/java/nio/HeapByteBuffer.scala +++ b/javalib/src/main/scala/java/nio/HeapByteBuffer.scala @@ -68,7 +68,7 @@ private[nio] class HeapByteBuffer( // Here begins the stuff specific to ByteArrays - @inline private def arrayBits: ByteArrayBits = + @inline private def byteArrayBits: ByteArrayBits = ByteArrayBits( _array.at(0), _arrayOffset, @@ -76,15 +76,17 @@ private[nio] class HeapByteBuffer( ) @noinline def getChar(): Char = - arrayBits.loadChar(getPosAndAdvanceRead(2)) + byteArrayBits.loadChar(getPosAndAdvanceRead(2)) @noinline def putChar(value: Char): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeChar(getPosAndAdvanceWrite(2), value); + ensureNotReadOnly(); + byteArrayBits.storeChar(getPosAndAdvanceWrite(2), value); this } @noinline def getChar(index: Int): Char = - arrayBits.loadChar(validateIndex(index, 2)) + byteArrayBits.loadChar(validateIndex(index, 2)) @noinline def putChar(index: Int, value: Char): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeChar(validateIndex(index, 2), value); + ensureNotReadOnly(); + byteArrayBits.storeChar(validateIndex(index, 2), value); this } @@ -92,15 +94,17 @@ private[nio] class HeapByteBuffer( HeapByteBufferCharView.fromHeapByteBuffer(this) @noinline def getShort(): Short = - arrayBits.loadShort(getPosAndAdvanceRead(2)) + byteArrayBits.loadShort(getPosAndAdvanceRead(2)) @noinline def putShort(value: Short): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeShort(getPosAndAdvanceWrite(2), value); + ensureNotReadOnly(); + byteArrayBits.storeShort(getPosAndAdvanceWrite(2), value); this } @noinline def getShort(index: Int): Short = - arrayBits.loadShort(validateIndex(index, 2)) + byteArrayBits.loadShort(validateIndex(index, 2)) @noinline def putShort(index: Int, value: Short): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeShort(validateIndex(index, 2), value); + ensureNotReadOnly(); + byteArrayBits.storeShort(validateIndex(index, 2), value); this } @@ -108,15 +112,16 @@ private[nio] class HeapByteBuffer( HeapByteBufferShortView.fromHeapByteBuffer(this) @noinline def getInt(): Int = - arrayBits.loadInt(getPosAndAdvanceRead(4)) + byteArrayBits.loadInt(getPosAndAdvanceRead(4)) @noinline def putInt(value: Int): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeInt(getPosAndAdvanceWrite(4), value); + ensureNotReadOnly(); + byteArrayBits.storeInt(getPosAndAdvanceWrite(4), value); this } @noinline def getInt(index: Int): Int = - arrayBits.loadInt(validateIndex(index, 4)) + byteArrayBits.loadInt(validateIndex(index, 4)) @noinline def putInt(index: Int, value: Int): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeInt(validateIndex(index, 4), value); + ensureNotReadOnly(); byteArrayBits.storeInt(validateIndex(index, 4), value); this } @@ -124,15 +129,17 @@ private[nio] class HeapByteBuffer( HeapByteBufferIntView.fromHeapByteBuffer(this) @noinline def getLong(): Long = - arrayBits.loadLong(getPosAndAdvanceRead(8)) + byteArrayBits.loadLong(getPosAndAdvanceRead(8)) @noinline def putLong(value: Long): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeLong(getPosAndAdvanceWrite(8), value); + ensureNotReadOnly(); + byteArrayBits.storeLong(getPosAndAdvanceWrite(8), value); this } @noinline def getLong(index: Int): Long = - arrayBits.loadLong(validateIndex(index, 8)) + byteArrayBits.loadLong(validateIndex(index, 8)) @noinline def putLong(index: Int, value: Long): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeLong(validateIndex(index, 8), value); + ensureNotReadOnly(); + byteArrayBits.storeLong(validateIndex(index, 8), value); this } @@ -140,15 +147,17 @@ private[nio] class HeapByteBuffer( HeapByteBufferLongView.fromHeapByteBuffer(this) @noinline def getFloat(): Float = - arrayBits.loadFloat(getPosAndAdvanceRead(4)) + byteArrayBits.loadFloat(getPosAndAdvanceRead(4)) @noinline def putFloat(value: Float): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeFloat(getPosAndAdvanceWrite(4), value); + ensureNotReadOnly(); + byteArrayBits.storeFloat(getPosAndAdvanceWrite(4), value); this } @noinline def getFloat(index: Int): Float = - arrayBits.loadFloat(validateIndex(index, 4)) + byteArrayBits.loadFloat(validateIndex(index, 4)) @noinline def putFloat(index: Int, value: Float): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeFloat(validateIndex(index, 4), value); + ensureNotReadOnly(); + byteArrayBits.storeFloat(validateIndex(index, 4), value); this } @@ -156,15 +165,17 @@ private[nio] class HeapByteBuffer( HeapByteBufferFloatView.fromHeapByteBuffer(this) @noinline def getDouble(): Double = - arrayBits.loadDouble(getPosAndAdvanceRead(8)) + byteArrayBits.loadDouble(getPosAndAdvanceRead(8)) @noinline def putDouble(value: Double): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeDouble(getPosAndAdvanceWrite(8), value); + ensureNotReadOnly(); + byteArrayBits.storeDouble(getPosAndAdvanceWrite(8), value); this } @noinline def getDouble(index: Int): Double = - arrayBits.loadDouble(validateIndex(index, 8)) + byteArrayBits.loadDouble(validateIndex(index, 8)) @noinline def putDouble(index: Int, value: Double): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeDouble(validateIndex(index, 8), value); + ensureNotReadOnly(); + byteArrayBits.storeDouble(validateIndex(index, 8), value); this } diff --git a/javalib/src/main/scala/java/nio/HeapByteBufferCharView.scala b/javalib/src/main/scala/java/nio/HeapByteBufferCharView.scala index 52edbaba38..3384b72330 100644 --- a/javalib/src/main/scala/java/nio/HeapByteBufferCharView.scala +++ b/javalib/src/main/scala/java/nio/HeapByteBufferCharView.scala @@ -16,6 +16,7 @@ private[nio] final class HeapByteBufferCharView private ( private def genBuffer = GenBuffer[CharBuffer](this) private def genHeapBufferView = GenHeapBufferView[CharBuffer](this) + @inline private def byteArrayBits = genHeapBufferView.byteArrayBits private implicit def newHeapBufferView : GenHeapBufferView.NewHeapBufferView[CharBuffer] = HeapByteBufferCharView.NewHeapByteBufferCharView @@ -86,11 +87,11 @@ private[nio] final class HeapByteBufferCharView private ( @inline private[nio] def load(index: Int): Char = - genHeapBufferView.byteArrayBits.loadChar(index) + byteArrayBits.loadChar(index) @inline private[nio] def store(index: Int, elem: Char): Unit = - genHeapBufferView.byteArrayBits.storeChar(index, elem) + byteArrayBits.storeChar(index, elem) } private[nio] object HeapByteBufferCharView { diff --git a/javalib/src/main/scala/java/nio/HeapByteBufferDoubleView.scala b/javalib/src/main/scala/java/nio/HeapByteBufferDoubleView.scala index a77dcfdcb3..836f675d97 100644 --- a/javalib/src/main/scala/java/nio/HeapByteBufferDoubleView.scala +++ b/javalib/src/main/scala/java/nio/HeapByteBufferDoubleView.scala @@ -16,6 +16,7 @@ private[nio] final class HeapByteBufferDoubleView private ( private def genBuffer = GenBuffer[DoubleBuffer](this) private def genHeapBufferView = GenHeapBufferView[DoubleBuffer](this) + @inline private def byteArrayBits = genHeapBufferView.byteArrayBits private implicit def newHeapBufferView : GenHeapBufferView.NewHeapBufferView[DoubleBuffer] = HeapByteBufferDoubleView.NewHeapByteBufferDoubleView @@ -72,11 +73,11 @@ private[nio] final class HeapByteBufferDoubleView private ( @inline private[nio] def load(index: Int): Double = - genHeapBufferView.byteArrayBits.loadDouble(index) + byteArrayBits.loadDouble(index) @inline private[nio] def store(index: Int, elem: Double): Unit = - genHeapBufferView.byteArrayBits.storeDouble(index, elem) + byteArrayBits.storeDouble(index, elem) } private[nio] object HeapByteBufferDoubleView { diff --git a/javalib/src/main/scala/java/nio/HeapByteBufferFloatView.scala b/javalib/src/main/scala/java/nio/HeapByteBufferFloatView.scala index 2e2183aea9..1a8ef3d952 100644 --- a/javalib/src/main/scala/java/nio/HeapByteBufferFloatView.scala +++ b/javalib/src/main/scala/java/nio/HeapByteBufferFloatView.scala @@ -16,6 +16,7 @@ private[nio] final class HeapByteBufferFloatView private ( private def genBuffer = GenBuffer[FloatBuffer](this) private def genHeapBufferView = GenHeapBufferView[FloatBuffer](this) + @inline private def byteArrayBits = genHeapBufferView.byteArrayBits private implicit def newHeapBufferView : GenHeapBufferView.NewHeapBufferView[FloatBuffer] = HeapByteBufferFloatView.NewHeapByteBufferFloatView @@ -72,11 +73,11 @@ private[nio] final class HeapByteBufferFloatView private ( @inline private[nio] def load(index: Int): Float = - genHeapBufferView.byteArrayBits.loadFloat(index) + byteArrayBits.loadFloat(index) @inline private[nio] def store(index: Int, elem: Float): Unit = - genHeapBufferView.byteArrayBits.storeFloat(index, elem) + byteArrayBits.storeFloat(index, elem) } private[nio] object HeapByteBufferFloatView { diff --git a/javalib/src/main/scala/java/nio/HeapByteBufferIntView.scala b/javalib/src/main/scala/java/nio/HeapByteBufferIntView.scala index 1c6ef1509a..c3362af32c 100644 --- a/javalib/src/main/scala/java/nio/HeapByteBufferIntView.scala +++ b/javalib/src/main/scala/java/nio/HeapByteBufferIntView.scala @@ -16,6 +16,7 @@ private[nio] final class HeapByteBufferIntView private ( private def genBuffer = GenBuffer[IntBuffer](this) private def genHeapBufferView = GenHeapBufferView[IntBuffer](this) + @inline private def byteArrayBits = genHeapBufferView.byteArrayBits private implicit def newHeapBufferView : GenHeapBufferView.NewHeapBufferView[IntBuffer] = HeapByteBufferIntView.NewHeapByteBufferIntView @@ -72,11 +73,11 @@ private[nio] final class HeapByteBufferIntView private ( @inline private[nio] def load(index: Int): Int = - genHeapBufferView.byteArrayBits.loadInt(index) + byteArrayBits.loadInt(index) @inline private[nio] def store(index: Int, elem: Int): Unit = - genHeapBufferView.byteArrayBits.storeInt(index, elem) + byteArrayBits.storeInt(index, elem) } private[nio] object HeapByteBufferIntView { diff --git a/javalib/src/main/scala/java/nio/HeapByteBufferLongView.scala b/javalib/src/main/scala/java/nio/HeapByteBufferLongView.scala index f599711905..e18a5346a7 100644 --- a/javalib/src/main/scala/java/nio/HeapByteBufferLongView.scala +++ b/javalib/src/main/scala/java/nio/HeapByteBufferLongView.scala @@ -16,6 +16,7 @@ private[nio] final class HeapByteBufferLongView private ( private def genBuffer = GenBuffer[LongBuffer](this) private def genHeapBufferView = GenHeapBufferView[LongBuffer](this) + @inline private def byteArrayBits = genHeapBufferView.byteArrayBits private implicit def newHeapBufferView : GenHeapBufferView.NewHeapBufferView[LongBuffer] = HeapByteBufferLongView.NewHeapByteBufferLongView @@ -72,11 +73,11 @@ private[nio] final class HeapByteBufferLongView private ( @inline private[nio] def load(index: Int): Long = - genHeapBufferView.byteArrayBits.loadLong(index) + byteArrayBits.loadLong(index) @inline private[nio] def store(index: Int, elem: Long): Unit = - genHeapBufferView.byteArrayBits.storeLong(index, elem) + byteArrayBits.storeLong(index, elem) } private[nio] object HeapByteBufferLongView { diff --git a/javalib/src/main/scala/java/nio/HeapByteBufferShortView.scala b/javalib/src/main/scala/java/nio/HeapByteBufferShortView.scala index 4eabeba0ee..cb7f254b99 100644 --- a/javalib/src/main/scala/java/nio/HeapByteBufferShortView.scala +++ b/javalib/src/main/scala/java/nio/HeapByteBufferShortView.scala @@ -16,6 +16,7 @@ private[nio] final class HeapByteBufferShortView private ( private def genBuffer = GenBuffer[ShortBuffer](this) private def genHeapBufferView = GenHeapBufferView[ShortBuffer](this) + @inline private def byteArrayBits = genHeapBufferView.byteArrayBits private implicit def newHeapBuffer : GenHeapBufferView.NewHeapBufferView[ShortBuffer] = HeapByteBufferShortView.NewHeapByteBufferShortView @@ -72,11 +73,11 @@ private[nio] final class HeapByteBufferShortView private ( @inline private[nio] def load(index: Int): Short = - genHeapBufferView.byteArrayBits.loadShort(index) + byteArrayBits.loadShort(index) @inline private[nio] def store(index: Int, elem: Short): Unit = - genHeapBufferView.byteArrayBits.storeShort(index, elem) + byteArrayBits.storeShort(index, elem) } private[nio] object HeapByteBufferShortView { diff --git a/javalib/src/main/scala/java/nio/MappedByteBufferCharView.scala b/javalib/src/main/scala/java/nio/MappedByteBufferCharView.scala index 9cc416cdd8..77303c8863 100644 --- a/javalib/src/main/scala/java/nio/MappedByteBufferCharView.scala +++ b/javalib/src/main/scala/java/nio/MappedByteBufferCharView.scala @@ -17,6 +17,7 @@ private[nio] final class MappedByteBufferCharView private ( private def genBuffer = GenBuffer[CharBuffer](this) private def genHeapBufferView = GenMappedBufferView[CharBuffer](this) + @inline private def byteArrayBits = genHeapBufferView.byteArrayBits private implicit def newMappedCharBufferView : GenMappedBufferView.NewMappedBufferView[CharBuffer] = MappedByteBufferCharView.NewMappedByteBufferCharView @@ -87,11 +88,11 @@ private[nio] final class MappedByteBufferCharView private ( @inline private[nio] def load(index: Int): Char = - genHeapBufferView.byteArrayBits.loadChar(index) + byteArrayBits.loadChar(index) @inline private[nio] def store(index: Int, elem: Char): Unit = - genHeapBufferView.byteArrayBits.storeChar(index, elem) + byteArrayBits.storeChar(index, elem) } private[nio] object MappedByteBufferCharView { diff --git a/javalib/src/main/scala/java/nio/MappedByteBufferDoubleView.scala b/javalib/src/main/scala/java/nio/MappedByteBufferDoubleView.scala index f43b7b0090..7f2c12cfb2 100644 --- a/javalib/src/main/scala/java/nio/MappedByteBufferDoubleView.scala +++ b/javalib/src/main/scala/java/nio/MappedByteBufferDoubleView.scala @@ -16,8 +16,9 @@ private[nio] final class MappedByteBufferDoubleView private ( limit(_initialLimit) private def genBuffer = GenBuffer[DoubleBuffer](this) - protected def genMappedBufferView = + protected lazy val genMappedBufferView = GenMappedBufferView[DoubleBuffer](this) + @inline private def byteArrayBits = genMappedBufferView.byteArrayBits private[this] implicit def newMappedDoubleBufferView : GenMappedBufferView.NewMappedBufferView[DoubleBuffer] = MappedByteBufferDoubleView.NewMappedByteBufferDoubleView @@ -74,11 +75,11 @@ private[nio] final class MappedByteBufferDoubleView private ( @inline private[nio] def load(index: Int): Double = - genMappedBufferView.byteArrayBits.loadDouble(index) + byteArrayBits.loadDouble(index) @inline private[nio] def store(index: Int, elem: Double): Unit = - genMappedBufferView.byteArrayBits.storeDouble(index, elem) + byteArrayBits.storeDouble(index, elem) } private[nio] object MappedByteBufferDoubleView { diff --git a/javalib/src/main/scala/java/nio/MappedByteBufferFloatView.scala b/javalib/src/main/scala/java/nio/MappedByteBufferFloatView.scala index 6560bb388c..44696ebdac 100644 --- a/javalib/src/main/scala/java/nio/MappedByteBufferFloatView.scala +++ b/javalib/src/main/scala/java/nio/MappedByteBufferFloatView.scala @@ -17,6 +17,7 @@ private[nio] final class MappedByteBufferFloatView private ( private def genBuffer = GenBuffer[FloatBuffer](this) protected def genMappedBufferView = GenMappedBufferView[FloatBuffer](this) + private lazy val byteArrayBits = genMappedBufferView.byteArrayBits private[this] implicit def newMappedFloatBufferView : GenMappedBufferView.NewMappedBufferView[FloatBuffer] = MappedByteBufferFloatView.NewMappedByteBufferFloatView @@ -73,11 +74,11 @@ private[nio] final class MappedByteBufferFloatView private ( @inline private[nio] def load(index: Int): Float = - genMappedBufferView.byteArrayBits.loadFloat(index) + byteArrayBits.loadFloat(index) @inline private[nio] def store(index: Int, elem: Float): Unit = - genMappedBufferView.byteArrayBits.storeFloat(index, elem) + byteArrayBits.storeFloat(index, elem) } private[nio] object MappedByteBufferFloatView { diff --git a/javalib/src/main/scala/java/nio/MappedByteBufferImpl.scala b/javalib/src/main/scala/java/nio/MappedByteBufferImpl.scala index 38f173b1ab..3c5e511abf 100644 --- a/javalib/src/main/scala/java/nio/MappedByteBufferImpl.scala +++ b/javalib/src/main/scala/java/nio/MappedByteBufferImpl.scala @@ -101,19 +101,21 @@ private class MappedByteBufferImpl( // Here begins the stuff specific to ByteArrays - @inline private def arrayBits: ByteArrayBits = + @inline @inline private def byteArrayBits: ByteArrayBits = ByteArrayBits(_mappedData.ptr, _arrayOffset, isBigEndian) @noinline def getChar(): Char = - arrayBits.loadChar(getPosAndAdvanceRead(2)) + byteArrayBits.loadChar(getPosAndAdvanceRead(2)) @noinline def putChar(value: Char): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeChar(getPosAndAdvanceWrite(2), value); + ensureNotReadOnly(); + byteArrayBits.storeChar(getPosAndAdvanceWrite(2), value); this } @noinline def getChar(index: Int): Char = - arrayBits.loadChar(validateIndex(index, 2)) + byteArrayBits.loadChar(validateIndex(index, 2)) @noinline def putChar(index: Int, value: Char): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeChar(validateIndex(index, 2), value); + ensureNotReadOnly(); + byteArrayBits.storeChar(validateIndex(index, 2), value); this } @@ -121,15 +123,17 @@ private class MappedByteBufferImpl( MappedByteBufferCharView.fromMappedByteBuffer(this) @noinline def getShort(): Short = - arrayBits.loadShort(getPosAndAdvanceRead(2)) + byteArrayBits.loadShort(getPosAndAdvanceRead(2)) @noinline def putShort(value: Short): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeShort(getPosAndAdvanceWrite(2), value); + ensureNotReadOnly(); + byteArrayBits.storeShort(getPosAndAdvanceWrite(2), value); this } @noinline def getShort(index: Int): Short = - arrayBits.loadShort(validateIndex(index, 2)) + byteArrayBits.loadShort(validateIndex(index, 2)) @noinline def putShort(index: Int, value: Short): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeShort(validateIndex(index, 2), value); + ensureNotReadOnly(); + byteArrayBits.storeShort(validateIndex(index, 2), value); this } @@ -137,15 +141,16 @@ private class MappedByteBufferImpl( MappedByteBufferShortView.fromMappedByteBuffer(this) @noinline def getInt(): Int = - arrayBits.loadInt(getPosAndAdvanceRead(4)) + byteArrayBits.loadInt(getPosAndAdvanceRead(4)) @noinline def putInt(value: Int): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeInt(getPosAndAdvanceWrite(4), value); + ensureNotReadOnly(); + byteArrayBits.storeInt(getPosAndAdvanceWrite(4), value); this } @noinline def getInt(index: Int): Int = - arrayBits.loadInt(validateIndex(index, 4)) + byteArrayBits.loadInt(validateIndex(index, 4)) @noinline def putInt(index: Int, value: Int): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeInt(validateIndex(index, 4), value); + ensureNotReadOnly(); byteArrayBits.storeInt(validateIndex(index, 4), value); this } @@ -153,15 +158,17 @@ private class MappedByteBufferImpl( MappedByteBufferIntView.fromMappedByteBuffer(this) @noinline def getLong(): Long = - arrayBits.loadLong(getPosAndAdvanceRead(8)) + byteArrayBits.loadLong(getPosAndAdvanceRead(8)) @noinline def putLong(value: Long): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeLong(getPosAndAdvanceWrite(8), value); + ensureNotReadOnly(); + byteArrayBits.storeLong(getPosAndAdvanceWrite(8), value); this } @noinline def getLong(index: Int): Long = - arrayBits.loadLong(validateIndex(index, 8)) + byteArrayBits.loadLong(validateIndex(index, 8)) @noinline def putLong(index: Int, value: Long): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeLong(validateIndex(index, 8), value); + ensureNotReadOnly(); + byteArrayBits.storeLong(validateIndex(index, 8), value); this } @@ -169,15 +176,17 @@ private class MappedByteBufferImpl( MappedByteBufferLongView.fromMappedByteBuffer(this) @noinline def getFloat(): Float = - arrayBits.loadFloat(getPosAndAdvanceRead(4)) + byteArrayBits.loadFloat(getPosAndAdvanceRead(4)) @noinline def putFloat(value: Float): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeFloat(getPosAndAdvanceWrite(4), value); + ensureNotReadOnly(); + byteArrayBits.storeFloat(getPosAndAdvanceWrite(4), value); this } @noinline def getFloat(index: Int): Float = - arrayBits.loadFloat(validateIndex(index, 4)) + byteArrayBits.loadFloat(validateIndex(index, 4)) @noinline def putFloat(index: Int, value: Float): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeFloat(validateIndex(index, 4), value); + ensureNotReadOnly(); + byteArrayBits.storeFloat(validateIndex(index, 4), value); this } @@ -185,15 +194,17 @@ private class MappedByteBufferImpl( MappedByteBufferFloatView.fromMappedByteBuffer(this) @noinline def getDouble(): Double = - arrayBits.loadDouble(getPosAndAdvanceRead(8)) + byteArrayBits.loadDouble(getPosAndAdvanceRead(8)) @noinline def putDouble(value: Double): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeDouble(getPosAndAdvanceWrite(8), value); + ensureNotReadOnly(); + byteArrayBits.storeDouble(getPosAndAdvanceWrite(8), value); this } @noinline def getDouble(index: Int): Double = - arrayBits.loadDouble(validateIndex(index, 8)) + byteArrayBits.loadDouble(validateIndex(index, 8)) @noinline def putDouble(index: Int, value: Double): ByteBuffer = { - ensureNotReadOnly(); arrayBits.storeDouble(validateIndex(index, 8), value); + ensureNotReadOnly(); + byteArrayBits.storeDouble(validateIndex(index, 8), value); this } diff --git a/javalib/src/main/scala/java/nio/MappedByteBufferIntView.scala b/javalib/src/main/scala/java/nio/MappedByteBufferIntView.scala index c84883d3d3..5814ca6b30 100644 --- a/javalib/src/main/scala/java/nio/MappedByteBufferIntView.scala +++ b/javalib/src/main/scala/java/nio/MappedByteBufferIntView.scala @@ -17,6 +17,7 @@ private[nio] final class MappedByteBufferIntView private ( private def genBuffer = GenBuffer[IntBuffer](this) protected def genMappedBufferView = GenMappedBufferView[IntBuffer](this) + @inline private def byteArrayBits = genMappedBufferView.byteArrayBits private implicit def newMappedIntBufferView : GenMappedBufferView.NewMappedBufferView[IntBuffer] = MappedByteBufferIntView.NewMappedByteBufferIntView @@ -73,11 +74,11 @@ private[nio] final class MappedByteBufferIntView private ( @inline private[nio] def load(index: Int): Int = - genMappedBufferView.byteArrayBits.loadInt(index) + byteArrayBits.loadInt(index) @inline private[nio] def store(index: Int, elem: Int): Unit = - genMappedBufferView.byteArrayBits.storeInt(index, elem) + byteArrayBits.storeInt(index, elem) } private[nio] object MappedByteBufferIntView { diff --git a/javalib/src/main/scala/java/nio/MappedByteBufferLongView.scala b/javalib/src/main/scala/java/nio/MappedByteBufferLongView.scala index 6bb106020e..18a8315732 100644 --- a/javalib/src/main/scala/java/nio/MappedByteBufferLongView.scala +++ b/javalib/src/main/scala/java/nio/MappedByteBufferLongView.scala @@ -17,6 +17,7 @@ private[nio] final class MappedByteBufferLongView private ( private def genBuffer = GenBuffer[LongBuffer](this) protected def genMappedBufferView = GenMappedBufferView[LongBuffer](this) + @inline private def byteArrayBits = genMappedBufferView.byteArrayBits private[this] implicit def newMappedLongBufferView : GenMappedBufferView.NewMappedBufferView[LongBuffer] = MappedByteBufferLongView.NewMappedByteBufferLongView @@ -71,11 +72,11 @@ private[nio] final class MappedByteBufferLongView private ( @inline private[nio] def load(index: Int): Long = - genMappedBufferView.byteArrayBits.loadLong(index) + byteArrayBits.loadLong(index) @inline private[nio] def store(index: Int, elem: Long): Unit = - genMappedBufferView.byteArrayBits.storeLong(index, elem) + byteArrayBits.storeLong(index, elem) } private[nio] object MappedByteBufferLongView { diff --git a/javalib/src/main/scala/java/nio/MappedByteBufferShortView.scala b/javalib/src/main/scala/java/nio/MappedByteBufferShortView.scala index e2ea0eb93a..960f4f38fe 100644 --- a/javalib/src/main/scala/java/nio/MappedByteBufferShortView.scala +++ b/javalib/src/main/scala/java/nio/MappedByteBufferShortView.scala @@ -18,6 +18,7 @@ private[nio] final class MappedByteBufferShortView private ( private def genBuffer = GenBuffer[ShortBuffer](this) protected def genMappedBufferView = GenMappedBufferView[ShortBuffer](this) + @inline private def byteArrayBits = genMappedBufferView.byteArrayBits private[this] implicit def newMappedShortBufferView : GenMappedBufferView.NewMappedBufferView[ShortBuffer] = MappedByteBufferShortView.NewMappedByteBufferShortView @@ -74,11 +75,11 @@ private[nio] final class MappedByteBufferShortView private ( @inline private[nio] def load(index: Int): Short = - genMappedBufferView.byteArrayBits.loadShort(index) + byteArrayBits.loadShort(index) @inline private[nio] def store(index: Int, elem: Short): Unit = - genMappedBufferView.byteArrayBits.storeShort(index, elem) + byteArrayBits.storeShort(index, elem) } private[nio] object MappedByteBufferShortView { diff --git a/nativelib/src/main/scala/scala/scalanative/runtime/Arrays.scala.gyb b/nativelib/src/main/scala/scala/scalanative/runtime/Arrays.scala.gyb index 0c10614b43..5ff7d3a7ea 100644 --- a/nativelib/src/main/scala/scala/scalanative/runtime/Arrays.scala.gyb +++ b/nativelib/src/main/scala/scala/scalanative/runtime/Arrays.scala.gyb @@ -199,7 +199,7 @@ final class ${T}Array private () extends Array[${T}] { @inline override def clone(): ${T}Array = { val arrcls = classOf[${T}Array] - val arrsize = new ULong(MemoryLayout.Array.ValuesOffset + ${sizeT} * length) + val arrsize = ULong.valueOf(MemoryLayout.Array.ValuesOffset + ${sizeT} * length) val arr = ${alloc}(arrcls, arrsize) val src = castObjectToRawPtr(this) libc.memcpy(arr, src, arrsize) @@ -215,7 +215,7 @@ object ${T}Array { } val arrcls = classOf[${T}Array] - val arrsize = new ULong(MemoryLayout.Array.ValuesOffset + ${sizeT} * length) + val arrsize = ULong.valueOf(MemoryLayout.Array.ValuesOffset + ${sizeT} * length) val arr = ${alloc}(arrcls, arrsize) storeInt(elemRawPtr(arr, MemoryLayout.Array.LengthOffset), length) storeInt(elemRawPtr(arr, MemoryLayout.Array.StrideOffset), ${sizeT}) @@ -226,7 +226,7 @@ object ${T}Array { val arr = alloc(length) val dst = arr.atRaw(0) val src = data - val size = new ULong(${sizeT} * length) + val size = ULong.valueOf(${sizeT} * length) libc.memcpy(dst, src, size) arr } diff --git a/nscplugin/src/main/scala-2/scala/scalanative/nscplugin/NirDefinitions.scala b/nscplugin/src/main/scala-2/scala/scalanative/nscplugin/NirDefinitions.scala index 5ded2159ae..c0cc19601c 100644 --- a/nscplugin/src/main/scala-2/scala/scalanative/nscplugin/NirDefinitions.scala +++ b/nscplugin/src/main/scala-2/scala/scalanative/nscplugin/NirDefinitions.scala @@ -17,6 +17,7 @@ trait NirDefinitions { lazy val UShortClass = getRequiredClass("scala.scalanative.unsigned.UShort") lazy val UIntClass = getRequiredClass("scala.scalanative.unsigned.UInt") lazy val ULongClass = getRequiredClass("scala.scalanative.unsigned.ULong") + lazy val PtrClass = getRequiredClass("scala.scalanative.unsafe.Ptr") lazy val RawPtrClass = getRequiredClass("scala.scalanative.runtime.RawPtr") diff --git a/nscplugin/src/main/scala-3/scala/scalanative/nscplugin/NirDefinitions.scala b/nscplugin/src/main/scala-3/scala/scalanative/nscplugin/NirDefinitions.scala index 35ba7729e4..893c2b56e7 100644 --- a/nscplugin/src/main/scala-3/scala/scalanative/nscplugin/NirDefinitions.scala +++ b/nscplugin/src/main/scala-3/scala/scalanative/nscplugin/NirDefinitions.scala @@ -47,14 +47,10 @@ final class NirDefinitions()(using ctx: Context) { def ExportAccessorsClass(using Context) = ExportAccessorsType.symbol.asClass // Unsigned types - @tu lazy val UByteClassVal = requiredClassRef("scala.scalanative.unsigned.UByte") - @tu lazy val UShortType = requiredClassRef("scala.scalanative.unsigned.UShort") - @tu lazy val UIntType = requiredClassRef("scala.scalanative.unsigned.UInt") - @tu lazy val ULongType = requiredClassRef("scala.scalanative.unsigned.ULong") - def UByteClass(using Context) = UByteClassVal.symbol.asClass - def UShortClass(using Context) = UShortType.symbol.asClass - def UIntClass(using Context) = UIntType.symbol.asClass - def ULongClass(using Context) = ULongType.symbol.asClass + @tu lazy val UByteClass = requiredClass("scala.scalanative.unsigned.UByte") + @tu lazy val UShortClass = requiredClass("scala.scalanative.unsigned.UShort") + @tu lazy val UIntClass = requiredClass("scala.scalanative.unsigned.UInt") + @tu lazy val ULongClass = requiredClass("scala.scalanative.unsigned.ULong") // Pointers @tu lazy val PtrType = requiredClassRef("scala.scalanative.unsafe.Ptr") From b4f377d8f1ce5ecfbfc10a1442ccbfc10d0be462 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Tue, 3 Oct 2023 13:38:52 +0200 Subject: [PATCH 32/51] Faster Ptr.{apply, update} by skipping unnecessary GC allocations (#3522) (cherry picked from commit ee84995a7b625f717ca1635ba43cb9b999088c24) --- .../scala/scala/scalanative/unsafe/Ptr.scala | 31 +- .../scala/scala/scalanative/unsafe/Tag.scala | 327 +++++++++--------- .../scala/scalanative/unsafe/Tag.scala.gyb | 63 ++-- 3 files changed, 220 insertions(+), 201 deletions(-) diff --git a/nativelib/src/main/scala/scala/scalanative/unsafe/Ptr.scala b/nativelib/src/main/scala/scala/scalanative/unsafe/Ptr.scala index 5cd175aee1..052e08abca 100644 --- a/nativelib/src/main/scala/scala/scalanative/unsafe/Ptr.scala +++ b/nativelib/src/main/scala/scala/scalanative/unsafe/Ptr.scala @@ -5,6 +5,7 @@ import scala.language.implicitConversions import scala.scalanative.annotation.alwaysinline import scala.scalanative.runtime.Intrinsics._ import scala.scalanative.runtime._ +import scala.scalanative.unsigned._ final class Ptr[T] private[scalanative] ( private[scalanative] val rawptr: RawPtr @@ -14,10 +15,8 @@ final class Ptr[T] private[scalanative] ( @alwaysinline override def equals(other: Any): Boolean = (this eq other.asInstanceOf[AnyRef]) || (other match { - case other: Ptr[_] => - other.rawptr == rawptr - case _ => - false + case other: Ptr[_] => other.rawptr == rawptr + case _ => false }) @alwaysinline override def toString: String = @@ -53,19 +52,33 @@ final class Ptr[T] private[scalanative] ( (left - right) / sizeof[T].toLong } + @alwaysinline def apply(offset: Int)(implicit tag: Tag[T]): T = + tag.load( + elemRawPtr(rawptr, offset * tag.size.toInt) + ) + @alwaysinline def apply(offset: UWord)(implicit tag: Tag[T]): T = - apply(offset.toLong) + tag.load( + elemRawPtr(rawptr, offset.toLong * tag.size.toLong) + ) @alwaysinline def apply(offset: Word)(implicit tag: Tag[T]): T = - (this + offset).unary_! + tag.load( + elemRawPtr(rawptr, offset * tag.size.toLong) + ) @alwaysinline def update(offset: Word, value: T)(implicit tag: Tag[T]): Unit = - (this + offset).`unary_!_=`(value) + tag.store( + elemRawPtr(rawptr, offset * tag.size.toLong), + value + ) @alwaysinline def update(offset: UWord, value: T)(implicit tag: Tag[T] ): Unit = - (this + offset).`unary_!_=`(value) - + tag.store( + elemRawPtr(rawptr, offset.toLong * tag.size.toLong), + value + ) } object Ptr { diff --git a/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala b/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala index b1c1ebf064..44779dc221 100644 --- a/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala +++ b/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala @@ -20,9 +20,12 @@ import scalanative.runtime.Intrinsics._ sealed abstract class Tag[T] { def size: CSize def alignment: CSize + @alwaysinline def load(ptr: unsafe.Ptr[T]): T = load(toRawPtr(ptr)) + @alwaysinline def store(ptr: unsafe.Ptr[T], value: T): Unit = store(toRawPtr(ptr), value) + @noinline def offset(idx: CSize): CSize = throwUndefined() - @noinline def load(ptr: unsafe.Ptr[T]): T = throwUndefined() - @noinline def store(ptr: unsafe.Ptr[T], value: T): Unit = throwUndefined() + @noinline private[unsafe] def load(rawptr: RawPtr): T = throwUndefined() + @noinline private[unsafe] def store(rawptr: RawPtr, value: T): Unit = throwUndefined() } object Tag { @@ -30,137 +33,137 @@ object Tag { extends Tag[unsafe.Ptr[T]] { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.Ptr[T]]): unsafe.Ptr[T] = - fromRawPtr[T](loadRawPtr(toRawPtr(ptr))) - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.Ptr[T]], value: unsafe.Ptr[T]): Unit = - storeRawPtr(toRawPtr(ptr), toRawPtr(value)) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.Ptr[T] = + fromRawPtr[T](loadRawPtr(rawptr)) + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.Ptr[T]): Unit = + storeRawPtr(rawptr, toRawPtr(value)) } final case class Class[T <: AnyRef](of: java.lang.Class[T]) extends Tag[T] { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[T]): T = - loadObject(toRawPtr(ptr)).asInstanceOf[T] - @alwaysinline override def store(ptr: unsafe.Ptr[T], value: T): Unit = - storeObject(toRawPtr(ptr), value.asInstanceOf[Object]) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): T = + loadObject(rawptr).asInstanceOf[T] + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: T): Unit = + storeObject(rawptr, value.asInstanceOf[Object]) } object Unit extends Tag[scala.Unit] { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[scala.Unit]): scala.Unit = - loadObject(toRawPtr(ptr)).asInstanceOf[Unit] - @alwaysinline override def store(ptr: unsafe.Ptr[scala.Unit], value: scala.Unit): Unit = - storeObject(toRawPtr(ptr), value.asInstanceOf[Object]) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Unit = + loadObject(rawptr).asInstanceOf[Unit] + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Unit): Unit = + storeObject(rawptr, value.asInstanceOf[Object]) } object Boolean extends Tag[scala.Boolean] { @alwaysinline def size: CSize = 1.toULong @alwaysinline def alignment: CSize = 1.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[scala.Boolean]): scala.Boolean = - loadBoolean(toRawPtr(ptr)) - @alwaysinline override def store(ptr: unsafe.Ptr[scala.Boolean], value: scala.Boolean): Unit = - storeBoolean(toRawPtr(ptr), value) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Boolean = + loadBoolean(rawptr) + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Boolean): Unit = + storeBoolean(rawptr, value) } object Char extends Tag[scala.Char] { @alwaysinline def size: CSize = 2.toULong @alwaysinline def alignment: CSize = 2.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[scala.Char]): scala.Char = - loadChar(toRawPtr(ptr)) - @alwaysinline override def store(ptr: unsafe.Ptr[scala.Char], value: scala.Char): Unit = - storeChar(toRawPtr(ptr), value) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Char = + loadChar(rawptr) + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Char): Unit = + storeChar(rawptr, value) } object Byte extends Tag[scala.Byte] { @alwaysinline def size: CSize = 1.toULong @alwaysinline def alignment: CSize = 1.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[scala.Byte]): scala.Byte = - loadByte(toRawPtr(ptr)) - @alwaysinline override def store(ptr: unsafe.Ptr[scala.Byte], value: scala.Byte): Unit = - storeByte(toRawPtr(ptr), value) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Byte = + loadByte(rawptr) + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Byte): Unit = + storeByte(rawptr, value) } object UByte extends Tag[unsigned.UByte] { @alwaysinline def size: CSize = 1.toULong @alwaysinline def alignment: CSize = 1.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[unsigned.UByte]): unsigned.UByte = - loadByte(toRawPtr(ptr)).toUByte - @alwaysinline override def store(ptr: unsafe.Ptr[unsigned.UByte], value: unsigned.UByte): Unit = - storeByte(toRawPtr(ptr), value.toByte) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsigned.UByte = + loadByte(rawptr).toUByte + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsigned.UByte): Unit = + storeByte(rawptr, value.toByte) } object Short extends Tag[scala.Short] { @alwaysinline def size: CSize = 2.toULong @alwaysinline def alignment: CSize = 2.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[scala.Short]): scala.Short = - loadShort(toRawPtr(ptr)) - @alwaysinline override def store(ptr: unsafe.Ptr[scala.Short], value: scala.Short): Unit = - storeShort(toRawPtr(ptr), value) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Short = + loadShort(rawptr) + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Short): Unit = + storeShort(rawptr, value) } object UShort extends Tag[unsigned.UShort] { @alwaysinline def size: CSize = 2.toULong @alwaysinline def alignment: CSize = 2.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[unsigned.UShort]): unsigned.UShort = - loadShort(toRawPtr(ptr)).toUShort - @alwaysinline override def store(ptr: unsafe.Ptr[unsigned.UShort], value: unsigned.UShort): Unit = - storeShort(toRawPtr(ptr), value.toShort) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsigned.UShort = + loadShort(rawptr).toUShort + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsigned.UShort): Unit = + storeShort(rawptr, value.toShort) } object Int extends Tag[scala.Int] { @alwaysinline def size: CSize = 4.toULong @alwaysinline def alignment: CSize = 4.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[scala.Int]): scala.Int = - loadInt(toRawPtr(ptr)) - @alwaysinline override def store(ptr: unsafe.Ptr[scala.Int], value: scala.Int): Unit = - storeInt(toRawPtr(ptr), value) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Int = + loadInt(rawptr) + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Int): Unit = + storeInt(rawptr, value) } object UInt extends Tag[unsigned.UInt] { @alwaysinline def size: CSize = 4.toULong @alwaysinline def alignment: CSize = 4.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[unsigned.UInt]): unsigned.UInt = - loadInt(toRawPtr(ptr)).toUInt - @alwaysinline override def store(ptr: unsafe.Ptr[unsigned.UInt], value: unsigned.UInt): Unit = - storeInt(toRawPtr(ptr), value.toInt) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsigned.UInt = + loadInt(rawptr).toUInt + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsigned.UInt): Unit = + storeInt(rawptr, value.toInt) } object Long extends Tag[scala.Long] { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[scala.Long]): scala.Long = - loadLong(toRawPtr(ptr)) - @alwaysinline override def store(ptr: unsafe.Ptr[scala.Long], value: scala.Long): Unit = - storeLong(toRawPtr(ptr), value) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Long = + loadLong(rawptr) + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Long): Unit = + storeLong(rawptr, value) } object ULong extends Tag[unsigned.ULong] { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[unsigned.ULong]): unsigned.ULong = - loadLong(toRawPtr(ptr)).toULong - @alwaysinline override def store(ptr: unsafe.Ptr[unsigned.ULong], value: unsigned.ULong): Unit = - storeLong(toRawPtr(ptr), value.toLong) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsigned.ULong = + loadLong(rawptr).toULong + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsigned.ULong): Unit = + storeLong(rawptr, value.toLong) } object Float extends Tag[scala.Float] { @alwaysinline def size: CSize = 4.toULong @alwaysinline def alignment: CSize = 4.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[scala.Float]): scala.Float = - loadFloat(toRawPtr(ptr)) - @alwaysinline override def store(ptr: unsafe.Ptr[scala.Float], value: scala.Float): Unit = - storeFloat(toRawPtr(ptr), value) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Float = + loadFloat(rawptr) + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Float): Unit = + storeFloat(rawptr, value) } object Double extends Tag[scala.Double] { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[scala.Double]): scala.Double = - loadDouble(toRawPtr(ptr)) - @alwaysinline override def store(ptr: unsafe.Ptr[scala.Double], value: scala.Double): Unit = - storeDouble(toRawPtr(ptr), value) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Double = + loadDouble(rawptr) + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Double): Unit = + storeDouble(rawptr, value) } @@ -368,11 +371,11 @@ object Tag { @alwaysinline def size: CSize = of.size * n.asInstanceOf[NatTag].toUInt @alwaysinline def alignment: CSize = of.alignment @alwaysinline override def offset(idx: CSize): CSize = of.size * idx.toUInt - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CArray[T, N]]): unsafe.CArray[T, N] = { - new unsafe.CArray[T, N](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CArray[T, N] = { + new unsafe.CArray[T, N](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CArray[T, N]], value: unsafe.CArray[T, N]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CArray[T, N]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size) @@ -407,11 +410,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct0]): unsafe.CStruct0 = { - new unsafe.CStruct0(ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct0 = { + new unsafe.CStruct0(rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct0], value: unsafe.CStruct0): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct0): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -440,11 +443,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct1[T1]]): unsafe.CStruct1[T1] = { - new unsafe.CStruct1[T1](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct1[T1] = { + new unsafe.CStruct1[T1](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct1[T1]], value: unsafe.CStruct1[T1]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct1[T1]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -479,11 +482,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct2[T1, T2]]): unsafe.CStruct2[T1, T2] = { - new unsafe.CStruct2[T1, T2](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct2[T1, T2] = { + new unsafe.CStruct2[T1, T2](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct2[T1, T2]], value: unsafe.CStruct2[T1, T2]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct2[T1, T2]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -525,11 +528,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct3[T1, T2, T3]]): unsafe.CStruct3[T1, T2, T3] = { - new unsafe.CStruct3[T1, T2, T3](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct3[T1, T2, T3] = { + new unsafe.CStruct3[T1, T2, T3](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct3[T1, T2, T3]], value: unsafe.CStruct3[T1, T2, T3]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct3[T1, T2, T3]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -579,11 +582,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct4[T1, T2, T3, T4]]): unsafe.CStruct4[T1, T2, T3, T4] = { - new unsafe.CStruct4[T1, T2, T3, T4](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct4[T1, T2, T3, T4] = { + new unsafe.CStruct4[T1, T2, T3, T4](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct4[T1, T2, T3, T4]], value: unsafe.CStruct4[T1, T2, T3, T4]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct4[T1, T2, T3, T4]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -642,11 +645,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct5[T1, T2, T3, T4, T5]]): unsafe.CStruct5[T1, T2, T3, T4, T5] = { - new unsafe.CStruct5[T1, T2, T3, T4, T5](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct5[T1, T2, T3, T4, T5] = { + new unsafe.CStruct5[T1, T2, T3, T4, T5](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct5[T1, T2, T3, T4, T5]], value: unsafe.CStruct5[T1, T2, T3, T4, T5]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct5[T1, T2, T3, T4, T5]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -715,11 +718,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct6[T1, T2, T3, T4, T5, T6]]): unsafe.CStruct6[T1, T2, T3, T4, T5, T6] = { - new unsafe.CStruct6[T1, T2, T3, T4, T5, T6](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct6[T1, T2, T3, T4, T5, T6] = { + new unsafe.CStruct6[T1, T2, T3, T4, T5, T6](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct6[T1, T2, T3, T4, T5, T6]], value: unsafe.CStruct6[T1, T2, T3, T4, T5, T6]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct6[T1, T2, T3, T4, T5, T6]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -799,11 +802,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct7[T1, T2, T3, T4, T5, T6, T7]]): unsafe.CStruct7[T1, T2, T3, T4, T5, T6, T7] = { - new unsafe.CStruct7[T1, T2, T3, T4, T5, T6, T7](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct7[T1, T2, T3, T4, T5, T6, T7] = { + new unsafe.CStruct7[T1, T2, T3, T4, T5, T6, T7](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct7[T1, T2, T3, T4, T5, T6, T7]], value: unsafe.CStruct7[T1, T2, T3, T4, T5, T6, T7]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct7[T1, T2, T3, T4, T5, T6, T7]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -895,11 +898,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct8[T1, T2, T3, T4, T5, T6, T7, T8]]): unsafe.CStruct8[T1, T2, T3, T4, T5, T6, T7, T8] = { - new unsafe.CStruct8[T1, T2, T3, T4, T5, T6, T7, T8](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct8[T1, T2, T3, T4, T5, T6, T7, T8] = { + new unsafe.CStruct8[T1, T2, T3, T4, T5, T6, T7, T8](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct8[T1, T2, T3, T4, T5, T6, T7, T8]], value: unsafe.CStruct8[T1, T2, T3, T4, T5, T6, T7, T8]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct8[T1, T2, T3, T4, T5, T6, T7, T8]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -1004,11 +1007,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]): unsafe.CStruct9[T1, T2, T3, T4, T5, T6, T7, T8, T9] = { - new unsafe.CStruct9[T1, T2, T3, T4, T5, T6, T7, T8, T9](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct9[T1, T2, T3, T4, T5, T6, T7, T8, T9] = { + new unsafe.CStruct9[T1, T2, T3, T4, T5, T6, T7, T8, T9](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], value: unsafe.CStruct9[T1, T2, T3, T4, T5, T6, T7, T8, T9]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct9[T1, T2, T3, T4, T5, T6, T7, T8, T9]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -1127,11 +1130,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]): unsafe.CStruct10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] = { - new unsafe.CStruct10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] = { + new unsafe.CStruct10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], value: unsafe.CStruct10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -1265,11 +1268,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]): unsafe.CStruct11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] = { - new unsafe.CStruct11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] = { + new unsafe.CStruct11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]], value: unsafe.CStruct11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -1419,11 +1422,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]): unsafe.CStruct12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] = { - new unsafe.CStruct12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] = { + new unsafe.CStruct12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]], value: unsafe.CStruct12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -1590,11 +1593,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]): unsafe.CStruct13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] = { - new unsafe.CStruct13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] = { + new unsafe.CStruct13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]], value: unsafe.CStruct13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -1779,11 +1782,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]): unsafe.CStruct14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] = { - new unsafe.CStruct14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] = { + new unsafe.CStruct14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]], value: unsafe.CStruct14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -1987,11 +1990,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]): unsafe.CStruct15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] = { - new unsafe.CStruct15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] = { + new unsafe.CStruct15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]], value: unsafe.CStruct15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -2215,11 +2218,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]): unsafe.CStruct16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] = { - new unsafe.CStruct16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] = { + new unsafe.CStruct16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]], value: unsafe.CStruct16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -2464,11 +2467,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]): unsafe.CStruct17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] = { - new unsafe.CStruct17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] = { + new unsafe.CStruct17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]], value: unsafe.CStruct17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -2735,11 +2738,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]): unsafe.CStruct18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] = { - new unsafe.CStruct18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] = { + new unsafe.CStruct18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]], value: unsafe.CStruct18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -3029,11 +3032,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]): unsafe.CStruct19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] = { - new unsafe.CStruct19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] = { + new unsafe.CStruct19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]], value: unsafe.CStruct19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -3347,11 +3350,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]): unsafe.CStruct20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] = { - new unsafe.CStruct20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] = { + new unsafe.CStruct20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]], value: unsafe.CStruct20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -3690,11 +3693,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]): unsafe.CStruct21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21] = { - new unsafe.CStruct21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21] = { + new unsafe.CStruct21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]], value: unsafe.CStruct21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -4059,11 +4062,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]): unsafe.CStruct22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] = { - new unsafe.CStruct22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] = { + new unsafe.CStruct22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]], value: unsafe.CStruct22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -4081,11 +4084,11 @@ object Tag { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[F]): F = - fromRawPtr(loadRawPtr(ptr.rawptr)) - @alwaysinline override def store(ptr: unsafe.Ptr[F], value: F): Unit = { + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): F = + fromRawPtr(loadRawPtr(rawptr)) + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: F): Unit = { val valuePtr = if(value != null) value.rawptr else null - storeRawPtr(toRawPtr(ptr), valuePtr) + storeRawPtr(rawptr, valuePtr) } } diff --git a/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala.gyb b/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala.gyb index 17390a9240..59ea9cfcc2 100644 --- a/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala.gyb +++ b/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala.gyb @@ -20,9 +20,12 @@ import scalanative.runtime.Intrinsics._ sealed abstract class Tag[T] { def size: CSize def alignment: CSize + @alwaysinline def load(ptr: unsafe.Ptr[T]): T = load(toRawPtr(ptr)) + @alwaysinline def store(ptr: unsafe.Ptr[T], value: T): Unit = store(toRawPtr(ptr), value) + @noinline def offset(idx: CSize): CSize = throwUndefined() - @noinline def load(ptr: unsafe.Ptr[T]): T = throwUndefined() - @noinline def store(ptr: unsafe.Ptr[T], value: T): Unit = throwUndefined() + @noinline private[unsafe] def load(rawptr: RawPtr): T = throwUndefined() + @noinline private[unsafe] def store(rawptr: RawPtr, value: T): Unit = throwUndefined() } object Tag { @@ -30,20 +33,20 @@ object Tag { extends Tag[unsafe.Ptr[T]] { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.Ptr[T]]): unsafe.Ptr[T] = - fromRawPtr[T](loadRawPtr(toRawPtr(ptr))) - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.Ptr[T]], value: unsafe.Ptr[T]): Unit = - storeRawPtr(toRawPtr(ptr), toRawPtr(value)) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.Ptr[T] = + fromRawPtr[T](loadRawPtr(rawptr)) + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.Ptr[T]): Unit = + storeRawPtr(rawptr, toRawPtr(value)) } final case class Class[T <: AnyRef](of: java.lang.Class[T]) extends Tag[T] { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[T]): T = - loadObject(toRawPtr(ptr)).asInstanceOf[T] - @alwaysinline override def store(ptr: unsafe.Ptr[T], value: T): Unit = - storeObject(toRawPtr(ptr), value.asInstanceOf[Object]) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): T = + loadObject(rawptr).asInstanceOf[T] + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: T): Unit = + storeObject(rawptr, value.asInstanceOf[Object]) } % prims = [('Unit', 'scala.Unit', 8), @@ -63,23 +66,23 @@ object Tag { object ${name} extends Tag[${T}] { @alwaysinline def size: CSize = ${size}.toULong @alwaysinline def alignment: CSize = ${size}.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[${T}]): ${T} = + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): ${T} = % if name == 'Unit': - loadObject(toRawPtr(ptr)).asInstanceOf[Unit] + loadObject(rawptr).asInstanceOf[Unit] % elif name.startswith('U'): % signed = name[1:] - load${signed}(toRawPtr(ptr)).to${name} + load${signed}(rawptr).to${name} % else: - load${name}(toRawPtr(ptr)) + load${name}(rawptr) % end - @alwaysinline override def store(ptr: unsafe.Ptr[${T}], value: ${T}): Unit = + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: ${T}): Unit = % if name == 'Unit': - storeObject(toRawPtr(ptr), value.asInstanceOf[Object]) + storeObject(rawptr, value.asInstanceOf[Object]) % elif name.startswith('U'): % signed = name[1:] - store${signed}(toRawPtr(ptr), value.to${signed}) + store${signed}(rawptr, value.to${signed}) % else: - store${name}(toRawPtr(ptr), value) + store${name}(rawptr, value) % end } @@ -126,11 +129,11 @@ object Tag { @alwaysinline def size: CSize = of.size * n.asInstanceOf[NatTag].toUInt @alwaysinline def alignment: CSize = of.alignment @alwaysinline override def offset(idx: CSize): CSize = of.size * idx.toUInt - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CArray[T, N]]): unsafe.CArray[T, N] = { - new unsafe.CArray[T, N](ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CArray[T, N] = { + new unsafe.CArray[T, N](rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CArray[T, N]], value: unsafe.CArray[T, N]): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CArray[T, N]): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size) @@ -184,11 +187,11 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct${N}${JustTs}]): unsafe.CStruct${N}${JustTs} = { - new unsafe.CStruct${N}${JustTs}(ptr.rawptr) + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct${N}${JustTs} = { + new unsafe.CStruct${N}${JustTs}(rawptr) } - @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct${N}${JustTs}], value: unsafe.CStruct${N}${JustTs}): Unit = { - val dst = ptr.rawptr + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct${N}${JustTs}): Unit = { + val dst = rawptr if (value != null) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -207,11 +210,11 @@ object Tag { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong - @alwaysinline override def load(ptr: unsafe.Ptr[F]): F = - fromRawPtr(loadRawPtr(ptr.rawptr)) - @alwaysinline override def store(ptr: unsafe.Ptr[F], value: F): Unit = { + @alwaysinline private[unsafe] override def load(rawptr: RawPtr): F = + fromRawPtr(loadRawPtr(rawptr)) + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: F): Unit = { val valuePtr = if(value != null) value.rawptr else null - storeRawPtr(toRawPtr(ptr), valuePtr) + storeRawPtr(rawptr, valuePtr) } } From a9c867b4189cb3057b5effe7a5d7362f87899ade Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Wed, 4 Oct 2023 10:44:52 +0200 Subject: [PATCH 33/51] Remove incorrect and no longer needed Reach.lookup fallback used to find a main method defined in subclass of main class. It's no longer needed since we're generating static forwarders. Fallback lead to skipping report of missing static methods (#3526) (cherry picked from commit 3e17bde02b45626f22abd983302a26c9f921b3e9) --- .../scala/scala/scalanative/linker/Reach.scala | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/tools/src/main/scala/scala/scalanative/linker/Reach.scala b/tools/src/main/scala/scala/scalanative/linker/Reach.scala index 7220ff98ed..1299c76517 100644 --- a/tools/src/main/scala/scala/scalanative/linker/Reach.scala +++ b/tools/src/main/scala/scala/scalanative/linker/Reach.scala @@ -120,26 +120,10 @@ class Reach( loaded(owner) = scope } } - def fallback = global match { - case Global.Member(owner, sig) => - infos - .get(owner) - .collect { - case scope: ScopeInfo => - scope.linearized - .find(_.responds.contains(sig)) - .map(_.responds(sig)) - .flatMap(lookup) - } - .flatten - - case _ => None - } loaded .get(owner) .flatMap(_.get(global)) - .orElse(fallback) .orElse { if (!ignoreIfUnavailable) { val resolvedPosition = for { From aaa3b81e51c99e23416d7b6700433dd7aad0ddae Mon Sep 17 00:00:00 2001 From: Jonas Spenger <6832643+jonasspenger@users.noreply.github.com> Date: Wed, 4 Oct 2023 13:31:29 +0200 Subject: [PATCH 34/51] Implement `Math.multiplyHigh` for Long (#3480) * Created Math multiplyHigh method * Move multiplyHigh tests to JDK9 tests dir (cherry picked from commit 6c89cde2673ea13cef864cfb7bfc8fa04beb4343) --- javalib/src/main/scala/java/lang/Math.scala | 18 +++++++++ .../javalib/lang/MathTestOnJDK9.scala | 37 +++++++++++++++++++ 2 files changed, 55 insertions(+) diff --git a/javalib/src/main/scala/java/lang/Math.scala b/javalib/src/main/scala/java/lang/Math.scala index 664c1ce2e0..f50cd7f11f 100644 --- a/javalib/src/main/scala/java/lang/Math.scala +++ b/javalib/src/main/scala/java/lang/Math.scala @@ -188,6 +188,24 @@ object Math { else overflow.value } + @alwaysinline def multiplyHigh(a: scala.Long, b: scala.Long): scala.Long = { + /* Algorithm from Hacker's Delight, "8–2. Multiply high signed." + * Here, `a` is replaced with `u`, and `b` with `v`, and reassignment of + * variables with suffix `p`. Unsigned ints correspond to shifting with + * `>>>` and performing the `& 0xffffffffL` operations. + */ + val u0 = a & 0xffffffffL + val u1 = a >> 32 + val v0 = b & 0xffffffffL + val v1 = b >> 32 + val w0 = u0 * v0 + val t = u1 * v0 + (w0 >>> 32) + val w1 = t & 0xffffffffL + val w2 = t >> 32 + val w1p = u0 * v1 + w1 + u1 * v1 + w2 + (w1p >> 32) + } + @alwaysinline def multiplyExact(a: scala.Long, b: scala.Int): scala.Long = multiplyExact(a, b.toLong) diff --git a/unit-tests/shared/src/test/require-jdk9/org/scalanative/testsuite/javalib/lang/MathTestOnJDK9.scala b/unit-tests/shared/src/test/require-jdk9/org/scalanative/testsuite/javalib/lang/MathTestOnJDK9.scala index a8a6aeeec1..4ba59df449 100644 --- a/unit-tests/shared/src/test/require-jdk9/org/scalanative/testsuite/javalib/lang/MathTestOnJDK9.scala +++ b/unit-tests/shared/src/test/require-jdk9/org/scalanative/testsuite/javalib/lang/MathTestOnJDK9.scala @@ -10,4 +10,41 @@ class MathTestOnJDK9 { assertEquals(10.0, Math.fma(2.0, 3.0, 4.0), 0.0) } + @Test def multiplyHighTests(): Unit = { + case class MHTest(a: Long, b: Long, expected: Long) + val maxval = java.lang.Long.MAX_VALUE + val minval = java.lang.Long.MIN_VALUE + val halfmax = maxval >> 32 + val halfmin = minval >> 32 + + val testcases: List[MHTest] = + MHTest(maxval, maxval, 4611686018427387903L) :: + MHTest(maxval, minval, -4611686018427387904L) :: + MHTest(minval, minval, 4611686018427387904L) :: + MHTest(maxval, 0L, 0L) :: + MHTest(minval, 0L, 0L) :: + MHTest(0L, 0L, 0L) :: + MHTest(maxval, halfmax, 1073741823L) :: + MHTest(maxval, halfmin, -1073741824L) :: + MHTest(halfmax, halfmin, -1L) :: + MHTest(halfmin, halfmin, 0L) :: + MHTest(halfmax, 127L, 0L) :: + MHTest(halfmax * 42L, halfmax * 1337L, 14038L) :: + MHTest(halfmin * 42L, halfmax * 1337L, -14039L) :: + MHTest(13L, 37L, 0L) :: + MHTest(123456789123456789L, 987654321L, 6609981L) :: + MHTest(123123456456789789L, 998877665544332211L, 6667044887047954L) :: + MHTest(-123123456456789789L, 998877665544332211L, -6667044887047955L) :: + MHTest(123123456456789789L, -998877665544332211L, -6667044887047955L) :: + MHTest(-123123456456789789L, -998877665544332211L, 6667044887047954L) :: + Nil + + for (tc <- testcases) { + val result = Math.multiplyHigh(tc.a, tc.b) + assertTrue( + s"Math.multiplyHigh(${tc.a}, ${tc.b}) result: ${result} != expected: ${tc.expected}", + Math.multiplyHigh(tc.a, tc.b) == tc.expected + ) + } + } } From be5c6eed612f315517d7c9d5421133d9bd7baa9e Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Wed, 4 Oct 2023 16:46:18 +0200 Subject: [PATCH 35/51] Add missing overrides in `java.util.concurrent.ConcurrentMap` (#3527) * Add j.u.c.ConcurrentMap overrides and restore failing scalaPartestJunitTest * Guard against concurrent modification in 2 j.u.Map functions (cherry picked from commit 493c3b8b32a9ec83fdd8845d8e78deca16561ef4) --- javalib/src/main/scala/java/util/Map.scala | 40 +++++- .../java/util/concurrent/ConcurrentMap.scala | 126 +++++++++++++++++- .../resources/2.13.12/BlacklistedTests.txt | 3 - 3 files changed, 159 insertions(+), 10 deletions(-) diff --git a/javalib/src/main/scala/java/util/Map.scala b/javalib/src/main/scala/java/util/Map.scala index e20219d89d..29b746dd4d 100644 --- a/javalib/src/main/scala/java/util/Map.scala +++ b/javalib/src/main/scala/java/util/Map.scala @@ -3,7 +3,7 @@ package java.util import java.util.function.{BiConsumer, BiFunction, Function} - +import scala.scalanative.annotation.alwaysinline import ScalaOps._ trait Map[K, V] { @@ -27,13 +27,22 @@ trait Map[K, V] { else defaultValue def forEach(action: BiConsumer[_ >: K, _ >: V]): Unit = { - for (entry <- entrySet().scalaOps) - action.accept(entry.getKey(), entry.getValue()) + Objects.requireNonNull(action) + entrySet().forEach(usingEntry(_)(action.accept)) } def replaceAll(function: BiFunction[_ >: K, _ >: V, _ <: V]): Unit = { - for (entry <- entrySet().scalaOps) - entry.setValue(function.apply(entry.getKey(), entry.getValue())) + Objects.requireNonNull(function) + entrySet().forEach(entry => + usingEntry(entry) { (k, v) => + val newValue = function.apply(k, v) + try entry.setValue(newValue) + catch { + case ex: IllegalStateException => + throw new ConcurrentModificationException(ex) + } + } + ) } def putIfAbsent(key: K, value: V): V = { @@ -136,6 +145,27 @@ trait Map[K, V] { else remove(key) } + + /** Helper method used to detect concurrent modification exception when + * accessing map entires. IllegalStateException means the entry is no longer + * available (remove) + */ + @alwaysinline + protected[util] def usingEntry[T]( + entry: Map.Entry[K, V] + )(apply: (K, V) => T) = { + var key: K = null.asInstanceOf[K] + var value: V = null.asInstanceOf[V] + + try { + key = entry.getKey() + value = entry.getValue() + } catch { + case ex: IllegalStateException => + throw new ConcurrentModificationException(ex) + } + apply(key, value) + } } object Map { diff --git a/javalib/src/main/scala/java/util/concurrent/ConcurrentMap.scala b/javalib/src/main/scala/java/util/concurrent/ConcurrentMap.scala index 58502cdff8..410f7dd0dc 100644 --- a/javalib/src/main/scala/java/util/concurrent/ConcurrentMap.scala +++ b/javalib/src/main/scala/java/util/concurrent/ConcurrentMap.scala @@ -1,12 +1,134 @@ -// Ported from Scala.js commit: bbf0314 dated: Mon, 13 Jun 2022 - +/* + * Ported from JSR-166 + * Written by Doug Lea with assistance from members of JCP JSR-166 + * Expert Group and released to the public domain, as explained at + * http://creativecommons.org/publicdomain/zero/1.0/ + */ package java.util.concurrent import java.util._ +import java.util.function.{BiFunction, Function, BiConsumer} +import java.{util => ju} trait ConcurrentMap[K, V] extends Map[K, V] { def putIfAbsent(key: K, value: V): V def remove(key: Any, value: Any): Boolean def replace(key: K, oldValue: V, newValue: V): Boolean def replace(key: K, value: V): V + + // Concurrency aware overrides + // JDK assumes ConcurrentMap cannot contain null values + override def getOrDefault(key: Any, defaultValue: V): V = get(key) match { + case null => defaultValue + case v => v + } + + override def forEach(action: BiConsumer[? >: K, ? >: V]): Unit = { + Objects.requireNonNull(action) + entrySet().forEach(usingEntry(_)(action.accept)) + } + + override def replaceAll( + function: BiFunction[? >: K, ? >: V, ? <: V] + ): Unit = { + Objects.requireNonNull(function) + forEach { (k, _v) => + var break = false + var v = _v + while (!break && !replace(k, v, function.apply(k, v))) { + v = get(k) + if (v == null) break = true + } + } + } + + override def computeIfAbsent( + key: K, + mappingFunction: Function[? >: K, ? <: V] + ): V = { + Objects.requireNonNull(mappingFunction) + + val oldValue = get(key) + if (oldValue != null) oldValue + else { + val newValue = mappingFunction.apply(key) + if (newValue == null) oldValue + else { + putIfAbsent(key, newValue) match { + case null => newValue + case oldValue => oldValue + } + } + } + } + + override def computeIfPresent( + key: K, + remappingFunction: BiFunction[? >: K, ? >: V, ? <: V] + ): V = { + Objects.requireNonNull(remappingFunction) + while ({ + val oldValue = get(key) + if (oldValue == null) return null.asInstanceOf[V] + else { + val newValue = remappingFunction.apply(key, oldValue) + val updated = + if (newValue == null) remove(key, oldValue) + else replace(key, oldValue, newValue) + if (updated) return newValue + true + } + }) () + // unreachable + null.asInstanceOf[V] + } + + override def compute( + key: K, + remappingFunction: BiFunction[? >: K, ? >: V, ? <: V] + ): V = { + var oldValue = get(key) + while (true) { // haveOldValue + // if putIfAbsent fails, opportunistically use its return value + val newValue = remappingFunction.apply(key, oldValue) + if (newValue != null) { + if (oldValue != null) { + if (replace(key, oldValue, newValue)) return newValue + } else { + oldValue = putIfAbsent(key, newValue) + if (oldValue == null) return newValue + else () // continue haveOldValue + } + } else if (oldValue == null || remove(key, oldValue)) { + return null.asInstanceOf[V] + } else oldValue = get(key) + } + // unreachable + return null.asInstanceOf[V] + } + + override def merge( + key: K, + value: V, + remappingFunction: BiFunction[? >: V, ? >: V, ? <: V] + ): V = { + Objects.requireNonNull(remappingFunction) + Objects.requireNonNull(value) + var oldValue = get(key) + while (true) { // haveOldValue + if (oldValue != null) { + val newValue = remappingFunction.apply(oldValue, value) + if (newValue != null) { + if (replace(key, oldValue, newValue)) return newValue + } else if (remove(key, oldValue)) return null.asInstanceOf[V] + else oldValue = get(key) + } else { + oldValue = putIfAbsent(key, value) + if (oldValue == null) return value + else () // continue haveOldValue + } + } + // unreachable + return null.asInstanceOf[V] + } } diff --git a/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt b/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt index 0abd4fbd53..e0de97a9d1 100644 --- a/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt +++ b/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt @@ -246,6 +246,3 @@ scala/util/TryTest.scala scala/math/BigIntTest.scala ### deadlocks maybe needs j.u.c.ConcurrentLinkedQueue scala/concurrent/impl/DefaultPromiseTest.scala - -# Bug, cannot find statically ConcurrentMap#computeIfPresent -scala/collection/convert/EqualsTest.scala \ No newline at end of file From 0cdd4b38dd759636d48db7736e4c42ea4fb5744d Mon Sep 17 00:00:00 2001 From: Rikito Taniguchi Date: Mon, 9 Oct 2023 21:23:29 +0900 Subject: [PATCH 36/51] Add last updated to each page beneath title based on git commit (#3520) * Cosmetic website / add last updated to each page based on git log * Remove unnecessary link to the next page * Update readthedocs.yml (cherry picked from commit 81b25a90895f5ec95619ec4fa6f595bb10f8079f) --- .github/workflows/build-docs.yml | 14 ++++++++++---- .readthedocs.yaml | 7 +++++++ docs/conf.py | 10 ++++++---- docs/index.rst | 3 +-- docs/requirements.txt | 3 +++ docs/sn_alabaster/layout.html | 27 +++++++++++++++++++++++++++ docs/sn_alabaster/theme.conf | 2 ++ scripts/makedocs | 7 +++---- 8 files changed, 59 insertions(+), 14 deletions(-) create mode 100644 docs/requirements.txt create mode 100644 docs/sn_alabaster/layout.html create mode 100644 docs/sn_alabaster/theme.conf diff --git a/.github/workflows/build-docs.yml b/.github/workflows/build-docs.yml index 9ccda128e2..2f37e7c90b 100644 --- a/.github/workflows/build-docs.yml +++ b/.github/workflows/build-docs.yml @@ -9,8 +9,14 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - - uses: ammaraskar/sphinx-action@0.4 with: - pre-build-command: "pip install Sphinx==7.0.1 recommonmark==0.7.1" - docs-folder: "docs/" - build-command: 'sphinx-build -b html . _build/html -W --keep-going -n' + fetch-depth: 0 # clone full repo to get last-updated dates + - uses: actions/setup-python@v4 + with: + python-version: '3.11' + - name: Install deps + run: | + pip install -r docs/requirements.txt + - name: Build docs + run: | + cd docs && SPHINXOPTS="-W" make html \ No newline at end of file diff --git a/.readthedocs.yaml b/.readthedocs.yaml index 7f28580630..56cf5d9fc5 100644 --- a/.readthedocs.yaml +++ b/.readthedocs.yaml @@ -7,7 +7,14 @@ build: os: ubuntu-22.04 tools: python: "3.11" + jobs: + post_checkout: + - git fetch --unshallow || true # for https://github.com/mgeier/sphinx-last-updated-by-git # Build documentation in the "docs/" directory with Sphinx sphinx: configuration: docs/conf.py + +python: + install: + - requirements: docs/requirements.txt diff --git a/docs/conf.py b/docs/conf.py index d0ba15ee84..896564cf0b 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -36,7 +36,7 @@ def generateScalaNativeCurrentYear(): # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. # recommonmark provides support for '.md' files -extensions = ['recommonmark'] +extensions = ['recommonmark', 'sphinx_last_updated_by_git'] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] @@ -92,7 +92,8 @@ def generateScalaNativeCurrentYear(): # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This patterns also effect to html_static_path and html_extra_path -exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] +# - '.venv' for https://github.com/sphinx-doc/sphinx/issues/2066 +exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store', 'requirements.txt', '.venv'] # The reST default role (used for this markup: `text`) to use for all # documents. @@ -131,7 +132,8 @@ def generateScalaNativeCurrentYear(): # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. # -html_theme = 'alabaster' +html_theme = 'sn_alabaster' +html_theme_path = ["."] # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the @@ -177,7 +179,7 @@ def generateScalaNativeCurrentYear(): # bottom, using the given strftime format. # The empty string is equivalent to '%b %d, %Y'. # -# html_last_updated_fmt = None +html_last_updated_fmt = '%Y-%m-%d %H:%M:%S' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. diff --git a/docs/index.rst b/docs/index.rst index c07d607ac3..34b58469f4 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -2,8 +2,7 @@ Scala Native ============ -- Version: |release| -- Document built: |today| +Version: |release| Scala Native is an optimizing ahead-of-time compiler and lightweight managed runtime designed specifically for Scala. It features: diff --git a/docs/requirements.txt b/docs/requirements.txt new file mode 100644 index 0000000000..40eb7621d0 --- /dev/null +++ b/docs/requirements.txt @@ -0,0 +1,3 @@ +recommonmark==0.7.1 +Sphinx==7.2.6 +sphinx-last-updated-by-git==0.3.6 diff --git a/docs/sn_alabaster/layout.html b/docs/sn_alabaster/layout.html new file mode 100644 index 0000000000..01b37e7578 --- /dev/null +++ b/docs/sn_alabaster/layout.html @@ -0,0 +1,27 @@ +{% extends "alabaster/layout.html" %} + +{# +Insert the last updated time below the page title +We need to do this using JavaScript since the page body is built before the theme applies +https://www.sphinx-doc.org/en/master/development/templating.html#working-with-the-builtin-templates +#} +{%- block extrahead %} + + + {{ super() }} +{%- endblock %} \ No newline at end of file diff --git a/docs/sn_alabaster/theme.conf b/docs/sn_alabaster/theme.conf new file mode 100644 index 0000000000..a83db1765b --- /dev/null +++ b/docs/sn_alabaster/theme.conf @@ -0,0 +1,2 @@ +[theme] +inherit = alabaster \ No newline at end of file diff --git a/scripts/makedocs b/scripts/makedocs index a291abdf3e..f246de92b4 100755 --- a/scripts/makedocs +++ b/scripts/makedocs @@ -1,7 +1,7 @@ #!/usr/bin/env bash cd docs function create_venv { - virtualenv .venv + python -m venv .venv } function activate_venv { @@ -9,12 +9,11 @@ function activate_venv { } function install_req { - pip install Sphinx==4.2.0 - pip install recommonmark==0.7.1 + pip install -r ../docs/requirements.txt } function generate_docs { - make html + make SPHINX_OPTS="-W" html } function usage { From a8b83bb701952a5c7eb8eb4e4ebc498173a9aa82 Mon Sep 17 00:00:00 2001 From: Anton Sviridov Date: Mon, 9 Oct 2023 14:24:34 +0200 Subject: [PATCH 37/51] Pass -soname and -install_name flags when linking dynamic library (#3547) This ensures that the result is portable and does not contain full library path (often including temporary target folder of build tool) --- .../scala/scala/scalanative/build/LLVM.scala | 20 ++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/tools/src/main/scala/scala/scalanative/build/LLVM.scala b/tools/src/main/scala/scala/scalanative/build/LLVM.scala index c36aa05a0c..582eaa132e 100644 --- a/tools/src/main/scala/scala/scalanative/build/LLVM.scala +++ b/tools/src/main/scala/scala/scalanative/build/LLVM.scala @@ -156,6 +156,7 @@ private[scalanative] object LLVM { platformsLinks ++ srclinks ++ gclinks } val linkopts = config.linkingOptions ++ links.map("-l" + _) + val flags = { val platformFlags = if (!config.targetsWindows) Nil @@ -170,8 +171,25 @@ private[scalanative] object LLVM { } Seq("-g") ++ ltoSupport } + + // This is to ensure that the load path of the resulting dynamic library + // only contains the library filename, instead of the full path + // (i.e. in the target folder of SBT build) - this would make the library + // non-portable + val linkNameFlags = { + val artifactName = outpath.getFileName().toString + if (config.compilerConfig.buildTarget == BuildTarget.LibraryDynamic) + if (config.targetsLinux) + List("-Wl,-soname", artifactName) + else if (config.targetsMac) + List("-Wl,-install_name", artifactName) + else Nil + else Nil + } + val output = Seq("-o", outpath.abs) - buildTargetLinkOpts ++ flto ++ platformFlags ++ output ++ target + + buildTargetLinkOpts ++ flto ++ platformFlags ++ linkNameFlags ++ output ++ target } val paths = objectsPaths.map(_.abs) // it's a fix for passing too many file paths to the clang compiler, From 25e4b0a79126efc472a82034a3ac6bdb17af5f40 Mon Sep 17 00:00:00 2001 From: Anton Sviridov Date: Mon, 9 Oct 2023 18:53:54 +0200 Subject: [PATCH 38/51] Attempt to use `ar` command for static libraries when possible (#3548) * Attempt to use `ar` command for static libraries when possible * Fix ar invocation withour MRI script * Correctly pass linker flags (cherry picked from commit 9b1b616e0c8dd7da496308d224b559b8e52fc94a) --- .../scala/scalanative/build/Discover.scala | 24 +++++++-- .../scala/scala/scalanative/build/LLVM.scala | 52 +++++++++++++------ 2 files changed, 58 insertions(+), 18 deletions(-) diff --git a/tools/src/main/scala/scala/scalanative/build/Discover.scala b/tools/src/main/scala/scala/scalanative/build/Discover.scala index 56bff1a781..2cceeea0bc 100644 --- a/tools/src/main/scala/scala/scalanative/build/Discover.scala +++ b/tools/src/main/scala/scala/scalanative/build/Discover.scala @@ -158,14 +158,23 @@ object Discover { private[scalanative] val docSetup = "http://www.scala-native.org/en/latest/user/setup.html" + private[scalanative] def tryDiscover( + binaryName: String, + envPath: String + ): Try[Path] = Try(discover(binaryName, envPath)) + + private[scalanative] def tryDiscover( + binaryName: String + ): Try[Path] = Try(discover(binaryName)) + /** Discover the binary path using environment variables or the command from * the path. */ private[scalanative] def discover( binaryName: String, - envPath: String + envPath: Option[String] ): Path = { - val binPath = sys.env.get(envPath) + val binPath = envPath.flatMap(sys.env.get(_)) val command: Seq[String] = { if (Platform.isWindows) { @@ -185,14 +194,23 @@ object Discover { .map { p => Paths.get(p) } .headOption .getOrElse { + val envMessage = envPath + .map(envPath => s"or via '$envPath' environment variable") + .getOrElse("") throw new BuildException( - s"""'$binaryName' not found in PATH or via '$envPath' environment variable. + s"""'$binaryName' not found in PATH$envMessage. |Please refer to ($docSetup)""".stripMargin ) } path } + private[scalanative] def discover(binaryName: String, envPath: String): Path = + discover(binaryName, Some(envPath)) + + private[scalanative] def discover(binaryName: String): Path = + discover(binaryName, None) + /** Detect the target architecture. * * @param clang diff --git a/tools/src/main/scala/scala/scalanative/build/LLVM.scala b/tools/src/main/scala/scala/scalanative/build/LLVM.scala index 582eaa132e..700083871d 100644 --- a/tools/src/main/scala/scala/scalanative/build/LLVM.scala +++ b/tools/src/main/scala/scala/scalanative/build/LLVM.scala @@ -180,9 +180,9 @@ private[scalanative] object LLVM { val artifactName = outpath.getFileName().toString if (config.compilerConfig.buildTarget == BuildTarget.LibraryDynamic) if (config.targetsLinux) - List("-Wl,-soname", artifactName) + List(s"-Wl,-soname,$artifactName") else if (config.targetsMac) - List("-Wl,-install_name", artifactName) + List(s"-Wl,-install_name,$artifactName") else Nil else Nil } @@ -220,12 +220,14 @@ private[scalanative] object LLVM { outpath: Path )(implicit config: Config) = { val workdir = config.workdir - val llvmAR = Discover.discover("llvm-ar", "LLVM_BIN") - val MIRScriptFile = workdir.resolve("MIRScript").toFile - val pw = new PrintWriter(MIRScriptFile) - try { - pw.println(s"CREATE ${escapeWhitespaces(outpath.abs)}") - objectPaths.foreach { path => + + val MRICompatibleAR = + Discover.tryDiscover("llvm-ar", "LLVM_BIN").toOption orElse + // MacOS ar command does not support -M flag... + Discover.tryDiscover("ar").toOption.filter(_ => config.targetsLinux) + + def stageFiles(): Seq[String] = { + objectPaths.map { path => val uniqueName = workdir .relativize(path) @@ -233,16 +235,36 @@ private[scalanative] object LLVM { .replace(File.separator, "_") val newPath = workdir.resolve(uniqueName) Files.move(path, newPath, StandardCopyOption.REPLACE_EXISTING) - pw.println(s"ADDMOD ${escapeWhitespaces(newPath.abs)}") + newPath.abs } - pw.println("SAVE") - pw.println("END") - } finally pw.close() + } - val command = Seq(llvmAR.abs, "-M") - config.logger.running(command) + def useMRIScript(ar: Path) = { + val MIRScriptFile = workdir.resolve("MIRScript").toFile + val pw = new PrintWriter(MIRScriptFile) + try { + pw.println(s"CREATE ${escapeWhitespaces(config.buildPath.abs)}") + stageFiles().foreach { path => + pw.println(s"ADDMOD ${escapeWhitespaces(path)}") + } + pw.println("SAVE") + pw.println("END") + } finally pw.close() + + val command = Seq(ar.abs, "-M") + config.logger.running(command) - Process(command, config.workdir.toFile()) #< MIRScriptFile + Process(command, config.workdir.toFile()) #< MIRScriptFile + } + + MRICompatibleAR match { + case None => + val ar = Discover.discover("ar") + val command = Seq(ar.abs, "rc", config.buildPath.abs) ++ stageFiles() + config.logger.running(command) + Process(command, config.workdir.toFile()) + case Some(path) => useMRIScript(path) + } } /** Checks the input timestamp to see if the file needs compiling. The call to From 65519519c6246f9e22cedbf7044c643846623e75 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Fri, 13 Oct 2023 13:04:42 +0200 Subject: [PATCH 39/51] After rebase fixes --- .../main/scala/java/nio/ByteArrayBits.scala | 26 +++++++++--------- .../scalanative/runtime/Arrays.scala.gyb | 6 ++--- .../run/java-net-socket/SocketHelpers.scala | 27 +++++++++++++++++++ .../scala/scala/scalanative/build/LLVM.scala | 4 +-- .../scala/scalanative/codegen/Metadata.scala | 2 +- .../scala/scala/scalanative/util/Stats.scala | 3 ++- 6 files changed, 48 insertions(+), 20 deletions(-) diff --git a/javalib/src/main/scala/java/nio/ByteArrayBits.scala b/javalib/src/main/scala/java/nio/ByteArrayBits.scala index 26014f60ac..8f19f57124 100644 --- a/javalib/src/main/scala/java/nio/ByteArrayBits.scala +++ b/javalib/src/main/scala/java/nio/ByteArrayBits.scala @@ -1,7 +1,7 @@ package java.nio import scala.scalanative.runtime.{Intrinsics, toRawPtr} -import scala.scalanative.runtime.Intrinsics.{elemRawPtr, castIntToRawSize} +import scala.scalanative.runtime.Intrinsics.{elemRawPtr} import scala.scalanative.unsafe._ private[nio] object ByteArrayBits { @@ -27,35 +27,35 @@ private[nio] final class ByteArrayBits( def loadChar(index: Int): Char = { val idx = indexMultiplier * index + arrayOffset val loaded = - Intrinsics.loadChar(elemRawPtr(toRawPtr(array), castIntToRawSize(idx))) + Intrinsics.loadChar(elemRawPtr(toRawPtr(array), idx)) if (isBigEndian) java.lang.Character.reverseBytes(loaded) else loaded } def loadShort(index: Int): Short = { val idx = indexMultiplier * index + arrayOffset val loaded = - Intrinsics.loadShort(elemRawPtr(toRawPtr(array), castIntToRawSize(idx))) + Intrinsics.loadShort(elemRawPtr(toRawPtr(array), idx)) if (isBigEndian) java.lang.Short.reverseBytes(loaded) else loaded } def loadInt(index: Int): Int = { val idx = indexMultiplier * index + arrayOffset val loaded = - Intrinsics.loadInt(elemRawPtr(toRawPtr(array), castIntToRawSize(idx))) + Intrinsics.loadInt(elemRawPtr(toRawPtr(array), idx)) if (isBigEndian) java.lang.Integer.reverseBytes(loaded) else loaded } def loadLong(index: Int): Long = { val idx = indexMultiplier * index + arrayOffset val loaded = - Intrinsics.loadLong(elemRawPtr(toRawPtr(array), castIntToRawSize(idx))) + Intrinsics.loadLong(elemRawPtr(toRawPtr(array), idx)) if (isBigEndian) java.lang.Long.reverseBytes(loaded) else loaded } def loadFloat(index: Int): Float = { val idx = indexMultiplier * index + arrayOffset val loaded = - Intrinsics.loadInt(elemRawPtr(toRawPtr(array), castIntToRawSize(idx))) + Intrinsics.loadInt(elemRawPtr(toRawPtr(array), idx)) val ordered = if (isBigEndian) java.lang.Integer.reverseBytes(loaded) else loaded @@ -64,7 +64,7 @@ private[nio] final class ByteArrayBits( def loadDouble(index: Int): Double = { val idx = indexMultiplier * index + arrayOffset val loaded = - Intrinsics.loadLong(elemRawPtr(toRawPtr(array), castIntToRawSize(idx))) + Intrinsics.loadLong(elemRawPtr(toRawPtr(array), idx)) val ordered = if (isBigEndian) java.lang.Long.reverseBytes(loaded) else loaded @@ -77,7 +77,7 @@ private[nio] final class ByteArrayBits( if (isBigEndian) java.lang.Character.reverseBytes(v) else v Intrinsics.storeChar( - elemRawPtr(toRawPtr(array), castIntToRawSize(idx)), + elemRawPtr(toRawPtr(array), idx), ordered ) } @@ -88,7 +88,7 @@ private[nio] final class ByteArrayBits( if (isBigEndian) java.lang.Short.reverseBytes(v) else v Intrinsics.storeShort( - elemRawPtr(toRawPtr(array), castIntToRawSize(idx)), + elemRawPtr(toRawPtr(array), idx), ordered ) } @@ -98,7 +98,7 @@ private[nio] final class ByteArrayBits( if (isBigEndian) java.lang.Integer.reverseBytes(v) else v Intrinsics.storeInt( - elemRawPtr(toRawPtr(array), castIntToRawSize(idx)), + elemRawPtr(toRawPtr(array), idx), ordered ) } @@ -108,7 +108,7 @@ private[nio] final class ByteArrayBits( if (isBigEndian) java.lang.Long.reverseBytes(v) else v Intrinsics.storeLong( - elemRawPtr(toRawPtr(array), castIntToRawSize(idx)), + elemRawPtr(toRawPtr(array), idx), ordered ) } @@ -119,7 +119,7 @@ private[nio] final class ByteArrayBits( if (isBigEndian) java.lang.Integer.reverseBytes(asInt) else asInt Intrinsics.storeInt( - elemRawPtr(toRawPtr(array), castIntToRawSize(idx)), + elemRawPtr(toRawPtr(array), idx), ordered ) } @@ -130,7 +130,7 @@ private[nio] final class ByteArrayBits( if (isBigEndian) java.lang.Long.reverseBytes(asLong) else asLong Intrinsics.storeLong( - elemRawPtr(toRawPtr(array), castIntToRawSize(idx)), + elemRawPtr(toRawPtr(array), idx), ordered ) } diff --git a/nativelib/src/main/scala/scala/scalanative/runtime/Arrays.scala.gyb b/nativelib/src/main/scala/scala/scalanative/runtime/Arrays.scala.gyb index 5ff7d3a7ea..0c10614b43 100644 --- a/nativelib/src/main/scala/scala/scalanative/runtime/Arrays.scala.gyb +++ b/nativelib/src/main/scala/scala/scalanative/runtime/Arrays.scala.gyb @@ -199,7 +199,7 @@ final class ${T}Array private () extends Array[${T}] { @inline override def clone(): ${T}Array = { val arrcls = classOf[${T}Array] - val arrsize = ULong.valueOf(MemoryLayout.Array.ValuesOffset + ${sizeT} * length) + val arrsize = new ULong(MemoryLayout.Array.ValuesOffset + ${sizeT} * length) val arr = ${alloc}(arrcls, arrsize) val src = castObjectToRawPtr(this) libc.memcpy(arr, src, arrsize) @@ -215,7 +215,7 @@ object ${T}Array { } val arrcls = classOf[${T}Array] - val arrsize = ULong.valueOf(MemoryLayout.Array.ValuesOffset + ${sizeT} * length) + val arrsize = new ULong(MemoryLayout.Array.ValuesOffset + ${sizeT} * length) val arr = ${alloc}(arrcls, arrsize) storeInt(elemRawPtr(arr, MemoryLayout.Array.LengthOffset), length) storeInt(elemRawPtr(arr, MemoryLayout.Array.StrideOffset), ${sizeT}) @@ -226,7 +226,7 @@ object ${T}Array { val arr = alloc(length) val dst = arr.atRaw(0) val src = data - val size = ULong.valueOf(${sizeT} * length) + val size = new ULong(${sizeT} * length) libc.memcpy(dst, src, size) arr } diff --git a/scripted-tests/run/java-net-socket/SocketHelpers.scala b/scripted-tests/run/java-net-socket/SocketHelpers.scala index 9caa1a7c8c..30ebab2216 100644 --- a/scripted-tests/run/java-net-socket/SocketHelpers.scala +++ b/scripted-tests/run/java-net-socket/SocketHelpers.scala @@ -5,8 +5,10 @@ import scala.scalanative.unsafe._ import scala.scalanative.posix.{netdb, netdbOps}, netdb._, netdbOps._ import scala.scalanative.posix.netinet.in +import scala.scalanative.posix.netinet.inOps._ import scala.scalanative.posix.sys.socket._ import scala.scalanative.posix.sys.socketOps._ +import scala.scalanative.posix.string.memcpy import scala.scalanative.meta.LinktimeInfo.isWindows @@ -130,6 +132,31 @@ object SocketHelpers { } } + private[net] def sockaddrToByteArray(sockAddr: Ptr[sockaddr]): Array[Byte] = { + + val (src, byteArraySize) = { + val af = sockAddr.sa_family.toInt + if (af == AF_INET6) { + val v6addr = sockAddr.asInstanceOf[Ptr[in.sockaddr_in6]] + val sin6Addr = v6addr.sin6_addr.at1.asInstanceOf[Ptr[Byte]] + val arraySize = 16 + (sin6Addr, arraySize) + } else if (af == AF_INET) { + val v4addr = sockAddr.asInstanceOf[Ptr[in.sockaddr_in]] + val sin4Addr = v4addr.sin_addr.at1.asInstanceOf[Ptr[Byte]] + val arraySize = 4 + (sin4Addr, arraySize) + } else { + throw new SocketException(s"Unsupported address family: ${af}") + } + } + + val byteArray = new Array[Byte](byteArraySize) + memcpy(byteArray.at(0), src, byteArraySize.toUInt) + + byteArray + } + // Create copies of loopback & wildcard, so that originals never get changed // ScalaJVM shows loopbacks with null host, wildcards with numeric host. diff --git a/tools/src/main/scala/scala/scalanative/build/LLVM.scala b/tools/src/main/scala/scala/scalanative/build/LLVM.scala index 700083871d..25d1aa9cb5 100644 --- a/tools/src/main/scala/scala/scalanative/build/LLVM.scala +++ b/tools/src/main/scala/scala/scalanative/build/LLVM.scala @@ -243,7 +243,7 @@ private[scalanative] object LLVM { val MIRScriptFile = workdir.resolve("MIRScript").toFile val pw = new PrintWriter(MIRScriptFile) try { - pw.println(s"CREATE ${escapeWhitespaces(config.buildPath.abs)}") + pw.println(s"CREATE ${escapeWhitespaces(outpath.abs)}") stageFiles().foreach { path => pw.println(s"ADDMOD ${escapeWhitespaces(path)}") } @@ -260,7 +260,7 @@ private[scalanative] object LLVM { MRICompatibleAR match { case None => val ar = Discover.discover("ar") - val command = Seq(ar.abs, "rc", config.buildPath.abs) ++ stageFiles() + val command = Seq(ar.abs, "rc", outpath.abs) ++ stageFiles() config.logger.running(command) Process(command, config.workdir.toFile()) case Some(path) => useMRIScript(path) diff --git a/tools/src/main/scala/scala/scalanative/codegen/Metadata.scala b/tools/src/main/scala/scala/scalanative/codegen/Metadata.scala index 2906f893c9..5e049ad2a0 100644 --- a/tools/src/main/scala/scala/scalanative/codegen/Metadata.scala +++ b/tools/src/main/scala/scala/scalanative/codegen/Metadata.scala @@ -72,7 +72,7 @@ class Metadata(val linked: linker.Result, proxies: Seq[Defn])(implicit Rt.PrimitiveTypes.foreach(fromRootClass(_)) fromRootClass( - Rt.Object.name, + Rt.Object.name.asInstanceOf[Global.Top], ordering = subclasses => { val (arrays, other) = subclasses.partition(_.name == Rt.GenericArray.name) diff --git a/util/src/main/scala/scala/scalanative/util/Stats.scala b/util/src/main/scala/scala/scalanative/util/Stats.scala index 6934bac0f1..d2f871bcb1 100644 --- a/util/src/main/scala/scala/scalanative/util/Stats.scala +++ b/util/src/main/scala/scala/scalanative/util/Stats.scala @@ -2,6 +2,7 @@ package scala.scalanative package util import scala.collection.mutable +import scala.annotation.nowarn object Stats { private val times = mutable.Map.empty[String, Long] @@ -73,7 +74,7 @@ object Stats { counts.clear() } private def threadKey(key: String): String = - "" + java.lang.Thread.currentThread.getId + ":" + key + "" + java.lang.Thread.currentThread.getId + ":" + key: @nowarn def in[T](f: => T): T = { clear() val res = f From 0d66202ca16af6ba719f4ac9e04fc51ae8723d7b Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Fri, 13 Oct 2023 13:42:28 +0200 Subject: [PATCH 40/51] Add limited Scala 3.3.1 support --- .github/workflows/publish.yml | 2 +- .../workflows/run-jdk-compliance-tests.yml | 16 ++++--------- .../workflows/run-tests-linux-multiarch.yml | 2 +- .github/workflows/run-tests-linux.yml | 24 +++++++++---------- .github/workflows/run-tests-macos.yml | 14 +++++------ .github/workflows/run-tests-windows.yml | 16 ++++++------- project/ScalaVersions.scala | 5 ++-- project/Settings.scala | 1 - 8 files changed, 36 insertions(+), 44 deletions(-) diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index fa3108e6d6..e6c86ecbcb 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -24,7 +24,7 @@ jobs: - uses: actions/checkout@v3 - uses: ./.github/actions/linux-setup-env with: - scala-version: "2.13.11" #Unused, any version can be placed here + scala-version: "2.13.12" #Unused, any version can be placed here java-version: 8 - name: Setup PGP Key diff --git a/.github/workflows/run-jdk-compliance-tests.yml b/.github/workflows/run-jdk-compliance-tests.yml index c69f894733..b8cc6899a4 100644 --- a/.github/workflows/run-jdk-compliance-tests.yml +++ b/.github/workflows/run-jdk-compliance-tests.yml @@ -20,13 +20,9 @@ jobs: fail-fast: false matrix: os: [ubuntu-20.04, macos-11] - scala: [3.3.1] - java: [11, 17] + scala: [3.3.1, 2.13.8] + java: [11, 17, 21] include: - # Does not compile with Scala 3 yet - # - java: 21 - # scala: 2.13.12 - # os: ubuntu-20.04 - java: 17 scala: 2.13.12 os: ubuntu-20.04 @@ -55,12 +51,8 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.0] - java: [11, 17] - # Does not compile with Scala 3 yet - # include: - # - java: 21 - # scala: 2.13.12 + scala: [3.3.1, 2.13.12] + java: [11, 17, 21] steps: # Disable autocrlf setting, otherwise scalalib patches might not be possible to apply - name: Setup git config diff --git a/.github/workflows/run-tests-linux-multiarch.yml b/.github/workflows/run-tests-linux-multiarch.yml index 4004358827..a3efbed728 100644 --- a/.github/workflows/run-tests-linux-multiarch.yml +++ b/.github/workflows/run-tests-linux-multiarch.yml @@ -79,7 +79,7 @@ jobs: fail-fast: false matrix: arch: [linux-arm64] - scala: [2.13.10, 3.3.0] + scala: [2.13.10, 3.3.1] build-mode: [debug, release-fast] lto: [none, thin] gc: [boehm, immix, commix] diff --git a/.github/workflows/run-tests-linux.yml b/.github/workflows/run-tests-linux.yml index 290ab82f2c..638c428179 100644 --- a/.github/workflows/run-tests-linux.yml +++ b/.github/workflows/run-tests-linux.yml @@ -20,7 +20,7 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.0, 2.13.11, 2.12.18] + scala: [3.3.1, 2.13.12, 2.12.18] steps: - uses: actions/checkout@v3 - uses: ./.github/actions/linux-setup-env @@ -58,7 +58,7 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.0, 2.13.11, 2.12.18] + scala: [3.3.1, 2.13.12, 2.12.18] if: "(github.event_name == 'schedule' || github.event_name == 'workflow_call') && github.repository == 'scala-native/scala-native'" steps: - uses: actions/checkout@v3 @@ -77,10 +77,10 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.0] + scala: [3.3.1] gc: [none, boehm, immix, commix] include: - - scala: 2.13.11 + - scala: 2.13.12 gc: immix - scala: 2.12.18 gc: immix @@ -101,23 +101,23 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.0, 2.13.11] + scala: [3.3.1, 2.13.12] build-mode: [debug, release-fast] gc: [boehm, immix, commix] # Create holes in grid to lower number of tests. # Excluded entries should have low impact on overall project coverage exclude: # Covered in basic test-runtime - - scala: 3.3.0 + - scala: 3.3.1 build-mode: debug - - scala: 2.13.11 + - scala: 2.13.12 build-mode: debug gc: immix # Slow, leads to timeouts - build-mode: release-fast lto: none include: - - scala: 3.3.0 + - scala: 3.3.1 build-mode: release-size gc: commix - scala: 3.1.3 @@ -148,7 +148,7 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.0, 2.13.11] + scala: [3.3.1, 2.13.12] build-mode: [debug] steps: - uses: actions/checkout@v3 @@ -170,7 +170,7 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.0, 2.13.10] + scala: [3.3.1, 2.13.10] lto: [thin] optimize: [true] include: @@ -178,7 +178,7 @@ jobs: - scala: 2.13.10 lto: full optimize: true - - scala: 3.3.0 + - scala: 3.3.1 lto: full optimize: false @@ -204,7 +204,7 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.0] + scala: [3.3.1] llvm: [13, 14, 15, 16, 17] # Last 3 stable versions + available future versions if: "(github.event_name == 'schedule' || github.event_name == 'workflow_call') && github.repository == 'scala-native/scala-native'" steps: diff --git a/.github/workflows/run-tests-macos.yml b/.github/workflows/run-tests-macos.yml index 4c4e0c5513..ae7bdf8b04 100644 --- a/.github/workflows/run-tests-macos.yml +++ b/.github/workflows/run-tests-macos.yml @@ -17,7 +17,7 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.0] + scala: [3.3.1] gc: [none, boehm, immix, commix] include: - scala: 2.13.10 @@ -56,27 +56,27 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.0, 2.13.11] + scala: [3.3.1, 2.13.12] build-mode: [debug, release-fast] lto: [none, thin] gc: [boehm, immix, commix] exclude: # Covered in basic test-runtime - - scala: 3.3.0 + - scala: 3.3.1 build-mode: debug - - scala: 2.13.11 + - scala: 2.13.12 build-mode: debug gc: immix include: - - scala: 3.3.0 + - scala: 3.3.1 build-mode: release-size lto: thin gc: immix - - scala: 3.3.0 + - scala: 3.3.1 build-mode: release-full lto: thin gc: commix - - scala: 2.13.11 + - scala: 2.13.12 build-mode: release-full lto: full gc: commix diff --git a/.github/workflows/run-tests-windows.yml b/.github/workflows/run-tests-windows.yml index c283e54491..f14eb97bb6 100644 --- a/.github/workflows/run-tests-windows.yml +++ b/.github/workflows/run-tests-windows.yml @@ -17,7 +17,7 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.0, 2.13.10] + scala: [3.3.1, 2.13.10] gc: [none, boehm, immix, commix] include: - scala: 2.12.18 @@ -90,29 +90,29 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.0, 2.13.11] + scala: [3.3.1, 2.13.12] build-mode: [debug, release-fast] lto: [none, thin] gc: [boehm, immix, commix] exclude: # Covered in basic test-runtime - - scala: 3.3.0 + - scala: 3.3.1 build-mode: debug - - scala: 2.13.11 + - scala: 2.13.12 build-mode: debug gc: immix - build-mode: release-fast lto: none include: - - scala: 3.3.0 + - scala: 3.3.1 build-mode: release-size lto: thin gc: immix - - scala: 3.3.0 + - scala: 3.3.1 build-mode: release-full lto: thin gc: commix - - scala: 2.13.11 + - scala: 2.13.12 build-mode: release-full lto: full optimize: true @@ -149,7 +149,7 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.0] + scala: [3.3.1] llvm: ["13.0.1", "14.0.6", "15.0.7"] # Last 3 stable versions steps: - name: Setup git config diff --git a/project/ScalaVersions.scala b/project/ScalaVersions.scala index 019c61bd83..1011dc1b8e 100644 --- a/project/ScalaVersions.scala +++ b/project/ScalaVersions.scala @@ -23,12 +23,13 @@ object ScalaVersions { val crossScala3 = List( (0 to 3).map(v => s"3.1.$v"), (0 to 2).map(v => s"3.2.$v"), - (0 to 0).map(v => s"3.3.$v") + (0 to 1).map(v => s"3.3.$v") ).flatten // Version of Scala 3 standard library sources used for publishing // Workaround allowing to produce NIR for Scala 3.2.x+ and allowing to consume existing libraries using 3.1.x - val scala3libSourcesVersion = crossScala3.last + // 3.3.0 is the last version which can be compiled using 3.1.3 compiler + val scala3libSourcesVersion = "3.3.0" // Scala versions used for publishing libraries val scala212: String = crossScala212.last diff --git a/project/Settings.scala b/project/Settings.scala index 6834555d62..d261dfbdda 100644 --- a/project/Settings.scala +++ b/project/Settings.scala @@ -320,7 +320,6 @@ object Settings { .takeWhile(_.isDigit) .toInt >= 2 => useLightweightLazyVals - case (3, minor) if minor >= 3 => useLightweightLazyVals } }, Test / testOptions ++= Seq( From c95d230c48d4d924ffba9be7ae69daeb5dcac6e5 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Fri, 13 Oct 2023 14:08:13 +0200 Subject: [PATCH 41/51] Add release notes for 0.4.16 --- docs/changelog/0.4.16.md | 124 +++++++++++++++++++++++++++++++++++++++ docs/changelog/index.rst | 1 + scripts/changelog.scala | 52 +--------------- 3 files changed, 127 insertions(+), 50 deletions(-) create mode 100644 docs/changelog/0.4.16.md diff --git a/docs/changelog/0.4.16.md b/docs/changelog/0.4.16.md new file mode 100644 index 0000000000..414ec7e287 --- /dev/null +++ b/docs/changelog/0.4.16.md @@ -0,0 +1,124 @@ + +# 0.4.16 (2023-10-13) + +We're happy to announce the release of Scala Native. +Scala Native 0.4.16 is yet another maintenance release backporting changed from the 0.5.0-SNAPSHOT branch. +This version introduces support for using Scala Native with JDK 21 and introduces bug fixes to the runtime. +It also fixes severe performance problems when using `java.nio.MappedByteBuffers`. + + +Scala standard library used by this release is based on the following versions: + + + + + + + + + + + + + + + + + + + +
Scala binary versionScala release
2.122.12.18
2.132.13.12
33.3.0
+ + + + + + + + + + + + + + + + +
Commits since last release40
Merged PRs23
Contributors10
+ +## Contributors + +Big thanks to everybody who contributed to this release or reported an issue! + +``` +$ git shortlog -sn --no-merges v0.4.15..v0.4.16 + 20 Wojciech Mazur + 5 LeeTibbert + 4 Rikito Taniguchi + 3 He-Pin + 2 Anton Sviridov + 2 kerr + 1 Eric K Richardson + 1 Jonas Spenger + 1 Lorenzo Gabriele + 1 Natsu Kagami +``` + +## Merged PRs + +## [v0.4.16](https://github.com/scala-native/scala-native/tree/v0.4.16) (2023-10-13) + +[Full Changelog](https://github.com/scala-native/scala-native/compare/v0.4.15...v0.4.16) + +**Merged pull requests:** + +### Java Standard Library +- Fix `java.lang.String.offsetByCodePoints` for unpaired surrogates + [\#3471](https://github.com/scala-native/scala-native/pull/3471) + ([tanishiking](https://github.com/tanishiking)) +- Fix #3477: `java.nio.channel.Channels.newChannel#read` now reports EOF + [\#3478](https://github.com/scala-native/scala-native/pull/3478) + ([LeeTibbert](https://github.com/LeeTibbert)) +- Add `java.nio.file.AccessMode` and `ReadOnlyFileSystemException` + [\#3479](https://github.com/scala-native/scala-native/pull/3479) + ([LeeTibbert](https://github.com/LeeTibbert)) +- Add `java.util.concurrent.CompletionException` + [\#3482](https://github.com/scala-native/scala-native/pull/3482) + ([He-Pin](https://github.com/He-Pin)) +- Fix `Class.isAssignableFrom` for primitive types + [\#3510](https://github.com/scala-native/scala-native/pull/3510) + ([WojciechMazur](https://github.com/WojciechMazur)) +- Fix performance problems of `java.nio.file.MappedByteBuffer` + [\#3521](https://github.com/scala-native/scala-native/pull/3521) + ([WojciechMazur](https://github.com/WojciechMazur)) +- Implement `java.lang.Math.multiplyHigh` for Long + [\#3480](https://github.com/scala-native/scala-native/pull/3480) + ([jonasspenger](https://github.com/jonasspenger)) +- Add missing overrides in `java.util.concurrent.ConcurrentMap` + [\#3527](https://github.com/scala-native/scala-native/pull/3527) + ([WojciechMazur](https://github.com/WojciechMazur)) + +### Scala Native Runtime Library +- Faster `scala.scalanative.unsafe.Ptr.{apply, update}` by skipping unnecessary GC allocations + [\#3522](https://github.com/scala-native/scala-native/pull/3522) + ([WojciechMazur](https://github.com/WojciechMazur)) + +### Scala Native Toolchain +- Allow to build Scala Native on JDK 21 + [\#3492](https://github.com/scala-native/scala-native/pull/3492) + ([WojciechMazur](https://github.com/WojciechMazur)) +- Attempt to use `ar` command for static libraries when possible + [\#3548](https://github.com/scala-native/scala-native/pull/3548) + ([keynmol](https://github.com/keynmol)) +- Pass `-soname` and `-install_name` flags when linking dynamic library + [\#3548](https://github.com/scala-native/scala-native/pull/3547) + ([keynmol](https://github.com/keynmol)) + +### Docs +- Add contributing quickstart guide + [\#3496](https://github.com/scala-native/scala-native/pull/3496) + ([tanishiking](https://github.com/tanishiking)) +- Add last updated to each page beneath title based on git commit + [\#3520](https://github.com/scala-native/scala-native/pull/3520) + ([tanishiking](https://github.com/tanishiking)) + diff --git a/docs/changelog/index.rst b/docs/changelog/index.rst index 3608fd0184..cfc9b1f80a 100644 --- a/docs/changelog/index.rst +++ b/docs/changelog/index.rst @@ -6,6 +6,7 @@ Changelog .. toctree:: :maxdepth: 1 + 0.4.16 0.4.15 0.4.14 0.4.13 diff --git a/scripts/changelog.scala b/scripts/changelog.scala index 914807c29e..6853f40582 100644 --- a/scripts/changelog.scala +++ b/scripts/changelog.scala @@ -62,56 +62,8 @@ def main( val mergedPRs = ListBuffer[String]() for { // group in order to optimize API - searchSha <- Seq( - "3dd595bc1c5315d42178cc4a3f5434563ab32ea8", - "ecdf41394758a5d0c59f853048df01caa77c3b47", - "7460645f44bf69fdb0dd708efba8113eec53733a", - "4c4006c6534699db3697bc376b65d05f5dab4aab", - "ec2402fa4d9dbd1e51c01f680c3179f74ec40dc2", - "3339fe40eb648ae87c19567935d22215464bcef7", - "f0b390e4dacdefa74c04a8f663f93f6402ae70a5", - "0a6d1368227b41339fc8cc38f099eab0539c766a", - "8f28b34d1c88aff0cf03171cbae11f993fbacda5", - "36d32f015d5a024edf307cbd3e68e8ee90753a5d", - "2a0e7ec7f36068aaf859d5e8c68bf5ec5415f8a4", - "3273166af3540b05d02c7200df1a09ba95093d7d", - "b54e0698dc426d7164dac4fb709e4c16ef05aa36", - "56861600e3c66e5afc61f23641251b09439441c2", - "c4e9c81d84971ec0a80b018a060ef6acdb0a1ccd", - "5b5db373b6636421d1d3218b84926cb9e024d695", - "b1bba76a8dc42852d378e1fff0b4da9517522430", - "04a19fe8a2a50cee7bbb331854a9668c787ca1c4", - "513df72133187fb5dcf35a26d114459618922216", - "9f6b9b835bfd4e7c8d5be3e8f32abfb49ef1eb14", - "f3b1a31edcecafd3b40f94af2360d8fff98a753a", - "bc5b65f88d319ca8059c06928feed19826a796f7", - "0e181d49c6125caf1307cc3de5e043067e14f112", - "3544ba66ad33729e35459e57e7bec717c91b89e4", - "9e4775d0d21b90e492b5dc9216a59e5d98af2162", - "61f4230a0bb7fe6c0fc58496ffddf4fd319debf0", - "ce94cf563a17e162d4349ffdb1152e09028d999c", - "f97ac0d307f81154b5ae9b5d808f013eed2f4504", - "eb2caf722be4e513b97aa8c2a7d54c97e37e460c", - "a65fe110edbde7c9c26343b99cfcc01808f8c387", - "637972d8656f2323adcffb7c5acac7cd54d963ac", - "789b5f4b8dce383ba7371a3a71bd3e4df017e087", - "3bcc03e962b202b21515a2875e33050e756ea77d", - "990e16e12fbdadc235df17126d0791ce9545f6db", - "014f0addcac859c72af81274cd44d571d12eb159", - "d51279a6fbe100f1762e8a45f2e0bae356045f05", - "594e24fc967e75aea9997468b7cd7531e221c101", - "6a9e7c9c49842576dd1a760374f89a379ee96c37", - "01b4fa1208946a6d2d77cca3399655cedd504bae", - "4687be081943f0d60e38662ebcdb2b038b5d539c", - "8c87a9aaad3994d68b6b5bde61be3a6bc62eefeb", - "40ef9b4ba9bc8e3ecff3f955598f5f6a1ddd3876", - "582022549183c062db3ff25e89796e39e8b5ec7d", - "2179e7304f57e8469ad028fd2c449a4e8fd7c733", - "2c0161dc23857a30cec394b3843fedd47d3ce06d", - "54a7fb87d95c401cf228232bae8eac78f78875cc", - "54a7fb87d95c401cf228232bae8eac78f78875cc" - ) - // .split('\n') + searchSha <- output + .split('\n') .grouped(5) .map(_.mkString("SHA ", " SHA ", "")) allMatching = gh From 382eec78b02424bc2033e3ba3748440bf661796c Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Fri, 13 Oct 2023 14:17:10 +0200 Subject: [PATCH 42/51] Fix ConcurrentMap type wildcards on Scala 2 --- .../scala/java/util/concurrent/ConcurrentMap.scala | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/javalib/src/main/scala/java/util/concurrent/ConcurrentMap.scala b/javalib/src/main/scala/java/util/concurrent/ConcurrentMap.scala index 410f7dd0dc..36ceb88ec9 100644 --- a/javalib/src/main/scala/java/util/concurrent/ConcurrentMap.scala +++ b/javalib/src/main/scala/java/util/concurrent/ConcurrentMap.scala @@ -23,13 +23,13 @@ trait ConcurrentMap[K, V] extends Map[K, V] { case v => v } - override def forEach(action: BiConsumer[? >: K, ? >: V]): Unit = { + override def forEach(action: BiConsumer[_ >: K, _ >: V]): Unit = { Objects.requireNonNull(action) entrySet().forEach(usingEntry(_)(action.accept)) } override def replaceAll( - function: BiFunction[? >: K, ? >: V, ? <: V] + function: BiFunction[_ >: K, _ >: V, _ <: V] ): Unit = { Objects.requireNonNull(function) forEach { (k, _v) => @@ -44,7 +44,7 @@ trait ConcurrentMap[K, V] extends Map[K, V] { override def computeIfAbsent( key: K, - mappingFunction: Function[? >: K, ? <: V] + mappingFunction: Function[_ >: K, _ <: V] ): V = { Objects.requireNonNull(mappingFunction) @@ -64,7 +64,7 @@ trait ConcurrentMap[K, V] extends Map[K, V] { override def computeIfPresent( key: K, - remappingFunction: BiFunction[? >: K, ? >: V, ? <: V] + remappingFunction: BiFunction[_ >: K, _ >: V, _ <: V] ): V = { Objects.requireNonNull(remappingFunction) while ({ @@ -85,7 +85,7 @@ trait ConcurrentMap[K, V] extends Map[K, V] { override def compute( key: K, - remappingFunction: BiFunction[? >: K, ? >: V, ? <: V] + remappingFunction: BiFunction[_ >: K, _ >: V, _ <: V] ): V = { var oldValue = get(key) while (true) { // haveOldValue @@ -110,7 +110,7 @@ trait ConcurrentMap[K, V] extends Map[K, V] { override def merge( key: K, value: V, - remappingFunction: BiFunction[? >: V, ? >: V, ? <: V] + remappingFunction: BiFunction[_ >: V, _ >: V, _ <: V] ): V = { Objects.requireNonNull(remappingFunction) Objects.requireNonNull(value) From fa115cfc59c2fb1e52e62c1455935ec11ce5f0c4 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Fri, 13 Oct 2023 14:27:13 +0200 Subject: [PATCH 43/51] Fix linux CI --- .github/workflows/run-tests-linux.yml | 3 --- 1 file changed, 3 deletions(-) diff --git a/.github/workflows/run-tests-linux.yml b/.github/workflows/run-tests-linux.yml index 638c428179..ecdb7e666a 100644 --- a/.github/workflows/run-tests-linux.yml +++ b/.github/workflows/run-tests-linux.yml @@ -113,9 +113,6 @@ jobs: - scala: 2.13.12 build-mode: debug gc: immix - # Slow, leads to timeouts - - build-mode: release-fast - lto: none include: - scala: 3.3.1 build-mode: release-size From a33357819fa6191aa48385f598e25d4eb839233f Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Fri, 13 Oct 2023 14:56:45 +0200 Subject: [PATCH 44/51] Use Scala 2.13.12 instead of 2.13.8 in the CI --- .github/workflows/run-jdk-compliance-tests.yml | 2 +- .github/workflows/run-tests-linux-multiarch.yml | 4 ++-- .github/workflows/run-tests-linux.yml | 4 ++-- .github/workflows/run-tests-macos.yml | 4 ++-- .github/workflows/run-tests-windows.yml | 6 +++--- 5 files changed, 10 insertions(+), 10 deletions(-) diff --git a/.github/workflows/run-jdk-compliance-tests.yml b/.github/workflows/run-jdk-compliance-tests.yml index b8cc6899a4..e0e4543523 100644 --- a/.github/workflows/run-jdk-compliance-tests.yml +++ b/.github/workflows/run-jdk-compliance-tests.yml @@ -20,7 +20,7 @@ jobs: fail-fast: false matrix: os: [ubuntu-20.04, macos-11] - scala: [3.3.1, 2.13.8] + scala: [3.3.1, 2.13.12] java: [11, 17, 21] include: - java: 17 diff --git a/.github/workflows/run-tests-linux-multiarch.yml b/.github/workflows/run-tests-linux-multiarch.yml index a3efbed728..cb9537a3ef 100644 --- a/.github/workflows/run-tests-linux-multiarch.yml +++ b/.github/workflows/run-tests-linux-multiarch.yml @@ -79,7 +79,7 @@ jobs: fail-fast: false matrix: arch: [linux-arm64] - scala: [2.13.10, 3.3.1] + scala: [2.13.12, 3.3.1] build-mode: [debug, release-fast] lto: [none, thin] gc: [boehm, immix, commix] @@ -97,7 +97,7 @@ jobs: - gc: immix build-mode: debug - gc: immix - scala: 2.13.10 + scala: 2.13.12 - gc: commix lto: none - gc: commix diff --git a/.github/workflows/run-tests-linux.yml b/.github/workflows/run-tests-linux.yml index ecdb7e666a..cd5e0b51fc 100644 --- a/.github/workflows/run-tests-linux.yml +++ b/.github/workflows/run-tests-linux.yml @@ -167,12 +167,12 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.1, 2.13.10] + scala: [3.3.1, 2.13.12] lto: [thin] optimize: [true] include: # LTO full fails with 3.1 in the CI - we were not able to reproduce it locally - - scala: 2.13.10 + - scala: 2.13.12 lto: full optimize: true - scala: 3.3.1 diff --git a/.github/workflows/run-tests-macos.yml b/.github/workflows/run-tests-macos.yml index ae7bdf8b04..6b44626b90 100644 --- a/.github/workflows/run-tests-macos.yml +++ b/.github/workflows/run-tests-macos.yml @@ -20,9 +20,9 @@ jobs: scala: [3.3.1] gc: [none, boehm, immix, commix] include: - - scala: 2.13.10 + - scala: 2.13.12 gc: commix - - scala: 2.13.10 + - scala: 2.13.12 gc: none - scala: 2.12.18 gc: boehm diff --git a/.github/workflows/run-tests-windows.yml b/.github/workflows/run-tests-windows.yml index f14eb97bb6..5dae29dd05 100644 --- a/.github/workflows/run-tests-windows.yml +++ b/.github/workflows/run-tests-windows.yml @@ -17,12 +17,12 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.1, 2.13.10] + scala: [3.3.1, 2.13.12] gc: [none, boehm, immix, commix] include: - scala: 2.12.18 gc: immix - - scala: 2.13.10 + - scala: 2.13.12 gc: boehm steps: # Disable autocrlf setting, otherwise scalalib patches might not be possible to apply @@ -116,7 +116,7 @@ jobs: build-mode: release-full lto: full optimize: true - - scala: 2.12.17 + - scala: 2.12.18 lto: full optimize: false steps: From 7e149c56b228c72754ade881f7f3ac74c41e5431 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Fri, 13 Oct 2023 15:15:50 +0200 Subject: [PATCH 45/51] Make changes to unsafe.Tag binary compatible --- .../scala/scala/scalanative/unsafe/Tag.scala | 165 +++++++++++++++++- .../scala/scalanative/unsafe/Tag.scala.gyb | 29 ++- 2 files changed, 188 insertions(+), 6 deletions(-) diff --git a/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala b/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala index 44779dc221..c9126d905f 100644 --- a/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala +++ b/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala @@ -20,10 +20,9 @@ import scalanative.runtime.Intrinsics._ sealed abstract class Tag[T] { def size: CSize def alignment: CSize - @alwaysinline def load(ptr: unsafe.Ptr[T]): T = load(toRawPtr(ptr)) - @alwaysinline def store(ptr: unsafe.Ptr[T], value: T): Unit = store(toRawPtr(ptr), value) - @noinline def offset(idx: CSize): CSize = throwUndefined() + @noinline def load(ptr: unsafe.Ptr[T]): T = throwUndefined() + @noinline def store(ptr: unsafe.Ptr[T], value: T): Unit = throwUndefined() @noinline private[unsafe] def load(rawptr: RawPtr): T = throwUndefined() @noinline private[unsafe] def store(rawptr: RawPtr, value: T): Unit = throwUndefined() } @@ -33,6 +32,10 @@ object Tag { extends Tag[unsafe.Ptr[T]] { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.Ptr[T]]): unsafe.Ptr[T] = + load(toRawPtr(ptr)) + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.Ptr[T]], value: unsafe.Ptr[T]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.Ptr[T] = fromRawPtr[T](loadRawPtr(rawptr)) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.Ptr[T]): Unit = @@ -43,6 +46,10 @@ object Tag { extends Tag[T] { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[T]): T = + load(toRawPtr(ptr)) + @alwaysinline override def store(ptr: unsafe.Ptr[T], value: T): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): T = loadObject(rawptr).asInstanceOf[T] @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: T): Unit = @@ -52,8 +59,12 @@ object Tag { object Unit extends Tag[scala.Unit] { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[scala.Unit]): scala.Unit = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Unit = loadObject(rawptr).asInstanceOf[Unit] + @alwaysinline override def store(ptr: unsafe.Ptr[scala.Unit], value: scala.Unit): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Unit): Unit = storeObject(rawptr, value.asInstanceOf[Object]) } @@ -61,8 +72,12 @@ object Tag { object Boolean extends Tag[scala.Boolean] { @alwaysinline def size: CSize = 1.toULong @alwaysinline def alignment: CSize = 1.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[scala.Boolean]): scala.Boolean = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Boolean = loadBoolean(rawptr) + @alwaysinline override def store(ptr: unsafe.Ptr[scala.Boolean], value: scala.Boolean): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Boolean): Unit = storeBoolean(rawptr, value) } @@ -70,8 +85,12 @@ object Tag { object Char extends Tag[scala.Char] { @alwaysinline def size: CSize = 2.toULong @alwaysinline def alignment: CSize = 2.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[scala.Char]): scala.Char = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Char = loadChar(rawptr) + @alwaysinline override def store(ptr: unsafe.Ptr[scala.Char], value: scala.Char): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Char): Unit = storeChar(rawptr, value) } @@ -79,8 +98,12 @@ object Tag { object Byte extends Tag[scala.Byte] { @alwaysinline def size: CSize = 1.toULong @alwaysinline def alignment: CSize = 1.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[scala.Byte]): scala.Byte = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Byte = loadByte(rawptr) + @alwaysinline override def store(ptr: unsafe.Ptr[scala.Byte], value: scala.Byte): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Byte): Unit = storeByte(rawptr, value) } @@ -88,8 +111,12 @@ object Tag { object UByte extends Tag[unsigned.UByte] { @alwaysinline def size: CSize = 1.toULong @alwaysinline def alignment: CSize = 1.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[unsigned.UByte]): unsigned.UByte = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsigned.UByte = loadByte(rawptr).toUByte + @alwaysinline override def store(ptr: unsafe.Ptr[unsigned.UByte], value: unsigned.UByte): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsigned.UByte): Unit = storeByte(rawptr, value.toByte) } @@ -97,8 +124,12 @@ object Tag { object Short extends Tag[scala.Short] { @alwaysinline def size: CSize = 2.toULong @alwaysinline def alignment: CSize = 2.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[scala.Short]): scala.Short = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Short = loadShort(rawptr) + @alwaysinline override def store(ptr: unsafe.Ptr[scala.Short], value: scala.Short): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Short): Unit = storeShort(rawptr, value) } @@ -106,8 +137,12 @@ object Tag { object UShort extends Tag[unsigned.UShort] { @alwaysinline def size: CSize = 2.toULong @alwaysinline def alignment: CSize = 2.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[unsigned.UShort]): unsigned.UShort = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsigned.UShort = loadShort(rawptr).toUShort + @alwaysinline override def store(ptr: unsafe.Ptr[unsigned.UShort], value: unsigned.UShort): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsigned.UShort): Unit = storeShort(rawptr, value.toShort) } @@ -115,8 +150,12 @@ object Tag { object Int extends Tag[scala.Int] { @alwaysinline def size: CSize = 4.toULong @alwaysinline def alignment: CSize = 4.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[scala.Int]): scala.Int = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Int = loadInt(rawptr) + @alwaysinline override def store(ptr: unsafe.Ptr[scala.Int], value: scala.Int): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Int): Unit = storeInt(rawptr, value) } @@ -124,8 +163,12 @@ object Tag { object UInt extends Tag[unsigned.UInt] { @alwaysinline def size: CSize = 4.toULong @alwaysinline def alignment: CSize = 4.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[unsigned.UInt]): unsigned.UInt = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsigned.UInt = loadInt(rawptr).toUInt + @alwaysinline override def store(ptr: unsafe.Ptr[unsigned.UInt], value: unsigned.UInt): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsigned.UInt): Unit = storeInt(rawptr, value.toInt) } @@ -133,8 +176,12 @@ object Tag { object Long extends Tag[scala.Long] { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[scala.Long]): scala.Long = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Long = loadLong(rawptr) + @alwaysinline override def store(ptr: unsafe.Ptr[scala.Long], value: scala.Long): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Long): Unit = storeLong(rawptr, value) } @@ -142,8 +189,12 @@ object Tag { object ULong extends Tag[unsigned.ULong] { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[unsigned.ULong]): unsigned.ULong = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsigned.ULong = loadLong(rawptr).toULong + @alwaysinline override def store(ptr: unsafe.Ptr[unsigned.ULong], value: unsigned.ULong): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsigned.ULong): Unit = storeLong(rawptr, value.toLong) } @@ -151,8 +202,12 @@ object Tag { object Float extends Tag[scala.Float] { @alwaysinline def size: CSize = 4.toULong @alwaysinline def alignment: CSize = 4.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[scala.Float]): scala.Float = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Float = loadFloat(rawptr) + @alwaysinline override def store(ptr: unsafe.Ptr[scala.Float], value: scala.Float): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Float): Unit = storeFloat(rawptr, value) } @@ -160,8 +215,12 @@ object Tag { object Double extends Tag[scala.Double] { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[scala.Double]): scala.Double = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): scala.Double = loadDouble(rawptr) + @alwaysinline override def store(ptr: unsafe.Ptr[scala.Double], value: scala.Double): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Double): Unit = storeDouble(rawptr, value) } @@ -371,9 +430,13 @@ object Tag { @alwaysinline def size: CSize = of.size * n.asInstanceOf[NatTag].toUInt @alwaysinline def alignment: CSize = of.alignment @alwaysinline override def offset(idx: CSize): CSize = of.size * idx.toUInt + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CArray[T, N]]): unsafe.CArray[T, N] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CArray[T, N] = { new unsafe.CArray[T, N](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CArray[T, N]], value: unsafe.CArray[T, N]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CArray[T, N]): Unit = { val dst = rawptr if (value != null) { @@ -410,9 +473,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct0]): unsafe.CStruct0 = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct0 = { new unsafe.CStruct0(rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct0], value: unsafe.CStruct0): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct0): Unit = { val dst = rawptr if (value != null) { @@ -443,9 +510,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct1[T1]]): unsafe.CStruct1[T1] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct1[T1] = { new unsafe.CStruct1[T1](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct1[T1]], value: unsafe.CStruct1[T1]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct1[T1]): Unit = { val dst = rawptr if (value != null) { @@ -482,9 +553,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct2[T1, T2]]): unsafe.CStruct2[T1, T2] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct2[T1, T2] = { new unsafe.CStruct2[T1, T2](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct2[T1, T2]], value: unsafe.CStruct2[T1, T2]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct2[T1, T2]): Unit = { val dst = rawptr if (value != null) { @@ -528,9 +603,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct3[T1, T2, T3]]): unsafe.CStruct3[T1, T2, T3] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct3[T1, T2, T3] = { new unsafe.CStruct3[T1, T2, T3](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct3[T1, T2, T3]], value: unsafe.CStruct3[T1, T2, T3]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct3[T1, T2, T3]): Unit = { val dst = rawptr if (value != null) { @@ -582,9 +661,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct4[T1, T2, T3, T4]]): unsafe.CStruct4[T1, T2, T3, T4] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct4[T1, T2, T3, T4] = { new unsafe.CStruct4[T1, T2, T3, T4](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct4[T1, T2, T3, T4]], value: unsafe.CStruct4[T1, T2, T3, T4]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct4[T1, T2, T3, T4]): Unit = { val dst = rawptr if (value != null) { @@ -645,9 +728,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct5[T1, T2, T3, T4, T5]]): unsafe.CStruct5[T1, T2, T3, T4, T5] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct5[T1, T2, T3, T4, T5] = { new unsafe.CStruct5[T1, T2, T3, T4, T5](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct5[T1, T2, T3, T4, T5]], value: unsafe.CStruct5[T1, T2, T3, T4, T5]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct5[T1, T2, T3, T4, T5]): Unit = { val dst = rawptr if (value != null) { @@ -718,9 +805,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct6[T1, T2, T3, T4, T5, T6]]): unsafe.CStruct6[T1, T2, T3, T4, T5, T6] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct6[T1, T2, T3, T4, T5, T6] = { new unsafe.CStruct6[T1, T2, T3, T4, T5, T6](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct6[T1, T2, T3, T4, T5, T6]], value: unsafe.CStruct6[T1, T2, T3, T4, T5, T6]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct6[T1, T2, T3, T4, T5, T6]): Unit = { val dst = rawptr if (value != null) { @@ -802,9 +893,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct7[T1, T2, T3, T4, T5, T6, T7]]): unsafe.CStruct7[T1, T2, T3, T4, T5, T6, T7] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct7[T1, T2, T3, T4, T5, T6, T7] = { new unsafe.CStruct7[T1, T2, T3, T4, T5, T6, T7](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct7[T1, T2, T3, T4, T5, T6, T7]], value: unsafe.CStruct7[T1, T2, T3, T4, T5, T6, T7]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct7[T1, T2, T3, T4, T5, T6, T7]): Unit = { val dst = rawptr if (value != null) { @@ -898,9 +993,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct8[T1, T2, T3, T4, T5, T6, T7, T8]]): unsafe.CStruct8[T1, T2, T3, T4, T5, T6, T7, T8] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct8[T1, T2, T3, T4, T5, T6, T7, T8] = { new unsafe.CStruct8[T1, T2, T3, T4, T5, T6, T7, T8](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct8[T1, T2, T3, T4, T5, T6, T7, T8]], value: unsafe.CStruct8[T1, T2, T3, T4, T5, T6, T7, T8]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct8[T1, T2, T3, T4, T5, T6, T7, T8]): Unit = { val dst = rawptr if (value != null) { @@ -1007,9 +1106,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]): unsafe.CStruct9[T1, T2, T3, T4, T5, T6, T7, T8, T9] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct9[T1, T2, T3, T4, T5, T6, T7, T8, T9] = { new unsafe.CStruct9[T1, T2, T3, T4, T5, T6, T7, T8, T9](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], value: unsafe.CStruct9[T1, T2, T3, T4, T5, T6, T7, T8, T9]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct9[T1, T2, T3, T4, T5, T6, T7, T8, T9]): Unit = { val dst = rawptr if (value != null) { @@ -1130,9 +1233,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]): unsafe.CStruct10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] = { new unsafe.CStruct10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], value: unsafe.CStruct10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Unit = { val dst = rawptr if (value != null) { @@ -1268,9 +1375,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]): unsafe.CStruct11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] = { new unsafe.CStruct11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]], value: unsafe.CStruct11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]): Unit = { val dst = rawptr if (value != null) { @@ -1422,9 +1533,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]): unsafe.CStruct12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] = { new unsafe.CStruct12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]], value: unsafe.CStruct12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]): Unit = { val dst = rawptr if (value != null) { @@ -1593,9 +1708,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]): unsafe.CStruct13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] = { new unsafe.CStruct13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]], value: unsafe.CStruct13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]): Unit = { val dst = rawptr if (value != null) { @@ -1782,9 +1901,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]): unsafe.CStruct14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] = { new unsafe.CStruct14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]], value: unsafe.CStruct14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]): Unit = { val dst = rawptr if (value != null) { @@ -1990,9 +2113,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]): unsafe.CStruct15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] = { new unsafe.CStruct15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]], value: unsafe.CStruct15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]): Unit = { val dst = rawptr if (value != null) { @@ -2218,9 +2345,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]): unsafe.CStruct16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] = { new unsafe.CStruct16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]], value: unsafe.CStruct16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]): Unit = { val dst = rawptr if (value != null) { @@ -2467,9 +2598,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]): unsafe.CStruct17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] = { new unsafe.CStruct17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]], value: unsafe.CStruct17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]): Unit = { val dst = rawptr if (value != null) { @@ -2738,9 +2873,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]): unsafe.CStruct18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] = { new unsafe.CStruct18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]], value: unsafe.CStruct18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]): Unit = { val dst = rawptr if (value != null) { @@ -3032,9 +3171,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]): unsafe.CStruct19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] = { new unsafe.CStruct19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]], value: unsafe.CStruct19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]): Unit = { val dst = rawptr if (value != null) { @@ -3350,9 +3493,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]): unsafe.CStruct20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] = { new unsafe.CStruct20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]], value: unsafe.CStruct20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]): Unit = { val dst = rawptr if (value != null) { @@ -3693,9 +3840,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]): unsafe.CStruct21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21] = { new unsafe.CStruct21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]], value: unsafe.CStruct21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]): Unit = { val dst = rawptr if (value != null) { @@ -4062,9 +4213,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]): unsafe.CStruct22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] = { new unsafe.CStruct22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]], value: unsafe.CStruct22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]): Unit = { val dst = rawptr if (value != null) { @@ -4084,8 +4239,12 @@ object Tag { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[F]): F = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): F = fromRawPtr(loadRawPtr(rawptr)) + @alwaysinline override def store(ptr: unsafe.Ptr[F], value: F): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: F): Unit = { val valuePtr = if(value != null) value.rawptr else null storeRawPtr(rawptr, valuePtr) diff --git a/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala.gyb b/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala.gyb index 59ea9cfcc2..5948b1a65b 100644 --- a/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala.gyb +++ b/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala.gyb @@ -20,10 +20,9 @@ import scalanative.runtime.Intrinsics._ sealed abstract class Tag[T] { def size: CSize def alignment: CSize - @alwaysinline def load(ptr: unsafe.Ptr[T]): T = load(toRawPtr(ptr)) - @alwaysinline def store(ptr: unsafe.Ptr[T], value: T): Unit = store(toRawPtr(ptr), value) - @noinline def offset(idx: CSize): CSize = throwUndefined() + @noinline def load(ptr: unsafe.Ptr[T]): T = throwUndefined() + @noinline def store(ptr: unsafe.Ptr[T], value: T): Unit = throwUndefined() @noinline private[unsafe] def load(rawptr: RawPtr): T = throwUndefined() @noinline private[unsafe] def store(rawptr: RawPtr, value: T): Unit = throwUndefined() } @@ -33,6 +32,10 @@ object Tag { extends Tag[unsafe.Ptr[T]] { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.Ptr[T]]): unsafe.Ptr[T] = + load(toRawPtr(ptr)) + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.Ptr[T]], value: unsafe.Ptr[T]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.Ptr[T] = fromRawPtr[T](loadRawPtr(rawptr)) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.Ptr[T]): Unit = @@ -43,6 +46,10 @@ object Tag { extends Tag[T] { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[T]): T = + load(toRawPtr(ptr)) + @alwaysinline override def store(ptr: unsafe.Ptr[T], value: T): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): T = loadObject(rawptr).asInstanceOf[T] @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: T): Unit = @@ -66,6 +73,8 @@ object Tag { object ${name} extends Tag[${T}] { @alwaysinline def size: CSize = ${size}.toULong @alwaysinline def alignment: CSize = ${size}.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[${T}]): ${T} = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): ${T} = % if name == 'Unit': loadObject(rawptr).asInstanceOf[Unit] @@ -75,6 +84,8 @@ object Tag { % else: load${name}(rawptr) % end + @alwaysinline override def store(ptr: unsafe.Ptr[${T}], value: ${T}): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: ${T}): Unit = % if name == 'Unit': storeObject(rawptr, value.asInstanceOf[Object]) @@ -129,9 +140,13 @@ object Tag { @alwaysinline def size: CSize = of.size * n.asInstanceOf[NatTag].toUInt @alwaysinline def alignment: CSize = of.alignment @alwaysinline override def offset(idx: CSize): CSize = of.size * idx.toUInt + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CArray[T, N]]): unsafe.CArray[T, N] = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CArray[T, N] = { new unsafe.CArray[T, N](rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CArray[T, N]], value: unsafe.CArray[T, N]): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CArray[T, N]): Unit = { val dst = rawptr if (value != null) { @@ -187,9 +202,13 @@ object Tag { case _ => throwUndefined() } + @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct${N}${JustTs}]): unsafe.CStruct${N}${JustTs} = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): unsafe.CStruct${N}${JustTs} = { new unsafe.CStruct${N}${JustTs}(rawptr) } + @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.CStruct${N}${JustTs}], value: unsafe.CStruct${N}${JustTs}): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: unsafe.CStruct${N}${JustTs}): Unit = { val dst = rawptr if (value != null) { @@ -210,8 +229,12 @@ object Tag { @alwaysinline def size: CSize = 8.toULong @alwaysinline def alignment: CSize = 8.toULong + @alwaysinline override def load(ptr: unsafe.Ptr[F]): F = + load(toRawPtr(ptr)) @alwaysinline private[unsafe] override def load(rawptr: RawPtr): F = fromRawPtr(loadRawPtr(rawptr)) + @alwaysinline override def store(ptr: unsafe.Ptr[F], value: F): Unit = + store(toRawPtr(ptr), value) @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: F): Unit = { val valuePtr = if(value != null) value.rawptr else null storeRawPtr(rawptr, valuePtr) From 5bab2047414f574e45e86dd1ef45b0addaa52402 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Fri, 13 Oct 2023 15:56:55 +0200 Subject: [PATCH 46/51] Fix list of disabled partestJunit tests --- .../src/test/resources/2.13.12/BlacklistedTests.txt | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt b/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt index e0de97a9d1..f2414acb64 100644 --- a/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt +++ b/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt @@ -246,3 +246,12 @@ scala/util/TryTest.scala scala/math/BigIntTest.scala ### deadlocks maybe needs j.u.c.ConcurrentLinkedQueue scala/concurrent/impl/DefaultPromiseTest.scala + +## TrieMap +scala/collection/concurrent/TrieMapTest.scala +scala/collection/concurrent/ConcurrentMapTestHelper.scala +scala/collection/concurrent/ConcurrentMapTester.scala +scala/collection/convert/MapWrapperTest.scala +scala/collection/convert/EqualsTest.scala +scala/collection/SetMapRulesTest.scala +scala/collection/IterableTest.scala From 258313f45b5ca8b65e208f3afde571ea50317fd0 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Wed, 4 Oct 2023 11:12:01 +0000 Subject: [PATCH 47/51] Use Zulu instead of Termuin for the JDK distribution used in CI (cherry picked from commit 2b3f49f4c1b13b169b4780c8f068ae0128a313d1) --- .github/actions/linux-setup-env/action.yml | 2 +- .github/actions/macos-setup-env/action.yml | 2 +- .github/actions/windows-setup-env/action.yml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/actions/linux-setup-env/action.yml b/.github/actions/linux-setup-env/action.yml index 71cdd6d38c..5cbab9dfeb 100644 --- a/.github/actions/linux-setup-env/action.yml +++ b/.github/actions/linux-setup-env/action.yml @@ -14,7 +14,7 @@ runs: steps: - uses: actions/setup-java@v3 with: - distribution: "temurin" + distribution: "zulu" java-version: ${{inputs.java-version}} - name: Calculate binary version shell: bash diff --git a/.github/actions/macos-setup-env/action.yml b/.github/actions/macos-setup-env/action.yml index 262546c2e7..daa1c81918 100644 --- a/.github/actions/macos-setup-env/action.yml +++ b/.github/actions/macos-setup-env/action.yml @@ -14,7 +14,7 @@ runs: steps: - uses: actions/setup-java@v3 with: - distribution: "temurin" + distribution: "zulu" java-version: ${{inputs.java-version}} - name: Calculate binary version shell: bash diff --git a/.github/actions/windows-setup-env/action.yml b/.github/actions/windows-setup-env/action.yml index 515b71190d..bb0dd50845 100644 --- a/.github/actions/windows-setup-env/action.yml +++ b/.github/actions/windows-setup-env/action.yml @@ -19,7 +19,7 @@ runs: steps: - uses: actions/setup-java@v3 with: - distribution: "temurin" + distribution: "zulu" java-version: ${{inputs.java-version}} # We need to set proper Pagefile limits in advance. # Github actions default page file size is quite small, From 0971a4f05b67f93d67ea5d6e8da24ddf415b4cc0 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Fri, 13 Oct 2023 16:48:07 +0200 Subject: [PATCH 48/51] Fix JVM CharsetTest (backport) --- .../javalib/nio/charset/CharsetTest.scala | 51 +++++++++++-------- 1 file changed, 31 insertions(+), 20 deletions(-) diff --git a/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/nio/charset/CharsetTest.scala b/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/nio/charset/CharsetTest.scala index 0fc9058d04..388b215726 100644 --- a/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/nio/charset/CharsetTest.scala +++ b/unit-tests/shared/src/test/scala/org/scalanative/testsuite/javalib/nio/charset/CharsetTest.scala @@ -12,12 +12,15 @@ import org.junit.Assert._ import org.scalanative.testsuite.javalib.util.TrivialImmutableCollection import org.scalanative.testsuite.utils.AssertThrows.assertThrows -import org.scalanative.testsuite.utils.Platform.executingInJVM +import org.scalanative.testsuite.utils.Platform._ class CharsetTest { def javaSet[A](elems: A*): java.util.Set[A] = new java.util.HashSet(TrivialImmutableCollection(elems: _*)) + val USASCIICharsetIsDefaultAlias = + !executingInJVM || (executingInJVMOnJDK17 || executingInJVMOnLowerThanJDK17) + @Test def defaultCharset(): Unit = { assertSame(UTF_8, Charset.defaultCharset()) } @@ -30,7 +33,9 @@ class CharsetTest { assertSame(ISO_8859_1, Charset.forName("l1")) assertSame(US_ASCII, Charset.forName("US-ASCII")) - assertSame(US_ASCII, Charset.forName("Default")) + if (USASCIICharsetIsDefaultAlias) { + assertSame(US_ASCII, Charset.forName("Default")) + } assertSame(UTF_8, Charset.forName("UTF-8")) assertSame(UTF_8, Charset.forName("utf-8")) @@ -62,7 +67,10 @@ class CharsetTest { @Test def isSupported(): Unit = { assertTrue(Charset.isSupported("ISO-8859-1")) assertTrue(Charset.isSupported("US-ASCII")) - assertTrue(Charset.isSupported("Default")) + assertEquals( + USASCIICharsetIsDefaultAlias, + Charset.isSupported("Default") + ) assertTrue(Charset.isSupported("utf-8")) assertTrue(Charset.isSupported("UnicodeBigUnmarked")) assertTrue(Charset.isSupported("Utf_16le")) @@ -90,23 +98,26 @@ class CharsetTest { javaSet("UnicodeLittleUnmarked", "UTF_16LE", "X-UTF-16LE") ) assertEquals( - Charset.forName("US-ASCII").aliases(), - javaSet( - "ANSI_X3.4-1968", - "cp367", - "csASCII", - "iso-ir-6", - "ASCII", - "iso_646.irv:1983", - "ANSI_X3.4-1986", - "ascii7", - "default", - "ISO_646.irv:1991", - "ISO646-US", - "IBM367", - "646", - "us" - ) + Charset.forName("US-ASCII").aliases(), { + val aliases = javaSet( + "ANSI_X3.4-1968", + "cp367", + "csASCII", + "iso-ir-6", + "ASCII", + "iso_646.irv:1983", + "ANSI_X3.4-1986", + "ascii7", + "ISO_646.irv:1991", + "ISO646-US", + "IBM367", + "646", + "us" + ) + // Since JDK-18 US-ASCII is no longer aliased as default + if (USASCIICharsetIsDefaultAlias) aliases.add("default") + aliases + } ) assertEquals( Charset.forName("ISO-8859-1").aliases(), From 8420dd84b11f631704e1c16da6d2359d17bc0bba Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Fri, 13 Oct 2023 19:18:20 +0200 Subject: [PATCH 49/51] [skip ci] Fix compilation of unit-tests-ext LocaleTest on JDK 21 --- .../org/scalanative/testsuite/javalib/util/LocaleTest.scala | 1 + 1 file changed, 1 insertion(+) diff --git a/unit-tests-ext/shared/src/test/scala/org/scalanative/testsuite/javalib/util/LocaleTest.scala b/unit-tests-ext/shared/src/test/scala/org/scalanative/testsuite/javalib/util/LocaleTest.scala index b2e7b71556..92774bbf7d 100644 --- a/unit-tests-ext/shared/src/test/scala/org/scalanative/testsuite/javalib/util/LocaleTest.scala +++ b/unit-tests-ext/shared/src/test/scala/org/scalanative/testsuite/javalib/util/LocaleTest.scala @@ -13,6 +13,7 @@ import org.junit.Test * cause tests to "fail to fail" if they are not respected. */ class LocaleTest { + @deprecated @Test def testLanguageIsNormalizedLowerCase(): Unit = { /* Our implementations of `String.toLowerCase(locale: Locale)` and * `String.toUpperCase(locale: Locale)` assume that the result of From 16ca6be9763ebcdee7ac623ff3b4caee186955c1 Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Fri, 13 Oct 2023 19:24:54 +0200 Subject: [PATCH 50/51] Update the publish.yml (backport from main branch) --- .github/workflows/publish.yml | 27 ++++++++++++++++----------- 1 file changed, 16 insertions(+), 11 deletions(-) diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index e6c86ecbcb..da92abe995 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -3,23 +3,28 @@ on: push: tags: - 'v0.4.*' + workflow_dispatch: jobs: - test-linux: - uses: ./.github/workflows/run-tests-linux.yml - test-windows: - uses: ./.github/workflows/run-tests-windows.yml - test-macos: - uses: ./.github/workflows/run-tests-macos.yml - test-jdk-compliance: - uses: ./.github/workflows/run-jdk-compliance-tests.yml - test-multiarch: - uses: ./.github/workflows/run-tests-linux-multiarch.yml + check-compiles: + name: Test compilation of all modules + runs-on: ubuntu-22.04 + if: github.repository == 'scala-native/scala-native' + steps: + - uses: actions/checkout@v3 + - uses: ./.github/actions/linux-setup-env + with: + scala-version: "2.13" #Unused, any version can be placed here + java-version: 8 + + - name: Compile everything + run: sbt "-v" "-J-Xmx7G" "++3.1.3; Test/compile; ++2.13.12; Test/compile; ++2.12.18; Test/compile" publish: name: Publish runs-on: ubuntu-22.04 - needs: [test-linux, test-windows, test-macos, test-jdk-compliance, test-multiarch] + needs: [check-compiles] + if: github.repository == 'scala-native/scala-native' steps: - uses: actions/checkout@v3 - uses: ./.github/actions/linux-setup-env From 645d35878c630b6e93558ec7cc63e56c93d82e8b Mon Sep 17 00:00:00 2001 From: Wojciech Mazur Date: Fri, 13 Oct 2023 21:30:34 +0200 Subject: [PATCH 51/51] Set version to 0.4.16 --- docs/conf.py | 4 ++-- nir/src/main/scala/scala/scalanative/nir/Versions.scala | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/conf.py b/docs/conf.py index 896564cf0b..43deab6260 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -69,9 +69,9 @@ def generateScalaNativeCurrentYear(): # built documents. # # The short X.Y version. -version = u'0.4.16-SNAPSHOT' +version = u'0.4.16' # The full version, including alpha/beta/rc tags. -release = u'0.4.16-SNAPSHOT' +release = u'0.4.16' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. diff --git a/nir/src/main/scala/scala/scalanative/nir/Versions.scala b/nir/src/main/scala/scala/scalanative/nir/Versions.scala index 6e105942ff..c575d80ff1 100644 --- a/nir/src/main/scala/scala/scalanative/nir/Versions.scala +++ b/nir/src/main/scala/scala/scalanative/nir/Versions.scala @@ -25,7 +25,7 @@ object Versions { final val revision: Int = 9 // a.k.a. MINOR version /* Current public release version of Scala Native. */ - final val current: String = "0.4.16-SNAPSHOT" + final val current: String = "0.4.16" final val currentBinaryVersion: String = binaryVersion(current) private object FullVersion {