rbs 1.2.1 → 1.3.0

data/lib/rbs/parser.y

@@ -1,5 +1,5 @@
 class RBS::Parser
-  token tUIDENT tLIDENT tNAMESPACE tINTERFACEIDENT tGLOBALIDENT
+  token tUIDENT tLIDENT tUNDERSCOREIDENT tNAMESPACE tINTERFACEIDENT tGLOBALIDENT
         tLKEYWORD tUKEYWORD tLKEYWORD_Q_E tUKEYWORD_Q_E
         tIVAR tCLASSVAR
         tANNOTATION
@@ -12,6 +12,7 @@ class RBS::Parser
         kPREPEND kEXTENSION kINCOMPATIBLE
         type_TYPE type_SIGNATURE type_METHODTYPE tEOF
         kOUT kIN kUNCHECKED kOVERLOAD
+        kUNDERSCORE
 
   prechigh
   nonassoc kQUESTION
@@ -1326,7 +1327,7 @@ rule
       }
 
   var_name_opt:
-    | tLIDENT | tINTERFACEIDENT | tQUOTEDIDENT
+    | tLIDENT | tINTERFACEIDENT | tQUOTEDIDENT | tUNDERSCOREIDENT | kUNDERSCORE
 
   qualified_name:
       namespace simple_name {
@@ -1713,12 +1714,16 @@ def next_token
     new_token(:tIVAR, input.matched.to_sym)
   when input.scan(/@@[a-zA-Z_]\w*/)
     new_token(:tCLASSVAR, input.matched.to_sym)
-  when input.scan(/_[a-zA-Z]\w*\b/)
+  when input.scan(/_[A-Z]\w*\b/)
     new_token(:tINTERFACEIDENT)
   when input.scan(/[A-Z]\w*\b/)
     new_token(:tUIDENT)
-  when input.scan(/[a-z_]\w*\b/)
+  when input.scan(/[a-z]\w*\b/)
     new_token(:tLIDENT)
+  when input.scan(/_[a-z]\w*\b/)
+    new_token(:tUNDERSCOREIDENT)
+  when input.scan(/_/)
+    new_token(:kUNDERSCORE)
   when input.scan(/"(\\"|[^"])*"/)
     s = input.matched.yield_self {|s| s[1, s.length - 2] }
                      .gsub(DBL_QUOTE_STR_ESCAPE_SEQUENCES_RE) do |match|

data/lib/rbs/prototype/rb.rb

@@ -148,7 +148,7 @@ module RBS
             types = [
               MethodType.new(
                 type_params: [],
-                type: function_type_from_body(def_body),
+                type: function_type_from_body(def_body, def_name),
                 block: block_from_body(def_body),
                 location: nil
               )
@@ -377,12 +377,16 @@ module RBS
         each_node node.children, &block
       end
 
-      def function_type_from_body(node)
+      def function_type_from_body(node, def_name)
         table_node, args_node, *_ = 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)
+        return_type = if def_name == :initialize
+                        Types::Bases::Void.new(location: nil)
+                      else
+                        function_return_type_from_body(node)
+                      end
 
         fun = Types::Function.empty(return_type)
 

data/lib/rbs/prototype/runtime.rb

@@ -9,6 +9,7 @@ module RBS
       def initialize(patterns:, env:, merge:, owners_included: [])
         @patterns = patterns
         @decls = nil
+        @modules = []
         @env = env
         @merge = merge
         @owners_included = owners_included.map do |name|
@@ -39,7 +40,8 @@ module RBS
       def decls
         unless @decls
           @decls = []
-          ObjectSpace.each_object(Module).select {|mod| target?(mod) }.sort_by{|mod| const_name(mod) }.each do |mod|
+          @modules = ObjectSpace.each_object(Module).to_a
+          @modules.select {|mod| target?(mod) }.sort_by{|mod| const_name(mod) }.each do |mod|
             case mod
             when Class
               generate_class mod
@@ -48,16 +50,21 @@ module RBS
             end
           end
         end
+
         @decls
       end
 
-      def to_type_name(name)
+      def to_type_name(name, full_name: false)
         *prefix, last = name.split(/::/)
 
-        if prefix.empty?
-          TypeName.new(name: last.to_sym, namespace: Namespace.empty)
+        if full_name
+          if prefix.empty?
+            TypeName.new(name: last.to_sym, namespace: Namespace.empty)
+          else
+            TypeName.new(name: last.to_sym, namespace: Namespace.parse(prefix.join("::")))
+          end
         else
-          TypeName.new(name: last.to_sym, namespace: Namespace.parse(prefix.join("::")))
+          TypeName.new(name: last.to_sym, namespace: Namespace.empty)
         end
       end
 
@@ -131,6 +138,11 @@ module RBS
           end
         end
 
+        return_type = if method.name == :initialize
+                        Types::Bases::Void.new(location: nil)
+                      else
+                        untyped
+                      end
         method_type = Types::Function.new(
           required_positionals: required_positionals,
           optional_positionals: optional_positionals,
@@ -139,7 +151,7 @@ module RBS
           required_keywords: required_keywords,
           optional_keywords: optional_keywords,
           rest_keywords: rest_keywords,
-          return_type: untyped
+          return_type: return_type,
         )
 
         MethodType.new(
@@ -300,7 +312,7 @@ module RBS
         end
       end
 
-      def generate_constants(mod)
+      def generate_constants(mod, decls)
         mod.constants(false).sort.each do |name|
           value = mod.const_get(name)
 
@@ -324,8 +336,8 @@ module RBS
                    Types::ClassInstance.new(name: value_type_name, args: args, location: nil)
                  end
 
-          @decls << AST::Declarations::Constant.new(
-            name: "#{const_name(mod)}::#{name}",
+          decls << AST::Declarations::Constant.new(
+            name: name,
             type: type,
             location: nil,
             comment: nil
@@ -333,28 +345,38 @@ module RBS
         end
       end
 
+      def generate_super_class(mod)
+        if mod.superclass == ::Object
+          nil
+        elsif const_name(mod.superclass).nil?
+          RBS.logger.warn("Skipping anonymous superclass #{mod.superclass} of #{mod}")
+          nil
+        else
+          super_name = to_type_name(const_name(mod.superclass), full_name: true)
+          super_args = type_args(super_name)
+          AST::Declarations::Class::Super.new(name: super_name, args: super_args, location: nil)
+        end
+      end
+
       def generate_class(mod)
         type_name = to_type_name(const_name(mod))
-        super_class = if mod.superclass == ::Object
-                        nil
-                      elsif const_name(mod.superclass).nil?
-                        RBS.logger.warn("Skipping anonymous superclass #{mod.superclass} of #{mod}")
-                        nil
-                      else
-                        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
+        outer_decls = ensure_outer_module_declarations(mod)
+
+        # Check if a declaration exists for the actual module
+        decl = outer_decls.detect { |decl| decl.is_a?(AST::Declarations::Class) && decl.name.name == only_name(mod).to_sym }
+        unless decl
+          decl = AST::Declarations::Class.new(
+            name: to_type_name(only_name(mod)),
+            type_params: AST::Declarations::ModuleTypeParams.empty,
+            super_class: generate_super_class(mod),
+            members: [],
+            annotations: [],
+            location: nil,
+            comment: nil
+          )
 
-        decl = AST::Declarations::Class.new(
-          name: type_name,
-          type_params: AST::Declarations::ModuleTypeParams.empty,
-          super_class: super_class,
-          members: [],
-          annotations: [],
-          location: nil,
-          comment: nil
-        )
+          outer_decls << decl
+        end
 
         each_included_module(type_name, mod) do |module_name, module_full_name, _|
           args = type_args(module_full_name)
@@ -380,9 +402,7 @@ module RBS
 
         generate_methods(mod, type_name, decl.members)
 
-        @decls << decl
-
-        generate_constants mod
+        generate_constants mod, decl.members
       end
 
       def generate_module(mod)
@@ -394,16 +414,23 @@ module RBS
         end
 
         type_name = to_type_name(name)
+        outer_decls = ensure_outer_module_declarations(mod)
+
+        # Check if a declaration exists for the actual class
+        decl = outer_decls.detect { |decl| decl.is_a?(AST::Declarations::Module) && decl.name.name == only_name(mod).to_sym }
+        unless decl
+          decl = AST::Declarations::Module.new(
+            name: to_type_name(only_name(mod)),
+            type_params: AST::Declarations::ModuleTypeParams.empty,
+            self_types: [],
+            members: [],
+            annotations: [],
+            location: nil,
+            comment: nil
+          )
 
-        decl = AST::Declarations::Module.new(
-          name: type_name,
-          type_params: AST::Declarations::ModuleTypeParams.empty,
-          self_types: [],
-          members: [],
-          annotations: [],
-          location: nil,
-          comment: nil
-        )
+          outer_decls << decl
+        end
 
         each_included_module(type_name, mod) do |module_name, module_full_name, _|
           args = type_args(module_full_name)
@@ -429,9 +456,58 @@ module RBS
 
         generate_methods(mod, type_name, decl.members)
 
-        @decls << decl
+        generate_constants mod, decl.members
+      end
+
+      # Generate/find outer module declarations
+      # This is broken down into another method to comply with `DRY`
+      # This generates/finds declarations in nested form & returns the last array of declarations
+      def ensure_outer_module_declarations(mod)
+        *outer_module_names, _ = const_name(mod).split(/::/) #=> parent = [A, B], mod = C
+        destination = @decls # Copy the entries in ivar @decls, not .dup
+
+        outer_module_names&.each do |outer_module_name|
+          outer_module = @modules.detect { |x| const_name(x) == outer_module_name }
+          outer_decl = destination.detect { |decl| decl.is_a?(outer_module.is_a?(Class) ? AST::Declarations::Class : AST::Declarations::Module) && decl.name.name == outer_module_name.to_sym }
+
+          # Insert AST::Declarations if declarations are not added previously
+          unless outer_decl
+            if outer_module.is_a?(Class)
+              outer_decl = AST::Declarations::Class.new(
+                name: to_type_name(outer_module_name),
+                type_params: AST::Declarations::ModuleTypeParams.empty,
+                super_class: generate_super_class(outer_module),
+                members: [],
+                annotations: [],
+                location: nil,
+                comment: nil
+              )
+            else
+              outer_decl = AST::Declarations::Module.new(
+                name: to_type_name(outer_module_name),
+                type_params: AST::Declarations::ModuleTypeParams.empty,
+                self_types: [],
+                members: [],
+                annotations: [],
+                location: nil,
+                comment: nil
+              )
+            end
+
+            destination << outer_decl
+          end
+
+          destination = outer_decl.members
+        end
+
+        # Return the array of declarations checked out at the end
+        destination
+      end
 
-        generate_constants mod
+      # Returns the exact name & not compactly declared name
+      def only_name(mod)
+        # No nil check because this method is invoked after checking if the module exists
+        const_name(mod).split(/::/).last # (A::B::C) => C
       end
 
       def const_name(const)

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "1.2.1"
+  VERSION = "1.3.0"
 end

data/sig/ancestor_builder.rbs

@@ -80,6 +80,7 @@ module RBS
       def interface_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::InstanceAncestors
 
       def mixin_ancestors: (Environment::ClassEntry | Environment::ModuleEntry,
+                            TypeName,
                             included_modules: Array[Definition::Ancestor::Instance]?,
                          included_interfaces:Array[Definition::Ancestor::Instance]?,
                            prepended_modules: Array[Definition::Ancestor::Instance]?,
@@ -87,6 +88,7 @@ module RBS
                          extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
 
       def mixin_ancestors0: (AST::Declarations::Class | AST::Declarations::Module | AST::Declarations::Interface,
+                             TypeName,
                              align_params: Substitution?,
                          included_modules: Array[Definition::Ancestor::Instance]?,
                       included_interfaces:Array[Definition::Ancestor::Instance]?,

data/sig/errors.rbs

@@ -181,4 +181,19 @@ module RBS
 
     def location: () -> Location?
   end
+
+  class MixinClassError < DefinitionError
+    type member = AST::Members::Include | AST::Members::Prepend | AST::Members::Extend
+
+    attr_reader type_name: TypeName
+    attr_reader member: member
+
+    def initialize: (type_name: TypeName, member: member) -> void
+
+    def location: () -> Location?
+
+    def self.check!: (type_name: TypeName, env: Environment, member: member) -> void
+
+    def mixin_name: () -> String
+  end
 end

data/sig/namespace.rbs

@@ -13,7 +13,7 @@ module RBS
   #    RBS::Types::Union
   #    ^^^^^^^^^^^^         Namespace
   #
-  # Note that `Namespace` is a RBS specific concept and there is no corresponding concept in Ruby.
+  # Note that `Namespace` is an RBS specific concept and there is no corresponding concept in Ruby.
   #
   # There are _absolute_ and _relative_ namespaces.
   #

data/sig/polyfill.rbs

@@ -11,24 +11,6 @@ module Gem
   end
 end
 
-class OptionParser
-  def initialize: () ?{ (instance) -> void } -> void
-
-  def on: [T] (*String) { (T) -> void } -> void
-
-  attr_accessor version: String
-
-  attr_accessor banner: String
-
-  def order!: (Array[String]) -> void
-
-  def parse!: (Array[String]) -> void
-
-  def ver: () -> String
-
-  def help: () -> String
-end
-
 module Enumerable[unchecked out Elem]
   def flat_map: [U] () { (Elem) -> Array[U] } -> Array[U]
               | [U] () { (Elem) -> U } -> Array[U]

data/stdlib/dbm/0/dbm.rbs

@@ -61,23 +61,24 @@
 #     puts db['822']
 #
 class DBM
-  include Enumerable[untyped]
+  include Enumerable[[String, String]]
 
   # Open a dbm database and yields it if a block is given. See also `DBM.new`.
   #
-  def self.open: (*untyped) -> ::DBM
+  def self.open: (String filename, ?Integer mode, ?Integer flags) -> DBM
+               | [T] (String filename, ?Integer mode, ?Integer flags) { (DBM) -> T } -> T
 
   public
 
   # Return a value from the database by locating the key string provided.  If the
   # key is not found, returns nil.
   #
-  def []: (untyped) -> untyped
+  def []: (String) -> String?
 
   # Stores the specified string value in the database, indexed via the string key
   # provided.
   #
-  def []=: (untyped, untyped) -> untyped
+  def []=: (String, String) -> String
 
   # Deletes all data from the database.
   #
@@ -85,7 +86,7 @@ class DBM
 
   # Closes the database.
   #
-  def close: () -> NilClass
+  def close: () -> void
 
   # Returns true if the database is closed, false otherwise.
   #
@@ -93,27 +94,31 @@ class DBM
 
   # Deletes an entry from the database.
   #
-  def delete: (untyped) -> untyped
+  def delete: (String) -> void
 
   # Deletes all entries for which the code block returns true. Returns self.
   #
-  def delete_if: () ?{ (untyped) -> bool } -> self
+  def delete_if: () { (String) -> boolish } -> self
 
   # Calls the block once for each [key, value] pair in the database. Returns self.
   #
-  def each: (?untyped, ?untyped) -> Enumerator[untyped, ::DBM]
+  def each: () { ([String, String]) -> void } -> self
+          | () -> Enumerator[[String, String], self]
 
   # Calls the block once for each key string in the database. Returns self.
   #
-  def each_key: () -> Enumerator[String, ::DBM]
+  def each_key: { (String) -> void } -> self
+              | () -> Enumerator[String, self]
 
   # Calls the block once for each [key, value] pair in the database. Returns self.
   #
-  def each_pair: (?untyped, ?untyped) -> Enumerator[untyped, ::DBM]
+  def each_pair: () { ([String, String]) -> void } -> self
+               | () -> Enumerator[[String, String], self]
 
   # Calls the block once for each value string in the database. Returns self.
   #
-  def each_value: () -> Enumerator[untyped, ::DBM]
+  def each_value: () { (String) -> void } -> self
+                | () -> Enumerator[String, self]
 
   # Returns true if the database is empty, false otherwise.
   #
@@ -123,7 +128,7 @@ class DBM
   # key is not found, returns `ifnone`. If `ifnone` is not given, raises
   # IndexError.
   #
-  def fetch: (*String) -> untyped
+  def fetch: (String key, ?String ifnone) -> String
 
   # Returns true if the database contains the specified key, false otherwise.
   #
@@ -132,7 +137,7 @@ class DBM
   # Returns true if the database contains the specified string value, false
   # otherwise.
   #
-  def has_value?: (untyped) -> bool
+  def has_value?: () -> bool
 
   # Returns true if the database contains the specified key, false otherwise.
   #
@@ -141,15 +146,15 @@ class DBM
   # Returns a Hash (not a DBM database) created by using each value in the
   # database as a key, with the corresponding key as its value.
   #
-  def invert: () -> Hash[untyped, String]
+  def invert: () -> Hash[String, String]
 
   # Returns the key for the specified value.
   #
-  def key: (untyped) -> (String | NilClass)
+  def key: (String) -> String?
 
   # Returns true if the database contains the specified key, false otherwise.
   #
-  def key?: (untyped) -> bool
+  def key?: (String) -> bool
 
   # Returns an array of all the string keys in the database.
   #
@@ -161,33 +166,37 @@ class DBM
 
   # Returns true if the database contains the specified key, false otherwise.
   #
-  def member?: (untyped) -> bool
+  def member?: (String) -> bool
 
   # Converts the contents of the database to an in-memory Hash, then calls
   # Hash#reject with the specified code block, returning a new Hash.
   #
-  def reject: () -> Hash[untyped, untyped]
+  def reject: () { (String, String) -> boolish } -> Hash[String, String]
 
   # Deletes all entries for which the code block returns true. Returns self.
   #
-  def reject!: () { (String, untyped) -> untyped } -> self
+  def reject!: () { (String, String) -> boolish } -> self
 
   # Replaces the contents of the database with the contents of the specified
   # object. Takes any object which implements the each_pair method, including Hash
   # and DBM objects.
   #
-  def replace: (untyped) -> ::DBM
+  def replace: (_ReplaceSource) -> ::DBM
+
+  interface _ReplaceSource
+    def each_pair: () { ([String, String]) -> void } -> void
+  end
 
   # Returns a new array consisting of the [key, value] pairs for which the code
   # block returns true.
   #
-  def select: () { () -> untyped } -> Array[untyped]
+  def select: () { ([String, String]) -> boolish } -> Array[[String, String]]
 
   # Removes a [key, value] pair from the database, and returns it. If the database
   # is empty, returns nil. The order in which values are removed/returned is not
   # guaranteed.
   #
-  def shift: () -> Array[untyped]
+  def shift: () -> [String, String]?
 
   # Returns the number of entries in the database.
   #
@@ -196,35 +205,39 @@ class DBM
   # Stores the specified string value in the database, indexed via the string key
   # provided.
   #
-  def store: (String, untyped) -> String
+  def store: (String, String) -> String
 
   # Converts the contents of the database to an array of [key, value] arrays, and
   # returns it.
   #
-  def to_a: () -> Array[untyped]
+  def to_a: () -> Array[[String, String]]
 
   # Converts the contents of the database to an in-memory Hash object, and returns
   # it.
   #
-  def to_hash: () -> Hash[String, untyped]
+  def to_hash: () -> Hash[String, String]
 
   # Updates the database with multiple values from the specified object. Takes any
   # object which implements the each_pair method, including Hash and DBM objects.
   #
-  def update: (untyped) -> ::DBM
+  def update: (_UpdateSource) -> ::DBM
+
+  interface _UpdateSource
+    def each_pair: () { ([String, String]) -> void } -> void
+  end
 
   # Returns true if the database contains the specified string value, false
   # otherwise.
   #
-  def value?: (untyped) -> bool
+  def value?: (String) -> bool
 
   # Returns an array of all the string values in the database.
   #
-  def values: () -> Array[untyped]
+  def values: () -> Array[String]
 
   # Returns an array containing the values associated with the given keys.
   #
-  def values_at: (*String) -> Array[untyped]
+  def values_at: (*String) -> Array[String]
 
   private
 
@@ -237,7 +250,7 @@ class DBM
   #
   # Flags should be one of READER, WRITER, WRCREAT or NEWDB.
   #
-  def initialize: (*untyped) -> self
+  def initialize: (String filename, ?Integer mode, ?Integer flags) -> void
 end
 
 # Indicates that dbm_open() should open the database in read/write mode, create