rbs 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce3b2807a94277727870ef841bdb1e3a96567098948930ab6885e9fba2fc3ccf
-  data.tar.gz: 5d4a01b26887124240ec757b8a0374c79d56c3daf8b32431a571a3ba401112cc
+  metadata.gz: d175f17e9f1226e0cb0d37c2167b3b52b0e736661d1406937922194c68adfd54
+  data.tar.gz: 204d38937da751f3ea15dfd64370e379689e54f264b63be54e6c4843c4827579
 SHA512:
-  metadata.gz: 7978edfd75f809eb604edb58e0c35ff9a1e85b0e34f7462399f76deb36c5a6a0c61030d1fc3a3bb42d689395a0372995e03e41dd47223063084703dc207294d6
-  data.tar.gz: e1216599f496cd883e8b301d1040f395984d3fc3029ba65fa6c2f63ab3e431a96bc8369ff06bd3f97390dd78e0a10279e1e556ba2c25ac4ef5af6dfaf9aafa77
+  metadata.gz: 242ffa432db2a94a59636be87e261411c0bf465ac170b6f5b52955cb671d2c70e6eaed7dc74b489868117fcaa360df33c16ed6e2e472edd96663491c1211d793
+  data.tar.gz: 6ccb639e3a73a7e4794f906e9e125dd173d0406198a11511592e3c3492126c31a5ff1798010087fb19d4eb053ba46140e42f869b913ae3b7aaee20303ef3f92c

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## master
 
+## 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/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_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
-
-      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
+    def one_singleton_ancestors(type_name)
+      as = one_singleton_ancestors_cache[type_name] and return as
 
-      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
+      mixin_ancestors(entry,
+                      included_modules: nil,
+                      prepended_modules: nil,
+                      extended_modules: ancestors.extended_modules)
 
-      building_ancestors.pop
-
-      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)
@@ -838,7 +993,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
 

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/parser.y

@@ -520,7 +520,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)

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

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbs
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-12 00:00:00.000000000 Z
+date: 2020-07-20 00:00:00.000000000 Z
 dependencies: []
 description: RBS is the language for type signatures for Ruby and standard library
   definitions.