vinter 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6f99b1ca16b7bbca35229a549ceed21f3cdf9b8bc86a3fedff9b978b18717de
-  data.tar.gz: 2aa4e1df5ae4fc08e78c06cf2107c7192099326b073bf45e45a9532b3fb5d0c3
+  metadata.gz: 319f22f198207f7d9d3b9e58c85327b20f7c873e905bc16a38acd6f9199d8b56
+  data.tar.gz: c5eeb2b1dd21094be8a901e570540b89a29619273b0c5fcb11b7edc278da9975
 SHA512:
-  metadata.gz: d739b01780f6ce12654b09b701f343e850bd2eb750e705ca608f793e7e9cfef26b226927157ff595dcbb3f62ddbbd4f530439074ef9fdbc9a2cfd075dd78a3da
-  data.tar.gz: 7ec3181349383a4b9667aab046f56099d25f830a07aaa6a6135b8640a25d59e85c2191b3ffbecd263afe703f1f17a986f40f769e458bab532e70f837f9c9a029
+  metadata.gz: b1556c23fd42b7b7d9d3163a97ecd353902f12341c203a913a4dffec05cbd6ffe867815f223dbfe8f169fd99c514b8b39ac1fab87fd26f195d0622fff9e62966
+  data.tar.gz: 2204f688018212f0b5ec6b13a0906da8a24078fe874dc10c2b9b326668627fb985fdcc11b9682bdbb67f2a452838b8088286260de54bf8941b6501180a7a8704

data/lib/vinter/ast_printer.rb

@@ -0,0 +1,14 @@
+module Vinter
+  module ASTPrinter
+    def self.print(ast, indent=0)
+      spaces = " " * indent * 2
+      ast[:body].each do |node|
+        puts "#{spaces}(#{node[:type]}|#{node[:value]})"
+        if node[:type] == :export_statement
+          puts "(#{node[:export][:type]})"
+          print(node[:export], indent=1)
+        end
+      end
+    end
+  end
+end

data/lib/vinter/cli.rb

@@ -6,7 +6,7 @@ module Vinter
 
     def run(args)
       if args.empty?
-        puts "Usage: vinter [file.vim|directory]"
+        puts "Usage: vinter [file.vim|directory] [--print-ast]"
         return 1
       end
 

data/lib/vinter/lexer.rb

@@ -2,7 +2,9 @@ module Vinter
   class Lexer
     TOKEN_TYPES = {
       # Vim9 specific keywords
-      keyword: /\b(if|else|elseif|endif|while|endwhile|for|endfor|def|enddef|function|endfunction|endfunc|return|const|var|final|import|export|class|extends|static|enum|type|vim9script|abort|autocmd|echom|echoerr|echohl|echomsg|let|unlet|execute|exec|continue|break|try|catch|finally|endtry|throw|runtime|silent|delete|command|call|set|setlocal|syntax|highlight|sleep|source|nnoremap|nmap|inoremap|imap|vnoremap|vmap|xnoremap|xmap|cnoremap|cmap|noremap|map)\b/,
+      keyword: /\b(if|else|elseif|endif|while|endwhile|for|endfor|def|enddef|function|endfunction|endfunc|return|const|var|final|import|export|class|extends|static|enum|type|vim9script|scriptencoding|abort|autocmd|echom|echoerr|echohl|echomsg|let|unlet|execute|exec|continue|break|try|catch|finally|endtry|throw|runtime|silent|delete|command|call|set|setlocal|syntax|highlight|sleep|source|nnoremap|nmap|inoremap|imap|vnoremap|vmap|xnoremap|xmap|cnoremap|cmap|noremap|map|var)\b/,
+      encodings: /\b(latin1|iso|koi8|macroman|cp437|cp737|cp775|cp850|cp852|cp855|cp857|cp860|cp861|cp862|cp863|cp865|cp866|cp869|cp874|cp1250|cp1251|cp1253|cp1254|cp1255|cp1256|cp1257|cp1258|cp932|euc\-jp|sjis|cp949|euc\-kr|cp936|euc\-cn|cp950|big5|euc\-tw|utf\-8|ucs\-2|ucs\-21e|utf\-16|utf\-16le|ucs\-4|ucs\-4le|ansi|japan|korea|prc|chinese|taiwan|utf8|unicode|ucs2be|ucs\-2be|ucs\-4be|utf\-32|utf\-32le|default)\b/,
+      vimfuncs: /\b(win_execute|win_findbuf|win_getid|win_gettype|win_gotoid|win_id2tabwin|win_id2win|win_move_separator|win_move_statusline|win_screenpos|win_splitmove)\b/,
       # Identifiers can include # and special characters
       identifier: /\b[a-zA-Z_][a-zA-Z0-9_#]*\b/,
       # Single-character operators
@@ -26,7 +28,7 @@ module Vinter
       comma: /,/,
       backslash: /\\/,
       question_mark: /\?/,
-      command_separator: /\|/,
+      command_separator: /\|/
     }
 
     CONTINUATION_OPERATORS = %w(. .. + - * / = == ==# ==? != > < >= <= && || ? : -> =>)
@@ -41,21 +43,21 @@ module Vinter
     def should_parse_as_regex
       # Look at recent tokens to determine if we're in a regex context
       recent_tokens = @tokens.last(3)
-      
+
       # Check for contexts where regex is expected
-      return true if recent_tokens.any? { |t| 
-        t && t[:type] == :keyword && ['syntax'].include?(t[:value]) 
+      return true if recent_tokens.any? { |t|
+        t && t[:type] == :keyword && ['syntax'].include?(t[:value])
       }
-      
+
       return true if recent_tokens.any? { |t|
         t && t[:type] == :identifier && ['match', 'region', 'keyword'].include?(t[:value])
       }
-      
+
       # Check for comparison operators that often use regex
       return true if recent_tokens.any? { |t|
         t && t[:type] == :operator && ['=~', '!~', '=~#', '!~#', '=~?', '!~?'].include?(t[:value])
       }
-      
+
       false
     end
 
@@ -85,7 +87,7 @@ module Vinter
           end
           line_start = temp_pos < 0 || @input[temp_pos] == "\n"
         end
-        
+
         # If we're at the start of a line and it begins with a quote
         if line_start && chunk.start_with?('"')
           # Find the end of the line
@@ -103,6 +105,47 @@ module Vinter
           @column += comment_text.length
           next
         end
+
+        # --- Interpolated String Handling ---
+        if chunk.start_with?("$'")
+          i = 2
+          string_value = "$'"
+          brace_depth = 0
+          escaped = false
+
+          while i < chunk.length
+            char = chunk[i]
+            string_value += char
+
+            if char == '\\' && !escaped
+              escaped = true
+            elsif char == "'" && !escaped && brace_depth == 0
+              # End of interpolated string
+              i += 1
+              break
+            elsif char == '{' && !escaped
+              brace_depth += 1
+            elsif char == '}' && !escaped && brace_depth > 0
+              brace_depth -= 1
+            elsif escaped
+              escaped = false
+            end
+
+            i += 1
+          end
+
+          @tokens << {
+            type: :interpolated_string,
+            value: string_value,
+            line: @line_num,
+            column: @column
+          }
+          @column += string_value.length
+          @position += string_value.length
+          @line_num += string_value.count("\n")
+          next
+        end
+
         # Handle string literals manually
         if chunk.start_with?("'") || chunk.start_with?('"')
           quote = chunk[0]
@@ -118,7 +161,7 @@ module Vinter
             if char == '\\' && !escaped
               escaped = true
             elsif (char == "\n" or char == quote) && !escaped
-              # Found closing quote
+              i += 1
               break
             elsif escaped
               escaped = false
@@ -186,7 +229,7 @@ module Vinter
         end
 
         # Check for keywords first, before other token types
-        if match = chunk.match(/\A\b(if|else|elseif|endif|while|endwhile|for|endfor|def|enddef|function|endfunction|endfunc|return|const|var|final|import|export|class|extends|static|enum|type|vim9script|abort|autocmd|echoerr|echohl|echomsg|let|unlet|execute|setlocal|syntax|highlight|sleep|source)\b/)
+        if match = chunk.match(/\A\b(if|else|elseif|endif|while|endwhile|for|endfor|def|enddef|function|endfunction|endfunc|return|const|var|final|import|export|class|extends|static|enum|type|vim9script|abort|autocmd|echoerr|echohl|echomsg|let|unlet|var|execute|setlocal|syntax|highlight|sleep|source)\b/)
           @tokens << {
             type: :keyword,
             value: match[0],
@@ -210,7 +253,7 @@ module Vinter
           @position += match[0].length
           next
         end
-        
+
         # Handle Vim option variables with & prefix
         if match = chunk.match(/\A&[a-zA-Z_][a-zA-Z0-9_]*/)
           @tokens << {
@@ -385,21 +428,21 @@ module Vinter
         if chunk.start_with?('/') && should_parse_as_regex
           i = 1
           regex_value = '/'
-          
+
           # Keep going until we find the closing slash
           while i < chunk.length
             char = chunk[i]
             regex_value += char
-            
+
             if char == '/' && (i == 1 || chunk[i-1] != '\\')
               # Found closing slash
               i += 1
               break
             end
-            
+
             i += 1
           end
-          
+
           # Add the regex token if we found a closing slash
           if regex_value.end_with?('/')
             @tokens << {

data/lib/vinter/parser.rb

@@ -71,6 +71,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 = []
 
@@ -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'
@@ -333,6 +424,24 @@ module Vinter
         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]}",
@@ -427,80 +536,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 +549,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 +569,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 +647,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 +707,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 +724,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 +736,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 +756,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
@@ -972,32 +975,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 +990,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
@@ -1029,19 +1007,7 @@ module Vinter
         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
+        expect_end_keyword('endif')
       end
 
       {
@@ -1061,20 +1027,11 @@ module Vinter
       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
+      # Parse statements until 'endwhile'
+      body = parse_body_until('endwhile')
 
       # Expect endwhile
-      expect(:keyword) # This should be 'endwhile'
+      expect_end_keyword('endwhile')
 
       {
         type: :while_statement,
@@ -1090,166 +1047,22 @@ module Vinter
       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
+      # 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 assignment: for [key, val] in dict
+        # Handle destructuring with brackets: 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
-        }
+        loop_vars = parse_loop_variables
+        expect(:bracket_close)
+        expect_in_keyword
       elsif current_token && current_token[:type] == :paren_open
-        # Handle multiple variables in parentheses: for (var1, var2) in list
+        # Handle multiple variables with 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 ')'
-
-        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
-        }
+        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 +1071,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
@@ -1336,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,
@@ -1391,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
@@ -1404,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
 
@@ -1444,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
@@ -1478,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
@@ -1496,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
 
@@ -2064,6 +1817,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 +1864,12 @@ module Vinter
       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]}",
@@ -2117,7 +1888,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 ||
@@ -2754,7 +2525,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
@@ -3086,6 +2857,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]
@@ -3296,33 +3074,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 +3264,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 +3295,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 +3315,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 +3327,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 +3598,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 +3617,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 +3625,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 +3636,7 @@ module Vinter
           break
         end
       end
-      
+
       return {
         type: :comma_separated_value,
         values: values,
@@ -3971,7 +3688,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 +3815,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

data/lib/vinter.rb

@@ -2,7 +2,8 @@ require "vinter/lexer"
 require "vinter/parser"
 require "vinter/linter"
 require "vinter/cli"
+require "vinter/ast_printer"
 
 module Vinter
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vinter
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Dan Bradbury
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-16 00:00:00.000000000 Z
+date: 2025-11-26 00:00:00.000000000 Z
 dependencies: []
 description: A linter for the Vim9 script language, helping to identify issues and
   enforce best practices
@@ -22,6 +22,7 @@ files:
 - README.md
 - bin/vinter
 - lib/vinter.rb
+- lib/vinter/ast_printer.rb
 - lib/vinter/cli.rb
 - lib/vinter/lexer.rb
 - lib/vinter/linter.rb