vinter 0.3.0 → 0.5.0

data/lib/vinter/parser.rb

@@ -1,10 +1,11 @@
 module Vinter
   class Parser
-    def initialize(tokens)
+    def initialize(tokens, source_text = nil)
       @tokens = tokens
       @position = 0
       @errors = []
       @warnings = []
+      @source_text = source_text
     end
 
     def parse
@@ -42,12 +43,123 @@ module Vinter
         found = current_token ? current_token[:type] : "end of input"
         line = current_token ? current_token[:line] : 0
         column = current_token ? current_token[:column] : 0
+
+        # Get the full line content from the input if available
+        line_content = nil
+        if line > 0 && @tokens.length > 0
+          # Find tokens on the same line
+          same_line_tokens = @tokens.select { |t| t[:line] == line }
+          if !same_line_tokens.empty?
+            # Create a representation of the line with a marker at the error position
+            line_representation = same_line_tokens.map { |t| t[:value] }.join('')
+            line_content = "Line content: #{line_representation}"
+          end
+        end
+
         error = "Expected #{expected} but found #{found}"
-        @errors << { message: error, position: @position, line: line, column: column }
+        error += ", at line #{line}, column #{column}"
+        error += "\n#{line_content}" if line_content
+
+        @errors << {
+          message: error,
+          position: @position,
+          line: line,
+          column: column,
+          line_content: line_content
+        }
         nil
       end
     end
 
+    # Helper method to add errors with consistent formatting
+    def add_error(message, token = current_token)
+      @errors << {
+        message: message,
+        position: @position,
+        line: token ? token[:line] : 0,
+        column: token ? token[:column] : 0
+      }
+    end
+
+    # Helper method to expect a specific keyword value
+    def expect_keyword(value)
+      if current_token && current_token[:type] == :keyword && current_token[:value] == value
+        advance
+        true
+      else
+        add_error("Expected '#{value}' keyword")
+        false
+      end
+    end
+
+    # Helper method to parse a body of statements until one or more end keywords
+    # Returns array of parsed statements
+    def parse_body_until(*end_keywords)
+      body = []
+      while @position < @tokens.length
+        # Check if we've reached an end keyword
+        if current_token && current_token[:type] == :keyword &&
+           end_keywords.include?(current_token[:value])
+          break
+        end
+
+        stmt = parse_statement
+        body << stmt if stmt
+      end
+      body
+    end
+
+    # Helper method to expect and consume an end keyword
+    # Returns true if found, false and adds error if not
+    def expect_end_keyword(*keywords)
+      if current_token && current_token[:type] == :keyword &&
+         keywords.include?(current_token[:value])
+        advance
+        true
+      else
+        # Only add error if we haven't reached end of file
+        if @position < @tokens.length
+          add_error("Expected #{keywords.join(' or ')} to close block")
+        end
+        false
+      end
+    end
+
+    # Helper method to parse comma-separated loop variables
+    # Used by for loops with brackets or parentheses
+    def parse_loop_variables
+      loop_vars = []
+
+      loop do
+        if current_token && (current_token[:type] == :identifier ||
+                            current_token[:type] == :local_variable ||
+                            current_token[:type] == :global_variable ||
+                            current_token[:type] == :script_local)
+          loop_vars << advance
+        else
+          add_error("Expected identifier in for loop variables")
+          break
+        end
+
+        if current_token && current_token[:type] == :comma
+          advance # Skip ','
+        else
+          break
+        end
+      end
+
+      loop_vars
+    end
+
+    # Helper method to expect 'in' keyword in for loops
+    def expect_in_keyword
+      if !current_token || (current_token[:type] != :identifier || current_token[:value] != 'in')
+        add_error("Expected 'in' after for loop variables")
+      else
+        advance # Skip 'in'
+      end
+    end
+
     def parse_program
       statements = []
 
@@ -65,15 +177,153 @@ module Vinter
       { type: :program, body: statements }
     end
 
+    def parse_mapping_statement
+      token = current_token
+      advance # Skip the mapping command
+      line = token[:line]
+      column = token[:column]
+      mapping_command = token[:value]
+
+      # Parse options (like <silent>, <buffer>, etc.)
+      options = []
+      while current_token &&
+            (current_token[:type] == :identifier || current_token[:type] == :special_key) &&
+            current_token[:value].start_with?('<') &&
+            current_token[:value].end_with?('>')
+        options << current_token[:value]
+        advance
+      end
+
+      # Parse the key sequence
+      key_sequence = nil
+      if current_token
+        if current_token[:type] == :special_key ||
+           (current_token[:value].start_with?('<') && current_token[:value].end_with?('>'))
+          key_sequence = current_token[:value]
+          advance
+        else
+          key_sequence = current_token[:value]
+          advance
+        end
+      end
+
+      # Collect everything else until end of line as the mapping target
+      # This is raw text and shouldn't be parsed as an expression
+      target_tokens = []
+
+      # Continue collecting tokens until we hit a newline or comment
+      while current_token &&
+            current_token[:type] != :comment &&
+            (current_token[:type] != :whitespace || current_token[:value].strip != '')
+
+        # If we hit a newline not preceded by a continuation character, we're done
+        if current_token[:value] == "\n" &&
+           (target_tokens.empty? || target_tokens.last[:value][-1] != '\\')
+          break
+        end
+
+        target_tokens << current_token
+        advance
+      end
+
+      # Join the target tokens to form the raw mapping target
+      target = target_tokens.map { |t| t[:value] }.join('')
+
+      {
+        type: :mapping_statement,
+        command: mapping_command,
+        options: options,
+        key_sequence: key_sequence,
+        target: target,
+        line: line,
+        column: column
+      }
+    end
+
     def parse_statement
       if !current_token
         return nil
       end
+      start_token = current_token
 
-      if current_token[:type] == :keyword
+      # Handle pipe as command separator
+      if current_token[:type] == :operator && current_token[:value] == '|'
+        advance # Skip the pipe
+        return parse_statement
+      end
+
+      # Handle endif keyword outside normal if structure (likely from one-line if)
+      if current_token[:type] == :keyword && current_token[:value] == 'endif'
+        token = advance # Skip the endif
+        return {
+          type: :endif_marker,
+          line: token[:line],
+          column: token[:column]
+        }
+      end
+
+      # Add special cases for other ending keywords too to be thorough
+      if current_token[:type] == :keyword &&
+         ['endwhile', 'endfor', 'endfunction', 'endfunc', 'enddef'].include?(current_token[:value])
+        token = advance # Skip the keyword
+        return {
+          type: :"#{token[:value]}_marker",
+          line: token[:line],
+          column: token[:column]
+        }
+      end
+
+      # Now, add specific handling for continue and break
+      if current_token[:type] == :keyword && current_token[:value] == 'continue'
+        token = advance # Skip 'continue'
+        return {
+          type: :continue_statement,
+          line: token[:line],
+          column: token[:column]
+        }
+      end
+
+      if current_token[:type] == :keyword && current_token[:value] == 'break'
+        token = advance # Skip 'break'
+        return {
+          type: :break_statement,
+          line: token[:line],
+          column: token[:column]
+        }
+      end
+
+      # Handle try-catch
+      if current_token[:type] == :keyword && current_token[:value] == 'try'
+        return parse_try_statement
+      end
+
+      # Handle throw
+      if current_token[:type] == :keyword && current_token[:value] == 'throw'
+        return parse_throw_statement
+      end
+
+      # Skip standalone catch, finally, endtry keywords outside of try blocks
+      if current_token[:type] == :keyword &&
+         ['catch', 'finally', 'endtry'].include?(current_token[:value])
+        token = advance # Skip these keywords
+        return nil
+      end
+
+      # Add case for mapping commands
+      if current_token[:type] == :keyword &&
+         ['nnoremap', 'nmap', 'inoremap', 'imap', 'vnoremap', 'vmap',
+          'xnoremap', 'xmap', 'cnoremap', 'cmap', 'noremap', 'map'].include?(current_token[:value])
+        parse_mapping_statement
+      elsif current_token[:type] == :runtime_command
+        parse_runtime_statement
+      elsif current_token[:type] == :keyword && current_token[:value] == 'runtime'
+        parse_runtime_statement
+      elsif current_token[:type] == :keyword
         case current_token[:value]
         when 'if'
           parse_if_statement
+        when 'command'
+          parse_command_definition
         when 'while'
           parse_while_statement
         when 'for'
@@ -81,7 +331,18 @@ module Vinter
         when 'def'
           parse_def_function
         when 'function'
-          parse_legacy_function
+          # Only parse as function declaration if it looks like one
+          # Function declarations are followed by ! or identifier (function name)
+          if peek_token && (
+            (peek_token[:type] == :operator && peek_token[:value] == '!') ||
+            peek_token[:type] == :identifier ||
+            peek_token[:type] == :script_local
+          )
+            parse_legacy_function
+          else
+            # Not a function declaration, parse as expression statement
+            parse_expression_statement
+          end
         when 'return'
           parse_return_statement
         when 'var', 'const', 'final'
@@ -93,14 +354,36 @@ module Vinter
         when 'vim9script'
           token = advance # Skip 'vim9script'
           { type: :vim9script_declaration, line: token[:line], column: token[:column] }
+        when 'scriptencoding'
+          parse_scriptencoding
         when 'autocmd'
           parse_autocmd_statement
-        when 'execute'
+        when 'execute', 'exec'
           parse_execute_statement
         when 'let'
-          parse_let_statement  
-        when 'echohl', 'echomsg'
+          parse_let_statement
+        when 'unlet'
+          parse_unlet_statement
+        when 'echohl', 'echomsg', 'echoerr', 'echom'
           parse_echo_statement
+        when 'augroup'
+          parse_augroup_statement
+        when 'silent'
+          parse_silent_command
+        when 'call'
+          parse_call_statement
+        when 'delete'
+          parse_delete_statement
+        when 'set', 'setlocal'
+          parse_set_command
+        when 'syntax'
+          parse_syntax_command
+        when 'highlight'
+          parse_highlight_command
+        when 'sleep'
+          parse_sleep_command
+        when 'source'
+          parse_source_command
         else
           @warnings << {
             message: "Unexpected keyword: #{current_token[:value]}",
@@ -114,11 +397,51 @@ module Vinter
       elsif current_token[:type] == :identifier
         if current_token[:value] == "echo"
           parse_echo_statement
+        elsif current_token[:value] == "augroup"
+          parse_augroup_statement
+        elsif current_token[:value] == "au" || current_token[:value] == "autocmd"
+          parse_autocmd_statement
+        elsif current_token[:value] == "filter" || current_token[:value] == "filt"
+          parse_filter_command
+        elsif current_token[:value] == "command"
+          parse_command_definition
         else
           parse_expression_statement
         end
       elsif current_token[:type] == :comment
         parse_comment
+      elsif current_token[:type] == :string && current_token[:value].start_with?('"')
+        parse_comment
+        # token = current_token
+        # line = token[:line]
+        # column = token[:column]
+        # value = token[:value]
+        # advance
+        # { type: :comment, value: value, line: line, column: column }
+      elsif current_token[:type] == :silent_bang
+        parse_silent_command
+      elsif current_token[:type] == :identifier && current_token[:value] == 'delete'
+        parse_delete_command
+      elsif current_token[:type] == :percentage
+        parse_range_command
+      elsif current_token[:type] == :global_variable
+        name = current_token[:value]
+        #advance#skip value
+        #advance#operator
+        ##parse_expression_statement
+        #advance#value
+        while peek_token[:line] == current_token[:line]
+          advance
+        end
+        advance
+        {
+          type: :global_variable,
+          name: name
+        }
+
+      elsif current_token[:type] == :vimfuncs
+        advance
+        parse_function_call(current_token[:value], current_token[:line], current_token[:column])
       else
         @warnings << {
           message: "Unexpected token type: #{current_token[:type]}",
@@ -131,391 +454,666 @@ module Vinter
       end
     end
 
-    def parse_execute_statement
-      token = advance # Skip 'execute'
+    def parse_range_command
+      token = advance # Skip '%'
       line = token[:line]
       column = token[:column]
 
-      # Parse arguments - typically string expressions with concatenation
-      # Just accept any tokens until we hit a statement terminator or another command
-      expressions = []
-      expr = parse_expression
-      expressions << expr if expr
+      # Parse the command that follows the range
+      command = parse_statement
 
-      # Return the execute statement
       {
-        type: :execute_statement,
-        expressions: expressions,
+        type: :range_command,
+        range: '%',
+        command: command,
         line: line,
         column: column
       }
     end
 
-    def parse_let_statement
-      token = advance # Skip 'let'
+    def parse_runtime_statement
+      token = advance # Skip 'runtime' or 'runtime!'
       line = token[:line]
       column = token[:column]
 
-      # Parse the target variable
-      target = nil
-      if current_token
-        case current_token[:type]
-        when :identifier, :global_variable, :script_local, :arg_variable, :option_variable, :special_variable
-          target = {
-            type: current_token[:type],
-            name: current_token[:value],
-            line: current_token[:line],
-            column: current_token[:column]
-          }
-          advance
-        else
-          @errors << {
-            message: "Expected variable name after let",
-            position: @position,
-            line: current_token ? current_token[:line] : 0,
-            column: current_token ? current_token[:column] : 0
-          }
-        end
+      is_bang = token[:type] == :runtime_command ||
+               (token[:value] == 'runtime' && current_token && current_token[:type] == :operator && current_token[:value] == '!')
+
+      # Skip the '!' if it's separate token
+      if token[:type] != :runtime_command && is_bang
+        advance # Skip '!'
       end
 
-      # Skip the '=' or other assignment operator
-      operator = nil
-      if current_token && (
-          (current_token[:type] == :operator && current_token[:value] == '=') ||
-          current_token[:type] == :compound_operator)
-        operator = current_token[:value]
+      # Collect the pattern argument
+      pattern_parts = []
+      while @position < @tokens.length &&
+            !(current_token[:type] == :keyword || current_token[:value] == "\n")
+        pattern_parts << current_token[:value]
         advance
-      else
-        @errors << {
-          message: "Expected assignment operator after variable in let statement",
-          position: @position,
-          line: current_token ? current_token[:line] : 0,
-          column: current_token ? current_token[:column] : 0
-        }
       end
 
-      # Parse the value expression
-      value = parse_expression
+      pattern = pattern_parts.join('').strip
 
       {
-        type: :let_statement,
-        target: target,
-        operator: operator,
-        value: value,
+        type: :runtime_statement,
+        bang: is_bang,
+        pattern: pattern,
         line: line,
         column: column
       }
     end
 
-    def parse_autocmd_statement
-      token = advance # Skip 'autocmd'
+    def parse_filter_command
+      token = advance # Skip 'execute'
       line = token[:line]
       column = token[:column]
+      # lets count the parens that are created as we parse through the filter command
+      expect(:paren_open)
+      open_parens = 1
+      while open_parens > 0
+        advance
+        if current_token[:type] == :paren_open
+          open_parens += 1
+        elsif current_token[:type] == :paren_close
+          open_parens -= 1
+        end
+      end
+      advance
 
-      # Parse event name (like BufNewFile)
-      event = nil
+      # Parse arguments - typically string expressions with concatenation
+      # Just accept any tokens until we hit a statement terminator or another command
+      #expressions = []
+      #expr = parse_expression
+      #expr = parse_string
+      #expressions << expr if expr
+
+      # Return the execute statement
+      {
+        type: :filter_command,
+        #expressions: expressions,
+        line: line,
+        column: column
+      }
+    end
+
+
+
+    def parse_augroup_statement
+      token = advance # Skip 'augroup'
+      line = token[:line]
+      column = token[:column]
+
+      # Get the augroup name
+      name = nil
       if current_token && current_token[:type] == :identifier
-        event = advance[:value]
+        name = current_token[:value]
+        advance
       else
-        @errors << {
-          message: "Expected event name after 'autocmd'",
-          position: @position,
-          line: current_token ? current_token[:line] : 0,
-          column: current_token ? current_token[:column] : 0
-        }
+        add_error("Expected augroup name")
       end
 
-      # Parse pattern (like *.match)
-      pattern = nil
-      if current_token
-        pattern = current_token[:value]
-        advance
+      # Check for augroup END
+      if name && name.upcase == "END"
+        return {
+          type: :augroup_end,
+          line: line,
+          column: column
+        }
       end
 
-      # Parse command (can be complex, including if statements)
-      commands = []
-
-      # Handle pipe-separated commands
-      in_command = true
-      while in_command && @position < @tokens.length
-        if current_token && current_token[:value] == '|'
-          advance # Skip '|'
-        end
-
-        # Parse the command
-        if current_token && current_token[:type] == :keyword
-          case current_token[:value]
-          when 'if'
-            commands << parse_if_statement
-          when 'echo'
-            commands << parse_echo_statement
-          # Add other command types as needed
-          else
-            # Generic command handling
-            cmd = parse_expression_statement
-            commands << cmd if cmd
+      # Parse statements within the augroup until we find 'augroup END'
+      body = []
+      while @position < @tokens.length
+        # Check for 'augroup END'
+        if (current_token[:type] == :keyword && current_token[:value] == 'augroup') ||
+           (current_token[:type] == :identifier && current_token[:value] == 'augroup')
+          # Look ahead for END
+          if peek_token &&
+             ((peek_token[:type] == :identifier && peek_token[:value].upcase == 'END') ||
+              (peek_token[:type] == :keyword && peek_token[:value].upcase == 'END'))
+            advance # Skip 'augroup'
+            advance # Skip 'END'
+            break
           end
-        elsif current_token && current_token[:type] == :identifier
-          cmd = parse_expression_statement
-          commands << cmd if cmd
-        else
-          in_command = false
         end
 
-        # Check if we've reached the end of the autocmd command
-        if !current_token || current_token[:type] == :comment || current_token[:value] == "\n"
-          in_command = false
-        end
+        stmt = parse_statement
+        body << stmt if stmt
       end
 
-      return {
-        type: :autocmd_statement,
-        event: event,
-        pattern: pattern,
-        commands: commands,
+      {
+        type: :augroup_statement,
+        name: name,
+        body: body,
         line: line,
         column: column
       }
     end
 
-    def parse_echo_statement
-      token = advance #Skip 'echo'
+    def parse_execute_statement
+      token = advance # Skip 'execute'
       line = token[:line]
       column = token[:column]
 
-      expression = parse_expression
+      # Parse arguments - typically string expressions with concatenation
+      # Just accept any tokens until we hit a statement terminator or another command
+      expressions = []
+      expr = parse_expression
+      #expr = parse_string
+      expressions << expr if expr
 
+      # Return the execute statement
       {
-        type: :echo_statement,
-        expression: expression,
+        type: :execute_statement,
+        expressions: expressions,
         line: line,
         column: column
       }
     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'
+    def parse_let_statement
+      # binding.pry
+      token = advance # Skip 'let'
       line = token[:line]
       column = token[:column]
-      condition = parse_expression
 
-      then_branch = []
-      else_branch = []
+      # Parse the target variable
+      target = nil
+      if current_token
+        case current_token[:type]
+        when :identifier, :global_variable, :script_local, :buffer_local, :window_local, :tab_local, :arg_variable, :option_variable, :special_variable, :local_variable
+          target = {
+            type: current_token[:type],
+            name: current_token[:value],
+            line: current_token[:line],
+            column: current_token[:column]
+          }
+          advance
 
-      # 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
+          # Check for property access with dot notation (e.g., person.job)
+          if current_token && current_token[:type] == :operator && current_token[:value] == '.'
+            dot_token = advance # Skip '.'
+
+            # Next token should be an identifier (property name)
+            if current_token && (current_token[:type] == :identifier || current_token[:type] == :keyword)
+              property_token = advance # Get the property name
+
+              # Update the target to be a property access
+              target = {
+                type: :property_access,
+                object: target,
+                property: property_token[:value],
+                line: dot_token[:line],
+                column: dot_token[:column]
+              }
+            else
+              add_error("Expected property name after '.'")
+            end
+          end
+
+          # Check for chained indexed access (dictionary key lookup)
+          while current_token && current_token[:type] == :bracket_open
+            bracket_token = advance # Skip '['
+            index_expr = parse_expression
+            expect(:bracket_close) # Skip ']'
+
+            # Update target to be an indexed access
+            target = {
+              type: :indexed_access,
+              object: target,
+              index: index_expr,
+              line: bracket_token[:line],
+              column: bracket_token[:column]
+            }
+          end
+        when :register_access
+          target = {
+            type: :register_access,
+            register: current_token[:value],
+            line: current_token[:line],
+            column: current_token[:column]
+          }
+          advance
+        when :bracket_open
+          # Handle array destructuring like: let [key, value] = split(header, ': ')
+          bracket_token = advance # Skip '['
+
+          # Parse the variable names inside the brackets
+          destructuring_targets = []
+
+          # Parse comma-separated list of variables
+          while current_token && current_token[:type] != :bracket_close
+            # Skip commas between variables
+            if current_token[:type] == :comma
+              advance
+              next
+            end
+
+            # Parse the variable name
+            if current_token && (
+              current_token[:type] == :identifier ||
+              current_token[:type] == :global_variable ||
+              current_token[:type] == :script_local ||
+              current_token[:type] == :arg_variable ||
+              current_token[:type] == :option_variable ||
+              current_token[:type] == :special_variable ||
+              current_token[:type] == :local_variable
+            )
+              destructuring_targets << {
+                type: current_token[:type],
+                name: current_token[:value],
+                line: current_token[:line],
+                column: current_token[:column]
+              }
+              advance
+            else
+              add_error("Expected variable name in destructuring assignment")
+              # Try to recover by advancing to next comma or closing bracket
+              while current_token && current_token[:type] != :comma && current_token[:type] != :bracket_close
+                advance
+              end
+            end
+          end
+
+          expect(:bracket_close) # Skip ']'
+
+          target = {
+            type: :destructuring_assignment,
+            targets: destructuring_targets,
+            line: bracket_token[:line],
+            column: bracket_token[:column]
+          }
+        else
+          add_error("Expected variable name after let")
         end
+      end
 
-        stmt = parse_statement
-        then_branch << stmt if stmt
+      # Skip the '=' or other assignment operator
+      operator = nil
+      if current_token && (
+          (current_token[:type] == :operator && current_token[:value] == '=') ||
+          current_token[:type] == :compound_operator)
+        operator = current_token[:value]
+        advance
+      else
+        add_error("Expected assignment operator after variable in let statement")
       end
 
-      # Check for else/elseif
-      if current_token && current_token[:type] == :keyword
-        if current_token[:value] == 'else'
-          advance # Skip 'else'
+      # Parse the value expression
+      value = nil
+
+      # Special handling for function() references in let statements
+      if current_token && current_token[:type] == :keyword && current_token[:value] == 'function'
+        advance # Skip 'function'
 
-          # Parse statements until 'endif'
-          while @position < @tokens.length
-            if current_token[:type] == :keyword && current_token[:value] == 'endif'
-              break
-            end
+        # Expect opening parenthesis
+        if current_token && current_token[:type] == :paren_open
+          paren_token = advance # Skip '('
 
-            stmt = parse_statement
-            else_branch << stmt if stmt
+          # Parse the function name as a string
+          func_name = nil
+          if current_token && current_token[:type] == :string
+            func_name = current_token[:value]
+            advance
+          else
+            add_error("Expected string with function name in function() call")
           end
-        elsif current_token[:value] == 'elseif'
-          # This is a simplified handling - elseif should be treated as a nested if
-          else_branch << parse_if_statement
+
+          # Expect closing parenthesis
+          expect(:paren_close) # Skip ')'
+
+          value = {
+            type: :function_reference,
+            function_name: func_name,
+            line: line,
+            column: column
+          }
+        else
+          # If not followed by parenthesis, parse as a normal expression
+          @position -= 1 # Go back to the 'function' keyword
+          value = parse_expression
         end
+      else
+        # Normal expression parsing
+        value = parse_expression
       end
+      {
+        type: :let_statement,
+        target: target,
+        operator: operator,
+        value: value,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_unlet_statement
+      token = advance # Skip 'unlet'
+      line = token[:line]
+      column = token[:column]
+
+      # Parse the variable to unlet
+      target = nil
+      if current_token
+        case current_token[:type]
+        when :identifier, :global_variable, :script_local, :buffer_local, :window_local, :tab_local, :arg_variable, :option_variable, :special_variable, :local_variable
+          target = {
+            type: current_token[:type],
+            name: current_token[:value],
+            line: current_token[:line],
+            column: current_token[:column]
+          }
+          advance
 
-      # Expect endif
-      expect(:keyword) # This should be 'endif'
+          # Check for chained indexed access (like variable[key])
+          while current_token && current_token[:type] == :bracket_open
+            bracket_token = advance # Skip '['
+            index_expr = parse_expression
+            expect(:bracket_close) # Skip ']'
+
+            # Update target to be an indexed access
+            target = {
+              type: :indexed_access,
+              object: target,
+              index: index_expr,
+              line: bracket_token[:line],
+              column: bracket_token[:column]
+            }
+          end
+        else
+          @errors << {
+            message: "Expected variable name after 'unlet'",
+            position: @position,
+            line: current_token ? current_token[:line] : 0,
+            column: current_token ? current_token[:column] : 0
+          }
+        end
+      end
 
       {
-        type: :if_statement,
-        condition: condition,
-        then_branch: then_branch,
-        else_branch: else_branch,
+        type: :unlet_statement,
+        target: target,
         line: line,
         column: column
       }
     end
 
-    def parse_while_statement
-      token = advance # Skip 'while'
+    def parse_autocmd_statement
+      token = advance # Skip 'autocmd'
       line = token[:line]
       column = token[:column]
-      condition = parse_expression
 
-      body = []
+      # Parse event name (like BufNewFile or VimEnter)
+      event = nil
+      if current_token && current_token[:type] == :identifier
+        event = advance[:value]
+      else
+        @errors << {
+          message: "Expected event name after 'autocmd'",
+          position: @position,
+          line: current_token ? current_token[:line] : 0,
+          column: current_token ? current_token[:column] : 0
+        }
+      end
 
-      # Parse statements until we hit 'endwhile'
+      # Parse pattern (like *.match or *)
+      pattern = nil
+      if current_token
+        pattern = current_token[:value]
+        advance
+      end
+
+      # Parse everything after as the command - collect as raw tokens
+      command_parts = []
       while @position < @tokens.length
-        if current_token[:type] == :keyword && current_token[:value] == 'endwhile'
+        if !current_token || current_token[:type] == :comment ||
+           (current_token[:value] == "\n" && !current_token[:value].start_with?("\\"))
           break
         end
 
-        stmt = parse_statement
-        body << stmt if stmt
+        command_parts << current_token
+        advance
       end
 
-      # Expect endwhile
-      expect(:keyword) # This should be 'endwhile'
-
-      {
-        type: :while_statement,
-        condition: condition,
-        body: body,
+      return {
+        type: :autocmd_statement,
+        event: event,
+        pattern: pattern,
+        command_parts: command_parts,
         line: line,
         column: column
       }
     end
 
-    def parse_for_statement
-      token = advance # Skip 'for'
+    def parse_echo_statement
+      token = advance #Skip 'echo'
       line = token[:line]
       column = token[:column]
 
-      # Parse the loop variable(s)
-      if current_token && current_token[:type] == :paren_open
-        # Handle tuple assignment: for (key, val) in dict
-        advance # Skip '('
+      expression = parse_expression
 
-        loop_vars = []
+      {
+        type: :echo_statement,
+        expression: expression,
+        line: line,
+        column: column
+      }
+    end
 
-        loop do
-          if current_token && current_token[:type] == :identifier
-            loop_vars << advance[:value]
-          else
-            @errors << {
-              message: "Expected identifier in for loop variables",
-              position: @position,
-              line: current_token ? current_token[:line] : 0,
-              column: current_token ? current_token[:column] : 0
-            }
-            break
-          end
+    def parse_comment
+      original_token = current_token
+      line = original_token[:line]
+      column = original_token[:column]
+      comment = original_token[:value]
+
+      # puts "INSIDE PARSE COMMENT"
+      # puts "Current token: #{current_token.inspect}"
+      # puts "Peek token: #{peek_token.inspect}"
+
+      # Check if the comment contains a newline
+      if comment.include?("\n")
+        # Split the comment at the newline
+        parts = comment.split("\n", 2)
+        comment = parts[0] # Only use the part before newline
+
+        # Create a new token for the content after the newline
+        remainder = parts[1].strip
+
+        if !remainder.empty?
+          # Position correctly - we'll advance past the current token
+          # But should process the remainder separately later
+
+          # For debugging only, you can print what's being processed
+          # puts "Found comment with newline. Using: '#{comment}', Remainder: '#{remainder}'"
+
+          # Don't call advance() - we'll modify the current token instead
+          @tokens[@position] = {
+            type: :string,  # Keep original type
+            value: comment, # Use only the part before newline
+            line: line,
+            column: column
+          }
 
-          if current_token && current_token[:type] == :comma
-            advance # Skip ','
-          else
-            break
-          end
+          # Insert the remainder as a new token after the current one
+          @tokens.insert(@position + 1, {
+            type: :comment,  # Same type for consistency
+            value: remainder, # Preserve as a string token
+            line: line + 1, # Increment line number for the part after newline
+            column: 0 # Approximate column based on indentation
+          })
         end
+      end
 
-        expect(:paren_close) # Skip ')'
+      # Now advance past the (potentially modified) current token
+      advance
+      { type: :comment, value: comment, line: line, column: column }
+    end
 
-        if !current_token || (current_token[:type] != :identifier || current_token[:value] != 'in')
-          @errors << {
-            message: "Expected 'in' after for loop variables",
-            position: @position,
-            line: current_token ? current_token[:line] : 0,
-            column: current_token ? current_token[:column] : 0
-          }
-        else
-          advance # Skip 'in'
-        end
+    def parse_if_statement
+      token = advance # Skip 'if'
+      line = token[:line]
+      column = token[:column]
 
-        iterable = parse_expression
+      condition = parse_expression
 
-        # Parse the body until 'endfor'
-        body = []
-        while @position < @tokens.length
-          if current_token[:type] == :keyword && current_token[:value] == 'endfor'
-            break
-          end
+      then_branch = []
+      else_branch = []
 
-          stmt = parse_statement
-          body << stmt if stmt
-        end
+      # Check if this might be a one-line if (look ahead for pipe character)
+      one_line_if = false
 
-        # Expect endfor
-        expect(:keyword) # This should be 'endfor'
+      if current_token && current_token[:type] == :operator && current_token[:value] == '|'
+        one_line_if = true
+        advance # Skip the pipe
 
-        return {
-          type: :for_statement,
-          loop_vars: loop_vars,
-          iterable: iterable,
-          body: body,
-          line: line,
-          column: column
-        }
-      else
-        # Simple for var in list
-        if !current_token || current_token[:type] != :identifier
-          @errors << {
-            message: "Expected identifier as for loop variable",
-            position: @position,
-            line: current_token ? current_token[:line] : 0,
-            column: current_token ? current_token[:column] : 0
-          }
-          return nil
-        end
+        # Parse the then statement
+        stmt = parse_statement
+        then_branch << stmt if stmt
 
-        loop_var = advance[:value]
+        # Check for the closing pipe and endif
+        if current_token && current_token[:type] == :operator && current_token[:value] == '|'
+          advance # Skip the pipe
 
-        if !current_token || (current_token[:type] != :identifier || current_token[:value] != 'in')
-          @errors << {
-            message: "Expected 'in' after for loop variable",
-            position: @position,
-            line: current_token ? current_token[:line] : 0,
-            column: current_token ? current_token[:column] : 0
-          }
-        else
-          advance # Skip 'in'
+          # Expect endif
+          unless expect_keyword('endif')
+            add_error("Expected 'endif' after '|' in one-line if statement")
+          end
         end
+      else
+        # Parse multi-line if statement
+        # Parse statements until 'else', 'elseif', or 'endif'
+        then_branch = parse_body_until('else', 'elseif', 'endif')
 
-        iterable = parse_expression
-
-        # Parse the body until 'endfor'
-        body = []
-        while @position < @tokens.length
-          if current_token[:type] == :keyword && current_token[:value] == 'endfor'
-            break
+        # Check for else/elseif
+        if current_token && current_token[:type] == :keyword
+          if current_token[:value] == 'else'
+            advance # Skip 'else'
+
+            # Parse statements until 'endif'
+            else_branch = parse_body_until('endif')
+          elsif current_token[:value] == 'elseif'
+            elseif_stmt = parse_if_statement
+            else_branch << elseif_stmt if elseif_stmt
+
+            return {
+              type: :if_statement,
+              condition: condition,
+              then_branch: then_branch,
+              else_branch: else_branch,
+              line: line,
+              column: column
+            }
           end
-
-          stmt = parse_statement
-          body << stmt if stmt
         end
 
-        # Expect endfor
-        expect(:keyword) # This should be 'endfor'
-
-        return {
-          type: :for_statement,
-          loop_var: loop_var,
-          iterable: iterable,
-          body: body,
-          line: line,
-          column: column
-        }
+        # Expect endif
+        expect_end_keyword('endif')
       end
+
+      {
+        type: :if_statement,
+        condition: condition,
+        then_branch: then_branch,
+        else_branch: else_branch,
+        one_line: one_line_if,
+        line: line,
+        column: column
+      }
     end
 
-    def parse_def_function
-      token = advance # Skip 'def'
+    def parse_while_statement
+      token = advance # Skip 'while'
       line = token[:line]
       column = token[:column]
+      condition = parse_expression
 
-      name = expect(:identifier)
+      # Parse statements until 'endwhile'
+      body = parse_body_until('endwhile')
 
-      # Parse parameter list
-      expect(:paren_open)
-      params = parse_parameter_list
-      expect(:paren_close)
+      # Expect endwhile
+      expect_end_keyword('endwhile')
+
+      {
+        type: :while_statement,
+        condition: condition,
+        body: body,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_for_statement
+      token = advance # Skip 'for'
+      line = token[:line]
+      column = token[:column]
+
+      # Determine the type of for loop and parse variables accordingly
+      loop_var = nil
+      loop_vars = nil
+
+      if current_token && current_token[:type] == :bracket_open
+        # Handle destructuring with brackets: for [key, val] in dict
+        advance # Skip '['
+        loop_vars = parse_loop_variables
+        expect(:bracket_close)
+        expect_in_keyword
+      elsif current_token && current_token[:type] == :paren_open
+        # Handle multiple variables with parentheses: for (var1, var2) in list
+        advance # Skip '('
+        loop_vars = parse_loop_variables
+        expect(:paren_close)
+        expect_in_keyword
+      else
+        # Handle single variable: for var in list
+        if current_token && (current_token[:type] == :identifier ||
+                            current_token[:type] == :local_variable ||
+                            current_token[:type] == :global_variable ||
+                            current_token[:type] == :script_local)
+          loop_var = advance
+        else
+          add_error("Expected identifier as for loop variable")
+        end
+        expect_in_keyword
+      end
+
+      # Parse the iterable expression
+      iterable = parse_expression
+
+      # Parse the body until 'endfor'
+      body = parse_body_until('endfor')
+
+      # Expect endfor
+      expect_end_keyword('endfor')
+
+      # Build result hash based on whether we have single or multiple vars
+      result = {
+        type: :for_statement,
+        iterable: iterable,
+        body: body,
+        line: line,
+        column: column
+      }
+
+      if loop_vars
+        result[:loop_vars] = loop_vars
+      else
+        result[:loop_var] = loop_var
+      end
+
+      result
+    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
@@ -524,19 +1122,11 @@ module Vinter
         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
+      # Parse function body until 'enddef'
+      body = parse_body_until('enddef')
 
       # Expect enddef
-      expect(:keyword) # This should be 'enddef'
+      expect_end_keyword('enddef')
 
       {
         type: :def_function,
@@ -579,12 +1169,7 @@ module Vinter
 
           # After varargs, we expect closing paren
           if current_token && current_token[:type] != :paren_close
-            @errors << {
-              message: "Expected closing parenthesis after varargs",
-              position: @position,
-              line: current_token[:line],
-              column: current_token[:column]
-            }
+            add_error("Expected closing parenthesis after varargs", current_token)
           end
 
           break
@@ -592,12 +1177,7 @@ module Vinter
 
         # 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
-          }
+          add_error("Expected parameter name")
           break
         end
 
@@ -632,12 +1212,7 @@ module Vinter
           advance
         # If we don't have a comma, we should have a closing paren
         elsif current_token && current_token[:type] != :paren_close
-          @errors << {
-            message: "Expected comma or closing parenthesis after parameter",
-            position: @position,
-            line: current_token[:line],
-            column: current_token[:column]
-          }
+          add_error("Expected comma or closing parenthesis after parameter", current_token)
           break
         end
       end
@@ -646,7 +1221,7 @@ module Vinter
     end
 
     def parse_type
-      if current_token && current_token[:type] == :identifier
+      if current_token && [:identifier, :keyword].include?(current_token[:type])
         type_name = advance
 
         # Handle generic types like list<string>
@@ -666,12 +1241,7 @@ module Vinter
 
         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
-        }
+        add_error("Expected type identifier")
         advance
         return "unknown"
       end
@@ -684,12 +1254,7 @@ module Vinter
       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
-        }
+        add_error("Expected variable name")
         return nil
       end
 
@@ -727,7 +1292,12 @@ module Vinter
       column = token[:column]
 
       value = nil
-      if @position < @tokens.length && current_token[:type] != :semicolon
+      # Check if we've reached the end of the file, end of line, or a semicolon
+      if @position < @tokens.length &&
+         current_token &&
+         current_token[:type] != :semicolon &&
+         !(current_token[:type] == :keyword &&
+           ['endif', 'endwhile', 'endfor', 'endfunction', 'endfunc'].include?(current_token[:value]))
         value = parse_expression
       end
 
@@ -783,7 +1353,72 @@ module Vinter
     end
 
     def parse_expression
-      return parse_binary_expression
+      # binding.pry
+      # Special case for empty return statements or standalone keywords that shouldn't be expressions
+      if current_token && current_token[:type] == :keyword &&
+         ['return', 'endif', 'endwhile', 'endfor', 'endfunction', 'endfunc'].include?(current_token[:value])
+        return nil
+      end
+
+      if current_token[:type] == :string
+        string_value = current_token[:value]
+        while current_token && peek_token && [:line_continuation, :identifier].include?(peek_token[:type])
+          # Handle strings with line continuation
+          if ["'", '"'].include? current_token[:value][-1]
+            token_line = current_token[:line]
+            token_column = current_token[:column]
+            advance # Consume the string token
+            return {
+              type: :literal,
+              value: string_value,
+              token_type: :string,
+              line: token_line,
+              column: token_column
+            }
+          else
+            advance
+            string_value += current_token[:value]
+          end
+        end
+      end
+
+      # Parse the condition expression
+      expr = parse_binary_expression
+
+      # Check if this is a ternary expression
+      if current_token && (current_token[:type] == :question_mark || (current_token[:type] == :operator && current_token[:value] == '?'))
+        question_token = advance # Skip '?'
+
+        # Parse the "then" expression
+        then_expr = parse_expression
+
+        # Expect the colon
+        if current_token && current_token[:type] == :colon
+          colon_token = advance # Skip ':'
+
+          # Parse the "else" expression
+          else_expr = parse_expression
+
+          # Return the ternary expression
+          return {
+            type: :ternary_expression,
+            condition: expr,
+            then_expr: then_expr,
+            else_expr: else_expr,
+            line: question_token[:line],
+            column: question_token[:column]
+          }
+        else
+          @errors << {
+            message: "Expected ':' in ternary expression",
+            position: @position,
+            line: current_token ? current_token[:line] : 0,
+            column: current_token ? current_token[:column] : 0
+          }
+        end
+      end
+
+      return expr
     end
 
     def parse_binary_expression(precedence = 0)
@@ -799,9 +1434,65 @@ module Vinter
           advance
         end
 
+        if current_token && current_token[:type] == :operator && current_token[:value] == '.' &&
+          operator_precedence(current_token[:value]) >= precedence
+         op_token = advance # Skip the operator
+
+         # Check if we're dealing with a command placeholder on either side
+         if (left && left[:type] == :command_arg_placeholder) ||
+            (peek_token && peek_token[:type] == :command_arg_placeholder)
+           # Handle command-specific concatenation
+           right = parse_binary_expression(operator_precedence('.') + 1)
+
+           left = {
+             type: :command_concat_expression,  # Special type for command concatenation
+             operator: '.',
+             left: left,
+             right: right,
+             line: op_token[:line],
+             column: op_token[:column]
+           }
+         else
+           # Normal expression concatenation
+           right = parse_binary_expression(operator_precedence('.') + 1)
+
+           left = {
+             type: :binary_expression,
+             operator: '.',
+             left: left,
+             right: right,
+             line: op_token[:line],
+             column: op_token[:column]
+           }
+         end
+        elsif current_token && current_token[:type] == :operator &&
+          ['<', '>', '=', '!'].include?(current_token[:value]) &&
+          peek_token && peek_token[:type] == :operator && peek_token[:value] == '='
+
+          # Combine the two operators into one token
+          op_token = current_token
+          op = current_token[:value] + peek_token[:value]
+          advance # Skip the first operator
+          advance # Skip the second operator
+
+          # Now process the combined operator
+          op_precedence = operator_precedence(op)
+
+          if op_precedence >= precedence
+            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
         # Now we should be at the operator
-        if current_token && current_token[:type] == :operator &&
-           operator_precedence(current_token[:value]) >= precedence
+        elsif current_token && current_token[:type] == :operator &&
+          operator_precedence(current_token[:value]) >= precedence
           op_token = advance
           op = op_token[:value]
           op_precedence = operator_precedence(op)
@@ -858,24 +1549,160 @@ module Vinter
       expr = nil
 
       case token[:type]
-      when :number
+      # Add handling for command arg placeholders
+      when :command_arg_placeholder
         advance
         expr = {
-          type: :literal,
+          type: :command_arg_placeholder,
           value: token[:value],
-          token_type: :number,
           line: line,
           column: column
         }
-      when :string
+      # Add special handling for keywords that might appear in expressions
+      when :keyword
+        # Special handling for map-related keywords when they appear in expressions
+        if ['map', 'nmap', 'imap', 'vmap', 'xmap', 'noremap', 'nnoremap', 'inoremap', 'vnoremap', 'xnoremap', 'cnoremap', 'cmap'].include?(token[:value])
+          if peek_token[:type] == :paren_open
+            parse_builtin_function_call(token[:value], line, column)
+          else
+            # Treat map commands as identifiers when inside expressions
+            advance
+            return {
+              type: :identifier,
+              name: token[:value],
+              line: line,
+              column: column
+            }
+          end
+        elsif token[:value] == 'type' && current_token && (current_token[:type] == :paren_open || peek_token && peek_token[:type] == :paren_open)
+          # This is the type() function call
+          return parse_builtin_function_call(token[:value], line, column)
+        elsif token[:value] == 'function'
+          # Check if this is a function() call or just 'function' as property name
+          if peek_token && peek_token[:type] == :paren_open
+            advance # Skip 'function'
+            # This is a function() call
+            if current_token && current_token[:type] == :paren_open
+            # This is a function reference call
+            paren_token = advance # Skip '('
+
+            # Parse the function name as a string or arrow function
+            if current_token && current_token[:type] == :string
+              func_name = current_token[:value]
+              advance
+
+              # Check for additional arguments (function() can take multiple arguments)
+              args = []
+              while current_token && current_token[:type] == :comma
+                advance # Skip comma
+                arg = parse_expression
+                args << arg if arg
+              end
+
+              # Expect closing parenthesis
+              expect(:paren_close) # Skip ')'
+
+              return {
+                type: :function_reference,
+                function_name: func_name,
+                arguments: args,
+                line: line,
+                column: column
+              }
+            elsif current_token && current_token[:type] == :brace_open
+              # This is an arrow function inside function()
+              arrow_function = parse_vim_lambda(line, column)
+
+              # Expect closing parenthesis
+              expect(:paren_close) # Skip ')'
+
+              return {
+                type: :function_reference,
+                function_body: arrow_function,
+                line: line,
+                column: column
+              }
+            else
+              @errors << {
+                message: "Expected string or arrow function definition in function() call",
+                position: @position,
+                line: current_token ? current_token[:line] : 0,
+                column: current_token ? current_token[:column] : 0
+              }
+            end
+          end
+          else
+            # If not followed by parenthesis, treat 'function' as an identifier (property name)
+            advance # Skip 'function'
+            return {
+              type: :identifier,
+              name: token[:value],
+              line: line,
+              column: column
+            }
+          end
+        # Legacy Vim allows certain keywords as identifiers in expressions
+        elsif ['return', 'type'].include?(token[:value])
+          # Handle 'return' keyword specially when it appears in an expression context
+          advance
+          @warnings << {
+            message: "Keyword '#{token[:value]}' used in an expression context",
+            position: @position,
+            line: line,
+            column: column
+          }
+          # Check if this is a function call for 'type'
+          if token[:value] == 'type' && current_token && current_token[:type] == :paren_open
+            return parse_function_call(token[:value], line, column)
+          end
+
+          expr = {
+            type: :identifier,
+            name: token[:value],
+            line: line,
+            column: column
+          }
+        else
+          @errors << {
+            message: "Unexpected keyword in expression: #{token[:value]}",
+            position: @position,
+            line: line,
+            column: column
+          }
+          advance
+          return nil
+        end
+      when :number
         advance
         expr = {
           type: :literal,
           value: token[:value],
-          token_type: :string,
+          token_type: :number,
           line: line,
           column: column
         }
+      when :string
+        # parse_string
+        if token[:value].start_with?('"')
+          advance
+          return {
+            type: :comment,
+            value: token[:value],
+            line: line,
+            column: column
+          }
+        else
+          string_value = token[:value]
+          advance
+          expr = {
+            type: :literal,
+            value: string_value,
+            raw_value: string_value, # Store the raw string to preserve escapes
+            token_type: :string,
+            line: line,
+            column: column
+          }
+        end
       when :option_variable
         # Handle Vim option variables (like &compatible)
         advance
@@ -885,6 +1712,14 @@ module Vinter
           line: line,
           column: column
         }
+      when :scoped_option_variable
+        advance
+        expr = {
+          type: :scoped_option_variable,
+          name: token[:value],
+          line: line,
+          column: column
+        }
       when :special_variable
         # Handle Vim special variables (like v:version)
         advance
@@ -909,6 +1744,21 @@ module Vinter
           line: line,
           column: column
         }
+      when :buffer_local
+        # Handle script-local variables/functions (like s:var)
+        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
+
+        expr = {
+          type: :buffer_local,
+          name: token[:value],
+          line: line,
+          column: column
+        }
       when :global_variable
         # Handle global variables (like g:var)
         advance
@@ -927,32 +1777,66 @@ module Vinter
           line: line,
           column: column
         }
-      when :identifier
+      when :local_variable
+        # Handle local variables (like l:var)
         advance
+        expr = {
+          type: :local_variable,
+          name: token[:value],
+          line: line,
+          column: column
+        }
+      when :identifier
+        # Special handling for Vim built-in functions
+        if ['has', 'exists', 'empty', 'get', 'type', 'map', 'copy'].include?(token[:value])
+          expr = parse_builtin_function_call(token[:value], line, column)
+        else
+          advance
 
-        # Check if this is a function call
-        if current_token && current_token[:type] == :paren_open
-          return parse_function_call(token[:value], line, column)
+          # Check if this is a function call
+          if current_token && current_token[:type] == :paren_open
+            expr = parse_function_call(token[:value], line, column)
+          else
+            # Special handling for execute command
+            if token[:value] == 'execute'
+              # Parse the string expressions for execute
+              # For now we'll just treat it as a normal identifier
+              expr = {
+                type: :identifier,
+                name: token[:value],
+                line: line,
+                column: column
+              }
+            else
+              expr = {
+                type: :identifier,
+                name: token[:value],
+                line: line,
+                column: column
+              }
+            end
+          end
         end
-        
-        # Special handling for execute command
-        if token[:value] == 'execute'
-          # Parse the string expressions for execute
-          # For now we'll just treat it as a normal identifier
-          expr = {
-            type: :identifier,
-            name: token[:value],
-            line: line,
-            column: column
-          }
+      when :vimfuncs
+        advance
+        if current_token[:type] == :paren_open
+          expr = parse_function_call(token[:value], line, column)
         else
           expr = {
-            type: :identifier,
+            type: :vimfuncs,
             name: token[:value],
             line: line,
             column: column
           }
         end
+      when :namespace_prefix
+        advance
+        expr = {
+          type: :namespace_prefix,
+          name: token[:value],
+          line: line,
+          column: column
+        }
       when :paren_open
         if is_lambda_expression
           return parse_lambda_expression(line, column)
@@ -964,11 +1848,28 @@ module Vinter
       when :bracket_open
         expr = parse_list_literal(line, column)
       when :brace_open
-        expr = parse_dict_literal(line, column)
+        expr = parse_vim_lambda_or_dict(line, column)
       when :backslash
         # Handle line continuation with backslash
         advance
         expr = parse_expression
+      when :register_access
+        advance
+        expr = {
+          type: :register_access,
+          register: token[:value][1..-1], # Remove the @ symbol
+          line: line,
+          column: column
+        }
+      when :line_continuation
+        advance
+        expr = parse_expression
+      when :interpolated_string
+        advance
+        expr = {
+          type: :interpolated_string,
+          value: token[:value],
+        }
       else
         @errors << {
           message: "Unexpected token in expression: #{token[:type]}",
@@ -984,28 +1885,44 @@ module Vinter
       while current_token
         # Check for property access with dot
         if current_token[:type] == :operator && current_token[:value] == '.'
-          dot_token = advance # Skip '.'
-
-          # Next token should be an identifier (property name)
-          if !current_token || current_token[:type] != :identifier
-            @errors << {
-              message: "Expected property name after '.'",
-              position: @position,
-              line: current_token ? current_token[:line] : 0,
-              column: current_token ? current_token[:column] : 0
+          # Look ahead to determine if this is property access or concatenation
+          next_token = peek_token
+          is_property_access = next_token && (next_token[:type] == :identifier || next_token[:type] == :keyword)
+
+          # Check if this is a property access (only when right side is identifier/keyword)
+          if is_property_access && (expr[:type] == :identifier || expr[:type] == :global_variable ||
+            expr[:type] == :script_local || expr[:type] == :namespace_prefix ||
+            expr[:type] == :arg_variable || expr[:type] == :buffer_local ||
+            expr[:type] == :window_local || expr[:type] == :tab_local ||
+            expr[:type] == :local_variable || expr[:type] == :property_access ||
+            expr[:type] == :indexed_access)
+
+            dot_token = advance # Skip '.'
+            # Next token should be an identifier (property name)
+            if !current_token || (current_token[:type] != :identifier &&
+              current_token[:type] != :keyword)
+                @errors << {
+                  message: "Expected property name after '.'",
+                  position: @position,
+                  line: current_token ? current_token[:line] : 0,
+                  column: current_token ? current_token[:column] : 0
+                }
+                break
+            end
+            property_token = advance
+
+            expr = {
+              type: :property_access,
+              object: expr,
+              property: property_token[:value],
+              line: dot_token[:line],
+              column: dot_token[:column]
             }
+          else
+            # This is concatenation or other binary operation, break to let binary expression parser handle it
             break
           end
 
-          property_token = advance # Get property name
-
-          expr = {
-            type: :property_access,
-            object: expr,
-            property: property_token[:value],
-            line: dot_token[:line],
-            column: dot_token[:column]
-          }
         # Check for method call with arrow ->
         elsif current_token[:type] == :operator && current_token[:value] == '->'
           arrow_token = advance # Skip '->'
@@ -1056,18 +1973,47 @@ module Vinter
         # Check for indexing with brackets
         elsif current_token[:type] == :bracket_open
           bracket_token = advance # Skip '['
-
           index_expr = parse_expression
 
+          # Add support for list slicing with colon
+          end_index = nil
+          if current_token && current_token[:type] == :colon
+            advance # Skip ':'
+            # handle omitted end index case like [6:]
+            if current_token && current_token[:type] == :bracket_close
+              end_index = {
+                type: :implicit_end_index,
+                value: nil,
+                line: current_token[:line],
+                column: current_token[:column]
+              }
+            else
+              end_index = parse_expression
+            end
+          end
+
           expect(:bracket_close) # Skip ']'
 
-          expr = {
-            type: :indexed_access,
-            object: expr,
-            index: index_expr,
-            line: bracket_token[:line],
-            column: bracket_token[:column]
-          }
+          if end_index
+            # This is a slice operation
+            expr = {
+              type: :slice_access,
+              object: expr,
+              start_index: index_expr,
+              end_index: end_index,
+              line: bracket_token[:line],
+              column: bracket_token[:column]
+            }
+          else
+            # Regular indexed access
+            expr = {
+              type: :indexed_access,
+              object: expr,
+              index: index_expr,
+              line: bracket_token[:line],
+              column: bracket_token[:column]
+            }
+          end
         # Check for function call directly on an expression
         elsif current_token[:type] == :paren_open
           paren_token = advance # Skip '('
@@ -1106,6 +2052,85 @@ module Vinter
       return expr
     end
 
+    def parse_builtin_function_call(name, line, column)
+      # Skip the function name (already consumed)
+      advance if current_token[:value] == name
+
+      # Check if there's an opening parenthesis
+      if current_token && current_token[:type] == :paren_open
+        advance # Skip '('
+
+        # Parse arguments
+        args = []
+
+        # Functions that take string expressions as code
+        special_functions = ['map', 'reduce', 'sort', 'call', 'eval', 'execute', 'exec']
+        is_special_function = special_functions.include?(name)
+
+        # Parse until closing parenthesis
+        while @position < @tokens.length && current_token && current_token[:type] != :paren_close
+          # Skip whitespace or comments
+          if current_token[:type] == :whitespace || current_token[:type] == :comment
+            advance
+            next
+          end
+
+          # Special handling for string arguments that contain code
+          if is_special_function &&
+             current_token && current_token[:type] == :string
+            string_token = parse_expression
+            args << {
+              type: :literal,
+              value: string_token[:value],
+              token_type: :string,
+              line: string_token[:line],
+              column: string_token[:column]
+            }
+          else
+            arg = parse_expression
+            args << arg if arg
+          end
+
+          if current_token && current_token[:type] == :comma
+            advance
+          elsif current_token && current_token[:type] != :paren_close
+            @errors << {
+              message: "Expected comma or closing parenthesis in #{name} function",
+              position: @position,
+              line: current_token[:line],
+              column: current_token[:column]
+            }
+            break
+          end
+        end
+
+        # Check for closing parenthesis
+        if current_token && current_token[:type] == :paren_close
+          advance # Skip ')'
+        else
+          @errors << {
+            message: "Expected ')' to close #{name} function call",
+            position: @position,
+            line: current_token ? current_token[:line] : 0,
+            column: current_token ? current_token[:column] : 0
+          }
+        end
+      else
+        # Handle legacy Vim script where parentheses might be omitted
+        # Just parse one expression as the argument
+        args = [parse_expression]
+      end
+
+      # Return function call node
+      {
+        type: :builtin_function_call,
+        name: name,
+        arguments: args,
+        line: line,
+        column: column
+      }
+    end
+
     def is_lambda_expression
       # Save the current position
       original_position = @position
@@ -1153,7 +2178,7 @@ module Vinter
           # There might be a return type annotation
           advance
           # Skip the type
-          advance if current_token && current_token[:type] == :identifier
+          advance if current_token && [:identifier, :keyword].include?(current_token[:type])
           # Check for the arrow
           has_arrow = current_token && current_token[:type] == :operator && current_token[:value] == '=>'
         end
@@ -1165,6 +2190,109 @@ module Vinter
       return has_params && has_arrow
     end
 
+    def parse_vim_lambda(line, column)
+      advance # Skip opening brace
+
+      # Parse parameters
+      params = []
+
+      # Check if this is a no-parameter lambda (starts with ->)
+      if current_token && current_token[:type] == :operator && current_token[:value] == '->'
+        # No parameters, skip to arrow parsing
+      else
+        # Parse parameter(s)
+        if current_token && (current_token[:type] == :identifier ||
+                            current_token[:type] == :local_variable ||
+                            current_token[:type] == :global_variable)
+          param_name = current_token[:value]
+          param_line = current_token[:line]
+          param_column = current_token[:column]
+          advance
+
+          params << {
+            type: :parameter,
+            name: param_name,
+            line: param_line,
+            column: param_column
+          }
+
+          # Handle multiple parameters (comma-separated)
+          while current_token && current_token[:type] == :comma
+            advance # Skip comma
+
+            if current_token && (current_token[:type] == :identifier ||
+                                current_token[:type] == :local_variable ||
+                                current_token[:type] == :global_variable)
+              param_name = current_token[:value]
+              param_line = current_token[:line]
+              param_column = current_token[:column]
+              advance
+
+              params << {
+                type: :parameter,
+                name: param_name,
+                line: param_line,
+                column: param_column
+              }
+            else
+              @errors << {
+                message: "Expected parameter name after comma in lambda function",
+                position: @position,
+                line: current_token ? current_token[:line] : 0,
+                column: current_token ? current_token[:column] : 0
+              }
+              break
+            end
+          end
+        else
+          # For no-parameter lambdas, this is not an error
+          if !(current_token && current_token[:type] == :operator && current_token[:value] == '->')
+            @errors << {
+              message: "Expected parameter name or '->' in lambda function",
+              position: @position,
+              line: current_token ? current_token[:line] : 0,
+              column: current_token ? current_token[:column] : 0
+            }
+          end
+        end
+      end
+
+      # Expect the arrow token
+      if current_token && current_token[:type] == :operator && current_token[:value] == '->'
+        advance # Skip ->
+      else
+        @errors << {
+          message: "Expected '->' in lambda function",
+          position: @position,
+          line: current_token ? current_token[:line] : 0,
+          column: current_token ? current_token[:column] : 0
+        }
+      end
+
+      # Parse the lambda body expression (everything until the closing brace)
+      body = parse_expression
+
+      # Expect closing brace
+      if current_token && current_token[:type] == :brace_close
+        advance # Skip }
+      else
+        @errors << {
+          message: "Expected closing brace for lambda function",
+          position: @position,
+          line: current_token ? current_token[:line] : 0,
+          column: current_token ? current_token[:column] : 0
+        }
+      end
+
+      return {
+        type: :vim_lambda,
+        params: params,
+        body: body,
+        line: line,
+        column: column
+      }
+    end
+
     def parse_lambda_expression(line, column)
       expect(:paren_open)  # Skip '('
 
@@ -1292,6 +2420,11 @@ module Vinter
       advance  # Skip '{'
       entries = []
 
+      # Handle whitespace after opening brace
+      while current_token && current_token[:type] == :whitespace
+        advance
+      end
+
       # Empty dictionary
       if current_token && current_token[:type] == :brace_close
         advance  # Skip '}'
@@ -1304,11 +2437,21 @@ module Vinter
       end
 
       # Parse dictionary entries
-      loop do
+      while current_token && current_token[:type] != :brace_close
+        # Skip any backslash line continuation markers and whitespace
+        while current_token && (current_token[:type] == :backslash || current_token[:type] == :whitespace || current_token[:type] == :line_continuation)
+          advance
+        end
+
+        # Break if we reached the end or found closing brace
+        if !current_token || current_token[:type] == :brace_close
+          break
+        end
+
         # Parse key (string or identifier)
         key = nil
         if current_token && (current_token[:type] == :string || current_token[:type] == :identifier)
-          key = current_token[:type] == :string ? current_token[:value] : current_token[:value]
+          key = current_token[:value]
           advance  # Skip key
         else
           @errors << {
@@ -1317,487 +2460,1429 @@ module Vinter
             line: current_token ? current_token[:line] : 0,
             column: current_token ? current_token[:column] : 0
           }
-          break
+          # Try to recover by advancing until we find a colon or closing brace
+          while current_token && current_token[:type] != :colon && current_token[:type] != :brace_close
+            advance
+          end
+          if !current_token || current_token[:type] == :brace_close
+            break
+          end
+        end
+
+        # Skip whitespace after key
+        while current_token && current_token[:type] == :whitespace
+          advance
         end
 
         # Expect colon
-        expect(:colon)
+        if current_token && current_token[:type] == :colon
+          advance  # Skip colon
+        else
+          @errors << {
+            message: "Expected colon after dictionary key",
+            position: @position,
+            line: current_token ? current_token[:line] : 0,
+            column: current_token ? current_token[:column] : 0
+          }
+        end
+
+        # Skip whitespace after colon
+        while current_token && current_token[:type] == :whitespace
+          advance
+        end
+
+        # Parse value
+        if current_token && current_token[:type] == :brace_open
+          lambda_or_dict = parse_vim_lambda_or_dict(line, column)
+          value = lambda_or_dict
+        else
+          value = parse_expression
+        end
+
+        entries << {
+          key: key,
+          value: value
+        }
+
+        # After parsing an entry, skip whitespace and look for comma or closing brace
+        while current_token && current_token[:type] == :whitespace
+          advance
+        end
+
+        # Check for comma (indicates more entries follow)
+        if current_token && current_token[:type] == :comma
+          advance # Skip comma
+          # Skip any line continuations and whitespace after comma
+          while current_token && (current_token[:type] == :whitespace ||
+                                 current_token[:type] == :backslash ||
+                                 current_token[:type] == :line_continuation)
+            advance
+          end
+        else
+          # No comma - skip any line continuations before checking for closing brace
+          while current_token && (current_token[:type] == :backslash ||
+                                 current_token[:type] == :line_continuation ||
+                                 current_token[:type] == :whitespace)
+            advance
+          end
+
+          # After skipping continuations, we should find the closing brace
+          if current_token && current_token[:type] == :brace_close
+            # This is fine - last entry without trailing comma
+            break
+          elsif current_token && current_token[:type] != :brace_close
+            @errors << {
+              message: "Expected comma or closing brace after dictionary entry",
+              position: @position,
+              line: current_token ? current_token[:line] : 0,
+              column: current_token ? current_token[:column] : 0
+            }
+            break
+          end
+        end
+      end
+
+      # Make sure we have a closing brace
+      if current_token && current_token[:type] == :brace_close
+        advance  # Skip '}'
+      else
+        @errors << {
+          message: "Expected closing brace for dictionary",
+          position: @position,
+          line: current_token ? current_token[:line] : 0,
+          column: current_token ? current_token[:column] : 0
+        }
+      end
+
+      {
+        type: :dict_literal,
+        entries: entries,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_list_literal(line, column)
+      advance  # Skip '['
+      elements = []
+
+      # Empty list
+      if current_token && current_token[:type] == :bracket_close
+        advance  # Skip ']'
+        return {
+          type: :list_literal,
+          elements: elements,
+          line: line,
+          column: column
+        }
+      end
+
+      # Parse list elements
+      while @position < @tokens.length
+        # Handle line continuation characters (backslash)
+        if current_token && [:backslash, :line_continuation].include?(current_token[:type])
+          # Skip the backslash token
+          advance
+
+          # Skip any whitespace that might follow the backslash
+          while current_token && current_token[:type] == :whitespace
+            advance
+          end
+
+          # Don't add a comma - just continue to parse the next element
+          next
+        end
+
+        # Check if we've reached the end of the list
+        if current_token && current_token[:type] == :bracket_close
+          advance  # Skip ']'
+          break
+        end
+
+        element = parse_expression
+        elements << element if element
+
+        # Continue if there's a comma
+        if current_token && current_token[:type] == :comma
+          advance  # Skip comma
+        # Or if the next token is a backslash (line continuation)
+        else
+          # binding.pry
+          # If no comma and not a closing bracket or backslash, then it's an error
+          # if current_token && current_token[:type] != :bracket_close
+          #   @errors << {
+          #     message: "Expected comma, backslash, or closing bracket after list element",
+          #     position: @position,
+          #     line: current_token[:line],
+          #     column: current_token[:column]
+          #   }
+          # end
+
+          # We still want to skip the closing bracket if it's there
+          if current_token && current_token[:type] == :bracket_close
+            advance
+            break
+          end
+          advance
+          #next
+        end
+      end
+
+      # Check if we have a second list immediately following this one (Vim's special syntax)
+      if current_token && current_token[:type] == :bracket_open
+        next_list = parse_list_literal(current_token[:line], current_token[:column])
+
+        return {
+          type: :list_concat_expression,
+          left: {
+            type: :list_literal,
+            elements: elements,
+            line: line,
+            column: column
+          },
+          right: next_list,
+          line: line,
+          column: column
+        }
+      end
+
+      return {
+        type: :list_literal,
+        elements: elements,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_unary_expression
+      # Check for unary operators (!, -, +)
+      if current_token && current_token[:type] == :operator &&
+         ['!', '-', '+'].include?(current_token[:value])
+
+        op_token = advance # Skip the operator
+        operand = parse_unary_expression  # Recursively parse the operand
+
+        return {
+          type: :unary_expression,
+          operator: op_token[:value],
+          operand: operand,
+          line: op_token[:line],
+          column: op_token[:column]
+        }
+      end
+
+      # If no unary operator, parse a primary expression
+      return parse_primary_expression
+    end
+
+    def parse_function_call(name, line, column)
+      expect(:paren_open)
+
+      args = []
+
+      # Special handling for Vim functions that take code strings as arguments
+      special_functions = ['map', 'reduce', 'sort', 'call', 'eval', 'execute', 'exec']
+      is_special_function = special_functions.include?(name)
+
+      # Parse arguments until we find a closing parenthesis
+      while @position < @tokens.length && current_token && current_token[:type] != :paren_close
+        # Skip comments inside parameter lists
+        if current_token && current_token[:type] == :comment
+          advance
+          next
+        end
+        if is_special_function && current_token && current_token[:type] == :string
+          # For functions like map(), filter(), directly add the string as an argument
+          string_token = parse_string
+          args << {
+            type: :literal,
+            value: string_token[:value],
+            token_type: :string,
+            line: string_token[:line],
+            column: string_token[:column]
+          }
+        else
+          # Parse the argument
+          arg = parse_expression
+          args << arg if arg
+        end
+
+        # Break if we hit the closing paren
+        if current_token && current_token[:type] == :paren_close
+          break
+        end
+        # If we have a comma, advance past it and continue
+        if current_token && current_token[:type] == :comma
+          advance
+        # If we don't have a comma and we're not at the end, it's an error
+        elsif current_token && current_token[:type] != :paren_close && current_token[:type] != :comment
+          @errors << {
+            message: "Expected comma or closing parenthesis after argument",
+            position: @position,
+            line: current_token[:line],
+            column: current_token[:column]
+          }
+          break
+        end
+      end
+
+      expect(:paren_close)
+
+      {
+        type: :function_call,
+        name: name,
+        arguments: args,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_vim_lambda_or_dict(line, column)
+      # Save current position to peek ahead
+      start_position = @position
+
+      advance # Skip opening brace
+
+      # Check if this is a lambda by looking for parameter names followed by arrow
+      is_lambda = false
+      param_names = []
+
+      # Check for immediate arrow (no parameters lambda)
+      if current_token && current_token[:type] == :operator && current_token[:value] == '->'
+        is_lambda = true
+      else
+        # Parse until closing brace or arrow
+        while @position < @tokens.length && current_token[:type] != :brace_close
+          if current_token[:type] == :identifier
+            param_names << current_token[:value]
+            advance
+
+            # Skip comma between parameters
+            if current_token && current_token[:type] == :comma
+              advance
+              next
+            end
+          elsif current_token[:type] == :operator && current_token[:value] == '->'
+            is_lambda = true
+            break
+          else
+            # If we see a colon, this is likely a nested dictionary
+            if current_token && current_token[:type] == :colon
+              break
+            end
+            advance
+          end
+        end
+      end
+
+      # Reset position
+      @position = start_position
+
+      if is_lambda
+        return parse_vim_lambda(line, column)
+      else
+        return parse_dict_literal(line, column)
+      end
+    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_scriptencoding
+      token = advance
+      advance
+      { type: :scriptencoding, encoding: current_token[:value] }
+    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_command_definition
+      token = advance # Skip 'command' or 'command!'
+      line = token[:line]
+      column = token[:column]
+
+      # Check if the command has a bang (!)
+      has_bang = false
+      if current_token && current_token[:type] == :operator && current_token[:value] == '!'
+        has_bang = true
+        advance # Skip '!'
+      end
+
+      # Parse command options/attributes (starting with hyphen)
+      attributes = []
+      while current_token && (
+        (current_token[:type] == :operator && current_token[:value] == '-') ||
+        (current_token[:type] == :identifier && current_token[:value].start_with?('-'))
+      )
+        # Handle option as a single attribute if it's already combined
+        if current_token[:type] == :identifier && current_token[:value].start_with?('-')
+          attributes << current_token[:value]
+          advance
+        else
+          # Otherwise combine the hyphen with the following identifier
+          advance # Skip the hyphen
+          if current_token && current_token[:type] == :identifier
+            attributes << "-#{current_token[:value]}"
+            advance
+          end
+        end
+
+        # If there's an = followed by a value, include it in the attribute
+        if current_token && current_token[:type] == :operator && current_token[:value] == '='
+          attribute = attributes.pop # Take the last attribute we added
+          advance # Skip the '='
+
+          # Get the value (number or identifier)
+          if current_token && (current_token[:type] == :number || current_token[:type] == :identifier)
+            attribute += "=#{current_token[:value]}"
+            attributes << attribute
+            advance
+          end
+        end
+      end
+
+      # Parse the command name
+      command_name = nil
+      if current_token && current_token[:type] == :identifier
+        command_name = current_token[:value]
+        advance
+      else
+        @errors << {
+          message: "Expected command name",
+          position: @position,
+          line: current_token ? current_token[:line] : 0,
+          column: current_token ? current_token[:column] : 0
+        }
+      end
+
+      # Parse the command implementation - collect all remaining tokens as raw parts
+      implementation_parts = []
+      while @position < @tokens.length
+        # Break on end of line or comment
+        if !current_token || current_token[:type] == :comment ||
+           (current_token[:value] == "\n" && !current_token[:value].start_with?("\\"))
+          break
+        end
+
+        implementation_parts << current_token
+        advance
+      end
+
+      {
+        type: :command_definition,
+        name: command_name,
+        has_bang: has_bang,
+        attributes: attributes,
+        implementation: implementation_parts,
+        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
+
+      # For script-local functions or other scoped functions
+      is_script_local = false
+      function_scope = nil
+
+      # Check if we have a script-local function (s:)
+      if current_token && current_token[:type] == :script_local
+        is_script_local = true
+        function_scope = current_token[:value]
+        advance # Skip s: prefix
+      elsif current_token && current_token[:type] == :identifier && current_token[:value].include?(':')
+        # Handle other scoped functions like g: or b:
+        parts = current_token[:value].split(':')
+        if parts.length == 2
+          function_scope = parts[0] + ':'
+          advance
+        end
+      end
+
+      # Now handle the function name, which might be separate from the scope
+      name = nil
+      if !is_script_local && function_scope.nil? && current_token && current_token[:type] == :identifier
+        name = current_token
+        advance
+      elsif is_script_local || !function_scope.nil?
+        if current_token && current_token[:type] == :identifier
+          name = current_token
+          advance
+        end
+      else
+        name = expect(:identifier)
+      end
+
+      # 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
+        if current_token[:type] == :keyword && current_token[:value] == 'abort'
+          attributes << advance[:value]
+        elsif current_token[:type] == :identifier &&
+              ['range', 'dict', 'closure'].include?(current_token[:value])
+          attributes << advance[:value]
+        else
+          break
+        end
+      end
+
+      # Parse function body until 'endfunction' or 'endfunc'
+      body = parse_body_until('endfunction', 'endfunc')
+
+      # Expect endfunction/endfunc
+      expect_end_keyword('endfunction', 'endfunc')
+
+      function_name = name ? name[:value] : nil
+      if function_scope
+        function_name = function_scope + function_name if function_name
+      end
+
+      {
+        type: :legacy_function,
+        name: function_name,
+        is_script_local: is_script_local,
+        scope: function_scope,
+        params: params,
+        has_bang: has_bang,
+        attributes: attributes,
+        body: body,
+        line: line,
+        column: column
+      }
+    end
+
+    # Legacy function parameters are different - they can use a:name syntax
+    def parse_parameter_list_legacy
+      params = []
+
+      # Empty parameter list
+      if current_token && current_token[:type] == :paren_close
+        return params
+      end
+
+      # Handle special case: varargs at the start of the parameter list
+      if current_token && (
+        (current_token[:type] == :ellipsis) ||
+        (current_token[:type] == :operator && current_token[:value] == '.')
+      )
+        if current_token[:type] == :ellipsis
+          token = advance
+          params << {
+            type: :var_args_legacy,
+            name: '...',
+            line: token[:line],
+            column: token[:column]
+          }
+          return params
+        else
+          # Count consecutive dots
+          dot_count = 0
+          first_dot_token = current_token
+
+          # Store the line and column before we advance
+          dot_line = first_dot_token[:line]
+          dot_column = first_dot_token[:column]
+
+          while current_token && current_token[:type] == :operator && current_token[:value] == '.'
+            dot_count += 1
+            advance
+          end
+
+          if dot_count == 3
+            params << {
+              type: :var_args_legacy,
+              name: '...',
+              line: dot_line,
+              column: dot_column
+            }
+            return params
+          end
+        end
+      end
+
+      # Regular parameter parsing (existing logic)
+      loop do
+        if current_token && current_token[:type] == :identifier
+          param_name = advance
+
+          # 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],
+            default_value: default_value,
+            optional: default_value != nil,
+            line: param_name[:line],
+            column: param_name[:column]
+          }
+        elsif current_token && current_token[:type] == :arg_variable
+          param_name = advance
+          name_without_prefix = param_name[:value].sub(/^a:/, '')
+
+          # 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: name_without_prefix,
+            default_value: default_value,
+            optional: default_value != nil,
+            line: param_name[:line],
+            column: param_name[:column],
+            is_arg_prefixed: true
+          }
+        else
+          # We might be at varargs after other parameters
+          if current_token && (
+            (current_token[:type] == :ellipsis) ||
+            (current_token[:type] == :operator && current_token[:value] == '.')
+          )
+            # Add debug
+            #puts "Found potential varargs token: #{current_token[:type]} #{current_token[:value]}"
+
+            if current_token[:type] == :ellipsis
+              token = current_token  # STORE the token before advancing
+              advance
+              params << {
+                type: :var_args_legacy,
+                name: '...',
+                line: token[:line],   # Use stored token
+                column: token[:column]
+              }
+            else
+              dot_count = 0
+              first_dot_token = current_token
+
+              # Store line/column BEFORE advancing
+              dot_line = first_dot_token[:line]
+              dot_column = first_dot_token[:column]
+
+              #puts "Starting dot sequence at line #{dot_line}, column #{dot_column}"
+
+              while current_token && current_token[:type] == :operator && current_token[:value] == '.'
+                dot_count += 1
+                #puts "Found dot #{dot_count}"
+                advance
+              end
+
+              if dot_count == 3
+                #puts "Complete varargs found (3 dots)"
+                params << {
+                  type: :var_args_legacy,
+                  name: '...',
+                  line: dot_line,     # Use stored values
+                  column: dot_column
+                }
+              else
+                #puts "Incomplete varargs: only #{dot_count} dots found"
+              end
+            end
+            break
+          else
+            # Add debug to see what unexpected token we're encountering
+            #puts "Unexpected token in parameter list: #{current_token ? current_token[:type] : 'nil'} #{current_token ? current_token[:value] : ''}"
+
+            # Not a valid parameter or varargs
+            @errors << {
+              message: "Expected parameter name",
+              position: @position,
+              line: current_token ? current_token[:line] : 0,
+              column: current_token ? current_token[:column] : 0
+            }
+            break
+          end
+        end
+        if current_token && current_token[:type] == :comma
+          advance
+        else
+          break
+        end
+      end
+
+      params
+    end
+
+    def parse_try_statement
+      token = advance # Skip 'try'
+      line = token[:line]
+      column = token[:column]
+
+      # Parse the try body until catch/finally/endtry
+      body = parse_body_until('catch', 'finally', 'endtry')
+
+      catch_clauses = []
+      finally_clause = nil
+
+      # Parse catch clauses
+      while @position < @tokens.length &&
+            current_token && current_token[:type] == :keyword &&
+            current_token[:value] == 'catch'
+        catch_token = advance # Skip 'catch'
+        catch_line = catch_token[:line]
+        catch_column = catch_token[:column]
+
+        # Parse the pattern (anything until the next statement)
+        pattern = ''
+        pattern_tokens = []
+
+        # Collect all tokens until we hit a newline or a statement
+        while @position < @tokens.length
+          if !current_token ||
+             (current_token[:type] == :whitespace && current_token[:value].include?("\n")) ||
+             current_token[:type] == :comment
+            break
+          end
+
+          pattern_tokens << current_token
+          pattern += current_token[:value]
+          advance
+        end
 
-        # Parse value
-        value = parse_expression
+        # Parse the catch body until next catch/finally/endtry
+        catch_body = parse_body_until('catch', 'finally', 'endtry')
 
-        entries << {
-          key: key,
-          value: value
+        catch_clauses << {
+          type: :catch_clause,
+          pattern: pattern.strip,
+          body: catch_body,
+          line: catch_line,
+          column: catch_column
         }
+      end
 
-        if current_token && current_token[:type] == :comma
-          advance  # Skip comma
-          # Allow trailing comma
-          break if current_token && current_token[:type] == :brace_close
-        else
-          break
-        end
+      # Parse finally clause if present
+      if @position < @tokens.length &&
+         current_token && current_token[:type] == :keyword &&
+         current_token[:value] == 'finally'
+        finally_token = advance # Skip 'finally'
+        finally_line = finally_token[:line]
+        finally_column = finally_token[:column]
+
+        # Parse the finally body until 'endtry'
+        finally_body = parse_body_until('endtry')
+
+        finally_clause = {
+          type: :finally_clause,
+          body: finally_body,
+          line: finally_line,
+          column: finally_column
+        }
       end
 
-      expect(:brace_close)  # Expect and skip '}'
+      # Expect endtry
+      expect_end_keyword('endtry')
 
-      {
-        type: :dict_literal,
-        entries: entries,
+      return {
+        type: :try_statement,
+        body: body,
+        catch_clauses: catch_clauses,
+        finally_clause: finally_clause,
         line: line,
         column: column
       }
     end
 
-    def parse_list_literal(line, column)
-      advance  # Skip '['
-      elements = []
+    # Also add a method to parse throw statements:
 
-      # Empty list
-      if current_token && current_token[:type] == :bracket_close
-        advance  # Skip ']'
-        return {
-          type: :list_literal,
-          elements: elements,
-          line: line,
-          column: column
-        }
-      end
+    def parse_throw_statement
+      token = advance # Skip 'throw'
+      line = token[:line]
+      column = token[:column]
 
-      # Parse list elements
-      while @position < @tokens.length
-        # Check if we've reached the end of the list
-        if current_token && current_token[:type] == :bracket_close
-          advance  # Skip ']'
-          break
-        end
+      # Parse the expression to throw
+      expression = parse_expression
 
-        element = parse_expression
-        elements << element if element
+      return {
+        type: :throw_statement,
+        expression: expression,
+        line: line,
+        column: column
+      }
+    end
 
-        # Continue if there's a comma
-        if current_token && current_token[:type] == :comma
-          advance  # Skip comma
-        else
-          # If no comma and not a closing bracket, then it's an error
-          if current_token && current_token[:type] != :bracket_close
-            @errors << {
-              message: "Expected comma or closing bracket after list element",
-              position: @position,
-              line: current_token[:line],
-              column: current_token[:column]
-            }
-          end
+    def parse_call_statement
+      token = advance # Skip 'call'
+      line = token[:line]
+      column = token[:column]
 
-          # We still want to skip the closing bracket if it's there
-          if current_token && current_token[:type] == :bracket_close
-            advance
+      # Parse the function call expression that follows 'call'
+      func_expr = nil
+
+      if current_token && current_token[:type] == :script_local
+        # Handle script-local function call (s:func_name)
+        func_name = current_token[:value]
+        func_line = current_token[:line]
+        func_column = current_token[:column]
+        advance
+
+        # Parse arguments
+        args = []
+        if current_token && current_token[:type] == :paren_open
+          expect(:paren_open) # Skip '('
+
+          # Parse arguments if any
+          unless current_token && current_token[:type] == :paren_close
+            loop do
+              arg = parse_expression
+              args << arg if arg
+
+              if current_token && current_token[:type] == :comma
+                advance # Skip comma
+              else
+                break
+              end
+            end
           end
 
-          break
+          expect(:paren_close) # Skip ')'
         end
-      end
-
-      # Check if we have a second list immediately following this one (Vim's special syntax)
-      if current_token && current_token[:type] == :bracket_open
-        next_list = parse_list_literal(current_token[:line], current_token[:column])
 
-        return {
-          type: :list_concat_expression,
-          left: {
-            type: :list_literal,
-            elements: elements,
-            line: line,
-            column: column
-          },
-          right: next_list,
-          line: line,
-          column: column
+        func_expr = {
+          type: :script_local_call,
+          name: func_name,
+          arguments: args,
+          line: func_line,
+          column: func_column
         }
+      else
+        # For other function calls
+        func_expr = parse_expression
       end
 
-      return {
-        type: :list_literal,
-        elements: elements,
+      {
+        type: :call_statement,
+        expression: func_expr,
         line: line,
         column: column
       }
     end
 
-    def parse_unary_expression
-      # Check for unary operators (!, -, +)
-      if current_token && current_token[:type] == :operator &&
-         ['!', '-', '+'].include?(current_token[:value])
+    def parse_string
+      # Start with the first string or expression
+      left = parse_primary_term
+
+      # Continue as long as we see the '.' or '..' string concatenation operator
+      while current_token && current_token[:type] == :operator &&
+            (current_token[:value] == '.' || current_token[:value] == '..')
 
+        # Store the operator token
         op_token = advance # Skip the operator
-        operand = parse_unary_expression  # Recursively parse the operand
+        op = op_token[:value]
 
-        return {
-          type: :unary_expression,
-          operator: op_token[:value],
-          operand: operand,
+        # If this is the dot operator, check if it's actually part of '..'
+        if op == '.' && peek_token && peek_token[:type] == :operator && peek_token[:value] == '.'
+          advance # Skip the second dot
+          op = '..'
+        end
+
+        # Parse the right side of the concatenation
+        right = parse_primary_term
+
+        # Create a string concatenation expression
+        left = {
+          type: :string_concatenation,
+          operator: op,
+          left: left,
+          right: right,
           line: op_token[:line],
           column: op_token[:column]
         }
       end
 
-      # If no unary operator, parse a primary expression
-      return parse_primary_expression
+      return left
     end
 
-    def parse_function_call(name, line, column)
-      expect(:paren_open)
+    # Helper function to parse a primary term in string expressions
+    def parse_primary_term
+      if !current_token
+        return nil
+      end
 
-      args = []
+      token = current_token
+      line = token[:line]
+      column = token[:column]
 
-      # Parse arguments until we find a closing parenthesis
-      while @position < @tokens.length && current_token && current_token[:type] != :paren_close
-        # Skip comments inside parameter lists
-        if current_token && current_token[:type] == :comment
-          advance
-          next
-        end
+      case token[:type]
+      when :string
+        # Handle string literal
+        advance
+        return {
+          type: :literal,
+          value: token[:value],
+          token_type: :string,
+          line: line,
+          column: column
+        }
+      when :identifier, :global_variable, :script_local, :arg_variable,
+           :local_variable, :buffer_local, :window_local, :tab_local
+        # Handle variable references
+        advance
+        return {
+          type: token[:type],
+          name: token[:value],
+          line: line,
+          column: column
+        }
+      when :paren_open
+        # Handle parenthesized expressions
+        advance # Skip '('
+        expr = parse_expression
+        expect(:paren_close) # Skip ')'
+        return expr
+      when :function
+        # Handle function calls
+        return parse_function_call(token[:value], line, column)
+      else
+        # For anything else, use the standard expression parser
+        return parse_expression
+      end
+    end
 
-        # Check if the argument might be a lambda expression
-        if current_token && current_token[:type] == :paren_open && is_lambda_expression
-          arg = parse_lambda_expression(current_token[:line], current_token[:column])
-        else
-          arg = parse_expression
-        end
+    def parse_silent_command
+      token = advance # Skip 'silent'
+      line = token[:line]
+      column = token[:column]
 
-        args << arg if arg
+      # Check for ! after silent
+      has_bang = false
+      if current_token && current_token[:type] == :operator && current_token[:value] == '!'
+        has_bang = true
+        advance # Skip '!'
+      end
 
-        # Break if we hit the closing paren
-        if current_token && current_token[:type] == :paren_close
-          break
-        end
+      # Now parse the command that follows silent
+      # It could be a standard command or a command with a range
+      command = nil
 
-        # If we have a comma, advance past it and continue
-        if current_token && current_token[:type] == :comma
-          advance
-        # If we don't have a comma and we're not at the end, it's an error
-        elsif current_token && current_token[:type] != :paren_close && current_token[:type] != :comment
+      # Check if the next token is a range operator (% in this case)
+      if current_token && current_token[:type] == :operator && current_token[:value] == '%'
+        range_token = advance # Skip '%'
+
+        # Now we expect a command (like 'delete')
+        if current_token &&
+           (current_token[:type] == :keyword || current_token[:type] == :identifier)
+          cmd_token = advance # Skip the command name
+          cmd_name = cmd_token[:value]
+
+          # Parse any arguments to the command
+          args = []
+          while current_token &&
+                current_token[:type] != :comment &&
+                (current_token[:value] != "\n" ||
+                 (current_token[:value] == "\n" &&
+                  !current_token[:value].start_with?("\\")))
+
+            # Add the token as an argument
+            args << current_token
+            advance
+          end
+
+          command = {
+            type: :range_command,
+            range: '%',
+            command: {
+              type: :command,
+              name: cmd_name,
+              args: args,
+              line: cmd_token[:line],
+              column: cmd_token[:column]
+            },
+            line: range_token[:line],
+            column: range_token[:column]
+          }
+        else
           @errors << {
-            message: "Expected comma or closing parenthesis after argument",
+            message: "Expected command after range operator '%'",
             position: @position,
-            line: current_token[:line],
-            column: current_token[:column]
+            line: current_token ? current_token[:line] : range_token[:line],
+            column: current_token ? current_token[:column] : range_token[:column] + 1
           }
-          break
         end
+      else
+        # Parse a regular command
+        command = parse_statement
       end
 
-      expect(:paren_close)
-
-      {
-        type: :function_call,
-        name: name,
-        arguments: args,
+      return {
+        type: :silent_command,
+        has_bang: has_bang,
+        command: command,
         line: line,
         column: column
       }
     end
 
-    def parse_import_statement
-      token = advance # Skip 'import'
+    def parse_delete_command
+      token = advance # Skip 'delete'
       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]
+      # Check for register argument (could be an underscore '_')
+      register = nil
+      if current_token
+        if current_token[:type] == :identifier && current_token[:value] == '_'
+          register = current_token[:value]
+          advance
+        elsif current_token[:type] == :operator && current_token[:value] == '_'
+          # Handle underscore as an operator (some lexers might classify it this way)
+          register = 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]
+      end
 
-          # Extract module name from the path
-          # This is simplified logic - you might need more complex extraction
-          module_name = path.gsub(/['"]/, '').split('/').last.split('.').first
+      return {
+        type: :delete_command,
+        register: register,
+        line: line,
+        column: column
+      }
+    end
 
-          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
+    def parse_brace_sequence_value
+      # Handle special brace sequences like {{{,}}} for foldmarker
+      value_parts = []
+
+      while current_token && (current_token[:type] == :brace_open ||
+                             current_token[:type] == :brace_close ||
+                             current_token[:type] == :comma)
+        value_parts << current_token[:value]
+        advance
+      end
+
+      return {
+        type: :brace_sequence,
+        value: value_parts.join(''),
+        line: current_token ? current_token[:line] : 0,
+        column: current_token ? current_token[:column] : 0
+      }
+    end
+
+    def parse_comma_separated_value
+      # Handle comma-separated option values like menu,menuone,noinsert,noselect
+      values = []
+
+      # Parse first value
+      if current_token && current_token[:type] == :identifier
+        values << current_token[:value]
+        advance
+      else
+        return parse_expression  # Fall back to regular expression parsing
       end
 
-      # Handle 'as name'
-      as_name = nil
-      if current_token && current_token[:type] == :identifier && current_token[:value] == 'as'
-        advance # Skip 'as'
+      # Parse additional comma-separated values
+      while current_token && current_token[:type] == :comma
+        advance # Skip comma
         if current_token && current_token[:type] == :identifier
-          as_name = advance[:value]
+          values << current_token[:value]
+          advance
         else
-          @errors << {
-            message: "Expected identifier after 'as'",
-            position: @position,
-            line: current_token ? current_token[:line] : 0,
-            column: current_token ? current_token[:column] : 0
-          }
+          break
         end
       end
 
-      {
-        type: :import_statement,
-        module: module_name,
-        path: path,
-        is_autoload: is_autoload,
-        as_name: as_name,
-        line: line,
-        column: column
+      return {
+        type: :comma_separated_value,
+        values: values,
+        line: current_token ? current_token[:line] : 0,
+        column: current_token ? current_token[:column] : 0
       }
     end
-    def parse_export_statement
-      token = advance # Skip 'export'
+
+    def parse_set_command
+      token = advance # Skip 'set'
       line = token[:line]
       column = token[:column]
 
-      # Export can be followed by var/const/def/function declarations
-      if !current_token
+      # Parse option name
+      option_name = nil
+      if current_token && current_token[:type] == :identifier
+        option_name = current_token[:value]
+        advance
+      elsif current_token && current_token[:type] == :option_variable
+        # Handle option variable directly (like &option)
+        option_name = current_token[:value].sub(/^&/, '')
+        advance
+      else
         @errors << {
-          message: "Expected declaration after export",
+          message: "Expected option name after 'set'",
           position: @position,
+          line: current_token ? current_token[:line] : line,
+          column: current_token ? current_token[:column] : column + 3
+        }
+        return {
+          type: :set_command,
+          option: nil,
+          value: nil,
+          reset_to_vim_default: false,
           line: line,
           column: column
         }
-        return nil
       end
 
-      exported_item = nil
+      # Check for &vim suffix (reset to Vim default)
+      reset_to_vim_default = false
+      if current_token && current_token[:type] == :option_variable &&
+         (current_token[:value] == '&vim' || current_token[:value] == '&')
+        reset_to_vim_default = true
+        advance
+      end
 
-      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
+      # Check for equals sign and value
+      value = nil
+      if current_token && current_token[:type] == :operator && current_token[:value] == '='
+        advance # Skip '='
+
+        # Special handling for foldmarker and similar options that use brace notation
+        if option_name == 'foldmarker' && current_token && current_token[:type] == :brace_open
+          # Parse as special brace sequence value (e.g., {{{,}}})
+          value = parse_brace_sequence_value
+        # Special handling for comma-separated option values
+        elsif ['completeopt', 'formatoptions', 'guioptions', 'wildoptions'].include?(option_name)
+          value = parse_comma_separated_value
         else
-          @errors << {
-            message: "Unexpected keyword after export: #{current_token[:value]}",
-            position: @position,
-            line: current_token[:line],
-            column: current_token[:column]
-          }
-          advance
-          return nil
+          value = parse_expression
         end
-      else
-        @errors << {
-          message: "Expected declaration after export",
-          position: @position,
-          line: current_token[:line],
-          column: current_token[:column]
+      elsif current_token && current_token[:type] == :operator && current_token[:value] == '-'
+        # Handle syntaxes like 'set option-=value'
+        op = current_token[:value]
+        advance # Skip the operator
+
+        if current_token && current_token[:type] == :operator &&
+           ['+', '=', '^'].include?(current_token[:value])
+          op += current_token[:value]
+          advance # Skip the second part of the operator
+        end
+
+        value = {
+          type: :option_operation,
+          operator: op,
+          value: parse_expression,
+          line: line,
+          column: column
+        }
+      elsif current_token && current_token[:type] == :operator && current_token[:value] == '+'
+        # Handle syntaxes like 'set option+=value'
+        op = current_token[:value]
+        advance # Skip the operator
+
+        if current_token && current_token[:type] == :operator && current_token[:value] == '='
+          op += current_token[:value]
+          advance # Skip the '=' part
+        end
+
+        value = {
+          type: :option_operation,
+          operator: op,
+          value: parse_expression,
+          line: line,
+          column: column
         }
-        advance
-        return nil
       end
 
-      {
-        type: :export_statement,
-        export: exported_item,
+      return {
+        type: :set_command,
+        option: option_name,
+        value: value,
+        reset_to_vim_default: reset_to_vim_default,
         line: line,
         column: column
       }
     end
 
-    def parse_legacy_function
-      token = advance # Skip 'function'
+    def parse_syntax_command
+      token = advance # Skip 'syntax'
       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 '!'
+      # Parse syntax subcommand (match, region, keyword, etc.)
+      subcommand = nil
+      if current_token && current_token[:type] == :identifier
+        subcommand = current_token[:value]
+        advance
       end
 
-      # For script-local functions or other scoped functions
-      is_script_local = false
-      function_scope = nil
-      
-      # Check if we have a script-local function (s:)
-      if current_token && current_token[:type] == :script_local
-        is_script_local = true
-        function_scope = current_token[:value]
-        advance # Skip s: prefix
-      elsif current_token && current_token[:type] == :identifier && current_token[:value].include?(':')
-        # Handle other scoped functions like g: or b:
-        parts = current_token[:value].split(':')
-        if parts.length == 2
-          function_scope = parts[0] + ':'
-          advance
-        end
+      # Parse syntax group name
+      group_name = nil
+      if current_token && current_token[:type] == :identifier
+        group_name = current_token[:value]
+        advance
       end
-      
-      # Now handle the function name, which might be separate from the scope
-      name = nil
-      if !is_script_local && function_scope.nil? && current_token && current_token[:type] == :identifier
-        name = current_token
+
+      # Parse pattern (regex or other pattern)
+      pattern = nil
+      if current_token && current_token[:type] == :regex
+        pattern = current_token[:value]
         advance
-      elsif is_script_local || !function_scope.nil?
+      end
+
+      # Parse any remaining arguments as raw text until end of line
+      args = []
+      while current_token && current_token[:type] != :comment
+        args << current_token[:value]
+        advance
+      end
+
+      {
+        type: :syntax_command,
+        subcommand: subcommand,
+        group_name: group_name,
+        pattern: pattern,
+        args: args.join(' ').strip,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_highlight_command
+      token = advance # Skip 'highlight'
+      line = token[:line]
+      column = token[:column]
+
+      # Parse highlight group name
+      group_name = nil
+      if current_token && current_token[:type] == :identifier
+        group_name = current_token[:value]
+        advance
+      end
+
+      # Parse highlight attributes as key=value pairs
+      attributes = {}
+      while current_token && current_token[:type] != :comment
+        # Parse attribute name
         if current_token && current_token[:type] == :identifier
-          name = current_token
+          attr_name = current_token[:value]
           advance
-        end
-      else
-        name = expect(:identifier)
-      end
 
-      # Parse parameter list
-      expect(:paren_open)
-      params = parse_parameter_list_legacy
-      expect(:paren_close)
+          # Parse = sign
+          if current_token && current_token[:type] == :operator && current_token[:value] == '='
+            advance
 
-      # Check for optional attributes (range, dict, abort, closure)
-      attributes = []
-      while current_token
-        if current_token[:type] == :keyword && current_token[:value] == 'abort'
-          attributes << advance[:value]
-        elsif current_token[:type] == :identifier && 
-              ['range', 'dict', 'closure'].include?(current_token[:value])
-          attributes << advance[:value]
+            # Parse attribute value (can be identifier, number, or hex color)
+            if current_token && (current_token[:type] == :identifier ||
+                                current_token[:type] == :number ||
+                                current_token[:type] == :hex_color)
+              attributes[attr_name] = current_token[:value]
+              advance
+            end
+          end
         else
-          break
+          advance
         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
+      {
+        type: :highlight_command,
+        group_name: group_name,
+        attributes: attributes,
+        line: line,
+        column: column
+      }
+    end
 
-        stmt = parse_statement
-        body << stmt if stmt
-      end
+    def parse_sleep_command
+      token = advance # Skip 'sleep'
+      line = token[:line]
+      column = token[:column]
 
-      # 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])
+      # Parse duration (number with optional suffix)
+      duration = nil
+      if current_token && current_token[:type] == :number
+        duration = current_token[:value]
+        advance
+      else
         @errors << {
-          message: "Expected 'endfunction' or 'endfunc'",
+          message: "Expected duration after 'sleep'",
           position: @position,
-          line: end_token ? end_token[:line] : 0,
-          column: end_token ? end_token[:column] : 0
+          line: current_token ? current_token[:line] : line,
+          column: current_token ? current_token[:column] : column + 5
         }
       end
 
-      function_name = name ? name[:value] : nil
-      if function_scope
-        function_name = function_scope + function_name if function_name
-      end
-      
       {
-        type: :legacy_function,
-        name: function_name,
-        is_script_local: is_script_local,
-        scope: function_scope,
-        params: params,
-        has_bang: has_bang,
-        attributes: attributes,
-        body: body,
+        type: :sleep_command,
+        duration: duration,
         line: line,
         column: column
       }
     end
 
-    # Legacy function parameters are different - they can use a:name syntax
-    def parse_parameter_list_legacy
-      params = []
+    def parse_source_command
+      token = advance # Skip 'source'
+      line = token[:line]
+      column = token[:column]
 
-      # Empty parameter list
-      if current_token && current_token[:type] == :paren_close
-        return params
+      # Parse file path - collect all tokens until end of line/comment
+      path_parts = []
+      while current_token && current_token[:type] != :comment
+        path_parts << current_token[:value]
+        advance
       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
-          # Regular parameter
-          param_name = advance
-          params << {
-            type: :parameter,
-            name: param_name[:value],
-            line: param_name[:line],
-            column: param_name[:column]
-          }
-        elsif current_token && current_token[:type] == :arg_variable
-          # Parameter with a: prefix
-          param_name = advance
-          # Extract name without 'a:' prefix
-          name_without_prefix = param_name[:value].sub(/^a:/, '')
-          params << {
-            type: :parameter,
-            name: name_without_prefix,
-            line: param_name[:line],
-            column: param_name[:column],
-            is_arg_prefixed: true
-          }
-        else
-          @errors << {
-            message: "Expected parameter name",
-            position: @position,
-            line: current_token ? current_token[:line] : 0,
-            column: current_token ? current_token[:column] : 0
-          }
-          break
-        end
-
-        if current_token && current_token[:type] == :comma
-          advance
-        else
-          break
-        end
-      end
+      file_path = path_parts.join('')
 
-      params
+      {
+        type: :source_command,
+        file_path: file_path,
+        line: line,
+        column: column
+      }
     end
-
   end
 end