vinter 0.2.0 → 0.3.0

data/lib/vinter/parser.rb

@@ -93,6 +93,14 @@ module Vinter
         when 'vim9script'
           token = advance # Skip 'vim9script'
           { type: :vim9script_declaration, line: token[:line], column: token[:column] }
+        when 'autocmd'
+          parse_autocmd_statement
+        when 'execute'
+          parse_execute_statement
+        when 'let'
+          parse_let_statement  
+        when 'echohl', 'echomsg'
+          parse_echo_statement
         else
           @warnings << {
             message: "Unexpected keyword: #{current_token[:value]}",
@@ -104,7 +112,11 @@ module Vinter
           nil
         end
       elsif current_token[:type] == :identifier
-        parse_expression_statement
+        if current_token[:value] == "echo"
+          parse_echo_statement
+        else
+          parse_expression_statement
+        end
       elsif current_token[:type] == :comment
         parse_comment
       else
@@ -119,6 +131,168 @@ module Vinter
       end
     end
 
+    def parse_execute_statement
+      token = advance # Skip 'execute'
+      line = token[:line]
+      column = token[:column]
+
+      # Parse arguments - typically string expressions with concatenation
+      # Just accept any tokens until we hit a statement terminator or another command
+      expressions = []
+      expr = parse_expression
+      expressions << expr if expr
+
+      # Return the execute statement
+      {
+        type: :execute_statement,
+        expressions: expressions,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_let_statement
+      token = advance # Skip 'let'
+      line = token[:line]
+      column = token[:column]
+
+      # Parse the target variable
+      target = nil
+      if current_token
+        case current_token[:type]
+        when :identifier, :global_variable, :script_local, :arg_variable, :option_variable, :special_variable
+          target = {
+            type: current_token[:type],
+            name: current_token[:value],
+            line: current_token[:line],
+            column: current_token[:column]
+          }
+          advance
+        else
+          @errors << {
+            message: "Expected variable name after let",
+            position: @position,
+            line: current_token ? current_token[:line] : 0,
+            column: current_token ? current_token[:column] : 0
+          }
+        end
+      end
+
+      # Skip the '=' or other assignment operator
+      operator = nil
+      if current_token && (
+          (current_token[:type] == :operator && current_token[:value] == '=') ||
+          current_token[:type] == :compound_operator)
+        operator = current_token[:value]
+        advance
+      else
+        @errors << {
+          message: "Expected assignment operator after variable in let statement",
+          position: @position,
+          line: current_token ? current_token[:line] : 0,
+          column: current_token ? current_token[:column] : 0
+        }
+      end
+
+      # Parse the value expression
+      value = parse_expression
+
+      {
+        type: :let_statement,
+        target: target,
+        operator: operator,
+        value: value,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_autocmd_statement
+      token = advance # Skip 'autocmd'
+      line = token[:line]
+      column = token[:column]
+
+      # Parse event name (like BufNewFile)
+      event = nil
+      if current_token && current_token[:type] == :identifier
+        event = advance[:value]
+      else
+        @errors << {
+          message: "Expected event name after 'autocmd'",
+          position: @position,
+          line: current_token ? current_token[:line] : 0,
+          column: current_token ? current_token[:column] : 0
+        }
+      end
+
+      # Parse pattern (like *.match)
+      pattern = nil
+      if current_token
+        pattern = current_token[:value]
+        advance
+      end
+
+      # Parse command (can be complex, including if statements)
+      commands = []
+
+      # Handle pipe-separated commands
+      in_command = true
+      while in_command && @position < @tokens.length
+        if current_token && current_token[:value] == '|'
+          advance # Skip '|'
+        end
+
+        # Parse the command
+        if current_token && current_token[:type] == :keyword
+          case current_token[:value]
+          when 'if'
+            commands << parse_if_statement
+          when 'echo'
+            commands << parse_echo_statement
+          # Add other command types as needed
+          else
+            # Generic command handling
+            cmd = parse_expression_statement
+            commands << cmd if cmd
+          end
+        elsif current_token && current_token[:type] == :identifier
+          cmd = parse_expression_statement
+          commands << cmd if cmd
+        else
+          in_command = false
+        end
+
+        # Check if we've reached the end of the autocmd command
+        if !current_token || current_token[:type] == :comment || current_token[:value] == "\n"
+          in_command = false
+        end
+      end
+
+      return {
+        type: :autocmd_statement,
+        event: event,
+        pattern: pattern,
+        commands: commands,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_echo_statement
+      token = advance #Skip 'echo'
+      line = token[:line]
+      column = token[:column]
+
+      expression = parse_expression
+
+      {
+        type: :echo_statement,
+        expression: expression,
+        line: line,
+        column: column
+      }
+    end
+
     def parse_comment
       comment = current_token[:value]
       line = current_token[:line]
@@ -375,8 +549,6 @@ module Vinter
       }
     end
 
-
-
     def parse_parameter_list
       params = []
 
@@ -385,7 +557,8 @@ module Vinter
         return params
       end
 
-      loop do
+      # 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
@@ -403,6 +576,17 @@ module Vinter
             line: ellipsis_token[:line],
             column: ellipsis_token[:column]
           }
+
+          # 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]
+            }
+          end
+
           break
         end
 
@@ -437,15 +621,23 @@ module Vinter
           type: :parameter,
           name: param_name[:value],
           param_type: param_type,
-          optional: false, # Set this based on default value
+          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
-        else
+        # 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]
+          }
           break
         end
       end
@@ -548,6 +740,39 @@ module Vinter
     end
 
     def parse_expression_statement
+      # Check if this is an assignment using a compound operator
+      if current_token && current_token[:type] == :identifier
+        variable_name = current_token[:value]
+        variable_token = current_token
+        advance  # Move past the identifier
+
+        if current_token && current_token[:type] == :compound_operator
+          operator = current_token[:value]
+          operator_token = current_token
+          advance  # Move past the operator
+
+          right = parse_expression
+
+          return {
+            type: :compound_assignment,
+            operator: operator,
+            target: {
+              type: :identifier,
+              name: variable_name,
+              line: variable_token[:line],
+              column: variable_token[:column]
+            },
+            value: right,
+            line: operator_token[:line],
+            column: operator_token[:column]
+          }
+        end
+
+        # If it wasn't a compound assignment, backtrack
+        @position -= 1
+      end
+
+      # Regular expression statement handling
       expr = parse_expression
       {
         type: :expression_statement,
@@ -562,24 +787,38 @@ module Vinter
     end
 
     def parse_binary_expression(precedence = 0)
-      left = parse_primary_expression
+      left = parse_unary_expression
 
-      while current_token && current_token[:type] == :operator &&
-            operator_precedence(current_token[:value]) >= precedence
-        op_token = advance
-        op = op_token[:value]
-        op_precedence = operator_precedence(op)
+      # Handle multi-line expressions where operators may appear at line beginnings
+      while current_token &&
+            (current_token[:type] == :operator ||
+             (peek_token && peek_token[:type] == :operator && current_token[:type] == :whitespace))
 
-        right = parse_binary_expression(op_precedence + 1)
+        # Skip any whitespace before the operator if it's at the beginning of a line
+        if current_token[:type] == :whitespace
+          advance
+        end
 
-        left = {
-          type: :binary_expression,
-          operator: op,
-          left: left,
-          right: right,
-          line: op_token[:line],
-          column: op_token[:column]
-        }
+        # Now we should be at the operator
+        if current_token && current_token[:type] == :operator &&
+           operator_precedence(current_token[:value]) >= precedence
+          op_token = advance
+          op = op_token[:value]
+          op_precedence = operator_precedence(op)
+
+          right = parse_binary_expression(op_precedence + 1)
+
+          left = {
+            type: :binary_expression,
+            operator: op,
+            left: left,
+            right: right,
+            line: op_token[:line],
+            column: op_token[:column]
+          }
+        else
+          break
+        end
       end
 
       return left
@@ -599,6 +838,10 @@ module Vinter
         5
       when '*', '/', '%'  # Multiplication, division, modulo
         6
+      when '.'
+        7
+      when '!'
+        8
       else
         0
       end
@@ -611,10 +854,13 @@ module Vinter
       line = token[:line]
       column = token[:column]
 
+      # First parse the basic expression
+      expr = nil
+
       case token[:type]
       when :number
         advance
-        {
+        expr = {
           type: :literal,
           value: token[:value],
           token_type: :number,
@@ -623,14 +869,33 @@ module Vinter
         }
       when :string
         advance
-        {
+        expr = {
           type: :literal,
           value: token[:value],
           token_type: :string,
           line: line,
           column: column
         }
-      when :identifier
+      when :option_variable
+        # Handle Vim option variables (like &compatible)
+        advance
+        expr = {
+          type: :option_variable,
+          name: token[:value],
+          line: line,
+          column: column
+        }
+      when :special_variable
+        # Handle Vim special variables (like v:version)
+        advance
+        expr = {
+          type: :special_variable,
+          name: token[:value],
+          line: line,
+          column: column
+        }
+      when :script_local
+        # Handle script-local variables/functions (like s:var)
         advance
 
         # Check if this is a function call
@@ -638,17 +903,72 @@ module Vinter
           return parse_function_call(token[:value], line, column)
         end
 
-        {
-          type: :identifier,
+        expr = {
+          type: :script_local,
+          name: token[:value],
+          line: line,
+          column: column
+        }
+      when :global_variable
+        # Handle global variables (like g:var)
+        advance
+        expr = {
+          type: :global_variable,
           name: token[:value],
           line: line,
           column: column
         }
+      when :arg_variable
+        # Handle function argument variables (like a:var)
+        advance
+        expr = {
+          type: :arg_variable,
+          name: token[:value],
+          line: line,
+          column: column
+        }
+      when :identifier
+        advance
+
+        # Check if this is a function call
+        if current_token && current_token[:type] == :paren_open
+          return parse_function_call(token[:value], line, column)
+        end
+        
+        # Special handling for execute command
+        if token[:value] == 'execute'
+          # Parse the string expressions for execute
+          # For now we'll just treat it as a normal identifier
+          expr = {
+            type: :identifier,
+            name: token[:value],
+            line: line,
+            column: column
+          }
+        else
+          expr = {
+            type: :identifier,
+            name: token[:value],
+            line: line,
+            column: column
+          }
+        end
       when :paren_open
-        advance  # Skip '('
+        if is_lambda_expression
+          return parse_lambda_expression(line, column)
+        else
+          advance  # Skip '('
+          expr = parse_expression
+          expect(:paren_close)  # Expect and skip ')'
+        end
+      when :bracket_open
+        expr = parse_list_literal(line, column)
+      when :brace_open
+        expr = parse_dict_literal(line, column)
+      when :backslash
+        # Handle line continuation with backslash
+        advance
         expr = parse_expression
-        expect(:paren_close)  # Expect and skip ')'
-        return expr
       else
         @errors << {
           message: "Unexpected token in expression: #{token[:type]}",
@@ -659,6 +979,471 @@ module Vinter
         advance
         return nil
       end
+
+      # Now handle any chained property access or method calls
+      while current_token
+        # Check for property access with dot
+        if current_token[:type] == :operator && current_token[:value] == '.'
+          dot_token = advance # Skip '.'
+
+          # Next token should be an identifier (property name)
+          if !current_token || current_token[:type] != :identifier
+            @errors << {
+              message: "Expected property name after '.'",
+              position: @position,
+              line: current_token ? current_token[:line] : 0,
+              column: current_token ? current_token[:column] : 0
+            }
+            break
+          end
+
+          property_token = advance # Get property name
+
+          expr = {
+            type: :property_access,
+            object: expr,
+            property: property_token[:value],
+            line: dot_token[:line],
+            column: dot_token[:column]
+          }
+        # Check for method call with arrow ->
+        elsif current_token[:type] == :operator && current_token[:value] == '->'
+          arrow_token = advance # Skip '->'
+
+          # Next token should be an identifier (method name)
+          if !current_token || current_token[:type] != :identifier
+            @errors << {
+              message: "Expected method name after '->'",
+              position: @position,
+              line: current_token ? current_token[:line] : 0,
+              column: current_token ? current_token[:column] : 0
+            }
+            break
+          end
+
+          method_name = advance[:value] # Get method name
+
+          # 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
+              end
+            end
+
+            expect(:paren_close) # Skip ')'
+          end
+
+          expr = {
+            type: :method_call,
+            object: expr,
+            method: method_name,
+            arguments: args,
+            line: arrow_token[:line],
+            column: arrow_token[:column]
+          }
+        # Check for indexing with brackets
+        elsif current_token[:type] == :bracket_open
+          bracket_token = advance # Skip '['
+
+          index_expr = parse_expression
+
+          expect(:bracket_close) # Skip ']'
+
+          expr = {
+            type: :indexed_access,
+            object: expr,
+            index: index_expr,
+            line: bracket_token[:line],
+            column: bracket_token[:column]
+          }
+        # Check for function call directly on an expression
+        elsif current_token[:type] == :paren_open
+          paren_token = advance # Skip '('
+
+          args = []
+
+          # Parse arguments if any
+          unless current_token && current_token[:type] == :paren_close
+            loop do
+              arg = parse_expression
+              args << arg if arg
+
+              if current_token && current_token[:type] == :comma
+                advance # Skip comma
+              else
+                break
+              end
+            end
+          end
+
+          expect(:paren_close) # Skip ')'
+
+          expr = {
+            type: :call_expression,
+            callee: expr,
+            arguments: args,
+            line: paren_token[:line],
+            column: paren_token[:column]
+          }
+        else
+          # No more chaining
+          break
+        end
+      end
+
+      return expr
+    end
+
+    def is_lambda_expression
+      # Save the current position
+      original_position = @position
+
+      # Skip the opening parenthesis
+      advance if current_token && current_token[:type] == :paren_open
+
+      # Check for a parameter list followed by => or ): =>
+      has_params = false
+      has_arrow = false
+
+      # Skip past parameters
+      loop do
+        break if !current_token
+
+        if current_token[:type] == :identifier
+          has_params = true
+          advance
+
+          # Either comma for another parameter, or close paren
+          if current_token && current_token[:type] == :comma
+            advance
+          elsif current_token && current_token[:type] == :paren_close
+            advance
+            break
+          else
+            # Not a valid lambda parameter list
+            break
+          end
+        elsif current_token[:type] == :paren_close
+          # Empty parameter list is valid
+          advance
+          break
+        else
+          # Not a valid lambda parameter list
+          break
+        end
+      end
+
+      # After parameters, check for either => or ): =>
+      if current_token
+        if current_token[:type] == :operator && current_token[:value] == '=>'
+          has_arrow = true
+        elsif current_token[:type] == :colon
+          # There might be a return type annotation
+          advance
+          # Skip the type
+          advance if current_token && current_token[:type] == :identifier
+          # Check for the arrow
+          has_arrow = current_token && current_token[:type] == :operator && current_token[:value] == '=>'
+        end
+      end
+
+      # Reset position to where we started
+      @position = original_position
+
+      return has_params && has_arrow
+    end
+
+    def parse_lambda_expression(line, column)
+      expect(:paren_open)  # Skip '('
+
+      params = []
+
+      # Parse parameters
+      unless current_token && current_token[:type] == :paren_close
+        loop do
+          if current_token && current_token[:type] == :identifier
+            param_name = current_token[:value]
+            param_token = current_token
+            advance
+
+            # Check for type annotation
+            param_type = nil
+            if current_token && current_token[:type] == :colon
+              advance  # Skip ':'
+              param_type = parse_type
+            end
+
+            params << {
+              type: :parameter,
+              name: param_name,
+              param_type: param_type,
+              line: param_token[:line],
+              column: param_token[:column]
+            }
+          else
+            @errors << {
+              message: "Expected parameter name in lambda expression",
+              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 comma
+          else
+            break
+          end
+        end
+      end
+
+      expect(:paren_close)  # Skip ')'
+
+      # Check for return type annotation
+      return_type = nil
+      if current_token && current_token[:type] == :colon
+        advance  # Skip ':'
+        return_type = parse_type
+      end
+
+      # Expect the arrow '=>'
+      arrow_found = false
+      if current_token && current_token[:type] == :operator && current_token[:value] == '=>'
+        arrow_found = true
+        advance  # Skip '=>'
+      else
+        @errors << {
+          message: "Expected '=>' in lambda expression",
+          position: @position,
+          line: current_token ? current_token[:line] : 0,
+          column: current_token ? current_token[:column] : 0
+        }
+      end
+
+      # Parse the lambda body - check if it's a block or an expression
+      if arrow_found
+        if current_token && current_token[:type] == :brace_open
+          # Parse block body
+          advance  # Skip '{'
+
+          block_body = []
+          brace_count = 1  # Track nested braces
+
+          while @position < @tokens.length && brace_count > 0
+            if current_token[:type] == :brace_open
+              brace_count += 1
+            elsif current_token[:type] == :brace_close
+              brace_count -= 1
+
+              # Skip the final closing brace, but don't process it as a statement
+              if brace_count == 0
+                advance
+                break
+              end
+            end
+
+            stmt = parse_statement
+            block_body << stmt if stmt
+
+            # Break if we've reached the end or found the matching closing brace
+            if brace_count == 0 || @position >= @tokens.length
+              break
+            end
+          end
+
+          body = {
+            type: :block_expression,
+            statements: block_body,
+            line: line,
+            column: column
+          }
+        else
+          # Simple expression body
+          body = parse_expression
+        end
+      else
+        body = nil
+      end
+
+      return {
+        type: :lambda_expression,
+        params: params,
+        return_type: return_type,
+        body: body,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_dict_literal(line, column)
+      advance  # Skip '{'
+      entries = []
+
+      # Empty dictionary
+      if current_token && current_token[:type] == :brace_close
+        advance  # Skip '}'
+        return {
+          type: :dict_literal,
+          entries: entries,
+          line: line,
+          column: column
+        }
+      end
+
+      # Parse dictionary entries
+      loop do
+        # Parse key (string or identifier)
+        key = nil
+        if current_token && (current_token[:type] == :string || current_token[:type] == :identifier)
+          key = current_token[:type] == :string ? current_token[:value] : current_token[:value]
+          advance  # Skip key
+        else
+          @errors << {
+            message: "Expected string or identifier as dictionary key",
+            position: @position,
+            line: current_token ? current_token[:line] : 0,
+            column: current_token ? current_token[:column] : 0
+          }
+          break
+        end
+
+        # Expect colon
+        expect(:colon)
+
+        # Parse value
+        value = parse_expression
+
+        entries << {
+          key: key,
+          value: value
+        }
+
+        if current_token && current_token[:type] == :comma
+          advance  # Skip comma
+          # Allow trailing comma
+          break if current_token && current_token[:type] == :brace_close
+        else
+          break
+        end
+      end
+
+      expect(:brace_close)  # Expect and skip '}'
+
+      {
+        type: :dict_literal,
+        entries: entries,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_list_literal(line, column)
+      advance  # Skip '['
+      elements = []
+
+      # Empty list
+      if current_token && current_token[:type] == :bracket_close
+        advance  # Skip ']'
+        return {
+          type: :list_literal,
+          elements: elements,
+          line: line,
+          column: column
+        }
+      end
+
+      # Parse list elements
+      while @position < @tokens.length
+        # Check if we've reached the end of the list
+        if current_token && current_token[:type] == :bracket_close
+          advance  # Skip ']'
+          break
+        end
+
+        element = parse_expression
+        elements << element if element
+
+        # Continue if there's a comma
+        if current_token && current_token[:type] == :comma
+          advance  # Skip comma
+        else
+          # If no comma and not a closing bracket, then it's an error
+          if current_token && current_token[:type] != :bracket_close
+            @errors << {
+              message: "Expected comma or closing bracket after list element",
+              position: @position,
+              line: current_token[:line],
+              column: current_token[:column]
+            }
+          end
+
+          # We still want to skip the closing bracket if it's there
+          if current_token && current_token[:type] == :bracket_close
+            advance
+          end
+
+          break
+        end
+      end
+
+      # Check if we have a second list immediately following this one (Vim's special syntax)
+      if current_token && current_token[:type] == :bracket_open
+        next_list = parse_list_literal(current_token[:line], current_token[:column])
+
+        return {
+          type: :list_concat_expression,
+          left: {
+            type: :list_literal,
+            elements: elements,
+            line: line,
+            column: column
+          },
+          right: next_list,
+          line: line,
+          column: column
+        }
+      end
+
+      return {
+        type: :list_literal,
+        elements: elements,
+        line: line,
+        column: column
+      }
+    end
+
+    def parse_unary_expression
+      # Check for unary operators (!, -, +)
+      if current_token && current_token[:type] == :operator &&
+         ['!', '-', '+'].include?(current_token[:value])
+
+        op_token = advance # Skip the operator
+        operand = parse_unary_expression  # Recursively parse the operand
+
+        return {
+          type: :unary_expression,
+          operator: op_token[:value],
+          operand: operand,
+          line: op_token[:line],
+          column: op_token[:column]
+        }
+      end
+
+      # If no unary operator, parse a primary expression
+      return parse_primary_expression
     end
 
     def parse_function_call(name, line, column)
@@ -666,14 +1451,40 @@ module Vinter
 
       args = []
 
-      # Parse arguments
-      unless current_token && current_token[:type] == :paren_close
-        loop do
+      # Parse arguments until we find a closing parenthesis
+      while @position < @tokens.length && current_token && current_token[:type] != :paren_close
+        # Skip comments inside parameter lists
+        if current_token && current_token[:type] == :comment
+          advance
+          next
+        end
+
+        # Check if the argument might be a lambda expression
+        if current_token && current_token[:type] == :paren_open && is_lambda_expression
+          arg = parse_lambda_expression(current_token[:line], current_token[:column])
+        else
           arg = parse_expression
-          args << arg if arg
+        end
 
-          break unless current_token && current_token[:type] == :comma
-          advance  # Skip comma
+        args << arg if arg
+
+        # Break if we hit the closing paren
+        if current_token && current_token[:type] == :paren_close
+          break
+        end
+
+        # If we have a comma, advance past it and continue
+        if current_token && current_token[:type] == :comma
+          advance
+        # If we don't have a comma and we're not at the end, it's an error
+        elsif current_token && current_token[:type] != :paren_close && current_token[:type] != :comment
+          @errors << {
+            message: "Expected comma or closing parenthesis after argument",
+            position: @position,
+            line: current_token[:line],
+            column: current_token[:column]
+          }
+          break
         end
       end
 
@@ -837,7 +1648,37 @@ module Vinter
         advance # Skip '!'
       end
 
-      name = expect(:identifier)
+      # For script-local functions or other scoped functions
+      is_script_local = false
+      function_scope = nil
+      
+      # Check if we have a script-local function (s:)
+      if current_token && current_token[:type] == :script_local
+        is_script_local = true
+        function_scope = current_token[:value]
+        advance # Skip s: prefix
+      elsif current_token && current_token[:type] == :identifier && current_token[:value].include?(':')
+        # Handle other scoped functions like g: or b:
+        parts = current_token[:value].split(':')
+        if parts.length == 2
+          function_scope = parts[0] + ':'
+          advance
+        end
+      end
+      
+      # Now handle the function name, which might be separate from the scope
+      name = nil
+      if !is_script_local && function_scope.nil? && current_token && current_token[:type] == :identifier
+        name = current_token
+        advance
+      elsif is_script_local || !function_scope.nil?
+        if current_token && current_token[:type] == :identifier
+          name = current_token
+          advance
+        end
+      else
+        name = expect(:identifier)
+      end
 
       # Parse parameter list
       expect(:paren_open)
@@ -846,8 +1687,11 @@ module Vinter
 
       # Check for optional attributes (range, dict, abort, closure)
       attributes = []
-      while current_token && current_token[:type] == :identifier
-        if ['range', 'dict', 'abort', 'closure'].include?(current_token[:value])
+      while current_token
+        if current_token[:type] == :keyword && current_token[:value] == 'abort'
+          attributes << advance[:value]
+        elsif current_token[:type] == :identifier && 
+              ['range', 'dict', 'closure'].include?(current_token[:value])
           attributes << advance[:value]
         else
           break
@@ -878,9 +1722,16 @@ module Vinter
         }
       end
 
+      function_name = name ? name[:value] : nil
+      if function_scope
+        function_name = function_scope + function_name if function_name
+      end
+      
       {
         type: :legacy_function,
-        name: name ? name[:value] : nil,
+        name: function_name,
+        is_script_local: is_script_local,
+        scope: function_scope,
         params: params,
         has_bang: has_bang,
         attributes: attributes,
@@ -890,7 +1741,7 @@ module Vinter
       }
     end
 
-    # Legacy function parameters are different - they use a:name syntax
+    # Legacy function parameters are different - they can use a:name syntax
     def parse_parameter_list_legacy
       params = []
 
@@ -907,7 +1758,28 @@ module Vinter
           break
         end
 
-        if !current_token || current_token[:type] != :identifier
+        if current_token && current_token[:type] == :identifier
+          # Regular parameter
+          param_name = advance
+          params << {
+            type: :parameter,
+            name: param_name[:value],
+            line: param_name[:line],
+            column: param_name[:column]
+          }
+        elsif current_token && current_token[:type] == :arg_variable
+          # Parameter with a: prefix
+          param_name = advance
+          # Extract name without 'a:' prefix
+          name_without_prefix = param_name[:value].sub(/^a:/, '')
+          params << {
+            type: :parameter,
+            name: name_without_prefix,
+            line: param_name[:line],
+            column: param_name[:column],
+            is_arg_prefixed: true
+          }
+        else
           @errors << {
             message: "Expected parameter name",
             position: @position,
@@ -917,15 +1789,6 @@ module Vinter
           break
         end
 
-        param_name = advance
-
-        params << {
-          type: :parameter,
-          name: param_name[:value],
-          line: param_name[:line],
-          column: param_name[:column]
-        }
-
         if current_token && current_token[:type] == :comma
           advance
         else