riml 0.2.5 → 0.2.6

data/README.md

@@ -1,15 +1,14 @@
 [![Build Status](https://secure.travis-ci.org/luke-gru/riml.png?branch=master)](https://travis-ci.org/luke-gru/riml)
 
-Riml, a relaxed version of Vimscript
+Riml, a relaxed Vimscript
 ====================================
 
-Riml aims to be a superset of VimL that includes some nice features that I
-enjoy in other scripting languages: classes, string interpolation,
+Riml is a subset of Vimscript with some added features, and it compiles to
+plain Vimscript. 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. Also, Riml takes
-some liberties and provides some syntactic sugar for lots of VimL constructs.
-To see how Riml constructs are compiled to VimL, just take a look at this README.
-The left side is Riml, and the right side is the VimL after compilation.
+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
+side is Riml, and the right side is the VimL after compilation.
 
 Variables
 ---------
@@ -51,7 +50,7 @@ much easier to just come up with unique variable names across a scope.
 
 ###Checking for existence
 
-    unless s:callcount?                   if !exists("s:callcount")
+    unless callcount?                     if !exists("s:callcount")
       callcount = 0                        let s:callcount = 0
     end                                   endif
     callcount += 1                        let s:callcount += 1
@@ -64,7 +63,7 @@ In Riml, you can choose to end any block with 'end', or with whatever you used
 to do in Vimscript ('endif', 'endfunction', etc...). Also, 'if' and 'unless' can
 now be used as statement modifiers:
 
-    callcount = 0 unless s:callcount?
+    callcount = 0 unless callcount?
     callcount += 1
     echo "called #{callcount} times"
 
@@ -92,9 +91,9 @@ Heredocs
     Hooray!
     EOS
 
-Riml heredocs must have the ending pattern start at the beginning
-of the line. Interpolating expressions is allowed in heredocs. Compiled
-heredocs always end with a newline.
+Riml heredocs must have the ending pattern ('EOS' in this case) start at the
+beginning of the line. Interpolating expressions is allowed in heredocs.
+Compiled heredocs always end with a newline.
 
 Functions
 ---------
@@ -107,10 +106,10 @@ Functions
 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 a superset of VimL. There are a few exceptions
-where Riml and VimL aren't compatible, and these differences are explained in
-the section 'Incompatibilities with VimL'.
+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
 
@@ -163,8 +162,8 @@ inside a class, use 'def'. To create an instance of this class, simply:
     obj = new MyClass('someData', 'someOtherData')
 
 In this basic example of a class, we see a \*splat variable. This is just a
-convenient way to refer to 'a:000' in a function. Splat variables are optional
-parameters and get compiled to '...'.
+convenient way to refer to 'a:000' in the body of a function. Splat variables
+are optional parameters and get compiled to '...'.
 
 ###Class Inheritance
 
@@ -196,10 +195,10 @@ parameters and get compiled to '...'.
 
 Classes that inherit must have their superclass defined before inheritance takes place. In
 this example, 'Translation' is defined first, which is legal. Since 'Translation'
-has an initialize function and 'FrenchToEnglishTranslation' (referred to now as FET)
-doesn't, FET 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.
+has an initialize function and 'FrenchToEnglishTranslation' doesn't, 'FrenchToEnglishTranslation'
+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 Vimscript's builtin 'call' function for calling the 'translate'
@@ -253,7 +252,7 @@ directory:
 
     $ riml -c example.riml
 
-This will create a new VimL file named 'example.vim'.
+This will create a new VimL file named 'example.vim' in the current directory.
 
 ###riml\_source
 
@@ -275,11 +274,22 @@ In 'awesome.riml', that line will be compiled to:
 This process is recursive, meaning that if 'my\_framework.riml' riml\_source's other
 files, then those files will be compiled as well.
 
-In 'awesome.riml', all the classes that were available by compiling 'my\_framework.riml'
-are now available to it, so we can now subclass classes that were defined either
-in 'my\_framework.riml' itself, or any files that it riml\_source'd either directly
-or indirecty.
+The previous example would only work if 'my\_framework.riml' were in the
+current working directory where the compilation command 'riml -c' was issued.
+In order to tell the compiler where to look for files that are being
+riml\_source'd, you can provide an environment variable or a command-line
+option of colon-separated paths. For example:
 
+    riml -c awesome.riml -S 'first_dir:second_dir'
+
+With this command, the compiler will look for files that are riml\_source'd
+first in ./first\_dir, then in ./second\_dir if not found in first\_dir.
+The same can be achieved by:
+
+    riml -c awesome.riml RIML_SOURCE_PATH='first_dir:second_dir'
+
+Paths can either be relative or absolute. The sourced files that are compiled
+will end up in the same directory in which they were found.
 
 ###riml\_include
 
@@ -296,15 +306,28 @@ Much like riml\_sourcing, the process is recursive. If 'my\_lib.riml' includes f
 are also compiled and will be part of the inclusion. Note that riml\_include does not create a
 new file like riml\_source does.
 
+Like riml\_source, riml\_include looks in a set of ordered paths to find the
+files to include, with the default being the working directory in which the
+compilation command was issued. Here are some examples of commands that set
+the include path:
+
+    riml -c 'main.riml' -I 'lib:helpers:debug'
+
+    riml -c 'plugin_name.riml' RIML_INCLUDE_PATH='lib:modules'
+
+Since riml\_include acts as a sort of preprocessor, it *cannot* be issued
+inside of a conditional, function, or anything dynamic. It must be at the
+top-level (non-nested).
+
 Incompatibilities with VimL
 ---------------------------
 
-Riml aims to be a superset of VimL, therefore any legal VimL should be legal
-Riml as well. Unfortunately, this is not 100% possible as Vim is an old and
-cryptic beast, and trying to create grammar for every possible Vim construct
-would be a nightmare. In practice, however, when I've transformed plain old vim plugins
-to be Riml-compatible, only a couple of ':' needed to be placed in strategic locations
-for it to be valid Riml. This is explained below.
+Riml aims to be as compatible with VimL as possible, therefore any legal VimL
+should be legal Riml as well. Unfortunately, this is not 100% possible as Vim
+is an old and cryptic beast, and trying to create grammar for every possible VimL
+construct would be a nightmare. In practice, however, when I've transformed plain
+old VimL plugins to be Riml-compatible, only a couple of ':' needed to be placed
+in strategic locations for it to be valid Riml. This is explained below.
 
 ###Ex-literals
 
@@ -336,7 +359,7 @@ needs to be an ex-literal in Riml.
 
 Note that, like 'echo' which isn't a builtin function (:h functions) but is still legal
 Riml, 'execute' is also allowed as it takes a string. This is extremely useful, as we can
-now use execute with a string that allows interpolation.
+now use execute with a string that allows interpolation!
 
 Imagine having to write a grammar rule for the following:
 

data/Rakefile

@@ -11,7 +11,16 @@ end
 
 desc 'recreate lib/parser.rb from lib/grammar.y using racc'
 task :parser do
+  sh_in_libdir 'racc -o parser.rb grammar.y'
+end
+
+desc 'recreate lib/parser.rb with debug info from lib/grammar.y using racc'
+task :debug_parser do
+  sh_in_libdir 'racc --verbose -o parser.rb grammar.y'
+end
+
+def sh_in_libdir(cmd)
   Dir.chdir(File.expand_path("../lib", __FILE__)) do
-    sh 'racc -o parser.rb grammar.y'
+    sh cmd
   end
 end

data/bin/riml

@@ -84,7 +84,7 @@ module Riml
         if File.exists?(expanded)
           list << fname
         else
-          raise UserArgumentError, "Couldn't find file #{fname.inspect}."
+          abort "Couldn't find file #{fname.inspect}."
         end
       end
     end

data/lib/ast_rewriter.rb

@@ -31,7 +31,8 @@ module Riml
         ClassDefinitionToFunctions.new(ast, classes),
         ObjectInstantiationToCall.new(ast, classes),
         CallToExplicitCall.new(ast, classes),
-        DefaultParamToIfNode.new(ast, classes)
+        DefaultParamToIfNode.new(ast, classes),
+        DeserializeVarAssignment.new(ast, classes)
       ]
       rewriters.each do |rewriter|
         rewriter.rewrite_on_match
@@ -51,7 +52,7 @@ module Riml
     end
 
     def rewrite_on_match(node = ast)
-      Walker.walk_node(node, method(:do_rewrite_on_match), lambda {|_| repeatable?})
+      Walker.walk_node(node, method(:do_rewrite_on_match), lambda { |_| recursive? })
     end
 
     def do_rewrite_on_match(node)
@@ -88,7 +89,7 @@ module Riml
       self.ast = old_ast
     end
 
-    def repeatable?
+    def recursive?
       true
     end
 
@@ -236,7 +237,7 @@ module Riml
           classes.superclass(ast.name).constructor.parameters
         end
 
-        def repeatable?
+        def recursive?
           false
         end
       end
@@ -287,7 +288,7 @@ module Riml
           end
         end
 
-        def repeatable?
+        def recursive?
           false
         end
       end
@@ -421,5 +422,30 @@ module Riml
       end
     end
 
+    class DeserializeVarAssignment < AST_Rewriter
+      def match?(node)
+        AssignNode === node && AssignNode === node.rhs && node.operator == '='
+      end
+
+      def replace(node)
+        orig_assign = node.dup
+        assigns = []
+        while assign_node = (node.respond_to?(:rhs) && node.rhs)
+          assigns.unshift([node.lhs, node.rhs])
+          node = assign_node
+        end
+        assigns = assigns[0..0].concat(assigns[1..-1].map! { |(lhs, rhs)| [lhs, rhs.lhs] })
+
+        assigns.map! do |(lhs, rhs)|
+          AssignNode.new('=', lhs, rhs)
+        end
+
+        new_assigns = Nodes.new(assigns)
+        new_assigns.parent = orig_assign.parent
+        orig_assign.replace_with(new_assigns)
+        establish_parents(new_assigns)
+      end
+    end
+
   end
 end

data/lib/compiler.rb

@@ -8,16 +8,15 @@ module Riml
     # Base abstract visitor
     class Visitor
       attr_writer :propagate_up_tree
-      attr_reader :value
 
       def initialize(options={})
         @propagate_up_tree = options[:propagate_up_tree]
       end
 
       def visit(node)
-        @value = compile(node)
-        @value << "\n" if node.force_newline and @value[-1] != "\n"
-        propagate_up_tree(node, @value)
+        output = compile(node)
+        output << "\n" if node.force_newline and output[-1] != "\n"
+        propagate_up_tree(node, output)
       end
 
       def propagate_up_tree(node, output)
@@ -41,7 +40,7 @@ module Riml
         node.body.accept(NodesVisitor.new(:propagate_up_tree => false))
 
         node.body.compiled_output.each_line do |line|
-          outdent = line =~ /\A(\s*)(else\s*|elseif .*)$/
+          outdent = line =~ /\A(\s*)(else\s*|elseif .+)$/
           if outdent && node.non_nested?
             node.compiled_output << node.outdent + line
           else
@@ -265,22 +264,15 @@ module Riml
 
     class AssignNodeVisitor < ScopedVisitor
       def compile(node)
-        first_shadow = nil
-
+        lhs = visit_lhs(node)
+        rhs = visit_rhs(node)
         if GetVariableNode === node.lhs && node.scope && (func = node.scope.function)
           if func.argument_variable_names.include?(node.lhs.full_name)
             if !func.shadowed_argument_variable_names.include?(node.lhs.full_name)
-              first_shadow = true
+              func.shadowed_argument_variable_names << node.lhs.full_name
             end
           end
         end
-
-        lhs = visit_lhs(node)
-        rhs = visit_rhs(node)
-        if first_shadow
-          func.shadowed_argument_variable_names << node.lhs.full_name
-        end
-
         node.compiled_output = "#{lhs}#{rhs}"
         node.compiled_output = "unlet! #{node.lhs.compiled_output}" if node.rhs.compiled_output == 'nil'
         node.force_newline = true
@@ -298,6 +290,16 @@ module Riml
       end
     end
 
+    class MultiAssignNodeVisitor < Visitor
+      def compile(node)
+        node.assigns.each do |assign|
+          assign.force_newline = true
+          assign.accept(visitor_for_node(assign))
+        end
+        node.compiled_output
+      end
+    end
+
     # scope_modifier, name
     class GetVariableNodeVisitor < ScopedVisitor
       def compile(node)
@@ -530,7 +532,8 @@ module Riml
                node.descendant_of_operator_node? ||
                node.descendant_of_wrap_in_parens_node? ||
                node.descendant_of_sublist_node? ||
-               node.descendant_of_dict_get_dot_node?
+               node.descendant_of_dict_get_dot_node? ||
+               node.descendant_of_dictionary_node?
           node.force_newline = true
         end
       end

data/lib/grammar.y

@@ -37,60 +37,60 @@ preclow
 rule
 
   Root:
-    /* nothing */                         { result = Riml::Nodes.new([]) }
-  | Expressions                           { result = val[0] }
+    /* nothing */                        { result = Riml::Nodes.new([]) }
+  | Statements                           { result = val[0] }
   ;
 
   # any list of expressions
-  Expressions:
-    AnyExpression                         { result = Riml::Nodes.new([ val[0] ]) }
-  | Expressions Terminator AnyExpression  { result = val[0] << val[2] }
-  | Expressions Terminator                { result = val[0] }
-  | Terminator                            { result = Riml::Nodes.new([]) }
-  | Terminator Expressions                { result = Riml::Nodes.new(val[1]) }
+  Statements:
+    Statement                            { result = Riml::Nodes.new([ val[0] ]) }
+  | Statements Terminator Statement      { result = val[0] << val[2] }
+  | Statements Terminator                { result = val[0] }
+  | Terminator                           { result = Riml::Nodes.new([]) }
+  | Terminator Statements                { result = Riml::Nodes.new(val[1]) }
   ;
 
   # All types of expressions in Riml
-  AnyExpression:
+  Statement:
     ExplicitCall                          { result = val[0] }
   | Def                                   { result = val[0] }
   | Return                                { result = val[0] }
   | UnletVariable                         { result = val[0] }
   | ExLiteral                             { result = val[0] }
-  | If                                    { result = val[0] }
-  | Unless                                { result = val[0] }
   | For                                   { result = val[0] }
   | While                                 { result = val[0] }
   | Until                                 { result = val[0] }
   | Try                                   { result = val[0] }
   | ClassDefinition                       { result = val[0] }
-  | Super                                 { result = val[0] }
   | LoopKeyword                           { result = val[0] }
   | EndScript                             { result = val[0] }
-  | ValueExpression                       { result = val[0] }
   | RimlCommand                           { result = val[0] }
+  | MultiAssign                           { result = val[0] }
+  | If                                    { result = val[0] }
+  | Unless                                { result = val[0] }
+  | Expression                            { result = val[0] }
   ;
 
-  # Expressions that evaluate to a value
-  ValueExpression:
-    ValueExpressionWithoutDictLiteral     { result = val[0] }
+  Expression:
+    ExpressionWithoutDictLiteral          { result = val[0] }
   | Dictionary                            { result = val[0] }
   | Dictionary DictGetWithDotLiteral      { result = Riml::DictGetDotNode.new(val[0], val[1]) }
   | BinaryOperator                        { result = val[0] }
   | Ternary                               { result = val[0] }
-  | '(' ValueExpression ')'               { result = Riml::WrapInParensNode.new(val[1]) }
+  | Assign                                { result = val[0] }
+  | Super                                 { result = val[0] }
+  | '(' Expression ')'                    { result = Riml::WrapInParensNode.new(val[1]) }
   ;
 
-  ValueExpressionWithoutDictLiteral:
+  ExpressionWithoutDictLiteral:
     UnaryOperator                         { result = val[0] }
-  | Assign                                { result = val[0] }
   | DictGet                               { result = val[0] }
   | ListOrDictGet                         { result = val[0] }
   | AllVariableRetrieval                  { result = val[0] }
   | LiteralWithoutDictLiteral             { result = val[0] }
   | Call                                  { result = val[0] }
   | ObjectInstantiation                   { result = val[0] }
-  | '(' ValueExpressionWithoutDictLiteral ')'               { result = Riml::WrapInParensNode.new(val[1]) }
+  | '(' ExpressionWithoutDictLiteral ')'               { result = Riml::WrapInParensNode.new(val[1]) }
   ;
 
   # for inside curly-brace variable names
@@ -144,7 +144,7 @@ rule
   ;
 
   ListUnpack:
-    '[' ListItems ';' ValueExpression ']' { result = Riml::ListUnpackNode.new(val[1] << val[3]) }
+    '[' ListItems ';' Expression ']' { result = Riml::ListUnpackNode.new(val[1] << val[3]) }
   ;
 
   ListLiteral:
@@ -154,8 +154,8 @@ rule
 
   ListItems:
     /* nothing */                         { result = [] }
-  | ValueExpression                       { result = [val[0]] }
-  | ListItems ',' ValueExpression         { result = val[0] << val[2] }
+  | Expression                       { result = [val[0]] }
+  | ListItems ',' Expression         { result = val[0] << val[2] }
   ;
 
   Dictionary:
@@ -177,37 +177,41 @@ rule
 
   # [key, value]
   DictItem:
-    ValueExpression ':' ValueExpression                   { result = [val[0], val[2]] }
+    Expression ':' Expression                   { result = [val[0], val[2]] }
   ;
 
   DictGet:
     AllVariableRetrieval DictGetWithDot          { result = Riml::DictGetDotNode.new(val[0], val[1]) }
   | ListOrDictGet DictGetWithDot                 { result = Riml::DictGetDotNode.new(val[0], val[1]) }
   | Call DictGetWithDot                          { result = Riml::DictGetDotNode.new(val[0], val[1]) }
-  | '(' ValueExpression ')' DictGetWithDot       { result = Riml::DictGetDotNode.new(Riml::WrapInParensNode.new(val[1]), val[3]) }
+  | '(' Expression ')' DictGetWithDot       { result = Riml::DictGetDotNode.new(Riml::WrapInParensNode.new(val[1]), val[3]) }
   ;
 
   ListOrDictGet:
-    ValueExpressionWithoutDictLiteral ListOrDictGetWithBrackets  { result = Riml::ListOrDictGetNode.new(val[0], val[1]) }
-  | '(' ValueExpression ')' ListOrDictGetWithBrackets            { result = Riml::ListOrDictGetNode.new(Riml::WrapInParensNode.new(val[1]), val[3]) }
+    ExpressionWithoutDictLiteral ListOrDictGetWithBrackets  { result = Riml::ListOrDictGetNode.new(val[0], val[1]) }
+  | '(' Expression ')' ListOrDictGetWithBrackets            { result = Riml::ListOrDictGetNode.new(Riml::WrapInParensNode.new(val[1]), val[3]) }
+  ;
+
+  ListOrDictGetAssign:
+    ExpressionWithoutDictLiteral ListOrDictGetWithBrackets  { result = Riml::ListOrDictGetNode.new(val[0], val[1]) }
   ;
 
   ListOrDictGetWithBrackets:
-    '['  ValueExpression ']'                          { result = [val[1]] }
-  | '['  SubList    ']'                               { result = [val[1]] }
-  | ListOrDictGetWithBrackets '[' ValueExpression ']' { result = val[0] << val[2] }
-  | ListOrDictGetWithBrackets '[' SubList    ']'      { result = val[0] << val[2] }
+    '['  Expression ']'                           { result = [val[1]] }
+  | '['  SubList    ']'                           { result = [val[1]] }
+  | ListOrDictGetWithBrackets '[' Expression ']'  { result = val[0] << val[2] }
+  | ListOrDictGetWithBrackets '[' SubList    ']'  { result = val[0] << val[2] }
   ;
 
   SubList:
-    ValueExpression ':' ValueExpression          { result = Riml::SublistNode.new([val[0], Riml::LiteralNode.new(' : '), val[2]]) }
-  | ValueExpression ':'                          { result = Riml::SublistNode.new([val[0], Riml::LiteralNode.new(' :')]) }
-  | ':' ValueExpression                          { result = Riml::SublistNode.new([Riml::LiteralNode.new(': '), val[1]]) }
-  | ':'                                          { result = Riml::SublistNode.new([Riml::LiteralNode.new(':')]) }
+    Expression ':' Expression          { result = Riml::SublistNode.new([val[0], Riml::LiteralNode.new(' : '), val[2]]) }
+  | Expression ':'                     { result = Riml::SublistNode.new([val[0], Riml::LiteralNode.new(' :')]) }
+  | ':' Expression                     { result = Riml::SublistNode.new([Riml::LiteralNode.new(': '), val[1]]) }
+  | ':'                                { result = Riml::SublistNode.new([Riml::LiteralNode.new(':')]) }
   ;
 
   DictGetWithDot:
-    DICT_VAL                        { result = [val[0]]}
+    DICT_VAL                        { result = [val[0]] }
   | DictGetWithDot DICT_VAL         { result = val[0] << val[1] }
   ;
 
@@ -220,10 +224,15 @@ rule
     Scope DefCallIdentifier '(' ArgList ')'       { result = Riml::CallNode.new(val[0], val[1], val[3]) }
   | DictGet '(' ArgList ')'                       { result = Riml::CallNode.new(nil, val[0], val[2]) }
   | BUILTIN_COMMAND '(' ArgList ')'               { result = Riml::CallNode.new(nil, val[0], val[2]) }
-  | BUILTIN_COMMAND ArgList                       { result = Riml::CallNode.new(nil, val[0], val[1]) }
+  | BUILTIN_COMMAND ArgListWithoutNothing         { result = Riml::CallNode.new(nil, val[0], val[1]) }
+  | BUILTIN_COMMAND NEWLINE                       { result = Riml::CallNode.new(nil, val[0], []) }
   | CALL '(' ArgList ')'                          { result = Riml::ExplicitCallNode.new(nil, nil, val[2]) }
   ;
 
+  ObjectInstantiationCall:
+    Scope DefCallIdentifier '(' ArgList ')'       { result = Riml::CallNode.new(val[0], val[1], val[3]) }
+  ;
+
   RimlCommand:
     RIML_COMMAND '(' ArgList ')'                  { result = Riml::RimlCommandNode.new(nil, val[0], val[2]) }
   | RIML_COMMAND ArgList                          { result = Riml::RimlCommandNode.new(nil, val[0], val[1]) }
@@ -241,64 +250,68 @@ rule
 
   ArgList:
     /* nothing */                         { result = [] }
-  | ValueExpression                       { result = val }
-  | ArgList "," ValueExpression           { result = val[0] << val[2] }
+  | ArgListWithoutNothing                 { result = val[0] }
+  ;
+
+  ArgListWithoutNothing:
+    Expression                               { result = val }
+  | ArgListWithoutNothing "," Expression     { result = val[0] << val[2] }
   ;
 
   BinaryOperator:
-    ValueExpression '||' ValueExpression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '&&' ValueExpression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+    Expression '||' Expression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '&&' Expression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | ValueExpression '==' ValueExpression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '==#' ValueExpression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '==?' ValueExpression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '==' Expression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '==#' Expression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '==?' Expression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
   # added by riml
-  | ValueExpression '===' ValueExpression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '===' Expression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | ValueExpression '!=' ValueExpression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '!=#' ValueExpression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '!=?' ValueExpression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '!=' Expression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '!=#' Expression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '!=?' Expression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | ValueExpression '=~' ValueExpression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '=~#' ValueExpression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '=~?' ValueExpression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '=~' Expression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '=~#' Expression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '=~?' Expression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | ValueExpression '!~' ValueExpression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '!~#' ValueExpression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '!~?' ValueExpression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '!~' Expression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '!~#' Expression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '!~?' Expression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | ValueExpression '>' ValueExpression             { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '>#' ValueExpression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '>?' ValueExpression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '>' Expression             { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '>#' Expression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '>?' Expression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | ValueExpression '>=' ValueExpression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '>=#' ValueExpression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '>=?' ValueExpression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '>=' Expression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '>=#' Expression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '>=?' Expression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | ValueExpression '<' ValueExpression             { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '<#' ValueExpression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '<?' ValueExpression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '<' Expression             { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '<#' Expression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '<?' Expression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | ValueExpression '<=' ValueExpression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '<=#' ValueExpression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '<=?' ValueExpression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '<=' Expression            { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '<=#' Expression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '<=?' Expression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | ValueExpression '+' ValueExpression             { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '-' ValueExpression             { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '*' ValueExpression             { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '/' ValueExpression             { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '.' ValueExpression             { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression '%' ValueExpression             { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '+' Expression             { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '-' Expression             { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '*' Expression             { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '/' Expression             { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '.' Expression             { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression '%' Expression             { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
 
-  | ValueExpression IS    ValueExpression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
-  | ValueExpression ISNOT ValueExpression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression IS    Expression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
+  | Expression ISNOT Expression           { result = Riml::BinaryOperatorNode.new(val[1], [val[0], val[2]]) }
   ;
 
   UnaryOperator:
-    '!' ValueExpression                        { result = Riml::UnaryOperatorNode.new(val[0], val[1]) }
-  | '+' ValueExpression                        { result = Riml::UnaryOperatorNode.new(val[0], val[1]) }
-  | '-' ValueExpression                        { result = Riml::UnaryOperatorNode.new(val[0], val[1]) }
+    '!' Expression                        { result = Riml::UnaryOperatorNode.new(val[0], [val[1]]) }
+  | '+' Expression                        { result = Riml::UnaryOperatorNode.new(val[0], [val[1]]) }
+  | '-' Expression                        { result = Riml::UnaryOperatorNode.new(val[0], [val[1]]) }
   ;
 
   # ['=', LHS, RHS]
@@ -307,12 +320,17 @@ rule
   | AssignExpression                           { result = Riml::AssignNode.new(val[0][0], val[0][1], val[0][2]) }
   ;
 
+  MultiAssign:
+    Assign ',' Assign                          { result = Riml::MultiAssignNode.new([val[0], val[2]]) }
+  | MultiAssign ',' Assign                     { val[0].assigns << val[2]; result = val[0] }
+  ;
+
   # ['=', AssignLHS, Expression]
   AssignExpression:
-    AssignLHS '='  ValueExpression             { result = [val[1], val[0], val[2]] }
-  | AssignLHS '+=' ValueExpression             { result = [val[1], val[0], val[2]] }
-  | AssignLHS '-=' ValueExpression             { result = [val[1], val[0], val[2]] }
-  | AssignLHS '.=' ValueExpression             { result = [val[1], val[0], val[2]] }
+    AssignLHS '='  Expression             { result = [val[1], val[0], val[2]] }
+  | AssignLHS '+=' Expression             { result = [val[1], val[0], val[2]] }
+  | AssignLHS '-=' Expression             { result = [val[1], val[0], val[2]] }
+  | AssignLHS '.=' Expression             { result = [val[1], val[0], val[2]] }
   ;
 
   AssignLHS:
@@ -320,13 +338,13 @@ rule
   | List                                       { result = val[0] }
   | ListUnpack                                 { result = val[0] }
   | DictGet                                    { result = val[0] }
-  | ListOrDictGet                              { result = val[0] }
+  | ListOrDictGetAssign                        { result = val[0] }
   ;
 
   # retrieving the value of a variable
   VariableRetrieval:
-    Scope IDENTIFIER                           { result = Riml::GetVariableNode.new(val[0], val[1]) }
-  | SPECIAL_VAR_PREFIX IDENTIFIER              { result = Riml::GetSpecialVariableNode.new(val[0], val[1]) }
+    Scope IDENTIFIER                               { result = Riml::GetVariableNode.new(val[0], val[1]) }
+  | SPECIAL_VAR_PREFIX IDENTIFIER                  { result = Riml::GetSpecialVariableNode.new(val[0], val[1]) }
   | ScopeModifierLiteral ListOrDictGetWithBrackets { result = Riml::GetVariableByScopeAndDictNameNode.new(val[0], val[1]) }
   ;
 
@@ -391,12 +409,18 @@ rule
   ;
 
   DefaultParam:
-    IDENTIFIER '=' ValueExpression        { result = Riml::DefaultParamNode.new(val[0], val[2]) }
+    IDENTIFIER '=' Expression        { result = Riml::DefaultParamNode.new(val[0], val[2]) }
   ;
 
   Return:
-    RETURN ValueExpression                { result = Riml::ReturnNode.new(val[1]) }
-  | RETURN                                { result = Riml::ReturnNode.new(nil) }
+    RETURN Returnable                        { result = Riml::ReturnNode.new(val[1]) }
+  | RETURN Returnable IF Expression          { result = Riml::IfNode.new(val[3], Nodes.new([ReturnNode.new(val[1])])) }
+  | RETURN Returnable UNLESS Expression      { result = Riml::UnlessNode.new(val[3], Nodes.new([ReturnNode.new(val[1])])) }
+  ;
+
+  Returnable:
+    /* nothing */     { result = nil }
+  | Expression        { result = val[0] }
   ;
 
   EndScript:
@@ -405,23 +429,23 @@ rule
 
   # [expression, expressions]
   If:
-    IF ValueExpression IfBlock END                    { result = Riml::IfNode.new(val[1], val[2]) }
-  | IF ValueExpression THEN ValueExpression END       { result = Riml::IfNode.new(val[1], Riml::Nodes.new([val[3]])) }
-  | AnyExpression IF ValueExpression                  { result = Riml::IfNode.new(val[2], Riml::Nodes.new([val[0]])) }
+    IF Expression IfBlock END               { result = Riml::IfNode.new(val[1], val[2]) }
+  | IF Expression THEN Expression END       { result = Riml::IfNode.new(val[1], Riml::Nodes.new([val[3]])) }
+  | Expression IF Expression                { result = Riml::IfNode.new(val[2], Riml::Nodes.new([val[0]])) }
   ;
 
   Unless:
-    UNLESS ValueExpression IfBlock END                { result = Riml::UnlessNode.new(val[1], val[2]) }
-  | UNLESS ValueExpression THEN ValueExpression END   { result = Riml::UnlessNode.new(val[1], Riml::Nodes.new([val[3]])) }
-  | ValueExpression UNLESS ValueExpression            { result = Riml::UnlessNode.new(val[2], Riml::Nodes.new([val[0]])) }
+    UNLESS Expression IfBlock END           { result = Riml::UnlessNode.new(val[1], val[2]) }
+  | UNLESS Expression THEN Expression END   { result = Riml::UnlessNode.new(val[1], Riml::Nodes.new([val[3]])) }
+  | Expression UNLESS Expression            { result = Riml::UnlessNode.new(val[2], Riml::Nodes.new([val[0]])) }
   ;
 
   Ternary:
-    ValueExpression '?' ValueExpression ':' ValueExpression   { result = Riml::TernaryOperatorNode.new([val[0], val[2], val[4]]) }
+    Expression '?' Expression ':' Expression   { result = Riml::TernaryOperatorNode.new([val[0], val[2], val[4]]) }
   ;
 
   While:
-    WHILE ValueExpression Block END                 { result = Riml::WhileNode.new(val[1], val[2]) }
+    WHILE Expression Block END                 { result = Riml::WhileNode.new(val[1], val[2]) }
   ;
 
   LoopKeyword:
@@ -430,13 +454,13 @@ rule
   ;
 
   Until:
-    UNTIL ValueExpression Block END                 { result = Riml::UntilNode.new(val[1], val[2]) }
+    UNTIL Expression Block END                 { result = Riml::UntilNode.new(val[1], val[2]) }
   ;
 
   For:
-    FOR IDENTIFIER IN ValueExpression Block END     { result = Riml::ForNode.new(val[1], val[3], val[4]) }
-  | FOR List IN ValueExpression Block END           { result = Riml::ForNode.new(val[1], val[3], val[4]) }
-  | FOR ListUnpack IN ValueExpression Block END     { result = Riml::ForNode.new(val[1], val[3], val[4]) }
+    FOR IDENTIFIER IN Expression Block END     { result = Riml::ForNode.new(val[1], val[3], val[4]) }
+  | FOR List IN Expression Block END           { result = Riml::ForNode.new(val[1], val[3], val[4]) }
+  | FOR ListUnpack IN Expression Block END     { result = Riml::ForNode.new(val[1], val[3], val[4]) }
   ;
 
   Try:
@@ -457,24 +481,24 @@ rule
   # expressions list could contain an ElseNode, which contains expressions
   # itself
   Block:
-    NEWLINE Expressions                        { result = val[1] }
-  | NEWLINE                                    { result = Riml::Nodes.new([]) }
+    NEWLINE Statements                        { result = val[1] }
+  | NEWLINE                                   { result = Riml::Nodes.new([]) }
   ;
 
   IfBlock:
-    Block                                      { result = val[0] }
-  | NEWLINE Expressions ElseBlock              { result = val[1] << val[2] }
-  | NEWLINE Expressions ElseifBlock            { result = val[1] << val[2] }
-  | NEWLINE Expressions ElseifBlock ElseBlock  { result = val[1] << val[2] << val[3] }
+    Block                                     { result = val[0] }
+  | NEWLINE Statements ElseBlock              { result = val[1] << val[2] }
+  | NEWLINE Statements ElseifBlock            { result = val[1] << val[2] }
+  | NEWLINE Statements ElseifBlock ElseBlock  { result = val[1] << val[2] << val[3] }
   ;
 
   ElseBlock:
-    ELSE NEWLINE Expressions                   { result = Riml::ElseNode.new(val[2]) }
+    ELSE NEWLINE Statements                   { result = Riml::ElseNode.new(val[2]) }
   ;
 
   ElseifBlock:
-    ELSEIF ValueExpression NEWLINE Expressions                   { result = Riml::Nodes.new([Riml::ElseifNode.new(val[1], val[3])]) }
-  | ElseifBlock ELSEIF ValueExpression NEWLINE Expressions       { result = val[0] << Riml::ElseifNode.new(val[2], val[4]) }
+    ELSEIF Expression NEWLINE Statements                   { result = Riml::Nodes.new([Riml::ElseifNode.new(val[1], val[3])]) }
+  | ElseifBlock ELSEIF Expression NEWLINE Statements       { result = val[0] << Riml::ElseifNode.new(val[2], val[4]) }
   ;
 
   ClassDefinition:
@@ -483,7 +507,7 @@ rule
   ;
 
   ObjectInstantiation:
-    NEW Call                  { result = Riml::ObjectInstantiationNode.new(val[1]) }
+    NEW ObjectInstantiationCall                  { result = Riml::ObjectInstantiationNode.new(val[1]) }
   ;
 
   Super:
@@ -518,7 +542,7 @@ end
       ast = do_parse
     rescue Racc::ParseError => e
       raise unless @lexer
-      raise Riml::ParseError,  "on line #{@lexer.lineno}: #{e.message}"
+      raise Riml::ParseError, "on line #{@lexer.lineno}: #{e.message}"
     end
 
     @ast_rewriter ||= ast_rewriter