arg_scanner 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d7016d5a2dddb4f8fd0be218fa11d5e1b65addeb
-  data.tar.gz: c7b233ada70e04c77b73f4b179cda89815f6f16b
+SHA256:
+  metadata.gz: 630a4491a80316eccf60cecf3306b8a9efe9344d8604e552a39a8a2fd1616790
+  data.tar.gz: 4365cc9d2dfe5a347423dd73c810d60957fec46bd092acda0e3cad08d358a1eb
 SHA512:
-  metadata.gz: c049b2d855fc27e37ff6feb1edad6713644d3955ce6780dc2b052ace6eea1c9afe2b010441106d437a568a52acb7ead358d0565648c85bb5def13ce67e82bf6a
-  data.tar.gz: bd3b07970807bff87c370be1fbc14acd9042a2e42090769056e6f7782ef0c02dc36f13375f5284350534bbfa6234f61871bb12643c4a9c9e71c57e3c0772de56
+  metadata.gz: 9cbfb9b78a501993d0fc8f42777cda5976e7c4d9dcfe79242991324371ed173baba0fb6f8f1f7238697996ffa27ddc0f623c83e5566bb56c5e439aef3eab69a5
+  data.tar.gz: c3cc36ef3faa5c9c8e09bcc91b00ca1743d6a9ab2d3201f8bcbeb8350f7ffe5076e65f5024150ba1e5805eb3e57ba9b3efe16cbf0a898633706d72f56411cd13

data/README.md

@@ -9,8 +9,13 @@ deliver the following information:
 This information can be used then to calculate and use type contracts
 for the analysed methods.
 
-## Installation
+## Requirements
+
+##### libglib2.0-dev
 
+On Ubuntu run: ` $ sudo apt install libglib2.0-dev` 
+
+## Installation
 
 `arg_scanner` is meant to be used as a binary to run any other ruby executable
 manually so including it in the `Gemfile` is not necessary.

data/bin/arg-scanner

@@ -14,25 +14,12 @@ option_parser = OptionParser.new do |opts|
   EOB
 
   opts.separator "Options:"
-  opts.on("-r", "--root=[ROOT]", String, "local project root(s) to distinguish from library sources (path1[:pathn]*)") do |paths|
-    options.project_roots = paths.split ':' if paths
-  end
-  opts.on("--local=[VERSION]", Integer,
-          "local source treatment: mark as fake gem with given VERSION, default: 0") do |local|
-    options.local_version = local.to_s
-  end
-  opts.on("--no-local", "local source treatment: ignore, do not send data from local sources") do
-    options.no_local = true
-  end
   opts.on("--type-tracker", "enable type tracker") do
     options.enable_type_tracker = true
   end
   opts.on("--state-tracker", "enable state tracker") do
     options.enable_state_tracker = true
   end
-  opts.on("--return-type-tracker", "enable return type tracker") do
-    options.enable_return_type_tracker = true
-  end
 
   opts.on("--no-type-tracker", "disable type tracker") do
     options.enable_type_tracker = false
@@ -40,14 +27,27 @@ option_parser = OptionParser.new do |opts|
   opts.on("--no-state-tracker", "disable state tracker") do
     options.enable_state_tracker = false
   end
-  opts.on("--no-return-type-tracker", "disable return type tracker") do
-    options.enable_return_type_tracker = false
-  end
 
   opts.on("--output-dir=[Dir]", String, "specify output directory (ignored by type tracker)") do |dir|
     options.output_dir = dir
   end
 
+  opts.on("--catch-only-every-N-call=[N]", Integer, "randomly catches only 1/N of all calls to speed up performance (by default N = 1)") do |n|
+    options.catch_only_every_n_call = n
+  end
+  opts.on("--project-root=[PATH]", String, "Specify project's root directory to catch every call from this directory. "\
+      "Calls from other directories aren't guaranteed to be caught") do |path|
+    options.project_root = path
+  end
+
+  opts.on("--pipe-file-path=[PATH]", String, "Specify pipe file path to connect to server") do |path|
+    options.pipe_file_path = path
+  end
+
+  opts.on("--buffering", "enable buffering between arg-scanner and server. It speeds up arg-scanner but doesn't allow "\
+      "to use arg-scanner \"interactively\". Disabled by default") do |buffering|
+    options.buffering = buffering
+  end
 end
 
 begin
@@ -69,7 +69,7 @@ end
 options.set_env
 
 old_opts = ENV['RUBYOPT'] || ''
-starter = "-r#{File.expand_path(File.dirname(__FILE__))}/../lib/arg_scanner/starter"
+starter = "-r #{File.expand_path(File.dirname(__FILE__))}/../lib/arg_scanner/starter"
 unless old_opts.include? starter
   ENV['RUBYOPT'] = starter
   ENV['RUBYOPT'] += " #{old_opts}" if old_opts != ''

data/bin/rubymine-type-tracker

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+# This is small script for launching type tracker under RubyMine's provided server. Acts like arg-scanner wrapper
+require 'optparse'
+require 'arg_scanner/version'
+require 'tmpdir'
+require 'json'
+
+option_parser = OptionParser.new do |opts|
+  opts.banner = <<~EOB
+    rubymine-type-tracker #{ArgScanner::VERSION}
+    
+    Usage: rubymine-type-tracker <ruby script to execute>
+        rubymine-type-tracker is a ruby script for easy launching some command under
+        RubyMine's type tracker. The data will be sent to a server run by RubyMine. 
+        So before launching this script be sure project is opened in RubyMine with 
+        "Ruby Dynamic Code Insight" plugin installed.
+  EOB
+end
+
+begin
+  option_parser.parse! ARGV
+  if ARGV.size == 0
+    raise StandardError.new("")
+  end
+rescue StandardError => e
+  puts option_parser
+  exit 1
+end
+
+dot_ruby_type_inference_dir = File.join(Dir.tmpdir, ".ruby-type-inference")
+if File.directory?(dot_ruby_type_inference_dir)
+  match_jsons = Dir.foreach(dot_ruby_type_inference_dir).map do |file_name|
+    if file_name == '.' || file_name == '..'
+      next nil
+    end
+    json = JSON.parse(IO.read(File.join(dot_ruby_type_inference_dir, file_name)))
+    if json["projectPath"] != Dir.pwd
+      next nil
+    end
+    next json
+  end.select { |x| x != nil }
+else
+  match_jsons = []
+end
+
+if match_jsons.count == 1
+  json = match_jsons[0]
+elsif match_jsons.count > 1
+  STDERR.puts <<~EOB
+      Critical error! You may try to:\n
+      1. Close RubyMine
+      2. Clean #{dot_ruby_type_inference_dir}
+      3. Open RubyMine
+  EOB
+  exit 1
+elsif match_jsons.count == 0
+  STDERR.puts <<~EOB
+      Error! You are possibly...
+      * launching this script under directory different from project 
+        opened in RubyMine (please `cd` to dir firstly)
+      * haven't opened project in RubyMine 
+      * haven't installed "Ruby Dynamic Code Insight" plugin in RubyMine
+  EOB
+  exit 1
+end
+
+to_exec = ["arg-scanner",
+           "--type-tracker",
+           "--project-root=#{json["projectPath"]}",
+           "--pipe-file-path=#{json["pipeFilePath"]}",
+           *ARGV]
+
+Kernel.exec(*to_exec)

data/ext/arg_scanner/arg_scanner.c

@@ -5,13 +5,19 @@
 #include <string.h>
 #include <assert.h>
 #include <stdarg.h>
+#include <netinet/in.h>
+#include <glib.h>
 
 //#define DEBUG_ARG_SCANNER 1
 
 #if RUBY_API_VERSION_CODE >= 20500
+  #if (RUBY_RELEASE_YEAR == 2017 && RUBY_RELEASE_MONTH == 10 && RUBY_RELEASE_DAY == 10) //workaround for 2.5.0-preview1
     #define TH_CFP(thread) ((rb_control_frame_t *)(thread)->ec.cfp)
+  #else
+    #define TH_CFP(thread) ((rb_control_frame_t *)(thread)->ec->cfp)
+  #endif
 #else
-    #define TH_CFP(thread) ((rb_control_frame_t *)(thread)->cfp)
+  #define TH_CFP(thread) ((rb_control_frame_t *)(thread)->cfp)
 #endif
 
 #ifdef DEBUG_ARG_SCANNER
@@ -28,64 +34,241 @@ int types_ids[20];
 
 static VALUE c_signature;
 
+/**
+ * Contains info related to explicitly passed args
+ * For example:
+ * def foo(a, b = 1); end
+ *
+ * `b` passed here implicitly:
+ * foo(1)
+ *
+ * But here explicitly:
+ * foo(1, 10)
+ */
 typedef struct
 {
-    ssize_t call_info_argc;
-    char* call_info_kw_args;
+    ssize_t call_info_explicit_argc;   // Number of arguments that was explicitly passed by user
+    char **call_info_kw_explicit_args; // kw arguments names that was explicitly passed by user (null terminating array)
 } call_info_t;
 
 typedef struct
 {
-    VALUE method_name;
-    char* args_info;
-    VALUE path;
-    char* call_info_kw_args;
-    ssize_t call_info_argc;
+    char *receiver_name;
+    char *method_name;
+    char *args_info;
+    char *path;
+    char *return_type_name;
+    ssize_t explicit_argc; // Number of arguments that was explicitly passed by user
     int lineno;
+    int is_in_project_root; // Can be 0, 1 or -1 when project_root is not specified
 } signature_t;
 
 void Init_arg_scanner();
 
-static char* get_args_info();
-static VALUE handle_call(VALUE self, VALUE lineno, VALUE method_name, VALUE path);
-static VALUE handle_return(VALUE self, VALUE signature, VALUE return_type_name);
+static const char *ARG_SCANNER_EXIT_COMMAND = "EXIT";
+static const char *EMPTY_VALUE = "";
+static const int MAX_NUMBER_OF_MISSED_CALLS = 10;
+/**
+ * There we keep information about signatures that have already been sent to server in order to not sent them again
+ */
+static GTree *sent_to_server_tree;
+/**
+ * Here we store map with key: signature_t and value: int number (how many times method was called with the same args)
+ * If we got that any method is called with the same args more than MAX_NUMBER_OF_MISSED_CALLS times in a row then
+ * we will ignore it.
+ */
+static GTree *number_missed_calls_tree;
+static GSList *call_stack = NULL;
+static char *get_args_info(const char *const *explicit_kw_args);
+static VALUE handle_call(VALUE self, VALUE tp);
+static VALUE handle_return(VALUE self, VALUE tp);
+static VALUE destructor(VALUE self);
+static const char *calc_sane_class_name(VALUE ptr);
+
+// returns Qnil if ready; or string containing error message otherwise 
+static VALUE check_if_arg_scanner_ready(VALUE self);
 
 // For testing
 static VALUE get_args_info_rb(VALUE self);
 static VALUE get_call_info_rb(VALUE self);
 
-static call_info_t* get_call_info();
+static call_info_t get_call_info();
 static bool is_call_info_needed();
 
-static void call_info_t_free(void *s)
+static void call_info_t_free(call_info_t s)
 {
-    if (((call_info_t *)s)->call_info_kw_args != 0)
-        free(((call_info_t *)s)->call_info_kw_args);
-    free(s);
+    free(s.call_info_kw_explicit_args);
 }
 
-static void signature_t_free(void *s)
+static void signature_t_free(signature_t *s)
 {
-    if (((signature_t *)s)->args_info != 0)
-        free(((signature_t *)s)->args_info);
-    if (((signature_t *)s)->call_info_kw_args != 0)
-        free(((signature_t *)s)->call_info_kw_args);
+    free(s->receiver_name);
+    free(s->method_name);
+    free(s->args_info);
+    free(s->path);
+    free(s->return_type_name);
     free(s);
 }
 
-static void
-signature_t_mark(signature_t *sig)
+// Free signature_t partially leaving parts that are used in sent_to_server_tree_comparator
+// @see_also sent_to_server_tree_comparator
+static void signature_t_free_partially(signature_t *s)
 {
-    rb_gc_mark(sig->method_name);
-    rb_gc_mark(sig->path);
+    free(s->receiver_name);
+    s->receiver_name = NULL;
+
+    free(s->method_name);
+    s->method_name = NULL;
+}
+
+// Comparator for number_missed_calls_tree.
+static gint
+number_missed_calls_tree_comparator(gconstpointer x, gconstpointer y, gpointer user_data_ignored) {
+    const signature_t *a = x;
+    const signature_t *b = y;
+    int ret;
+
+    // Comparison using lineno and path theoretically should guarantees us unique.
+    // And compare lineno firstly because it's faster O(1) than comparing path which is O(path_len)
+    ret = a->lineno - b->lineno;
+    if (ret != 0) return ret;
+
+    ret = strcmp(a->path, b->path);
+    if (ret != 0) return ret;
+
+    return 0;
+}
+
+// Comparator for sent_to_server_tree.
+// If you want to change the way it compare then don't forget to
+// change signature_t_free_partially accordingly
+// @see_also signature_t_free_partially
+static gint
+sent_to_server_tree_comparator(gconstpointer x, gconstpointer y, gpointer user_data_ignored) {
+    const signature_t *a = x;
+    const signature_t *b = y;
+    int ret;
+
+    ret = number_missed_calls_tree_comparator(x, y, user_data_ignored);
+    if (ret != 0) return ret;
+
+    if (a->args_info != NULL && b->args_info != NULL) {
+        ret = strcmp(a->args_info, b->args_info);
+        if (ret != 0) return ret;
+    }
+
+    ret = strcmp(a->return_type_name, b->return_type_name);
+    if (ret != 0) return ret;
+
+    return 0;
+}
+
+inline int start_with(const char *str, const char *prefix) {
+    if (str == NULL || prefix == NULL) {
+        return -1;
+    }
+    while (*str != '\0' && *prefix != '\0') {
+        if (*str != *prefix) {
+            return 0;
+        }
+        str++;
+        prefix++;
+    }
+    return 1;
+}
+
+FILE *pipe_file = NULL;
+static char *project_root = NULL;
+static int catch_only_every_n_call = 1;
+
+static int file_exists(const char *file_path) {
+    return access(file_path, F_OK) != -1;
+}
+
+static VALUE init(VALUE self, VALUE pipe_file_path, VALUE buffering,
+                  VALUE project_root_local, VALUE catch_only_every_n_call_local) {
+    if (pipe_file_path != Qnil) {
+        pipe_file_path = rb_file_s_expand_path(1, &pipe_file_path); // https://ruby-doc.org/core-2.2.0/File.html#method-c-expand_path
+        const char *pipe_file_path_c = StringValueCStr(pipe_file_path);
+        if (!file_exists(pipe_file_path_c)) {
+            fprintf(stderr, "Specified pipe file: %s doesn't exists\n", pipe_file_path_c);
+            exit(1);
+        }
+        pipe_file = fopen(pipe_file_path_c, "w");
+        if (pipe_file == NULL) {
+            fprintf(stderr, "Cannot open pipe file \"%s\" with write access\n", pipe_file_path_c);
+            exit(1);
+        }
+
+        int buffering_disabled = buffering == Qnil;
+        if (buffering_disabled) {
+            setbuf(pipe_file, NULL);
+        }
+    }
+    if (project_root_local != Qnil) {
+        project_root = strdup(StringValueCStr(project_root_local));
+    }
+    if (catch_only_every_n_call_local != Qnil) {
+        if (sscanf(StringValueCStr(catch_only_every_n_call_local), "%d", &catch_only_every_n_call) != 1) {
+            fprintf(stderr, "Please specify number in --catch-only-every-N-call arg\n");
+            exit(1);
+        }
+        srand(time(0));
+    }
+    return Qnil;
 }
 
 void Init_arg_scanner() {
     mArgScanner = rb_define_module("ArgScanner");
-    rb_define_module_function(mArgScanner, "handle_call", handle_call, 3);
-    rb_define_module_function(mArgScanner, "handle_return", handle_return, 2);
+    rb_define_module_function(mArgScanner, "handle_call", handle_call, 1);
+    rb_define_module_function(mArgScanner, "handle_return", handle_return, 1);
     rb_define_module_function(mArgScanner, "get_args_info", get_args_info_rb, 0);
     rb_define_module_function(mArgScanner, "get_call_info", get_call_info_rb, 0);
+    rb_define_module_function(mArgScanner, "destructor", destructor, 0);
+    rb_define_module_function(mArgScanner, "check_if_arg_scanner_ready", check_if_arg_scanner_ready, 0);
+    rb_define_module_function(mArgScanner, "init", init, 4);
+
+    sent_to_server_tree = g_tree_new_full(/*key_compare_func =*/sent_to_server_tree_comparator,
+                                          /*key_compare_data =*/NULL,
+                                          /*key_destroy_func =*/(GDestroyNotify)signature_t_free,
+                                          /*value_destroy_func =*/NULL);
+
+    // key_destroy_func is NULL because we will use the same keys for number_missed_calls_tree
+    // and sent_to_server_tree. And all memory management is done by sent_to_server_tree
+    number_missed_calls_tree = g_tree_new_full(/*key_compare_func =*/number_missed_calls_tree_comparator,
+                                               /*key_compare_data =*/NULL,
+                                               /*key_destroy_func =*/NULL,
+                                               /*value_destroy_func =*/NULL);
+}
+
+inline void push_to_call_stack(signature_t *signature) {
+    call_stack = g_slist_prepend(call_stack, (gpointer) signature);
+}
+
+inline signature_t *pop_from_call_stack() {
+    if (call_stack == NULL) {
+        return NULL;
+    }
+    signature_t *ret = (signature_t *) call_stack->data;
+
+    GSList *old_head = call_stack;
+    call_stack = g_slist_remove_link(call_stack, old_head);
+    g_slist_free_1(old_head);
+    return ret;
+}
+
+inline int is_call_stack_empty() {
+    return call_stack == NULL;
+}
+
+/**
+ * Looks at the object at the top of this stack without removing it from the stack.
+ */
+inline signature_t *top_of_call_stack() {
+    if (call_stack == NULL) {
+        return NULL;
+    }
+    return (signature_t *) call_stack[0].data;
 }
 
 rb_control_frame_t *
@@ -100,186 +283,188 @@ my_rb_vm_get_binding_creatable_next_cfp(const rb_thread_t *th, const rb_control_
     return 0;
 }
 
+static VALUE exit_from_handle_call_skipping_call() {
+    push_to_call_stack(NULL);
+    return Qnil;
+}
+
 static VALUE
-handle_call(VALUE self, VALUE lineno, VALUE method_name, VALUE path)
+handle_call(VALUE self, VALUE tp)
 {
-    //VALUE method_sym = rb_tracearg_method_id(trace_arg);
-    //VALUE path = trace_arg->path;
-    VALUE c_method_name = method_name;
-    VALUE c_path = path;
-    int c_lineno = FIX2INT(lineno);//trace_arg->lineno;
-
-    signature_t *sign;
-    sign = ALLOC(signature_t);
-
-    sign->lineno = c_lineno;
-    sign->method_name = c_method_name;
-    sign->path = c_path;
+    signature_t sign_temp;
+    memset(&sign_temp, 0, sizeof(sign_temp));
+    sign_temp.lineno = FIX2INT(rb_funcall(tp, rb_intern("lineno"), 0)); // Convert Ruby's Fixnum to C language int
+    VALUE path = rb_funcall(tp, rb_intern("path"), 0);
+    path = rb_file_s_expand_path(1, &path); // https://ruby-doc.org/core-2.2.0/File.html#method-c-expand_path
+    sign_temp.path = StringValueCStr(path);
 
-#ifdef DEBUG_ARG_SCANNER
-    LOG("Getting args info for %s %s %d \n", rb_id2name(SYM2ID(sign->method_name)), StringValuePtr(sign->path), sign->lineno);
-#endif
-    sign->args_info = get_args_info();
-
-    if (is_call_info_needed())
-    {
-        call_info_t *info = get_call_info();
+    int is_in_project_root = start_with(sign_temp.path, project_root);
 
-        sign->call_info_argc = info->call_info_argc;
-        sign->call_info_kw_args = info->call_info_kw_args;
+    if (project_root != NULL && !is_in_project_root) {
+        signature_t *peek = top_of_call_stack();
 
-        free(info);
-    } else {
-        sign->call_info_argc = -1;
-        sign->call_info_kw_args = 0;
+        if (!is_call_stack_empty() && (peek == NULL || !(peek->is_in_project_root))) {
+            return exit_from_handle_call_skipping_call();
+        }
     }
 
-    //return Data_Wrap_Struct(c_signature, signature_t_mark, signature_t_free, sign);
-    return Data_Wrap_Struct(c_signature, signature_t_mark, xfree, sign);
-}
-
-static VALUE
-handle_return(VALUE self, VALUE signature, VALUE return_type_name)
-{
-    signature_t *sign;
-    const char *args_info;
-    const char *call_info_kw_args;
-    char json_mes[2000];
+    if (project_root == NULL || !is_in_project_root) {
+        int number_of_missed_calls = (int)g_tree_lookup(number_missed_calls_tree, &sign_temp);
+        if (number_of_missed_calls > MAX_NUMBER_OF_MISSED_CALLS) {
+            return exit_from_handle_call_skipping_call();
+        }
+    }
 
-    Data_Get_Struct(signature, signature_t, sign);
+    if (catch_only_every_n_call != 1 && rand() % catch_only_every_n_call != 0) {
+        return exit_from_handle_call_skipping_call();
+    }
 
-    args_info = sign->args_info;
-    if (!args_info)
-        args_info = "";
-    call_info_kw_args = sign->call_info_kw_args;
-    if (!call_info_kw_args)
-        call_info_kw_args = "";
+    signature_t *sign = (signature_t *) calloc(1, sizeof(*sign));
 
+    sign->is_in_project_root = is_in_project_root;
+    sign->lineno = sign_temp.lineno;
+    sign->path = strdup(sign_temp.path);
+    sign->method_name = strdup(rb_id2name(SYM2ID(rb_funcall(tp, rb_intern("method_id"), 0))));
+    sign->explicit_argc = -1;
 
 #ifdef DEBUG_ARG_SCANNER
-    LOG("%s \n", rb_id2name(SYM2ID(sign->method_name)));
-    LOG("%d \n", sign->call_info_argc);
-    LOG("%s \n", call_info_kw_args);
-    LOG("%s \n", args_info);
-    LOG("%s \n", StringValuePtr(sign->path));
-    LOG("%d \n", sign->lineno);
+    LOG("Getting args info for %s %s %d \n", sign->method_name, sign->path, sign->lineno);
 #endif
+    call_info_t info;
+    info.call_info_kw_explicit_args = NULL;
+    if (is_call_info_needed()) {
+        info = get_call_info();
+        sign->explicit_argc = info.call_info_explicit_argc;
+    }
 
-    assert(strlen(args_info) < 1000);
-
-    snprintf(json_mes, 2000,
-        "{\"method_name\":\"%s\",\"call_info_argc\":\"%d\",\"call_info_kw_args\":\"%s\",\"args_info\":\"%s\",\"visibility\":\"%s\",\"path\":\"%s\",\"lineno\":\"%d\",",
-        rb_id2name(SYM2ID(sign->method_name)),
-        sign->call_info_argc,
-        call_info_kw_args,
-        //StringValuePtr(receiver_name),
-        args_info,
-        //StringValuePtr(return_type_name),
-        "PUBLIC",
-        StringValuePtr(sign->path),
-        sign->lineno);
+    sign->args_info = get_args_info(info.call_info_kw_explicit_args);
+    call_info_t_free(info);
 
-    LOG("%s \n", json_mes);
+    if (sign->args_info != NULL && strlen(sign->args_info) >= 1000) {
+        signature_t_free(sign);
+        return exit_from_handle_call_skipping_call();
+    }
 
-    return rb_str_new_cstr(json_mes);
+    push_to_call_stack(sign);
+    return Qnil;
 }
 
-static call_info_t*
-get_call_info()
+static VALUE
+handle_return(VALUE self, VALUE tp)
 {
-    rb_thread_t *thread;
-    rb_control_frame_t *cfp;
-    call_info_t *info;
-
-    thread = ruby_current_thread;
-    cfp = TH_CFP(thread);
-    info = malloc(sizeof(call_info_t));
-    //info = ALLOC(call_info_t);
-    //info = malloc;
+    signature_t *sign = pop_from_call_stack();
+    if (sign == NULL) {
+        return Qnil;
+    }
+    VALUE defined_class = rb_funcall(tp, rb_intern("defined_class"), 0);
 
-    info->call_info_argc = -1;
-    info->call_info_kw_args = 0;
+    VALUE receiver_name = rb_mod_name(defined_class);
 
-    cfp += 4;
-    cfp = my_rb_vm_get_binding_creatable_next_cfp(thread, cfp);
+    // if defined_class is nil then it means that method is invoked from anonymous module.
+    // Then trying to extract name of it's anonymous module. For more details see
+    // CallStatCompletionTest#testAnonymousModuleMethodCall
+    if (receiver_name == Qnil) {
+        VALUE this = rb_funcall(tp, rb_intern("self"), 0);
+        receiver_name = rb_funcall(this, rb_intern("to_s"), 0);
+    }
 
-    if(cfp->iseq != NULL)
-    {
-        if(cfp->pc == NULL || cfp->iseq->body == NULL)
-        {
-            return info;
+    VALUE return_type_name = rb_funcall(tp, rb_intern("return_value"), 0);
+
+    sign->receiver_name = strdup(StringValueCStr(receiver_name));
+    sign->return_type_name = strdup(calc_sane_class_name(return_type_name));
+
+    signature_t *sign_in_sent_to_server_tree = g_tree_lookup(sent_to_server_tree, sign);
+    if (sign_in_sent_to_server_tree == NULL) {
+        // Resets number of missed calls to 0
+        g_tree_insert(number_missed_calls_tree, /*key = */sign, /*value = */0);
+
+        // GTree will free memory allocated by sign by itself
+        g_tree_insert(sent_to_server_tree, /*key = */sign, /*value = */sign);
+
+        if (pipe_file != NULL) {
+            fprintf(pipe_file,
+                "{\"method_name\":\"%s\",\"call_info_argc\":\"%d\",\"args_info\":\"%s\",\"visibility\":\"%s\","
+                "\"path\":\"%s\",\"lineno\":\"%d\",\"receiver_name\":\"%s\",\"return_type_name\":\"%s\"}\n",
+                sign->method_name,
+                sign->explicit_argc,
+                sign->args_info != NULL ? sign->args_info : "",
+                "PUBLIC",
+                sign->path,
+                sign->lineno,
+                sign->receiver_name,
+                sign->return_type_name);
         }
 
-        const rb_iseq_t *iseq = cfp->iseq;
-
-        ptrdiff_t pc = cfp->pc - cfp->iseq->body->iseq_encoded;
+        signature_t_free_partially(sign);
+    } else if (project_root == NULL || !sign->is_in_project_root) {
+        signature_t_free(sign);
 
-        const VALUE *iseq_original = rb_iseq_original_iseq((rb_iseq_t *)iseq);
-
-        int tmp = 0;
-        int indent = 1;
-
-        for(; indent < 6; indent++)
-        {
-            VALUE insn = iseq_original[pc - indent];
-            tmp = (int)insn;
-
-            if(0 < tmp && tmp < 256)
-            {
-                if(indent < 3)
-                    return info;
+        int found = (int) g_tree_lookup(number_missed_calls_tree, sign_in_sent_to_server_tree);
+        g_tree_insert(number_missed_calls_tree, /*key = */sign_in_sent_to_server_tree, /*value = */found + 1);
+    }
+    return Qnil;
+}
 
-                struct rb_call_info *ci = (struct rb_call_info *)iseq_original[pc - indent + 1];
+static call_info_t
+get_call_info() {
+    rb_thread_t *thread = ruby_current_thread;
+    rb_control_frame_t *cfp = TH_CFP(thread);
 
-                info->call_info_argc = ci->orig_argc;
+    call_info_t empty;
+    empty.call_info_kw_explicit_args = NULL;
+    empty.call_info_explicit_argc = -1;
 
-                if (ci->flag & VM_CALL_KWARG)
-                {
-                    struct rb_call_info_kw_arg *kw_args = ((struct rb_call_info_with_kwarg *)ci)->kw_arg;
+    cfp += 3;
+    cfp = my_rb_vm_get_binding_creatable_next_cfp(thread, cfp);
 
-                    size_t kwArgSize = kw_args->keyword_len;
+    if(cfp->iseq == NULL || cfp->pc == NULL || cfp->iseq->body == NULL) {
+        return empty;
+    }
 
-                    VALUE kw_ary = rb_ary_new_from_values(kw_args->keyword_len, kw_args->keywords);
-                    const char *c_kw_ary[kwArgSize];
+    const rb_iseq_t *iseq = (const rb_iseq_t *) cfp->iseq;
 
-                    size_t ans_size = 0;
-                    int j;
+    ptrdiff_t pc = cfp->pc - cfp->iseq->body->iseq_encoded;
 
-                    for(j = kwArgSize - 1; j >= 0; j--)
-                    {
-                        VALUE kw = rb_ary_pop(kw_ary);
-                        const char* kw_name = rb_id2name(SYM2ID(kw));
+    const VALUE *iseq_original = rb_iseq_original_iseq(iseq);
 
-                        c_kw_ary[j] = kw_name;
-                        ans_size += strlen(kw_name);
+    int indent;
+    for (indent = 1; indent < 6; indent++) {
+        VALUE insn = iseq_original[pc - indent];
+        int tmp = (int)insn;
+        if(0 < tmp && tmp < 256) {
+            if(indent < 3) {
+                return empty;
+            }
+            call_info_t info;
+            struct rb_call_info *ci = (struct rb_call_info *)iseq_original[pc - indent + 1];
+            info.call_info_explicit_argc = ci->orig_argc;
+            info.call_info_kw_explicit_args = NULL;
 
-                        if((size_t)j + 1 < kwArgSize)
-                            ans_size++;
-                    }
+            if (ci->flag & VM_CALL_KWARG) {
+                struct rb_call_info_kw_arg *kw_args = ((struct rb_call_info_with_kwarg *)ci)->kw_arg;
 
-                    info->call_info_kw_args = (char*)malloc(ans_size + 1);
+                size_t kwArgSize = kw_args->keyword_len;
 
-                    if(kwArgSize > 0)
-                    {
-                        strcpy(info->call_info_kw_args, c_kw_ary[0]);
+                VALUE kw_ary = rb_ary_new_from_values(kw_args->keyword_len, kw_args->keywords);
 
-                        if(kwArgSize > 1)
-                            strcat(info->call_info_kw_args, ",");
-                    }
+                info.call_info_kw_explicit_args = (char **) malloc((kwArgSize + 1)*sizeof(*(info.call_info_kw_explicit_args)));
 
-                    for(j = 1; (size_t)j < kwArgSize; j++)
-                    {
-                        strcat(info->call_info_kw_args, c_kw_ary[j]);
+                int i;
+                for (i = kwArgSize -1 ; i >= 0; --i) {
+                    VALUE kw = rb_ary_pop(kw_ary);
+                    const char *kw_name = rb_id2name(SYM2ID(kw));
 
-                        if((size_t)j + 1 < kwArgSize)
-                            strcat(info->call_info_kw_args, ",");
-                    }
+                    info.call_info_kw_explicit_args[i] = kw_name;
                 }
-                return info;
+                info.call_info_kw_explicit_args[kwArgSize] = NULL;
+            } else {
+                info.call_info_kw_explicit_args = malloc(sizeof(*info.call_info_kw_explicit_args));
+                info.call_info_kw_explicit_args[0] = NULL;
             }
+            return info;
         }
     }
-    return info;
+    return empty;
 }
 
 static const char*
@@ -327,7 +512,7 @@ fast_join_array(char sep, size_t count, const char **strings)
         lengths[i + 1] = lengths[i] + length;
     }
 
-    result = (char*)malloc(sizeof(char) * (1 + lengths[count]));
+    result = (char *)malloc(sizeof(*result) * (1 + lengths[count]));
 
     for (i = 0; i < count; i++)
     {
@@ -338,7 +523,7 @@ fast_join_array(char sep, size_t count, const char **strings)
             if (i > 0)
                 result[start++] = sep;
 
-            memcpy(result + sizeof(char) * start, str, sizeof(char) * (lengths[i + 1] - start));
+            memcpy(result + start, str, sizeof(*result) * (lengths[i + 1] - start));
         }
     }
 
@@ -364,8 +549,72 @@ fast_join(char sep, size_t count, ...)
     return fast_join_array(sep, count, strings);
 }
 
+/**
+ * Checks that `container` contains `element`
+ */
+static int contains(const char *const *container, const char *element) {
+    if (container == NULL || element == NULL) {
+        return 0;
+    }
+    const char *const *iterator = container;
+    while (*iterator != NULL) {
+        if (strcmp(*iterator, element) == 0) {
+            return 1;
+        }
+        ++iterator;
+    }
+    return 0;
+}
+
+#define JOIN_KW_NAMES_AND_TYPES_BUF_SIZE 2048
+static char join_kw_names_and_types_buf[JOIN_KW_NAMES_AND_TYPES_BUF_SIZE];
+/**
+ * Null terminating array which contains strings of explicitly passed kw args.
+ * It's used for join_kw_names_and_types
+ */
+static const char *const *join_kw_names_and_types_explicit_kw_args = NULL;
+
+/**
+ * This function is used for concatenating hash keys and value's types.
+ * Be sure that buf is at least JOIN_KW_NAMES_AND_TYPES_BUF_SIZE bytes.
+ * If join_kw_names_and_types_buf size = JOIN_KW_NAMES_AND_TYPES_BUF_SIZE
+ * isn't enough then this buf will contain invalid information
+ */
+static int join_kw_names_and_types(VALUE key, VALUE val, VALUE ignored) {
+    const char *kw_name = rb_id2name(SYM2ID(key));
+    const char *kw_type = calc_sane_class_name(val);
+
+    const char *const *explicit_kw_args_iterator = join_kw_names_and_types_explicit_kw_args;
+
+    // Just such behaviour: when join_kw_names_and_types_explicit_kw_args is
+    // not provided then consider every kw arg as explicitly passed by user
+    int is_explicit = explicit_kw_args_iterator == NULL;
+
+    if (explicit_kw_args_iterator != NULL) {
+        while(*explicit_kw_args_iterator != NULL) {
+            if (strcmp(*explicit_kw_args_iterator, kw_name) == 0) {
+                is_explicit = 1;
+                break;
+            }
+            ++explicit_kw_args_iterator;
+        }
+    }
+
+    if (is_explicit) {
+        // Check that buf is not empty
+        if (join_kw_names_and_types_buf[0] != '\0') {
+            strncat(join_kw_names_and_types_buf, ";", JOIN_KW_NAMES_AND_TYPES_BUF_SIZE - 1);
+        }
+        strncat(join_kw_names_and_types_buf, "KEYREST,", JOIN_KW_NAMES_AND_TYPES_BUF_SIZE - 1);
+        strncat(join_kw_names_and_types_buf, kw_type, JOIN_KW_NAMES_AND_TYPES_BUF_SIZE - 1);
+        strncat(join_kw_names_and_types_buf, ",", JOIN_KW_NAMES_AND_TYPES_BUF_SIZE - 1);
+        strncat(join_kw_names_and_types_buf, kw_name, JOIN_KW_NAMES_AND_TYPES_BUF_SIZE - 1);
+    }
+    return ST_CONTINUE;
+}
+
 static char*
-get_args_info()
+get_args_info(const char *const *explicit_kw_args)
 {
     rb_thread_t *thread;
     rb_control_frame_t *cfp;
@@ -373,7 +622,7 @@ get_args_info()
     thread = ruby_current_thread;
     cfp = TH_CFP(thread);
 
-    cfp += 3;
+    cfp += 2;
 
     VALUE *ep = cfp->ep;
     ep -= cfp->iseq->body->local_table_size;
@@ -398,10 +647,11 @@ get_args_info()
     LOG("%d\n", has_kwrest);
     LOG("%d\n", has_block);
 
-    if(param_size == 0)
+    if (param_size == 0) {
         return 0;
+    }
 
-    const char **types = (const char **)malloc(param_size * sizeof(const char*));
+    const char **types = (const char **)malloc(param_size * sizeof(*types));
     size_t i, ans_iterator;
     int types_iterator;
 
@@ -412,17 +662,18 @@ get_args_info()
 
     for(i = param_size - 1 - new_version_flag, types_iterator = 0; (size_t)types_iterator < param_size; i--, types_iterator++)
     {
-        types[types_iterator] = calc_sane_class_name(*(ep + i - 1));
+        types[types_iterator] = calc_sane_class_name(ep[i - 1]);
         types_ids[types_iterator] = i - 1;
         LOG("Type #%d=%s\n", types_iterator, types[types_iterator])
     }
 
     types_iterator--;
 
-    if(has_kw)
+    if(has_kw) {
         param_size--;
+    }
 
-    char **ans = (char** )malloc(param_size * sizeof(char*));
+    char **ans = (char **)malloc(param_size * sizeof(*ans));
 
     for(i = 0; i < lead_num; i++, ans_iterator++, types_iterator--)
     {
@@ -439,11 +690,7 @@ get_args_info()
     for(i = 0; i < has_rest; i++, ans_iterator++, types_iterator--)
     {
         const char* name = rb_id2name(cfp->iseq->body->local_table[ans_iterator]);
-
-        char* type;
-        type = types[types_iterator];
-
-        ans[ans_iterator] = fast_join(',', 3, "REST", type, name);
+        ans[ans_iterator] = fast_join(',', 3, "REST", types[types_iterator], name);
     }
 
     for(i = 0; i < post_num; i++, ans_iterator++, types_iterator--)
@@ -458,6 +705,7 @@ get_args_info()
         const ID *keywords = cfp->iseq->body->param.keyword->table;
         size_t kw_num = cfp->iseq->body->param.keyword->num;
         size_t required_num = cfp->iseq->body->param.keyword->required_num;
+        size_t rest_start = cfp->iseq->body->param.keyword->rest_start;
 
         LOG("%d %d\n", kw_num, required_num)
 
@@ -466,26 +714,39 @@ get_args_info()
             ID key = keywords[i];
             ans[ans_iterator] = fast_join(',', 3, "KEYREQ", types[types_iterator], rb_id2name(key));
         }
-        for(i = required_num; i < kw_num; i++, ans_iterator++, types_iterator--)
+        for(i = required_num; i < kw_num; i++, types_iterator--)
         {
             ID key = keywords[i];
-            ans[ans_iterator] = fast_join(',', 3, "KEY", types[types_iterator], rb_id2name(key));
+            const char *name = rb_id2name(key);
+            if (explicit_kw_args == NULL || contains(explicit_kw_args, name)) {
+                ans[ans_iterator++] = fast_join(',', 3, "KEY", types[types_iterator], name);
+            }
         }
-    }
-
-    if(param_size - has_block > 1 && has_kwrest && TYPE(*(ep + types_ids[types_iterator])) == T_FIXNUM)
-        types_iterator--;
 
-    for(i = 0; i < has_kwrest; i++, ans_iterator++, types_iterator--)
-    {
-        const char* name = rb_id2name(cfp->iseq->body->local_table[ans_iterator]);
-        LOG("%s\n", calc_sane_class_name(*(ep + types_ids[types_iterator])));
-        LOG("%d\n", rb_hash_size(*(ep + types_ids[types_iterator])));
-        char* type;
-
-        type = types[types_iterator];
+        if (param_size - has_block > 1 && has_kwrest && TYPE(ep[types_ids[types_iterator]]) == T_FIXNUM) {
+            types_iterator--;
+        }
 
-        ans[ans_iterator] = fast_join(',', 3, "KEYREST", type, name);
+        if (has_kwrest)
+        {
+            char *buf = malloc(JOIN_KW_NAMES_AND_TYPES_BUF_SIZE * sizeof(*buf));
+            buf[0] = '\0';
+            join_kw_names_and_types_buf[0] = '\0';
+            join_kw_names_and_types_explicit_kw_args = explicit_kw_args;
+
+            // This function call will concatenate info into join_kw_names_and_types_buf
+            rb_hash_foreach(ep[types_ids[types_iterator]], join_kw_names_and_types, Qnil);
+
+            // Checking that join_kw_names_and_types_buf isn't possibly containing invalid info.
+            // See join_kw_names_and_types documentation to understand why it can be invalid
+            size_t len = strlen(join_kw_names_and_types_buf);
+            if (len > 0 && len < JOIN_KW_NAMES_AND_TYPES_BUF_SIZE - 1) {
+                strncpy(buf, join_kw_names_and_types_buf, JOIN_KW_NAMES_AND_TYPES_BUF_SIZE);
+                ans[ans_iterator++] = buf;
+            }
+            join_kw_names_and_types_explicit_kw_args = NULL;
+            types_iterator--;
+        }
     }
 
     for(i = 0; i < has_block; i++, ans_iterator++, types_iterator--)
@@ -494,15 +755,6 @@ get_args_info()
         ans[ans_iterator] = fast_join(',', 3, "BLOCK", types[types_iterator], name);
     }
 
-    int answer_size = 0;
-
-    for(i = 0; i < ans_iterator; i++)
-    {
-        answer_size += strlen(ans[i]);
-        if(i + 1 < ans_iterator)
-            answer_size++;
-    }
-
     LOG("%d\n", ans_iterator)
     char *answer = fast_join_array(';', ans_iterator, ans);
 
@@ -512,7 +764,6 @@ get_args_info()
     }
 
     LOG("%d %d %d", ans_iterator, param_size, types_iterator);
-    assert(ans_iterator == param_size);
     assert(types_iterator <= 0);
 
     free(types);
@@ -524,22 +775,42 @@ get_args_info()
 static VALUE
 get_args_info_rb(VALUE self)
 {
-    char *args_info = get_args_info();
-    return args_info ? rb_str_new_cstr(args_info) : Qnil;
+    call_info_t info;
+    info.call_info_kw_explicit_args = NULL;
+    if (is_call_info_needed()) {
+        info = get_call_info();
+    }
+
+    char *args_info = get_args_info(info.call_info_kw_explicit_args);
+    call_info_t_free(info);
+    VALUE ret = args_info ? rb_str_new_cstr(args_info) : Qnil;
+    free(args_info);
+    return ret;
 }
 
 static VALUE
 get_call_info_rb(VALUE self)
 {
-    if(is_call_info_needed())
+    if (is_call_info_needed())
     {
-        call_info_t *info = get_call_info();
+        call_info_t info = get_call_info();
 
         VALUE ans;
         ans = rb_ary_new();
-        rb_ary_push(ans, LONG2FIX(info->call_info_argc));
-        if(info->call_info_kw_args != 0)
-            rb_ary_push(ans, rb_str_new_cstr(info->call_info_kw_args));
+        rb_ary_push(ans, LONG2FIX(info.call_info_explicit_argc));
+        if (info.call_info_kw_explicit_args != NULL) {
+            const char *const *kwarg = info.call_info_kw_explicit_args;
+            int explicit_kw_count = 0;
+            while (*kwarg != NULL) {
+                ++explicit_kw_count;
+                ++kwarg;
+            }
+            char *answer = fast_join_array(',', explicit_kw_count, info.call_info_kw_explicit_args);
+            rb_ary_push(ans, rb_str_new_cstr(answer));
+            free(answer);
+        }
+
+        call_info_t_free(info);
 
         return ans;
     }
@@ -557,10 +828,30 @@ is_call_info_needed()
 
     thread = ruby_current_thread;
     cfp = TH_CFP(thread);
-    cfp += 3;
+    cfp += 2;
 
     return (cfp->iseq->body->param.flags.has_opt
         || cfp->iseq->body->param.flags.has_kwrest
         || cfp->iseq->body->param.flags.has_rest
         || (cfp->iseq->body->param.keyword != NULL && cfp->iseq->body->param.keyword->required_num == 0));
-}
+}
+
+static VALUE 
+check_if_arg_scanner_ready(VALUE self) {
+    char error_msg[1024];
+    if (pipe_file == NULL) {
+        snprintf(error_msg, sizeof(error_msg)/sizeof(*error_msg), "Pipe file is not specified");
+        return rb_str_new_cstr(error_msg);
+    }
+    return Qnil;
+}
+
+static VALUE
+destructor(VALUE self) {
+    g_tree_destroy(sent_to_server_tree);
+    g_tree_destroy(number_missed_calls_tree);
+    fprintf(pipe_file, "%s\n", ARG_SCANNER_EXIT_COMMAND);
+    fclose(pipe_file);
+    free(project_root);
+    return Qnil;
+}