rbs 0.12.1 → 0.15.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/test/hook.rb

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

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)

data/lib/rbs/type_name.rb

@@ -23,7 +23,7 @@ module RBS
     def ==(other)
       other.is_a?(self.class) && other.namespace == namespace && other.name == name
     end
-    
+
     alias eql? ==
 
     def hash

data/lib/rbs/variance_calculator.rb

@@ -120,7 +120,7 @@ module RBS
 
         type.args.each.with_index do |ty, i|
           var = type_params.params[i]
-          case var.variance
+          case var&.variance
           when :invariant
             type(ty, result: result, context: :invariant)
           when :covariant
@@ -135,7 +135,7 @@ module RBS
                   when :contravariant
                     :covariant
                   else
-                    raise                    
+                    raise
                   end
             type(ty, result: result, context: con)
           end

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "0.12.1"
+  VERSION = "0.15.0"
 end

data/lib/rbs/writer.rb

@@ -60,6 +60,8 @@ module RBS
 
     def write(decls)
       [nil, *decls].each_cons(2) do |prev, decl|
+        raise unless decl
+
         preserve_empty_line(prev, decl)
         write_decl decl
       end
@@ -68,8 +70,8 @@ module RBS
     def write_decl(decl)
       case decl
       when AST::Declarations::Class
-        super_class = if decl.super_class
-                        " < #{name_and_args(decl.super_class.name, decl.super_class.args)}"
+        super_class = if super_class = decl.super_class
+                        " < #{name_and_args(super_class.name, super_class.args)}"
                       end
         write_comment decl.comment
         write_annotation decl.annotations
@@ -77,6 +79,8 @@ module RBS
 
         indent do
           [nil, *decl.members].each_cons(2) do |prev, member|
+            raise unless member
+
             preserve_empty_line prev, member
             write_member member
           end
@@ -134,9 +138,6 @@ module RBS
 
         puts "end"
 
-      when AST::Declarations::Extension
-        RBS.logger.warn "Extension is ignored: #{decl.name}"
-
       end
     end
 
@@ -288,20 +289,29 @@ module RBS
     end
 
     def preserve_empty_line(prev, decl)
-      return unless prev
+      # @type var decl: _Located
 
-      decl = decl.comment if decl.respond_to?(:comment) && decl.comment
+      return unless prev
 
-      # When the signature is not constructed by the parser,
-      # it always inserts an empty line.
-      if !prev.location || !decl.location
-        puts
-        return
+      if (_ = decl).respond_to?(:comment)
+        if comment = (_ = decl).comment
+          decl = comment
+        end
       end
 
-      prev_end_line = prev.location.end_line
-      start_line = decl.location.start_line
-      if start_line - prev_end_line > 1
+      prev_loc = prev.location
+      decl_loc = decl.location
+
+      if prev_loc && decl_loc
+        prev_end_line = prev_loc.end_line
+        start_line = decl_loc.start_line
+
+        if start_line - prev_end_line > 1
+          puts
+        end
+      else
+        # When the signature is not constructed by the parser,
+        # it always inserts an empty line.
         puts
       end
     end

data/sig/constant.rbs

@@ -0,0 +1,21 @@
+module RBS
+  class Constant
+    type constant_entry = Environment::ClassEntry
+                        | Environment::ModuleEntry
+                        | Environment::SingleEntry[TypeName, AST::Declarations::Constant]
+
+    attr_reader name: TypeName
+
+    attr_reader type: Types::t
+
+    attr_reader entry: constant_entry
+
+    def initialize: (name: TypeName, type: Types::t, entry: constant_entry) -> void
+
+    def ==: (untyped other) -> bool
+
+    alias eql? ==
+
+    def hash: () -> Integer
+  end
+end

data/sig/constant_table.rbs

@@ -0,0 +1,30 @@
+module RBS
+  class ConstantTable
+    attr_reader definition_builder: DefinitionBuilder
+    attr_reader constant_scopes_cache: Hash[TypeName, Array[Namespace]]
+    attr_reader resolver: TypeNameResolver
+    attr_reader env(): Environment
+
+    def initialize: (builder: DefinitionBuilder) -> void
+
+    def absolute_type: (Types::t, context: Array[Namespace]) -> Types::t
+
+    def absolute_type_name: (TypeName, context: Array[Namespace], location: Location?) -> TypeName
+
+    def name_to_constant: (TypeName) -> Constant?
+
+    def split_name: (TypeName) -> Array[Symbol]
+
+    def resolve_constant_reference: (TypeName name, context: Array[Namespace]) -> Constant?
+
+    def resolve_constant_reference_context: (Symbol, context: Array[Namespace]) -> Constant?
+
+    def resolve_constant_reference_inherit: (Symbol, scopes: Array[Namespace], ?no_object: boolish) -> Constant?
+
+    def constant_scopes: (TypeName) -> Array[Namespace]
+
+    def constant_scopes_module: (TypeName, scopes: Array[Namespace]) -> Array[Namespace]
+
+    def constant_scopes0: (TypeName, ?scopes: Array[Namespace]) -> Array[Namespace]
+  end
+end