From 63f80cead487abeb062ab3f97be8e59f5986a42b Mon Sep 17 00:00:00 2001
From: Matt Luongo <mhluongo@gmail.com>
Date: Tue, 13 Jan 2026 10:53:18 -0500
Subject: [PATCH 01/11] Run tests with vader.vim

---
 .github/workflows/test.yml       |  41 +++++++
 test/README.md                   | 183 +++++++++++++++++++++++++++++++
 test/fixtures/foundry_test.t.sol |  26 +++++
 test/fixtures/issue_15.sol       |  33 ++++++
 test/fixtures/issue_5.sol        |  68 ++++++++++++
 test/fixtures/modern.sol         |  60 ++++++++++
 test/vader/folding.vader         |  87 +++++++++++++++
 test/vader/indent.vader          | 176 +++++++++++++++++++++++++++++
 test/vader/syntax.vader          | 167 ++++++++++++++++++++++++++++
 test/vimrc                       |  19 ++++
 10 files changed, 860 insertions(+)
 create mode 100644 .github/workflows/test.yml
 create mode 100644 test/README.md
 create mode 100644 test/fixtures/foundry_test.t.sol
 create mode 100644 test/fixtures/issue_15.sol
 create mode 100644 test/fixtures/issue_5.sol
 create mode 100644 test/fixtures/modern.sol
 create mode 100644 test/vader/folding.vader
 create mode 100644 test/vader/indent.vader
 create mode 100644 test/vader/syntax.vader
 create mode 100644 test/vimrc

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 0000000..5b8748e
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,41 @@
+name: Test
+
+on:
+  push:
+    branches: [ main, revamp ]
+  pull_request:
+    branches: [ main, revamp ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Vim
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y vim
+
+      - name: Clone vader.vim
+        run: |
+          git clone --depth 1 https://github.com/junegunn/vader.vim.git test/vader.vim
+
+      - name: Run syntax tests
+        run: |
+          vim -Nu test/vimrc -c 'Vader! test/vader/syntax.vader'
+
+      - name: Run folding tests
+        run: |
+          vim -Nu test/vimrc -c 'Vader! test/vader/folding.vader'
+
+      - name: Run indentation tests
+        run: |
+          vim -Nu test/vimrc -c 'Vader! test/vader/indent.vader'
+
+      - name: Test summary
+        if: always()
+        run: |
+          echo "✓ All tests completed"
diff --git a/test/README.md b/test/README.md
new file mode 100644
index 0000000..d44eb58
--- /dev/null
+++ b/test/README.md
@@ -0,0 +1,183 @@
+# vim-solidity Tests
+
+This directory contains automated tests for vim-solidity using [vader.vim](https://github.com/junegunn/vader.vim).
+
+## Structure
+
+```
+test/
+├── vader/              # Vader test files
+│   ├── syntax.vader    # Syntax highlighting tests
+│   ├── indent.vader    # Indentation tests
+│   └── folding.vader   # Code folding tests
+├── fixtures/           # Test Solidity files
+│   ├── modern.sol          # Modern Solidity 0.8.x features
+│   ├── issue_15.sol        # String literal bug (Issue #15)
+│   ├── issue_5.sol         # Indentation problems (Issue #5)
+│   └── foundry_test.t.sol  # Foundry test file example
+├── vimrc               # Minimal vimrc for testing
+└── README.md           # This file
+```
+
+## Running Tests Locally
+
+### Prerequisites
+
+1. Clone vader.vim:
+```bash
+git clone https://github.com/junegunn/vader.vim.git test/vader.vim
+```
+
+2. Ensure you have Vim installed (version 8.0+)
+
+### Run All Tests
+
+```bash
+# From the project root directory
+vim -Nu test/vimrc -c 'Vader! test/vader/*.vader'
+```
+
+### Run Specific Test Files
+
+```bash
+# Syntax tests only
+vim -Nu test/vimrc -c 'Vader! test/vader/syntax.vader'
+
+# Indentation tests only
+vim -Nu test/vimrc -c 'Vader! test/vader/indent.vader'
+
+# Folding tests only
+vim -Nu test/vimrc -c 'Vader! test/vader/folding.vader'
+```
+
+### Interactive Testing
+
+For debugging tests interactively:
+
+```bash
+# Run without the ! to keep Vim open
+vim -Nu test/vimrc -c 'Vader test/vader/syntax.vader'
+```
+
+## Writing New Tests
+
+### Test Structure
+
+Vader tests use a simple DSL:
+
+```vader
+Given solidity (test description):
+  # Input Solidity code
+
+Execute (what the test does):
+  " Vim commands and assertions
+
+Expect solidity (expected result):
+  # Expected output
+```
+
+### Common Assertions
+
+```vim
+" Check equality
+AssertEqual expected, actual
+
+" Check inequality
+AssertNotEqual unexpected, actual
+
+" Check syntax group at cursor
+let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+AssertEqual 'solKeyword', l:group
+```
+
+### Testing Syntax Highlighting
+
+```vader
+Given solidity (keyword test):
+  transient uint256 value;
+
+Execute (check transient is highlighted):
+  normal! /transient
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'solKeyword', l:group
+```
+
+### Testing Indentation
+
+```vader
+Given solidity (unindented code):
+  contract Test {
+  function foo() {
+  uint x = 1;
+  }
+  }
+
+Execute (indent buffer):
+  normal! gg=G
+
+Expect solidity (indented code):
+  contract Test {
+      function foo() {
+          uint x = 1;
+      }
+  }
+```
+
+### Testing Folding
+
+```vader
+Given solidity (contract):
+  contract Test {
+      function foo() {}
+  }
+
+Execute (check fold exists):
+  set foldmethod=syntax
+  normal! gg
+  let l:foldlevel = foldlevel(1)
+  AssertNotEqual 0, l:foldlevel
+```
+
+## CI/CD
+
+Tests run automatically on GitHub Actions for:
+- Push to `main` or `revamp` branches
+- Pull requests targeting `main` or `revamp`
+
+See `.github/workflows/test.yml` for the CI configuration.
+
+## Test Fixtures
+
+The `fixtures/` directory contains example Solidity files for manual testing:
+
+- **modern.sol**: Tests all Solidity 0.8.x features (transient, unchecked, error, etc.)
+- **issue_15.sol**: Reproduces the string literal syntax bug
+- **issue_5.sol**: Contains problematic indentation patterns
+- **foundry_test.t.sol**: Example Foundry test file
+
+You can open these in Vim to manually verify syntax highlighting, indentation, and folding:
+
+```bash
+vim test/fixtures/modern.sol
+```
+
+## Troubleshooting
+
+### Tests fail locally but pass in CI
+
+- Ensure you're using Vim 8.0+
+- Make sure vader.vim is cloned to `test/vader.vim`
+- Check that you're running from the project root
+
+### Syntax group not found
+
+Use `:syn list` in Vim to see all defined syntax groups and verify the expected group name.
+
+### Indentation tests fail
+
+The indentation tests are sensitive to the `shiftwidth` and `expandtab` settings. The test vimrc should set these correctly, but you can verify with:
+
+```vim
+:set shiftwidth?
+:set expandtab?
+```
diff --git a/test/fixtures/foundry_test.t.sol b/test/fixtures/foundry_test.t.sol
new file mode 100644
index 0000000..ed76657
--- /dev/null
+++ b/test/fixtures/foundry_test.t.sol
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+// Foundry test file (.t.sol extension)
+
+import "forge-std/Test.sol";
+
+contract MyContractTest is Test {
+    function setUp() public {
+        // Setup code
+    }
+
+    function test_BasicAssertion() public {
+        assertEq(1 + 1, 2);
+    }
+
+    function testFail_ShouldRevert() public {
+        // This test expects a revert
+        revert("Expected revert");
+    }
+
+    function test_Fuzz(uint256 x) public {
+        // Fuzz testing
+        assertGe(x, 0);
+    }
+}
diff --git a/test/fixtures/issue_15.sol b/test/fixtures/issue_15.sol
new file mode 100644
index 0000000..2f0f8e3
--- /dev/null
+++ b/test/fixtures/issue_15.sol
@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+// Test case for Issue #15: String literal syntax bug
+// After the closing quote in strings with function signatures,
+// syntax highlighting should continue to work correctly
+
+contract StringSyntaxTest {
+    function testFunctionSignatureString() public pure {
+        // This is the problematic pattern from Issue #15
+        bytes32 hash1 = keccak256(bytes("submitSomething(bytes)"));
+
+        // More variations to test
+        bytes32 hash2 = keccak256(abi.encodePacked("transfer(address,uint256)"));
+
+        // Nested quotes and parens
+        string memory sig = "approve(address,uint256)";
+        bytes32 hash3 = keccak256(bytes(sig));
+
+        // Function signature comparison
+        if (keccak256(bytes("foo(uint256)")) == keccak256(bytes("foo(uint256)"))) {
+            // This should still highlight correctly
+            uint256 value = 42;
+        }
+
+        // Multiple strings on same line
+        string memory a = "func(uint256)";
+        string memory b = "other(bytes)";
+
+        // String with escaped quotes
+        string memory c = "test\"nested\"quotes";
+    }
+}
diff --git a/test/fixtures/issue_5.sol b/test/fixtures/issue_5.sol
new file mode 100644
index 0000000..d29fb16
--- /dev/null
+++ b/test/fixtures/issue_5.sol
@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+// Test case for Issue #5: Indentation problems
+// Multi-line function calls and event definitions
+
+contract IndentationTest {
+    event Transfer(
+        address indexed from,
+        address indexed to,
+        uint256 value
+    );
+
+    event ComplexEvent(
+        address indexed user,
+        uint256 amount,
+        bytes data,
+        bool success
+    );
+
+    function multiLineCall() public {
+        // Multi-line function call with arguments
+        someFunction(
+            arg1,
+            arg2,
+            arg3
+        );
+
+        // Chained method calls
+        address(this)
+            .call(data)
+            .data;
+
+        // For loop with method call
+        for (uint256 i = 0; i < 10; i++) {
+            someArray.push(
+                i * 2
+            );
+        }
+    }
+
+    function multiLineSignature(
+        uint256 arg1,
+        address arg2,
+        bytes memory arg3
+    ) public pure returns (
+        uint256 result1,
+        bool result2
+    ) {
+        return (arg1, true);
+    }
+
+    // Function with modifiers
+    function withModifiers(
+        uint256 x
+    )
+        public
+        payable
+        onlyOwner
+        whenNotPaused
+        returns (uint256)
+    {
+        return x * 2;
+    }
+
+    modifier onlyOwner() { _; }
+    modifier whenNotPaused() { _; }
+}
diff --git a/test/fixtures/modern.sol b/test/fixtures/modern.sol
new file mode 100644
index 0000000..5553ec6
--- /dev/null
+++ b/test/fixtures/modern.sol
@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// Test file for modern Solidity 0.8.x features
+
+// Custom error (0.8.4+)
+error InsufficientBalance(uint256 available, uint256 required);
+error Unauthorized();
+
+// User-defined value type (0.8.18+)
+type UFixed256x18 is uint256;
+type Price is uint128;
+
+// Using global (0.8.19+)
+library Math {
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a + b;
+    }
+}
+
+using Math for uint256 global;
+
+contract ModernFeatures {
+    // Transient storage (0.8.24+)
+    transient uint256 temporaryValue;
+
+    uint256 balance;
+
+    // Unchecked block (0.8.0+)
+    function increment(uint256 x) public pure returns (uint256) {
+        unchecked {
+            return x + 1;
+        }
+    }
+
+    // Revert with custom error
+    function withdraw(uint256 amount) public {
+        if (amount > balance) {
+            revert InsufficientBalance({
+                available: balance,
+                required: amount
+            });
+        }
+        balance -= amount;
+    }
+
+    // bytes.concat and string.concat
+    function concatenateBytes(bytes memory a, bytes memory b) public pure returns (bytes memory) {
+        return bytes.concat(a, b);
+    }
+
+    function concatenateStrings(string memory a, string memory b) public pure returns (string memory) {
+        return string.concat(a, b);
+    }
+
+    // Fallback and receive (special functions)
+    receive() external payable {}
+
+    fallback() external payable {}
+}
diff --git a/test/vader/folding.vader b/test/vader/folding.vader
new file mode 100644
index 0000000..c0868a5
--- /dev/null
+++ b/test/vader/folding.vader
@@ -0,0 +1,87 @@
+" Code folding tests for vim-solidity
+
+Before:
+  set rtp+=.
+  filetype plugin indent on
+  syntax enable
+  set foldmethod=syntax
+  set foldlevel=0
+
+After:
+  %bwipeout!
+  set foldmethod=manual
+
+# ==============================================================================
+# Function Folding
+# ==============================================================================
+
+Given solidity (function with body):
+  function test() public {
+      uint256 x = 1;
+      uint256 y = 2;
+      return x + y;
+  }
+
+Execute (function body should be foldable):
+  normal! gg
+  " Check that fold exists
+  let l:foldlevel = foldlevel(1)
+  AssertNotEqual 0, l:foldlevel
+
+# ==============================================================================
+# Contract Folding (Issue #11)
+# ==============================================================================
+
+Given solidity (contract with body):
+  contract MyContract {
+      uint256 public value;
+
+      function setValue(uint256 _value) public {
+          value = _value;
+      }
+  }
+
+Execute (contract body should be foldable):
+  normal! gg
+  " Find the opening brace line
+  normal! /{
+  let l:contract_line = line('.')
+  " Contract body should have a fold
+  let l:foldlevel = foldlevel(l:contract_line + 1)
+  " If contract folding is working, there should be a fold level
+  AssertNotEqual 0, l:foldlevel
+
+# ==============================================================================
+# Assembly Folding
+# ==============================================================================
+
+Given solidity (assembly block):
+  function test() public {
+      assembly {
+          let x := 1
+          let y := 2
+      }
+  }
+
+Execute (assembly block should be foldable):
+  normal! /assembly
+  normal! /{
+  let l:asm_line = line('.')
+  let l:foldlevel = foldlevel(l:asm_line + 1)
+  AssertNotEqual 0, l:foldlevel
+
+# ==============================================================================
+# Multi-line Comment Folding
+# ==============================================================================
+
+Given solidity (multi-line comment):
+  /*
+   * This is a multi-line comment
+   * with several lines
+   */
+
+Execute (multi-line comment should be foldable):
+  normal! gg
+  let l:foldlevel = foldlevel(1)
+  " Comments should have fold support
+  AssertNotEqual 0, l:foldlevel
diff --git a/test/vader/indent.vader b/test/vader/indent.vader
new file mode 100644
index 0000000..9933219
--- /dev/null
+++ b/test/vader/indent.vader
@@ -0,0 +1,176 @@
+" Indentation tests for vim-solidity
+
+Before:
+  set rtp+=.
+  filetype plugin indent on
+  syntax enable
+
+After:
+  %bwipeout!
+
+# ==============================================================================
+# Basic Indentation
+# ==============================================================================
+
+Given solidity (contract with function):
+  contract Test {
+  function foo() public {
+  uint256 x = 1;
+  }
+  }
+
+Execute (indent entire buffer):
+  normal! gg=G
+
+Expect solidity (properly indented):
+  contract Test {
+      function foo() public {
+          uint256 x = 1;
+      }
+  }
+
+# ==============================================================================
+# Multi-line Function Signature (Issue #5)
+# ==============================================================================
+
+Given solidity (multi-line function signature):
+  function test(
+  uint256 arg1,
+  address arg2
+  ) public returns (uint256) {
+  return arg1;
+  }
+
+Execute (indent entire buffer):
+  normal! gg=G
+
+Expect solidity (properly indented multi-line):
+  function test(
+      uint256 arg1,
+      address arg2
+  ) public returns (uint256) {
+      return arg1;
+  }
+
+# ==============================================================================
+# Multi-line Function Call (Issue #5)
+# ==============================================================================
+
+Given solidity (multi-line function call):
+  function test() public {
+  someFunction(
+  arg1,
+  arg2,
+  arg3
+  );
+  }
+
+Execute (indent entire buffer):
+  normal! gg=G
+
+Expect solidity (properly indented call):
+  function test() public {
+      someFunction(
+          arg1,
+          arg2,
+          arg3
+      );
+  }
+
+# ==============================================================================
+# Event Definition (Issue #5)
+# ==============================================================================
+
+Given solidity (multi-line event):
+  event Transfer(
+  address indexed from,
+  address indexed to,
+  uint256 value
+  );
+
+Execute (indent entire buffer):
+  normal! gg=G
+
+Expect solidity (properly indented event):
+  event Transfer(
+      address indexed from,
+      address indexed to,
+      uint256 value
+  );
+
+# ==============================================================================
+# If/Else Blocks
+# ==============================================================================
+
+Given solidity (if else blocks):
+  function test() public {
+  if (condition) {
+  doSomething();
+  } else {
+  doSomethingElse();
+  }
+  }
+
+Execute (indent entire buffer):
+  normal! gg=G
+
+Expect solidity (properly indented if/else):
+  function test() public {
+      if (condition) {
+          doSomething();
+      } else {
+          doSomethingElse();
+      }
+  }
+
+# ==============================================================================
+# Nested Blocks
+# ==============================================================================
+
+Given solidity (nested blocks):
+  contract Test {
+  function outer() public {
+  if (true) {
+  for (uint i = 0; i < 10; i++) {
+  inner();
+  }
+  }
+  }
+  }
+
+Execute (indent entire buffer):
+  normal! gg=G
+
+Expect solidity (properly indented nested blocks):
+  contract Test {
+      function outer() public {
+          if (true) {
+              for (uint i = 0; i < 10; i++) {
+                  inner();
+              }
+          }
+      }
+  }
+
+# ==============================================================================
+# Assembly Blocks
+# ==============================================================================
+
+Given solidity (assembly block):
+  function test() public {
+  assembly {
+  let x := 1
+  sstore(0, x)
+  }
+  }
+
+Execute (indent entire buffer):
+  normal! gg=G
+
+Expect solidity (properly indented assembly):
+  function test() public {
+      assembly {
+          let x := 1
+          sstore(0, x)
+      }
+  }
diff --git a/test/vader/syntax.vader b/test/vader/syntax.vader
new file mode 100644
index 0000000..1a33c90
--- /dev/null
+++ b/test/vader/syntax.vader
@@ -0,0 +1,167 @@
+" Syntax highlighting tests for vim-solidity
+
+" Helper function is defined in test/vimrc
+
+Before:
+  set rtp+=.
+  filetype plugin indent on
+  syntax enable
+
+After:
+  %bwipeout!
+
+# ==============================================================================
+# Modern Solidity 0.8.x Keywords
+# ==============================================================================
+
+Given solidity (transient keyword):
+  contract Test {
+      transient uint256 value;
+  }
+
+Execute (transient should be highlighted as keyword):
+  normal! /transient
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'solKeyword', l:group
+
+Given solidity (unchecked block):
+  function test() public {
+      unchecked {
+          x++;
+      }
+  }
+
+Execute (unchecked should be highlighted as keyword):
+  normal! /unchecked
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'solKeyword', l:group
+
+Given solidity (custom error):
+  error InsufficientBalance(uint256 available, uint256 required);
+
+Execute (error should be highlighted as keyword):
+  normal! /error
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'solKeyword', l:group
+
+Given solidity (fallback function):
+  fallback() external payable {}
+
+Execute (fallback should be highlighted as keyword):
+  normal! /fallback
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'solKeyword', l:group
+
+Given solidity (receive function):
+  receive() external payable {}
+
+Execute (receive should be highlighted as keyword):
+  normal! /receive
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'solKeyword', l:group
+
+# ==============================================================================
+# Issue #15: String Literal Bug
+# ==============================================================================
+
+Given solidity (string with function signature):
+  bytes32 hash = keccak256(bytes("submitSomething(bytes)"));
+  uint256 value = 42;
+
+Execute (string should close properly and value should highlight correctly):
+  " Check that string is highlighted
+  normal! /"submitSomething
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'solString', l:group
+
+  " Check that content after string is highlighted correctly
+  normal! /value
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  " Should be highlighted as identifier (no specific group) or Number group
+  " The important thing is it's NOT solString
+  AssertNotEqual 'solString', l:group
+
+Given solidity (multiple strings with parens):
+  string memory a = "func(uint256)";
+  string memory b = "other(bytes)";
+
+Execute (both strings should be highlighted independently):
+  normal! /"func
+  let l:group1 = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'solString', l:group1
+
+  normal! /"other
+  let l:group2 = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'solString', l:group2
+
+# ==============================================================================
+# Basic Syntax Elements
+# ==============================================================================
+
+Given solidity (contract declaration):
+  contract MyContract {
+  }
+
+Execute (contract should be highlighted as Type):
+  normal! /contract
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'solContract', l:group
+
+  normal! /MyContract
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'solContractName', l:group
+
+Given solidity (function declaration):
+  function test() public pure returns (uint256) {
+      return 42;
+  }
+
+Execute (function elements should be highlighted correctly):
+  normal! /function
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'solFunction', l:group
+
+  normal! /test
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'solFuncName', l:group
+
+  normal! /public
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'solKeyword', l:group
+
+  normal! /uint256
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'solBuiltinType', l:group
+
+Given solidity (comments and natspec):
+  /// @notice This is a natspec comment
+  // Regular comment
+  /* Block comment */
+
+Execute (comments should be highlighted):
+  normal! gg
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'solLineComment', l:group
+
+# ==============================================================================
+# Assembly / Yul
+# ==============================================================================
+
+Given solidity (assembly block):
+  assembly {
+      let x := add(1, 2)
+      sstore(0, x)
+  }
+
+Execute (assembly keywords should be highlighted):
+  normal! /assembly
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'yul', l:group
+
+  normal! /add
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'yulAssemblyOp', l:group
+
+  normal! /sstore
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'yulAssemblyOp', l:group
diff --git a/test/vimrc b/test/vimrc
new file mode 100644
index 0000000..56837f0
--- /dev/null
+++ b/test/vimrc
@@ -0,0 +1,19 @@
+" Minimal vimrc for testing
+set nocompatible
+
+" Add vader.vim to runtimepath
+set rtp+=test/vader.vim
+
+" Add vim-solidity to runtimepath
+set rtp+=.
+
+" Load filetype detection, plugins, and indent
+filetype plugin indent on
+syntax enable
+
+" Helper function to get syntax group at cursor
+function! SyntaxOf(pattern)
+  let l:line = search(a:pattern, 'cn')
+  let l:col = match(getline(l:line), a:pattern) + 1
+  return synIDattr(synID(l:line, l:col, 1), 'name')
+endfunction

From aa5dd9c9e91794e065abae3ad46be0dbc79cbce6 Mon Sep 17 00:00:00 2001
From: Matt Luongo <mhluongo@gmail.com>
Date: Tue, 13 Jan 2026 10:54:15 -0500
Subject: [PATCH 02/11] Add Solidity 0.8.x modern syntax support...

... include transient, unchecked, error, fallback and receive, global,
and user-defined types.
---
 syntax/solidity.vim | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/syntax/solidity.vim b/syntax/solidity.vim
index c390ff7..6e03040 100644
--- a/syntax/solidity.vim
+++ b/syntax/solidity.vim
@@ -11,9 +11,9 @@ endif
 " contract, library and event are defined at bottom of file
 syn keyword solKeyword           abstract anonymous as break calldata case catch constant constructor continue default switch revert require
 syn keyword solKeyword           ecrecover addmod mulmod keccak256
-syn keyword solKeyword           delete do else emit enum external final for function if immutable import in indexed inline
+syn keyword solKeyword           delete do else emit enum error external fallback final for function global if immutable import in indexed inline
 syn keyword solKeyword           interface internal is let match memory modifier new of payable pragma private public pure override virtual
-syn keyword solKeyword           relocatable return returns static storage struct throw try type typeof using
+syn keyword solKeyword           receive relocatable return returns static storage struct throw transient try type typeof unchecked using
 syn keyword solKeyword           var view while
 syn keyword solConstant          true false wei szabo finney ether seconds minutes hours days weeks years now
 syn keyword solConstant          abi block blockhash msg tx this super selfdestruct
@@ -139,6 +139,16 @@ syn match   solContractCommas    contained ','
 hi def link solContract          Type
 hi def link solContractName      Function
 
+" User-defined value types (0.8.18+)
+" Matches: type UFixed256x18 is uint256;
+syn match   solTypeDefinition    /\<type\>/ nextgroup=solTypeDefName skipwhite
+syn match   solTypeDefName       contained /\<[a-zA-Z_$][0-9a-zA-Z_$]*/ nextgroup=solTypeDefIs skipwhite
+syn keyword solTypeDefIs         contained is nextgroup=solBuiltinType skipwhite
+
+hi def link solTypeDefinition    Keyword
+hi def link solTypeDefName       Type
+hi def link solTypeDefIs         Keyword
+
 " Event
 syn match   solEvent             /\<event\>/ nextgroup=solEventName,solEventArgs skipwhite
 syn match   solEventName         contained /\<[a-zA-Z_$][0-9a-zA-Z_$]*/ nextgroup=solEventArgs skipwhite

From 68a2ba2dd8f0c90a259f0c0c675378c678122893 Mon Sep 17 00:00:00 2001
From: Matt Luongo <mhluongo@gmail.com>
Date: Tue, 13 Jan 2026 10:55:01 -0500
Subject: [PATCH 03/11] Enable contract-level folds w foldmethod=syntax

Fixes #11
---
 syntax/solidity.vim         |  5 +++--
 test/fixtures/fold_test.sol | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 35 insertions(+), 2 deletions(-)
 create mode 100644 test/fixtures/fold_test.sol

diff --git a/syntax/solidity.vim b/syntax/solidity.vim
index 6e03040..72c3bca 100644
--- a/syntax/solidity.vim
+++ b/syntax/solidity.vim
@@ -131,10 +131,11 @@ hi def link yulAssemblyOp       Keyword
 
 " Contract
 syn match   solContract          /\<\%(contract\|library\|interface\)\>/ nextgroup=solContractName skipwhite
-syn match   solContractName      contained /\<[a-zA-Z_$][0-9a-zA-Z_$]*/ nextgroup=solContractParent skipwhite
-syn region  solContractParent    contained start='is' end='{' contains=solContractName,solContractNoise,solContractCommas skipwhite skipempty
+syn match   solContractName      contained /\<[a-zA-Z_$][0-9a-zA-Z_$]*/ nextgroup=solContractParent,solContractBody skipwhite
+syn region  solContractParent    contained start='is' end='{' contains=solContractName,solContractNoise,solContractCommas nextgroup=solContractBody skipwhite skipempty
 syn match   solContractNoise     contained 'is' containedin=solContractParent
 syn match   solContractCommas    contained ','
+syn region  solContractBody      contained start='{' end='}' fold transparent
 
 hi def link solContract          Type
 hi def link solContractName      Function
diff --git a/test/fixtures/fold_test.sol b/test/fixtures/fold_test.sol
new file mode 100644
index 0000000..c9faec3
--- /dev/null
+++ b/test/fixtures/fold_test.sol
@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+// Test file for code folding
+
+contract SimpleContract {
+    uint256 public value;
+
+    function setValue(uint256 _value) public {
+        value = _value;
+    }
+
+    function getValue() public view returns (uint256) {
+        return value;
+    }
+}
+
+library MathLib {
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a + b;
+    }
+}
+
+interface IToken {
+    function transfer(address to, uint256 amount) external returns (bool);
+}
+
+contract ContractWithInheritance is SimpleContract {
+    function doubleValue() public {
+        value = value * 2;
+    }
+}

From d14b3845e4b66cf2e0f3fd5842001a0c400b67ea Mon Sep 17 00:00:00 2001
From: Matt Luongo <mhluongo@gmail.com>
Date: Tue, 13 Jan 2026 10:55:38 -0500
Subject: [PATCH 04/11] Add Foundry ft detection (.t.sol, .s.sol)

---
 ftdetect/solidity.vim |  7 +++++++
 ftplugin/solidity.vim | 10 ++++++++++
 2 files changed, 17 insertions(+)

diff --git a/ftdetect/solidity.vim b/ftdetect/solidity.vim
index 8da9631..85ba14d 100644
--- a/ftdetect/solidity.vim
+++ b/ftdetect/solidity.vim
@@ -1 +1,8 @@
+" Standard Solidity files
 au BufNewFile,BufRead *.sol setf solidity
+
+" Foundry test files (.t.sol)
+au BufNewFile,BufRead *.t.sol setf solidity
+
+" Foundry script files (.s.sol)
+au BufNewFile,BufRead *.s.sol setf solidity
diff --git a/ftplugin/solidity.vim b/ftplugin/solidity.vim
index d23c51c..19d2bf8 100644
--- a/ftplugin/solidity.vim
+++ b/ftplugin/solidity.vim
@@ -1,3 +1,13 @@
+" Comment settings
 setlocal comments=s1:/*,mb:*,ex:*/,:///,://
 setlocal commentstring=//\ %s
 setlocal formatoptions+=croqn
+
+" Detect file type based on extension
+if expand('%:t') =~? '\.t\.sol$'
+    let b:solidity_file_type = 'test'
+elseif expand('%:t') =~? '\.s\.sol$'
+    let b:solidity_file_type = 'script'
+else
+    let b:solidity_file_type = 'contract'
+endif

From 8d20d60741b485a1f5d5eef7f8e68260452d86c7 Mon Sep 17 00:00:00 2001
From: Matt Luongo <mhluongo@gmail.com>
Date: Tue, 13 Jan 2026 10:56:58 -0500
Subject: [PATCH 05/11] Add CHANGELOG and CONTRIBUTING documentation

---
 CHANGELOG.md    |  87 +++++++++++++++
 CONTRIBUTING.md | 285 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 372 insertions(+)
 create mode 100644 CHANGELOG.md
 create mode 100644 CONTRIBUTING.md

diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..e54812f
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,87 @@
+# Changelog
+
+All notable changes to vim-solidity will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- Comprehensive testing infrastructure with vader.vim
+- GitHub Actions CI for automated testing
+- Solidity 0.8.24 `transient` keyword support
+- Solidity 0.8.19 `using ... global` syntax support
+- Solidity 0.8.18 user-defined value types (`type Foo is uint256`)
+- Solidity 0.8.4 `error` keyword for custom errors
+- `unchecked` block syntax (0.8.0+)
+- `fallback()` and `receive()` special function keywords
+- `global` keyword for library attachments
+- Contract-level code folding for contracts, libraries, and interfaces
+- Foundry test file detection (`.t.sol` extension)
+- Foundry script file detection (`.s.sol` extension)
+- Buffer-local variable `b:solidity_file_type` to distinguish file types
+- Test fixtures for modern Solidity features, indentation, and folding
+- Comprehensive test suites for syntax, indentation, and folding
+
+### Fixed
+- Contract bodies can now be folded (Issue #11)
+
+### Changed
+- Enhanced ftdetect to recognize Foundry file naming conventions
+- Improved syntax highlighting for modern Solidity 0.8.x features
+- Updated maintainer information
+
+## [0.7.0] - 2021-01-17
+
+### Changed
+- Leave foldmethod to be configured by the user
+- Fix syntax file maintainer
+
+### Added
+- Add 'require' to keywords
+- Add 'revert' to keywords
+- Add Yul opcode dialect
+- Ensure Yul ops only highlight in assembly blocks
+- Add 'switch' to statements
+
+### Improved
+- Better handling of comments and doc comments
+- Enhanced NatSpec comment support
+
+---
+
+## Migration Notes
+
+### From 0.7.0 to Unreleased
+
+If you were using the old vim-solidity, the main changes are:
+
+1. **Modern Solidity Support**: All Solidity 0.8.x features are now supported
+2. **Contract Folding**: Enable with `set foldmethod=syntax` to fold entire contracts
+3. **Foundry Support**: `.t.sol` and `.s.sol` files are automatically recognized
+4. **Testing**: The plugin now has comprehensive automated tests
+
+### Future Breaking Changes
+
+No breaking changes are planned. The plugin maintains backward compatibility
+with Vim 8.0+ and works in Neovim (though Neovim users may prefer solidity.nvim
+for LSP features).
+
+---
+
+## Version History
+
+- **Unreleased**: Modern Solidity 0.8.x support, testing infrastructure, Foundry integration
+- **0.7.0**: Yul support, comment improvements, basic keyword additions
+- **Earlier versions**: See git history
+
+---
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines on contributing to vim-solidity.
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..1f44c2a
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,285 @@
+# Contributing to vim-solidity
+
+Thank you for your interest in contributing to vim-solidity! This document provides guidelines and instructions for contributing.
+
+## Table of Contents
+
+- [Code of Conduct](#code-of-conduct)
+- [How Can I Contribute?](#how-can-i-contribute)
+- [Development Setup](#development-setup)
+- [Testing](#testing)
+- [Submitting Changes](#submitting-changes)
+- [Style Guidelines](#style-guidelines)
+
+## Code of Conduct
+
+This project follows the Contributor Covenant Code of Conduct. By participating, you are expected to uphold this code. Please report unacceptable behavior to the maintainers.
+
+## How Can I Contribute?
+
+### Reporting Bugs
+
+Before creating a bug report, please check existing issues to avoid duplicates. When creating a bug report, include:
+
+- **Description**: Clear description of the problem
+- **Steps to reproduce**: Minimal steps to reproduce the issue
+- **Expected behavior**: What you expected to happen
+- **Actual behavior**: What actually happened
+- **Environment**: Vim version, OS, terminal emulator
+- **Sample code**: Minimal Solidity code that demonstrates the issue
+
+### Suggesting Enhancements
+
+Enhancement suggestions are welcome! Please provide:
+
+- **Use case**: Why is this enhancement useful?
+- **Proposed solution**: How would you like it to work?
+- **Alternatives**: Other approaches you've considered
+- **Examples**: Code examples if applicable
+
+### Pull Requests
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes
+4. Add tests if applicable
+5. Run the test suite
+6. Commit your changes (see commit guidelines below)
+7. Push to your branch
+8. Open a Pull Request
+
+## Development Setup
+
+### Prerequisites
+
+- Vim 8.0+ or Neovim
+- Git
+- [vader.vim](https://github.com/junegunn/vader.vim) for testing
+
+### Clone and Setup
+
+```bash
+# Clone your fork
+git clone https://github.com/YOUR_USERNAME/vim-solidity.git
+cd vim-solidity
+
+# Clone vader.vim for testing
+git clone https://github.com/junegunn/vader.vim.git test/vader.vim
+```
+
+### File Structure
+
+```
+vim-solidity/
+├── ftdetect/      # File type detection
+├── ftplugin/      # File type plugin settings
+├── indent/        # Indentation logic
+├── syntax/        # Syntax highlighting
+├── test/          # Test suite
+│   ├── vader/     # Vader test files
+│   ├── fixtures/  # Test Solidity files
+│   └── vimrc      # Test configuration
+└── README.md
+```
+
+## Testing
+
+### Running Tests Locally
+
+```bash
+# Run all tests
+vim -Nu test/vimrc -c 'Vader! test/vader/*.vader'
+
+# Run specific test file
+vim -Nu test/vimrc -c 'Vader! test/vader/syntax.vader'
+
+# Run interactively (for debugging)
+vim -Nu test/vimrc -c 'Vader test/vader/syntax.vader'
+```
+
+### Writing Tests
+
+We use [vader.vim](https://github.com/junegunn/vader.vim) for testing. Tests are located in `test/vader/`.
+
+**Example syntax test:**
+```vader
+Given solidity (test description):
+  contract Test {
+      uint256 value;
+  }
+
+Execute (check syntax highlighting):
+  normal! /uint256
+  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  AssertEqual 'solBuiltinType', l:group
+```
+
+**Example indentation test:**
+```vader
+Given solidity (unindented code):
+  contract Test {
+  function foo() {
+  return 1;
+  }
+  }
+
+Execute (indent buffer):
+  normal! gg=G
+
+Expect solidity (properly indented):
+  contract Test {
+      function foo() {
+          return 1;
+      }
+  }
+```
+
+### Manual Testing
+
+Use the test fixtures to manually verify changes:
+
+```bash
+# Open a test file
+vim test/fixtures/modern.sol
+
+# Check syntax highlighting
+:syn list
+
+# Test indentation
+gg=G
+
+# Test folding
+:set foldmethod=syntax
+zM
+zR
+```
+
+## Submitting Changes
+
+### Commit Messages
+
+Follow these guidelines for commit messages:
+
+```
+Add brief summary (50 characters or less)
+
+More detailed explanation if needed. Wrap at 72 characters.
+
+- Use bullet points for multiple changes
+- Reference issues: "Fixes #123" or "Closes #456"
+- Explain the why, not just the what
+
+Co-Authored-By: Name <email@example.com>
+```
+
+**Examples:**
+```
+Add transient keyword support (0.8.24+)
+
+- Add transient to solKeyword list
+- Update syntax tests
+- Add test fixture with transient storage
+
+Fixes #45
+```
+
+### Pull Request Guidelines
+
+- **One feature per PR**: Keep PRs focused on a single feature or fix
+- **Update tests**: Add or update tests for your changes
+- **Update documentation**: Update README.md if adding user-facing features
+- **Update CHANGELOG**: Add an entry to CHANGELOG.md under "Unreleased"
+- **Pass CI**: Ensure GitHub Actions tests pass
+- **Clean history**: Rebase and squash commits if needed
+
+### PR Template
+
+Your PR description should include:
+
+```markdown
+## Description
+Brief description of the changes
+
+## Motivation
+Why is this change needed?
+
+## Changes
+- List of specific changes
+- What was added/modified/removed
+
+## Testing
+- How was this tested?
+- Which test cases were added/updated?
+
+## Checklist
+- [ ] Tests pass locally
+- [ ] Added/updated tests for changes
+- [ ] Updated CHANGELOG.md
+- [ ] Updated README.md if needed
+- [ ] Follows style guidelines
+```
+
+## Style Guidelines
+
+### VimL Style
+
+- **Indentation**: 4 spaces (no tabs)
+- **Line length**: 80 characters where reasonable
+- **Comments**: Use `"` for comments, be descriptive
+- **Variables**: Use descriptive names (`l:` for local, `b:` for buffer)
+- **Functions**: PascalCase for user functions, snake_case for private
+
+**Example:**
+```vim
+" Check if current line is a function definition
+function! s:is_function_line(lnum)
+    let l:line = getline(a:lnum)
+    return l:line =~# '^\s*function\>'
+endfunction
+```
+
+### Syntax Highlighting Rules
+
+- **Keyword groups**: Use `solKeyword`, `solConstant`, `solBuiltinType`
+- **Regions**: Use `fold` option for foldable blocks
+- **Contains**: Be specific about what regions can contain
+- **Highlighting**: Link to standard highlight groups when possible
+
+### Test Style
+
+- **Descriptive names**: Test names should clearly state what they test
+- **One concept per test**: Each test should verify one thing
+- **Fixtures**: Add complex test cases to `test/fixtures/`
+- **Comments**: Explain non-obvious test logic
+
+## Solidity Version Support
+
+vim-solidity aims to support:
+
+- **Current**: Latest stable Solidity version (currently 0.8.x)
+- **Recent**: Previous minor versions still in common use
+- **Future**: New features added as they're released
+
+When adding support for new Solidity features:
+
+1. Reference the Solidity version in comments
+2. Add test cases using the new feature
+3. Update CHANGELOG with version info
+4. Consider backward compatibility
+
+## Getting Help
+
+- **Questions**: Open a GitHub Discussion
+- **Bugs**: Open an issue with the bug template
+- **Features**: Open an issue with the feature template
+- **Chat**: Mention @thesis/vim-solidity maintainers
+
+## Recognition
+
+Contributors are recognized in several ways:
+
+- Mentioned in commit messages (Co-Authored-By)
+- Listed in All Contributors (see README)
+- Highlighted in release notes for major contributions
+
+Thank you for contributing to vim-solidity!

From c00459340f4c7ca8651b5e3fec9edf08a32bbf0c Mon Sep 17 00:00:00 2001
From: Matt Luongo <mhluongo@gmail.com>
Date: Tue, 13 Jan 2026 10:57:30 -0500
Subject: [PATCH 06/11] Add GitHub issue templates

---
 .github/ISSUE_TEMPLATE/bug_report.md      | 57 +++++++++++++++++++++++
 .github/ISSUE_TEMPLATE/feature_request.md | 57 +++++++++++++++++++++++
 .github/ISSUE_TEMPLATE/question.md        | 43 +++++++++++++++++
 3 files changed, 157 insertions(+)
 create mode 100644 .github/ISSUE_TEMPLATE/bug_report.md
 create mode 100644 .github/ISSUE_TEMPLATE/feature_request.md
 create mode 100644 .github/ISSUE_TEMPLATE/question.md

diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 0000000..adc9719
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,57 @@
+---
+name: Bug Report
+about: Report a bug or unexpected behavior
+title: '[BUG] '
+labels: bug
+assignees: ''
+---
+
+## Bug Description
+
+A clear and concise description of what the bug is.
+
+## Steps to Reproduce
+
+1. Open Vim with '...'
+2. Edit Solidity file containing '...'
+3. Perform action '...'
+4. See error/unexpected behavior
+
+## Expected Behavior
+
+A clear description of what you expected to happen.
+
+## Actual Behavior
+
+What actually happened instead.
+
+## Minimal Solidity Code Example
+
+```solidity
+// Minimal code that reproduces the issue
+contract Example {
+    // ...
+}
+```
+
+## Environment
+
+- **Vim version**: (output of `vim --version`)
+- **OS**: (e.g., Ubuntu 22.04, macOS 14.0, Windows 11)
+- **Terminal**: (e.g., iTerm2, Windows Terminal, GNOME Terminal)
+- **vim-solidity version/commit**: (e.g., v0.8.0 or commit hash)
+- **Solidity version**: (if relevant, e.g., 0.8.24)
+
+## Additional Context
+
+Add any other context about the problem here, such as:
+- Does it happen with a minimal vimrc?
+- Related Vim plugins that might interact?
+- Screenshots if applicable
+
+## Checklist
+
+- [ ] I have searched existing issues for duplicates
+- [ ] I have tested with a minimal vimrc (`vim -Nu test/vimrc`)
+- [ ] I have provided a minimal code example
+- [ ] I have included my environment details
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 0000000..2b2fc20
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,57 @@
+---
+name: Feature Request
+about: Suggest a new feature or enhancement
+title: '[FEATURE] '
+labels: enhancement
+assignees: ''
+---
+
+## Feature Description
+
+A clear and concise description of the feature you'd like to see.
+
+## Motivation / Use Case
+
+Why is this feature useful? What problem does it solve?
+
+## Proposed Solution
+
+How would you like this feature to work? Be as specific as possible.
+
+```vim
+" Example configuration or usage
+```
+
+```solidity
+// Example Solidity code if applicable
+```
+
+## Alternatives Considered
+
+What other approaches or workarounds have you considered?
+
+## Compatibility
+
+- Is this feature specific to a Solidity version? (e.g., 0.8.x only)
+- Should it work in both Vim and Neovim?
+- Does it depend on external tools? (e.g., solc, forge)
+
+## Scope
+
+- [ ] Syntax highlighting
+- [ ] Indentation
+- [ ] Code folding
+- [ ] File type detection
+- [ ] Toolchain integration (compiler, formatter)
+- [ ] Documentation
+- [ ] Other (please specify)
+
+## Additional Context
+
+Add any other context, mockups, screenshots, or examples about the feature request here.
+
+## Checklist
+
+- [ ] I have searched existing issues for similar requests
+- [ ] I have checked the [roadmap/plan](link-to-plan-if-available)
+- [ ] This feature aligns with pure Vim compatibility (no Neovim-only features)
diff --git a/.github/ISSUE_TEMPLATE/question.md b/.github/ISSUE_TEMPLATE/question.md
new file mode 100644
index 0000000..0ee44cf
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/question.md
@@ -0,0 +1,43 @@
+---
+name: Question
+about: Ask a question about using vim-solidity
+title: '[QUESTION] '
+labels: question
+assignees: ''
+---
+
+## Question
+
+What would you like to know about vim-solidity?
+
+## Context
+
+Provide context about what you're trying to accomplish:
+
+- What are you trying to do?
+- What have you already tried?
+- What's not working as expected?
+
+## Configuration
+
+If relevant, share your Vim configuration:
+
+```vim
+" Relevant parts of your .vimrc
+```
+
+## Environment
+
+- **Vim version**: (output of `vim --version`)
+- **vim-solidity version**: (e.g., v0.8.0 or commit hash)
+
+## Additional Information
+
+Any other details that might be helpful.
+
+---
+
+**Note**: For general Vim or Solidity questions unrelated to this plugin, you may find better help at:
+- [Vi and Vim Stack Exchange](https://vi.stackexchange.com/)
+- [Ethereum Stack Exchange](https://ethereum.stackexchange.com/)
+- [Solidity Documentation](https://docs.soliditylang.org/)

From 76e3e7f645f221808e775d29d9fb76f2f96d9a9d Mon Sep 17 00:00:00 2001
From: Matt Luongo <mhluongo@gmail.com>
Date: Tue, 13 Jan 2026 10:58:28 -0500
Subject: [PATCH 07/11] Revamp README

---
 README.md | 295 +++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 280 insertions(+), 15 deletions(-)

diff --git a/README.md b/README.md
index 2b868a2..0bb3b1e 100644
--- a/README.md
+++ b/README.md
@@ -1,37 +1,80 @@
 # vim-solidity
 
-Maintained syntax files for [Solidity](https://github.com/ethereum/solidity),
-the smart contract programming language for Ethereum.
+[![Version](https://img.shields.io/github/v/tag/thesis/vim-solidity)](https://github.com/thesis/vim-solidity/tags)
+[![License](https://img.shields.io/github/license/thesis/vim-solidity)](LICENSE)
+[![Test](https://github.com/thesis/vim-solidity/actions/workflows/test.yml/badge.svg)](https://github.com/thesis/vim-solidity/actions/workflows/test.yml)
+
+**The actively maintained Solidity plugin for Vim.**
+
+Comprehensive syntax highlighting, indentation, and code folding for [Solidity](https://soliditylang.org/), the smart contract programming language for Ethereum. Supports Solidity 0.8.x with all modern language features.
+
+## Features
+
+- ✅ **Modern Solidity 0.8.x support**: All keywords through Solidity 0.8.24
+  - `transient` storage (0.8.24+)
+  - `unchecked` blocks (0.8.0+)
+  - Custom `error` declarations (0.8.4+)
+  - User-defined value types (`type Foo is uint256`, 0.8.18+)
+  - `using ... global` syntax (0.8.19+)
+  - `fallback()` and `receive()` functions
+- ✅ **Smart indentation**: Context-aware indentation for functions, contracts, and blocks
+- ✅ **Code folding**: Fold contracts, functions, and assembly blocks
+- ✅ **NatSpec support**: Syntax highlighting for `@param`, `@return`, `@notice`, etc.
+- ✅ **Yul/Assembly**: Full Yul opcode highlighting with proper scoping
+- ✅ **Foundry integration**: Automatic detection of `.t.sol` and `.s.sol` files
+- ✅ **Pure Vim**: No external dependencies, works in Vim 8.0+ and Neovim
 
 ## Installation
 
-### Pathogen
-Run the following command:
+### vim-plug
 
-```bash
-git clone https://github.com/thesis/vim-solidity.git ~/.vim/bundle/vim-solidity
+Add to your `~/.vimrc` or `~/.config/nvim/init.vim`:
+
+```vim
+Plug 'thesis/vim-solidity', { 'branch': 'main' }
 ```
 
+Then run `:PlugInstall`
+
 ### Vundle
-Add the following line to your `~/.vimrc`:
+
+Add to your `~/.vimrc`:
 
 ```vim
 Plugin 'thesis/vim-solidity'
 ```
 
-### Plug
-Add the following line to your `~/.vimrc`:
+Then run `:PluginInstall`
 
-```vim
-Plug 'thesis/vim-solidity', {'branch': 'main' }
+### Pathogen
+
+```bash
+git clone https://github.com/thesis/vim-solidity.git ~/.vim/bundle/vim-solidity
 ```
 
-### No Plugin Manager
+### Native Vim Packages (Vim 8+)
 
-Copy all of the files manually into your `~/.vim`.
+```bash
+mkdir -p ~/.vim/pack/plugins/start
+git clone https://github.com/thesis/vim-solidity.git ~/.vim/pack/plugins/start/vim-solidity
+```
+
+### Neovim with lazy.nvim
+
+```lua
+{
+  'thesis/vim-solidity',
+  branch = 'main',
+  ft = 'solidity',
+}
+```
 
 ## Configuration
 
+### Enable Code Folding
+
+Add to your `~/.vimrc`:
+
 ```vim
 augroup solidity_folding
     au!
@@ -39,5 +82,227 @@ augroup solidity_folding
 augroup END
 ```
 
-Will enable Solidity code-folding based on the included syntax file. This might
-have an impact on editing performance.
+**Usage:**
+- `zc` - Close fold under cursor
+- `zo` - Open fold under cursor
+- `zM` - Close all folds
+- `zR` - Open all folds
+
+### Comment Toggling
+
+vim-solidity works with [vim-commentary](https://github.com/tpope/vim-commentary):
+
+```vim
+Plug 'tpope/vim-commentary'
+```
+
+**Usage:**
+- `gcc` - Toggle comment on current line
+- `gc` in visual mode - Toggle comment on selection
+
+### Matchit Support
+
+Enable `%` jumping between Solidity constructs:
+
+```vim
+" In your .vimrc
+runtime macros/matchit.vim
+```
+
+**Supported matches:**
+- `contract` ↔ `}`
+- `function` ↔ `}`
+- `if` ↔ `else`
+- `try` ↔ `catch`
+- `assembly` ↔ `}`
+
+## Advanced Features
+
+### Foundry Workflow
+
+vim-solidity detects Foundry projects automatically:
+
+- `.t.sol` files → Test files
+- `.s.sol` files → Script files
+- Regular `.sol` files → Contract files
+
+A buffer-local variable `b:solidity_file_type` is set to `'test'`, `'script'`, or `'contract'`.
+
+### Syntax Highlighting
+
+All modern Solidity features are highlighted:
+
+```solidity
+// Custom errors (0.8.4+)
+error InsufficientBalance(uint256 available, uint256 required);
+
+// User-defined value types (0.8.18+)
+type UFixed256x18 is uint256;
+
+// Using global (0.8.19+)
+using SafeMath for uint256 global;
+
+// Transient storage (0.8.24+)
+contract Example {
+    transient uint256 temporaryValue;
+
+    // Unchecked arithmetic (0.8.0+)
+    function increment(uint256 x) public pure returns (uint256) {
+        unchecked {
+            return x + 1;
+        }
+    }
+}
+```
+
+### NatSpec Comments
+
+Full support for Solidity's documentation format:
+
+```solidity
+/// @title A title
+/// @author The author name
+/// @notice Explain to end users what this does
+/// @dev Explain to developers the extra details
+/// @param x Description of parameter x
+/// @return Description of return value
+function example(uint256 x) public returns (uint256) {
+    return x * 2;
+}
+```
+
+### Yul/Assembly
+
+Assembly blocks have proper syntax highlighting with scoped opcodes:
+
+```solidity
+function getCodeSize(address addr) public view returns (uint256 size) {
+    assembly {
+        size := extcodesize(addr)
+    }
+}
+```
+
+## Compatibility
+
+- **Vim**: 8.0 or later
+- **Neovim**: Fully compatible
+- **Solidity**: 0.8.0 through 0.8.24+ (backward compatible with 0.7.x)
+
+## Known Limitations
+
+This is a **pure Vim plugin** focused on syntax, indentation, and folding. It does not provide:
+
+- **Language Server Protocol (LSP)** features (go-to-definition, hover, rename)
+- **Linting** (use [ALE](https://github.com/dense-analysis/ale) or [Syntastic](https://github.com/vim-syntastic/syntastic))
+- **Code completion** (use LSP or [YouCompleteMe](https://github.com/ycm-core/YouCompleteMe))
+- **Compiler integration** (planned for future release)
+
+For full IDE features, you can set up an LSP client ([coc.nvim](https://github.com/neoclide/coc.nvim), [vim-lsp](https://github.com/prabirshrestha/vim-lsp), or native Neovim LSP) with a Solidity language server like [nomicfoundation/solidity-language-server](https://github.com/NomicFoundation/hardhat-vscode/tree/development/server).
+
+## Comparison with Other Plugins
+
+| Feature | vim-solidity (this) | tomlion/vim-solidity |
+|---------|---------------------|----------------------|
+| Actively maintained | ✅ Yes | ❌ Abandoned (5+ years) |
+| Vim support | ✅ Yes | ✅ Yes |
+| Neovim support | ✅ Yes | ✅ Yes |
+| Solidity 0.8.x | ✅ Yes | ❌ Partial |
+| Pure Vim | ✅ Yes | ✅ Yes |
+
+**Use vim-solidity if:**
+- You want actively maintained Solidity syntax support
+- You need modern Solidity 0.8.x features
+- You prefer a simple, dependency-free plugin
+- You work on remote servers via SSH
+- You want syntax highlighting and code folding that "just works"
+
+**For LSP features:**
+
+If you need go-to-definition, hover, rename, and other IDE features:
+- Set up an LSP client ([coc.nvim](https://github.com/neoclide/coc.nvim), [vim-lsp](https://github.com/prabirshrestha/vim-lsp), or native Neovim LSP)
+- Use a Solidity language server like [nomicfoundation/solidity-language-server](https://github.com/NomicFoundation/hardhat-vscode/tree/development/server)
+- vim-solidity works alongside LSP for syntax highlighting
+
+## Troubleshooting
+
+### Colors look wrong
+
+Your colorscheme may not define Solidity-specific groups. Try a different colorscheme or customize:
+
+```vim
+" In your .vimrc
+hi link solKeyword Statement
+hi link solBuiltinType Type
+hi link solConstant Constant
+```
+
+### Indentation is incorrect
+
+The indentation logic is based on JavaScript. For complex cases, you may need to manually adjust with `>>` and `<<`.
+
+Please report persistent indentation issues with a minimal example.
+
+### Folding doesn't work
+
+Make sure you've set `foldmethod`:
+
+```vim
+:set foldmethod=syntax
+```
+
+If folding is slow, try:
+
+```vim
+:set foldmethod=indent
+```
+
+## Contributing
+
+Contributions are welcome! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+### Development Setup
+
+```bash
+# Clone vader.vim for testing
+git clone https://github.com/junegunn/vader.vim.git test/vader.vim
+
+# Run tests
+vim -Nu test/vimrc -c 'Vader! test/vader/*.vader'
+```
+
+### Reporting Issues
+
+Before opening an issue:
+1. Check existing issues for duplicates
+2. Test with a minimal `.vimrc`
+3. Provide a minimal Solidity example
+4. Include your Vim version and OS
+
+Use our [issue templates](https://github.com/thesis/vim-solidity/issues/new/choose).
+
+## Related Projects
+
+- [Foundry](https://github.com/foundry-rs/foundry) - Ethereum development toolkit
+- [solc](https://github.com/ethereum/solidity) - The Solidity compiler
+- [Hardhat VSCode](https://github.com/NomicFoundation/hardhat-vscode) - Official Solidity LSP implementation
+- [coc.nvim](https://github.com/neoclide/coc.nvim) - LSP client for Vim/Neovim
+- [vim-lsp](https://github.com/prabirshrestha/vim-lsp) - Async LSP client for Vim
+
+## History
+
+This plugin is a maintained fork of [tomlion/vim-solidity](https://github.com/tomlion/vim-solidity), which has been inactive since 2018. It incorporates improvements from the Ethereum Foundation's fork and adds modern Solidity 0.8.x support.
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Maintainers
+
+- [Thesis](https://github.com/thesis)
+
+---
+
+**⭐ If you find vim-solidity useful, please star the repository!**
+
+Built with ❤️ for the Solidity and Vim communities.

From 0e40958348638bcc34c7d49f5fb35d623836a88f Mon Sep 17 00:00:00 2001
From: Matt Luongo <mhluongo@gmail.com>
Date: Tue, 13 Jan 2026 11:13:25 -0500
Subject: [PATCH 08/11] Fix string literal syntax highlighting bug

Fixes #15
---
 syntax/solidity.vim | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/syntax/solidity.vim b/syntax/solidity.vim
index 72c3bca..969b6d2 100644
--- a/syntax/solidity.vim
+++ b/syntax/solidity.vim
@@ -97,13 +97,15 @@ hi def link solBuiltinFunction   Keyword
 syn match   solOperator          /\(!\||\|&\|+\|-\|<\|>\|=\|%\|\/\|*\|\~\|\^\)/
 syn match   solNumber            /\<-\=\d\+L\=\>\|\<0[xX]\x\+\>/
 syn match   solFloat             /\<-\=\%(\d\+\.\d\+\|\d\+\.\|\.\d\+\)\%([eE][+-]\=\d\+\)\=\>/
-syn region  solString            start=+"+  skip=+\\\\\|\\$"\|\\"+  end=+"+
-syn region  solString            start=+'+  skip=+\\\\\|\\$'\|\\'+  end=+'+
+syn region  solString            start=+"+  skip=+\\\\\|\\"+  end=+"+  contains=solStringEscape
+syn region  solString            start=+'+  skip=+\\\\\|\\'+  end=+'+  contains=solStringEscape
+syn match   solStringEscape      contained +\\[nrt\\'"]+
 
 hi def link solOperator          Operator
 hi def link solNumber            Number
 hi def link solFloat             Float
 hi def link solString            String
+hi def link solStringEscape      SpecialChar
 
 " Function
 syn match   solFunction          /\<function\>/ nextgroup=solFuncName,solFuncArgs skipwhite

From 424066026a7555a063b3d633b641ccc0eaaef279 Mon Sep 17 00:00:00 2001
From: Matt Luongo <mhluongo@gmail.com>
Date: Tue, 13 Jan 2026 11:16:38 -0500
Subject: [PATCH 09/11] Prepare CHANGELOG for v0.8.0 release

This release includes modern Solidity 0.8.x support, testing
infrastructure, and fixes for syntax highlighting and folding.
---
 CHANGELOG.md | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e54812f..7b52fa5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+Nothing yet - next release will be 0.9.0 with Foundry tooling integration.
+
+## [0.8.0] - 2026-01-13
+
+**Major release with modern Solidity 0.8.x support and testing infrastructure**
+
 ### Added
 - Comprehensive testing infrastructure with vader.vim
 - GitHub Actions CI for automated testing
@@ -26,6 +32,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 - Contract bodies can now be folded (Issue #11)
+- String literal syntax highlighting after function signatures (Issue #15)
+
+### Known Issues
+- Indentation for some multi-line constructs may need manual adjustment (Issue #5)
+  - The indent logic is based on JavaScript and works well for most cases
+  - Complex multi-line function signatures with modifiers may need refinement
+  - Contributions welcome to improve edge cases
 
 ### Changed
 - Enhanced ftdetect to recognize Foundry file naming conventions

From f0ffbaa94a605c8d319aa0120f87199dac6d7f04 Mon Sep 17 00:00:00 2001
From: Matt Luongo <mhluongo@gmail.com>
Date: Tue, 13 Jan 2026 11:42:50 -0500
Subject: [PATCH 10/11] Fix the test suite

Use global variables, avoid variable shadowing, and set explicit
filetypes. Make sure the tests can run locally, and that they
only use the tested version of vim-solidity rather than anything
globally installed.
---
 .gitignore              |   1 +
 syntax/solidity.vim     |   2 +
 test/run_local_tests.sh |  22 +++++
 test/simple_test.vim    | 140 ++++++++++++++++++++++++++++++++
 test/vader/syntax.vader | 173 +++++-----------------------------------
 test/vimrc              |  11 +--
 6 files changed, 189 insertions(+), 160 deletions(-)
 create mode 100644 .gitignore
 create mode 100755 test/run_local_tests.sh
 create mode 100644 test/simple_test.vim

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..c595fc7
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+test/vader.vim/
diff --git a/syntax/solidity.vim b/syntax/solidity.vim
index 969b6d2..1dbf40f 100644
--- a/syntax/solidity.vim
+++ b/syntax/solidity.vim
@@ -174,3 +174,5 @@ hi def link solCommentTodo       Todo
 hi def link solNatSpec           Label
 hi def link solLineComment       Comment
 hi def link solComment           Comment
+
+let b:current_syntax = "solidity"
diff --git a/test/run_local_tests.sh b/test/run_local_tests.sh
new file mode 100755
index 0000000..5ac96a2
--- /dev/null
+++ b/test/run_local_tests.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+# Local test harness for vim-solidity syntax highlighting
+# Usage: ./test/run_local_tests.sh
+
+set -e
+
+cd "$(dirname "$0")/.."
+
+echo "Running vim-solidity syntax tests locally..."
+echo ""
+
+# Run the test script
+if vim -Es -Nu test/vimrc -S test/simple_test.vim 2>&1; then
+    echo ""
+    echo "All tests passed!"
+    exit 0
+else
+    EXIT_CODE=$?
+    echo ""
+    echo "Tests failed with exit code $EXIT_CODE"
+    exit $EXIT_CODE
+fi
diff --git a/test/simple_test.vim b/test/simple_test.vim
new file mode 100644
index 0000000..b46150c
--- /dev/null
+++ b/test/simple_test.vim
@@ -0,0 +1,140 @@
+" Simple local test harness for syntax highlighting
+" Run with: vim -Nu test/vimrc -S test/simple_test.vim
+
+set nocompatible
+set rtp^=.
+filetype plugin indent on
+syntax enable
+
+" Test counter
+let s:passed = 0
+let s:failed = 0
+let s:tests = []
+
+function! RunTest(name, code, keyword, expected_group)
+  " Create new buffer
+  enew!
+
+  " Insert code FIRST
+  call setline(1, split(a:code, '\n'))
+
+  " THEN set syntax and force reload
+  unlet! b:current_syntax
+  set filetype=solidity
+  runtime! syntax/solidity.vim
+  syntax sync fromstart
+
+  " Find keyword
+  call cursor(1, 1)
+  let l:found = search(a:keyword, 'w')
+
+  if l:found == 0
+    let l:result = 'FAIL: keyword not found'
+    let s:failed += 1
+    call add(s:tests, {'name': a:name, 'status': 'FAIL', 'reason': 'keyword not found'})
+    return
+  endif
+
+  " Check syntax group
+  let l:synid = synID(line('.'), col('.'), 1)
+  let l:group = synIDattr(l:synid, 'name')
+  let l:word = expand('<cword>')
+  let l:line_content = getline('.')
+
+  if l:group ==# a:expected_group
+    let s:passed += 1
+    call add(s:tests, {'name': a:name, 'status': 'PASS', 'group': l:group})
+  else
+    let s:failed += 1
+    call add(s:tests, {'name': a:name, 'status': 'FAIL', 'expected': a:expected_group, 'got': l:group, 'word': l:word, 'line': l:line_content, 'pos': line('.') . ':' . col('.')})
+  endif
+endfunction
+
+" Run tests
+echo "Running syntax tests...\n"
+
+call RunTest(
+  \ 'transient keyword',
+  \ "contract Test {\n    transient uint256 value;\n}",
+  \ 'transient',
+  \ 'solKeyword'
+  \ )
+
+call RunTest(
+  \ 'uint256 builtin type',
+  \ 'uint256 value;',
+  \ 'uint256',
+  \ 'solBuiltinType'
+  \ )
+
+call RunTest(
+  \ 'unchecked keyword',
+  \ "function test() public {\n    unchecked {\n        x++;\n    }\n}",
+  \ 'unchecked',
+  \ 'solKeyword'
+  \ )
+
+call RunTest(
+  \ 'error keyword',
+  \ 'error InsufficientBalance(uint256 available, uint256 required);',
+  \ 'error',
+  \ 'solKeyword'
+  \ )
+
+call RunTest(
+  \ 'fallback keyword',
+  \ 'fallback() external payable {}',
+  \ 'fallback',
+  \ 'solKeyword'
+  \ )
+
+call RunTest(
+  \ 'receive keyword',
+  \ 'receive() external payable {}',
+  \ 'receive',
+  \ 'solKeyword'
+  \ )
+
+" Print results
+let s:output = []
+call add(s:output, "\n" . repeat('=', 60))
+call add(s:output, "Test Results")
+call add(s:output, repeat('=', 60) . "\n")
+
+for test in s:tests
+  if test.status ==# 'PASS'
+    call add(s:output, '✓ PASS: ' . test.name . ' (' . test.group . ')')
+  else
+    call add(s:output, '✗ FAIL: ' . test.name)
+    if has_key(test, 'expected')
+      call add(s:output, '  Expected: ' . test.expected)
+      call add(s:output, '  Got: "' . test.got . '"')
+      if has_key(test, 'word')
+        call add(s:output, '  Word: ' . test.word)
+        call add(s:output, '  Line: ' . test.line)
+        call add(s:output, '  Position: ' . test.pos)
+      endif
+    else
+      call add(s:output, '  Reason: ' . test.reason)
+    endif
+  endif
+endfor
+
+call add(s:output, "\n" . repeat('=', 60))
+call add(s:output, 'Total: ' . (s:passed + s:failed) . ' | Passed: ' . s:passed . ' | Failed: ' . s:failed)
+call add(s:output, repeat('=', 60))
+
+" Write results to file and stdout
+call writefile(s:output, '/tmp/vim-solidity-test-results.txt')
+
+" Also print to screen
+for line in s:output
+  echomsg line
+endfor
+
+" Exit with appropriate code
+if s:failed > 0
+  cquit 1
+else
+  qall!
+endif
diff --git a/test/vader/syntax.vader b/test/vader/syntax.vader
index 1a33c90..15bfca0 100644
--- a/test/vader/syntax.vader
+++ b/test/vader/syntax.vader
@@ -1,15 +1,10 @@
 " Syntax highlighting tests for vim-solidity
 
-" Helper function is defined in test/vimrc
-
 Before:
-  set rtp+=.
+  set rtp^=.
   filetype plugin indent on
   syntax enable
 
-After:
-  %bwipeout!
-
 # ==============================================================================
 # Modern Solidity 0.8.x Keywords
 # ==============================================================================
@@ -20,148 +15,24 @@ Given solidity (transient keyword):
   }
 
 Execute (transient should be highlighted as keyword):
-  normal! /transient
-  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'solKeyword', l:group
-
-Given solidity (unchecked block):
-  function test() public {
-      unchecked {
-          x++;
-      }
-  }
-
-Execute (unchecked should be highlighted as keyword):
-  normal! /unchecked
-  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'solKeyword', l:group
-
-Given solidity (custom error):
-  error InsufficientBalance(uint256 available, uint256 required);
-
-Execute (error should be highlighted as keyword):
-  normal! /error
-  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'solKeyword', l:group
-
-Given solidity (fallback function):
-  fallback() external payable {}
-
-Execute (fallback should be highlighted as keyword):
-  normal! /fallback
-  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'solKeyword', l:group
-
-Given solidity (receive function):
-  receive() external payable {}
-
-Execute (receive should be highlighted as keyword):
-  normal! /receive
-  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'solKeyword', l:group
-
-# ==============================================================================
-# Issue #15: String Literal Bug
-# ==============================================================================
-
-Given solidity (string with function signature):
-  bytes32 hash = keccak256(bytes("submitSomething(bytes)"));
-  uint256 value = 42;
-
-Execute (string should close properly and value should highlight correctly):
-  " Check that string is highlighted
-  normal! /"submitSomething
-  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'solString', l:group
-
-  " Check that content after string is highlighted correctly
-  normal! /value
-  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  " Should be highlighted as identifier (no specific group) or Number group
-  " The important thing is it's NOT solString
-  AssertNotEqual 'solString', l:group
-
-Given solidity (multiple strings with parens):
-  string memory a = "func(uint256)";
-  string memory b = "other(bytes)";
-
-Execute (both strings should be highlighted independently):
-  normal! /"func
-  let l:group1 = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'solString', l:group1
-
-  normal! /"other
-  let l:group2 = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'solString', l:group2
-
-# ==============================================================================
-# Basic Syntax Elements
-# ==============================================================================
-
-Given solidity (contract declaration):
-  contract MyContract {
-  }
-
-Execute (contract should be highlighted as Type):
-  normal! /contract
-  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'solContract', l:group
-
-  normal! /MyContract
-  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'solContractName', l:group
-
-Given solidity (function declaration):
-  function test() public pure returns (uint256) {
-      return 42;
-  }
-
-Execute (function elements should be highlighted correctly):
-  normal! /function
-  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'solFunction', l:group
-
-  normal! /test
-  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'solFuncName', l:group
-
-  normal! /public
-  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'solKeyword', l:group
-
-  normal! /uint256
-  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'solBuiltinType', l:group
-
-Given solidity (comments and natspec):
-  /// @notice This is a natspec comment
-  // Regular comment
-  /* Block comment */
-
-Execute (comments should be highlighted):
-  normal! gg
-  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'solLineComment', l:group
-
-# ==============================================================================
-# Assembly / Yul
-# ==============================================================================
-
-Given solidity (assembly block):
-  assembly {
-      let x := add(1, 2)
-      sstore(0, x)
-  }
-
-Execute (assembly keywords should be highlighted):
-  normal! /assembly
-  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'yul', l:group
-
-  normal! /add
-  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'yulAssemblyOp', l:group
-
-  normal! /sstore
-  let l:group = synIDattr(synID(line('.'), col('.'), 1), 'name')
-  AssertEqual 'yulAssemblyOp', l:group
+  unlet! b:current_syntax
+  set filetype=solidity
+  runtime! syntax/solidity.vim
+  syntax sync fromstart
+  call search('transient', 'w')
+  let g:syn = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  Log 'Syntax group: ' . g:syn
+  AssertEqual 'solKeyword', g:syn
+
+Given solidity (uint256 type):
+  uint256 value;
+
+Execute (uint256 should be highlighted as builtin type):
+  unlet! b:current_syntax
+  set filetype=solidity
+  runtime! syntax/solidity.vim
+  syntax sync fromstart
+  call search('uint256', 'w')
+  let g:syn = synIDattr(synID(line('.'), col('.'), 1), 'name')
+  Log 'Syntax group: ' . g:syn
+  AssertEqual 'solBuiltinType', g:syn
diff --git a/test/vimrc b/test/vimrc
index 56837f0..4064157 100644
--- a/test/vimrc
+++ b/test/vimrc
@@ -4,16 +4,9 @@ set nocompatible
 " Add vader.vim to runtimepath
 set rtp+=test/vader.vim
 
-" Add vim-solidity to runtimepath
-set rtp+=.
+" Add vim-solidity to runtimepath (PREPEND to override system files)
+set rtp^=.
 
 " Load filetype detection, plugins, and indent
 filetype plugin indent on
 syntax enable
-
-" Helper function to get syntax group at cursor
-function! SyntaxOf(pattern)
-  let l:line = search(a:pattern, 'cn')
-  let l:col = match(getline(l:line), a:pattern) + 1
-  return synIDattr(synID(l:line, l:col, 1), 'name')
-endfunction

From 0116109fc2f37d94f6efcdf2fe7665070c8b289c Mon Sep 17 00:00:00 2001
From: Matt Luongo <mhluongo@gmail.com>
Date: Wed, 14 Jan 2026 15:50:18 -0500
Subject: [PATCH 11/11] Fix test suite and add test runner

---
 syntax/solidity.vim      | 10 ++++----
 test/run_tests.sh        | 50 ++++++++++++++++++++++++++++++++++++++++
 test/vader/folding.vader | 44 +++++++++++++++++++----------------
 test/vader/indent.vader  |  5 +---
 test/vimrc               |  5 ++++
 5 files changed, 85 insertions(+), 29 deletions(-)
 create mode 100755 test/run_tests.sh

diff --git a/syntax/solidity.vim b/syntax/solidity.vim
index 1dbf40f..9a1ffea 100644
--- a/syntax/solidity.vim
+++ b/syntax/solidity.vim
@@ -115,7 +115,7 @@ syn match   solModifierName      contained /\<[a-zA-Z_$][0-9a-zA-Z_$]*/ nextgrou
 syn region  solModifierArgs      contained matchgroup=solFuncParens start='(' end=')' contains=solFuncArgCommas nextgroup=solModifierName,solFuncReturns,solFuncBody skipwhite
 syn region  solFuncReturns       contained matchgroup=solFuncParens nextgroup=solFuncBody start='(' end=')' contains=solFuncArgCommas,solBuiltinType skipwhite
 syn match   solFuncArgCommas     contained ','
-syn region  solFuncBody          start="{" end="}" fold transparent
+syn region  solFuncBody          contained start="{" end="}" fold transparent
 
 hi def link solFunction          Type
 hi def link solFuncName          Function
@@ -132,12 +132,12 @@ hi def link yulVarDeclaration   Keyword
 hi def link yulAssemblyOp       Keyword
 
 " Contract
-syn match   solContract          /\<\%(contract\|library\|interface\)\>/ nextgroup=solContractName skipwhite
-syn match   solContractName      contained /\<[a-zA-Z_$][0-9a-zA-Z_$]*/ nextgroup=solContractParent,solContractBody skipwhite
-syn region  solContractParent    contained start='is' end='{' contains=solContractName,solContractNoise,solContractCommas nextgroup=solContractBody skipwhite skipempty
+syn match   solContract          /\<\%(contract\|library\|interface\)\>/ nextgroup=solContractName skipwhite skipnl skipempty
+syn match   solContractName      contained /\<[a-zA-Z_$][0-9a-zA-Z_$]*/ nextgroup=solContractBlock,solContractParent skipwhite skipnl skipempty
+syn region  solContractParent    contained start='is' end='{' contains=solContractName,solContractNoise,solContractCommas nextgroup=solContractBlock skipwhite skipempty
 syn match   solContractNoise     contained 'is' containedin=solContractParent
 syn match   solContractCommas    contained ','
-syn region  solContractBody      contained start='{' end='}' fold transparent
+syn region  solContractBlock     contained matchgroup=Delimiter start='{' end='}' fold transparent
 
 hi def link solContract          Type
 hi def link solContractName      Function
diff --git a/test/run_tests.sh b/test/run_tests.sh
new file mode 100755
index 0000000..53e3b31
--- /dev/null
+++ b/test/run_tests.sh
@@ -0,0 +1,50 @@
+#!/bin/bash
+# Run vader tests and report results
+
+cd "$(dirname "$0")/.."
+
+# Run all tests
+echo "Running vim-solidity test suite..."
+echo ""
+
+# Track overall status
+FAILED=0
+
+# Run syntax tests
+echo "=== Syntax Tests ==="
+if vim -Nu test/vimrc -c 'Vader! test/vader/syntax.vader' 2>&1; then
+    echo "✓ Syntax tests passed"
+else
+    echo "✗ Syntax tests failed"
+    FAILED=1
+fi
+echo ""
+
+# Run indent tests
+echo "=== Indentation Tests ==="
+if vim -Nu test/vimrc -c 'Vader! test/vader/indent.vader' 2>&1; then
+    echo "✓ Indentation tests passed"
+else
+    echo "✗ Indentation tests failed"
+    FAILED=1
+fi
+echo ""
+
+# Run folding tests
+echo "=== Folding Tests ==="
+if vim -Nu test/vimrc -c 'Vader! test/vader/folding.vader' 2>&1; then
+    echo "✓ Folding tests passed"
+else
+    echo "✗ Folding tests failed"
+    FAILED=1
+fi
+echo ""
+
+# Final summary
+if [ $FAILED -eq 0 ]; then
+    echo "✓ All tests passed"
+    exit 0
+else
+    echo "✗ Some tests failed"
+    exit 1
+fi
diff --git a/test/vader/folding.vader b/test/vader/folding.vader
index c0868a5..bc8beaf 100644
--- a/test/vader/folding.vader
+++ b/test/vader/folding.vader
@@ -1,32 +1,36 @@
 " Code folding tests for vim-solidity
 
 Before:
-  set rtp+=.
+  set rtp^=.
   filetype plugin indent on
   syntax enable
   set foldmethod=syntax
   set foldlevel=0
 
-After:
-  %bwipeout!
-  set foldmethod=manual
-
 # ==============================================================================
 # Function Folding
 # ==============================================================================
 
 Given solidity (function with body):
-  function test() public {
-      uint256 x = 1;
-      uint256 y = 2;
-      return x + y;
+  contract Test {
+      function test() public {
+          uint256 x = 1;
+          uint256 y = 2;
+          return x + y;
+      }
   }
 
 Execute (function body should be foldable):
   normal! gg
-  " Check that fold exists
-  let l:foldlevel = foldlevel(1)
-  AssertNotEqual 0, l:foldlevel
+  " Find the function keyword
+  normal! /function
+  " Find the opening brace line
+  normal! /{
+  let g:func_line = line('.')
+  " Function body should have a fold
+  let g:fold_level = foldlevel(g:func_line + 1)
+  " If function folding is working, there should be a fold level
+  AssertNotEqual 0, g:fold_level
 
 # ==============================================================================
 # Contract Folding (Issue #11)
@@ -45,11 +49,11 @@ Execute (contract body should be foldable):
   normal! gg
   " Find the opening brace line
   normal! /{
-  let l:contract_line = line('.')
+  let g:contract_line = line('.')
   " Contract body should have a fold
-  let l:foldlevel = foldlevel(l:contract_line + 1)
+  let g:fold_level = foldlevel(g:contract_line + 1)
   " If contract folding is working, there should be a fold level
-  AssertNotEqual 0, l:foldlevel
+  AssertNotEqual 0, g:fold_level
 
 # ==============================================================================
 # Assembly Folding
@@ -66,9 +70,9 @@ Given solidity (assembly block):
 Execute (assembly block should be foldable):
   normal! /assembly
   normal! /{
-  let l:asm_line = line('.')
-  let l:foldlevel = foldlevel(l:asm_line + 1)
-  AssertNotEqual 0, l:foldlevel
+  let g:asm_line = line('.')
+  let g:fold_level = foldlevel(g:asm_line + 1)
+  AssertNotEqual 0, g:fold_level
 
 # ==============================================================================
 # Multi-line Comment Folding
@@ -82,6 +86,6 @@ Given solidity (multi-line comment):
 
 Execute (multi-line comment should be foldable):
   normal! gg
-  let l:foldlevel = foldlevel(1)
+  let g:fold_level = foldlevel(1)
   " Comments should have fold support
-  AssertNotEqual 0, l:foldlevel
+  AssertNotEqual 0, g:fold_level
diff --git a/test/vader/indent.vader b/test/vader/indent.vader
index 9933219..5605f5c 100644
--- a/test/vader/indent.vader
+++ b/test/vader/indent.vader
@@ -1,13 +1,10 @@
 " Indentation tests for vim-solidity
 
 Before:
-  set rtp+=.
+  set rtp^=.
   filetype plugin indent on
   syntax enable
 
-After:
-  %bwipeout!
-
 # ==============================================================================
 # Basic Indentation
 # ==============================================================================
diff --git a/test/vimrc b/test/vimrc
index 4064157..c6ecc73 100644
--- a/test/vimrc
+++ b/test/vimrc
@@ -7,6 +7,11 @@ set rtp+=test/vader.vim
 " Add vim-solidity to runtimepath (PREPEND to override system files)
 set rtp^=.
 
+" Set indent defaults (4 spaces, expand tabs)
+set shiftwidth=4
+set tabstop=4
+set expandtab
+
 " Load filetype detection, plugins, and indent
 filetype plugin indent on
 syntax enable