vinter 0.4.0 → 0.6.0

data/lib/vinter/parser.rb

@@ -1,3 +1,4 @@
+require 'pry'
 module Vinter
   class Parser
     def initialize(tokens, source_text = nil)
@@ -71,6 +72,95 @@ module Vinter
       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 = []
 
@@ -155,7 +245,6 @@ module Vinter
       if !current_token
         return nil
       end
-      start_token = current_token
 
       # Handle pipe as command separator
       if current_token[:type] == :operator && current_token[:value] == '|'
@@ -265,6 +354,8 @@ 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', 'exec'
@@ -287,7 +378,7 @@ module Vinter
           parse_set_command
         when 'syntax'
           parse_syntax_command
-        when 'highlight'
+        when 'highlight', 'hi'
           parse_highlight_command
         when 'sleep'
           parse_sleep_command
@@ -333,6 +424,24 @@ module Vinter
         parse_delete_command
       elsif current_token[:type] == :percentage
         parse_range_command
+      elsif current_token[:type] == :global_variable
+        parse_global_variable
+      elsif current_token[:type] == :buffer_local
+        parse_buffer_var
+      elsif current_token[:type] == :vimfuncs
+        advance
+        parse_function_call(current_token[:value], current_token[:line], current_token[:column])
+      elsif current_token[:type] == :builtin_funcs
+        parse_builtin_function_call
+      elsif current_token[:type] == :compound_operator
+        advance
+        parse_expression
+      elsif current_token[:type] == :string
+        parse_string
+      elsif current_token[:type] == :comma
+        advance
+      elsif current_token[:type] == :colon
+        parse_command_line_call
       else
         @warnings << {
           message: "Unexpected token type: #{current_token[:type]}",
@@ -345,6 +454,182 @@ module Vinter
       end
     end
 
+    def parse_command_line_call
+      token = advance # Skip the ':'
+      line = token[:line]
+      column = token[:column]
+
+      # Extract the command or range
+      command = token[:value][1..] # Remove the leading ':'
+
+      # Check if the command is a range (e.g., `:2`, `:$`)
+      if command.match?(/^\d+$/) || command == '$'
+        return {
+          type: :range_command,
+          range: command,
+          line: line,
+          column: column
+        }
+      end
+
+      # Otherwise, it's a regular command (e.g., `:exe`)
+      args = []
+      while current_token && current_token[:type] != :newline
+        args << current_token[:value]
+        advance
+      end
+
+      {
+        type: :command_line_call,
+        command: command,
+        arguments: args,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_buffer_var
+      token = current_token
+      line = token[:line]
+      column = token[:column]
+      name = token[:value]
+      advance
+
+      # Handle property access (e.g., b:foo.bar)
+      target = {
+        type: :buffer_variable,
+        name: name,
+        line: line,
+        column: column
+      }
+
+      # Property access (dot notation)
+      # shared with global (TODO)
+      # would almost just take an overly simple check to the = operator and call everything after b: name
+      if current_token && current_token[:type] == :operator && current_token[:value] == '.'
+        dot_token = advance
+        if current_token && (current_token[:type] == :identifier || current_token[:type] == :keyword)
+          property_token = advance
+          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 '.' in variable")
+        end
+      end
+
+      # Indexed access (e.g., b:foo[bar])
+      while current_token && current_token[:type] == :bracket_open
+        bracket_token = advance
+        index_expr = parse_expression
+        expect(:bracket_close)
+        target = {
+          type: :indexed_access,
+          object: target,
+          index: index_expr,
+          line: bracket_token[:line],
+          column: bracket_token[:column]
+        }
+      end
+
+      # Assignment operator (= or compound)
+      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 global variable")
+      end
+
+      # Value expression
+      value = parse_expression
+
+      {
+        type: :buffer_variable_assignment,
+        target: target,
+        operator: operator,
+        value: value,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_global_variable
+      token = current_token
+      line = token[:line]
+      column = token[:column]
+      name = token[:value]
+      advance # Skip the global variable token
+
+      # Handle property access (e.g., g:foo.bar)
+      target = {
+        type: :global_variable,
+        name: name,
+        line: line,
+        column: column
+      }
+
+      # Property access (dot notation)
+      if current_token && current_token[:type] == :operator && current_token[:value] == '.'
+        dot_token = advance
+        if current_token && (current_token[:type] == :identifier || current_token[:type] == :keyword)
+          property_token = advance
+          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 '.' in global variable")
+        end
+      end
+
+      # Indexed access (e.g., g:foo[bar])
+      while current_token && current_token[:type] == :bracket_open
+        bracket_token = advance
+        index_expr = parse_expression
+        expect(:bracket_close)
+        target = {
+          type: :indexed_access,
+          object: target,
+          index: index_expr,
+          line: bracket_token[:line],
+          column: bracket_token[:column]
+        }
+      end
+
+      # Assignment operator (= or compound)
+      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 global variable")
+      end
+
+      # Value expression
+      value = parse_expression
+
+      {
+        type: :global_variable_assignment,
+        target: target,
+        operator: operator,
+        value: value,
+        line: line,
+        column: column
+      }
+    end
+
     def parse_range_command
       token = advance # Skip '%'
       line = token[:line]
@@ -427,80 +712,7 @@ module Vinter
       }
     end
 
-    def old_parse_filter_command
-      token = advance # Skip 'filter' or 'filt'
-      line = token[:line]
-      column = token[:column]
 
-      # Check for bang (!)
-      has_bang = false
-      if current_token && current_token[:type] == :operator && current_token[:value] == '!'
-        has_bang = true
-        advance # Skip '!'
-      end
-
-      # Parse the pattern
-      pattern = nil
-      pattern_delimiter = nil
-
-      if current_token && current_token[:type] == :operator && current_token[:value] == '/'
-        # Handle /pattern/ form
-        pattern_delimiter = '/'
-        advance # Skip opening delimiter
-
-        # Collect all tokens until closing delimiter
-        pattern_parts = []
-        while @position < @tokens.length &&
-              !(current_token[:type] == :operator && current_token[:value] == pattern_delimiter)
-          pattern_parts << current_token[:value]
-          advance
-        end
-
-        pattern = pattern_parts.join('')
-
-        # Skip closing delimiter
-        if current_token && current_token[:type] == :operator && current_token[:value] == pattern_delimiter
-          advance
-        else
-          @errors << {
-            message: "Expected closing pattern delimiter: #{pattern_delimiter}",
-            position: @position,
-            line: current_token ? current_token[:line] : 0,
-            column: current_token ? current_token[:column] : 0
-          }
-        end
-      else
-        # Handle direct pattern form (without delimiters)
-        # Parse until we see what appears to be the command
-        pattern_parts = []
-        while @position < @tokens.length
-          # Don't consume tokens that likely belong to the command part
-          if current_token[:type] == :keyword ||
-             (current_token[:type] == :identifier &&
-              ['echo', 'let', 'execute', 'exec', 'autocmd', 'au', 'oldfiles', 'clist', 'command',
-               'files', 'highlight', 'jumps', 'list', 'llist', 'marks', 'registers', 'set'].include?(current_token[:value]))
-            break
-          end
-
-          pattern_parts << current_token[:value]
-          advance
-        end
-
-        pattern = pattern_parts.join('').strip
-      end
-
-      # Parse the command to be filtered
-      command = parse_statement
-
-      {
-        type: :filter_command,
-        pattern: pattern,
-        has_bang: has_bang,
-        command: command,
-        line: line,
-        column: column
-      }
-    end
 
     def parse_augroup_statement
       token = advance # Skip 'augroup'
@@ -513,18 +725,11 @@ module Vinter
         name = current_token[:value]
         advance
       else
-        @errors << {
-          message: "Expected augroup name",
-          position: @position,
-          line: current_token ? current_token[:line] : 0,
-          column: current_token ? current_token[:column] : 0
-        }
+        add_error("Expected augroup name")
       end
 
       # Check for augroup END
-      is_end_marker = false
-      if name && (name.upcase == "END" || name == "END")
-        is_end_marker = true
+      if name && name.upcase == "END"
         return {
           type: :augroup_end,
           line: line,
@@ -540,8 +745,7 @@ module Vinter
            (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[:value] == 'END')) ||
+             ((peek_token[:type] == :identifier && peek_token[:value].upcase == 'END') ||
               (peek_token[:type] == :keyword && peek_token[:value].upcase == 'END'))
             advance # Skip 'augroup'
             advance # Skip 'END'
@@ -619,12 +823,7 @@ module Vinter
                 column: dot_token[:column]
               }
             else
-              @errors << {
-                message: "Expected property name after '.'",
-                position: @position,
-                line: current_token ? current_token[:line] : 0,
-                column: current_token ? current_token[:column] : 0
-              }
+              add_error("Expected property name after '.'")
             end
           end
 
@@ -684,12 +883,7 @@ module Vinter
               }
               advance
             else
-              @errors << {
-                message: "Expected variable name in destructuring assignment",
-                position: @position,
-                line: current_token ? current_token[:line] : 0,
-                column: current_token ? current_token[:column] : 0
-              }
+              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
@@ -706,12 +900,7 @@ module Vinter
             column: bracket_token[:column]
           }
         else
-          @errors << {
-            message: "Expected variable name after let",
-            position: @position,
-            line: current_token ? current_token[:line] : 0,
-            column: current_token ? current_token[:column] : 0
-          }
+          add_error("Expected variable name after let")
         end
       end
 
@@ -723,12 +912,7 @@ module Vinter
         operator = 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
-        }
+        add_error("Expected assignment operator after variable in let statement")
       end
 
       # Parse the value expression
@@ -748,12 +932,7 @@ module Vinter
             func_name = current_token[:value]
             advance
           else
-            @errors << {
-              message: "Expected string with function name in function() call",
-              position: @position,
-              line: current_token ? current_token[:line] : 0,
-              column: current_token ? current_token[:column] : 0
-            }
+            add_error("Expected string with function name in function() call")
           end
 
           # Expect closing parenthesis
@@ -844,9 +1023,11 @@ module Vinter
       event = nil
       if current_token && current_token[:type] == :identifier
         event = advance[:value]
+      elsif current_token[:type] == :operator && current_token[:value] == "!"
+        advance
       else
         @errors << {
-          message: "Expected event name after 'autocmd'",
+          message: "Expected event name after 'autocmd' | #{current_token[:type]}",
           position: @position,
           line: current_token ? current_token[:line] : 0,
           column: current_token ? current_token[:column] : 0
@@ -972,32 +1153,14 @@ module Vinter
           advance # Skip the pipe
 
           # Expect endif
-          if current_token && current_token[:type] == :keyword && current_token[:value] == 'endif'
-            advance # Skip 'endif'
-          else
-            @errors << {
-              message: "Expected 'endif' after '|' in one-line if statement",
-              position: @position,
-              line: current_token ? current_token[:line] : 0,
-              column: current_token ? current_token[:column] : 0
-            }
+          unless expect_keyword('endif')
+            add_error("Expected 'endif' after '|' in one-line if statement")
           end
         end
       else
-        # This is a regular multi-line if statement
-        # Continue with your existing logic for parsing normal if statements
-
-        # Parse statements until we hit 'else', 'elseif', or 'endif'
-        while @position < @tokens.length
-          # Check for the tokens that would terminate this block
-          if current_token && current_token[:type] == :keyword &&
-             ['else', 'elseif', 'endif'].include?(current_token[:value])
-            break
-          end
-
-          stmt = parse_statement
-          then_branch << stmt if stmt
-        end
+        # Parse multi-line if statement
+        # Parse statements until 'else', 'elseif', or 'endif'
+        then_branch = parse_body_until('else', 'elseif', 'endif')
 
         # Check for else/elseif
         if current_token && current_token[:type] == :keyword
@@ -1005,14 +1168,7 @@ module Vinter
             advance # Skip 'else'
 
             # Parse statements until 'endif'
-            while @position < @tokens.length
-              if current_token[:type] == :keyword && current_token[:value] == 'endif'
-                break
-              end
-
-              stmt = parse_statement
-              else_branch << stmt if stmt
-            end
+            else_branch = parse_body_until('endif')
           elsif current_token[:value] == 'elseif'
             elseif_stmt = parse_if_statement
             else_branch << elseif_stmt if elseif_stmt
@@ -1028,228 +1184,63 @@ module Vinter
           end
         end
 
-        # Expect endif
-        if current_token && current_token[:type] == :keyword && current_token[:value] == 'endif'
-          advance # Skip 'endif'
-        else
-          # Don't add an error if we've already reached the end of the file
-          if @position < @tokens.length
-            @errors << {
-              message: "Expected 'endif' to close if statement",
-              position: @position,
-              line: current_token ? current_token[:line] : 0,
-              column: current_token ? current_token[:column] : 0
-            }
-          end
-        end
-      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_while_statement
-      token = advance # Skip 'while'
-      line = token[:line]
-      column = token[:column]
-      condition = parse_expression
-
-      body = []
-
-      # Parse statements until we hit 'endwhile'
-      while @position < @tokens.length
-        if current_token[:type] == :keyword && current_token[:value] == 'endwhile'
-          break
-        end
-
-        stmt = parse_statement
-        body << stmt if stmt
-      end
-
-      # Expect endwhile
-      expect(:keyword) # This should be '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]
-
-      # Two main patterns:
-      # 1. for [key, val] in dict - destructuring with bracket_open
-      # 2. for var in list - simple variable with identifier
-
-      if current_token && current_token[:type] == :bracket_open
-        # Handle destructuring assignment: for [key, val] in dict
-        advance # Skip '['
-
-        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
-            @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
-
-          if current_token && current_token[:type] == :comma
-            advance # Skip ','
-          else
-            break
-          end
-        end
-
-        expect(:bracket_close) # Skip ']'
-
-        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
-
-        iterable = parse_expression
-
-        # Parse the body until 'endfor'
-        body = []
-        while @position < @tokens.length
-          if current_token && current_token[:type] == :keyword && current_token[:value] == 'endfor'
-            break
-          end
-
-          stmt = parse_statement
-          body << stmt if stmt
-        end
-
-        # Expect endfor
-        if current_token && current_token[:type] == :keyword && current_token[:value] == 'endfor'
-          advance # Skip 'endfor'
-        else
-          # Only add an error if we haven't reached the end of the file
-          if @position < @tokens.length
-            @errors << {
-              message: "Expected 'endfor' to close for statement",
-              position: @position,
-              line: current_token ? current_token[:line] : 0,
-              column: current_token ? current_token[:column] : 0
-            }
-          end
-        end
-
-        return {
-          type: :for_statement,
-          loop_vars: loop_vars,
-          iterable: iterable,
-          body: body,
-          line: line,
-          column: column
-        }
-      elsif current_token && current_token[:type] == :paren_open
-        # Handle multiple variables in parentheses: for (var1, var2) in list
-        advance # Skip '('
-
-        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
-            @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
-
-          if current_token && current_token[:type] == :comma
-            advance # Skip ','
-          else
-            break
-          end
-        end
-
-        expect(:paren_close) # Skip ')'
+        # Expect endif
+        expect_end_keyword('endif')
+      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
+      {
+        type: :if_statement,
+        condition: condition,
+        then_branch: then_branch,
+        else_branch: else_branch,
+        one_line: one_line_if,
+        line: line,
+        column: column
+      }
+    end
 
-        iterable = parse_expression
+    def parse_while_statement
+      token = advance # Skip 'while'
+      line = token[:line]
+      column = token[:column]
+      condition = parse_expression
 
-        # Parse the body until 'endfor'
-        body = []
-        while @position < @tokens.length
-          if current_token && current_token[:type] == :keyword && current_token[:value] == 'endfor'
-            break
-          end
+      # Parse statements until 'endwhile'
+      body = parse_body_until('endwhile')
 
-          stmt = parse_statement
-          body << stmt if stmt
-        end
+      # Expect endwhile
+      expect_end_keyword('endwhile')
 
-        # Expect endfor
-        if current_token && current_token[:type] == :keyword && current_token[:value] == 'endfor'
-          advance # Skip 'endfor'
-        else
-          # Only add an error if we haven't reached the end of the file
-          if @position < @tokens.length
-            @errors << {
-              message: "Expected 'endfor' to close for statement",
-              position: @position,
-              line: current_token ? current_token[:line] : 0,
-              column: current_token ? current_token[:column] : 0
-            }
-          end
-        end
+      {
+        type: :while_statement,
+        condition: condition,
+        body: body,
+        line: line,
+        column: column
+      }
+    end
 
-        return {
-          type: :for_statement,
-          loop_vars: loop_vars,
-          iterable: iterable,
-          body: body,
-          line: line,
-          column: column
-        }
+    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 ||
@@ -1258,63 +1249,36 @@ module Vinter
                             current_token[:type] == :script_local)
           loop_var = advance
         else
-          @errors << {
-            message: "Expected identifier as for loop variable",
-            position: @position,
-            line: current_token ? current_token[:line] : 0,
-            column: current_token ? current_token[:column] : 0
-          }
-          loop_var = nil
-        end
-
-        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'
+          add_error("Expected identifier as for loop variable")
         end
+        expect_in_keyword
+      end
 
-        iterable = parse_expression
+      # Parse the iterable expression
+      iterable = parse_expression
 
-        # Parse the body until 'endfor'
-        body = []
-        while @position < @tokens.length
-          if current_token && current_token[:type] == :keyword && current_token[:value] == 'endfor'
-            break
-          end
+      # Parse the body until 'endfor'
+      body = parse_body_until('endfor')
 
-          stmt = parse_statement
-          body << stmt if stmt
-        end
+      # Expect endfor
+      expect_end_keyword('endfor')
 
-        # Expect endfor
-        if current_token && current_token[:type] == :keyword && current_token[:value] == 'endfor'
-          advance # Skip 'endfor'
-        else
-          # Only add an error if we haven't reached the end of the file
-          if @position < @tokens.length
-            @errors << {
-              message: "Expected 'endfor' to close for statement",
-              position: @position,
-              line: current_token ? current_token[:line] : 0,
-              column: current_token ? current_token[:column] : 0
-            }
-          end
-        end
+      # Build result hash based on whether we have single or multiple vars
+      result = {
+        type: :for_statement,
+        iterable: iterable,
+        body: body,
+        line: line,
+        column: column
+      }
 
-        return {
-          type: :for_statement,
-          loop_var: loop_var,
-          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
@@ -1331,24 +1295,16 @@ module Vinter
 
       # Parse optional return type
       return_type = nil
-      if current_token && current_token[:type] == :colon
+      if current_token && current_token[:type] == :colon && current_token[:line] == line
         advance # Skip ':'
         return_type = parse_type
       end
 
-      # Parse function body
-      body = []
-      while @position < @tokens.length
-        if current_token[:type] == :keyword && current_token[:value] == 'enddef'
-          break
-        end
-
-        stmt = parse_statement
-        body << stmt if stmt
-      end
+      # 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,
@@ -1391,28 +1347,12 @@ 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
         end
 
-        # Get parameter name
-        if !current_token || current_token[:type] != :identifier
-          @errors << {
-            message: "Expected parameter name",
-            position: @position,
-            line: current_token ? current_token[:line] : 0,
-            column: current_token ? current_token[:column] : 0
-          }
-          break
-        end
-
         param_name = advance
 
         # Check for type annotation
@@ -1444,12 +1384,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
@@ -1478,12 +1413,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
@@ -1496,12 +1426,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
 
@@ -1517,7 +1442,7 @@ module Vinter
 
       # Parse initializer if present
       initializer = nil
-      if current_token && current_token[:type] == :operator && current_token[:value] == '='
+      if current_token && (current_token[:type] == :operator && current_token[:value] == '=')
         advance # Skip '='
         initializer = parse_expression
       end
@@ -1810,7 +1735,7 @@ module Vinter
         # 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)
+            parse_builtin_function_call
           else
             # Treat map commands as identifiers when inside expressions
             advance
@@ -1823,7 +1748,7 @@ module Vinter
           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)
+          return parse_builtin_function_call
         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
@@ -1909,6 +1834,8 @@ module Vinter
             line: line,
             column: column
           }
+        elsif token[:value] == 'command'
+          advance
         else
           @errors << {
             message: "Unexpected keyword in expression: #{token[:value]}",
@@ -2036,7 +1963,7 @@ module Vinter
       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)
+          expr = parse_builtin_function_call
         else
           advance
 
@@ -2064,6 +1991,18 @@ module Vinter
             end
           end
         end
+      when :vimfuncs
+        advance
+        if current_token[:type] == :paren_open
+          expr = parse_function_call(token[:value], line, column)
+        else
+          expr = {
+            type: :vimfuncs,
+            name: token[:value],
+            line: line,
+            column: column
+          }
+        end
       when :namespace_prefix
         advance
         expr = {
@@ -2099,6 +2038,13 @@ module Vinter
       when :line_continuation
         advance
         expr = parse_expression
+      when :interpolated_string
+        token = advance
+        value = token[:value]
+        expr = {
+          type: :interpolated_string,
+          value: token[:value],
+        }
       else
         @errors << {
           message: "Unexpected token in expression: #{token[:type]}",
@@ -2117,7 +2063,7 @@ module Vinter
           # 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 ||
@@ -2155,6 +2101,7 @@ module Vinter
         # Check for method call with arrow ->
         elsif current_token[:type] == :operator && current_token[:value] == '->'
           arrow_token = advance # Skip '->'
+          advance if current_token[:type] == :line_continuation
 
           # Next token should be an identifier (method name)
           if !current_token || current_token[:type] != :identifier
@@ -2219,6 +2166,12 @@ module Vinter
             else
               end_index = parse_expression
             end
+          # handles array assignment [a,b] = split(thing)
+          elsif current_token[:type] == :comma
+            while current_token[:type] == :comma
+              advance
+              parse_expression
+            end
           end
 
           expect(:bracket_close) # Skip ']'
@@ -2281,76 +2234,19 @@ 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
+    def parse_builtin_function_call
+      token = advance # Consume the `builtin_funcs` token
+      line = token[:line]
+      column = token[:column]
+      name = token[:value]
 
-        # 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]
+      # Collect arguments (if any) until the end of the line
+      args = []
+      while current_token && current_token[:type] != :comment && current_token[:value] != "\n"
+        args << current_token[:value]
+        advance
       end
 
-      # Return function call node
       {
         type: :builtin_function_call,
         name: name,
@@ -2754,7 +2650,7 @@ module Vinter
                                  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
@@ -2909,42 +2805,30 @@ module Vinter
 
       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
+        # Skip line continuations
+        if current_token[:type] == :line_continuation
           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
+        # Parse the argument
+        arg = parse_expression
+        args << arg if arg
+
+        # Break if we hit the closing parenthesis
         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
+        elsif current_token[:type] == :line_continuation
+          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
+        elsif current_token && current_token[:type] != :paren_close
           @errors << {
             message: "Expected comma or closing parenthesis after argument",
             position: @position,
@@ -3086,6 +2970,13 @@ module Vinter
         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]
@@ -3188,7 +3079,7 @@ module Vinter
           advance # Skip the '='
 
           # Get the value (number or identifier)
-          if current_token && (current_token[:type] == :number || current_token[:type] == :identifier)
+          if current_token && (current_token[:type] == :number || current_token[:type] == :identifier) || current_token[:type] == :operator
             attribute += "=#{current_token[:value]}"
             attributes << attribute
             advance
@@ -3198,6 +3089,7 @@ module Vinter
 
       # Parse the command name
       command_name = nil
+      advance if current_token[:type] == :line_continuation
       if current_token && current_token[:type] == :identifier
         command_name = current_token[:value]
         advance
@@ -3296,33 +3188,11 @@ module Vinter
         end
       end
 
-      # Parse function body
-      body = []
-      while @position < @tokens.length
-        if current_token && current_token[:type] == :keyword &&
-           ['endfunction', 'endfunc'].include?(current_token[:value])
-          break
-        end
-
-        stmt = parse_statement
-        body << stmt if stmt
-      end
+      # Parse function body until 'endfunction' or 'endfunc'
+      body = parse_body_until('endfunction', 'endfunc')
 
       # Expect endfunction/endfunc
-      if current_token && current_token[:type] == :keyword && 
-         ['endfunction', 'endfunc'].include?(current_token[:value])
-        advance # Skip 'endfunction' or 'endfunc'
-      else
-        # Only add an error if we haven't reached the end of the file
-        if @position < @tokens.length
-          @errors << {
-            message: "Expected 'endfunction' or 'endfunc'",
-            position: @position,
-            line: current_token ? current_token[:line] : 0,
-            column: current_token ? current_token[:column] : 0
-          }
-        end
-      end
+      expect_end_keyword('endfunction', 'endfunc')
 
       function_name = name ? name[:value] : nil
       if function_scope
@@ -3508,22 +3378,12 @@ module Vinter
       line = token[:line]
       column = token[:column]
 
-      # Parse the try body
-      body = []
+      # Parse the try body until catch/finally/endtry
+      body = parse_body_until('catch', 'finally', 'endtry')
+
       catch_clauses = []
       finally_clause = nil
 
-      # Parse statements in the try block
-      while @position < @tokens.length
-        if current_token && current_token[:type] == :keyword &&
-           ['catch', 'finally', 'endtry'].include?(current_token[:value])
-          break
-        end
-
-        stmt = parse_statement
-        body << stmt if stmt
-      end
-
       # Parse catch clauses
       while @position < @tokens.length &&
             current_token && current_token[:type] == :keyword &&
@@ -3549,17 +3409,8 @@ module Vinter
           advance
         end
 
-        # Parse the catch body
-        catch_body = []
-        while @position < @tokens.length
-          if current_token && current_token[:type] == :keyword &&
-             ['catch', 'finally', 'endtry'].include?(current_token[:value])
-            break
-          end
-
-          stmt = parse_statement
-          catch_body << stmt if stmt
-        end
+        # Parse the catch body until next catch/finally/endtry
+        catch_body = parse_body_until('catch', 'finally', 'endtry')
 
         catch_clauses << {
           type: :catch_clause,
@@ -3578,16 +3429,8 @@ module Vinter
         finally_line = finally_token[:line]
         finally_column = finally_token[:column]
 
-        # Parse the finally body
-        finally_body = []
-        while @position < @tokens.length
-          if current_token && current_token[:type] == :keyword && current_token[:value] == 'endtry'
-            break
-          end
-
-          stmt = parse_statement
-          finally_body << stmt if stmt
-        end
+        # Parse the finally body until 'endtry'
+        finally_body = parse_body_until('endtry')
 
         finally_clause = {
           type: :finally_clause,
@@ -3598,19 +3441,7 @@ module Vinter
       end
 
       # Expect endtry
-      if current_token && current_token[:type] == :keyword && current_token[:value] == 'endtry'
-        advance # Skip 'endtry'
-      else
-        # Only add an error if we haven't reached the end of the file
-        if @position < @tokens.length
-          @errors << {
-            message: "Expected 'endtry' to close try statement",
-            position: @position,
-            line: current_token ? current_token[:line] : 0,
-            column: current_token ? current_token[:column] : 0
-          }
-        end
-      end
+      expect_end_keyword('endtry')
 
       return {
         type: :try_statement,
@@ -3881,14 +3712,14 @@ module Vinter
     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 || 
+
+      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(''),
@@ -3900,7 +3731,7 @@ module Vinter
     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]
@@ -3908,7 +3739,7 @@ module Vinter
       else
         return parse_expression  # Fall back to regular expression parsing
       end
-      
+
       # Parse additional comma-separated values
       while current_token && current_token[:type] == :comma
         advance # Skip comma
@@ -3919,7 +3750,7 @@ module Vinter
           break
         end
       end
-      
+
       return {
         type: :comma_separated_value,
         values: values,
@@ -3971,7 +3802,7 @@ module Vinter
       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., {{{,}}})
@@ -4098,8 +3929,8 @@ module Vinter
             advance
 
             # Parse attribute value (can be identifier, number, or hex color)
-            if current_token && (current_token[:type] == :identifier || 
-                                current_token[:type] == :number || 
+            if current_token && (current_token[:type] == :identifier ||
+                                current_token[:type] == :number ||
                                 current_token[:type] == :hex_color)
               attributes[attr_name] = current_token[:value]
               advance