diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs new file mode 100644 index 0000000000..ec61ed7897 --- /dev/null +++ b/.git-blame-ignore-revs @@ -0,0 +1,3 @@ +#scalafmt +8456ecd6e3700f0c9b81616ae04ac80c4f4173dc +cf6d1a4de1e1a9386fc437119158dc7384b9a58e \ No newline at end of file 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, 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/.github/workflows/publish.yml b/.github/workflows/publish.yml index 53646aa3f6..da92abe995 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -3,28 +3,33 @@ 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 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 @@ -38,4 +43,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/.github/workflows/run-jdk-compliance-tests.yml b/.github/workflows/run-jdk-compliance-tests.yml index 45bece0b4d..e0e4543523 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: @@ -20,14 +20,14 @@ jobs: fail-fast: false matrix: os: [ubuntu-20.04, macos-11] - scala: [3.3.0] - java: [11, 17] + scala: [3.3.1, 2.13.12] + java: [11, 17, 21] include: - 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 @@ -51,8 +51,8 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.0] - java: [11, 17] + 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..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.0] + 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 7ba514763f..cd5e0b51fc 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,20 +101,20 @@ 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 include: - - scala: 3.3.0 + - scala: 3.3.1 build-mode: release-size gc: commix - scala: 3.1.3 @@ -145,11 +145,8 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.0, 2.13.11] + scala: [3.3.1, 2.13.12] build-mode: [debug] - include: - - scala: 2.13.11 - build-mode: release-fast steps: - uses: actions/checkout@v3 - uses: ./.github/actions/linux-setup-env @@ -170,15 +167,15 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.0, 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.0 + - scala: 3.3.1 lto: full optimize: false @@ -204,7 +201,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..6b44626b90 100644 --- a/.github/workflows/run-tests-macos.yml +++ b/.github/workflows/run-tests-macos.yml @@ -17,12 +17,12 @@ jobs: strategy: fail-fast: false matrix: - scala: [3.3.0] + 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 @@ -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..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.0, 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 @@ -90,33 +90,33 @@ 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 - - scala: 2.12.17 + - scala: 2.12.18 lto: full optimize: false steps: @@ -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/.readthedocs.yaml b/.readthedocs.yaml new file mode 100644 index 0000000000..56cf5d9fc5 --- /dev/null +++ b/.readthedocs.yaml @@ -0,0 +1,20 @@ +# 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" + 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/.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 = [ 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/docs/conf.py b/docs/conf.py index 4dd866427d..43deab6260 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'] @@ -69,9 +69,9 @@ def generateScalaNativeCurrentYear(): # built documents. # # The short X.Y version. -version = u'0.4.15' +version = u'0.4.16' # The full version, including alpha/beta/rc tags. -release = u'0.4.15' +release = u'0.4.16' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. @@ -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/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 diff --git a/docs/index.rst b/docs/index.rst index 2a9291f9fd..34b58469f4 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -2,7 +2,7 @@ Scala Native ============ -Version |release| +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/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/javalib/src/main/scala/java/lang/Character.scala b/javalib/src/main/scala/java/lang/Character.scala index 7c8d1cc179..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 @@ -378,7 +379,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 +397,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 } } @@ -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/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/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/javalib/src/main/scala/java/nio/ByteArrayBits.scala b/javalib/src/main/scala/java/nio/ByteArrayBits.scala index f9ceec2473..8f19f57124 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} +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), 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), 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), 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), 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), 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), 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), 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), 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), 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), 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), 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), 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/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/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/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/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/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/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) +} diff --git a/javalib/src/main/scala/java/util/concurrent/ConcurrentMap.scala b/javalib/src/main/scala/java/util/concurrent/ConcurrentMap.scala index 58502cdff8..36ceb88ec9 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/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. 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/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/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..c9126d905f 100644 --- a/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala +++ b/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala @@ -23,6 +23,8 @@ sealed abstract class Tag[T] { @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 { @@ -31,9 +33,13 @@ object Tag { @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))) + load(toRawPtr(ptr)) @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.Ptr[T]], value: unsafe.Ptr[T]): Unit = - storeRawPtr(toRawPtr(ptr), toRawPtr(value)) + 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 = + storeRawPtr(rawptr, toRawPtr(value)) } final case class Class[T <: AnyRef](of: java.lang.Class[T]) @@ -41,126 +47,182 @@ object Tag { @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] + load(toRawPtr(ptr)) @alwaysinline override def store(ptr: unsafe.Ptr[T], value: T): Unit = - storeObject(toRawPtr(ptr), value.asInstanceOf[Object]) + 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 = + 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] + 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 = - storeObject(toRawPtr(ptr), value.asInstanceOf[Object]) + store(toRawPtr(ptr), value) + @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)) + 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 = - storeBoolean(toRawPtr(ptr), value) + store(toRawPtr(ptr), value) + @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)) + 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 = - storeChar(toRawPtr(ptr), value) + store(toRawPtr(ptr), value) + @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)) + 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 = - storeByte(toRawPtr(ptr), value) + store(toRawPtr(ptr), value) + @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 + 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 = - storeByte(toRawPtr(ptr), value.toByte) + store(toRawPtr(ptr), value) + @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)) + 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 = - storeShort(toRawPtr(ptr), value) + store(toRawPtr(ptr), value) + @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 + 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 = - storeShort(toRawPtr(ptr), value.toShort) + store(toRawPtr(ptr), value) + @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)) + 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 = - storeInt(toRawPtr(ptr), value) + store(toRawPtr(ptr), value) + @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 + 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 = - storeInt(toRawPtr(ptr), value.toInt) + store(toRawPtr(ptr), value) + @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)) + 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 = - storeLong(toRawPtr(ptr), value) + store(toRawPtr(ptr), value) + @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 + 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 = - storeLong(toRawPtr(ptr), value.toLong) + store(toRawPtr(ptr), value) + @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)) + 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 = - storeFloat(toRawPtr(ptr), value) + store(toRawPtr(ptr), value) + @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)) + 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 = - storeDouble(toRawPtr(ptr), value) + store(toRawPtr(ptr), value) + @alwaysinline private[unsafe] override def store(rawptr: RawPtr, value: scala.Double): Unit = + storeDouble(rawptr, value) } @@ -368,11 +430,15 @@ 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 override def store(ptr: unsafe.Ptr[unsafe.CArray[T, N]], value: unsafe.CArray[T, N]): Unit = { - val dst = ptr.rawptr + @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) { val src = value.rawptr libc.memcpy(dst, src, size) @@ -407,11 +473,15 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct0]): unsafe.CStruct0 = { - new unsafe.CStruct0(ptr.rawptr) + @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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -440,11 +510,15 @@ object Tag { case _ => throwUndefined() } - @alwaysinline override def load(ptr: unsafe.Ptr[unsafe.CStruct1[T1]]): unsafe.CStruct1[T1] = { - new unsafe.CStruct1[T1](ptr.rawptr) + @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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -479,11 +553,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -525,11 +603,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -579,11 +661,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -642,11 +728,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -715,11 +805,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -799,11 +893,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -895,11 +993,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -1004,11 +1106,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -1127,11 +1233,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -1265,11 +1375,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -1419,11 +1533,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -1590,11 +1708,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -1779,11 +1901,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -1987,11 +2113,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -2215,11 +2345,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -2464,11 +2598,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -2735,11 +2873,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -3029,11 +3171,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -3347,11 +3493,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -3690,11 +3840,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -4059,11 +4213,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -4082,10 +4240,14 @@ 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 = { + 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(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..5948b1a65b 100644 --- a/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala.gyb +++ b/nativelib/src/main/scala/scala/scalanative/unsafe/Tag.scala.gyb @@ -23,6 +23,8 @@ sealed abstract class Tag[T] { @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 { @@ -31,9 +33,13 @@ object Tag { @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))) + load(toRawPtr(ptr)) @alwaysinline override def store(ptr: unsafe.Ptr[unsafe.Ptr[T]], value: unsafe.Ptr[T]): Unit = - storeRawPtr(toRawPtr(ptr), toRawPtr(value)) + 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 = + storeRawPtr(rawptr, toRawPtr(value)) } final case class Class[T <: AnyRef](of: java.lang.Class[T]) @@ -41,9 +47,13 @@ object Tag { @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] + load(toRawPtr(ptr)) @alwaysinline override def store(ptr: unsafe.Ptr[T], value: T): Unit = - storeObject(toRawPtr(ptr), value.asInstanceOf[Object]) + 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 = + storeObject(rawptr, value.asInstanceOf[Object]) } % prims = [('Unit', 'scala.Unit', 8), @@ -64,22 +74,26 @@ object Tag { @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(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 = + store(toRawPtr(ptr), value) + @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 +140,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size) @@ -184,11 +202,15 @@ 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 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 = { - val dst = ptr.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) { val src = value.rawptr libc.memcpy(dst, src, size.toULong) @@ -208,10 +230,14 @@ 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 = { + 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(toRawPtr(ptr), valuePtr) + storeRawPtr(rawptr, valuePtr) } } 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/nir/src/main/scala/scala/scalanative/nir/Versions.scala b/nir/src/main/scala/scala/scalanative/nir/Versions.scala index 0c9bcef008..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.15" + final val current: String = "0.4.16" final val currentBinaryVersion: String = binaryVersion(current) private object FullVersion { 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..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") @@ -262,6 +263,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..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") @@ -267,6 +263,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/project/Commands.scala b/project/Commands.scala index 1c1baee171..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") { @@ -115,6 +114,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" ) diff --git a/project/ScalaVersions.scala b/project/ScalaVersions.scala index 5d8e8a1397..1011dc1b8e 100644 --- a/project/ScalaVersions.scala +++ b/project/ScalaVersions.scala @@ -19,24 +19,31 @@ 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"), - (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 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/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( 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 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..f2414acb64 --- /dev/null +++ b/scala-partest-junit-tests/src/test/resources/2.13.12/BlacklistedTests.txt @@ -0,0 +1,257 @@ +## 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 + +## 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 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(()) 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 @@ 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/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 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 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 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 { 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..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 @@ -5,11 +5,13 @@ 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 import scala.scalanative.testinterface.NativeRunnerRPC import scala.scalanative.testinterface.common._ +import scala.annotation.nowarn final class TestAdapter(config: TestAdapter.Config) { @@ -102,7 +104,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. 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) } 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 c36aa05a0c..25d1aa9cb5 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(s"-Wl,-soname,$artifactName") + else if (config.targetsMac) + List(s"-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, @@ -202,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) @@ -215,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(outpath.abs)}") + stageFiles().foreach { path => + pw.println(s"ADDMOD ${escapeWhitespaces(path)}") + } + pw.println("SAVE") + pw.println("END") + } finally pw.close() - Process(command, config.workdir.toFile()) #< MIRScriptFile + val command = Seq(ar.abs, "-M") + config.logger.running(command) + + Process(command, config.workdir.toFile()) #< MIRScriptFile + } + + MRICompatibleAR match { + case None => + val ar = Discover.discover("ar") + val command = Seq(ar.abs, "rc", outpath.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 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..5e049ad2a0 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.asInstanceOf[Global.Top], + ordering = subclasses => { + val (arrays, other) = + subclasses.partition(_.name == Rt.GenericArray.name) + arrays ++ other + } + ) out.toSeq } 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 { 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 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/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 + ) + } + } } 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( 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) 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", 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(), 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() + ) + } +} 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")) ) ) 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