Flatbuffers Version 2.0.7 (#7462)

* reworked keep prefix

* checking in missing schema

* fix flatc path for build scripts

.bazelci/presubmit.yml

@@ -2,11 +2,29 @@
 buildifier: latest
 platforms:
   ubuntu1804:
+    environment:
+      CC: clang
+      SWIFT_VERSION: "5.5.3"
+      SWIFT_HOME: "$HOME/swift-$SWIFT_VERSION"
+      PATH: "$PATH:$SWIFT_HOME/usr/bin"
+    shell_commands:
+      - "echo --- Downloading and extracting Swift $SWIFT_VERSION to $SWIFT_HOME"
+      - "mkdir $SWIFT_HOME"
+      - "curl https://download.swift.org/swift-${SWIFT_VERSION}-release/ubuntu1804/swift-${SWIFT_VERSION}-RELEASE/swift-${SWIFT_VERSION}-RELEASE-ubuntu18.04.tar.gz | tar xvz --strip-components=1 -C $SWIFT_HOME"
     build_targets:
     - "//..."
     test_targets:
     - "//..."
   ubuntu2004:
+    environment:
+      CC: clang
+      SWIFT_VERSION: "5.5.3"
+      SWIFT_HOME: "$HOME/swift-$SWIFT_VERSION"
+      PATH: "$PATH:$SWIFT_HOME/usr/bin"
+    shell_commands:
+      - "echo --- Downloading and extracting Swift $SWIFT_VERSION to $SWIFT_HOME"
+      - "mkdir $SWIFT_HOME"
+      - "curl https://download.swift.org/swift-${SWIFT_VERSION}-release/ubuntu2004/swift-${SWIFT_VERSION}-RELEASE/swift-${SWIFT_VERSION}-RELEASE-ubuntu20.04.tar.gz | tar xvz --strip-components=1 -C $SWIFT_HOME"
     build_targets:
     - "//..."
     test_targets:

.github/workflows/build.yml

@@ -1,7 +1,12 @@
 name: CI
+permissions: read-all
 
 on:
+  # For manual tests.
+  workflow_dispatch:
   push:
+    tags:
+      - "*" # new tag version, like `0.8.4` or else
     branches:
       - master
   pull_request:
@@ -10,57 +15,102 @@ on:
 
 jobs:
   build-linux:
+    permissions:
+      contents: write
+    outputs:
+      digests-gcc: ${{ steps.hash-gcc.outputs.hashes }}
+      digests-clang: ${{ steps.hash-clang.outputs.hashes }}
     name: Build Linux
     runs-on: ubuntu-latest
     strategy:
       matrix:
         cxx: [g++-10, clang++-12]
+      fail-fast: false
     steps:
     - uses: actions/checkout@v2
     - name: cmake
-      run: CXX=${{ matrix.cxx }} cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release .
+      run: CXX=${{ matrix.cxx }} cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON .
     - name: build
-      run: make -j4
+      run: make -j
     - name: test
       run: ./flattests
     - name: make flatc executable
       run: |
         chmod +x flatc
         ./flatc --version
+    - name: flatc tests
+      run: python3 tests/flatc/main.py
     - name: upload build artifacts
       uses: actions/upload-artifact@v1
       with:
         name: Linux flatc binary ${{ matrix.cxx }}
         path: flatc
+    # Below if only for release.
+    - name: Zip file
+      if: startsWith(github.ref, 'refs/tags/')
+      run: zip Linux.flatc.binary.${{ matrix.cxx }}.zip flatc
+    - name: Release zip file
+      uses: softprops/action-gh-release@v1
+      if: startsWith(github.ref, 'refs/tags/')
+      with:
+        files: Linux.flatc.binary.${{ matrix.cxx }}.zip
+    - name: Generate SLSA subjects - clang
+      if: matrix.cxx == 'clang++-12' && startsWith(github.ref, 'refs/tags/')
+      id: hash-clang
+      run: echo "::set-output name=hashes::$(sha256sum Linux.flatc.binary.${{ matrix.cxx }}.zip | base64 -w0)"
+    - name: Generate SLSA subjects - gcc
+      if: matrix.cxx == 'g++-10' && startsWith(github.ref, 'refs/tags/')
+      id: hash-gcc
+      run: echo "::set-output name=hashes::$(sha256sum Linux.flatc.binary.${{ matrix.cxx }}.zip | base64 -w0)"
 
   build-windows:
+    permissions:
+      contents: write
+    outputs:
+      digests: ${{ steps.hash.outputs.hashes }}
     name: Build Windows 2019 
-    runs-on: windows-latest
+    runs-on: windows-2019
     steps:
     - uses: actions/checkout@v2
     - name: Add msbuild to PATH
       uses: microsoft/setup-msbuild@v1.1
     - name: cmake
-      run: cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_CPP17=ON .
+      run: cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_CPP17=ON -DFLATBUFFERS_STRICT_MODE=ON .
     - name: build
       run: msbuild.exe FlatBuffers.sln /p:Configuration=Release /p:Platform=x64
     - name: test
       run: Release\flattests.exe
+    - name: flatc tests
+      run: python3 tests/flatc/main.py --flatc Release\flatc.exe
     - name: upload build artifacts
       uses: actions/upload-artifact@v1
       with:
         name: Windows flatc binary
         path: Release\flatc.exe
+    # Below if only for release.
+    - name: Zip file
+      if: startsWith(github.ref, 'refs/tags/')
+      run: move Release/flatc.exe . && Compress-Archive flatc.exe Windows.flatc.binary.zip
+    - name: Release binary
+      uses: softprops/action-gh-release@v1
+      if: startsWith(github.ref, 'refs/tags/')
+      with:
+        files: Windows.flatc.binary.zip
+    - name: Generate SLSA subjects
+      if: startsWith(github.ref, 'refs/tags/')
+      id: hash
+      shell: bash
+      run: echo "::set-output name=hashes::$(sha256sum Windows.flatc.binary.zip | base64 -w0)"
 
   build-windows-2017:
     name: Build Windows 2017
-    runs-on: windows-latest
+    runs-on: windows-2019
     steps:
     - uses: actions/checkout@v2
     - name: Add msbuild to PATH
       uses: microsoft/setup-msbuild@v1.1
     - name: cmake
-      run: cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_BUILD_TYPE=Release .
+      run: cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON .
     - name: build tool version 15 (VS 2017)
       run: msbuild.exe FlatBuffers.sln /p:Configuration=Release /p:Platform=x64 /p:VisualStudioVersion=15.0
     - name: test
@@ -68,13 +118,13 @@ jobs:
 
   build-windows-2015:
     name: Build Windows 2015
-    runs-on: windows-latest
+    runs-on: windows-2019
     steps:
     - uses: actions/checkout@v2
     - name: Add msbuild to PATH
       uses: microsoft/setup-msbuild@v1.1
     - name: cmake
-      run: cmake -G "Visual Studio 14 2015" -A x64 -DCMAKE_BUILD_TYPE=Release .
+      run: cmake -G "Visual Studio 14 2015" -A x64 -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON .
     - name: build tool version 14 (VS 2015)
       run: msbuild.exe FlatBuffers.sln /p:Configuration=Release /p:Platform=x64 /p:VisualStudioVersion=14.0
     - name: test
@@ -82,7 +132,7 @@ jobs:
 
   build-dotnet-windows:
     name: Build .NET Windows
-    runs-on: windows-latest
+    runs-on: windows-2019
     strategy:
       matrix:
         configuration: [
@@ -108,13 +158,63 @@ jobs:
         cd tests\FlatBuffers.Test
         out\FlatBuffers.Core.Test.exe
 
-  build-mac:
+  build-mac-intel:
-    name: Build Mac
+    permissions:
+      contents: write
+    outputs:
+      digests: ${{ steps.hash.outputs.hashes }}
+    name: Build Mac (for Intel)
     runs-on: macos-latest
     steps:
     - uses: actions/checkout@v2
     - name: cmake
-      run: cmake -G "Xcode" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_FLATC_EXECUTABLE=_build/Release/flatc .
+      run: cmake -G "Xcode" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_FLATC_EXECUTABLE=_build/Release/flatc -DFLATBUFFERS_STRICT_MODE=ON .
+    - name: build
+      # NOTE: we need this _build dir to not have xcodebuild's default ./build dir clash with the BUILD file.
+      run: xcodebuild -toolchain clang -configuration Release -target flattests SYMROOT=$(PWD)/_build
+    - name: check that the binary is x86_64
+      run: |
+        info=$(file _build/Release/flatc)
+        echo $info
+        echo $info | grep "Mach-O 64-bit executable x86_64"
+    - name: test
+      run: _build/Release/flattests
+    - name: make flatc executable
+      run: |
+        chmod +x _build/Release/flatc
+        ./_build/Release/flatc --version
+    - name: flatc tests
+      run: python3 tests/flatc/main.py --flatc ./_build/Release/flatc
+    - name: upload build artifacts
+      uses: actions/upload-artifact@v1
+      with:
+        name: Mac flatc binary
+        path: _build/Release/flatc
+    # Below if only for release.
+    - name: Zip file
+      if: startsWith(github.ref, 'refs/tags/')
+      run: mv _build/Release/flatc . && zip MacIntel.flatc.binary.zip flatc
+    - name: Release binary
+      uses: softprops/action-gh-release@v1
+      if: startsWith(github.ref, 'refs/tags/')
+      with:
+        files: MacIntel.flatc.binary.zip
+    - name: Generate SLSA subjects
+      if: startsWith(github.ref, 'refs/tags/')
+      id: hash
+      run: echo "::set-output name=hashes::$(shasum -a 256 MacIntel.flatc.binary.zip | base64)"
+
+  build-mac-universal:
+    permissions:
+      contents: write
+    outputs:
+      digests: ${{ steps.hash.outputs.hashes }}
+    name: Build Mac (universal build)
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: cmake
+      run: cmake -G "Xcode" -DCMAKE_OSX_ARCHITECTURES="arm64;x86_64" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_FLATC_EXECUTABLE=_build/Release/flatc -DFLATBUFFERS_STRICT_MODE=ON .
     - name: build
       # NOTE: we need this _build dir to not have xcodebuild's default ./build dir clash with the BUILD file.
       run: xcodebuild -toolchain clang -configuration Release -target flattests SYMROOT=$(PWD)/_build
@@ -122,7 +222,7 @@ jobs:
       run: |
         info=$(file _build/Release/flatc)
         echo $info
-        echo $info | grep "universal binary with 2 architectures"
+        echo $info | grep "Mach-O universal binary with 2 architectures"
     - name: test
       run: _build/Release/flattests
     - name: make flatc executable
@@ -134,6 +234,19 @@ jobs:
       with:
         name: Mac flatc binary
         path: _build/Release/flatc
+    # Below if only for release.
+    - name: Zip file
+      if: startsWith(github.ref, 'refs/tags/')
+      run: mv _build/Release/flatc . && zip Mac.flatc.binary.zip flatc
+    - name: Release binary
+      uses: softprops/action-gh-release@v1
+      if: startsWith(github.ref, 'refs/tags/')
+      with:
+        files: Mac.flatc.binary.zip
+    - name: Generate SLSA subjects
+      if: startsWith(github.ref, 'refs/tags/')
+      id: hash
+      run: echo "::set-output name=hashes::$(shasum -a 256 Mac.flatc.binary.zip | base64)"
 
   build-android:
    name: Build Android (on Linux)
@@ -146,12 +259,12 @@ jobs:
        java-version: 1.8
    - name: set up flatc
      run: |
-       cmake -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF .
+       cmake -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF -DFLATBUFFERS_STRICT_MODE=ON .
-       make
+       make -j
        echo "${PWD}" >> $GITHUB_PATH
    - name: build
      working-directory: android
-     run: bash ./gradlew clean build
+     run: gradle clean build
 
   build-generator:
     name: Check Generated Code
@@ -162,11 +275,11 @@ jobs:
     steps:
     - uses: actions/checkout@v2
     - name: cmake
-      run: CXX=${{ matrix.cxx }} cmake -G "Unix Makefiles" -DFLATBUFFERS_BUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=Release . && make -j4
+      run: CXX=${{ matrix.cxx }} cmake -G "Unix Makefiles" -DFLATBUFFERS_BUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON . && make -j
     - name: Generate
       run: scripts/check_generate_code.py
     - name: Generate gRPC
-      run: bash scripts/check-grpc-generated-code.sh
+      run: scripts/check-grpc-generated-code.py
 
   build-benchmarks:
     name: Build Benchmarks (on Linux)
@@ -177,7 +290,7 @@ jobs:
     steps:
     - uses: actions/checkout@v2
     - name: cmake
-      run: CXX=${{ matrix.cxx }} cmake -G "Unix Makefiles" -DFLATBUFFERS_CXX_FLAGS="-Wno-unused-parameter -fno-aligned-new" -DFLATBUFFERS_BUILD_BENCHMARKS=ON -DCMAKE_BUILD_TYPE=Release . && make -j4
+      run: CXX=${{ matrix.cxx }} cmake -G "Unix Makefiles" -DFLATBUFFERS_CXX_FLAGS="-Wno-unused-parameter -fno-aligned-new" -DFLATBUFFERS_BUILD_BENCHMARKS=ON -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON . && make -j
     - name: Run benchmarks
       run: ./flatbenchmark --benchmark_repetitions=5 --benchmark_display_aggregates_only=true --benchmark_out_format=console --benchmark_out=benchmarks/results_${{matrix.cxx}}
     - name: Upload benchmarks results
@@ -201,13 +314,14 @@ jobs:
     steps:
     - name: Checkout
       uses: actions/checkout@v2
+    - uses: gradle/wrapper-validation-action@v1
     - uses: actions/setup-java@v2
       with:
         distribution: 'adopt-hotspot'
         java-version: '11'
     - name: Build
       working-directory: kotlin
-      run: ./gradlew clean iosX64Test macosX64Test jsTest jsBrowserTest
+      run: ./gradlew clean iosX64Test macosX64Test
 
   build-kotlin-linux:
     name: Build Kotlin Linux
@@ -218,23 +332,14 @@ jobs:
     - uses: actions/setup-java@v2
       with:
         distribution: 'adopt-hotspot'
-        java-version: '8'
+        java-version: '11'
+    - uses: gradle/wrapper-validation-action@v1
     - name: Build
       working-directory: kotlin
-      run: ./gradlew jvmMainClasses jvmTest
+      # we are using docker's version of gradle
-    - name: Run Benchmark
+      # so no need for wrapper validadation or user
-      working-directory: kotlin
+      # gradlew
-      run: ./gradlew jvmBenchmark
+      run: gradle jvmMainClasses jvmTest jsTest jsBrowserTest
-    - name: Generate Benchmark Report
-      working-directory: kotlin
-      run: |
-        ./gradlew jmhReport;
-        mv benchmark/build/reports/benchmarks/main/* benchmark_latest
-    - name: Archive benchmark report
-      uses: actions/upload-artifact@v1
-      with:
-        name: Kotlin Benchmark Report
-        path: kotlin/benchmark_latest
 
   build-rust:
     name: Build Rust
@@ -261,7 +366,7 @@ jobs:
     - uses: actions/checkout@v2
     - name: flatc
       # FIXME: make test script not rely on flatc
-      run: cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_INSTALL=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF . && make -j4
+      run: cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_INSTALL=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF -DFLATBUFFERS_STRICT_MODE=ON . && make -j
     - name: test
       working-directory: tests
       run: bash GoTest.sh
@@ -275,16 +380,32 @@ jobs:
       working-directory: tests/FlatBuffers.Test.Swift
       run: sh SwiftTest.sh
 
+  build-swift-wasm:
+    name: Build Swift Wasm
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/swiftwasm/carton:0.15.3
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup Wasmer
+        uses: wasmerio/setup-wasmer@v1
+      - name: Test
+        working-directory: tests/FlatBuffers.Test.Swift.Wasm
+        run: carton test
+
   build-ts:
     name: Build TS
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
+    - name: flatc
+      # FIXME: make test script not rely on flatc
+      run: cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_INSTALL=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF . && make -j
     - name: compile
       run: npm run compile
     - name: test
       working-directory: tests
-      run: sh TypeScriptTest.sh
+      run: python3 TypeScriptTest.py
 
   build-dart:
     name: Build Dart
@@ -296,7 +417,43 @@ jobs:
           sdk: stable
       - name: flatc
         # FIXME: make test script not rely on flatc
-        run: cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_INSTALL=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF . && make -j4
+        run: cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_INSTALL=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF -DFLATBUFFERS_STRICT_MODE=ON . && make -j
       - name: test
         working-directory: tests
         run: bash DartTest.sh
+
+  release-digests:
+    if: startsWith(github.ref, 'refs/tags/')
+    needs: [build-linux, build-windows, build-mac-intel, build-mac-universal]
+    outputs:
+      digests: ${{ steps.hash.outputs.digests }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Merge results
+        id: hash
+        env:
+          LINUXGCC_DIGESTS: "${{ needs.build-linux.outputs.digests-gcc }}"
+          LINUXCLANG_DIGESTS: "${{ needs.build-linux.outputs.digests-clang }}"
+          MAC_DIGESTS: "${{ needs.build-mac-universal.outputs.digests }}"
+          MACINTEL_DIGESTS: "${{ needs.build-mac-intel.outputs.digests }}"
+          WINDOWS_DIGESTS: "${{ needs.build-windows.outputs.digests }}"
+        run: |
+          set -euo pipefail
+          echo "$LINUXGCC_DIGESTS" | base64 -d > checksums.txt
+          echo "$LINUXCLANG_DIGESTS" | base64 -d >> checksums.txt
+          echo "$MAC_DIGESTS" | base64 -d >> checksums.txt
+          echo "$MACINTEL_DIGESTS" | base64 -d >> checksums.txt
+          echo "$WINDOWS_DIGESTS" | base64 -d >> checksums.txt
+          echo "::set-output name=digests::$(cat checksums.txt | base64 -w0)"
+
+  provenance:
+    if: startsWith(github.ref, 'refs/tags/')
+    needs: [release-digests]
+    permissions:
+      actions: read   # To read the workflow path.
+      id-token: write # To sign the provenance.
+      contents: write # To add assets to a release.
+    uses: slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@v1.2.0
+    with:
+      base64-subjects: "${{ needs.release-digests.outputs.digests }}"
+      upload-assets: true # Optional: Upload to a new release

.github/workflows/codeql.yml

@@ -0,0 +1,71 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+permissions: read-all
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '16 20 * * 0'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'cpp' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://git.io/codeql-language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    # - name: Autobuild
+    #  uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    - run: |
+       cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON .
+       make -j       
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

.github/workflows/label.yml

@@ -6,11 +6,16 @@
 # https://github.com/actions/labeler
 
 name: Labeler
+permissions: read-all
+
 on: [pull_request_target]
 
 jobs:
   label:
-
+    permissions:
+      contents: read
+      pull-requests: write
+      
     runs-on: ubuntu-latest
 
     steps:

.github/workflows/main.yml

@@ -1,5 +1,15 @@
-name: CIFuzz
+name: OSS-Fuzz
-on: [pull_request]
+permissions: read-all
+
+on: 
+  pull_request:
+    branches:
+      - master
+    paths:
+      - include/**
+      - src/**
+      - tests/**.cpp
+      - tests/**.h
 jobs:
  Fuzzing:
    runs-on: ubuntu-latest
@@ -15,7 +25,7 @@ jobs:
      with:
        oss-fuzz-project-name: 'flatbuffers'
        language: c++
-       fuzz-seconds: 600
+       fuzz-seconds: 60
    - name: Upload Crash
      uses: actions/upload-artifact@v1
      if: failure() && steps.build.outcome == 'success'

.github/workflows/scorecards.yml

@@ -0,0 +1,55 @@
+name: Scorecards supply-chain security
+on:
+  # Only the default branch is supported.
+  branch_protection_rule:
+  schedule:
+    - cron: '21 2 * * 5'
+  push:
+    branches: [ master ]
+
+# Declare default permissions as read only.
+permissions: read-all
+
+jobs:
+  analysis:
+    name: Scorecards analysis
+    runs-on: ubuntu-latest
+    permissions:
+      # Needed to upload the results to code-scanning dashboard.
+      security-events: write
+      actions: read
+      contents: read
+
+    steps:
+      - name: "Checkout code"
+        uses: actions/checkout@a12a3943b4bdde767164f792f33f40b04645d846 # v3.0.0
+        with:
+          persist-credentials: false
+
+      - name: "Run analysis"
+        uses: ossf/scorecard-action@c1aec4ac820532bab364f02a81873c555a0ba3a1 # v1.0.4
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          # Read-only PAT token. To create it,
+          # follow the steps in https://github.com/ossf/scorecard-action#pat-token-creation.
+          repo_token: ${{ secrets.SCORECARD_READ_TOKEN }}
+          # Publish the results to enable scorecard badges. For more details, see
+          # https://github.com/ossf/scorecard-action#publishing-results.
+          # For private repositories, `publish_results` will automatically be set to `false`,
+          # regardless of the value entered here.
+          publish_results: true
+
+      # Upload the results as artifacts (optional).
+      - name: "Upload artifact"
+        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535 # v3.0.0
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      # Upload the results to GitHub's code scanning dashboard.
+      - name: "Upload to code-scanning"
+        uses: github/codeql-action/upload-sarif@5f532563584d71fdef14ee64d17bafb34f751ce5 # v1.0.26
+        with:
+          sarif_file: results.sarif

.github/workflows/stale.yml

@@ -1,4 +1,5 @@
 name: Mark stale issues and pull requests
+permissions: read-all
 
 on:
   schedule:

.gitignore

@@ -54,6 +54,8 @@ flathash
 flathash.exe
 flattests
 flattests.exe
+flattests_cpp17
+flattests_cpp17.exe
 flatsamplebinary
 flatsamplebinary.exe
 flatsampletext
@@ -76,7 +78,7 @@ tests/php/
 CMakeLists.txt.user
 CMakeScripts/**
 CTestTestfile.cmake
-FlatbuffersConfigVersion.cmake
+FlatBuffersConfigVersion.cmake
 FlatBuffers.cbp
 build/Xcode/FlatBuffers.xcodeproj/project.xcworkspace/**
 build/Xcode/FlatBuffers.xcodeproj/xcuserdata/**

.travis/build-and-run-docker-test-containers.sh

@@ -1,45 +0,0 @@
-#!/bin/bash
-#
-# Copyright 2018 Google Inc. All rights reserved.
-#
-# Licensed 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.
-set -e
-
-docker build -t build_cpp_image -f tests/docker/Dockerfile.testing.cpp.debian_buster .
-# Run tests with sanitizers  (--cap-add SYS_PTRACE), both GCC and Clang.
-cpp_test_args="--cap-add SYS_PTRACE build_cpp_image sh ./tests/docker/cpp_test.run.sh Debug"
-docker run --rm $cpp_test_args
-docker run --rm --env CC=/usr/bin/clang --env CXX=/usr/bin/clang++ $cpp_test_args
-# Build flatc on debian once to speed up the test loop below.
-docker run --name flatc_container build_cpp_image sh ./tests/docker/build_flatc.run.sh Debug
-# All dependent dockers refer to 'flatc_debian_stretch'.
-docker cp flatc_container:/flatbuffers/flatc flatc_debian_stretch
-
-for f in $(ls tests/docker/languages | sort)
-do
-        # docker pull sometimes fails for unknown reasons, probably travisci-related. this retries the pull we need a few times.
-        REQUIRED_BASE_IMAGE=$(cat tests/docker/languages/${f} | head -n 1  | awk ' { print $2 } ')
-
-        set +e
-        n=0
-        until [ $n -ge 5 ]
-        do
-           docker pull $REQUIRED_BASE_IMAGE && break
-           n=$[$n+1]
-           sleep 1
-        done
-        set -e
-
-        docker build -t $(echo ${f} | cut -f 3- -d .) -f tests/docker/languages/${f} .
-        echo "TEST OK: ${f}"
-done

.travis/check-sources.sh

@@ -1,33 +0,0 @@
-#!/bin/bash
-#
-# Copyright 2018 Google Inc. All rights reserved.
-#
-# Licensed 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.
-set -e
-
-if [ -n "$1" ]; then
-  scan_dir="$1"
-else
-  scan_dir="$( pwd )"
-fi
-
-py_checker="$0.py"
-
-echo "scan root directory = '$scan_dir'"
-python3 --version
-# Scan recursively and search all *.cpp and *.h files using regex patterns.
-# Assume that script running from a root of Flatbuffers working dir.
-python3 $py_checker "ascii" "$scan_dir/include" "\.h$"
-python3 $py_checker "ascii" "$scan_dir/src"     "\.cpp$"
-python3 $py_checker "ascii" "$scan_dir/tests"   "\.h$"
-python3 $py_checker "utf-8" "$scan_dir/tests"   "\.cpp$"

.travis/check-sources.sh.py

@@ -1,35 +0,0 @@
-import os
-import re
-import sys
-
-def check_encoding(encoding, scan_dir, regex_pattern):
-  fname = None
-  try:
-    assert encoding in ['ascii', 'utf-8'], "unexpected encoding"
-    cmp = re.compile(regex_pattern)
-    for root, dirs, files in os.walk(scan_dir):
-      fname = root
-      cmp_list = [f for f in files if cmp.search(f) is not None]
-      for f in cmp_list:
-        fname = os.path.join(root, f)
-        with open(fname, mode='rb') as test_file:
-          btext = test_file.read()
-        # check encoding
-        btext.decode(encoding=encoding, errors="strict")
-        if encoding == "utf-8" and btext.startswith(b'\xEF\xBB\xBF'):
-          raise ValueError("unexpected BOM in file")
-        # check LF line endings
-        LF = btext.count(b'\n')
-        CR = btext.count(b'\r')
-        if CR!=0:
-          raise ValueError("invalid line endings: LF({})/CR({})".format(LF, CR))
-  except Exception as err:
-    print("ERROR with [{}]: {}".format(fname, err))
-    return -1
-  else:
-    return 0
-
-if __name__ == "__main__":
-  # python check-sources.sh.py 'ascii' '.' '.*\.(cpp|h)$'
-  res = check_encoding(sys.argv[1], sys.argv[2], sys.argv[3])
-  sys.exit(0 if res == 0 else -1)

.travis/deploy-python.sh

@@ -1,12 +0,0 @@
-#!/bin/bash
-
-DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-PROD_REPOSITORY="https://upload.pypi.org/legacy/"
-TEST_REPOSITORY="https://test.pypi.org/legacy/"
-
-twine upload \
-    --username "$PYPI_USERNAME" \
-    --password "$PYPI_PASSWORD" \
-    --repository-url "$PROD_REPOSITORY" \
-    "$DIR/../python/dist/"*
-

.travis/format_check.sh

@@ -1,52 +0,0 @@
-#!/bin/bash
-#
-# Copyright 2021 Google Inc. All rights reserved.
-#
-# Licensed 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.
-
-set -e
-
-# HACKY solution to make nodejs work.
-source ~/.nvm/nvm.sh
-nvm alias default node
-nvm use default
-
-sh scripts/clang-format-git.sh
-
-# Check formatting for go lang
-
-cd go
-gofmt -w .
-cd ..
-cd grpc/examples/go
-sh format.sh
-cd ../../..
-
-node_modules/.bin/eslint ts/** --ext .ts --quiet --fix
-
-#PYTHON IS DISABLED UNTIL WE CREATE A .pylintrc FILE FOR IT
-pylint python/** --disable=all
-
-swiftformat --config swift.swiftformat .
-
-
-if ! git diff --quiet; then
-  echo >&2
-  echo "ERROR: ********************************************************" >&2
-  echo "ERROR: The following differences were found after running" >&2
-  echo "ERROR: .travis/format_check.sh script. Maybe you forgot to format" >&2
-  echo "ERROR: the code after making changes? please check Formatters.md" >&2
-  echo "ERROR: ********************************************************" >&2
-  echo >&2
-  git diff --binary --exit-code
-fi

.travis/format_install.sh

@@ -1,90 +0,0 @@
-#!/bin/bash
-#
-# Copyright 2020 Google Inc. All rights reserved.
-#
-# Licensed 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.
-
-set -e
-set -x
-
-# install devtools
-install_languages() {
-  sudo apt update
-
-  # Install nodeJS and yarn
-  wget https://raw.githubusercontent.com/creationix/nvm/v0.31.0/nvm.sh -O ~/.nvm/nvm.sh
-  source ~/.nvm/nvm.sh
-  nvm install node
-  node --version
-  curl -o- -L https://yarnpkg.com/install.sh | bash
-  export PATH="$HOME/.yarn/bin:$PATH"
-  yarn config set prefix ~/.yarn -g
-  export PATH="$HOME/.yarn/bin:$HOME/.config/yarn/global/node_modules/.bin:$PATH"
-
-  # Install swift
-  sudo apt-get install \
-          binutils \
-          git \
-          libc6-dev \
-          libcurl3 \
-          libedit2 \
-          libgcc-5-dev \
-          libpython2.7 \
-          libsqlite3-0 \
-          libstdc++-5-dev \
-          libxml2 \
-          pkg-config \
-          tzdata \
-          zlib1g-dev
-
-  SWIFT_URL=https://swift.org/builds/swift-5.3.1-release/ubuntu1604/swift-5.3.1-RELEASE/swift-5.3.1-RELEASE-ubuntu16.04.tar.gz
-  curl -fSsL "$SWIFT_URL" -o swift.tar.gz
-
-  mkdir ~/swiftbuild
-  tar -xvzf swift.tar.gz -C ~/swiftbuild
-
-  export PATH="~/swiftbuild/swift-5.3.1-RELEASE-ubuntu16.04/usr/bin:$PATH"
-
-
-  mkdir ~/gobuild
-  wget -c https://golang.org/dl/go1.15.2.linux-amd64.tar.gz
-  tar -xvzf go1.15.2.linux-amd64.tar.gz -C ~/gobuild
-
-  export  PATH="~/gobuild/go/bin:$PATH"
-
-  swift --version
-  go version
-  yarn -v
-  node -v
-}
-
-install_formatters() {
-  # installing swift formatter
-  git clone --depth 1 --branch 0.47.4 https://github.com/nicklockwood/SwiftFormat.git
-  cd SwiftFormat
-  swift build -c release
-  sudo cp .build/release/swiftformat /usr/local/bin/swiftformat
-  cd ..
-
-  which yarn
-  which node
-  yarn -v
-  node -v
-
-  yarn install
-  pip install pylint
-}
-
-install_languages
-export PATH="~/swift/swift/usr/bin:$PATH"
-install_formatters

BUILD.bazel

@@ -8,6 +8,7 @@ package(
 
 exports_files([
     "LICENSE",
+    "tsconfig.json",
 ])
 
 config_setting(
@@ -48,6 +49,7 @@ filegroup(
         "include/flatbuffers/detached_buffer.h",
         "include/flatbuffers/flatbuffer_builder.h",
         "include/flatbuffers/flatbuffers.h",
+        "include/flatbuffers/flex_flat_util.h",
         "include/flatbuffers/flexbuffers.h",
         "include/flatbuffers/grpc.h",
         "include/flatbuffers/hash.h",
@@ -79,6 +81,7 @@ cc_library(
 # Public flatc compiler.
 cc_binary(
     name = "flatc",
+    data = ["//reflection:reflection_fbs_schema"],
     deps = [
         "//src:flatc",
     ],

CHANGELOG.md

@@ -0,0 +1,22 @@
+# Flatbuffers Change Log
+
+All major or breaking changes will be documented in this file, as well as any
+new features that should be highlighted. Minor fixes or improvements are not
+necessarily listed.
+
+## 2.0.7 (Aug 22 2022)
+
+* This is the first version with an explicit change log, so all the previous
+features will not be listed.
+
+* Verifier now checks that buffers are at least the minimum size required to be
+a flatbuffers (12 bytes). This includes nested flatbuffers, which previously
+could be declared valid at size 0.
+
+* Annotated binaries. Given a flatbuffer binary and a schema (or binary schema)
+one can generate an annotated flatbuffer (.afb) to describe each byte in the
+binary with schema metadata and value.
+
+* First binary schema generator (Lua) to generate Lua code via a .bfbs file. 
+This is mostly an implementation detail of flatc internals, but will be slowly
+applied to the other language generators.

CMake/CMakeLists_legacy.cmake.in

@@ -8,10 +8,16 @@
 
 if (POLICY CMP0048)
   cmake_policy(SET CMP0048 NEW)
-  project(FlatBuffers
+  if(CMAKE_VERSION VERSION_LESS 3.9)
-        DESCRIPTION "Flatbuffers serialization library"
+    project(FlatBuffers
-        VERSION 2.0.0
+      VERSION 2.0.0
-        LANGUAGES CXX)
+      LANGUAGES CXX)
+  else()
+    project(FlatBuffers
+      DESCRIPTION "Flatbuffers serialization library"
+      VERSION 2.0.0
+      LANGUAGES CXX)
+  endif()
 else()
   project(FlatBuffers)
 endif (POLICY CMP0048)
@@ -648,28 +654,28 @@ if(FLATBUFFERS_INSTALL)
 
   set(FB_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/flatbuffers")
 
-  configure_file(CMake/FlatbuffersConfigVersion.cmake.in FlatbuffersConfigVersion.cmake @ONLY)
+  configure_file(CMake/FlatBuffersConfigVersion.cmake.in FlatBuffersConfigVersion.cmake @ONLY)
   install(
-      FILES "CMake/FlatbuffersConfig.cmake" "${CMAKE_CURRENT_BINARY_DIR}/FlatbuffersConfigVersion.cmake"
+      FILES "CMake/FlatBuffersConfig.cmake" "${CMAKE_CURRENT_BINARY_DIR}/FlatBuffersConfigVersion.cmake"
       DESTINATION ${FB_CMAKE_DIR}
   )
 
   if(FLATBUFFERS_BUILD_FLATLIB)
     if(CMAKE_VERSION VERSION_LESS 3.0)
       install(
-        TARGETS flatbuffers EXPORT FlatbuffersTargets
+        TARGETS flatbuffers EXPORT FlatBuffersTargets
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
       )
     else()
       install(
-        TARGETS flatbuffers EXPORT FlatbuffersTargets
+        TARGETS flatbuffers EXPORT FlatBuffersTargets
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
         INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
       )
     endif()
 
-    install(EXPORT FlatbuffersTargets
+    install(EXPORT FlatBuffersTargets
-      FILE FlatbuffersTargets.cmake
+      FILE FlatBuffersTargets.cmake
       NAMESPACE flatbuffers::
       DESTINATION ${FB_CMAKE_DIR}
     )
@@ -692,14 +698,14 @@ if(FLATBUFFERS_INSTALL)
   if(FLATBUFFERS_BUILD_SHAREDLIB)
     if(CMAKE_VERSION VERSION_LESS 3.0)
       install(
-        TARGETS flatbuffers_shared EXPORT FlatbuffersSharedTargets
+        TARGETS flatbuffers_shared EXPORT FlatBuffersSharedTargets
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
         RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}
         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
       )
     else()
       install(
-        TARGETS flatbuffers_shared EXPORT FlatbuffersSharedTargets
+        TARGETS flatbuffers_shared EXPORT FlatBuffersSharedTargets
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
         RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}
         LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
@@ -708,8 +714,8 @@ if(FLATBUFFERS_INSTALL)
     endif()
 
   install(
-      EXPORT FlatbuffersSharedTargets
+      EXPORT FlatBuffersSharedTargets
-      FILE FlatbuffersSharedTargets.cmake
+      FILE FlatBuffersSharedTargets.cmake
       NAMESPACE flatbuffers::
       DESTINATION ${FB_CMAKE_DIR}
     )
@@ -771,4 +777,4 @@ add_library(FlatBuffers::FlatBuffers ALIAS FlatBuffers)
 target_include_directories(
   FlatBuffers
   INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/include>)
+            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/include>)

CMake/FlatBuffersConfig.cmake

@@ -0,0 +1,3 @@
+include("${CMAKE_CURRENT_LIST_DIR}/FlatBuffersTargets.cmake" OPTIONAL)
+include("${CMAKE_CURRENT_LIST_DIR}/FlatcTargets.cmake" OPTIONAL)
+include("${CMAKE_CURRENT_LIST_DIR}/FlatBuffersSharedTargets.cmake" OPTIONAL)

CMake/FlatbuffersConfig.cmake

@@ -1,4 +0,0 @@
-include("${CMAKE_CURRENT_LIST_DIR}/FlatbuffersTargets.cmake" OPTIONAL)
-include("${CMAKE_CURRENT_LIST_DIR}/FlatcTargets.cmake" OPTIONAL)
-include("${CMAKE_CURRENT_LIST_DIR}/FlatbuffersSharedTargets.cmake" OPTIONAL)
-

CMake/Version.cmake

@@ -1,6 +1,6 @@
 set(VERSION_MAJOR 2)
 set(VERSION_MINOR 0)
-set(VERSION_PATCH 6)
+set(VERSION_PATCH 7)
 set(VERSION_COMMIT 0)
 
 find_program(GIT git)

CMakeLists.txt

@@ -1,5 +1,5 @@
 # This is the legacy minimum version flatbuffers supported for a while.
-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 2.8.12...3.22.1)
 
 # CMake version 3.16 is the 'de-facto' minimum version for flatbuffers. If the
 # current cmake is older than this, warn the user and include the legacy file to
@@ -15,18 +15,19 @@ if(CMAKE_VERSION VERSION_LESS 3.16)
   return()
 endif()
 
+# Attempt to read the current version of flatbuffers by looking at the latest tag.
+include(CMake/Version.cmake)
+
 if (POLICY CMP0048)
   cmake_policy(SET CMP0048 NEW)
   project(FlatBuffers
         DESCRIPTION "Flatbuffers serialization library"
-        VERSION 2.0.0
+        VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}
         LANGUAGES CXX)
 else()
   project(FlatBuffers)
 endif (POLICY CMP0048)
 
-include(CMake/Version.cmake)
-
 # generate compile_commands.json
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
@@ -41,8 +42,7 @@ option(FLATBUFFERS_BUILD_FLATC "Enable the build of the flatbuffers compiler"
 option(FLATBUFFERS_STATIC_FLATC "Build flatbuffers compiler with -static flag"
        OFF)
 option(FLATBUFFERS_BUILD_FLATHASH "Enable the build of flathash" ON)
-option(FLATBUFFERS_BUILD_BENCHMARKS "Enable the build of flatbenchmark. \"
+option(FLATBUFFERS_BUILD_BENCHMARKS "Enable the build of flatbenchmark."
-       Requires C++11."
        OFF)
 option(FLATBUFFERS_BUILD_GRPCTEST "Enable the build of grpctest" OFF)
 option(FLATBUFFERS_BUILD_SHAREDLIB
@@ -74,9 +74,14 @@ option(FLATBUFFERS_ENABLE_PCH
 option(FLATBUFFERS_SKIP_MONSTER_EXTRA 
       "Skip generating monster_extra.fbs that contains non-supported numerical\"
       types." OFF)
-option(FLATBUFFERS_OSX_BUILD_UNIVERSAL
+option(FLATBUFFERS_STRICT_MODE 
-      "Enable the build for multiple architectures on OS X (arm64, x86_64)."
+      "Build flatbuffers with all warnings as errors (-Werror or /WX)."
-      ON)
+      OFF)
+
+set(MSVC_LIKE OFF)
+if(MSVC OR CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
+    set(MSVC_LIKE ON)
+endif()
 
 if(NOT FLATBUFFERS_BUILD_FLATC AND FLATBUFFERS_BUILD_TESTS)
     message(WARNING
@@ -95,7 +100,7 @@ if(NOT DEFINED FLATBUFFERS_LOCALE_INDEPENDENT)
   include(CheckCXXSymbolExists)
 
   set(FLATBUFFERS_LOCALE_INDEPENDENT 0)
-  if(MSVC)
+  if(MSVC_LIKE)
     check_cxx_symbol_exists(_strtof_l stdlib.h FLATBUFFERS_HAS_STRTOF_L)
     check_cxx_symbol_exists(_strtoui64_l stdlib.h FLATBUFFERS_HAS_STRTOULL_L)
   else()
@@ -120,6 +125,7 @@ set(FlatBuffers_Library_SRCS
   include/flatbuffers/flatbuffer_builder.h
   include/flatbuffers/flatbuffers.h
   include/flatbuffers/flexbuffers.h
+  include/flatbuffers/flex_flat_util.h
   include/flatbuffers/hash.h
   include/flatbuffers/idl.h
   include/flatbuffers/minireflect.h
@@ -158,11 +164,18 @@ set(FlatBuffers_Compiler_SRCS
   src/idl_gen_grpc.cpp
   src/idl_gen_json_schema.cpp
   src/idl_gen_swift.cpp
+  src/idl_namer.h
+  src/namer.h
   src/flatc.cpp
   src/flatc_main.cpp
   src/bfbs_gen.h
   src/bfbs_gen_lua.h
+  src/bfbs_namer.h
   include/flatbuffers/code_generators.h
+  src/binary_annotator.h
+  src/binary_annotator.cpp
+  src/annotated_binary_text_gen.h
+  src/annotated_binary_text_gen.cpp
   src/bfbs_gen_lua.cpp
   src/code_generators.cpp
   grpc/src/compiler/schema_interface.h
@@ -266,86 +279,8 @@ set(FlatBuffers_GRPCTest_SRCS
   ${CMAKE_CURRENT_BINARY_DIR}/tests/monster_test_generated.h
 )
 
-# source_group(Compiler FILES ${FlatBuffers_Compiler_SRCS})
+# TODO(dbaileychess): Figure out how this would now work. I posted a question on
-# source_group(Tests FILES ${FlatBuffers_Tests_SRCS})
+# https://stackoverflow.com/questions/71772330/override-target-compile-options-via-cmake-command-line.
-
-if(EXISTS "${CMAKE_TOOLCHAIN_FILE}")
-  # do not apply any global settings if the toolchain
-  # is being configured externally
-  message(STATUS "Using toolchain file: ${CMAKE_TOOLCHAIN_FILE}.")
-elseif(CMAKE_COMPILER_IS_GNUCXX)
-  if(CYGWIN)
-    set(CMAKE_CXX_FLAGS
-      "${CMAKE_CXX_FLAGS} -std=gnu++11")
-  else(CYGWIN)
-    set(CMAKE_CXX_FLAGS
-      "${CMAKE_CXX_FLAGS} -std=c++0x")
-  endif(CYGWIN)
-  set(CMAKE_CXX_FLAGS
-    "${CMAKE_CXX_FLAGS} -Wall -pedantic -Werror -Wextra -Werror=shadow")
-  set(FLATBUFFERS_PRIVATE_CXX_FLAGS "-Wold-style-cast")
-  if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.4)
-    if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.0)
-      set(CMAKE_CXX_FLAGS
-        "${CMAKE_CXX_FLAGS} -faligned-new -Werror=implicit-fallthrough=2")
-    endif()
-    set(CMAKE_CXX_FLAGS
-      "${CMAKE_CXX_FLAGS} -Wunused-result -Werror=unused-result -Wunused-parameter -Werror=unused-parameter")
-  endif()
-
-  # Certain platforms such as ARM do not use signed chars by default
-  # which causes issues with certain bounds checks.
-  set(CMAKE_CXX_FLAGS
-    "${CMAKE_CXX_FLAGS} -fsigned-char")
-
-# MSVC **MUST** come before the Clang check, as clang-cl is flagged by CMake as "MSVC", but it still textually 
-# matches as Clang in its Compiler Id :)
-# Note: in CMake >= 3.14 we can check CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU" or "MSVC" to differentiate...
-elseif(MSVC)
-  # Visual Studio pedantic build settings
-  # warning C4512: assignment operator could not be generated
-  # warning C4316: object allocated on the heap may not be aligned
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /WX /wd4512 /wd4316")
-
-  if(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D_CRT_SECURE_NO_WARNINGS")
-  endif()
-
-elseif(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
-  if(APPLE)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-
-    if(FLATBUFFERS_OSX_BUILD_UNIVERSAL)
-      set(CMAKE_OSX_ARCHITECTURES "arm64;x86_64")
-    endif()
-  else()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
-  endif()
-
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -pedantic -Werror -Wextra -Wno-unused-parameter")
-  set(FLATBUFFERS_PRIVATE_CXX_FLAGS "-Wold-style-cast")
-  if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.8)
-    list(APPEND FLATBUFFERS_PRIVATE_CXX_FLAGS "-Wimplicit-fallthrough" "-Wextra-semi" "-Werror=unused-private-field") # enable warning
-  endif()
-  if(FLATBUFFERS_LIBCXX_WITH_CLANG)
-    if(NOT "${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
-      set(CMAKE_CXX_FLAGS
-          "${CMAKE_CXX_FLAGS} -stdlib=libc++")
-    endif()
-    if(NOT ("${CMAKE_SYSTEM_NAME}" MATCHES "FreeBSD" OR
-            "${CMAKE_SYSTEM_NAME}" MATCHES "Linux"))
-      set(CMAKE_EXE_LINKER_FLAGS
-          "${CMAKE_EXE_LINKER_FLAGS} -lc++abi")
-    endif()
-  endif()
-
-  # Certain platforms such as ARM do not use signed chars by default
-  # which causes issues with certain bounds checks.
-  set(CMAKE_CXX_FLAGS
-    "${CMAKE_CXX_FLAGS} -fsigned-char")
-
-endif()
-
 # Append FLATBUFFERS_CXX_FLAGS to CMAKE_CXX_FLAGS.
 if(DEFINED FLATBUFFERS_CXX_FLAGS AND NOT EXISTS "${CMAKE_TOOLCHAIN_FILE}")
   message(STATUS "extend CXX_FLAGS with ${FLATBUFFERS_CXX_FLAGS}")
@@ -353,12 +288,6 @@ if(DEFINED FLATBUFFERS_CXX_FLAGS AND NOT EXISTS "${CMAKE_TOOLCHAIN_FILE}")
 endif()
 message(STATUS "CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS}")
 
-if(FLATBUFFERS_CODE_COVERAGE)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -fprofile-arcs -ftest-coverage")
-  set(CMAKE_EXE_LINKER_FLAGS
-      "${CMAKE_EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage")
-endif()
-
 function(add_fsanitize_to_target _target _sanitizer)
   if(WIN32)
     target_compile_definitions(${_target} PRIVATE FLATBUFFERS_MEMORY_LEAK_TRACKING)
@@ -397,12 +326,116 @@ endfunction()
 include_directories(include)
 include_directories(grpc)
 
+# Creates an interface library that stores the configuration settings that each
+# target links too. This is a compromise between setting configuration globally
+# with add_compile_options() and the more targetted target_compile_options(). 
+# This way each target in this file can share settings and override them if 
+# needed.
+add_library(ProjectConfig INTERFACE)
+target_compile_features(ProjectConfig
+  INTERFACE
+    cxx_std_11
+)
+
+# Force the standard to be met.
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# We shouldn't rely on any compiler-extensions to make things work.
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+if(MSVC_LIKE)
+  target_compile_options(ProjectConfig
+    INTERFACE 
+      /W4
+      $<$<BOOL:${FLATBUFFERS_STRICT_MODE}>:
+        /WX       # Treat all compiler warnings as errors
+      >
+      /wd4512   # C4512: assignment operator could not be generated
+      /wd4316   # C4316: object allocated on the heap may not be aligned
+      /wd4456   # C4456: hides previous local declaration
+      $<$<CXX_COMPILER_ID:Clang>:
+        /D_CRT_SECURE_NO_WARNINGS
+      >
+  )
+else()
+  target_compile_options(ProjectConfig
+    INTERFACE
+      -Wall
+      -Wno-unknown-warning-option
+      $<$<BOOL:${FLATBUFFERS_STRICT_MODE}>:
+        -Werror   # Treat all compiler warnings as errors
+
+        # False positive string overflow
+        # https://github.com/google/flatbuffers/issues/7366
+        -Wno-error=stringop-overflow
+      >
+      -pedantic 
+      -Wextra 
+      -Wno-unused-parameter
+      -Wold-style-cast
+      -Wimplicit-fallthrough
+      -fsigned-char
+      -Wnon-virtual-dtor
+
+      $<$<CXX_COMPILER_ID:CLANG>:
+        -Wmissing-declarations
+        -Wzero-as-null-pointer-constant
+        $<$<VERSION_GREATER:$<CXX_COMPILER_VERSION>,3.8>:
+          -Wimplicit-fallthrough
+          -Wextra-semi
+          $<$<BOOL:${FLATBUFFERS_STRICT_MODE}>:            
+            -Werror=unused-private-field
+          >
+        >
+      >
+
+      $<$<CXX_COMPILER_ID:GNU>:
+        $<$<VERSION_GREATER:$<CXX_COMPILER_VERSION>,4.4>:
+          -Wunused-result
+          -Wunused-parameter 
+          -Werror=unused-parameter
+          -Wmissing-declarations
+        >
+        $<$<VERSION_GREATER:$<CXX_COMPILER_VERSION>,4.7>:
+          -Wzero-as-null-pointer-constant
+        >
+        $<$<VERSION_GREATER:$<CXX_COMPILER_VERSION>,7.0>:
+          -faligned-new 
+          $<$<BOOL:${FLATBUFFERS_STRICT_MODE}>:
+            -Werror=implicit-fallthrough=2
+          >
+        >
+        $<$<VERSION_GREATER:$<CXX_COMPILER_VERSION>,8.0>:
+          -Wextra-semi
+        >
+      >
+
+      $<$<BOOL:${FLATBUFFERS_CODE_COVERAGE}>:
+        -g
+        -fprofile-arcs
+        -ftest-coverage
+      >
+    )
+
+  if(FLATBUFFERS_CODE_COVERAGE)
+    target_link_options(ProjectConfig
+      INTERFACE
+        -fprofile-arcs
+        -ftest-coverage
+    )
+  endif()
+endif()
+
 if(FLATBUFFERS_BUILD_FLATLIB)
   add_library(flatbuffers STATIC ${FlatBuffers_Library_SRCS})
+
   # Attach header directory for when build via add_subdirectory().
-  target_include_directories(flatbuffers INTERFACE
+  target_include_directories(flatbuffers 
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
+    INTERFACE
-  target_compile_options(flatbuffers PRIVATE "${FLATBUFFERS_PRIVATE_CXX_FLAGS}")
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  )
+  target_link_libraries(flatbuffers PRIVATE $<BUILD_INTERFACE:ProjectConfig>)
+
   if(FLATBUFFERS_ENABLE_PCH)
     add_pch_to_target(flatbuffers include/flatbuffers/pch/pch.h)
   endif()
@@ -413,17 +446,21 @@ if(FLATBUFFERS_BUILD_FLATC)
   if(FLATBUFFERS_ENABLE_PCH)
     add_pch_to_target(flatc include/flatbuffers/pch/flatc_pch.h)
   endif()
-  target_compile_options(flatc PRIVATE "${FLATBUFFERS_PRIVATE_CXX_FLAGS}")
+
+  target_link_libraries(flatc PRIVATE $<BUILD_INTERFACE:ProjectConfig>)
+  target_compile_options(flatc 
+    PUBLIC
+      $<$<AND:$<BOOL:${MSVC_LIKE}>,$<CONFIG:Release>>:
+        /MT
+      >
+  )
+
   if(FLATBUFFERS_CODE_SANITIZE AND NOT WIN32)
     add_fsanitize_to_target(flatc ${FLATBUFFERS_CODE_SANITIZE})
   endif()
   if(NOT FLATBUFFERS_FLATC_EXECUTABLE)
     set(FLATBUFFERS_FLATC_EXECUTABLE $<TARGET_FILE:flatc>)
   endif()
-  if(MSVC)
-    # Make flatc.exe not depend on runtime dlls for easy distribution.
-    target_compile_options(flatc PUBLIC $<$<CONFIG:Release>:/MT>)
-  endif()
   if(FLATBUFFERS_STATIC_FLATC AND NOT MSVC)
     target_link_libraries(flatc PRIVATE -static)
   endif()
@@ -431,11 +468,12 @@ endif()
 
 if(FLATBUFFERS_BUILD_FLATHASH)
   add_executable(flathash ${FlatHash_SRCS})
+  target_link_libraries(flathash PRIVATE $<BUILD_INTERFACE:ProjectConfig>)
 endif()
 
 if(FLATBUFFERS_BUILD_SHAREDLIB)
   add_library(flatbuffers_shared SHARED ${FlatBuffers_Library_SRCS})
-
+  target_link_libraries(flatbuffers_shared PRIVATE $<BUILD_INTERFACE:ProjectConfig>)
   # Shared object version: "major.minor.micro"
   # - micro updated every release when there is no API/ABI changes
   # - minor updated when there are additions in API/ABI
@@ -536,30 +574,6 @@ function(compile_flatbuffers_schema_to_embedded_binary SRC_FBS OPT)
   register_generated_output(${GEN_BFBS_HEADER})
 endfunction()
 
-# Look if we have python 3.5 installed so that we can run the generate code
-# python script after flatc is built.
-find_package(Python3 3.5 COMPONENTS Interpreter)
-
-if(Python3_Interpreter_FOUND)
-  set(GENERATION_OPTS --flatc "${FLATBUFFERS_FLATC_EXECUTABLE}")
-  if(FLATBUFFERS_BUILD_LEGACY)
-    # Need to set --cpp-std c++-0x options
-    set(GENERATION_OPTS ${GENERATION_OPTS}--cpp-0x)
-  endif()
-  if(FLATBUFFERS_SKIP_MONSTER_EXTRA)
-    set(GENERATION_OPTS ${GENERATION_OPTS} --skip-monster-extra)
-  endif()
-  add_custom_command(
-    TARGET flatc
-    POST_BUILD
-    COMMAND ${Python3_EXECUTABLE} scripts/generate_code.py ${GENERATION_OPTS} --skip-gen-reflection
-    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-    COMMENT "Running scripts/generate_code.py..."
-    VERBATIM)
-else()
-  message("No Python3 interpreter found! Unable to generate files automatically.")
-endif()
-
 if(FLATBUFFERS_BUILD_TESTS)
   file(COPY "${CMAKE_CURRENT_SOURCE_DIR}/tests" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
   file(COPY "${CMAKE_CURRENT_SOURCE_DIR}/samples" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
@@ -580,10 +594,10 @@ if(FLATBUFFERS_BUILD_TESTS)
   endif()
   include_directories(${CMAKE_CURRENT_BINARY_DIR}/tests)
   add_executable(flattests ${FlatBuffers_Tests_SRCS})
+  target_link_libraries(flattests PRIVATE $<BUILD_INTERFACE:ProjectConfig>)
+
   add_dependencies(flattests generated_code)
-  set_property(TARGET flattests
+
-    PROPERTY COMPILE_DEFINITIONS FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
-    FLATBUFFERS_DEBUG_VERIFICATION_FAILURE=1)
   if(FLATBUFFERS_CODE_SANITIZE)
     add_fsanitize_to_target(flattests ${FLATBUFFERS_CODE_SANITIZE})
   endif()
@@ -591,24 +605,27 @@ if(FLATBUFFERS_BUILD_TESTS)
   compile_flatbuffers_schema_to_cpp(samples/monster.fbs)
   compile_flatbuffers_schema_to_binary(samples/monster.fbs)
   include_directories(${CMAKE_CURRENT_BINARY_DIR}/samples)
+
   add_executable(flatsamplebinary ${FlatBuffers_Sample_Binary_SRCS})
+  target_link_libraries(flatsamplebinary PRIVATE $<BUILD_INTERFACE:ProjectConfig>)
   add_dependencies(flatsamplebinary generated_code)
+
   add_executable(flatsampletext ${FlatBuffers_Sample_Text_SRCS})
+  target_link_libraries(flatsampletext PRIVATE $<BUILD_INTERFACE:ProjectConfig>)
   add_dependencies(flatsampletext generated_code)
+
   add_executable(flatsamplebfbs ${FlatBuffers_Sample_BFBS_SRCS})
+  target_link_libraries(flatsamplebfbs PRIVATE $<BUILD_INTERFACE:ProjectConfig>)
   add_dependencies(flatsamplebfbs generated_code)
 
   if(FLATBUFFERS_BUILD_CPP17)
     # Don't generate header for flattests_cpp17 target.
     # This target uses "generated_cpp17/monster_test_generated.h"
-    # produced by direct call of generate_code.py script.
     add_executable(flattests_cpp17 ${FlatBuffers_Tests_CPP17_SRCS})
     add_dependencies(flattests_cpp17 generated_code)
+    target_link_libraries(flattests_cpp17 PRIVATE $<BUILD_INTERFACE:ProjectConfig>)
     target_compile_features(flattests_cpp17 PRIVATE cxx_std_17)
-    target_compile_definitions(flattests_cpp17 PRIVATE
+
-      FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
-      FLATBUFFERS_DEBUG_VERIFICATION_FAILURE=1
-    )
     if(FLATBUFFERS_CODE_SANITIZE)
       add_fsanitize_to_target(flattests_cpp17 ${FLATBUFFERS_CODE_SANITIZE})
     endif()
@@ -616,9 +633,6 @@ if(FLATBUFFERS_BUILD_TESTS)
 endif()
 
 if(FLATBUFFERS_BUILD_GRPCTEST)
-  if(CMAKE_COMPILER_IS_GNUCXX)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-shadow")
-  endif()
   if(NOT GRPC_INSTALL_PATH)
     message(SEND_ERROR "GRPC_INSTALL_PATH variable is not defined. See grpc/README.md")
   endif()
@@ -634,14 +648,16 @@ if(FLATBUFFERS_BUILD_GRPCTEST)
   find_package(gRPC CONFIG REQUIRED)
   add_executable(grpctest ${FlatBuffers_GRPCTest_SRCS})
   add_dependencies(grpctest generated_code)
-  target_link_libraries(grpctest PRIVATE gRPC::grpc++_unsecure gRPC::grpc_unsecure gRPC::gpr pthread dl)
+  target_link_libraries(grpctext 
-  if(FLATBUFFERS_CODE_SANITIZE AND NOT WIN32)
+    PRIVATE 
-    # GRPC test has problems with alignment and will fail under ASAN/UBSAN.
+      $<BUILD_INTERFACE:ProjectConfig>
-    # add_fsanitize_to_target(grpctest ${FLATBUFFERS_CODE_SANITIZE})
+      gRPC::grpc++_unsecure 
-  endif()
+      gRPC::gpr 
+      pthread
+      dl 
+  )
 endif()
 
-
 if(FLATBUFFERS_INSTALL)
   include(GNUInstallDirs)
 
@@ -649,21 +665,21 @@ if(FLATBUFFERS_INSTALL)
 
   set(FB_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/flatbuffers")
 
-  configure_file(CMake/FlatbuffersConfigVersion.cmake.in FlatbuffersConfigVersion.cmake @ONLY)
+  configure_file(CMake/FlatBuffersConfigVersion.cmake.in FlatBuffersConfigVersion.cmake @ONLY)
   install(
-      FILES "CMake/FlatbuffersConfig.cmake" "${CMAKE_CURRENT_BINARY_DIR}/FlatbuffersConfigVersion.cmake"
+      FILES "CMake/FlatBuffersConfig.cmake" "${CMAKE_CURRENT_BINARY_DIR}/FlatBuffersConfigVersion.cmake"
       DESTINATION ${FB_CMAKE_DIR}
   )
 
   if(FLATBUFFERS_BUILD_FLATLIB)
     install(
-      TARGETS flatbuffers EXPORT FlatbuffersTargets
+      TARGETS flatbuffers EXPORT FlatBuffersTargets
       ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
       INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
     )
 
-    install(EXPORT FlatbuffersTargets
+    install(EXPORT FlatBuffersTargets
-      FILE FlatbuffersTargets.cmake
+      FILE FlatBuffersTargets.cmake
       NAMESPACE flatbuffers::
       DESTINATION ${FB_CMAKE_DIR}
     )
@@ -685,7 +701,7 @@ if(FLATBUFFERS_INSTALL)
 
   if(FLATBUFFERS_BUILD_SHAREDLIB)
     install(
-      TARGETS flatbuffers_shared EXPORT FlatbuffersSharedTargets
+      TARGETS flatbuffers_shared EXPORT FlatBuffersSharedTargets
       ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
       RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}
       LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
@@ -693,8 +709,8 @@ if(FLATBUFFERS_INSTALL)
     )
 
     install(
-      EXPORT FlatbuffersSharedTargets
+      EXPORT FlatBuffersSharedTargets
-      FILE FlatbuffersSharedTargets.cmake
+      FILE FlatBuffersSharedTargets.cmake
       NAMESPACE flatbuffers::
       DESTINATION ${FB_CMAKE_DIR}
     )
@@ -756,4 +772,4 @@ add_library(FlatBuffers::FlatBuffers ALIAS FlatBuffers)
 target_include_directories(
   FlatBuffers
   INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/include>)
+            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/include>)

WORKSPACE

@@ -3,20 +3,47 @@ workspace(name = "com_github_google_flatbuffers")
 load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 
 http_archive(
-    name = "io_bazel_rules_go",
+    name = "platforms",
-    sha256 = "d1ffd055969c8f8d431e2d439813e42326961d0942bdf734d2c95dc30c369566",
+    sha256 = "379113459b0feaf6bfbb584a91874c065078aa673222846ac765f86661c27407",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.24.5/rules_go-v0.24.5.tar.gz",
+        "https://mirror.bazel.build/github.com/bazelbuild/platforms/releases/download/0.0.5/platforms-0.0.5.tar.gz",
-        "https://github.com/bazelbuild/rules_go/releases/download/v0.24.5/rules_go-v0.24.5.tar.gz",
+        "https://github.com/bazelbuild/platforms/releases/download/0.0.5/platforms-0.0.5.tar.gz",
     ],
 )
 
-load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_dependencies")
+http_archive(
+    name = "build_bazel_rules_swift",
+    sha256 = "a2fd565e527f83fb3f9eb07eb9737240e668c9242d3bc318712efa54a7deda97",
+    url = "https://github.com/bazelbuild/rules_swift/releases/download/0.27.0/rules_swift.0.27.0.tar.gz",
+)
+
+load(
+    "@build_bazel_rules_swift//swift:repositories.bzl",
+    "swift_rules_dependencies",
+)
+
+swift_rules_dependencies()
+
+load(
+    "@build_bazel_rules_swift//swift:extras.bzl",
+    "swift_rules_extra_dependencies",
+)
+
+swift_rules_extra_dependencies()
+
+http_archive(
+    name = "io_bazel_rules_go",
+    sha256 = "16e9fca53ed6bd4ff4ad76facc9b7b651a89db1689a2877d6fd7b82aa824e366",
+    urls = [
+        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.34.0/rules_go-v0.34.0.zip",
+        "https://github.com/bazelbuild/rules_go/releases/download/v0.34.0/rules_go-v0.34.0.zip",
+    ],
+)
+
+load("@io_bazel_rules_go//go:deps.bzl", "go_rules_dependencies")
 
 go_rules_dependencies()
 
-go_register_toolchains()
-
 ##### Protobuf
 _PROTOBUF_VERSION = "3.15.2"
 
@@ -29,12 +56,12 @@ http_archive(
 )
 
 ##### GRPC
-_GRPC_VERSION = "1.42.0"
+_GRPC_VERSION = "1.48.0"  # https://github.com/grpc/grpc/releases/tag/v1.48.0
 
 http_archive(
     name = "com_github_grpc_grpc",
     strip_prefix = "grpc-" + _GRPC_VERSION,
-    urls = ["https://github.com/grpc/grpc/archive/v" + _GRPC_VERSION + ".tar.gz"],
+    urls = ["https://github.com/grpc/grpc/archive/refs/tags/v" + _GRPC_VERSION + ".tar.gz"],
 )
 
 load("@com_github_grpc_grpc//bazel:grpc_deps.bzl", "grpc_deps")
@@ -44,3 +71,28 @@ grpc_deps()
 load("@com_github_grpc_grpc//bazel:grpc_extra_deps.bzl", "grpc_extra_deps")
 
 grpc_extra_deps()
+
+# rules_go from https://github.com/bazelbuild/rules_go/releases/tag/v0.34.0
+http_archive(
+    name = "build_bazel_rules_nodejs",
+    sha256 = "965ee2492a2b087cf9e0f2ca472aeaf1be2eb650e0cfbddf514b9a7d3ea4b02a",
+    urls = ["https://github.com/bazelbuild/rules_nodejs/releases/download/5.2.0/rules_nodejs-5.2.0.tar.gz"],
+)
+
+load("@build_bazel_rules_nodejs//:repositories.bzl", "build_bazel_rules_nodejs_dependencies")
+
+build_bazel_rules_nodejs_dependencies()
+
+load("@build_bazel_rules_nodejs//:index.bzl", "node_repositories", "yarn_install")
+
+node_repositories()
+
+yarn_install(
+    name = "npm",
+    exports_directories_only = False,
+    # Unfreeze to add/remove packages.
+    frozen_lockfile = True,
+    package_json = "//:package.json",
+    symlink_node_modules = False,
+    yarn_lock = "//:yarn.lock",
+)

android/app/build.gradle

@@ -18,6 +18,10 @@ android {
       targetCompatibility JavaVersion.VERSION_1_8
     }
 
+    ndk {
+      abiFilters 'arm64-v8a', 'armeabi-v7a'
+    }
+    
     testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
     externalNativeBuild {
       cmake {
@@ -33,7 +37,6 @@ android {
     }
   }
 
-  ndkVersion "21.3.6528147"
   externalNativeBuild {
     cmake {
       path "src/main/cpp/CMakeLists.txt"
@@ -52,16 +55,17 @@ android {
     fbsFiles.forEach{
       commandLineArgs.add(it.path)
     }
+
     commandLine commandLineArgs
 
     doFirst {
       delete "$outputCppDir/"
       mkdir "$outputCppDir/"
     }
+
     doLast {
-      if (execResult.getExitValue() != 0) {
+      if (executionResult.get().exitValue != 0) {
-        println(standardOutput.toString())
+        throw new GradleException("flatc failed with: ${executionResult.get().toString()}")
-        throw new GradleException("flatc command line failed")
       }
     }
   }
@@ -74,6 +78,10 @@ android {
 
     standardOutput = new ByteArrayOutputStream()
     errorOutput = new ByteArrayOutputStream()
+
+    setErrorOutput(errorOutput)
+    setStandardOutput(standardOutput)
+
     def commandLineArgs = ['flatc', '-o', outputKotlinDir, '--kotlin']
     fbsFiles.forEach{
       commandLineArgs.add(it.path)
@@ -85,43 +93,42 @@ android {
       mkdir "$outputKotlinDir/"
     }
     doLast {
-      if (execResult.getExitValue() != 0) {
+      if (executionResult.get().exitValue != 0) {
-        println(standardOutput.toString())
+        throw new GradleException("flatc failed with: ${executionResult.get().toString()}")
-        throw new GradleException("flatc command line failed")
       }
     }
   }
 
   afterEvaluate {
-    android.applicationVariants.all { variant ->
+    tasks.named("preBuild") {
-      variant.javaCompiler.dependsOn(generateFbsKotlin)
+      dependsOn(generateFbsKotlin)
-      variant.javaCompiler.dependsOn(generateFbsCpp)
+      dependsOn(generateFbsCpp)
     }
   }
 
-  flavorDimensions "stl-variant"
+//  flavorDimensions "stl-variant"
-  productFlavors {
+//  productFlavors {
-    gnustl {
+//    gnustl {
-      dimension "stl-variant"
+//      dimension "stl-variant"
-      applicationIdSuffix ".gnustl"
+//      applicationIdSuffix ".gnustl"
-      versionNameSuffix "-gnustl"
+//      versionNameSuffix "-gnustl"
-      externalNativeBuild {
+//      externalNativeBuild {
-        ndkBuild {
+//        ndkBuild {
-          arguments "APP_STL=gnustl_static"
+//          arguments "APP_STL=gnustl_static"
-        }
+//        }
-      }
+//      }
-    }
+//    }
-    libcpp {
+//    libcpp {
-      dimension "stl-variant"
+//      dimension "stl-variant"
-      applicationIdSuffix ".libcpp"
+//      applicationIdSuffix ".libcpp"
-      versionNameSuffix "-libcpp"
+//      versionNameSuffix "-libcpp"
-      externalNativeBuild {
+//      externalNativeBuild {
-        ndkBuild {
+//        ndkBuild {
-          arguments "APP_STL=c++_static"
+//          arguments "APP_STL=c++_static"
-        }
+//        }
-      }
+//      }
-    }
+//    }
-  }
+//  }
 }
 
 dependencies {

android/app/src/main/cpp/flatbuffers/CMakeLists.txt

@@ -26,6 +26,7 @@ set(FlatBuffers_Library_SRCS
         ${FLATBUFFERS_SRC}/include/flatbuffers/flatbuffer_builder.h
         ${FLATBUFFERS_SRC}/include/flatbuffers/flatbuffers.h
         ${FLATBUFFERS_SRC}/include/flatbuffers/flexbuffers.h
+        ${FLATBUFFERS_SRC}/include/flatbuffers/flex_flat_util.h
         ${FLATBUFFERS_SRC}/include/flatbuffers/hash.h
         ${FLATBUFFERS_SRC}/include/flatbuffers/idl.h
         ${FLATBUFFERS_SRC}/include/flatbuffers/minireflect.h

android/app/src/main/cpp/generated/animal_generated.h

@@ -35,7 +35,7 @@ struct Animal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            verifier.VerifyString(name()) &&
            VerifyOffset(verifier, VT_SOUND) &&
            verifier.VerifyString(sound()) &&
-           VerifyField<uint16_t>(verifier, VT_WEIGHT) &&
+           VerifyField<uint16_t>(verifier, VT_WEIGHT, 2) &&
            verifier.EndTable();
   }
 };
@@ -57,7 +57,6 @@ struct AnimalBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  AnimalBuilder &operator=(const AnimalBuilder &);
   flatbuffers::Offset<Animal> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Animal>(end);

android/app/src/main/java/generated/com/fbs/app/Animal.kt

@@ -7,7 +7,6 @@ import kotlin.math.sign
 import com.google.flatbuffers.*
 
 @Suppress("unused")
-@ExperimentalUnsignedTypes
 class Animal : Table() {
 
     fun __init(_i: Int, _bb: ByteBuffer)  {

android/gradle.properties

@@ -19,3 +19,5 @@ android.useAndroidX=true
 android.enableJetifier=true
 # Kotlin code style for this project: "official" or "obsolete":
 kotlin.code.style=official
+# Use parallel builds
+org.gradle.parallel=true

android/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,5 @@
-#Thu Oct 29 19:47:23 CET 2020
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.5-all.zip

benchmarks/CMakeLists.txt

@@ -16,7 +16,7 @@ FetchContent_Declare(
 FetchContent_Declare(
     googlebenchmark
     GIT_REPOSITORY https://github.com/google/benchmark.git
-    GIT_TAG        f91b6b42b1b9854772a90ae9501464a161707d1e # v1.6.0
+    GIT_TAG        0d98dba29d66e93259db7daa53a9327df767a415 # v1.6.1
 )
 
 # For Windows: Prevent overriding the parent project's compiler/linker 
@@ -66,6 +66,12 @@ target_compile_features(flatbenchmark PUBLIC
     cxx_std_11
 )
 
+target_compile_options(flatbenchmark
+    PRIVATE
+        -fno-aligned-new
+        -Wno-deprecated-declarations
+)
+
 # Set the output directory to the root binary directory
 set_target_properties(flatbenchmark 
     PROPERTIES RUNTIME_OUTPUT_DIRECTORY 

benchmarks/cpp/flatbuffers/bench_generated.h

@@ -6,6 +6,13 @@
 
 #include "flatbuffers/flatbuffers.h"
 
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 2 &&
+              FLATBUFFERS_VERSION_MINOR == 0 &&
+              FLATBUFFERS_VERSION_REVISION == 6,
+             "Non-compatible flatbuffers version included");
+
 namespace benchmarks_flatbuffers {
 
 struct Foo;
@@ -157,11 +164,11 @@ struct FooBar FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<benchmarks_flatbuffers::Bar>(verifier, VT_SIBLING) &&
+           VerifyField<benchmarks_flatbuffers::Bar>(verifier, VT_SIBLING, 8) &&
            VerifyOffset(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
-           VerifyField<double>(verifier, VT_RATING) &&
+           VerifyField<double>(verifier, VT_RATING, 8) &&
-           VerifyField<uint8_t>(verifier, VT_POSTFIX) &&
+           VerifyField<uint8_t>(verifier, VT_POSTFIX, 1) &&
            verifier.EndTable();
   }
 };
@@ -247,8 +254,8 @@ struct FooBarContainer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            VerifyOffset(verifier, VT_LIST) &&
            verifier.VerifyVector(list()) &&
            verifier.VerifyVectorOfTables(list()) &&
-           VerifyField<uint8_t>(verifier, VT_INITIALIZED) &&
+           VerifyField<uint8_t>(verifier, VT_INITIALIZED, 1) &&
-           VerifyField<int16_t>(verifier, VT_FRUIT) &&
+           VerifyField<int16_t>(verifier, VT_FRUIT, 2) &&
            VerifyOffset(verifier, VT_LOCATION) &&
            verifier.VerifyString(location()) &&
            verifier.EndTable();

benchmarks/cpp/flatbuffers/fb_bench.cpp

@@ -16,7 +16,7 @@ struct FlatBufferBench : Bench {
   explicit FlatBufferBench(int64_t initial_size, Allocator *allocator)
       : fbb(initial_size, allocator, false) {}
 
-  uint8_t *Encode(void *, int64_t &len) {
+  uint8_t *Encode(void *, int64_t &len) override {
     fbb.Clear();
 
     const int kVectorLength = 3;
@@ -40,7 +40,7 @@ struct FlatBufferBench : Bench {
     return fbb.GetBufferPointer();
   }
 
-  int64_t Use(void *decoded) {
+  int64_t Use(void *decoded) override {
     sum = 0;
     auto foobarcontainer = GetFooBarContainer(decoded);
     sum = 0;
@@ -65,8 +65,8 @@ struct FlatBufferBench : Bench {
     return sum;
   }
 
-  void *Decode(void *buffer, int64_t) { return buffer; }
+  void *Decode(void *buffer, int64_t) override { return buffer; }
-  void Dealloc(void *) override{};
+  void Dealloc(void *) override {};
 
   FlatBufferBuilder fbb;
 };

benchmarks/cpp/raw/raw_bench.cpp

@@ -45,7 +45,7 @@ struct FooBarContainer {
 };
 
 struct RawBench : Bench {
-  uint8_t *Encode(void *buf, int64_t &len) {
+  uint8_t *Encode(void *buf, int64_t &len) override {
     FooBarContainer *fbc = new (buf) FooBarContainer;
     strcpy(fbc->location, "http://google.com/flatbuffers/");  // Unsafe eek!
     fbc->location_len = (int)strlen(fbc->location);
@@ -74,7 +74,7 @@ struct RawBench : Bench {
     return reinterpret_cast<uint8_t *>(fbc);
   };
 
-  int64_t Use(void *decoded) {
+  int64_t Use(void *decoded) override {
     auto foobarcontainer = reinterpret_cast<FooBarContainer *>(decoded);
     sum = 0;
     Add(foobarcontainer->initialized);
@@ -98,7 +98,7 @@ struct RawBench : Bench {
     return sum;
   }
 
-  void *Decode(void *buf, int64_t) { return buf; }
+  void *Decode(void *buf, int64_t) override { return buf; }
   void Dealloc(void *) override{};
 };
 

build_defs.bzl

@@ -13,6 +13,7 @@ DEFAULT_INCLUDE_PATHS = [
     "./",
     "$(GENDIR)",
     "$(BINDIR)",
+    "$(execpath @com_github_google_flatbuffers//:flatc).runfiles/com_github_google_flatbuffers",
 ]
 
 DEFAULT_FLATC_ARGS = [
@@ -37,6 +38,7 @@ def flatbuffer_library_public(
         reflection_visibility = None,
         compatible_with = None,
         restricted_to = None,
+        target_compatible_with = None,
         output_to_bindir = False):
     """Generates code files for reading/writing the given flatbuffers in the requested language using the public compiler.
 
@@ -58,6 +60,8 @@ def flatbuffer_library_public(
         built for, in addition to default-supported environments.
       restricted_to: Optional, The list of environments this rule can be built
         for, instead of default-supported environments.
+      target_compatible_with: Optional, The list of target platform constraints
+        to use.
       output_to_bindir: Passed to genrule for output to bin directory.
 
 
@@ -92,6 +96,7 @@ def flatbuffer_library_public(
         tools = [flatc_path],
         cmd = genrule_cmd,
         compatible_with = compatible_with,
+        target_compatible_with = target_compatible_with,
         restricted_to = restricted_to,
         message = "Generating flatbuffer files for %s:" % (name),
     )
@@ -120,8 +125,10 @@ def flatbuffer_library_public(
             tools = [flatc_path],
             compatible_with = compatible_with,
             restricted_to = restricted_to,
+            target_compatible_with = target_compatible_with,
             cmd = reflection_genrule_cmd,
             message = "Generating flatbuffer reflection binary for %s:" % (name),
+            visibility = reflection_visibility,
         )
         native.filegroup(
             name = "%s_out" % reflection_name,
@@ -136,15 +143,18 @@ def flatbuffer_cc_library(
         srcs,
         srcs_filegroup_name = "",
         out_prefix = "",
+        deps = [],
         includes = [],
         include_paths = DEFAULT_INCLUDE_PATHS,
+        cc_include_paths = [],
         flatc_args = DEFAULT_FLATC_ARGS,
         visibility = None,
         compatible_with = None,
         restricted_to = None,
+        target_compatible_with = None,
         srcs_filegroup_visibility = None,
         gen_reflections = False):
-    '''A cc_library with the generated reader/writers for the given flatbuffer definitions.
+    """A cc_library with the generated reader/writers for the given flatbuffer definitions.
 
     Args:
       name: Rule name.
@@ -154,9 +164,12 @@ def flatbuffer_cc_library(
           flatbuffer_cc_library that depends on this one's schemas.
       out_prefix: Prepend this path to the front of all generated files. Usually
           is a directory name.
+      deps: Optional, list of other flatbuffer_cc_library's to depend on. Cannot be specified
+          alongside includes.
       includes: Optional, list of filegroups of schemas that the srcs depend on.
-          ** SEE REMARKS BELOW **
+          Use of this is discouraged, and may be deprecated.
       include_paths: Optional, list of paths the includes files can be found in.
+      cc_include_paths: Optional, list of paths to add to the cc_library includes attribute.
       flatc_args: Optional list of additional arguments to pass to flatc
           (e.g. --gen-mutable).
       visibility: The visibility of the generated cc_library. By default, use the
@@ -169,6 +182,8 @@ def flatbuffer_cc_library(
         for, in addition to default-supported environments.
       restricted_to: Optional, The list of environments this rule can be built
         for, instead of default-supported environments.
+      target_compatible_with: Optional, The list of target platform constraints
+        to use.
 
     This produces:
       filegroup([name]_srcs): all generated .h files.
@@ -177,41 +192,17 @@ def flatbuffer_cc_library(
           parameter, if they depend on the schemas in this library.
       Fileset([name]_reflection): (Optional) all generated reflection binaries.
       cc_library([name]): library with sources and flatbuffers deps.
-
+    """
-    Remarks:
-      ** Because the genrule used to call flatc does not have any trivial way of
-        computing the output list of files transitively generated by includes and
-        --gen-includes (the default) being defined for flatc, the --gen-includes
-        flag will not work as expected. The way around this is to add a dependency
-        to the flatbuffer_cc_library defined alongside the flatc included Fileset.
-        For example you might define:
-
-        flatbuffer_cc_library(
-            name = "my_fbs",
-            srcs = [ "schemas/foo.fbs" ],
-            includes = [ "//third_party/bazz:bazz_fbs_includes" ],
-        )
-
-        In which foo.fbs includes a few files from the Fileset defined at
-        //third_party/bazz:bazz_fbs_includes. When compiling the library that
-        includes foo_generated.h, and therefore has my_fbs as a dependency, it
-        will fail to find any of the bazz *_generated.h files unless you also
-        add bazz's flatbuffer_cc_library to your own dependency list, e.g.:
-
-        cc_library(
-            name = "my_lib",
-            deps = [
-                ":my_fbs",
-                "//third_party/bazz:bazz_fbs"
-            ],
-        )
-
-        Happy dependent Flatbuffering!
-    '''
     output_headers = [
         (out_prefix + "%s_generated.h") % (s.replace(".fbs", "").split("/")[-1].split(":")[-1])
         for s in srcs
     ]
+    if deps and includes:
+        # There is no inherent reason we couldn't support both, but this discourages
+        # use of includes without good reason.
+        fail("Cannot specify both deps and include in flatbuffer_cc_library.")
+    if deps:
+        includes = [d + "_includes" for d in deps]
     reflection_name = "%s_reflection" % name if gen_reflections else ""
 
     srcs_lib = "%s_srcs" % (name)
@@ -226,6 +217,7 @@ def flatbuffer_cc_library(
         flatc_args = flatc_args,
         compatible_with = compatible_with,
         restricted_to = restricted_to,
+        target_compatible_with = target_compatible_with,
         reflection_name = reflection_name,
         reflection_visibility = visibility,
     )
@@ -242,10 +234,12 @@ def flatbuffer_cc_library(
         ],
         deps = [
             "@com_github_google_flatbuffers//:runtime_cc",
-        ],
+            "@com_github_google_flatbuffers//:flatbuffers",
-        includes = [],
+        ] + deps,
+        includes = cc_include_paths,
         compatible_with = compatible_with,
         restricted_to = restricted_to,
+        target_compatible_with = target_compatible_with,
         linkstatic = 1,
         visibility = visibility,
     )
@@ -254,7 +248,7 @@ def flatbuffer_cc_library(
     # Flatbuffer set.
     native.filegroup(
         name = srcs_filegroup_name if srcs_filegroup_name else "%s_includes" % (name),
-        srcs = srcs,
+        srcs = srcs + includes,
         compatible_with = compatible_with,
         restricted_to = restricted_to,
         visibility = srcs_filegroup_visibility if srcs_filegroup_visibility != None else visibility,

conan/CMakeLists.txt

@@ -5,8 +5,8 @@ message(STATUS "Conan FlatBuffers Wrapper")
 include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
 conan_basic_setup()
 
-if (WIN32 AND MSVC AND FLATBUFFERS_BUILD_SHAREDLIB)
+if (WIN32 AND MSVC_LIKE AND FLATBUFFERS_BUILD_SHAREDLIB)
     set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
-endif(WIN32 AND MSVC AND FLATBUFFERS_BUILD_SHAREDLIB)
+endif(WIN32 AND MSVC_LIKE AND FLATBUFFERS_BUILD_SHAREDLIB)
 
 include(${CMAKE_SOURCE_DIR}/CMakeListsOriginal.txt)

dart/lib/flat_buffers.dart

@@ -1,7 +1,3 @@
-// Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:math';
@@ -401,6 +397,15 @@ class Builder {
     _setFloat32AtTail(_tail, value);
   }
 
+  /// Writes a bool to the tail of the buffer after preparing space for it.
+  /// Bools are represented as a Uint8, with the value set to '1' for true, and '0' for false
+  ///
+  /// Updates the [offset] pointer.  This method is intended for use when writing structs to the buffer.
+  void putBool(bool value) {
+    _prepare(_sizeofUint8, 1);
+    _buf.setInt8(_buf.lengthInBytes - _tail, value ? 1 : 0);
+  }
+
   /// Writes a Int64 to the tail of the buffer after preparing space for it.
   ///
   /// Updates the [offset] pointer.  This method is intended for use when writing structs to the buffer.

dart/test/bool_structs.fbs

@@ -0,0 +1,10 @@
+// Test for #7355
+table Foo {
+  my_foo : foo_properties;
+}
+
+struct foo_properties
+{
+    a : bool;
+    b : bool;
+}

dart/test/flat_buffers_test.dart

@@ -1,7 +1,3 @@
-// Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
 import 'dart:typed_data';
 import 'dart:io' as io;
 
@@ -13,6 +9,9 @@ import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import './monster_test_my_game.example_generated.dart' as example;
 import './monster_test_my_game.example2_generated.dart' as example2;
+import './list_of_enums_generated.dart' as example3;
+import './bool_structs_generated.dart' as example4;
+import './keyword_test_keyword_test_generated.dart' as keyword_test;
 
 main() {
   defineReflectiveSuite(() {
@@ -20,6 +19,7 @@ main() {
     defineReflectiveTests(ObjectAPITest);
     defineReflectiveTests(CheckOtherLangaugesData);
     defineReflectiveTests(GeneratorTest);
+    defineReflectiveTests(ListOfEnumsTest);
   });
 }
 
@@ -85,7 +85,9 @@ class CheckOtherLangaugesData {
       'anyUniqueType: null, anyUnique: null, anyAmbiguousType: null, '
       'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race{value: -1}, '
       'testrequirednestedflatbuffer: null, scalarKeySortedTables: null, '
-      'nativeInline: null}, '
+      'nativeInline: null, '
+      'longEnumNonEnumDefault: LongEnum{value: 0}, '
+      'longEnumNormalDefault: LongEnum{value: 2}}, '
       'test4: [Test{a: 10, b: 20}, Test{a: 30, b: 40}], '
       'testarrayofstring: [test1, test2], testarrayoftables: null, '
       'enemy: Monster{pos: null, mana: 150, hp: 100, name: Fred, '
@@ -106,7 +108,9 @@ class CheckOtherLangaugesData {
       'anyUniqueType: null, anyUnique: null, anyAmbiguousType: null, '
       'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race{value: -1}, '
       'testrequirednestedflatbuffer: null, scalarKeySortedTables: null, '
-      'nativeInline: null}, '
+      'nativeInline: null, '
+      'longEnumNonEnumDefault: LongEnum{value: 0}, '
+      'longEnumNormalDefault: LongEnum{value: 2}}, '
       'testnestedflatbuffer: null, testempty: null, testbool: true, '
       'testhashs32Fnv1: -579221183, testhashu32Fnv1: 3715746113, '
       'testhashs64Fnv1: 7930699090847568257, '
@@ -131,7 +135,9 @@ class CheckOtherLangaugesData {
       'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race{value: -1}, '
       'testrequirednestedflatbuffer: null, scalarKeySortedTables: [Stat{id: '
       'miss, val: 0, count: 0}, Stat{id: hit, val: 10, count: 1}], '
-      'nativeInline: Test{a: 1, b: 2}}',
+      'nativeInline: Test{a: 1, b: 2}, '
+      'longEnumNonEnumDefault: LongEnum{value: 0}, '
+      'longEnumNormalDefault: LongEnum{value: 2}}',
     );
   }
 }
@@ -896,3 +902,32 @@ class GeneratorTest {
         same(example.AnyAmbiguousAliasesTypeId.values));
   }
 }
+
+// See #6869
+@reflectiveTest
+class ListOfEnumsTest {
+  void test_listOfEnums() async {
+    var mytable = example3.MyTableObjectBuilder(options: [
+      example3.OptionsEnum.A,
+      example3.OptionsEnum.B,
+      example3.OptionsEnum.C
+    ]);
+    var bytes = mytable.toBytes();
+    var mytable_read = example3.MyTable(bytes);
+    expect(mytable_read.options![0].value, example3.OptionsEnum.A.value);
+    expect(mytable_read.options![1].value, example3.OptionsEnum.B.value);
+    expect(mytable_read.options![2].value, example3.OptionsEnum.C.value);
+  }
+}
+
+@reflectiveTest
+class BoolInStructTest {
+  void test_boolInStruct() async {
+    var mystruct = example4.FooObjectBuilder(
+        myFoo: example4.FooPropertiesObjectBuilder(a: true, b: false));
+    var bytes = mystruct.toBytes();
+    var mystruct_read = example4.Foo(bytes);
+    expect(mystruct_read.myFoo!.a, true);
+    expect(mystruct_read.myFoo!.b, false);
+  }
+}

dart/test/keyword_test_keyword_test_generated.dart

@@ -0,0 +1,280 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable
+
+library keyword_test;
+
+import 'dart:typed_data' show Uint8List;
+import 'package:flat_buffers/flat_buffers.dart' as fb;
+
+
+class Abc {
+  final int value;
+  const Abc._(this.value);
+
+  factory Abc.fromValue(int value) {
+    final result = values[value];
+    if (result == null) {
+        throw StateError('Invalid value $value for bit flag enum Abc');
+    }
+    return result;
+  }
+
+  static Abc? _createOrNull(int? value) => 
+      value == null ? null : Abc.fromValue(value);
+
+  static const int minValue = 0;
+  static const int maxValue = 2;
+  static bool containsValue(int value) => values.containsKey(value);
+
+  static const Abc $void = Abc._(0);
+  static const Abc where = Abc._(1);
+  static const Abc stackalloc = Abc._(2);
+  static const Map<int, Abc> values = {
+    0: $void,
+    1: where,
+    2: stackalloc};
+
+  static const fb.Reader<Abc> reader = _AbcReader();
+
+  @override
+  String toString() {
+    return 'Abc{value: $value}';
+  }
+}
+
+class _AbcReader extends fb.Reader<Abc> {
+  const _AbcReader();
+
+  @override
+  int get size => 4;
+
+  @override
+  Abc read(fb.BufferContext bc, int offset) =>
+      Abc.fromValue(const fb.Int32Reader().read(bc, offset));
+}
+
+class Public {
+  final int value;
+  const Public._(this.value);
+
+  factory Public.fromValue(int value) {
+    final result = values[value];
+    if (result == null) {
+        throw StateError('Invalid value $value for bit flag enum Public');
+    }
+    return result;
+  }
+
+  static Public? _createOrNull(int? value) => 
+      value == null ? null : Public.fromValue(value);
+
+  static const int minValue = 0;
+  static const int maxValue = 0;
+  static bool containsValue(int value) => values.containsKey(value);
+
+  static const Public NONE = Public._(0);
+  static const Map<int, Public> values = {
+    0: NONE};
+
+  static const fb.Reader<Public> reader = _PublicReader();
+
+  @override
+  String toString() {
+    return 'Public{value: $value}';
+  }
+}
+
+class _PublicReader extends fb.Reader<Public> {
+  const _PublicReader();
+
+  @override
+  int get size => 4;
+
+  @override
+  Public read(fb.BufferContext bc, int offset) =>
+      Public.fromValue(const fb.Int32Reader().read(bc, offset));
+}
+
+class KeywordsInUnionTypeId {
+  final int value;
+  const KeywordsInUnionTypeId._(this.value);
+
+  factory KeywordsInUnionTypeId.fromValue(int value) {
+    final result = values[value];
+    if (result == null) {
+        throw StateError('Invalid value $value for bit flag enum KeywordsInUnionTypeId');
+    }
+    return result;
+  }
+
+  static KeywordsInUnionTypeId? _createOrNull(int? value) => 
+      value == null ? null : KeywordsInUnionTypeId.fromValue(value);
+
+  static const int minValue = 0;
+  static const int maxValue = 2;
+  static bool containsValue(int value) => values.containsKey(value);
+
+  static const KeywordsInUnionTypeId NONE = KeywordsInUnionTypeId._(0);
+  static const KeywordsInUnionTypeId $static = KeywordsInUnionTypeId._(1);
+  static const KeywordsInUnionTypeId internal = KeywordsInUnionTypeId._(2);
+  static const Map<int, KeywordsInUnionTypeId> values = {
+    0: NONE,
+    1: $static,
+    2: internal};
+
+  static const fb.Reader<KeywordsInUnionTypeId> reader = _KeywordsInUnionTypeIdReader();
+
+  @override
+  String toString() {
+    return 'KeywordsInUnionTypeId{value: $value}';
+  }
+}
+
+class _KeywordsInUnionTypeIdReader extends fb.Reader<KeywordsInUnionTypeId> {
+  const _KeywordsInUnionTypeIdReader();
+
+  @override
+  int get size => 1;
+
+  @override
+  KeywordsInUnionTypeId read(fb.BufferContext bc, int offset) =>
+      KeywordsInUnionTypeId.fromValue(const fb.Uint8Reader().read(bc, offset));
+}
+
+class KeywordsInTable {
+  KeywordsInTable._(this._bc, this._bcOffset);
+  factory KeywordsInTable(List<int> bytes) {
+    final rootRef = fb.BufferContext.fromBytes(bytes);
+    return reader.read(rootRef, 0);
+  }
+
+  static const fb.Reader<KeywordsInTable> reader = _KeywordsInTableReader();
+
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  Abc get $is => Abc.fromValue(const fb.Int32Reader().vTableGet(_bc, _bcOffset, 4, 0));
+  Public get private => Public.fromValue(const fb.Int32Reader().vTableGet(_bc, _bcOffset, 6, 0));
+  int get type => const fb.Int32Reader().vTableGet(_bc, _bcOffset, 8, 0);
+  bool get $default => const fb.BoolReader().vTableGet(_bc, _bcOffset, 10, false);
+
+  @override
+  String toString() {
+    return 'KeywordsInTable{\$is: ${$is}, private: ${private}, type: ${type}, \$default: ${$default}}';
+  }
+
+  KeywordsInTableT unpack() => KeywordsInTableT(
+      $is: $is,
+      private: private,
+      type: type,
+      $default: $default);
+
+  static int pack(fb.Builder fbBuilder, KeywordsInTableT? object) {
+    if (object == null) return 0;
+    return object.pack(fbBuilder);
+  }
+}
+
+class KeywordsInTableT implements fb.Packable {
+  Abc $is;
+  Public private;
+  int type;
+  bool $default;
+
+  KeywordsInTableT({
+      this.$is = Abc.$void,
+      this.private = Public.NONE,
+      this.type = 0,
+      this.$default = false});
+
+  @override
+  int pack(fb.Builder fbBuilder) {
+    fbBuilder.startTable(4);
+    fbBuilder.addInt32(0, $is.value);
+    fbBuilder.addInt32(1, private.value);
+    fbBuilder.addInt32(2, type);
+    fbBuilder.addBool(3, $default);
+    return fbBuilder.endTable();
+  }
+
+  @override
+  String toString() {
+    return 'KeywordsInTableT{\$is: ${$is}, private: ${private}, type: ${type}, \$default: ${$default}}';
+  }
+}
+
+class _KeywordsInTableReader extends fb.TableReader<KeywordsInTable> {
+  const _KeywordsInTableReader();
+
+  @override
+  KeywordsInTable createObject(fb.BufferContext bc, int offset) => 
+    KeywordsInTable._(bc, offset);
+}
+
+class KeywordsInTableBuilder {
+  KeywordsInTableBuilder(this.fbBuilder);
+
+  final fb.Builder fbBuilder;
+
+  void begin() {
+    fbBuilder.startTable(4);
+  }
+
+  int addIs(Abc? $is) {
+    fbBuilder.addInt32(0, $is?.value);
+    return fbBuilder.offset;
+  }
+  int addPrivate(Public? private) {
+    fbBuilder.addInt32(1, private?.value);
+    return fbBuilder.offset;
+  }
+  int addType(int? type) {
+    fbBuilder.addInt32(2, type);
+    return fbBuilder.offset;
+  }
+  int addDefault(bool? $default) {
+    fbBuilder.addBool(3, $default);
+    return fbBuilder.offset;
+  }
+
+  int finish() {
+    return fbBuilder.endTable();
+  }
+}
+
+class KeywordsInTableObjectBuilder extends fb.ObjectBuilder {
+  final Abc? _$is;
+  final Public? _private;
+  final int? _type;
+  final bool? _$default;
+
+  KeywordsInTableObjectBuilder({
+    Abc? $is,
+    Public? private,
+    int? type,
+    bool? $default,
+  })
+      : _$is = $is,
+        _private = private,
+        _type = type,
+        _$default = $default;
+
+  /// Finish building, and store into the [fbBuilder].
+  @override
+  int finish(fb.Builder fbBuilder) {
+    fbBuilder.startTable(4);
+    fbBuilder.addInt32(0, _$is?.value);
+    fbBuilder.addInt32(1, _private?.value);
+    fbBuilder.addInt32(2, _type);
+    fbBuilder.addBool(3, _$default);
+    return fbBuilder.endTable();
+  }
+
+  /// Convenience method to serialize to byte list.
+  @override
+  Uint8List toBytes([String? fileIdentifier]) {
+    final fbBuilder = fb.Builder(deduplicateTables: false);
+    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
+    return fbBuilder.buffer;
+  }
+}

dart/test/list_of_enums.fbs

@@ -0,0 +1,10 @@
+enum OptionsEnum : uint32
+{
+    A = 1,
+    B = 2,
+    C = 3
+}
+
+table MyTable {
+    options : [OptionsEnum];
+}

docs/source/Building.md

@@ -31,24 +31,22 @@ run 'flattests' or `flatsampletext`, or it will fail to load its files.*
 
 ### Make all warnings into errors
 
-By default all Flatbuffers `cmake` targets are build with `-Werror` flag.
+By default all Flatbuffers `cmake` targets are **not** built with the `-Werror` 
-With this flag (or `/WX` for MSVC) C++ compiler will treat all warnings as errors.
+(or `/WX` for MSVC) flag that treats any warning as an error. This allows more 
-Additionally `-Wall -pedantic -Wextra` (or `/W4` form MSVC) flags are set.
+flexibility for users of Flatbuffers to use newer compilers and toolsets that
-These flags minimize the number of possible defects in code and keep code highly portable.
+may add new warnings that would cause a build failure.
-Using these flags is considered good practice but sometimes it can break dependent projects 
-if a compiler is upgraded or a toolset is changed.
-Usually, newer compiler versions add new compile-time diagnostics that were unavailable before.
-These new diagnostic warnings could stop the build process if `-Werror` flag is set.
 
-It is possible to cancel `warnings as errors` flag at `cmake` configuration stage using 
+To enable a stricter build that does treat warnings as errors, set the
-`FLATBUFFERS_CXX_FLAGS` option. Compilation flags declared in `FLATBUFFERS_CXX_FLAGS` will be 
+`FLATBUFFERS_STRICT_MODE` `cmake` compliation flag to `ON`. 
-appended to the project-level `CMAKE_CXX_FLAGS` variable.
-Examples:
 
-- GCC and Clang: `cmake . -D FLATBUFFERS_CXX_FLAGS="-Wno-error"`
+```
-- MSVC: `cmake . -D FLATBUFFERS_CXX_FLAGS="/WX-"`
+cmake . -DFLATBUFFERS_STRICT_MODE=ON
-- MSVC: `cmake . -D FLATBUFFERS_CXX_FLAGS="/Wv <compiler.version>"`
+```
 
+Our CI builds run with strict mode on, ensuring the code that is committed to 
+the project is as portable and warning free as possible. Thus developers
+contributing to the project should enable strict mode locally before making a 
+PR.
 
 ## Building with VCPKG
 
@@ -63,6 +61,18 @@ You can download and install flatbuffers using the [vcpkg](https://github.com/Mi
 The flatbuffers port in vcpkg is kept up to date by Microsoft team members and community contributors.
 If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
 
+## Downloading binaries
+You can download the binaries from the
+[GitHub release page](https://github.com/google/flatbuffers/releases).
+
+We generate [SLSA3 signatures](slsa.dev) using the OpenSSF's [slsa-framework/slsa-github-generator](https://github.com/slsa-framework/slsa-github-generator). To verify the binaries:
+1. Install the verification tool from [slsa-framework/slsa-verifier#installation](https://github.com/slsa-framework/slsa-verifier#installation)
+1. Download the file named `attestation.intoto.jsonl` from the GitHub release
+1. Run:
+```shell
+$ slsa-verifier -artifact-path <downloaded.zip> -provenance attestation.intoto.jsonl -source github.com/google/flatbuffers -tag <version>
+  PASSED: Verified SLSA provenance
+
 ## Building for Android
 
 There is a `flatbuffers/android` directory that contains all you need to build

docs/source/GoUsage.md

@@ -52,10 +52,10 @@ a `[]byte`, which you pass to the `GetRootAsMonster` function:
        example "MyGame/Example"
        flatbuffers "github.com/google/flatbuffers/go"
 
-       io/ioutil
+       "os"
     )
 
-    buf, err := ioutil.ReadFile("monster.dat")
+    buf, err := os.ReadFile("monster.dat")
     // handle err
     monster := example.GetRootAsMonster(buf, 0)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

docs/source/RustUsage.md

@@ -58,7 +58,7 @@ and the generated code to read or write FlatBuffers.
 
 For example, here is how you would read a FlatBuffer binary file in Rust:
 First, include the library and generated code. Then read the file into
-a `u8` vector, which you pass, as a byte slice, to `get_root_as_monster()`.
+a `u8` vector, which you pass, as a byte slice, to `root_as_monster()`.
 
 This full example program is available in the Rust test suite:
 [monster_example.rs](https://github.com/google/flatbuffers/blob/master/tests/rust_usage_test/bin/monster_example.rs)
@@ -80,7 +80,7 @@ It can be run by `cd`ing to the `rust_usage_test` directory and executing: `carg
         let mut buf = Vec::new();
         f.read_to_end(&mut buf).expect("file reading failed");
 
-        let monster = my_game::example::get_root_as_monster(&buf[..]);
+        let monster = my_game::example::root_as_monster(&buf[..]);
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 `monster` is of type `Monster`, and points to somewhere *inside* your
@@ -108,7 +108,7 @@ the layout of things is generally not known to the user.
 For structs, layout is deterministic and guaranteed to be the same
 across platforms (scalars are aligned to their
 own size, and structs themselves to their largest member), and you
-are allowed to access this memory directly by using `safe_slice` and
+are allowed to access this memory directly by using `safe_slice`
 on the reference to a struct, or even an array of structs.
 
 To compute offsets to sub-elements of a struct, make sure they
@@ -118,9 +118,10 @@ handy for use of arrays of structs with calls like `glVertexAttribPointer`
 in OpenGL or similar APIs.
 
 It is important to note is that structs are still little endian on all
-machines, so only use tricks like this if you can guarantee you're not
+machines, so the functions to enable tricks like this are only exposed on little
-shipping on a big endian machine (using an `#[cfg(target_endian = "little")]`
+endian machines. If you also ship on big endian machines, using an
-attribute would be wise).
+`#[cfg(target_endian = "little")]` attribute would be wise or your code will not
+compile.
 
 The special function `safe_slice` is implemented on Vector objects that are
 represented in memory the same way as they are represented on the wire. This
@@ -134,22 +135,22 @@ of `safe_slice`.
 
 ## Access of untrusted buffers
 
+The safe Rust functions to interpret a slice as a table (`root`,
+`size_prefixed_root`, `root_with_opts`, and `size_prefixed_root_with_opts`)
+verify the data first. This has some performance cost, but is intended to be
+safe for use on flatbuffers from untrusted sources. There are corresponding
+`unsafe` versions with names ending in `_unchecked` which skip this
+verification, and may access arbitrary memory.
+
 The generated accessor functions access fields over offsets, which is
-very quick. These offsets are used to index into Rust slices, so they are
+very quick. The current implementation uses these to access memory without any
-bounds-checked by the Rust runtime. However, our Rust implementation may
+further bounds checking. All of the safe Rust APIs ensure the verifier is run
-change: we may convert access functions to use direct pointer dereferencing, to
+over these flatbuffers before accessing them.
-improve lookup speed. As a result, users should not rely on the aforementioned
-bounds-checking behavior.
 
 When you're processing large amounts of data from a source you know (e.g.
-your own generated data on disk), this is acceptable, but when reading
+your own generated data on disk), the `_unchecked` versions are acceptable, but
-data from the network that can potentially have been modified by an
+when reading data from the network that can potentially have been modified by an
-attacker, this is undesirable.
+attacker, it is desirable to use the safe versions which use the verifier.
-
-The C++ port provides a buffer verifier. At this time, Rust does not. Rust may
-provide a verifier in a future version. In the meantime, Rust users can access
-the buffer verifier generated by the C++ port through a foreign function
-interface (FFI).
 
 ## Threading
 
@@ -165,6 +166,17 @@ manually wrap it in synchronisation primitives. There's no automatic way to
 accomplish this, by design, as we feel multithreaded construction
 of a single buffer will be rare, and synchronisation overhead would be costly.
 
+Unlike most other languages, in Rust these properties are exposed to and
+enforced by the type system. `flatbuffers::Table` and the generated table types
+are `Send + Sync`, indicating they may be freely shared across threads and data
+may be accessed from any thread which receives a const (aka shared) reference.
+There are no functions which require a mutable (aka exclusive) reference, which
+means all the available functions may be called like this.
+`flatbuffers::FlatBufferBuilder` is also `Send + Sync`, but all of the mutating
+functions require a mutable (aka exclusive) reference which can only be created
+when no other references to the `FlatBufferBuilder` exist, and may not be copied
+within the same thread, let alone to a second thread.
+
 ## Useful tools created by others
 
 * [flatc-rust](https://github.com/frol/flatc-rust) - FlatBuffers compiler

docs/source/TypeScriptUsage.md

@@ -21,8 +21,8 @@ https://www.npmjs.com/package/flatbuffers.
 
 ## Testing the FlatBuffers TypeScript library
 
-To run the tests, use the [TypeScriptTest.sh](https://github.com/google/
+To run the tests, use the [TypeScriptTest.py](https://github.com/google/
-flatbuffers/blob/master/tests/TypeScriptTest.sh) shell script.
+flatbuffers/blob/master/tests/TypeScriptTest.py) Python3 script.
 
 *Note: The TypeScript test file requires [Node.js](https://nodejs.org/en/).*
 

docs/source/WhitePaper.md

@@ -64,7 +64,7 @@ through a *vtable*. Each table comes with a vtable (which may be shared
 between multiple tables with the same layout), and contains information
 where fields for this particular kind of instance of vtable are stored.
 The vtable may also indicate that the field is not present (because this
-FlatBuffer was written with an older version of the software, of simply
+FlatBuffer was written with an older version of the software, or simply
 because the information was not necessary for this instance, or deemed
 deprecated), in which case a default value is returned.
 

grpc/examples/generate.sh

@@ -1,71 +0,0 @@
-#!/bin/bash
-#
-# Copyright 2021 Google Inc. All rights reserved.
-#
-# Licensed 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.
-
-set -e
-
-current_dir=`pwd`
-
-cd ../..
-
-main_dir=`pwd`
-
-cd ${current_dir}
-
-# Looks for flatc within the root dir & debug
-if [ -e ${main_dir}/flatc ]; then
-  alias fbc='${main_dir}/flatc'
-elif [ -e ${main_dir}/Debug/flatc ]; then
-  alias fbc='${main_dir}/Debug/flatc'
-else
-  echo 'flatc' could not be found. Make sure to build FlatBuffers from the \
-       $rootdir directory.
-  exit 1
-fi
-
-generator="--grpc $current_dir/greeter.fbs"
-
-# Regenerate Go lang code
-cd go
-
-cd greeter
-fbc --bfbs-filenames ../.. --go ${generator}
-
-cd ${current_dir}
-
-# Regenerate Python code
-cd python
-
-cd greeter
-
-fbc --bfbs-filenames ../.. --python ${generator}
-
-cd ${current_dir}
-
-# Regenerate Swift code
-cd swift
-
-cd Greeter/Sources/Model
-fbc --bfbs-filenames ../../../.. --swift --gen-json-emit ${generator}
-
-cd ${current_dir}
-
-# Regenerate Typescript code
-cd ts
-
-cd greeter/src
-fbc --bfbs-filenames ../../.. --ts ${generator}
-
-cd ${current_dir}

grpc/examples/go/greeter/client/main.go

@@ -9,8 +9,10 @@ import (
 	"time"
 
 	flatbuffers "github.com/google/flatbuffers/go"
-	models "github.com/google/flatbuffers/grpc/examples/go/greeter/models"
 	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+
+	models "github.com/google/flatbuffers/grpc/examples/go/greeter/models"
 )
 
 var (
@@ -63,7 +65,9 @@ func printSayManyHello(client models.GreeterClient, name string) {
 
 func main() {
 	flag.Parse()
-	conn, err := grpc.Dial(fmt.Sprintf("localhost:%d", 3000), grpc.WithInsecure(), grpc.WithCodec(flatbuffers.FlatbuffersCodec{}))
+	conn, err := grpc.Dial(fmt.Sprintf("localhost:%d", 3000),
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithDefaultCallOptions(grpc.ForceCodec(flatbuffers.FlatbuffersCodec{})))
 	if err != nil {
 		log.Fatalf("fail to dial: %v", err)
 	}

grpc/examples/ts/greeter/src/greeter_generated.ts

@@ -0,0 +1,4 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+export { HelloReply } from './models/hello-reply';
+export { HelloRequest } from './models/hello-request';

grpc/examples/ts/greeter/src/models/hello-reply.ts

@@ -7,7 +7,7 @@ import * as flatbuffers from 'flatbuffers';
 export class HelloReply {
   bb: flatbuffers.ByteBuffer|null = null;
   bb_pos = 0;
-__init(i:number, bb:flatbuffers.ByteBuffer):HelloReply {
+  __init(i:number, bb:flatbuffers.ByteBuffer):HelloReply {
   this.bb_pos = i;
   this.bb = bb;
   return this;

grpc/examples/ts/greeter/src/models/hello-request.ts

@@ -7,7 +7,7 @@ import * as flatbuffers from 'flatbuffers';
 export class HelloRequest {
   bb: flatbuffers.ByteBuffer|null = null;
   bb_pos = 0;
-__init(i:number, bb:flatbuffers.ByteBuffer):HelloRequest {
+  __init(i:number, bb:flatbuffers.ByteBuffer):HelloRequest {
   this.bb_pos = i;
   this.bb = bb;
   return this;

grpc/src/compiler/cpp_generator.cc

@@ -8,24 +8,24 @@
 namespace grpc_cpp_generator {
 namespace {
 
-grpc::string message_header_ext() { return "_generated.h"; }
+static grpc::string service_header_ext() { return ".grpc.fb.h"; }
-grpc::string service_header_ext() { return ".grpc.fb.h"; }
 
-template<class T> grpc::string as_string(T x) {
+template<class T>
+static grpc::string as_string(T x) {
   std::ostringstream out;
   out << x;
   return out.str();
 }
 
-inline bool ClientOnlyStreaming(const grpc_generator::Method *method) {
+static inline bool ClientOnlyStreaming(const grpc_generator::Method *method) {
   return method->ClientStreaming() && !method->ServerStreaming();
 }
 
-inline bool ServerOnlyStreaming(const grpc_generator::Method *method) {
+static inline bool ServerOnlyStreaming(const grpc_generator::Method *method) {
   return !method->ClientStreaming() && method->ServerStreaming();
 }
 
-grpc::string FilenameIdentifier(const grpc::string &filename) {
+static grpc::string FilenameIdentifier(const grpc::string &filename) {
   grpc::string result;
   for (unsigned i = 0; i < filename.size(); i++) {
     char c = filename[i];
@@ -40,11 +40,11 @@ grpc::string FilenameIdentifier(const grpc::string &filename) {
   }
   return result;
 }
-}  // namespace
 
-template<class T, size_t N> T *array_end(T (&array)[N]) { return array + N; }
+template<class T, size_t N>
+static T *array_end(T (&array)[N]) { return array + N; }
 
-void PrintIncludes(grpc_generator::Printer *printer,
+static void PrintIncludes(grpc_generator::Printer *printer,
                    const std::vector<grpc::string> &headers,
                    const Parameters &params) {
   std::map<grpc::string, grpc::string> vars;
@@ -64,8 +64,10 @@ void PrintIncludes(grpc_generator::Printer *printer,
   }
 }
 
+}  // namespace
+
 grpc::string GetHeaderPrologue(grpc_generator::File *file,
-                               const Parameters & /*params*/) {
+                               const Parameters &params) {
   grpc::string output;
   {
     // Scope the output stream so it closes and finalizes output to the string.
@@ -75,7 +77,7 @@ grpc::string GetHeaderPrologue(grpc_generator::File *file,
     vars["filename"] = file->filename();
     vars["filename_identifier"] = FilenameIdentifier(file->filename());
     vars["filename_base"] = file->filename_without_ext();
-    vars["message_header_ext"] = file->message_header_ext();
+    vars["message_header_ext"] = params.message_header_extension;
 
     printer->Print(vars, "// Generated by the gRPC C++ plugin.\n");
     printer->Print(vars,
@@ -138,7 +140,10 @@ grpc::string GetHeaderIncludes(grpc_generator::File *file,
   return output;
 }
 
-void PrintHeaderClientMethodInterfaces(
+
+namespace {
+
+static void PrintHeaderClientMethodInterfaces(
     grpc_generator::Printer *printer, const grpc_generator::Method *method,
     std::map<grpc::string, grpc::string> *vars, bool is_public) {
   (*vars)["Method"] = method->name();
@@ -352,7 +357,9 @@ void PrintHeaderClientMethodInterfaces(
   }
 }
 
-void PrintHeaderClientMethod(grpc_generator::Printer *printer,
+
+
+static void PrintHeaderClientMethod(grpc_generator::Printer *printer,
                              const grpc_generator::Method *method,
                              std::map<grpc::string, grpc::string> *vars,
                              bool is_public) {
@@ -555,7 +562,7 @@ void PrintHeaderClientMethod(grpc_generator::Printer *printer,
   }
 }
 
-void PrintHeaderClientMethodData(grpc_generator::Printer *printer,
+static void PrintHeaderClientMethodData(grpc_generator::Printer *printer,
                                  const grpc_generator::Method *method,
                                  std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Method"] = method->name();
@@ -563,7 +570,7 @@ void PrintHeaderClientMethodData(grpc_generator::Printer *printer,
                  "const ::grpc::internal::RpcMethod rpcmethod_$Method$_;\n");
 }
 
-void PrintHeaderServerMethodSync(grpc_generator::Printer *printer,
+static void PrintHeaderServerMethodSync(grpc_generator::Printer *printer,
                                  const grpc_generator::Method *method,
                                  std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Method"] = method->name();
@@ -597,7 +604,7 @@ void PrintHeaderServerMethodSync(grpc_generator::Printer *printer,
   printer->Print(method->GetTrailingComments("//").c_str());
 }
 
-void PrintHeaderServerMethodAsync(grpc_generator::Printer *printer,
+static void PrintHeaderServerMethodAsync(grpc_generator::Printer *printer,
                                   const grpc_generator::Method *method,
                                   std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Method"] = method->name();
@@ -648,7 +655,7 @@ void PrintHeaderServerMethodAsync(grpc_generator::Printer *printer,
         "::grpc::Status $Method$("
         "::grpc::ServerContext* /*context*/, "
         "::grpc::ServerReader< $Request$>* /*reader*/, "
-        "$Response$* response) final override {\n"
+        "$Response$* /*response*/) final override {\n"
         "  abort();\n"
         "  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, \"\");\n"
         "}\n");
@@ -713,7 +720,7 @@ void PrintHeaderServerMethodAsync(grpc_generator::Printer *printer,
   printer->Print(*vars, "};\n");
 }
 
-void PrintHeaderServerMethodStreamedUnary(
+static void PrintHeaderServerMethodStreamedUnary(
     grpc_generator::Printer *printer, const grpc_generator::Method *method,
     std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Method"] = method->name();
@@ -764,7 +771,7 @@ void PrintHeaderServerMethodStreamedUnary(
   }
 }
 
-void PrintHeaderServerMethodSplitStreaming(
+static void PrintHeaderServerMethodSplitStreaming(
     grpc_generator::Printer *printer, const grpc_generator::Method *method,
     std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Method"] = method->name();
@@ -817,7 +824,7 @@ void PrintHeaderServerMethodSplitStreaming(
   }
 }
 
-void PrintHeaderServerMethodGeneric(
+static void PrintHeaderServerMethodGeneric(
     grpc_generator::Printer *printer, const grpc_generator::Method *method,
     std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Method"] = method->name();
@@ -888,7 +895,7 @@ void PrintHeaderServerMethodGeneric(
   printer->Print(*vars, "};\n");
 }
 
-void PrintHeaderService(grpc_generator::Printer *printer,
+static void PrintHeaderService(grpc_generator::Printer *printer,
                         const grpc_generator::Service *service,
                         std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Service"] = service->name();
@@ -1059,6 +1066,8 @@ void PrintHeaderService(grpc_generator::Printer *printer,
   printer->Print(service->GetTrailingComments("//").c_str());
 }
 
+} // namespace
+
 grpc::string GetHeaderServices(grpc_generator::File *file,
                                const Parameters &params) {
   grpc::string output;
@@ -1118,7 +1127,7 @@ grpc::string GetHeaderEpilogue(grpc_generator::File *file,
 }
 
 grpc::string GetSourcePrologue(grpc_generator::File *file,
-                               const Parameters & /*params*/) {
+                               const Parameters &params) {
   grpc::string output;
   {
     // Scope the output stream so it closes and finalizes output to the string.
@@ -1127,8 +1136,8 @@ grpc::string GetSourcePrologue(grpc_generator::File *file,
 
     vars["filename"] = file->filename();
     vars["filename_base"] = file->filename_without_ext();
-    vars["message_header_ext"] = file->message_header_ext();
+    vars["message_header_ext"] = params.message_header_extension;
-    vars["service_header_ext"] = file->service_header_ext();
+    vars["service_header_ext"] = service_header_ext();
 
     printer->Print(vars, "// Generated by the gRPC C++ plugin.\n");
     printer->Print(vars,
@@ -1177,7 +1186,10 @@ grpc::string GetSourceIncludes(grpc_generator::File *file,
   return output;
 }
 
-void PrintSourceClientMethod(grpc_generator::Printer *printer,
+
+namespace {
+
+static void PrintSourceClientMethod(grpc_generator::Printer *printer,
                              const grpc_generator::Method *method,
                              std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Method"] = method->name();
@@ -1321,7 +1333,7 @@ void PrintSourceClientMethod(grpc_generator::Printer *printer,
   }
 }
 
-void PrintSourceServerMethod(grpc_generator::Printer *printer,
+static void PrintSourceServerMethod(grpc_generator::Printer *printer,
                              const grpc_generator::Method *method,
                              std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Method"] = method->name();
@@ -1370,7 +1382,7 @@ void PrintSourceServerMethod(grpc_generator::Printer *printer,
   }
 }
 
-void PrintSourceService(grpc_generator::Printer *printer,
+static void PrintSourceService(grpc_generator::Printer *printer,
                         const grpc_generator::Service *service,
                         std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Service"] = service->name();
@@ -1487,6 +1499,8 @@ void PrintSourceService(grpc_generator::Printer *printer,
   }
 }
 
+} // namespace
+
 grpc::string GetSourceServices(grpc_generator::File *file,
                                const Parameters &params) {
   grpc::string output;
@@ -1532,9 +1546,8 @@ grpc::string GetSourceEpilogue(grpc_generator::File *file,
   return temp;
 }
 
-// TODO(mmukhi): Make sure we need parameters or not.
 grpc::string GetMockPrologue(grpc_generator::File *file,
-                             const Parameters & /*params*/) {
+                             const Parameters &params) {
   grpc::string output;
   {
     // Scope the output stream so it closes and finalizes output to the string.
@@ -1543,7 +1556,7 @@ grpc::string GetMockPrologue(grpc_generator::File *file,
 
     vars["filename"] = file->filename();
     vars["filename_base"] = file->filename_without_ext();
-    vars["message_header_ext"] = message_header_ext();
+    vars["message_header_ext"] = params.message_header_extension;
     vars["service_header_ext"] = service_header_ext();
 
     printer->Print(vars, "// Generated by the gRPC C++ plugin.\n");
@@ -1590,7 +1603,10 @@ grpc::string GetMockIncludes(grpc_generator::File *file,
   return output;
 }
 
-void PrintMockClientMethods(grpc_generator::Printer *printer,
+
+namespace {
+
+static void PrintMockClientMethods(grpc_generator::Printer *printer,
                             const grpc_generator::Method *method,
                             std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Method"] = method->name();
@@ -1682,7 +1698,7 @@ void PrintMockClientMethods(grpc_generator::Printer *printer,
   }
 }
 
-void PrintMockService(grpc_generator::Printer *printer,
+static void PrintMockService(grpc_generator::Printer *printer,
                       const grpc_generator::Service *service,
                       std::map<grpc::string, grpc::string> *vars) {
   (*vars)["Service"] = service->name();
@@ -1698,6 +1714,8 @@ void PrintMockService(grpc_generator::Printer *printer,
   printer->Print("};\n");
 }
 
+} // namespace
+
 grpc::string GetMockServices(grpc_generator::File *file,
                              const Parameters &params) {
   grpc::string output;

grpc/src/compiler/cpp_generator.h

@@ -33,6 +33,8 @@ struct Parameters {
   grpc::string grpc_search_path;
   // Generate GMOCK code to facilitate unit testing.
   bool generate_mock_code;
+  // By default, use "_generated.h"
+  std::string message_header_extension;
 };
 
 // Return the prologue of the generated header file.

grpc/src/compiler/go_generator.cc

@@ -19,22 +19,23 @@ inline bool ServerOnlyStreaming(const grpc_generator::Method *method) {
 }
 
 namespace grpc_go_generator {
+namespace {
 
 // Returns string with first letter to lowerCase
-grpc::string unexportName(grpc::string s) {
+static grpc::string unexportName(grpc::string s) {
   if (s.empty()) return s;
   s[0] = static_cast<char>(std::tolower(s[0]));
   return s;
 }
 
 // Returns string with first letter to uppercase
-grpc::string exportName(grpc::string s) {
+static grpc::string exportName(grpc::string s) {
   if (s.empty()) return s;
   s[0] = static_cast<char>(std::toupper(s[0]));
   return s;
 }
 
-void GenerateError(grpc_generator::Printer *printer,
+static void GenerateError(grpc_generator::Printer *printer,
                    std::map<grpc::string, grpc::string> vars,
                    const bool multiple_return = true) {
   printer->Print(vars, "if $Error_Check$ {\n");
@@ -46,7 +47,7 @@ void GenerateError(grpc_generator::Printer *printer,
 }
 
 // Generates imports for the service
-void GenerateImports(grpc_generator::File *file,
+static void GenerateImports(grpc_generator::File *file,
                      grpc_generator::Printer *printer,
                      std::map<grpc::string, grpc::string> vars) {
   vars["filename"] = file->filename();
@@ -66,7 +67,7 @@ void GenerateImports(grpc_generator::File *file,
 }
 
 // Generates Server method signature source
-void GenerateServerMethodSignature(const grpc_generator::Method *method,
+static void GenerateServerMethodSignature(const grpc_generator::Method *method,
                                    grpc_generator::Printer *printer,
                                    std::map<grpc::string, grpc::string> vars) {
   vars["Method"] = exportName(method->name());
@@ -86,7 +87,7 @@ void GenerateServerMethodSignature(const grpc_generator::Method *method,
   }
 }
 
-void GenerateServerMethod(const grpc_generator::Method *method,
+static void GenerateServerMethod(const grpc_generator::Method *method,
                           grpc_generator::Printer *printer,
                           std::map<grpc::string, grpc::string> vars) {
   vars["Method"] = exportName(method->name());
@@ -204,7 +205,7 @@ void GenerateServerMethod(const grpc_generator::Method *method,
 }
 
 // Generates Client method signature source
-void GenerateClientMethodSignature(const grpc_generator::Method *method,
+static void GenerateClientMethodSignature(const grpc_generator::Method *method,
                                    grpc_generator::Printer *printer,
                                    std::map<grpc::string, grpc::string> vars) {
   vars["Method"] = exportName(method->name());
@@ -225,7 +226,7 @@ void GenerateClientMethodSignature(const grpc_generator::Method *method,
 }
 
 // Generates Client method source
-void GenerateClientMethod(const grpc_generator::Method *method,
+static void GenerateClientMethod(const grpc_generator::Method *method,
                           grpc_generator::Printer *printer,
                           std::map<grpc::string, grpc::string> vars) {
   printer->Print(vars, "func (c *$ServiceUnexported$Client) ");
@@ -480,6 +481,7 @@ void GenerateService(const grpc_generator::Service *service,
   printer->Outdent();
   printer->Print("}\n");
 }
+}  // namespace
 
 // Returns source for the service
 grpc::string GenerateServiceSource(grpc_generator::File *file,

grpc/src/compiler/java_generator.cc

@@ -44,8 +44,9 @@ typedef grpc_generator::Method MethodDescriptor;
 
 namespace grpc_java_generator {
 typedef std::string string;
+namespace {
 // Generates imports for the service
-void GenerateImports(grpc_generator::File *file,
+static void GenerateImports(grpc_generator::File *file,
                      grpc_generator::Printer *printer, VARS &vars) {
   vars["filename"] = file->filename();
   printer->Print(vars,
@@ -287,7 +288,7 @@ static void GrpcWriteServiceDocComment(Printer *printer, VARS &vars,
   printer->Print(" */\n");
 }
 
-void GrpcWriteMethodDocComment(Printer *printer, VARS &vars,
+static void GrpcWriteMethodDocComment(Printer *printer, VARS &vars,
                                const MethodDescriptor *method) {
   printer->Print("/**\n");
   std::vector<string> lines = GrpcGetDocLinesForDescriptor(method);
@@ -1029,7 +1030,7 @@ static void PrintService(Printer *p, VARS &vars,
   p->Print("}\n");
 }
 
-void PrintStaticImports(Printer *p) {
+static void PrintStaticImports(Printer *p) {
   p->Print(
       "import java.nio.ByteBuffer;\n"
       "import static "
@@ -1062,7 +1063,7 @@ void PrintStaticImports(Printer *p) {
       "io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;\n\n");
 }
 
-void GenerateService(const grpc_generator::Service *service,
+static void GenerateService(const grpc_generator::Service *service,
                      grpc_generator::Printer *printer, VARS &vars,
                      bool disable_version) {
   // All non-generated classes must be referred by fully qualified names to
@@ -1097,6 +1098,7 @@ void GenerateService(const grpc_generator::Service *service,
 
   PrintService(printer, vars, service, disable_version);
 }
+} // namespace
 
 grpc::string GenerateServiceSource(
     grpc_generator::File *file, const grpc_generator::Service *service,

grpc/src/compiler/python_generator.cc

@@ -23,8 +23,9 @@
 #include "src/compiler/python_generator.h"
 
 namespace grpc_python_generator {
+namespace {
 
-grpc::string GenerateMethodType(const grpc_generator::Method *method) {
+static grpc::string GenerateMethodType(const grpc_generator::Method *method) {
 
   if (method->NoStreaming())
     return "unary_unary";
@@ -131,6 +132,7 @@ void GenerateRegister(const grpc_generator::Service *service,
   printer->Outdent();
   printer->Print("\n");
 }
+} // namespace
 
 grpc::string Generate(grpc_generator::File *file,
                       const grpc_generator::Service *service) {

grpc/src/compiler/schema_interface.h

@@ -107,8 +107,6 @@ struct File : public CommentHolder {
   virtual grpc::string package() const = 0;
   virtual std::vector<grpc::string> package_parts() const = 0;
   virtual grpc::string additional_headers() const = 0;
-  virtual std::string message_header_ext() const = 0;
-  virtual std::string service_header_ext() const = 0;
 
   virtual int service_count() const = 0;
   virtual std::unique_ptr<const Service> service(int i) const = 0;

grpc/src/compiler/swift_generator.cc

@@ -28,8 +28,9 @@
 #include "src/compiler/swift_generator.h"
 
 namespace grpc_swift_generator {
+namespace {
 
-std::string WrapInNameSpace(const std::vector<std::string> &components,
+static std::string WrapInNameSpace(const std::vector<std::string> &components,
                             const grpc::string &name) {
   std::string qualified_name;
   for (auto it = components.begin(); it != components.end(); ++it)
@@ -37,14 +38,14 @@ std::string WrapInNameSpace(const std::vector<std::string> &components,
   return qualified_name + name;
 }
 
-grpc::string GenerateMessage(const std::vector<std::string> &components,
+static grpc::string GenerateMessage(const std::vector<std::string> &components,
                              const grpc::string &name) {
   return "Message<" + WrapInNameSpace(components, name) + ">";
 }
 
 // MARK: - Client
 
-void GenerateClientFuncName(const grpc_generator::Method *method,
+static void GenerateClientFuncName(const grpc_generator::Method *method,
                             grpc_generator::Printer *printer,
                             std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
@@ -82,7 +83,7 @@ void GenerateClientFuncName(const grpc_generator::Method *method,
                  "  ) -> BidirectionalStreamingCall<$Input$, $Output$>");
 }
 
-void GenerateClientFuncBody(const grpc_generator::Method *method,
+static void GenerateClientFuncBody(const grpc_generator::Method *method,
                             grpc_generator::Printer *printer,
                             std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
@@ -372,6 +373,7 @@ void GenerateServerProtocol(const grpc_generator::Service *service,
   }
   printer->Print("}");
 }
+} // namespace
 
 grpc::string Generate(grpc_generator::File *file,
                       const grpc_generator::Service *service) {

grpc/src/compiler/ts_generator.cc

@@ -21,33 +21,18 @@
  * be maintained according to the Swift-grpc repository
  */
 
+#include "src/compiler/ts_generator.h"
+
 #include <map>
 #include <sstream>
 
 #include "flatbuffers/util.h"
 #include "src/compiler/schema_interface.h"
-#include "src/compiler/ts_generator.h"
 
 namespace grpc_ts_generator {
+namespace {
 
-grpc::string ToDasherizedCase(const grpc::string pascal_case) {
+static grpc::string GenerateNamespace(const std::vector<std::string> ns,
-  std::string dasherized_case;
-  char p = 0;
-  for (size_t i = 0; i < pascal_case.length(); i++) {
-    char const &c = pascal_case[i];
-    if (flatbuffers::is_alpha_upper(c)) {
-      if (i > 0 && p != flatbuffers::kPathSeparator) dasherized_case += "-";
-      dasherized_case += flatbuffers::CharToLower(c);
-    } else {
-      dasherized_case += c;
-    }
-    p = c;
-  }
-  return dasherized_case;
-}
-
-
-grpc::string GenerateNamespace(const std::vector<std::string> ns,
                                const std::string filename,
                                const bool include_separator) {
   grpc::string path = "";
@@ -55,17 +40,23 @@ grpc::string GenerateNamespace(const std::vector<std::string> ns,
 
   for (auto it = ns.begin(); it < ns.end(); it++) {
     if (include_separator) path += "/";
-    path += include_separator ? ToDasherizedCase(*it) : *it + "_";
+    path += include_separator
+                ? flatbuffers::ConvertCase(*it, flatbuffers::Case::kDasher,
+                                           flatbuffers::Case::kUpperCamel)
+                : *it + "_";
   }
 
   if (include_separator) path += "/";
-  path += include_separator ? ToDasherizedCase(filename) : filename;
+  path += include_separator
+              ? flatbuffers::ConvertCase(filename, flatbuffers::Case::kDasher,
+                                         flatbuffers::Case::kUpperCamel)
+              : filename;
   return path;
 }
 
 // MARK: - Shared code
 
-void GenerateImports(const grpc_generator::Service *service,
+static void GenerateImports(const grpc_generator::Service *service,
                      grpc_generator::Printer *printer,
                      std::map<grpc::string, grpc::string> *dictonary,
                      const bool grpc_var_import) {
@@ -114,7 +105,7 @@ void GenerateImports(const grpc_generator::Service *service,
 
 // MARK: - Generate Main GRPC Code
 
-void GetStreamType(grpc_generator::Printer *printer,
+static void GetStreamType(grpc_generator::Printer *printer,
                    const grpc_generator::Method *method,
                    std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
@@ -126,7 +117,7 @@ void GetStreamType(grpc_generator::Printer *printer,
   printer->Print(vars, "responseStream: $ServerStreaming$,\n");
 }
 
-void GenerateSerializeMethod(grpc_generator::Printer *printer,
+static void GenerateSerializeMethod(grpc_generator::Printer *printer,
                              std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
   printer->Print(vars, "function serialize_$Type$(buffer_args) {\n");
@@ -142,7 +133,7 @@ void GenerateSerializeMethod(grpc_generator::Printer *printer,
   printer->Print("}\n\n");
 }
 
-void GenerateDeserializeMethod(
+static void GenerateDeserializeMethod(
     grpc_generator::Printer *printer,
     std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
@@ -155,7 +146,7 @@ void GenerateDeserializeMethod(
   printer->Print("}\n\n");
 }
 
-void GenerateMethods(const grpc_generator::Service *service,
+static void GenerateMethods(const grpc_generator::Service *service,
                      grpc_generator::Printer *printer,
                      std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
@@ -187,7 +178,7 @@ void GenerateMethods(const grpc_generator::Service *service,
   }
 }
 
-void GenerateService(const grpc_generator::Service *service,
+static void GenerateService(const grpc_generator::Service *service,
                      grpc_generator::Printer *printer,
                      std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
@@ -222,6 +213,8 @@ void GenerateService(const grpc_generator::Service *service,
                  "grpc.makeGenericClientConstructor($NAME$);");
 }
 
+} // namespace
+
 grpc::string Generate(grpc_generator::File *file,
                       const grpc_generator::Service *service,
                       const grpc::string &filename) {
@@ -243,9 +236,11 @@ grpc::string Generate(grpc_generator::File *file,
   return output;
 }
 
+namespace {
+
 // MARK: - Generate Interface
 
-void FillInterface(grpc_generator::Printer *printer,
+static void FillInterface(grpc_generator::Printer *printer,
                    std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
   printer->Print(vars,
@@ -263,7 +258,7 @@ void FillInterface(grpc_generator::Printer *printer,
   printer->Print("}\n");
 }
 
-void GenerateInterfaces(const grpc_generator::Service *service,
+static void GenerateInterfaces(const grpc_generator::Service *service,
                         grpc_generator::Printer *printer,
                         std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
@@ -285,7 +280,7 @@ void GenerateInterfaces(const grpc_generator::Service *service,
   }
 }
 
-void GenerateExportedInterface(
+static void GenerateExportedInterface(
     const grpc_generator::Service *service, grpc_generator::Printer *printer,
     std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
@@ -329,7 +324,7 @@ void GenerateExportedInterface(
   printer->Print("}\n");
 }
 
-void GenerateMainInterface(const grpc_generator::Service *service,
+static void GenerateMainInterface(const grpc_generator::Service *service,
                            grpc_generator::Printer *printer,
                            std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
@@ -354,11 +349,11 @@ void GenerateMainInterface(const grpc_generator::Service *service,
   GenerateExportedInterface(service, printer, &vars);
 }
 
-grpc::string GenerateMetaData() { return "metadata: grpc.Metadata"; }
+static grpc::string GenerateMetaData() { return "metadata: grpc.Metadata"; }
 
-grpc::string GenerateOptions() { return "options: Partial<grpc.CallOptions>"; }
+static grpc::string GenerateOptions() { return "options: Partial<grpc.CallOptions>"; }
 
-void GenerateUnaryClientInterface(
+static void GenerateUnaryClientInterface(
     grpc_generator::Printer *printer,
     std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
@@ -373,7 +368,7 @@ void GenerateUnaryClientInterface(
   printer->Print(vars, (main + meta_data + options + callback).c_str());
 }
 
-void GenerateClientWriteStreamInterface(
+static void GenerateClientWriteStreamInterface(
     grpc_generator::Printer *printer,
     std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
@@ -390,7 +385,7 @@ void GenerateClientWriteStreamInterface(
   printer->Print(vars, (main + meta_data + options + callback).c_str());
 }
 
-void GenerateClientReadableStreamInterface(
+static void GenerateClientReadableStreamInterface(
     grpc_generator::Printer *printer,
     std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
@@ -402,7 +397,7 @@ void GenerateClientReadableStreamInterface(
   printer->Print(vars, (main + options + end_function).c_str());
 }
 
-void GenerateDepluxStreamInterface(
+static void GenerateDepluxStreamInterface(
     grpc_generator::Printer *printer,
     std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
@@ -418,7 +413,7 @@ void GenerateDepluxStreamInterface(
                            .c_str());
 }
 
-void GenerateClientInterface(const grpc_generator::Service *service,
+static void GenerateClientInterface(const grpc_generator::Service *service,
                              grpc_generator::Printer *printer,
                              std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
@@ -456,7 +451,7 @@ void GenerateClientInterface(const grpc_generator::Service *service,
   printer->Print("}\n");
 }
 
-void GenerateClientClassInterface(
+static void GenerateClientClassInterface(
     const grpc_generator::Service *service, grpc_generator::Printer *printer,
     std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
@@ -497,6 +492,8 @@ void GenerateClientClassInterface(
   printer->Outdent();
   printer->Print("}\n");
 }
+} // namespace
+
 
 grpc::string GenerateInterface(grpc_generator::File *file,
                                const grpc_generator::Service *service,

include/flatbuffers/base.h

@@ -140,7 +140,7 @@
 
 #define FLATBUFFERS_VERSION_MAJOR 2
 #define FLATBUFFERS_VERSION_MINOR 0
-#define FLATBUFFERS_VERSION_REVISION 6
+#define FLATBUFFERS_VERSION_REVISION 7
 #define FLATBUFFERS_STRING_EXPAND(X) #X
 #define FLATBUFFERS_STRING(X) FLATBUFFERS_STRING_EXPAND(X)
 namespace flatbuffers {
@@ -260,9 +260,12 @@ namespace flatbuffers {
 #endif // !FLATBUFFERS_HAS_NEW_STRTOD
 
 #ifndef FLATBUFFERS_LOCALE_INDEPENDENT
-  // Enable locale independent functions {strtof_l, strtod_l,strtoll_l, strtoull_l}.
+  // Enable locale independent functions {strtof_l, strtod_l,strtoll_l,
-  #if ((defined(_MSC_VER) && _MSC_VER >= 1800)            || \
+  // strtoull_l}.
-       (defined(_XOPEN_VERSION) && (_XOPEN_VERSION>=700)) && (!defined(__ANDROID_API__) || (defined(__ANDROID_API__) && (__ANDROID_API__>=21))))
+  #if (defined(_MSC_VER) && _MSC_VER >= 1800) || \
+      (defined(__ANDROID_API__) && __ANDROID_API__>= 21) || \
+      (defined(_XOPEN_VERSION) && (_XOPEN_VERSION >= 700)) && \
+        (!defined(__Fuchsia__) && !defined(__ANDROID_API__))
     #define FLATBUFFERS_LOCALE_INDEPENDENT 1
   #else
     #define FLATBUFFERS_LOCALE_INDEPENDENT 0
@@ -328,8 +331,17 @@ typedef uintmax_t largest_scalar_t;
 // In 32bits, this evaluates to 2GB - 1
 #define FLATBUFFERS_MAX_BUFFER_SIZE ((1ULL << (sizeof(::flatbuffers::soffset_t) * 8 - 1)) - 1)
 
+// The minimum size buffer that can be a valid flatbuffer.
+// Includes the offset to the root table (uoffset_t), the offset to the vtable
+// of the root table (soffset_t), the size of the vtable (uint16_t), and the
+// size of the referring table (uint16_t).
+#define FLATBUFFERS_MIN_BUFFER_SIZE sizeof(uoffset_t) + sizeof(soffset_t) + \
+   sizeof(uint16_t) + sizeof(uint16_t)
+
 // We support aligning the contents of buffers up to this size.
-#define FLATBUFFERS_MAX_ALIGNMENT 16
+#ifndef FLATBUFFERS_MAX_ALIGNMENT
+  #define FLATBUFFERS_MAX_ALIGNMENT 32
+#endif
 
 /// @brief The length of a FlatBuffer file header.
 static const size_t kFileIdentifierLength = 4;

include/flatbuffers/code_generators.h

@@ -97,8 +97,6 @@ class BaseGenerator {
                                   const Namespace &ns,
                                   const bool dasherize = false);
 
-  static std::string ToDasherizedCase(const std::string pascal_case);
-
   std::string GeneratedFileName(const std::string &path,
                                 const std::string &file_name,
                                 const IDLOptions &options) const;
@@ -140,7 +138,8 @@ class BaseGenerator {
   std::string WrapInNameSpace(const Namespace *ns,
                               const std::string &name) const;
 
-  std::string WrapInNameSpace(const Definition &def) const;
+  std::string WrapInNameSpace(const Definition &def,
+                              const std::string &suffix = "") const;
 
   std::string GetNameSpace(const Definition &def) const;
 

include/flatbuffers/flatbuffer_builder.h

@@ -18,6 +18,7 @@
 #define FLATBUFFERS_FLATBUFFER_BUILDER_H_
 
 #include <functional>
+#include <initializer_list>
 
 #include "flatbuffers/allocator.h"
 #include "flatbuffers/array.h"
@@ -442,6 +443,7 @@ class FlatBufferBuilder {
   // Aligns such that when "len" bytes are written, an object can be written
   // after it with "alignment" without padding.
   void PreAlign(size_t len, size_t alignment) {
+    if (len == 0) return;
     TrackMinAlign(alignment);
     buf_.fill(PaddingBytes(GetSize() + len, alignment));
   }
@@ -600,12 +602,14 @@ class FlatBufferBuilder {
   // This is useful when storing a nested_flatbuffer in a vector of bytes,
   // or when storing SIMD floats, etc.
   void ForceVectorAlignment(size_t len, size_t elemsize, size_t alignment) {
+    if (len == 0) return;
     FLATBUFFERS_ASSERT(VerifyAlignmentRequirements(alignment));
     PreAlign(len * elemsize, alignment);
   }
 
   // Similar to ForceVectorAlignment but for String fields.
   void ForceStringAlignment(size_t len, size_t alignment) {
+    if (len == 0) return;
     FLATBUFFERS_ASSERT(VerifyAlignmentRequirements(alignment));
     PreAlign((len + 1) * sizeof(char), alignment);
   }
@@ -652,6 +656,16 @@ class FlatBufferBuilder {
     return CreateVector(array.data(), array.size());
   }
 
+  /// @brief Serialize an initializer list into a FlatBuffer `vector`.
+  /// @tparam T The data type of the initializer list elements.
+  /// @param[in] v The value of the initializer list.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T>
+  Offset<Vector<T>> CreateVector(std::initializer_list<T> v) {
+    return CreateVector(v.begin(), v.size());
+  }
+
   template<typename T>
   Offset<Vector<Offset<T>>> CreateVector(const Offset<T> *v, size_t len) {
     StartVector(len, sizeof(Offset<T>));
@@ -716,15 +730,18 @@ class FlatBufferBuilder {
     return CreateVector(elems);
   }
 
-  /// @brief Serialize a `std::vector<std::string>` into a FlatBuffer `vector`.
+  /// @brief Serialize a `std::vector<StringType>` into a FlatBuffer `vector`.
+  /// whereas StringType is any type that is accepted by the CreateString()
+  /// overloads.
   /// This is a convenience function for a common case.
   /// @param v A const reference to the `std::vector` to serialize into the
   /// buffer as a `vector`.
   /// @return Returns a typed `Offset` into the serialized data indicating
   /// where the vector is stored.
-  template<typename Alloc = std::allocator<std::string>>
+  template<typename StringType = std::string,
+           typename Alloc = std::allocator<StringType>>
   Offset<Vector<Offset<String>>> CreateVectorOfStrings(
-      const std::vector<std::string, Alloc> &v) {
+      const std::vector<StringType, Alloc> &v) {
     return CreateVectorOfStrings(v.cbegin(), v.cend());
   }
 

include/flatbuffers/flatc.h

@@ -103,6 +103,11 @@ class FlatCompiler {
   void Error(const std::string &err, bool usage = true,
              bool show_exe_name = true) const;
 
+  void AnnotateBinaries(const uint8_t *binary_schema,
+                        uint64_t binary_schema_size,
+                        const std::string & schema_filename,
+                        const std::vector<std::string> &binary_files);
+
   InitParams params_;
 };
 

include/flatbuffers/flex_flat_util.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2022 Google Inc. All rights reserved.
+ *
+ * Licensed 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.
+ */
+
+#ifndef FLATBUFFERS_FLEX_FLAT_UTIL_H_
+#define FLATBUFFERS_FLEX_FLAT_UTIL_H_
+
+#include "flatbuffers/flatbuffers.h"
+#include "flatbuffers/flexbuffers.h"
+
+namespace flexbuffers {
+
+// Verifies the `nested` flexbuffer within a flatbuffer vector is valid.
+inline bool VerifyNestedFlexBuffer(
+    const flatbuffers::Vector<uint8_t> *const nested,
+    flatbuffers::Verifier &verifier) {
+  if (!nested) return true;
+  return verifier.Check(flexbuffers::VerifyBuffer(
+      nested->data(), nested->size(), verifier.GetFlexReuseTracker()));
+}
+
+}  // namespace flexbuffers
+
+#endif  // FLATBUFFERS_FLEX_FLAT_UTIL_H_

include/flatbuffers/flexbuffers.h

@@ -156,6 +156,7 @@ inline uint64_t ReadUInt64(const uint8_t *data, uint8_t byte_width) {
   // TODO: GCC apparently replaces memcpy by a rep movsb, but only if count is a
   // constant, which here it isn't. Test if memcpy is still faster than
   // the conditionals in ReadSizedScalar. Can also use inline asm.
+
   // clang-format off
   #if defined(_MSC_VER) && defined(_M_X64) && !defined(_M_ARM64EC)
   // This is 64-bit Windows only, __movsb does not work on 32-bit Windows.
@@ -578,7 +579,7 @@ class Reference {
           // unquoted if it looks like an "identifier":
           const char *p = keys[i].AsKey();
           if (!flatbuffers::is_alpha(*p) && *p != '_') {
-              kq = true;
+            kq = true;
           } else {
             while (*++p) {
               if (!flatbuffers::is_alnum(*p) && *p != '_') {
@@ -1422,10 +1423,12 @@ class Builder FLATBUFFERS_FINAL_CLASS {
 
   template<typename T> static Type GetScalarType() {
     static_assert(flatbuffers::is_scalar<T>::value, "Unrelated types");
-    return flatbuffers::is_floating_point<T>::value ? FBT_FLOAT
+    return flatbuffers::is_floating_point<T>::value
-           : flatbuffers::is_same<T, bool>::value
+               ? FBT_FLOAT
-               ? FBT_BOOL
+               : flatbuffers::is_same<T, bool>::value
-               : (flatbuffers::is_unsigned<T>::value ? FBT_UINT : FBT_INT);
+                     ? FBT_BOOL
+                     : (flatbuffers::is_unsigned<T>::value ? FBT_UINT
+                                                           : FBT_INT);
   }
 
  public:
@@ -1737,9 +1740,9 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
     if (!Check(depth_ <= max_depth_ && num_vectors_ <= max_vectors_))
       return false;
     auto size_byte_width = r.byte_width_;
-    FLEX_CHECK_VERIFIED(p,
-                        PackedType(Builder::WidthB(size_byte_width), r.type_));
     if (!VerifyBeforePointer(p, size_byte_width)) return false;
+    FLEX_CHECK_VERIFIED(p - size_byte_width,
+                        PackedType(Builder::WidthB(size_byte_width), r.type_));
     auto sized = Sized(p, size_byte_width);
     auto num_elems = sized.size();
     auto elem_byte_width = r.type_ == FBT_STRING || r.type_ == FBT_BLOB
@@ -1876,18 +1879,6 @@ inline bool VerifyBuffer(const uint8_t *buf, size_t buf_len,
   return verifier.VerifyBuffer();
 }
 
-#ifdef FLATBUFFERS_H_
-// This is a verifier utility function that works together with the
-// FlatBuffers verifier, which should only be present if flatbuffer.h
-// has been included (which it typically is in generated code).
-inline bool VerifyNestedFlexBuffer(const flatbuffers::Vector<uint8_t> *nv,
-                                   flatbuffers::Verifier &verifier) {
-  if (!nv) return true;
-  return verifier.Check(flexbuffers::VerifyBuffer(
-      nv->data(), nv->size(), verifier.GetFlexReuseTracker()));
-}
-#endif
-
 }  // namespace flexbuffers
 
 #if defined(_MSC_VER)

include/flatbuffers/idl.h

@@ -164,7 +164,7 @@ struct Type {
         enum_def(_ed),
         fixed_length(_fixed_length) {}
 
-  bool operator==(const Type &o) {
+  bool operator==(const Type &o) const {
     return base_type == o.base_type && element == o.element &&
            struct_def == o.struct_def && enum_def == o.enum_def;
   }
@@ -295,7 +295,7 @@ struct FieldDef : public Definition {
         native_inline(false),
         flexbuffer(false),
         presence(kDefault),
-        nested_flatbuffer(NULL),
+        nested_flatbuffer(nullptr),
         padding(0) {}
 
   Offset<reflection::Field> Serialize(FlatBufferBuilder *builder, uint16_t id,
@@ -551,6 +551,7 @@ struct IDLOptions {
   bool output_enum_identifiers;
   bool prefixed_enums;
   bool scoped_enums;
+  bool swift_implementation_only;
   bool include_dependence_headers;
   bool mutable_buffer;
   bool one_file;
@@ -576,7 +577,7 @@ struct IDLOptions {
   bool allow_non_utf8;
   bool natural_utf8;
   std::string include_prefix;
-  bool keep_include_path;
+  bool keep_prefix;
   bool binary_schema_comments;
   bool binary_schema_builtins;
   bool binary_schema_gen_embed;
@@ -601,6 +602,8 @@ struct IDLOptions {
   bool json_nested_flatbuffers;
   bool json_nested_flexbuffers;
   bool json_nested_legacy_flatbuffers;
+  bool ts_flat_file;
+  bool no_leak_private_annotations;
 
   // Possible options for the more general generator below.
   enum Language {
@@ -657,6 +660,7 @@ struct IDLOptions {
         output_enum_identifiers(true),
         prefixed_enums(true),
         scoped_enums(false),
+        swift_implementation_only(false),
         include_dependence_headers(true),
         mutable_buffer(false),
         one_file(false),
@@ -679,7 +683,7 @@ struct IDLOptions {
         union_value_namespacing(true),
         allow_non_utf8(false),
         natural_utf8(false),
-        keep_include_path(false),
+        keep_prefix(false),
         binary_schema_comments(false),
         binary_schema_builtins(false),
         binary_schema_gen_embed(false),
@@ -698,6 +702,8 @@ struct IDLOptions {
         json_nested_flatbuffers(true),
         json_nested_flexbuffers(true),
         json_nested_legacy_flatbuffers(false),
+        ts_flat_file(false),
+        no_leak_private_annotations(false),
         mini_reflect(IDLOptions::kNone),
         require_explicit_ids(false),
         rust_serialize(false),
@@ -905,6 +911,11 @@ class Parser : public ParserState {
   // @param opts Options used to parce a schema and generate code.
   static bool SupportsOptionalScalars(const flatbuffers::IDLOptions &opts);
 
+  // Get the set of included files that are directly referenced by the file
+  // being parsed. This does not include files that are transitively included by
+  // others includes.
+  std::vector<std::string> GetIncludedFiles() const;
+
  private:
   class ParseDepthGuard;
 
@@ -989,6 +1000,9 @@ class Parser : public ParserState {
   FLATBUFFERS_CHECKED_ERROR ParseRoot(const char *_source,
                                       const char **include_paths,
                                       const char *source_filename);
+  FLATBUFFERS_CHECKED_ERROR CheckPrivateLeak();
+  FLATBUFFERS_CHECKED_ERROR CheckPrivatelyLeakedFields(
+      const Definition &def, const Definition &value_type);
   FLATBUFFERS_CHECKED_ERROR DoParse(const char *_source,
                                     const char **include_paths,
                                     const char *source_filename,
@@ -1040,11 +1054,11 @@ class Parser : public ParserState {
 
   uint64_t advanced_features_;
 
+  std::string file_being_parsed_;
+
  private:
   const char *source_;
 
-  std::string file_being_parsed_;
-
   std::vector<std::pair<Value, FieldDef *>> field_stack_;
 
   // TODO(cneo): Refactor parser to use string_cache more often to save
@@ -1057,10 +1071,6 @@ class Parser : public ParserState {
 
 // Utility functions for multiple generators:
 
-extern std::string MakeCamel(const std::string &in, bool first = true);
-
-extern std::string MakeScreamingCamel(const std::string &in);
-
 // Generate text (JSON) from a given FlatBuffer, and a given Parser
 // object that has been populated with the corresponding schema.
 // If ident_step is 0, no indentation will be generated. Additionally,

include/flatbuffers/reflection.h

@@ -88,13 +88,22 @@ inline size_t GetTypeSizeInline(reflection::BaseType base_type, int type_index,
 }
 
 // Get the root, regardless of what type it is.
-inline Table *GetAnyRoot(uint8_t *flatbuf) {
+inline Table *GetAnyRoot(uint8_t *const flatbuf) {
   return GetMutableRoot<Table>(flatbuf);
 }
-inline const Table *GetAnyRoot(const uint8_t *flatbuf) {
+
+inline const Table *GetAnyRoot(const uint8_t *const flatbuf) {
   return GetRoot<Table>(flatbuf);
 }
 
+inline Table *GetAnySizePrefixedRoot(uint8_t *const flatbuf) {
+  return GetMutableSizePrefixedRoot<Table>(flatbuf);
+}
+
+inline const Table *GetAnySizePrefixedRoot(const uint8_t *const flatbuf) {
+  return GetSizePrefixedRoot<Table>(flatbuf);
+}
+
 // Get a field's default, if you know it's an integer, and its exact type.
 template<typename T> T GetFieldDefaultI(const reflection::Field &field) {
   FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type()));
@@ -279,6 +288,12 @@ T *GetAnyFieldAddressOf(const Struct &st, const reflection::Field &field) {
   return reinterpret_cast<T *>(st.GetAddressOf(field.offset()));
 }
 
+// Loop over all the fields of the provided `object` and call `func` on each one
+// in increasing order by their field->id(). If `reverse` is true, `func` is
+// called in descending order
+void ForAllFields(const reflection::Object *object, bool reverse,
+                  std::function<void(const reflection::Field *)> func);
+
 // ------------------------- SETTERS -------------------------
 
 // Set any scalar field, if you know its exact type.
@@ -497,6 +512,11 @@ bool Verify(const reflection::Schema &schema, const reflection::Object &root,
             const uint8_t *buf, size_t length, uoffset_t max_depth = 64,
             uoffset_t max_tables = 1000000);
 
+bool VerifySizePrefixed(const reflection::Schema &schema,
+                        const reflection::Object &root, const uint8_t *buf,
+                        size_t length, uoffset_t max_depth = 64,
+                        uoffset_t max_tables = 1000000);
+
 }  // namespace flatbuffers
 
 #endif  // FLATBUFFERS_REFLECTION_H_

include/flatbuffers/reflection_generated.h

@@ -6,6 +6,13 @@
 
 #include "flatbuffers/flatbuffers.h"
 
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 2 &&
+              FLATBUFFERS_VERSION_MINOR == 0 &&
+              FLATBUFFERS_VERSION_REVISION == 7,
+             "Non-compatible flatbuffers version included");
+
 namespace reflection {
 
 struct Type;

include/flatbuffers/stl_emulation.h

@@ -26,16 +26,20 @@
 #include <memory>
 #include <limits>
 
-// Detect C++17 compatible compiler.
+#ifndef FLATBUFFERS_USE_STD_OPTIONAL
-// __cplusplus >= 201703L - a compiler has support of 'static inline' variables.
+  // Detect C++17 compatible compiler.
-#if defined(FLATBUFFERS_USE_STD_OPTIONAL) \
+  // __cplusplus >= 201703L - a compiler has support of 'static inline' variables.
-    || (defined(__cplusplus) && __cplusplus >= 201703L) \
+  #if (defined(__cplusplus) && __cplusplus >= 201703L) \
-    || (defined(_MSVC_LANG) &&  (_MSVC_LANG >= 201703L))
+      || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+    #define FLATBUFFERS_USE_STD_OPTIONAL 1
+  #else
+    #define FLATBUFFERS_USE_STD_OPTIONAL 0
+  #endif // (defined(__cplusplus) && __cplusplus >= 201703L) ...
+#endif // FLATBUFFERS_USE_STD_OPTIONAL
+
+#if FLATBUFFERS_USE_STD_OPTIONAL
   #include <optional>
-  #ifndef FLATBUFFERS_USE_STD_OPTIONAL
+#endif
-    #define FLATBUFFERS_USE_STD_OPTIONAL
-  #endif
-#endif // defined(FLATBUFFERS_USE_STD_OPTIONAL) ...
 
 // The __cpp_lib_span is the predefined feature macro.
 #if defined(FLATBUFFERS_USE_STD_SPAN)
@@ -128,7 +132,7 @@ namespace flatbuffers {
   };
 #endif  // defined(FLATBUFFERS_TEMPLATES_ALIASES)
 
-#ifdef FLATBUFFERS_USE_STD_OPTIONAL
+#if FLATBUFFERS_USE_STD_OPTIONAL
 template<class T>
 using Optional = std::optional<T>;
 using nullopt_t = std::nullopt_t;
@@ -284,13 +288,13 @@ FLATBUFFERS_CONSTEXPR std::size_t dynamic_extent = static_cast<std::size_t>(-1);
 namespace internal {
   // This is SFINAE helper class for checking of a common condition:
   // > This overload only participates in overload resolution
-  // > Check whether a pointer to an array of U can be converted
+  // > Check whether a pointer to an array of From can be converted
-  // > to a pointer to an array of E.
+  // > to a pointer to an array of To.
-  // This helper is used for checking of 'U -> const U'.
+  // This helper is used for checking of 'From -> const From'.
-  template<class E, std::size_t Extent, class U, std::size_t N>
+  template<class To, std::size_t Extent, class From, std::size_t N>
   struct is_span_convertable {
     using type =
-      typename std::conditional<std::is_convertible<U (*)[], E (*)[]>::value
+      typename std::conditional<std::is_convertible<From (*)[], To (*)[]>::value
                                 && (Extent == dynamic_extent || N == Extent),
                                 int, void>::type;
   };
@@ -362,13 +366,9 @@ class span FLATBUFFERS_FINAL_CLASS {
 
   #if !defined(FLATBUFFERS_SPAN_MINIMAL)
     using Iterator = internal::SpanIterator<T>;
-    using ConstIterator = internal::SpanIterator<const T>;
 
     Iterator begin() const { return Iterator(data()); }
     Iterator end() const   { return Iterator(data() + size()); }
-
-    ConstIterator cbegin() const { return ConstIterator(data()); }
-    ConstIterator cend() const  { return ConstIterator(data() + size()); }
   #endif
 
   // Returns a reference to the idx-th element of the sequence.
@@ -462,45 +462,45 @@ class span FLATBUFFERS_FINAL_CLASS {
  private:
   // This is a naive implementation with 'count_' member even if (Extent != dynamic_extent).
   pointer const data_;
-  const size_type count_;
+  size_type count_;
 };
 #endif  // defined(FLATBUFFERS_USE_STD_SPAN)
 
 #if !defined(FLATBUFFERS_SPAN_MINIMAL)
-template<class U, std::size_t N>
+template<class ElementType, std::size_t Extent>
 FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<U, N> make_span(U(&arr)[N]) FLATBUFFERS_NOEXCEPT {
+flatbuffers::span<ElementType, Extent> make_span(ElementType(&arr)[Extent]) FLATBUFFERS_NOEXCEPT {
-  return span<U, N>(arr);
+  return span<ElementType, Extent>(arr);
 }
 
-template<class U, std::size_t N>
+template<class ElementType, std::size_t Extent>
 FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<const U, N> make_span(const U(&arr)[N]) FLATBUFFERS_NOEXCEPT {
+flatbuffers::span<const ElementType, Extent> make_span(const ElementType(&arr)[Extent]) FLATBUFFERS_NOEXCEPT {
-  return span<const U, N>(arr);
+  return span<const ElementType, Extent>(arr);
 }
 
-template<class U, std::size_t N>
+template<class ElementType, std::size_t Extent>
 FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<U, N> make_span(std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT {
+flatbuffers::span<ElementType, Extent> make_span(std::array<ElementType, Extent> &arr) FLATBUFFERS_NOEXCEPT {
-  return span<U, N>(arr);
+  return span<ElementType, Extent>(arr);
 }
 
-template<class U, std::size_t N>
+template<class ElementType, std::size_t Extent>
 FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<const U, N> make_span(const std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT {
+flatbuffers::span<const ElementType, Extent> make_span(const std::array<ElementType, Extent> &arr) FLATBUFFERS_NOEXCEPT {
-  return span<const U, N>(arr);
+  return span<const ElementType, Extent>(arr);
 }
 
-template<class U, std::size_t N>
+template<class ElementType, std::size_t Extent>
 FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<U, dynamic_extent> make_span(U *first, std::size_t count) FLATBUFFERS_NOEXCEPT {
+flatbuffers::span<ElementType, dynamic_extent> make_span(ElementType *first, std::size_t count) FLATBUFFERS_NOEXCEPT {
-  return span<U, dynamic_extent>(first, count);
+  return span<ElementType, dynamic_extent>(first, count);
 }
 
-template<class U, std::size_t N>
+template<class ElementType, std::size_t Extent>
 FLATBUFFERS_CONSTEXPR_CPP11
-flatbuffers::span<const U, dynamic_extent> make_span(const U *first, std::size_t count) FLATBUFFERS_NOEXCEPT {
+flatbuffers::span<const ElementType, dynamic_extent> make_span(const ElementType *first, std::size_t count) FLATBUFFERS_NOEXCEPT {
-  return span<const U, dynamic_extent>(first, count);
+  return span<const ElementType, dynamic_extent>(first, count);
 }
 #endif // !defined(FLATBUFFERS_SPAN_MINIMAL)
 

include/flatbuffers/util.h

@@ -448,6 +448,9 @@ std::string StripPath(const std::string &filepath);
 // Strip the last component of the path + separator.
 std::string StripFileName(const std::string &filepath);
 
+std::string StripPrefix(const std::string &filepath,
+                        const std::string &prefix_to_remove);
+
 // Concatenates a path with a filename, regardless of whether the path
 // ends in a separator or not.
 std::string ConCatPathFileName(const std::string &path,
@@ -685,6 +688,32 @@ bool ReadEnvironmentVariable(const char *var_name,
 // MSVC specific: Send all assert reports to STDOUT to prevent CI hangs.
 void SetupDefaultCRTReportMode();
 
+enum class Case {
+  kUnknown = 0,
+  // TheQuickBrownFox
+  kUpperCamel = 1,
+  // theQuickBrownFox
+  kLowerCamel = 2,
+  // the_quick_brown_fox
+  kSnake = 3,
+  // THE_QUICK_BROWN_FOX
+  kScreamingSnake = 4,
+  // THEQUICKBROWNFOX
+  kAllUpper = 5,
+  // thequickbrownfox
+  kAllLower = 6,
+  // the-quick-brown-fox
+  kDasher = 7,
+  // THEQuiCKBr_ownFox (or whatever you want, we won't change it)
+  kKeep = 8,
+  // the_quick_brown_fox123 (as opposed to the_quick_brown_fox_123)
+  kSnake2 = 9,
+};
+
+// Convert the `input` string of case `input_case` to the specified `output_case`.
+std::string ConvertCase(const std::string &input, Case output_case,
+                    Case input_case = Case::kSnake);
+
 }  // namespace flatbuffers
 
 #endif  // FLATBUFFERS_UTIL_H_

include/flatbuffers/vector.h

@@ -19,6 +19,7 @@
 
 #include "flatbuffers/base.h"
 #include "flatbuffers/buffer.h"
+#include "flatbuffers/stl_emulation.h"
 
 namespace flatbuffers {
 
@@ -326,6 +327,24 @@ FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const uint8_t> make_bytes_span(
   return span<const uint8_t>(vec.Data(), vec.size() * sizeof(U));
 }
 
+// Convenient helper functions to get a span of any vector, regardless
+// of whether it is null or not (the field is not set).
+template<class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U> make_span(Vector<U> *ptr)
+    FLATBUFFERS_NOEXCEPT {
+  static_assert(Vector<U>::is_span_observable,
+                "wrong type U, only LE-scalar, or byte types are allowed");
+  return ptr ? make_span(*ptr) : span<U>();
+}
+
+template<class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U> make_span(
+    const Vector<U> *ptr) FLATBUFFERS_NOEXCEPT {
+  static_assert(Vector<U>::is_span_observable,
+                "wrong type U, only LE-scalar, or byte types are allowed");
+  return ptr ? make_span(*ptr) : span<const U>();
+}
+
 // Represent a vector much like the template above, but in this case we
 // don't know what the element types are (used with reflection.h).
 class VectorOfAny {

include/flatbuffers/verifier.h

@@ -18,7 +18,6 @@
 #define FLATBUFFERS_VERIFIER_H_
 
 #include "flatbuffers/base.h"
-#include "flatbuffers/util.h"
 #include "flatbuffers/vector.h"
 
 namespace flatbuffers {
@@ -26,22 +25,24 @@ namespace flatbuffers {
 // Helper class to verify the integrity of a FlatBuffer
 class Verifier FLATBUFFERS_FINAL_CLASS {
  public:
-  Verifier(const uint8_t *buf, size_t buf_len, uoffset_t _max_depth = 64,
+  Verifier(const uint8_t *const buf, const size_t buf_len,
-           uoffset_t _max_tables = 1000000, bool _check_alignment = true)
+           const uoffset_t _max_depth = 64,
+           const uoffset_t _max_tables = 1000000,
+           const bool _check_alignment = true)
       : buf_(buf),
         size_(buf_len),
-        depth_(0),
         max_depth_(_max_depth),
-        num_tables_(0),
         max_tables_(_max_tables),
-        upper_bound_(0),
         check_alignment_(_check_alignment),
+        upper_bound_(0),
+        depth_(0),
+        num_tables_(0),
         flex_reuse_tracker_(nullptr) {
     FLATBUFFERS_ASSERT(size_ < FLATBUFFERS_MAX_BUFFER_SIZE);
   }
 
   // Central location where any verification failures register.
-  bool Check(bool ok) const {
+  bool Check(const bool ok) const {
     // clang-format off
     #ifdef FLATBUFFERS_DEBUG_VERIFICATION_FAILURE
       FLATBUFFERS_ASSERT(ok);
@@ -55,7 +56,7 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
   }
 
   // Verify any range within the buffer.
-  bool Verify(size_t elem, size_t elem_len) const {
+  bool Verify(const size_t elem, const size_t elem_len) const {
     // clang-format off
     #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
       auto upper_bound = elem + elem_len;
@@ -66,52 +67,52 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
     return Check(elem_len < size_ && elem <= size_ - elem_len);
   }
 
-  bool VerifyAlignment(size_t elem, size_t align) const {
+  bool VerifyAlignment(const size_t elem, const size_t align) const {
     return Check((elem & (align - 1)) == 0 || !check_alignment_);
   }
 
   // Verify a range indicated by sizeof(T).
-  template<typename T> bool Verify(size_t elem) const {
+  template<typename T> bool Verify(const size_t elem) const {
     return VerifyAlignment(elem, sizeof(T)) && Verify(elem, sizeof(T));
   }
 
-  bool VerifyFromPointer(const uint8_t *p, size_t len) {
+  bool VerifyFromPointer(const uint8_t *const p, const size_t len) {
-    auto o = static_cast<size_t>(p - buf_);
+    return Verify(static_cast<size_t>(p - buf_), len);
-    return Verify(o, len);
   }
 
   // Verify relative to a known-good base pointer.
-  bool VerifyFieldStruct(const uint8_t *base, voffset_t elem_off,
+  bool VerifyFieldStruct(const uint8_t *const base, const voffset_t elem_off,
-                         size_t elem_len, size_t align) const {
+                         const size_t elem_len, const size_t align) const {
-    auto f = static_cast<size_t>(base - buf_) + elem_off;
+    const auto f = static_cast<size_t>(base - buf_) + elem_off;
     return VerifyAlignment(f, align) && Verify(f, elem_len);
   }
 
   template<typename T>
-  bool VerifyField(const uint8_t *base, voffset_t elem_off,
+  bool VerifyField(const uint8_t *const base, const voffset_t elem_off,
-                   size_t align) const {
+                   const size_t align) const {
-    auto f = static_cast<size_t>(base - buf_) + elem_off;
+    const auto f = static_cast<size_t>(base - buf_) + elem_off;
     return VerifyAlignment(f, align) && Verify(f, sizeof(T));
   }
 
   // Verify a pointer (may be NULL) of a table type.
-  template<typename T> bool VerifyTable(const T *table) {
+  template<typename T> bool VerifyTable(const T *const table) {
     return !table || table->Verify(*this);
   }
 
   // Verify a pointer (may be NULL) of any vector type.
-  template<typename T> bool VerifyVector(const Vector<T> *vec) const {
+  template<typename T> bool VerifyVector(const Vector<T> *const vec) const {
     return !vec || VerifyVectorOrString(reinterpret_cast<const uint8_t *>(vec),
                                         sizeof(T));
   }
 
   // Verify a pointer (may be NULL) of a vector to struct.
-  template<typename T> bool VerifyVector(const Vector<const T *> *vec) const {
+  template<typename T>
+  bool VerifyVector(const Vector<const T *> *const vec) const {
     return VerifyVector(reinterpret_cast<const Vector<T> *>(vec));
   }
 
   // Verify a pointer (may be NULL) to string.
-  bool VerifyString(const String *str) const {
+  bool VerifyString(const String *const str) const {
     size_t end;
     return !str || (VerifyVectorOrString(reinterpret_cast<const uint8_t *>(str),
                                          1, &end) &&
@@ -120,24 +121,24 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
   }
 
   // Common code between vectors and strings.
-  bool VerifyVectorOrString(const uint8_t *vec, size_t elem_size,
+  bool VerifyVectorOrString(const uint8_t *const vec, const size_t elem_size,
-                            size_t *end = nullptr) const {
+                            size_t *const end = nullptr) const {
-    auto veco = static_cast<size_t>(vec - buf_);
+    const auto veco = static_cast<size_t>(vec - buf_);
     // Check we can read the size field.
     if (!Verify<uoffset_t>(veco)) return false;
     // Check the whole array. If this is a string, the byte past the array
     // must be 0.
-    auto size = ReadScalar<uoffset_t>(vec);
+    const auto size = ReadScalar<uoffset_t>(vec);
-    auto max_elems = FLATBUFFERS_MAX_BUFFER_SIZE / elem_size;
+    const auto max_elems = FLATBUFFERS_MAX_BUFFER_SIZE / elem_size;
     if (!Check(size < max_elems))
       return false;  // Protect against byte_size overflowing.
-    auto byte_size = sizeof(size) + elem_size * size;
+    const auto byte_size = sizeof(size) + elem_size * size;
     if (end) *end = veco + byte_size;
     return Verify(veco, byte_size);
   }
 
   // Special case for string contents, after the above has been called.
-  bool VerifyVectorOfStrings(const Vector<Offset<String>> *vec) const {
+  bool VerifyVectorOfStrings(const Vector<Offset<String>> *const vec) const {
     if (vec) {
       for (uoffset_t i = 0; i < vec->size(); i++) {
         if (!VerifyString(vec->Get(i))) return false;
@@ -147,7 +148,8 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
   }
 
   // Special case for table contents, after the above has been called.
-  template<typename T> bool VerifyVectorOfTables(const Vector<Offset<T>> *vec) {
+  template<typename T>
+  bool VerifyVectorOfTables(const Vector<Offset<T>> *const vec) {
     if (vec) {
       for (uoffset_t i = 0; i < vec->size(); i++) {
         if (!vec->Get(i)->Verify(*this)) return false;
@@ -157,30 +159,40 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
   }
 
   __supress_ubsan__("unsigned-integer-overflow") bool VerifyTableStart(
-      const uint8_t *table) {
+      const uint8_t *const table) {
     // Check the vtable offset.
-    auto tableo = static_cast<size_t>(table - buf_);
+    const auto tableo = static_cast<size_t>(table - buf_);
     if (!Verify<soffset_t>(tableo)) return false;
     // This offset may be signed, but doing the subtraction unsigned always
     // gives the result we want.
-    auto vtableo = tableo - static_cast<size_t>(ReadScalar<soffset_t>(table));
+    const auto vtableo =
+        tableo - static_cast<size_t>(ReadScalar<soffset_t>(table));
     // Check the vtable size field, then check vtable fits in its entirety.
-    return VerifyComplexity() && Verify<voffset_t>(vtableo) &&
+    if (!(VerifyComplexity() && Verify<voffset_t>(vtableo) &&
-           VerifyAlignment(ReadScalar<voffset_t>(buf_ + vtableo),
+          VerifyAlignment(ReadScalar<voffset_t>(buf_ + vtableo),
-                           sizeof(voffset_t)) &&
+                          sizeof(voffset_t))))
-           Verify(vtableo, ReadScalar<voffset_t>(buf_ + vtableo));
+      return false;
+    const auto vsize = ReadScalar<voffset_t>(buf_ + vtableo);
+    return Check((vsize & 1) == 0) && Verify(vtableo, vsize);
   }
 
   template<typename T>
-  bool VerifyBufferFromStart(const char *identifier, size_t start) {
+  bool VerifyBufferFromStart(const char *const identifier, const size_t start) {
+    // Buffers have to be of some size to be valid. The reason it is a runtime
+    // check instead of static_assert, is that nested flatbuffers go through
+    // this call and their size is determined at runtime.
+    if (!Check(size_ >= FLATBUFFERS_MIN_BUFFER_SIZE)) return false;
+
+    // If an identifier is provided, check that we have a buffer
     if (identifier && !Check((size_ >= 2 * sizeof(flatbuffers::uoffset_t) &&
                               BufferHasIdentifier(buf_ + start, identifier)))) {
       return false;
     }
 
     // Call T::Verify, which must be in the generated code for this type.
-    auto o = VerifyOffset(start);
+    const auto o = VerifyOffset(start);
-    return o && reinterpret_cast<const T *>(buf_ + start + o)->Verify(*this)
+    return Check(o != 0) &&
+           reinterpret_cast<const T *>(buf_ + start + o)->Verify(*this)
     // clang-format off
     #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
            && GetComputedSize()
@@ -190,9 +202,14 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
   }
 
   template<typename T>
-  bool VerifyNestedFlatBuffer(const Vector<uint8_t> *buf,
+  bool VerifyNestedFlatBuffer(const Vector<uint8_t> *const buf,
-                              const char *identifier) {
+                              const char *const identifier) {
+    // An empty buffer is OK as it indicates not present.
     if (!buf) return true;
+
+    // If there is a nested buffer, it must be greater than the min size.
+    if(!Check(buf->size() >= FLATBUFFERS_MIN_BUFFER_SIZE)) return false;
+
     Verifier nested_verifier(buf->data(), buf->size());
     return nested_verifier.VerifyBuffer<T>(identifier);
   }
@@ -200,19 +217,20 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
   // Verify this whole buffer, starting with root type T.
   template<typename T> bool VerifyBuffer() { return VerifyBuffer<T>(nullptr); }
 
-  template<typename T> bool VerifyBuffer(const char *identifier) {
+  template<typename T> bool VerifyBuffer(const char *const identifier) {
     return VerifyBufferFromStart<T>(identifier, 0);
   }
 
-  template<typename T> bool VerifySizePrefixedBuffer(const char *identifier) {
+  template<typename T>
+  bool VerifySizePrefixedBuffer(const char *const identifier) {
     return Verify<uoffset_t>(0U) &&
-           ReadScalar<uoffset_t>(buf_) == size_ - sizeof(uoffset_t) &&
+           Check(ReadScalar<uoffset_t>(buf_) == size_ - sizeof(uoffset_t)) &&
            VerifyBufferFromStart<T>(identifier, sizeof(uoffset_t));
   }
 
-  uoffset_t VerifyOffset(size_t start) const {
+  uoffset_t VerifyOffset(const size_t start) const {
     if (!Verify<uoffset_t>(start)) return 0;
-    auto o = ReadScalar<uoffset_t>(buf_ + start);
+    const auto o = ReadScalar<uoffset_t>(buf_ + start);
     // May not point to itself.
     if (!Check(o != 0)) return 0;
     // Can't wrap around / buffers are max 2GB.
@@ -223,7 +241,8 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
     return o;
   }
 
-  uoffset_t VerifyOffset(const uint8_t *base, voffset_t start) const {
+  uoffset_t VerifyOffset(const uint8_t *const base,
+                         const voffset_t start) const {
     return VerifyOffset(static_cast<size_t>(base - buf_) + start);
   }
 
@@ -262,19 +281,21 @@ class Verifier FLATBUFFERS_FINAL_CLASS {
 
   std::vector<uint8_t> *GetFlexReuseTracker() { return flex_reuse_tracker_; }
 
-  void SetFlexReuseTracker(std::vector<uint8_t> *rt) {
+  void SetFlexReuseTracker(std::vector<uint8_t> *const rt) {
     flex_reuse_tracker_ = rt;
   }
 
  private:
   const uint8_t *buf_;
-  size_t size_;
+  const size_t size_;
-  uoffset_t depth_;
+  const uoffset_t max_depth_;
-  uoffset_t max_depth_;
+  const uoffset_t max_tables_;
-  uoffset_t num_tables_;
+  const bool check_alignment_;
-  uoffset_t max_tables_;
+
   mutable size_t upper_bound_;
-  bool check_alignment_;
+
+  uoffset_t depth_;
+  uoffset_t num_tables_;
   std::vector<uint8_t> *flex_reuse_tracker_;
 };
 

kotlin/benchmark/build.gradle.kts

@@ -1,15 +1,15 @@
 import org.jetbrains.kotlin.ir.backend.js.compile
 
 plugins {
-  kotlin("multiplatform") version "1.4.20"
+  kotlin("multiplatform")
   id("org.jetbrains.kotlin.plugin.allopen") version "1.4.20"
-  id("org.jetbrains.kotlinx.benchmark") version "0.3.0"
+  id("org.jetbrains.kotlinx.benchmark") version "0.4.2"
   id("io.morethan.jmhreport") version "0.9.0"
-  id("de.undercouch.download") version "4.1.1"
+  id("de.undercouch.download")
 }
 
 // allOpen plugin is needed for the benchmark annotations.
-// for more infomation, see https://github.com/Kotlin/kotlinx-benchmark#gradle-plugin
+// for more information, see https://github.com/Kotlin/kotlinx-benchmark#gradle-plugin
 allOpen {
   annotation("org.openjdk.jmh.annotations.State")
 }
@@ -45,54 +45,25 @@ benchmark {
 kotlin {
   jvm {
     withJava()
-    compilations.all {
-      kotlinOptions {
-        jvmTarget = JavaVersion.VERSION_1_8.toString()
-      }
-    }
   }
 
   sourceSets {
 
     all {
       languageSettings.enableLanguageFeature("InlineClasses")
-      languageSettings.useExperimentalAnnotation("kotlin.ExperimentalUnsignedTypes")
     }
 
-    val commonTest by getting {
-      dependencies {
-        implementation(kotlin("test-common"))
-        implementation(kotlin("test-annotations-common"))
-      }
-    }
-    val jvmTest by getting {
-      dependencies {
-        implementation(kotlin("test-junit"))
-      }
-    }
     val jvmMain by getting {
       dependencies {
-        implementation("org.jetbrains.kotlinx:kotlinx-benchmark-runtime:0.3.0")
         implementation(kotlin("stdlib-common"))
         implementation(project(":flatbuffers-kotlin"))
-        implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
+        implementation(libs.kotlinx.benchmark.runtime)
-        implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm:1.4.1")
 
-        //moshi
+        // json serializers
-        implementation("com.squareup.moshi:moshi-kotlin:1.11.0")
+        implementation(libs.moshi.kotlin)
-
+        implementation(libs.gson)
-        //gson
-        implementation("com.google.code.gson:gson:2.8.5")
       }
     }
-
-    /* Targets configuration omitted.
-     *  To find out how to configure the targets, please follow the link:
-     *  https://kotlinlang.org/docs/reference/building-mpp-with-gradle.html#setting-up-targets
-     */
-    targets {
-      targetFromPreset(presets.getAt("jvm"))
-    }
   }
 }
 
@@ -105,7 +76,3 @@ tasks.register<de.undercouch.gradle.tasks.download.Download>("downloadMultipleFi
   dest(File("${project.projectDir.absolutePath}/src/jvmMain/resources"))
   overwrite(false)
 }
-
-project.tasks.named("compileKotlinJvm") {
-  dependsOn("downloadMultipleFiles")
-}

kotlin/build.gradle.kts

@@ -1,22 +1,24 @@
 plugins {
-  id("com.diffplug.spotless") version "5.8.2"
+  id("com.diffplug.spotless") version "6.3.0"
 }
 
 group = "com.google.flatbuffers"
 version = "2.0.0-SNAPSHOT"
 
-subprojects {
+buildscript {
-
   repositories {
-    maven { setUrl("https://plugins.gradle.org/m2/") }
+    gradlePluginPortal()
+    google()
     mavenCentral()
   }
+  dependencies {
+    classpath(libs.bundles.plugins)
+  }
 }
 
-buildscript {
+allprojects {
   repositories {
-    maven { setUrl("https://plugins.gradle.org/m2/") }
+    google()
-    gradlePluginPortal()
     mavenCentral()
   }
 }

kotlin/flatbuffers-kotlin/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-  kotlin("multiplatform") version "1.4.20"
+  kotlin("multiplatform")
 }
 
 group = "com.google.flatbuffers.kotlin"
@@ -10,13 +10,13 @@ kotlin {
   jvm()
   js {
     browser {
-      binaries.executable()
+     testTask {
-      testTask {
         useKarma {
           useChromeHeadless()
         }
       }
     }
+    binaries.executable()
   }
   macosX64()
   iosArm32()
@@ -32,8 +32,7 @@ kotlin {
 
     val commonTest by getting {
       dependencies {
-        implementation(kotlin("test-common"))
+        implementation(kotlin("test"))
-        implementation(kotlin("test-annotations-common"))
       }
     }
     val jvmTest by getting {
@@ -43,9 +42,6 @@ kotlin {
     }
     val jvmMain by getting {
       kotlin.srcDir("java")
-      dependencies {
-        implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm:1.4.1")
-      }
     }
 
     val jsMain by getting {
@@ -79,19 +75,12 @@ kotlin {
 
     all {
       languageSettings.enableLanguageFeature("InlineClasses")
-      languageSettings.useExperimentalAnnotation("kotlin.ExperimentalUnsignedTypes")
+      languageSettings.optIn("kotlin.ExperimentalUnsignedTypes")
     }
   }
-
+}
-  /* Targets configuration omitted.
+
-   *  To find out how to configure the targets, please follow the link:
+// Fixes JS issue: https://youtrack.jetbrains.com/issue/KT-49109
-   *  https://kotlinlang.org/docs/reference/building-mpp-with-gradle.html#setting-up-targets */
+rootProject.plugins.withType<org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootPlugin> {
-  targets {
+  rootProject.the<org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootExtension>().nodeVersion = "16.0.0"
-    targetFromPreset(presets.getAt("jvm"))
-    targetFromPreset(presets.getAt("js"))
-    targetFromPreset(presets.getAt("macosX64"))
-    targetFromPreset(presets.getAt("iosArm32"))
-    targetFromPreset(presets.getAt("iosArm64"))
-    targetFromPreset(presets.getAt("iosX64"))
-  }
 }

kotlin/gradle.properties

@@ -0,0 +1,14 @@
+#Gradle
+
+org.gradle.parallel=true
+org.gradle.caching=true
+
+#Kotlin
+kotlin.code.style=official
+
+#MPP
+kotlin.mpp.enableGranularSourceSetsMetadata=true
+kotlin.native.enableDependencyPropagation=false
+kotlin.mpp.enableCompatibilityMetadataVariant=true
+kotlin.mpp.stability.nowarn=true
+kotlin.incremental.multiplatform=true

kotlin/gradle/libs.versions.toml

@@ -0,0 +1,20 @@
+[versions]
+plugin-kotlin = "1.6.10"
+plugin-gver = "0.42.0"
+kotlinx-benchmark-runtime = "0.4.2"
+junit = "4.12"
+gson = "2.8.5"
+moshi-kotlin = "1.11.0"
+
+[libraries]
+moshi-kotlin = { module = "com.squareup.moshi:moshi-kotlin", version.ref = "moshi-kotlin" }
+gson = { module = "com.google.code.gson:gson", version.ref = "gson" }
+kotlinx-benchmark-runtime = { module = "org.jetbrains.kotlinx:kotlinx-benchmark-runtime", version.ref = "kotlinx-benchmark-runtime" }
+plugin-kotlin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "plugin-kotlin" }
+plugin-kotlin-serialization = { module = "org.jetbrains.kotlin:kotlin-serialization", version.ref = "plugin-kotlin" }
+plugin-gver = { module = "com.github.ben-manes:gradle-versions-plugin", version.ref = "plugin-gver" }
+
+junit = { module="junit:junit", version.ref="junit"}
+
+[bundles]
+plugins = ["plugin-kotlin",  "plugin-kotlin-serialization", "plugin-gver"]

kotlin/gradle/wrapper/gradle-wrapper.properties

@@ -1,9 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-# Remove kotlin MPP warning
-kotlin.mpp.stability.nowarn=true
-# Needed to share source among different targets
-kotlin.mpp.enableGranularSourceSetsMetadata=true

kotlin/gradlew

@@ -1,7 +1,7 @@
-#!/usr/bin/env sh
+#!/bin/sh
 
 #
-# Copyright 2015 the original author or authors.
+# Copyright © 2015-2021 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,67 +17,101 @@
 #
 
 ##############################################################################
-##
+#
-##  Gradle start up script for UN*X
+#   Gradle start up script for POSIX generated by Gradle.
-##
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
+
 # Resolve links: $0 may be a link
-PRG="$0"
+app_path=$0
-# Need this for relative symlinks.
+
-while [ -h "$PRG" ] ; do
+# Need this for daisy-chained symlinks.
-    ls=`ls -ld "$PRG"`
+while
-    link=`expr "$ls" : '.*-> \(.*\)$'`
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    if expr "$link" : '/.*' > /dev/null; then
+    [ -h "$app_path" ]
-        PRG="$link"
+do
-    else
+    ls=$( ls -ld "$app_path" )
-        PRG=`dirname "$PRG"`"/$link"
+    link=${ls#*' -> '}
-    fi
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
 done
-SAVED="`pwd`"
+
-cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
 
 APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
+APP_BASE_NAME=${0##*/}
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
 warn () {
     echo "$*"
-}
+} >&2
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
+case "$( uname )" in                #(
-  CYGWIN* )
+  CYGWIN* )         cygwin=true  ;; #(
-    cygwin=true
+  Darwin* )         darwin=true  ;; #(
-    ;;
+  MSYS* | MINGW* )  msys=true    ;; #(
-  Darwin* )
+  NONSTOP* )        nonstop=true ;;
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
@@ -87,9 +121,9 @@ CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -98,7 +132,7 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
+    JAVACMD=java
     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
@@ -106,80 +140,95 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
+    case $MAX_FD in #(
-    if [ $? -eq 0 ] ; then
+      max*)
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+        MAX_FD=$( ulimit -H -n ) ||
-            MAX_FD="$MAX_FD_LIMIT"
+            warn "Could not query maximum file descriptor limit"
-        fi
+    esac
-        ulimit -n $MAX_FD
+    case $MAX_FD in  #(
-        if [ $? -ne 0 ] ; then
+      '' | soft) :;; #(
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
+      *)
-        fi
+        ulimit -n "$MAX_FD" ||
-    else
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=`expr $i + 1`
-    done
-    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
     esac
 fi
 
-# Escape application args
+# Collect all arguments for the java command, stacking in reverse order:
-save () {
+#   * args from the command line
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+#   * the main class name
-    echo " "
+#   * -classpath
-}
+#   * -D...appname settings
-APP_ARGS=`save "$@"`
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
+# For Cygwin or MSYS, switch paths to Windows format before running java
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
 
 exec "$JAVACMD" "$@"

kotlin/gradlew.bat

@@ -40,7 +40,7 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if "%ERRORLEVEL%" == "0" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -54,7 +54,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -64,21 +64,6 @@ echo location of your Java installation.
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
 :execute
 @rem Setup the command line
 
@@ -86,7 +71,7 @@ set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell

kotlin/settings.gradle

@@ -1,10 +0,0 @@
-pluginManagement {
-  repositories {
-    mavenCentral()
-    gradlePluginPortal()
-  }
-}
-
-
-rootProject.name = 'flatbuffers-kotlin'
-include 'flatbuffers-kotlin', "benchmark"

kotlin/settings.gradle.kts

@@ -0,0 +1,3 @@
+rootProject.name = "flatbuffers-kotlin"
+include("flatbuffers-kotlin")
+include("benchmark")

lobster/flatbuffers.lobster

@@ -175,25 +175,30 @@ class builder:
         while current_vtable.length <= slotnum: current_vtable.push(0)
         current_vtable[slotnum] = head
 
-    def __Finish(root_table:offset, size_prefix:int):
+    def __Finish(root_table:offset, size_prefix:int, file_identifier:string?):
         // Finish finalizes a buffer, pointing to the given root_table
         assert not finished
         assert not nested
         var prep_size = sz_32
+        if file_identifier:
+            prep_size += sz_32
         if size_prefix:
             prep_size += sz_32
         Prep(minalign, prep_size)
+        if file_identifier:
+            assert file_identifier.length == 4
+            buf, head = buf.write_substring_back(head, file_identifier, false)
         PrependUOffsetTRelative(root_table)
         if size_prefix:
             PrependInt32(head)
         finished = true
         return Start()
 
-    def Finish(root_table:offset):
+    def Finish(root_table:offset, file_identifier:string? = nil):
-        return __Finish(root_table, false)
+        return __Finish(root_table, false, file_identifier)
 
-    def FinishSizePrefixed(root_table:offset):
+    def FinishSizePrefixed(root_table:offset, file_identifier:string? = nil):
-        return __Finish(root_table, true)
+        return __Finish(root_table, true, file_identifier)
 
     def PrependBool(x):
         buf, head = buf.write_int8_le_back(head, x)
@@ -299,3 +304,9 @@ class builder:
             // elsewhere.
             assert x.o == head
             Slot(v)
+
+def has_identifier(buf:string, file_identifier:string):
+    assert file_identifier.length == 4
+    return buf.length >= 8 and buf.substring(4, 4) == file_identifier
+
+

net/FlatBuffers/ByteBuffer.cs

@@ -225,6 +225,18 @@ namespace FlatBuffers
             return SizeOf<T>() * x.Length;
         }
 
+        /// <summary>
+        /// Get the wire-size (in bytes) of an typed array segment, taking only the
+        /// range specified by <paramref name="x"/> into account.
+        /// </summary>
+        /// <typeparam name="T">The type of the array</typeparam>
+        /// <param name="x">The array segment to get the size of</param>
+        /// <returns>The number of bytes the array segment takes on wire</returns>
+        public static int ArraySize<T>(ArraySegment<T> x)
+        {
+            return SizeOf<T>() * x.Count;
+        }
+
 #if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         public static int ArraySize<T>(Span<T> x)
         {
@@ -869,7 +881,30 @@ namespace FlatBuffers
                 throw new ArgumentNullException("Cannot put a null array");
             }
 
-            if (x.Length == 0)
+            return Put(offset, new ArraySegment<T>(x));
+        }
+
+        /// <summary>
+        /// Copies an array segment of type T into this buffer, ending at the 
+        /// given offset into this buffer. The starting offset is calculated 
+        /// based on the count of the array segment and is the value returned.
+        /// </summary>
+        /// <typeparam name="T">The type of the input data (must be a struct)
+        /// </typeparam>
+        /// <param name="offset">The offset into this buffer where the copy 
+        /// will end</param>
+        /// <param name="x">The array segment to copy data from</param>
+        /// <returns>The 'start' location of this buffer now, after the copy 
+        /// completed</returns>
+        public int Put<T>(int offset, ArraySegment<T> x)
+            where T : struct
+        {
+            if (x.Equals(default(ArraySegment<T>)))
+            {
+                throw new ArgumentNullException("Cannot put a uninitialized array segment");
+            }
+
+            if (x.Count == 0)
             {
                 throw new ArgumentException("Cannot put an empty array");
             }
@@ -889,7 +924,68 @@ namespace FlatBuffers
 #if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
                 MemoryMarshal.Cast<T, byte>(x).CopyTo(_buffer.Span.Slice(offset, numBytes));
 #else
-                Buffer.BlockCopy(x, 0, _buffer.Buffer, offset, numBytes);
+                var srcOffset = ByteBuffer.SizeOf<T>() * x.Offset;
+                Buffer.BlockCopy(x.Array, srcOffset, _buffer.Buffer, offset, numBytes);
+#endif
+            }
+            else
+            {
+                throw new NotImplementedException("Big Endian Support not implemented yet " +
+                    "for putting typed arrays");
+                // if we are BE, we have to swap each element by itself
+                //for(int i = x.Length - 1; i >= 0; i--)
+                //{
+                //  todo: low priority, but need to genericize the Put<T>() functions
+                //}
+            }
+            return offset;
+        }
+
+        /// <summary>
+        /// Copies an array segment of type T into this buffer, ending at the 
+        /// given offset into this buffer. The starting offset is calculated 
+        /// based on the count of the array segment and is the value returned.
+        /// </summary>
+        /// <typeparam name="T">The type of the input data (must be a struct)
+        /// </typeparam>
+        /// <param name="offset">The offset into this buffer where the copy 
+        /// will end</param>
+        /// <param name="ptr">The pointer to copy data from</param>
+        /// <param name="sizeInBytes">The number of bytes to copy</param>
+        /// <returns>The 'start' location of this buffer now, after the copy 
+        /// completed</returns>
+        public int Put<T>(int offset, IntPtr ptr, int sizeInBytes)
+            where T : struct
+        {
+            if (ptr == IntPtr.Zero)
+            {
+                throw new ArgumentNullException("Cannot add a null pointer");
+            }
+
+            if(sizeInBytes <= 0)
+            {
+                throw new ArgumentException("Cannot put an empty array");
+            }
+
+            if (!IsSupportedType<T>())
+            {
+                throw new ArgumentException("Cannot put an array of type "
+                    + typeof(T) + " into this buffer");
+            }
+
+            if (BitConverter.IsLittleEndian)
+            {
+                offset -= sizeInBytes;
+                AssertOffsetAndLength(offset, sizeInBytes);
+                // if we are LE, just do a block copy
+#if ENABLE_SPAN_T && UNSAFE_BYTEBUFFER
+                unsafe
+                { 
+                    var span = new Span<byte>(ptr.ToPointer(), sizeInBytes);
+                    span.CopyTo(_buffer.Span.Slice(offset, sizeInBytes));
+                }
+#else
+                Marshal.Copy(ptr, _buffer.Buffer, offset, sizeInBytes);
 #endif
             }
             else

net/FlatBuffers/FlatBufferBuilder.cs

@@ -210,6 +210,31 @@ namespace FlatBuffers
             _space = _bb.Put(_space, x);
         }
 
+        /// <summary>
+        /// Puts an array of type T into this builder at the
+        /// current offset
+        /// </summary>
+        /// <typeparam name="T">The type of the input data </typeparam>
+        /// <param name="x">The array segment to copy data from</param>
+        public void Put<T>(ArraySegment<T> x)
+            where T : struct
+        {
+            _space = _bb.Put(_space, x);
+        }
+
+        /// <summary>
+        /// Puts data of type T into this builder at the
+        /// current offset
+        /// </summary>
+        /// <typeparam name="T">The type of the input data </typeparam>
+        /// <param name="ptr">The pointer to copy data from</param>
+        /// <param name="sizeInBytes">The length of the data in bytes</param>
+        public void Put<T>(IntPtr ptr, int sizeInBytes)
+            where T : struct
+        {
+            _space = _bb.Put<T>(_space, ptr, sizeInBytes);
+        }
+
 #if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         /// <summary>
         /// Puts a span of type T into this builder at the
@@ -297,13 +322,24 @@ namespace FlatBuffers
         /// <param name="x">The array to copy data from</param>
         public void Add<T>(T[] x)
             where T : struct
+        {
+            Add(new ArraySegment<T>(x));
+        }
+
+        /// <summary>
+        /// Add an array of type T to the buffer (aligns the data and grows if necessary).
+        /// </summary>
+        /// <typeparam name="T">The type of the input data</typeparam>
+        /// <param name="x">The array segment to copy data from</param>
+        public void Add<T>(ArraySegment<T> x)
+            where T : struct
         {
             if (x == null)
             {
                 throw new ArgumentNullException("Cannot add a null array");
             }
 
-            if( x.Length == 0)
+            if( x.Count == 0)
             {
                 // don't do anything if the array is empty
                 return;
@@ -317,10 +353,52 @@ namespace FlatBuffers
             int size = ByteBuffer.SizeOf<T>();
             // Need to prep on size (for data alignment) and then we pass the
             // rest of the length (minus 1) as additional bytes
-            Prep(size, size * (x.Length - 1));
+            Prep(size, size * (x.Count - 1));
             Put(x);
         }
 
+        /// <summary>
+        /// Adds the data of type T pointed to by the given pointer to the buffer (aligns the data and grows if necessary).
+        /// </summary>
+        /// <typeparam name="T">The type of the input data</typeparam>
+        /// <param name="ptr">The pointer to copy data from</param>
+        /// <param name="sizeInBytes">The data size in bytes</param>
+        public void Add<T>(IntPtr ptr, int sizeInBytes)
+            where T : struct
+        {
+            if(sizeInBytes == 0)
+            {
+                // don't do anything if the array is empty
+                return;
+            }
+
+            if (ptr == IntPtr.Zero)
+            {
+                throw new ArgumentNullException("Cannot add a null pointer");
+            }
+
+            if(sizeInBytes < 0)
+            {
+                throw new ArgumentOutOfRangeException("sizeInBytes", "sizeInBytes cannot be negative");
+            }
+
+            if(!ByteBuffer.IsSupportedType<T>())
+            {
+                throw new ArgumentException("Cannot add this Type array to the builder");
+            }
+
+            int size = ByteBuffer.SizeOf<T>();
+            if((sizeInBytes % size) != 0)
+            {
+                throw new ArgumentException("The given size in bytes " + sizeInBytes + " doesn't match the element size of T ( " + size + ")", "sizeInBytes");
+            }
+
+            // Need to prep on size (for data alignment) and then we pass the
+            // rest of the length (minus 1) as additional bytes
+            Prep(size, sizeInBytes - size);
+            Put<T>(ptr, sizeInBytes);
+        }
+
 #if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         /// <summary>
         /// Add a span of type T to the buffer (aligns the data and grows if necessary).

package.json

@@ -1,6 +1,6 @@
 {
   "name": "flatbuffers",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "Memory Efficient Serialization Library",
   "files": [
     "js/**/*.js",
@@ -9,14 +9,14 @@
     "mjs/**/*.d.ts",
     "ts/**/*.ts"
   ],
-  "main": "js/flatbuffers.js",
+  "main": "js/index.js",
-  "module": "mjs/flatbuffers.js",
+  "module": "mjs/index.js",
   "directories": {
     "doc": "docs",
     "test": "tests"
   },
   "scripts": {
-    "test": "npm run compile && cd tests && ./TypeScriptTest.sh",
+    "test": "npm run compile && cd tests && python3 ./TypeScriptTest.py",
     "compile": "tsc && tsc -p tsconfig.mjs.json",
     "prepublishOnly": "npm install --only=dev && npm run compile"
   },
@@ -35,9 +35,11 @@
   "homepage": "https://google.github.io/flatbuffers/",
   "dependencies": {},
   "devDependencies": {
+    "@bazel/typescript": "^5.2.0",
+    "@types/node": "17.0.21",
     "@typescript-eslint/eslint-plugin": "^4.12.0",
     "@typescript-eslint/parser": "^4.12.0",
     "eslint": "^7.17.0",
-    "typescript": "^4.1.3"
+    "typescript": "^4.5.5"
   }
 }

python/flatbuffers/builder.py

@@ -23,6 +23,8 @@ from .compat import range_func
 from .compat import memoryview_type
 from .compat import import_numpy, NumpyRequiredForThisFeature
 
+import warnings
+
 np = import_numpy()
 ## @file
 ## @addtogroup flatbuffers_python_api
@@ -75,6 +77,13 @@ class BuilderNotFinishedError(RuntimeError):
     """
     pass
 
+class EndVectorLengthMismatched(RuntimeError):
+    """
+    The number of elements passed to EndVector does not match the number 
+    specified in StartVector.
+    """
+    pass
+
 
 # VtableMetadataFields is the count of metadata fields in each vtable.
 VtableMetadataFields = 2
@@ -377,13 +386,20 @@ class Builder(object):
         return self.Offset()
     ## @endcond
 
-    def EndVector(self):
+    def EndVector(self, numElems = None):
         """EndVector writes data necessary to finish vector construction."""
 
         self.assertNested()
         ## @cond FLATBUFFERS_INTERNAL
         self.nested = False
         ## @endcond
+               
+        if numElems:
+            warnings.warn("numElems is deprecated.", 
+                          DeprecationWarning, stacklevel=2)
+            if numElems != self.vectorNumElems:
+                raise EndVectorLengthMismatched();
+
         # we already made space for this, so write without PrependUint32
         self.PlaceUOffsetT(self.vectorNumElems)
         self.vectorNumElems = None
@@ -562,9 +578,11 @@ class Builder(object):
         self.Place(off, flags)
 
     def PrependSlot(self, flags, o, x, d):
-        N.enforce_number(x, flags)
+        if x is not None:
-        N.enforce_number(d, flags)
+            N.enforce_number(x, flags)
-        if x != d or self.forceDefaults:
+        if d is not None:
+            N.enforce_number(d, flags)
+        if x != d or (self.forceDefaults and d is not None):
             self.Prepend(flags, x)
             self.Slot(o)
 

readme.md

@@ -2,6 +2,8 @@
 ===========
 
 ![Build status](https://github.com/google/flatbuffers/actions/workflows/build.yml/badge.svg?branch=master)
+[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/flatbuffers.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:flatbuffers)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/google/flatbuffers/badge)](https://api.securityscorecards.dev/projects/github.com/google/flatbuffers)
 [![Join the chat at https://gitter.im/google/flatbuffers](https://badges.gitter.im/google/flatbuffers.svg)](https://gitter.im/google/flatbuffers?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![Discord Chat](https://img.shields.io/discord/656202785926152206.svg)](https:///discord.gg/6qgKs3R)
 [![Twitter Follow](https://img.shields.io/twitter/follow/wvo.svg?style=social)](https://twitter.com/wvo)
@@ -33,6 +35,7 @@ maximum memory efficiency. It allows you to directly access serialized data with
 * PHP
 * Python
 * Rust
+* Swift
 * TypeScript
 
 *and more in progress...*

reflection/BUILD.bazel

@@ -0,0 +1,5 @@
+filegroup(
+    name = "reflection_fbs_schema",
+    srcs = ["reflection.fbs"],
+    visibility = ["//visibility:public"],
+)

reflection/reflection.fbs

@@ -37,6 +37,7 @@ table Type {
     index:int = -1;  // If base_type == Object, index into "objects" below.
                      // If base_type == Union, UnionType, or integral derived
                      // from an enum, index into "enums" below.
+                     // If base_type == Vector && element == Union or UnionType.
     fixed_length:uint16 = 0;  // Only if base_type == Array.
     /// The size (octets) of the `base_type` field.
     base_size:uint = 4; // 4 Is a common size due to offsets being that size.

reflection/ts/BUILD.bazel

@@ -0,0 +1,16 @@
+load("//:typescript.bzl", "flatbuffer_ts_library")
+
+genrule(
+    name = "copy_schema_to_folder",
+    srcs = ["//reflection:reflection_fbs_schema"],
+    outs = ["reflection.fbs"],
+    cmd = "cp $< $@",
+)
+
+flatbuffer_ts_library(
+    name = "reflection_ts_fbs",
+    package_name = "flatbuffers_reflection",
+    srcs = [":reflection.fbs"],
+    include_reflection = False,
+    visibility = ["//visibility:public"],
+)

rust/flatbuffers/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "flatbuffers"
-version = "2.1.0"
+version = "2.1.2"
 edition = "2018"
 authors = ["Robert Winslow <hello@rwinslow.com>", "FlatBuffers Maintainers"]
 license = "Apache-2.0"

rust/flatbuffers/src/array.rs

@@ -39,7 +39,7 @@ where
 impl<'a, T: 'a, const N: usize> Array<'a, T, N> {
     #[inline(always)]
     pub fn new(buf: &'a [u8]) -> Self {
-        debug_assert!(size_of::<T>() * N == buf.len());
+        assert!(size_of::<T>() * N == buf.len());
 
         Array {
             0: buf,
@@ -59,7 +59,7 @@ impl<'a, T: 'a, const N: usize> Array<'a, T, N> {
 impl<'a, T: Follow<'a> + 'a, const N: usize> Array<'a, T, N> {
     #[inline(always)]
     pub fn get(&self, idx: usize) -> T::Inner {
-        debug_assert!(idx < N);
+        assert!(idx < N);
         let sz = size_of::<T>();
         T::follow(self.0, sz * idx)
     }

rust/flatbuffers/src/vector.rs

@@ -84,7 +84,7 @@ impl<'a, T: 'a> Vector<'a, T> {
 impl<'a, T: Follow<'a> + 'a> Vector<'a, T> {
     #[inline(always)]
     pub fn get(&self, idx: usize) -> T::Inner {
-        debug_assert!(idx < self.len() as usize);
+        assert!(idx < self.len() as usize);
         let sz = size_of::<T>();
         debug_assert!(sz > 0);
         T::follow(self.0, self.1 as usize + SIZE_UOFFSET + sz * idx)

rust/flatbuffers/src/verifier.rs

@@ -6,7 +6,8 @@ use crate::follow::Follow;
 use crate::{ForwardsUOffset, SOffsetT, SkipSizePrefix, UOffsetT, VOffsetT, Vector, SIZE_UOFFSET};
 
 #[cfg(feature="no_std")]
-extern crate thiserror_core2 as thiserror;
+use thiserror_core2::Error;
+#[cfg(not(feature="no_std"))]
 use thiserror::Error;
 
 /// Traces the location of data errors. Not populated for Dos detecting errors.

samples/monster_generated.h

@@ -6,6 +6,13 @@
 
 #include "flatbuffers/flatbuffers.h"
 
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 2 &&
+              FLATBUFFERS_VERSION_MINOR == 0 &&
+              FLATBUFFERS_VERSION_REVISION == 7,
+             "Non-compatible flatbuffers version included");
+
 namespace MyGame {
 namespace Sample {
 
@@ -549,7 +556,7 @@ inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
       (lhs.name == rhs.name) &&
       (lhs.inventory == rhs.inventory) &&
       (lhs.color == rhs.color) &&
-      (lhs.weapons == rhs.weapons) &&
+      (lhs.weapons.size() == rhs.weapons.size() && std::equal(lhs.weapons.cbegin(), lhs.weapons.cend(), rhs.weapons.cbegin(), [](flatbuffers::unique_ptr<MyGame::Sample::WeaponT> const &a, flatbuffers::unique_ptr<MyGame::Sample::WeaponT> const &b) { return (a == b) || (a && b && *a == *b); })) &&
       (lhs.equipped == rhs.equipped) &&
       (lhs.path == rhs.path);
 }
@@ -569,7 +576,7 @@ inline MonsterT::MonsterT(const MonsterT &o)
         equipped(o.equipped),
         path(o.path) {
   weapons.reserve(o.weapons.size());
-  for (const auto &v : o.weapons) { weapons.emplace_back((v) ? new MyGame::Sample::WeaponT(*v) : nullptr); }
+  for (const auto &weapons_ : o.weapons) { weapons.emplace_back((weapons_) ? new MyGame::Sample::WeaponT(*weapons_) : nullptr); }
 }
 
 inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT {
@@ -600,7 +607,7 @@ inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function
   { auto _e = name(); if (_e) _o->name = _e->str(); }
   { auto _e = inventory(); if (_e) { _o->inventory.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->inventory.begin()); } }
   { auto _e = color(); _o->color = _e; }
-  { auto _e = weapons(); if (_e) { _o->weapons.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->weapons[_i]) { _e->Get(_i)->UnPackTo(_o->weapons[_i].get(), _resolver); } else { _o->weapons[_i] = flatbuffers::unique_ptr<MyGame::Sample::WeaponT>(_e->Get(_i)->UnPack(_resolver)); }; } } }
+  { auto _e = weapons(); if (_e) { _o->weapons.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->weapons[_i] = flatbuffers::unique_ptr<MyGame::Sample::WeaponT>(_e->Get(_i)->UnPack(_resolver)); } } }
   { auto _e = equipped_type(); _o->equipped.type = _e; }
   { auto _e = equipped(); if (_e) _o->equipped.value = MyGame::Sample::EquipmentUnion::UnPack(_e, equipped_type(), _resolver); }
   { auto _e = path(); if (_e) { _o->path.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->path[_i] = *_e->Get(_i); } } }
@@ -614,7 +621,7 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
   (void)_rehasher;
   (void)_o;
   struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
-  auto _pos = _o->pos ? _o->pos.get() : 0;
+  auto _pos = _o->pos ? _o->pos.get() : nullptr;
   auto _mana = _o->mana;
   auto _hp = _o->hp;
   auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);

samples/monster_generated.lobster

@@ -19,11 +19,11 @@ class Monster
 class Weapon
 
 class Vec3 : flatbuffers_handle
-    def x():
+    def x() -> float:
         return buf_.read_float32_le(pos_ + 0)
-    def y():
+    def y() -> float:
         return buf_.read_float32_le(pos_ + 4)
-    def z():
+    def z() -> float:
         return buf_.read_float32_le(pos_ + 8)
 
 def CreateVec3(b_:flatbuffers_builder, x:float, y:float, z:float):
@@ -34,32 +34,32 @@ def CreateVec3(b_:flatbuffers_builder, x:float, y:float, z:float):
     return b_.Offset()
 
 class Monster : flatbuffers_handle
-    def pos():
+    def pos() -> MyGame_Sample_Vec3?:
         let o = buf_.flatbuffers_field_struct(pos_, 4)
         return if o: MyGame_Sample_Vec3 { buf_, o } else: nil
-    def mana():
+    def mana() -> int:
         return buf_.flatbuffers_field_int16(pos_, 6, 150)
-    def hp():
+    def hp() -> int:
         return buf_.flatbuffers_field_int16(pos_, 8, 100)
-    def name():
+    def name() -> string:
         return buf_.flatbuffers_field_string(pos_, 10)
-    def inventory(i:int):
+    def inventory(i:int) -> int:
-        return buf_.read_int8_le(buf_.flatbuffers_field_vector(pos_, 14) + i * 1)
+        return buf_.read_uint8_le(buf_.flatbuffers_field_vector(pos_, 14) + i * 1)
-    def inventory_length():
+    def inventory_length() -> int:
         return buf_.flatbuffers_field_vector_len(pos_, 14)
-    def color():
+    def color() -> Color:
         return Color(buf_.flatbuffers_field_int8(pos_, 16, 2))
-    def weapons(i:int):
+    def weapons(i:int) -> MyGame_Sample_Weapon:
         return MyGame_Sample_Weapon { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 18) + i * 4) }
-    def weapons_length():
+    def weapons_length() -> int:
         return buf_.flatbuffers_field_vector_len(pos_, 18)
-    def equipped_type():
+    def equipped_type() -> Equipment:
-        return Equipment(buf_.flatbuffers_field_int8(pos_, 20, 0))
+        return Equipment(buf_.flatbuffers_field_uint8(pos_, 20, 0))
     def equipped_as_Weapon():
         return MyGame_Sample_Weapon { buf_, buf_.flatbuffers_field_table(pos_, 22) }
-    def path(i:int):
+    def path(i:int) -> MyGame_Sample_Vec3:
         return MyGame_Sample_Vec3 { buf_, buf_.flatbuffers_field_vector(pos_, 24) + i * 12 }
-    def path_length():
+    def path_length() -> int:
         return buf_.flatbuffers_field_vector_len(pos_, 24)
 
 def GetRootAsMonster(buf:string): return Monster { buf, buf.flatbuffers_indirect(0) }
@@ -120,9 +120,9 @@ def MonsterStartPathVector(b_:flatbuffers_builder, n_:int):
     b_.StartVector(12, n_, 4)
 
 class Weapon : flatbuffers_handle
-    def name():
+    def name() -> string:
         return buf_.flatbuffers_field_string(pos_, 4)
-    def damage():
+    def damage() -> int:
         return buf_.flatbuffers_field_int16(pos_, 6, 0)
 
 def GetRootAsWeapon(buf:string): return Weapon { buf, buf.flatbuffers_indirect(0) }

samples/rust_generated/mod.rs

@@ -1,4 +1,5 @@
 // Automatically generated by the Flatbuffers compiler. Do not modify.
+// @generated
 pub mod my_game {
   use super::*;
   pub mod sample {

samples/rust_generated/my_game/sample/color_generated.rs

@@ -1,7 +1,12 @@
 // automatically generated by the FlatBuffers compiler, do not modify
+// @generated
+extern crate alloc;
 extern crate flatbuffers;
-use std::mem;
+use alloc::boxed::Box;
-use std::cmp::Ordering;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+use core::mem;
+use core::cmp::Ordering;
 use self::flatbuffers::{EndianScalar, Follow};
 use super::*;
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
@@ -42,8 +47,8 @@ impl Color {
     }
   }
 }
-impl std::fmt::Debug for Color {
+impl core::fmt::Debug for Color {
-  fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
     if let Some(name) = self.variant_name() {
       f.write_str(name)
     } else {