rbs 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5318ae7911a3e7e4e1bed761e0c7b8d1fc248e698b0d53f8a39d388da5617f0
-  data.tar.gz: d90f20d41372bcc852f49b844aa6b6b5367d9d88ec686a13ab00841f1cf1e2ed
+  metadata.gz: ce3b2807a94277727870ef841bdb1e3a96567098948930ab6885e9fba2fc3ccf
+  data.tar.gz: 5d4a01b26887124240ec757b8a0374c79d56c3daf8b32431a571a3ba401112cc
 SHA512:
-  metadata.gz: 702ae082267eb6a087e19c5a37a83aaaeea0f76e83eba7cc984a15cca869745d1b934231bf6910dbbba972a06301948eca740aa2a8fc49c378487a030befe909
-  data.tar.gz: 8f467c52d50c25886965e1762f7c52f246cb90fa313c7d0a9400051f32c7f3603ada0142cf90ebfad4b56ccbaf57bacd5d1467cb8daf20247254c90937b9c599
+  metadata.gz: 7978edfd75f809eb604edb58e0c35ff9a1e85b0e34f7462399f76deb36c5a6a0c61030d1fc3a3bb42d689395a0372995e03e41dd47223063084703dc207294d6
+  data.tar.gz: e1216599f496cd883e8b301d1040f395984d3fc3029ba65fa6c2f63ab3e431a96bc8369ff06bd3f97390dd78e0a10279e1e556ba2c25ac4ef5af6dfaf9aafa77

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## master
 
+## 0.6.0 (2020-07-12)
+
+* Signature update for `Logger`.
+* Clean `Environment#inspect`. [#331](https://github.com/ruby/rbs/pull/331)
+* Module self type syntax update. [#329](https://github.com/ruby/rbs/pull/329)
+* Better validation. [#328](https://github.com/ruby/rbs/pull/328)
+* Parser performance improvement. [#327](https://github.com/ruby/rbs/pull/327)
+* Runtime type checking performance improvements with sampling [#323](https://github.com/ruby/rbs/pull/323)
+
 ## 0.5.0 (2020-07-04)
 
 * Signature updates for `Mutex_m`, `IO`, and `Enumerable`.

data/Gemfile

@@ -13,6 +13,8 @@ gem "minitest-reporters"
 gem "json"
 gem "json-schema"
 gem 'stackprof'
+gem "goodcheck"
 
 # Test gems
 gem "rbs-amber", path: "test/assets/test-gem"
+

data/Rakefile

@@ -78,11 +78,10 @@ namespace :generate do
       def call
         ERB.new(<<~ERB, trim_mode: "-").result(binding)
           require_relative "test_helper"
-          require 'rbs/test/test_helper'
 
           <%- unless class_methods.empty? -%>
           class <%= klass %>SingletonTest < Minitest::Test
-            include RBS::Test::TypeAssertions
+            include TypeAssertions
 
             # library "pathname", "set", "securerandom"     # Declare library signatures to load
             testing "singleton(::<%= klass %>)"
@@ -100,7 +99,7 @@ namespace :generate do
 
           <%- unless instance_methods.empty? -%>
           class <%= klass %>Test < Minitest::Test
-            include RBS::Test::TypeAssertions
+            include TypeAssertions
 
             # library "pathname", "set", "securerandom"     # Declare library signatures to load
             testing "::<%= klass %>"

data/docs/stdlib.md

@@ -120,7 +120,6 @@ The test scripts would look like the following:
 ```rb
 class StringTest < StdlibTest
   target String
-  using hook.refinement
 
   def test_gsub
     s = "string"
@@ -136,7 +135,6 @@ end
 
 You need two method calls, `target` and `using`.
 `target` method call tells which class is the subject of the class.
-`using hook.refinement` installs a special instrumentation for stdlib, based on refinements.
 And you write the sample programs which calls all of the patterns of overloads.
 
 Note that the instrumentation is based on refinements and you need to write all method calls in the unit class definitions.

data/docs/syntax.md

@@ -166,7 +166,7 @@ end
 
 ### Proc type
 
-Proc type denots type of procedures, `Proc` instances.
+Proc type denotes type of procedures, `Proc` instances.
 
 ```
 ^(Integer) -> String                  # A procedure with an `Integer` parameter and returns `String`
@@ -348,7 +348,7 @@ attr_reader id: Integer
 # @id: Integer
 # def id: () -> Integer
 
-# Defines `name=` method and `raw_name` instance variable.
+# Defines `name=` method and `@raw_name` instance variable.
 attr_writer name (@raw_name) : String
 # @raw_name: String
 # def name=: (String) -> String
@@ -408,7 +408,10 @@ _class-decl_ ::= `class` _class-name_ _module-type-parameters_ _members_ `end`
                | `class` _class-name_ _module-type-parameters_ `<` _class-name_ _type-arguments_ _members_ `end`
 
 _module-decl_ ::= `module` _module-name_ _module-type-parameters_ _members_ `end`
-                | `module` _module-name_ _module-type-parameters_ `:` _class-name_ _type-arguments_ _members_ `end`
+                | `module` _module-name_ _module-type-parameters_ `:` _module-self-types_ _members_ `end`
+
+_module-self-types_ ::= _class-name_ _type-arguments_ `,` _module-self-types_            (Class instance)
+                      | _interface-name_ _type-arguments_ `,` _module-self-types_        (Interface)
 
 _interface-decl_ ::= `interface` _interface-name_ _module-type-parameters_ _interface-members_ `end`
 

data/goodcheck.yml

@@ -0,0 +1,65 @@
+rules:
+  - id: rbs.no_mark
+    pattern: 💪👽🚨
+    message: Do you forget to delete `arglists` section?
+    glob:
+      - "stdlib/**/*.rbs"
+    fail:
+      - |
+        # arglists 💪👽🚨 << Delete this section   
+        #    File.absolute_path?(file_name)  ->  true or false    
+        #
+
+  - id: rbs.no_arg
+    pattern: 
+      regexp: arg\d+
+    message: |
+      Stop using parameter names like `arg0` or `arg1`
+
+      The parameter names like `arg0` or `arg1` is not informative enough.
+      Try finding good parameter names from documents or arglists.
+      If you cannot find a good name, just delete the name of the parameters.
+    justification:
+      - Documents (comments) may contain that pattern.
+    glob:
+      - "stdlib/**/*.rbs"
+    fail: 
+      - "def `send`: (String | Symbol arg0, *untyped arg1) -> untyped"
+    pass:
+      - "def `send`: (String | Symbol, *untyped) -> untyped"
+
+  - id: deprecate_stdlib_test
+    pattern:
+      token: < StdlibTest
+    message: |
+      StdlibTest is deprecated
+
+      We recommend writing tests based on `TypeAssertions` and `#assert_send_type`.
+    justification:
+      - When you are updating existing tests.
+      - When you are writing tests for callback, which cannot be done with `#assert_send_type`.
+    glob:
+      - "test/stdlib/**/*_test.rb"
+    fail:
+      - |
+        class IntegerTest < StdlibTest
+          target Integer
+
+          def test_plus
+            1 + 2
+          end
+        end
+    pass:
+      - |
+        class IntegerTest < Minitest::Test
+          include TypeAssertions
+
+          testing "Integer"
+
+          def test_plus
+            assert_send_type "(::Integer) -> ::Integer",
+                             1, :+, 2
+          end
+        end
+
+

data/lib/rbs.rb

@@ -36,6 +36,7 @@ require "rbs/type_name_resolver"
 require "rbs/environment_walker"
 require "rbs/vendorer"
 require "rbs/validator"
+require "rbs/factory"
 
 begin
   require "rbs/parser"

data/lib/rbs/ast/declarations.rb

@@ -204,6 +204,44 @@ module RBS
       end
 
       class Module < Base
+        class Self
+          attr_reader :name
+          attr_reader :args
+          attr_reader :location
+
+          def initialize(name:, args:, location:)
+            @name = name
+            @args = args
+            @location = location
+          end
+
+          def ==(other)
+            other.is_a?(Self) && other.name == name && other.args == args
+          end
+
+          alias eql? ==
+
+          def hash
+            self.class.hash ^ name.hash ^ args.hash ^ location.hash
+          end
+
+          def to_json(*a)
+            {
+              name: name,
+              args: args,
+              location: location
+            }.to_json(*a)
+          end
+
+          def to_s
+            if args.empty?
+              name.to_s
+            else
+              "#{name}[#{args.join(", ")}]"
+            end
+          end
+        end
+
         include NestedDeclarationHelper
         include MixinHelper
 
@@ -212,13 +250,13 @@ module RBS
         attr_reader :members
         attr_reader :location
         attr_reader :annotations
-        attr_reader :self_type
+        attr_reader :self_types
         attr_reader :comment
 
-        def initialize(name:, type_params:, members:, self_type:, annotations:, location:, comment:)
+        def initialize(name:, type_params:, members:, self_types:, annotations:, location:, comment:)
           @name = name
           @type_params = type_params
-          @self_type = self_type
+          @self_types = self_types
           @members = members
           @annotations = annotations
           @location = location
@@ -229,14 +267,14 @@ module RBS
           other.is_a?(Module) &&
             other.name == name &&
             other.type_params == type_params &&
-            other.self_type == self_type &&
+            other.self_types == self_types &&
             other.members == members
         end
 
         alias eql? ==
 
         def hash
-          self.class.hash ^ name.hash ^ type_params.hash ^ self_type.hash ^ members.hash
+          self.class.hash ^ name.hash ^ type_params.hash ^ self_types.hash ^ members.hash
         end
 
         def to_json(*a)
@@ -245,7 +283,7 @@ module RBS
             name: name,
             type_params: type_params,
             members: members,
-            self_type: self_type,
+            self_types: self_types,
             annotations: annotations,
             location: location,
             comment: comment

data/lib/rbs/definition_builder.rb

@@ -48,7 +48,7 @@ module RBS
     def instance_ancestors(type_name, building_ancestors: [])
       as = instance_ancestors_cache[type_name] and return as
 
-      entry = env.class_decls[type_name]
+      entry = env.class_decls[type_name] or raise "Unknown name for instance_ancestors: #{type_name}"
       params = entry.type_params.each.map(&:name)
       args = Types::Variable.build(params)
       self_ancestor = Definition::Ancestor::Instance.new(name: type_name, args: args)
@@ -77,6 +77,8 @@ module RBS
             super_args = []
           end
 
+          NoSuperclassFoundError.check!(super_name, env: env, location: primary.decl.location)
+
           super_ancestors = instance_ancestors(super_name, building_ancestors: building_ancestors)
           ancestors.unshift(*super_ancestors.apply(super_args, location: primary.decl.location))
         end
@@ -100,7 +102,7 @@ module RBS
     def singleton_ancestors(type_name, building_ancestors: [])
       as = singleton_ancestor_cache[type_name] and return as
 
-      entry = env.class_decls[type_name]
+      entry = env.class_decls[type_name] or raise "Unknown name for singleton_ancestors: #{type_name}"
       self_ancestor = Definition::Ancestor::Singleton.new(name: type_name)
 
       RecursiveAncestorError.check!(self_ancestor,
@@ -123,6 +125,8 @@ module RBS
             super_name = BuiltinNames::Object.name
           end
 
+          NoSuperclassFoundError.check!(super_name, env: env, location: primary.decl.location)
+
           super_ancestors = singleton_ancestors(super_name, building_ancestors: building_ancestors)
           ancestors.unshift(*super_ancestors.ancestors)
         else
@@ -143,6 +147,8 @@ module RBS
           case member
           when AST::Members::Extend
             if member.name.class?
+              NoMixinFoundError.check!(member.name, env: env, member: member)
+
               module_ancestors = instance_ancestors(member.name, building_ancestors: building_ancestors)
               ancestors.unshift(*module_ancestors.apply(member.args, location: member.location))
             end
@@ -174,6 +180,8 @@ module RBS
           case member
           when AST::Members::Include
             if member.name.class?
+              NoMixinFoundError.check!(member.name, env: env, member: member)
+
               module_name = member.name
               module_args = member.args.map {|type| type.sub(align_params) }
 
@@ -197,6 +205,8 @@ module RBS
         decl.each_mixin do |member|
           case member
           when AST::Members::Prepend
+            NoMixinFoundError.check!(member.name, env: env, member: member)
+
             module_name = member.name
             module_args = member.args.map {|type| type.sub(align_params) }
 
@@ -222,7 +232,7 @@ module RBS
 
     def build_instance(type_name)
       try_cache type_name, cache: instance_cache do
-        entry = env.class_decls[type_name]
+        entry = env.class_decls[type_name] or raise "Unknown name for build_instance: #{type_name}"
 
         case entry
         when Environment::ClassEntry, Environment::ModuleEntry
@@ -243,11 +253,18 @@ module RBS
           end
 
           if entry.is_a?(Environment::ModuleEntry)
-            if self_type_ancestor = module_self_ancestor(type_name, entry)
-              definition_pairs.push [
-                                      self_type_ancestor,
-                                      build_interface(self_type_ancestor.name)
-                                    ]
+            entry.self_types.each do |module_self|
+              ancestor = Definition::Ancestor::Instance.new(name: module_self.name, args: module_self.args)
+              definition_pairs.push(
+                [
+                  ancestor,
+                  if module_self.name.interface?
+                    build_interface(module_self.name)
+                  else
+                    build_instance(module_self.name)
+                  end
+                ]
+              )
             end
           end
 
@@ -259,32 +276,9 @@ module RBS
       end
     end
 
-    def module_self_ancestor(type_name, entry)
-      self_decls = entry.decls.select {|d| d.decl.self_type }
-
-      return if self_decls.empty?
-
-      selfs = self_decls.map do |d|
-        Definition::Ancestor::Instance.new(
-          name: d.decl.self_type.name,
-          args: d.decl.self_type.args
-        )
-      end
-
-      selfs.uniq!
-
-      return selfs[0] if selfs.size == 1
-
-      raise ModuleSelfTypeMismatchError.new(
-        name: type_name,
-        entry: entry,
-        location: self_decls[0].decl.location
-      )
-    end
-
     def build_singleton(type_name)
       try_cache type_name, cache: singleton_cache do
-        entry = env.class_decls[type_name]
+        entry = env.class_decls[type_name] or raise "Unknown name for build_singleton: #{type_name}"
 
         case entry
         when Environment::ClassEntry, Environment::ModuleEntry
@@ -350,6 +344,8 @@ module RBS
           when AST::Members::Include, AST::Members::Extend
             if member.name.interface?
               if (kind == :instance && member.is_a?(AST::Members::Include)) || (kind == :singleton && member.is_a?(AST::Members::Extend))
+                NoMixinFoundError.check!(member.name, env: env, member: member)
+
                 interface_name = member.name
                 interface_args = member.args
 
@@ -867,7 +863,7 @@ module RBS
 
     def build_interface(type_name)
       try_cache(type_name, cache: interface_cache) do
-        entry = env.interface_decls[type_name]
+        entry = env.interface_decls[type_name] or raise "Unknown name for build_interface: #{type_name}"
         declaration = entry.decl
 
         self_type = Types::Interface.new(
@@ -893,6 +889,8 @@ module RBS
           end
 
           include_members.each do |member|
+            NoMixinFoundError.check!(member.name, env: env, member: member)
+
             mixin = build_interface(member.name)
 
             args = member.args
@@ -957,7 +955,8 @@ module RBS
     end
 
     def expand_alias(type_name)
-      env.alias_decls[type_name].decl.type
+      entry = env.alias_decls[type_name] or raise "Unknown name for expand_alias: #{type_name}"
+      entry.decl.type
     end
   end
 end

data/lib/rbs/environment.rb

@@ -34,56 +34,49 @@ module RBS
 
       def insert(decl:, outer:)
         decls << D.new(decl: decl, outer: outer)
+        @primary = nil
       end
 
-      def type_params
-        primary.decl.type_params
-      end
-    end
+      def validate_type_params
+        unless decls.empty?
+          hd_decl, *tl_decls = decls
+          hd_params = hd_decl.decl.type_params
+          hd_names = hd_params.params.map(&:name)
 
-    class ModuleEntry < MultiEntry
-      def insert(decl:, outer:)
-        unless decl.is_a?(AST::Declarations::Module)
-          raise MixedClassModuleDeclarationError.new(name: name, decl: decl)
-        end
+          tl_decls.each do |tl_decl|
+            tl_params = tl_decl.decl.type_params
 
-        unless decls.empty?
-          names = decls[0].decl.type_params.each.map(&:name)
-          unless names.size == decl.type_params.each.size && decls[0].decl.type_params == decl.type_params.rename_to(names)
-            raise GenericParameterMismatchError.new(name: name, decl: decl)
+            unless hd_params.size == tl_params.size && hd_params == tl_params.rename_to(hd_names)
+              raise GenericParameterMismatchError.new(name: name, decl: tl_decl.decl)
+            end
           end
         end
+      end
 
-        super(decl: decl, outer: outer)
+      def type_params
+        primary.decl.type_params
       end
+    end
 
-      def primary
-        @primary ||= decls.find {|d| d.decl.self_type } || decls.first
+    class ModuleEntry < MultiEntry
+      def self_types
+        decls.flat_map do |d|
+          d.decl.self_types
+        end.uniq
       end
 
-      def self_type
-        primary.decl.self_type
+      def primary
+        @primary ||= begin
+                       validate_type_params
+                       decls.first
+                     end
       end
     end
 
     class ClassEntry < MultiEntry
-      def insert(decl:, outer:)
-        unless decl.is_a?(AST::Declarations::Class)
-          raise MixedClassModuleDeclarationError.new(name: name, decl: decl)
-        end
-
-        unless decls.empty?
-          names = decls[0].decl.type_params.each.map(&:name)
-          unless names.size == decl.type_params.each.size && decls[0].decl.type_params == decl.type_params.rename_to(names)
-            raise GenericParameterMismatchError.new(name: name, decl: decl)
-          end
-        end
-
-        super(decl: decl, outer: outer)
-      end
-
       def primary
         @primary ||= begin
+                       validate_type_params
                        decls.find {|d| d.decl.super_class } || decls.first
                      end
       end
@@ -157,7 +150,18 @@ module RBS
           end
         end
 
-        class_decls[name].insert(decl: decl, outer: outer)
+        existing_entry = class_decls[name]
+
+        case
+        when decl.is_a?(AST::Declarations::Module) && existing_entry.is_a?(ModuleEntry)
+          # OK
+        when decl.is_a?(AST::Declarations::Class) && existing_entry.is_a?(ClassEntry)
+          # OK
+        else
+          raise DuplicatedDeclarationError.new(name, decl, existing_entry.primary.decl)
+        end
+
+        existing_entry.insert(decl: decl, outer: outer)
 
         prefix = outer + [decl]
         ns = name.to_namespace
@@ -255,8 +259,12 @@ module RBS
         AST::Declarations::Module.new(
           name: decl.name.with_prefix(prefix),
           type_params: decl.type_params,
-          self_type: decl.self_type&.yield_self do |self_type|
-            absolute_type(resolver, self_type, context: context)
+          self_types: decl.self_types.map do |module_self|
+            AST::Declarations::Module::Self.new(
+              name: absolute_type_name(resolver, module_self.name, context: context),
+              args: module_self.args.map {|type| absolute_type(resolver, type, context: context) },
+              location: module_self.location
+            )
           end,
           members: decl.members.map do |member|
             case member
@@ -406,5 +414,10 @@ module RBS
         absolute_type_name(resolver, name, context: context)
       end
     end
+
+    def inspect
+      ivars = %i[@buffers @declarations @class_decls @interface_decls @alias_decls @constant_decls @global_decls]
+      "\#<RBS::Environment #{ivars.map { |iv| "#{iv}=(#{instance_variable_get(iv).size} items)"}.join(' ')}>"
+    end
   end
 end