rbs 0.12.2 → 0.16.0

data/lib/rbs/parser.y

@@ -1,5 +1,6 @@
 class RBS::Parser
-  token tUIDENT tLIDENT tNAMESPACE tINTERFACEIDENT tLKEYWORD tUKEYWORD tGLOBALIDENT
+  token tUIDENT tLIDENT tNAMESPACE tINTERFACEIDENT tGLOBALIDENT
+        tLKEYWORD tUKEYWORD tLKEYWORD_Q_E tUKEYWORD_Q_E
         tIVAR tCLASSVAR
         tANNOTATION
         tSTRING tSYMBOL tINTEGER tWRITE_ATTR
@@ -474,6 +475,8 @@ rule
 
   method_type:
       start_merged_scope type_params params_opt block_opt kARROW simple_type {
+        reset_variable_scope
+
         location = (val[1] || val[2] || val[3] || val[4]).location + val[5].location
         type_params = val[1]&.value || []
 
@@ -846,7 +849,7 @@ rule
         result = val[0]
       }
 
-  keyword: tLKEYWORD | tUKEYWORD
+  keyword: tLKEYWORD | tUKEYWORD | tLKEYWORD_Q_E | tUKEYWORD_Q_E
 
   function_type:
       kLPAREN params kRPAREN kARROW simple_type {
@@ -874,7 +877,7 @@ rule
           required_keywords: {},
           optional_keywords: {},
           rest_keywords: nil,
-          return_type: val[2]
+          return_type: val[1]
         )
 
         result = LocatedValue.new(value: type, location: location)
@@ -1344,8 +1347,12 @@ def next_token
     new_token(:tNAMESPACE)
   when input.scan(/[a-z_]\w*:/)
     new_token(:tLKEYWORD, input.matched.chop.to_sym)
+  when input.scan(/[a-z_]\w*[?!]:/)
+    new_token(:tLKEYWORD_Q_E, input.matched.chop.to_sym)
   when input.scan(/[A-Z]\w*:/)
     new_token(:tUKEYWORD, input.matched.chop.to_sym)
+  when input.scan(/[A-Z]\w*[?!]:/)
+    new_token(:tUKEYWORD_Q_E, input.matched.chop.to_sym)
   when input.scan(/\$[A-Za-z_]\w*/)
     new_token(:tGLOBALIDENT)
   when input.scan(/@[a-zA-Z_]\w*/)

data/lib/rbs/prototype/rb.rb

@@ -135,6 +135,18 @@ module RBS
 
             decls.push member unless decls.include?(member)
 
+        when :ALIAS
+          new_name, old_name = node.children.map { |c| literal_to_symbol(c) }
+          member = AST::Members::Alias.new(
+            new_name: new_name,
+            old_name: old_name,
+            kind: singleton ? :singleton : :instance,
+            annotations: [],
+            location: nil,
+            comment: comments[node.first_lineno - 1],
+          )
+          decls.push member unless decls.include?(member)
+
         when :FCALL
           # Inside method definition cannot reach here.
           args = node.children[1]&.children || []
@@ -166,9 +178,9 @@ module RBS
             end
           when :attr_reader
             args.each do |arg|
-              if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
+              if arg && (name = literal_to_symbol(arg))
                 decls << AST::Members::AttrReader.new(
-                  name: arg.children[0],
+                  name: name,
                   ivar_name: nil,
                   type: Types::Bases::Any.new(location: nil),
                   location: nil,
@@ -179,9 +191,9 @@ module RBS
             end
           when :attr_accessor
             args.each do |arg|
-              if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
+              if arg && (name = literal_to_symbol(arg))
                 decls << AST::Members::AttrAccessor.new(
-                  name: arg.children[0],
+                  name: name,
                   ivar_name: nil,
                   type: Types::Bases::Any.new(location: nil),
                   location: nil,
@@ -192,9 +204,9 @@ module RBS
             end
           when :attr_writer
             args.each do |arg|
-              if arg&.type == :LIT && arg.children[0].is_a?(Symbol)
+              if arg && (name = literal_to_symbol(arg))
                 decls << AST::Members::AttrWriter.new(
-                  name: arg.children[0],
+                  name: name,
                   ivar_name: nil,
                   type: Types::Bases::Any.new(location: nil),
                   location: nil,
@@ -203,6 +215,17 @@ module RBS
                 )
               end
             end
+          when :alias_method
+            if args[0] && args[1] && (new_name = literal_to_symbol(args[0])) && (old_name = literal_to_symbol(args[1]))
+              decls << AST::Members::Alias.new(
+                new_name: new_name,
+                old_name: old_name,
+                kind: singleton ? :singleton : :instance,
+                annotations: [],
+                location: nil,
+                comment: comments[node.first_lineno - 1],
+              )
+            end
           end
 
           each_child node do |child|
@@ -248,6 +271,15 @@ module RBS
         end
       end
 
+      def literal_to_symbol(node)
+        case node.type
+        when :LIT
+          node.children[0] if node.children[0].is_a?(Symbol)
+        when :STR
+          node.children[0].to_sym
+        end
+      end
+
       def each_node(nodes)
         nodes.each do |child|
           if child.is_a?(RubyVM::AbstractSyntaxTree::Node)

data/lib/rbs/prototype/runtime.rb

@@ -17,11 +17,13 @@ module RBS
       end
 
       def target?(const)
+        name = const_name(const)
+
         patterns.any? do |pattern|
           if pattern.end_with?("*")
-            (const.name || "").start_with?(pattern.chop)
+            (name || "").start_with?(pattern.chop)
           else
-            const.name == pattern
+            name == pattern
           end
         end
       end
@@ -37,7 +39,7 @@ module RBS
       def decls
         unless @decls
           @decls = []
-          ObjectSpace.each_object(Module).select {|mod| target?(mod) }.sort_by(&:name).each do |mod|
+          ObjectSpace.each_object(Module).select {|mod| target?(mod) }.sort_by{|mod| const_name(mod) }.each do |mod|
             case mod
             when Class
               generate_class mod
@@ -356,12 +358,14 @@ module RBS
       end
 
       def generate_module(mod)
-        unless mod.name
+        name = const_name(mod)
+
+        unless name
           RBS.logger.warn("Skipping anonymous module #{mod}")
           return
         end
 
-        type_name = to_type_name(mod.name)
+        type_name = to_type_name(name)
 
         decl = AST::Declarations::Module.new(
           name: type_name,
@@ -374,12 +378,13 @@ module RBS
         )
 
         each_mixin(mod.included_modules, *mod.included_modules.flat_map(&:included_modules), namespace: type_name.namespace) do |included_module|
-          unless included_module.name
+          included_module_name = const_name(included_module)
+          unless included_module_name
             RBS.logger.warn("Skipping anonymous module #{included_module} included in #{mod}")
             next
           end
 
-          module_name = to_type_name(included_module.name)
+          module_name = to_type_name(included_module_name)
           if module_name.namespace == type_name.namespace
             module_name = TypeName.new(name: module_name.name, namespace: Namespace.empty)
           end
@@ -399,6 +404,11 @@ module RBS
 
         generate_constants mod
       end
+
+      def const_name(const)
+        @module_name_method ||= Module.instance_method(:name)
+        @module_name_method.bind(const).call
+      end
     end
   end
 end

data/lib/rbs/repository.rb

@@ -0,0 +1,121 @@
+module RBS
+  class Repository
+    DEFAULT_STDLIB_ROOT = Pathname(_ = __dir__) + "../../stdlib"
+
+    class GemRBS
+      attr_reader :name
+      attr_reader :paths
+
+      def initialize(name:)
+        @name = name
+        @paths = []
+        @versions = nil
+      end
+
+      def versions
+        load! unless @versions
+        @versions or raise
+      end
+
+      def load!
+        @versions = {}
+        versions = @versions or raise
+
+        paths.each do |gem_path|
+          gem_path.each_child(false) do |child|
+            next unless Gem::Version.correct?(child.to_s)
+
+            if version = Gem::Version.create(child.to_s)
+              unless version.prerelease?
+                path = gem_path + child
+
+                if prev = versions[version]
+                  RBS.logger.info { "Overwriting gem RBS in repository: gem=#{name}, prev_path=#{prev.path}, new_path=#{path}" }
+                end
+
+                versions[version] = VersionPath.new(gem: self, version: version, path: path)
+              end
+            end
+          end
+        end
+      end
+
+      def version_names
+        versions.keys.sort_by(&:version)
+      end
+
+      def oldest_version
+        oldest = version_names.first or raise
+        versions[oldest] or raise
+      end
+
+      def latest_version
+        latest = version_names.last or raise
+        versions[latest] or raise
+      end
+
+      def find_best_version(version)
+        return latest_version unless version
+
+        if v = version_names.reverse.bsearch {|v| v <= version ? true : false }
+          versions[v]
+        else
+          oldest_version
+        end
+      end
+
+      def empty?
+        versions.empty?
+      end
+    end
+
+    VersionPath = _ = Struct.new(:gem, :version, :path, keyword_init: true)
+
+    attr_reader :dirs
+    attr_reader :gems
+
+    def initialize(no_stdlib: false)
+      @dirs = []
+      @gems = {}
+
+      unless no_stdlib
+        add(DEFAULT_STDLIB_ROOT)
+      end
+    end
+
+    def self.default
+      new().tap do |repo|
+        repo.add(DEFAULT_STDLIB_ROOT)
+      end
+    end
+
+    def add(dir)
+      dirs << dir
+
+      dir.each_child(false) do |child|
+        gem_name = child.to_s
+        gem_rbs = (gems[gem_name] ||= GemRBS.new(name: gem_name))
+        gem_rbs.paths << dir + child
+      end
+    end
+
+    def lookup(gem, version)
+      _, set = lookup_path(gem, version)
+      set&.path
+    end
+
+    def lookup_path(gem, version)
+      if gem_rbs = gems[gem]
+        unless gem_rbs.empty?
+          set = if v = Gem::Version.create(version)&.release
+            gem_rbs.find_best_version(v)
+          else
+            gem_rbs.latest_version
+          end
+
+          [gem_rbs, set]
+        end
+      end
+    end
+  end
+end

data/lib/rbs/test/hook.rb

@@ -5,6 +5,8 @@ module RBS
   module Test
     module Hook
       OPERATORS = {
+        :[] => "indexlookup",
+        :[]= => "indexset",
         :== => "eqeq",
         :=== => "eqeqeq",
         :!= => "noteq",

data/lib/rbs/test/setup.rb

@@ -2,6 +2,7 @@ require "rbs"
 require "rbs/test"
 require "optparse"
 require "shellwords"
+require "rbs/cli"
 
 include RBS::Test::SetupHelper
 
@@ -32,12 +33,13 @@ if filter.empty?
   exit 1
 end
 
-loader = RBS::EnvironmentLoader.new
+options = RBS::CLI::LibraryOptions.new()
+
 OptionParser.new do |opts|
-  opts.on("-r [LIB]") do |name| loader.add(library: name) end
-  opts.on("-I [DIR]") do |dir| loader.add(path: Pathname(dir)) end
+  options.setup_library_options(opts)
 end.parse!(opts)
 
+loader = options.loader
 env = RBS::Environment.from_loader(loader).resolve_type_names
 
 def match(filter, name)

data/lib/rbs/test/setup_helper.rb

@@ -3,15 +3,15 @@ module RBS
     module SetupHelper
       class InvalidSampleSizeError < StandardError
         attr_reader :string
-        
+
         def initialize(string)
           @string = string
           super("Sample size should be a positive integer: `#{string}`")
         end
       end
-      
+
       DEFAULT_SAMPLE_SIZE = 100
-      
+
       def get_sample_size(string)
         case string
         when ""
@@ -32,7 +32,7 @@ module RBS
         when 'rspec'
           ['::RSpec::Mocks::Double']
         when 'minitest'
-          ['::Minitest::Mock'] 
+          ['::Minitest::Mock']
         else
           RBS.logger.warn "Unknown test suite - defaults to nil"
           nil

data/lib/rbs/test/tester.rb

@@ -56,7 +56,10 @@ module RBS
                 RBS.logger.info { "Skipping ##{name} because of `#{reason}`..." }
               end
             else
-              if klass.instance_methods(false).include?(name) && !set.include?(name)
+              if !set.include?(name) && (
+                  name == :initialize ||
+                  klass.instance_methods(false).include?(name) ||
+                  klass.private_instance_methods(false).include?(name))
                 RBS.logger.info { "Setting up method hook in ##{name}..." }
                 Hook.hook_instance_method klass, name, key: instance_key
                 set << name

data/lib/rbs/test/type_check.rb

@@ -202,24 +202,30 @@ module RBS
       end
 
       def get_class(type_name)
-        const_cache[type_name] ||= Object.const_get(type_name.to_s)
+        const_cache[type_name] ||= begin
+                                     Object.const_get(type_name.to_s)
+                                   rescue NameError
+                                     nil
+                                   end
       end
 
       def is_double?(value)
         unchecked_classes.any? { |unchecked_class| Test.call(value, IS_AP, Object.const_get(unchecked_class))}
+      rescue NameError
+        false
       end
 
       def value(val, type)
         if is_double?(val)
           RBS.logger.info("A double (#{val.inspect}) is detected!")
-          return true 
+          return true
         end
 
         case type
         when Types::Bases::Any
           true
         when Types::Bases::Bool
-          true
+          val.is_a?(TrueClass) || val.is_a?(FalseClass)
         when Types::Bases::Top
           true
         when Types::Bases::Bottom
@@ -235,7 +241,7 @@ module RBS
         when Types::Bases::Instance
           Test.call(val, IS_AP, self_class)
         when Types::ClassInstance
-          klass = get_class(type.name)
+          klass = get_class(type.name) or return false
           case
           when klass == ::Array
             Test.call(val, IS_AP, klass) && each_sample(val).all? {|v| value(v, type.args[0]) }
@@ -281,7 +287,7 @@ module RBS
             Test.call(val, IS_AP, klass)
           end
         when Types::ClassSingleton
-          klass = get_class(type.name)
+          klass = get_class(type.name) or return false
           val == klass
         when Types::Interface
           methods = Set.new(Test.call(val, METHODS))
@@ -306,7 +312,7 @@ module RBS
           Test.call(val, IS_AP, ::Array) &&
             type.types.map.with_index {|ty, index| value(val[index], ty) }.all?
         when Types::Record
-          Test::call(val, IS_AP, ::Hash) && 
+          Test::call(val, IS_AP, ::Hash) &&
             type.fields.map {|key, type| value(val[key], type) }.all?
         when Types::Proc
           Test::call(val, IS_AP, ::Proc)