riml 0.3.3 → 0.3.4

data/Rakefile

@@ -1,4 +1,4 @@
-require File.expand_path('../lib/environment', __FILE__)
+require File.expand_path('../lib/riml/environment', __FILE__)
 require 'rake/testtask'
 require 'bundler/setup'
 require 'bundler/gem_tasks'
@@ -22,7 +22,7 @@ task :debug_parser do
 end
 
 def in_libdir
-  Dir.chdir(File.expand_path("../lib", __FILE__)) do
+  Dir.chdir(File.expand_path("../lib/riml", __FILE__)) do
     yield
   end
 end

data/bin/riml

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # vim: syntax=ruby
 
-require File.expand_path("../../lib/environment", __FILE__)
+require File.expand_path("../../lib/riml/environment", __FILE__)
 
 module Riml
   include Environment
@@ -20,6 +20,7 @@ module Riml
       options.check_syntax_files = []
       options.repl = false
       options.vi_readline = false
+      options.allow_undefined_global_classes = DEFAULT_PARSE_OPTIONS[:allow_undefined_global_classes]
       options.readable = DEFAULT_COMPILE_OPTIONS[:readable]
       options.output_dir = DEFAULT_COMPILE_FILES_OPTIONS[:output_dir]
 
@@ -36,7 +37,7 @@ module Riml
           options.stdio = true
         end
 
-        opts.on("-k", "--check FILES", Array, "Checks syntax of file(s). Because Riml is (mostly) compatible with VimL, this can be used to check VimL's syntax as well.") do |filenames|
+        opts.on("-k", "--check FILES", Array, "Checks syntax of file(s). Because Riml is (mostly) compatible with VimL, this can also be used to check VimL syntax.") do |filenames|
           append_filenames_to_list_if_valid(options.check_syntax_files, *filenames)
         end
 
@@ -56,6 +57,10 @@ module Riml
           end
         end
 
+        opts.on("-a", "--allow-undef-global-classes", "Continue compilation when encountering undefined global class(es).") do
+          options.allow_undefined_global_classes = true
+        end
+
         opts.on("-o", "--output-dir DIR", "Output all .vim files in specified directory.") do |dir|
           options.output_dir = dir
         end
@@ -108,7 +113,8 @@ module Riml
       def start
         options = Options.parse(ARGV)
         compile_options = {
-          :readable => options.readable
+          :readable => options.readable,
+          :allow_undefined_global_classes => options.allow_undefined_global_classes
         }
         compile_files_options = compile_options.merge(
           :output_dir => options.output_dir
@@ -124,7 +130,7 @@ module Riml
           # "ok (1 file)" OR "ok (2 files)"
           puts "ok (#{size} file#{'s' if size > 1})"
         elsif options.repl
-          require 'repl'
+          require 'riml/repl'
           Riml::Repl.new(options.vi_readline, compile_options).run
         else
           ARGV.replace ['--help']

data/lib/riml.rb

@@ -1,13 +1,15 @@
 require 'pathname'
 require 'fileutils'
 
-require File.expand_path('../environment', __FILE__)
-require 'nodes'
-require 'lexer'
-require 'parser'
-require 'compiler'
-require 'warning_buffer'
-require 'include_cache'
+require File.expand_path('../riml/environment', __FILE__)
+require 'riml/nodes'
+require 'riml/lexer'
+require 'riml/parser'
+require 'riml/compiler'
+require 'riml/warning_buffer'
+require 'riml/include_cache'
+require 'riml/path_cache'
+require 'riml/rewritten_ast_cache'
 
 module Riml
 
@@ -15,6 +17,11 @@ module Riml
   DEFAULT_COMPILE_FILES_OPTIONS = DEFAULT_COMPILE_OPTIONS.merge(
     :output_dir => nil
   )
+  DEFAULT_PARSE_OPTIONS = { :allow_undefined_global_classes => false }
+
+  EXTRACT_PARSE_OPTIONS   = lambda { |k,_| DEFAULT_PARSE_OPTIONS.keys.include?(k.to_sym) }
+  EXTRACT_COMPILE_OPTIONS = lambda { |k,_| DEFAULT_COMPILE_OPTIONS.keys.include?(k.to_sym) }
+  EXTRACT_COMPILE_FILES_OPTIONS = lambda { |k,_| DEFAULT_COMPILE_FILES_OPTIONS.keys.include?(k.to_sym) }
 
   # lex code (String) into tokens (Array)
   def self.lex(code)
@@ -31,9 +38,12 @@ module Riml
   end
 
   def self.compile(input, options = {})
+    parse_options = options.select(&EXTRACT_PARSE_OPTIONS)
+    compile_options = options.select(&EXTRACT_COMPILE_OPTIONS)
     parser = Parser.new
+    parser.options = DEFAULT_PARSE_OPTIONS.merge(parse_options)
     compiler = Compiler.new
-    compiler.options = DEFAULT_COMPILE_OPTIONS.merge(options)
+    compiler.options = DEFAULT_COMPILE_OPTIONS.merge(compile_options)
     do_compile(input, parser, compiler)
   end
 
@@ -79,10 +89,17 @@ module Riml
     filenames = filenames.dup
     parser, compiler = Parser.new, Compiler.new
 
+    # extract parser and compiler options from last argument, or use default
+    # options
     if filenames.last.is_a?(Hash)
-      compiler.options = DEFAULT_COMPILE_FILES_OPTIONS.merge(filenames.pop)
+      options = filenames.pop
+      compile_options = options.select(&EXTRACT_COMPILE_FILES_OPTIONS)
+      parse_options = options.select(&EXTRACT_PARSE_OPTIONS)
+      compiler.options = DEFAULT_COMPILE_FILES_OPTIONS.merge(compile_options)
+      parser.options = DEFAULT_PARSE_OPTIONS.merge(parse_options)
     else
       compiler.options = DEFAULT_COMPILE_FILES_OPTIONS.dup
+      parser.options = DEFAULT_PARSE_OPTIONS.dup
     end
 
     filenames.uniq!
@@ -93,7 +110,8 @@ module Riml
         to_compile = filenames.shift(4)
         to_compile.each do |fname|
           _parser, _compiler = Parser.new, Compiler.new
-          _compiler.options = compiler.options
+          _compiler.options = compiler.options.dup
+          _parser.options = parser.options.dup
           threads << Thread.new do
             f = File.open(fname)
             # `do_compile` will close file handle
@@ -134,17 +152,15 @@ module Riml
   def self.source_path
     get_path(:source_path)
   end
-
-  def self.source_path=(path)
-    set_path(:source_path, path)
+  def self.source_path=(path, force_cache_bust = false)
+    set_path(:source_path, path, force_cache_bust)
   end
 
   def self.include_path
     get_path(:include_path)
   end
-
-  def self.include_path=(path)
-    set_path(:include_path, path)
+  def self.include_path=(path, force_cache_bust = false)
+    set_path(:include_path, path, force_cache_bust)
   end
 
   def self.warn(warning)
@@ -154,9 +170,20 @@ module Riml
   def self.include_cache
     @include_cache
   end
-  # initialize non-lazily because ||= isn't thread-safe
+  # initialize non-lazily because ||= isn't thread-safe and
+  # this is used across threads
   @include_cache = IncludeCache.new
 
+  def self.path_cache
+    @path_cache
+  end
+  @path_cache = PathCache.new
+
+  def self.rewritten_ast_cache
+    @rewritten_ast_cache
+  end
+  @rewritten_ast_cache = RewrittenASTCache.new
+
   class << self
     attr_accessor :warnings
   end
@@ -175,10 +202,11 @@ module Riml
   def self.warning_buffer
     @warning_buffer
   end
-  # initialize non-lazily because ||= isn't thread-safe
+  # initialize non-lazily because ||= isn't thread-safe and
+  # this is used across threads
   @warning_buffer = WarningBuffer.new
 
-  def self.set_path(name, path)
+  def self.set_path(name, path, force_cache_bust = false)
     return instance_variable_set("@#{name}", nil) if path.nil?
     path = path.split(':') if path.is_a?(String)
     path.each do |dir|
@@ -188,10 +216,17 @@ module Riml
       end
     end
     instance_variable_set("@#{name}", path)
+    cache_files_in_path(path, force_cache_bust)
+    path
   end
   self.source_path  = nil  # eliminate ivar warnings
   self.include_path = nil  # eliminate ivar warnings
 
+  def self.cache_files_in_path(path, force_cache_bust = false)
+    @path_cache[path] = nil if force_cache_bust
+    @path_cache[path] || @path_cache.cache(path)
+  end
+
   def self.get_path(name)
     ivar = instance_variable_get("@#{name}")
     return ivar if ivar
@@ -214,9 +249,9 @@ module Riml
     end
   end
 
-  FILE_HEADER = File.read(File.expand_path("../header.vim", __FILE__)) % VERSION.join('.')
-  INCLUDE_COMMENT_FMT = File.read(File.expand_path("../included.vim", __FILE__))
-  GET_SID_FUNCTION_SRC = File.read(File.expand_path("../get_sid_function.vim", __FILE__))
+  FILE_HEADER = File.read(File.expand_path("../riml/header.vim", __FILE__)) % VERSION.join('.')
+  INCLUDE_COMMENT_FMT = File.read(File.expand_path("../riml/included.vim", __FILE__))
+  GET_SID_FUNCTION_SRC = File.read(File.expand_path("../riml/get_sid_function.vim", __FILE__))
 
   def self.write_file(compiler, output, fname, cmdline_file = true)
     # writing out a file that's compiled from cmdline, output into output_dir
@@ -236,6 +271,8 @@ module Riml
     basename_without_riml_ext = File.basename(fname).sub(/\.riml\Z/i, '')
     FileUtils.mkdir_p(output_dir) unless File.directory?(output_dir)
     full_path = File.join(output_dir, "#{basename_without_riml_ext}.vim")
+    # if a function definition is at the end of a file and the :readable compiler
+    # option is `true`, there will be 2 NL at EOF
     if output[-2..-1] == "\n\n"
       output.chomp!
     end

data/lib/{ast_rewriter.rb → riml/ast_rewriter.rb}

@@ -1,4 +1,5 @@
 require File.expand_path("../constants", __FILE__)
+require File.expand_path("../imported_class", __FILE__)
 require File.expand_path("../class_map", __FILE__)
 require File.expand_path("../walker", __FILE__)
 
@@ -6,12 +7,15 @@ module Riml
   class AST_Rewriter
     include Riml::Constants
 
-    attr_accessor :ast
-    attr_reader   :classes, :rewritten_included_and_sourced_files
+    attr_accessor :ast, :options
+    attr_reader :classes, :rewritten_included_and_sourced_files
 
     def initialize(ast = nil, classes = 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 = {}
@@ -22,10 +26,16 @@ module Riml
     end
 
     def rewrite(filename = nil, included = false)
-      if filename && (rewritten_ast = rewritten_included_and_sourced_files[filename])
-        return rewritten_ast
+      if filename && (rewritten_ast = Riml.rewritten_ast_cache[filename])
+        rewrite_included_and_sourced_files!(filename)
+        rewritten_ast
+      end
+      if @options && @options[:allow_undefined_global_classes] && !@classes.has_global_import?
+        @classes.globbed_imports.unshift(ImportedClass.new('*'))
       end
       establish_parents(ast)
+      class_imports = RegisterImportedClasses.new(ast, classes)
+      class_imports.rewrite_on_match
       class_registry = RegisterDefinedClasses.new(ast, classes)
       class_registry.rewrite_on_match
       rewrite_included_and_sourced_files!(filename)
@@ -76,7 +86,7 @@ module Riml
     def rewrite_included_and_sourced_files!(filename)
       old_ast = ast
       ast.children.each do |node|
-        next unless RimlCommandNode === node
+        next unless RimlFileCommandNode === node
         action = node.name == 'riml_include' ? 'include' : 'source'
 
         node.each_existing_file! do |file, fullpath|
@@ -86,20 +96,49 @@ module Riml
             # IncludeFileLoop/SourceFileLoop
             raise Riml.const_get("#{action.capitalize}FileLoop"), msg
           elsif filename == file
-            raise UserArgumentError, "#{file.inspect} can't include itself"
+            raise UserArgumentError, "#{file.inspect} can't #{action} itself"
           end
           @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, action == 'include')
-          rewritten_included_and_sourced_files[file] = rewritten_ast
+          rewritten_ast = nil
+          watch_for_class_pickup do
+            rewritten_ast = Riml.rewritten_ast_cache.fetch(file) do
+              riml_src = File.read(fullpath)
+              Parser.new.tap { |p| p.options = @options }.
+                parse(riml_src, self, file, action == 'include')
+            end
+          end
+          @rewritten_included_and_sourced_files[file] ||= rewritten_ast
         end
       end
     ensure
       self.ast = old_ast
     end
 
+    def watch_for_class_pickup
+      before_class_names = classes.class_names
+      ast = yield
+      after_class_names = classes.class_names
+      diff_class_names = after_class_names - before_class_names
+      class_diff = diff_class_names.inject({}) do |hash, class_name|
+        hash[class_name] = classes[class_name]
+        hash
+      end
+      # no classes were picked up, it could be that the cache was hit. Let's
+      # register the cached classes for this ast, if there are any
+      if class_diff.empty?
+        real_diff = Riml.rewritten_ast_cache.fetch_classes_registered(ast)
+        return if real_diff.empty?
+        real_diff.each do |k,v|
+          classes[k] = v unless classes.safe_fetch(k)
+        end
+      # new classes were picked up, let's save them with this ast as the key
+      else
+        Riml.rewritten_ast_cache.save_classes_registered(ast, class_diff)
+      end
+    end
+
     def recursive?
       true
     end
@@ -112,7 +151,7 @@ module Riml
       while included_files.any?
         incs = []
         included_files.each do |included_file|
-          if (ast = rewritten_included_and_sourced_files[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]
@@ -139,6 +178,26 @@ module Riml
       ast.nodes.unshift fn
     end
 
+    class RegisterImportedClasses < AST_Rewriter
+      def match?(node)
+        RimlClassCommandNode === node
+      end
+
+      def replace(node)
+        node.class_names_without_modifiers.each do |class_name|
+          # TODO: check for wrong scope modifier
+          imported_class = ImportedClass.new(class_name)
+          if imported_class.globbed?
+            classes.globbed_imports << imported_class
+          else
+            imported_class.instance_variable_set("@registered_state", true)
+            classes["g:#{class_name}"] = imported_class
+          end
+        end
+        node.remove
+      end
+    end
+
     class RegisterDefinedClasses < AST_Rewriter
       def match?(node)
         ClassDefinitionNode === node
@@ -216,6 +275,7 @@ module Riml
         SelfToDictName.new(dict_name).rewrite_on_match(constructor)
         SuperToSuperclassFunction.new(node, classes).rewrite_on_match
         PrivateFunctionCallToPassObjExplicitly.new(node, classes).rewrite_on_match
+        SplatsToExecuteInCallingContext.new(node, classes).rewrite_on_match
 
         constructor.expressions.push(
           ReturnNode.new(GetVariableNode.new(nil, dict_name))
@@ -233,6 +293,150 @@ 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)
@@ -267,6 +471,7 @@ module Riml
           class_node = ast
           class_name = class_node.name
           node.scope_modifier = 's:'
+          node.original_name = node.name
           node.name = "#{class_name}_#{node.name}"
           node.sid = nil
           node.keywords -= ['dict']
@@ -306,7 +511,7 @@ module Riml
 
       class ExtendObjectWithMethods < AST_Rewriter
         def match?(node)
-          DefMethodNode === node
+          node.instance_of?(DefMethodNode)
         end
 
         def replace(node)
@@ -379,10 +584,16 @@ module Riml
         end
 
         def replace(class_node)
-          if class_node.superclass?
+          if class_node.superclass? && !imported_superclass?
             def_node = DefNode.new(
               '!', nil, nil, "initialize", superclass_params, nil, Nodes.new([SuperNode.new([], false)])
             )
+          # has imported superclass and no initialize method. Must create
+          # 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)])
+            )
           else
             def_node = DefNode.new(
               '!', nil, nil, "initialize", [], nil, Nodes.new([])
@@ -396,6 +607,10 @@ module Riml
           classes.superclass(ast.full_name).constructor.parameters
         end
 
+        def imported_superclass?
+          classes.superclass(ast.full_name).imported?
+        end
+
         def recursive?
           false
         end
@@ -458,7 +673,7 @@ module Riml
         end
       end
 
-      # rewrites calls to 'super' in non-initialize function
+      # rewrites calls to 'super' in public/private non-initialize functions
       class SuperToSuperclassFunction < AST_Rewriter
         def match?(node)
           return false unless SuperNode === node
@@ -469,29 +684,55 @@ module Riml
         end
 
         def replace(node)
-          # 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_full_name]
           end
-          if superclass.nil? || !superclass.has_function?(func_scope, superclass_func_name(superclass))
+          superclass_function = superclass.find_function(func_scope, superclass_func_name(superclass))
+          if superclass.nil? || !superclass_function
             raise Riml::UserFunctionNotFoundError,
               "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
-          call_node = CallNode.new(
-            nil,
-            DictGetDotNode.new(
+          node_args = if node.arguments.empty? && !node.with_parens && superclass_function.splat
+            [SplatNode.new('*a:000')]
+          else
+            if @function_node.private_function?
+              node.arguments.unshift GetVariableNode.new(nil, @function_node.parameters.first)
+            end
+            node.arguments
+          end
+          # check if SplatNode is in node_args. If it is, check if the splat
+          # value is equal to splat param. If it is, and we're inside a
+          # 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"
+            end
+            # call s.ClassA_private_func(args)
+            call_node_name = superclass_func_name(superclass)
+          else
+            # call self.ClassA_public_func(args)
+            call_node_name = DictGetDotNode.new(
               GetVariableNode.new(nil, 'self'),
               [superclass_func_name(superclass)]
-            ),
-            node.arguments
+            )
+          end
+          call_node = CallNode.new(
+            nil,
+            call_node_name,
+            node_args
           )
 
           node.replace_with(call_node)
-          add_superclass_func_ref_to_constructor(superclass)
+          # private functions are NOT extended in constructor function
+          unless @function_node.private_function?
+            add_superclass_func_ref_to_constructor(superclass)
+          end
           reestablish_parents(@function_node)
         end