rbs 0.7.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d175f17e9f1226e0cb0d37c2167b3b52b0e736661d1406937922194c68adfd54
-  data.tar.gz: 204d38937da751f3ea15dfd64370e379689e54f264b63be54e6c4843c4827579
+  metadata.gz: fe2c03d38ca9869e7c7bdf283f56e61e5ccbad3831b524ba14c6fd31941985e2
+  data.tar.gz: d9cc6563f7eb3173410209daeda05a8216d2ade261a3f05d3f258d0782a08e64
 SHA512:
-  metadata.gz: 242ffa432db2a94a59636be87e261411c0bf465ac170b6f5b52955cb671d2c70e6eaed7dc74b489868117fcaa360df33c16ed6e2e472edd96663491c1211d793
-  data.tar.gz: 6ccb639e3a73a7e4794f906e9e125dd173d0406198a11511592e3c3492126c31a5ff1798010087fb19d4eb053ba46140e42f869b913ae3b7aaee20303ef3f92c
+  metadata.gz: fb4391906260a8414e2c2ef44ded8fda974c495830fb6c2335204052cba67260f1f0d0fd44dd560c3c05b7cdcaffa20ee24d7d16a529c37f900689bb084ce198
+  data.tar.gz: 68cb88ea29edbce815a6887b716f20c640b651628b55b9b3e660e6bc93c218081464888632f9df7bc42da49700c253bc74fb9d01970f7bf13a2425742890431e

data/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 ## master
 
+## 0.11.0 (2020-08-31)
+
+* Signature update for `date/datetime` [#367](https://github.com/ruby/rbs/pull/367)
+* Add test double support for runtime type checker [#380](https://github.com/ruby/rbs/pull/380)
+* Add `rbs test` command for runtime type checking [#366](https://github.com/ruby/rbs/pull/366)
+* Fix runtime type checking for record types [#365](https://github.com/ruby/rbs/pull/365)
+* Improve EnvironmentLoader API [#370](https://github.com/ruby/rbs/pull/370)
+* Allow overloading from super methods [#364](https://github.com/ruby/rbs/pull/364)
+
+## 0.10.0 (2020-08-10)
+
+* Signature update for `Zlib`
+* Make "no type checker installed" message a debug print [#363](https://github.com/ruby/rbs/pull/363)
+* Print `...` for overloading method definitions [#362](https://github.com/ruby/rbs/pull/362)
+* Allow missing method implementation in Ruby code [#359](https://github.com/ruby/rbs/pull/359)
+* Runtime testing improvements [#356](https://github.com/ruby/rbs/pull/356)
+
+## 0.9.1 (2020-08-04)
+
+* Ensure using Module#name [#354](https://github.com/ruby/rbs/pull/354)
+* Fix runtime test setup [#353](https://github.com/ruby/rbs/pull/353)
+
+## 0.9.0 (2020-08-03)
+
+* Fix signature validation [#351](https://github.com/ruby/rbs/pull/351), [#352](https://github.com/ruby/rbs/pull/352)
+* Parsing performance improvement [#350](https://github.com/ruby/rbs/pull/350)
+
+## 0.8.0 (2020-08-01)
+
+* Signature updates for `Enumerator` and `PTY`
+* Fix prototype rb/rbi error handling [#349](https://github.com/ruby/rbs/pull/349)
+* Runtime test improvements [#344](https://github.com/ruby/rbs/pull/344), [#343](https://github.com/ruby/rbs/pull/343)
+* Add `...` syntax [#342](https://github.com/ruby/rbs/pull/342)
+
 ## 0.7.0 (2020-07-20)
 
 * Add `DefinitionBuilder#one_instance_ancestors` and `DefinitionBuilder#one_singleton_ancestors` [#341](https://github.com/ruby/rbs/pull/341)

data/Gemfile

@@ -6,6 +6,7 @@ gemspec
 # Development dependencies
 gem "rake"
 gem "minitest"
+gem "rspec"
 gem "racc"
 gem "rubocop"
 gem "rubocop-rubycw"

data/README.md

@@ -123,7 +123,7 @@ puts singleton.methods[:gsub]
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 

data/docs/syntax.md

@@ -212,7 +212,7 @@ _method-type_ ::= `(` _parameters_ `) ->` _type_
 
 _parameters_ ::= _required-positionals_ _optional-positionals_ _rest-positional_ _trailing-positionals_ _keywords_
 
-_paramater_ ::= _type_ _var-name_                                  # Parameter with var name
+_parameter_ ::= _type_ _var-name_                                  # Parameter with var name
               | _type_                                             # Parameter without var name
 _required-positionals_ ::= _parameter_ `,` ...
 _optional-positionals_ ::= `?` _parameter_ `,` ...
@@ -529,3 +529,16 @@ You can declare a global variable.
 $LOAD_PATH: Array[String]
 ```
 
+### Comments
+
+You can write single line comments. Comments must be on their own line. Comments can lead with whitespace.
+
+```
+# This if interface Foo
+# Usage of Foo is bar
+interface _Foo
+  # New foo is a method
+  # it will return foo.
+  def new: () -> Foo
+end
+```

data/lib/rbs/ast/comment.rb

@@ -22,6 +22,12 @@ module RBS
       def to_json(*a)
         { string: string, location: location }.to_json(*a)
       end
+
+      def concat(string:, location:)  
+        @string.concat string
+        @location.concat location
+        self
+      end
     end
   end
 end

data/lib/rbs/ast/members.rb

@@ -11,17 +11,15 @@ module RBS
         attr_reader :annotations
         attr_reader :location
         attr_reader :comment
-        attr_reader :attributes
         attr_reader :overload
 
-        def initialize(name:, kind:, types:, annotations:, location:, comment:, attributes:, overload:)
+        def initialize(name:, kind:, types:, annotations:, location:, comment:, overload:)
           @name = name
           @kind = kind
           @types = types
           @annotations = annotations
           @location = location
           @comment = comment
-          @attributes = attributes
           @overload = overload
         end
 
@@ -30,14 +28,13 @@ module RBS
             other.name == name &&
             other.kind == kind &&
             other.types == types &&
-            other.attributes == attributes &&
             other.overload == overload
         end
 
         alias eql? ==
 
         def hash
-          self.class.hash ^ name.hash ^ kind.hash ^ types.hash ^ attributes.hash ^ overload.hash
+          self.class.hash ^ name.hash ^ kind.hash ^ types.hash ^ overload.hash
         end
 
         def instance?
@@ -52,7 +49,7 @@ module RBS
           overload
         end
 
-        def update(name: self.name, kind: self.kind, types: self.types, annotations: self.annotations, location: self.location, comment: self.comment, attributes: self.attributes, overload: self.overload)
+        def update(name: self.name, kind: self.kind, types: self.types, annotations: self.annotations, location: self.location, comment: self.comment, overload: self.overload)
           self.class.new(
             name: name,
             kind: kind,
@@ -60,7 +57,6 @@ module RBS
             annotations: annotations,
             location: location,
             comment: comment,
-            attributes: attributes,
             overload: overload
           )
         end
@@ -73,7 +69,6 @@ module RBS
             annotations: annotations,
             location: location,
             comment: comment,
-            attributes: attributes,
             overload: overload
           }.to_json(*a)
         end

data/lib/rbs/cli.rb

@@ -1,4 +1,5 @@
 require "optparse"
+require "shellwords"
 
 module RBS
   class CLI
@@ -36,7 +37,7 @@ module RBS
       @stderr = stderr
     end
 
-    COMMANDS = [:ast, :list, :ancestors, :methods, :method, :validate, :constant, :paths, :prototype, :vendor, :parse]
+    COMMANDS = [:ast, :list, :ancestors, :methods, :method, :validate, :constant, :paths, :prototype, :vendor, :parse, :test]
 
     def library_parse(opts, options:)
       opts.on("-r LIBRARY", "Load RBS files of the library") do |lib|
@@ -66,6 +67,10 @@ module RBS
       opts
     end
 
+    def has_parser?
+      defined?(RubyVM::AbstractSyntaxTree)
+    end
+
     def run(args)
       options = LibraryOptions.new
 
@@ -409,6 +414,7 @@ EOU
       env.constant_decls.each do |name, const|
         stdout.puts "Validating constant: `#{name}`..."
         validator.validate_type const.decl.type, context: const.context
+        builder.ensure_namespace!(name.namespace, location: const.decl.location)
       end
 
       env.global_decls.each do |name, global|
@@ -418,7 +424,9 @@ EOU
 
       env.alias_decls.each do |name, decl|
         stdout.puts "Validating alias: `#{name}`..."
-        validator.validate_type decl.decl.type, context: decl.context
+        builder.expand_alias(name).tap do |type|
+          validator.validate_type type, context: [Namespace.root]
+        end
       end
     end
 
@@ -599,12 +607,18 @@ EOU
     end
 
     def run_prototype_file(format, args)
+      availability = unless has_parser?
+                       "\n** This command does not work on this interpreter (#{RUBY_ENGINE}) **\n"
+                     end
+
       opts = OptionParser.new
       opts.banner = <<EOU
 Usage: rbs prototype #{format} [options...] [files...]
-
+#{availability}
 Generate RBS prototype from source code.
-It parses specified Ruby code and and generates RBS prototypes. 
+It parses specified Ruby code and and generates RBS prototypes.
+
+It only works on MRI because it parses Ruby code with `RubyVM::AbstractSyntaxTree`.
 
 Examples:
 
@@ -613,6 +627,11 @@ Examples:
 EOU
       opts.parse!(args)
 
+      unless has_parser?
+        stdout.puts "Not supported on this interpreter (#{RUBY_ENGINE})."
+        exit 1
+      end
+
       if args.empty?
         stdout.puts opts
         return nil
@@ -732,5 +751,65 @@ Examples:
         TypeName.new(name: last, namespace: namespace.parent)
       end
     end
+
+    def test_opt options
+      opt_string = options.dirs.map { |dir| "-I #{Shellwords.escape(dir)}"}.concat(options.libs.map { |lib| "-r#{Shellwords.escape(lib)}"}).join(' ')
+      opt_string.empty? ? nil : opt_string
+    end
+
+    def run_test(args, options)
+      unchecked_classes = []
+      targets = []
+      sample_size = nil
+      double_suite = nil
+
+      (opts = OptionParser.new do |opts|
+        opts.banner = <<EOB
+Usage: rbs [rbs options...] test [test options...] COMMAND
+
+Examples:
+
+  $ rbs test rake test
+  $ rbs --log-level=debug test --target SomeModule::* rspec
+  $ rbs test --target SomeModule::* --target AnotherModule::* --target SomeClass rake test
+
+Options:
+EOB
+        opts.on("--target TARGET", "Sets the runtime test target") do |target|
+          targets << target
+        end
+
+        opts.on("--sample-size SAMPLE_SIZE", "Sets the sample size") do |size|
+          sample_size = size
+        end
+
+        opts.on("--unchecked-class UNCHECKED_CLASS", "Sets the class that would not be checked") do |unchecked_class|
+          unchecked_classes << unchecked_class
+        end
+
+        opts.on("--double-suite DOUBLE_SUITE", "Sets the double suite in use (currently supported: rspec | minitest)") do |suite|
+          double_suite = suite
+        end
+
+      end).order!(args)
+
+      if args.length.zero?
+        stdout.puts opts.help
+        exit 1
+      end
+
+      env_hash = {
+        'RUBYOPT' => "#{ENV['RUBYOPT']} -rrbs/test/setup",
+        'RBS_TEST_OPT' => test_opt(options),
+        'RBS_TEST_LOGLEVEL' => RBS.logger_level,
+        'RBS_TEST_SAMPLE_SIZE' => sample_size,
+        'RBS_TEST_DOUBLE_SUITE' => double_suite,
+        'RBS_TEST_UNCHECKED_CLASSES' => (unchecked_classes.join(',') unless unchecked_classes.empty?),
+        'RBS_TEST_TARGET' => (targets.join(',') unless targets.empty?)
+      }
+
+      system(env_hash, *args)
+      $?
+    end
   end
 end

data/lib/rbs/definition.rb

@@ -45,16 +45,27 @@ module RBS
         def update(type: self.type, member: self.member, defined_in: self.defined_in, implemented_in: self.implemented_in)
           TypeDef.new(type: type, member: member, defined_in: defined_in, implemented_in: implemented_in)
         end
+
+        def overload?
+          case member
+          when AST::Members::MethodDefinition
+            member.overload?
+          else
+            false
+          end
+        end
       end
 
       attr_reader :super_method
       attr_reader :defs
       attr_reader :accessibility
+      attr_reader :extra_annotations
 
-      def initialize(super_method:, defs:, accessibility:)
+      def initialize(super_method:, defs:, accessibility:, annotations: [])
         @super_method = super_method
         @defs = defs
         @accessibility = accessibility
+        @extra_annotations = annotations
       end
 
       def defined_in
@@ -74,12 +85,11 @@ module RBS
       end
 
       def annotations
-        @annotations ||= defs.flat_map(&:annotations)
+        @annotations ||= @extra_annotations + defs.flat_map(&:annotations)
       end
 
-      # @deprecated
-      def attributes
-        []
+      def members
+        @members ||= defs.map(&:member).uniq
       end
 
       def public?

data/lib/rbs/definition_builder.rb

@@ -385,9 +385,18 @@ module RBS
       end
     end
 
+    def ensure_namespace!(namespace, location:)
+      namespace.ascend do |ns|
+        unless ns.empty?
+          NoTypeFoundError.check!(ns.to_type_name, env: env, location: location)
+        end
+      end
+    end
+
     def build_instance(type_name)
       try_cache type_name, cache: instance_cache do
         entry = env.class_decls[type_name] or raise "Unknown name for build_instance: #{type_name}"
+        ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
 
         case entry
         when Environment::ClassEntry, Environment::ModuleEntry
@@ -434,6 +443,7 @@ module RBS
     def build_singleton(type_name)
       try_cache type_name, cache: singleton_cache do
         entry = env.class_decls[type_name] or raise "Unknown name for build_singleton: #{type_name}"
+        ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
 
         case entry
         when Environment::ClassEntry, Environment::ModuleEntry
@@ -559,7 +569,7 @@ module RBS
             member, visibility = array[0]
             result[method_name] = [visibility, nil, member]
 
-          when array.count {|pair| !pair[0].overload? } == 1
+          else
             visibilities = array.group_by {|pair| pair[1] }
 
             if visibilities.size > 1
@@ -573,14 +583,6 @@ module RBS
 
             overloads, primary = array.map(&:first).partition(&:overload?)
             result[method_name] = [array[0][1], nil, *primary, *overloads]
-
-          else
-            raise InvalidOverloadMethodError.new(
-              type_name: type_name,
-              method_name: method_name,
-              kind: :instance,
-              members: array.map(&:first)
-            )
           end
         end
       end
@@ -924,7 +926,8 @@ module RBS
                     implemented_in: nil
                   )
                 end,
-                accessibility: :public
+                accessibility: :public,
+                annotations: [AST::Annotation.new(location: nil, string: "rbs:test:target")]
               )
             end
           end
@@ -962,8 +965,15 @@ module RBS
                   Substitution.build([], [])
                 end
 
+          kind = case ancestor
+                 when Definition::Ancestor::Instance
+                   :instance
+                 when Definition::Ancestor::Singleton
+                   :singleton
+                 end
+
           current_definition.methods.each do |name, method|
-            merge_method definition.methods, name, method, sub
+            merge_method type_name, definition.methods, name, method, sub, kind: kind
           end
 
           current_definition.instance_variables.each do |name, variable|
@@ -987,13 +997,20 @@ module RBS
       )
     end
 
-    def merge_method(methods, name, method, sub)
+    def merge_method(type_name, methods, name, method, sub, kind:)
       super_method = methods[name]
 
+      defs = if method.defs.all? {|d| d.overload? }
+               raise InvalidOverloadMethodError.new(type_name: type_name, method_name: name, kind: kind, members: method.members) unless super_method
+               method.defs + super_method.defs
+             else
+               method.defs
+             end
+
       methods[name] = Definition::Method.new(
         super_method: super_method,
         accessibility: method.accessibility,
-        defs: sub.mapping.empty? ? method.defs : method.defs.map {|defn| defn.update(type: defn.type.sub(sub)) }
+        defs: sub.mapping.empty? ? defs : defs.map {|defn| defn.update(type: defn.type.sub(sub)) }
       )
     end
 
@@ -1020,6 +1037,7 @@ module RBS
       try_cache(type_name, cache: interface_cache) do
         entry = env.interface_decls[type_name] or raise "Unknown name for build_interface: #{type_name}"
         declaration = entry.decl
+        ensure_namespace!(type_name.namespace, location: declaration.location)
 
         self_type = Types::Interface.new(
           name: type_name,
@@ -1111,6 +1129,7 @@ module RBS
 
     def expand_alias(type_name)
       entry = env.alias_decls[type_name] or raise "Unknown name for expand_alias: #{type_name}"
+      ensure_namespace!(type_name.namespace, location: entry.decl.location)
       entry.decl.type
     end
   end