riml 0.2.9 → 0.3.0

data/Gemfile.lock

@@ -1,13 +1,6 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    columnize (0.3.6)
-    debugger (1.6.1)
-      columnize (>= 0.3.1)
-      debugger-linecache (~> 1.2.0)
-      debugger-ruby_core_source (~> 1.2.3)
-    debugger-linecache (1.2.0)
-    debugger-ruby_core_source (1.2.3)
     minitest (2.5.1)
     racc (1.4.9)
     rake (10.0.4)
@@ -16,7 +9,6 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  debugger
   minitest (~> 2.5.1)
   racc
   rake

data/README.md

@@ -171,21 +171,25 @@ Classes
 
 ###Basic Class
 
-    class MyClass                                      function! g:MyClassConstructor(data, otherData, ...)
+                                                       function! s:SID()
+                                                         return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$')
+                                                       endfunction
+
+    class MyClass                                      function! s:MyClassConstructor(data, otherData, ...)
       def initialize(data, otherData, *options)          let myClassObj = {}
         self.data = data                                 let myClassObj.data = a:data
         self.otherData = otherData                       let myClassObj.otherData = a:otherData
         self.options = options                           let myClassObj.options = a:000
-      end                                                let myClassObj.getData = function('g:MyClass_getData')
-                                                         let myClassObj.getOtherData = function('g:MyClass_getOtherData')
+      end                                                let myClassObj.getData = function('<SNR>' . s:SID() . '_s:MyClass_getData')
+                                                         let myClassObj.getOtherData = function('<SNR>' . s:SID() . '_s:MyClass_getOtherData')
       defm getData                                       return myClassObj
         return self.data                               endfunction
       end
-                                                       function! g:MyClass_getdata() dict
+                                                       function! <SID>s:MyClass_getdata() dict
       defm getOtherData                                  return self.data
         return self.otherData                          endfunction
       end
-    end                                                function! g:MyClass_getOtherData() dict
+    end                                                function! <SID>s:MyClass_getOtherData() dict
                                                          return self.otherData
                                                        endfunction
 
@@ -195,27 +199,40 @@ inside a class, use 'def'. To create an instance of this class, simply:
 
     obj = new MyClass('someData', 'someOtherData')
 
+Classes have a default scope modifier of 's:'. That is, they cannot be instantiated
+outside the script in which they are defined. In order to allow them to be instantiated
+in any script file, you must declare the class with the explicit scope modifier of 'g:'.
+For example:
+
+    class g:MyClass
+      ...
+    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
 
-    class Translation                                  function! g:TranslationConstructor(input)
+                                                       function! s:SID()
+                                                         return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$')
+                                                       endfunction
+
+    class Translation                                  function! s:TranslationConstructor(input)
       def initialize(input)                              let translationObj = {}
         self.input = input                               let translationObj.input = a:input
       end                                                return translationObj
     end                                                endfunction
 
-    class FrenchToEnglishTranslation < Translation     function! g:FrenchToEnglishTranslationConstructor(input)
+    class FrenchToEnglishTranslation < Translation     function! s:FrenchToEnglishTranslationConstructor(input)
       defm translate                                     let frenchToEnglishTranslationObj = {}
-        if (self.input == "Bonjour!")                    let translationObj = g:TranslationConstructor(a:input)
+        if (self.input == "Bonjour!")                    let translationObj = s:TranslationConstructor(a:input)
           echo "Hello!"                                  call extend(frenchToEnglishTranslationObj, translationObj)
-        else                                             let frenchToEnglishTranslationObj.translate = function('g:FrenchToEnglishTranslation_translate')
+        else                                             let frenchToEnglishTranslationObj.translate = function('<SNR>' . s:SID() . '_s:FrenchToEnglishTranslation_translate')
           echo "Sorry, I don't know that word."          return frenchToEnglishTranslationObj
         end                                            endfunction
       end
-    end                                                function! g:FrenchToEnglishTranslation_translate() dict
+    end                                                function! <SID>s:FrenchToEnglishTranslation_translate() dict
                                                          if (self.input ==# "Bonjour!")
     translation = new                                      echo "Hello!"
     \ FrenchToEnglishTranslation("Bonjour!")             else
@@ -223,7 +240,7 @@ are optional parameters and get compiled to '...'.
                                                          endif
                                                        endfunction
 
-                                                       let s:translation = g:TranslationConstructor("Bonjour!")
+                                                       let s:translation = s:TranslationConstructor("Bonjour!")
                                                        call s:translation.translate()
     => "Hello!"
 
@@ -234,6 +251,14 @@ 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.
 
+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:
+
+    class g:GlobalClass < ScriptLocalClass
+      ...
+    end
+
 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'
 method on the translation object. Riml can figure out when 'call' is necessary,
@@ -241,7 +266,11 @@ and will add it to the compiled Vimscript.
 
 ###Using 'super'
 
-    class Car                                             function! g:CarConstructor(make, model, color)
+                                                          function! s:SID()
+                                                            return matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$')
+                                                          endfunction
+
+    class Car                                             function! s:CarConstructor(make, model, color)
       def initialize(make, model, color)                    let carObj = {}
         self.make = make                                    let carObj.make = a:make
         self.model = model                                  let carObj.model = a:model
@@ -249,16 +278,16 @@ and will add it to the compiled Vimscript.
       end                                                 endfunction
     end
 
-    class HotRod < Car                                    function! g:HotRodConstructor(make, model, color, topSpeed)
+    class HotRod < Car                                    function! s:HotRodConstructor(make, model, color, topSpeed)
       def initialize(make, model, color, topSpeed)          let hotRodObj = {}
         self.topSpeed = topSpeed                            let hotRodObj.topSpeed = a:topSpeed
-        super(make, model, color)                           let carObj = g:CarConstructor(a:make, a:model, a:color)
+        super(make, model, color)                           let carObj = s:CarConstructor(a:make, a:model, a:color)
       end                                                   call extend(hotRodObj, carObj)
-                                                            let hotRodObj.drive = function('g:HotRod_drive')
+                                                            let hotRodObj.drive = function('<SNR>' . s:SID() . '_s:HotRod_drive')
       defm drive                                            return hotRodObj
         if self.topSpeed > 140                            endfunction
           echo "Ahhhhhhh!"
-        else                                              function! g:HotRod_drive() dict
+        else                                              function! <SID>s:HotRod_drive() dict
           echo "Nice"                                       if self.topSpeed ># 140
         end                                                   echo "Ahhhhhhh!"
       end                                                   else
@@ -266,8 +295,9 @@ and will add it to the compiled Vimscript.
                                                             endif
     newCar = new HotRod("chevy", "mustang", "red", 160)   endfunction
     newCar.drive()
-                                                          let s:newCar = g:HotRodConstructor("chevy", "mustang", "red", 160)
+                                                          let s:newCar = s:HotRodConstructor("chevy", "mustang", "red", 160)
                                                           call s:newCar.drive()
+    => "Ahhhhhhh!"
 
 Use of 'super' is legal only within subclasses. If arguments are given, these arguments are sent
 to the superclass's function of the same name. If no arguments are given and parentheses are omitted,

data/lib/ast_rewriter.rb

@@ -7,24 +7,31 @@ module Riml
     include Riml::Constants
 
     attr_accessor :ast
-    attr_reader   :classes, :rewritten_include_files
+    attr_reader   :classes, :rewritten_included_and_sourced_files
 
     def initialize(ast = nil, classes = nil)
       @ast = ast
       @classes = classes || ClassMap.new
-      @rewritten_include_files = {}
-      # keeps track of which files included which, to prevent infinite loops
-      @included_file_refs = {}
+      # 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] = [] }
     end
 
-    def rewrite(from_file = nil)
-      if from_file
-        if rewritten_ast = rewritten_include_files[from_file]
-          return rewritten_ast
-        end
-        rewrite_included_files!(from_file)
+    def rewrite(filename = nil, included = false)
+      if filename && (rewritten_ast = rewritten_included_and_sourced_files[filename])
+        return rewritten_ast
       end
       establish_parents(ast)
+      class_registry = RegisterDefinedClasses.new(ast, classes)
+      class_registry.rewrite_on_match
+      rewrite_included_and_sourced_files!(filename)
+      if filename && !included && add_SID_function?(filename)
+        add_SID_function!
+      end
       rewriters = [
         StrictEqualsComparisonOperator.new(ast, classes),
         VarEqualsComparisonOperator.new(ast, classes),
@@ -60,30 +67,33 @@ module Riml
       replace node if match?(node)
     end
 
-    # We need to rewrite the included files before anything else. This is in
-    # order to keep track of any classes defined in the included files (and
-    # files included in those, etc...). We keep a cache of rewritten asts
-    # because the 'riml_include'd files are parsed more than once. They're
-    # parsed first before anything else, plus whenever the compiler visits a
-    # 'compile_include' node in order to compile it on the spot.
-    def rewrite_included_files!(from_file)
+    # We need to rewrite the included/sourced files before anything else. This is in
+    # order to keep track of any classes defined in the included and sourced files (and
+    # files included/sourced in those, etc...). We keep a cache of rewritten asts
+    # because the included/sourced files are parsed more than once. They're parsed
+    # first in this step, plus whenever the compiler visits a 'riml_include'/'riml_source'
+    # node in order to compile it on the spot.
+    def rewrite_included_and_sourced_files!(filename)
       old_ast = ast
       ast.children.each do |node|
-        next unless RimlCommandNode === node && node.name == 'riml_include'
+        next unless RimlCommandNode === node
+        action = node.name == 'riml_include' ? 'include' : 'source'
+
         node.each_existing_file! do |file, fullpath|
-          if from_file && @included_file_refs[file] == from_file
-            msg = "#{from_file.inspect} can't include #{file.inspect}, as " \
-                  " #{file.inspect} already included #{from_file.inspect}"
-            raise IncludeFileLoop, msg
-          elsif from_file == file
+          if filename && @included_and_sourced_file_refs[file].include?(filename)
+            msg = "#{filename.inspect} can't #{action} #{file.inspect}, as " \
+                  " #{file.inspect} already included/sourced #{filename.inspect}"
+            # IncludeFileLoop/SourceFileLoop
+            raise Riml.const_get("#{action.capitalize}FileLoop"), msg
+          elsif filename == file
             raise UserArgumentError, "#{file.inspect} can't include itself"
           end
-          @included_file_refs[from_file] = file
+          @included_and_sourced_file_refs[filename] << file
           riml_src = File.read(fullpath)
           # recursively parse included files with this ast_rewriter in order
           # to pick up any classes that are defined there
-          rewritten_ast = Parser.new.parse(riml_src, self, file)
-          rewritten_include_files[file] = rewritten_ast
+          rewritten_ast = Parser.new.parse(riml_src, self, file, action == 'include')
+          rewritten_included_and_sourced_files[file] = rewritten_ast
         end
       end
     ensure
@@ -94,6 +104,53 @@ module Riml
       true
     end
 
+    # Add SID function if this is the main file and it has defined classes, or
+    # if it included other files and any one of those other files defined classes.
+    def add_SID_function?(filename)
+      return true if ast.children.grep(ClassDefinitionNode).any?
+      included_files = @included_and_sourced_file_refs[filename]
+      while included_files.any?
+        incs = []
+        included_files.each do |included_file|
+          if (ast = rewritten_included_and_sourced_files[included_file])
+            return true if ast.children.grep(ClassDefinitionNode).any?
+          end
+          incs.concat @included_and_sourced_file_refs[included_file]
+        end
+        included_files = incs
+      end
+      false
+    end
+
+    # :h <SID>
+    def add_SID_function!
+      fchild = ast.nodes.first
+      return false if DefNode === fchild && fchild.name == 'SID' && fchild.scope_modifier == 's:'
+      fn = DefNode.new('!', nil, 's:', 'SID', [], nil, Nodes.new([
+          ReturnNode.new(CallNode.new(nil, 'matchstr', [
+            CallNode.new(nil, 'expand', [StringNode.new('<sfile>', :s)]),
+            StringNode.new('<SNR>\zs\d\+\ze_SID$', :s)
+          ]
+          ))
+        ])
+      )
+      fn.parent = ast.nodes
+      establish_parents(fn)
+      ast.nodes.unshift fn
+    end
+
+    class RegisterDefinedClasses < AST_Rewriter
+      def match?(node)
+        ClassDefinitionNode === node
+      end
+
+      def replace(node)
+        n = node.dup
+        n.instance_variable_set("@registered_state", true)
+        classes[node.full_name] = n
+      end
+    end
+
     class StrictEqualsComparisonOperator < AST_Rewriter
       def match?(node)
         BinaryOperatorNode === node && node.operator == '==='
@@ -139,12 +196,15 @@ module Riml
       end
 
       def replace(node)
-        classes[node.name] = node
+        classes[node.full_name] = node
 
+        RegisterPrivateFunctions.new(node, classes).rewrite_on_match
+        DefNodeToPrivateFunction.new(node, classes).rewrite_on_match
         InsertInitializeMethod.new(node, classes).rewrite_on_match
         constructor = node.constructor
-        constructor.scope_modifier = 'g:' unless constructor.scope_modifier
         constructor.name = node.constructor_name
+        constructor.original_name = 'initialize'
+        constructor.scope_modifier = node.scope_modifier
         # set up dictionary variable at top of function
         dict_name = node.constructor_obj_name
         constructor.expressions.unshift(
@@ -155,6 +215,7 @@ module Riml
         ExtendObjectWithMethods.new(node, classes).rewrite_on_match
         SelfToDictName.new(dict_name).rewrite_on_match(constructor)
         SuperToSuperclassFunction.new(node, classes).rewrite_on_match
+        PrivateFunctionCallToPassObjExplicitly.new(node, classes).rewrite_on_match
 
         constructor.expressions.push(
           ReturnNode.new(GetVariableNode.new(nil, dict_name))
@@ -162,6 +223,87 @@ module Riml
         reestablish_parents(constructor)
       end
 
+      class RegisterPrivateFunctions < AST_Rewriter
+        def match?(node)
+          node.instance_of?(DefNode) && node.name != 'initialize'
+        end
+
+        def replace(node)
+          ast.private_function_names << node.name
+        end
+      end
+
+      class SelfToObjArgumentInPrivateFunction < AST_Rewriter
+        def initialize(ast, classes, class_node)
+          super(ast, classes)
+          @class_node = class_node
+        end
+
+        def match?(node)
+          return unless GetVariableNode === node && node.scope_modifier == nil && node.name == 'self'
+          return if node.parent.is_a?(DictGetDotNode) && node.parent.parent.is_a?(CallNode) &&
+            (@class_node.private_function_names & node.parent.keys).size == 1
+          # make sure we're not nested in a different function
+          n = node
+          until n.instance_of?(DefNode)
+            n = n.parent
+          end
+          n == ast
+        end
+
+        def replace(node)
+          node.name = @class_node.constructor_obj_name
+          node.scope_modifier = 'a:'
+        end
+      end
+
+      class DefNodeToPrivateFunction < AST_Rewriter
+        def match?(node)
+          return unless node.instance_of?(DefNode) && node.name != 'initialize'
+          node.private_function = true
+        end
+
+        def replace(node)
+          class_node = ast
+          class_name = class_node.name
+          node.scope_modifier = 's:'
+          node.name = "#{class_name}_#{node.name}"
+          node.sid = nil
+          node.keywords -= ['dict']
+          node.parameters.unshift(class_node.constructor_obj_name)
+          # rewrite `self` in function body to a:#{class_name}Obj
+          self_to_obj_argument = SelfToObjArgumentInPrivateFunction.new(node, classes, class_node)
+          self_to_obj_argument.rewrite_on_match
+          reestablish_parents(node)
+        end
+      end
+
+      class PrivateFunctionCallToPassObjExplicitly < AST_Rewriter
+        def match?(node)
+          CallNode === node && DictGetDotNode === node.name && node.name.dict.scope_modifier.nil? &&
+            node.name.dict.name == 'self' && (node.name.keys & ast.private_function_names).size == 1
+        end
+
+        def replace(node)
+          node.scope_modifier = 's:'
+          # find function that I'm in
+          n = node
+          until n.instance_of?(DefNode)
+            n = n.parent
+          end
+          if n.original_name == 'initialize'
+            node.arguments.unshift(GetVariableNode.new(nil, ast.constructor_obj_name))
+          elsif n.private_function
+            node.arguments.unshift(GetVariableNode.new('a:', ast.constructor_obj_name))
+          else
+            node.arguments.unshift(GetVariableNode.new(nil, 'self'))
+          end
+          func_name = node.name.keys.first
+          node.name = "#{ast.name}_#{func_name}"
+          reestablish_parents(node)
+        end
+      end
+
       class ExtendObjectWithMethods < AST_Rewriter
         def match?(node)
           DefMethodNode === node
@@ -177,10 +319,12 @@ module Riml
           node.remove
           def_node.original_name = def_node.name.dup
           def_node.name.insert(0, "#{ast.name}_")
+          def_node.sid = SIDNode.new
           reestablish_parents(def_node)
           extend_obj_with_methods(def_node)
         end
 
+        # Ex: `let dogObj.bark = function('<SNR>' . s:SID() . '_s:Dog_bark')`
         def extend_obj_with_methods(def_node)
           constructor = ast.constructor
           extension =
@@ -190,9 +334,23 @@ module Riml
                 [def_node.original_name]
               ),
               CallNode.new(
-                nil, 'function', [StringNode.new("#{def_node.scope_modifier}#{def_node.name}", :s)]
+                nil, 'function', [
+                  BinaryOperatorNode.new(
+                    '.',
+                    [
+                      BinaryOperatorNode.new(
+                        '.',
+                        [
+                          StringNode.new('<SNR>', :s),
+                          CallNode.new('s:', 'SID', []),
+                        ]
+                      ),
+                      StringNode.new("_s:#{def_node.name}", :s)
+                    ],
+                  )
+                ],
               )
-          )
+            )
           constructor.expressions << extension
           extension.parent = constructor.expressions
         end
@@ -223,11 +381,11 @@ module Riml
         def replace(class_node)
           if class_node.superclass?
             def_node = DefNode.new(
-              '!', nil, "initialize", superclass_params, nil, Nodes.new([SuperNode.new([], false)])
+              '!', nil, nil, "initialize", superclass_params, nil, Nodes.new([SuperNode.new([], false)])
             )
           else
             def_node = DefNode.new(
-              '!', nil, "initialize", [], nil, Nodes.new([])
+              '!', nil, nil, "initialize", [], nil, Nodes.new([])
             )
           end
           class_node.expressions.unshift(def_node)
@@ -235,7 +393,7 @@ module Riml
         end
 
         def superclass_params
-          classes.superclass(ast.name).constructor.parameters
+          classes.superclass(ast.full_name).constructor.parameters
         end
 
         def recursive?
@@ -255,7 +413,13 @@ module Riml
         end
 
         def replace(constructor)
-          superclass = classes.superclass(class_node.name)
+          unless class_node.superclass?
+            # TODO: raise error instead of aborting
+            abort "class #{class_node.full_name.inspect} called super in its " \
+              " initialize function, but it has no superclass."
+          end
+
+          superclass = classes.superclass(class_node.full_name)
           super_constructor = superclass.constructor
 
           set_var_node = AssignNode.new('=', GetVariableNode.new(nil, superclass.constructor_obj_name),
@@ -305,14 +469,15 @@ module Riml
         end
 
         def replace(node)
-          func_scope = @function_node.scope_modifier
-          superclass = classes[ast.superclass_name]
+          # TODO: check if class even has superclass before all this
+          func_scope = 's:'
+          superclass = classes[ast.superclass_full_name]
           while superclass && !superclass.has_function?(func_scope, superclass_func_name(superclass)) && superclass.superclass?
-            superclass = classes[superclass.superclass_name]
+            superclass = classes[superclass.superclass_full_name]
           end
           if superclass.nil? || !superclass.has_function?(func_scope, superclass_func_name(superclass))
             raise Riml::UserFunctionNotFoundError,
-              "super was called in class #{ast.name} in " \
+              "super was called in class #{ast.full_name} in " \
               "function #{@function_node.original_name}, but there are no " \
               "functions with this name in that class's superclass hierarchy."
           end
@@ -342,9 +507,21 @@ module Riml
               [super_func_name]
             ),
             CallNode.new(
-              nil,
-              'function',
-              [StringNode.new("g:#{super_func_name}", :s)]
+              nil, 'function', [
+                BinaryOperatorNode.new(
+                  '.',
+                  [
+                    BinaryOperatorNode.new(
+                      '.',
+                      [
+                        StringNode.new('<SNR>', :s),
+                        CallNode.new('s:', 'SID', []),
+                      ]
+                    ),
+                    StringNode.new("_s:#{super_func_name}", :s)
+                  ],
+                )
+              ],
             )
           )
           ast.constructor.expressions << assign_node
@@ -359,7 +536,9 @@ module Riml
       end
 
       def replace(node)
-        constructor_name = node.call_node.name
+        constructor_name = (node.call_node.scope_modifier ||
+                            ClassDefinitionNode::DEFAULT_SCOPE_MODIFIER) +
+                            node.call_node.name
         class_node = classes[constructor_name]
         call_node = node.call_node
         call_node.name = class_node.constructor_name