WIP

This is nice for deployments

.github/workflows/npm.yml

@@ -0,0 +1,446 @@
+name: nodejs
+env:
+  DEBUG: napi:*
+  APP_NAME: nodejs
+  MACOSX_DEPLOYMENT_TARGET: '10.13'
+permissions:
+  contents: write
+  id-token: write
+'on':
+  workflow_dispatch:
+    inputs:
+      publish:
+        description: "Publish to npm"
+        required: true
+        type: boolean
+defaults:
+  run:
+    working-directory: ./bindings/nodejs
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        settings:
+          - host: macos-latest
+            target: x86_64-apple-darwin
+            build: yarn build --target x86_64-apple-darwin
+          - host: windows-latest
+            build: yarn build --target x86_64-pc-windows-msvc
+            target: x86_64-pc-windows-msvc
+          - host: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian
+            build: yarn build --target x86_64-unknown-linux-gnu
+          - host: ubuntu-latest
+            target: x86_64-unknown-linux-musl
+            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine
+            build: yarn build --target x86_64-unknown-linux-musl
+          - host: macos-latest
+            target: aarch64-apple-darwin
+            build: yarn build --target aarch64-apple-darwin
+          - host: ubuntu-latest
+            target: aarch64-unknown-linux-gnu
+            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian-aarch64
+            build: yarn build --target aarch64-unknown-linux-gnu
+          - host: ubuntu-latest
+            target: armv7-unknown-linux-gnueabihf
+            setup: |
+              sudo apt-get update
+              sudo apt-get install gcc-arm-linux-gnueabihf -y
+            build: yarn build --target armv7-unknown-linux-gnueabihf
+          - host: ubuntu-latest
+            target: armv7-unknown-linux-musleabihf
+            build: yarn build --target armv7-unknown-linux-musleabihf
+          - host: ubuntu-latest
+            target: aarch64-linux-android
+            build: yarn build --target aarch64-linux-android
+          - host: ubuntu-latest
+            target: armv7-linux-androideabi
+            build: yarn build --target armv7-linux-androideabi
+          - host: ubuntu-latest
+            target: aarch64-unknown-linux-musl
+            docker: ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine
+            build: |-
+              set -e &&
+              rustup target add aarch64-unknown-linux-musl &&
+              yarn build --target aarch64-unknown-linux-musl
+          - host: windows-latest
+            target: aarch64-pc-windows-msvc
+            build: yarn build --target aarch64-pc-windows-msvc
+          - host: ubuntu-latest
+            target: riscv64gc-unknown-linux-gnu
+            setup: |
+              sudo apt-get update
+              sudo apt-get install gcc-riscv64-linux-gnu -y
+            build: yarn build --target riscv64gc-unknown-linux-gnu
+    name: stable - ${{ matrix.settings.target }} - node@20
+    runs-on: ${{ matrix.settings.host }}
+    defaults:
+      run:
+        working-directory: ./bindings/nodejs
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup node
+        uses: actions/setup-node@v4
+        if: ${{ !matrix.settings.docker }}
+        with:
+          node-version: 20
+          cache: yarn
+          cache-dependency-path: "bindings/nodejs"
+      - name: Install
+        uses: dtolnay/rust-toolchain@stable
+        if: ${{ !matrix.settings.docker }}
+        with:
+          toolchain: stable
+          targets: ${{ matrix.settings.target }}
+      - name: Cache cargo
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            .cargo-cache
+            target/
+          key: ${{ matrix.settings.target }}-cargo-${{ matrix.settings.host }}
+      - uses: goto-bus-stop/setup-zig@v2
+        if: ${{ matrix.settings.target == 'armv7-unknown-linux-gnueabihf' || matrix.settings.target == 'armv7-unknown-linux-musleabihf' }}
+        with:
+          version: 0.13.0
+      - name: Setup toolchain
+        run: ${{ matrix.settings.setup }}
+        if: ${{ matrix.settings.setup }}
+        shell: bash
+      - name: Install dependencies
+        run: yarn install
+      - name: Build in docker
+        uses: addnab/docker-run-action@v3
+        if: ${{ matrix.settings.docker }}
+        with:
+          image: ${{ matrix.settings.docker }}
+          options: '--user 0:0 -v ${{ github.workspace }}/.cargo-cache/git/db:/usr/local/cargo/git/db -v ${{ github.workspace }}/.cargo/registry/cache:/usr/local/cargo/registry/cache -v ${{ github.workspace }}/.cargo/registry/index:/usr/local/cargo/registry/index -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
+          run: ${{ matrix.settings.build }}
+      - name: Build
+        run: ${{ matrix.settings.build }}
+        if: ${{ !matrix.settings.docker }}
+        shell: bash
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: bindings-${{ matrix.settings.target }}
+          path: bindings/nodejs/${{ env.APP_NAME }}.*.node
+          if-no-files-found: error
+  test-macOS-windows-binding:
+    name: Test bindings on ${{ matrix.settings.target }} - node@${{ matrix.node }}
+    needs:
+      - build
+    strategy:
+      fail-fast: false
+      matrix:
+        settings:
+          - host: macos-latest
+            target: x86_64-apple-darwin
+          - host: windows-latest
+            target: x86_64-pc-windows-msvc
+        node:
+          - '18'
+          - '20'
+    runs-on: ${{ matrix.settings.host }}
+    defaults:
+      run:
+        working-directory: ./bindings/nodejs
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup node
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node }}
+          cache: yarn
+          cache-dependency-path: "bindings/nodejs"
+          architecture: x64
+      - name: Install dependencies
+        run: yarn install
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: bindings-${{ matrix.settings.target }}
+          path: bindings/nodejs/
+      - name: List packages
+        run: ls -R .
+        shell: bash
+      - name: Test bindings
+        run: yarn test
+  test-linux-x64-gnu-binding:
+    name: Test bindings on Linux-x64-gnu - node@${{ matrix.node }}
+    needs:
+      - build
+    strategy:
+      fail-fast: false
+      matrix:
+        node:
+          - '18'
+          - '20'
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./bindings/nodejs
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup node
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node }}
+          cache: yarn
+          cache-dependency-path: "bindings/nodejs"
+      - name: Install dependencies
+        run: yarn install
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: bindings-x86_64-unknown-linux-gnu
+          path: bindings/nodejs/
+      - name: List packages
+        run: ls -R .
+        shell: bash
+      - name: Test bindings
+        run: docker run --rm -v $(pwd):/build -w /build/bindings/nodejs node:${{ matrix.node }}-slim yarn test
+  test-linux-x64-musl-binding:
+    name: Test bindings on x86_64-unknown-linux-musl - node@${{ matrix.node }}
+    needs:
+      - build
+    strategy:
+      fail-fast: false
+      matrix:
+        node:
+          - '18'
+          - '20'
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./bindings/nodejs
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup node
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node }}
+          cache: yarn
+          cache-dependency-path: "bindings/nodejs"
+      - name: Install dependencies
+        run: |
+          yarn config set supportedArchitectures.libc "musl"
+          yarn install
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: bindings-x86_64-unknown-linux-musl
+          path: bindings/nodejs/
+      - name: List packages
+        run: ls -R .
+        shell: bash
+      - name: Test bindings
+        run: docker run --rm -v $(pwd):/build -w /build/bindings/nodejs node:${{ matrix.node }}-alpine yarn test
+  test-linux-aarch64-gnu-binding:
+    name: Test bindings on aarch64-unknown-linux-gnu - node@${{ matrix.node }}
+    needs:
+      - build
+    strategy:
+      fail-fast: false
+      matrix:
+        node:
+          - '18'
+          - '20'
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./bindings/nodejs
+    steps:
+      - uses: actions/checkout@v4
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: bindings-aarch64-unknown-linux-gnu
+          path: bindings/nodejs/
+      - name: List packages
+        run: ls -R .
+        shell: bash
+      - name: Install dependencies
+        run: |
+          yarn config set supportedArchitectures.cpu "arm64"
+          yarn config set supportedArchitectures.libc "glibc"
+          yarn install
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        with:
+          platforms: arm64
+      - run: docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
+      - name: Setup and run tests
+        uses: addnab/docker-run-action@v3
+        with:
+          image: node:${{ matrix.node }}-slim
+          options: '--platform linux/arm64 -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
+          run: |
+            set -e
+            yarn test
+            ls -la
+  test-linux-aarch64-musl-binding:
+    name: Test bindings on aarch64-unknown-linux-musl - node@${{ matrix.node }}
+    needs:
+      - build
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./bindings/nodejs
+    steps:
+      - uses: actions/checkout@v4
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: bindings-aarch64-unknown-linux-musl
+          path: bindings/nodejs/
+      - name: List packages
+        run: ls -R .
+        shell: bash
+      - name: Install dependencies
+        run: |
+          yarn config set supportedArchitectures.cpu "arm64"
+          yarn config set supportedArchitectures.libc "musl"
+          yarn install
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        with:
+          platforms: arm64
+      - run: docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
+      - name: Setup and run tests
+        uses: addnab/docker-run-action@v3
+        with:
+          image: node:lts-alpine
+          options: '--platform linux/arm64 -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
+          run: |
+            set -e
+            yarn test
+  test-linux-arm-gnueabihf-binding:
+    name: Test bindings on armv7-unknown-linux-gnueabihf - node@${{ matrix.node }}
+    needs:
+      - build
+    strategy:
+      fail-fast: false
+      matrix:
+        node:
+          - '18'
+          - '20'
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./bindings/nodejs
+    steps:
+      - uses: actions/checkout@v4
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: bindings-armv7-unknown-linux-gnueabihf
+          path: bindings/nodejs/
+      - name: List packages
+        run: ls -R .
+        shell: bash
+      - name: Install dependencies
+        run: |
+          yarn config set supportedArchitectures.cpu "arm"
+          yarn install
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        with:
+          platforms: arm
+      - run: docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
+      - name: Setup and run tests
+        uses: addnab/docker-run-action@v3
+        with:
+          image: node:${{ matrix.node }}-bullseye-slim
+          options: '--platform linux/arm/v7 -v ${{ github.workspace }}:/build -w /build/bindings/nodejs'
+          run: |
+            set -e
+            yarn test
+            ls -la
+  universal-macOS:
+    name: Build universal macOS binary
+    needs:
+      - build
+    runs-on: macos-latest
+    defaults:
+      run:
+        working-directory: ./bindings/nodejs
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: yarn
+          cache-dependency-path: "bindings/nodejs"
+      - name: Install dependencies
+        run: yarn install
+      - name: Download macOS x64 artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: bindings-x86_64-apple-darwin
+          path: bindings/nodejs/artifacts
+      - name: Download macOS arm64 artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: bindings-aarch64-apple-darwin
+          path: bindings/nodejs/artifacts
+      - name: Combine binaries
+        run: yarn universal
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: bindings-universal-apple-darwin
+          path: bindings/nodejs/${{ env.APP_NAME }}.*.node
+          if-no-files-found: error
+  publish:
+    name: Publish
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./bindings/nodejs
+    needs:
+      - test-macOS-windows-binding
+      - test-linux-x64-gnu-binding
+      - test-linux-x64-musl-binding
+      - test-linux-aarch64-gnu-binding
+      - test-linux-aarch64-musl-binding
+      - test-linux-arm-gnueabihf-binding
+      - universal-macOS
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: yarn
+          cache-dependency-path: "bindings/nodejs"
+      - name: Install dependencies
+        run: yarn install
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: bindings/nodejs/artifacts
+      - name: Move artifacts
+        run: yarn artifacts
+      - name: List packages
+        run: ls -R ./npm
+        shell: bash
+      - name: Publish
+        run: |
+          echo "${{ github.event.inputs.publish }}"
+          if [ "${{ github.event.inputs.publish }}" = "true" ]; then
+            echo "//registry.npmjs.org/:_authToken=$NPM_TOKEN" >> ~/.npmrc
+            npm publish --access public
+            echo "Published to npm"
+          else
+            echo "Not a release, skipping publish"
+          fi
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/publish-wiki.yml

@@ -1,18 +0,0 @@
-name: Publish wiki
-on:
-  push:
-    branches: [main]
-    paths:
-      - wiki/**
-      - .github/workflows/publish-wiki.yml
-concurrency:
-  group: publish-wiki
-  cancel-in-progress: true
-permissions:
-  contents: write
-jobs:
-  publish-wiki:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: Andrew-Chen-Wang/github-wiki-action@v4

.github/workflows/pypi.yml

@@ -0,0 +1,141 @@
+name: Upload component to Python Package Index
+
+on:
+  workflow_dispatch:
+    inputs:
+      release:
+        type: boolean
+        default: false
+        required: false
+        description: "Release? If false, publish to test.pypi.org, if true, publish to pypi.org"
+
+permissions:
+  contents: read
+
+jobs:
+  linux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [x86_64, x86, aarch64, armv7, s390x, ppc64le]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist --find-interpreter
+          sccache: 'true'
+          manylinux: auto
+          working-directory: bindings/python
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ runner.os }}-${{ matrix.target }}
+          path: bindings/python/dist
+
+  windows:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        target: [x64, x86]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+          architecture: ${{ matrix.target }}
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist --find-interpreter
+          sccache: 'true'
+          working-directory: bindings/python
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ runner.os }}-${{ matrix.target }}
+          path: bindings/python/dist
+
+  macos:
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        target: [x86_64, aarch64]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+      - name: Build wheels
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist --find-interpreter
+          sccache: 'true'
+          working-directory: bindings/python
+      - name: Upload wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ runner.os }}-${{ matrix.target }}
+          path: bindings/python/dist
+
+  sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Build sdist
+        uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out dist
+          working-directory: bindings/python
+      - name: Upload sdist
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ runner.os }}-sdist
+          path: bindings/python/dist
+
+  publish-to-test-pypi:
+    if: ${{ github.event.inputs.release != 'true' }}
+    name: >-
+        Publish Python 🐍 distribution 📦 to Test PyPI
+    runs-on: ubuntu-latest
+    needs: [linux, windows, macos, sdist]
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          path: bindings/python/
+      - name: Publish distribution 📦 to Test PyPI
+        uses: PyO3/maturin-action@v1
+        env:
+          MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_TEST_API_TOKEN }}
+          MATURIN_REPOSITORY_URL: "https://test.pypi.org/legacy/"
+        with:
+          command: upload
+          args: "--skip-existing **/*.whl **/*.tar.gz"
+          working-directory: bindings/python
+
+  publish-pypi:
+    if: ${{ github.event.inputs.release == 'true' }}
+    name: >-
+        Publish Python 🐍 distribution 📦 to PyPI
+    runs-on: ubuntu-latest
+    needs: [linux, windows, macos, sdist]
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          path: bindings/python/
+      - name: Publish distribution 📦 to PyPI
+        uses: PyO3/maturin-action@v1
+        env:
+          MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+          MATURIN_REPOSITORY_URL: "https://upload.pypi.org/legacy/"
+        with:
+          command: upload
+          args: "--skip-existing **/*.whl **/*.tar.gz"
+          working-directory: bindings/python

.github/workflows/test-coverage.yaml

@@ -1,6 +1,7 @@
 name: Coverage
 
-on: [pull_request]
+on:
+  workflow_dispatch:
 
 jobs:
   coverage:
@@ -14,10 +15,11 @@ jobs:
       - name: Install cargo-llvm-cov
         uses: taiki-e/install-action@cargo-llvm-cov
       - name: Generate code coverage
-        run: cargo llvm-cov --all-features --workspace --lcov --output-path lcov.info
+        run: cargo llvm-cov --all-features --workspace --exclude pyroncalc --exclude wasm --lcov --output-path lcov.info
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v3
+        uses: codecov/codecov-action@v5
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
         with:
-          token: ${{ secrets.CODECOV_TOKEN }}
           files: lcov.info
           fail_ci_if_error: true

.gitignore

@@ -1,2 +1,3 @@
 target/*
+**/node_modules/**
 .DS_Store

.readthedocs.yaml

@@ -0,0 +1,32 @@
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version and other tools you might need
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.12"
+    # You can also specify other tool versions:
+    # nodejs: "19"
+    # rust: "1.64"
+    # golang: "1.19"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+  configuration: bindings/python/docs/conf.py
+
+# Optionally build your docs in additional formats such as PDF and ePub
+# formats:
+#    - pdf
+#    - epub
+
+# Optional but recommended, declare the Python requirements required
+# to build your documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+# python:
+#    install:
+#    - requirements: docs/requirements.txt

CHANGELOG.md

@@ -0,0 +1,36 @@
+# CHANGELOG
+
+## Unreleased
+
+### Added
+
+- New function UNICODE ([#128](https://github.com/ironcalc/IronCalc/pull/128))
+- New document server (Thanks Dani!)
+- New function FORMULATEXT
+- Name Manager ([#212](https://github.com/ironcalc/IronCalc/pull/212) [#220](https://github.com/ironcalc/IronCalc/pull/220))
+- Add context menu. We can now insert rows and columns. Freeze and unfreeze rows and columns. Delete rows and columns [#271]
+- Add nodejs bindings [#254]
+- Add python bindings for all platforms
+- Add is split into the product and widget
+- Add Python documentation [#260]
+
+### Fixed
+
+- Fixed several issues with pasting content
+- Fixed several issues with borders
+- Fixed bug where columns and rows could be resized to negative width and height, respectively
+- Undo/redo when add/delete sheet now works [#270]
+- Numerous small fixes
+- Multiple fixes to the documentation
+
+## [0.2.0] - 2024-11-06 (The HN release)
+
+### Added
+
+- Rust crate ironcalc_base
+- Rust crate ironcalc
+- Minimal Python bindings (only Linux)
+- JavaScript bindings
+- React WebApp
+
+[0.2.0]: https://github.com/IronCalc/ironcalc/releases/tag/v0.2.0

CONTRIBUTING.md

@@ -0,0 +1,73 @@
+# Contributing to IronCalc
+
+Whether you are a seasoned developer or a rookie, welcome to IronCalc! 
+
+🎉 We appreciate your interest in contributing to our project.
+
+Before starting any work it is best if you get in touch to make sure your work is relevant.
+
+Please be patient, I am only one and this is a side project.
+
+---
+
+## 🛠 Changes to the main repo
+
+If are comfortable working with GitHub and Git, the following steps should be straightforward. For more general information visit [GitHub Docs](https://docs.github.com/en) and [Git Documentation](https://git-scm.com/doc). 
+
+1. **Fork the repository**
+   Start by forking the repository to your own GitHub account. You can do this by clicking the "Fork" button on the top right of the repository page.
+
+2. **Clone the original repository**
+   Clone the original repository to your local machine:
+   ```bash
+   git clone https://github.com/ironcalc/IronCalc.git
+   cd IronCalc
+   ```
+
+
+3. **Add your fork as a remote**
+    Add your forked repository as a remote named fork:
+
+    ```bash
+    git remote add fork https://github.com/<your-username>/IronCalc.git
+    ```
+4. **Create a new branch**
+    Always create a new branch for your changes to keep your work isolated:
+
+    ```bash
+    git checkout -b your-feature-name
+    ```
+5. **Make changes**
+    Implement your changes, improvements, or bug fixes. Make sure to follow any coding style or project-specific guidelines.
+
+6. **Commit your changes**
+    Write clear and concise commit messages:
+
+    ```bash
+    git add .
+    git commit -m "Brief description of your changes"
+    ```
+7. **Push to your fork**
+    Push your branch to your forked repository:
+    ```bash
+    git push fork your-feature-name
+    ````
+
+8. **Create a Pull Request (PR)**
+   Follow the steps on the terminal or go to the orig IronCalc repository, and click on "New Pull Request."
+   Ensure your PR has a clear title and description explaining the purpose of your changes.
+
+Always start from the main branch in a clean state. `git pull` will generally get the lastest changes form the original repo.
+
+You should make sure that your changes are properly tested.
+
+# 🤝 Community and Support
+
+Feel free to reach out if you have questions or need help. Via GitHub, email, our discord server or bluesky.
+
+* Open an issue to report a bug or discuss a feature before implementing it.
+* Engage with the community to share ideas or seek guidance.
+
+Note that not all contributors need to be coding. To contribute testing, bug reports, typos, ideas of all kinds, you can just send us an email.
+
+Thank you for your contributions! 💪 Together, we can make IronCalc even better.

Cargo.lock

@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "adler"
@@ -43,6 +43,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
 [[package]]
 name = "autocfg"
 version = "1.2.0"
@@ -57,25 +63,34 @@ checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
 
 [[package]]
 name = "bitcode"
-version = "0.6.0"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48bc1c27654127a24c476d40198746860ef56475f41a601bfa5c4d0f832968f0"
+checksum = "ee1bce7608560cd4bf0296a4262d0dbf13e6bcec5ff2105724c8ab88cc7fc784"
 dependencies = [
+ "arrayvec",
  "bitcode_derive",
  "bytemuck",
+ "glam",
+ "serde",
 ]
 
 [[package]]
 name = "bitcode_derive"
-version = "0.6.0"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2966755a19aad59ee2aae91e2d48842c667a99d818ec72168efdab07200701cc"
+checksum = "a539389a13af092cd345a2b47ae7dec12deb306d660b2223d25cd3419b253ebe"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
 ]
 
+[[package]]
+name = "bitflags"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f68f53c83ab957f72c32642f3868eec03eb974d1fb82e453128456482613d36"
+
 [[package]]
 name = "block-buffer"
 version = "0.10.4"
@@ -142,9 +157,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.37"
+version = "0.4.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a0d04d43504c61aa6c7531f1871dd0d418d91130162063b789da00fd7057a5e"
+checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
@@ -156,9 +171,9 @@ dependencies = [
 
 [[package]]
 name = "chrono-tz"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93698b29de5e97ad0ae26447b344c482a7284c737d9ddc5f9e52b74a336671bb"
+checksum = "cd6dd8046d00723a59a2f8c5f295c515b9bb9a331ee4f8f3d4dd49e428acd3b6"
 dependencies = [
  "chrono",
  "chrono-tz-build",
@@ -167,12 +182,11 @@ dependencies = [
 
 [[package]]
 name = "chrono-tz-build"
-version = "0.3.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c088aee841df9c3041febbb73934cfc39708749bf96dc827e3359cd39ef11b1"
+checksum = "e94fea34d77a245229e7746bd2beb786cd2a896f306ff491fb8cecb3074b10a7"
 dependencies = [
  "parse-zoneinfo",
- "phf",
  "phf_codegen",
 ]
 
@@ -202,6 +216,15 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
 
+[[package]]
+name = "convert_case"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
+dependencies = [
+ "unicode-segmentation",
+]
+
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.6"
@@ -242,6 +265,37 @@ dependencies = [
  "typenum",
 ]
 
+[[package]]
+name = "csv"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac574ff4d437a7b5ad237ef331c17ccca63c46479e5b5453eb8e10bb99a759fe"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5efa2b3d7902f4b634a20cae3c9c4e6209dc4779feb6863329607560143efa70"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "ctor"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a2785755761f3ddc1492979ce1e48d2c00d09311c39e4466429188f3dd6501"
+dependencies = [
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "deranged"
 version = "0.3.11"
@@ -299,6 +353,18 @@ dependencies = [
  "wasi",
 ]
 
+[[package]]
+name = "glam"
+version = "0.29.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc46dd3ec48fdd8e693a98d2b8bafae273a2d54c1de02a2a7e3d57d501f39677"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
 [[package]]
 name = "hmac"
 version = "0.12.1"
@@ -331,6 +397,12 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "indoc"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"
+
 [[package]]
 name = "inout"
 version = "0.1.3"
@@ -342,7 +414,7 @@ dependencies = [
 
 [[package]]
 name = "ironcalc"
-version = "0.1.3"
+version = "0.5.0"
 dependencies = [
  "bitcode",
  "chrono",
@@ -358,20 +430,32 @@ dependencies = [
 
 [[package]]
 name = "ironcalc_base"
-version = "0.1.3"
+version = "0.5.0"
 dependencies = [
  "bitcode",
  "chrono",
  "chrono-tz",
+ "csv",
  "js-sys",
- "once_cell",
  "rand",
  "regex",
+ "regex-lite",
  "ryu",
  "serde",
  "serde_json",
 ]
 
+[[package]]
+name = "ironcalc_nodejs"
+version = "0.5.0"
+dependencies = [
+ "ironcalc",
+ "napi",
+ "napi-build",
+ "napi-derive",
+ "serde",
+]
+
 [[package]]
 name = "itertools"
 version = "0.12.1"
@@ -411,6 +495,16 @@ version = "0.2.153"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
 
+[[package]]
+name = "libloading"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
+dependencies = [
+ "cfg-if",
+ "windows-targets",
+]
+
 [[package]]
 name = "log"
 version = "0.4.21"
@@ -423,6 +517,15 @@ version = "2.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"
 
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "miniz_oxide"
 version = "0.7.2"
@@ -432,6 +535,65 @@ dependencies = [
  "adler",
 ]
 
+[[package]]
+name = "napi"
+version = "2.16.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "214f07a80874bb96a8433b3cdfc84980d56c7b02e1a0d7ba4ba0db5cef785e2b"
+dependencies = [
+ "bitflags",
+ "ctor",
+ "napi-derive",
+ "napi-sys",
+ "once_cell",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "napi-build"
+version = "2.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db836caddef23662b94e16bf1f26c40eceb09d6aee5d5b06a7ac199320b69b19"
+
+[[package]]
+name = "napi-derive"
+version = "2.16.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cbe2585d8ac223f7d34f13701434b9d5f4eb9c332cccce8dee57ea18ab8ab0c"
+dependencies = [
+ "cfg-if",
+ "convert_case",
+ "napi-derive-backend",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "napi-derive-backend"
+version = "1.0.75"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1639aaa9eeb76e91c6ae66da8ce3e89e921cd3885e99ec85f4abacae72fc91bf"
+dependencies = [
+ "convert_case",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "semver",
+ "syn",
+]
+
+[[package]]
+name = "napi-sys"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "427802e8ec3a734331fec1035594a210ce1ff4dc5bc1950530920ab717964ea3"
+dependencies = [
+ "libloading",
+]
+
 [[package]]
 name = "num-conv"
 version = "0.1.0"
@@ -455,9 +617,9 @@ checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
 
 [[package]]
 name = "parse-zoneinfo"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c705f256449c60da65e11ff6626e0c16a0a0b96aaa348de61376b249bc340f41"
+checksum = "1f2a05b18d44e2957b88f96ba460715e295bc1d7510468a2f3d3b44535d26c24"
 dependencies = [
  "regex",
 ]
@@ -529,6 +691,12 @@ version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
 
+[[package]]
+name = "portable-atomic"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da544ee218f0d287a911e9c99a39a8c9bc8fcad3cb8db5959940044ecfc67265"
+
 [[package]]
 name = "powerfmt"
 version = "0.2.0"
@@ -543,13 +711,86 @@ checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.79"
+version = "1.0.86"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
 dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "pyo3"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f239d656363bcee73afef85277f1b281e8ac6212a1d42aa90e55b90ed43c47a4"
+dependencies = [
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "755ea671a1c34044fa165247aaf6f419ca39caa6003aee791a0df2713d8f1b6d"
+dependencies = [
+ "once_cell",
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc95a2e67091e44791d4ea300ff744be5293f394f1bafd9f78c080814d35956e"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a179641d1b93920829a62f15e87c0ed791b6c8db2271ba0fd7c2686090510214"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dff85ebcaab8c441b0e3f7ae40a6963ecea8a9f5e74f647e33fcf5ec9a1e89e"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyroncalc"
+version = "0.5.7"
+dependencies = [
+ "bitcode",
+ "ironcalc",
+ "pyo3",
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.35"
@@ -612,6 +853,12 @@ dependencies = [
  "regex-syntax",
 ]
 
+[[package]]
+name = "regex-lite"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53a49587ad06b26609c52e423de037e7f57f20d53535d66e08c695f347df952a"
+
 [[package]]
 name = "regex-syntax"
 version = "0.8.3"
@@ -624,6 +871,12 @@ version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3cd14fd5e3b777a7422cca79358c57a8f6e3a703d9ac187448d0daf220c2407f"
 
+[[package]]
+name = "rustversion"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d"
+
 [[package]]
 name = "ryu"
 version = "1.0.17"
@@ -636,6 +889,12 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
 
+[[package]]
+name = "semver"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f79dfe2d285b0488816f30e700a7438c5a73d816b5b7d3ac72fbc48b0d185e03"
+
 [[package]]
 name = "serde"
 version = "1.0.197"
@@ -714,15 +973,21 @@ checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
 
 [[package]]
 name = "syn"
-version = "2.0.58"
+version = "2.0.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44cfb93f38070beee36b3fef7d4f5a16f27751d94b187b666a5cc5e9b0d30687"
+checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-ident",
 ]
 
+[[package]]
+name = "target-lexicon"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
+
 [[package]]
 name = "thiserror"
 version = "1.0.58"
@@ -774,6 +1039,18 @@ version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 
+[[package]]
+name = "unicode-segmentation"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
+
+[[package]]
+name = "unindent"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7de7d73e1754487cb58364ee906a499937a0dfabd86bcb980fa99ec8c8fa2ce"
+
 [[package]]
 name = "uuid"
 version = "1.8.0"
@@ -798,7 +1075,7 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm"
-version = "0.1.3"
+version = "0.5.0"
 dependencies = [
  "ironcalc_base",
  "serde",
@@ -809,23 +1086,24 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.92"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
 dependencies = [
  "cfg-if",
+ "once_cell",
+ "rustversion",
  "wasm-bindgen-macro",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.92"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
 dependencies = [
  "bumpalo",
  "log",
- "once_cell",
  "proc-macro2",
  "quote",
  "syn",
@@ -846,9 +1124,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.92"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -856,9 +1134,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.92"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -869,9 +1147,12 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.92"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+dependencies = [
+ "unicode-ident",
+]
 
 [[package]]
 name = "wasm-bindgen-test"

Cargo.toml

@@ -5,10 +5,13 @@ members = [
   "base",
   "xlsx",
   "bindings/wasm",
+  "bindings/python",
+  "bindings/nodejs",
 ]
 
 exclude = [
   "generate_locale",
+  "webapp/app.ironcalc.com/server",
 ]
 
 [profile.release]

Makefile

@@ -1,41 +1,51 @@
+.PHONY: lint
 lint:
 	cargo fmt -- --check
-	cargo clippy --all-targets --all-features
+	cargo clippy --all-targets --all-features -- -W clippy::unwrap_used -W clippy::expect_used -W clippy::panic -D warnings
+	cd webapp/IronCalc/ && npm install && npm run check
+	cd webapp/app.ironcalc.com/frontend/ && npm install && npm run check
 
+.PHONY: format
 format:
 	cargo fmt
 
+.PHONY: tests
 tests: lint
 	cargo test
-	./target/debug/documentation
-	cmp functions.md wiki/functions.md || exit 1
 	make remove-artifacts
-	cd bindings/wasm/ && wasm-pack build --target nodejs && node tests/test.mjs
+	# Regretabbly we need to build the wasm twice, once for the nodejs tests
+	# and a second one for the vitest.
+	cd bindings/wasm/ && wasm-pack build --target nodejs && node tests/test.mjs && make
+	cd webapp/IronCalc/ && npm run test
+	cd bindings/python && ./run_tests.sh && ./run_examples.sh
 
+.PHONY: remove-artifacts
 remove-artifacts:
 	rm -f xlsx/hello-calc.xlsx
 	rm -f xlsx/hello-styles.xlsx
 	rm -f xlsx/widths-and-heights.xlsx
-	rm -f functions.md
 
+.PHONY: clean
 clean: remove-artifacts
 	cargo clean
 	rm -r -f base/target
 	rm -r -f xlsx/target
+	rm -r -f bindings/python/target
+	rm -r -f bindings/wasm/target
+	rm -r -f bindings/wasm/pkg
+	rm -r -f webapp/IronCalc/node_modules
+	rm -r -f webapp/IronCalc/dist
+	rm -r -f webapp/app.ironcalc.com/frontend/node_modules
+	rm -r -f webapp/app.ironcalc.com/frontend/dist
 	rm -f cargo-test-*
 	rm -f base/cargo-test-*
 	rm -f xlsx/cargo-test-*
 
-
+.PHONY: coverage
 coverage:
 	CARGO_INCREMENTAL=0 RUSTFLAGS='-C instrument-coverage' LLVM_PROFILE_FILE='cargo-test-%p-%m.profraw' cargo test
 	grcov . --binary-path ./target/debug/deps/ -s . -t html --branch --ignore-not-existing --ignore '../*' --ignore "/*" -o target/coverage/html
 
-update-docs:
-	cargo build
-	./target/debug/documentation -o wiki/functions.md
-
+.PHONY: docs
 docs:
 	cargo doc --no-deps
-
-.PHONY: lint format tests docs coverage all

README.md

@@ -77,7 +77,7 @@ And visit <http://0.0.0.0:8000/ironcalc/>
 Add the dependency to `Cargo.toml`:
 ```toml
 [dependencies]
-ironcalc = { git = "https://github.com/ironcalc/IronCalc", version = "0.1"}
+ironcalc = { git = "https://github.com/ironcalc/IronCalc", version = "0.5"}
 ```
 
 And then use this code in `main.rs`:
@@ -123,12 +123,12 @@ See https://github.com/ironcalc
 
 An early preview of the technology running entirely in your browser:
 
-https://playground.ironcalc.com
+https://app.ironcalc.com
 
 
 # Collaborators needed!. Call to action
 
-We don't have a vibrant community just yet. This is the very stages of the project. But if you are passionate about code with high standards and no compromises, if you are looking for a project with high impact, if you are interested in a better, more open infrastructure for spreadsheets, whether you are a developer (rust, python, TypeScript, electron/tauri/anything else native app, React, you name it), a designer (we need a logo desperately!), an Excel power user who wants features, a business looking to integrate a MIT/Apache licensed spreadsheet in your own SaaS application join us!
+We don't have a vibrant community just yet. This is the very stages of the project. But if you are passionate about code with high standards and no compromises, if you are looking for a project with high impact, if you are interested in a better, more open infrastructure for spreadsheets, whether you are a developer (rust, python, TypeScript, electron/tauri/anything else native app, React, you name it), a designer, an Excel power user who wants features, a business looking to integrate a MIT/Apache licensed spreadsheet in your own SaaS application join us!
 
 The best place to start will be to join or [discord channel](https://discord.gg/zZYWfh3RHJ) or send us an email at hello@ironcalc.com.
 

base/CALC.md

@@ -0,0 +1,61 @@
+# Evaluation Strategy
+
+
+We have a list of the spill cells:
+
+```
+// Checks if the array starting at cell will cover cells whose values
+// has been requested
+def CheckSpill(cell, array):
+    for c in cell+array:
+        support CellHasBeenRequested(c):
+        if support is not empty:
+            return support
+    return []
+
+// Fills cells with the result (an array)
+def FillCells(cell, result):
+
+
+def EvaluateNodeInContext(node, context):
+    match node:
+        case OP(left, right, op):
+            l = EvaluateNodeInContext(left, context)?
+            r = EvaluateNodeInContext(left, context)?
+            return op(l, r)
+        case FUNCTION(args, fn):
+            ...
+        case CELL(cell):
+            EvaluateCell(cell)
+        case RANGE(start, end):
+            ...
+
+
+
+def EvaluateCell(cell):
+    if IsCellEvaluating(cell):
+        return CIRC
+    MarkEvaluating(cell)
+    result = EvaluateNodeInContext(cell.formula, cell)
+    if isSpill(result):
+        CheckSpill(cell, array)?
+        FillCells(result)
+
+
+def EvaluateWorkbook():
+    spill_cells = [cell_1, ...., cell_n];
+
+
+    for cell in spill_cells:
+        result = evaluate(cell)
+```   
+
+
+
+
+
+
+
+# When updating a cell value
+
+If it was a spill cell we nee

base/Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "ironcalc_base"
-version = "0.1.3"
+version = "0.5.0"
 authors = ["Nicolás Hatcher <nicolas@theuniverse.today>"]
 edition = "2021"
 homepage = "https://www.ironcalc.com"
 repository = "https://github.com/ironcalc/ironcalc/"
-description = "The democratization of spreadsheets"
+description = "Open source spreadsheet engine"
 license = "MIT OR Apache-2.0"
 readme = "README.md"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -14,10 +14,16 @@ readme = "README.md"
 serde = { version = "1.0", features = ["derive"] }
 ryu = "1.0"
 chrono = "0.4"
-chrono-tz = "0.9"
-regex = "1.0"
-once_cell = "1.16.0"
-bitcode = "0.6.0"
+chrono-tz = "0.10"
+regex = { version = "1.0", optional = true}
+regex-lite = { version = "0.1.6", optional = true}
+bitcode = "0.6.3"
+csv = "1.3.0"
+
+[features]
+default = ["use_regex_full"]
+use_regex_full = ["regex"]
+use_regex_lite = ["regex-lite"]
 
 [dev-dependencies]
 serde_json = "1.0"

base/examples/formulas_and_errors.rs

@@ -3,15 +3,15 @@ use ironcalc_base::{types::CellType, Model};
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut model = Model::new_empty("formulas-and-errors", "en", "UTC")?;
     // A1
-    model.set_user_input(0, 1, 1, "1".to_string());
+    model.set_user_input(0, 1, 1, "1".to_string())?;
     // A2
-    model.set_user_input(0, 2, 1, "2".to_string());
+    model.set_user_input(0, 2, 1, "2".to_string())?;
     // A3
-    model.set_user_input(0, 3, 1, "3".to_string());
+    model.set_user_input(0, 3, 1, "3".to_string())?;
     // B1
-    model.set_user_input(0, 1, 2, "=SUM(A1:A3)".to_string());
+    model.set_user_input(0, 1, 2, "=SUM(A1:A3)".to_string())?;
     // B2
-    model.set_user_input(0, 2, 2, "=B1/0".to_string());
+    model.set_user_input(0, 2, 2, "=B1/0".to_string())?;
     // Evaluate
     model.evaluate();
 

base/examples/hello_world.rs

@@ -3,11 +3,11 @@ use ironcalc_base::{cell::CellValue, Model};
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut model = Model::new_empty("hello-world", "en", "UTC")?;
     // A1
-    model.set_user_input(0, 1, 1, "Hello".to_string());
+    model.set_user_input(0, 1, 1, "Hello".to_string())?;
     // B1
-    model.set_user_input(0, 1, 2, "world!".to_string());
+    model.set_user_input(0, 1, 2, "world!".to_string())?;
     // C1
-    model.set_user_input(0, 1, 3, "=CONCAT(A1, \" \", B1".to_string());
+    model.set_user_input(0, 1, 3, "=CONCAT(A1, \" \", B1".to_string())?;
     // evaluates
     model.evaluate();
 

base/src/actions.rs

@@ -1,5 +1,6 @@
 use crate::constants::{LAST_COLUMN, LAST_ROW};
-use crate::expressions::parser::stringify::DisplaceData;
+use crate::expressions::parser::stringify::{to_string, to_string_displaced, DisplaceData};
+use crate::expressions::types::CellReferenceRC;
 use crate::model::Model;
 
 // NOTE: There is a difference with Excel behaviour when deleting cells/rows/columns
@@ -8,16 +9,45 @@ use crate::model::Model;
 // I feel this is unimportant for now.
 
 impl Model {
+    fn shift_cell_formula(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        displace_data: &DisplaceData,
+    ) -> Result<(), String> {
+        if let Some(f) = self
+            .workbook
+            .worksheet(sheet)?
+            .cell(row, column)
+            .and_then(|c| c.get_formula())
+        {
+            let node = &self.parsed_formulas[sheet as usize][f as usize].0.clone();
+            let cell_reference = CellReferenceRC {
+                sheet: self.workbook.worksheets[sheet as usize].get_name(),
+                row,
+                column,
+            };
+            // FIXME: This is not a very performant way if the formula has changed :S.
+            let formula = to_string(node, &cell_reference);
+            let formula_displaced = to_string_displaced(node, &cell_reference, displace_data);
+            if formula != formula_displaced {
+                self.update_cell_with_formula(sheet, row, column, format!("={formula_displaced}"))?;
+            }
+        }
+        Ok(())
+    }
     /// This function iterates over all cells in the model and shifts their formulas according to the displacement data.
     ///
     /// # Arguments
     ///
     /// * `displace_data` - A reference to `DisplaceData` describing the displacement's direction and magnitude.
-    fn displace_cells(&mut self, displace_data: &DisplaceData) {
+    fn displace_cells(&mut self, displace_data: &DisplaceData) -> Result<(), String> {
         let cells = self.get_all_cells();
         for cell in cells {
-            self.shift_cell_formula(cell.index, cell.row, cell.column, displace_data);
+            self.shift_cell_formula(cell.index, cell.row, cell.column, displace_data)?;
         }
+        Ok(())
     }
 
     /// Retrieves the column indices for a specific row in a given sheet, sorted in ascending or descending order.
@@ -79,12 +109,11 @@ impl Model {
         let formula_or_value = self
             .get_cell_formula(sheet, source_row, source_column)?
             .unwrap_or_else(|| source_cell.get_text(&self.workbook.shared_strings, &self.language));
-        self.set_user_input(sheet, target_row, target_column, formula_or_value);
+        self.set_user_input(sheet, target_row, target_column, formula_or_value)?;
         self.workbook
             .worksheet_mut(sheet)?
-            .set_cell_style(target_row, target_column, style);
-        self.cell_clear_all(sheet, source_row, source_column)?;
-        Ok(())
+            .set_cell_style(target_row, target_column, style)?;
+        self.cell_clear_all(sheet, source_row, source_column)
     }
 
     /// Inserts one or more new columns into the model at the specified index.
@@ -135,7 +164,34 @@ impl Model {
                 column,
                 delta: column_count,
             }),
-        );
+        )?;
+
+        // In the list of columns:
+        // * Keep all the columns to the left
+        // * Displace all the columns to the right
+
+        let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
+
+        let mut new_columns = Vec::new();
+        for col in worksheet.cols.iter_mut() {
+            // range under study
+            let min = col.min;
+            let max = col.max;
+            if column > max {
+                // If the range under study is to our left, this is a noop
+            } else if column <= min {
+                // If the range under study is to our right, we displace it
+                col.min = min + column_count;
+                col.max = max + column_count;
+            } else {
+                // If the range under study is in the middle we augment it
+                col.max = max + column_count;
+            }
+            new_columns.push(col.clone());
+        }
+        // TODO: If in a row the cell to the right and left have the same style we should copy it
+
+        worksheet.cols = new_columns;
 
         Ok(())
     }
@@ -156,6 +212,12 @@ impl Model {
         if column_count <= 0 {
             return Err("Please use insert columns instead".to_string());
         }
+        if !(1..=LAST_COLUMN).contains(&column) {
+            return Err(format!("Column number '{column}' is not valid."));
+        }
+        if column + column_count - 1 > LAST_COLUMN {
+            return Err("Cannot delete columns beyond the last column of the sheet".to_string());
+        }
 
         // first column being deleted
         let column_start = column;
@@ -188,7 +250,7 @@ impl Model {
                 column,
                 delta: -column_count,
             }),
-        );
+        )?;
         let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
 
         // deletes all the column styles
@@ -312,7 +374,7 @@ impl Model {
                 row,
                 delta: row_count,
             }),
-        );
+        )?;
 
         Ok(())
     }
@@ -328,6 +390,13 @@ impl Model {
         if row_count <= 0 {
             return Err("Please use insert rows instead".to_string());
         }
+        if !(1..=LAST_ROW).contains(&row) {
+            return Err(format!("Row number '{row}' is not valid."));
+        }
+        if row + row_count - 1 > LAST_ROW {
+            return Err("Cannot delete rows beyond the last row of the sheet".to_string());
+        }
+
         // Move cells
         let worksheet = &self.workbook.worksheet(sheet)?;
         let mut all_rows: Vec<i32> = worksheet.sheet_data.keys().copied().collect();
@@ -373,7 +442,7 @@ impl Model {
                 row,
                 delta: -row_count,
             }),
-        );
+        )?;
         Ok(())
     }
 
@@ -384,27 +453,90 @@ impl Model {
     ///    * All cell references to initial_column will go to target_column
     ///    * All cell references to columns in between (initial_column, target_column] will be displaced one to the left
     ///    * All other cell references are left unchanged
-    /// Ranges. This is the tricky bit:
+    ///      Ranges. This is the tricky bit:
     ///    * Column is one of the extremes of the range. The new extreme would be target_column.
     ///      Range is then normalized
     ///    * Any other case, range is left unchanged.
-    /// NOTE: This does NOT move the data in the columns or move the colum styles
+    ///      NOTE: This moves the data and column styles along with the formulas
     pub fn move_column_action(
         &mut self,
         sheet: u32,
         column: i32,
         delta: i32,
-    ) -> Result<(), &'static str> {
+    ) -> Result<(), String> {
         // Check boundaries
         let target_column = column + delta;
         if !(1..=LAST_COLUMN).contains(&target_column) {
-            return Err("Target column out of boundaries");
+            return Err("Target column out of boundaries".to_string());
         }
         if !(1..=LAST_COLUMN).contains(&column) {
-            return Err("Initial column out of boundaries");
+            return Err("Initial column out of boundaries".to_string());
         }
 
-        // TODO: Add the actual displacement of data and styles
+        if delta == 0 {
+            return Ok(());
+        }
+
+        // Preserve cell contents, width and style of the column being moved
+        let original_refs = self
+            .workbook
+            .worksheet(sheet)?
+            .column_cell_references(column)?;
+        let mut original_cells = Vec::new();
+        for r in &original_refs {
+            let cell = self
+                .workbook
+                .worksheet(sheet)?
+                .cell(r.row, column)
+                .ok_or("Expected Cell to exist")?;
+            let style_idx = cell.get_style();
+            let formula_or_value = self
+                .get_cell_formula(sheet, r.row, column)?
+                .unwrap_or_else(|| cell.get_text(&self.workbook.shared_strings, &self.language));
+            original_cells.push((r.row, formula_or_value, style_idx));
+            self.cell_clear_all(sheet, r.row, column)?;
+        }
+
+        let width = self.workbook.worksheet(sheet)?.get_column_width(column)?;
+        let style = self.workbook.worksheet(sheet)?.get_column_style(column)?;
+
+        if delta > 0 {
+            for c in column + 1..=target_column {
+                let refs = self.workbook.worksheet(sheet)?.column_cell_references(c)?;
+                for r in refs {
+                    self.move_cell(sheet, r.row, c, r.row, c - 1)?;
+                }
+
+                let w = self.workbook.worksheet(sheet)?.get_column_width(c)?;
+                let s = self.workbook.worksheet(sheet)?.get_column_style(c)?;
+                self.workbook
+                    .worksheet_mut(sheet)?
+                    .set_column_width_and_style(c - 1, w, s)?;
+            }
+        } else {
+            for c in (target_column..=column - 1).rev() {
+                let refs = self.workbook.worksheet(sheet)?.column_cell_references(c)?;
+                for r in refs {
+                    self.move_cell(sheet, r.row, c, r.row, c + 1)?;
+                }
+
+                let w = self.workbook.worksheet(sheet)?.get_column_width(c)?;
+                let s = self.workbook.worksheet(sheet)?.get_column_style(c)?;
+                self.workbook
+                    .worksheet_mut(sheet)?
+                    .set_column_width_and_style(c + 1, w, s)?;
+            }
+        }
+
+        for (r, value, style_idx) in original_cells {
+            self.set_user_input(sheet, r, target_column, value)?;
+            self.workbook
+                .worksheet_mut(sheet)?
+                .set_cell_style(r, target_column, style_idx)?;
+        }
+        self.workbook
+            .worksheet_mut(sheet)?
+            .set_column_width_and_style(target_column, width, style)?;
 
         // Update all formulas in the workbook
         self.displace_cells(
@@ -413,7 +545,91 @@ impl Model {
                 column,
                 delta,
             }),
-        );
+        )?;
+
+        Ok(())
+    }
+
+    /// Displaces cells due to a move row action
+    /// from initial_row to target_row = initial_row + row_delta
+    /// References will be updated following the same rules as move_column_action
+    /// NOTE: This moves the data and row styles along with the formulas
+    pub fn move_row_action(&mut self, sheet: u32, row: i32, delta: i32) -> Result<(), String> {
+        // Check boundaries
+        let target_row = row + delta;
+        if !(1..=LAST_ROW).contains(&target_row) {
+            return Err("Target row out of boundaries".to_string());
+        }
+        if !(1..=LAST_ROW).contains(&row) {
+            return Err("Initial row out of boundaries".to_string());
+        }
+
+        if delta == 0 {
+            return Ok(());
+        }
+
+        let original_cols = self.get_columns_for_row(sheet, row, false)?;
+        let mut original_cells = Vec::new();
+        for c in &original_cols {
+            let cell = self
+                .workbook
+                .worksheet(sheet)?
+                .cell(row, *c)
+                .ok_or("Expected Cell to exist")?;
+            let style_idx = cell.get_style();
+            let formula_or_value = self
+                .get_cell_formula(sheet, row, *c)?
+                .unwrap_or_else(|| cell.get_text(&self.workbook.shared_strings, &self.language));
+            original_cells.push((*c, formula_or_value, style_idx));
+            self.cell_clear_all(sheet, row, *c)?;
+        }
+
+        if delta > 0 {
+            for r in row + 1..=target_row {
+                let cols = self.get_columns_for_row(sheet, r, false)?;
+                for c in cols {
+                    self.move_cell(sheet, r, c, r - 1, c)?;
+                }
+            }
+        } else {
+            for r in (target_row..=row - 1).rev() {
+                let cols = self.get_columns_for_row(sheet, r, false)?;
+                for c in cols {
+                    self.move_cell(sheet, r, c, r + 1, c)?;
+                }
+            }
+        }
+
+        for (c, value, style_idx) in original_cells {
+            self.set_user_input(sheet, target_row, c, value)?;
+            self.workbook
+                .worksheet_mut(sheet)?
+                .set_cell_style(target_row, c, style_idx)?;
+        }
+
+        let worksheet = &mut self.workbook.worksheet_mut(sheet)?;
+        let mut new_rows = Vec::new();
+        for r in worksheet.rows.iter() {
+            if r.r == row {
+                let mut nr = r.clone();
+                nr.r = target_row;
+                new_rows.push(nr);
+            } else if delta > 0 && r.r > row && r.r <= target_row {
+                let mut nr = r.clone();
+                nr.r -= 1;
+                new_rows.push(nr);
+            } else if delta < 0 && r.r < row && r.r >= target_row {
+                let mut nr = r.clone();
+                nr.r += 1;
+                new_rows.push(nr);
+            } else {
+                new_rows.push(r.clone());
+            }
+        }
+        worksheet.rows = new_rows;
+
+        // Update all formulas in the workbook
+        self.displace_cells(&(DisplaceData::RowMove { sheet, row, delta }))?;
 
         Ok(())
     }

base/src/arithmetic.rs

@@ -0,0 +1,150 @@
+use crate::{
+    calc_result::CalcResult,
+    cast::NumberOrArray,
+    expressions::{
+        parser::{ArrayNode, Node},
+        token::Error,
+        types::CellReferenceIndex,
+    },
+    model::Model,
+};
+
+/// Unify how we map booleans/strings to f64
+fn to_f64(value: &ArrayNode) -> Result<f64, Error> {
+    match value {
+        ArrayNode::Number(f) => Ok(*f),
+        ArrayNode::Boolean(b) => Ok(if *b { 1.0 } else { 0.0 }),
+        ArrayNode::String(s) => match s.parse::<f64>() {
+            Ok(f) => Ok(f),
+            Err(_) => Err(Error::VALUE),
+        },
+        ArrayNode::Error(err) => Err(err.clone()),
+    }
+}
+
+impl Model {
+    /// Applies `op` element‐wise for arrays/numbers.
+    pub(crate) fn handle_arithmetic(
+        &mut self,
+        left: &Node,
+        right: &Node,
+        cell: CellReferenceIndex,
+        op: &dyn Fn(f64, f64) -> Result<f64, Error>,
+    ) -> CalcResult {
+        let l = match self.get_number_or_array(left, cell) {
+            Ok(f) => f,
+            Err(s) => {
+                return s;
+            }
+        };
+        let r = match self.get_number_or_array(right, cell) {
+            Ok(f) => f,
+            Err(s) => {
+                return s;
+            }
+        };
+        match (l, r) {
+            // -----------------------------------------------------
+            // Case 1: Both are numbers
+            // -----------------------------------------------------
+            (NumberOrArray::Number(f1), NumberOrArray::Number(f2)) => match op(f1, f2) {
+                Ok(x) => CalcResult::Number(x),
+                Err(Error::DIV) => CalcResult::Error {
+                    error: Error::DIV,
+                    origin: cell,
+                    message: "Divide by 0".to_string(),
+                },
+                Err(Error::VALUE) => CalcResult::Error {
+                    error: Error::VALUE,
+                    origin: cell,
+                    message: "Invalid number".to_string(),
+                },
+                Err(e) => CalcResult::Error {
+                    error: e,
+                    origin: cell,
+                    message: "Unknown error".to_string(),
+                },
+            },
+
+            // -----------------------------------------------------
+            // Case 2: left is Number, right is Array
+            // -----------------------------------------------------
+            (NumberOrArray::Number(f1), NumberOrArray::Array(a2)) => {
+                let mut array = Vec::new();
+                for row in a2 {
+                    let mut data_row = Vec::new();
+                    for node in row {
+                        match to_f64(&node) {
+                            Ok(f2) => match op(f1, f2) {
+                                Ok(x) => data_row.push(ArrayNode::Number(x)),
+                                Err(e) => data_row.push(ArrayNode::Error(e)),
+                            },
+                            Err(err) => data_row.push(ArrayNode::Error(err)),
+                        }
+                    }
+                    array.push(data_row);
+                }
+                CalcResult::Array(array)
+            }
+
+            // -----------------------------------------------------
+            // Case 3: left is Array, right is Number
+            // -----------------------------------------------------
+            (NumberOrArray::Array(a1), NumberOrArray::Number(f2)) => {
+                let mut array = Vec::new();
+                for row in a1 {
+                    let mut data_row = Vec::new();
+                    for node in row {
+                        match to_f64(&node) {
+                            Ok(f1) => match op(f1, f2) {
+                                Ok(x) => data_row.push(ArrayNode::Number(x)),
+                                Err(e) => data_row.push(ArrayNode::Error(e)),
+                            },
+                            Err(err) => data_row.push(ArrayNode::Error(err)),
+                        }
+                    }
+                    array.push(data_row);
+                }
+                CalcResult::Array(array)
+            }
+
+            // -----------------------------------------------------
+            // Case 4: Both are arrays
+            // -----------------------------------------------------
+            (NumberOrArray::Array(a1), NumberOrArray::Array(a2)) => {
+                let n1 = a1.len();
+                let m1 = a1.first().map(|r| r.len()).unwrap_or(0);
+                let n2 = a2.len();
+                let m2 = a2.first().map(|r| r.len()).unwrap_or(0);
+                let n = n1.max(n2);
+                let m = m1.max(m2);
+
+                let mut array = Vec::new();
+                for i in 0..n {
+                    let row1 = a1.get(i);
+                    let row2 = a2.get(i);
+
+                    let mut data_row = Vec::new();
+                    for j in 0..m {
+                        let val1 = row1.and_then(|r| r.get(j));
+                        let val2 = row2.and_then(|r| r.get(j));
+
+                        match (val1, val2) {
+                            (Some(v1), Some(v2)) => match (to_f64(v1), to_f64(v2)) {
+                                (Ok(f1), Ok(f2)) => match op(f1, f2) {
+                                    Ok(x) => data_row.push(ArrayNode::Number(x)),
+                                    Err(e) => data_row.push(ArrayNode::Error(e)),
+                                },
+                                (Err(e), _) | (_, Err(e)) => data_row.push(ArrayNode::Error(e)),
+                            },
+                            // Mismatched dimensions => #VALUE!
+                            _ => data_row.push(ArrayNode::Error(Error::VALUE)),
+                        }
+                    }
+                    array.push(data_row);
+                }
+                CalcResult::Array(array)
+            }
+        }
+    }
+}

base/src/calc_result.rs

@@ -1,7 +1,8 @@
 use std::cmp::Ordering;
 
-use crate::expressions::{token::Error, types::CellReferenceIndex};
+use crate::expressions::{parser::ArrayNode, token::Error, types::CellReferenceIndex};
 
+#[derive(Clone)]
 pub struct Range {
     pub left: CellReferenceIndex,
     pub right: CellReferenceIndex,
@@ -23,6 +24,7 @@ pub(crate) enum CalcResult {
     },
     EmptyCell,
     EmptyArg,
+    Array(Vec<Vec<ArrayNode>>),
 }
 
 impl CalcResult {

base/src/cast.rs

@@ -1,11 +1,85 @@
 use crate::{
     calc_result::{CalcResult, Range},
-    expressions::{parser::Node, token::Error, types::CellReferenceIndex},
-    implicit_intersection::implicit_intersection,
+    expressions::{
+        parser::{ArrayNode, Node},
+        token::Error,
+        types::CellReferenceIndex,
+    },
     model::Model,
 };
 
+pub(crate) enum NumberOrArray {
+    Number(f64),
+    Array(Vec<Vec<ArrayNode>>),
+}
+
 impl Model {
+    pub(crate) fn get_number_or_array(
+        &mut self,
+        node: &Node,
+        cell: CellReferenceIndex,
+    ) -> Result<NumberOrArray, CalcResult> {
+        match self.evaluate_node_in_context(node, cell) {
+            CalcResult::Number(f) => Ok(NumberOrArray::Number(f)),
+            CalcResult::String(s) => match s.parse::<f64>() {
+                Ok(f) => Ok(NumberOrArray::Number(f)),
+                _ => Err(CalcResult::new_error(
+                    Error::VALUE,
+                    cell,
+                    "Expecting number".to_string(),
+                )),
+            },
+            CalcResult::Boolean(f) => {
+                if f {
+                    Ok(NumberOrArray::Number(1.0))
+                } else {
+                    Ok(NumberOrArray::Number(0.0))
+                }
+            }
+            CalcResult::EmptyCell | CalcResult::EmptyArg => Ok(NumberOrArray::Number(0.0)),
+            CalcResult::Range { left, right } => {
+                let sheet = left.sheet;
+                if sheet != right.sheet {
+                    return Err(CalcResult::Error {
+                        error: Error::ERROR,
+                        origin: cell,
+                        message: "3D ranges are not allowed".to_string(),
+                    });
+                }
+                // we need to convert the range into an array
+                let mut array = Vec::new();
+                for row in left.row..=right.row {
+                    let mut row_data = Vec::new();
+                    for column in left.column..=right.column {
+                        let value =
+                            match self.evaluate_cell(CellReferenceIndex { sheet, column, row }) {
+                                CalcResult::String(s) => ArrayNode::String(s),
+                                CalcResult::Number(f) => ArrayNode::Number(f),
+                                CalcResult::Boolean(b) => ArrayNode::Boolean(b),
+                                CalcResult::Error { error, .. } => ArrayNode::Error(error),
+                                CalcResult::Range { .. } => {
+                                    // if we do things right this can never happen.
+                                    // the evaluation of a cell should never return a range
+                                    ArrayNode::Number(0.0)
+                                }
+                                CalcResult::EmptyCell => ArrayNode::Number(0.0),
+                                CalcResult::EmptyArg => ArrayNode::Number(0.0),
+                                CalcResult::Array(_) => {
+                                    // if we do things right this can never happen.
+                                    // the evaluation of a cell should never return an array
+                                    ArrayNode::Number(0.0)
+                                }
+                            };
+                        row_data.push(value);
+                    }
+                    array.push(row_data);
+                }
+                Ok(NumberOrArray::Array(array))
+            }
+            CalcResult::Array(s) => Ok(NumberOrArray::Array(s)),
+            error @ CalcResult::Error { .. } => Err(error),
+        }
+    }
     pub(crate) fn get_number(
         &mut self,
         node: &Node,
@@ -39,19 +113,16 @@ impl Model {
             }
             CalcResult::EmptyCell | CalcResult::EmptyArg => Ok(0.0),
             error @ CalcResult::Error { .. } => Err(error),
-            CalcResult::Range { left, right } => {
-                match implicit_intersection(&cell, &Range { left, right }) {
-                    Some(cell_reference) => {
-                        let result = self.evaluate_cell(cell_reference);
-                        self.cast_to_number(result, cell_reference)
-                    }
-                    None => Err(CalcResult::Error {
-                        error: Error::VALUE,
-                        origin: cell,
-                        message: "Invalid reference (number)".to_string(),
-                    }),
-                }
-            }
+            CalcResult::Range { .. } => Err(CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Arrays not supported yet".to_string(),
+            }),
+            CalcResult::Array(_) => Err(CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Arrays not supported yet".to_string(),
+            }),
         }
     }
 
@@ -88,7 +159,7 @@ impl Model {
         // FIXME: I think when casting a number we should convert it to_precision(x, 15)
         // See function Exact
         match result {
-            CalcResult::Number(f) => Ok(format!("{}", f)),
+            CalcResult::Number(f) => Ok(format!("{f}")),
             CalcResult::String(s) => Ok(s),
             CalcResult::Boolean(f) => {
                 if f {
@@ -99,19 +170,16 @@ impl Model {
             }
             CalcResult::EmptyCell | CalcResult::EmptyArg => Ok("".to_string()),
             error @ CalcResult::Error { .. } => Err(error),
-            CalcResult::Range { left, right } => {
-                match implicit_intersection(&cell, &Range { left, right }) {
-                    Some(cell_reference) => {
-                        let result = self.evaluate_cell(cell_reference);
-                        self.cast_to_string(result, cell_reference)
-                    }
-                    None => Err(CalcResult::Error {
-                        error: Error::VALUE,
-                        origin: cell,
-                        message: "Invalid reference (string)".to_string(),
-                    }),
-                }
-            }
+            CalcResult::Range { .. } => Err(CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Arrays not supported yet".to_string(),
+            }),
+            CalcResult::Array(_) => Err(CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Arrays not supported yet".to_string(),
+            }),
         }
     }
 
@@ -151,19 +219,16 @@ impl Model {
             CalcResult::Boolean(b) => Ok(b),
             CalcResult::EmptyCell | CalcResult::EmptyArg => Ok(false),
             error @ CalcResult::Error { .. } => Err(error),
-            CalcResult::Range { left, right } => {
-                match implicit_intersection(&cell, &Range { left, right }) {
-                    Some(cell_reference) => {
-                        let result = self.evaluate_cell(cell_reference);
-                        self.cast_to_bool(result, cell_reference)
-                    }
-                    None => Err(CalcResult::Error {
-                        error: Error::VALUE,
-                        origin: cell,
-                        message: "Invalid reference (bool)".to_string(),
-                    }),
-                }
-            }
+            CalcResult::Range { .. } => Err(CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Arrays not supported yet".to_string(),
+            }),
+            CalcResult::Array(_) => Err(CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Arrays not supported yet".to_string(),
+            }),
         }
     }
 

base/src/cell.rs

@@ -64,12 +64,50 @@ impl Cell {
     /// Returns the formula of a cell if any.
     pub fn get_formula(&self) -> Option<i32> {
         match self {
-            Cell::CellFormula { f, .. } => Some(*f),
-            Cell::CellFormulaBoolean { f, .. } => Some(*f),
-            Cell::CellFormulaNumber { f, .. } => Some(*f),
-            Cell::CellFormulaString { f, .. } => Some(*f),
-            Cell::CellFormulaError { f, .. } => Some(*f),
-            _ => None,
+            Cell::CellFormula { f, .. }
+            | Cell::CellFormulaBoolean { f, .. }
+            | Cell::CellFormulaNumber { f, .. }
+            | Cell::CellFormulaString { f, .. }
+            | Cell::CellFormulaError { f, .. }
+            | Cell::DynamicCellFormula { f, .. }
+            | Cell::DynamicCellFormulaBoolean { f, .. }
+            | Cell::DynamicCellFormulaNumber { f, .. }
+            | Cell::DynamicCellFormulaString { f, .. }
+            | Cell::DynamicCellFormulaError { f, .. } => Some(*f),
+            Cell::EmptyCell { .. }
+            | Cell::BooleanCell { .. }
+            | Cell::NumberCell { .. }
+            | Cell::ErrorCell { .. }
+            | Cell::SharedString { .. }
+            | Cell::SpillNumberCell { .. }
+            | Cell::SpillBooleanCell { .. }
+            | Cell::SpillErrorCell { .. }
+            | Cell::SpillStringCell { .. } => None,
+        }
+    }
+
+    /// Returns the dynamic range of a cell if any.
+    pub fn get_dynamic_range(&self) -> Option<(i32, i32)> {
+        match self {
+            Cell::DynamicCellFormula { r, .. } => Some(*r),
+            Cell::DynamicCellFormulaBoolean { r, .. } => Some(*r),
+            Cell::DynamicCellFormulaNumber { r, .. } => Some(*r),
+            Cell::DynamicCellFormulaString { r, .. } => Some(*r),
+            Cell::DynamicCellFormulaError { r, .. } => Some(*r),
+            Cell::EmptyCell { .. }
+            | Cell::BooleanCell { .. }
+            | Cell::NumberCell { .. }
+            | Cell::ErrorCell { .. }
+            | Cell::SharedString { .. }
+            | Cell::CellFormula { .. }
+            | Cell::CellFormulaBoolean { .. }
+            | Cell::CellFormulaNumber { .. }
+            | Cell::CellFormulaString { .. }
+            | Cell::CellFormulaError { .. }
+            | Cell::SpillNumberCell { .. }
+            | Cell::SpillBooleanCell { .. }
+            | Cell::SpillErrorCell { .. }
+            | Cell::SpillStringCell { .. } => None,
         }
     }
 
@@ -89,6 +127,15 @@ impl Cell {
             Cell::CellFormulaNumber { s, .. } => *s = style,
             Cell::CellFormulaString { s, .. } => *s = style,
             Cell::CellFormulaError { s, .. } => *s = style,
+            Cell::SpillBooleanCell { s, .. } => *s = style,
+            Cell::SpillNumberCell { s, .. } => *s = style,
+            Cell::SpillStringCell { s, .. } => *s = style,
+            Cell::SpillErrorCell { s, .. } => *s = style,
+            Cell::DynamicCellFormula { s, .. } => *s = style,
+            Cell::DynamicCellFormulaBoolean { s, .. } => *s = style,
+            Cell::DynamicCellFormulaNumber { s, .. } => *s = style,
+            Cell::DynamicCellFormulaString { s, .. } => *s = style,
+            Cell::DynamicCellFormulaError { s, .. } => *s = style,
         };
     }
 
@@ -104,6 +151,15 @@ impl Cell {
             Cell::CellFormulaNumber { s, .. } => *s,
             Cell::CellFormulaString { s, .. } => *s,
             Cell::CellFormulaError { s, .. } => *s,
+            Cell::SpillBooleanCell { s, .. } => *s,
+            Cell::SpillNumberCell { s, .. } => *s,
+            Cell::SpillStringCell { s, .. } => *s,
+            Cell::SpillErrorCell { s, .. } => *s,
+            Cell::DynamicCellFormula { s, .. } => *s,
+            Cell::DynamicCellFormulaBoolean { s, .. } => *s,
+            Cell::DynamicCellFormulaNumber { s, .. } => *s,
+            Cell::DynamicCellFormulaString { s, .. } => *s,
+            Cell::DynamicCellFormulaError { s, .. } => *s,
         }
     }
 
@@ -119,6 +175,15 @@ impl Cell {
             Cell::CellFormulaNumber { .. } => CellType::Number,
             Cell::CellFormulaString { .. } => CellType::Text,
             Cell::CellFormulaError { .. } => CellType::ErrorValue,
+            Cell::SpillBooleanCell { .. } => CellType::LogicalValue,
+            Cell::SpillNumberCell { .. } => CellType::Number,
+            Cell::SpillStringCell { .. } => CellType::Text,
+            Cell::SpillErrorCell { .. } => CellType::ErrorValue,
+            Cell::DynamicCellFormula { .. } => CellType::Number,
+            Cell::DynamicCellFormulaBoolean { .. } => CellType::LogicalValue,
+            Cell::DynamicCellFormulaNumber { .. } => CellType::Number,
+            Cell::DynamicCellFormulaString { .. } => CellType::Text,
+            Cell::DynamicCellFormulaError { .. } => CellType::ErrorValue,
         }
     }
 
@@ -136,7 +201,7 @@ impl Cell {
             Cell::EmptyCell { .. } => CellValue::None,
             Cell::BooleanCell { v, s: _ } => CellValue::Boolean(*v),
             Cell::NumberCell { v, s: _ } => CellValue::Number(*v),
-            Cell::ErrorCell { ei, .. } => {
+            Cell::ErrorCell { ei, .. } | Cell::SpillErrorCell { ei, .. } => {
                 let v = ei.to_localized_error_string(language);
                 CellValue::String(v)
             }
@@ -148,14 +213,25 @@ impl Cell {
                 };
                 CellValue::String(v)
             }
-            Cell::CellFormula { .. } => CellValue::String("#ERROR!".to_string()),
-            Cell::CellFormulaBoolean { v, .. } => CellValue::Boolean(*v),
-            Cell::CellFormulaNumber { v, .. } => CellValue::Number(*v),
-            Cell::CellFormulaString { v, .. } => CellValue::String(v.clone()),
-            Cell::CellFormulaError { ei, .. } => {
+            Cell::DynamicCellFormula { .. } | Cell::CellFormula { .. } => {
+                CellValue::String("#ERROR!".to_string())
+            }
+            Cell::DynamicCellFormulaBoolean { v, .. } | Cell::CellFormulaBoolean { v, .. } => {
+                CellValue::Boolean(*v)
+            }
+            Cell::DynamicCellFormulaNumber { v, .. } | Cell::CellFormulaNumber { v, .. } => {
+                CellValue::Number(*v)
+            }
+            Cell::DynamicCellFormulaString { v, .. } | Cell::CellFormulaString { v, .. } => {
+                CellValue::String(v.clone())
+            }
+            Cell::DynamicCellFormulaError { ei, .. } | Cell::CellFormulaError { ei, .. } => {
                 let v = ei.to_localized_error_string(language);
                 CellValue::String(v)
             }
+            Cell::SpillBooleanCell { v, .. } => CellValue::Boolean(*v),
+            Cell::SpillNumberCell { v, .. } => CellValue::Number(*v),
+            Cell::SpillStringCell { v, .. } => CellValue::String(v.clone()),
         }
     }
 

base/src/constants.rs

@@ -2,10 +2,12 @@
 /// COLUMN_WIDTH and ROW_HEIGHT are pixel values
 /// A column width of Excel value `w` will result in `w * COLUMN_WIDTH_FACTOR` pixels
 /// Note that these constants are inlined
-pub(crate) const DEFAULT_COLUMN_WIDTH: f64 = 100.0;
-pub(crate) const DEFAULT_ROW_HEIGHT: f64 = 21.0;
+pub(crate) const DEFAULT_COLUMN_WIDTH: f64 = 125.0;
+pub(crate) const DEFAULT_ROW_HEIGHT: f64 = 28.0;
 pub(crate) const COLUMN_WIDTH_FACTOR: f64 = 12.0;
 pub(crate) const ROW_HEIGHT_FACTOR: f64 = 2.0;
+pub(crate) const DEFAULT_WINDOW_HEIGHT: i64 = 600;
+pub(crate) const DEFAULT_WINDOW_WIDTH: i64 = 800;
 
 pub(crate) const LAST_COLUMN: i32 = 16_384;
 pub(crate) const LAST_ROW: i32 = 1_048_576;
@@ -14,3 +16,10 @@ pub(crate) const LAST_ROW: i32 = 1_048_576;
 // NaiveDate::from_ymd(1900, 1, 1).num_days_from_ce() - 2
 // The 2 days offset is because of Excel 1900 bug
 pub(crate) const EXCEL_DATE_BASE: i32 = 693_594;
+
+// We do not support dates before 1899-12-31.
+pub(crate) const MINIMUM_DATE_SERIAL_NUMBER: i32 = 1;
+
+// Excel can handle dates until the year 9999-12-31
+// 2958465 is the number of days from 1900-01-01 to 9999-12-31
+pub(crate) const MAXIMUM_DATE_SERIAL_NUMBER: i32 = 2_958_465;

base/src/diffs.rs

@@ -1,136 +0,0 @@
-use crate::{
-    expressions::{
-        parser::{
-            move_formula::ref_is_in_area,
-            stringify::{to_string, to_string_displaced, DisplaceData},
-            walk::forward_references,
-        },
-        types::{Area, CellReferenceIndex, CellReferenceRC},
-    },
-    model::Model,
-};
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
-#[serde(untagged, deny_unknown_fields)]
-pub enum CellValue {
-    Value(String),
-    None,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
-pub struct SetCellValue {
-    cell: CellReferenceIndex,
-    new_value: CellValue,
-    old_value: CellValue,
-}
-
-impl Model {
-    pub(crate) fn shift_cell_formula(
-        &mut self,
-        sheet: u32,
-        row: i32,
-        column: i32,
-        displace_data: &DisplaceData,
-    ) {
-        if let Some(f) = self
-            .workbook
-            .worksheet(sheet)
-            .expect("Worksheet must exist")
-            .cell(row, column)
-            .expect("Cell must exist")
-            .get_formula()
-        {
-            let node = &self.parsed_formulas[sheet as usize][f as usize].clone();
-            let cell_reference = CellReferenceRC {
-                sheet: self.workbook.worksheets[sheet as usize].get_name(),
-                row,
-                column,
-            };
-            // FIXME: This is not a very performant way if the formula has changed :S.
-            let formula = to_string(node, &cell_reference);
-            let formula_displaced = to_string_displaced(node, &cell_reference, displace_data);
-            if formula != formula_displaced {
-                self.update_cell_with_formula(sheet, row, column, format!("={formula_displaced}"))
-                    .expect("Failed to shift cell formula");
-            }
-        }
-    }
-
-    pub fn forward_references(
-        &mut self,
-        source_area: &Area,
-        target: &CellReferenceIndex,
-    ) -> Result<Vec<SetCellValue>, String> {
-        let mut diff_list: Vec<SetCellValue> = Vec::new();
-        let target_area = &Area {
-            sheet: target.sheet,
-            row: target.row,
-            column: target.column,
-            width: source_area.width,
-            height: source_area.height,
-        };
-        // Walk over every formula
-        let cells = self.get_all_cells();
-        for cell in cells {
-            if let Some(f) = self
-                .workbook
-                .worksheet(cell.index)
-                .expect("Worksheet must exist")
-                .cell(cell.row, cell.column)
-                .expect("Cell must exist")
-                .get_formula()
-            {
-                let sheet = cell.index;
-                let row = cell.row;
-                let column = cell.column;
-
-                // If cell is in the source or target area, skip
-                if ref_is_in_area(sheet, row, column, source_area)
-                    || ref_is_in_area(sheet, row, column, target_area)
-                {
-                    continue;
-                }
-
-                // Get the formula
-                // Get a copy of the AST
-                let node = &mut self.parsed_formulas[sheet as usize][f as usize].clone();
-                let cell_reference = CellReferenceRC {
-                    sheet: self.workbook.worksheets[sheet as usize].get_name(),
-                    column: cell.column,
-                    row: cell.row,
-                };
-                let context = CellReferenceIndex { sheet, column, row };
-                let formula = to_string(node, &cell_reference);
-                let target_sheet_name = &self.workbook.worksheets[target.sheet as usize].name;
-                forward_references(
-                    node,
-                    &context,
-                    source_area,
-                    target.sheet,
-                    target_sheet_name,
-                    target.row,
-                    target.column,
-                );
-
-                // If the string representation of the formula has changed update the cell
-                let updated_formula = to_string(node, &cell_reference);
-                if formula != updated_formula {
-                    self.update_cell_with_formula(
-                        sheet,
-                        row,
-                        column,
-                        format!("={updated_formula}"),
-                    )?;
-                    // Update the diff list
-                    diff_list.push(SetCellValue {
-                        cell: CellReferenceIndex { sheet, column, row },
-                        new_value: CellValue::Value(format!("={}", updated_formula)),
-                        old_value: CellValue::Value(format!("={}", formula)),
-                    });
-                }
-            }
-        }
-        Ok(diff_list)
-    }
-}

base/src/expressions/lexer/mod.rs

@@ -142,7 +142,7 @@ impl Lexer {
     pub fn expect(&mut self, tk: TokenType) -> Result<()> {
         let nt = self.next_token();
         if mem::discriminant(&nt) != mem::discriminant(&tk) {
-            return Err(self.set_error(&format!("Error, expected {:?}", tk), self.position));
+            return Err(self.set_error(&format!("Error, expected {tk:?}"), self.position));
         }
         Ok(())
     }
@@ -187,6 +187,7 @@ impl Lexer {
                     ']' => TokenType::RightBracket,
                     ':' => TokenType::Colon,
                     ';' => TokenType::Semicolon,
+                    '@' => TokenType::At,
                     ',' => {
                         if self.locale.numbers.symbols.decimal == "," {
                             match self.consume_number(',') {
@@ -313,6 +314,9 @@ impl Lexer {
                             } else if name_upper == self.language.booleans.r#false {
                                 return TokenType::Boolean(false);
                             }
+                            if self.peek_char() == Some('(') {
+                                return TokenType::Ident(name);
+                            }
                             if self.mode == LexerMode::A1 {
                                 let parsed_reference = utils::parse_reference_a1(&name_upper);
                                 if parsed_reference.is_some()
@@ -510,7 +514,7 @@ impl Lexer {
         self.position = position;
         chars.parse::<i32>().map_err(|_| LexerError {
             position,
-            message: format!("Failed to parse to int: {}", chars),
+            message: format!("Failed to parse to int: {chars}"),
         })
     }
 
@@ -571,9 +575,7 @@ impl Lexer {
         }
         self.position = position;
         match chars.parse::<f64>() {
-            Err(_) => {
-                Err(self.set_error(&format!("Failed to parse to double: {}", chars), position))
-            }
+            Err(_) => Err(self.set_error(&format!("Failed to parse to double: {chars}"), position)),
             Ok(v) => Ok(v),
         }
     }

base/src/expressions/lexer/ranges.rs

@@ -148,15 +148,16 @@ impl Lexer {
                     let row_left = match row_left.parse::<i32>() {
                         Ok(n) => n,
                         Err(_) => {
-                            return Err(self
-                                .set_error(&format!("Failed parsing row {}", row_left), position))
+                            return Err(
+                                self.set_error(&format!("Failed parsing row {row_left}"), position)
+                            )
                         }
                     };
                     let row_right = match row_right.parse::<i32>() {
                         Ok(n) => n,
                         Err(_) => {
                             return Err(self
-                                .set_error(&format!("Failed parsing row {}", row_right), position))
+                                .set_error(&format!("Failed parsing row {row_right}"), position))
                         }
                     };
                     if row_left > LAST_ROW {

base/src/expressions/lexer/structured_references.rs

@@ -23,19 +23,19 @@ impl Lexer {
             // TODO(TD): There are better ways of doing this :)
             let rest_of_formula: String = self.chars[self.position..self.len].iter().collect();
             let specifier = if rest_of_formula.starts_with("#This Row]") {
-                self.position += "#This Row]".bytes().len();
+                self.position += "#This Row]".len();
                 TableSpecifier::ThisRow
             } else if rest_of_formula.starts_with("#All]") {
-                self.position += "#All]".bytes().len();
+                self.position += "#All]".len();
                 TableSpecifier::All
             } else if rest_of_formula.starts_with("#Data]") {
-                self.position += "#Data]".bytes().len();
+                self.position += "#Data]".len();
                 TableSpecifier::Data
             } else if rest_of_formula.starts_with("#Headers]") {
-                self.position += "#Headers]".bytes().len();
+                self.position += "#Headers]".len();
                 TableSpecifier::Headers
             } else if rest_of_formula.starts_with("#Totals]") {
-                self.position += "#Totals]".bytes().len();
+                self.position += "#Totals]".len();
                 TableSpecifier::Totals
             } else {
                 return Err(LexerError {

base/src/expressions/lexer/test/mod.rs

@@ -1,4 +1,5 @@
 mod test_common;
+mod test_implicit_intersection;
 mod test_language;
 mod test_locale;
 mod test_ranges;

base/src/expressions/lexer/test/test_common.rs

@@ -1,5 +1,6 @@
 #![allow(clippy::unwrap_used)]
 
+use crate::expressions::utils::column_to_number;
 use crate::language::get_language;
 use crate::locale::get_locale;
 
@@ -685,3 +686,29 @@ fn test_comparisons() {
     assert_eq!(lx.next_token(), Number(7.0));
     assert_eq!(lx.next_token(), EOF);
 }
+
+#[test]
+fn test_log10_is_cell_reference() {
+    let mut lx = new_lexer("LOG10", true);
+    assert_eq!(
+        lx.next_token(),
+        Reference {
+            sheet: None,
+            column: column_to_number("LOG").unwrap(),
+            row: 10,
+            absolute_column: false,
+            absolute_row: false,
+        }
+    );
+    assert_eq!(lx.next_token(), EOF);
+}
+
+#[test]
+fn test_log10_is_function() {
+    let mut lx = new_lexer("LOG10(100)", true);
+    assert_eq!(lx.next_token(), Ident("LOG10".to_string()));
+    assert_eq!(lx.next_token(), LeftParenthesis);
+    assert_eq!(lx.next_token(), Number(100.0));
+    assert_eq!(lx.next_token(), RightParenthesis);
+    assert_eq!(lx.next_token(), EOF);
+}

base/src/expressions/lexer/test/test_implicit_intersection.rs

@@ -0,0 +1,25 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::expressions::{
+    lexer::{Lexer, LexerMode},
+    token::TokenType::*,
+};
+use crate::language::get_language;
+use crate::locale::get_locale;
+
+fn new_lexer(formula: &str) -> Lexer {
+    let locale = get_locale("en").unwrap();
+    let language = get_language("en").unwrap();
+    Lexer::new(formula, LexerMode::A1, locale, language)
+}
+
+#[test]
+fn sum_implicit_intersection() {
+    let mut lx = new_lexer("sum(@A1:A3)");
+    assert_eq!(lx.next_token(), Ident("sum".to_string()));
+    assert_eq!(lx.next_token(), LeftParenthesis);
+    assert_eq!(lx.next_token(), At);
+    assert!(matches!(lx.next_token(), Range { .. }));
+    assert_eq!(lx.next_token(), RightParenthesis);
+    assert_eq!(lx.next_token(), EOF);
+}

base/src/expressions/lexer/test/test_util.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::expect_used)]
+
 use crate::expressions::{
     lexer::util::get_tokens,
     token::{OpCompare, OpSum, TokenType},
@@ -22,6 +24,25 @@ fn test_get_tokens() {
     assert_eq!(l.end, 10);
 }
 
+#[test]
+fn get_tokens_unicode() {
+    let formula = "'🇵🇭 Philippines'!A1";
+    let t = get_tokens(formula);
+    assert_eq!(t.len(), 1);
+
+    let expected = TokenType::Reference {
+        sheet: Some("🇵🇭 Philippines".to_string()),
+        row: 1,
+        column: 1,
+        absolute_column: false,
+        absolute_row: false,
+    };
+    let l = t.first().expect("expected token");
+    assert_eq!(l.token, expected);
+    assert_eq!(l.start, 0);
+    assert_eq!(l.end, 19);
+}
+
 #[test]
 fn test_simple_tokens() {
     assert_eq!(

base/src/expressions/lexer/util.rs

@@ -52,7 +52,9 @@ pub fn get_tokens(formula: &str) -> Vec<MarkedToken> {
     let mut lexer = Lexer::new(
         formula,
         LexerMode::A1,
+        #[allow(clippy::expect_used)]
         get_locale("en").expect(""),
+        #[allow(clippy::expect_used)]
         get_language("en").expect(""),
     );
     let mut start = lexer.get_position();

base/src/expressions/parser/mod.rs

@@ -1,5 +1,5 @@
 /*!
-# GRAMAR
+# GRAMMAR
 
 <pre class="rust">
 opComp   => '=' | '<' | '>' | '<=' } '>=' | '<>'
@@ -12,7 +12,8 @@ term    => factor (opFactor factor)*
 factor  => prod (opProd prod)*
 prod    => power ('^' power)*
 power   => (unaryOp)* range '%'*
-range   => primary (':' primary)?
+range   => implicit (':' primary)?
+implicit=> '@' primary | primary
 primary => '(' expr ')'
         => number
         => function '(' f_args ')'
@@ -45,25 +46,19 @@ use super::utils::number_to_column;
 use token::OpCompare;
 
 pub mod move_formula;
+pub mod static_analysis;
 pub mod stringify;
-pub mod walk;
 
 #[cfg(test)]
-mod test;
-
-#[cfg(test)]
-mod test_ranges;
-
-#[cfg(test)]
-mod test_move_formula;
-#[cfg(test)]
-mod test_tables;
+mod tests;
 
 pub(crate) fn parse_range(formula: &str) -> Result<(i32, i32, i32, i32), String> {
     let mut lexer = lexer::Lexer::new(
         formula,
         lexer::LexerMode::A1,
+        #[allow(clippy::expect_used)]
         get_locale("en").expect(""),
+        #[allow(clippy::expect_used)]
         get_language("en").expect(""),
     );
     if let TokenType::Range {
@@ -87,6 +82,9 @@ fn get_table_column_by_name(table_column_name: &str, table: &Table) -> Option<i3
     None
 }
 
+// DefinedNameS is a tuple with the name of the defined name, the index of the sheet and the formula
+pub type DefinedNameS = (String, Option<u32>, String);
+
 pub(crate) struct Reference<'a> {
     sheet_name: &'a Option<String>,
     sheet_index: u32,
@@ -96,6 +94,14 @@ pub(crate) struct Reference<'a> {
     column: i32,
 }
 
+#[derive(PartialEq, Clone, Debug)]
+pub enum ArrayNode {
+    Boolean(bool),
+    Number(f64),
+    String(String),
+    Error(token::Error),
+}
+
 #[derive(PartialEq, Clone, Debug)]
 pub enum Node {
     BooleanKind(bool),
@@ -169,8 +175,14 @@ pub enum Node {
         name: String,
         args: Vec<Node>,
     },
-    ArrayKind(Vec<Node>),
-    VariableKind(String),
+    ArrayKind(Vec<Vec<ArrayNode>>),
+    DefinedNameKind(DefinedNameS),
+    TableNameKind(String),
+    WrongVariableKind(String),
+    ImplicitIntersection {
+        automatic: bool,
+        child: Box<Node>,
+    },
     CompareKind {
         kind: OpCompare,
         left: Box<Node>,
@@ -193,22 +205,35 @@ pub enum Node {
 pub struct Parser {
     lexer: lexer::Lexer,
     worksheets: Vec<String>,
-    context: Option<CellReferenceRC>,
+    defined_names: Vec<DefinedNameS>,
+    context: CellReferenceRC,
     tables: HashMap<String, Table>,
 }
 
 impl Parser {
-    pub fn new(worksheets: Vec<String>, tables: HashMap<String, Table>) -> Parser {
+    pub fn new(
+        worksheets: Vec<String>,
+        defined_names: Vec<DefinedNameS>,
+        tables: HashMap<String, Table>,
+    ) -> Parser {
         let lexer = lexer::Lexer::new(
             "",
             lexer::LexerMode::A1,
+            #[allow(clippy::expect_used)]
             get_locale("en").expect(""),
+            #[allow(clippy::expect_used)]
             get_language("en").expect(""),
         );
+        let context = CellReferenceRC {
+            sheet: worksheets.first().map_or("", |v| v).to_string(),
+            column: 1,
+            row: 1,
+        };
         Parser {
             lexer,
             worksheets,
-            context: None,
+            defined_names,
+            context,
             tables,
         }
     }
@@ -216,13 +241,18 @@ impl Parser {
         self.lexer.set_lexer_mode(mode)
     }
 
-    pub fn set_worksheets(&mut self, worksheets: Vec<String>) {
+    pub fn set_worksheets_and_names(
+        &mut self,
+        worksheets: Vec<String>,
+        defined_names: Vec<DefinedNameS>,
+    ) {
         self.worksheets = worksheets;
+        self.defined_names = defined_names;
     }
 
-    pub fn parse(&mut self, formula: &str, context: &Option<CellReferenceRC>) -> Node {
+    pub fn parse(&mut self, formula: &str, context: &CellReferenceRC) -> Node {
         self.lexer.set_formula(formula);
-        self.context.clone_from(context);
+        self.context = context.clone();
         self.parse_expr()
     }
 
@@ -236,6 +266,24 @@ impl Parser {
         None
     }
 
+    // Returns:
+    //  * None: If there is no defined name by that name
+    //  * Some((Some(index), formula)): If there is a defined name local to that sheet
+    //  * Some(None): If there is a global defined name
+    fn get_defined_name(&self, name: &str, sheet: u32) -> Option<(Option<u32>, String)> {
+        for (df_name, df_scope, df_formula) in &self.defined_names {
+            if name.to_lowercase() == df_name.to_lowercase() && df_scope == &Some(sheet) {
+                return Some((*df_scope, df_formula.to_owned()));
+            }
+        }
+        for (df_name, df_scope, df_formula) in &self.defined_names {
+            if name.to_lowercase() == df_name.to_lowercase() && df_scope.is_none() {
+                return Some((None, df_formula.to_owned()));
+            }
+        }
+        None
+    }
+
     fn parse_expr(&mut self) -> Node {
         let mut t = self.parse_concat();
         if let Node::ParseErrorKind { .. } = t {
@@ -379,7 +427,7 @@ impl Parser {
     }
 
     fn parse_range(&mut self) -> Node {
-        let t = self.parse_primary();
+        let t = self.parse_implicit();
         if let Node::ParseErrorKind { .. } = t {
             return t;
         }
@@ -398,6 +446,65 @@ impl Parser {
         t
     }
 
+    fn parse_implicit(&mut self) -> Node {
+        let next_token = self.lexer.peek_token();
+        if next_token == TokenType::At {
+            self.lexer.advance_token();
+            let t = self.parse_primary();
+            if let Node::ParseErrorKind { .. } = t {
+                return t;
+            }
+            return Node::ImplicitIntersection {
+                automatic: false,
+                child: Box::new(t),
+            };
+        }
+        self.parse_primary()
+    }
+
+    fn parse_array_row(&mut self) -> Result<Vec<ArrayNode>, Node> {
+        let mut row = Vec::new();
+        // and array can only have numbers, string or booleans
+        // otherwise it is a syntax error
+        let first_element = match self.parse_expr() {
+            Node::BooleanKind(s) => ArrayNode::Boolean(s),
+            Node::NumberKind(s) => ArrayNode::Number(s),
+            Node::StringKind(s) => ArrayNode::String(s),
+            Node::ErrorKind(kind) => ArrayNode::Error(kind),
+            error @ Node::ParseErrorKind { .. } => return Err(error),
+            _ => {
+                return Err(Node::ParseErrorKind {
+                    formula: self.lexer.get_formula(),
+                    message: "Invalid value in array".to_string(),
+                    position: self.lexer.get_position() as usize,
+                });
+            }
+        };
+        row.push(first_element);
+        let mut next_token = self.lexer.peek_token();
+        // FIXME: this is not respecting the locale
+        while next_token == TokenType::Comma {
+            self.lexer.advance_token();
+            let value = match self.parse_expr() {
+                Node::BooleanKind(s) => ArrayNode::Boolean(s),
+                Node::NumberKind(s) => ArrayNode::Number(s),
+                Node::StringKind(s) => ArrayNode::String(s),
+                Node::ErrorKind(kind) => ArrayNode::Error(kind),
+                error @ Node::ParseErrorKind { .. } => return Err(error),
+                _ => {
+                    return Err(Node::ParseErrorKind {
+                        formula: self.lexer.get_formula(),
+                        message: "Invalid value in array".to_string(),
+                        position: self.lexer.get_position() as usize,
+                    });
+                }
+            };
+            row.push(value);
+            next_token = self.lexer.peek_token();
+        }
+        Ok(row)
+    }
+
     fn parse_primary(&mut self) -> Node {
         let next_token = self.lexer.next_token();
         match next_token {
@@ -419,21 +526,35 @@ impl Parser {
             TokenType::Number(s) => Node::NumberKind(s),
             TokenType::String(s) => Node::StringKind(s),
             TokenType::LeftBrace => {
-                let t = self.parse_expr();
-                if let Node::ParseErrorKind { .. } = t {
-                    return t;
-                }
+                // It's an array. It's a collection of rows all of the same dimension
+
+                let first_row = match self.parse_array_row() {
+                    Ok(s) => s,
+                    Err(error) => return error,
+                };
+                let length = first_row.len();
+
+                let mut matrix = Vec::new();
+                matrix.push(first_row);
+                // FIXME: this is not respecting the locale
                 let mut next_token = self.lexer.peek_token();
-                let mut args: Vec<Node> = vec![t];
                 while next_token == TokenType::Semicolon {
                     self.lexer.advance_token();
-                    let p = self.parse_expr();
-                    if let Node::ParseErrorKind { .. } = p {
-                        return p;
-                    }
+                    let row = match self.parse_array_row() {
+                        Ok(s) => s,
+                        Err(error) => return error,
+                    };
                     next_token = self.lexer.peek_token();
-                    args.push(p);
+                    if row.len() != length {
+                        return Node::ParseErrorKind {
+                            formula: self.lexer.get_formula(),
+                            position: self.lexer.get_position() as usize,
+                            message: "All rows in an array should be the same length".to_string(),
+                        };
+                    }
+                    matrix.push(row);
                 }
+
                 if let Err(err) = self.lexer.expect(TokenType::RightBrace) {
                     return Node::ParseErrorKind {
                         formula: self.lexer.get_formula(),
@@ -441,7 +562,7 @@ impl Parser {
                         message: err.message,
                     };
                 }
-                Node::ArrayKind(args)
+                Node::ArrayKind(matrix)
             }
             TokenType::Reference {
                 sheet,
@@ -450,16 +571,7 @@ impl Parser {
                 absolute_column,
                 absolute_row,
             } => {
-                let context = match &self.context {
-                    Some(c) => c,
-                    None => {
-                        return Node::ParseErrorKind {
-                            formula: self.lexer.get_formula(),
-                            position: self.lexer.get_position() as usize,
-                            message: "Expected context for the reference".to_string(),
-                        }
-                    }
-                };
+                let context = &self.context;
                 let sheet_index = match &sheet {
                     Some(name) => self.get_sheet_index_by_name(name),
                     None => self.get_sheet_index_by_name(&context.sheet),
@@ -494,16 +606,7 @@ impl Parser {
                 }
             }
             TokenType::Range { sheet, left, right } => {
-                let context = match &self.context {
-                    Some(c) => c,
-                    None => {
-                        return Node::ParseErrorKind {
-                            formula: self.lexer.get_formula(),
-                            position: self.lexer.get_position() as usize,
-                            message: "Expected context for the reference".to_string(),
-                        }
-                    }
-                };
+                let context = &self.context;
                 let sheet_index = match &sheet {
                     Some(name) => self.get_sheet_index_by_name(name),
                     None => self.get_sheet_index_by_name(&context.sheet),
@@ -518,20 +621,6 @@ impl Parser {
                 let mut absolute_row1 = left.absolute_row;
                 let mut absolute_row2 = right.absolute_row;
 
-                if self.lexer.is_a1_mode() {
-                    if !left.absolute_row {
-                        row1 -= context.row
-                    };
-                    if !left.absolute_column {
-                        column1 -= context.column
-                    };
-                    if !right.absolute_row {
-                        row2 -= context.row
-                    };
-                    if !right.absolute_column {
-                        column2 -= context.column
-                    };
-                }
                 if row1 > row2 {
                     (row2, row1) = (row1, row2);
                     (absolute_row2, absolute_row1) = (absolute_row1, absolute_row2);
@@ -540,6 +629,22 @@ impl Parser {
                     (column2, column1) = (column1, column2);
                     (absolute_column2, absolute_column1) = (absolute_column1, absolute_column2);
                 }
+
+                if self.lexer.is_a1_mode() {
+                    if !absolute_row1 {
+                        row1 -= context.row
+                    };
+                    if !absolute_column1 {
+                        column1 -= context.column
+                    };
+                    if !absolute_row2 {
+                        row2 -= context.row
+                    };
+                    if !absolute_column2 {
+                        column2 -= context.column
+                    };
+                }
+
                 match sheet_index {
                     Some(index) => Node::RangeKind {
                         sheet_name: sheet,
@@ -587,11 +692,47 @@ impl Parser {
                             kind: function_kind,
                             args,
                         };
-                    } else {
-                        return Node::InvalidFunctionKind { name, args };
+                    }
+                    if &name == "_xlfn.SINGLE" {
+                        if args.len() != 1 {
+                            return Node::ParseErrorKind {
+                                formula: self.lexer.get_formula(),
+                                position: self.lexer.get_position() as usize,
+                                message: "Implicit Intersection requires just one argument"
+                                    .to_string(),
+                            };
+                        }
+                        return Node::ImplicitIntersection {
+                            automatic: false,
+                            child: Box::new(args[0].clone()),
+                        };
+                    }
+                    return Node::InvalidFunctionKind { name, args };
+                }
+                let context = &self.context;
+
+                let context_sheet_index = match self.get_sheet_index_by_name(&context.sheet) {
+                    Some(i) => i,
+                    None => {
+                        return Node::ParseErrorKind {
+                            formula: self.lexer.get_formula(),
+                            position: 0,
+                            message: format!("sheet not found: {}", context.sheet),
+                        };
+                    }
+                };
+
+                // Could be a defined name or a table
+                if let Some((scope, formula)) = self.get_defined_name(&name, context_sheet_index) {
+                    return Node::DefinedNameKind((name, scope, formula));
+                }
+                let name_lower = name.to_lowercase();
+                for table_name in self.tables.keys() {
+                    if table_name.to_lowercase() == name_lower {
+                        return Node::TableNameKind(name);
                     }
                 }
-                Node::VariableKind(name)
+                Node::WrongVariableKind(name)
             }
             TokenType::Error(kind) => Node::ErrorKind(kind),
             TokenType::Illegal(error) => Node::ParseErrorKind {
@@ -604,7 +745,38 @@ impl Parser {
                 position: 0,
                 message: "Unexpected end of input.".to_string(),
             },
-            TokenType::Boolean(value) => Node::BooleanKind(value),
+            TokenType::Boolean(value) => {
+                // Could be a function call "TRUE()"
+                let next_token = self.lexer.peek_token();
+                if next_token == TokenType::LeftParenthesis {
+                    self.lexer.advance_token();
+                    // We parse all the arguments, although technically this is moot
+                    // But is has the upside of transforming `=TRUE( 4 )` into `=TRUE(4)`
+                    let args = match self.parse_function_args() {
+                        Ok(s) => s,
+                        Err(e) => return e,
+                    };
+                    if let Err(err) = self.lexer.expect(TokenType::RightParenthesis) {
+                        return Node::ParseErrorKind {
+                            formula: self.lexer.get_formula(),
+                            position: err.position,
+                            message: err.message,
+                        };
+                    }
+                    if value {
+                        return Node::FunctionKind {
+                            kind: Function::True,
+                            args,
+                        };
+                    } else {
+                        return Node::FunctionKind {
+                            kind: Function::False,
+                            args,
+                        };
+                    }
+                }
+                Node::BooleanKind(value)
+            }
             TokenType::Compare(_) => {
                 // A primary Node cannot start with an operator
                 Node::ParseErrorKind {
@@ -637,6 +809,14 @@ impl Parser {
                     message: "Unexpected token: 'POWER'".to_string(),
                 }
             }
+            TokenType::At => {
+                // A primary Node cannot start with an operator
+                Node::ParseErrorKind {
+                    formula: self.lexer.get_formula(),
+                    position: 0,
+                    message: "Unexpected token: '@'".to_string(),
+                }
+            }
             TokenType::RightParenthesis
             | TokenType::RightBracket
             | TokenType::Colon
@@ -648,7 +828,7 @@ impl Parser {
             | TokenType::Percent => Node::ParseErrorKind {
                 formula: self.lexer.get_formula(),
                 position: 0,
-                message: format!("Unexpected token: '{:?}'", next_token),
+                message: format!("Unexpected token: '{next_token:?}'"),
             },
             TokenType::LeftBracket => Node::ParseErrorKind {
                 formula: self.lexer.get_formula(),
@@ -663,177 +843,177 @@ impl Parser {
                 // We will try to convert to a normal reference
                 // table_name[column_name] => cell1:cell2
                 // table_name[[#This Row], [column_name]:[column_name]] => cell1:cell2
-                if let Some(context) = &self.context {
-                    let context_sheet_index = match self.get_sheet_index_by_name(&context.sheet) {
-                        Some(i) => i,
-                        None => {
-                            return Node::ParseErrorKind {
-                                formula: self.lexer.get_formula(),
-                                position: 0,
-                                message: "sheet not found".to_string(),
-                            };
-                        }
-                    };
-                    // table-name => table
-                    let table = self.tables.get(&table_name).unwrap_or_else(|| {
-                        panic!(
+                let context = &self.context;
+                let context_sheet_index = match self.get_sheet_index_by_name(&context.sheet) {
+                    Some(i) => i,
+                    None => {
+                        return Node::ParseErrorKind {
+                            formula: self.lexer.get_formula(),
+                            position: 0,
+                            message: format!("sheet not found: {}", context.sheet),
+                        };
+                    }
+                };
+                // table-name => table
+                let table = match self.tables.get(&table_name) {
+                    Some(t) => t,
+                    None => {
+                        let message = format!(
                             "Table not found: '{table_name}' at '{}!{}{}'",
                             context.sheet,
-                            number_to_column(context.column).expect(""),
+                            number_to_column(context.column)
+                                .unwrap_or(format!("{}", context.column)),
                             context.row
-                        )
-                    });
-                    let table_sheet_index = match self.get_sheet_index_by_name(&table.sheet_name) {
-                        Some(i) => i,
-                        None => {
-                            return Node::ParseErrorKind {
-                                formula: self.lexer.get_formula(),
-                                position: 0,
-                                message: "sheet not found".to_string(),
-                            };
-                        }
-                    };
+                        );
+                        return Node::ParseErrorKind {
+                            formula: self.lexer.get_formula(),
+                            position: 0,
+                            message,
+                        };
+                    }
+                };
+                let table_sheet_index = match self.get_sheet_index_by_name(&table.sheet_name) {
+                    Some(i) => i,
+                    None => {
+                        return Node::ParseErrorKind {
+                            formula: self.lexer.get_formula(),
+                            position: 0,
+                            message: format!("table sheet not found: {}", table.sheet_name),
+                        };
+                    }
+                };
 
-                    let sheet_name = if table_sheet_index == context_sheet_index {
-                        None
-                    } else {
-                        Some(table.sheet_name.clone())
-                    };
+                let sheet_name = if table_sheet_index == context_sheet_index {
+                    None
+                } else {
+                    Some(table.sheet_name.clone())
+                };
 
-                    // context must be with tables.reference
-                    let (column_start, mut row_start, column_end, mut row_end) =
-                        parse_range(&table.reference).expect("Failed parsing range");
+                // context must be with tables.reference
+                #[allow(clippy::expect_used)]
+                let (column_start, mut row_start, column_end, mut row_end) =
+                    parse_range(&table.reference).expect("Failed parsing range");
 
-                    let totals_row_count = table.totals_row_count as i32;
-                    let header_row_count = table.header_row_count as i32;
-                    row_end -= totals_row_count;
+                let totals_row_count = table.totals_row_count as i32;
+                let header_row_count = table.header_row_count as i32;
+                row_end -= totals_row_count;
 
-                    match specifier {
-                        Some(token::TableSpecifier::ThisRow) => {
-                            row_start = context.row;
-                            row_end = context.row;
-                        }
-                        Some(token::TableSpecifier::Totals) => {
-                            if totals_row_count != 0 {
-                                row_start = row_end + 1;
-                                row_end = row_start;
-                            } else {
-                                // Table1[#Totals] is #REF! if Table1 does not have totals
-                                return Node::ErrorKind(token::Error::REF);
-                            }
-                        }
-                        Some(token::TableSpecifier::Headers) => {
+                match specifier {
+                    Some(token::TableSpecifier::ThisRow) => {
+                        row_start = context.row;
+                        row_end = context.row;
+                    }
+                    Some(token::TableSpecifier::Totals) => {
+                        if totals_row_count != 0 {
+                            row_start = row_end + 1;
                             row_end = row_start;
-                        }
-                        Some(token::TableSpecifier::Data) => {
-                            row_start += header_row_count;
-                        }
-                        Some(token::TableSpecifier::All) => {
-                            if totals_row_count != 0 {
-                                row_end += 1;
-                            }
-                        }
-                        None => {
-                            // skip the headers
-                            row_start += header_row_count;
+                        } else {
+                            // Table1[#Totals] is #REF! if Table1 does not have totals
+                            return Node::ErrorKind(token::Error::REF);
                         }
                     }
-                    match table_reference {
-                        None => {
-                            return Node::RangeKind {
-                                sheet_name,
-                                sheet_index: table_sheet_index,
-                                absolute_row1: true,
-                                absolute_column1: true,
-                                row1: row_start,
-                                column1: column_start,
-                                absolute_row2: true,
-                                absolute_column2: true,
-                                row2: row_end,
-                                column2: column_end,
-                            };
-                        }
-                        Some(TableReference::ColumnReference(s)) => {
-                            let column_index = match get_table_column_by_name(&s, table) {
-                                Some(s) => s + column_start,
-                                None => {
-                                    return Node::ParseErrorKind {
-                                        formula: self.lexer.get_formula(),
-                                        position: self.lexer.get_position() as usize,
-                                        message: format!(
-                                            "Expecting column: {s} in table {table_name}"
-                                        ),
-                                    };
-                                }
-                            };
-                            if row_start == row_end {
-                                return Node::ReferenceKind {
-                                    sheet_name,
-                                    sheet_index: table_sheet_index,
-                                    absolute_row: true,
-                                    absolute_column: true,
-                                    row: row_start,
-                                    column: column_index,
-                                };
-                            }
-                            return Node::RangeKind {
-                                sheet_name,
-                                sheet_index: table_sheet_index,
-                                absolute_row1: true,
-                                absolute_column1: true,
-                                row1: row_start,
-                                column1: column_index,
-                                absolute_row2: true,
-                                absolute_column2: true,
-                                row2: row_end,
-                                column2: column_index,
-                            };
-                        }
-                        Some(TableReference::RangeReference((left, right))) => {
-                            let left_column_index = match get_table_column_by_name(&left, table) {
-                                Some(f) => f + column_start,
-                                None => {
-                                    return Node::ParseErrorKind {
-                                        formula: self.lexer.get_formula(),
-                                        position: self.lexer.get_position() as usize,
-                                        message: format!(
-                                            "Expecting column: {left} in table {table_name}"
-                                        ),
-                                    };
-                                }
-                            };
-
-                            let right_column_index = match get_table_column_by_name(&right, table) {
-                                Some(f) => f + column_start,
-                                None => {
-                                    return Node::ParseErrorKind {
-                                        formula: self.lexer.get_formula(),
-                                        position: self.lexer.get_position() as usize,
-                                        message: format!(
-                                            "Expecting column: {right} in table {table_name}"
-                                        ),
-                                    };
-                                }
-                            };
-                            return Node::RangeKind {
-                                sheet_name,
-                                sheet_index: table_sheet_index,
-                                absolute_row1: true,
-                                absolute_column1: true,
-                                row1: row_start,
-                                column1: left_column_index,
-                                absolute_row2: true,
-                                absolute_column2: true,
-                                row2: row_end,
-                                column2: right_column_index,
-                            };
+                    Some(token::TableSpecifier::Headers) => {
+                        row_end = row_start;
+                    }
+                    Some(token::TableSpecifier::Data) => {
+                        row_start += header_row_count;
+                    }
+                    Some(token::TableSpecifier::All) => {
+                        if totals_row_count != 0 {
+                            row_end += 1;
                         }
                     }
+                    None => {
+                        // skip the headers
+                        row_start += header_row_count;
+                    }
                 }
-                Node::ParseErrorKind {
-                    formula: self.lexer.get_formula(),
-                    position: 0,
-                    message: "Structured references not supported in R1C1 mode".to_string(),
+                match table_reference {
+                    None => Node::RangeKind {
+                        sheet_name,
+                        sheet_index: table_sheet_index,
+                        absolute_row1: true,
+                        absolute_column1: true,
+                        row1: row_start,
+                        column1: column_start,
+                        absolute_row2: true,
+                        absolute_column2: true,
+                        row2: row_end,
+                        column2: column_end,
+                    },
+                    Some(TableReference::ColumnReference(s)) => {
+                        let column_index = match get_table_column_by_name(&s, table) {
+                            Some(s) => s + column_start,
+                            None => {
+                                return Node::ParseErrorKind {
+                                    formula: self.lexer.get_formula(),
+                                    position: self.lexer.get_position() as usize,
+                                    message: format!("Expecting column: {s} in table {table_name}"),
+                                };
+                            }
+                        };
+                        if row_start == row_end {
+                            return Node::ReferenceKind {
+                                sheet_name,
+                                sheet_index: table_sheet_index,
+                                absolute_row: true,
+                                absolute_column: true,
+                                row: row_start,
+                                column: column_index,
+                            };
+                        }
+                        Node::RangeKind {
+                            sheet_name,
+                            sheet_index: table_sheet_index,
+                            absolute_row1: true,
+                            absolute_column1: true,
+                            row1: row_start,
+                            column1: column_index,
+                            absolute_row2: true,
+                            absolute_column2: true,
+                            row2: row_end,
+                            column2: column_index,
+                        }
+                    }
+                    Some(TableReference::RangeReference((left, right))) => {
+                        let left_column_index = match get_table_column_by_name(&left, table) {
+                            Some(f) => f + column_start,
+                            None => {
+                                return Node::ParseErrorKind {
+                                    formula: self.lexer.get_formula(),
+                                    position: self.lexer.get_position() as usize,
+                                    message: format!(
+                                        "Expecting column: {left} in table {table_name}"
+                                    ),
+                                };
+                            }
+                        };
+
+                        let right_column_index = match get_table_column_by_name(&right, table) {
+                            Some(f) => f + column_start,
+                            None => {
+                                return Node::ParseErrorKind {
+                                    formula: self.lexer.get_formula(),
+                                    position: self.lexer.get_position() as usize,
+                                    message: format!(
+                                        "Expecting column: {right} in table {table_name}"
+                                    ),
+                                };
+                            }
+                        };
+                        Node::RangeKind {
+                            sheet_name,
+                            sheet_index: table_sheet_index,
+                            absolute_row1: true,
+                            absolute_column1: true,
+                            row1: row_start,
+                            column1: left_column_index,
+                            absolute_row2: true,
+                            absolute_column2: true,
+                            row2: row_end,
+                            column2: right_column_index,
+                        }
+                    }
                 }
             }
         }

base/src/expressions/parser/move_formula.rs

@@ -1,6 +1,6 @@
 use super::{
     stringify::{stringify_reference, DisplaceData},
-    Node, Reference,
+    ArrayNode, Node, Reference,
 };
 use crate::{
     constants::{LAST_COLUMN, LAST_ROW},
@@ -53,15 +53,24 @@ fn move_function(name: &str, args: &Vec<Node>, move_context: &MoveContext) -> St
             arguments = to_string_moved(el, move_context);
         }
     }
-    format!("{}({})", name, arguments)
+    format!("{name}({arguments})")
+}
+
+pub(crate) fn to_string_array_node(node: &ArrayNode) -> String {
+    match node {
+        ArrayNode::Boolean(value) => format!("{value}").to_ascii_uppercase(),
+        ArrayNode::Number(number) => to_excel_precision_str(*number),
+        ArrayNode::String(value) => format!("\"{value}\""),
+        ArrayNode::Error(kind) => format!("{kind}"),
+    }
 }
 
 fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
     use self::Node::*;
     match node {
-        BooleanKind(value) => format!("{}", value).to_ascii_uppercase(),
+        BooleanKind(value) => format!("{value}").to_ascii_uppercase(),
         NumberKind(number) => to_excel_precision_str(*number),
-        StringKind(value) => format!("\"{}\"", value),
+        StringKind(value) => format!("\"{value}\""),
         ReferenceKind {
             sheet_name,
             sheet_index,
@@ -232,7 +241,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
                 full_row,
                 full_column,
             );
-            format!("{}:{}", s1, s2)
+            format!("{s1}:{s2}")
         }
         WrongReferenceKind {
             sheet_name,
@@ -316,7 +325,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
                 full_row,
                 full_column,
             );
-            format!("{}:{}", s1, s2)
+            format!("{s1}:{s2}")
         }
         OpRangeKind { left, right } => format!(
             "{}:{}",
@@ -349,7 +358,7 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
                 }
                 _ => to_string_moved(right, move_context),
             };
-            format!("{}{}{}", x, kind, y)
+            format!("{x}{kind}{y}")
         }
         OpPowerKind { left, right } => format!(
             "{}^{}",
@@ -362,20 +371,43 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
             move_function(name, args, move_context)
         }
         ArrayKind(args) => {
-            // This code is a placeholder. Arrays are not yet implemented
-            let mut first = true;
-            let mut arguments = "".to_string();
-            for el in args {
-                if !first {
-                    arguments = format!("{},{}", arguments, to_string_moved(el, move_context));
+            let mut first_row = true;
+            let mut matrix_string = String::new();
+
+            // Each element in `args` is assumed to be one "row" (itself a `Vec<T>`).
+            for row in args {
+                if !first_row {
+                    matrix_string.push(',');
                 } else {
-                    first = false;
-                    arguments = to_string_moved(el, move_context);
+                    first_row = false;
                 }
+
+                // Build the string for the current row
+                let mut first_col = true;
+                let mut row_string = String::new();
+                for el in row {
+                    if !first_col {
+                        row_string.push(',');
+                    } else {
+                        first_col = false;
+                    }
+
+                    // Reuse your existing element-stringification function
+                    row_string.push_str(&to_string_array_node(el));
+                }
+
+                // Enclose the row in braces
+                matrix_string.push('{');
+                matrix_string.push_str(&row_string);
+                matrix_string.push('}');
             }
-            format!("{{{}}}", arguments)
+
+            // Enclose the whole matrix in braces
+            format!("{{{matrix_string}}}")
         }
-        VariableKind(value) => value.to_string(),
+        DefinedNameKind((name, ..)) => name.to_string(),
+        TableNameKind(name) => name.to_string(),
+        WrongVariableKind(name) => name.to_string(),
         CompareKind { kind, left, right } => format!(
             "{}{}{}",
             to_string_moved(left, move_context),
@@ -386,12 +418,18 @@ fn to_string_moved(node: &Node, move_context: &MoveContext) -> String {
             OpUnary::Minus => format!("-{}", to_string_moved(right, move_context)),
             OpUnary::Percentage => format!("{}%", to_string_moved(right, move_context)),
         },
-        ErrorKind(kind) => format!("{}", kind),
+        ErrorKind(kind) => format!("{kind}"),
         ParseErrorKind {
             formula,
             message: _,
             position: _,
         } => formula.to_string(),
         EmptyArgKind => "".to_string(),
+        ImplicitIntersection {
+            automatic: _,
+            child,
+        } => {
+            format!("@{}", to_string_moved(child, move_context))
+        }
     }
 }

base/src/expressions/parser/static_analysis.rs

@@ -0,0 +1,995 @@
+use crate::functions::Function;
+
+use super::Node;
+
+use regex::Regex;
+use std::sync::OnceLock;
+
+static RANGE_REFERENCE_REGEX: OnceLock<Regex> = OnceLock::new();
+
+#[allow(clippy::expect_used)]
+fn get_re() -> &'static Regex {
+    RANGE_REFERENCE_REGEX
+        .get_or_init(|| Regex::new(r":[A-Z]*[0-9]*$").expect("Regex is known to be valid"))
+}
+
+fn is_range_reference(s: &str) -> bool {
+    get_re().is_match(s)
+}
+
+/*
+
+# NOTES on the Implicit Intersection operator: @
+
+ Sometimes we obtain a range where we expected a single argument. This can happen:
+
+ * As an argument of a function, eg: `SIN(A1:A5)`
+ * As the result of a computation of a formula `=A1:A5`
+
+ In previous versions of the Friendly Giant the spreadsheet engine would perform an operation called _implicit intersection_
+ that tries to find a single cell within the range. It works by picking a cell in the range that is the same row or the same column
+ as the cell. If there is just one we return that otherwise we return the `#REF!` error.
+
+ Examples:
+
+ * Siting on `C3` the formula `=D1:D5` will return `D3`
+ * Sitting on `C3` the formula `=D:D` will return `D3`
+ * Sitting on `C3` the formula `=A1:A7` will return `A3`
+ * Sitting on `C3` the formula `=A5:A8` will return `#REF!`
+ * Sitting on `C3` the formula `D1:G7` will return `#REF!`
+
+ Today's version of the engine will result in a dynamic array spilling the result through several cells.
+ To force the old behaviour we can use the _implicit intersection operator_: @
+
+ * `=@A1:A7` or `=SIN(@A1:A7)
+
+ When parsing formulas that come form old workbooks this is done automatically.
+ We call this version of the II operator the _automatic_ II operator.
+
+ We can also insert the II operator in places where before was impossible:
+
+ * `=SUM(@A1:A7)`
+
+ This formulas will not be compatible with old versions of the engine. The FG will stringify this as `=SUM(_xlfn.SIMPLE(A1:A7))`.
+ */
+
+/// Transverses the formula tree adding the implicit intersection operator in all arguments of functions that
+/// expect a scalar but get a range.
+///  * A:A => @A:A
+///  * SIN(A1:D1) => SIN(@A1:D1)
+///
+/// Assumes formula return a scalar
+pub fn add_implicit_intersection(node: &mut Node, add: bool) {
+    match node {
+        Node::BooleanKind(_)
+        | Node::NumberKind(_)
+        | Node::StringKind(_)
+        | Node::ErrorKind(_)
+        | Node::EmptyArgKind
+        | Node::ParseErrorKind { .. }
+        | Node::WrongReferenceKind { .. }
+        | Node::WrongRangeKind { .. }
+        | Node::InvalidFunctionKind { .. }
+        | Node::ArrayKind(_)
+        | Node::ReferenceKind { .. } => {}
+        Node::ImplicitIntersection { child, .. } => {
+            // We need to check wether the II can be automatic or not
+            let mut new_node = child.as_ref().clone();
+            add_implicit_intersection(&mut new_node, add);
+            if matches!(&new_node, Node::ImplicitIntersection { .. }) {
+                *node = new_node
+            }
+        }
+        Node::RangeKind {
+            row1,
+            column1,
+            row2,
+            column2,
+            sheet_name,
+            sheet_index,
+            absolute_row1,
+            absolute_column1,
+            absolute_row2,
+            absolute_column2,
+        } => {
+            if add {
+                *node = Node::ImplicitIntersection {
+                    automatic: true,
+                    child: Box::new(Node::RangeKind {
+                        sheet_name: sheet_name.clone(),
+                        sheet_index: *sheet_index,
+                        absolute_row1: *absolute_row1,
+                        absolute_column1: *absolute_column1,
+                        row1: *row1,
+                        column1: *column1,
+                        absolute_row2: *absolute_row2,
+                        absolute_column2: *absolute_column2,
+                        row2: *row2,
+                        column2: *column2,
+                    }),
+                };
+            }
+        }
+        Node::OpRangeKind { left, right } => {
+            if add {
+                *node = Node::ImplicitIntersection {
+                    automatic: true,
+                    child: Box::new(Node::OpRangeKind {
+                        left: left.clone(),
+                        right: right.clone(),
+                    }),
+                }
+            }
+        }
+
+        // operations
+        Node::UnaryKind { right, .. } => add_implicit_intersection(right, add),
+        Node::OpConcatenateKind { left, right }
+        | Node::OpSumKind { left, right, .. }
+        | Node::OpProductKind { left, right, .. }
+        | Node::OpPowerKind { left, right, .. }
+        | Node::CompareKind { left, right, .. } => {
+            add_implicit_intersection(left, add);
+            add_implicit_intersection(right, add);
+        }
+
+        Node::DefinedNameKind(v) => {
+            if add {
+                // Not all defined names deserve the II operator
+                // For instance =Sheet1!A1 doesn't need to be intersected
+                if is_range_reference(&v.2) {
+                    *node = Node::ImplicitIntersection {
+                        automatic: true,
+                        child: Box::new(Node::DefinedNameKind(v.to_owned())),
+                    }
+                }
+            }
+        }
+        Node::WrongVariableKind(v) => {
+            if add {
+                *node = Node::ImplicitIntersection {
+                    automatic: true,
+                    child: Box::new(Node::WrongVariableKind(v.to_owned())),
+                }
+            }
+        }
+        Node::TableNameKind(_) => {
+            // noop for now
+        }
+        Node::FunctionKind { kind, args } => {
+            let arg_count = args.len();
+            let signature = get_function_args_signature(kind, arg_count);
+            for index in 0..arg_count {
+                if matches!(signature[index], Signature::Scalar)
+                    && matches!(
+                        run_static_analysis_on_node(&args[index]),
+                        StaticResult::Range(_, _) | StaticResult::Unknown
+                    )
+                {
+                    add_implicit_intersection(&mut args[index], true);
+                } else {
+                    add_implicit_intersection(&mut args[index], false);
+                }
+            }
+            if add
+                && matches!(
+                    run_static_analysis_on_node(node),
+                    StaticResult::Range(_, _) | StaticResult::Unknown
+                )
+            {
+                *node = Node::ImplicitIntersection {
+                    automatic: true,
+                    child: Box::new(node.clone()),
+                }
+            }
+        }
+    };
+}
+
+#[derive(Clone)]
+pub enum StaticResult {
+    Scalar,
+    Array(i32, i32),
+    Range(i32, i32),
+    Unknown,
+    // TODO: What if one of the dimensions is known?
+    // what if the dimensions are unknown but bounded?
+}
+
+fn static_analysis_op_nodes(left: &Node, right: &Node) -> StaticResult {
+    let lhs = run_static_analysis_on_node(left);
+    let rhs = run_static_analysis_on_node(right);
+    match (lhs, rhs) {
+        (StaticResult::Scalar, StaticResult::Scalar) => StaticResult::Scalar,
+        (StaticResult::Scalar, StaticResult::Array(a, b) | StaticResult::Range(a, b)) => {
+            StaticResult::Array(a, b)
+        }
+
+        (StaticResult::Array(a, b) | StaticResult::Range(a, b), StaticResult::Scalar) => {
+            StaticResult::Array(a, b)
+        }
+        (
+            StaticResult::Array(a1, b1) | StaticResult::Range(a1, b1),
+            StaticResult::Array(a2, b2) | StaticResult::Range(a2, b2),
+        ) => StaticResult::Array(a1.max(a2), b1.max(b2)),
+
+        (_, StaticResult::Unknown) => StaticResult::Unknown,
+        (StaticResult::Unknown, _) => StaticResult::Unknown,
+    }
+}
+
+// Returns:
+//  * Scalar if we can proof the result of the evaluation is a scalar
+//  * Array(a, b) if we know it will be an a x b array.
+//  * Range(a, b) if we know it will be a a x b range.
+//  * Unknown if we cannot guaranty either
+pub(crate) fn run_static_analysis_on_node(node: &Node) -> StaticResult {
+    match node {
+        Node::BooleanKind(_)
+        | Node::NumberKind(_)
+        | Node::StringKind(_)
+        | Node::ErrorKind(_)
+        | Node::EmptyArgKind => StaticResult::Scalar,
+        Node::UnaryKind { right, .. } => run_static_analysis_on_node(right),
+        Node::ParseErrorKind { .. } => {
+            // StaticResult::Unknown is also valid
+            StaticResult::Scalar
+        }
+        Node::WrongReferenceKind { .. } => {
+            // StaticResult::Unknown is also valid
+            StaticResult::Scalar
+        }
+        Node::WrongRangeKind { .. } => {
+            // StaticResult::Unknown or Array is also valid
+            StaticResult::Scalar
+        }
+        Node::InvalidFunctionKind { .. } => {
+            // StaticResult::Unknown is also valid
+            StaticResult::Scalar
+        }
+        Node::ArrayKind(array) => {
+            let n = array.len() as i32;
+            // FIXME: This is a placeholder until we implement arrays
+            StaticResult::Array(n, 1)
+        }
+        Node::RangeKind {
+            row1,
+            column1,
+            row2,
+            column2,
+            ..
+        } => StaticResult::Range(row2 - row1, column2 - column1),
+        Node::OpRangeKind { .. } => {
+            // TODO: We could do a bit better here
+            StaticResult::Unknown
+        }
+        Node::ReferenceKind { .. } => StaticResult::Scalar,
+
+        // binary operations
+        Node::OpConcatenateKind { left, right } => static_analysis_op_nodes(left, right),
+        Node::OpSumKind { left, right, .. } => static_analysis_op_nodes(left, right),
+        Node::OpProductKind { left, right, .. } => static_analysis_op_nodes(left, right),
+        Node::OpPowerKind { left, right, .. } => static_analysis_op_nodes(left, right),
+        Node::CompareKind { left, right, .. } => static_analysis_op_nodes(left, right),
+
+        // defined names
+        Node::DefinedNameKind(_) => StaticResult::Unknown,
+        Node::WrongVariableKind(_) => StaticResult::Unknown,
+        Node::TableNameKind(_) => StaticResult::Unknown,
+        Node::FunctionKind { kind, args } => static_analysis_on_function(kind, args),
+        Node::ImplicitIntersection { .. } => StaticResult::Scalar,
+    }
+}
+
+// If all the arguments are scalars the function will return a scalar
+// If any of the arguments is a range or an array it will return an array
+fn scalar_arguments(args: &[Node]) -> StaticResult {
+    let mut n = 0;
+    let mut m = 0;
+    for arg in args {
+        match run_static_analysis_on_node(arg) {
+            StaticResult::Scalar => {
+                // noop
+            }
+            StaticResult::Array(a, b) | StaticResult::Range(a, b) => {
+                n = n.max(a);
+                m = m.max(b);
+            }
+            StaticResult::Unknown => return StaticResult::Unknown,
+        }
+    }
+    if n == 0 && m == 0 {
+        return StaticResult::Scalar;
+    }
+    StaticResult::Array(n, m)
+}
+
+// We only care if the function can return a range or not
+fn not_implemented(_args: &[Node]) -> StaticResult {
+    StaticResult::Scalar
+}
+
+fn static_analysis_offset(args: &[Node]) -> StaticResult {
+    // If first argument is a single cell reference and there are no4th and 5th argument,
+    // or they are 1, then it is a scalar
+    let arg_count = args.len();
+    if arg_count < 3 {
+        // Actually an error
+        return StaticResult::Scalar;
+    }
+    if !matches!(args[0], Node::ReferenceKind { .. }) {
+        return StaticResult::Unknown;
+    }
+    if arg_count == 3 {
+        return StaticResult::Scalar;
+    }
+    match args[3] {
+        Node::NumberKind(f) => {
+            if f != 1.0 {
+                return StaticResult::Unknown;
+            }
+        }
+        _ => return StaticResult::Unknown,
+    };
+    if arg_count == 4 {
+        return StaticResult::Scalar;
+    }
+    match args[4] {
+        Node::NumberKind(f) => {
+            if f != 1.0 {
+                return StaticResult::Unknown;
+            }
+        }
+        _ => return StaticResult::Unknown,
+    };
+    StaticResult::Unknown
+}
+
+// fn static_analysis_choose(_args: &[Node]) -> StaticResult {
+//     // We will always insert the @ in CHOOSE, but technically it is only needed if one of the elements is a range
+//     StaticResult::Unknown
+// }
+
+fn static_analysis_indirect(_args: &[Node]) -> StaticResult {
+    // We will always insert the @, but we don't need to do that in every scenario`
+    StaticResult::Unknown
+}
+
+fn static_analysis_index(_args: &[Node]) -> StaticResult {
+    // INDEX has two forms, but they are indistinguishable at parse time.
+    StaticResult::Unknown
+}
+
+#[derive(Clone)]
+enum Signature {
+    Scalar,
+    Vector,
+    Error,
+}
+
+fn args_signature_no_args(arg_count: usize) -> Vec<Signature> {
+    if arg_count == 0 {
+        vec![]
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
+fn args_signature_scalars(
+    arg_count: usize,
+    required_count: usize,
+    optional_count: usize,
+) -> Vec<Signature> {
+    if arg_count >= required_count && arg_count <= required_count + optional_count {
+        vec![Signature::Scalar; arg_count]
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
+fn args_signature_one_vector(arg_count: usize) -> Vec<Signature> {
+    if arg_count == 1 {
+        vec![Signature::Vector]
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
+fn args_signature_sumif(arg_count: usize) -> Vec<Signature> {
+    if arg_count == 2 {
+        vec![Signature::Vector, Signature::Scalar]
+    } else if arg_count == 3 {
+        vec![Signature::Vector, Signature::Scalar, Signature::Vector]
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
+// 1 or none scalars
+fn args_signature_sheet(arg_count: usize) -> Vec<Signature> {
+    if arg_count == 0 {
+        vec![]
+    } else if arg_count == 1 {
+        vec![Signature::Scalar]
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
+fn args_signature_hlookup(arg_count: usize) -> Vec<Signature> {
+    if arg_count == 3 {
+        vec![Signature::Vector, Signature::Vector, Signature::Scalar]
+    } else if arg_count == 4 {
+        vec![
+            Signature::Vector,
+            Signature::Vector,
+            Signature::Scalar,
+            Signature::Vector,
+        ]
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
+fn args_signature_index(arg_count: usize) -> Vec<Signature> {
+    if arg_count == 2 {
+        vec![Signature::Vector, Signature::Scalar]
+    } else if arg_count == 3 {
+        vec![Signature::Vector, Signature::Scalar, Signature::Scalar]
+    } else if arg_count == 4 {
+        vec![
+            Signature::Vector,
+            Signature::Scalar,
+            Signature::Scalar,
+            Signature::Scalar,
+        ]
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
+fn args_signature_lookup(arg_count: usize) -> Vec<Signature> {
+    if arg_count == 2 {
+        vec![Signature::Vector, Signature::Vector]
+    } else if arg_count == 3 {
+        vec![Signature::Vector, Signature::Vector, Signature::Vector]
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
+fn args_signature_match(arg_count: usize) -> Vec<Signature> {
+    if arg_count == 2 {
+        vec![Signature::Vector, Signature::Vector]
+    } else if arg_count == 3 {
+        vec![Signature::Vector, Signature::Vector, Signature::Scalar]
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
+fn args_signature_offset(arg_count: usize) -> Vec<Signature> {
+    if arg_count == 3 {
+        vec![Signature::Vector, Signature::Scalar, Signature::Scalar]
+    } else if arg_count == 4 {
+        vec![
+            Signature::Vector,
+            Signature::Scalar,
+            Signature::Scalar,
+            Signature::Scalar,
+        ]
+    } else if arg_count == 5 {
+        vec![
+            Signature::Vector,
+            Signature::Scalar,
+            Signature::Scalar,
+            Signature::Scalar,
+            Signature::Scalar,
+        ]
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
+fn args_signature_row(arg_count: usize) -> Vec<Signature> {
+    if arg_count == 0 {
+        vec![]
+    } else if arg_count == 1 {
+        vec![Signature::Vector]
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
+fn args_signature_xlookup(arg_count: usize) -> Vec<Signature> {
+    if !(3..=6).contains(&arg_count) {
+        return vec![Signature::Error; arg_count];
+    }
+    let mut result = vec![Signature::Scalar; arg_count];
+    result[0] = Signature::Vector;
+    result[1] = Signature::Vector;
+    result[2] = Signature::Vector;
+    result
+}
+
+fn args_signature_textafter(arg_count: usize) -> Vec<Signature> {
+    if !(2..=6).contains(&arg_count) {
+        vec![Signature::Scalar; arg_count]
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
+fn args_signature_textjoin(arg_count: usize) -> Vec<Signature> {
+    if arg_count >= 3 {
+        let mut result = vec![Signature::Vector; arg_count];
+        result[0] = Signature::Scalar;
+        result[1] = Signature::Scalar;
+        result
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
+fn args_signature_npv(arg_count: usize) -> Vec<Signature> {
+    if arg_count < 2 {
+        return vec![Signature::Error; arg_count];
+    }
+    let mut result = vec![Signature::Vector; arg_count];
+    result[0] = Signature::Scalar;
+    result
+}
+
+fn args_signature_irr(arg_count: usize) -> Vec<Signature> {
+    if arg_count > 2 {
+        vec![Signature::Error; arg_count]
+    } else if arg_count == 1 {
+        vec![Signature::Vector]
+    } else {
+        vec![Signature::Vector, Signature::Scalar]
+    }
+}
+
+fn args_signature_xirr(arg_count: usize) -> Vec<Signature> {
+    if arg_count == 2 {
+        vec![Signature::Vector; arg_count]
+    } else if arg_count == 3 {
+        vec![Signature::Vector, Signature::Vector, Signature::Scalar]
+    } else {
+        vec![Signature::Error; arg_count]
+    }
+}
+
+fn args_signature_mirr(arg_count: usize) -> Vec<Signature> {
+    if arg_count != 3 {
+        vec![Signature::Error; arg_count]
+    } else {
+        vec![Signature::Vector, Signature::Scalar, Signature::Scalar]
+    }
+}
+
+fn args_signature_xnpv(arg_count: usize) -> Vec<Signature> {
+    if arg_count != 3 {
+        vec![Signature::Error; arg_count]
+    } else {
+        vec![Signature::Scalar, Signature::Vector, Signature::Vector]
+    }
+}
+
+// FIXME: This is terrible duplications of efforts. We use the signature in at least three different places:
+// 1. When computing the function
+// 2. Checking the arguments to see if we need to insert the implicit intersection operator
+// 3. Understanding the return value
+//
+// The signature of the functions should be defined only once
+
+// Given a function and a number of arguments this returns the arguments at each position
+// are expected to be scalars or vectors (array/ranges).
+// Sets signature::Error to all arguments if the number of arguments is incorrect.
+fn get_function_args_signature(kind: &Function, arg_count: usize) -> Vec<Signature> {
+    match kind {
+        Function::And => vec![Signature::Vector; arg_count],
+        Function::False => args_signature_no_args(arg_count),
+        Function::If => args_signature_scalars(arg_count, 2, 1),
+        Function::Iferror => args_signature_scalars(arg_count, 2, 0),
+        Function::Ifna => args_signature_scalars(arg_count, 2, 0),
+        Function::Ifs => vec![Signature::Scalar; arg_count],
+        Function::Not => args_signature_scalars(arg_count, 1, 0),
+        Function::Or => vec![Signature::Vector; arg_count],
+        Function::Switch => vec![Signature::Scalar; arg_count],
+        Function::True => args_signature_no_args(arg_count),
+        Function::Xor => vec![Signature::Vector; arg_count],
+        Function::Abs => args_signature_scalars(arg_count, 1, 0),
+        Function::Acos => args_signature_scalars(arg_count, 1, 0),
+        Function::Acosh => args_signature_scalars(arg_count, 1, 0),
+        Function::Asin => args_signature_scalars(arg_count, 1, 0),
+        Function::Asinh => args_signature_scalars(arg_count, 1, 0),
+        Function::Atan => args_signature_scalars(arg_count, 1, 0),
+        Function::Atan2 => args_signature_scalars(arg_count, 2, 0),
+        Function::Atanh => args_signature_scalars(arg_count, 1, 0),
+        Function::Choose => vec![Signature::Scalar; arg_count],
+        Function::Column => args_signature_row(arg_count),
+        Function::Columns => args_signature_one_vector(arg_count),
+        Function::Ln => args_signature_scalars(arg_count, 1, 0),
+        Function::Log => args_signature_scalars(arg_count, 1, 1),
+        Function::Log10 => args_signature_scalars(arg_count, 1, 0),
+        Function::Cos => args_signature_scalars(arg_count, 1, 0),
+        Function::Cosh => args_signature_scalars(arg_count, 1, 0),
+        Function::Max => vec![Signature::Vector; arg_count],
+        Function::Min => vec![Signature::Vector; arg_count],
+        Function::Pi => args_signature_no_args(arg_count),
+        Function::Power => args_signature_scalars(arg_count, 2, 0),
+        Function::Product => vec![Signature::Vector; arg_count],
+        Function::Round => args_signature_scalars(arg_count, 2, 0),
+        Function::Rounddown => args_signature_scalars(arg_count, 2, 0),
+        Function::Roundup => args_signature_scalars(arg_count, 2, 0),
+        Function::Sin => args_signature_scalars(arg_count, 1, 0),
+        Function::Sinh => args_signature_scalars(arg_count, 1, 0),
+        Function::Sqrt => args_signature_scalars(arg_count, 1, 0),
+        Function::Sqrtpi => args_signature_scalars(arg_count, 1, 0),
+        Function::Sum => vec![Signature::Vector; arg_count],
+        Function::Sumif => args_signature_sumif(arg_count),
+        Function::Sumifs => vec![Signature::Vector; arg_count],
+        Function::Tan => args_signature_scalars(arg_count, 1, 0),
+        Function::Tanh => args_signature_scalars(arg_count, 1, 0),
+        Function::ErrorType => args_signature_scalars(arg_count, 1, 0),
+        Function::Isblank => args_signature_scalars(arg_count, 1, 0),
+        Function::Iserr => args_signature_scalars(arg_count, 1, 0),
+        Function::Iserror => args_signature_scalars(arg_count, 1, 0),
+        Function::Iseven => args_signature_scalars(arg_count, 1, 0),
+        Function::Isformula => args_signature_scalars(arg_count, 1, 0),
+        Function::Islogical => args_signature_scalars(arg_count, 1, 0),
+        Function::Isna => args_signature_scalars(arg_count, 1, 0),
+        Function::Isnontext => args_signature_scalars(arg_count, 1, 0),
+        Function::Isnumber => args_signature_scalars(arg_count, 1, 0),
+        Function::Isodd => args_signature_scalars(arg_count, 1, 0),
+        Function::Isref => args_signature_one_vector(arg_count),
+        Function::Istext => args_signature_scalars(arg_count, 1, 0),
+        Function::Na => args_signature_no_args(arg_count),
+        Function::Sheet => args_signature_sheet(arg_count),
+        Function::Type => args_signature_one_vector(arg_count),
+        Function::Hlookup => args_signature_hlookup(arg_count),
+        Function::Index => args_signature_index(arg_count),
+        Function::Indirect => args_signature_scalars(arg_count, 1, 0),
+        Function::Lookup => args_signature_lookup(arg_count),
+        Function::Match => args_signature_match(arg_count),
+        Function::Offset => args_signature_offset(arg_count),
+        Function::Row => args_signature_row(arg_count),
+        Function::Rows => args_signature_one_vector(arg_count),
+        Function::Vlookup => args_signature_hlookup(arg_count),
+        Function::Xlookup => args_signature_xlookup(arg_count),
+        Function::Concat => vec![Signature::Vector; arg_count],
+        Function::Concatenate => vec![Signature::Scalar; arg_count],
+        Function::Exact => args_signature_scalars(arg_count, 2, 0),
+        Function::Find => args_signature_scalars(arg_count, 2, 1),
+        Function::Left => args_signature_scalars(arg_count, 1, 1),
+        Function::Len => args_signature_scalars(arg_count, 1, 0),
+        Function::Lower => args_signature_scalars(arg_count, 1, 0),
+        Function::Mid => args_signature_scalars(arg_count, 3, 0),
+        Function::Rept => args_signature_scalars(arg_count, 2, 0),
+        Function::Right => args_signature_scalars(arg_count, 2, 1),
+        Function::Search => args_signature_scalars(arg_count, 2, 1),
+        Function::Substitute => args_signature_scalars(arg_count, 3, 1),
+        Function::T => args_signature_scalars(arg_count, 1, 0),
+        Function::Text => args_signature_scalars(arg_count, 2, 0),
+        Function::Textafter => args_signature_textafter(arg_count),
+        Function::Textbefore => args_signature_textafter(arg_count),
+        Function::Textjoin => args_signature_textjoin(arg_count),
+        Function::Trim => args_signature_scalars(arg_count, 1, 0),
+        Function::Upper => args_signature_scalars(arg_count, 1, 0),
+        Function::Value => args_signature_scalars(arg_count, 1, 0),
+        Function::Valuetotext => args_signature_scalars(arg_count, 1, 1),
+        Function::Average => vec![Signature::Vector; arg_count],
+        Function::Averagea => vec![Signature::Vector; arg_count],
+        Function::Averageif => args_signature_sumif(arg_count),
+        Function::Averageifs => vec![Signature::Vector; arg_count],
+        Function::Count => vec![Signature::Vector; arg_count],
+        Function::Counta => vec![Signature::Vector; arg_count],
+        Function::Countblank => vec![Signature::Vector; arg_count],
+        Function::Countif => args_signature_sumif(arg_count),
+        Function::Countifs => vec![Signature::Vector; arg_count],
+        Function::Maxifs => vec![Signature::Vector; arg_count],
+        Function::Minifs => vec![Signature::Vector; arg_count],
+        Function::Date => args_signature_scalars(arg_count, 3, 0),
+        Function::Day => args_signature_scalars(arg_count, 1, 0),
+        Function::Edate => args_signature_scalars(arg_count, 2, 0),
+        Function::Eomonth => args_signature_scalars(arg_count, 2, 0),
+        Function::Month => args_signature_scalars(arg_count, 1, 0),
+        Function::Now => args_signature_no_args(arg_count),
+        Function::Today => args_signature_no_args(arg_count),
+        Function::Year => args_signature_scalars(arg_count, 1, 0),
+        Function::Cumipmt => args_signature_scalars(arg_count, 6, 0),
+        Function::Cumprinc => args_signature_scalars(arg_count, 6, 0),
+        Function::Db => args_signature_scalars(arg_count, 4, 1),
+        Function::Ddb => args_signature_scalars(arg_count, 4, 1),
+        Function::Dollarde => args_signature_scalars(arg_count, 2, 0),
+        Function::Dollarfr => args_signature_scalars(arg_count, 2, 0),
+        Function::Effect => args_signature_scalars(arg_count, 2, 0),
+        Function::Fv => args_signature_scalars(arg_count, 3, 2),
+        Function::Ipmt => args_signature_scalars(arg_count, 4, 2),
+        Function::Irr => args_signature_irr(arg_count),
+        Function::Ispmt => args_signature_scalars(arg_count, 4, 0),
+        Function::Mirr => args_signature_mirr(arg_count),
+        Function::Nominal => args_signature_scalars(arg_count, 2, 0),
+        Function::Nper => args_signature_scalars(arg_count, 3, 2),
+        Function::Npv => args_signature_npv(arg_count),
+        Function::Pduration => args_signature_scalars(arg_count, 3, 0),
+        Function::Pmt => args_signature_scalars(arg_count, 3, 2),
+        Function::Ppmt => args_signature_scalars(arg_count, 4, 2),
+        Function::Pv => args_signature_scalars(arg_count, 3, 2),
+        Function::Rate => args_signature_scalars(arg_count, 3, 3),
+        Function::Rri => args_signature_scalars(arg_count, 3, 0),
+        Function::Sln => args_signature_scalars(arg_count, 3, 0),
+        Function::Syd => args_signature_scalars(arg_count, 4, 0),
+        Function::Tbilleq => args_signature_scalars(arg_count, 3, 0),
+        Function::Tbillprice => args_signature_scalars(arg_count, 3, 0),
+        Function::Tbillyield => args_signature_scalars(arg_count, 3, 0),
+        Function::Xirr => args_signature_xirr(arg_count),
+        Function::Xnpv => args_signature_xnpv(arg_count),
+        Function::Besseli => args_signature_scalars(arg_count, 2, 0),
+        Function::Besselj => args_signature_scalars(arg_count, 2, 0),
+        Function::Besselk => args_signature_scalars(arg_count, 2, 0),
+        Function::Bessely => args_signature_scalars(arg_count, 2, 0),
+        Function::Erf => args_signature_scalars(arg_count, 1, 1),
+        Function::Erfc => args_signature_scalars(arg_count, 1, 0),
+        Function::ErfcPrecise => args_signature_scalars(arg_count, 1, 0),
+        Function::ErfPrecise => args_signature_scalars(arg_count, 1, 0),
+        Function::Bin2dec => args_signature_scalars(arg_count, 1, 0),
+        Function::Bin2hex => args_signature_scalars(arg_count, 1, 0),
+        Function::Bin2oct => args_signature_scalars(arg_count, 1, 0),
+        Function::Dec2Bin => args_signature_scalars(arg_count, 1, 0),
+        Function::Dec2hex => args_signature_scalars(arg_count, 1, 0),
+        Function::Dec2oct => args_signature_scalars(arg_count, 1, 0),
+        Function::Hex2bin => args_signature_scalars(arg_count, 1, 0),
+        Function::Hex2dec => args_signature_scalars(arg_count, 1, 0),
+        Function::Hex2oct => args_signature_scalars(arg_count, 1, 0),
+        Function::Oct2bin => args_signature_scalars(arg_count, 1, 0),
+        Function::Oct2dec => args_signature_scalars(arg_count, 1, 0),
+        Function::Oct2hex => args_signature_scalars(arg_count, 1, 0),
+        Function::Bitand => args_signature_scalars(arg_count, 2, 0),
+        Function::Bitlshift => args_signature_scalars(arg_count, 2, 0),
+        Function::Bitor => args_signature_scalars(arg_count, 2, 0),
+        Function::Bitrshift => args_signature_scalars(arg_count, 2, 0),
+        Function::Bitxor => args_signature_scalars(arg_count, 2, 0),
+        Function::Complex => args_signature_scalars(arg_count, 2, 1),
+        Function::Imabs => args_signature_scalars(arg_count, 1, 0),
+        Function::Imaginary => args_signature_scalars(arg_count, 1, 0),
+        Function::Imargument => args_signature_scalars(arg_count, 1, 0),
+        Function::Imconjugate => args_signature_scalars(arg_count, 1, 0),
+        Function::Imcos => args_signature_scalars(arg_count, 1, 0),
+        Function::Imcosh => args_signature_scalars(arg_count, 1, 0),
+        Function::Imcot => args_signature_scalars(arg_count, 1, 0),
+        Function::Imcsc => args_signature_scalars(arg_count, 1, 0),
+        Function::Imcsch => args_signature_scalars(arg_count, 1, 0),
+        Function::Imdiv => args_signature_scalars(arg_count, 2, 0),
+        Function::Imexp => args_signature_scalars(arg_count, 1, 0),
+        Function::Imln => args_signature_scalars(arg_count, 1, 0),
+        Function::Imlog10 => args_signature_scalars(arg_count, 1, 0),
+        Function::Imlog2 => args_signature_scalars(arg_count, 1, 0),
+        Function::Impower => args_signature_scalars(arg_count, 2, 0),
+        Function::Improduct => args_signature_scalars(arg_count, 2, 0),
+        Function::Imreal => args_signature_scalars(arg_count, 1, 0),
+        Function::Imsec => args_signature_scalars(arg_count, 1, 0),
+        Function::Imsech => args_signature_scalars(arg_count, 1, 0),
+        Function::Imsin => args_signature_scalars(arg_count, 1, 0),
+        Function::Imsinh => args_signature_scalars(arg_count, 1, 0),
+        Function::Imsqrt => args_signature_scalars(arg_count, 1, 0),
+        Function::Imsub => args_signature_scalars(arg_count, 2, 0),
+        Function::Imsum => args_signature_scalars(arg_count, 2, 0),
+        Function::Imtan => args_signature_scalars(arg_count, 1, 0),
+        Function::Convert => args_signature_scalars(arg_count, 3, 0),
+        Function::Delta => args_signature_scalars(arg_count, 1, 1),
+        Function::Gestep => args_signature_scalars(arg_count, 1, 1),
+        Function::Subtotal => args_signature_npv(arg_count),
+        Function::Rand => args_signature_no_args(arg_count),
+        Function::Randbetween => args_signature_scalars(arg_count, 2, 0),
+        Function::Formulatext => args_signature_scalars(arg_count, 1, 0),
+        Function::Unicode => args_signature_scalars(arg_count, 1, 0),
+        Function::Geomean => vec![Signature::Vector; arg_count],
+    }
+}
+
+// Returns the type of the result (Scalar, Array or Range) depending on the arguments
+fn static_analysis_on_function(kind: &Function, args: &[Node]) -> StaticResult {
+    match kind {
+        Function::And => StaticResult::Scalar,
+        Function::False => StaticResult::Scalar,
+        Function::If => scalar_arguments(args),
+        Function::Iferror => scalar_arguments(args),
+        Function::Ifna => scalar_arguments(args),
+        Function::Ifs => not_implemented(args),
+        Function::Not => StaticResult::Scalar,
+        Function::Or => StaticResult::Scalar,
+        Function::Switch => not_implemented(args),
+        Function::True => StaticResult::Scalar,
+        Function::Xor => StaticResult::Scalar,
+        Function::Abs => scalar_arguments(args),
+        Function::Acos => scalar_arguments(args),
+        Function::Acosh => scalar_arguments(args),
+        Function::Asin => scalar_arguments(args),
+        Function::Asinh => scalar_arguments(args),
+        Function::Atan => scalar_arguments(args),
+        Function::Atan2 => scalar_arguments(args),
+        Function::Atanh => scalar_arguments(args),
+        Function::Choose => scalar_arguments(args), // static_analysis_choose(args, cell),
+        Function::Column => not_implemented(args),
+        Function::Columns => not_implemented(args),
+        Function::Cos => scalar_arguments(args),
+        Function::Cosh => scalar_arguments(args),
+        Function::Max => StaticResult::Scalar,
+        Function::Min => StaticResult::Scalar,
+        Function::Pi => StaticResult::Scalar,
+        Function::Power => scalar_arguments(args),
+        Function::Product => not_implemented(args),
+        Function::Round => scalar_arguments(args),
+        Function::Rounddown => scalar_arguments(args),
+        Function::Roundup => scalar_arguments(args),
+        Function::Ln => scalar_arguments(args),
+        Function::Log => scalar_arguments(args),
+        Function::Log10 => scalar_arguments(args),
+        Function::Sin => scalar_arguments(args),
+        Function::Sinh => scalar_arguments(args),
+        Function::Sqrt => scalar_arguments(args),
+        Function::Sqrtpi => StaticResult::Scalar,
+        Function::Sum => StaticResult::Scalar,
+        Function::Sumif => not_implemented(args),
+        Function::Sumifs => not_implemented(args),
+        Function::Tan => scalar_arguments(args),
+        Function::Tanh => scalar_arguments(args),
+        Function::ErrorType => not_implemented(args),
+        Function::Isblank => not_implemented(args),
+        Function::Iserr => not_implemented(args),
+        Function::Iserror => not_implemented(args),
+        Function::Iseven => not_implemented(args),
+        Function::Isformula => not_implemented(args),
+        Function::Islogical => not_implemented(args),
+        Function::Isna => not_implemented(args),
+        Function::Isnontext => not_implemented(args),
+        Function::Isnumber => not_implemented(args),
+        Function::Isodd => not_implemented(args),
+        Function::Isref => not_implemented(args),
+        Function::Istext => not_implemented(args),
+        Function::Na => StaticResult::Scalar,
+        Function::Sheet => StaticResult::Scalar,
+        Function::Type => not_implemented(args),
+        Function::Hlookup => not_implemented(args),
+        Function::Index => static_analysis_index(args),
+        Function::Indirect => static_analysis_indirect(args),
+        Function::Lookup => not_implemented(args),
+        Function::Match => not_implemented(args),
+        Function::Offset => static_analysis_offset(args),
+        // FIXME: Row could return an array
+        Function::Row => StaticResult::Scalar,
+        Function::Rows => not_implemented(args),
+        Function::Vlookup => not_implemented(args),
+        Function::Xlookup => not_implemented(args),
+        Function::Concat => not_implemented(args),
+        Function::Concatenate => not_implemented(args),
+        Function::Exact => not_implemented(args),
+        Function::Find => not_implemented(args),
+        Function::Left => not_implemented(args),
+        Function::Len => not_implemented(args),
+        Function::Lower => not_implemented(args),
+        Function::Mid => not_implemented(args),
+        Function::Rept => not_implemented(args),
+        Function::Right => not_implemented(args),
+        Function::Search => not_implemented(args),
+        Function::Substitute => not_implemented(args),
+        Function::T => not_implemented(args),
+        Function::Text => not_implemented(args),
+        Function::Textafter => not_implemented(args),
+        Function::Textbefore => not_implemented(args),
+        Function::Textjoin => not_implemented(args),
+        Function::Trim => not_implemented(args),
+        Function::Unicode => not_implemented(args),
+        Function::Upper => not_implemented(args),
+        Function::Value => not_implemented(args),
+        Function::Valuetotext => not_implemented(args),
+        Function::Average => not_implemented(args),
+        Function::Averagea => not_implemented(args),
+        Function::Averageif => not_implemented(args),
+        Function::Averageifs => not_implemented(args),
+        Function::Count => not_implemented(args),
+        Function::Counta => not_implemented(args),
+        Function::Countblank => not_implemented(args),
+        Function::Countif => not_implemented(args),
+        Function::Countifs => not_implemented(args),
+        Function::Maxifs => not_implemented(args),
+        Function::Minifs => not_implemented(args),
+        Function::Date => not_implemented(args),
+        Function::Day => not_implemented(args),
+        Function::Edate => not_implemented(args),
+        Function::Month => not_implemented(args),
+        Function::Now => not_implemented(args),
+        Function::Today => not_implemented(args),
+        Function::Year => not_implemented(args),
+        Function::Cumipmt => not_implemented(args),
+        Function::Cumprinc => not_implemented(args),
+        Function::Db => not_implemented(args),
+        Function::Ddb => not_implemented(args),
+        Function::Dollarde => not_implemented(args),
+        Function::Dollarfr => not_implemented(args),
+        Function::Effect => not_implemented(args),
+        Function::Fv => not_implemented(args),
+        Function::Ipmt => not_implemented(args),
+        Function::Irr => not_implemented(args),
+        Function::Ispmt => not_implemented(args),
+        Function::Mirr => not_implemented(args),
+        Function::Nominal => not_implemented(args),
+        Function::Nper => not_implemented(args),
+        Function::Npv => not_implemented(args),
+        Function::Pduration => not_implemented(args),
+        Function::Pmt => not_implemented(args),
+        Function::Ppmt => not_implemented(args),
+        Function::Pv => not_implemented(args),
+        Function::Rate => not_implemented(args),
+        Function::Rri => not_implemented(args),
+        Function::Sln => not_implemented(args),
+        Function::Syd => not_implemented(args),
+        Function::Tbilleq => not_implemented(args),
+        Function::Tbillprice => not_implemented(args),
+        Function::Tbillyield => not_implemented(args),
+        Function::Xirr => not_implemented(args),
+        Function::Xnpv => not_implemented(args),
+        Function::Besseli => scalar_arguments(args),
+        Function::Besselj => scalar_arguments(args),
+        Function::Besselk => scalar_arguments(args),
+        Function::Bessely => scalar_arguments(args),
+        Function::Erf => scalar_arguments(args),
+        Function::Erfc => scalar_arguments(args),
+        Function::ErfcPrecise => scalar_arguments(args),
+        Function::ErfPrecise => scalar_arguments(args),
+        Function::Bin2dec => scalar_arguments(args),
+        Function::Bin2hex => scalar_arguments(args),
+        Function::Bin2oct => scalar_arguments(args),
+        Function::Dec2Bin => scalar_arguments(args),
+        Function::Dec2hex => scalar_arguments(args),
+        Function::Dec2oct => scalar_arguments(args),
+        Function::Hex2bin => scalar_arguments(args),
+        Function::Hex2dec => scalar_arguments(args),
+        Function::Hex2oct => scalar_arguments(args),
+        Function::Oct2bin => scalar_arguments(args),
+        Function::Oct2dec => scalar_arguments(args),
+        Function::Oct2hex => scalar_arguments(args),
+        Function::Bitand => scalar_arguments(args),
+        Function::Bitlshift => scalar_arguments(args),
+        Function::Bitor => scalar_arguments(args),
+        Function::Bitrshift => scalar_arguments(args),
+        Function::Bitxor => scalar_arguments(args),
+        Function::Complex => scalar_arguments(args),
+        Function::Imabs => scalar_arguments(args),
+        Function::Imaginary => scalar_arguments(args),
+        Function::Imargument => scalar_arguments(args),
+        Function::Imconjugate => scalar_arguments(args),
+        Function::Imcos => scalar_arguments(args),
+        Function::Imcosh => scalar_arguments(args),
+        Function::Imcot => scalar_arguments(args),
+        Function::Imcsc => scalar_arguments(args),
+        Function::Imcsch => scalar_arguments(args),
+        Function::Imdiv => scalar_arguments(args),
+        Function::Imexp => scalar_arguments(args),
+        Function::Imln => scalar_arguments(args),
+        Function::Imlog10 => scalar_arguments(args),
+        Function::Imlog2 => scalar_arguments(args),
+        Function::Impower => scalar_arguments(args),
+        Function::Improduct => scalar_arguments(args),
+        Function::Imreal => scalar_arguments(args),
+        Function::Imsec => scalar_arguments(args),
+        Function::Imsech => scalar_arguments(args),
+        Function::Imsin => scalar_arguments(args),
+        Function::Imsinh => scalar_arguments(args),
+        Function::Imsqrt => scalar_arguments(args),
+        Function::Imsub => scalar_arguments(args),
+        Function::Imsum => scalar_arguments(args),
+        Function::Imtan => scalar_arguments(args),
+        Function::Convert => not_implemented(args),
+        Function::Delta => not_implemented(args),
+        Function::Gestep => not_implemented(args),
+        Function::Subtotal => not_implemented(args),
+        Function::Rand => not_implemented(args),
+        Function::Randbetween => scalar_arguments(args),
+        Function::Eomonth => scalar_arguments(args),
+        Function::Formulatext => not_implemented(args),
+        Function::Geomean => not_implemented(args),
+    }
+}

base/src/expressions/parser/stringify.rs

@@ -1,6 +1,8 @@
 use super::{super::utils::quote_name, Node, Reference};
 use crate::constants::{LAST_COLUMN, LAST_ROW};
-use crate::expressions::token::OpUnary;
+use crate::expressions::parser::move_formula::to_string_array_node;
+use crate::expressions::parser::static_analysis::add_implicit_intersection;
+use crate::expressions::token::{OpSum, OpUnary};
 use crate::{expressions::types::CellReferenceRC, number_format::to_excel_precision_str};
 
 pub enum DisplaceData {
@@ -26,6 +28,11 @@ pub enum DisplaceData {
         column: i32,
         delta: i32,
     },
+    RowMove {
+        sheet: u32,
+        row: i32,
+        delta: i32,
+    },
     ColumnMove {
         sheet: u32,
         column: i32,
@@ -34,10 +41,21 @@ pub enum DisplaceData {
     None,
 }
 
+/// This is the internal mode in IronCalc
 pub fn to_rc_format(node: &Node) -> String {
     stringify(node, None, &DisplaceData::None, false)
 }
 
+/// This is the mode used to display the formula in the UI
+pub fn to_string(node: &Node, context: &CellReferenceRC) -> String {
+    stringify(node, Some(context), &DisplaceData::None, false)
+}
+
+/// This is the mode used to export the formula to Excel
+pub fn to_excel_string(node: &Node, context: &CellReferenceRC) -> String {
+    stringify(node, Some(context), &DisplaceData::None, true)
+}
+
 pub fn to_string_displaced(
     node: &Node,
     context: &CellReferenceRC,
@@ -46,18 +64,10 @@ pub fn to_string_displaced(
     stringify(node, Some(context), displace_data, false)
 }
 
-pub fn to_string(node: &Node, context: &CellReferenceRC) -> String {
-    stringify(node, Some(context), &DisplaceData::None, false)
-}
-
-pub fn to_excel_string(node: &Node, context: &CellReferenceRC) -> String {
-    stringify(node, Some(context), &DisplaceData::None, true)
-}
-
 /// Converts a local reference to a string applying some displacement if needed.
 /// It uses A1 style if context is not None. If context is None it uses R1C1 style
 /// If full_row is true then the row details will be omitted in the A1 case
-/// If full_colum is true then column details will be omitted.
+/// If full_column is true then column details will be omitted.
 pub(crate) fn stringify_reference(
     context: Option<&CellReferenceRC>,
     displace_data: &DisplaceData,
@@ -154,6 +164,29 @@ pub(crate) fn stringify_reference(
                         }
                     }
                 }
+                DisplaceData::RowMove {
+                    sheet,
+                    row: move_row,
+                    delta,
+                } => {
+                    if sheet_index == *sheet {
+                        if row == *move_row {
+                            row += *delta;
+                        } else if *delta > 0 {
+                            // Moving the row downwards
+                            if row > *move_row && row <= *move_row + *delta {
+                                // Intermediate rows move up by one position
+                                row -= 1;
+                            }
+                        } else if *delta < 0 {
+                            // Moving the row upwards
+                            if row < *move_row && row >= *move_row + *delta {
+                                // Intermediate rows move down by one position
+                                row += 1;
+                            }
+                        }
+                    }
+                }
                 DisplaceData::ColumnMove {
                     sheet,
                     column: move_column,
@@ -162,14 +195,18 @@ pub(crate) fn stringify_reference(
                     if sheet_index == *sheet {
                         if column == *move_column {
                             column += *delta;
-                        } else if (*delta > 0
-                            && column > *move_column
-                            && column <= *move_column + *delta)
-                            || (*delta < 0
-                                && column < *move_column
-                                && column >= *move_column + *delta)
-                        {
-                            column -= *delta;
+                        } else if *delta > 0 {
+                            // Moving the column to the right
+                            if column > *move_column && column <= *move_column + *delta {
+                                // Intermediate columns move left by one position
+                                column -= 1;
+                            }
+                        } else if *delta < 0 {
+                            // Moving the column to the left
+                            if column < *move_column && column >= *move_column + *delta {
+                                // Intermediate columns move right by one position
+                                column += 1;
+                            }
                         }
                     }
                 }
@@ -179,16 +216,16 @@ pub(crate) fn stringify_reference(
                 return "#REF!".to_string();
             }
             let mut row_abs = if absolute_row {
-                format!("${}", row)
+                format!("${row}")
             } else {
-                format!("{}", row)
+                format!("{row}")
             };
             let column = match crate::expressions::utils::number_to_column(column) {
                 Some(s) => s,
                 None => return "#REF!".to_string(),
             };
             let mut col_abs = if absolute_column {
-                format!("${}", column)
+                format!("${column}")
             } else {
                 column
             };
@@ -203,27 +240,27 @@ pub(crate) fn stringify_reference(
                     format!("{}!{}{}", quote_name(name), col_abs, row_abs)
                 }
                 None => {
-                    format!("{}{}", col_abs, row_abs)
+                    format!("{col_abs}{row_abs}")
                 }
             }
         }
         None => {
             let row_abs = if absolute_row {
-                format!("R{}", row)
+                format!("R{row}")
             } else {
-                format!("R[{}]", row)
+                format!("R[{row}]")
             };
             let col_abs = if absolute_column {
-                format!("C{}", column)
+                format!("C{column}")
             } else {
-                format!("C[{}]", column)
+                format!("C[{column}]")
             };
             match &sheet_name {
                 Some(name) => {
                     format!("{}!{}{}", quote_name(name), row_abs, col_abs)
                 }
                 None => {
-                    format!("{}{}", row_abs, col_abs)
+                    format!("{row_abs}{col_abs}")
                 }
             }
         }
@@ -235,7 +272,7 @@ fn format_function(
     args: &Vec<Node>,
     context: Option<&CellReferenceRC>,
     displace_data: &DisplaceData,
-    use_original_name: bool,
+    export_to_excel: bool,
 ) -> String {
     let mut first = true;
     let mut arguments = "".to_string();
@@ -244,27 +281,52 @@ fn format_function(
             arguments = format!(
                 "{},{}",
                 arguments,
-                stringify(el, context, displace_data, use_original_name)
+                stringify(el, context, displace_data, export_to_excel)
             );
         } else {
             first = false;
-            arguments = stringify(el, context, displace_data, use_original_name);
+            arguments = stringify(el, context, displace_data, export_to_excel);
         }
     }
-    format!("{}({})", name, arguments)
+    format!("{name}({arguments})")
 }
 
+// There is just one representation in the AST (Abstract Syntax Tree) of a formula.
+// But three different ways to convert it to a string.
+//
+// To stringify a formula we need a "context", that is in which cell are we doing the "stringifying"
+//
+// But there are three ways to stringify a formula:
+//
+// * To show it to the IronCalc user
+// * To store internally
+// * To export to Excel
+//
+// There are, of course correspondingly three "modes" when parsing a formula.
+//
+// The internal representation is the more different as references are stored in the RC representation.
+// The the AST of the formula is kept close to this representation we don't need a context
+//
+// In the export to Excel representation certain things are different:
+// * We add a _xlfn. in front of some (more modern) functions
+// * We remove the Implicit Intersection operator when it is automatic and add _xlfn.SINGLE when it is not
+//
+// Examples:
+// * =A1+B2
+// * =RC+R1C1
+// * =A1+B1
+
 fn stringify(
     node: &Node,
     context: Option<&CellReferenceRC>,
     displace_data: &DisplaceData,
-    use_original_name: bool,
+    export_to_excel: bool,
 ) -> String {
     use self::Node::*;
     match node {
-        BooleanKind(value) => format!("{}", value).to_ascii_uppercase(),
+        BooleanKind(value) => format!("{value}").to_ascii_uppercase(),
         NumberKind(number) => to_excel_precision_str(*number),
-        StringKind(value) => format!("\"{}\"", value),
+        StringKind(value) => format!("\"{value}\""),
         WrongReferenceKind {
             sheet_name,
             column,
@@ -354,7 +416,7 @@ fn stringify(
                 full_row,
                 full_column,
             );
-            format!("{}:{}", s1, s2)
+            format!("{s1}:{s2}")
         }
         WrongRangeKind {
             sheet_name,
@@ -403,114 +465,235 @@ fn stringify(
                 full_row,
                 full_column,
             );
-            format!("{}:{}", s1, s2)
+            format!("{s1}:{s2}")
         }
         OpRangeKind { left, right } => format!(
             "{}:{}",
-            stringify(left, context, displace_data, use_original_name),
-            stringify(right, context, displace_data, use_original_name)
+            stringify(left, context, displace_data, export_to_excel),
+            stringify(right, context, displace_data, export_to_excel)
         ),
         OpConcatenateKind { left, right } => format!(
             "{}&{}",
-            stringify(left, context, displace_data, use_original_name),
-            stringify(right, context, displace_data, use_original_name)
+            stringify(left, context, displace_data, export_to_excel),
+            stringify(right, context, displace_data, export_to_excel)
         ),
         CompareKind { kind, left, right } => format!(
             "{}{}{}",
-            stringify(left, context, displace_data, use_original_name),
+            stringify(left, context, displace_data, export_to_excel),
             kind,
-            stringify(right, context, displace_data, use_original_name)
-        ),
-        OpSumKind { kind, left, right } => format!(
-            "{}{}{}",
-            stringify(left, context, displace_data, use_original_name),
-            kind,
-            stringify(right, context, displace_data, use_original_name)
+            stringify(right, context, displace_data, export_to_excel)
         ),
+        OpSumKind { kind, left, right } => {
+            let left_str = stringify(left, context, displace_data, export_to_excel);
+            // if kind is minus then we need parentheses in the right side if they are OpSumKind or CompareKind
+            let right_str = if (matches!(kind, OpSum::Minus) && matches!(**right, OpSumKind { .. }))
+                | matches!(**right, CompareKind { .. })
+            {
+                format!(
+                    "({})",
+                    stringify(right, context, displace_data, export_to_excel)
+                )
+            } else {
+                stringify(right, context, displace_data, export_to_excel)
+            };
+
+            format!("{left_str}{kind}{right_str}")
+        }
         OpProductKind { kind, left, right } => {
             let x = match **left {
-                OpSumKind { .. } => format!(
+                OpSumKind { .. } | CompareKind { .. } => format!(
                     "({})",
-                    stringify(left, context, displace_data, use_original_name)
+                    stringify(left, context, displace_data, export_to_excel)
                 ),
-                CompareKind { .. } => format!(
-                    "({})",
-                    stringify(left, context, displace_data, use_original_name)
-                ),
-                _ => stringify(left, context, displace_data, use_original_name),
+                _ => stringify(left, context, displace_data, export_to_excel),
             };
             let y = match **right {
-                OpSumKind { .. } => format!(
+                OpSumKind { .. } | CompareKind { .. } | OpProductKind { .. } => format!(
                     "({})",
-                    stringify(right, context, displace_data, use_original_name)
+                    stringify(right, context, displace_data, export_to_excel)
                 ),
-                CompareKind { .. } => format!(
-                    "({})",
-                    stringify(right, context, displace_data, use_original_name)
-                ),
-                OpProductKind { .. } => format!(
-                    "({})",
-                    stringify(right, context, displace_data, use_original_name)
-                ),
-                _ => stringify(right, context, displace_data, use_original_name),
+                _ => stringify(right, context, displace_data, export_to_excel),
             };
-            format!("{}{}{}", x, kind, y)
+            format!("{x}{kind}{y}")
+        }
+        OpPowerKind { left, right } => {
+            let x = match **left {
+                BooleanKind(_)
+                | NumberKind(_)
+                | StringKind(_)
+                | ReferenceKind { .. }
+                | RangeKind { .. }
+                | WrongReferenceKind { .. }
+                | DefinedNameKind(_)
+                | TableNameKind(_)
+                | WrongVariableKind(_)
+                | WrongRangeKind { .. } => stringify(left, context, displace_data, export_to_excel),
+                OpRangeKind { .. }
+                | OpConcatenateKind { .. }
+                | OpProductKind { .. }
+                | OpPowerKind { .. }
+                | FunctionKind { .. }
+                | InvalidFunctionKind { .. }
+                | ArrayKind(_)
+                | UnaryKind { .. }
+                | ErrorKind(_)
+                | ParseErrorKind { .. }
+                | OpSumKind { .. }
+                | CompareKind { .. }
+                | ImplicitIntersection { .. }
+                | EmptyArgKind => format!(
+                    "({})",
+                    stringify(left, context, displace_data, export_to_excel)
+                ),
+            };
+            let y = match **right {
+                BooleanKind(_)
+                | NumberKind(_)
+                | StringKind(_)
+                | ReferenceKind { .. }
+                | RangeKind { .. }
+                | WrongReferenceKind { .. }
+                | DefinedNameKind(_)
+                | TableNameKind(_)
+                | WrongVariableKind(_)
+                | WrongRangeKind { .. } => {
+                    stringify(right, context, displace_data, export_to_excel)
+                }
+                OpRangeKind { .. }
+                | OpConcatenateKind { .. }
+                | OpProductKind { .. }
+                | OpPowerKind { .. }
+                | FunctionKind { .. }
+                | InvalidFunctionKind { .. }
+                | ArrayKind(_)
+                | UnaryKind { .. }
+                | ErrorKind(_)
+                | ParseErrorKind { .. }
+                | OpSumKind { .. }
+                | CompareKind { .. }
+                | ImplicitIntersection { .. }
+                | EmptyArgKind => format!(
+                    "({})",
+                    stringify(right, context, displace_data, export_to_excel)
+                ),
+            };
+            format!("{x}^{y}")
         }
-        OpPowerKind { left, right } => format!(
-            "{}^{}",
-            stringify(left, context, displace_data, use_original_name),
-            stringify(right, context, displace_data, use_original_name)
-        ),
         InvalidFunctionKind { name, args } => {
-            format_function(name, args, context, displace_data, use_original_name)
+            format_function(name, args, context, displace_data, export_to_excel)
         }
         FunctionKind { kind, args } => {
-            let name = if use_original_name {
+            let name = if export_to_excel {
                 kind.to_xlsx_string()
             } else {
                 kind.to_string()
             };
-            format_function(&name, args, context, displace_data, use_original_name)
+            format_function(&name, args, context, displace_data, export_to_excel)
         }
         ArrayKind(args) => {
-            let mut first = true;
-            let mut arguments = "".to_string();
-            for el in args {
-                if !first {
-                    arguments = format!(
-                        "{},{}",
-                        arguments,
-                        stringify(el, context, displace_data, use_original_name)
-                    );
+            let mut first_row = true;
+            let mut matrix_string = String::new();
+
+            for row in args {
+                if !first_row {
+                    matrix_string.push(';');
                 } else {
-                    first = false;
-                    arguments = stringify(el, context, displace_data, use_original_name);
+                    first_row = false;
                 }
+                let mut first_column = true;
+                let mut row_string = String::new();
+                for el in row {
+                    if !first_column {
+                        row_string.push(',');
+                    } else {
+                        first_column = false;
+                    }
+                    row_string.push_str(&to_string_array_node(el));
+                }
+                matrix_string.push_str(&row_string);
             }
-            format!("{{{}}}", arguments)
+            format!("{{{matrix_string}}}")
         }
-        VariableKind(value) => value.to_string(),
+        TableNameKind(value) => value.to_string(),
+        DefinedNameKind((name, ..)) => name.to_string(),
+        WrongVariableKind(name) => name.to_string(),
         UnaryKind { kind, right } => match kind {
             OpUnary::Minus => {
-                format!(
-                    "-{}",
-                    stringify(right, context, displace_data, use_original_name)
-                )
+                let needs_parentheses = match **right {
+                    BooleanKind(_)
+                    | NumberKind(_)
+                    | StringKind(_)
+                    | ReferenceKind { .. }
+                    | RangeKind { .. }
+                    | WrongReferenceKind { .. }
+                    | WrongRangeKind { .. }
+                    | OpRangeKind { .. }
+                    | OpConcatenateKind { .. }
+                    | OpProductKind { .. }
+                    | OpPowerKind { .. }
+                    | FunctionKind { .. }
+                    | InvalidFunctionKind { .. }
+                    | ArrayKind(_)
+                    | DefinedNameKind(_)
+                    | TableNameKind(_)
+                    | WrongVariableKind(_)
+                    | ImplicitIntersection { .. }
+                    | CompareKind { .. }
+                    | ErrorKind(_)
+                    | ParseErrorKind { .. }
+                    | EmptyArgKind => false,
+
+                    OpSumKind { .. } | UnaryKind { .. } => true,
+                };
+                if needs_parentheses {
+                    format!(
+                        "-({})",
+                        stringify(right, context, displace_data, export_to_excel)
+                    )
+                } else {
+                    format!(
+                        "-{}",
+                        stringify(right, context, displace_data, export_to_excel)
+                    )
+                }
             }
             OpUnary::Percentage => {
                 format!(
                     "{}%",
-                    stringify(right, context, displace_data, use_original_name)
+                    stringify(right, context, displace_data, export_to_excel)
                 )
             }
         },
-        ErrorKind(kind) => format!("{}", kind),
+        ErrorKind(kind) => format!("{kind}"),
         ParseErrorKind {
             formula,
             position: _,
             message: _,
         } => formula.to_string(),
         EmptyArgKind => "".to_string(),
+        ImplicitIntersection {
+            automatic: _,
+            child,
+        } => {
+            if export_to_excel {
+                // We need to check wether the II can be automatic or not
+                let mut new_node = child.as_ref().clone();
+
+                add_implicit_intersection(&mut new_node, true);
+                if matches!(&new_node, Node::ImplicitIntersection { .. }) {
+                    return stringify(child, context, displace_data, export_to_excel);
+                }
+
+                return format!(
+                    "_xlfn.SINGLE({})",
+                    stringify(child, context, displace_data, export_to_excel)
+                );
+            }
+            format!(
+                "@{}",
+                stringify(child, context, displace_data, export_to_excel)
+            )
+        }
     }
 }
 
@@ -598,6 +781,12 @@ pub(crate) fn rename_sheet_in_node(node: &mut Node, sheet_index: u32, new_name:
         Node::UnaryKind { kind: _, right } => {
             rename_sheet_in_node(right, sheet_index, new_name);
         }
+        Node::ImplicitIntersection {
+            automatic: _,
+            child,
+        } => {
+            rename_sheet_in_node(child, sheet_index, new_name);
+        }
 
         // Do nothing
         Node::BooleanKind(_) => {}
@@ -606,7 +795,96 @@ pub(crate) fn rename_sheet_in_node(node: &mut Node, sheet_index: u32, new_name:
         Node::ErrorKind(_) => {}
         Node::ParseErrorKind { .. } => {}
         Node::ArrayKind(_) => {}
-        Node::VariableKind(_) => {}
+        Node::DefinedNameKind(_) => {}
+        Node::TableNameKind(_) => {}
+        Node::WrongVariableKind(_) => {}
         Node::EmptyArgKind => {}
     }
 }
+
+pub(crate) fn rename_defined_name_in_node(
+    node: &mut Node,
+    name: &str,
+    scope: Option<u32>,
+    new_name: &str,
+) {
+    match node {
+        // Rename
+        Node::DefinedNameKind((n, s, _)) => {
+            if name.to_lowercase() == n.to_lowercase() && *s == scope {
+                *n = new_name.to_string();
+            }
+        }
+        // Go next level
+        Node::OpRangeKind { left, right } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::OpConcatenateKind { left, right } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::OpSumKind {
+            kind: _,
+            left,
+            right,
+        } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::OpProductKind {
+            kind: _,
+            left,
+            right,
+        } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::OpPowerKind { left, right } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::FunctionKind { kind: _, args } => {
+            for arg in args {
+                rename_defined_name_in_node(arg, name, scope, new_name);
+            }
+        }
+        Node::InvalidFunctionKind { name: _, args } => {
+            for arg in args {
+                rename_defined_name_in_node(arg, name, scope, new_name);
+            }
+        }
+        Node::CompareKind {
+            kind: _,
+            left,
+            right,
+        } => {
+            rename_defined_name_in_node(left, name, scope, new_name);
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::UnaryKind { kind: _, right } => {
+            rename_defined_name_in_node(right, name, scope, new_name);
+        }
+        Node::ImplicitIntersection {
+            automatic: _,
+            child,
+        } => {
+            rename_defined_name_in_node(child, name, scope, new_name);
+        }
+
+        // Do nothing
+        Node::BooleanKind(_) => {}
+        Node::NumberKind(_) => {}
+        Node::StringKind(_) => {}
+        Node::ErrorKind(_) => {}
+        Node::ParseErrorKind { .. } => {}
+        Node::ArrayKind(_) => {}
+        Node::EmptyArgKind => {}
+        Node::ReferenceKind { .. } => {}
+        Node::RangeKind { .. } => {}
+        Node::WrongReferenceKind { .. } => {}
+        Node::WrongRangeKind { .. } => {}
+        Node::TableNameKind(_) => {}
+        Node::WrongVariableKind(_) => {}
+    }
+}

base/src/expressions/parser/tests/mod.rs

@@ -0,0 +1,9 @@
+mod test_add_implicit_intersection;
+mod test_arrays;
+mod test_general;
+mod test_implicit_intersection;
+mod test_issue_155;
+mod test_move_formula;
+mod test_ranges;
+mod test_stringify;
+mod test_tables;

base/src/expressions/parser/tests/test_add_implicit_intersection.rs

@@ -0,0 +1,80 @@
+use std::collections::HashMap;
+
+use crate::expressions::{
+    parser::{
+        stringify::{to_excel_string, to_string},
+        Parser,
+    },
+    types::CellReferenceRC,
+};
+
+use crate::expressions::parser::static_analysis::add_implicit_intersection;
+
+#[test]
+fn simple_test() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let cases = vec![
+        ("A1:A10*SUM(A1:A10)", "@A1:A10*SUM(A1:A10)"),
+        ("A1:A10", "@A1:A10"),
+        // Math and trigonometry functions
+        ("SUM(A1:A10)", "SUM(A1:A10)"),
+        ("SIN(A1:A10)", "SIN(@A1:A10)"),
+        ("COS(A1:A10)", "COS(@A1:A10)"),
+        ("TAN(A1:A10)", "TAN(@A1:A10)"),
+        ("ASIN(A1:A10)", "ASIN(@A1:A10)"),
+        ("ACOS(A1:A10)", "ACOS(@A1:A10)"),
+        ("ATAN(A1:A10)", "ATAN(@A1:A10)"),
+        ("SINH(A1:A10)", "SINH(@A1:A10)"),
+        ("COSH(A1:A10)", "COSH(@A1:A10)"),
+        ("TANH(A1:A10)", "TANH(@A1:A10)"),
+        ("ASINH(A1:A10)", "ASINH(@A1:A10)"),
+        ("ACOSH(A1:A10)", "ACOSH(@A1:A10)"),
+        ("ATANH(A1:A10)", "ATANH(@A1:A10)"),
+        ("ATAN2(A1:A10,B1:B10)", "ATAN2(@A1:A10,@B1:B10)"),
+        ("ATAN2(A1:A10,A1)", "ATAN2(@A1:A10,A1)"),
+        ("SQRT(A1:A10)", "SQRT(@A1:A10)"),
+        ("SQRTPI(A1:A10)", "SQRTPI(@A1:A10)"),
+        ("POWER(A1:A10,A1)", "POWER(@A1:A10,A1)"),
+        ("POWER(A1:A10,B1:B10)", "POWER(@A1:A10,@B1:B10)"),
+        ("MAX(A1:A10)", "MAX(A1:A10)"),
+        ("MIN(A1:A10)", "MIN(A1:A10)"),
+        ("ABS(A1:A10)", "ABS(@A1:A10)"),
+        ("FALSE()", "FALSE()"),
+        ("TRUE()", "TRUE()"),
+        // Defined names
+        ("BADNMAE", "@BADNMAE"),
+        // Logical
+        ("AND(A1:A10)", "AND(A1:A10)"),
+        ("OR(A1:A10)", "OR(A1:A10)"),
+        ("NOT(A1:A10)", "NOT(@A1:A10)"),
+        ("IF(A1:A10,B1:B10,C1:C10)", "IF(@A1:A10,@B1:B10,@C1:C10)"),
+        // Information
+        // ("ISBLANK(A1:A10)", "ISBLANK(A1:A10)"),
+        // ("ISERR(A1:A10)", "ISERR(A1:A10)"),
+        // ("ISERROR(A1:A10)", "ISERROR(A1:A10)"),
+        // ("ISEVEN(A1:A10)", "ISEVEN(A1:A10)"),
+        // ("ISLOGICAL(A1:A10)", "ISLOGICAL(A1:A10)"),
+        // ("ISNA(A1:A10)", "ISNA(A1:A10)"),
+        // ("ISNONTEXT(A1:A10)", "ISNONTEXT(A1:A10)"),
+        // ("ISNUMBER(A1:A10)", "ISNUMBER(A1:A10)"),
+        // ("ISODD(A1:A10)", "ISODD(A1:A10)"),
+        // ("ISREF(A1:A10)", "ISREF(A1:A10)"),
+        // ("ISTEXT(A1:A10)", "ISTEXT(A1:A10)"),
+    ];
+    for (formula, expected) in cases {
+        let mut t = parser.parse(formula, &cell_reference);
+        add_implicit_intersection(&mut t, true);
+        let r = to_string(&t, &cell_reference);
+        assert_eq!(r, expected);
+        let excel_formula = to_excel_string(&t, &cell_reference);
+        assert_eq!(excel_formula, formula);
+    }
+}

base/src/expressions/parser/tests/test_arrays.rs

@@ -0,0 +1,92 @@
+#![allow(clippy::panic)]
+
+use std::collections::HashMap;
+
+use crate::expressions::parser::stringify::{to_rc_format, to_string};
+use crate::expressions::parser::{ArrayNode, Node, Parser};
+use crate::expressions::types::CellReferenceRC;
+
+#[test]
+fn simple_horizontal() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let horizontal = parser.parse("{1, 2, 3}", &cell_reference);
+    assert_eq!(
+        horizontal,
+        Node::ArrayKind(vec![vec![
+            ArrayNode::Number(1.0),
+            ArrayNode::Number(2.0),
+            ArrayNode::Number(3.0)
+        ]])
+    );
+
+    assert_eq!(to_rc_format(&horizontal), "{1,2,3}");
+    assert_eq!(to_string(&horizontal, &cell_reference), "{1,2,3}");
+}
+
+#[test]
+fn simple_vertical() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let vertical = parser.parse("{1;2; 3}", &cell_reference);
+    assert_eq!(
+        vertical,
+        Node::ArrayKind(vec![
+            vec![ArrayNode::Number(1.0)],
+            vec![ArrayNode::Number(2.0)],
+            vec![ArrayNode::Number(3.0)]
+        ])
+    );
+    assert_eq!(to_rc_format(&vertical), "{1;2;3}");
+    assert_eq!(to_string(&vertical, &cell_reference), "{1;2;3}");
+}
+
+#[test]
+fn simple_matrix() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let matrix = parser.parse("{1,2,3; 4, 5, 6; 7,8,9}", &cell_reference);
+    assert_eq!(
+        matrix,
+        Node::ArrayKind(vec![
+            vec![
+                ArrayNode::Number(1.0),
+                ArrayNode::Number(2.0),
+                ArrayNode::Number(3.0)
+            ],
+            vec![
+                ArrayNode::Number(4.0),
+                ArrayNode::Number(5.0),
+                ArrayNode::Number(6.0)
+            ],
+            vec![
+                ArrayNode::Number(7.0),
+                ArrayNode::Number(8.0),
+                ArrayNode::Number(9.0)
+            ]
+        ])
+    );
+    assert_eq!(to_rc_format(&matrix), "{1,2,3;4,5,6;7,8,9}");
+    assert_eq!(to_string(&matrix, &cell_reference), "{1,2,3;4,5,6;7,8,9}");
+}

base/src/expressions/parser/tests/test_general.rs

@@ -1,17 +1,13 @@
+#![allow(clippy::panic)]
+
 use std::collections::HashMap;
 
 use crate::expressions::lexer::LexerMode;
-use crate::expressions::parser::stringify::DisplaceData;
-
-use super::super::types::CellReferenceRC;
-use super::Parser;
-use super::{
-    super::parser::{
-        stringify::{to_rc_format, to_string},
-        Node,
-    },
-    stringify::to_string_displaced,
+use crate::expressions::parser::stringify::{
+    to_rc_format, to_string, to_string_displaced, DisplaceData,
 };
+use crate::expressions::parser::{Node, Parser};
+use crate::expressions::types::CellReferenceRC;
 
 struct Formula<'a> {
     initial: &'a str,
@@ -21,7 +17,7 @@ struct Formula<'a> {
 #[test]
 fn test_parser_reference() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -29,14 +25,14 @@ fn test_parser_reference() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("A2", &Some(cell_reference));
+    let t = parser.parse("A2", &cell_reference);
     assert_eq!(to_rc_format(&t), "R[1]C[0]");
 }
 
 #[test]
 fn test_parser_absolute_column() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -44,14 +40,14 @@ fn test_parser_absolute_column() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("$A1", &Some(cell_reference));
+    let t = parser.parse("$A1", &cell_reference);
     assert_eq!(to_rc_format(&t), "R[0]C1");
 }
 
 #[test]
 fn test_parser_absolute_row_col() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -59,14 +55,14 @@ fn test_parser_absolute_row_col() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("$C$5", &Some(cell_reference));
+    let t = parser.parse("$C$5", &cell_reference);
     assert_eq!(to_rc_format(&t), "R5C3");
 }
 
 #[test]
 fn test_parser_absolute_row_col_1() {
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -74,14 +70,14 @@ fn test_parser_absolute_row_col_1() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("$A$1", &Some(cell_reference));
+    let t = parser.parse("$A$1", &cell_reference);
     assert_eq!(to_rc_format(&t), "R1C1");
 }
 
 #[test]
 fn test_parser_simple_formula() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -90,14 +86,14 @@ fn test_parser_simple_formula() {
         column: 1,
     };
 
-    let t = parser.parse("C3+Sheet2!D4", &Some(cell_reference));
+    let t = parser.parse("C3+Sheet2!D4", &cell_reference);
     assert_eq!(to_rc_format(&t), "R[2]C[2]+Sheet2!R[3]C[3]");
 }
 
 #[test]
 fn test_parser_boolean() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -106,14 +102,14 @@ fn test_parser_boolean() {
         column: 1,
     };
 
-    let t = parser.parse("true", &Some(cell_reference));
+    let t = parser.parse("true", &cell_reference);
     assert_eq!(to_rc_format(&t), "TRUE");
 }
 
 #[test]
 fn test_parser_bad_formula() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -121,7 +117,7 @@ fn test_parser_bad_formula() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("#Value", &Some(cell_reference));
+    let t = parser.parse("#Value", &cell_reference);
     match &t {
         Node::ParseErrorKind {
             formula,
@@ -142,7 +138,7 @@ fn test_parser_bad_formula() {
 #[test]
 fn test_parser_bad_formula_1() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -150,7 +146,7 @@ fn test_parser_bad_formula_1() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("<5", &Some(cell_reference));
+    let t = parser.parse("<5", &cell_reference);
     match &t {
         Node::ParseErrorKind {
             formula,
@@ -171,7 +167,7 @@ fn test_parser_bad_formula_1() {
 #[test]
 fn test_parser_bad_formula_2() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -179,7 +175,7 @@ fn test_parser_bad_formula_2() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("*5", &Some(cell_reference));
+    let t = parser.parse("*5", &cell_reference);
     match &t {
         Node::ParseErrorKind {
             formula,
@@ -200,7 +196,7 @@ fn test_parser_bad_formula_2() {
 #[test]
 fn test_parser_bad_formula_3() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -208,7 +204,7 @@ fn test_parser_bad_formula_3() {
         row: 1,
         column: 1,
     };
-    let t = parser.parse("SUM(#VALVE!)", &Some(cell_reference));
+    let t = parser.parse("SUM(#VALVE!)", &cell_reference);
     match &t {
         Node::ParseErrorKind {
             formula,
@@ -229,7 +225,7 @@ fn test_parser_bad_formula_3() {
 #[test]
 fn test_parser_formulas() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     let formulas = vec![
         Formula {
@@ -263,11 +259,11 @@ fn test_parser_formulas() {
     for formula in formulas {
         let t = parser.parse(
             formula.initial,
-            &Some(CellReferenceRC {
+            &CellReferenceRC {
                 sheet: "Sheet1".to_string(),
                 row: 1,
                 column: 1,
-            }),
+            },
         );
         assert_eq!(to_rc_format(&t), formula.expected);
         assert_eq!(to_string(&t, &cell_reference), formula.initial);
@@ -277,7 +273,7 @@ fn test_parser_formulas() {
 #[test]
 fn test_parser_r1c1_formulas() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
     parser.set_lexer_mode(LexerMode::R1C1);
 
     let formulas = vec![
@@ -328,11 +324,11 @@ fn test_parser_r1c1_formulas() {
     for formula in formulas {
         let t = parser.parse(
             formula.initial,
-            &Some(CellReferenceRC {
+            &CellReferenceRC {
                 sheet: "Sheet1".to_string(),
                 row: 1,
                 column: 1,
-            }),
+            },
         );
         assert_eq!(to_string(&t, &cell_reference), formula.expected);
         assert_eq!(to_rc_format(&t), formula.initial);
@@ -342,7 +338,7 @@ fn test_parser_r1c1_formulas() {
 #[test]
 fn test_parser_quotes() {
     let worksheets = vec!["Sheet1".to_string(), "Second Sheet".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -351,14 +347,14 @@ fn test_parser_quotes() {
         column: 1,
     };
 
-    let t = parser.parse("C3+'Second Sheet'!D4", &Some(cell_reference));
+    let t = parser.parse("C3+'Second Sheet'!D4", &cell_reference);
     assert_eq!(to_rc_format(&t), "R[2]C[2]+'Second Sheet'!R[3]C[3]");
 }
 
 #[test]
 fn test_parser_escape_quotes() {
     let worksheets = vec!["Sheet1".to_string(), "Second '2' Sheet".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -367,14 +363,14 @@ fn test_parser_escape_quotes() {
         column: 1,
     };
 
-    let t = parser.parse("C3+'Second ''2'' Sheet'!D4", &Some(cell_reference));
+    let t = parser.parse("C3+'Second ''2'' Sheet'!D4", &cell_reference);
     assert_eq!(to_rc_format(&t), "R[2]C[2]+'Second ''2'' Sheet'!R[3]C[3]");
 }
 
 #[test]
 fn test_parser_parenthesis() {
     let worksheets = vec!["Sheet1".to_string(), "Second2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -383,14 +379,14 @@ fn test_parser_parenthesis() {
         column: 1,
     };
 
-    let t = parser.parse("(C3=\"Yes\")*5", &Some(cell_reference));
+    let t = parser.parse("(C3=\"Yes\")*5", &cell_reference);
     assert_eq!(to_rc_format(&t), "(R[2]C[2]=\"Yes\")*5");
 }
 
 #[test]
 fn test_parser_excel_xlfn() {
     let worksheets = vec!["Sheet1".to_string(), "Second2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -399,7 +395,7 @@ fn test_parser_excel_xlfn() {
         column: 1,
     };
 
-    let t = parser.parse("_xlfn.CONCAT(C3)", &Some(cell_reference));
+    let t = parser.parse("_xlfn.CONCAT(C3)", &cell_reference);
     assert_eq!(to_rc_format(&t), "CONCAT(R[2]C[2])");
 }
 
@@ -411,9 +407,9 @@ fn test_to_string_displaced() {
         column: 1,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
-    let node = parser.parse("C3", &Some(context.clone()));
+    let node = parser.parse("C3", context);
     let displace_data = DisplaceData::Column {
         sheet: 0,
         column: 1,
@@ -431,9 +427,9 @@ fn test_to_string_displaced_full_ranges() {
         column: 1,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
-    let node = parser.parse("SUM(3:3)", &Some(context.clone()));
+    let node = parser.parse("SUM(3:3)", context);
     let displace_data = DisplaceData::Column {
         sheet: 0,
         column: 1,
@@ -444,7 +440,7 @@ fn test_to_string_displaced_full_ranges() {
         "SUM(3:3)".to_string()
     );
 
-    let node = parser.parse("SUM(D:D)", &Some(context.clone()));
+    let node = parser.parse("SUM(D:D)", context);
     let displace_data = DisplaceData::Row {
         sheet: 0,
         row: 3,
@@ -464,9 +460,9 @@ fn test_to_string_displaced_too_low() {
         column: 1,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
-    let node = parser.parse("C3", &Some(context.clone()));
+    let node = parser.parse("C3", context);
     let displace_data = DisplaceData::Column {
         sheet: 0,
         column: 1,
@@ -484,9 +480,9 @@ fn test_to_string_displaced_too_high() {
         column: 1,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
-    let node = parser.parse("C3", &Some(context.clone()));
+    let node = parser.parse("C3", context);
     let displace_data = DisplaceData::Column {
         sheet: 0,
         column: 1,

base/src/expressions/parser/tests/test_implicit_intersection.rs

@@ -0,0 +1,75 @@
+#![allow(clippy::panic)]
+
+use crate::expressions::parser::{Node, Parser};
+use crate::expressions::types::CellReferenceRC;
+use std::collections::HashMap;
+
+#[test]
+fn simple() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!B3
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 3,
+        column: 2,
+    };
+    let t = parser.parse("@A1:A10", &cell_reference);
+    let child = Node::RangeKind {
+        sheet_name: None,
+        sheet_index: 0,
+        absolute_row1: false,
+        absolute_column1: false,
+        row1: -2,
+        column1: -1,
+        absolute_row2: false,
+        absolute_column2: false,
+        row2: 7,
+        column2: -1,
+    };
+    assert_eq!(
+        t,
+        Node::ImplicitIntersection {
+            automatic: false,
+            child: Box::new(child)
+        }
+    )
+}
+
+#[test]
+fn simple_add() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!B3
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 3,
+        column: 2,
+    };
+    let t = parser.parse("@A1:A10+12", &cell_reference);
+    let child = Node::RangeKind {
+        sheet_name: None,
+        sheet_index: 0,
+        absolute_row1: false,
+        absolute_column1: false,
+        row1: -2,
+        column1: -1,
+        absolute_row2: false,
+        absolute_column2: false,
+        row2: 7,
+        column2: -1,
+    };
+    assert_eq!(
+        t,
+        Node::OpSumKind {
+            kind: crate::expressions::token::OpSum::Add,
+            left: Box::new(Node::ImplicitIntersection {
+                automatic: false,
+                child: Box::new(child)
+            }),
+            right: Box::new(Node::NumberKind(12.0))
+        }
+    )
+}

base/src/expressions/parser/tests/test_issue_155.rs

@@ -0,0 +1,69 @@
+#![allow(clippy::panic)]
+
+use std::collections::HashMap;
+
+use crate::expressions::parser::stringify::to_string;
+use crate::expressions::parser::Parser;
+use crate::expressions::types::CellReferenceRC;
+
+#[test]
+fn issue_155_parser() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 2,
+        column: 2,
+    };
+    let t = parser.parse("A$1:A2", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "A$1:A2");
+}
+
+#[test]
+fn issue_155_parser_case_2() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 20,
+        column: 20,
+    };
+    let t = parser.parse("C$1:D2", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "C$1:D2");
+}
+
+#[test]
+fn issue_155_parser_only_row() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 20,
+        column: 20,
+    };
+    // This is tricky, I am not sure what to do in these cases
+    let t = parser.parse("A$2:B1", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "A1:B$2");
+}
+
+#[test]
+fn issue_155_parser_only_column() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 20,
+        column: 20,
+    };
+    // This is tricky, I am not sure what to do in these cases
+    let t = parser.parse("D1:$A3", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "$A1:D3");
+}

base/src/expressions/parser/tests/test_move_formula.rs

@@ -1,10 +1,8 @@
 use std::collections::HashMap;
 
 use crate::expressions::parser::move_formula::{move_formula, MoveContext};
-use crate::expressions::types::Area;
-
-use super::super::types::CellReferenceRC;
-use super::Parser;
+use crate::expressions::parser::Parser;
+use crate::expressions::types::{Area, CellReferenceRC};
 
 #[test]
 fn test_move_formula() {
@@ -17,7 +15,7 @@ fn test_move_formula() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -29,7 +27,7 @@ fn test_move_formula() {
     };
 
     // formula AB31 will not change
-    let node = parser.parse("AB31", &Some(context.clone()));
+    let node = parser.parse("AB31", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -45,7 +43,7 @@ fn test_move_formula() {
     assert_eq!(t, "AB31");
 
     // formula $AB$31 will not change
-    let node = parser.parse("AB31", &Some(context.clone()));
+    let node = parser.parse("AB31", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -61,7 +59,7 @@ fn test_move_formula() {
     assert_eq!(t, "AB31");
 
     // but formula D5 will change to N15  (N = D + 10)
-    let node = parser.parse("D5", &Some(context.clone()));
+    let node = parser.parse("D5", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -77,7 +75,7 @@ fn test_move_formula() {
     assert_eq!(t, "N15");
 
     // Also formula $D$5 will change to N15  (N = D + 10)
-    let node = parser.parse("$D$5", &Some(context.clone()));
+    let node = parser.parse("$D$5", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -104,7 +102,7 @@ fn test_move_formula_context_offset() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -115,7 +113,7 @@ fn test_move_formula_context_offset() {
         height: 5,
     };
 
-    let node = parser.parse("-X9+C2%", &Some(context.clone()));
+    let node = parser.parse("-X9+C2%", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -142,7 +140,7 @@ fn test_move_formula_area_limits() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -154,7 +152,7 @@ fn test_move_formula_area_limits() {
     };
 
     // Outside of the area. Not moved
-    let node = parser.parse("B2+B3+C1+G6+H5", &Some(context.clone()));
+    let node = parser.parse("B2+B3+C1+G6+H5", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -170,7 +168,7 @@ fn test_move_formula_area_limits() {
     assert_eq!(t, "B2+B3+C1+G6+H5");
 
     // In the area. Moved
-    let node = parser.parse("C2+F4+F5+F6", &Some(context.clone()));
+    let node = parser.parse("C2+F4+F5+F6", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -197,7 +195,7 @@ fn test_move_formula_ranges() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     let area = &Area {
         sheet: 0,
@@ -207,7 +205,7 @@ fn test_move_formula_ranges() {
         height: 5,
     };
     // Ranges inside the area are fully displaced (absolute or not)
-    let node = parser.parse("SUM(C2:F5)", &Some(context.clone()));
+    let node = parser.parse("SUM(C2:F5)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -222,7 +220,7 @@ fn test_move_formula_ranges() {
     );
     assert_eq!(t, "SUM(M12:P15)");
 
-    let node = parser.parse("SUM($C$2:$F$5)", &Some(context.clone()));
+    let node = parser.parse("SUM($C$2:$F$5)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -238,7 +236,7 @@ fn test_move_formula_ranges() {
     assert_eq!(t, "SUM($M$12:$P$15)");
 
     // Ranges completely outside of the area are not touched
-    let node = parser.parse("SUM(A1:B3)", &Some(context.clone()));
+    let node = parser.parse("SUM(A1:B3)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -253,7 +251,7 @@ fn test_move_formula_ranges() {
     );
     assert_eq!(t, "SUM(A1:B3)");
 
-    let node = parser.parse("SUM($A$1:$B$3)", &Some(context.clone()));
+    let node = parser.parse("SUM($A$1:$B$3)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -269,7 +267,7 @@ fn test_move_formula_ranges() {
     assert_eq!(t, "SUM($A$1:$B$3)");
 
     // Ranges that overlap with the area are also NOT displaced
-    let node = parser.parse("SUM(A1:F5)", &Some(context.clone()));
+    let node = parser.parse("SUM(A1:F5)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -285,7 +283,7 @@ fn test_move_formula_ranges() {
     assert_eq!(t, "SUM(A1:F5)");
 
     // Ranges that contain the area are also NOT displaced
-    let node = parser.parse("SUM(A1:X50)", &Some(context.clone()));
+    let node = parser.parse("SUM(A1:X50)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -320,10 +318,10 @@ fn test_move_formula_wrong_reference() {
         height: 5,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Wrong formulas will NOT be displaced
-    let node = parser.parse("Sheet3!AB31", &Some(context.clone()));
+    let node = parser.parse("Sheet3!AB31", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -337,7 +335,7 @@ fn test_move_formula_wrong_reference() {
         },
     );
     assert_eq!(t, "Sheet3!AB31");
-    let node = parser.parse("Sheet3!$X$9", &Some(context.clone()));
+    let node = parser.parse("Sheet3!$X$9", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -352,7 +350,7 @@ fn test_move_formula_wrong_reference() {
     );
     assert_eq!(t, "Sheet3!$X$9");
 
-    let node = parser.parse("SUM(Sheet3!D2:D3)", &Some(context.clone()));
+    let node = parser.parse("SUM(Sheet3!D2:D3)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -379,7 +377,7 @@ fn test_move_formula_misc() {
         column,
     };
     let worksheets = vec!["Sheet1".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -389,7 +387,7 @@ fn test_move_formula_misc() {
         width: 4,
         height: 5,
     };
-    let node = parser.parse("X9^C2-F4*H2", &Some(context.clone()));
+    let node = parser.parse("X9^C2-F4*H2+SUM(F2:H4)+SUM(C2:F6)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -402,9 +400,9 @@ fn test_move_formula_misc() {
             column_delta: 10,
         },
     );
-    assert_eq!(t, "X9^M12-P14*H2");
+    assert_eq!(t, "X9^M12-P14*H2+SUM(F2:H4)+SUM(M12:P16)");
 
-    let node = parser.parse("F5*(-D5)*SUM(A1, X9, $D$5)", &Some(context.clone()));
+    let node = parser.parse("F5*(-D5)*SUM(A1, X9, $D$5)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -419,7 +417,7 @@ fn test_move_formula_misc() {
     );
     assert_eq!(t, "P15*(-N15)*SUM(A1,X9,$N$15)");
 
-    let node = parser.parse("IF(F5 < -D5, X9 & F5, FALSE)", &Some(context.clone()));
+    let node = parser.parse("IF(F5 < -D5, X9 & F5, FALSE)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -447,7 +445,7 @@ fn test_move_formula_another_sheet() {
     };
     // we add two sheets and we cut/paste from Sheet1 to Sheet2
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Area is C2:F6
     let area = &Area {
@@ -459,10 +457,7 @@ fn test_move_formula_another_sheet() {
     };
 
     // Formula AB31 and JJ3:JJ4 refers to original Sheet1!AB31 and Sheet1!JJ3:JJ4
-    let node = parser.parse(
-        "AB31*SUM(JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(C2:F6)",
-        &Some(context.clone()),
-    );
+    let node = parser.parse("AB31*SUM(JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(C2:F6)", context);
     let t = move_formula(
         &node,
         &MoveContext {
@@ -480,3 +475,77 @@ fn test_move_formula_another_sheet() {
         "Sheet1!AB31*SUM(Sheet1!JJ3:JJ4)+SUM(Sheet2!C2:F6)*SUM(M12:P16)"
     );
 }
+
+#[test]
+fn move_formula_implicit_intersetion() {
+    // context is E4
+    let row = 4;
+    let column = 5;
+    let context = &CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row,
+        column,
+    };
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Area is C2:F6
+    let area = &Area {
+        sheet: 0,
+        row: 2,
+        column: 3,
+        width: 4,
+        height: 5,
+    };
+    let node = parser.parse("SUM(@F2:H4)+SUM(@C2:F6)", context);
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "SUM(@F2:H4)+SUM(@M12:P16)");
+}
+
+#[test]
+fn move_formula_implicit_intersetion_with_ranges() {
+    // context is E4
+    let row = 4;
+    let column = 5;
+    let context = &CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row,
+        column,
+    };
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Area is C2:F6
+    let area = &Area {
+        sheet: 0,
+        row: 2,
+        column: 3,
+        width: 4,
+        height: 5,
+    };
+    let node = parser.parse("SUM(@F2:H4)+SUM(@C2:F6)+SUM(@A1, @X9, @$D$5)", context);
+    let t = move_formula(
+        &node,
+        &MoveContext {
+            source_sheet_name: "Sheet1",
+            row,
+            column,
+            area,
+            target_sheet_name: "Sheet1",
+            row_delta: 10,
+            column_delta: 10,
+        },
+    );
+    assert_eq!(t, "SUM(@F2:H4)+SUM(@M12:P16)+SUM(@A1,@X9,@$N$15)");
+}

base/src/expressions/parser/tests/test_ranges.rs

@@ -2,9 +2,9 @@ use std::collections::HashMap;
 
 use crate::expressions::lexer::LexerMode;
 
-use super::super::parser::stringify::{to_rc_format, to_string};
-use super::super::types::CellReferenceRC;
-use super::Parser;
+use crate::expressions::parser::stringify::{to_rc_format, to_string};
+use crate::expressions::parser::Parser;
+use crate::expressions::types::CellReferenceRC;
 
 struct Formula<'a> {
     formula_a1: &'a str,
@@ -14,7 +14,7 @@ struct Formula<'a> {
 #[test]
 fn test_parser_formulas_with_full_ranges() {
     let worksheets = vec!["Sheet1".to_string(), "Second Sheet".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     let formulas = vec![
         Formula {
@@ -52,11 +52,11 @@ fn test_parser_formulas_with_full_ranges() {
     for formula in &formulas {
         let t = parser.parse(
             formula.formula_a1,
-            &Some(CellReferenceRC {
+            &CellReferenceRC {
                 sheet: "Sheet1".to_string(),
                 row: 1,
                 column: 1,
-            }),
+            },
         );
         assert_eq!(to_rc_format(&t), formula.formula_r1c1);
         assert_eq!(to_string(&t, &cell_reference), formula.formula_a1);
@@ -67,11 +67,11 @@ fn test_parser_formulas_with_full_ranges() {
     for formula in &formulas {
         let t = parser.parse(
             formula.formula_r1c1,
-            &Some(CellReferenceRC {
+            &CellReferenceRC {
                 sheet: "Sheet1".to_string(),
                 row: 1,
                 column: 1,
-            }),
+            },
         );
         assert_eq!(to_rc_format(&t), formula.formula_r1c1);
         assert_eq!(to_string(&t, &cell_reference), formula.formula_a1);
@@ -81,7 +81,7 @@ fn test_parser_formulas_with_full_ranges() {
 #[test]
 fn test_range_inverse_order() {
     let worksheets = vec!["Sheet1".to_string(), "Sheet2".to_string()];
-    let mut parser = Parser::new(worksheets, HashMap::new());
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
 
     // Reference cell is Sheet1!A1
     let cell_reference = CellReferenceRC {
@@ -93,7 +93,7 @@ fn test_range_inverse_order() {
     // D4:C2 => C2:D4
     let t = parser.parse(
         "SUM(D4:C2)*SUM(Sheet2!D4:C20)*SUM($C$20:D4)",
-        &Some(cell_reference.clone()),
+        &cell_reference,
     );
     assert_eq!(
         to_string(&t, &cell_reference),

base/src/expressions/parser/tests/test_stringify.rs

@@ -0,0 +1,70 @@
+#![allow(clippy::panic)]
+
+use std::collections::HashMap;
+
+use crate::expressions::parser::stringify::to_string;
+use crate::expressions::parser::Parser;
+use crate::expressions::types::CellReferenceRC;
+
+#[test]
+fn exp_order() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    // Reference cell is Sheet1!A1
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+    let t = parser.parse("(1 + 2)^3  + 4", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "(1+2)^3+4");
+
+    let t = parser.parse("(C5 + 3)^R4", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "(C5+3)^R4");
+
+    let t = parser.parse("(C5 + 3)^(R4*6)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "(C5+3)^(R4*6)");
+
+    let t = parser.parse("(C5)^(R4)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "C5^R4");
+
+    let t = parser.parse("(5)^(4)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "5^4");
+}
+
+#[test]
+fn correct_parenthesis() {
+    let worksheets = vec!["Sheet1".to_string()];
+    let mut parser = Parser::new(worksheets, vec![], HashMap::new());
+
+    let cell_reference = CellReferenceRC {
+        sheet: "Sheet1".to_string(),
+        row: 1,
+        column: 1,
+    };
+
+    let t = parser.parse("-(1 + 1)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "-(1+1)");
+
+    let t = parser.parse("1 - (3 + 4)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "1-(3+4)");
+
+    let t = parser.parse("-(1.05*(0.0284 + 0.0046) - 0.0284)", &cell_reference);
+    assert_eq!(
+        to_string(&t, &cell_reference),
+        "-(1.05*(0.0284+0.0046)-0.0284)"
+    );
+
+    let t = parser.parse("1 + (3+5)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "1+3+5");
+
+    let t = parser.parse("1 - (3+5)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "1-(3+5)");
+
+    let t = parser.parse("(1 - 3) - (3+5)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "1-3-(3+5)");
+
+    let t = parser.parse("1 + (3<5)", &cell_reference);
+    assert_eq!(to_string(&t, &cell_reference), "1+(3<5)");
+}

base/src/expressions/parser/tests/test_tables.rs

@@ -3,12 +3,11 @@
 use std::collections::HashMap;
 
 use crate::expressions::parser::stringify::to_string;
+use crate::expressions::parser::Parser;
+use crate::expressions::types::CellReferenceRC;
 use crate::expressions::utils::{number_to_column, parse_reference_a1};
 use crate::types::{Table, TableColumn, TableStyleInfo};
 
-use super::super::types::CellReferenceRC;
-use super::Parser;
-
 fn create_test_table(
     table_name: &str,
     column_names: &[&str],
@@ -63,7 +62,7 @@ fn simple_table() {
     let row_count = 3;
     let tables = create_test_table("tblIncome", &column_names, "A1", row_count);
 
-    let mut parser = Parser::new(worksheets, tables);
+    let mut parser = Parser::new(worksheets, vec![], tables);
     // Reference cell is 'Sheet One'!F2
     let cell_reference = CellReferenceRC {
         sheet: "Sheet One".to_string(),
@@ -72,7 +71,7 @@ fn simple_table() {
     };
 
     let formula = "SUM(tblIncome[[#This Row],[Jan]:[Dec]])";
-    let t = parser.parse(formula, &Some(cell_reference.clone()));
+    let t = parser.parse(formula, &cell_reference);
     assert_eq!(to_string(&t, &cell_reference), "SUM($A$2:$E$2)");
 
     // Cell A3
@@ -82,7 +81,7 @@ fn simple_table() {
         column: 1,
     };
     let formula = "SUBTOTAL(109, tblIncome[Jan])";
-    let t = parser.parse(formula, &Some(cell_reference.clone()));
+    let t = parser.parse(formula, &cell_reference);
     assert_eq!(to_string(&t, &cell_reference), "SUBTOTAL(109,$A$2:$A$3)");
 
     // Cell A3 in 'Second Sheet'
@@ -92,7 +91,7 @@ fn simple_table() {
         column: 1,
     };
     let formula = "SUBTOTAL(109, tblIncome[Jan])";
-    let t = parser.parse(formula, &Some(cell_reference.clone()));
+    let t = parser.parse(formula, &cell_reference);
     assert_eq!(
         to_string(&t, &cell_reference),
         "SUBTOTAL(109,'Sheet One'!$A$2:$A$3)"

base/src/expressions/parser/walk.rs

@@ -1,276 +0,0 @@
-use super::{move_formula::ref_is_in_area, Node};
-
-use crate::expressions::types::{Area, CellReferenceIndex};
-
-pub(crate) fn forward_references(
-    node: &mut Node,
-    context: &CellReferenceIndex,
-    source_area: &Area,
-    target_sheet: u32,
-    target_sheet_name: &str,
-    target_row: i32,
-    target_column: i32,
-) {
-    match node {
-        Node::ReferenceKind {
-            sheet_name,
-            sheet_index: reference_sheet,
-            absolute_row,
-            absolute_column,
-            row: reference_row,
-            column: reference_column,
-        } => {
-            let reference_row_absolute = if *absolute_row {
-                *reference_row
-            } else {
-                *reference_row + context.row
-            };
-            let reference_column_absolute = if *absolute_column {
-                *reference_column
-            } else {
-                *reference_column + context.column
-            };
-            if ref_is_in_area(
-                *reference_sheet,
-                reference_row_absolute,
-                reference_column_absolute,
-                source_area,
-            ) {
-                if *reference_sheet != target_sheet {
-                    *sheet_name = Some(target_sheet_name.to_string());
-                    *reference_sheet = target_sheet;
-                }
-                *reference_row = target_row + *reference_row - source_area.row;
-                *reference_column = target_column + *reference_column - source_area.column;
-            }
-        }
-        Node::RangeKind {
-            sheet_name,
-            sheet_index,
-            absolute_row1,
-            absolute_column1,
-            row1,
-            column1,
-            absolute_row2,
-            absolute_column2,
-            row2,
-            column2,
-        } => {
-            let reference_row1 = if *absolute_row1 {
-                *row1
-            } else {
-                *row1 + context.row
-            };
-            let reference_column1 = if *absolute_column1 {
-                *column1
-            } else {
-                *column1 + context.column
-            };
-
-            let reference_row2 = if *absolute_row2 {
-                *row2
-            } else {
-                *row2 + context.row
-            };
-            let reference_column2 = if *absolute_column2 {
-                *column2
-            } else {
-                *column2 + context.column
-            };
-            if ref_is_in_area(*sheet_index, reference_row1, reference_column1, source_area)
-                && ref_is_in_area(*sheet_index, reference_row2, reference_column2, source_area)
-            {
-                if *sheet_index != target_sheet {
-                    *sheet_index = target_sheet;
-                    *sheet_name = Some(target_sheet_name.to_string());
-                }
-                *row1 = target_row + *row1 - source_area.row;
-                *column1 = target_column + *column1 - source_area.column;
-                *row2 = target_row + *row2 - source_area.row;
-                *column2 = target_column + *column2 - source_area.column;
-            }
-        }
-        // Recurse
-        Node::OpRangeKind { left, right } => {
-            forward_references(
-                left,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-            forward_references(
-                right,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-        }
-        Node::OpConcatenateKind { left, right } => {
-            forward_references(
-                left,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-            forward_references(
-                right,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-        }
-        Node::OpSumKind {
-            kind: _,
-            left,
-            right,
-        } => {
-            forward_references(
-                left,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-            forward_references(
-                right,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-        }
-        Node::OpProductKind {
-            kind: _,
-            left,
-            right,
-        } => {
-            forward_references(
-                left,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-            forward_references(
-                right,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-        }
-        Node::OpPowerKind { left, right } => {
-            forward_references(
-                left,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-            forward_references(
-                right,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-        }
-        Node::FunctionKind { kind: _, args } => {
-            for arg in args {
-                forward_references(
-                    arg,
-                    context,
-                    source_area,
-                    target_sheet,
-                    target_sheet_name,
-                    target_row,
-                    target_column,
-                );
-            }
-        }
-        Node::InvalidFunctionKind { name: _, args } => {
-            for arg in args {
-                forward_references(
-                    arg,
-                    context,
-                    source_area,
-                    target_sheet,
-                    target_sheet_name,
-                    target_row,
-                    target_column,
-                );
-            }
-        }
-        Node::CompareKind {
-            kind: _,
-            left,
-            right,
-        } => {
-            forward_references(
-                left,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-            forward_references(
-                right,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-        }
-        Node::UnaryKind { kind: _, right } => {
-            forward_references(
-                right,
-                context,
-                source_area,
-                target_sheet,
-                target_sheet_name,
-                target_row,
-                target_column,
-            );
-        }
-        // TODO: Not implemented
-        Node::ArrayKind(_) => {}
-        // Do nothing. Note: we could do a blanket _ => {}
-        Node::VariableKind(_) => {}
-        Node::ErrorKind(_) => {}
-        Node::ParseErrorKind { .. } => {}
-        Node::EmptyArgKind => {}
-        Node::BooleanKind(_) => {}
-        Node::NumberKind(_) => {}
-        Node::StringKind(_) => {}
-        Node::WrongReferenceKind { .. } => {}
-        Node::WrongRangeKind { .. } => {}
-    }
-}

base/src/expressions/token.rs

@@ -79,7 +79,7 @@ impl fmt::Display for OpProduct {
 /// Note that "#ERROR!" and "#N/IMPL!" are not part of the xlsx standard
 ///  * "#ERROR!" means there was an error processing the formula (for instance "=A1+")
 ///  * "#N/IMPL!" means the formula or feature in Excel but has not been implemented in IronCalc
-/// Note that they are serialized/deserialized by index
+///    Note that they are serialized/deserialized by index
 #[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub enum Error {
     REF,
@@ -197,7 +197,7 @@ pub fn is_english_error_string(name: &str) -> bool {
         "#REF!", "#NAME?", "#VALUE!", "#DIV/0!", "#N/A", "#NUM!", "#ERROR!", "#N/IMPL!", "#SPILL!",
         "#CALC!", "#CIRC!", "#NULL!",
     ];
-    names.iter().any(|e| *e == name)
+    names.contains(&name)
 }
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -240,6 +240,7 @@ pub enum TokenType {
     Bang,               // !
     Percent,            // %
     And,                // &
+    At,                 // @
     Reference {
         sheet: Option<String>,
         row: i32,

base/src/expressions/utils/test.rs

@@ -211,4 +211,6 @@ fn test_names() {
     assert!(!is_valid_identifier("test€"));
     assert!(!is_valid_identifier("truñe"));
     assert!(!is_valid_identifier("tr&ue"));
+
+    assert!(!is_valid_identifier("LOG10"));
 }

base/src/formatter/dates.rs

@@ -1,17 +1,156 @@
 use chrono::Datelike;
+use chrono::Days;
 use chrono::Duration;
+use chrono::Months;
 use chrono::NaiveDate;
 
 use crate::constants::EXCEL_DATE_BASE;
+use crate::constants::MAXIMUM_DATE_SERIAL_NUMBER;
+use crate::constants::MINIMUM_DATE_SERIAL_NUMBER;
 
-pub fn from_excel_date(days: i64) -> NaiveDate {
+#[inline]
+fn convert_to_serial_number(date: NaiveDate) -> i32 {
+    date.num_days_from_ce() - EXCEL_DATE_BASE
+}
+
+fn is_date_within_range(date: NaiveDate) -> bool {
+    convert_to_serial_number(date) >= MINIMUM_DATE_SERIAL_NUMBER
+        && convert_to_serial_number(date) <= MAXIMUM_DATE_SERIAL_NUMBER
+}
+
+pub fn from_excel_date(days: i64) -> Result<NaiveDate, String> {
+    if days < MINIMUM_DATE_SERIAL_NUMBER as i64 {
+        return Err(format!(
+            "Excel date must be greater than {MINIMUM_DATE_SERIAL_NUMBER}"
+        ));
+    };
+    if days > MAXIMUM_DATE_SERIAL_NUMBER as i64 {
+        return Err(format!(
+            "Excel date must be less than {MAXIMUM_DATE_SERIAL_NUMBER}"
+        ));
+    };
+    #[allow(clippy::expect_used)]
     let dt = NaiveDate::from_ymd_opt(1900, 1, 1).expect("problem with chrono::NaiveDate");
-    dt + Duration::days(days - 2)
+    Ok(dt + Duration::days(days - 2))
 }
 
 pub fn date_to_serial_number(day: u32, month: u32, year: i32) -> Result<i32, String> {
     match NaiveDate::from_ymd_opt(year, month, day) {
-        Some(native_date) => Ok(native_date.num_days_from_ce() - EXCEL_DATE_BASE),
+        Some(native_date) => Ok(convert_to_serial_number(native_date)),
         None => Err("Out of range parameters for date".to_string()),
     }
 }
+
+pub fn permissive_date_to_serial_number(day: i32, month: i32, year: i32) -> Result<i32, String> {
+    // Excel parses `DATE` very permissively. It allows not just for valid date values, but it
+    // allows for invalid dates as well. If you for example enter `DATE(1900, 1, 32)` it will
+    // return the date `1900-02-01`. Despite giving a day that is out of range it will just
+    // wrap the month and year around.
+    //
+    // This function applies that same logic to dates. And does it in the most compatible way as
+    // possible.
+
+    // Special case for the minimum date
+    if year == 1899 && month == 12 && day == 31 {
+        return Ok(MINIMUM_DATE_SERIAL_NUMBER);
+    }
+    let Some(mut date) = NaiveDate::from_ymd_opt(year, 1, 1) else {
+        return Err("Out of range parameters for date".to_string());
+    };
+
+    // One thing to note for example is that even if you started with a year out of range
+    // but tried to increment the months so that it wraps around into within range, excel
+    // would still return an error.
+    //
+    // I.E. DATE(0,13,-1) will return an error, despite it being equivalent to DATE(1,1,0) which
+    // is within range.
+    //
+    // As a result, we have to run range checks as we parse the date from the biggest unit to the
+    // smallest unit.
+    if !is_date_within_range(date) {
+        return Err("Out of range parameters for date".to_string());
+    }
+
+    date = {
+        let month_diff = month - 1;
+        let abs_month = month_diff.unsigned_abs();
+        if month_diff <= 0 {
+            date = date - Months::new(abs_month);
+        } else {
+            date = date + Months::new(abs_month);
+        }
+        if !is_date_within_range(date) {
+            return Err("Out of range parameters for date".to_string());
+        }
+        date
+    };
+
+    date = {
+        let day_diff = day - 1;
+        let abs_day = day_diff.unsigned_abs() as u64;
+        if day_diff <= 0 {
+            date = date - Days::new(abs_day);
+        } else {
+            date = date + Days::new(abs_day);
+        }
+        if !is_date_within_range(date) {
+            return Err("Out of range parameters for date".to_string());
+        }
+        date
+    };
+
+    Ok(convert_to_serial_number(date))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_permissive_date_to_serial_number() {
+        assert_eq!(
+            permissive_date_to_serial_number(42, 42, 2002),
+            date_to_serial_number(12, 7, 2005)
+        );
+        assert_eq!(
+            permissive_date_to_serial_number(1, 42, 2002),
+            date_to_serial_number(1, 6, 2005)
+        );
+        assert_eq!(
+            permissive_date_to_serial_number(1, 15, 2000),
+            date_to_serial_number(1, 3, 2001)
+        );
+        assert_eq!(
+            permissive_date_to_serial_number(1, 49, 2000),
+            date_to_serial_number(1, 1, 2004)
+        );
+        assert_eq!(
+            permissive_date_to_serial_number(1, 49, 2000),
+            date_to_serial_number(1, 1, 2004)
+        );
+        assert_eq!(
+            permissive_date_to_serial_number(31, 49, 2000),
+            date_to_serial_number(31, 1, 2004)
+        );
+        assert_eq!(
+            permissive_date_to_serial_number(256, 49, 2000),
+            date_to_serial_number(12, 9, 2004)
+        );
+        assert_eq!(
+            permissive_date_to_serial_number(256, 1, 2004),
+            date_to_serial_number(12, 9, 2004)
+        );
+    }
+
+    #[test]
+    fn test_max_and_min_dates() {
+        assert_eq!(
+            permissive_date_to_serial_number(31, 12, 9999),
+            Ok(MAXIMUM_DATE_SERIAL_NUMBER),
+        );
+        assert_eq!(
+            permissive_date_to_serial_number(31, 12, 1899),
+            Ok(MINIMUM_DATE_SERIAL_NUMBER),
+        );
+    }
+}

base/src/formatter/format.rs

@@ -120,7 +120,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
             // We should have different codepaths for general formatting and errors
             let value_abs = value.abs();
             if (1.0e-8..1.0e+11).contains(&value_abs) {
-                let mut text = format!("{:.9}", value);
+                let mut text = format!("{value:.9}");
                 text = text.trim_end_matches('0').trim_end_matches('.').to_string();
                 Formatted {
                     text,
@@ -138,7 +138,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                 let exponent = value_abs.log10().floor();
                 value /= 10.0_f64.powf(exponent);
                 let sign = if exponent < 0.0 { '-' } else { '+' };
-                let s = format!("{:.5}", value);
+                let s = format!("{value:.5}");
                 Formatted {
                     text: format!(
                         "{}E{}{:02}",
@@ -154,45 +154,46 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
         ParsePart::Date(p) => {
             let tokens = &p.tokens;
             let mut text = "".to_string();
-            if !(1.0..=2_958_465.0).contains(&value) {
-                // 2_958_465 is 31 December 9999
-                return Formatted {
-                    text: "#VALUE!".to_owned(),
-                    color: None,
-                    error: Some("Date negative or too long".to_owned()),
-                };
-            }
-            let date = from_excel_date(value as i64);
+            let date = match from_excel_date(value as i64) {
+                Ok(d) => d,
+                Err(e) => {
+                    return Formatted {
+                        text: "#VALUE!".to_owned(),
+                        color: None,
+                        error: Some(e),
+                    }
+                }
+            };
             for token in tokens {
                 match token {
                     TextToken::Literal(c) => {
-                        text = format!("{}{}", text, c);
+                        text = format!("{text}{c}");
                     }
                     TextToken::Text(t) => {
-                        text = format!("{}{}", text, t);
+                        text = format!("{text}{t}");
                     }
                     TextToken::Ghost(_) => {
                         // we just leave a whitespace
                         // This is what the TEXT function does
-                        text = format!("{} ", text);
+                        text = format!("{text} ");
                     }
                     TextToken::Spacer(_) => {
                         // we just leave a whitespace
                         // This is what the TEXT function does
-                        text = format!("{} ", text);
+                        text = format!("{text} ");
                     }
                     TextToken::Raw => {
-                        text = format!("{}{}", text, value);
+                        text = format!("{text}{value}");
                     }
                     TextToken::Digit(_) => {}
                     TextToken::Period => {}
                     TextToken::Day => {
                         let day = date.day() as usize;
-                        text = format!("{}{}", text, day);
+                        text = format!("{text}{day}");
                     }
                     TextToken::DayPadded => {
                         let day = date.day() as usize;
-                        text = format!("{}{:02}", text, day);
+                        text = format!("{text}{day:02}");
                     }
                     TextToken::DayNameShort => {
                         let mut day = date.weekday().number_from_monday() as usize;
@@ -210,11 +211,11 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                     }
                     TextToken::Month => {
                         let month = date.month() as usize;
-                        text = format!("{}{}", text, month);
+                        text = format!("{text}{month}");
                     }
                     TextToken::MonthPadded => {
                         let month = date.month() as usize;
-                        text = format!("{}{:02}", text, month);
+                        text = format!("{text}{month:02}");
                     }
                     TextToken::MonthNameShort => {
                         let month = date.month() as usize;
@@ -227,7 +228,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                     TextToken::MonthLetter => {
                         let month = date.month() as usize;
                         let months_letter = &locale.dates.months_letter[month - 1];
-                        text = format!("{}{}", text, months_letter);
+                        text = format!("{text}{months_letter}");
                     }
                     TextToken::YearShort => {
                         text = format!("{}{}", text, date.format("%y"));
@@ -245,6 +246,9 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
         }
         ParsePart::Number(p) => {
             let mut text = "".to_string();
+            if let Some(c) = p.currency {
+                text = format!("{c}");
+            }
             let tokens = &p.tokens;
             value = value * 100.0_f64.powi(p.percent) / (1000.0_f64.powi(p.comma));
             // p.precision is the number of significant digits _after_ the decimal point
@@ -291,26 +295,26 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
             for token in tokens {
                 match token {
                     TextToken::Literal(c) => {
-                        text = format!("{}{}", text, c);
+                        text = format!("{text}{c}");
                     }
                     TextToken::Text(t) => {
-                        text = format!("{}{}", text, t);
+                        text = format!("{text}{t}");
                     }
                     TextToken::Ghost(_) => {
                         // we just leave a whitespace
                         // This is what the TEXT function does
-                        text = format!("{} ", text);
+                        text = format!("{text} ");
                     }
                     TextToken::Spacer(_) => {
                         // we just leave a whitespace
                         // This is what the TEXT function does
-                        text = format!("{} ", text);
+                        text = format!("{text} ");
                     }
                     TextToken::Raw => {
-                        text = format!("{}{}", text, value);
+                        text = format!("{text}{value}");
                     }
                     TextToken::Period => {
-                        text = format!("{}{}", text, decimal_separator);
+                        text = format!("{text}{decimal_separator}");
                     }
                     TextToken::Digit(digit) => {
                         if digit.number == 'i' {
@@ -318,7 +322,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                             let index = digit.index;
                             let number_index = ln - digit_count + index;
                             if index == 0 && is_negative {
-                                text = format!("-{}", text);
+                                text = format!("-{text}");
                             }
                             if ln <= digit_count {
                                 // The number of digits is less or equal than the number of digit tokens
@@ -343,7 +347,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                                     } else {
                                         ""
                                     };
-                                    text = format!("{}{}{}", text, c, sep);
+                                    text = format!("{text}{c}{sep}");
                                 }
                                 digit_index += 1;
                             } else {
@@ -369,18 +373,18 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                             if index < fract_part.len() {
                                 text = format!("{}{}", text, fract_part[index]);
                             } else if digit.kind == '0' {
-                                text = format!("{}0", text);
+                                text = format!("{text}0");
                             } else if digit.kind == '?' {
-                                text = format!("{} ", text);
+                                text = format!("{text} ");
                             }
                         } else if digit.number == 'e' {
                             // 3. Exponent part
                             let index = digit.index;
                             if index == 0 {
                                 if exponent_is_negative {
-                                    text = format!("{}E-", text);
+                                    text = format!("{text}E-");
                                 } else {
-                                    text = format!("{}E+", text);
+                                    text = format!("{text}E+");
                                 }
                             }
                             let number_index = l_exp - (p.exponent_digit_count - index);
@@ -396,7 +400,7 @@ pub fn format_number(value_original: f64, format: &str, locale: &Locale) -> Form
                                         exponent_part[number_index as usize]
                                     };
 
-                                    text = format!("{}{}", text, c);
+                                    text = format!("{text}{c}");
                                 }
                             } else {
                                 for i in 0..number_index + 1 {
@@ -610,7 +614,7 @@ pub(crate) fn parse_formatted_number(
 
     // check if it is a currency in currencies
     for currency in currencies {
-        if let Some(p) = value.strip_prefix(&format!("-{}", currency)) {
+        if let Some(p) = value.strip_prefix(&format!("-{currency}")) {
             let (f, options) = parse_number(p.trim())?;
             if options.is_scientific {
                 return Ok((f, Some(scientific_format.to_string())));

base/src/formatter/lexer.rs

@@ -10,6 +10,7 @@ pub struct Lexer {
 pub enum Token {
     Color(i32),              // [Red] or [Color 23]
     Condition(Compare, f64), // [<=100] (Comparator, number)
+    Currency(char),          // [$€] ($ currency symbol)
     Literal(char), // €, $, (, ), /, :, +, -, ^, ', {, }, <, =, !, ~, > and space or scaped \X
     Spacer(char),  // *X
     Ghost(char),   // _X
@@ -177,10 +178,7 @@ impl Lexer {
             }
         }
         self.position = position;
-        match chars.parse::<f64>() {
-            Err(_) => None,
-            Ok(v) => Some(v),
-        }
+        chars.parse::<f64>().ok()
     }
 
     fn consume_condition(&mut self) -> Option<(Compare, f64)> {
@@ -274,6 +272,15 @@ impl Lexer {
                                 self.set_error("Failed to parse condition");
                                 Token::ILLEGAL
                             }
+                        } else if c == '$' {
+                            // currency
+                            self.read_next_char();
+                            if let Some(currency) = self.read_next_char() {
+                                self.read_next_char();
+                                return Token::Currency(currency);
+                            }
+                            self.set_error("Failed to parse currency");
+                            Token::ILLEGAL
                         } else {
                             // Color
                             if let Some(index) = self.consume_color() {
@@ -326,7 +333,7 @@ impl Lexer {
                         } else if s == '-' {
                             Token::ScientificMinus
                         } else {
-                            self.set_error(&format!("Unexpected char: {}. Expected + or -", s));
+                            self.set_error(&format!("Unexpected char: {s}. Expected + or -"));
                             Token::ILLEGAL
                         }
                     } else {
@@ -378,14 +385,14 @@ impl Lexer {
                     for c in "eneral".chars() {
                         let cc = self.read_next_char();
                         if Some(c) != cc {
-                            self.set_error(&format!("Unexpected character: {}", x));
+                            self.set_error(&format!("Unexpected character: {x}"));
                             return Token::ILLEGAL;
                         }
                     }
                     Token::General
                 }
                 _ => {
-                    self.set_error(&format!("Unexpected character: {}", x));
+                    self.set_error(&format!("Unexpected character: {x}"));
                     Token::ILLEGAL
                 }
             },

base/src/formatter/mod.rs

@@ -74,6 +74,7 @@ mod test;
 //
 // * Color [Red] or [Color 23] or [Color23]
 // * Conditions [<100]
+// * Currency [$€]
 // * Space _X when X is any given char
 // * A spacer of chars: *X where X is repeated as much as possible
 // * Literals: $, (, ), :, +, - and space

base/src/formatter/parser.rs

@@ -40,6 +40,7 @@ pub struct NumberPart {
     pub is_scientific: bool,
     pub scientific_minus: bool,
     pub exponent_digit_count: i32,
+    pub currency: Option<char>,
 }
 
 pub struct DatePart {
@@ -114,6 +115,7 @@ impl Parser {
         let mut exponent_digit_count = 0;
         let mut number = 'i';
         let mut index = 0;
+        let mut currency = None;
 
         while token != Token::EOF && token != Token::Separator {
             let next_token = self.lexer.next_token();
@@ -170,6 +172,9 @@ impl Parser {
                 Token::Condition(cmp, value) => {
                     condition = Some((cmp, value));
                 }
+                Token::Currency(c) => {
+                    currency = Some(c);
+                }
                 Token::QuestionMark => {
                     tokens.push(TextToken::Digit(Digit {
                         kind: '?',
@@ -291,6 +296,7 @@ impl Parser {
                 is_scientific,
                 scientific_minus,
                 exponent_digit_count,
+                currency,
             })
         }
     }

base/src/formatter/test/test_general.rs

@@ -76,6 +76,14 @@ fn test_color() {
     assert_eq!(format_number(3.1, "[blue]0.00", locale).color, Some(4));
 }
 
+#[test]
+fn dollar_euro() {
+    let locale = get_default_locale();
+    let format = "[$€]#,##0.00";
+    let t = format_number(3.1, format, locale);
+    assert_eq!(t.text, "€3.10");
+}
+
 #[test]
 fn test_parts() {
     let locale = get_default_locale();

base/src/functions/date_and_time.rs

@@ -3,8 +3,11 @@ use chrono::Datelike;
 use chrono::Months;
 use chrono::Timelike;
 
+use crate::constants::MAXIMUM_DATE_SERIAL_NUMBER;
+use crate::constants::MINIMUM_DATE_SERIAL_NUMBER;
 use crate::expressions::types::CellReferenceIndex;
 use crate::formatter::dates::date_to_serial_number;
+use crate::formatter::dates::permissive_date_to_serial_number;
 use crate::model::get_milliseconds_since_epoch;
 use crate::{
     calc_result::CalcResult, constants::EXCEL_DATE_BASE, expressions::parser::Node,
@@ -18,20 +21,19 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let serial_number = match self.get_number(&args[0], cell) {
-            Ok(c) => {
-                let t = c.floor() as i64;
-                if t < 0 {
-                    return CalcResult::Error {
-                        error: Error::NUM,
-                        origin: cell,
-                        message: "Function DAY parameter 1 value is negative. It should be positive or zero.".to_string(),
-                    };
-                }
-                t
-            }
+            Ok(c) => c.floor() as i64,
             Err(s) => return s,
         };
-        let date = from_excel_date(serial_number);
+        let date = match from_excel_date(serial_number) {
+            Ok(date) => date,
+            Err(_) => {
+                return CalcResult::Error {
+                    error: Error::NUM,
+                    origin: cell,
+                    message: "Out of range parameters for date".to_string(),
+                }
+            }
+        };
         let day = date.day() as f64;
         CalcResult::Number(day)
     }
@@ -42,20 +44,19 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let serial_number = match self.get_number(&args[0], cell) {
-            Ok(c) => {
-                let t = c.floor() as i64;
-                if t < 0 {
-                    return CalcResult::Error {
-                        error: Error::NUM,
-                        origin: cell,
-                        message: "Function MONTH parameter 1 value is negative. It should be positive or zero.".to_string(),
-                    };
-                }
-                t
-            }
+            Ok(c) => c.floor() as i64,
             Err(s) => return s,
         };
-        let date = from_excel_date(serial_number);
+        let date = match from_excel_date(serial_number) {
+            Ok(date) => date,
+            Err(_) => {
+                return CalcResult::Error {
+                    error: Error::NUM,
+                    origin: cell,
+                    message: "Out of range parameters for date".to_string(),
+                }
+            }
+        };
         let month = date.month() as f64;
         CalcResult::Number(month)
     }
@@ -79,6 +80,23 @@ impl Model {
             }
             Err(s) => return s,
         };
+        let date = match from_excel_date(serial_number) {
+            Ok(date) => date,
+            Err(_) => {
+                return CalcResult::Error {
+                    error: Error::NUM,
+                    origin: cell,
+                    message: "Out of range parameters for date".to_string(),
+                }
+            }
+        };
+        if serial_number > MAXIMUM_DATE_SERIAL_NUMBER as i64 {
+            return CalcResult::Error {
+                error: Error::NUM,
+                origin: cell,
+                message: "Function DAY parameter 1 value is too large.".to_string(),
+            };
+        }
 
         let months = match self.get_number_no_bools(&args[1], cell) {
             Ok(c) => {
@@ -91,9 +109,9 @@ impl Model {
         let months_abs = months.unsigned_abs();
 
         let native_date = if months > 0 {
-            from_excel_date(serial_number) + Months::new(months_abs)
+            date + Months::new(months_abs)
         } else {
-            from_excel_date(serial_number) - Months::new(months_abs)
+            date - Months::new(months_abs)
         };
 
         // Instead of calculating the end of month we compute the first day of the following month
@@ -137,32 +155,18 @@ impl Model {
         let month = match self.get_number(&args[1], cell) {
             Ok(c) => {
                 let t = c.floor();
-                if t < 0.0 {
-                    return CalcResult::Error {
-                        error: Error::NUM,
-                        origin: cell,
-                        message: "Out of range parameters for date".to_string(),
-                    };
-                }
-                t as u32
+                t as i32
             }
             Err(s) => return s,
         };
         let day = match self.get_number(&args[2], cell) {
             Ok(c) => {
                 let t = c.floor();
-                if t < 0.0 {
-                    return CalcResult::Error {
-                        error: Error::NUM,
-                        origin: cell,
-                        message: "Out of range parameters for date".to_string(),
-                    };
-                }
-                t as u32
+                t as i32
             }
             Err(s) => return s,
         };
-        match date_to_serial_number(day, month, year) {
+        match permissive_date_to_serial_number(day, month, year) {
             Ok(serial_number) => CalcResult::Number(serial_number as f64),
             Err(message) => CalcResult::Error {
                 error: Error::NUM,
@@ -178,20 +182,19 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let serial_number = match self.get_number(&args[0], cell) {
-            Ok(c) => {
-                let t = c.floor() as i64;
-                if t < 0 {
-                    return CalcResult::Error {
-                        error: Error::NUM,
-                        origin: cell,
-                        message: "Function YEAR parameter 1 value is negative. It should be positive or zero.".to_string(),
-                    };
-                }
-                t
-            }
+            Ok(c) => c.floor() as i64,
             Err(s) => return s,
         };
-        let date = from_excel_date(serial_number);
+        let date = match from_excel_date(serial_number) {
+            Ok(date) => date,
+            Err(_) => {
+                return CalcResult::Error {
+                    error: Error::NUM,
+                    origin: cell,
+                    message: "Out of range parameters for date".to_string(),
+                }
+            }
+        };
         let year = date.year() as f64;
         CalcResult::Number(year)
     }
@@ -203,20 +206,19 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let serial_number = match self.get_number(&args[0], cell) {
-            Ok(c) => {
-                let t = c.floor() as i64;
-                if t < 0 {
-                    return CalcResult::Error {
-                        error: Error::NUM,
-                        origin: cell,
-                        message: "Parameter 1 value is negative. It should be positive or zero."
-                            .to_string(),
-                    };
-                }
-                t
-            }
+            Ok(c) => c.floor() as i64,
             Err(s) => return s,
         };
+        let date = match from_excel_date(serial_number) {
+            Ok(date) => date,
+            Err(_) => {
+                return CalcResult::Error {
+                    error: Error::NUM,
+                    origin: cell,
+                    message: "Out of range parameters for date".to_string(),
+                }
+            }
+        };
 
         let months = match self.get_number(&args[1], cell) {
             Ok(c) => {
@@ -229,13 +231,13 @@ impl Model {
         let months_abs = months.unsigned_abs();
 
         let native_date = if months > 0 {
-            from_excel_date(serial_number) + Months::new(months_abs)
+            date + Months::new(months_abs)
         } else {
-            from_excel_date(serial_number) - Months::new(months_abs)
+            date - Months::new(months_abs)
         };
 
         let serial_number = native_date.num_days_from_ce() - EXCEL_DATE_BASE;
-        if serial_number < 0 {
+        if serial_number < MINIMUM_DATE_SERIAL_NUMBER {
             return CalcResult::Error {
                 error: Error::NUM,
                 origin: cell,

base/src/functions/engineering/complex.rs

@@ -46,18 +46,18 @@ impl fmt::Display for Complex {
         // it is a bit weird what Excel does but it seems it uses general notation for
         // numbers > 1e-20 and scientific notation for the rest
         let y_str = if y.abs() <= 9e-20 {
-            format!("{:E}", y)
+            format!("{y:E}")
         } else if y == 1.0 {
             "".to_string()
         } else if y == -1.0 {
             "-".to_string()
         } else {
-            format!("{}", y)
+            format!("{y}")
         };
         let x_str = if x.abs() <= 9e-20 {
-            format!("{:E}", x)
+            format!("{x:E}")
         } else {
-            format!("{}", x)
+            format!("{x}")
         };
         if y == 0.0 && x == 0.0 {
             write!(f, "0")
@@ -188,10 +188,7 @@ impl Model {
         node: &Node,
         cell: CellReferenceIndex,
     ) -> Result<(f64, f64, Suffix), CalcResult> {
-        let value = match self.get_string(node, cell) {
-            Ok(s) => s,
-            Err(s) => return Err(s),
-        };
+        let value = self.get_string(node, cell)?;
         if value.is_empty() {
             return Ok((0.0, 0.0, Suffix::I));
         }

base/src/functions/engineering/number_basis.rs

@@ -76,7 +76,7 @@ impl Model {
         if value < 0 {
             CalcResult::String(format!("{:0width$X}", HEX_MAX + value, width = 9))
         } else {
-            let result = format!("{:X}", value);
+            let result = format!("{value:X}");
             if let Some(places) = places {
                 if places < result.len() as i32 {
                     return CalcResult::new_error(
@@ -120,7 +120,7 @@ impl Model {
         if value < 0 {
             CalcResult::String(format!("{:0width$o}", OCT_MAX + value, width = 9))
         } else {
-            let result = format!("{:o}", value);
+            let result = format!("{value:o}");
             if let Some(places) = places {
                 if places < result.len() as i32 {
                     return CalcResult::new_error(
@@ -163,7 +163,7 @@ impl Model {
         if value < 0 {
             value += 1024;
         }
-        let result = format!("{:b}", value);
+        let result = format!("{value:b}");
         if let Some(places) = places {
             if value_raw > 0.0 && places < result.len() as i32 {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -202,7 +202,7 @@ impl Model {
         if value < 0 {
             value += HEX_MAX;
         }
-        let result = format!("{:X}", value);
+        let result = format!("{value:X}");
         if let Some(places) = places {
             if value_raw > 0.0 && places < result.len() as i32 {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -242,7 +242,7 @@ impl Model {
         if value < 0 {
             value += OCT_MAX;
         }
-        let result = format!("{:o}", value);
+        let result = format!("{value:o}");
         if let Some(places) = places {
             if value_raw > 0.0 && places < result.len() as i32 {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -301,7 +301,7 @@ impl Model {
         if value < 0 {
             value += 1024;
         }
-        let result = format!("{:b}", value);
+        let result = format!("{value:b}");
         if let Some(places) = places {
             if places <= 0 || (value > 0 && places < result.len() as i32) {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -391,7 +391,7 @@ impl Model {
         if value < 0 {
             value += OCT_MAX;
         }
-        let result = format!("{:o}", value);
+        let result = format!("{value:o}");
         if let Some(places) = places {
             if places <= 0 || (value > 0 && places < result.len() as i32) {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -446,7 +446,7 @@ impl Model {
         if value < 0 {
             value += 1024;
         }
-        let result = format!("{:b}", value);
+        let result = format!("{value:b}");
         if let Some(places) = places {
             if value < 512 && places < result.len() as i32 {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());
@@ -532,7 +532,7 @@ impl Model {
         if value < 0 {
             value += HEX_MAX;
         }
-        let result = format!("{:X}", value);
+        let result = format!("{value:X}");
         if let Some(places) = places {
             if value < HEX_MAX_HALF && places < result.len() as i32 {
                 return CalcResult::new_error(Error::NUM, cell, "Out of bounds".to_string());

base/src/functions/engineering/transcendental/test_bessel.rs

@@ -12,7 +12,7 @@ const EPS_LOW: f64 = 1e-6;
 
 // Known values computed with Arb via Nemo.jl in Julia
 // You can also use Mathematica
-/// But please do not use Excel or any other software without arbitrary precision
+// But please do not use Excel or any other software without arbitrary precision
 
 fn numbers_are_close(a: f64, b: f64) -> bool {
     if a == b {

base/src/functions/financial.rs

@@ -2,7 +2,7 @@ use chrono::Datelike;
 
 use crate::{
     calc_result::CalcResult,
-    constants::{LAST_COLUMN, LAST_ROW},
+    constants::{LAST_COLUMN, LAST_ROW, MAXIMUM_DATE_SERIAL_NUMBER, MINIMUM_DATE_SERIAL_NUMBER},
     expressions::{parser::Node, token::Error, types::CellReferenceIndex},
     formatter::dates::from_excel_date,
     model::Model,
@@ -13,37 +13,32 @@ use super::financial_util::{compute_irr, compute_npv, compute_rate, compute_xirr
 // See:
 // https://github.com/apache/openoffice/blob/c014b5f2b55cff8d4b0c952d5c16d62ecde09ca1/main/scaddins/source/analysis/financial.cxx
 
-// FIXME: Is this enough?
-fn is_valid_date(date: f64) -> bool {
-    date > 0.0
-}
-
-fn is_less_than_one_year(start_date: i64, end_date: i64) -> bool {
+fn is_less_than_one_year(start_date: i64, end_date: i64) -> Result<bool, String> {
+    let end = from_excel_date(end_date)?;
+    let start = from_excel_date(start_date)?;
     if end_date - start_date < 365 {
-        return true;
+        return Ok(true);
     }
-    let end = from_excel_date(end_date);
-    let start = from_excel_date(start_date);
     let end_year = end.year();
     let start_year = start.year();
     if end_year == start_year {
-        return true;
+        return Ok(true);
     }
     if end_year != start_year + 1 {
-        return false;
+        return Ok(false);
     }
     let start_month = start.month();
     let end_month = end.month();
     if end_month < start_month {
-        return true;
+        return Ok(true);
     }
     if end_month > start_month {
-        return false;
+        return Ok(false);
     }
     // we are one year later same month
     let start_day = start.day();
     let end_day = end.day();
-    end_day <= start_day
+    Ok(end_day <= start_day)
 }
 
 fn compute_payment(
@@ -89,6 +84,9 @@ fn compute_future_value(
     if rate == 0.0 {
         return Ok(-pv - pmt * nper);
     }
+    if rate == -1.0 && nper < 0.0 {
+        return Err((Error::DIV, "Divide by zero".to_string()));
+    }
 
     let rate_nper = (1.0 + rate).powf(nper);
     let fv = if period_start {
@@ -194,16 +192,24 @@ fn compute_ppmt(
 // In these formulas the payment (pmt) is normally negative
 
 impl Model {
-    // FIXME: These three functions (get_array_of_numbers..) need to be refactored
-    // They are really similar expect for small issues
-    fn get_array_of_numbers(
+    fn get_array_of_numbers_generic(
         &mut self,
         arg: &Node,
         cell: &CellReferenceIndex,
+        accept_number_node: bool,
+        handle_empty_cell: impl Fn() -> Result<Option<f64>, CalcResult>,
+        handle_non_number_cell: impl Fn() -> Result<Option<f64>, CalcResult>,
     ) -> Result<Vec<f64>, CalcResult> {
         let mut values = Vec::new();
         match self.evaluate_node_in_context(arg, *cell) {
-            CalcResult::Number(value) => values.push(value),
+            CalcResult::Number(value) if accept_number_node => values.push(value),
+            CalcResult::Number(_) => {
+                return Err(CalcResult::new_error(
+                    Error::VALUE,
+                    *cell,
+                    "Expected range of numbers".to_string(),
+                ));
+            }
             CalcResult::Range { left, right } => {
                 if left.sheet != right.sheet {
                     return Err(CalcResult::new_error(
@@ -212,6 +218,7 @@ impl Model {
                         "Ranges are in different sheets".to_string(),
                     ));
                 }
+                let sheet = left.sheet;
                 let row1 = left.row;
                 let mut row2 = right.row;
                 let column1 = left.column;
@@ -219,32 +226,46 @@ impl Model {
                 if row1 == 1 && row2 == LAST_ROW {
                     row2 = self
                         .workbook
-                        .worksheet(left.sheet)
-                        .expect("Sheet expected during evaluation.")
+                        .worksheet(sheet)
+                        .map_err(|_| {
+                            CalcResult::new_error(
+                                Error::ERROR,
+                                *cell,
+                                format!("Invalid worksheet index: '{sheet}'"),
+                            )
+                        })?
                         .dimension()
                         .max_row;
                 }
                 if column1 == 1 && column2 == LAST_COLUMN {
                     column2 = self
                         .workbook
-                        .worksheet(left.sheet)
-                        .expect("Sheet expected during evaluation.")
+                        .worksheet(sheet)
+                        .map_err(|_| {
+                            CalcResult::new_error(
+                                Error::ERROR,
+                                *cell,
+                                format!("Invalid worksheet index: '{sheet}'"),
+                            )
+                        })?
                         .dimension()
                         .max_column;
                 }
-                for row in row1..row2 + 1 {
-                    for column in column1..(column2 + 1) {
-                        match self.evaluate_cell(CellReferenceIndex {
-                            sheet: left.sheet,
-                            row,
-                            column,
-                        }) {
-                            CalcResult::Number(value) => {
-                                values.push(value);
-                            }
+                for row in row1..=row2 {
+                    for column in column1..=column2 {
+                        let cell_ref = CellReferenceIndex { sheet, row, column };
+                        match self.evaluate_cell(cell_ref) {
+                            CalcResult::Number(value) => values.push(value),
                             error @ CalcResult::Error { .. } => return Err(error),
+                            CalcResult::EmptyCell => {
+                                if let Some(value) = handle_empty_cell()? {
+                                    values.push(value);
+                                }
+                            }
                             _ => {
-                                // We ignore booleans and strings
+                                if let Some(value) = handle_non_number_cell()? {
+                                    values.push(value);
+                                }
                             }
                         }
                     }
@@ -252,88 +273,51 @@ impl Model {
             }
             error @ CalcResult::Error { .. } => return Err(error),
             _ => {
-                // We ignore booleans and strings
+                handle_non_number_cell()?;
             }
-        };
+        }
         Ok(values)
     }
 
+    fn get_array_of_numbers(
+        &mut self,
+        arg: &Node,
+        cell: &CellReferenceIndex,
+    ) -> Result<Vec<f64>, CalcResult> {
+        self.get_array_of_numbers_generic(
+            arg,
+            cell,
+            true,        // accept_number_node
+            || Ok(None), // Ignore empty cells
+            || Ok(None), // Ignore non-number cells
+        )
+    }
+
     fn get_array_of_numbers_xpnv(
         &mut self,
         arg: &Node,
         cell: &CellReferenceIndex,
         error: Error,
     ) -> Result<Vec<f64>, CalcResult> {
-        let mut values = Vec::new();
-        match self.evaluate_node_in_context(arg, *cell) {
-            CalcResult::Number(value) => values.push(value),
-            CalcResult::Range { left, right } => {
-                if left.sheet != right.sheet {
-                    return Err(CalcResult::new_error(
-                        Error::VALUE,
-                        *cell,
-                        "Ranges are in different sheets".to_string(),
-                    ));
-                }
-                let row1 = left.row;
-                let mut row2 = right.row;
-                let column1 = left.column;
-                let mut column2 = right.column;
-                if row1 == 1 && row2 == LAST_ROW {
-                    row2 = self
-                        .workbook
-                        .worksheet(left.sheet)
-                        .expect("Sheet expected during evaluation.")
-                        .dimension()
-                        .max_row;
-                }
-                if column1 == 1 && column2 == LAST_COLUMN {
-                    column2 = self
-                        .workbook
-                        .worksheet(left.sheet)
-                        .expect("Sheet expected during evaluation.")
-                        .dimension()
-                        .max_column;
-                }
-                for row in row1..row2 + 1 {
-                    for column in column1..(column2 + 1) {
-                        match self.evaluate_cell(CellReferenceIndex {
-                            sheet: left.sheet,
-                            row,
-                            column,
-                        }) {
-                            CalcResult::Number(value) => {
-                                values.push(value);
-                            }
-                            error @ CalcResult::Error { .. } => return Err(error),
-                            CalcResult::EmptyCell => {
-                                return Err(CalcResult::new_error(
-                                    Error::NUM,
-                                    *cell,
-                                    "Expected number".to_string(),
-                                ));
-                            }
-                            _ => {
-                                return Err(CalcResult::new_error(
-                                    error,
-                                    *cell,
-                                    "Expected number".to_string(),
-                                ));
-                            }
-                        }
-                    }
-                }
-            }
-            error @ CalcResult::Error { .. } => return Err(error),
-            _ => {
-                return Err(CalcResult::new_error(
-                    error,
+        self.get_array_of_numbers_generic(
+            arg,
+            cell,
+            true, // accept_number_node
+            || {
+                Err(CalcResult::new_error(
+                    Error::NUM,
                     *cell,
                     "Expected number".to_string(),
-                ));
-            }
-        };
-        Ok(values)
+                ))
+            },
+            || {
+                Err(CalcResult::new_error(
+                    error.clone(),
+                    *cell,
+                    "Expected number".to_string(),
+                ))
+            },
+        )
     }
 
     fn get_array_of_numbers_xirr(
@@ -341,69 +325,19 @@ impl Model {
         arg: &Node,
         cell: &CellReferenceIndex,
     ) -> Result<Vec<f64>, CalcResult> {
-        let mut values = Vec::new();
-        match self.evaluate_node_in_context(arg, *cell) {
-            CalcResult::Range { left, right } => {
-                if left.sheet != right.sheet {
-                    return Err(CalcResult::new_error(
-                        Error::VALUE,
-                        *cell,
-                        "Ranges are in different sheets".to_string(),
-                    ));
-                }
-                let row1 = left.row;
-                let mut row2 = right.row;
-                let column1 = left.column;
-                let mut column2 = right.column;
-                if row1 == 1 && row2 == LAST_ROW {
-                    row2 = self
-                        .workbook
-                        .worksheet(left.sheet)
-                        .expect("Sheet expected during evaluation.")
-                        .dimension()
-                        .max_row;
-                }
-                if column1 == 1 && column2 == LAST_COLUMN {
-                    column2 = self
-                        .workbook
-                        .worksheet(left.sheet)
-                        .expect("Sheet expected during evaluation.")
-                        .dimension()
-                        .max_column;
-                }
-                for row in row1..row2 + 1 {
-                    for column in column1..(column2 + 1) {
-                        match self.evaluate_cell(CellReferenceIndex {
-                            sheet: left.sheet,
-                            row,
-                            column,
-                        }) {
-                            CalcResult::Number(value) => {
-                                values.push(value);
-                            }
-                            error @ CalcResult::Error { .. } => return Err(error),
-                            CalcResult::EmptyCell => values.push(0.0),
-                            _ => {
-                                return Err(CalcResult::new_error(
-                                    Error::VALUE,
-                                    *cell,
-                                    "Expected number".to_string(),
-                                ));
-                            }
-                        }
-                    }
-                }
-            }
-            error @ CalcResult::Error { .. } => return Err(error),
-            _ => {
-                return Err(CalcResult::new_error(
+        self.get_array_of_numbers_generic(
+            arg,
+            cell,
+            false,            // Do not accept a single number node
+            || Ok(Some(0.0)), // Treat empty cells as zero
+            || {
+                Err(CalcResult::new_error(
                     Error::VALUE,
                     *cell,
                     "Expected number".to_string(),
-                ));
-            }
-        };
-        Ok(values)
+                ))
+            },
+        )
     }
 
     /// PMT(rate, nper, pv, [fv], [type])
@@ -497,7 +431,7 @@ impl Model {
         }
         if rate == -1.0 {
             return CalcResult::Error {
-                error: Error::NUM,
+                error: Error::DIV,
                 origin: cell,
                 message: "Rate must be != -1".to_string(),
             };
@@ -862,20 +796,28 @@ impl Model {
                     let column1 = left.column;
                     let mut column2 = right.column;
                     if row1 == 1 && row2 == LAST_ROW {
-                        row2 = self
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_row;
+                        row2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_row,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_column;
+                        column2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_column,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     for row in row1..row2 + 1 {
                         for column in column1..(column2 + 1) {
@@ -976,7 +918,9 @@ impl Model {
         }
         let first_date = dates[0];
         for date in &dates {
-            if !is_valid_date(*date) {
+            if *date < MINIMUM_DATE_SERIAL_NUMBER as f64
+                || *date > MAXIMUM_DATE_SERIAL_NUMBER as f64
+            {
                 // Excel docs claim that if any number in dates is not a valid date,
                 // XNPV returns the #VALUE! error value, but it seems to return #VALUE!
                 return CalcResult::new_error(
@@ -1042,7 +986,9 @@ impl Model {
         }
         let first_date = dates[0];
         for date in &dates {
-            if !is_valid_date(*date) {
+            if *date < MINIMUM_DATE_SERIAL_NUMBER as f64
+                || *date > MAXIMUM_DATE_SERIAL_NUMBER as f64
+            {
                 return CalcResult::new_error(
                     Error::NUM,
                     cell,
@@ -1393,21 +1339,21 @@ impl Model {
         CalcResult::Number(result)
     }
 
-    /// This next three functions deal with Treasure Bills or T-Bills for short
-    /// They are zero-coupon that mature in one year or less.
-    ///  Definitions:
-    ///    $r$ be the discount rate
-    ///    $v$ the face value of the Bill
-    ///    $p$ the price of the Bill
-    ///    $d_m$ is the number of days from the settlement to maturity
-    /// Then:
-    ///   $$ p = v \times\left(1-\frac{d_m}{r}\right) $$
-    /// If d_m is less than 183 days the he Bond Equivalent Yield (BEY, here $y$) is given by:
-    /// $$ y = \frac{F - B}{M}\times \frac{365}{d_m} = \frac{365\times r}{360-r\times d_m}
-    /// If d_m>= 183 days things are a bit more complicated.
-    /// Let $d_e = d_m - 365/2$ if $d_m <= 365$ or $d_e = 183$ if $d_m = 366$.
-    /// $$ v = p\times \left(1+\frac{y}{2}\right)\left(1+d_e\times\frac{y}{365}\right) $$
-    /// Together with the previous relation of $p$ and $v$ gives us a quadratic equation for $y$.
+    // This next three functions deal with Treasure Bills or T-Bills for short
+    // They are zero-coupon that mature in one year or less.
+    //  Definitions:
+    //    $r$ be the discount rate
+    //    $v$ the face value of the Bill
+    //    $p$ the price of the Bill
+    //    $d_m$ is the number of days from the settlement to maturity
+    // Then:
+    //   $$ p = v \times\left(1-\frac{d_m}{r}\right) $$
+    // If d_m is less than 183 days the he Bond Equivalent Yield (BEY, here $y$) is given by:
+    // $$ y = \frac{F - B}{M}\times \frac{365}{d_m} = \frac{365\times r}{360-r\times d_m}
+    // If d_m>= 183 days things are a bit more complicated.
+    // Let $d_e = d_m - 365/2$ if $d_m <= 365$ or $d_e = 183$ if $d_m = 366$.
+    // $$ v = p\times \left(1+\frac{y}{2}\right)\left(1+d_e\times\frac{y}{365}\right) $$
+    // Together with the previous relation of $p$ and $v$ gives us a quadratic equation for $y$.
 
     // TBILLEQ(settlement, maturity, discount)
     pub(crate) fn fn_tbilleq(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
@@ -1426,9 +1372,10 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        if !is_valid_date(settlement) || !is_valid_date(maturity) {
-            return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string());
-        }
+        let less_than_one_year = match is_less_than_one_year(settlement as i64, maturity as i64) {
+            Ok(f) => f,
+            Err(_) => return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string()),
+        };
         if settlement > maturity {
             return CalcResult::new_error(
                 Error::NUM,
@@ -1436,7 +1383,7 @@ impl Model {
                 "settlement should be <= maturity".to_string(),
             );
         }
-        if !is_less_than_one_year(settlement as i64, maturity as i64) {
+        if !less_than_one_year {
             return CalcResult::new_error(
                 Error::NUM,
                 cell,
@@ -1490,9 +1437,10 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        if !is_valid_date(settlement) || !is_valid_date(maturity) {
-            return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string());
-        }
+        let less_than_one_year = match is_less_than_one_year(settlement as i64, maturity as i64) {
+            Ok(f) => f,
+            Err(_) => return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string()),
+        };
         if settlement > maturity {
             return CalcResult::new_error(
                 Error::NUM,
@@ -1500,7 +1448,7 @@ impl Model {
                 "settlement should be <= maturity".to_string(),
             );
         }
-        if !is_less_than_one_year(settlement as i64, maturity as i64) {
+        if !less_than_one_year {
             return CalcResult::new_error(
                 Error::NUM,
                 cell,
@@ -1540,9 +1488,10 @@ impl Model {
             Ok(f) => f,
             Err(s) => return s,
         };
-        if !is_valid_date(settlement) || !is_valid_date(maturity) {
-            return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string());
-        }
+        let less_than_one_year = match is_less_than_one_year(settlement as i64, maturity as i64) {
+            Ok(f) => f,
+            Err(_) => return CalcResult::new_error(Error::NUM, cell, "Invalid date".to_string()),
+        };
         if settlement > maturity {
             return CalcResult::new_error(
                 Error::NUM,
@@ -1550,7 +1499,7 @@ impl Model {
                 "settlement should be <= maturity".to_string(),
             );
         }
-        if !is_less_than_one_year(settlement as i64, maturity as i64) {
+        if !less_than_one_year {
             return CalcResult::new_error(
                 Error::NUM,
                 cell,

base/src/functions/information.rs

@@ -235,6 +235,11 @@ impl Model {
                 // This cannot happen
                 CalcResult::Number(1.0)
             }
+            CalcResult::Array(_) => CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Arrays not supported yet".to_string(),
+            },
         }
     }
     pub(crate) fn fn_sheet(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
@@ -247,45 +252,67 @@ impl Model {
             return CalcResult::Number(cell.sheet as f64 + 1.0);
         }
         // The arg could be a defined name or a table
-        let arg = &args[0];
-        if let Node::VariableKind(name) = arg {
-            // Let's see if it is a defined name
-            if let Some(defined_name) = self.parsed_defined_names.get(&(None, name.to_lowercase()))
-            {
-                match defined_name {
-                    ParsedDefinedName::CellReference(reference) => {
-                        return CalcResult::Number(reference.sheet as f64 + 1.0)
+        // let  = &args[0];
+        match &args[0] {
+            Node::DefinedNameKind((name, scope, _)) => {
+                // Let's see if it is a defined name
+                if let Some(defined_name) = self
+                    .parsed_defined_names
+                    .get(&(*scope, name.to_lowercase()))
+                {
+                    match defined_name {
+                        ParsedDefinedName::CellReference(reference) => {
+                            return CalcResult::Number(reference.sheet as f64 + 1.0)
+                        }
+                        ParsedDefinedName::RangeReference(range) => {
+                            return CalcResult::Number(range.left.sheet as f64 + 1.0)
+                        }
+                        ParsedDefinedName::InvalidDefinedNameFormula => {
+                            return CalcResult::Error {
+                                error: Error::ERROR,
+                                origin: cell,
+                                message: "Invalid name".to_string(),
+                            };
+                        }
                     }
-                    ParsedDefinedName::RangeReference(range) => {
-                        return CalcResult::Number(range.left.sheet as f64 + 1.0)
-                    }
-                    ParsedDefinedName::InvalidDefinedNameFormula => {
-                        return CalcResult::Error {
-                            error: Error::NA,
-                            origin: cell,
-                            message: "Invalid name".to_string(),
-                        };
+                } else {
+                    // This should never happen
+                    return CalcResult::Error {
+                        error: Error::ERROR,
+                        origin: cell,
+                        message: "Invalid name".to_string(),
+                    };
+                }
+            }
+            Node::TableNameKind(name) => {
+                // Now let's see if it is a table
+                for (table_name, table) in &self.workbook.tables {
+                    if table_name == name {
+                        if let Some(sheet_index) = self.get_sheet_index_by_name(&table.sheet_name) {
+                            return CalcResult::Number(sheet_index as f64 + 1.0);
+                        } else {
+                            break;
+                        }
                     }
                 }
             }
-            // Now let's see if it is a table
-            for (table_name, table) in &self.workbook.tables {
-                if table_name == name {
-                    if let Some(sheet_index) = self.get_sheet_index_by_name(&table.sheet_name) {
-                        return CalcResult::Number(sheet_index as f64 + 1.0);
-                    } else {
-                        break;
-                    }
+            Node::WrongVariableKind(name) => {
+                return CalcResult::Error {
+                    error: Error::NAME,
+                    origin: cell,
+                    message: format!("Name not found: {name}"),
+                }
+            }
+            arg => {
+                // Now it should be the name of a sheet
+                let sheet_name = match self.get_string(arg, cell) {
+                    Ok(s) => s,
+                    Err(e) => return e,
+                };
+                if let Some(sheet_index) = self.get_sheet_index_by_name(&sheet_name) {
+                    return CalcResult::Number(sheet_index as f64 + 1.0);
                 }
             }
-        }
-        // Now it should be the name of a sheet
-        let sheet_name = match self.get_string(arg, cell) {
-            Ok(s) => s,
-            Err(e) => return e,
-        };
-        if let Some(sheet_index) = self.get_sheet_index_by_name(&sheet_name) {
-            return CalcResult::Number(sheet_index as f64 + 1.0);
         }
         CalcResult::Error {
             error: Error::NA,

base/src/functions/logical.rs

@@ -7,6 +7,22 @@ use crate::{
 use super::util::compare_values;
 
 impl Model {
+    pub(crate) fn fn_true(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.is_empty() {
+            CalcResult::Boolean(true)
+        } else {
+            CalcResult::new_args_number_error(cell)
+        }
+    }
+
+    pub(crate) fn fn_false(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.is_empty() {
+            CalcResult::Boolean(false)
+        } else {
+            CalcResult::new_args_number_error(cell)
+        }
+    }
+
     pub(crate) fn fn_if(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 2 || args.len() == 3 {
             let cond_result = self.get_boolean(&args[0], cell);
@@ -66,88 +82,61 @@ impl Model {
     }
 
     pub(crate) fn fn_and(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let mut true_count = 0;
-        for arg in args {
-            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Boolean(b) => {
-                    if !b {
-                        return CalcResult::Boolean(false);
-                    }
-                    true_count += 1;
-                }
-                CalcResult::Number(value) => {
-                    if value == 0.0 {
-                        return CalcResult::Boolean(false);
-                    }
-                    true_count += 1;
-                }
-                CalcResult::String(_value) => {
-                    true_count += 1;
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        );
-                    }
-                    for row in left.row..(right.row + 1) {
-                        for column in left.column..(right.column + 1) {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Boolean(b) => {
-                                    if !b {
-                                        return CalcResult::Boolean(false);
-                                    }
-                                    true_count += 1;
-                                }
-                                CalcResult::Number(value) => {
-                                    if value == 0.0 {
-                                        return CalcResult::Boolean(false);
-                                    }
-                                    true_count += 1;
-                                }
-                                CalcResult::String(_value) => {
-                                    true_count += 1;
-                                }
-                                error @ CalcResult::Error { .. } => return error,
-                                CalcResult::Range { .. } => {}
-                                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
-                            }
-                        }
-                    }
-                }
-                error @ CalcResult::Error { .. } => return error,
-                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
-            };
-        }
-        if true_count == 0 {
-            return CalcResult::new_error(
-                Error::VALUE,
-                cell,
-                "Boolean values not found".to_string(),
-            );
-        }
-        CalcResult::Boolean(true)
+        self.logical_nary(
+            args,
+            cell,
+            |acc, value| acc.unwrap_or(true) && value,
+            Some(false),
+        )
     }
 
     pub(crate) fn fn_or(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let mut result = false;
+        self.logical_nary(
+            args,
+            cell,
+            |acc, value| acc.unwrap_or(false) || value,
+            Some(true),
+        )
+    }
+
+    pub(crate) fn fn_xor(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        self.logical_nary(args, cell, |acc, value| acc.unwrap_or(false) ^ value, None)
+    }
+
+    /// Base function for AND, OR, XOR. These are all n-ary functions that perform a boolean operation on a series of
+    /// boolean values. These boolean values are sourced from `args`. Note that there is not a 1-1 relationship between
+    /// arguments and boolean values evaluated (see how Ranges are handled for example).
+    ///
+    /// Each argument in `args` is evaluated and the resulting value is interpreted as a boolean as follows:
+    /// - Boolean: The value is used directly.
+    /// - Number: 0 is FALSE, all other values are TRUE.
+    /// - Range: Each cell in the range is evaluated as if they were individual arguments with some caveats
+    /// - Empty arg: FALSE
+    /// - Empty cell & String: Ignored, behaves exactly like the argument wasn't passed in at all
+    /// - Error: Propagated
+    ///
+    /// If no arguments are provided, or all arguments are ignored, the function returns a #VALUE! error
+    ///
+    /// **`fold_fn`:** The function that combines the running result with the next value boolean value. The running result
+    /// starts as `None`.
+    ///
+    /// **`short_circuit_value`:** If the running result reaches `short_circuit_value`, the function returns early.
+    fn logical_nary(
+        &mut self,
+        args: &[Node],
+        cell: CellReferenceIndex,
+        fold_fn: fn(Option<bool>, bool) -> bool,
+        short_circuit_value: Option<bool>,
+    ) -> CalcResult {
+        if args.is_empty() {
+            return CalcResult::new_args_number_error(cell);
+        }
+
+        let mut result = None;
         for arg in args {
             match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Boolean(value) => result = value || result,
-                CalcResult::Number(value) => {
-                    if value != 0.0 {
-                        return CalcResult::Boolean(true);
-                    }
-                }
-                CalcResult::String(_value) => {
-                    return CalcResult::Boolean(true);
-                }
+                CalcResult::Boolean(value) => result = Some(fold_fn(result, value)),
+                CalcResult::Number(value) => result = Some(fold_fn(result, value != 0.0)),
                 CalcResult::Range { left, right } => {
                     if left.sheet != right.sheet {
                         return CalcResult::new_error(
@@ -163,94 +152,72 @@ impl Model {
                                 row,
                                 column,
                             }) {
-                                CalcResult::Boolean(value) => {
-                                    result = value || result;
-                                }
+                                CalcResult::Boolean(value) => result = Some(fold_fn(result, value)),
                                 CalcResult::Number(value) => {
-                                    if value != 0.0 {
-                                        return CalcResult::Boolean(true);
-                                    }
-                                }
-                                CalcResult::String(_value) => {
-                                    return CalcResult::Boolean(true);
+                                    result = Some(fold_fn(result, value != 0.0))
                                 }
                                 error @ CalcResult::Error { .. } => return error,
-                                CalcResult::Range { .. } => {}
-                                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+                                CalcResult::EmptyArg => {} // unreachable
+                                CalcResult::Range { .. }
+                                | CalcResult::String { .. }
+                                | CalcResult::EmptyCell => {}
+                                CalcResult::Array(_) => {
+                                    return CalcResult::Error {
+                                        error: Error::NIMPL,
+                                        origin: cell,
+                                        message: "Arrays not supported yet".to_string(),
+                                    }
+                                }
+                            }
+                            if let (Some(current_result), Some(short_circuit_value)) =
+                                (result, short_circuit_value)
+                            {
+                                if current_result == short_circuit_value {
+                                    return CalcResult::Boolean(current_result);
+                                }
                             }
                         }
                     }
                 }
                 error @ CalcResult::Error { .. } => return error,
-                CalcResult::EmptyCell | CalcResult::EmptyArg => {}
-            };
-        }
-        CalcResult::Boolean(result)
-    }
-
-    /// XOR(logical1, [logical]*,...)
-    /// Logical1 is required, subsequent logical values are optional. Can be logical values, arrays, or references.
-    /// The result of XOR is TRUE when the number of TRUE inputs is odd and FALSE when the number of TRUE inputs is even.
-    pub(crate) fn fn_xor(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        let mut true_count = 0;
-        let mut false_count = 0;
-        for arg in args {
-            match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::Boolean(b) => {
-                    if b {
-                        true_count += 1;
-                    } else {
-                        false_count += 1;
-                    }
-                }
-                CalcResult::Number(value) => {
-                    if value != 0.0 {
-                        true_count += 1;
-                    } else {
-                        false_count += 1;
-                    }
-                }
-                CalcResult::Range { left, right } => {
-                    if left.sheet != right.sheet {
-                        return CalcResult::new_error(
-                            Error::VALUE,
-                            cell,
-                            "Ranges are in different sheets".to_string(),
-                        );
-                    }
-                    for row in left.row..(right.row + 1) {
-                        for column in left.column..(right.column + 1) {
-                            match self.evaluate_cell(CellReferenceIndex {
-                                sheet: left.sheet,
-                                row,
-                                column,
-                            }) {
-                                CalcResult::Boolean(b) => {
-                                    if b {
-                                        true_count += 1;
-                                    } else {
-                                        false_count += 1;
-                                    }
-                                }
-                                CalcResult::Number(value) => {
-                                    if value != 0.0 {
-                                        true_count += 1;
-                                    } else {
-                                        false_count += 1;
-                                    }
-                                }
-                                _ => {}
-                            }
+                CalcResult::EmptyArg => result = Some(result.unwrap_or(false)),
+                // Strings are ignored unless they are "TRUE" or "FALSE" (case insensitive). EXCEPT if the string value
+                // comes from a reference, in which case it is always ignored regardless of its value.
+                CalcResult::String(..) => {
+                    if !matches!(arg, Node::ReferenceKind { .. }) {
+                        if let Ok(f) = self.get_boolean(arg, cell) {
+                            result = Some(fold_fn(result, f));
                         }
                     }
                 }
-                _ => {}
-            };
+                // References to empty cells are ignored. If all args are ignored the result is #VALUE!
+                CalcResult::EmptyCell => {}
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
+            }
+
+            if let (Some(current_result), Some(short_circuit_value)) = (result, short_circuit_value)
+            {
+                if current_result == short_circuit_value {
+                    return CalcResult::Boolean(current_result);
+                }
+            }
         }
-        if true_count == 0 && false_count == 0 {
-            return CalcResult::new_error(Error::VALUE, cell, "No booleans found".to_string());
+
+        if let Some(result) = result {
+            CalcResult::Boolean(result)
+        } else {
+            CalcResult::new_error(
+                Error::VALUE,
+                cell,
+                "No logical values in argument list".to_string(),
+            )
         }
-        CalcResult::Boolean(true_count % 2 == 1)
     }
 
     /// =SWITCH(expression, case1, value1, [case, value]*, [default])
@@ -279,7 +246,7 @@ impl Model {
         }
         // None of the cases matched so we return the default
         // If there is an even number of args is the last one otherwise is #N/A
-        if args_count % 2 == 0 {
+        if args_count.is_multiple_of(2) {
             return self.evaluate_node_in_context(&args[args_count - 1], cell);
         }
         CalcResult::Error {
@@ -295,7 +262,7 @@ impl Model {
         if args_count < 2 {
             return CalcResult::new_args_number_error(cell);
         }
-        if args_count % 2 != 0 {
+        if !args_count.is_multiple_of(2) {
             // Missing value for last condition
             return CalcResult::new_args_number_error(cell);
         }

base/src/functions/lookup_and_reference.rs

@@ -838,4 +838,43 @@ impl Model {
         };
         CalcResult::Range { left, right }
     }
+
+    pub(crate) fn fn_formulatext(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() != 1 {
+            return CalcResult::new_args_number_error(cell);
+        }
+        if let CalcResult::Range { left, right } = self.evaluate_node_with_reference(&args[0], cell)
+        {
+            if left.sheet != right.sheet {
+                return CalcResult::Error {
+                    error: Error::ERROR,
+                    origin: cell,
+                    message: "3D ranges not supported".to_string(),
+                };
+            }
+            if left.row != right.row || left.column != right.column {
+                // FIXME: Implicit intersection or dynamic arrays
+                return CalcResult::Error {
+                    error: Error::NIMPL,
+                    origin: cell,
+                    message: "argument must be a reference to a single cell".to_string(),
+                };
+            }
+            if let Ok(Some(f)) = self.get_cell_formula(left.sheet, left.row, left.column) {
+                CalcResult::String(f)
+            } else {
+                CalcResult::Error {
+                    error: Error::NA,
+                    origin: cell,
+                    message: "Reference does not have a formula".to_string(),
+                }
+            }
+        } else {
+            CalcResult::Error {
+                error: Error::ERROR,
+                origin: cell,
+                message: "Argument must be a reference".to_string(),
+            }
+        }
+    }
 }

base/src/functions/macros.rs

@@ -0,0 +1,100 @@
+#[macro_export]
+macro_rules! single_number_fn {
+    // The macro takes:
+    //   1) A function name to define (e.g. fn_sin)
+    //   2) The operation to apply (e.g. f64::sin)
+    ($fn_name:ident, $op:expr) => {
+        pub(crate) fn $fn_name(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+            // 1) Check exactly one argument
+            if args.len() != 1 {
+                return CalcResult::new_args_number_error(cell);
+            }
+            // 2) Try to get a "NumberOrArray"
+            match self.get_number_or_array(&args[0], cell) {
+                // -----------------------------------------
+                // Case A: It's a single number
+                // -----------------------------------------
+                Ok(NumberOrArray::Number(f)) => match $op(f) {
+                    Ok(x) => CalcResult::Number(x),
+                    Err(Error::DIV) => CalcResult::Error {
+                        error: Error::DIV,
+                        origin: cell,
+                        message: "Divide by 0".to_string(),
+                    },
+                    Err(Error::VALUE) => CalcResult::Error {
+                        error: Error::VALUE,
+                        origin: cell,
+                        message: "Invalid number".to_string(),
+                    },
+                    Err(e) => CalcResult::Error {
+                        error: e,
+                        origin: cell,
+                        message: "Unknown error".to_string(),
+                    },
+                },
+
+                // -----------------------------------------
+                // Case B: It's an array, so apply $op
+                // element-by-element.
+                // -----------------------------------------
+                Ok(NumberOrArray::Array(a)) => {
+                    let mut array = Vec::new();
+                    for row in a {
+                        let mut data_row = Vec::with_capacity(row.len());
+                        for value in row {
+                            match value {
+                                // If Boolean, treat as 0.0 or 1.0
+                                ArrayNode::Boolean(b) => {
+                                    let n = if b { 1.0 } else { 0.0 };
+                                    match $op(n) {
+                                        Ok(x) => data_row.push(ArrayNode::Number(x)),
+                                        Err(Error::DIV) => {
+                                            data_row.push(ArrayNode::Error(Error::DIV))
+                                        }
+                                        Err(Error::VALUE) => {
+                                            data_row.push(ArrayNode::Error(Error::VALUE))
+                                        }
+                                        Err(e) => data_row.push(ArrayNode::Error(e)),
+                                    }
+                                }
+                                // If Number, apply directly
+                                ArrayNode::Number(n) => match $op(n) {
+                                    Ok(x) => data_row.push(ArrayNode::Number(x)),
+                                    Err(Error::DIV) => data_row.push(ArrayNode::Error(Error::DIV)),
+                                    Err(Error::VALUE) => {
+                                        data_row.push(ArrayNode::Error(Error::VALUE))
+                                    }
+                                    Err(e) => data_row.push(ArrayNode::Error(e)),
+                                },
+                                // If String, parse to f64 then apply or #VALUE! error
+                                ArrayNode::String(s) => {
+                                    let node = match s.parse::<f64>() {
+                                        Ok(f) => match $op(f) {
+                                            Ok(x) => ArrayNode::Number(x),
+                                            Err(Error::DIV) => ArrayNode::Error(Error::DIV),
+                                            Err(Error::VALUE) => ArrayNode::Error(Error::VALUE),
+                                            Err(e) => ArrayNode::Error(e),
+                                        },
+                                        Err(_) => ArrayNode::Error(Error::VALUE),
+                                    };
+                                    data_row.push(node);
+                                }
+                                // If Error, propagate the error
+                                e @ ArrayNode::Error(_) => {
+                                    data_row.push(e);
+                                }
+                            }
+                        }
+                        array.push(data_row);
+                    }
+                    CalcResult::Array(array)
+                }
+
+                // -----------------------------------------
+                // Case C: It's an Error => just return it
+                // -----------------------------------------
+                Err(err_result) => err_result,
+            }
+        }
+    };
+}

base/src/functions/mathematical.rs

@@ -1,5 +1,9 @@
+use crate::cast::NumberOrArray;
 use crate::constants::{LAST_COLUMN, LAST_ROW};
+use crate::expressions::parser::ArrayNode;
 use crate::expressions::types::CellReferenceIndex;
+use crate::number_format::to_precision;
+use crate::single_number_fn;
 use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
@@ -128,20 +132,28 @@ impl Model {
                     let column1 = left.column;
                     let mut column2 = right.column;
                     if row1 == 1 && row2 == LAST_ROW {
-                        row2 = self
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_row;
+                        row2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_row,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_column;
+                        column2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_column,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     for row in row1..row2 + 1 {
                         for column in column1..(column2 + 1) {
@@ -161,6 +173,27 @@ impl Model {
                         }
                     }
                 }
+                CalcResult::Array(array) => {
+                    for row in array {
+                        for value in row {
+                            match value {
+                                ArrayNode::Number(value) => {
+                                    result += value;
+                                }
+                                ArrayNode::Error(error) => {
+                                    return CalcResult::Error {
+                                        error,
+                                        origin: cell,
+                                        message: "Error in array".to_string(),
+                                    }
+                                }
+                                _ => {
+                                    // We ignore booleans and strings
+                                }
+                            }
+                        }
+                    }
+                }
                 error @ CalcResult::Error { .. } => return error,
                 _ => {
                     // We ignore booleans and strings
@@ -195,20 +228,28 @@ impl Model {
                     let column1 = left.column;
                     let mut column2 = right.column;
                     if row1 == 1 && row2 == LAST_ROW {
-                        row2 = self
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_row;
+                        row2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_row,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_column;
+                        column2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_column,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     for row in row1..row2 + 1 {
                         for column in column1..(column2 + 1) {
@@ -271,7 +312,7 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
+            Ok(f) => to_precision(f, 15),
             Err(s) => return s,
         };
         let number_of_digits = match self.get_number(&args[1], cell) {
@@ -287,12 +328,13 @@ impl Model {
         let scale = 10.0_f64.powf(number_of_digits);
         CalcResult::Number((value * scale).round() / scale)
     }
+
     pub(crate) fn fn_roundup(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 2 {
             return CalcResult::new_args_number_error(cell);
         }
         let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
+            Ok(f) => to_precision(f, 15),
             Err(s) => return s,
         };
         let number_of_digits = match self.get_number(&args[1], cell) {
@@ -312,12 +354,13 @@ impl Model {
             CalcResult::Number((value * scale).floor() / scale)
         }
     }
+
     pub(crate) fn fn_rounddown(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 2 {
             return CalcResult::new_args_number_error(cell);
         }
         let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
+            Ok(f) => to_precision(f, 15),
             Err(s) => return s,
         };
         let number_of_digits = match self.get_number(&args[1], cell) {
@@ -338,187 +381,39 @@ impl Model {
         }
     }
 
-    pub(crate) fn fn_sin(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        let result = value.sin();
-        CalcResult::Number(result)
-    }
-    pub(crate) fn fn_cos(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        let result = value.cos();
-        CalcResult::Number(result)
-    }
-
-    pub(crate) fn fn_tan(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        let result = value.tan();
-        CalcResult::Number(result)
-    }
-
-    pub(crate) fn fn_sinh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        let result = value.sinh();
-        CalcResult::Number(result)
-    }
-    pub(crate) fn fn_cosh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        let result = value.cosh();
-        CalcResult::Number(result)
-    }
-
-    pub(crate) fn fn_tanh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        let result = value.tanh();
-        CalcResult::Number(result)
-    }
-
-    pub(crate) fn fn_asin(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        let result = value.asin();
-        if result.is_nan() || result.is_infinite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid argument for ASIN".to_string(),
-            };
-        }
-        CalcResult::Number(result)
-    }
-    pub(crate) fn fn_acos(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        let result = value.acos();
-        if result.is_nan() || result.is_infinite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid argument for COS".to_string(),
-            };
-        }
-        CalcResult::Number(result)
-    }
-
-    pub(crate) fn fn_atan(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        let result = value.atan();
-        if result.is_nan() || result.is_infinite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid argument for ATAN".to_string(),
-            };
-        }
-        CalcResult::Number(result)
-    }
-
-    pub(crate) fn fn_asinh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        let result = value.asinh();
-        if result.is_nan() || result.is_infinite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid argument for ASINH".to_string(),
-            };
-        }
-        CalcResult::Number(result)
-    }
-    pub(crate) fn fn_acosh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        let result = value.acosh();
-        if result.is_nan() || result.is_infinite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid argument for ACOSH".to_string(),
-            };
-        }
-        CalcResult::Number(result)
-    }
-
-    pub(crate) fn fn_atanh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        let result = value.atanh();
-        if result.is_nan() || result.is_infinite() {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Invalid argument for ATANH".to_string(),
-            };
-        }
-        CalcResult::Number(result)
-    }
+    single_number_fn!(fn_log10, |f| if f <= 0.0 {
+        Err(Error::NUM)
+    } else {
+        Ok(f64::log10(f))
+    });
+    single_number_fn!(fn_ln, |f| if f <= 0.0 {
+        Err(Error::NUM)
+    } else {
+        Ok(f64::ln(f))
+    });
+    single_number_fn!(fn_sin, |f| Ok(f64::sin(f)));
+    single_number_fn!(fn_cos, |f| Ok(f64::cos(f)));
+    single_number_fn!(fn_tan, |f| Ok(f64::tan(f)));
+    single_number_fn!(fn_sinh, |f| Ok(f64::sinh(f)));
+    single_number_fn!(fn_cosh, |f| Ok(f64::cosh(f)));
+    single_number_fn!(fn_tanh, |f| Ok(f64::tanh(f)));
+    single_number_fn!(fn_asin, |f| Ok(f64::asin(f)));
+    single_number_fn!(fn_acos, |f| Ok(f64::acos(f)));
+    single_number_fn!(fn_atan, |f| Ok(f64::atan(f)));
+    single_number_fn!(fn_asinh, |f| Ok(f64::asinh(f)));
+    single_number_fn!(fn_acosh, |f| Ok(f64::acosh(f)));
+    single_number_fn!(fn_atanh, |f| Ok(f64::atanh(f)));
+    single_number_fn!(fn_abs, |f| Ok(f64::abs(f)));
+    single_number_fn!(fn_sqrt, |f| if f < 0.0 {
+        Err(Error::NUM)
+    } else {
+        Ok(f64::sqrt(f))
+    });
+    single_number_fn!(fn_sqrtpi, |f: f64| if f < 0.0 {
+        Err(Error::NUM)
+    } else {
+        Ok((f * PI).sqrt())
+    });
 
     pub(crate) fn fn_pi(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if !args.is_empty() {
@@ -527,53 +422,6 @@ impl Model {
         CalcResult::Number(PI)
     }
 
-    pub(crate) fn fn_abs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        CalcResult::Number(value.abs())
-    }
-
-    pub(crate) fn fn_sqrtpi(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        if value < 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Argument of SQRTPI should be >= 0".to_string(),
-            };
-        }
-        CalcResult::Number((value * PI).sqrt())
-    }
-
-    pub(crate) fn fn_sqrt(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
-        if args.len() != 1 {
-            return CalcResult::new_args_number_error(cell);
-        }
-        let value = match self.get_number(&args[0], cell) {
-            Ok(f) => f,
-            Err(s) => return s,
-        };
-        if value < 0.0 {
-            return CalcResult::Error {
-                error: Error::NUM,
-                origin: cell,
-                message: "Argument of SQRT should be >= 0".to_string(),
-            };
-        }
-        CalcResult::Number(value.sqrt())
-    }
-
     pub(crate) fn fn_atan2(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 2 {
             return CalcResult::new_args_number_error(cell);
@@ -596,6 +444,47 @@ impl Model {
         CalcResult::Number(f64::atan2(y, x))
     }
 
+    pub(crate) fn fn_log(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        let n_args = args.len();
+        if !(1..=2).contains(&n_args) {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let x = match self.get_number(&args[0], cell) {
+            Ok(f) => f,
+            Err(s) => return s,
+        };
+        let y = if n_args == 1 {
+            10.0
+        } else {
+            match self.get_number(&args[1], cell) {
+                Ok(f) => f,
+                Err(s) => return s,
+            }
+        };
+        if x <= 0.0 {
+            return CalcResult::Error {
+                error: Error::NUM,
+                origin: cell,
+                message: "Number must be positive".to_string(),
+            };
+        }
+        if y == 1.0 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "Logarithm base cannot be 1".to_string(),
+            };
+        }
+        if y <= 0.0 {
+            return CalcResult::Error {
+                error: Error::NUM,
+                origin: cell,
+                message: "Logarithm base must be positive".to_string(),
+            };
+        }
+        CalcResult::Number(f64::log(x, y))
+    }
+
     pub(crate) fn fn_power(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 2 {
             return CalcResult::new_args_number_error(cell);

base/src/functions/mod.rs

@@ -15,6 +15,7 @@ mod financial_util;
 mod information;
 mod logical;
 mod lookup_and_reference;
+mod macros;
 mod mathematical;
 mod statistical;
 mod subtotal;
@@ -53,6 +54,9 @@ pub enum Function {
     Columns,
     Cos,
     Cosh,
+    Log,
+    Log10,
+    Ln,
     Max,
     Min,
     Pi,
@@ -75,6 +79,7 @@ pub enum Function {
 
     // Information
     ErrorType,
+    Formulatext,
     Isblank,
     Iserr,
     Iserror,
@@ -122,6 +127,7 @@ pub enum Function {
     Textbefore,
     Textjoin,
     Trim,
+    Unicode,
     Upper,
     Value,
     Valuetotext,
@@ -138,6 +144,7 @@ pub enum Function {
     Countifs,
     Maxifs,
     Minifs,
+    Geomean,
 
     // Date and time
     Date,
@@ -246,7 +253,7 @@ pub enum Function {
 }
 
 impl Function {
-    pub fn into_iter() -> IntoIter<Function, 192> {
+    pub fn into_iter() -> IntoIter<Function, 198> {
         [
             Function::And,
             Function::False,
@@ -273,6 +280,9 @@ impl Function {
             Function::Atanh,
             Function::Abs,
             Function::Pi,
+            Function::Ln,
+            Function::Log,
+            Function::Log10,
             Function::Sqrt,
             Function::Sqrtpi,
             Function::Atan2,
@@ -316,6 +326,7 @@ impl Function {
             Function::Search,
             Function::Text,
             Function::Trim,
+            Function::Unicode,
             Function::Upper,
             Function::Isnumber,
             Function::Isnontext,
@@ -330,6 +341,7 @@ impl Function {
             Function::Isodd,
             Function::Iseven,
             Function::ErrorType,
+            Function::Formulatext,
             Function::Isformula,
             Function::Type,
             Function::Sheet,
@@ -344,6 +356,7 @@ impl Function {
             Function::Countifs,
             Function::Maxifs,
             Function::Minifs,
+            Function::Geomean,
             Function::Year,
             Function::Day,
             Function::Month,
@@ -460,6 +473,7 @@ impl Function {
             Function::Textbefore => "_xlfn.TEXTBEFORE".to_string(),
             Function::Textafter => "_xlfn.TEXTAFTER".to_string(),
             Function::Textjoin => "_xlfn.TEXTJOIN".to_string(),
+            Function::Unicode => "_xlfn.UNICODE".to_string(),
             Function::Rri => "_xlfn.RRI".to_string(),
             Function::Pduration => "_xlfn.PDURATION".to_string(),
             Function::Bitand => "_xlfn.BITAND".to_string(),
@@ -479,6 +493,7 @@ impl Function {
             Function::Valuetotext => "_xlfn.VALUETOTEXT".to_string(),
             Function::Isformula => "_xlfn.ISFORMULA".to_string(),
             Function::Sheet => "_xlfn.SHEET".to_string(),
+            Function::Formulatext => "_xlfn.FORMULATEXT".to_string(),
             _ => self.to_string(),
         }
     }
@@ -525,6 +540,10 @@ impl Function {
             "POWER" => Some(Function::Power),
             "ATAN2" => Some(Function::Atan2),
 
+            "LN" => Some(Function::Ln),
+            "LOG" => Some(Function::Log),
+            "LOG10" => Some(Function::Log10),
+
             "MAX" => Some(Function::Max),
             "MIN" => Some(Function::Min),
             "PRODUCT" => Some(Function::Product),
@@ -567,6 +586,7 @@ impl Function {
             "SEARCH" => Some(Function::Search),
             "TEXT" => Some(Function::Text),
             "TRIM" => Some(Function::Trim),
+            "UNICODE" | "_XLFN.UNICODE" => Some(Function::Unicode),
             "UPPER" => Some(Function::Upper),
 
             "REPT" => Some(Function::Rept),
@@ -588,6 +608,7 @@ impl Function {
             "ISODD" => Some(Function::Isodd),
             "ISEVEN" => Some(Function::Iseven),
             "ERROR.TYPE" => Some(Function::ErrorType),
+            "FORMULATEXT" | "_XLFN.FORMULATEXT" => Some(Function::Formulatext),
             "ISFORMULA" | "_XLFN.ISFORMULA" => Some(Function::Isformula),
             "TYPE" => Some(Function::Type),
             "SHEET" | "_XLFN.SHEET" => Some(Function::Sheet),
@@ -603,6 +624,7 @@ impl Function {
             "COUNTIFS" => Some(Function::Countifs),
             "MAXIFS" | "_XLFN.MAXIFS" => Some(Function::Maxifs),
             "MINIFS" | "_XLFN.MINIFS" => Some(Function::Minifs),
+            "GEOMEAN" => Some(Function::Geomean),
             // Date and Time
             "YEAR" => Some(Function::Year),
             "DAY" => Some(Function::Day),
@@ -722,6 +744,9 @@ impl fmt::Display for Function {
             Function::Switch => write!(f, "SWITCH"),
             Function::True => write!(f, "TRUE"),
             Function::Xor => write!(f, "XOR"),
+            Function::Log => write!(f, "LOG"),
+            Function::Log10 => write!(f, "LOG10"),
+            Function::Ln => write!(f, "LN"),
             Function::Sin => write!(f, "SIN"),
             Function::Cos => write!(f, "COS"),
             Function::Tan => write!(f, "TAN"),
@@ -779,6 +804,7 @@ impl fmt::Display for Function {
             Function::Search => write!(f, "SEARCH"),
             Function::Text => write!(f, "TEXT"),
             Function::Trim => write!(f, "TRIM"),
+            Function::Unicode => write!(f, "UNICODE"),
             Function::Upper => write!(f, "UPPER"),
             Function::Isnumber => write!(f, "ISNUMBER"),
             Function::Isnontext => write!(f, "ISNONTEXT"),
@@ -793,6 +819,7 @@ impl fmt::Display for Function {
             Function::Isodd => write!(f, "ISODD"),
             Function::Iseven => write!(f, "ISEVEN"),
             Function::ErrorType => write!(f, "ERROR.TYPE"),
+            Function::Formulatext => write!(f, "FORMULATEXT"),
             Function::Isformula => write!(f, "ISFORMULA"),
             Function::Type => write!(f, "TYPE"),
             Function::Sheet => write!(f, "SHEET"),
@@ -808,6 +835,7 @@ impl fmt::Display for Function {
             Function::Countifs => write!(f, "COUNTIFS"),
             Function::Maxifs => write!(f, "MAXIFS"),
             Function::Minifs => write!(f, "MINIFS"),
+            Function::Geomean => write!(f, "GEOMEAN"),
             Function::Year => write!(f, "YEAR"),
             Function::Day => write!(f, "DAY"),
             Function::Month => write!(f, "MONTH"),
@@ -935,7 +963,7 @@ impl Model {
         match kind {
             // Logical
             Function::And => self.fn_and(args, cell),
-            Function::False => CalcResult::Boolean(false),
+            Function::False => self.fn_false(args, cell),
             Function::If => self.fn_if(args, cell),
             Function::Iferror => self.fn_iferror(args, cell),
             Function::Ifna => self.fn_ifna(args, cell),
@@ -943,9 +971,12 @@ impl Model {
             Function::Not => self.fn_not(args, cell),
             Function::Or => self.fn_or(args, cell),
             Function::Switch => self.fn_switch(args, cell),
-            Function::True => CalcResult::Boolean(true),
+            Function::True => self.fn_true(args, cell),
             Function::Xor => self.fn_xor(args, cell),
             // Math and trigonometry
+            Function::Log => self.fn_log(args, cell),
+            Function::Log10 => self.fn_log10(args, cell),
+            Function::Ln => self.fn_ln(args, cell),
             Function::Sin => self.fn_sin(args, cell),
             Function::Cos => self.fn_cos(args, cell),
             Function::Tan => self.fn_tan(args, cell),
@@ -1012,6 +1043,7 @@ impl Model {
             Function::Search => self.fn_search(args, cell),
             Function::Text => self.fn_text(args, cell),
             Function::Trim => self.fn_trim(args, cell),
+            Function::Unicode => self.fn_unicode(args, cell),
             Function::Upper => self.fn_upper(args, cell),
             // Information
             Function::Isnumber => self.fn_isnumber(args, cell),
@@ -1027,6 +1059,7 @@ impl Model {
             Function::Isodd => self.fn_isodd(args, cell),
             Function::Iseven => self.fn_iseven(args, cell),
             Function::ErrorType => self.fn_errortype(args, cell),
+            Function::Formulatext => self.fn_formulatext(args, cell),
             Function::Isformula => self.fn_isformula(args, cell),
             Function::Type => self.fn_type(args, cell),
             Function::Sheet => self.fn_sheet(args, cell),
@@ -1042,6 +1075,7 @@ impl Model {
             Function::Countifs => self.fn_countifs(args, cell),
             Function::Maxifs => self.fn_maxifs(args, cell),
             Function::Minifs => self.fn_minifs(args, cell),
+            Function::Geomean => self.fn_geomean(args, cell),
             // Date and Time
             Function::Year => self.fn_year(args, cell),
             Function::Day => self.fn_day(args, cell),
@@ -1148,6 +1182,7 @@ impl Model {
 
 #[cfg(test)]
 mod tests {
+    #![allow(clippy::unwrap_used)]
     use std::{
         fs::File,
         io::{BufRead, BufReader},
@@ -1195,7 +1230,7 @@ mod tests {
         }
         // We make a list with their functions names, but we escape ".": ERROR.TYPE => ERRORTYPE
         let iter_list = Function::into_iter()
-            .map(|f| format!("{}", f).replace('.', ""))
+            .map(|f| format!("{f}").replace('.', ""))
             .collect::<Vec<_>>();
 
         let len = iter_list.len();

base/src/functions/statistical.rs

@@ -134,6 +134,13 @@ impl Model {
                                     );
                                 }
                                 CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+                                CalcResult::Array(_) => {
+                                    return CalcResult::Error {
+                                        error: Error::NIMPL,
+                                        origin: cell,
+                                        message: "Arrays not supported yet".to_string(),
+                                    }
+                                }
                             }
                         }
                     }
@@ -165,6 +172,13 @@ impl Model {
                 }
                 error @ CalcResult::Error { .. } => return error,
                 CalcResult::EmptyCell | CalcResult::EmptyArg => {}
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             };
         }
         if count == 0.0 {
@@ -336,7 +350,7 @@ impl Model {
     // FIXME: This function shares a lot of code with apply_ifs. Can we merge them?
     pub(crate) fn fn_countifs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         let args_count = args.len();
-        if args_count < 2 || args_count % 2 == 1 {
+        if args_count < 2 || !args_count.is_multiple_of(2) {
             return CalcResult::new_args_number_error(cell);
         }
 
@@ -381,11 +395,16 @@ impl Model {
         let right_row = first_range.right.row;
         let right_column = first_range.right.column;
 
-        let dimension = self
-            .workbook
-            .worksheet(first_range.left.sheet)
-            .expect("Sheet expected during evaluation.")
-            .dimension();
+        let dimension = match self.workbook.worksheet(first_range.left.sheet) {
+            Ok(s) => s.dimension(),
+            Err(_) => {
+                return CalcResult::new_error(
+                    Error::ERROR,
+                    cell,
+                    format!("Invalid worksheet index: '{}'", first_range.left.sheet),
+                )
+            }
+        };
         let max_row = dimension.max_row;
         let max_column = dimension.max_column;
 
@@ -457,7 +476,7 @@ impl Model {
         F: FnMut(f64),
     {
         let args_count = args.len();
-        if args_count < 3 || args_count % 2 == 0 {
+        if args_count < 3 || args_count.is_multiple_of(2) {
             return Err(CalcResult::new_args_number_error(cell));
         }
         let arg_0 = self.evaluate_node_in_context(&args[0], cell);
@@ -526,20 +545,28 @@ impl Model {
         let mut right_column = sum_range.right.column;
 
         if left_row == 1 && right_row == LAST_ROW {
-            right_row = self
-                .workbook
-                .worksheet(sum_range.left.sheet)
-                .expect("Sheet expected during evaluation.")
-                .dimension()
-                .max_row;
+            right_row = match self.workbook.worksheet(sum_range.left.sheet) {
+                Ok(s) => s.dimension().max_row,
+                Err(_) => {
+                    return Err(CalcResult::new_error(
+                        Error::ERROR,
+                        cell,
+                        format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
+                    ));
+                }
+            };
         }
         if left_column == 1 && right_column == LAST_COLUMN {
-            right_column = self
-                .workbook
-                .worksheet(sum_range.left.sheet)
-                .expect("Sheet expected during evaluation.")
-                .dimension()
-                .max_column;
+            right_column = match self.workbook.worksheet(sum_range.left.sheet) {
+                Ok(s) => s.dimension().max_column,
+                Err(_) => {
+                    return Err(CalcResult::new_error(
+                        Error::ERROR,
+                        cell,
+                        format!("Invalid worksheet index: '{}'", sum_range.left.sheet),
+                    ));
+                }
+            };
         }
 
         for row in left_row..right_row + 1 {
@@ -622,4 +649,85 @@ impl Model {
         }
         CalcResult::Number(max)
     }
+
+    pub(crate) fn fn_geomean(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.is_empty() {
+            return CalcResult::new_args_number_error(cell);
+        }
+        let mut count = 0.0;
+        let mut product = 1.0;
+        for arg in args {
+            match self.evaluate_node_in_context(arg, cell) {
+                CalcResult::Number(value) => {
+                    count += 1.0;
+                    product *= value;
+                }
+                CalcResult::Boolean(b) => {
+                    if let Node::ReferenceKind { .. } = arg {
+                    } else {
+                        product *= if b { 1.0 } else { 0.0 };
+                        count += 1.0;
+                    }
+                }
+                CalcResult::Range { left, right } => {
+                    if left.sheet != right.sheet {
+                        return CalcResult::new_error(
+                            Error::VALUE,
+                            cell,
+                            "Ranges are in different sheets".to_string(),
+                        );
+                    }
+                    for row in left.row..(right.row + 1) {
+                        for column in left.column..(right.column + 1) {
+                            match self.evaluate_cell(CellReferenceIndex {
+                                sheet: left.sheet,
+                                row,
+                                column,
+                            }) {
+                                CalcResult::Number(value) => {
+                                    count += 1.0;
+                                    product *= value;
+                                }
+                                error @ CalcResult::Error { .. } => return error,
+                                CalcResult::Range { .. } => {
+                                    return CalcResult::new_error(
+                                        Error::ERROR,
+                                        cell,
+                                        "Unexpected Range".to_string(),
+                                    );
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                }
+                error @ CalcResult::Error { .. } => return error,
+                CalcResult::String(s) => {
+                    if let Node::ReferenceKind { .. } = arg {
+                        // Do nothing
+                    } else if let Ok(t) = s.parse::<f64>() {
+                        product *= t;
+                        count += 1.0;
+                    } else {
+                        return CalcResult::Error {
+                            error: Error::VALUE,
+                            origin: cell,
+                            message: "Argument cannot be cast into number".to_string(),
+                        };
+                    }
+                }
+                _ => {
+                    // Ignore everything else
+                }
+            };
+        }
+        if count == 0.0 {
+            return CalcResult::Error {
+                error: Error::DIV,
+                origin: cell,
+                message: "Division by Zero".to_string(),
+            };
+        }
+        CalcResult::Number(product.powf(1.0 / count))
+    }
 }

base/src/functions/subtotal.rs

@@ -53,8 +53,13 @@ impl Model {
         false
     }
 
-    fn cell_hidden_status(&self, sheet_index: u32, row: i32, column: i32) -> CellTableStatus {
-        let worksheet = self.workbook.worksheet(sheet_index).expect("");
+    fn cell_hidden_status(
+        &self,
+        sheet_index: u32,
+        row: i32,
+        column: i32,
+    ) -> Result<CellTableStatus, String> {
+        let worksheet = self.workbook.worksheet(sheet_index)?;
         let mut hidden = false;
         for row_style in &worksheet.rows {
             if row_style.r == row {
@@ -63,13 +68,13 @@ impl Model {
             }
         }
         if !hidden {
-            return CellTableStatus::Normal;
+            return Ok(CellTableStatus::Normal);
         }
         // The row is hidden we need to know if the table has filters
         if self.get_table_for_cell(sheet_index, row, column) {
-            CellTableStatus::Filtered
+            Ok(CellTableStatus::Filtered)
         } else {
-            CellTableStatus::Hidden
+            Ok(CellTableStatus::Hidden)
         }
     }
 
@@ -91,7 +96,7 @@ impl Model {
 
         match cell.get_formula() {
             Some(f) => {
-                let node = &self.parsed_formulas[sheet_index as usize][f as usize];
+                let node = &self.parsed_formulas[sheet_index as usize][f as usize].0;
                 matches!(
                     node,
                     Node::FunctionKind {
@@ -143,7 +148,11 @@ impl Model {
                             let column2 = right.column;
 
                             for row in row1..=row2 {
-                                let cell_status = self.cell_hidden_status(left.sheet, row, column1);
+                                let cell_status = self
+                                    .cell_hidden_status(left.sheet, row, column1)
+                                    .map_err(|message| {
+                                        CalcResult::new_error(Error::ERROR, cell, message)
+                                    })?;
                                 if cell_status == CellTableStatus::Filtered {
                                     continue;
                                 }
@@ -173,6 +182,13 @@ impl Model {
                             }
                         }
                         CalcResult::EmptyCell | CalcResult::EmptyArg => result.push(0.0),
+                        CalcResult::Array(_) => {
+                            return Err(CalcResult::Error {
+                                error: Error::NIMPL,
+                                origin: cell,
+                                message: "Arrays not supported yet".to_string(),
+                            })
+                        }
                     }
                 }
             }
@@ -380,7 +396,14 @@ impl Model {
                             let column2 = right.column;
 
                             for row in row1..=row2 {
-                                let cell_status = self.cell_hidden_status(left.sheet, row, column1);
+                                let cell_status = match self
+                                    .cell_hidden_status(left.sheet, row, column1)
+                                {
+                                    Ok(s) => s,
+                                    Err(message) => {
+                                        return CalcResult::new_error(Error::ERROR, cell, message);
+                                    }
+                                };
                                 if cell_status == CellTableStatus::Filtered {
                                     continue;
                                 }
@@ -410,6 +433,13 @@ impl Model {
                         | CalcResult::Number(_)
                         | CalcResult::Boolean(_)
                         | CalcResult::Error { .. } => counta += 1,
+                        CalcResult::Array(_) => {
+                            return CalcResult::Error {
+                                error: Error::NIMPL,
+                                origin: cell,
+                                message: "Arrays not supported yet".to_string(),
+                            }
+                        }
                     }
                 }
             }
@@ -449,7 +479,14 @@ impl Model {
                             let column2 = right.column;
 
                             for row in row1..=row2 {
-                                let cell_status = self.cell_hidden_status(left.sheet, row, column1);
+                                let cell_status = match self
+                                    .cell_hidden_status(left.sheet, row, column1)
+                                {
+                                    Ok(s) => s,
+                                    Err(message) => {
+                                        return CalcResult::new_error(Error::ERROR, cell, message);
+                                    }
+                                };
                                 if cell_status == CellTableStatus::Filtered {
                                     continue;
                                 }

base/src/functions/text.rs

@@ -55,14 +55,14 @@ impl Model {
         let mut result = "".to_string();
         for arg in args {
             match self.evaluate_node_in_context(arg, cell) {
-                CalcResult::String(value) => result = format!("{}{}", result, value),
-                CalcResult::Number(value) => result = format!("{}{}", result, value),
+                CalcResult::String(value) => result = format!("{result}{value}"),
+                CalcResult::Number(value) => result = format!("{result}{value}"),
                 CalcResult::EmptyCell | CalcResult::EmptyArg => {}
                 CalcResult::Boolean(value) => {
                     if value {
-                        result = format!("{}TRUE", result);
+                        result = format!("{result}TRUE");
                     } else {
-                        result = format!("{}FALSE", result);
+                        result = format!("{result}FALSE");
                     }
                 }
                 error @ CalcResult::Error { .. } => return error,
@@ -82,25 +82,37 @@ impl Model {
                                 column,
                             }) {
                                 CalcResult::String(value) => {
-                                    result = format!("{}{}", result, value);
-                                }
-                                CalcResult::Number(value) => {
-                                    result = format!("{}{}", result, value)
+                                    result = format!("{result}{value}");
                                 }
+                                CalcResult::Number(value) => result = format!("{result}{value}"),
                                 CalcResult::Boolean(value) => {
                                     if value {
-                                        result = format!("{}TRUE", result);
+                                        result = format!("{result}TRUE");
                                     } else {
-                                        result = format!("{}FALSE", result);
+                                        result = format!("{result}FALSE");
                                     }
                                 }
                                 error @ CalcResult::Error { .. } => return error,
                                 CalcResult::EmptyCell | CalcResult::EmptyArg => {}
                                 CalcResult::Range { .. } => {}
+                                CalcResult::Array(_) => {
+                                    return CalcResult::Error {
+                                        error: Error::NIMPL,
+                                        origin: cell,
+                                        message: "Arrays not supported yet".to_string(),
+                                    }
+                                }
                             }
                         }
                     }
                 }
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             };
         }
         CalcResult::String(result)
@@ -125,6 +137,13 @@ impl Model {
                     };
                 }
                 CalcResult::EmptyCell | CalcResult::EmptyArg => 0.0,
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             };
             let format_code = match self.get_string(&args[1], cell) {
                 Ok(s) => s,
@@ -151,7 +170,7 @@ impl Model {
     ///  * If find_text does not appear in within_text, FIND and FINDB return the #VALUE! error value.
     ///  * If start_num is not greater than zero, FIND and FINDB return the #VALUE! error value.
     ///  * If start_num is greater than the length of within_text, FIND and FINDB return the #VALUE! error value.
-    /// NB: FINDB is not implemented. It is the same as FIND function unless locale is a DBCS (Double Byte Character Set)
+    ///    NB: FINDB is not implemented. It is the same as FIND function unless locale is a DBCS (Double Byte Character Set)
     pub(crate) fn fn_find(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() < 2 || args.len() > 3 {
             return CalcResult::new_args_number_error(cell);
@@ -203,7 +222,7 @@ impl Model {
     /// Same API as FIND but:
     ///  * Allows wildcards
     ///  * It is case insensitive
-    /// SEARCH(find_text, within_text, [start_num])
+    ///    SEARCH(find_text, within_text, [start_num])
     pub(crate) fn fn_search(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() < 2 || args.len() > 3 {
             return CalcResult::new_args_number_error(cell);
@@ -261,7 +280,7 @@ impl Model {
     pub(crate) fn fn_len(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 1 {
             let s = match self.evaluate_node_in_context(&args[0], cell) {
-                CalcResult::Number(v) => format!("{}", v),
+                CalcResult::Number(v) => format!("{v}"),
                 CalcResult::String(v) => v,
                 CalcResult::Boolean(b) => {
                     if b {
@@ -280,6 +299,13 @@ impl Model {
                     };
                 }
                 CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             };
             return CalcResult::Number(s.chars().count() as f64);
         }
@@ -289,7 +315,7 @@ impl Model {
     pub(crate) fn fn_trim(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 1 {
             let s = match self.evaluate_node_in_context(&args[0], cell) {
-                CalcResult::Number(v) => format!("{}", v),
+                CalcResult::Number(v) => format!("{v}"),
                 CalcResult::String(v) => v,
                 CalcResult::Boolean(b) => {
                     if b {
@@ -308,6 +334,13 @@ impl Model {
                     };
                 }
                 CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             };
             return CalcResult::String(s.trim().to_owned());
         }
@@ -317,7 +350,7 @@ impl Model {
     pub(crate) fn fn_lower(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 1 {
             let s = match self.evaluate_node_in_context(&args[0], cell) {
-                CalcResult::Number(v) => format!("{}", v),
+                CalcResult::Number(v) => format!("{v}"),
                 CalcResult::String(v) => v,
                 CalcResult::Boolean(b) => {
                     if b {
@@ -336,16 +369,77 @@ impl Model {
                     };
                 }
                 CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             };
             return CalcResult::String(s.to_lowercase());
         }
         CalcResult::new_args_number_error(cell)
     }
 
+    pub(crate) fn fn_unicode(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
+        if args.len() == 1 {
+            let s = match self.evaluate_node_in_context(&args[0], cell) {
+                CalcResult::Number(v) => format!("{v}"),
+                CalcResult::String(v) => v,
+                CalcResult::Boolean(b) => {
+                    if b {
+                        "TRUE".to_string()
+                    } else {
+                        "FALSE".to_string()
+                    }
+                }
+                error @ CalcResult::Error { .. } => return error,
+                CalcResult::Range { .. } => {
+                    // Implicit Intersection not implemented
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Implicit Intersection not implemented".to_string(),
+                    };
+                }
+                CalcResult::EmptyCell | CalcResult::EmptyArg => {
+                    return CalcResult::Error {
+                        error: Error::VALUE,
+                        origin: cell,
+                        message: "Empty cell".to_string(),
+                    }
+                }
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
+            };
+
+            match s.chars().next() {
+                Some(c) => {
+                    let unicode_number = c as u32;
+                    return CalcResult::Number(unicode_number as f64);
+                }
+                None => {
+                    return CalcResult::Error {
+                        error: Error::VALUE,
+                        origin: cell,
+                        message: "Empty cell".to_string(),
+                    };
+                }
+            }
+        }
+        CalcResult::new_args_number_error(cell)
+    }
+
     pub(crate) fn fn_upper(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 1 {
             let s = match self.evaluate_node_in_context(&args[0], cell) {
-                CalcResult::Number(v) => format!("{}", v),
+                CalcResult::Number(v) => format!("{v}"),
                 CalcResult::String(v) => v,
                 CalcResult::Boolean(b) => {
                     if b {
@@ -364,6 +458,13 @@ impl Model {
                     };
                 }
                 CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             };
             return CalcResult::String(s.to_uppercase());
         }
@@ -375,7 +476,7 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let s = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Number(v) => format!("{}", v),
+            CalcResult::Number(v) => format!("{v}"),
             CalcResult::String(v) => v,
             CalcResult::Boolean(b) => {
                 if b {
@@ -394,6 +495,13 @@ impl Model {
                 };
             }
             CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+            CalcResult::Array(_) => {
+                return CalcResult::Error {
+                    error: Error::NIMPL,
+                    origin: cell,
+                    message: "Arrays not supported yet".to_string(),
+                }
+            }
         };
         let num_chars = if args.len() == 2 {
             match self.evaluate_node_in_context(&args[1], cell) {
@@ -424,6 +532,13 @@ impl Model {
                     };
                 }
                 CalcResult::EmptyCell | CalcResult::EmptyArg => 0,
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             }
         } else {
             1
@@ -443,7 +558,7 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let s = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Number(v) => format!("{}", v),
+            CalcResult::Number(v) => format!("{v}"),
             CalcResult::String(v) => v,
             CalcResult::Boolean(b) => {
                 if b {
@@ -462,6 +577,13 @@ impl Model {
                 };
             }
             CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+            CalcResult::Array(_) => {
+                return CalcResult::Error {
+                    error: Error::NIMPL,
+                    origin: cell,
+                    message: "Arrays not supported yet".to_string(),
+                }
+            }
         };
         let num_chars = if args.len() == 2 {
             match self.evaluate_node_in_context(&args[1], cell) {
@@ -492,6 +614,13 @@ impl Model {
                     };
                 }
                 CalcResult::EmptyCell | CalcResult::EmptyArg => 0,
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             }
         } else {
             1
@@ -503,7 +632,7 @@ impl Model {
             }
             result.push(ch);
         }
-        return CalcResult::String(result.chars().rev().collect::<String>());
+        CalcResult::String(result.chars().rev().collect::<String>())
     }
 
     pub(crate) fn fn_mid(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
@@ -511,7 +640,7 @@ impl Model {
             return CalcResult::new_args_number_error(cell);
         }
         let s = match self.evaluate_node_in_context(&args[0], cell) {
-            CalcResult::Number(v) => format!("{}", v),
+            CalcResult::Number(v) => format!("{v}"),
             CalcResult::String(v) => v,
             CalcResult::Boolean(b) => {
                 if b {
@@ -530,6 +659,13 @@ impl Model {
                 };
             }
             CalcResult::EmptyCell | CalcResult::EmptyArg => "".to_string(),
+            CalcResult::Array(_) => {
+                return CalcResult::Error {
+                    error: Error::NIMPL,
+                    origin: cell,
+                    message: "Arrays not supported yet".to_string(),
+                }
+            }
         };
         let start_num = match self.evaluate_node_in_context(&args[1], cell) {
             CalcResult::Number(v) => {
@@ -594,6 +730,13 @@ impl Model {
                 };
             }
             CalcResult::EmptyCell | CalcResult::EmptyArg => 0,
+            CalcResult::Array(_) => {
+                return CalcResult::Error {
+                    error: Error::NIMPL,
+                    origin: cell,
+                    message: "Arrays not supported yet".to_string(),
+                }
+            }
         };
         let mut result = "".to_string();
         let mut count: usize = 0;
@@ -888,20 +1031,28 @@ impl Model {
                     let column1 = left.column;
                     let mut column2 = right.column;
                     if row1 == 1 && row2 == LAST_ROW {
-                        row2 = self
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_row;
+                        row2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_row,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     if column1 == 1 && column2 == LAST_COLUMN {
-                        column2 = self
-                            .workbook
-                            .worksheet(left.sheet)
-                            .expect("Sheet expected during evaluation.")
-                            .dimension()
-                            .max_column;
+                        column2 = match self.workbook.worksheet(left.sheet) {
+                            Ok(s) => s.dimension().max_column,
+                            Err(_) => {
+                                return CalcResult::new_error(
+                                    Error::ERROR,
+                                    cell,
+                                    format!("Invalid worksheet index: '{}'", left.sheet),
+                                );
+                            }
+                        };
                     }
                     for row in row1..row2 + 1 {
                         for column in column1..(column2 + 1) {
@@ -928,6 +1079,13 @@ impl Model {
                                 }
                                 error @ CalcResult::Error { .. } => return error,
                                 CalcResult::EmptyArg | CalcResult::Range { .. } => {}
+                                CalcResult::Array(_) => {
+                                    return CalcResult::Error {
+                                        error: Error::NIMPL,
+                                        origin: cell,
+                                        message: "Arrays not supported yet".to_string(),
+                                    }
+                                }
                             }
                         }
                     }
@@ -947,6 +1105,13 @@ impl Model {
                     }
                 }
                 CalcResult::EmptyArg => {}
+                CalcResult::Array(_) => {
+                    return CalcResult::Error {
+                        error: Error::NIMPL,
+                        origin: cell,
+                        message: "Arrays not supported yet".to_string(),
+                    }
+                }
             };
         }
         let result = values.join(&delimiter);
@@ -1070,6 +1235,11 @@ impl Model {
                 }
             }
             CalcResult::EmptyCell | CalcResult::EmptyArg => CalcResult::Number(0.0),
+            CalcResult::Array(_) => CalcResult::Error {
+                error: Error::NIMPL,
+                origin: cell,
+                message: "Arrays not supported yet".to_string(),
+            },
         }
     }
 

base/src/functions/util.rs

@@ -1,4 +1,5 @@
-use regex::{escape, Regex};
+#[cfg(feature = "use_regex_lite")]
+use regex_lite as regex;
 
 use crate::{calc_result::CalcResult, expressions::token::is_english_error_string};
 
@@ -25,9 +26,9 @@ pub(crate) fn values_are_equal(left: &CalcResult, right: &CalcResult) -> bool {
     }
 }
 
-/// In Excel there are two ways of comparing cell values.
-/// The old school comparison valid in formulas like D3 < D4 or HLOOKUP,... cast empty cells into empty strings or 0
-/// For the new formulas like XLOOKUP or SORT an empty cell is always larger than anything else.
+// In Excel there are two ways of comparing cell values.
+// The old school comparison valid in formulas like D3 < D4 or HLOOKUP,... cast empty cells into empty strings or 0
+// For the new formulas like XLOOKUP or SORT an empty cell is always larger than anything else.
 
 // ..., -2, -1, 0, 1, 2, ..., A-Z, FALSE, TRUE;
 pub(crate) fn compare_values(left: &CalcResult, right: &CalcResult) -> i32 {
@@ -86,7 +87,7 @@ pub(crate) fn from_wildcard_to_regex(
     exact: bool,
 ) -> Result<regex::Regex, regex::Error> {
     // 1. Escape all
-    let reg = &escape(wildcard);
+    let reg = &regex::escape(wildcard);
 
     // 2. We convert the escaped '?' into '.' (matches a single character)
     let reg = &reg.replace("\\?", ".");
@@ -109,13 +110,13 @@ pub(crate) fn from_wildcard_to_regex(
 
     // And we have a valid Perl regex! (As Kim Kardashian said before me: "I know, right?")
     if exact {
-        return Regex::new(&format!("^{}$", reg));
+        return regex::Regex::new(&format!("^{reg}$"));
     }
-    Regex::new(reg)
+    regex::Regex::new(reg)
 }
 
-/// NUMBERS ///
-///*********///
+// NUMBERS ///
+//*********///
 
 // It could be either the number or a string representation of the number
 // In the rest of the cases calc_result needs to be a number (cannot be the string "23", for instance)
@@ -180,8 +181,8 @@ fn result_is_not_equal_to_number(calc_result: &CalcResult, target: f64) -> bool
     }
 }
 
-/// BOOLEANS ///
-///**********///
+// BOOLEANS ///
+//**********///
 
 // Booleans have to be "exactly" equal
 fn result_is_equal_to_bool(calc_result: &CalcResult, target: bool) -> bool {
@@ -198,12 +199,12 @@ fn result_is_not_equal_to_bool(calc_result: &CalcResult, target: bool) -> bool {
     }
 }
 
-/// STRINGS ///
-///*********///
+// STRINGS ///
+//*********///
 
-/// Note that strings are case insensitive. `target` must always be lower case.
+// Note that strings are case insensitive. `target` must always be lower case.
 
-pub(crate) fn result_matches_regex(calc_result: &CalcResult, reg: &Regex) -> bool {
+pub(crate) fn result_matches_regex(calc_result: &CalcResult, reg: &regex::Regex) -> bool {
     match calc_result {
         CalcResult::String(s) => reg.is_match(&s.to_lowercase()),
         _ => false,
@@ -269,8 +270,8 @@ fn result_is_greater_or_equal_than_string(calc_result: &CalcResult, target: &str
     }
 }
 
-/// ERRORS ///
-///********///
+// ERRORS ///
+//********///
 
 fn result_is_equal_to_error(calc_result: &CalcResult, target: &str) -> bool {
     match calc_result {
@@ -286,8 +287,8 @@ fn result_is_not_equal_to_error(calc_result: &CalcResult, target: &str) -> bool
     }
 }
 
-/// EMPTY ///
-///*******///
+// EMPTY ///
+//*******///
 
 // Note that these two are not inverse of each other.
 // In particular, you can never match an empty cell.
@@ -392,10 +393,8 @@ pub(crate) fn build_criteria<'a>(value: &'a CalcResult) -> Box<dyn Fn(&CalcResul
             // An error will match an error (never a string that is an error)
             Box::new(move |x| result_is_equal_to_error(x, &error.to_string()))
         }
-        CalcResult::Range { left: _, right: _ } => {
-            // TODO: Implicit Intersection
-            Box::new(move |_x| false)
-        }
+        CalcResult::Range { left: _, right: _ } => Box::new(move |_x| false),
+        CalcResult::Array(_) => Box::new(move |_x| false),
         CalcResult::EmptyCell | CalcResult::EmptyArg => Box::new(result_is_equal_to_empty),
     }
 }

base/src/functions/xlookup.rs

@@ -141,9 +141,9 @@ impl Model {
     ///   *  1 - Perform a search starting at the first item. This is the default.
     ///   * -1 - Perform a reverse search starting at the last item.
     ///   *  2 - Perform a binary search that relies on lookup_array being sorted
-    ///          in ascending order. If not sorted, invalid results will be returned.
+    ///      in ascending order. If not sorted, invalid results will be returned.
     ///   * -2 - Perform a binary search that relies on lookup_array being sorted
-    ///          in descending order. If not sorted, invalid results will be returned.
+    ///     in descending order. If not sorted, invalid results will be returned.
     pub(crate) fn fn_xlookup(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() < 3 || args.len() > 6 {
             return CalcResult::new_args_number_error(cell);
@@ -251,20 +251,28 @@ impl Model {
                         let column1 = left.column;
 
                         if row1 == 1 && row2 == LAST_ROW {
-                            row2 = self
-                                .workbook
-                                .worksheet(left.sheet)
-                                .expect("Sheet expected during evaluation.")
-                                .dimension()
-                                .max_row;
+                            row2 = match self.workbook.worksheet(left.sheet) {
+                                Ok(s) => s.dimension().max_row,
+                                Err(_) => {
+                                    return CalcResult::new_error(
+                                        Error::ERROR,
+                                        cell,
+                                        format!("Invalid worksheet index: '{}'", left.sheet),
+                                    );
+                                }
+                            };
                         }
                         if column1 == 1 && column2 == LAST_COLUMN {
-                            column2 = self
-                                .workbook
-                                .worksheet(left.sheet)
-                                .expect("Sheet expected during evaluation.")
-                                .dimension()
-                                .max_column;
+                            column2 = match self.workbook.worksheet(left.sheet) {
+                                Ok(s) => s.dimension().max_column,
+                                Err(_) => {
+                                    return CalcResult::new_error(
+                                        Error::ERROR,
+                                        cell,
+                                        format!("Invalid worksheet index: '{}'", left.sheet),
+                                    );
+                                }
+                            };
                         }
                         let left = CellReferenceIndex {
                             sheet: left.sheet,

base/src/language/mod.rs

@@ -1,7 +1,6 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, sync::OnceLock};
 
 use bitcode::{Decode, Encode};
-use once_cell::sync::Lazy;
 
 #[derive(Encode, Decode, Clone)]
 pub struct Booleans {
@@ -31,13 +30,17 @@ pub struct Language {
     pub errors: Errors,
 }
 
-static LANGUAGES: Lazy<HashMap<String, Language>> = Lazy::new(|| {
-    bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
-});
+static LANGUAGES: OnceLock<HashMap<String, Language>> = OnceLock::new();
+
+#[allow(clippy::expect_used)]
+fn get_languages() -> &'static HashMap<String, Language> {
+    LANGUAGES.get_or_init(|| {
+        bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
+    })
+}
 
 pub fn get_language(id: &str) -> Result<&Language, String> {
-    let language = LANGUAGES
+    get_languages()
         .get(id)
-        .ok_or(format!("Language is not supported: '{}'", id))?;
-    Ok(language)
+        .ok_or_else(|| format!("Language is not supported: '{id}'"))
 }

base/src/lib.rs

@@ -25,6 +25,8 @@
 #![doc = include_str!("../examples/formulas_and_errors.rs")]
 //! ```
 
+#![warn(clippy::print_stdout)]
+
 pub mod calc_result;
 pub mod cell;
 pub mod expressions;
@@ -37,9 +39,9 @@ pub mod types;
 pub mod worksheet;
 
 mod actions;
+mod arithmetic;
 mod cast;
 mod constants;
-mod diffs;
 mod functions;
 mod implicit_intersection;
 mod model;
@@ -57,4 +59,6 @@ pub mod mock_time;
 
 pub use model::get_milliseconds_since_epoch;
 pub use model::Model;
+pub use user_model::BorderArea;
+pub use user_model::ClipboardData;
 pub use user_model::UserModel;

base/src/locale/mod.rs

@@ -1,7 +1,6 @@
-use bitcode::{Decode, Encode};
-use once_cell::sync::Lazy;
+use std::{collections::HashMap, sync::OnceLock};
 
-use std::collections::HashMap;
+use bitcode::{Decode, Encode};
 
 #[derive(Encode, Decode, Clone)]
 pub struct Locale {
@@ -65,11 +64,17 @@ pub struct DecimalFormats {
     pub standard: String,
 }
 
-static LOCALES: Lazy<HashMap<String, Locale>> =
-    Lazy::new(|| bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale"));
+static LOCALES: OnceLock<HashMap<String, Locale>> = OnceLock::new();
+
+#[allow(clippy::expect_used)]
+fn get_locales() -> &'static HashMap<String, Locale> {
+    LOCALES.get_or_init(|| {
+        bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale")
+    })
+}
 
 pub fn get_locale(id: &str) -> Result<&Locale, String> {
-    // TODO: pass the locale once we implement locales in Rust
-    let locale = LOCALES.get(id).ok_or("Invalid locale")?;
-    Ok(locale)
+    get_locales()
+        .get(id)
+        .ok_or_else(|| format!("Invalid locale: '{id}'"))
 }

base/src/new_empty.rs

@@ -4,19 +4,22 @@ use std::collections::HashMap;
 
 use crate::{
     calc_result::Range,
+    constants::{DEFAULT_WINDOW_HEIGHT, DEFAULT_WINDOW_WIDTH},
     expressions::{
         lexer::LexerMode,
         parser::{
-            stringify::{rename_sheet_in_node, to_rc_format},
+            static_analysis::run_static_analysis_on_node,
+            stringify::{rename_sheet_in_node, to_rc_format, to_string},
             Parser,
         },
         types::CellReferenceRC,
     },
     language::get_language,
     locale::get_locale,
-    model::{get_milliseconds_since_epoch, Model, ParsedDefinedName},
+    model::{get_milliseconds_since_epoch, EvaluationState, Model, ParsedDefinedName},
     types::{
-        Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet, WorksheetView,
+        DefinedName, Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet,
+        WorksheetView,
     },
     utils::ParsedReference,
 };
@@ -84,15 +87,16 @@ impl Model {
         let worksheets = &self.workbook.worksheets;
         for worksheet in worksheets {
             let shared_formulas = &worksheet.shared_formulas;
-            let cell_reference = &Some(CellReferenceRC {
+            let cell_reference = CellReferenceRC {
                 sheet: worksheet.get_name(),
                 row: 1,
                 column: 1,
-            });
+            };
             let mut parse_formula = Vec::new();
             for formula in shared_formulas {
-                let t = self.parser.parse(formula, cell_reference);
-                parse_formula.push(t);
+                let t = self.parser.parse(formula, &cell_reference);
+                let static_result = run_static_analysis_on_node(&t);
+                parse_formula.push((t, static_result));
             }
             self.parsed_formulas.push(parse_formula);
         }
@@ -143,8 +147,9 @@ impl Model {
 
     /// Reparses all formulas and defined names
     pub(crate) fn reset_parsed_structures(&mut self) {
+        let defined_names = self.workbook.get_defined_names_with_scope();
         self.parser
-            .set_worksheets(self.workbook.get_worksheet_names());
+            .set_worksheets_and_names(self.workbook.get_worksheet_names(), defined_names);
         self.parsed_formulas = vec![];
         self.parse_formulas();
         self.parsed_defined_names = HashMap::new();
@@ -165,11 +170,11 @@ impl Model {
             .get_worksheet_names()
             .iter()
             .map(|s| s.to_uppercase())
-            .any(|x| x == format!("{}{}", base_name_uppercase, index))
+            .any(|x| x == format!("{base_name_uppercase}{index}"))
         {
             index += 1;
         }
-        let sheet_name = format!("{}{}", base_name, index);
+        let sheet_name = format!("{base_name}{index}");
         // Now we need a sheet_id
         let sheet_id = self.get_new_sheet_id();
         let view_ids: Vec<&u32> = self.workbook.views.keys().collect();
@@ -189,7 +194,7 @@ impl Model {
         sheet_id: Option<u32>,
     ) -> Result<(), String> {
         if !is_valid_sheet_name(sheet_name) {
-            return Err(format!("Invalid name for a sheet: '{}'", sheet_name));
+            return Err(format!("Invalid name for a sheet: '{sheet_name}'"));
         }
         if self
             .workbook
@@ -231,12 +236,12 @@ impl Model {
         if let Some(sheet_index) = self.get_sheet_index_by_name(old_name) {
             return self.rename_sheet_by_index(sheet_index, new_name);
         }
-        Err(format!("Could not find sheet {}", old_name))
+        Err(format!("Could not find sheet {old_name}"))
     }
 
     /// Renames a sheet and updates all existing references to that sheet.
     /// It can fail if:
-    ///   * The original index is too large
+    ///   * The original index is out of bounds
     ///   * The target sheet name already exists
     ///   * The target sheet name is invalid
     pub fn rename_sheet_by_index(
@@ -245,27 +250,25 @@ impl Model {
         new_name: &str,
     ) -> Result<(), String> {
         if !is_valid_sheet_name(new_name) {
-            return Err(format!("Invalid name for a sheet: '{}'.", new_name));
+            return Err(format!("Invalid name for a sheet: '{new_name}'."));
         }
         if self.get_sheet_index_by_name(new_name).is_some() {
-            return Err(format!("Sheet already exists: '{}'.", new_name));
-        }
-        let worksheets = &self.workbook.worksheets;
-        let sheet_count = worksheets.len() as u32;
-        if sheet_index >= sheet_count {
-            return Err("Sheet index out of bounds".to_string());
+            return Err(format!("Sheet already exists: '{new_name}'."));
         }
+        // Gets the new name and checks that a sheet with that index exists
+        let old_name = self.workbook.worksheet(sheet_index)?.get_name();
+
         // Parse all formulas with the old name
         // All internal formulas are R1C1
         self.parser.set_lexer_mode(LexerMode::R1C1);
-        // We use iter because the default would be a mut_iter and we don't need a mutable reference
-        let worksheets = &mut self.workbook.worksheets;
-        for worksheet in worksheets {
-            let cell_reference = &Some(CellReferenceRC {
+
+        for worksheet in &mut self.workbook.worksheets {
+            // R1C1 formulas are not tied to a cell (but are tied to a cell)
+            let cell_reference = &CellReferenceRC {
                 sheet: worksheet.get_name(),
                 row: 1,
                 column: 1,
-            });
+            };
             let mut formulas = Vec::new();
             for formula in &worksheet.shared_formulas {
                 let mut t = self.parser.parse(formula, cell_reference);
@@ -274,11 +277,32 @@ impl Model {
             }
             worksheet.shared_formulas = formulas;
         }
-        // Se the mode back to A1
+
+        // Set the mode back to A1
         self.parser.set_lexer_mode(LexerMode::A1);
+
+        // We reparse all the defined names formulas
+        let mut defined_names = Vec::new();
+        // Defined names do not have a context, we can use anything
+        let cell_reference = &CellReferenceRC {
+            sheet: old_name.clone(),
+            row: 1,
+            column: 1,
+        };
+        for defined_name in &mut self.workbook.defined_names {
+            let mut t = self.parser.parse(&defined_name.formula, cell_reference);
+            rename_sheet_in_node(&mut t, sheet_index, new_name);
+            let formula = to_string(&t, cell_reference);
+            defined_names.push(DefinedName {
+                name: defined_name.name.clone(),
+                formula,
+                sheet_id: defined_name.sheet_id,
+            });
+        }
+        self.workbook.defined_names = defined_names;
+
         // Update the name of the worksheet
-        let worksheets = &mut self.workbook.worksheets;
-        worksheets[sheet_index as usize].set_name(new_name);
+        self.workbook.worksheet_mut(sheet_index)?.set_name(new_name);
         self.reset_parsed_structures();
         Ok(())
     }
@@ -294,7 +318,7 @@ impl Model {
         };
         if sheet_index >= sheet_count {
             return Err("Sheet index too large".to_string());
-        }
+        };
         self.workbook.worksheets.remove(sheet_index as usize);
         self.reset_parsed_structures();
         Ok(())
@@ -340,20 +364,27 @@ impl Model {
         };
         let locale = match get_locale(locale_id) {
             Ok(l) => l.clone(),
-            Err(_) => return Err(format!("Invalid locale: {}", locale_id)),
+            Err(_) => return Err(format!("Invalid locale: {locale_id}")),
         };
 
         let milliseconds = get_milliseconds_since_epoch();
         let seconds = milliseconds / 1000;
         let dt = match DateTime::from_timestamp(seconds, 0) {
             Some(s) => s,
-            None => return Err(format!("Invalid timestamp: {}", milliseconds)),
+            None => return Err(format!("Invalid timestamp: {milliseconds}")),
         };
         // "2020-08-06T21:20:53Z
         let now = dt.format("%Y-%m-%dT%H:%M:%SZ").to_string();
 
         let mut views = HashMap::new();
-        views.insert(0, WorkbookView { sheet: 0 });
+        views.insert(
+            0,
+            WorkbookView {
+                sheet: 0,
+                window_width: DEFAULT_WINDOW_WIDTH,
+                window_height: DEFAULT_WINDOW_HEIGHT,
+            },
+        );
 
         // String versions of the locale are added here to simplify the serialize/deserialize logic
         let workbook = Workbook {
@@ -376,14 +407,16 @@ impl Model {
             },
             tables: HashMap::new(),
             views,
+            spill_cells: Vec::new(),
         };
         let parsed_formulas = Vec::new();
         let worksheets = &workbook.worksheets;
         let worksheet_names = worksheets.iter().map(|s| s.get_name()).collect();
-        let parser = Parser::new(worksheet_names, HashMap::new());
+        let parser = Parser::new(worksheet_names, vec![], HashMap::new());
         let cells = HashMap::new();
 
         // FIXME: Add support for display languages
+        #[allow(clippy::expect_used)]
         let language = get_language("en").expect("").clone();
 
         let mut model = Model {
@@ -397,6 +430,10 @@ impl Model {
             language,
             tz,
             view_id: 0,
+            support_graph: HashMap::new(),
+            switch_cells: None,
+            stack: Vec::new(),
+            state: EvaluationState::Ready,
         };
         model.parse_formulas();
         Ok(model)

base/src/number_format.rs

@@ -126,7 +126,7 @@ pub fn to_precision_str(value: f64, precision: usize) -> String {
     let exponent = value.abs().log10().floor();
     let base = value / 10.0_f64.powf(exponent);
     let base = format!("{0:.1$}", base, precision - 1);
-    let value = format!("{}e{}", base, exponent).parse::<f64>().unwrap_or({
+    let value = format!("{base}e{exponent}").parse::<f64>().unwrap_or({
         // TODO: do this in a way that does not require a possible error
         0.0
     });

base/src/styles.rs

@@ -4,8 +4,6 @@ use crate::{
     types::{Border, CellStyles, CellXfs, Fill, Font, NumFmt, Style, Styles},
 };
 
-// TODO: Move Styles and all related types from crate::types here
-// Not doing it right now to not have conflicts with exporter branch
 impl Styles {
     fn get_font_index(&self, font: &Font) -> Option<i32> {
         for (font_index, item) in self.fonts.iter().enumerate() {
@@ -156,31 +154,34 @@ impl Styles {
                 return Ok(cell_style.xf_id);
             }
         }
-        Err(format!("Style '{}' not found", style_name))
+        Err(format!("Style '{style_name}' not found"))
     }
 
     pub fn create_named_style(&mut self, style_name: &str, style: &Style) -> Result<(), String> {
         let style_index = self.create_new_style(style);
-        self.add_named_cell_style(style_name, style_index)?;
-        Ok(())
+        self.add_named_cell_style(style_name, style_index)
     }
 
-    pub(crate) fn get_style_with_quote_prefix(&mut self, index: i32) -> i32 {
-        let mut style = self.get_style(index);
+    pub(crate) fn get_style_with_quote_prefix(&mut self, index: i32) -> Result<i32, String> {
+        let mut style = self.get_style(index)?;
         style.quote_prefix = true;
-        self.get_style_index_or_create(&style)
+        Ok(self.get_style_index_or_create(&style))
     }
 
-    pub(crate) fn get_style_with_format(&mut self, index: i32, num_fmt: &str) -> i32 {
-        let mut style = self.get_style(index);
+    pub(crate) fn get_style_with_format(
+        &mut self,
+        index: i32,
+        num_fmt: &str,
+    ) -> Result<i32, String> {
+        let mut style = self.get_style(index)?;
         style.num_fmt = num_fmt.to_string();
-        self.get_style_index_or_create(&style)
+        Ok(self.get_style_index_or_create(&style))
     }
 
-    pub(crate) fn get_style_without_quote_prefix(&mut self, index: i32) -> i32 {
-        let mut style = self.get_style(index);
+    pub(crate) fn get_style_without_quote_prefix(&mut self, index: i32) -> Result<i32, String> {
+        let mut style = self.get_style(index)?;
         style.quote_prefix = false;
-        self.get_style_index_or_create(&style)
+        Ok(self.get_style_index_or_create(&style))
     }
 
     pub(crate) fn style_is_quote_prefix(&self, index: i32) -> bool {
@@ -188,9 +189,11 @@ impl Styles {
         cell_xf.quote_prefix
     }
 
-    pub(crate) fn get_style(&self, index: i32) -> Style {
-        let cell_xf = &self.cell_xfs[index as usize];
-
+    pub(crate) fn get_style(&self, index: i32) -> Result<Style, String> {
+        let cell_xf = &self
+            .cell_xfs
+            .get(index as usize)
+            .ok_or("Invalid index provided".to_string())?;
         let border_id = cell_xf.border_id as usize;
         let fill_id = cell_xf.fill_id as usize;
         let font_id = cell_xf.font_id as usize;
@@ -198,14 +201,14 @@ impl Styles {
         let quote_prefix = cell_xf.quote_prefix;
         let alignment = cell_xf.alignment.clone();
 
-        Style {
+        Ok(Style {
             alignment,
             num_fmt: get_num_fmt(num_fmt_id, &self.num_fmts),
             fill: self.fills[fill_id].clone(),
             font: self.fonts[font_id].clone(),
             border: self.borders[border_id].clone(),
             quote_prefix,
-        }
+        })
     }
 }
 
@@ -221,8 +224,7 @@ impl Model {
         let style_index = self.workbook.styles.get_style_index_or_create(style);
         self.workbook
             .worksheet_mut(sheet)?
-            .set_cell_style(row, column, style_index);
-        Ok(())
+            .set_cell_style(row, column, style_index)
     }
 
     pub fn copy_cell_style(
@@ -237,9 +239,7 @@ impl Model {
 
         self.workbook
             .worksheet_mut(destination_cell.0)?
-            .set_cell_style(destination_cell.1, destination_cell.2, source_style_index);
-
-        Ok(())
+            .set_cell_style(destination_cell.1, destination_cell.2, source_style_index)
     }
 
     /// Sets the style "style_name" in cell
@@ -253,8 +253,7 @@ impl Model {
         let style_index = self.workbook.styles.get_style_index_by_name(style_name)?;
         self.workbook
             .worksheet_mut(sheet)?
-            .set_cell_style(row, column, style_index);
-        Ok(())
+            .set_cell_style(row, column, style_index)
     }
 
     pub fn set_sheet_style(&mut self, sheet: u32, style_name: &str) -> Result<(), String> {

base/src/test/mod.rs

@@ -13,18 +13,21 @@ mod test_fn_averageifs;
 mod test_fn_choose;
 mod test_fn_concatenate;
 mod test_fn_count;
+mod test_fn_day;
 mod test_fn_exact;
 mod test_fn_financial;
+mod test_fn_formulatext;
 mod test_fn_if;
 mod test_fn_maxifs;
 mod test_fn_minifs;
+mod test_fn_or_xor;
 mod test_fn_product;
 mod test_fn_rept;
 mod test_fn_sum;
 mod test_fn_sumifs;
 mod test_fn_textbefore;
 mod test_fn_textjoin;
-mod test_forward_references;
+mod test_fn_unicode;
 mod test_frozen_rows_columns;
 mod test_general;
 mod test_math;
@@ -33,11 +36,13 @@ mod test_model_cell_clear_all;
 mod test_model_is_empty_cell;
 mod test_move_formula;
 mod test_quote_prefix;
+mod test_row_column_styles;
 mod test_set_user_input;
 mod test_sheet_markup;
 mod test_sheets;
 mod test_styles;
 mod test_trigonometric;
+mod test_true_false;
 mod test_workbook;
 mod test_worksheet;
 pub(crate) mod util;
@@ -46,12 +51,23 @@ mod engineering;
 mod test_fn_offset;
 mod test_number_format;
 
+mod test_arrays;
+mod test_dynamic_arrays;
 mod test_escape_quotes;
 mod test_extend;
+mod test_fn_fv;
+mod test_fn_round;
 mod test_fn_type;
 mod test_frozen_rows_and_columns;
+mod test_geomean;
 mod test_get_cell_content;
+mod test_implicit_intersection;
+mod test_issue_155;
+mod test_ln;
+mod test_log;
+mod test_log10;
 mod test_percentage;
+mod test_set_functions_error_handling;
 mod test_today;
 mod test_types;
 mod user_model;

base/src/test/test_actions.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::unwrap_used)]
 
-use crate::constants::LAST_COLUMN;
+use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN, LAST_ROW};
 use crate::model::Model;
 use crate::test::util::new_empty_model;
 use crate::types::Col;
@@ -87,7 +87,8 @@ fn test_insert_rows_styles() {
     let mut model = new_empty_model();
 
     assert!(
-        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
+        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
+            < f64::EPSILON
     );
     // sets height 42 in row 10
     model
@@ -106,7 +107,8 @@ fn test_insert_rows_styles() {
 
     // Row 10 has the default height
     assert!(
-        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
+        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
+            < f64::EPSILON
     );
 
     // Row 10 is now row 15
@@ -120,7 +122,8 @@ fn test_delete_rows_styles() {
     let mut model = new_empty_model();
 
     assert!(
-        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
+        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
+            < f64::EPSILON
     );
     // sets height 42 in row 10
     model
@@ -139,7 +142,8 @@ fn test_delete_rows_styles() {
 
     // Row 10 has the default height
     assert!(
-        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
+        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
+            < f64::EPSILON
     );
 
     // Row 10 is now row 5
@@ -504,6 +508,10 @@ fn test_move_column_right() {
     assert_eq!(model._get_formula("E5"), "=SUM(H3:J7)");
     assert_eq!(model._get_formula("E6"), "=SUM(H3:H7)");
     assert_eq!(model._get_formula("E7"), "=SUM(G3:G7)");
+
+    // Data moved as well
+    assert_eq!(model._get_text("G1"), "1");
+    assert_eq!(model._get_text("H1"), "3");
 }
 
 #[test]
@@ -528,5 +536,249 @@ fn tets_move_column_error() {
     assert!(result.is_ok());
 }
 
+#[test]
+fn test_move_row_down() {
+    let mut model = new_empty_model();
+    populate_table(&mut model);
+    // Formulas referencing rows 3 and 4
+    model._set("E3", "=G3");
+    model._set("E4", "=G4");
+    model._set("E5", "=SUM(G3:J3)");
+    model._set("E6", "=SUM(G3:G3)");
+    model._set("E7", "=SUM(G4:G4)");
+    model.evaluate();
+
+    // Move row 3 down by one position
+    let result = model.move_row_action(0, 3, 1);
+    assert!(result.is_ok());
+    model.evaluate();
+
+    assert_eq!(model._get_formula("E3"), "=G3");
+    assert_eq!(model._get_formula("E4"), "=G4");
+    assert_eq!(model._get_formula("E5"), "=SUM(G4:J4)");
+    assert_eq!(model._get_formula("E6"), "=SUM(G4:G4)");
+    assert_eq!(model._get_formula("E7"), "=SUM(G3:G3)");
+
+    // Data moved as well
+    assert_eq!(model._get_text("G4"), "-2");
+    assert_eq!(model._get_text("G3"), "");
+}
+
+#[test]
+fn test_move_row_up() {
+    let mut model = new_empty_model();
+    populate_table(&mut model);
+    // Formulas referencing rows 4 and 5
+    model._set("E4", "=G4");
+    model._set("E5", "=G5");
+    model._set("E6", "=SUM(G4:J4)");
+    model._set("E7", "=SUM(G4:G4)");
+    model._set("E8", "=SUM(G5:G5)");
+    model.evaluate();
+
+    // Move row 5 up by one position
+    let result = model.move_row_action(0, 5, -1);
+    assert!(result.is_ok());
+    model.evaluate();
+
+    assert_eq!(model._get_formula("E4"), "=G4");
+    assert_eq!(model._get_formula("E5"), "=G5");
+    assert_eq!(model._get_formula("E6"), "=SUM(G5:J5)");
+    assert_eq!(model._get_formula("E7"), "=SUM(G5:G5)");
+    assert_eq!(model._get_formula("E8"), "=SUM(G4:G4)");
+
+    // Data moved as well
+    assert_eq!(model._get_text("G4"), "");
+    assert_eq!(model._get_text("G5"), "");
+}
+
+#[test]
+fn test_move_row_error() {
+    let mut model = new_empty_model();
+    model.evaluate();
+
+    let result = model.move_row_action(0, 7, -10);
+    assert!(result.is_err());
+
+    let result = model.move_row_action(0, -7, 20);
+    assert!(result.is_err());
+
+    let result = model.move_row_action(0, LAST_ROW, 1);
+    assert!(result.is_err());
+
+    let result = model.move_row_action(0, LAST_ROW + 1, -10);
+    assert!(result.is_err());
+
+    // This works
+    let result = model.move_row_action(0, LAST_ROW, -1);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_move_row_down_absolute_refs() {
+    let mut model = new_empty_model();
+    populate_table(&mut model);
+    // Absolute references
+    model._set("E3", "=$G$3");
+    model._set("E4", "=$G$4");
+    model._set("E5", "=SUM($G$3:$J$3)");
+    model._set("E6", "=SUM($G$3:$G$3)");
+    model._set("E7", "=SUM($G$4:$G$4)");
+    model.evaluate();
+
+    assert!(model.move_row_action(0, 3, 1).is_ok());
+    model.evaluate();
+
+    assert_eq!(model._get_formula("E3"), "=$G$3");
+    assert_eq!(model._get_formula("E4"), "=$G$4");
+    assert_eq!(model._get_formula("E5"), "=SUM($G$4:$J$4)");
+    assert_eq!(model._get_formula("E6"), "=SUM($G$4:$G$4)");
+    assert_eq!(model._get_formula("E7"), "=SUM($G$3:$G$3)");
+}
+
+#[test]
+fn test_move_column_right_absolute_refs() {
+    let mut model = new_empty_model();
+    populate_table(&mut model);
+    // Absolute references
+    model._set("E3", "=$G$3");
+    model._set("E4", "=$H$3");
+    model._set("E5", "=SUM($G$3:$J$7)");
+    model._set("E6", "=SUM($G$3:$G$7)");
+    model._set("E7", "=SUM($H$3:$H$7)");
+    model.evaluate();
+
+    assert!(model.move_column_action(0, 7, 1).is_ok());
+    model.evaluate();
+
+    assert_eq!(model._get_formula("E3"), "=$H$3");
+    assert_eq!(model._get_formula("E4"), "=$G$3");
+    assert_eq!(model._get_formula("E5"), "=SUM($H$3:$J$7)");
+    assert_eq!(model._get_formula("E6"), "=SUM($H$3:$H$7)");
+    assert_eq!(model._get_formula("E7"), "=SUM($G$3:$G$7)");
+}
+
+#[test]
+fn test_move_row_down_mixed_refs() {
+    let mut model = new_empty_model();
+    populate_table(&mut model);
+    model._set("E3", "=$G3"); // absolute col, relative row
+    model._set("E4", "=$G4");
+    model._set("E5", "=SUM($G3:$J3)");
+    model._set("E6", "=SUM($G3:$G3)");
+    model._set("E7", "=SUM($G4:$G4)");
+    model._set("F3", "=H$3"); // relative col, absolute row
+    model._set("F4", "=G$3");
+    model.evaluate();
+
+    assert!(model.move_row_action(0, 3, 1).is_ok());
+    model.evaluate();
+
+    assert_eq!(model._get_formula("E3"), "=$G3");
+    assert_eq!(model._get_formula("E4"), "=$G4");
+    assert_eq!(model._get_formula("E5"), "=SUM($G4:$J4)");
+    assert_eq!(model._get_formula("E6"), "=SUM($G4:$G4)");
+    assert_eq!(model._get_formula("E7"), "=SUM($G3:$G3)");
+    assert_eq!(model._get_formula("F3"), "=G$4");
+    assert_eq!(model._get_formula("F4"), "=H$4");
+}
+
+#[test]
+fn test_move_column_right_mixed_refs() {
+    let mut model = new_empty_model();
+    populate_table(&mut model);
+    model._set("E3", "=$G3");
+    model._set("E4", "=$H3");
+    model._set("E5", "=SUM($G3:$J7)");
+    model._set("E6", "=SUM($G3:$G7)");
+    model._set("E7", "=SUM($H3:$H7)");
+    model._set("F3", "=H$3");
+    model._set("F4", "=H$3");
+    model.evaluate();
+
+    assert!(model.move_column_action(0, 7, 1).is_ok());
+    model.evaluate();
+
+    assert_eq!(model._get_formula("E3"), "=$H3");
+    assert_eq!(model._get_formula("E4"), "=$G3");
+    assert_eq!(model._get_formula("E5"), "=SUM($H3:$J7)");
+    assert_eq!(model._get_formula("E6"), "=SUM($H3:$H7)");
+    assert_eq!(model._get_formula("E7"), "=SUM($G3:$G7)");
+    assert_eq!(model._get_formula("F3"), "=G$3");
+    assert_eq!(model._get_formula("F4"), "=G$3");
+}
+
+#[test]
+fn test_move_row_height() {
+    let mut model = new_empty_model();
+    let sheet = 0;
+    let custom_height = DEFAULT_ROW_HEIGHT * 2.0;
+    // Set a custom height for row 3
+    model
+        .workbook
+        .worksheet_mut(sheet)
+        .unwrap()
+        .set_row_height(3, custom_height)
+        .unwrap();
+
+    // Record the original height of row 4 (should be the default)
+    let original_row4_height = model.get_row_height(sheet, 4).unwrap();
+
+    // Move row 3 down by one position
+    assert!(model.move_row_action(sheet, 3, 1).is_ok());
+
+    // The custom height should now be on row 4
+    assert_eq!(model.get_row_height(sheet, 4), Ok(custom_height));
+
+    // Row 3 should now have the previous height of row 4
+    assert_eq!(model.get_row_height(sheet, 3), Ok(original_row4_height));
+}
+
+/// Moving a row down by two positions should shift formulas on intermediate
+/// rows by only one (the row that gets skipped), not by the full delta ‒ this
+/// guards against the regression fixed in the RowMove displacement logic.
+#[test]
+fn test_row_move_down_two_updates_intermediate_refs_by_one() {
+    let mut model = new_empty_model();
+    populate_table(&mut model);
+    // Set up formulas to verify intermediate rows shift by 1 (not full delta).
+    model._set("E3", "=G3"); // target row
+    model._set("E4", "=G4"); // intermediate row
+    model._set("E5", "=SUM(G3:J3)");
+    model.evaluate();
+
+    // Move row 3 down by two positions (row 3 -> row 5)
+    assert!(model.move_row_action(0, 3, 2).is_ok());
+    model.evaluate();
+
+    // Assert that references for the moved row and intermediate row are correct.
+    assert_eq!(model._get_formula("E3"), "=G3");
+    assert_eq!(model._get_formula("E5"), "=G5");
+    assert_eq!(model._get_formula("E4"), "=SUM(G5:J5)");
+}
+
+/// Moving a column right by two positions should shift formulas on
+/// intermediate columns by only one, ensuring the ColumnMove displacement
+/// logic handles multi-position moves correctly.
+#[test]
+fn test_column_move_right_two_updates_intermediate_refs_by_one() {
+    let mut model = new_empty_model();
+    populate_table(&mut model);
+    // Set up formulas to verify intermediate columns shift by 1 (not full delta).
+    model._set("E3", "=$G3"); // target column
+    model._set("E4", "=$H3"); // intermediate column
+    model._set("E5", "=SUM($G3:$J7)");
+    model.evaluate();
+
+    // Move column G (7) right by two positions (G -> I)
+    assert!(model.move_column_action(0, 7, 2).is_ok());
+    model.evaluate();
+
+    // Assert that references for moved and intermediate columns are correct.
+    assert_eq!(model._get_formula("E3"), "=$I3");
+    assert_eq!(model._get_formula("E4"), "=$G3");
+    assert_eq!(model._get_formula("E5"), "=SUM($I3:$J7)");
+}
+
 // A  B  C  D  E  F  G   H  I  J   K   L   M   N   O   P   Q   R
 // 1  2  3  4  5  6  7   8  9  10  11  12  13  14  15  16  17  18

base/src/test/test_arrays.rs

@@ -0,0 +1,13 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn sum_arrays() {
+    let mut model = new_empty_model();
+    model._set("A1", "=SUM({1,2,3}+{3,4,5})");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"18");
+}

base/src/test/test_column_width.rs

@@ -26,7 +26,7 @@ fn test_column_width() {
     assert!((worksheet.get_column_width(1).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
     assert!((worksheet.get_column_width(2).unwrap() - 30.0).abs() < f64::EPSILON);
     assert!((worksheet.get_column_width(3).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
-    assert_eq!(model.get_cell_style_index(0, 23, 2), 6);
+    assert_eq!(model.get_cell_style_index(0, 23, 2), Ok(6));
 }
 
 #[test]
@@ -53,7 +53,7 @@ fn test_column_width_lower_edge() {
     assert!(
         (worksheet.get_column_width(6).unwrap() - 10.0 * COLUMN_WIDTH_FACTOR).abs() < f64::EPSILON
     );
-    assert_eq!(model.get_cell_style_index(0, 23, 5), 1);
+    assert_eq!(model.get_cell_style_index(0, 23, 5), Ok(1));
 }
 
 #[test]
@@ -80,5 +80,23 @@ fn test_column_width_higher_edge() {
     );
     assert!((worksheet.get_column_width(16).unwrap() - 30.0).abs() < f64::EPSILON);
     assert!((worksheet.get_column_width(17).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
-    assert_eq!(model.get_cell_style_index(0, 23, 16), 1);
+    assert_eq!(model.get_cell_style_index(0, 23, 16), Ok(1));
+}
+
+#[test]
+fn test_column_width_negative() {
+    let mut model = new_empty_model();
+    let result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_column_width(16, -1.0);
+    assert_eq!(result, Err("Can not set a negative width: -1".to_string()));
+    assert_eq!(model.workbook.worksheets[0].cols.len(), 0);
+    let worksheet = model.workbook.worksheet(0).unwrap();
+    assert_eq!(
+        (worksheet.get_column_width(16).unwrap()),
+        DEFAULT_COLUMN_WIDTH
+    );
+    assert_eq!(model.get_cell_style_index(0, 23, 16), Ok(0));
 }

base/src/test/test_date_and_time.rs

@@ -37,12 +37,12 @@ fn test_fn_date_arguments() {
     assert_eq!(model._get_text("A3"), *"#ERROR!");
     assert_eq!(model._get_text("A4"), *"#ERROR!");
 
-    assert_eq!(model._get_text("A5"), *"#NUM!");
-    assert_eq!(model._get_text("A6"), *"#NUM!");
-    assert_eq!(model._get_text("A7"), *"#NUM!");
-    assert_eq!(model._get_text("A8"), *"#NUM!");
+    assert_eq!(model._get_text("A5"), *"10/10/1974");
+    assert_eq!(model._get_text("A6"), *"21/01/1975");
+    assert_eq!(model._get_text("A7"), *"10/02/1976");
+    assert_eq!(model._get_text("A8"), *"02/03/1975");
 
-    assert_eq!(model._get_text("A9"), *"#NUM!");
+    assert_eq!(model._get_text("A9"), *"01/03/1975");
     assert_eq!(model._get_text("A10"), *"29/02/1976");
     assert_eq!(
         model.get_cell_value_by_ref("Sheet1!A10"),
@@ -64,15 +64,18 @@ fn test_date_out_of_range() {
 
     // year (actually years < 1900 don't really make sense)
     model._set("C1", "=DATE(-1, 5, 5)");
+    // excel is not compatible with years past 9999
+    model._set("C2", "=DATE(10000, 5, 5)");
 
     model.evaluate();
 
-    assert_eq!(model._get_text("A1"), *"#NUM!");
-    assert_eq!(model._get_text("A2"), *"#NUM!");
-    assert_eq!(model._get_text("B1"), *"#NUM!");
-    assert_eq!(model._get_text("B2"), *"#NUM!");
+    assert_eq!(model._get_text("A1"), *"10/12/2021");
+    assert_eq!(model._get_text("A2"), *"10/01/2023");
+    assert_eq!(model._get_text("B1"), *"30/04/2042");
+    assert_eq!(model._get_text("B2"), *"01/06/2025");
 
     assert_eq!(model._get_text("C1"), *"#NUM!");
+    assert_eq!(model._get_text("C2"), *"#NUM!");
 }
 
 #[test]
@@ -129,8 +132,7 @@ fn test_day_small_serial() {
     model.evaluate();
 
     assert_eq!(model._get_text("A1"), *"#NUM!");
-    // This agrees with Google Docs and disagrees with Excel
-    assert_eq!(model._get_text("A2"), *"30");
+    assert_eq!(model._get_text("A2"), *"#NUM!");
     // Excel thinks is Feb 29, 1900
     assert_eq!(model._get_text("A3"), *"28");
 
@@ -150,8 +152,7 @@ fn test_month_small_serial() {
     model.evaluate();
 
     assert_eq!(model._get_text("A1"), *"#NUM!");
-    // This agrees with Google Docs and disagrees with Excel
-    assert_eq!(model._get_text("A2"), *"12");
+    assert_eq!(model._get_text("A2"), *"#NUM!");
     // We agree with Excel here (We are both in Feb)
     assert_eq!(model._get_text("A3"), *"2");
 
@@ -171,8 +172,7 @@ fn test_year_small_serial() {
     model.evaluate();
 
     assert_eq!(model._get_text("A1"), *"#NUM!");
-    // This agrees with Google Docs and disagrees with Excel
-    assert_eq!(model._get_text("A2"), *"1899");
+    assert_eq!(model._get_text("A2"), *"#NUM!");
 
     assert_eq!(model._get_text("A3"), *"1900");
 
@@ -204,7 +204,10 @@ fn test_date_early_dates() {
         model.get_cell_value_by_ref("Sheet1!A2"),
         Ok(CellValue::Number(60.0))
     );
-    assert_eq!(model._get_text("B2"), *"#NUM!");
+
+    // This does not agree with Excel, instead of mistakenly allowing
+    // for Feb 29, it will auto-wrap to the next day after Feb 28.
+    assert_eq!(model._get_text("B2"), *"01/03/1900");
 
     // This agrees with Excel from he onward
     assert_eq!(model._get_text("A3"), *"01/03/1900");

base/src/test/test_dynamic_arrays.rs

@@ -0,0 +1,50 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn they_spill() {
+    let mut model = new_empty_model();
+    model._set("A1", "42");
+    model._set("A2", "5");
+    model._set("A3", "7");
+
+    model._set("B1", "=A1:A3");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"42");
+    assert_eq!(model._get_text("B2"), *"5");
+    assert_eq!(model._get_text("B3"), *"7");
+}
+
+#[test]
+fn spill_error() {
+    let mut model = new_empty_model();
+    model._set("A1", "42");
+    model._set("A2", "5");
+    model._set("A3", "7");
+
+    model._set("B1", "=A1:A3");
+    model._set("B2", "4");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#SPILL!");
+    assert_eq!(model._get_text("B2"), *"4");
+    assert_eq!(model._get_text("B3"), *"");
+}
+
+#[test]
+fn second_evaluation() {
+    let mut model = new_empty_model();
+    model._set("C3", "={1,2,3}");
+    model.evaluate();
+
+    assert_eq!(model._get_text("D3"), "2");
+
+    model._set("D8", "23");
+    model.evaluate();
+
+    assert_eq!(model._get_text("D3"), "2");
+}

base/src/test/test_error_propagation.rs

@@ -1,4 +1,5 @@
 #![allow(clippy::unwrap_used)]
+#![allow(clippy::panic)]
 
 use crate::test::util::new_empty_model;
 use crate::types::Cell;

base/src/test/test_fn_concatenate.rs

@@ -22,13 +22,14 @@ fn fn_concatenate() {
     model._set("B1", r#"=CONCATENATE(A1, A2, A3, "!")"#);
     // This will break once we implement the implicit intersection operator
     // It should be:
-    // model._set("B2", r#"=CONCATENATE(@A1:A3, "!")"#);
+    model._set("C2", r#"=CONCATENATE(@A1:A3, "!")"#);
     model._set("B2", r#"=CONCATENATE(A1:A3, "!")"#);
     model._set("B3", r#"=CONCAT(A1:A3, "!")"#);
 
     model.evaluate();
 
     assert_eq!(model._get_text("B1"), *"Hello my World!");
-    assert_eq!(model._get_text("B2"), *" my !");
+    assert_eq!(model._get_text("B2"), *"#N/IMPL!");
     assert_eq!(model._get_text("B3"), *"Hello my World!");
+    assert_eq!(model._get_text("C2"), *" my !");
 }

base/src/test/test_fn_day.rs

@@ -0,0 +1,15 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn test_fn_date_arguments() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=DAY(95051806)");
+    model._set("A2", "=DAY(2958465)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#NUM!");
+    assert_eq!(model._get_text("A2"), *"31");
+}

base/src/test/test_fn_formulatext.rs

@@ -0,0 +1,54 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn wrong_number_of_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=FORMULATEXT()");
+    model._set("A2", "=FORMULATEXT(\"B\",\"A\")");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+}
+
+#[test]
+fn multi_sheet_ref() {
+    let mut model = new_empty_model();
+    model.new_sheet();
+    model._set("A1", "=FORMULATEXT(Sheet1!A1:Sheet2!A1)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+}
+
+#[test]
+fn implicit_intersection() {
+    let mut model = new_empty_model();
+    model._set("A1", "=FORMULATEXT(C1:C2)");
+    model._set("A2", "=FORMULATEXT(D1:E1)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#N/IMPL!");
+    assert_eq!(model._get_text("A2"), *"#N/IMPL!");
+}
+
+#[test]
+fn implicit_intersection_operator() {
+    let mut model = new_empty_model();
+    model._set("A1", "=1 +  2");
+    model._set("B1", "=FORMULATEXT(@A:A)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#N/IMPL!");
+}
+
+#[test]
+fn non_reference() {
+    let mut model = new_empty_model();
+    model._set("A1", "=FORMULATEXT(42)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+}

base/src/test/test_fn_fv.rs

@@ -0,0 +1,36 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn computation() {
+    let i2 = "=-C2*(1+D2)^E2-F2*((D2+1)*((1+D2)^E2-1))/D2";
+
+    let mut model = new_empty_model();
+    model._set("C2", "1");
+    model._set("D2", "2");
+    model._set("E2", "3");
+    model._set("F2", "4");
+
+    model._set("I2", i2);
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("I2"), "-183");
+    assert_eq!(model._get_formula("I2"), i2);
+}
+
+#[test]
+fn format_as_currency() {
+    let mut model = new_empty_model();
+    model._set("C2", "1");
+    model._set("D2", "2");
+    model._set("E2", "3");
+    model._set("F2", "4");
+
+    model._set("I2", "=FV(D2,E2,F2,C2,1)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("I2"), "-$183.00");
+}

base/src/test/test_fn_or_xor.rs

@@ -0,0 +1,204 @@
+#![allow(clippy::unwrap_used)]
+#![allow(clippy::print_stdout)]
+use crate::test::util::new_empty_model;
+
+// These tests are grouped because in many cases XOR and OR have similar behaviour.
+
+// Test specific to xor
+#[test]
+fn fn_xor() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=XOR(1, 1, 1, 0, 0)");
+    model._set("A2", "=XOR(1, 1, 0, 0, 0)");
+    model._set("A3", "=XOR(TRUE, TRUE, TRUE, FALSE, FALSE)");
+    model._set("A4", "=XOR(TRUE, TRUE, FALSE, FALSE, FALSE)");
+    model._set("A5", "=XOR(FALSE, FALSE, FALSE, FALSE, FALSE)");
+    model._set("A6", "=XOR(TRUE, TRUE)");
+    model._set("A7", "=XOR(0,0,0)");
+    model._set("A8", "=XOR(0,0,1)");
+    model._set("A9", "=XOR(0,1,0)");
+    model._set("A10", "=XOR(0,1,1)");
+    model._set("A11", "=XOR(1,0,0)");
+    model._set("A12", "=XOR(1,0,1)");
+    model._set("A13", "=XOR(1,1,0)");
+    model._set("A14", "=XOR(1,1,1)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"TRUE");
+    assert_eq!(model._get_text("A2"), *"FALSE");
+    assert_eq!(model._get_text("A3"), *"TRUE");
+    assert_eq!(model._get_text("A4"), *"FALSE");
+    assert_eq!(model._get_text("A5"), *"FALSE");
+    assert_eq!(model._get_text("A6"), *"FALSE");
+    assert_eq!(model._get_text("A7"), *"FALSE");
+    assert_eq!(model._get_text("A8"), *"TRUE");
+    assert_eq!(model._get_text("A9"), *"TRUE");
+    assert_eq!(model._get_text("A10"), *"FALSE");
+    assert_eq!(model._get_text("A11"), *"TRUE");
+    assert_eq!(model._get_text("A12"), *"FALSE");
+    assert_eq!(model._get_text("A13"), *"FALSE");
+    assert_eq!(model._get_text("A14"), *"TRUE");
+}
+
+#[test]
+fn fn_or() {
+    let mut model = new_empty_model();
+
+    model._set("A1", "=OR(1, 1, 1, 0, 0)");
+    model._set("A2", "=OR(1, 1, 0, 0, 0)");
+    model._set("A3", "=OR(TRUE, TRUE, TRUE, FALSE, FALSE)");
+    model._set("A4", "=OR(TRUE, TRUE, FALSE, FALSE, FALSE)");
+    model._set("A5", "=OR(FALSE, FALSE, FALSE, FALSE, FALSE)");
+    model._set("A6", "=OR(TRUE, TRUE)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"TRUE");
+    assert_eq!(model._get_text("A2"), *"TRUE");
+    assert_eq!(model._get_text("A3"), *"TRUE");
+    assert_eq!(model._get_text("A4"), *"TRUE");
+    assert_eq!(model._get_text("A5"), *"FALSE");
+    assert_eq!(model._get_text("A6"), *"TRUE");
+}
+
+#[test]
+fn fn_or_xor() {
+    inner("or");
+    inner("xor");
+
+    fn inner(func: &str) {
+        println!("Testing function: {func}");
+
+        let mut model = new_empty_model();
+
+        // Text args
+        model._set("A1", &format!(r#"={func}("")"#));
+        model._set("A2", &format!(r#"={func}("", "")"#));
+        model._set("A3", &format!(r#"={func}("", TRUE)"#));
+        model._set("A4", &format!(r#"={func}("", FALSE)"#));
+
+        model._set("A5", &format!("={func}(FALSE, TRUE)"));
+        model._set("A6", &format!("={func}(FALSE, FALSE)"));
+        model._set("A7", &format!("={func}(TRUE, FALSE)"));
+
+        // Reference to empty cell, plus true argument
+        model._set("A8", &format!("={func}(Z99, 1)"));
+
+        // Reference to empty cell/range
+        model._set("A9", &format!("={func}(Z99)"));
+        model._set("A10", &format!("={func}(X99:Z99"));
+
+        // Reference to cell with reference to empty range
+        model._set("B11", "=@X99:Z99");
+        model._set("A11", &format!("={func}(B11)"));
+
+        // Reference to cell with non-empty range
+        model._set("X12", "1");
+        model._set("B12", "=@X12:Z12");
+        model._set("A12", &format!("={func}(B12)"));
+
+        // Reference to text cell
+        model._set("B13", "some_text");
+        model._set("A13", &format!("={func}(B13)"));
+        model._set("A14", &format!("={func}(B13, 0)"));
+        model._set("A15", &format!("={func}(B13, 1)"));
+
+        // Reference to Implicit intersection
+        model._set("X16", "1");
+        model._set("B16", "=@X15:X16");
+        model._set("A16", &format!("={func}(B16)"));
+
+        // Non-empty range
+        model._set("B17", "1");
+        model._set("A17", &format!("={func}(B17:C17)"));
+
+        // Non-empty range with text
+        model._set("B18", "text");
+        model._set("A18", &format!("={func}(B18:C18)"));
+
+        // Non-empty range with text and number
+        model._set("B19", "text");
+        model._set("C19", "1");
+        model._set("A19", &format!("={func}(B19:C19)"));
+
+        // range with error
+        model._set("B20", "=1/0");
+        model._set("A20", &format!("={func}(B20:C20)"));
+
+        model.evaluate();
+
+        assert_eq!(model._get_text("A1"), *"#VALUE!");
+        assert_eq!(model._get_text("A2"), *"#VALUE!");
+        assert_eq!(model._get_text("A3"), *"TRUE");
+        assert_eq!(model._get_text("A4"), *"FALSE");
+
+        assert_eq!(model._get_text("A5"), *"TRUE");
+        assert_eq!(model._get_text("A6"), *"FALSE");
+        assert_eq!(model._get_text("A7"), *"TRUE");
+
+        assert_eq!(model._get_text("A8"), *"TRUE");
+
+        assert_eq!(model._get_text("A9"), *"#VALUE!");
+        assert_eq!(model._get_text("A10"), *"#VALUE!");
+
+        assert_eq!(model._get_text("A11"), *"#VALUE!");
+
+        // TODO: This one depends on spill behaviour which isn't implemented yet
+        // assert_eq!(model._get_text("A12"), *"TRUE");
+
+        assert_eq!(model._get_text("A13"), *"#VALUE!");
+        assert_eq!(model._get_text("A14"), *"FALSE");
+        assert_eq!(model._get_text("A15"), *"TRUE");
+
+        // TODO: This one depends on @ implicit intersection behaviour which isn't implemented yet
+        // assert_eq!(model._get_text("A16"), *"TRUE");
+
+        assert_eq!(model._get_text("A17"), *"TRUE");
+
+        assert_eq!(model._get_text("A18"), *"#VALUE!");
+
+        assert_eq!(model._get_text("A19"), *"TRUE");
+
+        assert_eq!(model._get_text("A20"), *"#DIV/0!");
+    }
+}
+
+#[test]
+fn fn_or_xor_no_arguments() {
+    inner("or");
+    inner("xor");
+
+    fn inner(func: &str) {
+        println!("Testing function: {func}");
+
+        let mut model = new_empty_model();
+        model._set("A1", &format!("={func}()"));
+        model.evaluate();
+        assert_eq!(model._get_text("A1"), *"#ERROR!");
+    }
+}
+
+#[test]
+fn fn_or_xor_missing_arguments() {
+    inner("or");
+    inner("xor");
+
+    fn inner(func: &str) {
+        println!("Testing function: {func}");
+
+        let mut model = new_empty_model();
+        model._set("A1", &format!("={func}(,)"));
+        model._set("A2", &format!("={func}(,1)"));
+        model._set("A3", &format!("={func}(1,)"));
+        model._set("A4", &format!("={func}(,B1)"));
+        model._set("A5", &format!("={func}(,B1:B4)"));
+        model.evaluate();
+        assert_eq!(model._get_text("A1"), *"FALSE");
+        assert_eq!(model._get_text("A2"), *"TRUE");
+        assert_eq!(model._get_text("A3"), *"TRUE");
+        assert_eq!(model._get_text("A4"), *"FALSE");
+        assert_eq!(model._get_text("A5"), *"FALSE");
+    }
+}

base/src/test/test_fn_round.rs

@@ -0,0 +1,15 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn fn_round_approximation() {
+    let mut model = new_empty_model();
+    model._set("A1", "=ROUND(1.05*(0.0284+0.0046)-0.0284,4)");
+    model._set("A2", "=ROUNDDOWN(1.05*(0.0284+0.0046)-0.0284,5)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"0.0063");
+    assert_eq!(model._get_text("A2"), *"0.00625");
+}

base/src/test/test_fn_sum.rs

@@ -17,3 +17,19 @@ fn test_fn_sum_arguments() {
     assert_eq!(model._get_text("A3"), *"1");
     assert_eq!(model._get_text("A4"), *"4");
 }
+
+#[test]
+fn arrays() {
+    let mut model = new_empty_model();
+    model._set("A1", "=SUM({1, 2, 3})");
+    model._set("A2", "=SUM({1; 2; 3})");
+    model._set("A3", "=SUM({1, 2; 3, 4})");
+    model._set("A4", "=SUM({1, 2; 3, 4; 5, 6})");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"6");
+    assert_eq!(model._get_text("A2"), *"6");
+    assert_eq!(model._get_text("A3"), *"10");
+    assert_eq!(model._get_text("A4"), *"21");
+}

base/src/test/test_fn_unicode.rs

@@ -0,0 +1,63 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn simple_cases() {
+    let mut model = new_empty_model();
+    model._set("A1", "=UNICODE(\"1,00\")");
+    model._set("A2", "=UNICODE(\"1\")");
+    model._set("A3", "=UNICODE(1)");
+    model._set("A4", "=UNICODE(\"T\")");
+    model._set("A5", "=UNICODE(\"TRUE\")");
+    model._set("A6", "=UNICODE(TRUE)");
+    model._set("A7", "=UNICODE(FALSE)");
+    model._set("A8", "=UNICODE(\"の\")");
+    model._set("A9", "=UNICODE(\" \")");
+
+    model._set("A10", "=_xlfn.UNICODE(\"T\")");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"49");
+    assert_eq!(model._get_text("A2"), *"49");
+    assert_eq!(model._get_text("A3"), *"49");
+    assert_eq!(model._get_text("A4"), *"84");
+    assert_eq!(model._get_text("A5"), *"84");
+    assert_eq!(model._get_text("A6"), *"84");
+    assert_eq!(model._get_text("A7"), *"70");
+    assert_eq!(model._get_text("A8"), *"12398");
+    assert_eq!(model._get_text("A9"), *"32");
+    assert_eq!(model._get_text("A10"), *"84");
+}
+
+#[test]
+fn test_error_cases() {
+    let mut model = new_empty_model();
+    model._set("A1", "=UNICODE(\"\")");
+    model._set("A2", "=UNICODE(#CALC!)");
+    model._set("A3", "=UNICODE(#NAME?)");
+    model._set("A4", "=UNICODE(#VALUE!)");
+    model._set("A5", "=UNICODE(#REF!)");
+    model._set("A6", "=UNICODE(#DIV/0!)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#VALUE!");
+    assert_eq!(model._get_text("A2"), *"#CALC!");
+    assert_eq!(model._get_text("A3"), *"#NAME?");
+    assert_eq!(model._get_text("A4"), *"#VALUE!");
+    assert_eq!(model._get_text("A5"), *"#REF!");
+    assert_eq!(model._get_text("A6"), *"#DIV/0!");
+}
+
+#[test]
+fn wrong_number_of_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=UNICODE()");
+    model._set("A2", "=UNICODE(\"B\",\"A\")");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+}

base/src/test/test_forward_references.rs

@@ -1,121 +0,0 @@
-#![allow(clippy::unwrap_used)]
-
-use crate::expressions::types::{Area, CellReferenceIndex};
-use crate::test::util::new_empty_model;
-
-#[test]
-fn test_forward_references() {
-    let mut model = new_empty_model();
-
-    // test single ref changed nd not changed
-    model._set("H8", "=F6*G9");
-    // tests areas
-    model._set("H9", "=SUM(D4:F6)");
-    // absolute coordinates
-    model._set("H10", "=$F$6");
-    // area larger than the source area
-    model._set("H11", "=SUM(D3:F6)");
-    // Test arguments and concat
-    model._set("H12", "=SUM(F6, D4:F6) & D4");
-    // Test range operator. This is syntax error for now.
-    // model._set("H13", "=SUM(D4:INDEX(D4:F5,4,2))");
-    // Test operations
-    model._set("H14", "=-D4+D5*F6/F5");
-
-    model.evaluate();
-
-    // Source Area is D4:F6
-    let source_area = &Area {
-        sheet: 0,
-        row: 4,
-        column: 4,
-        width: 3,
-        height: 3,
-    };
-
-    // We paste in B10
-    let target_row = 10;
-    let target_column = 2;
-    let result = model.forward_references(
-        source_area,
-        &CellReferenceIndex {
-            sheet: 0,
-            row: target_row,
-            column: target_column,
-        },
-    );
-    assert!(result.is_ok());
-    model.evaluate();
-
-    assert_eq!(model._get_formula("H8"), "=D12*G9");
-    assert_eq!(model._get_formula("H9"), "=SUM(B10:D12)");
-    assert_eq!(model._get_formula("H10"), "=$D$12");
-
-    assert_eq!(model._get_formula("H11"), "=SUM(D3:F6)");
-    assert_eq!(model._get_formula("H12"), "=SUM(D12,B10:D12)&B10");
-    // assert_eq!(model._get_formula("H13"), "=SUM(B10:INDEX(B10:D11,4,2))");
-    assert_eq!(model._get_formula("H14"), "=-B10+B11*D12/D11");
-}
-
-#[test]
-fn test_different_sheet() {
-    let mut model = new_empty_model();
-
-    // test single ref changed not changed
-    model._set("H8", "=F6*G9");
-    // tests areas
-    model._set("H9", "=SUM(D4:F6)");
-    // absolute coordinates
-    model._set("H10", "=$F$6");
-    // area larger than the source area
-    model._set("H11", "=SUM(D3:F6)");
-    // Test arguments and concat
-    model._set("H12", "=SUM(F6, D4:F6) & D4");
-    // Test range operator. This is syntax error for now.
-    // model._set("H13", "=SUM(D4:INDEX(D4:F5,4,2))");
-    // Test operations
-    model._set("H14", "=-D4+D5*F6/F5");
-
-    // Adds a new sheet
-    assert!(model.add_sheet("Sheet2").is_ok());
-
-    model.evaluate();
-
-    // Source Area is D4:F6
-    let source_area = &Area {
-        sheet: 0,
-        row: 4,
-        column: 4,
-        width: 3,
-        height: 3,
-    };
-
-    // We paste in Sheet2!B10
-    let target_row = 10;
-    let target_column = 2;
-    let result = model.forward_references(
-        source_area,
-        &CellReferenceIndex {
-            sheet: 1,
-            row: target_row,
-            column: target_column,
-        },
-    );
-    assert!(result.is_ok());
-    model.evaluate();
-
-    assert_eq!(model._get_formula("H8"), "=Sheet2!D12*G9");
-    assert_eq!(model._get_formula("H9"), "=SUM(Sheet2!B10:D12)");
-    assert_eq!(model._get_formula("H10"), "=Sheet2!$D$12");
-
-    assert_eq!(model._get_formula("H11"), "=SUM(D3:F6)");
-    assert_eq!(
-        model._get_formula("H12"),
-        "=SUM(Sheet2!D12,Sheet2!B10:D12)&Sheet2!B10"
-    );
-    // assert_eq!(model._get_formula("H13"), "=SUM(B10:INDEX(B10:D11,4,2))");
-    assert_eq!(
-        model._get_formula("H14"),
-        "=-Sheet2!B10+Sheet2!B11*Sheet2!D12/Sheet2!D11"
-    );
-}

base/src/test/test_general.rs

@@ -1,5 +1,7 @@
 #![allow(clippy::unwrap_used)]
 
+use crate::constants::DEFAULT_ROW_HEIGHT;
+
 use crate::cell::CellValue;
 
 use crate::number_format::to_excel_precision_str;
@@ -17,7 +19,9 @@ fn test_empty_model() {
 #[test]
 fn test_model_simple_evaluation() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "= 1 + 3".to_string());
+    model
+        .set_user_input(0, 1, 1, "= 1 + 3".to_string())
+        .unwrap();
     model.evaluate();
     let result = model._get_text_at(0, 1, 1);
     assert_eq!(result, *"4");
@@ -43,7 +47,7 @@ fn test_model_simple_evaluation_order() {
 #[test]
 fn test_model_invalid_formula() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "= 1 +".to_string());
+    model.set_user_input(0, 1, 1, "= 1 +".to_string()).unwrap();
     model.evaluate();
     let result = model._get_text_at(0, 1, 1);
     assert_eq!(result, *"#ERROR!");
@@ -54,8 +58,10 @@ fn test_model_invalid_formula() {
 #[test]
 fn test_model_dependencies() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "23".to_string()); // A1
-    model.set_user_input(0, 1, 2, "= A1* 2-4".to_string()); // B1
+    model.set_user_input(0, 1, 1, "23".to_string()).unwrap(); // A1
+    model
+        .set_user_input(0, 1, 2, "= A1* 2-4".to_string())
+        .unwrap(); // B1
     model.evaluate();
     let result = model._get_text_at(0, 1, 1);
     assert_eq!(result, *"23");
@@ -65,7 +71,9 @@ fn test_model_dependencies() {
     let result = model._get_formula("B1");
     assert_eq!(result, *"=A1*2-4");
 
-    model.set_user_input(0, 2, 1, "=SUM(A1, B1)".to_string()); // A2
+    model
+        .set_user_input(0, 2, 1, "=SUM(A1, B1)".to_string())
+        .unwrap(); // A2
     model.evaluate();
     let result = model._get_text_at(0, 2, 1);
     assert_eq!(result, *"65");
@@ -74,8 +82,10 @@ fn test_model_dependencies() {
 #[test]
 fn test_model_strings() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "Hello World".to_string());
-    model.set_user_input(0, 1, 2, "=A1".to_string());
+    model
+        .set_user_input(0, 1, 1, "Hello World".to_string())
+        .unwrap();
+    model.set_user_input(0, 1, 2, "=A1".to_string()).unwrap();
     model.evaluate();
     let result = model._get_text_at(0, 1, 1);
     assert_eq!(result, *"Hello World");
@@ -105,6 +115,15 @@ fn test_set_row_height() {
     worksheet.set_row_height(5, 5.0).unwrap();
     let worksheet = model.workbook.worksheet(0).unwrap();
     assert!((5.0 - worksheet.row_height(5).unwrap()).abs() < f64::EPSILON);
+
+    let worksheet = model.workbook.worksheet_mut(0).unwrap();
+    let result = worksheet.set_row_height(6, -1.0);
+    assert_eq!(result, Err("Can not set a negative height: -1".to_string()));
+
+    assert_eq!(worksheet.row_height(6).unwrap(), DEFAULT_ROW_HEIGHT);
+
+    worksheet.set_row_height(6, 0.0).unwrap();
+    assert_eq!(worksheet.row_height(6).unwrap(), 0.0);
 }
 
 #[test]
@@ -152,21 +171,35 @@ fn test_to_excel_precision_str() {
 #[test]
 fn test_booleans() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "true".to_string());
-    model.set_user_input(0, 2, 1, "TRUE".to_string());
-    model.set_user_input(0, 3, 1, "True".to_string());
-    model.set_user_input(0, 4, 1, "false".to_string());
-    model.set_user_input(0, 5, 1, "FALSE".to_string());
-    model.set_user_input(0, 6, 1, "False".to_string());
+    model.set_user_input(0, 1, 1, "true".to_string()).unwrap();
+    model.set_user_input(0, 2, 1, "TRUE".to_string()).unwrap();
+    model.set_user_input(0, 3, 1, "True".to_string()).unwrap();
+    model.set_user_input(0, 4, 1, "false".to_string()).unwrap();
+    model.set_user_input(0, 5, 1, "FALSE".to_string()).unwrap();
+    model.set_user_input(0, 6, 1, "False".to_string()).unwrap();
 
-    model.set_user_input(0, 1, 2, "=ISLOGICAL(A1)".to_string());
-    model.set_user_input(0, 2, 2, "=ISLOGICAL(A2)".to_string());
-    model.set_user_input(0, 3, 2, "=ISLOGICAL(A3)".to_string());
-    model.set_user_input(0, 4, 2, "=ISLOGICAL(A4)".to_string());
-    model.set_user_input(0, 5, 2, "=ISLOGICAL(A5)".to_string());
-    model.set_user_input(0, 6, 2, "=ISLOGICAL(A6)".to_string());
+    model
+        .set_user_input(0, 1, 2, "=ISLOGICAL(A1)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 2, 2, "=ISLOGICAL(A2)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 3, 2, "=ISLOGICAL(A3)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 4, 2, "=ISLOGICAL(A4)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 5, 2, "=ISLOGICAL(A5)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 6, 2, "=ISLOGICAL(A6)".to_string())
+        .unwrap();
 
-    model.set_user_input(0, 1, 5, "=IF(false, True, FALSe)".to_string());
+    model
+        .set_user_input(0, 1, 5, "=IF(false, True, FALSe)".to_string())
+        .unwrap();
 
     model.evaluate();
 
@@ -191,19 +224,19 @@ fn test_booleans() {
 #[test]
 fn test_set_cell_style() {
     let mut model = new_empty_model();
-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
     assert!(!style.font.b);
 
     style.font.b = true;
     assert!(model.set_cell_style(0, 1, 1, &style).is_ok());
 
-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
     assert!(style.font.b);
 
     style.font.b = false;
     assert!(model.set_cell_style(0, 1, 1, &style).is_ok());
 
-    let style = model.get_style_for_cell(0, 1, 1);
+    let style = model.get_style_for_cell(0, 1, 1).unwrap();
     assert!(!style.font.b);
 }
 
@@ -211,21 +244,21 @@ fn test_set_cell_style() {
 fn test_copy_cell_style() {
     let mut model = new_empty_model();
 
-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
     style.font.b = true;
     assert!(model.set_cell_style(0, 1, 1, &style).is_ok());
 
-    let mut style = model.get_style_for_cell(0, 1, 2);
+    let mut style = model.get_style_for_cell(0, 1, 2).unwrap();
     style.font.i = true;
     assert!(model.set_cell_style(0, 1, 2, &style).is_ok());
 
     assert!(model.copy_cell_style((0, 1, 1), (0, 1, 2)).is_ok());
 
-    let style = model.get_style_for_cell(0, 1, 1);
+    let style = model.get_style_for_cell(0, 1, 1).unwrap();
     assert!(style.font.b);
     assert!(!style.font.i);
 
-    let style = model.get_style_for_cell(0, 1, 2);
+    let style = model.get_style_for_cell(0, 1, 2).unwrap();
     assert!(style.font.b);
     assert!(!style.font.i);
 }
@@ -234,15 +267,15 @@ fn test_copy_cell_style() {
 fn test_get_cell_style_index() {
     let mut model = new_empty_model();
 
-    let mut style = model.get_style_for_cell(0, 1, 1);
-    let style_index = model.get_cell_style_index(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
+    let style_index = model.get_cell_style_index(0, 1, 1).unwrap();
     assert_eq!(style_index, 0);
     assert!(!style.font.b);
 
     style.font.b = true;
     assert!(model.set_cell_style(0, 1, 1, &style).is_ok());
 
-    let style_index = model.get_cell_style_index(0, 1, 1);
+    let style_index = model.get_cell_style_index(0, 1, 1).unwrap();
     assert_eq!(style_index, 1);
 }
 
@@ -250,29 +283,29 @@ fn test_get_cell_style_index() {
 fn test_model_set_cells_with_values_styles() {
     let mut model = new_empty_model();
     // Inputs
-    model.set_user_input(0, 1, 1, "21".to_string()); // A1
-    model.set_user_input(0, 2, 1, "2".to_string()); // A2
+    model.set_user_input(0, 1, 1, "21".to_string()).unwrap(); // A1
+    model.set_user_input(0, 2, 1, "2".to_string()).unwrap(); // A2
 
-    let style_index = model.get_cell_style_index(0, 1, 1);
+    let style_index = model.get_cell_style_index(0, 1, 1).unwrap();
     assert_eq!(style_index, 0);
-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
     style.font.b = true;
     assert!(model.set_cell_style(0, 1, 1, &style).is_ok());
     assert!(model.set_cell_style(0, 2, 1, &style).is_ok());
-    let style_index = model.get_cell_style_index(0, 1, 1);
+    let style_index = model.get_cell_style_index(0, 1, 1).unwrap();
     assert_eq!(style_index, 1);
-    let style_index = model.get_cell_style_index(0, 2, 1);
+    let style_index = model.get_cell_style_index(0, 2, 1).unwrap();
     assert_eq!(style_index, 1);
 
-    model.update_cell_with_number(0, 1, 2, 1.0);
-    model.update_cell_with_number(0, 2, 1, 2.0);
+    model.update_cell_with_number(0, 1, 2, 1.0).unwrap();
+    model.update_cell_with_number(0, 2, 1, 2.0).unwrap();
 
     model.evaluate();
 
     // Styles are not modified
-    let style_index = model.get_cell_style_index(0, 1, 1);
+    let style_index = model.get_cell_style_index(0, 1, 1).unwrap();
     assert_eq!(style_index, 1);
-    let style_index = model.get_cell_style_index(0, 2, 1);
+    let style_index = model.get_cell_style_index(0, 2, 1).unwrap();
     assert_eq!(style_index, 1);
 }
 
@@ -280,20 +313,20 @@ fn test_model_set_cells_with_values_styles() {
 fn test_style_fmt_id() {
     let mut model = new_empty_model();
 
-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
     style.num_fmt = "#.##".to_string();
     assert!(model.set_cell_style(0, 1, 1, &style).is_ok());
-    let style = model.get_style_for_cell(0, 1, 1);
+    let style = model.get_style_for_cell(0, 1, 1).unwrap();
     assert_eq!(style.num_fmt, "#.##");
 
-    let mut style = model.get_style_for_cell(0, 10, 1);
+    let mut style = model.get_style_for_cell(0, 10, 1).unwrap();
     style.num_fmt = "$$#,##0.0000".to_string();
     assert!(model.set_cell_style(0, 10, 1, &style).is_ok());
-    let style = model.get_style_for_cell(0, 10, 1);
+    let style = model.get_style_for_cell(0, 10, 1).unwrap();
     assert_eq!(style.num_fmt, "$$#,##0.0000");
 
     // Make sure old style is not touched
-    let style = model.get_style_for_cell(0, 1, 1);
+    let style = model.get_style_for_cell(0, 1, 1).unwrap();
     assert_eq!(style.num_fmt, "#.##");
 }
 
@@ -357,9 +390,13 @@ fn set_input_autocomplete() {
     let mut model = new_empty_model();
     model._set("A1", "1");
     model._set("A2", "2");
-    model.set_user_input(0, 3, 1, "=SUM(A1:A2".to_string());
+    model
+        .set_user_input(0, 3, 1, "=SUM(A1:A2".to_string())
+        .unwrap();
     // This will fail anyway
-    model.set_user_input(0, 4, 1, "=SUM(A1*".to_string());
+    model
+        .set_user_input(0, 4, 1, "=SUM(A1*".to_string())
+        .unwrap();
     model.evaluate();
 
     assert_eq!(model._get_formula("A3"), "=SUM(A1:A2)");
@@ -405,7 +442,7 @@ fn test_get_formatted_cell_value() {
     model._set("A5", "123.456");
 
     // change A5 format
-    let mut style = model.get_style_for_cell(0, 5, 1);
+    let mut style = model.get_style_for_cell(0, 5, 1).unwrap();
     style.num_fmt = "$#,##0.00".to_string();
     model.set_cell_style(0, 5, 1, &style).unwrap();
 

base/src/test/test_geomean.rs

@@ -0,0 +1,27 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn test_fn_geomean_arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=GEOMEAN()");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#ERROR!");
+}
+
+#[test]
+fn test_fn_geomean_minimal() {
+    let mut model = new_empty_model();
+    model._set("B1", "1");
+    model._set("B2", "2");
+    model._set("B3", "3");
+    model._set("B4", "'2");
+    // B5 is empty
+    model._set("B6", "true");
+    model._set("A1", "=GEOMEAN(B1:B6)");
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"1.817120593");
+}

base/src/test/test_get_cell_content.rs

@@ -5,8 +5,12 @@ use crate::test::util::new_empty_model;
 #[test]
 fn test_formulas() {
     let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "$100.348".to_string());
-    model.set_user_input(0, 1, 2, "=ISNUMBER(A1)".to_string());
+    model
+        .set_user_input(0, 1, 1, "$100.348".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 1, 2, "=ISNUMBER(A1)".to_string())
+        .unwrap();
 
     model.evaluate();
 

base/src/test/test_implicit_intersection.rs

@@ -0,0 +1,50 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn simple_column() {
+    let mut model = new_empty_model();
+    // We populate cells A1 to A3
+    model._set("A1", "1");
+    model._set("A2", "2");
+    model._set("A3", "3");
+
+    model._set("C2", "=@A1:A3");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("C2"), "2".to_string());
+}
+
+#[test]
+fn return_of_array_is_n_impl() {
+    let mut model = new_empty_model();
+    // We populate cells A1 to A3
+    model._set("A1", "1");
+    model._set("A2", "2");
+    model._set("A3", "3");
+
+    model._set("C2", "=A1:A3");
+    model._set("D2", "=SUM(SIN(A:A)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("C2"), "1".to_string());
+    assert_eq!(model._get_text("D2"), "1.89188842".to_string());
+}
+
+#[test]
+fn concat() {
+    let mut model = new_empty_model();
+    model._set("A1", "=CONCAT(@B1:B3)");
+    model._set("A2", "=CONCAT(B1:B3)");
+    model._set("B1", "Hello");
+    model._set("B2", " ");
+    model._set("B3", "world!");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"Hello");
+    assert_eq!(model._get_text("A2"), *"Hello world!");
+}

base/src/test/test_issue_155.rs

@@ -0,0 +1,14 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn issue_155() {
+    let mut model = new_empty_model();
+    model._set("A1", "1");
+    model._set("A2", "2");
+    model._set("B2", "=A$1:A2");
+    model.evaluate();
+
+    assert_eq!(model._get_formula("B2"), "=A$1:A2".to_string());
+}

base/src/test/test_ln.rs

@@ -0,0 +1,17 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=LN(100)");
+    model._set("A2", "=LN()");
+    model._set("A3", "=LN(100, 10)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"4.605170186");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+    assert_eq!(model._get_text("A3"), *"#ERROR!");
+}

base/src/test/test_log.rs

@@ -0,0 +1,19 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+
+#[test]
+fn arguments() {
+    let mut model = new_empty_model();
+    model._set("A1", "=LOG(100)");
+    model._set("A2", "=LOG()");
+    model._set("A3", "=LOG(10000, 10)");
+    model._set("A4", "=LOG(100, 10, 1)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"2");
+    assert_eq!(model._get_text("A2"), *"#ERROR!");
+    assert_eq!(model._get_text("A3"), *"4");
+    assert_eq!(model._get_text("A4"), *"#ERROR!");
+}