rbs 0.6.0 → 0.10.0

data/lib/rbs/environment.rb

@@ -126,7 +126,7 @@ module RBS
 
     def cache_name(cache, name:, decl:, outer:)
       if cache.key?(name)
-        raise DuplicatedDeclarationError.new(name, decl, cache[name])
+        raise DuplicatedDeclarationError.new(name, decl, cache[name].decl)
       end
 
       cache[name] = SingleEntry.new(name: name, decl: decl, outer: outer)

data/lib/rbs/errors.rb

@@ -141,6 +141,31 @@ module RBS
     end
   end
 
+  class NoSelfTypeFoundError < StandardError
+    attr_reader :type_name
+    attr_reader :location
+
+    def initialize(type_name:, location:)
+      @type_name = type_name
+      @location = location
+
+      super "#{Location.to_string location}: Could not find self type: #{type_name}"
+    end
+
+    def self.check!(self_type, env:)
+      type_name = self_type.name
+
+      dic = case
+            when type_name.class?
+              env.class_decls
+            when type_name.interface?
+              env.interface_decls
+            end
+
+      dic.key?(type_name) or raise new(type_name: type_name, location: self_type.location)
+    end
+  end
+
   class NoMixinFoundError < StandardError
     attr_reader :type_name
     attr_reader :member

data/lib/rbs/location.rb

@@ -77,6 +77,21 @@ module RBS
       locations.inject {|l1, l2| l1 + l2 }
     end
 
+    def concat(*others)
+      others.each { |other| self << other }
+      self
+    end
+
+    def <<(other)
+      if other
+        raise "Invalid concat: buffer=#{buffer.name}, other.buffer=#{other.buffer.name}" unless other.buffer == buffer
+        @end_pos = other.end_pos
+        @source = nil
+        @end_loc = nil
+      end
+      self
+    end
+
     def pred?(loc)
       loc.is_a?(Location) &&
         loc.name == name &&

data/lib/rbs/parser.y

@@ -4,9 +4,9 @@ class RBS::Parser
         tANNOTATION
         tSTRING tSYMBOL tINTEGER tWRITE_ATTR
         kLPAREN kRPAREN kLBRACKET kRBRACKET kLBRACE kRBRACE
-        kVOID kNIL kTRUE kFALSE kANY kUNTYPED kTOP kBOT kSELF kSELFQ kINSTANCE kCLASS kBOOL kSINGLETON kTYPE kDEF kMODULE kSUPER
+        kVOID kNIL kTRUE kFALSE kANY kUNTYPED kTOP kBOT kSELF kSELFQ kINSTANCE kCLASS kBOOL kSINGLETON kTYPE kDEF kMODULE
         kPRIVATE kPUBLIC kALIAS
-        kCOLON kCOLON2 kCOMMA kBAR kAMP kHAT kARROW kQUESTION kEXCLAMATION kSTAR kSTAR2 kFATARROW kEQ kDOT kLT
+        kCOLON kCOLON2 kCOMMA kBAR kAMP kHAT kARROW kQUESTION kEXCLAMATION kSTAR kSTAR2 kFATARROW kEQ kDOT kDOT3 kLT
         kINTERFACE kEND kINCLUDE kEXTEND kATTRREADER kATTRWRITER kATTRACCESSOR tOPERATOR tQUOTEDMETHOD tQUOTEDIDENT
         kPREPEND kEXTENSION kINCOMPATIBLE
         type_TYPE type_SIGNATURE type_METHODTYPE tEOF
@@ -425,7 +425,12 @@ rule
                                       comment: leading_comment(val[0].first&.location || location))
       }
 
-  overload: { result = nil } | kOVERLOAD
+  overload:
+        { result = nil }
+    | kOVERLOAD {
+        RBS.logger.warn "`overload def` syntax is deprecated. Use `...` syntax instead."
+        result = val[0]
+      }
 
   method_member:
       annotations attributes overload kDEF method_kind def_name method_types {
@@ -438,15 +443,24 @@ rule
             type
           end
         end
+
+        last_type = val[6].last
+        if last_type.is_a?(LocatedValue) && last_type.value == :dot3
+          overload = true
+          val[6].pop
+        else
+          overload = false
+        end
+
         result = Members::MethodDefinition.new(
           name: val[5].value,
           kind: val[4],
-          types: types,
+          types: val[6],
           annotations: val[0],
           location: location,
           comment: leading_comment(val[0].first&.location || val[1].first&.location || val[2]&.location || val[3].location),
           attributes: val[1].map(&:value),
-          overload: !!val[2]
+          overload: overload || !!val[2]
         )
       }
 
@@ -463,7 +477,7 @@ rule
 
   method_types:
       method_type { result = [val[0]] }
-    | kSUPER { result = [LocatedValue.new(value: :super, location: val[0].location)] }
+    | kDOT3 { result = [LocatedValue.new(value: :dot3, location: val[0].location)] }
     | method_type kBAR method_types {
         result = val[2].unshift(val[0])
       }
@@ -520,7 +534,7 @@ rule
 
   method_name:
       tOPERATOR
-    | kAMP | kHAT | kSTAR | kLT | kEXCLAMATION | kSTAR2 | kBAR | kOUT | kIN
+    | kAMP | kHAT | kSTAR | kLT | kEXCLAMATION | kSTAR2 | kBAR
     | method_name0
     | method_name0 kQUESTION {
         unless val[0].location.pred?(val[1].location)
@@ -548,7 +562,7 @@ rule
       kCLASS | kVOID | kNIL | kTRUE | kFALSE | kANY | kUNTYPED | kTOP | kBOT | kINSTANCE | kBOOL | kSINGLETON
     | kTYPE | kMODULE | kPRIVATE | kPUBLIC | kEND | kINCLUDE | kEXTEND | kPREPEND
     | kATTRREADER | kATTRACCESSOR | kATTRWRITER | kDEF | kEXTENSION | kSELF | kINCOMPATIBLE
-    | kUNCHECKED | kINTERFACE | kSUPER | kALIAS | kOUT | kIN | kOVERLOAD
+    | kUNCHECKED | kINTERFACE | kALIAS | kOUT | kIN | kOVERLOAD
 
   module_type_params:
       { result = nil }
@@ -1150,15 +1164,13 @@ def leading_comment(location)
 end
 
 def push_comment(string, location)
-  new_comment = AST::Comment.new(string: string+"\n", location: location)
-
-  if (prev_comment = leading_comment(location)) && prev_comment.location.start_column == location.start_column
-    @comments.delete prev_comment.location.end_line
-    new_comment = AST::Comment.new(string: prev_comment.string + new_comment.string,
-                                   location: prev_comment.location + new_comment.location)
+  if (comment = leading_comment(location)) && comment.location.start_column == location.start_column
+    comment.concat(string: "#{string}\n", location: location)
+    @comments[comment.location.end_line] = comment
+  else
+    new_comment = AST::Comment.new(string: "#{string}\n", location: location)
+    @comments[new_comment.location.end_line] = new_comment
   end
-
-  @comments[new_comment.location.end_line] = new_comment
 end
 
 def new_token(type, value = input.matched)
@@ -1218,7 +1230,6 @@ KEYWORDS = {
   "attr_reader" => :kATTRREADER,
   "attr_writer" => :kATTRWRITER,
   "attr_accessor" => :kATTRACCESSOR,
-  "super" => :kSUPER,
   "public" => :kPUBLIC,
   "private" => :kPRIVATE,
   "alias" => :kALIAS,
@@ -1267,6 +1278,7 @@ PUNCTS = {
   "!" => :kEXCLAMATION,
   "**" => :kSTAR2,
   "*" => :kSTAR,
+  "..." => :kDOT3,
   "." => :kDOT,
   "<" => :kLT,
   "-@" => :tOPERATOR,

data/lib/rbs/prototype/rb.rb

@@ -134,7 +134,7 @@ module RBS
               overload: false
             )
 
-            decls.push member
+            decls.push member unless decls.include?(member)
 
         when :FCALL
           # Inside method definition cannot reach here.

data/lib/rbs/substitution.rb

@@ -11,7 +11,7 @@ module RBS
       mapping[from] = to
     end
 
-    def self.build(variables, types, instance_type: Types::Bases::Instance.new(location: nil), &block)
+    def self.build(variables, types, instance_type: nil, &block)
       unless variables.size == types.size
         raise "Broken substitution: variables=#{variables}, types=#{types}"
       end
@@ -33,7 +33,11 @@ module RBS
       when Types::Variable
         mapping[ty.name] || ty
       when Types::Bases::Instance
-        instance_type
+        if instance_type
+          instance_type
+        else
+          ty
+        end
       else
         ty
       end

data/lib/rbs/test.rb

@@ -5,6 +5,7 @@ require "rbs/test/errors"
 require "rbs/test/type_check"
 require "rbs/test/tester"
 require "rbs/test/hook"
+require "rbs/test/setup_helper"
 
 module RBS
   module Test

data/lib/rbs/test/errors.rb

@@ -28,7 +28,11 @@ module RBS
       end
 
       def self.inspect_(obj)
-        Test::INSPECT.bind(obj).call
+        if obj.respond_to?(:inspect)
+          obj.inspect
+        else
+          Test::INSPECT.bind(obj).call     # For the case inspect is not defined (like BasicObject)
+        end
       end
 
       def self.to_string(error)

data/lib/rbs/test/hook.rb

@@ -7,6 +7,7 @@ module RBS
       OPERATORS = {
         :== => "eqeq",
         :=== => "eqeqeq",
+        :!= => "noteq",
         :+ => "plus",
         :- => "minus",
         :* => "star",

data/lib/rbs/test/setup.rb

@@ -1,24 +1,30 @@
 require "rbs"
 require "rbs/test"
-
 require "optparse"
 require "shellwords"
 
+include RBS::Test::SetupHelper
+
 logger = Logger.new(STDERR)
 
 begin
   opts = Shellwords.shellsplit(ENV["RBS_TEST_OPT"] || "-I sig")
-  filter = ENV.fetch("RBS_TEST_TARGET").split(",")
-  skips = (ENV["RBS_TEST_SKIP"] || "").split(",")
-  sampling = !ENV.key?("RBS_TEST_NO_SAMPLE")
+  filter = ENV.fetch('RBS_TEST_TARGET', "").split(',').map! { |e| e.strip }
+  skips = (ENV['RBS_TEST_SKIP'] || '').split(',').map! { |e| e.strip }
   RBS.logger_level = (ENV["RBS_TEST_LOGLEVEL"] || "info")
-rescue
+  sample_size = get_sample_size(ENV['RBS_TEST_SAMPLE_SIZE'] || '')
+rescue InvalidSampleSizeError => exception
+  RBS.logger.error exception.message
+  exit 1
+end
+
+if filter.empty?
   STDERR.puts "rbs/test/setup handles the following environment variables:"
   STDERR.puts "  [REQUIRED] RBS_TEST_TARGET: test target class name, `Foo::Bar,Foo::Baz` for each class or `Foo::*` for all classes under `Foo`"
   STDERR.puts "  [OPTIONAL] RBS_TEST_SKIP: skip testing classes"
   STDERR.puts "  [OPTIONAL] RBS_TEST_OPT: options for signatures (`-r` for libraries or `-I` for signatures)"
   STDERR.puts "  [OPTIONAL] RBS_TEST_LOGLEVEL: one of debug|info|warn|error|fatal (defaults to info)"
-  STDERR.puts "  [OPTIONAL] RBS_TEST_NO_SAMPLE: if set, the type checker tests all the values of a collection"
+  STDERR.puts "  [OPTIONAL] RBS_TEST_SAMPLE_SIZE: sets the amount of values in a collection to be type-checked (Set to `ALL` to type check all the values)"
   exit 1
 end
 
@@ -32,26 +38,38 @@ env = RBS::Environment.from_loader(loader).resolve_type_names
 
 def match(filter, name)
   if filter.end_with?("*")
-    name.start_with?(filter[0, filter.size - 1]) || name == filter[0, filter.size-3]
+    size = filter.size
+    name.start_with?(filter[0, size - 1]) || name == filter[0, size-3]
   else
     filter == name
   end
 end
 
-factory = RBS::Factory.new()
+def to_absolute_typename(type_name)
+  RBS::Factory.new().type_name(type_name).absolute!
+end
+
 tester = RBS::Test::Tester.new(env: env)
 
+module_name = Module.instance_method(:name)
+
 TracePoint.trace :end do |tp|
-  class_name = tp.self.name&.yield_self {|name| factory.type_name(name).absolute! }
+  class_name = module_name.bind(tp.self).call&.yield_self {|name| to_absolute_typename name }
 
   if class_name
-    if filter.any? {|f| match(f, class_name.to_s) } && skips.none? {|f| match(f, class_name.to_s) }
-      if tester.checkers.none? {|hook| hook.klass == tp.self }
-        if env.class_decls.key?(class_name)
-          logger.info "Setting up hooks for #{class_name}"
-          tester.install!(tp.self, sampling: sampling)
-        end
+    if filter.any? {|f| match(to_absolute_typename(f).to_s, class_name.to_s) } && skips.none? {|f| match(f, class_name.to_s) }
+      if env.class_decls.key?(class_name)
+        logger.info "Setting up hooks for #{class_name}"
+        tester.install!(tp.self, sample_size: sample_size)
       end
     end
   end
 end
+
+at_exit do
+  if $!.nil? || $!.is_a?(SystemExit) && $!.success?
+    if tester.targets.empty?
+      logger.debug { "No type checker was installed!" }
+    end
+  end
+end

data/lib/rbs/test/setup_helper.rb

@@ -0,0 +1,29 @@
+module RBS
+  module Test
+    module SetupHelper
+      class InvalidSampleSizeError < StandardError
+        attr_reader :string
+        
+        def initialize(string)
+          @string = string
+          super("Sample size should be a positive integer: `#{string}`")
+        end
+      end
+      
+      DEFAULT_SAMPLE_SIZE = 100
+      
+      def get_sample_size(string)
+        case string
+        when ""
+          DEFAULT_SAMPLE_SIZE
+        when 'ALL'
+          nil
+        else
+          int_size = string.to_i
+          raise InvalidSampleSizeError.new(string) unless int_size.positive?
+          int_size
+        end
+      end
+    end
+  end
+end

data/lib/rbs/test/tester.rb

@@ -2,11 +2,15 @@ module RBS
   module Test
     class Tester
       attr_reader :env
-      attr_reader :checkers
+      attr_reader :targets
+      attr_reader :instance_testers
+      attr_reader :singleton_testers
 
       def initialize(env:)
         @env = env
-        @checkers = []
+        @targets = []
+        @instance_testers = {}
+        @singleton_testers = {}
       end
 
       def factory
@@ -17,34 +21,74 @@ module RBS
         @builder ||= DefinitionBuilder.new(env: env)
       end
 
-      def install!(klass, sampling:)
+      def skip_method?(type_name, method)
+        if method.implemented_in == type_name
+          if method.annotations.any? {|a| a.string == "rbs:test:skip" }
+            :skip
+          else
+            false
+          end
+        else
+          if method.annotations.any? {|a| a.string == "rbs:test:target" }
+            false
+          else
+            :implemented_in
+          end
+        end
+      end
+
+      def install!(klass, sample_size:)
         RBS.logger.info { "Installing runtime type checker in #{klass}..." }
 
         type_name = factory.type_name(klass.name).absolute!
 
         builder.build_instance(type_name).tap do |definition|
           instance_key = new_key(type_name, "InstanceChecker")
-          Observer.register(instance_key, MethodCallTester.new(klass, builder, definition, kind: :instance, sampling: sampling))
+          tester, set = instance_testers[klass] ||= [
+            MethodCallTester.new(klass, builder, definition, kind: :instance, sample_size: sample_size),
+            Set[]
+          ]
+          Observer.register(instance_key, tester)
 
           definition.methods.each do |name, method|
-            if method.implemented_in == type_name
-              RBS.logger.info { "Setting up method hook in ##{name}..." }
-              Hook.hook_instance_method klass, name, key: instance_key
+            if reason = skip_method?(type_name, method)
+              unless reason == :implemented_in
+                RBS.logger.info { "Skipping ##{name} because of `#{reason}`..." }
+              end
+            else
+              if klass.instance_methods(false).include?(name) && !set.include?(name)
+                RBS.logger.info { "Setting up method hook in ##{name}..." }
+                Hook.hook_instance_method klass, name, key: instance_key
+                set << name
+              end
             end
           end
         end
 
         builder.build_singleton(type_name).tap do |definition|
           singleton_key = new_key(type_name, "SingletonChecker")
-          Observer.register(singleton_key, MethodCallTester.new(klass.singleton_class, builder, definition, kind: :singleton, sampling: sampling))
+          tester, set = singleton_testers[klass] ||= [
+            MethodCallTester.new(klass.singleton_class, builder, definition, kind: :singleton, sample_size: sample_size),
+            Set[]
+          ]
+          Observer.register(singleton_key, tester)
 
           definition.methods.each do |name, method|
-            if method.implemented_in == type_name || name == :new
-              RBS.logger.info { "Setting up method hook in .#{name}..." }
-              Hook.hook_singleton_method klass, name, key: singleton_key
+            if reason = skip_method?(type_name, method)
+              unless reason == :implemented_in
+                RBS.logger.info { "Skipping .#{name} because of `#{reason}`..." }
+              end
+            else
+              if klass.methods(false).include?(name) && !set.include?(name)
+                RBS.logger.info { "Setting up method hook in .#{name}..." }
+                Hook.hook_singleton_method klass, name, key: singleton_key
+                set << name
+              end
             end
           end
         end
+
+        targets << klass
       end
 
       def new_key(type_name, prefix)
@@ -66,14 +110,14 @@ module RBS
         attr_reader :definition
         attr_reader :builder
         attr_reader :kind
-        attr_reader :sampling
+        attr_reader :sample_size
 
-        def initialize(self_class, builder, definition, kind:, sampling:)
+        def initialize(self_class, builder, definition, kind:, sample_size:)
           @self_class = self_class
           @definition = definition
           @builder = builder
           @kind = kind
-          @sampling = sampling
+          @sample_size = sample_size
         end
 
         def env
@@ -81,7 +125,7 @@ module RBS
         end
 
         def check
-          @check ||= TypeCheck.new(self_class: self_class, builder: builder, sampling: sampling)
+          @check ||= TypeCheck.new(self_class: self_class, builder: builder, sample_size: sample_size)
         end
 
         def format_method_name(name)