rbs 2.8.4 → 3.0.0.dev.2

data/lib/rbs/environment_loader.rb

@@ -60,25 +60,26 @@ module RBS
 
     def resolve_dependencies(library:, version:)
       [Collection::Sources::Rubygems.instance, Collection::Sources::Stdlib.instance].each do |source|
-        # @type var gem: { 'name' => String, 'version' => String? }
-        gem = { 'name' => library, 'version' => version }
-        next unless source.has?(gem)
+        next unless source.has?(library, version)
 
-        gem['version'] ||= source.versions(gem).last
-        source.dependencies_of(gem)&.each do |dep|
+        unless version
+          version = source.versions(library).last or raise
+        end
+
+        source.dependencies_of(library, version)&.each do |dep|
           add(library: dep['name'], version: nil)
         end
         return
       end
     end
 
-    def add_collection(collection_config)
-      collection_config.check_rbs_availability!
+    def add_collection(lockfile)
+      lockfile.check_rbs_availability!
 
-      repository.add(collection_config.repo_path)
+      repository.add(lockfile.fullpath)
 
-      collection_config.gems.each do |gem|
-        add(library: gem['name'], version: gem['version'], resolve_dependencies: false)
+      lockfile.gems.each_value do |gem|
+        add(library: gem[:name], version: gem[:version], resolve_dependencies: false)
       end
     end
 
@@ -94,9 +95,11 @@ module RBS
       # @type var loaded: Array[[AST::Declarations::t, Pathname, source]]
       loaded = []
 
-      each_decl do |decl, buf, source, path|
-        env << decl
-        loaded << [decl, path, source]
+      each_signature do |source, path, buffer, decls, dirs|
+        decls.each do |decl|
+          loaded << [decl, path, source]
+        end
+        env.add_signature(buffer: buffer, directives: dirs, decls: decls)
       end
 
       loaded
@@ -147,7 +150,7 @@ module RBS
       end
     end
 
-    def each_decl
+    def each_signature
       files = Set[]
 
       each_dir do |source, dir|
@@ -159,9 +162,9 @@ module RBS
           files << path
           buffer = Buffer.new(name: path.to_s, content: path.read(encoding: "UTF-8"))
 
-          Parser.parse_signature(buffer).each do |decl|
-            yield decl, buffer, source, path
-          end
+          _, dirs, decls = Parser.parse_signature(buffer)
+
+          yield source, path, buffer, decls, dirs
         end
       end
     end

data/lib/rbs/environment_walker.rb

@@ -36,7 +36,7 @@ module RBS
       env.interface_decls.each_key do |type_name|
         yield TypeNameNode.new(type_name: type_name)
       end
-      env.alias_decls.each_key do |type_name|
+      env.type_alias_decls.each_key do |type_name|
         yield TypeNameNode.new(type_name: type_name)
       end
     end

data/lib/rbs/errors.rb

@@ -119,19 +119,7 @@ module RBS
     end
 
     def self.check!(type_name, env:, location:)
-      dic = case
-            when type_name.class?
-              env.class_decls
-            when type_name.alias?
-              env.alias_decls
-            when type_name.interface?
-              env.interface_decls
-            else
-              raise
-            end
-
-      dic.key?(type_name) or raise new(type_name: type_name, location: location)
-
+      env.type_name?(type_name) or raise new(type_name: type_name, location: location)
       type_name
     end
   end
@@ -148,7 +136,7 @@ module RBS
     end
 
     def self.check!(type_name, env:, location:)
-      if decl = env.class_decls[type_name]
+      if env.module_name?(type_name)
         return
       end
 
@@ -166,7 +154,7 @@ module RBS
     end
 
     def self.check!(super_decl, env:)
-      return if env.class_decls[super_decl.name].is_a?(Environment::ClassEntry)
+      return if env.class_decl?(super_decl.name) || env.class_alias?(super_decl.name)
 
       raise new(super_decl)
     end
@@ -186,16 +174,7 @@ module RBS
     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
-            else
-              raise
-            end
-
-      dic.key?(type_name) or raise new(type_name: type_name, location: self_type.location)
+      (env.module_name?(type_name) || env.interface_name?(type_name)) or raise new(type_name: type_name, location: self_type.location)
     end
   end
 
@@ -215,16 +194,7 @@ module RBS
     end
 
     def self.check!(type_name, env:, member:)
-      dic = case
-            when type_name.class?
-              env.class_decls
-            when type_name.interface?
-              env.interface_decls
-            else
-              raise
-            end
-
-      dic.key?(type_name) or raise new(type_name: type_name, member: member)
+      (env.module_name?(type_name) || env.interface_name?(type_name)) or raise new(type_name: type_name, member: member)
     end
   end
 
@@ -416,8 +386,7 @@ module RBS
     end
 
     def self.check!(type_name:, env:, member:)
-      case env.class_decls[member.name]
-      when Environment::ClassEntry
+      if env.class_decl?(member.name)
         raise new(type_name: type_name, member: member)
       end
     end
@@ -478,4 +447,32 @@ module RBS
       super "#{Location.to_string(location)}: Cyclic type parameter bound is prohibited"
     end
   end
+
+  class InconsistentClassModuleAliasError < BaseError
+    attr_reader :alias_entry
+
+    def initialize(entry)
+      @alias_entry = entry
+
+      expected_kind, actual_kind =
+        case entry
+        when Environment::ModuleAliasEntry
+          ["module", "class"]
+        when Environment::ClassAliasEntry
+          ["class", "module"]
+        end
+
+      super "#{Location.to_string(entry.decl.location&.[](:old_name))}: A #{expected_kind} `#{entry.decl.new_name}` cannot be an alias of a #{actual_kind} `#{entry.decl.old_name}`"
+    end
+  end
+
+  class CyclicClassAliasDefinitionError < BaseError
+    attr_reader :alias_entry
+
+    def initialize(entry)
+      @alias_entry = entry
+
+      super "#{Location.to_string(entry.decl.location&.[](:old_name))}: A #{alias_entry.decl.new_name} is a cyclic definition"
+    end
+  end
 end

data/lib/rbs/locator.rb

@@ -95,7 +95,7 @@ module RBS
         when AST::Declarations::Constant, AST::Declarations::Global
           find_in_type(pos, array: array, type: decl.type) and return true
 
-        when AST::Declarations::Alias
+        when AST::Declarations::TypeAlias
           find_in_type(pos, array: array, type: decl.type) and return true
         end
 
@@ -113,8 +113,8 @@ module RBS
 
         case member
         when AST::Members::MethodDefinition
-          member.types.each do |method_type|
-            find_in_method_type(pos, array: array, method_type: method_type) and return true
+          member.overloads.each do |overload|
+            find_in_method_type(pos, array: array, method_type: overload.method_type) and return true
           end
         when AST::Members::InstanceVariable, AST::Members::ClassInstanceVariable, AST::Members::ClassVariable
           find_in_type(pos, array: array, type: member.type) and return true

data/lib/rbs/parser_aux.rb

@@ -2,19 +2,21 @@
 
 module RBS
   class Parser
-    def self.parse_type(source, line: nil, column: nil, range: nil, variables: [])
+    def self.parse_type(source, range: 0..., variables: [])
       buf = buffer(source)
-      _parse_type(buf, range&.begin || 0, range&.end || buf.last_position, variables, range.nil?)
+      _parse_type(buf, range.begin || 0, range.end || buf.last_position, variables)
     end
 
-    def self.parse_method_type(source, line: nil, column: nil, range: nil, variables: [])
+    def self.parse_method_type(source, range: 0..., variables: [])
       buf = buffer(source)
-      _parse_method_type(buf, range&.begin || 0, range&.end || buf.last_position, variables, range.nil?)
+      _parse_method_type(buf, range.begin || 0, range.end || buf.last_position, variables)
     end
 
-    def self.parse_signature(source, line: nil, column: nil)
+    def self.parse_signature(source)
       buf = buffer(source)
-      _parse_signature(buf, buf.last_position)
+      dirs, decls = _parse_signature(buf, buf.last_position)
+
+      [buf, dirs, decls]
     end
 
     def self.buffer(source)

data/lib/rbs/prototype/helpers.rb

@@ -7,27 +7,43 @@ module RBS
 
       def block_from_body(node)
         _, args_node, body_node = node.children
+        _pre_num, _pre_init, _opt, _first_post, _post_num, _post_init, _rest, _kw, _kwrest, block_var = args_from_node(args_node)
 
-        _pre_num, _pre_init, _opt, _first_post, _post_num, _post_init, _rest, _kw, _kwrest, block = args_from_node(args_node)
+        # @type var body_node: node?
+        if body_node
+          yields = any_node?(body_node) {|n| n.type == :YIELD }
+        end
+
+        if yields || block_var
+          required = true
+
+          if body_node
+            if any_node?(body_node) {|n| n.type == :FCALL && n.children[0] == :block_given? && !n.children[1] }
+              required = false
+            end
+          end
+
+          if _rest == :* && block_var == :&
+            # ... is given
+            required = false
+          end
 
-        method_block = nil
+          if block_var
+            if body_node
+              usage = NodeUsage.new(body_node)
+              if usage.each_conditional_node.any? {|n| n.type == :LVAR && n.children[0] == block_var }
+                required = false
+              end
+            end
+          end
 
-        if block
           method_block = Types::Block.new(
-            required: false,
+            required: required,
             type: Types::Function.empty(untyped),
             self_type: nil
           )
-        end
-
-        if body_node
-          if (yields = any_node?(body_node) {|n| n.type == :YIELD })
-            method_block = Types::Block.new(
-              required: true,
-              type: Types::Function.empty(untyped),
-              self_type: nil
-            )
 
+          if yields
             yields.each do |yield_node|
               array_content = yield_node.children[0]&.children&.compact || []
 

data/lib/rbs/prototype/node_usage.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RBS
+  module Prototype
+    class NodeUsage
+      include Helpers
+
+      attr_reader :conditional_nodes
+
+      def initialize(node)
+        @node = node
+        @conditional_nodes = Set[].compare_by_identity
+
+        calculate(node, conditional: false)
+      end
+
+      def each_conditional_node(&block)
+        if block
+          conditional_nodes.each(&block)
+        else
+          conditional_nodes.each
+        end
+      end
+
+      def calculate(node, conditional:)
+        if conditional
+          conditional_nodes << node
+        end
+
+        case node.type
+        when :IF, :UNLESS
+          cond_node, true_node, false_node = node.children
+          calculate(cond_node, conditional: true)
+          calculate(true_node, conditional: conditional) if true_node
+          calculate(false_node, conditional: conditional) if false_node
+        when :AND, :OR
+          left, right = node.children
+          calculate(left, conditional: true)
+          calculate(right, conditional: conditional)
+        when :QCALL
+          receiver, _, args = node.children
+          calculate(receiver, conditional: true)
+          calculate(args, conditional: false) if args
+        when :WHILE
+          cond, body = node.children
+          calculate(cond, conditional: true)
+          calculate(body, conditional: false) if body
+        when :OP_ASGN_OR, :OP_ASGN_AND
+          var, _, asgn = node.children
+          calculate(var, conditional: true)
+          calculate(asgn, conditional: conditional)
+        when :LASGN, :IASGN, :GASGN
+          _, lhs = node.children
+          calculate(lhs, conditional: conditional) if lhs
+        when :MASGN
+          lhs, _ = node.children
+          calculate(lhs, conditional: conditional)
+        when :CDECL
+          if node.children.size == 2
+            _, lhs = node.children
+            calculate(lhs, conditional: conditional)
+          else
+            const, _, lhs = node.children
+            calculate(const, conditional: false)
+            calculate(lhs, conditional: conditional)
+          end
+        when :SCOPE
+          _, _, body = node.children
+          calculate(body, conditional: conditional)
+        when :CASE2
+          _, *branches = node.children
+          branches.each do |branch|
+            if branch.type == :WHEN
+              list, body = branch.children
+              list.children.each do |child|
+                if child
+                  calculate(child, conditional: true)
+                end
+              end
+              calculate(body, conditional: conditional)
+            else
+              calculate(branch, conditional: conditional)
+            end
+          end
+        when :BLOCK
+          *nodes, last = node.children
+          nodes.each do |no|
+            calculate(no, conditional: false)
+          end
+          calculate(last, conditional: conditional) if last
+        else
+          each_child(node) do |child|
+            calculate(child, conditional: false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/prototype/rb.rb

@@ -186,10 +186,11 @@ module RBS
             name: def_name,
             location: nil,
             annotations: [],
-            types: types,
+            overloads: types.map {|type| AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: type )},
             kind: kind,
             comment: comments[node.first_lineno - 1],
-            overload: false
+            overloading: false,
+            visibility: nil
           )
 
           decls.push member unless decls.include?(member)

data/lib/rbs/prototype/rbi.rb

@@ -185,10 +185,11 @@ module RBS
               name: node.children[1],
               location: nil,
               annotations: [],
-              types: types,
+              overloads: types.map {|type| AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: type) },
               kind: :singleton,
               comment: comment,
-              overload: false
+              overloading: false,
+              visibility: nil
             )
           end
 
@@ -205,10 +206,11 @@ module RBS
               name: node.children[0],
               location: nil,
               annotations: [],
-              types: types,
+              overloads: types.map {|type| AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: type) },
               kind: :instance,
               comment: comment,
-              overload: false
+              overloading: false,
+              visibility: nil
             )
           end
 

data/lib/rbs/prototype/runtime.rb

@@ -187,18 +187,22 @@ module RBS
             if method
               members << AST::Members::MethodDefinition.new(
                 name: method_name,
-                types: method.method_types.map {|type|
-                  type.update.tap do |ty|
-                    def ty.to_s
-                      location.source
+                overloads: method.method_types.map {|type|
+                  AST::Members::MethodDefinition::Overload.new(
+                    annotations: [],
+                    method_type: type.update.tap do |ty|
+                      def ty.to_s
+                        location.source
+                      end
                     end
-                  end
+                  )
                 },
                 kind: kind,
                 location: nil,
                 comment: method.comments[0],
                 annotations: method.annotations,
-                overload: false
+                overloading: false,
+                visibility: nil
               )
               return
             end
@@ -231,12 +235,15 @@ module RBS
 
               members << AST::Members::MethodDefinition.new(
                 name: method.name,
-                types: [method_type(method)],
+                overloads: [
+                  AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: method_type(method))
+                ],
                 kind: :singleton,
                 location: nil,
                 comment: nil,
                 annotations: [],
-                overload: false
+                overloading: false,
+                visibility: nil
               )
             end
           else
@@ -264,12 +271,15 @@ module RBS
 
                 members << AST::Members::MethodDefinition.new(
                   name: method.name,
-                  types: [method_type(method)],
+                  overloads: [
+                    AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: method_type(method))
+                  ],
                   kind: :instance,
                   location: nil,
                   comment: nil,
                   annotations: [],
-                  overload: false
+                  overloading: false,
+                  visibility: nil
                 )
               end
             else
@@ -298,12 +308,15 @@ module RBS
 
                 members << AST::Members::MethodDefinition.new(
                   name: method.name,
-                  types: [method_type(method)],
+                  overloads: [
+                    AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: method_type(method))
+                  ],
                   kind: :instance,
                   location: nil,
                   comment: nil,
                   annotations: [],
-                  overload: false
+                  overloading: false,
+                  visibility: nil
                 )
               end
             else

data/lib/rbs/resolver/constant_resolver.rb

@@ -18,20 +18,33 @@ module RBS
           end
 
           environment.class_decls.each do |name, entry|
+            constant = constant_of_module(name, entry)
+
             unless name.namespace.empty?
               parent = name.namespace.to_type_name
-
               table = children_table[parent] or raise
-              constant = constant_of_module(name, entry)
             else
               table = toplevel
-              constant = constant_of_module(name, entry)
             end
 
             table[name.name] = constant
             constants_table[name] = constant
           end
 
+          environment.class_alias_decls.each do |name, entry|
+            normalized_entry = environment.normalized_module_class_entry(name) or next
+            constant = constant_of_module(name, normalized_entry)
+
+            # Insert class/module aliases into `children_table` and `toplevel` table
+            unless name.namespace.empty?
+              normalized_parent = environment.normalize_module_name?(name.namespace.to_type_name) or raise
+              table = children_table[normalized_parent] or raise
+              table[name.name] = constant
+            else
+              toplevel[name.name] = constant
+            end
+          end
+
           environment.constant_decls.each do |name, entry|
             unless name.namespace.empty?
               parent = name.namespace.to_type_name
@@ -97,6 +110,8 @@ module RBS
       end
 
       def children(module_name)
+        module_name = builder.env.normalize_module_name(module_name)
+
         unless child_constants_cache.key?(module_name)
           load_child_constants(module_name)
         end
@@ -113,6 +128,7 @@ module RBS
         else
           constants_from_ancestors(BuiltinNames::Object.name, constants: consts)
         end
+
         constants_from_context(context, constants: consts) or return
         constants_itself(context, constants: consts)
 
@@ -151,7 +167,7 @@ module RBS
           constants_from_context(parent, constants: constants) or return false
 
           if last
-            consts = table.children(last) or return false
+            consts = table.children(builder.env.normalize_module_name(last)) or return false
             constants.merge!(consts)
           end
         end
@@ -160,14 +176,14 @@ module RBS
       end
 
       def constants_from_ancestors(module_name, constants:)
-        entry = builder.env.class_decls[module_name]
+        entry = builder.env.normalized_module_class_entry(module_name) or raise
 
-        if entry.is_a?(Environment::ModuleEntry)
+        if entry.is_a?(Environment::ClassEntry) || entry.is_a?(Environment::ModuleEntry)
           constants.merge!(table.children(BuiltinNames::Object.name) || raise)
           constants.merge!(table.toplevel)
         end
 
-        builder.ancestor_builder.instance_ancestors(module_name).ancestors.reverse_each do |ancestor|
+        builder.ancestor_builder.instance_ancestors(entry.name).ancestors.reverse_each do |ancestor|
           if ancestor.is_a?(Definition::Ancestor::Instance)
             case ancestor.source
             when AST::Members::Include, :super, nil

data/lib/rbs/resolver/type_name_resolver.rb

@@ -12,7 +12,8 @@ module RBS
 
         all_names.merge(env.class_decls.keys)
         all_names.merge(env.interface_decls.keys)
-        all_names.merge(env.alias_decls.keys)
+        all_names.merge(env.type_alias_decls.keys)
+        all_names.merge(env.class_alias_decls.keys)
       end
 
       def try_cache(query)

data/lib/rbs/sorter.rb

@@ -15,7 +15,7 @@ module RBS
       stdout.puts "Opening #{path}..."
 
       buffer = Buffer.new(name: path, content: path.read)
-      sigs = Parser.parse_signature(buffer)
+      _, _, sigs = Parser.parse_signature(buffer)
 
       sigs.each do |m|
         sort_decl! m
@@ -30,7 +30,7 @@ module RBS
 
     def group(member)
       case member
-      when Declarations::Alias
+      when Declarations::TypeAlias
         -3
       when Declarations::Constant
         -2
@@ -100,7 +100,7 @@ module RBS
         member.new_name.to_s
       when Declarations::Constant
         member.name.to_s
-      when Declarations::Alias
+      when Declarations::TypeAlias
         member.name.to_s
       when Declarations::Class, Declarations::Module
         member.name.to_s

data/lib/rbs/substitution.rb

@@ -50,6 +50,8 @@ module RBS
       end
     end
 
+    alias [] apply
+
     def without(*vars)
       Substitution.new.tap do |subst|
         subst.mapping.merge!(mapping)
@@ -60,5 +62,22 @@ module RBS
         subst.instance_type = self.instance_type
       end
     end
+
+    def +(other)
+      return self if other.empty?
+      return other if self.empty?
+
+      Substitution.new.tap do |subst|
+        subst.mapping.merge!(mapping)
+
+        other.mapping.each do |var, type|
+          if mapping.key?(var)
+            subst.add(from: var, to: self[type])
+          else
+            subst.add(from: var, to: type)
+          end
+        end
+      end
+    end
   end
 end