vinter 0.6.4 → 0.6.5

data/lib/vinter/parser.rb

@@ -1,3 +1,4 @@
+require 'pry'
 module Vinter
   class Parser
     def initialize(tokens, source_text = nil)
@@ -383,6 +384,12 @@ module Vinter
           parse_sleep_command
         when 'source'
           parse_source_command
+        when 'elseif'
+          advance
+        when 'else'
+          advance
+        when 'class'
+          parse_class_definition
         else
           @warnings << {
             message: "Unexpected keyword: #{current_token[:value]}",
@@ -409,14 +416,8 @@ module Vinter
         end
       elsif current_token[:type] == :comment
         parse_comment
-      elsif current_token[:type] == :string && current_token[:value].start_with?('"')
-        parse_comment
-        # token = current_token
-        # line = token[:line]
-        # column = token[:column]
-        # value = token[:value]
-        # advance
-        # { type: :comment, value: value, line: line, column: column }
+      #elsif current_token[:type] == :string && current_token[:value].start_with?('"')
+        #parse_comment
       elsif current_token[:type] == :silent_bang
         parse_silent_command
       elsif current_token[:type] == :identifier && current_token[:value] == 'delete'
@@ -441,6 +442,26 @@ module Vinter
         advance
       elsif current_token[:type] == :colon
         parse_command_line_call
+      elsif current_token[:type] == :number
+        advance
+      elsif current_token[:type] == :paren_close
+        advance
+      elsif current_token[:type] == :brace_close
+        advance
+      elsif current_token[:type] == :interpolated_string
+        advance
+      elsif current_token[:type] == :heredoc
+        # TODO: parse_herdoc
+        advance # move past =<<
+        while ["trim", "eval"].include?(current_token[:value])
+          advance
+        end
+        stop_token = advance
+        while current_token && current_token[:value] != stop_token
+          advance
+        end
+      elsif [:bracket_open, :bracket_close, :operator, :question_mark].include?(current_token[:type])
+        advance
       else
         @warnings << {
           message: "Unexpected token type: #{current_token[:type]}",
@@ -566,6 +587,12 @@ module Vinter
       name = token[:value]
       advance # Skip the global variable token
 
+      # handle vars that include #
+      while current_token && (current_token[:type] == :comment || current_token[:type] == :identifier)
+        name += current_token[:value]
+        advance
+      end
+
       # Handle property access (e.g., g:foo.bar)
       target = {
         type: :global_variable,
@@ -575,7 +602,7 @@ module Vinter
       }
 
       # Property access (dot notation)
-      if current_token && current_token[:type] == :operator && current_token[:value] == '.'
+      while 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
@@ -613,7 +640,7 @@ module Vinter
         operator = current_token[:value]
         advance
       else
-        add_error("Expected assignment operator after global variable")
+        add_error("Expected assignment operator after global variable: #{current_token[:type]}")
       end
 
       # Value expression
@@ -787,7 +814,6 @@ module Vinter
     end
 
     def parse_let_statement
-      # binding.pry
       token = advance # Skip 'let'
       line = token[:line]
       column = token[:column]
@@ -1245,7 +1271,8 @@ module Vinter
         if current_token && (current_token[:type] == :identifier ||
                             current_token[:type] == :local_variable ||
                             current_token[:type] == :global_variable ||
-                            current_token[:type] == :script_local)
+                            current_token[:type] == :script_local ||
+                            current_token[:type] == :builtin_funcs)
           loop_var = advance
         else
           add_error("Expected identifier as for loop variable")
@@ -1285,12 +1312,18 @@ module Vinter
       line = token[:line]
       column = token[:column]
 
-      name = expect(:identifier)
+      if current_token && current_token[:value] == "!"
+        advance
+      end
+
+      if current_token && [:identifier, :global_variable].include?(current_token[:type])
+        name = advance
+      end
+      #name = expect(:identifier)
 
       # Parse parameter list
       expect(:paren_open)
       params = parse_parameter_list
-      expect(:paren_close)
 
       # Parse optional return type
       return_type = nil
@@ -1298,12 +1331,12 @@ module Vinter
         advance # Skip ':'
         return_type = parse_type
       end
-
-      # Parse function body until 'enddef'
-      body = parse_body_until('enddef')
-
-      # Expect enddef
-      expect_end_keyword('enddef')
+      body = []
+      while current_token && current_token[:value] != 'enddef'
+        stmt = parse_statement
+        body << stmt if stmt
+      end
+      advance
 
       {
         type: :def_function,
@@ -1321,78 +1354,89 @@ module Vinter
 
       # Empty parameter list
       if current_token && current_token[:type] == :paren_close
+        advance
         return params
       end
-
-      # Parse parameters until we find a closing parenthesis
-      while @position < @tokens.length && current_token && current_token[:type] != :paren_close
-        # Check for variable args
-        if current_token && current_token[:type] == :ellipsis
-          ellipsis_token = advance
-
-          # Parse type for variable args if present
-          param_type = nil
-          if current_token && current_token[:type] == :colon
-            advance # Skip ':'
-            param_type = parse_type
-          end
-
-          params << {
-            type: :var_args,
-            param_type: param_type,
-            line: ellipsis_token[:line],
-            column: ellipsis_token[:column]
-          }
-
-          # After varargs, we expect closing paren
-          if current_token && current_token[:type] != :paren_close
-            add_error("Expected closing parenthesis after varargs", current_token)
-          end
-
-          break
-        end
-
-        param_name = advance
-
-        # Check for type annotation
-        param_type = nil
-        if current_token && current_token[:type] == :colon
-          advance # Skip ':'
-          param_type = parse_type
-        end
-
-        # Check for default value
-        default_value = nil
-        if current_token && current_token[:type] == :operator && current_token[:value] == '='
-          advance # Skip '='
-          default_value = parse_expression
-        end
-
-        params << {
-          type: :parameter,
-          name: param_name[:value],
-          param_type: param_type,
-          optional: default_value != nil,
-          default_value: default_value,
-          line: param_name[:line],
-          column: param_name[:column]
-        }
-
-        # If we have a comma, advance past it and continue
-        if current_token && current_token[:type] == :comma
-          advance
-        # If we don't have a comma, we should have a closing paren
-        elsif current_token && current_token[:type] != :paren_close
-          add_error("Expected comma or closing parenthesis after parameter", current_token)
-          break
+      # TODO actually save params
+      required_parens = 1
+      while current_token && required_parens > 0
+        if current_token[:type] == :paren_open
+          required_parens += 1
+        elsif current_token[:type] == :paren_close
+          required_parens -= 1
         end
+        advance
       end
 
+      # Parse parameters until we find a closing parenthesis
+      #while @position < @tokens.length && current_token && current_token[:type] != :paren_close
+        ## Check for variable args
+        #if current_token && current_token[:type] == :ellipsis
+          #ellipsis_token = advance
+
+          ## Parse type for variable args if present
+          #param_type = nil
+          #if current_token && current_token[:type] == :colon
+            #advance # Skip ':'
+            #param_type = parse_type
+          #end
+
+          #params << {
+            #type: :var_args,
+            #param_type: param_type,
+            #line: ellipsis_token[:line],
+            #column: ellipsis_token[:column]
+          #}
+
+          ## After varargs, we expect closing paren
+          #if current_token && current_token[:type] != :paren_close
+            #add_error("Expected closing parenthesis after varargs", current_token)
+          #end
+
+          #break
+        #end
+
+        #param_name = advance
+
+        ## Check for type annotation
+        #param_type = nil
+        #if current_token && current_token[:type] == :colon
+          #advance # Skip ':'
+          #param_type = parse_type
+        #end
+
+        ## Check for default value
+        #default_value = nil
+        #if current_token && current_token[:type] == :operator && current_token[:value] == '='
+          #advance # Skip '='
+          #default_value = parse_expression
+        #end
+
+        #params << {
+          #type: :parameter,
+          #name: param_name[:value],
+          #param_type: param_type,
+          #optional: default_value != nil,
+          #default_value: default_value,
+          #line: param_name[:line],
+          #column: param_name[:column]
+        #}
+
+        ## If we have a comma, advance past it and continue
+        #if current_token && current_token[:type] == :comma
+          #advance
+        ## If we don't have a comma, we should have a closing paren
+        #elsif current_token && current_token[:type] != :paren_close
+          #add_error("Expected comma or closing parenthesis after parameter", current_token)
+          #break
+        #end
+      #end
+
       params
     end
 
     def parse_type
-      if current_token && [:identifier, :keyword].include?(current_token[:type])
+      if current_token && [:identifier, :keyword, :type].include?(current_token[:type])
         type_name = advance
 
         # Handle generic types like list<string>
@@ -1412,7 +1456,7 @@ module Vinter
 
         return type_name[:value]
       else
-        add_error("Expected type identifier")
+        add_error("Expected type identifier: #{current_token[:value]}, #{current_token[:type]}")
         advance
         return "unknown"
       end
@@ -1424,14 +1468,22 @@ module Vinter
       line = var_type_token[:line]
       column = var_type_token[:column]
 
-      if !current_token || current_token[:type] != :identifier
-        add_error("Expected variable name")
+      # TODO: also handle the variable declration with [a,b]
+      if current_token[:type] == :bracket_open
+        advance
+        name = "[#{current_token[:value]}"
+        while current_token && current_token[:type] != :bracket_close
+          advance
+          name += current_token[:value]
+        end
+      elsif !current_token || ![:identifier, :keyword].include?(current_token[:type])
+        add_error("Expected variable name: #{current_token[:type]}")
         return nil
+      else
+        name_token = advance
+        name = name_token[:value]
       end
 
-      name_token = advance
-      name = name_token[:value]
-
       # Parse optional type annotation
       var_type_annotation = nil
       if current_token && current_token[:type] == :colon
@@ -1443,7 +1495,10 @@ module Vinter
       initializer = nil
       if current_token && (current_token[:type] == :operator && current_token[:value] == '=')
         advance # Skip '='
-        initializer = parse_expression
+        assignment_line = current_token[:line]
+        while current_token[:line] == assignment_line
+          advance
+        end
       end
 
       {
@@ -1524,14 +1579,13 @@ module Vinter
     end
 
     def parse_expression
-      # binding.pry
       # Special case for empty return statements or standalone keywords that shouldn't be expressions
       if current_token && current_token[:type] == :keyword &&
          ['return', 'endif', 'endwhile', 'endfor', 'endfunction', 'endfunc'].include?(current_token[:value])
         return nil
       end
 
-      if current_token[:type] == :string
+      if current_token && current_token[:type] == :string
         string_value = current_token[:value]
         while current_token && peek_token && [:line_continuation, :identifier].include?(peek_token[:type])
           # Handle strings with line continuation
@@ -1557,36 +1611,14 @@ module Vinter
       expr = parse_binary_expression
 
       # Check if this is a ternary expression
-      if current_token && (current_token[:type] == :question_mark || (current_token[:type] == :operator && current_token[:value] == '?'))
+      if current_token && (current_token[:type] == :question_mark && peek_token[:type] != :question_mark || (current_token[:type] == :operator && current_token[:value] == '?'))
         question_token = advance # Skip '?'
-
-        # Parse the "then" expression
-        then_expr = parse_expression
-
-        # Expect the colon
-        if current_token && current_token[:type] == :colon
-          colon_token = advance # Skip ':'
-
-          # Parse the "else" expression
-          else_expr = parse_expression
-
-          # Return the ternary expression
-          return {
-            type: :ternary_expression,
-            condition: expr,
-            then_expr: then_expr,
-            else_expr: else_expr,
-            line: question_token[:line],
-            column: question_token[:column]
-          }
-        else
-          @errors << {
-            message: "Expected ':' in ternary expression",
-            position: @position,
-            line: current_token ? current_token[:line] : 0,
-            column: current_token ? current_token[:column] : 0
-          }
+        while current_token[:value] != ':'
+          advance
         end
+        advance # skip :
+
+        parse_expression
       end
 
       return expr
@@ -1793,9 +1825,18 @@ module Vinter
                 line: line,
                 column: column
               }
+            elsif current_token && current_token[:type] == :option_variable
+              option_var = advance
+              expect(:paren_close)
+              return {
+                type: :function_reference,
+                function_body: option_var[:value],
+                line: line,
+                column: column
+              }
             else
               @errors << {
-                message: "Expected string or arrow function definition in function() call",
+                message: "Expected string or arrow function definition in function() call: #{current_token}",
                 position: @position,
                 line: current_token ? current_token[:line] : 0,
                 column: current_token ? current_token[:column] : 0
@@ -1812,29 +1853,12 @@ module Vinter
               column: column
             }
           end
-        # Legacy Vim allows certain keywords as identifiers in expressions
-        elsif ['return', 'type'].include?(token[:value])
-          # Handle 'return' keyword specially when it appears in an expression context
-          advance
-          @warnings << {
-            message: "Keyword '#{token[:value]}' used in an expression context",
-            position: @position,
-            line: line,
-            column: column
-          }
-          # Check if this is a function call for 'type'
-          if token[:value] == 'type' && current_token && current_token[:type] == :paren_open
-            return parse_function_call(token[:value], line, column)
-          end
-
-          expr = {
-            type: :identifier,
-            name: token[:value],
-            line: line,
-            column: column
-          }
         elsif token[:value] == 'command'
           advance
+        elsif token[:value] == 'return'
+          advance
+        elsif token[:value] == 'elseif'
+          advance
         else
           @errors << {
             message: "Unexpected keyword in expression: #{token[:value]}",
@@ -2015,8 +2039,18 @@ module Vinter
           return parse_lambda_expression(line, column)
         else
           advance  # Skip '('
-          expr = parse_expression
-          expect(:paren_close)  # Expect and skip ')'
+          required_parens = 1
+          while current_token && required_parens > 0
+            if current_token[:type] == :paren_open
+              required_parens += 1
+            elsif current_token[:type] == :paren_close
+              required_parens -= 1
+            end
+            advance
+          end
+          #expr = parse_expression
+          #binding.pry
+          #expect(:paren_close)  # Expect and skip ')'
         end
       when :bracket_open
         expr = parse_list_literal(line, column)
@@ -2044,9 +2078,23 @@ module Vinter
           type: :interpolated_string,
           value: token[:value],
         }
+      when :builtin_funcs
+        expr = parse_builtin_function_call
+      when :type
+        advance
+      when :colon
+        advance
+      when :operator
+        advance
+      when :silent_bang
+        advance
+      when :question_mark
+        advance
+      when :comment, :compound_operator, :bracket_close
+        advance
       else
         @errors << {
-          message: "Unexpected token in expression: #{token[:type]}",
+          message: "Unexpected token in expression: #{token[:type]} | #{token[:value]}",
           position: @position,
           line: line,
           column: column
@@ -2103,7 +2151,9 @@ module Vinter
           advance if current_token[:type] == :line_continuation
 
           # Next token should be an identifier (method name)
-          if !current_token || current_token[:type] != :identifier
+          if current_token && current_token[:type] == :builtin_funcs
+            parse_builtin_function_call
+          elsif !current_token || current_token[:type] != :identifier
             @errors << {
               message: "Expected method name after '->'",
               position: @position,
@@ -2118,23 +2168,15 @@ module Vinter
           # Check for arguments
           args = []
           if current_token && current_token[:type] == :paren_open
-            expect(:paren_open) # Skip '('
-
-            # Parse arguments if any
-            unless current_token && current_token[:type] == :paren_close
-              loop do
-                arg = parse_expression
-                args << arg if arg
-
-                if current_token && current_token[:type] == :comma
-                  advance # Skip comma
-                else
-                  break
-                end
+            paren_count = 1
+            while current_token && paren_count > 0
+              if current_token[:type] == :paren_open
+                paren_count += 1
+              elsif current_token[:type] == :paren_close
+                paren_count -= 1
               end
+              advance
             end
-
-            expect(:paren_close) # Skip ')'
           end
 
           expr = {
@@ -2239,17 +2281,29 @@ module Vinter
       column = token[:column]
       name = token[:value]
 
-      # 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]
+      #expect(:paren_open)
+      required_parens = 1
+      while current_token && required_parens > 0
+        if current_token[:type] == :paren_close
+          required_parens -= 1
+        elsif current_token[:type] == :paren_open
+          required_parens += 1
+        end
         advance
       end
 
+      # Collect arguments (if any) until the end of the line
+      #args = []
+      #while current_token && current_token[:type] != :comment && current_token[:value] != "\n"
+        #puts current_token[:value]
+        #args << current_token[:value]
+        #advance
+      #end
+
       {
         type: :builtin_function_call,
         name: name,
-        arguments: args,
+        #arguments: args,
         line: line,
         column: column
       }
@@ -2563,7 +2617,7 @@ module Vinter
       # Parse dictionary entries
       while current_token && current_token[:type] != :brace_close
         # Skip any backslash line continuation markers and whitespace
-        while current_token && (current_token[:type] == :backslash || current_token[:type] == :whitespace || current_token[:type] == :line_continuation)
+        while current_token && [:backslash, :whitespace, :line_continuation, :comment].include?(current_token[:type])
           advance
         end
 
@@ -2574,12 +2628,12 @@ module Vinter
 
         # Parse key (string or identifier)
         key = nil
-        if current_token && (current_token[:type] == :string || current_token[:type] == :identifier)
+        if current_token && [:string, :identifier, :keyword].include?(current_token[:type])
           key = current_token[:value]
           advance  # Skip key
         else
           @errors << {
-            message: "Expected string or identifier as dictionary key",
+            message: "Expected string or identifier as dictionary key #{current_token}",
             position: @position,
             line: current_token ? current_token[:line] : 0,
             column: current_token ? current_token[:column] : 0
@@ -2639,7 +2693,7 @@ module Vinter
           # Skip any line continuations and whitespace after comma
           while current_token && (current_token[:type] == :whitespace ||
                                  current_token[:type] == :backslash ||
-                                 current_token[:type] == :line_continuation)
+                                 current_token[:type] == :line_continuation || current_token[:type] == :comment)
             advance
           end
         else
@@ -2805,41 +2859,17 @@ module Vinter
       args = []
 
       # Parse arguments until we find a closing parenthesis
-      while @position < @tokens.length && current_token && current_token[:type] != :paren_close
-        # Skip line continuations
-        if current_token[:type] == :line_continuation
-          advance
-          next
-        end
 
-        # 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
-          @errors << {
-            message: "Expected comma or closing parenthesis after argument",
-            position: @position,
-            line: current_token[:line],
-            column: current_token[:column]
-          }
-          break
+      required_parens = 1
+      while current_token && required_parens > 0
+        if current_token[:type] == :paren_open
+          required_parens += 1
+        elsif current_token[:type] == :paren_close
+          required_parens -= 1
         end
+        advance
       end
 
-      expect(:paren_close)
-
       {
         type: :function_call,
         name: name,
@@ -2945,9 +2975,10 @@ module Vinter
 
       # Handle 'as name'
       as_name = nil
-      if current_token && current_token[:type] == :identifier && current_token[:value] == 'as'
+      if current_token && current_token[:value] == 'as'
         advance # Skip 'as'
-        if current_token && current_token[:type] == :identifier
+
+        if current_token && [:identifier, :keyword].include?(current_token[:type])
           as_name = advance[:value]
         else
           @errors << {
@@ -2994,7 +3025,7 @@ module Vinter
 
       exported_item = nil
 
-      if current_token[:type] == :keyword
+      if current_token[:type] == :keyword || current_token[:type] == :identifier
         case current_token[:value]
         when 'def'
           exported_item = parse_def_function
@@ -3003,15 +3034,13 @@ module Vinter
         when 'var', 'const', 'final'
           exported_item = parse_variable_declaration
         when 'class'
-          # Handle class export when implemented
-          @errors << {
-            message: "Class export not implemented yet",
-            position: @position,
-            line: current_token[:line],
-            column: current_token[:column]
-          }
+          exported_item = parse_class_definition
+        when 'interface'
+          exported_item = parse_interface_definition
+        when 'enum'
+          exported_item = parse_enum_definition
+        when 'abstract'
           advance
-          return nil
         else
           @errors << {
             message: "Unexpected keyword after export: #{current_token[:value]}",
@@ -3041,6 +3070,34 @@ module Vinter
       }
     end
 
+    def parse_enum_definition
+      while current_token && current_token[:value] != "endenum"
+        advance
+      end
+      {
+        type: :enum_definition,
+      }
+    end
+
+    def parse_interface_definition
+      while current_token && current_token[:value] != "endinterface"
+        advance
+      end
+      {
+        type: :interface_definition,
+      }
+    end
+
+    def parse_class_definition
+      # TODO: do this properly.. for now we will just look for endclass
+      while current_token && current_token[:value] != "endclass"
+        advance
+      end
+      {
+        type: :class_definition,
+      }
+    end
+
     def parse_command_definition
       token = advance # Skip 'command' or 'command!'
       line = token[:line]