rbs 0.6.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce3b2807a94277727870ef841bdb1e3a96567098948930ab6885e9fba2fc3ccf
-  data.tar.gz: 5d4a01b26887124240ec757b8a0374c79d56c3daf8b32431a571a3ba401112cc
+  metadata.gz: 29535fcd236ba4d658d2c975b5084aa58b125203c4aaa1ec4704881b92ed89c7
+  data.tar.gz: 71e165ea5cb1ccbf1b48e9683201f6058dc7c95c7a7619865bf26af2cb6485ad
 SHA512:
-  metadata.gz: 7978edfd75f809eb604edb58e0c35ff9a1e85b0e34f7462399f76deb36c5a6a0c61030d1fc3a3bb42d689395a0372995e03e41dd47223063084703dc207294d6
-  data.tar.gz: e1216599f496cd883e8b301d1040f395984d3fc3029ba65fa6c2f63ab3e431a96bc8369ff06bd3f97390dd78e0a10279e1e556ba2c25ac4ef5af6dfaf9aafa77
+  metadata.gz: 236e10d6a7372a1c9b3c07a343a4620048c3f269f750e74f82539fd819f690475deb52090eec0cf38bc338344d240586f44941339bea7759066f68f90c5a3bdb
+  data.tar.gz: 8ef6ef34e9b39c310f70138135589611c31c8840fdea06eaa606b5004fc5d6634882ddd169b030dd4140645ad9d18c7a4a796a8bba88cd917ea1a69b461efdd1

data/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 ## master
 
+## 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)
+* Bug fix in ConstantTable [#340](https://github.com/ruby/rbs/pull/340)
+* Make `rbs validate` faster [#338](https://github.com/ruby/rbs/pull/338)
+* Dedup methods generated by `rbs prototype rb` [#334](https://github.com/ruby/rbs/pull/334)
+
 ## 0.6.0 (2020-07-12)
 
 * Signature update for `Logger`.

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/cli.rb

@@ -66,6 +66,10 @@ module RBS
       opts
     end
 
+    def has_parser?
+      defined?(RubyVM::AbstractSyntaxTree)
+    end
+
     def run(args)
       options = LibraryOptions.new
 
@@ -409,6 +413,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 +423,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 +606,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 +626,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

data/lib/rbs/constant_table.rb

@@ -152,7 +152,7 @@ module RBS
         constant_scopes_module name, scopes: scopes
 
       else
-        raise "Unexpected declaration: #{name} (#{decl.class})"
+        raise "Unexpected declaration: #{name} (#{entry.class})"
       end
 
       scopes

data/lib/rbs/definition.rb

@@ -50,11 +50,13 @@ module RBS
       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,7 +76,7 @@ module RBS
       end
 
       def annotations
-        @annotations ||= defs.flat_map(&:annotations)
+        @annotations ||= @extra_annotations + defs.flat_map(&:annotations)
       end
 
       # @deprecated

data/lib/rbs/definition_builder.rb

@@ -13,6 +13,77 @@ module RBS
     attr_reader :instance_ancestors_cache
     attr_reader :singleton_ancestor_cache
 
+    attr_reader :one_instance_ancestors_cache
+    attr_reader :one_singleton_ancestors_cache
+
+    class OneAncestors
+      attr_reader :type_name
+      attr_reader :params
+      attr_reader :super_class
+      attr_reader :self_types
+      attr_reader :included_modules
+      attr_reader :prepended_modules
+      attr_reader :extended_modules
+
+      def initialize(type_name:, params:, super_class:, self_types:, included_modules:, prepended_modules:, extended_modules:)
+        @type_name = type_name
+        @params = params
+        @super_class = super_class
+        @self_types = self_types
+        @included_modules = included_modules
+        @prepended_modules = prepended_modules
+        @extended_modules = extended_modules
+      end
+
+      def each_ancestor(&block)
+        if block_given?
+          yield super_class if super_class
+          self_types&.each(&block)
+          included_modules&.each(&block)
+          prepended_modules&.each(&block)
+          extended_modules&.each(&block)
+        else
+          enum_for :each_ancestor
+        end
+      end
+
+      def self.class_instance(type_name:, params:, super_class:)
+        new(
+          type_name: type_name,
+          params: params,
+          super_class: super_class,
+          self_types: nil,
+          included_modules: [],
+          prepended_modules: [],
+          extended_modules: nil
+        )
+      end
+
+      def self.singleton(type_name:, super_class:)
+        new(
+          type_name: type_name,
+          params: nil,
+          super_class: super_class,
+          self_types: nil,
+          included_modules: nil,
+          prepended_modules: nil,
+          extended_modules: []
+        )
+      end
+
+      def self.module_instance(type_name:, params:)
+        new(
+          type_name: type_name,
+          params: params,
+          self_types: [],
+          included_modules: [],
+          prepended_modules: [],
+          super_class: nil,
+          extended_modules: nil
+        )
+      end
+    end
+
     def initialize(env:)
       @env = env
       @type_name_resolver = TypeNameResolver.from_env(env)
@@ -26,6 +97,9 @@ module RBS
 
       @instance_ancestors_cache = {}
       @singleton_ancestor_cache = {}
+
+      @one_instance_ancestors_cache = {}
+      @one_singleton_ancestors_cache = {}
     end
 
     def validate_super_class!(type_name, entry)
@@ -45,30 +119,19 @@ module RBS
       raise SuperclassMismatchError.new(name: type_name, super_classes: super_types, entry: entry)
     end
 
-    def instance_ancestors(type_name, building_ancestors: [])
-      as = instance_ancestors_cache[type_name] and return as
+    def one_instance_ancestors(type_name)
+      as = one_instance_ancestors_cache[type_name] and return as
 
-      entry = env.class_decls[type_name] or raise "Unknown name for instance_ancestors: #{type_name}"
+      entry = env.class_decls[type_name] or raise "Unknown name for one_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)
-
-      RecursiveAncestorError.check!(self_ancestor,
-                                    ancestors: building_ancestors,
-                                    location: entry.primary.decl.location)
-      building_ancestors.push self_ancestor
-
-      ancestors = []
 
       case entry
       when Environment::ClassEntry
         validate_super_class!(type_name, entry)
+        primary = entry.primary
+        super_class = primary.decl.super_class
 
-        # Super class comes last
-        if self_ancestor.name != BuiltinNames::BasicObject.name
-          primary = entry.primary
-          super_class = primary.decl.super_class
-
+        if type_name != BuiltinNames::BasicObject.name
           if super_class
             super_name = super_class.name
             super_args = super_class.args
@@ -79,46 +142,49 @@ module RBS
 
           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))
+          ancestors = OneAncestors.class_instance(
+            type_name: type_name,
+            params: params,
+            super_class: Definition::Ancestor::Instance.new(name: super_name, args: super_args)
+          )
+        else
+          ancestors = OneAncestors.class_instance(
+            type_name: type_name,
+            params: params,
+            super_class: nil
+          )
         end
-
-        build_ancestors_mixin_self(self_ancestor, entry, ancestors: ancestors, building_ancestors: building_ancestors)
-
       when Environment::ModuleEntry
-        build_ancestors_mixin_self(self_ancestor, entry, ancestors: ancestors, building_ancestors: building_ancestors)
+        ancestors = OneAncestors.module_instance(type_name: type_name, params: params)
 
+        entry.self_types.each do |module_self|
+          NoSelfTypeFoundError.check!(module_self, env: env)
+          ancestors.self_types.push Definition::Ancestor::Instance.new(name: module_self.name, args: module_self.args)
+        end
+      else
+        raise "Unexpected entry for: #{type_name}"
       end
 
-      building_ancestors.pop
+      mixin_ancestors(entry,
+                      included_modules: ancestors.included_modules,
+                      prepended_modules: ancestors.prepended_modules,
+                      extended_modules: nil)
 
-      instance_ancestors_cache[type_name] = Definition::InstanceAncestors.new(
-        type_name: type_name,
-        params: params,
-        ancestors: ancestors
-      )
+      one_instance_ancestors_cache[type_name] = ancestors
     end
 
-    def singleton_ancestors(type_name, building_ancestors: [])
-      as = singleton_ancestor_cache[type_name] and return as
+    def one_singleton_ancestors(type_name)
+      as = one_singleton_ancestors_cache[type_name] and return as
 
-      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,
-                                    ancestors: building_ancestors,
-                                    location: entry.primary.decl.location)
-      building_ancestors.push self_ancestor
-
-      ancestors = []
+      entry = env.class_decls[type_name] or raise "Unknown name for one_singleton_ancestors: #{type_name}"
 
       case entry
       when Environment::ClassEntry
-        # Super class comes last
-        if self_ancestor.name != BuiltinNames::BasicObject.name
-          primary = entry.primary
-          super_class = primary.decl.super_class
+        validate_super_class!(type_name, entry)
+        primary = entry.primary
+        super_class = primary.decl.super_class
 
+        if type_name != BuiltinNames::BasicObject.name
           if super_class
             super_name = super_class.name
           else
@@ -127,47 +193,35 @@ module RBS
 
           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)
+          ancestors = OneAncestors.singleton(
+            type_name: type_name,
+            super_class: Definition::Ancestor::Singleton.new(name: super_name)
+          )
         else
-          as = instance_ancestors(BuiltinNames::Class.name, building_ancestors: building_ancestors)
-          ancestors.unshift(*as.apply([], location: entry.primary.decl.location))
+          ancestors = OneAncestors.singleton(
+            type_name: type_name,
+            super_class: Definition::Ancestor::Instance.new(name: BuiltinNames::Class.name, args: [])
+          )
         end
-
       when Environment::ModuleEntry
-        as = instance_ancestors(BuiltinNames::Module.name, building_ancestors: building_ancestors)
-        ancestors.unshift(*as.apply([], location: entry.primary.decl.location))
-      end
-
-      # Extend comes next
-      entry.decls.each do |d|
-        decl = d.decl
-
-        decl.each_mixin do |member|
-          case member
-          when AST::Members::Extend
-            if member.name.class?
-              NoMixinFoundError.check!(member.name, env: env, member: member)
+        ancestors = OneAncestors.singleton(
+          type_name: type_name,
+          super_class: Definition::Ancestor::Instance.new(name: BuiltinNames::Module.name, args: [])
+        )
 
-              module_ancestors = instance_ancestors(member.name, building_ancestors: building_ancestors)
-              ancestors.unshift(*module_ancestors.apply(member.args, location: member.location))
-            end
-          end
-        end
+      else
+        raise "Unexpected entry for: #{type_name}"
       end
 
-      ancestors.unshift self_ancestor
-
-      building_ancestors.pop
+      mixin_ancestors(entry,
+                      included_modules: nil,
+                      prepended_modules: nil,
+                      extended_modules: ancestors.extended_modules)
 
-      singleton_ancestor_cache[type_name] = Definition::SingletonAncestors.new(
-        type_name: type_name,
-        ancestors: ancestors
-      )
+      one_singleton_ancestors_cache[type_name] = ancestors
     end
 
-    def build_ancestors_mixin_self(self_ancestor, entry, ancestors:, building_ancestors:)
-      # Include comes next
+    def mixin_ancestors(entry, included_modules:, extended_modules:, prepended_modules:)
       entry.decls.each do |d|
         decl = d.decl
 
@@ -179,42 +233,143 @@ module RBS
         decl.each_mixin do |member|
           case member
           when AST::Members::Include
-            if member.name.class?
+            if included_modules
+              NoMixinFoundError.check!(member.name, env: env, member: member)
+
+              module_name = member.name
+              module_args = member.args.map {|type| type.sub(align_params) }
+
+              included_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args)
+            end
+
+          when AST::Members::Prepend
+            if prepended_modules
               NoMixinFoundError.check!(member.name, env: env, member: member)
 
               module_name = member.name
               module_args = member.args.map {|type| type.sub(align_params) }
 
-              module_ancestors = instance_ancestors(module_name, building_ancestors: building_ancestors)
-              ancestors.unshift(*module_ancestors.apply(module_args, location: member.location))
+              prepended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args)
+            end
+
+          when AST::Members::Extend
+            if extended_modules
+              NoMixinFoundError.check!(member.name, env: env, member: member)
+
+              module_name = member.name
+              module_args = member.args
+
+              extended_modules << Definition::Ancestor::Instance.new(name: module_name, args: module_args)
             end
           end
         end
       end
+    end
+
+    def instance_ancestors(type_name, building_ancestors: [])
+      as = instance_ancestors_cache[type_name] and return as
+
+      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)
+
+      RecursiveAncestorError.check!(self_ancestor,
+                                    ancestors: building_ancestors,
+                                    location: entry.primary.decl.location)
+      building_ancestors.push self_ancestor
+
+      one_ancestors = one_instance_ancestors(type_name)
+
+      ancestors = []
+
+      case entry
+      when Environment::ClassEntry
+        if one_ancestors.super_class
+          super_name = one_ancestors.super_class.name
+          super_args = one_ancestors.super_class.args
+
+          super_ancestors = instance_ancestors(super_name, building_ancestors: building_ancestors)
+          ancestors.unshift(*super_ancestors.apply(super_args, location: entry.primary.decl.location))
+        end
+      end
+
+      one_ancestors.included_modules.each do |mod|
+        if mod.name.class?
+          name = mod.name
+          args = mod.args
+          mod_ancestors = instance_ancestors(name, building_ancestors: building_ancestors)
+          ancestors.unshift(*mod_ancestors.apply(args, location: entry.primary.decl.location))
+        end
+      end
 
-      # Self
       ancestors.unshift(self_ancestor)
 
-      # Prepends
-      entry.decls.each do |d|
-        decl = d.decl
+      one_ancestors.prepended_modules.each do |mod|
+        if mod.name.class?
+          name = mod.name
+          args = mod.args
+          mod_ancestors = instance_ancestors(name, building_ancestors: building_ancestors)
+          ancestors.unshift(*mod_ancestors.apply(args, location: entry.primary.decl.location))
+        end
+      end
 
-        align_params = Substitution.build(decl.type_params.each.map(&:name),
-                                          Types::Variable.build(entry.type_params.each.map(&:name)))
+      building_ancestors.pop
 
-        decl.each_mixin do |member|
-          case member
-          when AST::Members::Prepend
-            NoMixinFoundError.check!(member.name, env: env, member: member)
+      instance_ancestors_cache[type_name] = Definition::InstanceAncestors.new(
+        type_name: type_name,
+        params: params,
+        ancestors: ancestors
+      )
+    end
 
-            module_name = member.name
-            module_args = member.args.map {|type| type.sub(align_params) }
+    def singleton_ancestors(type_name, building_ancestors: [])
+      as = singleton_ancestor_cache[type_name] and return as
 
-            module_ancestors = instance_ancestors(module_name, building_ancestors: building_ancestors)
-            ancestors.unshift(*module_ancestors.apply(module_args))
-          end
+      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,
+                                    ancestors: building_ancestors,
+                                    location: entry.primary.decl.location)
+      building_ancestors.push self_ancestor
+
+      one_ancestors = one_singleton_ancestors(type_name)
+
+      ancestors = []
+
+      case one_ancestors.super_class
+      when Definition::Ancestor::Instance
+        super_name = one_ancestors.super_class.name
+        super_args = one_ancestors.super_class.args
+
+        super_ancestors = instance_ancestors(super_name, building_ancestors: building_ancestors)
+        ancestors.unshift(*super_ancestors.apply(super_args, location: entry.primary.decl.location))
+
+      when Definition::Ancestor::Singleton
+        super_name = one_ancestors.super_class.name
+
+        super_ancestors = singleton_ancestors(super_name, building_ancestors: [])
+        ancestors.unshift(*super_ancestors.ancestors)
+      end
+
+      one_ancestors.extended_modules.each do |mod|
+        if mod.name.class?
+          name = mod.name
+          args = mod.args
+          mod_ancestors = instance_ancestors(name, building_ancestors: building_ancestors)
+          ancestors.unshift(*mod_ancestors.apply(args, location: entry.primary.decl.location))
         end
       end
+
+      ancestors.unshift(self_ancestor)
+
+      building_ancestors.pop
+
+      singleton_ancestor_cache[type_name] = Definition::SingletonAncestors.new(
+        type_name: type_name,
+        ancestors: ancestors
+      )
     end
 
     def each_member_with_accessibility(members, accessibility: :public)
@@ -230,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
@@ -279,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
@@ -769,7 +934,8 @@ module RBS
                     implemented_in: nil
                   )
                 end,
-                accessibility: :public
+                accessibility: :public,
+                annotations: [AST::Annotation.new(location: nil, string: "rbs:test:target")]
               )
             end
           end
@@ -838,7 +1004,7 @@ module RBS
       methods[name] = Definition::Method.new(
         super_method: super_method,
         accessibility: method.accessibility,
-        defs: method.defs.map {|defn| defn.update(type: defn.type.sub(sub)) }
+        defs: sub.mapping.empty? ? method.defs : method.defs.map {|defn| defn.update(type: defn.type.sub(sub)) }
       )
     end
 
@@ -865,6 +1031,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,
@@ -956,6 +1123,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