arg_scanner 0.1.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7a5018e4c54e0aac945b4eb3d1d19c0915109516
+  data.tar.gz: 97a6c8b858413da9a447a4d34d7310ad9ab97f3b
+SHA512:
+  metadata.gz: d2b050da192b7def101aea6f66c8ac2fa6cb5e507fe01579bc96bcb129a64e04b8c272fcf1057b197aa53016b1527b2a10f32b5525573488e7ef92bf7d14b2f3
+  data.tar.gz: 55d111320901c78a7a64a71c39c2ba2a991543db1993a5b6b795fd8adf2900202fd9297465829c82ec2b0ae559c9b21f9abca935a9d0992dd8cf580eca250882

data/.gitignore

@@ -0,0 +1,16 @@
+*.iml
+
+.bundle/
+.yardoc
+Gemfile.lock
+_yardoc/
+coverage/
+doc/
+pkg/
+spec/reports/
+tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in arg_scanner.gemspec
+gemspec
+
+group :test do
+  gem 'test-unit'
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 JetBrains
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,49 @@
+# ArgScanner
+
+`arg_scanner` is a gem with the purpose to track all method calls and
+deliver the following information:
+
+* Method signature (arguments, their names and kinds) and declaration place
+* The types of argument variables given to each method call done
+
+This information can be used then to calculate and use type contracts
+for the analysed methods.
+
+## 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.
+
+The recommended way to install it is to install manually:
+
+    $ gem install arg_scanner
+    
+If you want to compile the gem from sources, just run
+    
+    $ bundle install
+    $ bundle exec rake install
+    
+If you have problems with native extension compilation, make sure you have
+actual version of [ruby-core-source gem](https://github.com/os97673/debase-ruby_core_source). 
+
+## Usage
+
+`arg_scanner` provides binary `arg-scanner` which receives any number of
+arguments and executes the given command in type tracking mode,
+for example:
+
+    $ arg-scanner bundle exec rake spec
+    
+The gem will need to send the obtained data though TCP socket on **port 7777**.
+See [global readme](../README.md) for instructions on how to run server
+to receive and process that data.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/JetBrains/ruby-type-inference
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,22 @@
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+require 'rake/testtask'
+
+BASE_TEST_FILE_LIST = Dir['test/**/test_*.rb']
+
+task :build => :compile
+
+Rake::ExtensionTask.new("arg_scanner") do |ext|
+  ext.lib_dir = "lib/arg_scanner"
+end
+
+desc "Test arg_scanner."
+Rake::TestTask.new(:test => [:clean, :compile]) do |t|
+  t.libs += %w(./ext ./lib)
+  t.test_files = FileList[BASE_TEST_FILE_LIST]
+  t.verbose = true
+end
+
+task :test => :lib
+
+task :default => [:clobber, :compile, :test]

data/arg_scanner.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'arg_scanner/version'
+
+Gem::Specification.new do |spec|
+  spec.name = "arg_scanner"
+  spec.version = ArgScanner::VERSION
+  spec.authors = ["Nickolay Viuginov", "Valentin Fondaratov"]
+  spec.email = ["viuginov.nickolay@gmail.com", "fondarat@gmail.com"]
+
+  spec.summary = %q{Program execution tracker to retrieve data types information}
+  spec.homepage = "https://github.com/jetbrains/ruby-type-inference"
+  spec.license = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against " \
+  #     "public gem pushes."
+  # end
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir = "bin"
+  spec.executables = spec.files.grep(%r{^bin/}) {|f| File.basename(f)}
+  spec.require_paths = ["lib"]
+  spec.extensions = ["ext/arg_scanner/extconf.rb"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "debase-ruby_core_source", "~> 0.9.6"
+end

data/bin/arg-scanner

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'arg_scanner/options'
+
+options = ArgScanner::OPTIONS
+option_parser = OptionParser.new do |opts|
+  opts.banner = <<~EOB
+    Usage: arg-scanner [OPTIONS] <ruby cmdline> 
+    arg-scanner is a ruby script mediator supposed to be run from the command line or IDE.
+        The data will be sent to a signature server so it must be running during arg-scanner execution.
+  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
+end
+
+begin
+  option_parser.parse! ARGV
+rescue StandardError => e
+  puts option_parser
+  puts
+  puts e.message
+  exit 1
+end
+
+if ARGV.size < 1
+  puts option_parser
+  puts
+  puts "Ruby program to trace must be specified."
+  exit 1
+end
+
+options.set_env
+
+old_opts = ENV['RUBYOPT'] || ''
+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 != ''
+end
+
+$0 = ARGV[0]
+Kernel.exec *ARGV

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "arg_scanner"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/arg_scanner/arg_scanner.c

@@ -0,0 +1,568 @@
+#include "arg_scanner.h"
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stdarg.h>
+
+//#define DEBUG_ARG_SCANNER 1
+
+#ifdef DEBUG_ARG_SCANNER
+    #define LOG(f, args...) { fprintf(stderr, "DEBUG: '%s'=", #args); fprintf(stderr, f, ##args); fflush(stderr); }
+#else
+    #define LOG(...) {}
+#endif
+
+#define ruby_current_thread ((rb_thread_t *)RTYPEDDATA_DATA(rb_thread_current()))
+typedef struct rb_trace_arg_struct rb_trace_arg_t;
+
+VALUE mArgScanner = Qnil;
+int types_ids[20];
+
+static VALUE c_signature;
+
+typedef struct
+{
+    ssize_t call_info_argc;
+    char* call_info_kw_args;
+} call_info_t;
+
+typedef struct
+{
+    VALUE method_name;
+    char* args_info;
+    VALUE path;
+    char* call_info_kw_args;
+    ssize_t call_info_argc;
+    int lineno;
+} 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);
+
+// 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 bool is_call_info_needed();
+
+static void call_info_t_free(void *s)
+{
+    if (((call_info_t *)s)->call_info_kw_args != 0)
+        free(((call_info_t *)s)->call_info_kw_args);
+    free(s);
+}
+
+static void signature_t_free(void *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);
+}
+
+static void
+signature_t_mark(signature_t *sig)
+{
+    rb_gc_mark(sig->method_name);
+    rb_gc_mark(sig->path);
+}
+
+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, "get_args_info", get_args_info_rb, 0);
+    rb_define_module_function(mArgScanner, "get_call_info", get_call_info_rb, 0);
+}
+
+rb_control_frame_t *
+my_rb_vm_get_binding_creatable_next_cfp(const rb_thread_t *th, const rb_control_frame_t *cfp)
+{
+    while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp)) {
+        if (cfp->iseq) {
+            return (rb_control_frame_t *)cfp;
+        }
+	    cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+    }
+    return 0;
+}
+
+static VALUE
+handle_call(VALUE self, VALUE lineno, VALUE method_name, VALUE path)
+{
+    //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;
+
+#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();
+
+        sign->call_info_argc = info->call_info_argc;
+        sign->call_info_kw_args = info->call_info_kw_args;
+
+        free(info);
+    } else {
+        sign->call_info_argc = -1;
+        sign->call_info_kw_args = 0;
+    }
+
+    //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];
+
+    Data_Get_Struct(signature, signature_t, sign);
+
+    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 = "";
+
+
+#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);
+#endif
+
+    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);
+
+    LOG("%s \n", json_mes);
+
+    return rb_str_new_cstr(json_mes);
+}
+
+static call_info_t*
+get_call_info()
+{
+    rb_thread_t *thread;
+    rb_control_frame_t *cfp;
+    call_info_t *info;
+
+    thread = ruby_current_thread;
+    cfp = thread->cfp;
+    info = malloc(sizeof(call_info_t));
+    //info = ALLOC(call_info_t);
+    //info = malloc;
+
+    info->call_info_argc = -1;
+    info->call_info_kw_args = 0;
+
+    cfp += 4;
+    cfp = my_rb_vm_get_binding_creatable_next_cfp(thread, cfp);
+
+    if(cfp->iseq != NULL)
+    {
+        if(cfp->pc == NULL || cfp->iseq->body == NULL)
+        {
+            return info;
+        }
+
+        const rb_iseq_t *iseq = cfp->iseq;
+
+        ptrdiff_t pc = cfp->pc - cfp->iseq->body->iseq_encoded;
+
+        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;
+
+                struct rb_call_info *ci = (struct rb_call_info *)iseq_original[pc - indent + 1];
+
+                info->call_info_argc = ci->orig_argc;
+
+                if (ci->flag & VM_CALL_KWARG)
+                {
+                    struct rb_call_info_kw_arg *kw_args = ((struct rb_call_info_with_kwarg *)ci)->kw_arg;
+
+                    size_t kwArgSize = kw_args->keyword_len;
+
+                    VALUE kw_ary = rb_ary_new_from_values(kw_args->keyword_len, kw_args->keywords);
+                    const char *c_kw_ary[kwArgSize];
+
+                    size_t ans_size = 0;
+                    int j;
+
+                    for(j = kwArgSize - 1; j >= 0; j--)
+                    {
+                        VALUE kw = rb_ary_pop(kw_ary);
+                        const char* kw_name = rb_id2name(SYM2ID(kw));
+
+                        c_kw_ary[j] = kw_name;
+                        ans_size += strlen(kw_name);
+
+                        if((size_t)j + 1 < kwArgSize)
+                            ans_size++;
+                    }
+
+                    info->call_info_kw_args = (char*)malloc(ans_size + 1);
+
+                    if(kwArgSize > 0)
+                    {
+                        strcpy(info->call_info_kw_args, c_kw_ary[0]);
+
+                        if(kwArgSize > 1)
+                            strcat(info->call_info_kw_args, ",");
+                    }
+
+                    for(j = 1; (size_t)j < kwArgSize; j++)
+                    {
+                        strcat(info->call_info_kw_args, c_kw_ary[j]);
+
+                        if((size_t)j + 1 < kwArgSize)
+                            strcat(info->call_info_kw_args, ",");
+                    }
+                }
+                return info;
+            }
+        }
+    }
+    return info;
+}
+
+static const char*
+calc_sane_class_name(VALUE ptr)
+{
+    VALUE klass = rb_obj_class(ptr);
+
+    const char* klass_name;
+    // may be false, see `object.c#rb_class_get_superclass`
+    if (klass == Qfalse) {
+        klass_name = "<err>";
+    }
+    else
+    {
+        klass_name = rb_class2name(klass);
+    }
+
+    // returned value may be NULL, see `variable.c#rb_class2name`
+    if (klass_name == NULL)
+    {
+        klass_name = "<err>";
+    }
+
+    if (strlen(klass_name) >= 200)
+    {
+        fprintf(stderr, "ERROR: too long class name: '%s'\n", klass_name);
+        assert(false);
+    }
+    return klass_name;
+}
+
+static char *
+fast_join_array(char sep, size_t count, const char **strings)
+{
+    size_t lengths[count + 1];
+    size_t i;
+    char *result;
+
+    lengths[0] = 0;
+
+    for (i = 0; i < count; i++)
+    {
+        const char *str = strings[i];
+        size_t length;
+        if (!str)
+            length = 0;
+        else
+            length = strlen(str) + (i > 0); // 1 for separator before
+
+        lengths[i + 1] = lengths[i] + length;
+    }
+
+    result = (char*)malloc(sizeof(char) * (1 + lengths[count]));
+
+    for (i = 0; i < count; i++)
+    {
+        const char *str = strings[i];
+        if (str)
+        {
+            int start = lengths[i];
+            if (i > 0)
+                result[start++] = sep;
+
+            memcpy(result + sizeof(char) * start, str, sizeof(char) * (lengths[i + 1] - start));
+        }
+    }
+
+    result[lengths[count]] = 0;
+
+    return result;
+}
+
+static char *
+fast_join(char sep, size_t count, ...)
+{
+    char *strings[count];
+    size_t i;
+    va_list ap;
+
+    va_start(ap, count);
+    for (i = 0; i < count; i++)
+    {
+        strings[i] = va_arg(ap, char *);
+    }
+    va_end(ap);
+
+    return fast_join_array(sep, count, strings);
+}
+
+static char*
+get_args_info()
+{
+    rb_thread_t *thread;
+    rb_control_frame_t *cfp;
+
+    thread = ruby_current_thread;
+    cfp = thread->cfp;
+
+    cfp += 3;
+
+    VALUE *ep = cfp->ep;
+    ep -= cfp->iseq->body->local_table_size;
+
+    size_t param_size = cfp->iseq->body->param.size;
+    size_t lead_num = cfp->iseq->body->param.lead_num;
+    size_t opt_num = cfp->iseq->body->param.opt_num;
+    size_t post_num = cfp->iseq->body->param.post_num;
+
+    unsigned int has_rest = cfp->iseq->body->param.flags.has_rest;
+    unsigned int has_kw = cfp->iseq->body->param.flags.has_kw;
+    unsigned int has_kwrest = cfp->iseq->body->param.flags.has_kwrest;
+    unsigned int has_block = cfp->iseq->body->param.flags.has_block;
+
+    LOG("%d\n", param_size);
+    LOG("%d\n", lead_num);
+    LOG("%d\n", opt_num);
+    LOG("%d\n", post_num);
+
+    LOG("%d\n", has_rest);
+    LOG("%d\n", has_kw);
+    LOG("%d\n", has_kwrest);
+    LOG("%d\n", has_block);
+
+    if(param_size == 0)
+        return 0;
+
+    const char **types = (const char **)malloc(param_size * sizeof(const char*));
+    size_t i, ans_iterator;
+    int types_iterator;
+
+    ans_iterator = 0;
+
+    for(i = param_size - 1 - (RUBY_VERSION >= "2.4.1"), types_iterator = 0; (size_t)types_iterator < param_size; i--, types_iterator++)
+    {
+        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)
+        param_size--;
+
+    char **ans = (char** )malloc(param_size * sizeof(char*));
+
+    for(i = 0; i < lead_num; i++, ans_iterator++, types_iterator--)
+    {
+        const char* name = rb_id2name(cfp->iseq->body->local_table[ans_iterator]);
+        ans[ans_iterator] = fast_join(',', 3, "REQ", types[types_iterator], name);
+    }
+
+    for(i = 0; i < opt_num; i++, ans_iterator++, types_iterator--)
+    {
+        const char* name = rb_id2name(cfp->iseq->body->local_table[ans_iterator]);
+        ans[ans_iterator] = fast_join(',', 3, "OPT", types[types_iterator], name);
+    }
+
+    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;
+        if(RARRAY_LEN(*(ep + types_ids[types_iterator])) == 0)
+            type = "Array/empty";
+        else
+            type = types[types_iterator];
+
+        ans[ans_iterator] = fast_join(',', 3, "REST", type, name);
+    }
+
+    for(i = 0; i < post_num; i++, ans_iterator++, types_iterator--)
+    {
+        const char* name = rb_id2name(cfp->iseq->body->local_table[ans_iterator]);
+        ans[ans_iterator] = fast_join(',', 3, "POST", types[types_iterator], name);
+    }
+
+
+    if(cfp->iseq->body->param.keyword != NULL)
+    {
+        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;
+
+        LOG("%d %d\n", kw_num, required_num)
+
+        for(i = 0; i < required_num; i++, ans_iterator++, types_iterator--)
+        {
+            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--)
+        {
+            ID key = keywords[i];
+            ans[ans_iterator] = fast_join(',', 3, "KEY", types[types_iterator], rb_id2name(key));
+        }
+    }
+
+    if(param_size - has_block > 1 && has_kwrest)
+        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;
+
+        if(rb_hash_size(*(ep + types_ids[types_iterator])) == 1)
+            type = "Hash/empty";
+        else
+            type = types[types_iterator];
+
+        ans[ans_iterator] = fast_join(',', 3, "KEYREST", type, name);
+    }
+
+    for(i = 0; i < has_block; i++, ans_iterator++, types_iterator--)
+    {
+        const char* name = rb_id2name(cfp->iseq->body->local_table[ans_iterator]);
+        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);
+
+    for(i = 0; i < ans_iterator; i++) {
+        LOG("free2 %d %d =%s= \n", ans[i], strlen(ans[i]), ans[i]);
+        free(ans[i]);
+    }
+
+    LOG("%d %d %d", ans_iterator, param_size, types_iterator);
+    assert(ans_iterator == param_size);
+    assert(types_iterator <= 0);
+
+    free(types);
+    free(ans);
+
+    return answer;
+}
+
+static VALUE
+get_args_info_rb(VALUE self)
+{
+    char *args_info = get_args_info();
+    return args_info ? rb_str_new_cstr(args_info) : Qnil;
+}
+
+static VALUE
+get_call_info_rb(VALUE self)
+{
+    if(is_call_info_needed())
+    {
+        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));
+
+        return ans;
+    }
+    else
+    {
+        return Qnil;
+    }
+}
+
+static bool
+is_call_info_needed()
+{
+    rb_thread_t *thread;
+    rb_control_frame_t *cfp;
+
+    thread = ruby_current_thread;
+    cfp = thread->cfp;
+    cfp += 3;
+
+    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));
+}

data/ext/arg_scanner/arg_scanner.h

@@ -0,0 +1,11 @@
+#ifndef ARG_SCANNER_H
+#define ARG_SCANNER_H 1
+
+#include "ruby.h"
+#include "vm_core.h"
+#include "version.h"
+#include "iseq.h"
+#include "vm_insnhelper.h"
+#include "method.h"
+
+#endif /* ARG_SCANNER_H */

data/ext/arg_scanner/extconf.rb

@@ -0,0 +1,37 @@
+require "mkmf"
+
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+require "debase/ruby_core_source"
+
+hdrs = proc {
+  have_header("vm_core.h") and
+  have_header("iseq.h") and
+  have_header("version.h") and
+      have_header("vm_core.h") and
+      have_header("vm_insnhelper.h") and
+      have_header("vm_core.h") and
+      have_header("method.h")
+}
+
+# Allow use customization of compile options. For example, the
+# following lines could be put in config_options to to turn off
+# optimization:
+#   $CFLAGS='-fPIC -fno-strict-aliasing -g3 -ggdb -O2 -fPIC'
+config_file = File.join(File.dirname(__FILE__), 'config_options.rb')
+load config_file if File.exist?(config_file)
+
+if ENV['debase_debug']
+  $CFLAGS+=' -Wall -Werror'
+  $CFLAGS+=' -g3'
+end
+
+dir_config("ruby")
+if !Debase::RubyCoreSource.create_makefile_with_core(hdrs, "arg_scanner/arg_scanner")
+  STDERR.print("Makefile creation failed\n")
+  STDERR.print("*************************************************************\n\n")
+  STDERR.print("  NOTE: If your headers were not found, try passing\n")
+  STDERR.print("        --with-ruby-include=PATH_TO_HEADERS      \n\n")
+  STDERR.print("*************************************************************\n\n")
+  exit(1)
+end

data/lib/arg_scanner.rb

@@ -0,0 +1,7 @@
+require "arg_scanner/version"
+require "arg_scanner/arg_scanner"
+require "arg_scanner/type_tracker"
+
+module ArgScanner
+  # Your code goes here...
+end

data/lib/arg_scanner/options.rb

@@ -0,0 +1,15 @@
+require 'ostruct'
+
+module ArgScanner
+  OPTIONS = OpenStruct.new(
+      :local_version => ENV['ARG_SCANNER_LOCAL_VERSION'] || '0',
+      :no_local => ENV['ARG_SCANNER_NO_LOCAL'] ? true : false,
+      :project_roots => ((ENV['ARG_SCANNER_PROJECT_ROOTS'] || "").split ':')
+  )
+
+  def OPTIONS.set_env
+    ENV['ARG_SCANNER_LOCAL_VERSION'] = self.local_version.to_s
+    ENV['ARG_SCANNER_NO_LOCAL'] = self.no_local ? "1" : nil
+    ENV['ARG_SCANNER_PROJECT_ROOTS'] = self.project_roots.join ':'
+  end
+end

data/lib/arg_scanner/starter.rb

@@ -0,0 +1,4 @@
+require 'arg_scanner'
+
+# instantiating type tracker will enable calls tracing and sending the data
+ArgScanner::TypeTracker.instance

data/lib/arg_scanner/type_tracker.rb

@@ -0,0 +1,88 @@
+require 'set'
+require 'socket'
+require 'singleton'
+
+require_relative 'options'
+
+module ArgScanner
+  class TypeTracker
+    include Singleton
+
+    GEM_PATH_REVERSED_REGEX = /((?:[0-9A-Za-z]+\.)+\d+)-([A-Za-z0-9_-]+)/
+
+    def initialize
+      @cache = Set.new
+      @socket = TCPSocket.new('127.0.0.1', 7777)
+
+      TracePoint.trace(:call, :return) do |tp|
+        case tp.event
+          when :call
+            handle_call(tp)
+          when :return
+            handle_return(tp)
+        end
+      end
+    end
+
+    attr_accessor :cache
+    attr_accessor :socket
+
+
+    # @param [String] path
+    def self.extract_gem_name_and_version(path)
+      if OPTIONS.project_roots && path.start_with?(*OPTIONS.project_roots)
+        return OPTIONS.no_local ? ['', ''] : ['LOCAL', OPTIONS.local_version]
+      end
+
+      reversed = path.reverse
+      return ['', ''] unless GEM_PATH_REVERSED_REGEX =~ reversed
+
+      name_and_version = Regexp.last_match
+      return name_and_version[2].reverse, name_and_version[1].reverse
+    end
+
+    def signatures
+      Thread.current[:signatures] ||= Array.new
+    end
+
+    def at_exit
+      socket.close
+    end
+
+    def put_to_socket(message)
+      socket.puts(message)
+    end
+
+    private
+    def handle_call(tp)
+      #handle_call(VALUE self, VALUE lineno, VALUE method_name, VALUE path)
+      signature = ArgScanner.handle_call(tp.lineno, tp.method_id, tp.path)
+      signatures.push(signature)
+    end
+
+    def handle_return(tp)
+      sigi = signatures
+      unless sigi.empty?
+        signature = sigi.pop
+
+        defined_class = tp.defined_class
+        return if !defined_class || defined_class.singleton_class?
+
+        receiver_name = defined_class.name ? defined_class : defined_class.ancestors.first
+        return_type_name = tp.return_value.class
+
+        return if !receiver_name || !receiver_name.to_s || receiver_name.to_s.length > 200
+
+        json = ArgScanner.handle_return(signature, return_type_name) +
+            "\"receiver_name\":\"#{receiver_name}\",\"return_type_name\":\"#{return_type_name}\","
+
+        if cache.add?(json)
+          gem_name, gem_version = TypeTracker.extract_gem_name_and_version(tp.path)
+          json += '"gem_name":"' + gem_name.to_s + '","gem_version":"' + gem_version.to_s + '"}'
+          put_to_socket(json)
+        end
+      end
+    end
+
+  end
+end

data/lib/arg_scanner/version.rb

@@ -0,0 +1,3 @@
+module ArgScanner
+  VERSION = "0.1.9"
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: arg_scanner
+version: !ruby/object:Gem::Version
+  version: 0.1.9
+platform: ruby
+authors:
+- Nickolay Viuginov
+- Valentin Fondaratov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debase-ruby_core_source
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.6
+description: 
+email:
+- viuginov.nickolay@gmail.com
+- fondarat@gmail.com
+executables:
+- arg-scanner
+- console
+- setup
+extensions:
+- ext/arg_scanner/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- arg_scanner.gemspec
+- arg_scanner.iml
+- bin/arg-scanner
+- bin/console
+- bin/setup
+- ext/arg_scanner/arg_scanner.c
+- ext/arg_scanner/arg_scanner.h
+- ext/arg_scanner/extconf.rb
+- lib/arg_scanner.rb
+- lib/arg_scanner/options.rb
+- lib/arg_scanner/starter.rb
+- lib/arg_scanner/type_tracker.rb
+- lib/arg_scanner/version.rb
+homepage: https://github.com/jetbrains/ruby-type-inference
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Program execution tracker to retrieve data types information
+test_files: []