rbs 1.0.0.pre → 1.0.3

data/lib/rbs/parser.y

@@ -50,7 +50,6 @@ rule
     | interface_decl
     | module_decl
     | class_decl
-    | extension_decl
 
   start_new_scope: { start_new_variables_scope }
   start_merged_scope: { start_merged_variables_scope }
@@ -61,24 +60,6 @@ rule
         result = val[1].unshift(Annotation.new(string: val[0].value, location: val[0].location))
       }
 
-  extension_decl:
-      annotations kEXTENSION start_new_scope class_name type_params kLPAREN extension_name kRPAREN class_members kEND {
-        reset_variable_scope
-
-        location = val[1].location + val[9].location
-        result = Declarations::Extension.new(
-          name: val[3].value,
-          type_params: val[4]&.value || [],
-          extension_name: val[6].value.to_sym,
-          members: val[8],
-          annotations: val[0],
-          location: location,
-          comment: leading_comment(val[0].first&.location || location)
-        )
-      }
-
-  extension_name: tUIDENT | tLIDENT
-
   class_decl:
       annotations kCLASS start_new_scope class_name module_type_params super_class class_members kEND {
         reset_variable_scope
@@ -630,7 +611,7 @@ rule
       }
 
   type_decl:
-      annotations kTYPE qualified_name kEQ type {
+      annotations kTYPE type_alias_name kEQ type {
         location = val[1].location + val[4].location
         result = Declarations::Alias.new(name: val[2].value,
                                          type: val[4],
@@ -1056,6 +1037,16 @@ rule
         result = LocatedValue.new(value: type_name, location: location)
       }
 
+  type_alias_name:
+      namespace tLIDENT {
+        namespace = val[0]&.value || Namespace.empty
+        name = val[1].value.to_sym
+        type_name = TypeName.new(namespace: namespace, name: name)
+        location = (loc0 = val[0]&.location) ? loc0 + val[1].location : val[1].location
+        result = LocatedValue.new(value: type_name, location: location)
+      }
+
+
   namespace:
       {
         result = nil
@@ -1380,7 +1371,7 @@ def next_token
     new_token(:tWRITE_ATTR)
   when input.scan(KEYWORDS_RE)
     new_token(KEYWORDS[input.matched], input.matched.to_sym)
-  when input.scan(/:((@{,2}|\$)?\w+(\?|\!)?|\+|\-)\b?/)
+  when input.scan(/:((@{,2}|\$)?\w+(\?|\!)?|[|&\/%~`^]|<=>|={2,3}|=~|[<>]{2}|[<>]=?|[-+]@?|\*{1,2}|\[\]=?|![=~]?)\b?/)
     s = input.matched.yield_self {|s| s[1, s.length] }.to_sym
     new_token(:tSYMBOL, s)
   when input.scan(/[+-]?\d[\d_]*/)

data/lib/rbs/prototype/rb.rb

@@ -129,9 +129,13 @@ module RBS
             RBS.logger.warn "`class <<` syntax with not-self may be compiled to incorrect code: #{this}"
           end
 
+          accessibility = current_accessibility(decls)
+
           ctx = Context.initial.tap { |ctx| ctx.singleton = true }
           process_children(body, decls: decls, comments: comments, context: ctx)
 
+          decls << accessibility
+
         when :DEFN, :DEFS
             if node.type == :DEFN
               def_name, def_body = node.children
@@ -376,7 +380,7 @@ module RBS
       def function_type_from_body(node)
         table_node, args_node, *_ = node.children
 
-        pre_num, _pre_init, opt, _first_post, post_num, _post_init, rest, kw, kwrest, _block = args_node.children
+        pre_num, _pre_init, opt, _first_post, post_num, _post_init, rest, kw, kwrest, _block = args_from_node(args_node)
 
         return_type = function_return_type_from_body(node)
 
@@ -396,7 +400,8 @@ module RBS
         end
 
         if rest
-          fun = fun.update(rest_positionals: Types::Function::Param.new(name: rest, type: untyped))
+          rest_name = rest == :* ? nil : rest # # For `def f(...) end` syntax
+          fun = fun.update(rest_positionals: Types::Function::Param.new(name: rest_name, type: untyped))
         end
 
         table_node.drop(fun.required_positionals.size + fun.optional_positionals.size + (fun.rest_positionals ? 1 : 0)).take(post_num).each do |name|
@@ -555,13 +560,16 @@ 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 = args_node.children
+        _pre_num, _pre_init, _opt, _first_post, _post_num, _post_init, _rest, _kw, _kwrest, block = args_from_node(args_node)
 
         method_block = nil
 
         if block
           method_block = Types::Block.new(
-            required: true,
+            # HACK: The `block` is :& on `def m(...)` syntax.
+            #       In this case the block looks optional in most cases, so it marks optional.
+            #       In other cases, we can't determine which is required or optional, so it marks required.
+            required: block != :&,
             type: Types::Function.empty(untyped)
           )
         end
@@ -610,6 +618,12 @@ module RBS
         method_block
       end
 
+      # NOTE: args_node may be a nil by a bug
+      #       https://bugs.ruby-lang.org/issues/17495
+      def args_from_node(args_node)
+        args_node&.children || [0, nil, nil, nil, 0, nil, nil, nil, nil, nil]
+      end
+
       def keyword_hash?(node)
         if node
           if node.type == :HASH

data/lib/rbs/prototype/runtime.rb

@@ -80,12 +80,12 @@ module RBS
             unless const_name(mix)
               RBS.logger.warn("Skipping anonymous module #{mix} included in #{mod}")
             else
-              module_name = to_type_name(const_name(mix))
-              if module_name.namespace == type_name.namespace
-                module_name = TypeName.new(name: module_name.name, namespace: Namespace.empty)
+              module_name = module_full_name = to_type_name(const_name(mix))
+              if module_full_name.namespace == type_name.namespace
+                module_name = TypeName.new(name: module_full_name.name, namespace: Namespace.empty)
               end
 
-              yield module_name, mix
+              yield module_name, module_full_name, mix
             end
           end
         end
@@ -319,7 +319,9 @@ module RBS
                      location: nil
                    )
                  else
-                   Types::ClassInstance.new(name: to_type_name(const_name(value.class)), args: [], location: nil)
+                   value_type_name = to_type_name(const_name(value.class))
+                   args = type_args(value_type_name)
+                   Types::ClassInstance.new(name: value_type_name, args: args, location: nil)
                  end
 
           @decls << AST::Declarations::Constant.new(
@@ -339,7 +341,9 @@ module RBS
                         RBS.logger.warn("Skipping anonymous superclass #{mod.superclass} of #{mod}")
                         nil
                       else
-                        AST::Declarations::Class::Super.new(name: to_type_name(const_name(mod.superclass)), args: [], location: nil)
+                        super_name = to_type_name(const_name(mod.superclass))
+                        super_args = type_args(super_name)
+                        AST::Declarations::Class::Super.new(name: super_name, args: super_args, location: nil)
                       end
 
         decl = AST::Declarations::Class.new(
@@ -352,20 +356,22 @@ module RBS
           comment: nil
         )
 
-        each_included_module(type_name, mod) do |module_name, _|
+        each_included_module(type_name, mod) do |module_name, module_full_name, _|
+          args = type_args(module_full_name)
           decl.members << AST::Members::Include.new(
             name: module_name,
-            args: [],
+            args: args,
             location: nil,
             comment: nil,
             annotations: []
           )
         end
 
-        each_included_module(type_name, mod.singleton_class) do |module_name, _|
+        each_included_module(type_name, mod.singleton_class) do |module_name, module_full_name ,_|
+          args = type_args(module_full_name)
           decl.members << AST::Members::Extend.new(
             name: module_name,
-            args: [],
+            args: args,
             location: nil,
             comment: nil,
             annotations: []
@@ -399,20 +405,22 @@ module RBS
           comment: nil
         )
 
-        each_included_module(type_name, mod) do |module_name, _|
+        each_included_module(type_name, mod) do |module_name, module_full_name, _|
+          args = type_args(module_full_name)
           decl.members << AST::Members::Include.new(
             name: module_name,
-            args: [],
+            args: args,
             location: nil,
             comment: nil,
             annotations: []
           )
         end
 
-        each_included_module(type_name, mod.singleton_class) do |module_name, _|
+        each_included_module(type_name, mod.singleton_class) do |module_name, module_full_name, _|
+          args = type_args(module_full_name)
           decl.members << AST::Members::Extend.new(
             name: module_name,
-            args: [],
+            args: args,
             location: nil,
             comment: nil,
             annotations: []
@@ -430,6 +438,14 @@ module RBS
         @module_name_method ||= Module.instance_method(:name)
         @module_name_method.bind(const).call
       end
+
+      def type_args(type_name)
+        if class_decl = env.class_decls[type_name.absolute!]
+          class_decl.type_params.size.times.map { :untyped }
+        else
+          []
+        end
+      end
     end
   end
 end

data/lib/rbs/test/hook.rb

@@ -71,14 +71,15 @@ module RBS
         with_name, without_name = alias_names(method_name, random)
         full_method_name = "#{prefix}#{method_name}"
 
-        param_source = params.take_while {|param| param[0] == :req }.map(&:last) + ["*rest_args_#{random}"]
+        param_source = params.take_while {|param| param[0] == :req }.map(&:last) + ["*rest_args__#{random}"]
+        block_param = "block__#{random}"
 
         RBS.logger.debug {
-          "Generating method definition: def #{with_name}(#{param_source.join(", ")}, &block) ..."
+          "Generating method definition: def #{with_name}(#{param_source.join(", ")}, &#{block_param}) ..."
         }
 
         [__LINE__ + 1, <<RUBY]
-def #{with_name}(#{param_source.join(", ")}, &block)
+def #{with_name}(#{param_source.join(", ")}, &#{block_param})
   args = [#{param_source.join(", ")}]
   ::RBS.logger.debug { "#{full_method_name} with arguments: [" + args.map(&:inspect).join(", ") + "]" }
 
@@ -88,7 +89,7 @@ def #{with_name}(#{param_source.join(", ")}, &block)
 
     if block_given?
       receiver = self
-      block_receives_block = block.parameters.last&.yield_self {|type, _| type == :block }
+      block_receives_block = #{block_param}.parameters.last&.yield_self {|type, _| type == :block }
 
       wrapped_block = proc do |*block_args, &block2|
         return_from_block = false
@@ -96,12 +97,12 @@ def #{with_name}(#{param_source.join(", ")}, &block)
         begin
           block_result = if receiver.equal?(self)
                            if block_receives_block
-                             block.call(*block_args, &block2)
+                             #{block_param}.call(*block_args, &block2)
                            else
                              yield(*block_args)
                            end
                          else
-                           instance_exec(*block_args, &block)
+                           instance_exec(*block_args, &#{block_param})
                          end
 
           return_from_block = true

data/lib/rbs/test/setup_helper.rb

@@ -38,7 +38,6 @@ module RBS
           nil
         end
       end
-
     end
   end
 end

data/lib/rbs/types.rb

@@ -943,7 +943,11 @@ module RBS
       end
 
       def has_keyword?
-        !required_keywords.empty? || !optional_keywords.empty? || rest_keywords
+        if !required_keywords.empty? || !optional_keywords.empty? || rest_keywords
+          true
+        else
+          false
+        end
       end
     end
 
@@ -953,7 +957,7 @@ module RBS
 
       def initialize(type:, required:)
         @type = type
-        @required = required
+        @required = required ? true : false
       end
 
       def ==(other)

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "1.0.0.pre"
+  VERSION = "1.0.3"
 end

data/lib/rbs/writer.rb

@@ -232,10 +232,11 @@ module RBS
     def method_name(name)
       s = name.to_s
 
-      if /\A#{Parser::KEYWORDS_RE}\z/.match?(s)
-        "`#{s}`"
-      else
+      if [:tOPERATOR, :kAMP, :kHAT, :kSTAR, :kLT, :kEXCLAMATION, :kSTAR2, :kBAR].include?(Parser::PUNCTS[s]) ||
+          (/\A[a-zA-Z_]\w*[?!=]?\z/.match?(s) && !/\Aself\??\z/.match?(s))
         s
+      else
+        "`#{s}`"
       end
     end
 

data/rbs.gemspec

@@ -34,4 +34,5 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 2.6"
 end

data/sig/ancestor_builder.rbs

@@ -0,0 +1,98 @@
+module RBS
+  class DefinitionBuilder
+    class AncestorBuilder
+      class OneAncestors
+        attr_reader type_name: TypeName
+        attr_reader params: Array[Symbol]?
+        attr_reader super_class: Definition::Ancestor::t?
+        attr_reader self_types: Array[Definition::Ancestor::Instance]?
+        attr_reader included_modules: Array[Definition::Ancestor::Instance]?
+        attr_reader included_interfaces: Array[Definition::Ancestor::Instance]?
+        attr_reader prepended_modules: Array[Definition::Ancestor::Instance]?
+        attr_reader extended_modules: Array[Definition::Ancestor::Instance]?
+        attr_reader extended_interfaces: Array[Definition::Ancestor::Instance]?
+
+        def initialize: (type_name: TypeName,
+                            params: Array[Symbol]?,
+                       super_class: Definition::Ancestor::t?,
+                        self_types: Array[Definition::Ancestor::Instance]?,
+                  included_modules: Array[Definition::Ancestor::Instance]?,
+               included_interfaces: Array[Definition::Ancestor::Instance]?,
+                 prepended_modules: Array[Definition::Ancestor::Instance]?,
+                  extended_modules: Array[Definition::Ancestor::Instance]?,
+               extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
+
+        def each_ancestor: { (Definition::Ancestor::t) -> void } -> void
+                         | -> Enumerator[Definition::Ancestor::t, void]
+
+        def self.class_instance: (type_name: TypeName, params: Array[Symbol], super_class: Definition::Ancestor::t?) -> instance
+
+        def self.singleton: (type_name: TypeName, super_class: Definition::Ancestor::t?) -> instance
+
+        def self.module_instance: (type_name: TypeName, params: Array[Symbol]) -> instance
+
+        def self.interface: (type_name: TypeName, params: Array[Symbol]) -> instance
+
+        def each_included_module: () { (Definition::Ancestor::Instance) -> void } -> void
+                                | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_included_interface: () { (Definition::Ancestor::Instance) -> void } -> void
+                                   | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_prepended_module: () { (Definition::Ancestor::Instance) -> void } -> void
+                                 | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_extended_module: () { (Definition::Ancestor::Instance) -> void } -> void
+                                | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_extended_interface: () { (Definition::Ancestor::Instance) -> void } -> void
+                                   | () -> Enumerator[Definition::Ancestor::Instance, void]
+
+        def each_self_type: () { (Definition::Ancestor::Instance) -> void } -> void
+                          | () -> Enumerator[Definition::Ancestor::Instance, void]
+      end
+
+      attr_reader env: Environment
+
+      attr_reader one_instance_ancestors_cache: Hash[TypeName, OneAncestors]
+      attr_reader instance_ancestors_cache: Hash[TypeName, Definition::InstanceAncestors]
+
+      attr_reader one_singleton_ancestors_cache: Hash[TypeName, OneAncestors]
+      attr_reader singleton_ancestors_cache: Hash[TypeName, Definition::SingletonAncestors]
+
+      attr_reader one_interface_ancestors_cache: Hash[TypeName, OneAncestors]
+      attr_reader interface_ancestors_cache: Hash[TypeName, Definition::InstanceAncestors]
+
+      def initialize: (env: Environment) -> void
+
+      def validate_super_class!: (TypeName, Environment::ClassEntry) -> void
+
+      def one_instance_ancestors: (TypeName) -> OneAncestors
+
+      def one_singleton_ancestors: (TypeName) -> OneAncestors
+
+      def one_interface_ancestors: (TypeName) -> OneAncestors
+
+      def instance_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::InstanceAncestors
+
+      def singleton_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::SingletonAncestors
+
+      def interface_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::InstanceAncestors
+
+      def mixin_ancestors: (Environment::ClassEntry | Environment::ModuleEntry,
+                            included_modules: Array[Definition::Ancestor::Instance]?,
+                         included_interfaces:Array[Definition::Ancestor::Instance]?,
+                           prepended_modules: Array[Definition::Ancestor::Instance]?,
+                            extended_modules: Array[Definition::Ancestor::Instance]?,
+                         extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
+
+      def mixin_ancestors0: (AST::Declarations::Class | AST::Declarations::Module | AST::Declarations::Interface,
+                             align_params: Substitution?,
+                         included_modules: Array[Definition::Ancestor::Instance]?,
+                      included_interfaces:Array[Definition::Ancestor::Instance]?,
+                        prepended_modules: Array[Definition::Ancestor::Instance]?,
+                         extended_modules: Array[Definition::Ancestor::Instance]?,
+                      extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
+    end
+  end
+end

data/sig/declarations.rbs

@@ -73,8 +73,9 @@ module RBS
         class Super
           attr_reader name: TypeName
           attr_reader args: Array[Types::t]
+          attr_reader location: Location?
 
-          def initialize: (name: TypeName, args: Array[Types::t]) -> void
+          def initialize: (name: TypeName, args: Array[Types::t], location: Location?) -> void
 
           include _HashEqual
           include _ToJson
@@ -130,21 +131,6 @@ module RBS
         include _ToJson
       end
 
-      class Extension < Base
-        attr_reader name: TypeName
-        attr_reader type_params: ModuleTypeParams
-        attr_reader extension_name: Symbol
-        attr_reader members: Array[Members::t]
-        attr_reader annotations: Array[Annotation]
-        attr_reader location: Location?
-        attr_reader comment: Comment?
-
-        def initialize: (name: TypeName, type_params: ModuleTypeParams, extension_name: Symbol, members: Array[Members::t], annotations: Array[Annotation], location: Location?, comment: Comment?) -> void
-
-        include _HashEqual
-        include _ToJson
-      end
-
       class Interface
         type member = Members::t
 
@@ -157,6 +143,8 @@ module RBS
 
         def initialize: (name: TypeName, type_params: ModuleTypeParams, members: Array[member], annotations: Array[Annotation], location: Location?, comment: Comment?) -> void
 
+        include MixinHelper
+
         include _HashEqual
         include _ToJson
       end