riml 0.3.8 → 0.3.9

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MDk4OTEyMjkyYTk1YzVjYjEzNzAxNTllZGVmNjY0NGE5YTJjZWZmYQ==
+  data.tar.gz: !binary |-
+    OTY1ZDRlMDVjNGY3ZjA3YmViZGE2M2RjY2VkODg2ZjJhMDk5NTkxZA==
+SHA512:
+  metadata.gz: !binary |-
+    MTk4MTY0Y2FiMGQ0ZDc4ODNjNDk4NDdmOGViZmFhODUxMmYxY2E1NjY5Njk4
+    ZDIxNGI3ZjI3ZjQyZjcxNDNmYWQxYWUyNTNlNzk0ODc1ZmEzZDU1YmUwZGQ1
+    YmQ1Y2E0N2M4YzE1OWFhMmZlNjkzYTZlOWQ4OWUyYmFlOWVlZmU=
+  data.tar.gz: !binary |-
+    MTc4ZjZkZjE1MmU3YTRkNDVlYjA2NTE4YzRhYjk1MGE1NTkwM2FlMjM1NTYw
+    OGU2ZWRmZDM2YmM2OTZlZmIwODI0ZmYxNTFjMWNlZWIxM2EyNWMyNDQxYzBk
+    MTU3NjJhMjNlM2Q3YTVkNDYxNjljZjZiNDNlMzA2NzQyOTZlODI=

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012-2013 by Luke Gruber
+Copyright (c) 2012-2014 by Luke Gruber
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,10 +1,10 @@
 [![Build Status](https://secure.travis-ci.org/luke-gru/riml.png?branch=master)](https://travis-ci.org/luke-gru/riml)
 
-Riml, a relaxed Vim script
-====================================
+Riml, a relaxed VimL
+====================
 
-Riml is a subset of Vim script with some added features, and it compiles to
-plain Vim script. Some of the added features include classes, string interpolation,
+Riml is a subset of VimL with some added features, and it compiles to
+plain VimL. Some of the added features include classes, string interpolation,
 heredocs, default case-sensitive string comparison, default parameters
 in functions, and other things programmers tend to take for granted.
 To see how Riml is compiled to VimL, just take a look at this README. The left
@@ -19,7 +19,7 @@ Variables
       count += 1                    let s:count += 1
     end                           endwhile
 
-If you don't specify a scope modifier (or namespace in Vimspeak), it's script local (s:)
+If you don't specify a scope modifier (or 'namespace' in Vimspeak), it's script local (s:)
 by default in the global scope. Within a function, variables without scope modifiers are plain
 old local variables.
 
@@ -70,7 +70,7 @@ Notice in the last line of Riml there's string interpolation. This works
 in double-quoted strings and heredocs, which we'll encounter later.
 
 In Riml, you can choose to end any block with 'end', or with whatever you used
-to do in Vim script ('endif', 'endfunction', etc...). Also, 'if' and 'unless' can
+to do in VimL ('endif', 'endfunction', etc...). Also, 'if' and 'unless' can
 now be used as statement modifiers:
 
     callcount = 0 unless callcount?
@@ -82,15 +82,15 @@ Here, the compiled output is the same as the previous example's. Both 'if' and
 
 ###True and False
 
-    a = true                                      let a = 1
-    b = false                                     let b = 0
+    a = true                                      let s:a = 1
+    b = false                                     let s:b = 0
 
 Operators And Case Sensitivity
 ------------------------------
 
-    if "hi" == greeting                      if "hi" ==# s:greeting
-      echo greeting                            echo s:greeting
-    end                                      end
+    if "hi" == greeting                           if "hi" ==# s:greeting
+      echo greeting                                 echo s:greeting
+    end                                           end
 
 Comparisons compile to case-sensitive by default. To get case-insensitive
 comparisons, you have to explicitly use the form ending in '?' (ex: '==?').
@@ -101,7 +101,7 @@ cousin 'is#', and the same is true of 'isnot'.
 
 ###=== Operator
 
-Oh no, not another of THOSE operators! Well, this one is pretty sweet
+Oh no, not another of __those__ operators! Well, this one is pretty sweet
 actually. In VimL, automatic type conversion can be a pain. For example:
 
     echo 4 ==# "4"
@@ -116,7 +116,7 @@ regarding equality:
 The '===' operator wraps both operands in lists:
 
     echo 4 === "4"                        echo [4] ==# ["4"]
-
+    => 0
 
 Heredocs
 --------
@@ -126,8 +126,8 @@ Heredocs
     Hooray!
     EOS
 
-Riml heredocs must have the ending pattern ('EOS' in this case) start at the
-beginning of the line. Interpolated expressions are allowed in heredocs.
+Riml heredocs must have the ending pattern ('EOS' in this case, but can be anything) start
+at the beginning of the line. Interpolated expressions are allowed in heredocs.
 
 Functions
 ---------
@@ -137,15 +137,16 @@ Functions
       return @/                     return @/
     end                           endfunction
 
-When defining a function with no parameters, the parens after the function name are optional.
-
 Functions are by default prepended by 's:' unless explicitly prepended with a
 different scope modifier. Of course, you can use the old form ('function! Name()')
 for defining functions if you want, as Riml aims to be as compatible as possible
 with VimL. There are a few exceptions where Riml and VimL aren't compatible, and
 these differences are explained in the section 'Incompatibilities with VimL'.
 
-###Default Arguments
+When defining a function with no parameters and no keywords (such as 'dict' or 'abort'),
+the parens after the function name are optional.
+
+###Default Parameters
 
     def fillSearchPat(pat = getDefaultSearchPat())        function! s:fillSearchPat(...)
       @/ = pat                                              if get(a:000, 0, 'rimldefault') !=# 'rimldefault'
@@ -158,13 +159,63 @@ these differences are explained in the section 'Incompatibilities with VimL'.
                                                           endfunction
 
 
-Default arguments must be the last arguments given to a function, but there can be more
-than one default argument. Also, a splat argument (... or \*argName) can come after default argument(s).
-Splats will be explained in the next section.
+Default parameters must be the last parameters given to a function, but there can be more
+than one default parameter. Also, a splat parameter (... or \*argName) can come after default parameters.
+Splats parameters and splat arguments will be explained in the next section.
 
 We can now call the function 'fillSearchPat' without any arguments and it will use the default
-argument. Also, if we pass the string 'rimldefault', it will use the default argument as well. This
-is useful if a function has many default arguments.
+parameter. Also, if we pass the string 'rimldefault', it will use the default parameter as well. This
+is useful if a function has many default parameters.
+
+###Splat Parameters
+
+A splat parameter is a formal parameter to a function starting with a '\*'. They must be the last
+parameters given to a function.
+
+    def my_echo(*words)                             function! s:my_echo(...)
+      echo words                                      echo a:000
+    end                                             endfunction
+    my_echo("hello", "world")                       call my_echo("hello", "world")
+
+    => ["hello", "world"]
+
+###Splat Arguments
+
+Splat arguments are splats used in a function call context. With the function `my_echo` defined in the
+previous section, here's an example at work:
+
+    words = ["hello", "world"]                      let s:words = ["hello", "world"]
+    echo 'without splat:'                           echo 'without splat:'
+    my_echo(words)                                  call my_echo(s:words)
+    echo 'with splat:'                              echo 'with splat:'
+    my_echo(*words)                                 let s:__riml_splat_list = s:words
+
+                                                    let s:__riml_splat_size = len(s:__riml_splat_list)
+                                                    let s:__riml_splat_str_vars = []
+                                                    let s:__riml_splat_idx = 1
+                                                    while s:__riml_splat_idx <=# s:__riml_splat_size
+                                                      let s:__riml_splat_var_{s:__riml_splat_idx} = get(s:__riml_splat_list, s:__riml_splat_idx - 1)
+                                                      call add(s:__riml_splat_str_vars, '__riml_splat_var_' . s:__riml_splat_idx)
+                                                      let s:__riml_splat_idx += 1
+                                                    endwhile
+                                                    execute 'call s:my_echo(' . join(s:__riml_splat_str_vars, ', ') . ')'
+
+    => without splat:
+    => [["hello", "world"]]
+
+    => with splat:
+    => ["hello", "world"]
+
+The way to think about how splat arguments work is that the list variable that's
+splatted is broke into its constituent parts, just like in Ruby. So, `my_echo(*words)`
+is equivalent to `my_echo("hello", "world")` in this example. Notice how you can now
+pass the exact same arguments your function received to another function by splatting a
+parameter and passing it on to another function.
+
+    def some_func(*args)
+      other_func(*args) " passes same arguments along to other function.
+    end
+
 
 Classes
 -------
@@ -193,6 +244,10 @@ Classes
                                                          return self.otherData
                                                        endfunction
 
+In this basic example of a class, we see a \*splat variable. This is just a
+convenient way to refer to 'a:000' in the body of a function. Splat variables
+are optional parameters and get compiled to '...'.
+
 Classes can only be defined once, and cannot be reopened. Public member
 functions are defined with 'defm'. If you want to create a non-public function
 inside a class, use 'def'. To create an instance of this class, simply:
@@ -208,9 +263,6 @@ For example:
       ...
     end
 
-In this basic example of a class, we see a \*splat variable. This is just a
-convenient way to refer to 'a:000' in the body of a function. Splat variables
-are optional parameters and get compiled to '...'.
 
 ###Class Inheritance
 
@@ -251,6 +303,11 @@ instances use the initialize function from 'Translation', and new instances must
 be provided with an 'input' argument on creation. Basically, if a class doesn't
 provide an initialize function, it uses its superclass's.
 
+If you look at the last line of Riml in the previous example, you'll see that
+it doesn't use VimL's builtin 'call' function for calling the 'translate'
+method on the translation object. Riml can figure out when 'call' is necessary,
+and will add it to the compiled VimL.
+
 A base class and inheriting class can have different scope modifiers. For example, if you
 had a script-local base class and wanted to extend it but have the extending class be
 global, this is not a problem. Simply:
@@ -259,10 +316,6 @@ global, this is not a problem. Simply:
       ...
     end
 
-If you look at the last line of Riml in the previous example, you'll see that
-it doesn't use Vim script's builtin 'call' function for calling the 'translate'
-method on the translation object. Riml can figure out when 'call' is necessary,
-and will add it to the compiled Vim script.
 
 ###Using 'super'
 

data/Rakefile

@@ -15,6 +15,11 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb'].to_a
 end
 
+desc 'Run benchmarks'
+task :bench => [:parser] do
+  load File.expand_path('../benchmarks/run', __FILE__)
+end
+
 desc 'recreate lib/parser.rb from lib/grammar.y using racc'
 task :parser do
   in_libdir { sh 'racc -o parser.rb grammar.y' }

data/bin/riml

@@ -135,6 +135,7 @@ module Riml
         compile_files_options = compile_options.merge(
           :output_dir => options.output_dir
         )
+        Riml.config = options
         Riml.debug = options.debug
         if options.stdio
           puts Riml.compile($stdin.read, compile_options)

data/lib/riml.rb

@@ -1,5 +1,6 @@
 require 'pathname'
 require 'fileutils'
+require 'ostruct'
 
 if RUBY_VERSION < '1.9'
   require 'thread'
@@ -229,6 +230,20 @@ module Riml
   self.warnings = true
   self.debug = false
 
+  # @return OpenStruct|nil
+  def self.config
+    @config
+  end
+
+  # possible values: OpenStruct|nil
+  def self.config=(config)
+    unless config.nil? || OpenStruct === config
+      raise ArgumentError, "config must be OpenStruct or NilClass, is #{config.class}"
+    end
+    @config = config
+  end
+  self.config = nil # avoid ivar warnings
+
   private
 
   def self.flush_warnings
@@ -259,8 +274,8 @@ module Riml
     cache_files_in_path(path, force_cache_bust)
     path
   end
-  self.source_path  = nil  # eliminate ivar warnings
-  self.include_path = nil  # eliminate ivar warnings
+  self.source_path  = nil  # avoid ivar warnings
+  self.include_path = nil  # avoid ivar warnings
 
   def self.cache_files_in_path(path, force_cache_bust = false)
     @path_cache[path] = nil if force_cache_bust

data/lib/riml/ast_rewriter.rb

@@ -13,19 +13,24 @@ module Riml
 
     def initialize(ast = nil, classes = nil, class_dependency_graph = nil)
       @ast = ast
-      @classes = classes || ClassMap.new
-      # AST_Rewriter shares options with Parser. Parser set AST_Rewriter's
-      # options before call to `rewrite`.
-      @options = nil
-      # Keeps track of filenames with their rewritten ASTs, to prevent rewriting
-      # the same AST more than once.
-      @rewritten_included_and_sourced_files = {}
-      # Keeps track of which filenames included/sourced which.
-      # ex: { nil => ["main.riml"], "main.riml" => ["lib1.riml", "lib2.riml"],
-      # "lib1.riml" => [], "lib2.riml" => [] }
-      @included_and_sourced_file_refs = Hash.new { |h, k| h[k] = [] }
-      @class_dependency_graph = class_dependency_graph || ClassDependencyGraph.new
-      @resolving_class_dependencies = nil
+      @classes = classes
+      @class_dependency_graph = class_dependency_graph
+      # only the top-most rewriter has these properties and defaults
+      if self.instance_of?(Riml::AST_Rewriter)
+        @classes ||= ClassMap.new
+        # AST_Rewriter shares options with Parser. Parser set AST_Rewriter's
+        # options before call to `rewrite`.
+        @options = nil
+        # Keeps track of filenames with their rewritten ASTs, to prevent rewriting
+        # the same AST more than once.
+        @rewritten_included_and_sourced_files = {}
+        # Keeps track of which filenames included/sourced which.
+        # ex: { nil => ["main.riml"], "main.riml" => ["lib1.riml", "lib2.riml"],
+        # "lib1.riml" => [], "lib2.riml" => [] }
+        @included_and_sourced_file_refs = Hash.new { |h, k| h[k] = [] }
+        @class_dependency_graph ||= ClassDependencyGraph.new
+        @resolving_class_dependencies = nil
+      end
     end
 
     def rewrite(filename = nil, included = false)
@@ -57,7 +62,8 @@ module Riml
         CallToExplicitCall.new(ast, classes),
         DefaultParamToIfNode.new(ast, classes),
         DeserializeVarAssignment.new(ast, classes),
-        TopLevelDefMethodToDef.new(ast, classes)
+        TopLevelDefMethodToDef.new(ast, classes),
+        SplatsToExecuteInCallingContext.new(ast, classes)
       ]
       rewriters.each do |rewriter|
         rewriter.rewrite_on_match
@@ -72,8 +78,8 @@ module Riml
 
     def do_establish_parents(node)
       node.children.each do |child|
-        child.parent_node = node if child.respond_to?(:parent_node=)
-      end if node.respond_to?(:children)
+        child.parent_node = node if Visitable === child
+      end if Visitable === node
     end
 
     def rewrite_on_match(node = ast)
@@ -437,150 +443,6 @@ module Riml
         end
       end
 
-      # Rewrite constructs like:
-      #
-      #   let animalObj = s:AnimalConstructor(*a:000)
-      #
-      # to:
-      #
-      #   let __riml_splat_list = a:000
-      #   let __riml_splat_size = len(__riml_splat_list)
-      #   let __riml_splat_str_vars = []
-      #   let __riml_splat_idx = 1
-      #   while __riml_splat_idx <=# __riml_splat_size
-      #     let __riml_splat_var_{__riml_splat_idx} = get(__riml_splat_list, __riml_splat_idx - 1)
-      #     call add(__riml_splat_str_vars, __riml_splat_var_{__riml_splat_idx})
-      #     let __riml_splat_idx += 1
-      #   endwhile
-      #   execute 'let l:animalObj = s:AnimalConstructor(' . join(__riml_splat_str_vars, ', ') . ')'
-      #
-      # Basically, mimic Ruby's approach to expanding lists to their
-      # constituent argument parts with '*' in calling context.
-      # NOTE: currently only works with `super`.
-      class SplatsToExecuteInCallingContext < AST_Rewriter
-
-        def match?(node)
-          if SplatNode === node && CallNode === node.parent
-            @splat_node = node
-          end
-        end
-
-        def replace(node)
-          construct_splat_str_vars_node = build_construct_splat_str_vars_node
-          call_node_args =
-            CallNode.new(
-              nil,
-              'join',
-              [
-                GetVariableNode.new('n:', '__riml_splat_str_vars'),
-                StringNode.new(', ', :s)
-              ]
-            )
-          call_node = node.parent
-          node_to_execute = if AssignNode === call_node.parent
-            assign_node = call_node.parent
-            # This is necessary because this node is getting put into a new
-            # compiler where it's not wrapped in a function context, therefore
-            # variables will be script-local there unless their scope_modifier
-            # is set
-            assign_node.lhs.scope_modifier = 'l:'
-            assign_node
-          else
-            call_node
-          end
-          call_node.arguments.clear
-          compiler = Compiler.new
-          # have to dup node_to_execute here because, if not, its parent will
-          # get reset during this next compilation step
-          output = compiler.compile(Nodes.new([node_to_execute.dup]))
-          execute_string_node = StringNode.new(output.chomp[0..-2], :s)
-          execute_string_node.value.insert(0, 'call ') if CallNode === node_to_execute
-          execute_arg = BinaryOperatorNode.new(
-            '.',
-            [
-              execute_string_node,
-              BinaryOperatorNode.new(
-                '.',
-                [
-                  call_node_args,
-                  StringNode.new(')', :s)
-                ]
-              )
-            ]
-          )
-          execute_node = CallNode.new(nil, 'execute', [execute_arg])
-          establish_parents(execute_node)
-          node.remove
-          node_to_execute.replace_with(construct_splat_str_vars_node)
-          execute_node.parent = construct_splat_str_vars_node.parent
-          construct_splat_str_vars_node.parent.insert_after(construct_splat_str_vars_node, execute_node)
-        end
-
-        private
-
-        def build_construct_splat_str_vars_node
-          nodes = Nodes.new([])
-          splat_list_init = AssignNode.new(
-            '=',
-            GetVariableNode.new('n:', '__riml_splat_list'),
-            splat_value
-          )
-          splat_size = AssignNode.new(
-            '=',
-            GetVariableNode.new('n:', '__riml_splat_size'),
-            CallNode.new(nil, 'len', [GetVariableNode.new('n:', '__riml_splat_list')])
-          )
-          splat_string_vars_init = AssignNode.new(
-            '=',
-            GetVariableNode.new('n:', '__riml_splat_str_vars'),
-            ListNode.new([])
-          )
-          splat_list_idx_init = AssignNode.new(
-            '=',
-            GetVariableNode.new('n:', '__riml_splat_idx'),
-            NumberNode.new('1')
-          )
-          while_loop = WhileNode.new(
-            # condition
-            BinaryOperatorNode.new('<=', [GetVariableNode.new('n:', '__riml_splat_idx'), GetVariableNode.new('n:', '__riml_splat_size')]),
-            # body
-            Nodes.new([
-              AssignNode.new(
-                '=',
-                GetCurlyBraceNameNode.new('n:', CurlyBraceVariable.new([CurlyBracePart.new('__riml_splat_var_'), CurlyBraceVariable.new([CurlyBracePart.new(GetVariableNode.new('n:', '__riml_splat_idx'))])])),
-                CallNode.new(nil, 'get', [
-                  GetVariableNode.new('n:', '__riml_splat_list'),
-                  BinaryOperatorNode.new('-', [
-                    GetVariableNode.new('n:', '__riml_splat_idx'),
-                    NumberNode.new('1')
-                  ])
-                ])
-              ),
-              ExplicitCallNode.new(nil, 'add', [
-                GetVariableNode.new('n:', '__riml_splat_str_vars'),
-                BinaryOperatorNode.new('.', [StringNode.new('__riml_splat_var_', :s), GetVariableNode.new('n:', '__riml_splat_idx')])
-              ]),
-              AssignNode.new('+=', GetVariableNode.new('n:', '__riml_splat_idx'), NumberNode.new('1'))
-            ])
-          )
-          nodes << splat_list_init << splat_size << splat_string_vars_init <<
-            splat_list_idx_init << while_loop
-          establish_parents(nodes)
-          nodes
-        end
-
-        def splat_value
-          n = @splat_node
-          until DefNode === n || n.nil?
-            n = n.parent
-          end
-          var_str_without_star = @splat_node.value[1..-1]
-          var_without_star = GetVariableNode.new(nil, var_str_without_star)
-          return var_without_star if n.nil? || !n.splat || (n.splat != @splat_node.value)
-          GetVariableNode.new('a:', '000')
-        end
-      end
-
       class SelfToObjArgumentInPrivateFunction < AST_Rewriter
         def initialize(ast, classes, class_node)
           super(ast, classes)
@@ -744,7 +606,7 @@ module Riml
           # initialize method taking *splat parameter and call super with it
           elsif class_node.superclass?
             def_node = DefNode.new(
-              '!', nil, nil, "initialize", ['...'], nil, Nodes.new([SuperNode.new([SplatNode.new('*a:000')], false)])
+              '!', nil, nil, "initialize", ['...'], nil, Nodes.new([SuperNode.new([SplatNode.new(GetVariableNode.new('a:', '000'))], false)])
             )
           else
             def_node = DefNode.new(
@@ -851,7 +713,7 @@ module Riml
             raise error
           end
           node_args = if node.arguments.empty? && !node.with_parens && superclass_function.splat
-            [SplatNode.new('*a:000')]
+            [SplatNode.new(GetVariableNode.new('a:', '000'))]
           else
             if @function_node.private_function?
               node.arguments.unshift GetVariableNode.new(nil, @function_node.parameters.first)
@@ -863,9 +725,19 @@ module Riml
           # private function, we have to add the explicit object (first
           # parameter to the function we're in) to the splat arg
           if @function_node.private_function?
-            if (splat_node = node_args.detect { |arg| SplatNode === arg }) &&
-              @function_node.splat == splat_node.value
-                splat_node.value = "*[a:#{@function_node.parameters.first}] + a:000"
+            if (splat_node = node_args.detect { |arg| SplatNode === arg })
+              splat_node.expression = WrapInParensNode.new(
+                BinaryOperatorNode.new(
+                  '+',
+                  [
+                    ListNode.new([
+                      GetVariableNode.new('a:', @function_node.parameters.first)
+                    ]),
+                    GetVariableNode.new('a:', '000')
+                  ]
+                )
+              )
+              establish_parents(splat_node.expression)
             end
             # call s.ClassA_private_func(args)
             call_node_name = superclass_func_name(superclass)
@@ -925,6 +797,174 @@ module Riml
       end
     end # ClassDefinitionToFunctions
 
+    # Rewrite constructs like:
+    #
+    #   let animalObj = s:AnimalConstructor(*a:000)
+    #
+    # to:
+    #
+    #   let __riml_splat_list = a:000
+    #   let __riml_splat_size = len(__riml_splat_list)
+    #   let __riml_splat_str_vars = []
+    #   let __riml_splat_idx = 1
+    #   while __riml_splat_idx <=# __riml_splat_size
+    #     let __riml_splat_var_{__riml_splat_idx} = get(__riml_splat_list, __riml_splat_idx - 1)
+    #     call add(__riml_splat_str_vars, __riml_splat_var_{__riml_splat_idx})
+    #     let __riml_splat_idx += 1
+    #   endwhile
+    #   execute 'let s:animalObj = s:AnimalConstructor(' . join(__riml_splat_str_vars, ', ') . ')'
+    #
+    # Basically, mimic Ruby's approach to expanding lists to their
+    # constituent argument parts with '*' in calling context.
+    class SplatsToExecuteInCallingContext < AST_Rewriter
+
+      def match?(node)
+        if SplatNode === node && CallNode === node.parent
+          @splat_node = node
+        end
+      end
+
+      def replace(node)
+        construct_splat_str_vars_node = build_construct_splat_str_vars_node
+        call_node_args =
+          CallNode.new(
+            nil,
+            'join',
+            [
+              GetVariableNode.new(tmp_var_modifier.dup, '__riml_splat_str_vars'),
+              StringNode.new(', ', :s)
+            ]
+          )
+        call_node = node.parent
+        node_to_execute = if AssignNode === call_node.parent
+          assign_node = call_node.parent
+          n = call_node
+          until DefNode === n || n.nil?
+            n = n.parent
+          end
+          # This is necessary because this node is getting put into a new
+          # compiler where it not wrapped in a function context, therefore
+          # variables will be script-local there unless their scope_modifier
+          # is set
+          if n && assign_node.lhs.scope_modifier.nil?
+            if global_scope?
+              assign_node.lhs.scope_modifier = 's:'
+            else
+              assign_node.lhs.scope_modifier = 'l:'
+            end
+          end
+          assign_node
+        else
+          call_node
+        end
+        call_node.arguments.clear
+        compiler = Compiler.new
+        # have to dup node_to_execute here because, if not, its parent will
+        # get reset during this next compilation step
+        output = compiler.compile(Nodes.new([node_to_execute.clone]))
+        execute_string_node = StringNode.new(output.chomp[0..-2], :s)
+        if node_to_execute.instance_of?(CallNode)
+          execute_string_node.value.insert(0, 'call ')
+        end
+        execute_arg = BinaryOperatorNode.new(
+          '.',
+          [
+            execute_string_node,
+            BinaryOperatorNode.new(
+              '.',
+              [
+                call_node_args,
+                StringNode.new(')', :s)
+              ]
+            )
+          ]
+        )
+        execute_node = CallNode.new(nil, 'execute', [execute_arg])
+        establish_parents(execute_node)
+        node.remove
+        node_to_execute.replace_with(construct_splat_str_vars_node)
+        execute_node.parent = construct_splat_str_vars_node.parent
+        construct_splat_str_vars_node.parent.insert_after(construct_splat_str_vars_node, execute_node)
+      end
+
+      private
+
+      def build_construct_splat_str_vars_node
+        nodes = Nodes.new([])
+        splat_list_init = AssignNode.new(
+          '=',
+          GetVariableNode.new(tmp_var_modifier.dup, '__riml_splat_list'),
+          @splat_node.expression
+        )
+        splat_size = AssignNode.new(
+          '=',
+          GetVariableNode.new(tmp_var_modifier.dup, '__riml_splat_size'),
+          CallNode.new(nil, 'len', [GetVariableNode.new(tmp_var_modifier.dup, '__riml_splat_list')])
+        )
+        splat_string_vars_init = AssignNode.new(
+          '=',
+          GetVariableNode.new(tmp_var_modifier.dup, '__riml_splat_str_vars'),
+          ListNode.new([])
+        )
+        splat_list_idx_init = AssignNode.new(
+          '=',
+          GetVariableNode.new(tmp_var_modifier.dup, '__riml_splat_idx'),
+          NumberNode.new('1')
+        )
+        while_loop = WhileNode.new(
+          # condition
+          BinaryOperatorNode.new('<=', [GetVariableNode.new(tmp_var_modifier.dup, '__riml_splat_idx'), GetVariableNode.new(tmp_var_modifier.dup, '__riml_splat_size')]),
+          # body
+          Nodes.new([
+            AssignNode.new(
+              '=',
+              GetCurlyBraceNameNode.new(tmp_var_modifier.dup, CurlyBraceVariable.new([CurlyBracePart.new('__riml_splat_var_'), CurlyBraceVariable.new([CurlyBracePart.new(GetVariableNode.new(tmp_var_modifier.dup, '__riml_splat_idx'))])])),
+              CallNode.new(nil, 'get', [
+                GetVariableNode.new(tmp_var_modifier.dup, '__riml_splat_list'),
+                BinaryOperatorNode.new('-', [
+                  GetVariableNode.new(tmp_var_modifier.dup, '__riml_splat_idx'),
+                  NumberNode.new('1')
+                ])
+              ])
+            ),
+            ExplicitCallNode.new(nil, 'add', [
+              GetVariableNode.new(tmp_var_modifier.dup, '__riml_splat_str_vars'),
+              BinaryOperatorNode.new('.', [StringNode.new('__riml_splat_var_', :s), GetVariableNode.new(tmp_var_modifier.dup, '__riml_splat_idx')])
+            ]),
+            AssignNode.new('+=', GetVariableNode.new(tmp_var_modifier.dup, '__riml_splat_idx'), NumberNode.new('1'))
+          ])
+        )
+        nodes << splat_list_init << splat_size << splat_string_vars_init <<
+          splat_list_idx_init << while_loop
+        establish_parents(nodes)
+        nodes
+      end
+
+      def tmp_var_modifier
+        @tmp_var_modifier ||= begin
+          n = @splat_node
+          while n != nil && !(DefNode === n)
+            n = n.parent
+          end
+          # n is either `nil` or DefNode
+          if n.nil?
+            's:'
+          else
+            'n:'
+          end
+        end
+      end
+
+      def global_scope?
+        tmp_var_modifier == 's:'
+      end
+
+      def local_scope?
+        not global_scope?
+      end
+    end
+
+
     class ObjectInstantiationToCall < AST_Rewriter
       def match?(node)
         ObjectInstantiationNode === node
@@ -1011,7 +1051,7 @@ module Riml
       def replace(node)
         orig_assign = node.dup
         assigns = []
-        while assign_node = (node.respond_to?(:rhs) && node.rhs)
+        while assign_node = (AssignNode === node && node.rhs)
           assigns.unshift([node.lhs, node.rhs])
           node = assign_node
         end