vinter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '0916f02e9f17998516fc27eb0d2b2ec2807d1f4ae3ab12050590556c6d78e0ba'
+  data.tar.gz: 21cec3329527181dde80ebe5e12d5dba094c4596c1bcb725a1ef7dc95505b43e
+SHA512:
+  metadata.gz: ce1879809bfc52ff91ad591bbd862ef347cfc8a6595a042cd7bc9efb0c9bb95824ee177844a5499b9264c9dc3c81f4e5bda1b7ccbdb9a85800ab2a87697d07d0
+  data.tar.gz: 10741136273e679ba2cf0c334e4ba815a9ba8fae25ba677fb0d7bd9f441bd912cff8c87e8919c27db110b6bab066102de5188f23305cbde76542793a4a4cb7c2

data/README.md

@@ -0,0 +1,95 @@
+# Vinter
+
+A Ruby gem that provides linting capabilities for Vim9 script files. This linter helps identify syntax errors and enforce best practices for the new Vim9 script language introduced in Vim 9.0.
+
+## Features
+
+- Lexical analysis of Vim9 script syntax
+- Parsing of Vim9 script constructs
+- Detection of common errors and code smells
+- Command-line interface for easy integration with editors
+
+## Installation
+
+Install the gem:
+
+```bash
+gem install vinter
+```
+
+## Usage
+
+### Command Line
+
+Lint a Vim9 script file:
+
+```bash
+vim9-lint path/to/your/script.vim
+```
+
+### Ruby API
+
+```ruby
+require 'vinter'
+
+content = File.read('path/to/your/script.vim')
+linter = Vim9Linter::Linter.new
+issues = linter.lint(content)
+
+issues.each do |issue|
+  puts "#{issue[:type]}: #{issue[:message]} at line #{issue[:line]}, column #{issue[:column]}"
+end
+```
+
+## Supported Rules
+
+The linter includes several built-in rules:
+
+1. **missing-vim9script-declaration**: Checks if Vim9 script files start with the required `vim9script` declaration
+2. **prefer-def-over-function**: Encourages using `def` instead of `function` in Vim9 scripts
+3. **missing-type-annotation**: Identifies variable declarations without type annotations
+4. **missing-return-type**: Identifies functions without return type annotations
+
+## Adding Custom Rules
+
+You can extend the linter with your own custom rules:
+
+```ruby
+linter = Vinter::Linter.new
+
+# Define a custom rule
+custom_rule = Vinter::Rule.new(
+  "my-custom-rule",
+  "Description of what the rule checks"
+) do |ast|
+  issues = []
+
+  # Analyze the AST and identify issues
+  # ...
+
+  issues
+end
+
+# Register the custom rule
+linter.register_rule(custom_rule)
+
+# Run the linter with your custom rule
+issues = linter.lint(content)
+```
+
+## Vim9 Script Resources
+
+- [Vim9 Script Documentation](https://vimhelp.org/vim9.txt.html)
+- [Upgrading to Vim9 Script](https://www.baeldung.com/linux/vim-script-upgrade)
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b my-new-feature`
+3. Commit your changes: `git commit -am 'Add some feature'`
+4. Push to the branch: `git push origin my-new-feature`
+5. Submit a pull request
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

data/bin/vinter

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "vinter"
+
+exit Vinter::CLI.new.run(ARGV)

data/lib/vinter/cli.rb

@@ -0,0 +1,47 @@
+module Vinter
+  class CLI
+    def initialize
+      @linter = Linter.new
+    end
+
+    def run(args)
+      if args.empty?
+        puts "Usage: vim9-lint [file.vim]"
+        return 1
+      end
+
+      file_path = args[0]
+
+      unless File.exist?(file_path)
+        puts "Error: File not found: #{file_path}"
+        return 1
+      end
+
+      content = File.read(file_path)
+      issues = @linter.lint(content)
+
+      if issues.empty?
+        puts "No issues found in #{file_path}"
+        return 0
+      else
+        puts "Found #{issues.length} issues in #{file_path}:"
+
+        issues.each do |issue|
+          type_str = case issue[:type]
+                     when :error then "ERROR"
+                     when :warning then "WARNING"
+                     when :rule then "RULE(#{issue[:rule]})"
+                     else "UNKNOWN"
+                     end
+
+          line = issue[:line] || 1
+          column = issue[:column] || 1
+
+          puts "#{file_path}:#{line}:#{column}: #{type_str}: #{issue[:message]}"
+        end
+
+        return issues.any? { |i| i[:type] == :error } ? 1 : 0
+      end
+    end
+  end
+end

data/lib/vinter/lexer.rb

@@ -0,0 +1,136 @@
+module Vinter
+  class Lexer
+    TOKEN_TYPES = {
+      # Vim9 specific keywords
+      keyword: /\b(if|else|elseif|endif|while|endwhile|for|endfor|def|enddef|function|endfunction|return|const|var|final|import|export|class|extends|static|enum|type|vim9script|abort)\b/,
+      # Identifiers can include # and special characters
+      identifier: /\b[a-zA-Z_][a-zA-Z0-9_#]*\b/,
+      # Single-character operators
+      operator: /[\+\-\*\/=<>!&\|\.]/,
+      # Multi-character operators handled separately
+      number: /\b\d+(\.\d+)?\b/,
+      # Handle both single and double quoted strings
+      string: /"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/,
+      # Vim9 comments use #
+      comment: /#.*/,
+      whitespace: /\s+/,
+      brace_open: /\{/,
+      brace_close: /\}/,
+      paren_open: /\(/,
+      paren_close: /\)/,
+      bracket_open: /\[/,
+      bracket_close: /\]/,
+      colon: /:/,
+      semicolon: /;/,
+      comma: /,/,
+    }
+
+    def initialize(input)
+      @input = input
+      @tokens = []
+      @position = 0
+      @line_num = 1
+      @column = 1
+    end
+
+    def tokenize
+      until @position >= @input.length
+        chunk = @input[@position..-1]
+        
+        # Handle multi-character operators explicitly
+        if match = chunk.match(/\A(==|!=|=>|->|\.\.)/)
+          @tokens << { 
+            type: :operator, 
+            value: match[0], 
+            line: @line_num, 
+            column: @column 
+          }
+          @column += match[0].length
+          @position += match[0].length
+          next
+        end
+        
+        # Handle ellipsis for variable args
+        if chunk.start_with?('...')
+          @tokens << { 
+            type: :ellipsis, 
+            value: '...', 
+            line: @line_num, 
+            column: @column 
+          }
+          @column += 3
+          @position += 3
+          next
+        end
+        
+        # Skip whitespace but track position
+        if match = chunk.match(/\A(\s+)/)
+          whitespace = match[0]
+          whitespace.each_char do |c|
+            if c == "\n"
+              @line_num += 1
+              @column = 1
+            else
+              @column += 1
+            end
+          end
+          @position += whitespace.length
+          next
+        end
+        
+        match_found = false
+        
+        TOKEN_TYPES.each do |type, pattern|
+          if match = chunk.match(/\A(#{pattern})/)
+            value = match[0]
+            token = { 
+              type: type, 
+              value: value, 
+              line: @line_num, 
+              column: @column 
+            }
+            @tokens << token unless type == :whitespace
+            
+            # Update position
+            if value.include?("\n")
+              lines = value.split("\n")
+              @line_num += lines.size - 1
+              if lines.size > 1
+                @column = lines.last.length + 1
+              else
+                @column += value.length
+              end
+            else
+              @column += value.length
+            end
+            
+            @position += value.length
+            match_found = true
+            break
+          end
+        end
+        
+        unless match_found
+          # Try to handle unknown characters
+          @tokens << { 
+            type: :unknown, 
+            value: chunk[0], 
+            line: @line_num, 
+            column: @column 
+          }
+          
+          if chunk[0] == "\n"
+            @line_num += 1
+            @column = 1
+          else
+            @column += 1
+          end
+          
+          @position += 1
+        end
+      end
+      
+      @tokens
+    end
+  end
+end

data/lib/vinter/linter.rb

@@ -0,0 +1,153 @@
+module Vinter
+  class Linter
+    def initialize
+      @rules = []
+      register_default_rules
+    end
+
+    def register_rule(rule)
+      @rules << rule
+    end
+
+    def register_default_rules
+      # Rule: Vim9 script files should start with vim9script declaration
+      register_rule(Rule.new("missing-vim9script-declaration", "Script does not start with vim9script declaration") do |ast|
+        if ast[:type] == :program && (ast[:body].empty? || ast[:body][0][:type] != :vim9script_declaration)
+          [{ message: "File should start with vim9script declaration", line: 1, column: 1 }]
+        else
+          []
+        end
+      end)
+
+      # Rule: Prefer def over function in Vim9 script
+      register_rule(Rule.new("prefer-def-over-function", "Use def instead of function in Vim9 script") do |ast|
+        issues = []
+
+        traverse_ast(ast) do |node|
+          if node[:type] == :legacy_function
+            issues << { message: "Use def instead of function for #{node[:name]}", line: node[:line] || 0, column: node[:column] || 0 }
+          end
+        end
+
+        issues
+      end)
+
+      # Rule: Variables should have type annotations
+      register_rule(Rule.new("missing-type-annotation", "Variable declaration is missing type annotation") do |ast|
+        issues = []
+
+        traverse_ast(ast) do |node|
+          if node[:type] == :variable_declaration && node[:var_type_annotation].nil? && node[:var_type] != 'const'
+            issues << { message: "Variable #{node[:name]} should have a type annotation", line: node[:line] || 0, column: node[:column] || 0 }
+          end
+        end
+
+        issues
+      end)
+
+      # Rule: Functions should have return type annotations
+      register_rule(Rule.new("missing-return-type", "Function is missing return type annotation") do |ast|
+        issues = []
+
+        traverse_ast(ast) do |node|
+          if node[:type] == :def_function && node[:return_type].nil?
+            issues << { message: "Function #{node[:name]} should have a return type annotation", line: node[:line] || 0, column: node[:column] || 0 }
+          end
+        end
+
+        issues
+      end)
+
+      # Rule: Function parameters should have type annotations
+      register_rule(Rule.new("missing-param-type", "Function parameter is missing type annotation") do |ast|
+        issues = []
+
+        traverse_ast(ast) do |node|
+          if node[:type] == :def_function
+            node[:params].each do |param|
+              if param[:type] == :parameter && param[:param_type].nil?
+                issues << { message: "Parameter #{param[:name]} should have a type annotation", line: param[:line] || 0, column: param[:column] || 0 }
+              end
+            end
+          end
+        end
+
+        issues
+      end)
+    end
+
+    def traverse_ast(node, &block)
+      return unless node.is_a?(Hash)
+
+      yield node
+
+      node.each do |key, value|
+        if value.is_a?(Array)
+          value.each { |item| traverse_ast(item, &block) if item.is_a?(Hash) }
+        elsif value.is_a?(Hash)
+          traverse_ast(value, &block)
+        end
+      end
+    end
+
+    def lint(content)
+      lexer = Lexer.new(content)
+      tokens = lexer.tokenize
+
+      parser = Parser.new(tokens)
+      result = parser.parse
+
+      issues = []
+
+      # Add parser errors
+      result[:errors].each do |error|
+        issues << {
+          type: :error,
+          message: error[:message],
+          position: error[:position],
+          line: error[:line] || 0,
+          column: error[:column] || 0
+        }
+      end
+
+      # Add parser warnings
+      result[:warnings].each do |warning|
+        issues << {
+          type: :warning,
+          message: warning[:message],
+          position: warning[:position],
+          line: warning[:line] || 0,
+          column: warning[:column] || 0
+        }
+      end
+
+      # Apply rules
+      @rules.each do |rule|
+        rule_issues = rule.apply(result[:ast])
+        issues.concat(rule_issues.map { |i| {
+          type: :rule,
+          rule: rule.id,
+          message: i[:message],
+          line: i[:line] || 0,
+          column: i[:column] || 0
+        }})
+      end
+
+      issues
+    end
+  end
+
+  class Rule
+    attr_reader :id, :description
+
+    def initialize(id, description, &block)
+      @id = id
+      @description = description
+      @check = block
+    end
+
+    def apply(ast)
+      @check.call(ast)
+    end
+  end
+end

data/lib/vinter/parser.rb

@@ -0,0 +1,789 @@
+module Vinter
+  class Parser
+    def initialize(tokens)
+      @tokens = tokens
+      @position = 0
+      @errors = []
+      @warnings = []
+    end
+
+    def parse
+      result = parse_program
+      {
+        ast: result,
+        errors: @errors,
+        warnings: @warnings
+      }
+    end
+
+    private
+
+    def current_token
+      @tokens[@position]
+    end
+
+    def peek_token(offset = 1)
+      @tokens[@position + offset]
+    end
+
+    def advance
+      token = current_token
+      @position += 1 if @position < @tokens.length
+      token
+    end
+
+    def expect(type)
+      if current_token && current_token[:type] == type
+        token = current_token
+        advance
+        return token
+      else
+        expected = type
+        found = current_token ? current_token[:type] : "end of input"
+        line = current_token ? current_token[:line] : 0
+        column = current_token ? current_token[:column] : 0
+        error = "Expected #{expected} but found #{found}"
+        @errors << { message: error, position: @position, line: line, column: column }
+        nil
+      end
+    end
+
+    def parse_program
+      statements = []
+
+      # Check for vim9script declaration
+      if current_token && current_token[:type] == :keyword && current_token[:value] == 'vim9script'
+        statements << { type: :vim9script_declaration }
+        advance
+      end
+
+      while @position < @tokens.length
+        stmt = parse_statement
+        statements << stmt if stmt
+      end
+
+      { type: :program, body: statements }
+    end
+
+    def parse_statement
+      if !current_token
+        return nil
+      end
+
+      if current_token[:type] == :keyword
+        case current_token[:value]
+        when 'if'
+          parse_if_statement
+        when 'while'
+          parse_while_statement
+        when 'for'
+          parse_for_statement
+        when 'def'
+          parse_def_function
+        when 'function'
+          parse_legacy_function
+        when 'return'
+          parse_return_statement
+        when 'var', 'const', 'final'
+          parse_variable_declaration
+        when 'import'
+          parse_import_statement
+        when 'export'
+          parse_export_statement
+        when 'vim9script'
+          token = advance # Skip 'vim9script'
+          { type: :vim9script_declaration, line: token[:line], column: token[:column] }
+        else
+          @warnings << {
+            message: "Unexpected keyword: #{current_token[:value]}",
+            position: @position,
+            line: current_token[:line],
+            column: current_token[:column]
+          }
+          advance
+          nil
+        end
+      elsif current_token[:type] == :identifier
+        parse_expression_statement
+      elsif current_token[:type] == :comment
+        parse_comment
+      else
+        @warnings << {
+          message: "Unexpected token type: #{current_token[:type]}",
+          position: @position,
+          line: current_token[:line],
+          column: current_token[:column]
+        }
+        advance
+        nil
+      end
+    end
+
+    def parse_comment
+      comment = current_token[:value]
+      line = current_token[:line]
+      column = current_token[:column]
+      advance
+      { type: :comment, value: comment, line: line, column: column }
+    end
+
+    def parse_if_statement
+      token = advance # Skip 'if'
+      line = token[:line]
+      column = token[:column]
+      condition = parse_expression
+
+      then_branch = []
+      else_branch = []
+
+      # Parse statements until we hit 'else', 'elseif', or 'endif'
+      while @position < @tokens.length
+        if current_token[:type] == :keyword &&
+           ['else', 'elseif', 'endif'].include?(current_token[:value])
+          break
+        end
+
+        stmt = parse_statement
+        then_branch << stmt if stmt
+      end
+
+      # Check for else/elseif
+      if current_token && current_token[:type] == :keyword
+        if current_token[:value] == 'else'
+          advance # Skip 'else'
+
+          # Parse statements until 'endif'
+          while @position < @tokens.length
+            if current_token[:type] == :keyword && current_token[:value] == 'endif'
+              break
+            end
+
+            stmt = parse_statement
+            else_branch << stmt if stmt
+          end
+        elsif current_token[:value] == 'elseif'
+          # This is a simplified handling - elseif should be treated as a nested if
+          else_branch << parse_if_statement
+        end
+      end
+
+      # Expect endif
+      expect(:keyword) # This should be 'endif'
+
+      {
+        type: :if_statement,
+        condition: condition,
+        then_branch: then_branch,
+        else_branch: else_branch,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_def_function
+      token = advance # Skip 'def'
+      line = token[:line]
+      column = token[:column]
+
+      name = expect(:identifier)
+
+      # Parse parameter list
+      expect(:paren_open)
+      params = parse_parameter_list
+      expect(:paren_close)
+
+      # Parse optional return type
+      return_type = nil
+      if current_token && current_token[:type] == :colon
+        advance # Skip ':'
+        return_type = parse_type
+      end
+
+      # Parse function body
+      body = []
+      while @position < @tokens.length
+        if current_token[:type] == :keyword && current_token[:value] == 'enddef'
+          break
+        end
+
+        stmt = parse_statement
+        body << stmt if stmt
+      end
+
+      # Expect enddef
+      expect(:keyword) # This should be 'enddef'
+
+      {
+        type: :def_function,
+        name: name ? name[:value] : nil,
+        params: params,
+        return_type: return_type,
+        body: body,
+        line: line,
+        column: column
+      }
+    end
+
+
+
+    def parse_parameter_list
+      params = []
+
+      # Empty parameter list
+      if current_token && current_token[:type] == :paren_close
+        return params
+      end
+
+      loop do
+        # Check for variable args
+        if current_token && current_token[:type] == :ellipsis
+          ellipsis_token = advance
+
+          # Parse type for variable args if present
+          param_type = nil
+          if current_token && current_token[:type] == :colon
+            advance # Skip ':'
+            param_type = parse_type
+          end
+
+          params << {
+            type: :var_args,
+            param_type: param_type,
+            line: ellipsis_token[:line],
+            column: ellipsis_token[:column]
+          }
+          break
+        end
+
+        # Get parameter name
+        if !current_token || current_token[:type] != :identifier
+          @errors << {
+            message: "Expected parameter name",
+            position: @position,
+            line: current_token ? current_token[:line] : 0,
+            column: current_token ? current_token[:column] : 0
+          }
+          break
+        end
+
+        param_name = advance
+
+        # Check for type annotation
+        param_type = nil
+        if current_token && current_token[:type] == :colon
+          advance # Skip ':'
+          param_type = parse_type
+        end
+
+        # Check for default value
+        default_value = nil
+        if current_token && current_token[:type] == :operator && current_token[:value] == '='
+          advance # Skip '='
+          default_value = parse_expression
+        end
+
+        params << {
+          type: :parameter,
+          name: param_name[:value],
+          param_type: param_type,
+          optional: false, # Set this based on default value
+          default_value: default_value,
+          line: param_name[:line],
+          column: param_name[:column]
+        }
+
+        if current_token && current_token[:type] == :comma
+          advance
+        else
+          break
+        end
+      end
+
+      params
+    end
+
+    def parse_type
+      if current_token && current_token[:type] == :identifier
+        type_name = advance
+
+        # Handle generic types like list<string>
+        if current_token && current_token[:type] == :operator && current_token[:value] == '<'
+          advance # Skip '<'
+          inner_type = parse_type
+          expect(:operator) # This should be '>'
+
+          return {
+            type: :generic_type,
+            base_type: type_name[:value],
+            inner_type: inner_type,
+            line: type_name[:line],
+            column: type_name[:column]
+          }
+        end
+
+        return type_name[:value]
+      else
+        @errors << {
+          message: "Expected type identifier",
+          position: @position,
+          line: current_token ? current_token[:line] : 0,
+          column: current_token ? current_token[:column] : 0
+        }
+        advance
+        return "unknown"
+      end
+    end
+
+    def parse_variable_declaration
+      var_type_token = advance # Skip 'var', 'const', or 'final'
+      var_type = var_type_token[:value]
+      line = var_type_token[:line]
+      column = var_type_token[:column]
+
+      if !current_token || current_token[:type] != :identifier
+        @errors << {
+          message: "Expected variable name",
+          position: @position,
+          line: current_token ? current_token[:line] : 0,
+          column: current_token ? current_token[:column] : 0
+        }
+        return nil
+      end
+
+      name_token = advance
+      name = name_token[:value]
+
+      # Parse optional type annotation
+      var_type_annotation = nil
+      if current_token && current_token[:type] == :colon
+        advance # Skip ':'
+        var_type_annotation = parse_type
+      end
+
+      # Parse initializer if present
+      initializer = nil
+      if current_token && current_token[:type] == :operator && current_token[:value] == '='
+        advance # Skip '='
+        initializer = parse_expression
+      end
+
+      {
+        type: :variable_declaration,
+        var_type: var_type,
+        name: name,
+        var_type_annotation: var_type_annotation,
+        initializer: initializer,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_return_statement
+      token = advance # Skip 'return'
+      line = token[:line]
+      column = token[:column]
+
+      value = nil
+      if @position < @tokens.length && current_token[:type] != :semicolon
+        value = parse_expression
+      end
+
+      {
+        type: :return_statement,
+        value: value,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_expression_statement
+      expr = parse_expression
+      {
+        type: :expression_statement,
+        expression: expr,
+        line: expr ? expr[:line] : 0,
+        column: expr ? expr[:column] : 0
+      }
+    end
+
+    def parse_expression
+      return parse_binary_expression
+    end
+
+    def parse_binary_expression(precedence = 0)
+      left = parse_primary_expression
+
+      while current_token && current_token[:type] == :operator &&
+            operator_precedence(current_token[:value]) >= precedence
+        op_token = advance
+        op = op_token[:value]
+        op_precedence = operator_precedence(op)
+
+        right = parse_binary_expression(op_precedence + 1)
+
+        left = {
+          type: :binary_expression,
+          operator: op,
+          left: left,
+          right: right,
+          line: op_token[:line],
+          column: op_token[:column]
+        }
+      end
+
+      return left
+    end
+
+    def operator_precedence(op)
+      case op
+      when '..'  # String concatenation
+        1
+      when '||'  # Logical OR
+        2
+      when '&&'  # Logical AND
+        3
+      when '==', '!=', '>', '<', '>=', '<='  # Comparison
+        4
+      when '+', '-'  # Addition, subtraction
+        5
+      when '*', '/', '%'  # Multiplication, division, modulo
+        6
+      else
+        0
+      end
+    end
+
+    def parse_primary_expression
+      return nil unless current_token
+
+      token = current_token
+      line = token[:line]
+      column = token[:column]
+
+      case token[:type]
+      when :number
+        advance
+        {
+          type: :literal,
+          value: token[:value],
+          token_type: :number,
+          line: line,
+          column: column
+        }
+      when :string
+        advance
+        {
+          type: :literal,
+          value: token[:value],
+          token_type: :string,
+          line: line,
+          column: column
+        }
+      when :identifier
+        advance
+
+        # Check if this is a function call
+        if current_token && current_token[:type] == :paren_open
+          return parse_function_call(token[:value], line, column)
+        end
+
+        {
+          type: :identifier,
+          name: token[:value],
+          line: line,
+          column: column
+        }
+      when :paren_open
+        advance  # Skip '('
+        expr = parse_expression
+        expect(:paren_close)  # Expect and skip ')'
+        return expr
+      else
+        @errors << {
+          message: "Unexpected token in expression: #{token[:type]}",
+          position: @position,
+          line: line,
+          column: column
+        }
+        advance
+        return nil
+      end
+    end
+
+    def parse_function_call(name, line, column)
+      expect(:paren_open)
+
+      args = []
+
+      # Parse arguments
+      unless current_token && current_token[:type] == :paren_close
+        loop do
+          arg = parse_expression
+          args << arg if arg
+
+          break unless current_token && current_token[:type] == :comma
+          advance  # Skip comma
+        end
+      end
+
+      expect(:paren_close)
+
+      {
+        type: :function_call,
+        name: name,
+        arguments: args,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_import_statement
+      token = advance # Skip 'import'
+      line = token[:line]
+      column = token[:column]
+      
+      # Handle 'import autoload'
+      is_autoload = false
+      module_name = nil
+      path = nil
+      
+      if current_token && current_token[:type] == :identifier && current_token[:value] == 'autoload'
+        is_autoload = true
+        module_name = advance[:value]  # Store "autoload" as the module name
+        
+        # After "autoload" keyword, expect a string path
+        if current_token && current_token[:type] == :string
+          path = current_token[:value]
+          advance
+        else
+          @errors << { 
+            message: "Expected string path after 'autoload'", 
+            position: @position,
+            line: current_token ? current_token[:line] : 0,
+            column: current_token ? current_token[:column] : 0
+          }
+        end
+      else
+        # Regular import with a string path
+        if current_token && current_token[:type] == :string
+          path = current_token[:value]
+          
+          # Extract module name from the path
+          # This is simplified logic - you might need more complex extraction
+          module_name = path.gsub(/['"]/, '').split('/').last.split('.').first
+          
+          advance
+        else
+          # Handle other import formats
+          module_expr = parse_expression()
+          if module_expr && module_expr[:type] == :literal && module_expr[:token_type] == :string
+            path = module_expr[:value]
+            module_name = path.gsub(/['"]/, '').split('/').last.split('.').first
+          end
+        end
+      end
+      
+      # Handle 'as name'
+      as_name = nil
+      if current_token && current_token[:type] == :identifier && current_token[:value] == 'as'
+        advance # Skip 'as'
+        if current_token && current_token[:type] == :identifier
+          as_name = advance[:value]
+        else
+          @errors << { 
+            message: "Expected identifier after 'as'", 
+            position: @position,
+            line: current_token ? current_token[:line] : 0,
+            column: current_token ? current_token[:column] : 0
+          }
+        end
+      end
+      
+      { 
+        type: :import_statement, 
+        module: module_name,
+        path: path,
+        is_autoload: is_autoload,
+        as_name: as_name,
+        line: line,
+        column: column
+      }
+    end    
+    def parse_export_statement
+      token = advance # Skip 'export'
+      line = token[:line]
+      column = token[:column]
+
+      # Export can be followed by var/const/def/function declarations
+      if !current_token
+        @errors << {
+          message: "Expected declaration after export",
+          position: @position,
+          line: line,
+          column: column
+        }
+        return nil
+      end
+
+      exported_item = nil
+
+      if current_token[:type] == :keyword
+        case current_token[:value]
+        when 'def'
+          exported_item = parse_def_function
+        when 'function'
+          exported_item = parse_legacy_function
+        when 'var', 'const', 'final'
+          exported_item = parse_variable_declaration
+        when 'class'
+          # Handle class export when implemented
+          @errors << {
+            message: "Class export not implemented yet",
+            position: @position,
+            line: current_token[:line],
+            column: current_token[:column]
+          }
+          advance
+          return nil
+        else
+          @errors << {
+            message: "Unexpected keyword after export: #{current_token[:value]}",
+            position: @position,
+            line: current_token[:line],
+            column: current_token[:column]
+          }
+          advance
+          return nil
+        end
+      else
+        @errors << {
+          message: "Expected declaration after export",
+          position: @position,
+          line: current_token[:line],
+          column: current_token[:column]
+        }
+        advance
+        return nil
+      end
+
+      {
+        type: :export_statement,
+        export: exported_item,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_legacy_function
+      token = advance # Skip 'function'
+      line = token[:line]
+      column = token[:column]
+
+      # Check for bang (!) in function definition
+      has_bang = false
+      if current_token && current_token[:type] == :operator && current_token[:value] == '!'
+        has_bang = true
+        advance # Skip '!'
+      end
+
+      name = expect(:identifier)
+
+      # Parse parameter list
+      expect(:paren_open)
+      params = parse_parameter_list_legacy
+      expect(:paren_close)
+
+      # Check for optional attributes (range, dict, abort, closure)
+      attributes = []
+      while current_token && current_token[:type] == :identifier
+        if ['range', 'dict', 'abort', 'closure'].include?(current_token[:value])
+          attributes << advance[:value]
+        else
+          break
+        end
+      end
+
+      # Parse function body
+      body = []
+      while @position < @tokens.length
+        if current_token && current_token[:type] == :keyword &&
+           ['endfunction', 'endfunc'].include?(current_token[:value])
+          break
+        end
+
+        stmt = parse_statement
+        body << stmt if stmt
+      end
+
+      # Expect endfunction/endfunc
+      end_token = advance # This should be 'endfunction' or 'endfunc'
+      if end_token && end_token[:type] != :keyword &&
+         !['endfunction', 'endfunc'].include?(end_token[:value])
+        @errors << {
+          message: "Expected 'endfunction' or 'endfunc'",
+          position: @position,
+          line: end_token ? end_token[:line] : 0,
+          column: end_token ? end_token[:column] : 0
+        }
+      end
+
+      {
+        type: :legacy_function,
+        name: name ? name[:value] : nil,
+        params: params,
+        has_bang: has_bang,
+        attributes: attributes,
+        body: body,
+        line: line,
+        column: column
+      }
+    end
+
+    # Legacy function parameters are different - they use a:name syntax
+    def parse_parameter_list_legacy
+      params = []
+
+      # Empty parameter list
+      if current_token && current_token[:type] == :paren_close
+        return params
+      end
+
+      loop do
+        # Check for ... (varargs) in legacy function
+        if current_token && current_token[:type] == :ellipsis
+          advance
+          params << { type: :var_args_legacy, name: '...' }
+          break
+        end
+
+        if !current_token || current_token[:type] != :identifier
+          @errors << {
+            message: "Expected parameter name",
+            position: @position,
+            line: current_token ? current_token[:line] : 0,
+            column: current_token ? current_token[:column] : 0
+          }
+          break
+        end
+
+        param_name = advance
+
+        params << {
+          type: :parameter,
+          name: param_name[:value],
+          line: param_name[:line],
+          column: param_name[:column]
+        }
+
+        if current_token && current_token[:type] == :comma
+          advance
+        else
+          break
+        end
+      end
+
+      params
+    end
+
+  end
+end

data/lib/vinter.rb

@@ -0,0 +1,8 @@
+require "vinter/lexer"
+require "vinter/parser"
+require "vinter/linter"
+require "vinter/cli"
+
+module Vinter
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: vinter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dan Bradbury
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-04-04 00:00:00.000000000 Z
+dependencies: []
+description: A linter for the Vim9 script language, helping to identify issues and
+  enforce best practices
+email: dan.luckydaisy@gmail.com
+executables:
+- vinter
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/vinter
+- lib/vinter.rb
+- lib/vinter/cli.rb
+- lib/vinter/lexer.rb
+- lib/vinter/linter.rb
+- lib/vinter/parser.rb
+homepage: https://github.com/DanBradbury/vinter
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: A linter for Vim9 script
+test_files: []