Merge ~vpa1977/ubuntu/+source/jruby:2054619 into ubuntu/+source/jruby:ubuntu/devel

[Vladimir Petko]

This is a sync merge proposal.

Unmerged commits

306c15d... by Vladimir Petko on 2024-02-22

update maintainer

7933535... by Vladimir Petko on 2024-02-22

changelog

99ff39c... by Jerome Charaoui on 2024-02-21

9.4.5.0+ds-1 (patches unapplied)

Imported using git-ubuntu import.

3de720d... by Jerome Charaoui on 2024-02-20

9.4.5.0+ds-1~exp1 (patches unapplied)

Imported using git-ubuntu import.

75da7ff... by Jerome Charaoui on 2023-12-20

9.4.3.0+ds-1~exp2 (patches unapplied)

Imported using git-ubuntu import.

ae8b688... by Jerome Charaoui on 2023-12-08

9.4.3.0+ds-1~exp1 (patches unapplied)

Imported using git-ubuntu import.

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 117f022..d1f1d28 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -10,72 +10,97 @@ permissions:
 
 jobs:
 
-  mvn-test-m1:
-    runs-on: [self-hosted, macos, aarch64]
+  rake-test:
+    runs-on: ubuntu-latest
 
     strategy:
       matrix:
-        package-flags: ['-Ptest']
-        # dist, complete, and osgi do not pass on 17 yet
-        java-version: ['11']
+        target: ['test:jruby:int', 'spec:ruby:fast', 'spec:ji', 'spec:ffi']
+        java-version: ['8', '11', '17', '21']
       fail-fast: false
 
-    name: mvn ${{ matrix.package-flags }} (Java ${{ matrix.java-version }} Apple aarch64)
+    name: rake ${{ matrix.target }} (Java ${{ matrix.java-version }})
 
     steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: cache dependencies
-        uses: actions/cache@v2
-        with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.rb') }}
-          restore-keys: ${{ runner.os }}-m2
+      - name: Bootstrap build
+        uses: jruby/jruby-ci-build@v1
       - name: set up java ${{ matrix.java-version }}
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@v3
         with:
           distribution: 'zulu'
           java-version: ${{ matrix.java-version }}
-          architecture: arm
-      - name: bootstrap
-        run: mvn -Pbootstrap clean package
-      - name: mvn package ${{ matrix.package-flags }}
-        run: tool/maven-ci-script.sh
-        env:
-          PHASE: 'package ${{ matrix.package-flags }}'
+          cache: 'maven'
+      - name: rake ${{ matrix.target }}
+        run: bin/jruby -S rake ${{ matrix.target }}
+
+  rake-test-8:
+    runs-on: ubuntu-latest
 
-  spec-m1:
-    runs-on: [self-hosted, macos, aarch64]
-    
     strategy:
       matrix:
-        target: ['spec:ffi']
-        java-version: ['11']
+        target: ['test:mri:core:jit', 'test:mri:extra', 'spec:ruby:fast:jit', 'test:mri:stdlib', 'spec:ruby:slow', 'spec:ruby:debug', 'test:jruby:aot', 'test:slow_suites', 'spec:compiler', 'spec:regression', 'spec:jruby', 'spec:jrubyc', 'spec:profiler']
       fail-fast: false
 
-    name: rake ${{ matrix.target }} (Java ${{ matrix.java-version }} Apple aarch64)
+    name: rake ${{ matrix.target }} (Java 8)
 
     steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: cache dependencies
-        uses: actions/cache@v2
+      - name: Bootstrap build
+        uses: jruby/jruby-ci-build@v1
+      - name: set up java 8
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'zulu'
+          java-version: '8'
+          cache: 'maven'
+      - name: rake ${{ matrix.target }}
+        run: bin/jruby -S rake ${{ matrix.target }}
+
+  jruby-tests-dev:
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+
+    env:
+      JRUBY_OPTS: '--dev'
+
+    steps:
+      - name: Bootstrap build
+        uses: jruby/jruby-ci-build@v1
+      - name: set up java 8
+        uses: actions/setup-java@v3
         with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.rb') }}
-          restore-keys: ${{ runner.os }}-m2
+          distribution: 'temurin'
+          java-version: 8
+          cache: 'maven'
+      - name: rake test:jruby
+        run: bin/jruby --dev -S rake test:jruby
+
+  rake-test-17-indy:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        target: ['test:mri:core:jit', 'test:jruby:jit', 'spec:compiler', 'spec:ruby:fast:jit', 'spec:ji']
+        java-version: ['17', '21']
+      fail-fast: false
+
+    name: rake ${{ matrix.target }} (Java ${{ matrix.java-version }} +indy)
+
+    env:
+      JRUBY_OPTS: '-Xcompile.invokedynamic -X+C -Xjit.threshold=0'
+
+    steps:
+      - name: Bootstrap build
+        uses: jruby/jruby-ci-build@v1
       - name: set up java ${{ matrix.java-version }}
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@v3
         with:
           distribution: 'zulu'
           java-version: ${{ matrix.java-version }}
-          architecture: arm
-      - name: bootstrap
-        run: mvn -Pbootstrap clean package
-      - name: bundle install
-        run: bin/jruby --dev -S bundle install
+          cache: 'maven'
       - name: rake ${{ matrix.target }}
-        run: bin/jruby --dev -S rake ${{ matrix.target }}
+        run: bin/jruby -S rake ${{ matrix.target }}
 
   mvn-test:
     runs-on: ubuntu-latest
@@ -83,65 +108,72 @@ jobs:
     strategy:
       matrix:
         package-flags: ['-Pmain', '-Pdist', '-Pcomplete', '-Posgi', '-Ptest', '-Pmain,test -Dinvoker.test=extended']
-        # dist, complete, and osgi do not pass on 17 yet
-        java-version: ['8', '11']
+        java-version: [8, 11, 21]
       fail-fast: false
 
     name: mvn ${{ matrix.package-flags }} (Java ${{ matrix.java-version }})
 
     steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: cache dependencies
-        uses: actions/cache@v2
-        with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.rb') }}
-          restore-keys: ${{ runner.os }}-m2
+      - name: Bootstrap build
+        uses: jruby/jruby-ci-build@v1
       - name: set up java ${{ matrix.java-version }}
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@v3
         with:
           distribution: 'zulu'
           java-version: ${{ matrix.java-version }}
-      - name: bootstrap
-        run: mvn -Pbootstrap clean package
+          cache: 'maven'
       - name: mvn package ${{ matrix.package-flags }}
         run: tool/maven-ci-script.sh
         env:
           PHASE: 'package ${{ matrix.package-flags }}'
 
-  mvn-test-8:
+  mvn-test-extended:
     runs-on: ubuntu-latest
 
     strategy:
       matrix:
-        # jruby-jars phase only passes on 8
         package-flags: ['-Pjruby-jars', '-Pjruby-jars,test -Dinvoker.test=extended', '-Pjruby_complete_jar_extended -Dinvoker.skip=true']
+        java-version: [11, 17]
       fail-fast: false
 
-    name: mvn ${{ matrix.package-flags }} (Java 8)
+
+    name: mvn ${{ matrix.package-flags }} (Java ${{ matrix.java-version }})
 
     steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: cache dependencies
-        uses: actions/cache@v2
-        with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.rb') }}
-          restore-keys: ${{ runner.os }}-m2
-      - name: set up java 8
-        uses: actions/setup-java@v2
+      - name: Bootstrap build
+        uses: jruby/jruby-ci-build@v1
+      - name: set up java ${{ matrix.java-version }}
+        uses: actions/setup-java@v3
         with:
-          distribution: 'zulu'
-          java-version: '8'
-      - name: bootstrap
-        run: mvn -Pbootstrap clean package
+          distribution: temurin
+          java-version: ${{ matrix.java-version }}
+          cache: 'maven'
       - name: mvn package ${{ matrix.package-flags }}
         run: tool/maven-ci-script.sh
         env:
           PHASE: 'package ${{ matrix.package-flags }}'
 
+  regression-specs-jit:
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+
+    env:
+      JRUBY_OPTS: '-Xjit.threshold=0'
+
+    steps:
+      - name: Bootstrap build
+        uses: jruby/jruby-ci-build@v1
+      - name: set up java 8
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'zulu'
+          java-version: 8
+          cache: 'maven'
+      - name: rake spec:regression
+        run: bin/jruby -S rake spec:regression
+
   mvn-test-windows:
     runs-on: windows-latest
 
@@ -155,27 +187,16 @@ jobs:
       JDK_JAVA_OPTS: "-Djdk.io.File.enableADS=true"
 
     steps:
-      - name: checkout
-        uses: actions/checkout@v2
+      - name: Bootstrap build
+        uses: jruby/jruby-ci-build@v1
       - name: set up java 11
         uses: actions/setup-java@v3
         with:
           distribution: 'zulu'
           java-version: 11
-      - name: cache dependencies
-        uses: actions/cache@v2
-        with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
-          restore-keys: ${{ runner.os }}-m2
-      - name: bootstrap
-        run: mvn -Pbootstrap clean package
-      - name: install bundler
-        run: bin/jruby --dev -S gem install bundler
-      - name: bundle install
-        run: bin/jruby --dev -S bundle install
+          cache: 'maven'
       - name: rake test:jruby
-        run: bin/jruby --dev -S rake test:jruby TESTOPTS="--no-show-detail-immediately"
+        run: bin/jruby -S rake test:jruby TESTOPTS="--no-show-detail-immediately"
         env:
           JRUBY_OPTS: ''
       - name: mvn -P test
@@ -188,121 +209,18 @@ jobs:
 
     steps:
       - name: checkout
-        uses: actions/checkout@v2
-      - name: cache dependencies
-        uses: actions/cache@v2
-        with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.rb') }}
-          restore-keys: ${{ runner.os }}-m2
+        uses: actions/checkout@v3
       - name: set up java 8
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@v3
         with:
           distribution: 'zulu'
           java-version: '8'
+          cache: 'maven'
       - name: dependency convergence
         run: tool/maven-ci-script.sh
         env:
           PHASE: 'install -Pmain -Dinvoker.test=GH-6081*'
 
-  rake-test:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        target: ['test:mri:core:jit', 'spec:ruby:fast', 'spec:ruby:fast:jit', 'spec:ji', 'spec:ffi']
-        java-version: ['8', '11', '17']
-      fail-fast: false
-
-    name: rake ${{ matrix.target }} (Java ${{ matrix.java-version }})
-
-    steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: cache dependencies
-        uses: actions/cache@v2
-        with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.rb') }}
-          restore-keys: ${{ runner.os }}-m2
-      - name: set up java ${{ matrix.java-version }}
-        uses: actions/setup-java@v2
-        with:
-          distribution: 'zulu'
-          java-version: ${{ matrix.java-version }}
-      - name: bootstrap
-        run: mvn -Pbootstrap clean package
-      - name: bundle install
-        run: bin/jruby --dev -S bundle install
-      - name: rake ${{ matrix.target }}
-        run: bin/jruby --dev -S rake ${{ matrix.target }}
-
-  rake-test-indy:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        target: ['test:jruby', 'spec:compiler']
-        java-version: ['8', '11', '17']
-      fail-fast: false
-
-    name: rake ${{ matrix.target }} (Java ${{ matrix.java-version }} +indy)
-
-    env:
-      JRUBY_OPTS: '-Xcompile.invokedynamic'
-
-    steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: cache dependencies
-        uses: actions/cache@v2
-        with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.rb') }}
-          restore-keys: ${{ runner.os }}-m2
-      - name: set up java ${{ matrix.java-version }}
-        uses: actions/setup-java@v2
-        with:
-          distribution: 'zulu'
-          java-version: ${{ matrix.java-version }}
-      - name: bootstrap
-        run: mvn -Pbootstrap clean package
-      - name: bundle install
-        run: bin/jruby --dev -S bundle install
-      - name: rake ${{ matrix.target }}
-        run: bin/jruby --dev -S rake ${{ matrix.target }}
-
-  rake-test-8:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        target: ['test:mri:core:int', 'test:mri:extra', 'test:jruby:int', 'test:mri:stdlib', 'spec:ruby:slow', 'spec:ruby:debug', 'test:jruby:aot', 'test:slow_suites', 'spec:compiler', 'spec:regression', 'spec:jruby', 'spec:jrubyc', 'spec:profiler']
-      fail-fast: false
-
-    name: rake ${{ matrix.target }} (Java 8)
-
-    steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: cache dependencies
-        uses: actions/cache@v2
-        with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.rb') }}
-          restore-keys: ${{ runner.os }}-m2
-      - name: set up java 8
-        uses: actions/setup-java@v2
-        with:
-          distribution: 'zulu'
-          java-version: '8'
-      - name: bootstrap
-        run: mvn -Pbootstrap clean package
-      - name: bundle install
-        run: bin/jruby --dev -S bundle install
-      - name: rake ${{ matrix.target }}
-        run: bin/jruby --dev -S rake ${{ matrix.target }}
-
   test-versions:
     runs-on: ubuntu-latest
 
@@ -312,18 +230,13 @@ jobs:
     name: Verify build artifacts
     steps:
       - name: checkout
-        uses: actions/checkout@v2
-      - name: cache dependencies
-        uses: actions/cache@v2
-        with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.rb') }}
-          restore-keys: ${{ runner.os }}-m2
+        uses: actions/checkout@v3
       - name: set up java 8
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@v3
         with:
           distribution: 'zulu'
           java-version: 8
+          cache: 'maven'
       - name: maven-ci-script.sh
         run: tool/maven-ci-script.sh
         env:
@@ -337,33 +250,28 @@ jobs:
 
     services:
       postgres:
-        image: postgres:11.5
-        ports: ["5432:5432"]
+        image: postgres:latest
+        ports: [ "5432:5432" ]
         options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
+        env:
+          POSTGRES_PASSWORD: postgres
       mysql:
-        image: mysql:5.7
+        image: mysql:latest
         env:
           MYSQL_ROOT_PASSWORD: root
           MYSQL_DATABASE: sequel_test
-        ports: ["3306:3306"]
+        ports: [ "3306:3306" ]
         options: --health-cmd="mysqladmin ping" --health-interval=10s --health-timeout=5s --health-retries=3
 
     steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: cache dependencies
-        uses: actions/cache@v2
-        with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.rb') }}
-          restore-keys: ${{ runner.os }}-m2
-      - name: set up java 8
-        uses: actions/setup-java@v2
+      - name: Bootstrap build
+        uses: jruby/jruby-ci-build@v1
+      - name: set up java
+        uses: actions/setup-java@v3
         with:
-          distribution: 'zulu'
-          java-version: 8
-      - name: bootstrap
-        run: mvn -Pbootstrap clean package
+          distribution: 'temurin'
+          java-version: 11
+          cache: 'maven'
       - name: sequel
         run: tool/sequel-github-actions.sh
 
@@ -374,143 +282,118 @@ jobs:
       fail-fast: false
 
     steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: cache dependencies
-        uses: actions/cache@v2
-        with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.rb') }}
-          restore-keys: ${{ runner.os }}-m2
+      - name: Bootstrap build
+        uses: jruby/jruby-ci-build@v1
       - name: set up java 8
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@v3
         with:
-          distribution: 'zulu'
+          distribution: 'temurin'
           java-version: 8
-      - name: bootstrap
-        run: mvn -Pbootstrap clean package
+          cache: 'maven'
       - name: concurrent-ruby
         run: tool/concurrent-ruby-github-actions.sh
 
-  jruby-tests-dev:
-    runs-on: ubuntu-latest
-
-    strategy:
-      fail-fast: false
+#  mvn-test-m1:
+#    runs-on: [self-hosted, macos, aarch64]
+#
+#    strategy:
+#      matrix:
+#        package-flags: ['-Ptest']
+#        # dist, complete, and osgi do not pass on 17 yet
+#        java-version: ['11']
+#      fail-fast: false
+#
+#    name: mvn ${{ matrix.package-flags }} (Java ${{ matrix.java-version }} Apple aarch64)
+#
+#    steps:
+#      - name: checkout
+#        uses: actions/checkout@v3
+#      - name: set up java ${{ matrix.java-version }}
+#        uses: actions/setup-java@v3
+#        with:
+#          distribution: 'zulu'
+#          java-version: ${{ matrix.java-version }}
+#          architecture: arm
+#      - name: bootstrap
+#        run: ./mvnw -Pbootstrap clean package
+#      - name: mvn package ${{ matrix.package-flags }}
+#        run: tool/maven-ci-script.sh
+#        env:
+#          PHASE: 'package ${{ matrix.package-flags }}'
+#
+#  spec-m1:
+#    runs-on: [self-hosted, macos, aarch64]
+#
+#    strategy:
+#      matrix:
+#        target: ['spec:ffi']
+#        java-version: ['11']
+#      fail-fast: false
+#
+#    name: rake ${{ matrix.target }} (Java ${{ matrix.java-version }} Apple aarch64)
+#
+#    steps:
+#      - name: Bootstrap build
+#        uses: jruby/jruby-ci-build@v1
+#      - name: set up java ${{ matrix.java-version }}
+#        uses: actions/setup-java@v3
+#        with:
+#          distribution: 'zulu'
+#          java-version: ${{ matrix.java-version }}
+#          architecture: arm
+#          cache: 'maven'
+#      - name: rake ${{ matrix.target }}
+##        run: "bin/jruby -S rake ${{ matrix.target }}"
+#        run: "true"
 
-    env:
-      JRUBY_OPTS: '--dev'
-
-    steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: cache dependencies
-        uses: actions/cache@v2
-        with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.rb') }}
-          restore-keys: ${{ runner.os }}-m2
-      - name: set up java 8
-        uses: actions/setup-java@v2
-        with:
-          distribution: 'zulu'
-          java-version: 8
-      - name: bootstrap
-        run: mvn -Pbootstrap clean package
-      - name: bundle install
-        run: bin/jruby --dev -S bundle install
-      - name: rake test:jruby
-        run: bin/jruby --dev -S rake test:jruby
-
-  ji-specs-indy:
+  maven-test-openj9-8:
     runs-on: ubuntu-latest
 
-    strategy:
-      fail-fast: false
-
-    env:
-      JRUBY_OPTS: '-Xcompile.invokedynamic'
+    name: mvn -Ptest (OpenJ9 Java 17)
 
     steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: cache dependencies
-        uses: actions/cache@v2
-        with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.rb') }}
-          restore-keys: ${{ runner.os }}-m2
-      - name: set up java 8
-        uses: actions/setup-java@v2
+      - name: Bootstrap build
+        uses: jruby/jruby-ci-build@v1
+      - name: set up java ${{ matrix.java-version }}
+        uses: actions/setup-java@v3
         with:
-          distribution: 'zulu'
-          java-version: 8
-      - name: bootstrap
-        run: mvn -Pbootstrap clean package
-      - name: bundle install
-        run: bin/jruby --dev -S bundle install
-      - name: rake spec:ji
-        run: bin/jruby --dev -S rake spec:ji
+          distribution: 'adopt-openj9'
+          java-version: '17'
+          cache: 'maven'
+      - name: test profile
+        run: "tool/maven-ci-script.sh"
+        env:
+          PHASE: 'package -Ptest'
 
-  regression-specs-jit:
+  rake-test-wip-8:
     runs-on: ubuntu-latest
 
     strategy:
+      matrix:
+        target: ['test:mri:core_wip', 'test:mri:stdlib_wip']
       fail-fast: false
 
-    env:
-      JRUBY_OPTS: '-Xjit.threshold=0'
+    name: rake ${{ matrix.target }} (Java 8)
 
     steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: cache dependencies
-        uses: actions/cache@v2
-        with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.rb') }}
-          restore-keys: ${{ runner.os }}-m2
+      - name: Bootstrap build
+        uses: jruby/jruby-ci-build@v1
       - name: set up java 8
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@v3
         with:
           distribution: 'zulu'
-          java-version: 8
-      - name: bootstrap
-        run: mvn -Pbootstrap clean package
-      - name: bundle install
-        run: bin/jruby --dev -S bundle install
-      - name: rake spec:regression
-        run: bin/jruby --dev -S rake spec:regression
-
-  maven-test-openj9-8:
-    runs-on: ubuntu-latest
-
-    name: mvn -Ptest (OpenJ9 Java 8)
-
-    steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: cache dependencies
-        uses: actions/cache@v2
-        with:
-          path: ~/.m2
-          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.rb') }}
-          restore-keys: ${{ runner.os }}-m2
-      - name: set up java ${{ matrix.java-version }}
-        uses: actions/setup-java@v2
-        with:
-          distribution: 'adopt-openj9'
           java-version: '8'
-      - name: test profile
-        run: tool/maven-ci-script.sh
-        env:
-          PHASE: 'package -Ptest'
+          cache: 'maven'
+      - name: rake ${{ matrix.target }}
+        continue-on-error: true
+        run: "bin/jruby -S rake ${{ matrix.target }}"
+      - run: true
 
   publish-snapshot:
     permissions:
       contents: none
     if: ${{ github.ref == 'refs/heads/master' || github.ref == 'refs/heads/jruby-9.3' }}
-    needs: [mvn-test, mvn-test-8, mvn-test-windows, dependency-check, rake-test, rake-test-indy, rake-test-8, test-versions, sequel, concurrent-ruby, jruby-tests-dev, ji-specs-indy, regression-specs-jit, maven-test-openj9-8]
+    needs: [mvn-test, mvn-test-extended, mvn-test-windows, dependency-check, rake-test, rake-test-17-indy, rake-test-8, test-versions, sequel, concurrent-ruby, jruby-tests-dev, regression-specs-jit]
     uses: jruby/jruby/.github/workflows/snapshot-publish.yml@6cd0d4d96d9406635183d81cf91acc82cd78245f
     secrets:
       SONATYPE_USERNAME: ${{ secrets.SONATYPE_USERNAME }}
diff --git a/.github/workflows/nightly-snapshot-publish.yml b/.github/workflows/nightly-snapshot-publish.yml
new file mode 100644
index 0000000..eee8db9
--- /dev/null
+++ b/.github/workflows/nightly-snapshot-publish.yml
@@ -0,0 +1,21 @@
+name: Nightly Master Snapshot
+
+on:
+  schedule:
+    - cron: '30 6 * * *'
+
+env:
+  JAVA_OPTS: '-XX:+TieredCompilation -XX:TieredStopAtLevel=1 -Xms60M -Xmx1G -XX:InitialCodeCacheSize=40M -XX:ReservedCodeCacheSize=120M'
+
+permissions:
+  contents: read
+
+jobs:
+  publish-snapshot:
+    permissions:
+      contents: none
+    if: ${{ github.ref == 'refs/heads/master' }}
+    uses: jruby/jruby/.github/workflows/snapshot-publish.yml@6cd0d4d96d9406635183d81cf91acc82cd78245f
+    secrets:
+      SONATYPE_USERNAME: ${{ secrets.SONATYPE_USERNAME }}
+      SONATYPE_PASSWORD: ${{ secrets.SONATYPE_PASSWORD }}
diff --git a/.github/workflows/snapshot-publish.yml b/.github/workflows/snapshot-publish.yml
index 9278687..8c8049c 100644
--- a/.github/workflows/snapshot-publish.yml
+++ b/.github/workflows/snapshot-publish.yml
@@ -17,7 +17,7 @@ jobs:
 
     steps:
       - name: checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
       - name: set up Java
         uses: actions/setup-java@v2
         with:
@@ -26,6 +26,11 @@ jobs:
           server-id: sonatype-nexus-snapshots
           server-username: MAVEN_USERNAME
           server-password: MAVEN_PASSWORD
+      - name: Setup Maven Action
+        uses: s4u/setup-maven-action@v1.6.0
+        with:
+          java-version: '8'
+          maven-version: '3.8.7'
       - name: Publish package
         run: ./mvnw -B clean deploy -Prelease
         env:
diff --git a/.gitignore b/.gitignore
index c202f56..7b38a79 100644
--- a/.gitignore
+++ b/.gitignore
@@ -56,18 +56,31 @@ lib/ruby/gems
 # Ruby stdlib files installed from external sources
 lib/ruby/stdlib/**/maven-metadata-local.xml
 lib/ruby/stdlib/*.jar
+lib/ruby/stdlib/abbrev*
 lib/ruby/stdlib/ant*
+lib/ruby/stdlib/base64*
+lib/ruby/stdlib/benchmark*
+lib/ruby/stdlib/bigdecimal*
 lib/ruby/stdlib/bundler*
-lib/ruby/stdlib/cmath.rb
+lib/ruby/stdlib/cgi*
 lib/ruby/stdlib/csv*
+lib/ruby/stdlib/debug*
+lib/ruby/stdlib/delegate*
 lib/ruby/stdlib/did_you_mean*
-lib/ruby/stdlib/e2mmap*
+lib/ruby/stdlib/digest*
+lib/ruby/stdlib/drb*
+lib/ruby/stdlib/English*
+lib/ruby/stdlib/erb*
+lib/ruby/stdlib/error_highlight*
 lib/ruby/stdlib/ffi*
-lib/ruby/stdlib/fileutils.rb
+lib/ruby/stdlib/fileutils*
+lib/ruby/stdlib/find*
 lib/ruby/stdlib/forwardable*
 lib/ruby/stdlib/gauntlet_rdoc.rb
+lib/ruby/stdlib/getoptlong*
 lib/ruby/stdlib/hoe*
 lib/ruby/stdlib/io/console*
+lib/ruby/stdlib/io/wait*
 lib/ruby/stdlib/ipaddr*
 lib/ruby/stdlib/irb*
 lib/ruby/stdlib/jar*
@@ -75,34 +88,53 @@ lib/ruby/stdlib/jline
 lib/ruby/stdlib/jopenssl*
 lib/ruby/stdlib/json*
 lib/ruby/stdlib/krypt*
+lib/ruby/stdlib/libfixposix*
 lib/ruby/stdlib/logger*
 lib/ruby/stdlib/matrix*
 lib/ruby/stdlib/minitest*
 lib/ruby/stdlib/mutex_m.rb
-lib/ruby/stdlib/net-telnet.rb
-lib/ruby/stdlib/net/telnet*
+lib/ruby/stdlib/net/protocol*
+lib/ruby/stdlib/net/http*
+lib/ruby/stdlib/observer*
+lib/ruby/stdlib/open3*
+lib/ruby/stdlib/open-uri*
+lib/ruby/stdlib/optparse*
+lib/ruby/stdlib/optionparser*
 lib/ruby/stdlib/openssl*
 lib/ruby/stdlib/org/
-lib/ruby/stdlib/ostruct.rb
+lib/ruby/stdlib/ostruct*
+lib/ruby/stdlib/pp*
+lib/ruby/stdlib/prettyprint*
 lib/ruby/stdlib/power_assert*
 lib/ruby/stdlib/prime*
+lib/ruby/stdlib/pstore*
 lib/ruby/stdlib/psych*
+lib/ruby/stdlib/random*
 lib/ruby/stdlib/racc*
 lib/ruby/stdlib/rake*
 lib/ruby/stdlib/rdoc*
 lib/ruby/stdlib/readline*
-lib/ruby/stdlib/rexml*
+lib/ruby/stdlib/reline*
+lib/ruby/stdlib/resolv-replace*
+lib/ruby/stdlib/rinda*
 lib/ruby/stdlib/ripper.jar
-lib/ruby/stdlib/rss*
+lib/ruby/stdlib/ruby2_keywords*
 lib/ruby/stdlib/rubygems*
 lib/ruby/stdlib/rubygems/defaults/jruby_native.rb
-lib/ruby/stdlib/scanf.rb
-lib/ruby/stdlib/shell*
-lib/ruby/stdlib/sync.rb
-lib/ruby/stdlib/test*
-lib/ruby/stdlib/thwait*
+lib/ruby/stdlib/securerandom*
+lib/ruby/stdlib/shellwords*
+lib/ruby/stdlib/singleton*
+lib/ruby/stdlib/stringio*
+lib/ruby/stdlib/strscan*
+lib/ruby/stdlib/subspawn*
+lib/ruby/stdlib/time.rb
+lib/ruby/stdlib/timeout*
 lib/ruby/stdlib/tracer*
-lib/ruby/stdlib/webrick*
+lib/ruby/stdlib/tsort*
+lib/ruby/stdlib/un*
+lib/ruby/stdlib/uri*
+lib/ruby/stdlib/yaml*
+lib/ruby/stdlib/weakref*
 
 release.properties
 share
diff --git a/.mvn/extensions.xml b/.mvn/extensions.xml
index 443f848..38ba828 100644
--- a/.mvn/extensions.xml
+++ b/.mvn/extensions.xml
@@ -3,6 +3,6 @@
   <extension>
     <groupId>io.takari.polyglot</groupId>
     <artifactId>polyglot-ruby</artifactId>
-    <version>0.4.7</version>
+    <version>0.4.11</version>
   </extension>
 </extensions>
diff --git a/.mvn/wrapper/maven-wrapper.jar b/.mvn/wrapper/maven-wrapper.jar
index 5fd4d50..cb28b0e 100644
Binary files a/.mvn/wrapper/maven-wrapper.jar and b/.mvn/wrapper/maven-wrapper.jar differ
diff --git a/.mvn/wrapper/maven-wrapper.properties b/.mvn/wrapper/maven-wrapper.properties
index c6046c0..70f4f50 100644
--- a/.mvn/wrapper/maven-wrapper.properties
+++ b/.mvn/wrapper/maven-wrapper.properties
@@ -1 +1,18 @@
-distributionUrl=https://repo1.maven.org/maven2/org/apache/maven/apache-maven/3.8.1/apache-maven-3.8.1-bin.zip
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.8.8/apache-maven-3.8.8-bin.zip
+wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar
diff --git a/BUILDING.md b/BUILDING.md
index a87c0d3..ec41470 100644
--- a/BUILDING.md
+++ b/BUILDING.md
@@ -44,7 +44,7 @@ rvm use system
 
 After building lib/jruby.jar, JRuby can be run with the `bin/jruby` executable. If the `jruby-launcher` gem installed successfully, this will be a native
 executable for your platform; otherwise, it will be a copy of the
-`bin/jruby.bash` bash script.
+`bin/jruby.sh` shell script.
 
 RubyGems is installed by default, and available in `bin/gem`. It will
 attempt to locate the `jruby` executable using `/usr/bin/env`, so you
diff --git a/Gemfile b/Gemfile
index b22e68c..eedf471 100644
--- a/Gemfile
+++ b/Gemfile
@@ -1,3 +1,3 @@
 source 'https://rubygems.org'
 
-gem 'rspec', '3.10.0'
+gem 'rspec', '3.12.0'
diff --git a/README.md b/README.md
index 882dab5..2e480b1 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 # JRuby - an implementation of the Ruby language on the JVM
 
-Master: ![Linux](https://github.com/jruby/jruby/actions/workflows/ci.yml/badge.svg), ![Windows](https://github.com/jruby/jruby/actions/workflows/ci-windows.yml/badge.svg)
-9.3 branch: ![Linux](https://github.com/jruby/jruby/actions/workflows/ci.yml/badge.svg?branch=jruby-9.3), ![Windows](https://github.com/jruby/jruby/actions/workflows/ci-windows.yml/badge.svg?branch=jruby-9.3)
+Master: [![JRuby CI](https://github.com/jruby/jruby/actions/workflows/ci.yml/badge.svg)](https://github.com/jruby/jruby/actions/workflows/ci.yml), [![JRuby CI (Windows)](https://github.com/jruby/jruby/actions/workflows/ci-windows.yml/badge.svg)](https://github.com/jruby/jruby/actions/workflows/ci-windows.yml)
+9.3 branch: [![JRuby CI](https://github.com/jruby/jruby/actions/workflows/ci.yml/badge.svg?branch=jruby-9.3)](https://github.com/jruby/jruby/actions/workflows/ci.yml), [![JRuby CI (Windows)](https://github.com/jruby/jruby/actions/workflows/ci-windows.yml/badge.svg?branch=jruby-9.3)](https://github.com/jruby/jruby/actions/workflows/ci-windows.yml)
 
 ## About
 
@@ -36,7 +36,7 @@ version is very old.
 An alternative is to use one of the [Ruby version managers](https://www.ruby-lang.org/en/documentation/installation/#managers).
 
 For [`rbenv`](https://github.com/sstephenson/rbenv) you will need the
-[`ruby-build`](https://githubcom/sstephenson/ruby-build) plugin. You may find that your system
+[`ruby-build`](https://github.com/sstephenson/ruby-build) plugin. You may find that your system
 package manager can provide these. To see which versions of JRuby are available you should run:
 
 ```
diff --git a/VERSION b/VERSION
index 8e16f67..5511636 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-9.3.9.0
+9.4.5.0
diff --git a/bin/jirb_swing b/bin/jirb_swing
index e221c8c..3a96eb5 100755
--- a/bin/jirb_swing
+++ b/bin/jirb_swing
@@ -5,6 +5,7 @@
 # Damian Steer ([e-mail])
 
 require 'jruby'
+require 'readline'
 require 'irb'
 require 'irb/completion'
 
diff --git a/bin/jruby.bash b/bin/jruby.bash
deleted file mode 100755
index 1cbea4f..0000000
--- a/bin/jruby.bash
+++ /dev/null
@@ -1,527 +0,0 @@
-#!/usr/bin/env bash
-# -----------------------------------------------------------------------------
-# jruby.bash - Start Script for the JRuby interpreter
-# -----------------------------------------------------------------------------
-
-# ----- Set variable defaults --------------
-
-cygwin=false
-use_exec=true
-java_opts_from_files=""
-JRUBY_SHELL=/bin/sh
-
-if [ -z "$JRUBY_OPTS" ] ; then
-  JRUBY_OPTS=""
-fi
-
-if [ -z "$JAVA_STACK" ] ; then
-  JAVA_STACK=-Xss2048k
-fi
-
-declare -a java_args
-declare -a ruby_args
-
-JAVA_CLASS_JRUBY_MAIN=org.jruby.Main
-java_class="$JAVA_CLASS_JRUBY_MAIN"
-
-# Force OpenJDK-based JVMs to use /dev/urandom for random number generation
-# See https://github.com/jruby/jruby/issues/4685 among others.
-# OpenJDK tries really hard to prevent you from using urandom.
-# See https://bugs.openjdk.java.net/browse/JDK-6202721
-# Non-file URL causes fallback to slow threaded SeedGenerator.
-# See https://bz.apache.org/bugzilla/show_bug.cgi?id=56139
-if [ -r "/dev/urandom" ]; then
-  JAVA_SECURITY_EGD="file:/dev/urandom"
-fi
-
-# Gather environment information as we go
-environment_log=$'JRuby Environment\n================='
-add_log() {
-    environment_log+=$'\n'"$1"
-}
-
-# Logic to process "arguments files" on both Java 8 and Java 9+
-unset java_opts_from_files
-process_java_opts() {
-  java_opts_file="$1"
-  if [ -r "$java_opts_file" ]; then
-    add_log
-    add_log "Adding Java options from: $java_opts_file"
-
-    while read -r line; do
-      if [ "$line" ]; then
-          add_log "  $line"
-      fi
-    done < "$java_opts_file"
-
-    # On Java 9+, add an @argument for the given file.
-    # On earlier versions the file contents will be read and expanded on the Java command line.
-    if [ "$use_modules" ]; then
-      java_opts_from_files="$java_opts_from_files @$java_opts_file"
-    else
-      java_opts_from_files="$java_opts_from_files $(cat "$java_opts_file")"
-    fi
-  fi
-}
-
-# Pure shell dirname/basename
-dir_name() {
-  local filename="$1" trail
-  case $filename in
-    */*[!/]*)
-      trail=${filename##*[!/]}
-      filename=${filename%%"$trail"}
-      result=${filename%/*}
-      ;;
-    *[!/]*)
-      trail=${filename##*[!/]}
-      result="."
-      ;;
-    *)
-      result="/"
-      ;;
-  esac
-}
-
-base_name() {
-  local filename="$1" trail
-  case $filename in
-    */*[!/]*)
-      trail=${filename##*[!/]}
-      filename=${filename%%"$trail"}
-      result=${filename##*/}
-      ;;
-    *[!/]*)
-      trail=${filename##*[!/]}
-      result=${filename%%"$trail"}
-      ;;
-    *)
-      result="/"
-      ;;
-  esac
-}
-
-# Resolve all symlinks in a chain
-resolve_symlinks() {
-  cur_path="$1"
-  while [ -h "$cur_path" ]; do
-    # 1) cd to directory of the symlink
-    # 2) cd to the directory of where the symlink points
-    # 3) get the physical pwd
-    # 4) append the basename
-    sym="$(readlink "$cur_path")"
-
-    dir_name "$cur_path"
-    dirname="$result"
-
-    sym_base="$(cd -P -- "$dirname" >/dev/null && pwd -P)"
-
-    dir_name "$sym"
-    dirname="$result"
-
-    base_name "$sym"
-    basename="$result"
-
-    cur_path="$(cd "$sym_base" && cd "$dirname" && pwd -P)/$basename"
-  done
-  result="$cur_path"
-}
-
-# ----- Determine JRUBY_HOME based on this executable's path ------------------
-
-# get the absolute path of the executable
-dir_name "$BASH_SOURCE"
-BASE_DIR="$(cd -P -- "$result" >/dev/null && pwd -P)"
-base_name "$BASH_SOURCE"
-resolve_symlinks "$BASE_DIR/$result"
-SELF_PATH="$result"
-
-JRUBY_HOME="${SELF_PATH%/*/*}"
-
-# ----- File paths for various options and files we'll process later ----------
-
-# Module options to open up packages we need to reflect
-jruby_module_opts_file="$JRUBY_HOME/bin/.jruby.module_opts"
-
-# Cascading .java_opts files for localized JVM flags
-installed_jruby_java_opts_file="$JRUBY_HOME/bin/.jruby.java_opts"
-home_jruby_java_opts_file="$HOME/.jruby.java_opts"
-pwd_jruby_java_opts_file="$PWD/.jruby.java_opts"
-
-# Options from .dev_mode.java_opts for "--dev" mode, to reduce JRuby startup time
-dev_mode_opts_file="$JRUBY_HOME/bin/.dev_mode.java_opts"
-
-# Default JVM Class Data Sharing Archive (jsa) file for JVMs that support it
-jruby_jsa_file="$JRUBY_HOME/lib/jruby.jsa"
-
-# ----- Initialize environment log -------------------------
-
-add_log
-add_log "JRuby executable:"
-add_log "  $BASH_SOURCE"
-add_log "JRuby command line options:"
-add_log "  $*"
-add_log "Current directory:"
-add_log "  $(pwd)"
-
-add_log
-add_log "Environment:"
-add_log "  JRUBY_HOME: $JRUBY_HOME"
-add_log "  JRUBY_OPTS: $JRUBY_OPTS"
-add_log "  JAVA_OPTS: $JAVA_OPTS"
-
-# ----- Discover JVM and prep environment to run it ---------------------------
-
-# Detect cygwin and mingw environments
-case "$(uname)" in
-  CYGWIN*) cygwin=true;;
-  MINGW*) jruby.exe "$@"; exit $?;;
-esac
-
-# Determine where the java command is and ensure we have a good JAVA_HOME
-if [ -z "$JAVACMD" ] ; then
-  if [ -z "$JAVA_HOME" ] ; then
-    java_home_command="/usr/libexec/java_home"
-    if [ -r "$java_home_command" ] && [ -x "$java_home_command" ] && [ ! -d "$java_home_command" ] ; then
-      # use java_home command when none is set (on MacOS)
-      JAVA_HOME="$("$java_home_command")"
-      JAVACMD="$JAVA_HOME"/bin/java
-    else
-      # Linux and others have a chain of symlinks
-      resolve_symlinks "$(command -v java)"
-      JAVACMD="$result"
-
-      # export separately from command execution
-      dir_name "$JAVACMD"
-      dir_name "$result"
-      JAVA_HOME="$result"
-    fi
-  else
-    if $cygwin; then
-      JAVACMD="$(cygpath -u "$JAVA_HOME")/bin/java"
-    else
-      JAVACMD="$JAVA_HOME/bin/java"
-    fi
-  fi
-else
-  resolve_symlinks "$(command -v "$JAVACMD")"
-  expanded_javacmd="$result"
-  if [ -z "$JAVA_HOME" ] && [ -x "$expanded_javacmd" ] ; then
-    dir_name "$expanded_javacmd"
-    dir_name "$result"
-    JAVA_HOME="$result"
-  fi
-fi
-
-# Detect modularized Java if modules file is present or a MODULES line appears in release
-if [ -f "$JAVA_HOME"/lib/modules ] || { [ -f "$JAVA_HOME"/release ] && grep -q ^MODULES "$JAVA_HOME"/release; } ; then
-  use_modules=1
-fi
-
-add_log "  JAVACMD: $JAVACMD"
-add_log "  JAVA_HOME: $JAVA_HOME"
-
-if [ "$use_modules" ]; then
-  add_log
-  add_log "Detected Java modules at $JAVA_HOME"
-fi
-
-# ----- Process .java_opts files ----------------------------------------------
-
-# We include options on the java command line in the following order:
-#
-# * JRuby installed bin/.jruby.java_opts (empty by default)
-# * user directory .jruby.java_opts
-# * current directory .jruby.java_opts
-# * dev mode options from bin/.dev_mode.java_opts, if --dev is specified
-# * module options from bin/.jruby.module_opts if modules are detected
-# * JAVA_OPTS environment variable
-# * command line flags
-
-# Add local and global .jruby.java_opts
-process_java_opts "$installed_jruby_java_opts_file"
-process_java_opts "$home_jruby_java_opts_file"
-process_java_opts "$pwd_jruby_java_opts_file"
-
-# Capture some Java options to be passed separately
-unset JAVA_OPTS_TEMP
-JAVA_OPTS_TEMP=""
-for opt in $JAVA_OPTS; do
-  case $opt in
-    -Xmx*)
-      JAVA_MEM="$opt";;
-    -Xss*)
-      JAVA_STACK="$opt";;
-    *)
-      JAVA_OPTS_TEMP="$JAVA_OPTS_TEMP $opt";;
-  esac
-done
-
-JAVA_OPTS="$JAVA_OPTS_TEMP"
-
-# ----- Set up the JRuby class/module path ------------------------------------
-
-CP_DELIMITER=":"
-
-# add main jruby jar to the classpath
-for j in "$JRUBY_HOME"/lib/jruby.jar "$JRUBY_HOME"/lib/jruby-complete.jar; do
-    if [ ! -e "$j" ]; then
-      continue
-    fi
-    if [ "$JRUBY_CP" ]; then
-        JRUBY_CP="$JRUBY_CP$CP_DELIMITER$j"
-    else
-        JRUBY_CP="$j"
-    fi
-    if [ "$JRUBY_ALREADY_ADDED" ]; then
-        echo "WARNING: more than one JRuby JAR found in lib directory" 1>&2
-    fi
-    JRUBY_ALREADY_ADDED=true
-done
-
-if $cygwin; then
-    JRUBY_CP="$(cygpath -p -w "$JRUBY_CP")"
-fi
-
-# ----- Add additional jars from lib to classpath -----------------------------
-
-if [ "$JRUBY_PARENT_CLASSPATH" ]; then
-    # Use same classpath propagated from parent jruby
-    CP="$JRUBY_PARENT_CLASSPATH"
-else
-    # add other jars in lib to CP for command-line execution
-    for j in "$JRUBY_HOME"/lib/*.jar; do
-        if [ "$j" = "$JRUBY_HOME"/lib/jruby.jar ]; then
-          continue
-        fi
-        if [ "$j" = "$JRUBY_HOME"/lib/jruby-complete.jar ]; then
-          continue
-        fi
-        if [ "$CP" ]; then
-            CP="$CP$CP_DELIMITER$j"
-            else
-            CP="$j"
-        fi
-    done
-
-    if [ "$CP" ] && $cygwin; then
-        CP="$(cygpath -p -w "$CP")"
-    fi
-fi
-
-if $cygwin; then
-    # switch delimiter only after building Unix style classpaths
-    CP_DELIMITER=";"
-fi
-
-# ----- Continue processing JRuby options into JVM options --------------------
-
-# Split out any -J argument for passing to the JVM.
-# Scanning for args is aborted by '--'.
-set -- $JRUBY_OPTS "$@"
-while [ $# -gt 0 ]
-do
-    case $1 in
-     # Stuff after '-J' in this argument goes to JVM
-     -J-Xmx*)
-         JAVA_MEM="${1#-J}" ;;
-     -J-Xss*)
-         JAVA_STACK="${1#-J}" ;;
-     -J)
-         "$JAVACMD" -help
-         echo "(Prepend -J in front of these options when using 'jruby' command)" 1>&2
-         exit ;;
-     -J-X)
-         "$JAVACMD" -X
-         echo "(Prepend -J in front of these options when using 'jruby' command)" 1>&2
-         exit ;;
-     -J-classpath)
-         CP="$CP$CP_DELIMITER$2"
-         CLASSPATH=""
-         shift ;;
-     -J-cp)
-         CP="$CP$CP_DELIMITER$2"
-         CLASSPATH=""
-         shift ;;
-     -J-ea*)
-         VERIFY_JRUBY="yes"
-         java_args+=("${1#-J}") ;;
-     -J-Djava.security.egd=*)
-         JAVA_SECURITY_EGD=${1#-J-Djava.security.egd=} ;;
-     # This must be the last check for -J
-     -J*)
-         java_args+=("${1#-J}") ;;
-     # Pass -X... and -X? search options through
-     -X*...|-X*\?)
-        ruby_args+=("$1") ;;
-     # Match -Xa.b.c=d to translate to -Da.b.c=d as a java option
-     -X*.*)
-        java_args+=("-Djruby.${1#-X}") ;;
-     # Match switches that take an argument
-     -C|-e|-I|-S)
-        ruby_args+=("$1" "$2")
-        shift ;;
-     # Run with JMX management enabled
-     --manage)
-        java_args+=("-Dcom.sun.management.jmxremote")
-        java_args+=("-Djruby.management.enabled=true") ;;
-     # Don't launch a GUI window, no matter what
-     --headless)
-        java_args+=("-Djava.awt.headless=true") ;;
-     # Run under JDB
-     --jdb)
-        if [ -z "$JAVA_HOME" ] ; then
-          JAVACMD='jdb'
-        else
-          if $cygwin; then
-            JAVACMD="$(cygpath -u "$JAVA_HOME")/bin/jdb"
-          else
-            JAVACMD="$JAVA_HOME/bin/jdb"
-          fi
-        fi
-        JDB_SOURCEPATH="${JRUBY_HOME}/core/src/main/java:${JRUBY_HOME}/lib/ruby/stdlib:."
-        java_args+=("-sourcepath" "$JDB_SOURCEPATH")
-        JRUBY_OPTS+=("-X+C") ;;
-     --client|--server|--noclient)
-        echo "Warning: the $1 flag is deprecated and has no effect most JVMs" 1>&2 ;;
-     --dev)
-        process_java_opts "$dev_mode_opts_file"
-        # For OpenJ9 use environment variable to enable quickstart and shareclasses
-        export OPENJ9_JAVA_OPTIONS="-Xquickstart -Xshareclasses" ;;
-     --sample)
-        java_args+=("-Xprof") ;;
-     --record)
-        java_args+=("-XX:+FlightRecorder" "-XX:StartFlightRecording=dumponexit=true") ;;
-     --no-bootclasspath)
-        NO_BOOTCLASSPATH=true ;;
-     --ng*)
-       echo "Error: Nailgun is no longer supported" 1>&2
-       exit 1 ;;
-     --environment)
-       print_environment_log=1 ;;
-     # warn but ignore
-     --1.8|--1.9|--2.0)
-       echo "warning: $1 ignored" 1>&2 ;;
-     # Abort processing on the double dash
-     --)
-       break ;;
-     # Other opts go to ruby
-     -*)
-       ruby_args+=("$1") ;;
-     # Abort processing on first non-opt arg
-     *)
-       break ;;
-    esac
-    shift
-done
-
-# Force JDK to use specified java.security.egd rand source
-if [ -n "$JAVA_SECURITY_EGD" ]; then
-  java_args+=("-Djava.security.egd=$JAVA_SECURITY_EGD")
-fi
-
-# Append the rest of the arguments
-ruby_args+=("$@")
-
-# Put the ruby_args back into the position arguments $1, $2 etc
-set -- "${ruby_args[@]}"
-
-JAVA_OPTS="$JAVA_OPTS $JAVA_MEM $JAVA_STACK"
-
-JFFI_OPTS="-Djffi.boot.library.path=$JRUBY_HOME/lib/jni"
-
-# ----- Tweak console environment for cygwin ------------------------------------------
-
-if $cygwin; then
-  use_exec=false
-  JRUBY_HOME="$(cygpath --mixed "$JRUBY_HOME")"
-  JRUBY_SHELL="$(cygpath --mixed "$JRUBY_SHELL")"
-
-  if [ "${1:0:1}" = "/" ] && [ -f "$1" ] || [ -d "$1" ]; then
-    win_arg="$(cygpath -w "$1")"
-    shift
-    win_args=("$win_arg" "$@")
-    set -- "${win_args[@]}"
-  fi
-
-  # fix JLine to use UnixTerminal
-  if stty -icanon min 1 -echo > /dev/null 2>&1; then
-    JAVA_OPTS="$JAVA_OPTS -Djline.terminal=jline.UnixTerminal"
-  fi
-
-fi
-
-# ----- Module and Class Data Sharing flags for Java 9+ -----------------------
-
-if [ "$use_modules" ]; then
-  # Use module path instead of classpath for the jruby libs
-  classpath_args=(--module-path "$JRUBY_CP" -classpath "$CP$CP_DELIMITER$CLASSPATH")
-
-  # Switch to non-boot path since we can't use bootclasspath on 9+
-  NO_BOOTCLASSPATH=1
-
-  # Add base opens we need for Ruby compatibility
-  process_java_opts "$jruby_module_opts_file"
-
-  # Allow overriding default JSA file location
-  if [ -z "$JRUBY_JSA" ]; then
-    JRUBY_JSA="$jruby_jsa_file"
-  fi
-
-  # If we have a jruby.jsa file, enable AppCDS
-  if [ -f "$JRUBY_JSA" ]; then
-    add_log
-    add_log "Detected Class Data Sharing archive:"
-    add_log "  $JRUBY_JSA"
-
-    JAVA_OPTS="$JAVA_OPTS -XX:+UnlockDiagnosticVMOptions -XX:SharedArchiveFile=$JRUBY_JSA"
-  fi
-else
-  classpath_args=(-classpath "$JRUBY_CP$CP_DELIMITER$CP$CP_DELIMITER$CLASSPATH")
-fi
-
-# ----- Final prepration of the Java command line -----------------------------
-
-# Include all options from files at the beginning of the Java command line
-JAVA_OPTS="$java_opts_from_files $JAVA_OPTS"
-
-# Don't quote JAVA_OPTS; we want it to expand
-jvm_command=("$JAVACMD" $JAVA_OPTS "$JFFI_OPTS" "${java_args[@]}")
-
-if [ "$NO_BOOTCLASSPATH" ] || [ "$VERIFY_JRUBY" ]; then
-  jvm_command+=("${classpath_args[@]}")
-else
-  jvm_command+=(-Xbootclasspath/a:"$JRUBY_CP" \
-    -classpath "$CP$CP_DELIMITER$CLASSPATH" "-Djruby.home=$JRUBY_HOME")
-fi
-
-jvm_command+=("-Djruby.home=$JRUBY_HOME" \
-    "-Djruby.lib=$JRUBY_HOME/lib" "-Djruby.script=jruby" \
-    "-Djruby.shell=$JRUBY_SHELL" \
-    "$java_class" "$@")
-
-add_log
-add_log "Java command line:"
-add_log "  ${jvm_command[*]}"
-
-if [ "$print_environment_log" ]; then
-  echo "$environment_log"
-  exit 0
-fi
-
-# ----- Run JRuby! ------------------------------------------------------------
-
-if $use_exec; then
-  exec "${jvm_command[@]}"
-else
-  "${jvm_command[@]}"
-
-  # Record the exit status immediately, or it will be overridden.
-  JRUBY_STATUS=$?
-
-  if $cygwin; then
-    stty icanon echo > /dev/null 2>&1
-  fi
-
-  exit $JRUBY_STATUS
-fi
diff --git a/bin/jruby.sh b/bin/jruby.sh
index b6409c0..7fdd80d 100755
--- a/bin/jruby.sh
+++ b/bin/jruby.sh
@@ -1,285 +1,733 @@
-#! /bin/sh
+#!/bin/sh
+# shellcheck disable=1007
 # -----------------------------------------------------------------------------
-# jruby.sh - Start Script for the JRuby interpreter
+# jruby.bash - Start Script for the JRuby interpreter
+# -----------------------------------------------------------------------------
+
+# ----- Guarantee local variables are available -------------------------------
+if command -v local >/dev/null; then
+    :
+elif command -v typeset >/dev/null; then
+    # ksh93 and older have typeset but not local, and expand aliases at parse
+    # time so require re-sourcing the script
+    alias local=typeset
+    if [ -z "$KSH_VERSION" ] || (eval : '"${.sh.version}"' >/dev/null 2>&1); then
+        # shellcheck source=/dev/null
+        . "$0"
+        exit
+    fi
+else
+    echo >&2 "Error: Your shell does not support local variables. Re-run this script with one that does (e.g. bash, ksh)"
+    exit 1
+fi
+
+# ----- Helper functions ------------------------------------------------------
+
+# esceval [ARGUMENT...]
 #
-# Environment Variable Prequisites
+# Escape ARGUMENT for safe use with eval
+# Returns escaped arguments via $REPLY
+# Thanks to @mentalisttraceur for original implementation:
+# https://github.com/mentalisttraceur/esceval
+esceval()
+{
+    local escaped= unescaped= output=
+    REPLY=
+
+    [ $# -gt 0 ] || return 0
+    while true; do
+        escaped=\'
+        unescaped=$1
+        while true; do
+            case $unescaped in
+                (*\'*)
+                    escaped="$escaped${unescaped%%\'*}'\''"
+                    unescaped=${unescaped#*\'}
+                    ;;
+                (*) break ;;
+            esac
+        done
+        escaped=$escaped$unescaped\'
+        shift
+        [ $# -gt 0 ] || break
+        output="$output $escaped"
+    done
+    REPLY="$output $escaped"
+}
+
+# assign LISTNAME ELEMENT [ELEMENT...]
 #
-#   JRUBY_OPTS    (Optional) Default JRuby command line args
-#   JRUBY_SHELL   Where/What is system shell
+# Assign ELEMENT to the list named by LISTNAME.
+assign() {
+    local listname="$1"
+    local REPLY=
+    shift
+
+    esceval "$@"
+    eval "$listname=\"\${REPLY}\""
+}
+
+# append LISTNAME ELEMENT [ELEMENT...]
 #
-#   JAVA_HOME     Must point at your Java Development Kit installation.
+# Append ELEMENT to the list named by LISTNAME.
+append() {
+    local listname="$1"
+    local REPLY=
+    shift
+
+    esceval "$@"
+    eval "$listname=\"\${$listname} \${REPLY}\""
+}
+
+# prepend LISTNAME ELEMENT [ELEMENT...]
 #
-# -----------------------------------------------------------------------------
+# Prepend ELEMENT to the list named by LISTNAME, preserving order.
+prepend() {
+    local listname="$1"
+    local REPLY=
+    shift
 
-# ********************************** NOTE *************************************
-# This script is provided as a convenience for users on systems that do not
-# have the "bash" shell available. It does not support all the flags the bash
-# and native executables do, but should be complete enough for most users.
-# Improvements are welcome.
-# *****************************************************************************
-
-# ----- Verify and Set Required Environment Variables -------------------------
-
-## resolve links - $0 may be a link to  home
-PRG=$0
-progname=`basename "$0"`
-
-while [ -h "$PRG" ] ; do
-  ls=`ls -ld "$PRG"`
-  link=`expr -- "$ls" : '.*-> \(.*\)$'`
-  if expr -- "$link" : '.*/.*' > /dev/null; then
-    if expr -- "$link" : '/' > /dev/null; then
-      PRG="$link"
-    else
-      PRG="`dirname ${PRG}`/${link}"
+    esceval "$@"
+    eval "$listname=\"\${REPLY} \${$listname}\""
+}
+
+# extend LISTNAME1 LISTNAME2
+#
+# Append the elements stored in the list named by LISTNAME2
+# to the list named by LISTNAME1.
+extend() {
+    eval "$1=\"\${$1} \${$2}\""
+}
+
+# preextend LISTNAME1 LISTNAME2
+#
+# Prepend the elements stored in the list named by LISTNAME2
+# to the named by LISTNAME1, preserving order.
+preextend() {
+    eval "$1=\"\${$2} \${$1}\""
+}
+
+# echo [STRING...]
+#
+# Dumb echo, i.e. print arguments joined by spaces with no further processing
+echo() {
+    printf "%s\n" "$*"
+}
+
+# ----- Set variable defaults -------------------------------------------------
+
+readonly java_class=org.jruby.Main
+JRUBY_SHELL=/bin/sh
+
+# Detect cygwin and mingw environments
+cygwin=false
+case "$(uname)" in
+    CYGWIN*) cygwin=true ;;
+    MINGW*)
+        release_id=$(awk -F= '$1=="ID" { print $2; }' /etc/os-release 2> /dev/null)
+        case $release_id in
+            "msys2") ;;
+            *)
+                jruby.exe "$@"
+                exit $?
+                ;;
+        esac
+        ;;
+esac
+readonly cygwin
+
+use_exec=true
+java_opts_from_files=""
+
+NO_BOOTCLASSPATH=false
+VERIFY_JRUBY=false
+print_environment_log=false
+
+if [ -z "$JRUBY_OPTS" ]; then
+    JRUBY_OPTS=""
+fi
+
+if [ -z "$JAVA_STACK" ]; then
+    JAVA_STACK=-Xss2048k
+fi
+
+java_args=""
+ruby_args=""
+
+# Force OpenJDK-based JVMs to use /dev/urandom for random number generation
+# See https://github.com/jruby/jruby/issues/4685 among others.
+# OpenJDK tries really hard to prevent you from using urandom.
+# See https://bugs.openjdk.java.net/browse/JDK-6202721
+# Non-file URL causes fallback to slow threaded SeedGenerator.
+# See https://bz.apache.org/bugzilla/show_bug.cgi?id=56139
+if [ -r "/dev/urandom" ]; then
+    JAVA_SECURITY_EGD="file:/dev/urandom"
+fi
+
+# Gather environment information as we go
+readonly cr='
+'
+environment_log="JRuby Environment$cr================="
+add_log() {
+    environment_log="${environment_log}${cr}${*}"
+}
+
+# Logic to process "arguments files" on both Java 8 and Java 9+
+process_java_opts() {
+    local java_opts_file="$1" java_opts=
+    if [ -r "$java_opts_file" ]; then
+        add_log
+        add_log "Adding Java options from: $java_opts_file"
+
+        while read -r line; do
+            if [ "$line" ]; then
+                java_opts="${java_opts} ${line}"
+                add_log "  $line"
+            fi
+        done < "$java_opts_file"
+
+        # On Java 9+, add an @argument for the given file.
+        # On earlier versions the file contents will be read and expanded on the Java command line.
+        if $use_modules; then
+            java_opts_from_files="$java_opts_from_files @$java_opts_file"
+        else
+            java_opts_from_files="$java_opts_from_files $java_opts"
+        fi
+    fi
+}
+
+# Pure shell dirname/basename
+dir_name() {
+    local filename="$1" trail=
+    case $filename in
+        */*[!/]*)
+            trail=${filename##*[!/]}
+            filename=${filename%%"$trail"}
+            REPLY=${filename%/*}
+            ;;
+        *[!/]*)
+            trail=${filename##*[!/]}
+            REPLY="."
+            ;;
+        *)
+            REPLY="/"
+            ;;
+    esac
+}
+
+base_name() {
+    local filename="$1" trail=
+    case $filename in
+        */*[!/]*)
+            trail=${filename##*[!/]}
+            filename=${filename%%"$trail"}
+            REPLY=${filename##*/}
+            ;;
+        *[!/]*)
+            trail=${filename##*[!/]}
+            REPLY=${filename%%"$trail"}
+            ;;
+        *)
+            REPLY="/"
+            ;;
+    esac
+}
+
+# Determine whether path is absolute and contains no relative segments or symlinks
+path_is_canonical() {
+    local path=
+    for path; do
+        case $path in
+            ([!/]*) return 1 ;;
+            (./*|../*) return 1 ;;
+            (*/.|*/..) return 1 ;;
+            (*/./*|*/../*) return 1 ;;
+        esac
+        while [ "$path" ]; do
+            [ -h "$path" ] && return 1
+            path="${path%/*}"
+        done
+    done
+    return 0
+}
+
+# Resolve directory to its canonical value
+resolve_dir() {
+    # Some shells (dash, ksh) resolve relative paths by default before cd'ing, i.e.
+    # cd /foo/bar/../baz = cd /foo/baz
+    # This is fine unless bar is a symlink, in which case the second form is
+    # invalid. Passing -P to cd fixes this behaviour.
+    REPLY="$(cd -P -- "$1" && pwd)"
+}
+
+# Resolve symlink until it's not a symlink
+resolve_file() {
+    local current="$1" target=
+
+    while [ -h "$current" ]; do
+        target="$(readlink "$current")" || return
+        case $target in
+            (/*) current="$target" ;;
+            # handle relative symlinks
+            (*) dir_name "$current"; current="$REPLY/$target" ;;
+        esac
+    done
+    REPLY="$current"
+}
+
+# Resolve path to its canonical value
+resolve() {
+    local target="$1" base=
+    REPLY=
+
+    # Verify target actually exists (and isn't too deep in symlinks)
+    if ! [ -e "$target" ]; then
+        echo >&2 "Error: No such file or directory: $target"
+        return 1
     fi
-  else
-    PRG="`dirname $PRG`/$link"
-  fi
-done
 
-JRUBY_HOME_1=`dirname "$PRG"`           # the ./bin dir
-if [ "$JRUBY_HOME_1" = '.' ] ; then
-  cwd=`pwd`
-  JRUBY_HOME=`dirname $cwd` # JRUBY-2699
+    # Realpath is way faster than repeatedly calling readlink, so use it if possible
+    if command -v realpath >/dev/null; then
+        REPLY="$(realpath "$target")" && return
+    fi
+
+    # Take shortcut for directories
+    if [ -d "$target" ]; then
+        resolve_dir "$target" && return
+    fi
+
+    # Ensure $target is not a symlink
+    resolve_file "$target" || return
+    target="$REPLY"
+
+    # Resolve parent directory if it's not absolute
+    if ! path_is_canonical "$target"; then
+        dir_name "$target"
+        resolve_dir "$REPLY" || return
+        base="$REPLY"
+
+        base_name "$target"
+        target="$base/$REPLY"
+    fi
+    REPLY="$target"
+}
+
+# ----- Determine JRUBY_HOME based on this executable's path ------------------
+
+# get the absolute path of the executable
+if [ "$BASH" ]; then
+    # shellcheck disable=2128,3028
+    script_src="$BASH_SOURCE"
+else
+    script_src="$0"
+fi
+dir_name "$script_src"
+BASE_DIR="$(cd -P -- "$REPLY" >/dev/null && pwd -P)"
+base_name "$script_src"
+resolve "$BASE_DIR/$REPLY"
+SELF_PATH="$REPLY"
+
+JRUBY_HOME="${SELF_PATH%/*/*}"
+
+# ----- File paths for various options and files we'll process later ----------
+
+# Module options to open up packages we need to reflect
+readonly jruby_module_opts_file="$JRUBY_HOME/bin/.jruby.module_opts"
+
+# Cascading .java_opts files for localized JVM flags
+readonly installed_jruby_java_opts_file="$JRUBY_HOME/bin/.jruby.java_opts"
+readonly home_jruby_java_opts_file="$HOME/.jruby.java_opts"
+readonly pwd_jruby_java_opts_file="$PWD/.jruby.java_opts"
+
+# Options from .dev_mode.java_opts for "--dev" mode, to reduce JRuby startup time
+readonly dev_mode_opts_file="$JRUBY_HOME/bin/.dev_mode.java_opts"
+
+# Default JVM Class Data Sharing Archive (jsa) file for JVMs that support it
+readonly jruby_jsa_file="$JRUBY_HOME/lib/jruby.jsa"
+
+# ----- Initialize environment log --------------------------------------------
+
+add_log
+add_log "JRuby executable:"
+add_log "  $script_src"
+add_log "JRuby command line options:"
+add_log "  $*"
+add_log "Current directory:"
+add_log "  $PWD"
+
+add_log
+add_log "Environment:"
+add_log "  JRUBY_HOME: $JRUBY_HOME"
+add_log "  JRUBY_OPTS: $JRUBY_OPTS"
+add_log "  JAVA_OPTS: $JAVA_OPTS"
+
+# ----- Discover JVM and prep environment to run it ---------------------------
+
+# Determine where the java command is and ensure we have a good JAVA_HOME
+if [ -z "$JAVACMD" ]; then
+    if [ -z "$JAVA_HOME" ]; then
+        readonly java_home_command="/usr/libexec/java_home"
+        if [ -r "$java_home_command" ] \
+            && [ -x "$java_home_command" ] \
+            && [ ! -d "$java_home_command" ]
+        then
+            # use java_home command when none is set (on MacOS)
+            JAVA_HOME="$("$java_home_command")"
+            JAVACMD="$JAVA_HOME"/bin/java
+        else
+            # Linux and others have a chain of symlinks
+            resolve "$(command -v java)"
+            JAVACMD="$REPLY"
+
+            # export separately from command execution
+            dir_name "$JAVACMD"
+            dir_name "$REPLY"
+            JAVA_HOME="$REPLY"
+        fi
+    elif $cygwin; then
+        JAVACMD="$(cygpath -u "$JAVA_HOME")/bin/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
 else
-  JRUBY_HOME=`dirname "$JRUBY_HOME_1"`  # the . dir
+    resolve "$(command -v "$JAVACMD")"
+    expanded_javacmd="$REPLY"
+    if [ -z "$JAVA_HOME" ] && [ -x "$expanded_javacmd" ]; then
+        dir_name "$expanded_javacmd"
+        dir_name "$REPLY"
+        JAVA_HOME="$REPLY"
+    fi
 fi
 
-if [ -z "$JRUBY_OPTS" ] ; then
-  JRUBY_OPTS=""
+# Detect modularized Java
+java_is_modular() {
+    # check that modules file is present
+    if [ -f "$JAVA_HOME"/lib/modules ]; then
+        return 0
+    fi
+
+    # check if a MODULES line appears in release
+    if [ -f "$JAVA_HOME"/release ] && grep -q ^MODULES "$JAVA_HOME"/release; then
+        return 0
+    fi
+
+    return 1
+}
+
+if java_is_modular; then
+    use_modules=true
+else
+    use_modules=false
 fi
+readonly use_modules
 
-if [ -z "$JAVACMD" ] ; then
-  if [ -z "$JAVA_HOME" ] ; then
-    JAVACMD='java'
-  else
-    JAVACMD="$JAVA_HOME/bin/java"
-  fi
+add_log "  JAVACMD: $JAVACMD"
+add_log "  JAVA_HOME: $JAVA_HOME"
+
+if $use_modules; then
+    add_log
+    add_log "Detected Java modules at $JAVA_HOME"
 fi
 
-# If you're seeing odd exceptions, you may have a bad JVM install.
-# Uncomment this and report the version to the JRuby team along with error.
-#$JAVACMD -version
+# ----- Process .java_opts files ----------------------------------------------
 
-JRUBY_SHELL=/bin/sh
+# We include options on the java command line in the following order:
+#
+# * JRuby installed bin/.jruby.java_opts (empty by default)
+# * user directory .jruby.java_opts
+# * current directory .jruby.java_opts
+# * dev mode options from bin/.dev_mode.java_opts, if --dev is specified
+# * module options from bin/.jruby.module_opts if modules are detected
+# * JAVA_OPTS environment variable
+# * command line flags
+
+# Add local and global .jruby.java_opts
+process_java_opts "$installed_jruby_java_opts_file"
+process_java_opts "$home_jruby_java_opts_file"
+process_java_opts "$pwd_jruby_java_opts_file"
+
+# Capture some Java options to be passed separately
+JAVA_OPTS_TEMP=""
+for opt in $JAVA_OPTS; do
+    case $opt in
+        -Xmx*) JAVA_MEM="$opt" ;;
+        -Xss*) JAVA_STACK="$opt" ;;
+        *) JAVA_OPTS_TEMP="$JAVA_OPTS_TEMP $opt" ;;
+    esac
+done
+
+JAVA_OPTS="$JAVA_OPTS_TEMP"
 
-# ----- Set Up The Boot Classpath -------------------------------------------
+# ----- Set up the JRuby class/module path ------------------------------------
 
 CP_DELIMITER=":"
 
-# add main jruby jar to the bootclasspath
+# add main jruby jar to the classpath
+JRUBY_ALREADY_ADDED=false
 for j in "$JRUBY_HOME"/lib/jruby.jar "$JRUBY_HOME"/lib/jruby-complete.jar; do
     if [ ! -e "$j" ]; then
-      continue
+        continue
     fi
     if [ "$JRUBY_CP" ]; then
         JRUBY_CP="$JRUBY_CP$CP_DELIMITER$j"
-        else
+    else
         JRUBY_CP="$j"
     fi
-    if [ $JRUBY_ALREADY_ADDED ]; then
-        echo "WARNING: more than one JRuby JAR found in lib directory"
+    if $JRUBY_ALREADY_ADDED; then
+        echo "WARNING: more than one JRuby JAR found in lib directory" 1>&2
     fi
     JRUBY_ALREADY_ADDED=true
 done
 
-# ----- Set Up The System Classpath -------------------------------------------
+if $cygwin; then
+    JRUBY_CP="$(cygpath -p -w "$JRUBY_CP")"
+fi
+
+# ----- Add additional jars from lib to classpath -----------------------------
 
-if [ "$JRUBY_PARENT_CLASSPATH" != "" ]; then
+if [ "$JRUBY_PARENT_CLASSPATH" ]; then
     # Use same classpath propagated from parent jruby
-    CP=$JRUBY_PARENT_CLASSPATH
+    CP="$JRUBY_PARENT_CLASSPATH"
 else
     # add other jars in lib to CP for command-line execution
     for j in "$JRUBY_HOME"/lib/*.jar; do
-        if [ "$j" == "$JRUBY_HOME"/lib/jruby.jar ]; then
-          continue
-        fi
-        if [ "$j" == "$JRUBY_HOME"/lib/jruby-complete.jar ]; then
-          continue
-        fi
+        case "${j#"$JRUBY_HOME/lib/"}" in
+            jruby.jar|jruby-complete.jar) continue
+        esac
         if [ "$CP" ]; then
             CP="$CP$CP_DELIMITER$j"
-            else
+        else
             CP="$j"
         fi
     done
 
+    if [ "$CP" ] && $cygwin; then
+        CP="$(cygpath -p -w "$CP")"
+    fi
 fi
 
-
-# ----- Execute The Requested Command -----------------------------------------
-
-if [ -z "$JAVA_MEM" ] ; then
-  JAVA_MEM=-Xmx500m
-fi
-
-if [ -z "$JAVA_STACK" ] ; then
-  JAVA_STACK=-Xss2048k
-fi
-
-if [ -z "$JAVA_VM" ]; then
-  JAVA_VM=-client
+if $cygwin; then
+    # switch delimiter only after building Unix style classpaths
+    CP_DELIMITER=";"
 fi
-JAVA_ENCODING=""
 
-#declare -a java_args
-#declare -a ruby_args
+readonly CP_DELIMITER
 
-JAVA_CLASS_JRUBY_MAIN=org.jruby.Main
-java_class=$JAVA_CLASS_JRUBY_MAIN
+# ----- Continue processing JRuby options into JVM options --------------------
 
 # Split out any -J argument for passing to the JVM.
 # Scanning for args is aborted by '--'.
+# shellcheck disable=2086
+set -- $JRUBY_OPTS "$@"
+# increment pointer, permute arguments
 while [ $# -gt 0 ]
 do
-    case "$1" in
-    # Stuff after '-J' in this argument goes to JVM
-    -J*)
-        val=${1:2}
-        if [ "${val:0:4}" = "-Xmx" ]; then
-            JAVA_MEM=$val
-        elif [ "${val:0:4}" = "-Xss" ]; then
-            JAVA_STACK=$val
-        elif [ "${val}" = "" ]; then
-            $JAVACMD -help
-            echo "(Prepend -J in front of these options when using 'jruby' command)" 
+    case $1 in
+        # Stuff after '-J' in this argument goes to JVM
+        -J-Xmx*) JAVA_MEM="${1#-J}" ;;
+        -J-Xss*) JAVA_STACK="${1#-J}" ;;
+        -J)
+            "$JAVACMD" -help
+            echo "(Prepend -J in front of these options when using 'jruby' command)" 1>&2
             exit
-        elif [ "${val}" = "-X" ]; then
-            $JAVACMD -X
-            echo "(Prepend -J in front of these options when using 'jruby' command)" 
+            ;;
+        -J-X)
+            "$JAVACMD" -X
+            echo "(Prepend -J in front of these options when using 'jruby' command)" 1>&2
             exit
-        elif [ "${val}" = "-classpath" ]; then
+            ;;
+        -J-classpath|-J-cp)
             CP="$CP$CP_DELIMITER$2"
             CLASSPATH=""
             shift
-        elif [ "${val}" = "-cp" ]; then
-            CP="$CP$CP_DELIMITER$2"
-            CLASSPATH=""
+            ;;
+        -J-ea*)
+            VERIFY_JRUBY=true
+            append java_args "${1#-J}"
+            ;;
+        -J-Djava.security.egd=*) JAVA_SECURITY_EGD=${1#-J-Djava.security.egd=} ;;
+        # This must be the last check for -J
+        -J*) append java_args "${1#-J}" ;;
+        # Pass -X... and -X? search options through
+        -X*...|-X*\?) append ruby_args "$1" ;;
+        # Match -Xa.b.c=d to translate to -Da.b.c=d as a java option
+        -X*.*) append java_args -Djruby."${1#-X}" ;;
+        # Match switches that take an argument
+        -[CeIS])
+            append ruby_args "$1" "$2"
             shift
-        else
-            if [ "${val:0:3}" = "-ea" ]; then
-                VERIFY_JRUBY="yes"
-            elif [ "${val:0:16}" = "-Dfile.encoding=" ]; then
-                JAVA_ENCODING=$val
+            ;;
+        # Run with JMX management enabled
+        --manage)
+            append java_args -Dcom.sun.management.jmxremote
+            append java_args -Djruby.management.enabled=true
+            ;;
+        # Don't launch a GUI window, no matter what
+        --headless) append java_args -Djava.awt.headless=true ;;
+        # Run under JDB
+        --jdb)
+            if [ -z "$JAVA_HOME" ]; then
+                JAVACMD='jdb'
+            else
+                if $cygwin; then
+                    JAVACMD="$(cygpath -u "$JAVA_HOME")/bin/jdb"
+                else
+                    JAVACMD="$JAVA_HOME/bin/jdb"
+                fi
             fi
-            java_args="${java_args} ${1:2}"
-        fi
-        ;;
-     # Pass -X... and -X? search options through
-     -X*\.\.\.|-X*\?)
-        ruby_args="${ruby_args} $1" ;;
-     -X+T)
-      echo "error: -X+T isn't supported in the shell launcher"
-      exit 1
-      ;;
-     -Xclassic)
-      ;;
-     # Match -Xa.b.c=d to translate to -Da.b.c=d as a java option
-     -X*)
-     val=${1:2}
-     if expr -- "$val" : '.*[.]' > /dev/null; then
-       java_args="${java_args} -Djruby.${val}"
-     else
-       ruby_args="${ruby_args} -X${val}"
-     fi
-     ;;
-     # Match switches that take an argument
-     -C|-e|-I|-S) ruby_args="${ruby_args} $1 $2"; shift ;;
-     # Match same switches with argument stuck together
-     -e*|-I*|-S*) ruby_args="${ruby_args} $1" ;;
-     # Run with JMX management enabled
-     --manage)
-        java_args="${java_args} -Dcom.sun.management.jmxremote"
-        java_args="${java_args} -Djruby.management.enabled=true" ;;
-     # Don't launch a GUI window, no matter what
-     --headless)
-        java_args="${java_args} -Djava.awt.headless=true" ;;
-     # Run under JDB
-     --jdb)
-        if [ -z "$JAVA_HOME" ] ; then
-          JAVACMD='jdb'
-        else
-          JAVACMD="$JAVA_HOME/bin/jdb"
-        fi 
-        JDB_SOURCEPATH="${JRUBY_HOME}/core/src/main/java:${JRUBY_HOME}/lib/ruby/stdlib:."
-        java_args="${java_args} -sourcepath ${JDB_SOURCEPATH}"
-        JRUBY_OPTS="${JRUBY_OPTS} -X+C" ;;
-     --client)
-        JAVA_VM=-client ;;
-     --server)
-        JAVA_VM=-server ;;
-     --noclient)         # JRUBY-4296
-        unset JAVA_VM ;; # For IBM JVM, neither '-client' nor '-server' is applicable
-     --sample)
-        java_args="${java_args} -Xprof" ;;
-     --ng*)
-       echo "Error: Nailgun is no longer supported" 1>&2
-       exit 1 ;;
-     --no-bootclasspath)
-        NO_BOOTCLASSPATH=true ;;
-     # Abort processing on the double dash
-     --) break ;;
-     # Other opts go to ruby
-     -*) ruby_args="${ruby_args} $1" ;;
-     # Abort processing on first non-opt arg
-     *) break ;;
+            JDB_SOURCEPATH="${JRUBY_HOME}/core/src/main/java:${JRUBY_HOME}/lib/ruby/stdlib:."
+            append java_args -sourcepath "$JDB_SOURCEPATH"
+            append ruby_args -X+C
+            ;;
+        --client|--server|--noclient)
+            echo "Warning: the $1 flag is deprecated and has no effect most JVMs" 1>&2
+            ;;
+        --dev)
+            process_java_opts "$dev_mode_opts_file"
+            # For OpenJ9 use environment variable to enable quickstart and shareclasses
+            export OPENJ9_JAVA_OPTIONS="-Xquickstart -Xshareclasses"
+            ;;
+        --sample) append java_args -Xprof ;;
+        --record)
+            append java_args -XX:+FlightRecorder -XX:StartFlightRecording=dumponexit=true
+            ;;
+        --no-bootclasspath) NO_BOOTCLASSPATH=true ;;
+        --ng*)
+            echo "Error: Nailgun is no longer supported" 1>&2
+            exit 1
+            ;;
+        --environment) print_environment_log=true ;;
+        # warn but ignore
+        --1.8|--1.9|--2.0) echo "warning: $1 ignored" 1>&2 ;;
+        # Abort processing on the double dash
+        --) break ;;
+        # Other opts go to ruby
+        -*) append ruby_args "$1" ;;
+        # Abort processing on first non-opt arg
+        *) break ;;
     esac
     shift
 done
 
-# Force file.encoding to UTF-8 when on Mac, since Apple JDK defaults to MacRoman (JRUBY-3576)
-if [[ -z "$JAVA_ENCODING" ]]; then
-  java_args="${java_args} -Dfile.encoding=UTF-8"
+# Force JDK to use specified java.security.egd rand source
+if [ -n "$JAVA_SECURITY_EGD" ]; then
+    append java_args "-Djava.security.egd=$JAVA_SECURITY_EGD"
 fi
 
-# Append the rest of the arguments
-ruby_args="${ruby_args} $@"
+# The rest of the arguments are for ruby
+append ruby_args "$@"
 
-# Put the ruby_args back into the position arguments $1, $2 etc
-set -- "${ruby_args}"
-
-JAVA_OPTS="$JAVA_OPTS $JAVA_VM $JAVA_MEM $JAVA_STACK"
+JAVA_OPTS="$JAVA_OPTS $JAVA_MEM $JAVA_STACK"
 
 JFFI_OPTS="-Djffi.boot.library.path=$JRUBY_HOME/lib/jni"
 
+CLASSPATH="${CP}${CP_DELIMITER}${CLASSPATH}"
+
+# ----- Tweak console environment for cygwin ----------------------------------
+
+if $cygwin; then
+    use_exec=false
+    JRUBY_HOME="$(cygpath --mixed "$JRUBY_HOME")"
+    JRUBY_SHELL="$(cygpath --mixed "$JRUBY_SHELL")"
+
+    eval set -- "$ruby_args"
+
+    case $1 in
+        /*)
+            if [ -f "$1" ] || [ -d "$1" ]; then
+                # replace first element of ruby_args with cygwin form
+                win_arg="$(cygpath -w "$1")"
+                shift
+                set -- "$win_arg" "$@"
+                assign ruby_args "$@"
+            fi
+            ;;
+    esac
+
+    # fix JLine to use UnixTerminal
+    if stty -icanon min 1 -echo > /dev/null 2>&1; then
+        JAVA_OPTS="$JAVA_OPTS -Djline.terminal=jline.UnixTerminal"
+    fi
+
+fi
 
-if [[ "$NO_BOOTCLASSPATH" != "" || ( "$VERIFY_JRUBY" != "" ) ]]; then
-  if [ "$PROFILE_ARGS" != "" ]; then
-      echo "Running with instrumented profiler"
-  fi
+# ----- Module and Class Data Sharing flags for Java 9+ -----------------------
 
-  if [ $java_class = $JAVA_CLASS_NGSERVER -a -n "${JRUBY_OPTS}" ]; then
-    echo "warning: starting a nailgun server; discarding JRUBY_OPTS: ${JRUBY_OPTS}"
-    JRUBY_OPTS=''
-  fi
+if $use_modules; then
+    # Switch to non-boot path since we can't use bootclasspath on 9+
+    NO_BOOTCLASSPATH=true
 
+    # Add base opens we need for Ruby compatibility
+    process_java_opts "$jruby_module_opts_file"
 
-  "$JAVACMD" $PROFILE_ARGS $JAVA_OPTS "$JFFI_OPTS" ${java_args} -classpath "$JRUBY_CP$CP_DELIMITER$CP$CP_DELIMITER$CLASSPATH" \
-    "-Djruby.home=$JRUBY_HOME" \
-    "-Djruby.lib=$JRUBY_HOME/lib" -Djruby.script=jruby \
-    "-Djruby.shell=$JRUBY_SHELL" \
-    $java_class $JRUBY_OPTS $@
+    # Allow overriding default JSA file location
+    if [ -z "$JRUBY_JSA" ]; then
+        JRUBY_JSA="$jruby_jsa_file"
+    fi
 
-  # Record the exit status immediately, or it will be overridden.
-  JRUBY_STATUS=$?
+    # If we have a jruby.jsa file, enable AppCDS
+    if [ -f "$JRUBY_JSA" ]; then
+        add_log
+        add_log "Detected Class Data Sharing archive:"
+        add_log "  $JRUBY_JSA"
 
-  if [ "$PROFILE_ARGS" != "" ]; then
-      echo "Profiling results:"
-      cat profile.txt
-      rm profile.txt
-  fi
+        JAVA_OPTS="$JAVA_OPTS -XX:+UnlockDiagnosticVMOptions -XX:SharedArchiveFile=$JRUBY_JSA"
+    fi
+fi
 
+# ----- Final prepration of the Java command line -----------------------------
 
-  exit $JRUBY_STATUS
+# Include all options from files at the beginning of the Java command line
+JAVA_OPTS="$java_opts_from_files $JAVA_OPTS"
+
+# Don't quote JAVA_OPTS; we want it to expand
+# shellcheck disable=2086
+prepend java_args "$JAVACMD" $JAVA_OPTS "$JFFI_OPTS"
+
+if $NO_BOOTCLASSPATH || $VERIFY_JRUBY; then
+    if $use_modules; then
+        # Use module path instead of classpath for the jruby libs
+        append java_args --module-path "$JRUBY_CP" -classpath "$CLASSPATH"
+    else
+        append java_args -classpath "$JRUBY_CP$CP_DELIMITER$CLASSPATH"
+    fi
 else
-  exec $JAVACMD $JAVA_OPTS $JFFI_OPTS ${java_args} -Xbootclasspath/a:$JRUBY_CP -classpath $CP$CP_DELIMITER$CLASSPATH \
-      -Djruby.home=$JRUBY_HOME \
-      -Djruby.lib=$JRUBY_HOME/lib -Djruby.script=jruby \
-      -Djruby.shell=$JRUBY_SHELL \
-      $java_class $JRUBY_OPTS $@
+    append java_args -Xbootclasspath/a:"$JRUBY_CP"
+    append java_args -classpath "$CLASSPATH"
+    append java_args -Djruby.home="$JRUBY_HOME"
 fi
+
+append java_args -Djruby.home="$JRUBY_HOME" \
+    -Djruby.lib="$JRUBY_HOME/lib" \
+    -Djruby.script=jruby \
+    -Djruby.shell="$JRUBY_SHELL" \
+    "$java_class"
+extend java_args ruby_args
+
+eval set -- "$java_args"
+
+add_log
+add_log "Java command line:"
+add_log "  $*"
+
+if $print_environment_log; then
+    echo "$environment_log"
+    exit 0
 fi
 
-# Be careful adding code down here, you might override the exit
-# status of the jruby invocation.
+# ----- Run JRuby! ------------------------------------------------------------
+
+if $use_exec; then
+    exec "$@"
+else
+    "$@"
+
+    # Record the exit status immediately, or it will be overridden.
+    JRUBY_STATUS=$?
+
+    if $cygwin; then
+        stty icanon echo > /dev/null 2>&1
+    fi
+
+    exit $JRUBY_STATUS
+fi
diff --git a/core/pom.rb b/core/pom.rb
index b443fa6..a82417f 100644
--- a/core/pom.rb
+++ b/core/pom.rb
@@ -43,29 +43,29 @@ project 'JRuby Base' do
 
   # exclude jnr-ffi to avoid problems with shading and relocation of the asm packages
   jar 'com.github.jnr:jnr-netdb:1.2.0', :exclusions => ['com.github.jnr:jnr-ffi']
-  jar 'com.github.jnr:jnr-enxio:0.32.13', :exclusions => ['com.github.jnr:jnr-ffi']
-  jar 'com.github.jnr:jnr-unixsocket:0.38.17', :exclusions => ['com.github.jnr:jnr-ffi']
-  jar 'com.github.jnr:jnr-posix:3.1.15', :exclusions => ['com.github.jnr:jnr-ffi']
-  jar 'com.github.jnr:jnr-constants:0.10.3', :exclusions => ['com.github.jnr:jnr-ffi']
-  jar 'com.github.jnr:jnr-ffi:2.2.11'
+  jar 'com.github.jnr:jnr-enxio:0.32.16', :exclusions => ['com.github.jnr:jnr-ffi']
+  jar 'com.github.jnr:jnr-unixsocket:0.38.21', :exclusions => ['com.github.jnr:jnr-ffi']
+  jar 'com.github.jnr:jnr-posix:3.1.18', :exclusions => ['com.github.jnr:jnr-ffi']
+  jar 'com.github.jnr:jnr-constants:0.10.4', :exclusions => ['com.github.jnr:jnr-ffi']
+  jar 'com.github.jnr:jnr-ffi:2.2.15'
   jar 'com.github.jnr:jffi:${jffi.version}'
   jar 'com.github.jnr:jffi:${jffi.version}:native'
 
-  jar 'org.jruby.joni:joni:2.1.43'
-  jar 'org.jruby.jcodings:jcodings:1.0.57'
+  jar 'org.jruby.joni:joni:2.2.1'
+  jar 'org.jruby.jcodings:jcodings:1.0.58'
   jar 'org.jruby:dirgra:0.3'
 
-  jar 'com.headius:invokebinder:1.12'
+  jar 'com.headius:invokebinder:1.13'
   jar 'com.headius:options:1.6'
 
-  jar 'com.jcraft:jzlib:1.1.3'
+  jar 'org.jruby:jzlib:1.1.5'
   jar 'junit:junit', :scope => 'test'
   jar 'org.awaitility:awaitility', :scope => 'test'
   jar 'org.apache.ant:ant:${ant.version}', :scope => 'provided'
   jar 'org.osgi:org.osgi.core:5.0.0', :scope => 'provided'
 
   # joda timezone must be before joda-time to be packed correctly
-  jar 'org.jruby:joda-timezones:${tzdata.version}', :scope => '${tzdata.scope}'
+  # jar 'org.jruby:joda-timezones:${tzdata.version}', :scope => '${tzdata.scope}'
   jar 'joda-time:joda-time:${joda.time.version}'
 
   # SLF4J only used within SLF4JLogger (JRuby logger impl) class
@@ -74,7 +74,7 @@ project 'JRuby Base' do
 
   jar 'me.qmx.jitescript:jitescript:0.4.1', :exclusions => ['org.ow2.asm:asm-all']
 
-  jar 'com.headius:backport9:1.12'
+  jar 'com.headius:backport9:1.13'
 
   jar 'jakarta.annotation:jakarta.annotation-api:2.0.0', scope: 'provided'
 
@@ -133,7 +133,6 @@ project 'JRuby Base' do
     execute_goals( 'create',
                    :id => 'jruby-revision',
                    :phase => 'generate-sources',
-                   'shortRevisionLength' =>  '10',
                    'buildNumberPropertyName' =>  'jruby.revision' )
   end
 
@@ -168,12 +167,21 @@ project 'JRuby Base' do
     end
   end
 
+  fork_compiler_args = [ '-XDignore.symbol.file=true',
+                         '-J-Duser.language=en',
+                         '-J-Dfile.encoding=UTF-8',
+                         '-J-Xmx${jruby.compile.memory}' ]
+
+  default_compile_configuration = {
+    'fork' => 'true',
+    'annotationProcessors' => [ 'org.jruby.anno.AnnotationBinder' ],
+    'generatedSourcesDirectory' =>  'target/generated-sources',
+    'compilerArgs' => fork_compiler_args
+  }
+
   plugin( :compiler,
           'encoding' => 'utf-8',
-          'debug' => 'true',
           'verbose' => 'false',
-          'fork' => 'true',
-          'compilerArgs' => { 'arg' => '-J-Xmx1G' },
           'showWarnings' => 'true',
           'showDeprecation' => 'true',
           'source' => [ '${base.java.version}', '1.8' ],
@@ -191,24 +199,19 @@ project 'JRuby Base' do
                                    'org/jruby/util/CodegenUtils.java',
                                    'org/jruby/util/SafePropertyAccessor.java' ] )
     execute_goals( 'compile',
-                   :id => 'default-compile',
-                   :phase => 'compile',
-                   'debug' => 'true',
-                   'annotationProcessors' => [ 'org.jruby.anno.AnnotationBinder' ],
-                   'generatedSourcesDirectory' =>  'target/generated-sources',
-                   'compilerArgs' => [ '-XDignore.symbol.file=true',
-                                       '-J-Duser.language=en',
-                                       '-J-Dfile.encoding=UTF-8',
-                                       '-J-Xmx${jruby.compile.memory}' ] )
+                   default_compile_configuration.merge(
+                     :id => 'default-compile',
+                     :phase => 'compile'
+                   ))
+
     execute_goals( 'compile',
                    :id => 'populators',
                    :phase => 'process-classes',
-                   'debug' => 'true',
-                   'compilerArgs' => [ '-XDignore.symbol.file=true',
-                                       '-J-Duser.language=en',
-                                       '-J-Dfile.encoding=UTF-8',
-                                       '-J-Xmx${jruby.compile.memory}' ],
+                   'debug' => 'false',
+                   'fork' => 'true',
+                   'compilerArgs' => fork_compiler_args,
                    'includes' => [ 'org/jruby/gen/**/*.java' ] )
+
     execute_goals( 'compile',
                    :id => 'eclipse-hack',
                    :phase => 'process-classes',
@@ -237,7 +240,7 @@ project 'JRuby Base' do
           },
           'argLine' =>  '-Xmx${jruby.test.memory} -Dfile.encoding=UTF-8 -Djava.awt.headless=true',
           'environmentVariables' => {
-              'JDK_JAVA_OPTIONS' => '--add-modules java.scripting'
+              'JDK_JAVA_OPTIONS' => '--add-modules java.scripting --add-opens java.base/sun.nio.ch=ALL-UNNAMED --add-opens java.base/java.io=ALL-UNNAMED'
           },
           includes: [
             'org/jruby/test/**/*Test*.java',
@@ -283,7 +286,7 @@ project 'JRuby Base' do
                   ])
   end
 
-  copy_goal = [:exec, :executable => '/bin/sh', :arguments => ['-c', 'cp ${jruby.basedir}/bin/jruby.bash ${jruby.basedir}/bin/jruby']]
+  copy_goal = [:exec, :executable => '/bin/sh', :arguments => ['-c', 'cp ${jruby.basedir}/bin/jruby.sh ${jruby.basedir}/bin/jruby']]
 
   profile :clean do
     activation do
@@ -300,7 +303,41 @@ project 'JRuby Base' do
     end
   end
 
-  profile 'jruby.bash' do
+  profile 'error-prone' do
+    activation do
+      jdk('11') # even an older (2.10.0) version of error-prone would need an adjusted setup on Java 8
+      property(name: 'env.CI') # for keeping fast development cycle, by default only run on CI
+    end
+
+    plugin :compiler do
+      execute_goals( 'compile',
+                     :id => 'default-compile',
+                     :phase => 'none' ) # do not execute default-compile, we have a replacement bellow
+
+      execute_goals( 'compile',
+                     default_compile_configuration.merge(
+                       :id => 'default-compile_with_error_prone',
+                       :phase => 'compile',
+                       'fork' => 'true',
+                       'compilerArgs' => default_compile_configuration['compilerArgs'] + [
+                         '-XDcompilePolicy=simple', '-Xplugin:ErrorProne'
+                       ],
+                        'annotationProcessorPaths' => { 'path' => [ {
+                                                                      'groupId' => 'com.google.errorprone',
+                                                                      'artifactId' => 'error_prone_core',
+                                                                      'version' => '2.18.0'
+                                                                    },
+                                                                    {
+                                                                      'groupId' => 'org.jruby',
+                                                                      'artifactId' => 'jruby-base',
+                                                                      'version' => version
+                                                                    } ]
+                        }
+                    ) )
+    end
+  end
+
+  profile 'jruby.sh' do
 
     activation do
       file( :missing => '../bin/jruby' )
diff --git a/core/pom.xml b/core/pom.xml
index b1d33fc..b471010 100644
--- a/core/pom.xml
+++ b/core/pom.xml
@@ -12,7 +12,7 @@ DO NOT MODIFY - GENERATED CODE
   <parent>
     <groupId>org.jruby</groupId>
     <artifactId>jruby-parent</artifactId>
-    <version>9.3.9.0</version>
+    <version>9.4.5.0</version>
   </parent>
   <artifactId>jruby-base</artifactId>
   <name>JRuby Base</name>
@@ -55,10 +55,9 @@ DO NOT MODIFY - GENERATED CODE
     <test.results.dir>${build.dir}/test-results</test.results.dir>
     <tzdata.scope>provided</tzdata.scope>
     <tzdata.version>2019c</tzdata.version>
-    <version.ruby>2.6.8</version.ruby>
-    <version.ruby.major>2.6</version.ruby.major>
-    <version.ruby.minor>0</version.ruby.minor>
-    <version.ruby.revision>67951</version.ruby.revision>
+    <version.ruby>3.1.4</version.ruby>
+    <version.ruby.major>3.1</version.ruby.major>
+    <version.ruby.minor>4</version.ruby.minor>
   </properties>
   <dependencies>
     <dependency>
@@ -82,59 +81,59 @@ DO NOT MODIFY - GENERATED CODE
       <version>1.2.0</version>
       <exclusions>
         <exclusion>
-          <artifactId>jnr-ffi</artifactId>
           <groupId>com.github.jnr</groupId>
+          <artifactId>jnr-ffi</artifactId>
         </exclusion>
       </exclusions>
     </dependency>
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-enxio</artifactId>
-      <version>0.32.13</version>
+      <version>0.32.16</version>
       <exclusions>
         <exclusion>
-          <artifactId>jnr-ffi</artifactId>
           <groupId>com.github.jnr</groupId>
+          <artifactId>jnr-ffi</artifactId>
         </exclusion>
       </exclusions>
     </dependency>
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-unixsocket</artifactId>
-      <version>0.38.17</version>
+      <version>0.38.21</version>
       <exclusions>
         <exclusion>
-          <artifactId>jnr-ffi</artifactId>
           <groupId>com.github.jnr</groupId>
+          <artifactId>jnr-ffi</artifactId>
         </exclusion>
       </exclusions>
     </dependency>
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-posix</artifactId>
-      <version>3.1.15</version>
+      <version>3.1.18</version>
       <exclusions>
         <exclusion>
-          <artifactId>jnr-ffi</artifactId>
           <groupId>com.github.jnr</groupId>
+          <artifactId>jnr-ffi</artifactId>
         </exclusion>
       </exclusions>
     </dependency>
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-constants</artifactId>
-      <version>0.10.3</version>
+      <version>0.10.4</version>
       <exclusions>
         <exclusion>
-          <artifactId>jnr-ffi</artifactId>
           <groupId>com.github.jnr</groupId>
+          <artifactId>jnr-ffi</artifactId>
         </exclusion>
       </exclusions>
     </dependency>
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-ffi</artifactId>
-      <version>2.2.11</version>
+      <version>2.2.15</version>
     </dependency>
     <dependency>
       <groupId>com.github.jnr</groupId>
@@ -150,12 +149,12 @@ DO NOT MODIFY - GENERATED CODE
     <dependency>
       <groupId>org.jruby.joni</groupId>
       <artifactId>joni</artifactId>
-      <version>2.1.43</version>
+      <version>2.2.1</version>
     </dependency>
     <dependency>
       <groupId>org.jruby.jcodings</groupId>
       <artifactId>jcodings</artifactId>
-      <version>1.0.57</version>
+      <version>1.0.58</version>
     </dependency>
     <dependency>
       <groupId>org.jruby</groupId>
@@ -165,7 +164,7 @@ DO NOT MODIFY - GENERATED CODE
     <dependency>
       <groupId>com.headius</groupId>
       <artifactId>invokebinder</artifactId>
-      <version>1.12</version>
+      <version>1.13</version>
     </dependency>
     <dependency>
       <groupId>com.headius</groupId>
@@ -173,9 +172,9 @@ DO NOT MODIFY - GENERATED CODE
       <version>1.6</version>
     </dependency>
     <dependency>
-      <groupId>com.jcraft</groupId>
+      <groupId>org.jruby</groupId>
       <artifactId>jzlib</artifactId>
-      <version>1.1.3</version>
+      <version>1.1.5</version>
     </dependency>
     <dependency>
       <groupId>junit</groupId>
@@ -200,12 +199,6 @@ DO NOT MODIFY - GENERATED CODE
       <scope>provided</scope>
     </dependency>
     <dependency>
-      <groupId>org.jruby</groupId>
-      <artifactId>joda-timezones</artifactId>
-      <version>${tzdata.version}</version>
-      <scope>${tzdata.scope}</scope>
-    </dependency>
-    <dependency>
       <groupId>joda-time</groupId>
       <artifactId>joda-time</artifactId>
       <version>${joda.time.version}</version>
@@ -229,15 +222,15 @@ DO NOT MODIFY - GENERATED CODE
       <version>0.4.1</version>
       <exclusions>
         <exclusion>
-          <artifactId>asm-all</artifactId>
           <groupId>org.ow2.asm</groupId>
+          <artifactId>asm-all</artifactId>
         </exclusion>
       </exclusions>
     </dependency>
     <dependency>
       <groupId>com.headius</groupId>
       <artifactId>backport9</artifactId>
-      <version>1.12</version>
+      <version>1.13</version>
     </dependency>
     <dependency>
       <groupId>jakarta.annotation</groupId>
@@ -355,7 +348,6 @@ DO NOT MODIFY - GENERATED CODE
               <goal>create</goal>
             </goals>
             <configuration>
-              <shortRevisionLength>10</shortRevisionLength>
               <buildNumberPropertyName>jruby.revision</buildNumberPropertyName>
             </configuration>
           </execution>
@@ -451,7 +443,7 @@ DO NOT MODIFY - GENERATED CODE
               <goal>compile</goal>
             </goals>
             <configuration>
-              <debug>true</debug>
+              <fork>true</fork>
               <annotationProcessors>
                 <annotationProcessor>org.jruby.anno.AnnotationBinder</annotationProcessor>
               </annotationProcessors>
@@ -471,7 +463,8 @@ DO NOT MODIFY - GENERATED CODE
               <goal>compile</goal>
             </goals>
             <configuration>
-              <debug>true</debug>
+              <debug>false</debug>
+              <fork>true</fork>
               <compilerArgs>
                 <compilerArg>-XDignore.symbol.file=true</compilerArg>
                 <compilerArg>-J-Duser.language=en</compilerArg>
@@ -499,12 +492,7 @@ DO NOT MODIFY - GENERATED CODE
         </executions>
         <configuration>
           <encoding>utf-8</encoding>
-          <debug>true</debug>
           <verbose>false</verbose>
-          <fork>true</fork>
-          <compilerArgs>
-            <arg>-J-Xmx1G</arg>
-          </compilerArgs>
           <showWarnings>true</showWarnings>
           <showDeprecation>true</showDeprecation>
           <source>${base.java.version}</source>
@@ -559,7 +547,7 @@ DO NOT MODIFY - GENERATED CODE
           </systemProperties>
           <argLine>-Xmx${jruby.test.memory} -Dfile.encoding=UTF-8 -Djava.awt.headless=true</argLine>
           <environmentVariables>
-            <JDK_JAVA_OPTIONS>--add-modules java.scripting</JDK_JAVA_OPTIONS>
+            <JDK_JAVA_OPTIONS>--add-modules java.scripting --add-opens java.base/sun.nio.ch=ALL-UNNAMED --add-opens java.base/java.io=ALL-UNNAMED</JDK_JAVA_OPTIONS>
           </environmentVariables>
           <includes>
             <include>org/jruby/test/**/*Test*.java</include>
@@ -665,7 +653,7 @@ DO NOT MODIFY - GENERATED CODE
                   <executable>/bin/sh</executable>
                   <arguments>
                     <argument>-c</argument>
-                    <argument>cp ${jruby.basedir}/bin/jruby.bash ${jruby.basedir}/bin/jruby</argument>
+                    <argument>cp ${jruby.basedir}/bin/jruby.sh ${jruby.basedir}/bin/jruby</argument>
                   </arguments>
                 </configuration>
               </execution>
@@ -675,7 +663,66 @@ DO NOT MODIFY - GENERATED CODE
       </build>
     </profile>
     <profile>
-      <id>jruby.bash</id>
+      <id>error-prone</id>
+      <activation>
+        <jdk>11</jdk>
+        <property>
+          <name>env.CI</name>
+        </property>
+      </activation>
+      <build>
+        <plugins>
+          <plugin>
+            <artifactId>maven-compiler-plugin</artifactId>
+            <executions>
+              <execution>
+                <id>default-compile</id>
+                <phase>none</phase>
+                <goals>
+                  <goal>compile</goal>
+                </goals>
+              </execution>
+              <execution>
+                <id>default-compile_with_error_prone</id>
+                <phase>compile</phase>
+                <goals>
+                  <goal>compile</goal>
+                </goals>
+                <configuration>
+                  <fork>true</fork>
+                  <annotationProcessors>
+                    <annotationProcessor>org.jruby.anno.AnnotationBinder</annotationProcessor>
+                  </annotationProcessors>
+                  <generatedSourcesDirectory>target/generated-sources</generatedSourcesDirectory>
+                  <compilerArgs>
+                    <compilerArg>-XDignore.symbol.file=true</compilerArg>
+                    <compilerArg>-J-Duser.language=en</compilerArg>
+                    <compilerArg>-J-Dfile.encoding=UTF-8</compilerArg>
+                    <compilerArg>-J-Xmx${jruby.compile.memory}</compilerArg>
+                    <compilerArg>-XDcompilePolicy=simple</compilerArg>
+                    <compilerArg>-Xplugin:ErrorProne</compilerArg>
+                  </compilerArgs>
+                  <annotationProcessorPaths>
+                    <path>
+                      <groupId>com.google.errorprone</groupId>
+                      <artifactId>error_prone_core</artifactId>
+                      <version>2.18.0</version>
+                    </path>
+                    <path>
+                      <groupId>org.jruby</groupId>
+                      <artifactId>jruby-base</artifactId>
+                      <version>9.4.5.0</version>
+                    </path>
+                  </annotationProcessorPaths>
+                </configuration>
+              </execution>
+            </executions>
+          </plugin>
+        </plugins>
+      </build>
+    </profile>
+    <profile>
+      <id>jruby.sh</id>
       <activation>
         <os>
           <family>unix</family>
@@ -696,7 +743,7 @@ DO NOT MODIFY - GENERATED CODE
                   <executable>/bin/sh</executable>
                   <arguments>
                     <argument>-c</argument>
-                    <argument>cp ${jruby.basedir}/bin/jruby.bash ${jruby.basedir}/bin/jruby</argument>
+                    <argument>cp ${jruby.basedir}/bin/jruby.sh ${jruby.basedir}/bin/jruby</argument>
                   </arguments>
                 </configuration>
               </execution>
diff --git a/core/src/main/java/org/jruby/AbstractRubyMethod.java b/core/src/main/java/org/jruby/AbstractRubyMethod.java
index 49e1f69..b3ccb01 100644
--- a/core/src/main/java/org/jruby/AbstractRubyMethod.java
+++ b/core/src/main/java/org/jruby/AbstractRubyMethod.java
@@ -119,6 +119,21 @@ public abstract class AbstractRubyMethod extends RubyObject implements DataType 
         return context.nil;
     }
 
+    @JRubyMethod(name = "public?")
+    public RubyBoolean public_p(ThreadContext context) {
+        return context.runtime.newBoolean(method.getVisibility().isPublic());
+    }
+
+    @JRubyMethod(name = "protected?")
+    public RubyBoolean protected_p(ThreadContext context) {
+        return context.runtime.newBoolean(method.getVisibility().isProtected());
+    }
+
+    @JRubyMethod(name = "private?")
+    public RubyBoolean private_p(ThreadContext context) {
+        return context.runtime.newBoolean(method.getVisibility().isPrivate());
+    }
+
     public String getFilename() {
         DynamicMethod realMethod = method.getRealMethod(); // Follow Aliases
         if (realMethod instanceof PositionAware) {
@@ -153,9 +168,9 @@ public abstract class AbstractRubyMethod extends RubyObject implements DataType 
         }
 
         if (receiver == null) {
-            return RubyUnboundMethod.newUnboundMethod(superClass, methodName, superClass, originName, entry);
+            return RubyUnboundMethod.newUnboundMethod(entry.sourceModule, methodName, superClass, originName, entry);
         } else {
-            return RubyMethod.newMethod(superClass, methodName, superClass, originName, entry, receiver);
+            return RubyMethod.newMethod(entry.sourceModule, methodName, superClass, originName, entry, receiver);
         }
     }
 
diff --git a/core/src/main/java/org/jruby/BasicObjectStub.java b/core/src/main/java/org/jruby/BasicObjectStub.java
index 8d3ad83..d7d706a 100644
--- a/core/src/main/java/org/jruby/BasicObjectStub.java
+++ b/core/src/main/java/org/jruby/BasicObjectStub.java
@@ -158,7 +158,6 @@ public final class BasicObjectStub {
         IRubyObject str = Helpers.invoke(getRuntime(self).getCurrentContext(), self, "to_s");
 
         if (!(str instanceof RubyString)) return (RubyString) anyToString(self);
-        if (isTaint(self)) str.setTaint(true);
         return (RubyString) str;
     }
 
@@ -196,9 +195,7 @@ public final class BasicObjectStub {
         final RubyClass metaClass = getMetaClass(self);
         String cname = metaClass.getRealClass().getName();
         /* 6:tags 16:addr 1:eos */
-        RubyString str = metaClass.runtime.newString("#<" + cname + ":0x" + Integer.toHexString(System.identityHashCode(self)) + '>');
-        str.setTaint(isTaint(self));
-        return str;
+        return metaClass.runtime.newString("#<" + cname + ":0x" + Integer.toHexString(System.identityHashCode(self)) + '>');
     }
 
     public static IRubyObject checkStringType(IRubyObject self) {
diff --git a/core/src/main/java/org/jruby/DelegatedModule.java b/core/src/main/java/org/jruby/DelegatedModule.java
new file mode 100644
index 0000000..83deee3
--- /dev/null
+++ b/core/src/main/java/org/jruby/DelegatedModule.java
@@ -0,0 +1,5 @@
+package org.jruby;
+
+public interface DelegatedModule {
+    public RubyModule getDelegate();
+}
diff --git a/core/src/main/java/org/jruby/EvalType.java b/core/src/main/java/org/jruby/EvalType.java
index b2d8e72..bdc41cd 100644
--- a/core/src/main/java/org/jruby/EvalType.java
+++ b/core/src/main/java/org/jruby/EvalType.java
@@ -1,5 +1,8 @@
 package org.jruby;
 
+/**
+ * Code evaluation type
+ */
 public enum EvalType {
     NONE, BINDING_EVAL, INSTANCE_EVAL, MODULE_EVAL
-};
+}
diff --git a/core/src/main/java/org/jruby/FiberScheduler.java b/core/src/main/java/org/jruby/FiberScheduler.java
new file mode 100644
index 0000000..0a4af4b
--- /dev/null
+++ b/core/src/main/java/org/jruby/FiberScheduler.java
@@ -0,0 +1,210 @@
+package org.jruby;
+
+import jnr.constants.platform.Errno;
+import org.jruby.runtime.Helpers;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.io.OpenFile;
+
+import java.nio.ByteBuffer;
+
+public class FiberScheduler {
+    // MRI: rb_fiber_scheduler_kernel_sleep
+    public static IRubyObject kernelSleep(ThreadContext context, IRubyObject scheduler, IRubyObject timeout) {
+        return scheduler.callMethod(context, "kernel_sleep", timeout);
+    }
+
+    // MRI: rb_fiber_scheduler_kernel_sleepv
+    public static IRubyObject kernelSleep(ThreadContext context, IRubyObject scheduler, IRubyObject[] args) {
+        return scheduler.callMethod(context, "kernel_sleep", args);
+    }
+
+    // MRI: rb_fiber_scheduler_process_wait
+    public static IRubyObject processWait(ThreadContext context, IRubyObject scheduler, long pid, int flags) {
+        return Helpers.invokeChecked(context, scheduler, "process_wait", context.runtime.newFixnum(pid), context.runtime.newFixnum(flags));
+    }
+
+    // MRI: rb_fiber_scheduler_block
+    public static IRubyObject block(ThreadContext context, IRubyObject scheduler, IRubyObject blocker, IRubyObject timeout) {
+        return Helpers.invoke(context, scheduler, "block", blocker, timeout);
+    }
+
+    // MRI: rb_fiber_scheduler_unblock
+    public static IRubyObject unblock(ThreadContext context, IRubyObject scheduler, IRubyObject blocker, IRubyObject fiber) {
+        return Helpers.invoke(context, scheduler, "unblock", blocker, fiber);
+    }
+
+    // MRI: rb_fiber_scheduler_io_wait
+    public static IRubyObject ioWait(ThreadContext context, IRubyObject scheduler, IRubyObject io, IRubyObject events, IRubyObject timeout) {
+        return Helpers.invoke(context, scheduler, "io_wait", io, events, timeout);
+    }
+
+    // MRI: rb_fiber_scheduler_io_wait_readable
+    public static IRubyObject ioWaitReadable(ThreadContext context, IRubyObject scheduler, IRubyObject io) {
+        return ioWait(context, scheduler, io, context.runtime.newFixnum(OpenFile.READABLE), context.nil);
+    }
+
+    // MRI: rb_fiber_scheduler_io_wait_writable
+    public static IRubyObject ioWaitWritable(ThreadContext context, IRubyObject scheduler, IRubyObject io) {
+        return ioWait(context, scheduler, io, context.runtime.newFixnum(OpenFile.WRITABLE), context.nil);
+    }
+
+    // MRI: rb_fiber_scheduler_io_select
+    public static IRubyObject ioSelect(ThreadContext context, IRubyObject scheduler, IRubyObject readables, IRubyObject writables, IRubyObject exceptables, IRubyObject timeout) {
+        return ioSelectv(context, scheduler, readables, writables, exceptables, timeout);
+    }
+
+    // MRI: rb_fiber_scheduler_io_selectv
+    public static IRubyObject ioSelectv(ThreadContext context, IRubyObject scheduler, IRubyObject... args) {
+        return Helpers.invokeChecked(context, scheduler, "io_select", args);
+    }
+
+    // MRI: rb_fiber_scheduler_io_read
+    public static IRubyObject ioRead(ThreadContext context, IRubyObject scheduler, IRubyObject io, IRubyObject buffer, int length, int offset) {
+        Ruby runtime = context.runtime;
+        return Helpers.invokeChecked(context, scheduler, "io_read", io, buffer, runtime.newFixnum(length), runtime.newFixnum(offset));
+    }
+
+    public static IRubyObject ioRead(ThreadContext context, IRubyObject scheduler, IRubyObject io, IRubyObject buffer, RubyInteger length, RubyInteger offset) {
+        return Helpers.invokeChecked(context, scheduler, "io_read", io, buffer, length, offset);
+    }
+
+    // MRI: rb_fiber_scheduler_io_pread
+    public static IRubyObject ioPRead(ThreadContext context, IRubyObject scheduler, IRubyObject io, IRubyObject buffer, int from, int length, int offset) {
+        return Helpers.invokeChecked(context, scheduler, "io_pread", io, buffer, context.runtime.newFixnum(from), context.runtime.newFixnum(length), context.runtime.newFixnum(offset));
+    }
+
+    public static IRubyObject ioPRead(ThreadContext context, IRubyObject scheduler, IRubyObject io, IRubyObject buffer, RubyInteger from, RubyInteger length, RubyInteger offset) {
+        return Helpers.invokeChecked(context, scheduler, "io_pread", io, buffer, from, length, offset);
+    }
+
+    // MRI: rb_fiber_scheduler_io_write
+    public static IRubyObject ioWrite(ThreadContext context, IRubyObject scheduler, IRubyObject io, IRubyObject buffer, int length, int offset) {
+        Ruby runtime = context.runtime;
+        return Helpers.invokeChecked(context, scheduler, "io_write", io, buffer, runtime.newFixnum(length), runtime.newFixnum(offset));
+    }
+
+    public static IRubyObject ioWrite(ThreadContext context, IRubyObject scheduler, IRubyObject io, IRubyObject buffer, RubyInteger length, RubyInteger offset) {
+        return Helpers.invokeChecked(context, scheduler, "io_write", io, buffer, length, offset);
+    }
+
+    // MRI: rb_fiber_scheduler_io_pwrite
+    public static IRubyObject ioPWrite(ThreadContext context, IRubyObject scheduler, IRubyObject io, IRubyObject buffer, int from, int length, int offset) {
+        return Helpers.invokeChecked(context, scheduler, "io_pwrite", io, buffer, context.runtime.newFixnum(from), context.runtime.newFixnum(length), context.runtime.newFixnum(offset));
+    }
+
+    public static IRubyObject ioPWrite(ThreadContext context, IRubyObject scheduler, IRubyObject io, IRubyObject buffer, RubyInteger from, RubyInteger length, RubyInteger offset) {
+        return Helpers.invokeChecked(context, scheduler, "io_pwrite", io, buffer, from, length, offset);
+    }
+
+    // MRI: rb_fiber_scheduler_io_read_memory
+    public static IRubyObject ioReadMemory(ThreadContext context, IRubyObject scheduler, IRubyObject io, ByteBuffer base, int size, int length) {
+        RubyIOBuffer buffer = RubyIOBuffer.newBuffer(context.runtime, base, size, RubyIOBuffer.LOCKED);
+
+        IRubyObject result = ioRead(context, scheduler, io, buffer, length, 0);
+
+        buffer.unlock(context);
+        buffer.free(context);
+
+        return result;
+    }
+
+    // MRI: rb_fiber_scheduler_io_pread_memory
+    public static IRubyObject ioPReadMemory(ThreadContext context, IRubyObject scheduler, IRubyObject io, ByteBuffer base, int from, int size, int length) {
+        RubyIOBuffer buffer = RubyIOBuffer.newBuffer(context.runtime, base, size, RubyIOBuffer.LOCKED);
+
+        IRubyObject result = ioPRead(context, scheduler, io, buffer, from, length, 0);
+
+        buffer.unlock(context);
+        buffer.free(context);
+
+        return result;
+    }
+
+    // MRI: rb_fiber_scheduler_io_write_memory
+    public static IRubyObject ioWriteMemory(ThreadContext context, IRubyObject scheduler, IRubyObject io, ByteBuffer base, int size, int length) {
+        RubyIOBuffer buffer = RubyIOBuffer.newBuffer(context.runtime, base, size, RubyIOBuffer.LOCKED | RubyIOBuffer.READONLY);
+
+        IRubyObject result = ioWrite(context, scheduler, io, buffer, length, 0);
+
+        buffer.unlock(context);
+        buffer.free(context);
+
+        return result;
+    }
+
+    // MRI: p
+    public static IRubyObject ioPWriteMemory(ThreadContext context, IRubyObject scheduler, IRubyObject io, ByteBuffer base, int from, int size, int length) {
+        RubyIOBuffer buffer = RubyIOBuffer.newBuffer(context.runtime, base, size, RubyIOBuffer.LOCKED | RubyIOBuffer.READONLY);
+
+        IRubyObject result = ioPWrite(context, scheduler, io, buffer, from, length, 0);
+
+        buffer.unlock(context);
+        buffer.free(context);
+
+        return result;
+    }
+
+    // MRI: rb_fiber_scheduler_io_close
+    public static IRubyObject ioClose(ThreadContext context, IRubyObject scheduler, IRubyObject io) {
+        return Helpers.invokeChecked(context, scheduler, "io_close", io);
+    }
+
+    // MRI: rb_fiber_scheduler_address_resolve
+    public static IRubyObject addressResolve(ThreadContext context, IRubyObject scheduler, IRubyObject hostname) {
+        return Helpers.invokeChecked(context, scheduler, "address_resolve", hostname);
+    }
+
+    // MRI: verify_scheduler
+    static void verifyInterface(IRubyObject scheduler) {
+        if (!scheduler.respondsTo("block")) {
+            throw scheduler.getRuntime().newArgumentError("Scheduler must implement #block");
+        }
+
+        if (!scheduler.respondsTo("unblock")) {
+            throw scheduler.getRuntime().newArgumentError("Scheduler must implement #unblock");
+        }
+
+        if (!scheduler.respondsTo("kernel_sleep")) {
+            throw scheduler.getRuntime().newArgumentError("Scheduler must implement #kernel_sleep");
+        }
+
+        if (!scheduler.respondsTo("io_wait")) {
+            throw scheduler.getRuntime().newArgumentError("Scheduler must implement #io_wait");
+        }
+    }
+
+    // MRI: rb_fiber_scheduler_close
+    public static IRubyObject close(ThreadContext context, IRubyObject scheduler) {
+//        VM_ASSERT(ruby_thread_has_gvl_p());
+
+        IRubyObject result;
+
+        result = Helpers.invokeChecked(context, scheduler, "scheduler_close");
+        if (result != null) return result;
+
+        result = Helpers.invokeChecked(context, scheduler, "close");
+        if (result != null) return result;
+
+        return context.nil;
+    }
+
+    // MRI: rb_fiber_scheduler_io_result_apply
+    public static int resultApply(ThreadContext context, IRubyObject result) {
+        int resultInt;
+        if (result instanceof RubyFixnum && (resultInt = RubyNumeric.num2int(result)) < 0) {
+            context.runtime.getPosix().errno(-resultInt);
+            return -1;
+        } else {
+            return RubyNumeric.num2int(result);
+        }
+    }
+
+    public static IRubyObject result(Ruby runtime, int result, Errno error) {
+        if (result == -1) {
+            return RubyFixnum.newFixnum(runtime, error.value());
+        } else {
+            return RubyFixnum.newFixnum(runtime, result);
+        }
+    }
+}
diff --git a/core/src/main/java/org/jruby/IncludedModule.java b/core/src/main/java/org/jruby/IncludedModule.java
index 0c1d075..f562b2d 100644
--- a/core/src/main/java/org/jruby/IncludedModule.java
+++ b/core/src/main/java/org/jruby/IncludedModule.java
@@ -4,7 +4,7 @@ import java.util.Map;
 
 import org.jruby.runtime.builtin.IRubyObject;
 
-public class IncludedModule extends RubyClass {
+public class IncludedModule extends RubyClass implements DelegatedModule {
     public IncludedModule(Ruby runtime, RubyClass superClass, RubyModule origin) {
         super(runtime, superClass, false);
         this.origin = origin;
diff --git a/core/src/main/java/org/jruby/Main.java b/core/src/main/java/org/jruby/Main.java
index 3cdabba..d502136 100644
--- a/core/src/main/java/org/jruby/Main.java
+++ b/core/src/main/java/org/jruby/Main.java
@@ -41,7 +41,6 @@ package org.jruby;
 import org.jruby.exceptions.MainExitException;
 import org.jruby.exceptions.JumpException;
 import org.jruby.exceptions.RaiseException;
-import org.jruby.exceptions.SignalException;
 import org.jruby.exceptions.ThreadKill;
 import org.jruby.main.DripMain;
 import org.jruby.platform.Platform;
@@ -53,25 +52,16 @@ import org.jruby.util.cli.OutputStrings;
 import org.jruby.util.log.Logger;
 import org.jruby.util.log.LoggerFactory;
 
-import java.io.File;
-import java.io.FileDescriptor;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.PrintStream;
+import java.io.*;
 import java.lang.management.ManagementFactory;
 import java.lang.management.RuntimeMXBean;
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.Method;
-import java.lang.reflect.Proxy;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.HashSet;
 import java.util.Properties;
-import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
  * Class used to launch the interpreter.
@@ -471,11 +461,47 @@ public class Main {
 
     private void doPrintUsage(boolean force) {
         if (config.getShouldPrintUsage() || force) {
-            config.getOutput().print(OutputStrings.getBasicUsageHelp());
-            config.getOutput().print(OutputStrings.getFeaturesHelp());
+            String rubyPager = getRubyPagerEnv();
+
+            // Do not want to boot native subsystem here, so we do best guess based on System.console. It will be
+            // non-null only if both STDIN and STDOUT are tty.
+            boolean tty = System.console() != null;
+
+            if (rubyPager == null) {
+                config.getOutput().print(OutputStrings.getBasicUsageHelp(tty));
+                config.getOutput().print(OutputStrings.getFeaturesHelp(tty));
+            } else {
+                try {
+                    ProcessBuilder builder = new ProcessBuilder(rubyPager);
+                    builder.environment().put("LESS", "-R");
+
+                    builder.redirectOutput(ProcessBuilder.Redirect.INHERIT);
+                    builder.redirectError(ProcessBuilder.Redirect.INHERIT);
+
+                    Process process = builder.start();
+                    OutputStream in = process.getOutputStream();
+
+                    String fullHelp = OutputStrings.getBasicUsageHelp(tty) + OutputStrings.getFeaturesHelp(tty);
+                    in.write(fullHelp.getBytes(StandardCharsets.UTF_8));
+
+                    in.flush();
+                    in.close();
+                    process.waitFor();
+                } catch (InterruptedException | IOException e) {
+                    e.printStackTrace();
+                }
+            }
         }
     }
 
+    private String getRubyPagerEnv() {
+        String rubyPager = System.getenv("RUBY_PAGER");
+        if (rubyPager == null)
+            rubyPager = System.getenv("PAGER");
+
+        return rubyPager;
+    }
+
     private void doShowCopyright() {
         if (config.isShowCopyright()) {
             config.getOutput().println(OutputStrings.getCopyrightString());
diff --git a/core/src/main/java/org/jruby/ObjectFlags.java b/core/src/main/java/org/jruby/ObjectFlags.java
index 3d1d727..e3cf10b 100644
--- a/core/src/main/java/org/jruby/ObjectFlags.java
+++ b/core/src/main/java/org/jruby/ObjectFlags.java
@@ -1,7 +1,5 @@
 package org.jruby;
 
-import org.jruby.ext.stringio.StringIO;
-
 /**
  * Flags used by RubyBasicObject descendants.
  */
@@ -13,6 +11,9 @@ public interface ObjectFlags {
     int FALSE_F = registry.newFlag(RubyBasicObject.class);
     int NIL_F = registry.newFlag(RubyBasicObject.class);
     int FROZEN_F = registry.newFlag(RubyBasicObject.class);
+
+    // Deprecated and unused but don't move due to checks elsewhere for the following flags
+    @Deprecated
     int TAINTED_F = registry.newFlag(RubyBasicObject.class);
 
     int CACHEPROXY_F = registry.newFlag(RubyModule.class);
@@ -25,12 +26,11 @@ public interface ObjectFlags {
     int CR_7BIT_F    = registry.newFlag(RubyString.class);
     int CR_VALID_F   = registry.newFlag(RubyString.class);
 
-    int STRIO_READABLE = registry.newFlag(StringIO.class);
-    int STRIO_WRITABLE = registry.newFlag(StringIO.class);
-
     int MATCH_BUSY = registry.newFlag(RubyMatchData.class);
 
     int COMPARE_BY_IDENTITY_F = registry.newFlag(RubyHash.class);
     int KEYWORD_REST_ARGUMENTS_F = registry.newFlag(RubyHash.class);
     int PROCDEFAULT_HASH_F = registry.newFlag(RubyHash.class);
+    int KEYWORD_ARGUMENTS_F = registry.newFlag(RubyHash.class);
+    int RUBY2_KEYWORD_F = registry.newFlag(RubyHash.class);
 }
diff --git a/core/src/main/java/org/jruby/PrependedModule.java b/core/src/main/java/org/jruby/PrependedModule.java
index aa69f6f..db1d388 100644
--- a/core/src/main/java/org/jruby/PrependedModule.java
+++ b/core/src/main/java/org/jruby/PrependedModule.java
@@ -48,7 +48,7 @@ import org.jruby.runtime.builtin.IRubyObject;
  * @see org.jruby.IncludedModuleWrapper
  * @see org.jruby.RubyModule
  */
-public class PrependedModule extends RubyClass {
+public class PrependedModule extends RubyClass implements DelegatedModule {
     private RubyModule origin;
 
     public PrependedModule(Ruby runtime, RubyClass superClass, RubyModule prependedClass) {
diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
index dcf2ac0..4736f50 100644
--- a/core/src/main/java/org/jruby/Ruby.java
+++ b/core/src/main/java/org/jruby/Ruby.java
@@ -49,7 +49,6 @@ import org.jruby.ast.CallNode;
 import org.jruby.ast.FCallNode;
 import org.jruby.ast.GlobalAsgnNode;
 import org.jruby.ast.GlobalVarNode;
-import org.jruby.ast.StrNode;
 import org.jruby.ast.VCallNode;
 import org.jruby.ast.WhileNode;
 import org.jruby.compiler.Constantizable;
@@ -64,8 +63,8 @@ import org.jruby.ext.thread.SizedQueue;
 import org.jruby.ir.IRScope;
 import org.jruby.ir.IRScriptBody;
 import org.jruby.ir.runtime.IRReturnJump;
+import org.jruby.java.util.ClassUtils;
 import org.jruby.javasupport.Java;
-import org.jruby.javasupport.JavaClass;
 import org.jruby.javasupport.JavaPackage;
 import org.jruby.javasupport.JavaSupport;
 import org.jruby.javasupport.JavaSupportImpl;
@@ -74,6 +73,7 @@ import org.jruby.management.InlineStats;
 import org.jruby.parser.StaticScope;
 import org.jruby.runtime.JavaSites;
 import org.jruby.runtime.MethodIndex;
+import org.jruby.runtime.TraceEventManager;
 import org.jruby.runtime.invokedynamic.InvokeDynamicSupport;
 import org.jruby.util.CommonByteLists;
 import org.jruby.util.JavaNameMangler;
@@ -187,9 +187,9 @@ import java.lang.invoke.MethodHandle;
 import java.lang.ref.WeakReference;
 import java.net.BindException;
 import java.nio.charset.Charset;
+import java.nio.charset.UnsupportedCharsetException;
 import java.security.SecureRandom;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.EnumMap;
 import java.util.EnumSet;
@@ -201,6 +201,7 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Random;
+import java.util.Set;
 import java.util.WeakHashMap;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentHashMap;
@@ -213,11 +214,12 @@ import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
 import java.util.function.ToIntFunction;
 import java.util.regex.Pattern;
-import java.util.stream.Collectors;
 
 import static java.lang.invoke.MethodHandles.explicitCastArguments;
 import static java.lang.invoke.MethodHandles.insertArguments;
 import static java.lang.invoke.MethodType.methodType;
+import static org.jruby.RubyBoolean.FALSE_BYTES;
+import static org.jruby.RubyBoolean.TRUE_BYTES;
 import static org.jruby.internal.runtime.GlobalVariable.Scope.GLOBAL;
 import static org.jruby.util.RubyStringBuilder.str;
 import static org.jruby.util.RubyStringBuilder.ids;
@@ -322,22 +324,26 @@ public final class Ruby implements Constantizable {
         objectClass = RubyClass.createBootstrapClass(this, "Object", basicObjectClass, RubyObject.OBJECT_ALLOCATOR);
         moduleClass = RubyClass.createBootstrapClass(this, "Module", objectClass, RubyModule.MODULE_ALLOCATOR);
         classClass = RubyClass.createBootstrapClass(this, "Class", moduleClass, RubyClass.CLASS_ALLOCATOR);
+        refinementClass = RubyClass.createBootstrapClass(this, "Refinement", moduleClass, RubyModule.MODULE_ALLOCATOR);
 
         basicObjectClass.setMetaClass(classClass);
         objectClass.setMetaClass(basicObjectClass);
         moduleClass.setMetaClass(classClass);
         classClass.setMetaClass(classClass);
+        refinementClass.setMetaClass(classClass);
 
         RubyClass metaClass;
         metaClass = basicObjectClass.makeMetaClass(classClass);
         metaClass = objectClass.makeMetaClass(metaClass);
         metaClass = moduleClass.makeMetaClass(metaClass);
         classClass.makeMetaClass(metaClass);
+        refinementClass.makeMetaClass(metaClass);
 
         RubyBasicObject.createBasicObjectClass(this, basicObjectClass);
         RubyObject.createObjectClass(this, objectClass);
         RubyModule.createModuleClass(this, moduleClass);
         RubyClass.createClassClass(this, classClass);
+        RubyModule.createRefinementClass(this, refinementClass);
 
         // set constants now that they're initialized
         basicObjectClass.setConstant("BasicObject", basicObjectClass);
@@ -345,6 +351,7 @@ public final class Ruby implements Constantizable {
         objectClass.setConstant("Object", objectClass);
         objectClass.setConstant("Class", classClass);
         objectClass.setConstant("Module", moduleClass);
+        objectClass.setConstant("Refinement", refinementClass);
 
         // Initialize Kernel and include into Object
         RubyModule kernel = kernelModule = RubyKernel.createKernelModule(this);
@@ -381,12 +388,17 @@ public final class Ruby implements Constantizable {
         context.prepareTopLevel(objectClass, topSelf);
 
         // Initialize all the core classes
-        dataClass = initDataClass();
-
         comparableModule = RubyComparable.createComparable(this);
         enumerableModule = RubyEnumerable.createEnumerableModule(this);
         stringClass = RubyString.createStringClass(this);
 
+        falseString = newString(FALSE_BYTES);
+        falseString.setFrozen(true);
+        nilString = RubyString.newEmptyString(this);
+        nilString.setFrozen(true);
+        trueString = newString(TRUE_BYTES);
+        trueString.setFrozen(true);
+
         encodingService = new EncodingService(this);
 
         symbolClass = RubySymbol.createSymbolClass(this);
@@ -429,9 +441,13 @@ public final class Ruby implements Constantizable {
         } else {
             bignumClass = null;
             randomClass = null;
-            defaultRand = null;
         }
         ioClass = RubyIO.createIOClass(this);
+        if (Options.FIBER_SCHEDULER.load()) {
+            ioBufferClass = RubyIOBuffer.createIOBufferClass(this);
+        } else {
+            ioBufferClass = null;
+        }
 
         structClass = profile.allowClass("Struct") ? RubyStruct.createStructClass(this) : null;
         bindingClass = profile.allowClass("Binding") ? RubyBinding.createBindingClass(this) : null;
@@ -462,18 +478,21 @@ public final class Ruby implements Constantizable {
             yielderClass = RubyYielder.createYielderClass(this);
             chainClass = RubyChain.createChainClass(this, enumeratorClass);
             aseqClass = RubyArithmeticSequence.createArithmeticSequenceClass(this, enumeratorClass);
+            producerClass = RubyProducer.createProducerClass(this, enumeratorClass);
         } else {
             enumeratorClass = null;
             generatorClass = null;
             yielderClass = null;
             chainClass = null;
             aseqClass = null;
+            producerClass = null;
         }
 
         continuationClass = initContinuation();
 
         TracePoint.createTracePointClass(this);
 
+        warningCategories = config.getWarningCategories();
         warningModule = RubyWarnings.createWarningModule(this);
 
         // Initialize exceptions
@@ -537,6 +556,13 @@ public final class Ruby implements Constantizable {
 
         // Done booting JRuby runtime
         runtimeIsBooted = true;
+        if ("true".equals(System.getenv("USE_SUBSPAWN"))) {
+            if (Platform.IS_WINDOWS) {
+                LOG.warn("env USE_SUBSPAWN=true is unsupported on Windows at this time");
+            } else {
+                getLoadService().require("subspawn/replace-builtin");
+            }
+        }
     }
 
     private void initProfiling() {
@@ -569,6 +595,8 @@ public final class Ruby implements Constantizable {
         loadService.provide("rational.rb");
         loadService.provide("complex.rb");
         loadService.provide("thread.rb");
+        loadService.provide("fiber.rb");
+        loadService.provide("ruby2_keywords.rb");
 
         // Load preludes
         initRubyPreludes();
@@ -649,15 +677,6 @@ public final class Ruby implements Constantizable {
         }
     }
 
-    private RubyClass initDataClass() {
-        RubyClass dataClass = null;
-        if (profile.allowClass("Data")) {
-            dataClass = defineClass("Data", objectClass, ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
-            getObject().deprecateConstant(this, "Data");
-        }
-        return dataClass;
-    }
-
     private Random initRandom() {
         Random myRandom;
         try {
@@ -791,7 +810,7 @@ public final class Ruby implements Constantizable {
 
     /**
      * Convenience method for java integrators who may need to switch the notion
-     * of "global" runtime. Use <tt>JRuby.runtime.use_as_global_runtime</tt>
+     * of "global" runtime. Use <code>JRuby.runtime.use_as_global_runtime</code>
      * from Ruby code to activate the current runtime as the global one.
      */
     public void useAsGlobalRuntime() {
@@ -836,7 +855,7 @@ public final class Ruby implements Constantizable {
      * and runtime preparation typical to normal script runs.
      *
      * @param script The scriptlet to run
-     * @returns The result of the eval
+     * @return The result of the eval
      */
     public IRubyObject evalScriptlet(String script) {
         ThreadContext context = getCurrentContext();
@@ -858,7 +877,7 @@ public final class Ruby implements Constantizable {
      * @param script The scriptlet to run
      * @param scope The scope to execute against (ManyVarsDynamicScope is
      * recommended, so it can grow as needed)
-     * @returns The result of the eval
+     * @return The result of the eval
      */
     public IRubyObject evalScriptlet(String script, DynamicScope scope) {
         ThreadContext context = getCurrentContext();
@@ -867,7 +886,7 @@ public final class Ruby implements Constantizable {
         context.preEvalScriptlet(scope);
 
         try {
-            return interpreter.execute(this, rootNode, context.getFrameSelf());
+            return interpreter.execute(this, rootNode, getTopSelf());
         } finally {
             context.postEvalScriptlet();
         }
@@ -923,6 +942,9 @@ public final class Ruby implements Constantizable {
         getGlobalVariables().define("$PROGRAM_NAME", d, GLOBAL);
         getGlobalVariables().define("$0", d, GLOBAL);
 
+        // set main script and canonical path for require_relative use
+        loadService.setMainScript(filename, getCurrentDirectory());
+
         for (Map.Entry<String, String> entry : config.getOptionGlobals().entrySet()) {
             final IRubyObject varvalue;
             if (entry.getValue() != null) {
@@ -1021,7 +1043,7 @@ public final class Ruby implements Constantizable {
      *
      * @param inputStream The input stream from which to read the script
      * @param filename The filename to use for parsing
-     * @returns The root node of the parsed script
+     * @return The root node of the parsed script
      */
     public Node parseFromMain(InputStream inputStream, String filename) {
         if (config.isInlineScript()) {
@@ -1085,6 +1107,8 @@ public final class Ruby implements Constantizable {
                 if (Options.JIT_LOGGING.load()) {
                     LOG.info("successfully compiled: {}", scriptNode.getFile());
                 }
+            } catch (RaiseException e) {
+                throw e;
             } catch (Throwable e) {
                 if (Options.JIT_LOGGING.load()) {
                     if (Options.JIT_LOGGING_VERBOSE.load()) {
@@ -1123,10 +1147,11 @@ public final class Ruby implements Constantizable {
     private RootNode addGetsLoop(RootNode oldRoot, boolean printing, boolean processLineEndings, boolean split) {
         int line = oldRoot.getLine();
         BlockNode newBody = new BlockNode(line);
-        RubySymbol dollarSlash = newSymbol(CommonByteLists.DOLLAR_SLASH);
-        newBody.add(new GlobalAsgnNode(line, dollarSlash, new StrNode(line, ((RubyString) globalVariables.get("$/")).getByteList())));
 
-        if (processLineEndings) newBody.add(new GlobalAsgnNode(line, newSymbol(CommonByteLists.DOLLAR_BACKSLASH), new GlobalVarNode(line, dollarSlash)));
+        if (processLineEndings) {
+            RubySymbol dollarSlash = newSymbol(CommonByteLists.DOLLAR_SLASH);
+            newBody.add(new GlobalAsgnNode(line, newSymbol(CommonByteLists.DOLLAR_BACKSLASH), new GlobalVarNode(line, dollarSlash)));
+        }
 
         GlobalVarNode dollarUnderscore = new GlobalVarNode(line, newSymbol("$_"));
 
@@ -1142,7 +1167,7 @@ public final class Ruby implements Constantizable {
             whileBody.add(oldRoot.getBodyNode());
         }
 
-        if (printing) whileBody.add(new FCallNode(line, newSymbol("puts"), new ArrayNode(line, dollarUnderscore), null));
+        if (printing) whileBody.add(new FCallNode(line, newSymbol("print"), new ArrayNode(line, dollarUnderscore), null));
 
         return new RootNode(line, oldRoot.getScope(), newBody, oldRoot.getFile());
     }
@@ -1206,6 +1231,8 @@ public final class Ruby implements Constantizable {
             if (scriptAndCode != null && Options.JIT_LOGGING.load()) {
                 LOG.info("done compiling target script: {}", scriptNode.getFile());
             }
+        } catch (RaiseException e) {
+            throw e;
         } catch (Exception e) {
             if (Options.JIT_LOGGING.load()) {
                 if (Options.JIT_LOGGING_VERBOSE.load()) {
@@ -1505,7 +1532,7 @@ public final class Ruby implements Constantizable {
      * rb_define_module in MRI.
      *
      * @param name The name of the new module
-     * @returns The new module
+     * @return The new module
      */
     @Extension
     public RubyModule defineModule(String name) {
@@ -1519,7 +1546,7 @@ public final class Ruby implements Constantizable {
      * @param name The name of the new module
      * @param parent The class or module namespace under which to define the
      * module
-     * @returns The new module
+     * @return The new module
      */
     @Extension
     public RubyModule defineModuleUnder(String name, RubyModule parent) {
@@ -1544,7 +1571,7 @@ public final class Ruby implements Constantizable {
      * new module is created.
      *
      * @param id The name of the module
-     * @returns The existing or new module
+     * @return The existing or new module
      */
     public RubyModule getOrCreateModule(String id) {
         IRubyObject module = objectClass.getConstantAt(id);
@@ -1599,6 +1626,7 @@ public final class Ruby implements Constantizable {
         loadService.loadFromClassLoader(getClassLoader(), "jruby/bundler/startup.rb", false);
     }
 
+    @SuppressWarnings("ReturnValueIgnored")
     private boolean doesReflectionWork() {
         try {
             ClassLoader.class.getDeclaredMethod("getResourceAsStream", String.class);
@@ -1661,6 +1689,7 @@ public final class Ruby implements Constantizable {
         ifAllowed("Fatal",                  (ruby) -> fatal = RubyFatal.define(ruby, exceptionClass));
         ifAllowed("Interrupt",              (ruby) -> interrupt = RubyInterrupt.define(ruby, signalException));
         ifAllowed("TypeError",              (ruby) -> typeError = RubyTypeError.define(ruby, standardError));
+        ifAllowed("NoMatchingPatternError", (ruby) -> noMatchingPatternError = RubyNoMatchingPatternError.define(ruby, standardError));
         ifAllowed("ArgumentError",          (ruby) -> argumentError = RubyArgumentError.define(ruby, standardError));
         ifAllowed("UncaughtThrowError",     (ruby) -> uncaughtThrowError = RubyUncaughtThrowError.define(ruby, argumentError));
         ifAllowed("IndexError",             (ruby) -> indexError = RubyIndexError.define(ruby, standardError));
@@ -1691,6 +1720,17 @@ public final class Ruby implements Constantizable {
         ifAllowed("KeyError",               (ruby) -> keyError = RubyKeyError.define(ruby, indexError));
         ifAllowed("DomainError",            (ruby) -> mathDomainError = RubyDomainError.define(ruby, argumentError, mathModule));
 
+        RubyClass runtimeError = this.runtimeError;
+        ObjectAllocator runtimeErrorAllocator = runtimeError.getAllocator();
+
+        if (Options.FIBER_SCHEDULER.load()) {
+            bufferLockedError = ioBufferClass.defineClassUnder("LockedError", runtimeError, runtimeErrorAllocator);
+            bufferAllocationError = ioBufferClass.defineClassUnder("AllocationError", runtimeError, runtimeErrorAllocator);
+            bufferAccessError = ioBufferClass.defineClassUnder("AccessError", runtimeError, runtimeErrorAllocator);
+            bufferInvalidatedError = ioBufferClass.defineClassUnder("InvalidatedError", runtimeError, runtimeErrorAllocator);
+            bufferMaskError = ioBufferClass.defineClassUnder("MaskError", runtimeError, runtimeErrorAllocator);
+        }
+
         initErrno();
 
         initNativeException();
@@ -1853,6 +1893,10 @@ public final class Ruby implements Constantizable {
         return moduleClass;
     }
 
+    public RubyClass getRefinement() {
+        return refinementClass;
+    }
+
     public RubyClass getClassClass() {
         return classClass;
     }
@@ -1992,6 +2036,10 @@ public final class Ruby implements Constantizable {
         return aseqClass;
     }
 
+    public RubyClass getProducer() {
+        return producerClass;
+    }
+
     public RubyClass getFiber() {
         return fiberClass;
     }
@@ -2031,6 +2079,15 @@ public final class Ruby implements Constantizable {
         return trueObject;
     }
 
+    public RubyString getTrueString() {
+        return trueString;
+    }
+
+    public RubyString getNilString() {
+        return nilString;
+    }
+
+
     /** Returns the "false" instance from the instance pool.
      * @return The "false" instance.
      */
@@ -2038,6 +2095,10 @@ public final class Ruby implements Constantizable {
         return falseObject;
     }
 
+    public RubyString getFalseString() {
+        return falseString;
+    }
+
     /** Returns the "nil" singleton instance.
      * @return "nil"
      */
@@ -2101,6 +2162,15 @@ public final class Ruby implements Constantizable {
         return bignumClass;
     }
 
+
+    public RubyClass getDateError() {
+        return this.dateErrorClass;
+    }
+
+    public void setDateError(RubyClass dateError) {
+        this.dateErrorClass = dateError;
+    }
+
     public RubyClass getDir() {
         return dirClass;
     }
@@ -2121,6 +2191,10 @@ public final class Ruby implements Constantizable {
         return ioClass;
     }
 
+    public RubyClass getIOBuffer() {
+        return ioBufferClass;
+    }
+
     public RubyClass getThread() {
         return threadClass;
     }
@@ -2316,6 +2390,10 @@ public final class Ruby implements Constantizable {
         return typeError;
     }
 
+    public RubyClass getNoMatchingPatternError() {
+        return noMatchingPatternError;
+    }
+
     public RubyClass getArgumentError() {
         return argumentError;
     }
@@ -2428,17 +2506,52 @@ public final class Ruby implements Constantizable {
         return invalidByteSequenceError;
     }
 
+    public RubyClass getBufferLockedError() {
+        return bufferLockedError;
+    }
+
+    public RubyClass getBufferAllocationError() {
+        return bufferAllocationError;
+    }
+
+    public RubyClass getBufferAccessError() {
+        return bufferAccessError;
+    }
+
+    public RubyClass getBufferInvalidatedError() {
+        return bufferInvalidatedError;
+    }
+
+    public RubyClass getBufferMaskError() {
+        return bufferMaskError;
+    }
+
+    @Deprecated
     RubyRandom.RandomType defaultRand;
 
+    /** The default Ruby Random object for this runtime */
+    private RubyRandom defaultRandom;
+
+    public RubyRandom getDefaultRandom() {
+        return defaultRandom;
+    }
+
+    public void setDefaultRandom(RubyRandom random) {
+        this.defaultRandom = random;
+        this.defaultRand = random.getRandomType();
+    }
+
     /**
      * @deprecated internal API, to be hidden
      */
     public RubyRandom.RandomType getDefaultRand() {
-        return defaultRand;
+        return getDefaultRandom().getRandomType();
     }
 
+    /**
+     * @deprecated the modified field is now unused and deprecated and the set is ignored
+     */
     public void setDefaultRand(RubyRandom.RandomType defaultRand) {
-        this.defaultRand = defaultRand;
     }
 
     private RubyHash charsetMap;
@@ -2448,46 +2561,97 @@ public final class Ruby implements Constantizable {
         return charsetMap;
     }
 
-    /** Getter for property isVerbose.
-     * @return Value of property isVerbose.
+    /**
+     * @return $VERBOSE value
      */
     public IRubyObject getVerbose() {
         return verboseValue;
     }
 
+    /**
+     * @return $VERBOSE value as a Java primitive
+     */
     public boolean isVerbose() {
         return verbose;
     }
 
+    /**
+     * If the user explicitly disabled warnings using: {@link #setWarningsEnabled(boolean)} return false.
+     *
+     * Otherwise fallback to a $VERBOSE value check (which is the default behavior).
+     *
+     * @return whether warnings are enabled
+     */
     public boolean warningsEnabled() {
-        return warningsEnabled;
+        return warningsEnabled && verboseWarnings;
     }
 
-    /** Setter for property isVerbose.
-     * @param verbose New value of property isVerbose.
+    /**
+     * Setter that enables/disabled warnings (without changing verbose mode).
+     * @param warningsEnabled
+     * @see #setVerbose(IRubyObject)
+     */
+    public void setWarningsEnabled(final boolean warningsEnabled) {
+        this.warningsEnabled = warningsEnabled;
+    }
+
+    /**
+     * Sets the runtime verbosity ($VERBOSE global which usually gets set to nil/false or true).
+     * <p>Note: warnings get enabled whenever the verbose level is set to a value that is not nil.</p>
+     * @param verbose the verbose ruby value
      */
-    public void setVerbose(IRubyObject verbose) {
+    public void setVerbose(final IRubyObject verbose) {
         this.verbose = verbose.isTrue();
         this.verboseValue = verbose;
-        warningsEnabled = !verbose.isNil();
+        verboseWarnings = !verbose.isNil();
     }
 
-    /** Getter for property isDebug.
-     * @return Value of property isDebug.
+    /**
+     * Sets the $VERBOSE level
+     * @param verbose null, true and false are all valid
+     * @see #setVerbose(IRubyObject)
+     */
+    public void setVerbose(final Boolean verbose) {
+        setVerbose(verbose == null ? nilObject : (verbose ? trueObject : falseObject));
+    }
+
+    /**
+     * @return $DEBUG value
      */
     public IRubyObject getDebug() {
         return debug ? trueObject : falseObject;
     }
 
+    /**
+     * @return $DEBUG value as a boolean
+     */
     public boolean isDebug() {
         return debug;
     }
 
-    /** Setter for property isDebug.
-     * @param debug New value of property isDebug.
+    /**
+     * Setter for property isDebug.
+     * @param debug the $DEBUG value
      */
     public void setDebug(IRubyObject debug) {
-        this.debug = debug.isTrue();
+        setDebug(debug.isTrue());
+    }
+
+    /**
+     * Sets the $DEBUG flag
+     * @param debug
+     */
+    public void setDebug(final boolean debug) {
+        this.debug = debug;
+    }
+
+    /**
+     * Get the current enabled warning categories.
+     *
+     * @return a set of the currently-enabled warning categories
+     */
+    public Set<RubyWarnings.Category> getWarningCategories() {
+        return warningCategories;
     }
 
     public JavaSupport getJavaSupport() {
@@ -2627,9 +2791,7 @@ public final class Ruby implements Constantizable {
     private byte[] encodeToBytes(String string) {
         Charset charset = getDefaultCharset();
 
-        byte[] bytes = charset == null ? string.getBytes() : string.getBytes(charset);
-
-        return bytes;
+        return charset == null ? string.getBytes() : string.getBytes(charset);
     }
 
     @Deprecated
@@ -2703,11 +2865,11 @@ public final class Ruby implements Constantizable {
      * Get the default java.nio.charset.Charset for the current default internal encoding.
      */
     public Charset getDefaultCharset() {
-        Encoding enc = getDefaultEncoding();
-
-        Charset charset = EncodingUtils.charsetForEncoding(enc);
-
-        return charset;
+        try {
+            return EncodingUtils.charsetForEncoding(getDefaultEncoding());
+        } catch (UnsupportedCharsetException e) {
+            return null;
+        }
     }
 
     /**
@@ -2771,7 +2933,6 @@ public final class Ruby implements Constantizable {
             throw newRaiseException(getTypeError(), str(this, "can't retrieve anonymous class ", ids(this, path)));
         }
 
-        ThreadContext context = getCurrentContext();
         RubyModule c = getObject();
         int pbeg = 0, p = 0;
         for (int l = path.length(); p < l; ) {
@@ -2787,8 +2948,7 @@ public final class Ruby implements Constantizable {
             }
 
             // FIXME: JI depends on const_missing getting called from Marshal.load (ruby objests do not).  We should marshal JI objects differently so we do not differentiate here.
-            boolean isJava = c instanceof JavaPackage || JavaClass.isProxyType(context, c);
-            IRubyObject cc = flexibleSearch || isJava ? c.getConstant(str) : c.getConstantAt(str);
+            IRubyObject cc = flexibleSearch || isJavaPackageOrJavaClassProxyType(c) ? c.getConstant(str) : c.getConstantAt(str);
 
             if (!flexibleSearch && cc == null) return null;
 
@@ -2801,6 +2961,10 @@ public final class Ruby implements Constantizable {
         return c;
     }
 
+    private static boolean isJavaPackageOrJavaClassProxyType(final RubyModule type) {
+        return type instanceof JavaPackage || ClassUtils.isJavaClassProxyType(type);
+    }
+
     /** Prints an error with backtrace to the error stream.
      *
      * MRI: eval.c - error_print()
@@ -2906,8 +3070,13 @@ public final class Ruby implements Constantizable {
     }
 
     public StaticScope setupWrappedToplevel(IRubyObject self, StaticScope top) {
+        RubyModule wrapper = loadService.getWrapperSelf();
+
+        if (wrapper == null || wrapper.isNil()) {
+            wrapper = RubyModule.newModule(this);
+        }
+
         // toss an anonymous module into the search path
-        RubyModule wrapper = RubyModule.newModule(this);
         ((RubyBasicObject) self).extend(new IRubyObject[] {wrapper});
         StaticScope newTop = staticScopeFactory.newLocalScope(null);
         top.setPreviousCRefScope(newTop);
@@ -2952,12 +3121,12 @@ public final class Ruby implements Constantizable {
     }
 
     public void addBoundMethod(String className, String methodName, String rubyName) {
-        Map<String, String> javaToRuby = boundMethods.computeIfAbsent(className, s -> new HashMap<>());
+        Map<String, String> javaToRuby = boundMethods.computeIfAbsent(className, s -> new ConcurrentHashMap<>(2, 0.9f, 2));
         javaToRuby.putIfAbsent(methodName, rubyName);
     }
 
     public void addBoundMethods(String className, String... tuples) {
-        Map<String, String> javaToRuby = boundMethods.computeIfAbsent(className, s -> new HashMap<>());
+        Map<String, String> javaToRuby = boundMethods.computeIfAbsent(className, s -> new ConcurrentHashMap<>(2, 0.9f, 2));
         for (int i = 0; i < tuples.length; i += 2) {
             javaToRuby.putIfAbsent(tuples[i], tuples[i+1]);
         }
@@ -2972,10 +3141,9 @@ public final class Ruby implements Constantizable {
 
         for (int i = 0; i < tuplesIndex; i++) {
             String className = classNamesAndTuples[i];
-            if (boundMethods.containsKey(className)) {
-                boundMethods.get(className).putAll(javaToRuby);
-            } else {
-                boundMethods.put(className, new HashMap<>(javaToRuby));
+            Map<String, String> javaToRubyForClass = boundMethods.computeIfAbsent(className, s -> new ConcurrentHashMap<>((int)(javaToRuby.size() / 0.9f) + 1, 0.9f, 2));
+            for (Map.Entry<String, String> entry : javaToRuby.entrySet()) {
+                javaToRubyForClass.putIfAbsent(entry.getKey(), entry.getValue());
             }
         }
     }
@@ -3000,180 +3168,10 @@ public final class Ruby implements Constantizable {
         return boundMethods;
     }
 
-    private static final EnumSet<RubyEvent> interest =
-            EnumSet.of(
-                    RubyEvent.C_CALL,
-                    RubyEvent.C_RETURN,
-                    RubyEvent.CALL,
-                    RubyEvent.CLASS,
-                    RubyEvent.END,
-                    RubyEvent.LINE,
-                    RubyEvent.RAISE,
-                    RubyEvent.RETURN
-            );
-
-    public static class CallTraceFuncHook extends EventHook {
-        private RubyProc traceFunc;
-        private final ThreadContext thread; // if non-null only call traceFunc if it is from this thread.
-
-        public CallTraceFuncHook(ThreadContext context) {
-            this.thread = context;
-        }
-
-        public void setTraceFunc(RubyProc traceFunc) {
-            this.traceFunc = traceFunc;
-        }
-
-        public void eventHandler(ThreadContext context, String eventName, String file, int line, String name, IRubyObject type) {
-            if (context.isWithinTrace()) return;
-            if (thread != null && thread != context) return;
-
-            if (file == null) file = "(ruby)";
-            if (type == null) type = context.nil;
-
-            Ruby runtime = context.runtime;
-            RubyBinding binding = RubyBinding.newBinding(runtime, context.currentBinding());
-
-            // FIXME: Ultimately we should be getting proper string for this event type
-            switch(eventName) {
-                case "c_return":
-                    eventName = "c-return";
-                    break;
-                case "c_call":
-                    eventName = "c-call";
-                    break;
-            };
-
-            context.preTrace();
-            try {
-                traceFunc.call(context, new IRubyObject[]{
-                        runtime.newString(eventName), // event name
-                        runtime.newString(file), // filename
-                        runtime.newFixnum(line), // line numbers should be 1-based
-                        name != null ? runtime.newSymbol(name) : runtime.getNil(),
-                        binding,
-                        type
-                });
-            } finally {
-                context.postTrace();
-            }
-        }
-
-        @Override
-        public boolean equals(Object other) {
-            if (!(other instanceof CallTraceFuncHook)) return false;
-
-            return super.equals(other) && thread == ((CallTraceFuncHook) other).thread;
-        }
-
-        @Override
-        public boolean isInterestedInEvent(RubyEvent event) {
-            return interest.contains(event);
-        }
-
-        public ThreadContext getThread() {
-            return thread;
-        }
-
-        @Override
-        public EnumSet<RubyEvent> eventSet() {
-            return interest;
-        }
-    };
-
-    private final CallTraceFuncHook callTraceFuncHook = new CallTraceFuncHook(null);
-
-    public synchronized void addEventHook(EventHook hook) {
-        if (!RubyInstanceConfig.FULL_TRACE_ENABLED && hook.needsDebug()) {
-            // without full tracing, many events will not fire
-            getWarnings().warn("tracing (e.g. set_trace_func) will not capture all events without --debug flag");
-        }
-
-        EventHook[] hooks = eventHooks;
-        EventHook[] newHooks = Arrays.copyOf(hooks, hooks.length + 1);
-        newHooks[hooks.length] = hook;
-        eventHooks = newHooks;
-        hasEventHooks = true;
-    }
-
-    public synchronized void removeEventHook(EventHook hook) {
-        EventHook[] hooks = eventHooks;
-
-        if (hooks.length == 0) return;
-
-        int pivot = -1;
-        for (int i = 0; i < hooks.length; i++) {
-            if (hooks[i].equals(hook)) {
-                pivot = i;
-                break;
-            }
-        }
-
-        if (pivot == -1) return; // No such hook found.
-
-        EventHook[] newHooks = new EventHook[hooks.length - 1];
-        // copy before and after pivot into the new array but don't bother
-        // to arraycopy if pivot is first/last element of the old list.
-        if (pivot != 0) System.arraycopy(hooks, 0, newHooks, 0, pivot);
-        if (pivot != hooks.length-1) System.arraycopy(hooks, pivot + 1, newHooks, pivot, hooks.length - (pivot + 1));
-
-        eventHooks = newHooks;
-        hasEventHooks = newHooks.length > 0;
-    }
-
-    public void setTraceFunction(RubyProc traceFunction) {
-        setTraceFunction(callTraceFuncHook, traceFunction);
-    }
-
-    public void setTraceFunction(CallTraceFuncHook hook, RubyProc traceFunction) {
-        removeEventHook(hook);
-
-        if (traceFunction == null) return;
-
-        hook.setTraceFunc(traceFunction);
-        addEventHook(hook);
-    }
-
-    /**
-     * Remove all event hooks which are associated with a particular thread.
-     * @param context the context of the ruby thread we are interested in.
-     */
-    public void removeAllCallEventHooksFor(ThreadContext context) {
-        if (eventHooks.length == 0) return;
-
-        List<EventHook> hooks = new ArrayList<>(Arrays.asList(eventHooks));
-
-        hooks = hooks.stream().filter(hook ->
-                !(hook instanceof CallTraceFuncHook) || !((CallTraceFuncHook) hook).getThread().equals(context)
-        ).collect(Collectors.toList());
-
-        EventHook[] newHooks = new EventHook[hooks.size()];
-        eventHooks = hooks.toArray(newHooks);
-        hasEventHooks = hooks.size() > 0;
-    }
-
-    public void callEventHooks(ThreadContext context, RubyEvent event, String file, int line, String name, IRubyObject type) {
-        if (context.isEventHooksEnabled()) {
-            EventHook hooks[] = eventHooks;
-
-            for (EventHook eventHook: hooks) {
-                if (eventHook.isInterestedInEvent(event)) {
-                    IRubyObject klass = context.nil;
-                    if (type instanceof RubyModule) {
-                        if (((RubyModule) type).isIncluded()) {
-                            klass = ((RubyModule) type).getOrigin();
-                        } else if (((RubyModule) type).isSingleton()) {
-                            klass = ((MetaClass) type).getAttached();
-                        }
-                    }
-                    eventHook.event(context, event, file, line, name, klass);
-                }
-            }
-        }
-    }
+    private final TraceEventManager traceEvents = new TraceEventManager(this);
 
-    public boolean hasEventHooks() {
-        return hasEventHooks;
+    public TraceEventManager getTraceEvents() {
+        return traceEvents;
     }
 
     public GlobalVariables getGlobalVariables() {
@@ -3313,11 +3311,12 @@ public final class Ruby implements Constantizable {
         }
     }
 
-    private void systemTeardown(ThreadContext context) {
+    @SuppressWarnings("ReturnValueIgnored")
+    private void systemTeardown(final ThreadContext context) {
         // Run post-user exit hooks, such as for shutting down internal JRuby services
         while (!postExitBlocks.isEmpty()) {
             ExitFunction fun = postExitBlocks.remove(0);
-            fun.applyAsInt(context);
+            fun.applyAsInt(context); // return value ignored
         }
 
         synchronized (internalFinalizersMutex) {
@@ -3644,11 +3643,11 @@ public final class Ruby implements Constantizable {
 
     public RaiseException newArgumentError(String name, int got, int min, int max) {
         if (min == max) {
-            return newRaiseException(getArgumentError(), str(this, "wrong number of arguments calling `", ids(this, name),  ("` (given " + got + ", expected " + min + ")")));
+            return newRaiseException(getArgumentError(), str(this, "`", ids(this, name), "': wrong number of arguments (given " + got + ", expected " + min + ")"));
         } else if (max == UNLIMITED_ARGUMENTS) {
-            return newRaiseException(getArgumentError(), str(this, "wrong number of arguments calling `", ids(this, name),  ("` (given " + got + ", expected " + min + "+)")));
+            return newRaiseException(getArgumentError(), str(this, "`", ids(this, name), "': wrong number of arguments (given " + got + ", expected " + min + "+)"));
         } else {
-            return newRaiseException(getArgumentError(), str(this, "wrong number of arguments calling `", ids(this, name),  ("` (given " + got + ", expected " + min + ".." + max + ")")));
+            return newRaiseException(getArgumentError(), str(this, "`", ids(this, name), "': wrong number of arguments (given " + got + ", expected " + min + ".." + max + ")"));
         }
     }
 
@@ -3817,6 +3816,10 @@ public final class Ruby implements Constantizable {
         return newRaiseException(getErrno().getClass("EDOM"), "Domain error - " + message);
     }
 
+    public RaiseException newErrnoEDOMError() {
+        return newRaiseException(getErrno().getClass("EDOM"), "Numerical argument out of domain");
+    }
+
     public RaiseException newErrnoECHILDError() {
         return newRaiseException(getErrno().getClass("ECHILD"), "No child processes");
     }
@@ -3873,6 +3876,10 @@ public final class Ruby implements Constantizable {
         return newRaiseException(getErrno().getClass("EAFNOSUPPORT"), message);
     }
 
+    public RaiseException newErrnoETIMEDOUTError() {
+        return newRaiseException(getErrno().getClass("ETIMEDOUT"), "Broken pipe");
+    }
+
     public RaiseException newErrnoFromLastPOSIXErrno() {
         RubyClass errnoClass = getErrno(getPosix().errno());
         if (errnoClass == null) errnoClass = systemCallError;
@@ -4175,16 +4182,14 @@ public final class Ruby implements Constantizable {
         return loadError;
     }
 
-    public RaiseException newFrozenError(String objectType) {
-        return newFrozenError(objectType, false);
+    public RaiseException newFrozenError(String objectType, IRubyObject receiver) {
+        return RubyFrozenError.newFrozenError(getCurrentContext(), newString("can't modify frozen " + objectType), receiver)
+                .toThrowable();
     }
 
-    public RaiseException newFrozenError(RubyModule type) {
-        return newRaiseException(getFrozenError(), str(this, "can't modify frozen ", types(this, type)));
-    }
-
-    public RaiseException newFrozenError(String objectType, boolean runtimeError) {
-        return newRaiseException(getFrozenError(), str(this, "can't modify frozen ", ids(this, objectType)));
+    public RaiseException newFrozenError(IRubyObject receiver) {
+        return RubyFrozenError.newFrozenError(getCurrentContext(), newString("can't modify frozen " + receiver.getType()), receiver)
+                .toThrowable();
     }
 
     public RaiseException newSystemStackError(String message) {
@@ -4282,6 +4287,26 @@ public final class Ruby implements Constantizable {
         return newRaiseException(getInvalidByteSequenceError(), message);
     }
 
+    public RaiseException newBufferLockedError(String message) {
+        return newRaiseException(getBufferLockedError(), message);
+    }
+
+    public RaiseException newBufferAllocationError(String message) {
+        return newRaiseException(getBufferAllocationError(), message);
+    }
+
+    public RaiseException newBufferAccessError(String message) {
+        return newRaiseException(getBufferAccessError(), message);
+    }
+
+    public RaiseException newBufferInvalidatedError(String message) {
+        return newRaiseException(getBufferInvalidatedError(), message);
+    }
+
+    public RaiseException newBufferMaskError(String message) {
+        return newRaiseException(getBufferMaskError(), message);
+    }
+
     /**
      * Construct a new RaiseException wrapping a new Ruby exception object appropriate to the given exception class.
      *
@@ -4976,6 +5001,17 @@ public final class Ruby implements Constantizable {
         return this.nullToNil = nullToNil;
     }
 
+    public MethodHandle getNullToUndefinedHandle() {
+        MethodHandle filter = this.nullToUndefined;
+
+        if (filter != null) return filter;
+
+        filter = InvokeDynamicSupport.findStatic(Helpers.class, "nullToUndefined", methodType(IRubyObject.class, IRubyObject.class));
+        filter = explicitCastArguments(filter, methodType(IRubyObject.class, Object.class));
+
+        return this.nullToUndefined = filter;
+    }
+
     // Parser stats methods
     private void addLoadParseToStats() {
         if (parserStats != null) parserStats.addLoadParse();
@@ -4989,13 +5025,9 @@ public final class Ruby implements Constantizable {
         return filenoUtil;
     }
 
-    public RubyClass getData() {
-        return dataClass;
-    }
-
     /**
-     * @return Class -> extension initializer map
-     * @note Internal API, subject to change!
+     * @return Class$ -&gt; extension initializer map
+     * <p>Note: Internal API, subject to change!</p>
      */
     public Map<Class, Consumer<RubyModule>> getJavaExtensionDefinitions() { return javaExtensionDefinitions; }
 
@@ -5288,6 +5320,11 @@ public final class Ruby implements Constantizable {
     void setException(RubyClass exceptionClass) {
     }
 
+    @Deprecated
+    public RubyClass getData() {
+        return null;
+    }
+
     private final ConcurrentHashMap<String, Invalidator> constantNameInvalidators =
         new ConcurrentHashMap<String, Invalidator>(
             16    /* default initial capacity */,
@@ -5304,10 +5341,6 @@ public final class Ruby implements Constantizable {
 
     private final RubySymbol.SymbolTable symbolTable = new RubySymbol.SymbolTable(this);
 
-    private static final EventHook[] EMPTY_HOOKS = new EventHook[0];
-    private volatile EventHook[] eventHooks = EMPTY_HOOKS;
-    private boolean hasEventHooks;
-
     private boolean abortOnException = false; // Thread.abort_on_exception
     private boolean reportOnException = true; // Thread.report_on_exception
     private boolean doNotReverseLookupEnabled = false;
@@ -5323,15 +5356,23 @@ public final class Ruby implements Constantizable {
     private final IRubyObject[] singleNilArray;
     private final RubyBoolean trueObject;
     private final RubyBoolean falseObject;
+    private final RubyString trueString;
+    private final RubyString falseString;
+    private final RubyString nilString;
     final RubyFixnum[] fixnumCache = new RubyFixnum[2 * RubyFixnum.CACHE_OFFSET];
     final Object[] fixnumConstants = new Object[fixnumCache.length];
 
     @Deprecated
     private IRubyObject rootFiber;
 
-    private boolean verbose, warningsEnabled, debug;
+    private boolean warningsEnabled = true; // global flag to be able to disable warnings regardless of $VERBOSE
+    private boolean verboseWarnings; // whether warnings are enabled based on $VERBOSE
+    private boolean verbose, debug;
     private IRubyObject verboseValue;
 
+    // Set of categories we care about (set defined when creating warnings).
+    private final Set<RubyWarnings.Category> warningCategories;
+
     private RubyThreadGroup defaultThreadGroup;
 
     /**
@@ -5343,6 +5384,7 @@ public final class Ruby implements Constantizable {
     private final RubyClass basicObjectClass;
     private final RubyClass objectClass;
     private final RubyClass moduleClass;
+    private final RubyClass refinementClass;
     private final RubyClass classClass;
     private final RubyClass nilClass;
     private final RubyClass trueClass;
@@ -5359,6 +5401,7 @@ public final class Ruby implements Constantizable {
     private final RubyClass generatorClass;
     private final RubyClass chainClass;
     private final RubyClass aseqClass;
+    private final RubyClass producerClass;
     private final RubyClass arrayClass;
     private final RubyClass hashClass;
     private final RubyClass rangeClass;
@@ -5375,9 +5418,11 @@ public final class Ruby implements Constantizable {
     private final RubyClass timeClass;
     private final RubyClass bignumClass;
     private final RubyClass dirClass;
+    private RubyClass dateErrorClass;
     private final RubyClass fileClass;
     private final RubyClass fileStatClass;
     private final RubyClass ioClass;
+    private final RubyClass ioBufferClass;
     private final RubyClass threadClass;
     private final RubyClass threadGroupClass;
     private final RubyClass continuationClass;
@@ -5385,7 +5430,6 @@ public final class Ruby implements Constantizable {
     private final RubyClass exceptionClass;
     private final RubyClass dummyClass;
     private final RubyClass randomClass;
-    private final RubyClass dataClass;
     private final RubyClass mutexClass;
     private final RubyClass conditionVariableClass;
     private final RubyClass queueClass;
@@ -5412,6 +5456,7 @@ public final class Ruby implements Constantizable {
     private RubyClass fatal;
     private RubyClass interrupt;
     private RubyClass typeError;
+    private RubyClass noMatchingPatternError;
     private RubyClass argumentError;
     private RubyClass uncaughtThrowError;
     private RubyClass indexError;
@@ -5439,6 +5484,11 @@ public final class Ruby implements Constantizable {
     private RubyClass keyError;
     private RubyClass locationClass;
     private RubyClass interruptedRegexpError;
+    private RubyClass bufferLockedError;
+    private RubyClass bufferAllocationError;
+    private RubyClass bufferAccessError;
+    private RubyClass bufferInvalidatedError;
+    private RubyClass bufferMaskError;
 
     /**
      * All the core modules we keep direct references to, for quick access and
@@ -5597,7 +5647,7 @@ public final class Ruby implements Constantizable {
     private final AtomicInteger moduleGeneration = new AtomicInteger(1);
 
     // A list of Java class+method names to include in backtraces
-    private final Map<String, Map<String, String>> boundMethods = new HashMap();
+    private final Map<String, Map<String, String>> boundMethods = new ConcurrentHashMap<>();
 
     // A soft pool of selectors for blocking IO operations
     private final SelectorPool selectorPool = new SelectorPool();
@@ -5695,7 +5745,7 @@ public final class Ruby implements Constantizable {
         }
 
         public boolean matches(Object o) {
-            return (o instanceof RubyProc) && ((RubyProc) o).getBlock() == proc.getBlock();
+            return (o instanceof RubyProc) && ((RubyProc) o).getBlock().getBody() == proc.getBlock().getBody();
         }
 
         @Override
@@ -5774,6 +5824,7 @@ public final class Ruby implements Constantizable {
      * The nullToNil filter for this runtime.
      */
     private MethodHandle nullToNil;
+    private MethodHandle nullToUndefined;
 
     public final ClassValue<TypePopulator> POPULATORS = new ClassValue<TypePopulator>() {
         @Override
@@ -5814,4 +5865,54 @@ public final class Ruby implements Constantizable {
         return newErrnoEADDRFromBindException(be, null);
     }
 
+    @Deprecated
+    public RaiseException newFrozenError(String objectType) {
+        return newFrozenError(objectType, null);
+    }
+
+    @Deprecated
+    public RaiseException newFrozenError(RubyModule type) {
+        return newRaiseException(getFrozenError(), str(this, "can't modify frozen ", types(this, type)));
+    }
+
+    @Deprecated
+    public RaiseException newFrozenError(String objectType, boolean runtimeError) {
+        return newRaiseException(getFrozenError(), str(this, "can't modify frozen ", ids(this, objectType)));
+    }
+
+    @Deprecated
+    public synchronized void addEventHook(EventHook hook) {
+        traceEvents.addEventHook(hook);
+    }
+
+    @Deprecated
+    public synchronized void removeEventHook(EventHook hook) {
+        traceEvents.removeEventHook(hook);
+    }
+
+    @Deprecated
+    public void setTraceFunction(RubyProc traceFunction) {
+        traceEvents.setTraceFunction(traceFunction);
+    }
+
+    @Deprecated
+    public void setTraceFunction(TraceEventManager.CallTraceFuncHook hook, RubyProc traceFunction) {
+        traceEvents.setTraceFunction(hook, traceFunction);
+    }
+
+    @Deprecated
+    public void removeAllCallEventHooksFor(ThreadContext context) {
+        traceEvents.removeAllCallEventHooksFor(context);
+    }
+
+    @Deprecated
+    public void callEventHooks(ThreadContext context, RubyEvent event, String file, int line, String name, IRubyObject type) {
+        traceEvents.callEventHooks(context, event, file, line, name, type);
+    }
+
+    @Deprecated
+    public boolean hasEventHooks() {
+        return traceEvents.hasEventHooks();
+    }
+
 }
diff --git a/core/src/main/java/org/jruby/RubyArgsFile.java b/core/src/main/java/org/jruby/RubyArgsFile.java
index 261089a..5d3d670 100644
--- a/core/src/main/java/org/jruby/RubyArgsFile.java
+++ b/core/src/main/java/org/jruby/RubyArgsFile.java
@@ -39,14 +39,16 @@ import java.io.IOException;
 import jnr.posix.FileStat;
 import jnr.posix.util.Platform;
 
+import static org.jruby.RubyArgsFile.Next.NextFile;
+import static org.jruby.RubyArgsFile.Next.Stream;
 import static org.jruby.RubyEnumerator.enumeratorize;
 import static org.jruby.anno.FrameField.LASTLINE;
 import static org.jruby.runtime.Visibility.PRIVATE;
 
-import org.jruby.anno.FrameField;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.internal.runtime.GlobalVariable;
+import org.jruby.runtime.Arity;
 import org.jruby.runtime.Block;
 import org.jruby.runtime.CallSite;
 import org.jruby.runtime.IAccessor;
@@ -54,7 +56,9 @@ import org.jruby.runtime.JavaSites;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ByteList;
+import org.jruby.util.StringSupport;
 import org.jruby.util.TypeConverter;
+import org.jruby.util.io.Getline;
 
 public class RubyArgsFile extends RubyObject {
 
@@ -115,18 +119,25 @@ public class RubyArgsFile extends RubyObject {
         return this;
     }
 
+    public enum Next {
+        Stream,   // We are only getting from $stdin
+        SameFile, // We are continuing to interact with the same file
+        NextFile  // Time to advance to the next file.
+    };
+
     public static final class ArgsFileData {
 
         private final Ruby runtime;
         private RubyArray argv;
         public IRubyObject currentFile;
         private boolean inited = false;
-        public int next_p = 0;
+        public Next next_p = NextFile;
         public boolean binmode = false;
+        private IRubyObject inPlace; // false, nil, String
 
         public ArgsFileData(Ruby runtime, RubyArray argv) {
             this.runtime = runtime;
-            this.argv = argv;
+            setArgs(argv);
             this.currentFile = runtime.getNil();
         }
 
@@ -135,29 +146,32 @@ public class RubyArgsFile extends RubyObject {
             runtime.setCurrentLine(linenumber);
         }
 
+        // ARGF.class.new
         void setArgs(RubyArray argv) {
             inited = false;
             this.argv = argv;
+            this.inPlace = runtime.getFalse();
         }
 
         public boolean next_argv(ThreadContext context) {
             if (!inited) {
-                next_p = argv.getLength() > 0 ? 1 : -1;
+                next_p = argv.getLength() > 0 ? NextFile : Stream;
                 inited = true;
                 runtime.setCurrentLine(0);
             } else {
                 if (argv.isNil()) {
-                    next_p = -1;
-                } else if (next_p == -1 && argv.getLength() > 0) {
-                    next_p = 1;
+                    next_p = Stream;
+                } else if (next_p == Stream && argv.getLength() > 0) {
+                    next_p = NextFile;
                 }
             }
 
             IRubyObject $FILENAME = runtime.getGlobalVariables().get("$FILENAME");
 
-            if (next_p == 1) {
+            if (next_p == NextFile) {
                 if (argv.getLength() > 0) {
-                    final RubyString filename = argv.shift(context).convertToString();
+                    RubyString filename = TypeConverter.convertToType(argv.shift(context), context.runtime.getString(), "to_path").convertToString();
+                    StringSupport.checkStringSafety(runtime, filename);
                     if ( ! filename.op_equal(context, $FILENAME).isTrue() ) {
                         runtime.defineReadonlyVariable("$FILENAME", filename, GlobalVariable.Scope.GLOBAL);
                     }
@@ -166,7 +180,9 @@ public class RubyArgsFile extends RubyObject {
                         currentFile = runtime.getGlobalVariables().get("$stdin");
                     } else {
                         currentFile = RubyFile.open(context, runtime.getFile(), new IRubyObject[]{ filename }, Block.NULL_BLOCK);
-                        String extension = runtime.getInstanceConfig().getInPlaceBackupExtension();
+                        String extension = null;
+                        if (inPlace.isTrue()) extension = inPlace.asJavaString();
+                        if (extension == null) extension = runtime.getInstanceConfig().getInPlaceBackupExtension();
                         if (extension != null) {
                             if (Platform.IS_WINDOWS) {
                                 inplaceEditWindows(context, filename.asJavaString(), extension);
@@ -176,17 +192,18 @@ public class RubyArgsFile extends RubyObject {
                         }
                         if (binmode) ((RubyIO) currentFile).binmode();
                     }
-                    next_p = 0;
+                    next_p = Next.SameFile;
                 } else {
-                    next_p = 1;
+                    next_p = NextFile;
                     return false;
                 }
-            } else if (next_p == -1) {
+            } else if (next_p == Stream) {
                 currentFile = runtime.getGlobalVariables().get("$stdin");
                 if (!filenameEqlDash((RubyString) $FILENAME)) {
                     runtime.defineReadonlyVariable("$FILENAME", runtime.newString("-"), GlobalVariable.Scope.GLOBAL);
                 }
             }
+
             return true;
         }
 
@@ -262,6 +279,47 @@ public class RubyArgsFile extends RubyObject {
         recv.getRuntime().setCurrentLine(newLineNumber);
     }
 
+    @JRubyMethod
+    public static IRubyObject inplace_mode(ThreadContext context, IRubyObject recv) {
+        ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);
+
+        if (data.inPlace == null) return context.nil;
+        if (data.inPlace.isNil()) return context.nil;
+
+        return data.inPlace.dup();
+    }
+
+    @JRubyMethod(name = "inplace_mode=")
+    public static IRubyObject inplace_mode_set(ThreadContext context, IRubyObject recv, IRubyObject test) {
+        return setInplaceMode(context, recv, test);
+    }
+
+    private static IRubyObject setInplaceMode(ThreadContext context, IRubyObject recv, IRubyObject test) {
+        ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);
+
+        if (test.isNil()) {
+            data.inPlace = context.nil;
+        } else if (!test.isTrue()) {
+            data.inPlace = context.fals;
+        } else {
+            test = TypeConverter.convertToType(test, context.runtime.getString(), "to_str", false);
+            if (test.isNil() || ((RubyString) test).length() == 0) {
+                data.inPlace = context.nil;
+            } else {
+                StringSupport.checkStringSafety(context.runtime, test);
+                test.setFrozen(true);
+                data.inPlace = test;
+            }
+        }
+
+        return recv;
+    }
+
+    @JRubyMethod(name = "inplace_mode=")
+    public IRubyObject inplace_mode_set(ThreadContext context, IRubyObject test) {
+        return setInplaceMode(context, this, test);
+    }
+
     @JRubyMethod(name = "argv")
     public static IRubyObject argv(ThreadContext context, IRubyObject recv) {
         return ArgsFileData.getArgsFileData(context.runtime).argv;
@@ -304,37 +362,60 @@ public class RubyArgsFile extends RubyObject {
 
     // MRI: argf_getline
     private static IRubyObject argf_getline(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
-        ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);
+        Ruby runtime = context.runtime;
+
+        IRubyObject line;
+
+        ArgsFileData data = ArgsFileData.getArgsFileData(runtime);
 
         while (true) {
             if (!data.next_argv(context)) return context.nil;
 
-            IRubyObject line = data.currentFile.callMethod(context, "gets", args);
+            RubyIO currentFile = (RubyIO) data.currentFile;
+
+            if (isGenericInput(runtime, data)) {
+                line = data.currentFile.callMethod(context, "gets", args);
+            } else {
+                if (args.length == 0 && runtime.getRecordSeparatorVar().get() == runtime.getGlobalVariables().getDefaultSeparator()) {
+                    line = (currentFile).gets(context);
+                } else {
+                    line = Getline.getlineCall(context, GETLINE, currentFile, currentFile.getReadEncoding(), args);
+                }
 
-            if (line.isNil() && data.next_p != -1) {
-                argf_close(context, data.currentFile);
-                data.next_p = 1;
-                continue;
+                if (line.isNil() && data.next_p != Stream) {
+                    argf_close(context, data.currentFile);
+                    data.next_p = NextFile;
+                    continue;
+                }
             }
 
             return line;
         }
     }
 
+    private static boolean isGenericInput(Ruby runtime, ArgsFileData data) {
+        return data.currentFile == runtime.getGlobalVariables().get("$stdin") && !(data.currentFile instanceof RubyFile);
+    }
+
+    private static final Getline.Callback<RubyIO, IRubyObject> GETLINE =
+            (context, self, rs, limit, chomp, block) -> self.getlineImpl(context, rs, limit, chomp);
+
     // ARGF methods
 
     /** Read a line.
      *
      */
-    @JRubyMethod(name = "gets", optional = 1, writes = LASTLINE)
+    @JRubyMethod(name = "gets", optional = 1, checkArity = false, writes = LASTLINE)
     public static IRubyObject gets(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+        Arity.checkArgumentCount(context, args, 0, 1);
+
         return context.setLastLine(argf_getline(context, recv, args));
     }
 
     /** Read a line.
      *
      */
-    @JRubyMethod(name = "readline", optional = 1, writes = LASTLINE)
+    @JRubyMethod(name = "readline", optional = 1, checkArity = false, writes = LASTLINE)
     public static IRubyObject readline(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
         IRubyObject line = gets(context, recv, args);
 
@@ -343,8 +424,10 @@ public class RubyArgsFile extends RubyObject {
         return line;
     }
 
-    @JRubyMethod(optional = 1)
+    @JRubyMethod(optional = 1, checkArity = false)
     public static IRubyObject readlines(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+        Arity.checkArgumentCount(context, args, 0, 1);
+
         Ruby runtime = context.runtime;
         ArgsFileData data = ArgsFileData.getArgsFileData(runtime);
 
@@ -360,8 +443,10 @@ public class RubyArgsFile extends RubyObject {
         return ary;
     }
 
-    @JRubyMethod(optional = 1)
+    @JRubyMethod(optional = 1, checkArity = false)
     public static IRubyObject to_a(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+        Arity.checkArgumentCount(context, args, 0, 1);
+
         Ruby runtime = context.runtime;
         ArgsFileData data = ArgsFileData.getArgsFileData(runtime);
 
@@ -393,8 +478,9 @@ public class RubyArgsFile extends RubyObject {
         return block.isGiven() ? each_byte(context, recv, block) : enumeratorize(context.runtime, recv, "each_byte");
     }
 
-    @JRubyMethod(optional = 1)
+    @JRubyMethod(optional = 1, checkArity = false)
     public static IRubyObject bytes(final ThreadContext context, IRubyObject recv, IRubyObject[] args, final Block block) {
+        Arity.checkArgumentCount(context, args, 0, 1);
         return block.isGiven() ? each_byte(context, recv, block) : enumeratorize(context.runtime, recv, "bytes");
     }
 
@@ -422,7 +508,6 @@ public class RubyArgsFile extends RubyObject {
                 int n = runtime.getKCode().getEncoding().length(c);
                 IRubyObject file = data.currentFile;
                 RubyString str = runtime.newString();
-                str.setTaint(true);
                 str.cat(c);
 
                 while(--n > 0) {
@@ -446,12 +531,13 @@ public class RubyArgsFile extends RubyObject {
 
     @JRubyMethod
     public static IRubyObject each_codepoint(ThreadContext context, IRubyObject recv, Block block) {
-        if (!block.isGiven()) return RubyEnumerator.enumeratorize(context.runtime, recv, "each_line");
+        if (!block.isGiven()) return RubyEnumerator.enumeratorize(context.runtime, recv, "each_codepoint");
         ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);
 
         CallSite each_codepoint = sites(context).each_codepoint;
         while (data.next_argv(context)) {
             each_codepoint.call(context, recv, data.currentFile, block);
+            data.next_p = NextFile;
         }
 
         return context.nil;
@@ -469,10 +555,12 @@ public class RubyArgsFile extends RubyObject {
     /** Invoke a block for each line.
      *
      */
-    @JRubyMethod(name = "each_line", optional = 1)
+    @JRubyMethod(name = "each_line", optional = 1, checkArity = false)
     public static IRubyObject each_line(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {
         if (!block.isGiven()) return enumeratorize(context.runtime, recv, "each_line", args);
 
+        Arity.checkArgumentCount(context, args, 0, 1);
+
         ArgsFileData data = ArgsFileData.getArgsFileData(context.runtime);
 
         if (!data.next_argv(context)) return context.nil;
@@ -481,7 +569,7 @@ public class RubyArgsFile extends RubyObject {
             if (!data.next_argv(context)) return recv;
 
             data.currentFile.callMethod(context, "each", NULL_ARRAY, block);
-            data.next_p = 1;
+            data.next_p = NextFile;
         }
 
         IRubyObject str;
@@ -493,7 +581,7 @@ public class RubyArgsFile extends RubyObject {
     }
 
     @Deprecated // TODO "warning: ARGF#lines is deprecated; use #each_line instead"
-    @JRubyMethod(optional = 1)
+    @JRubyMethod(optional = 1, checkArity = false)
     public static IRubyObject lines(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {
         if (!block.isGiven()) return RubyEnumerator.enumeratorize(context.runtime, recv, "each_line");
         return each_line(context, recv, args, block);
@@ -504,7 +592,7 @@ public class RubyArgsFile extends RubyObject {
         return each_line(context, recv, args, block);
     }
 
-    @JRubyMethod(name = "each", optional = 1)
+    @JRubyMethod(name = "each", optional = 1, checkArity = false)
     public static IRubyObject each(final ThreadContext context, IRubyObject recv, IRubyObject[] args, final Block block) {
         return block.isGiven() ? each_line(context, recv, args, block) : enumeratorize(context.runtime, recv, "each", args);
     }
@@ -528,9 +616,9 @@ public class RubyArgsFile extends RubyObject {
         Ruby runtime = recv.getRuntime();
         ArgsFileData data = ArgsFileData.getArgsFileData(runtime);
 
-        if (data.inited && data.next_p == 0) {
+        if (data.inited && data.next_p == Next.SameFile) {
             argf_close(runtime.getCurrentContext(), data.currentFile);
-            data.next_p = 1;
+            data.next_p = NextFile;
         }
 
         return recv;
@@ -554,7 +642,7 @@ public class RubyArgsFile extends RubyObject {
 
         argf_close(context, data.currentFile);
 
-        if (data.next_p != -1) data.next_p = 1;
+        if (data.next_p != Stream) data.next_p = NextFile;
 
         context.runtime.setCurrentLine(0);
 
@@ -649,8 +737,10 @@ public class RubyArgsFile extends RubyObject {
         return getCurrentDataFile(context, "no stream to set position").pos_set(context, offset);
     }
 
-    @JRubyMethod(name = "seek", required = 1, optional = 1)
+    @JRubyMethod(name = "seek", required = 1, optional = 1, checkArity = false)
     public static IRubyObject seek(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+        Arity.checkArgumentCount(context, args, 1, 2);
+
         return getCurrentDataFile(context, "no stream to seek").seek(context, args);
     }
 
@@ -680,17 +770,21 @@ public class RubyArgsFile extends RubyObject {
             if (bt != context.nil) return bt;
 
             argf_close(context, data.currentFile);
-            data.next_p = 1;
+            data.next_p = NextFile;
         }
     }
 
-    @JRubyMethod(required = 1, optional = 2)
+    @JRubyMethod(required = 1, optional = 2, checkArity = false)
     public static IRubyObject read_nonblock(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+        Arity.checkArgumentCount(context, args, 1, 3);
+
         return getPartial(context, recv, args, true);
     }
 
-    @JRubyMethod(required = 1, optional = 1)
+    @JRubyMethod(required = 1, optional = 1, checkArity = false)
     public static IRubyObject readpartial(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+        Arity.checkArgumentCount(context, args, 1, 2);
+
         return getPartial(context, recv, args, false);
     }
 
@@ -722,10 +816,10 @@ public class RubyArgsFile extends RubyObject {
 
         IRubyObject res = ((RubyIO) data.currentFile).getPartial(context, args, nonBlocking, noException);
         if (res == context.nil) {
-            if (data.next_p == -1) return RubyIO.nonblockEOF(runtime, noException);
+            if (data.next_p == Stream) return RubyIO.nonblockEOF(runtime, noException);
 
             argf_close(context, data.currentFile);
-            data.next_p = 1;
+            data.next_p = NextFile;
 
             if (data.argv.isEmpty()) return RubyIO.nonblockEOF(runtime, noException);
 
@@ -762,20 +856,22 @@ public class RubyArgsFile extends RubyObject {
             if (bt != context.nil) return bt;