rbs 1.0.0.pre → 1.0.3

data/core/module.rbs

@@ -259,7 +259,7 @@ class Module < Object
   #         or method `code' for Thing:Class
   #
   def class_eval: (String arg0, ?String filename, ?Integer lineno) -> untyped
-                | [U] (untyped arg0) { (untyped m) -> U } -> U
+                | [U] { (self m) -> U } -> U
 
   # Evaluates the given block in the context of the class/module. The method
   # defined in the block will belong to the receiver. Any arguments passed to the
@@ -443,6 +443,47 @@ class Module < Object
   #
   def const_set: (Symbol | String arg0, untyped arg1) -> untyped
 
+  # Returns the Ruby source filename and line number containing first definition
+  # of constant specified. If the named constant is not found, `nil` is returned.
+  # If the constant is found, but its source location can not be extracted
+  # (constant is defined in C code), empty array is returned.
+  #
+  # *inherit* specifies whether to lookup in `mod.ancestors` (`true` by default).
+  #
+  #     # test.rb:
+  #     class A
+  #       C1 = 1
+  #     end
+  #
+  #     module M
+  #       C2 = 2
+  #     end
+  #
+  #     class B < A
+  #       include M
+  #       C3 = 3
+  #     end
+  #
+  #     class A # continuation of A definition
+  #     end
+  #
+  #     p B.const_source_location('C3')           # => ["test.rb", 11]
+  #     p B.const_source_location('C2')           # => ["test.rb", 6]
+  #     p B.const_source_location('C1')           # => ["test.rb", 2]
+  #
+  #     p B.const_source_location('C2', false)    # => nil  -- don't lookup in ancestors
+  #
+  #     p Object.const_source_location('B')       # => ["test.rb", 9]
+  #     p Object.const_source_location('A')       # => ["test.rb", 1]  -- note it is first entry, not "continuation"
+  #
+  #     p B.const_source_location('A')            # => ["test.rb", 1]  -- because Object is in ancestors
+  #     p M.const_source_location('A')            # => ["test.rb", 1]  -- Object is not ancestor, but additionally checked for modules
+  #
+  #     p Object.const_source_location('A::C1')   # => ["test.rb", 2]  -- nesting is supported
+  #     p Object.const_source_location('String')  # => []  -- constant is defined in C code
+  #
+  def const_source_location: (Symbol | String name, ?boolish inherit) -> ([String, Integer] | [ ] | nil)
+
   # Returns an array of the names of the constants accessible in *mod*. This
   # includes the names of constants in any included modules (example at start of
   # section), unless the *inherit* parameter is set to `false`.
@@ -752,7 +793,7 @@ class Module < Object
   #         or method `code' for Thing:Class
   #
   def module_eval: (String arg0, ?String filename, ?Integer lineno) -> untyped
-                 | [U] (untyped arg0) { (untyped m) -> U } -> U
+                 | [U] { (self m) -> U } -> U
 
   # Evaluates the given block in the context of the class/module. The method
   # defined in the block will belong to the receiver. Any arguments passed to the

data/core/unbound_method.rbs

@@ -150,4 +150,20 @@ class UnboundMethod
   # if there is no method on superclass.
   #
   def super_method: () -> UnboundMethod?
+
+  # Returns the original name of the method.
+  #
+  #     class C
+  #       def foo; end
+  #       alias bar foo
+  #     end
+  #     C.instance_method(:bar).original_name # => :foo
+  #
+  def original_name: () -> Symbol
+
+  # Bind *umeth* to *recv* and then invokes the method with the specified
+  # arguments. This is semantically equivalent to `umeth.bind(recv).call(args,
+  # ...)`.
+  #
+  def bind_call: (untyped recv, *untyped args) ?{ (*untyped) -> untyped } -> untyped
 end

data/docs/CONTRIBUTING.md

@@ -49,12 +49,12 @@ You may find the *Good for first contributor* column where you can find some cla
   * `--merge` tells to use the method types in RBS if exists.
 * `rbs prototype runtime --merge --method-owner=Numeric Integer`
   * You can use --method-owner if you want to print method of other classes too, for documentation purpose.
-* `bin/annotate-with-rdoc stdlib/builtin/string.rbs`
+* `bin/annotate-with-rdoc core/string.rbs`
   * Write comments using RDoc.
   * It contains arglists section, but I don't think we should have it in RBS files.
 * `bin/query-rdoc String#initialize`
   * Print RDoc documents in the format you can copy-and-paste to RBS.
-* `bin/sort stdlib/builtin/string.rbs`
+* `bin/sort core/string.rbs`
   * Sort declarations members in RBS files.
 * `rbs validate -r LIB`
   Validate the syntax and some of the semantics.

data/docs/stdlib.md

@@ -11,7 +11,7 @@ The typical steps of writing signatures will be like the following:
 
 ## Signatures
 
-Signatures for standard libraries are located in `stdlib` directory. `stdlib/builtin` is for builtin libraries. Other libraries have directories like `stdlib/set` or `stdlib/pathname`.
+Signatures for builtin libraries are located in `core` directory. Also, signatures for standard libraries are located in `stdlib` directory.
 
 To write signatures see [syntax guide](syntax.md).
 
@@ -118,23 +118,61 @@ It generates `test/stdlib/[class_name]_test.rb`.
 The test scripts would look like the following:
 
 ```rb
-class StringTest < StdlibTest
-  target String
+class StringSingletonTest < Test::Unit::TestCase
+  include TypeAssertions
+
+  testing "singleton(::String)"
+
+  def test_initialize
+    assert_send_type "() -> String",
+                     String, :new
+    assert_send_type "(String) -> String",
+                     String, :new, ""
+    assert_send_type "(String, encoding: Encoding) -> String",
+                     String, :new, "", encoding: Encoding::ASCII_8BIT
+    assert_send_type "(String, encoding: Encoding, capacity: Integer) -> String",
+                     String, :new, "", encoding: Encoding::ASCII_8BIT, capacity: 123
+    assert_send_type "(encoding: Encoding, capacity: Integer) -> String",
+                     String, :new, encoding: Encoding::ASCII_8BIT, capacity: 123
+    assert_send_type "(ToStr) -> String",
+                     String, :new, ToStr.new("")
+    assert_send_type "(encoding: ToStr) -> String",
+                     String, :new, encoding: ToStr.new('Shift_JIS')
+    assert_send_type "(capacity: ToInt) -> String",
+                     String, :new, capacity: ToInt.new(123)
+  end
+end
+
+class StringTest < Test::Unit::TestCase
+  include TypeAssertions
+
+  # library "pathname", "set", "securerandom"     # Declare library signatures to load
+  testing "::String"
 
   def test_gsub
-    s = "string"
-    s.gsub(/./, "")
-    s.gsub("a", "b")
-    s.gsub(/./) {|x| "" }
-    s.gsub(/./, {"foo" => "bar"})
-    s.gsub(/./)
-    s.gsub("")
+    assert_send_type "(Regexp, String) -> String",
+                     "string", :gsub, /./, ""
+    assert_send_type "(String, String) -> String",
+                     "string", :gsub, "a", "b"
+    assert_send_type "(Regexp) { (String) -> String } -> String",
+                     "string", :gsub, /./ do |x| "" end
+    assert_send_type "(Regexp) { (String) -> ToS } -> String",
+                     "string", :gsub, /./ do |x| ToS.new("") end
+    assert_send_type "(Regexp, Hash[String, String]) -> String",
+                     "string", :gsub, /./, {"foo" => "bar"}
+    assert_send_type "(Regexp) -> Enumerator[String, self]",
+                     "string", :gsub, /./
+    assert_send_type "(String) -> Enumerator[String, self]",
+                     "string", :gsub, ""
+    assert_send_type "(ToStr, ToStr) -> String",
+                     "string", :gsub, ToStr.new("a"), ToStr.new("b")
   end
 end
 ```
 
-You need two method calls, `target` and `using`.
-`target` method call tells which class is the subject of the class.
+You need include `TypeAssertions` which provide useful methods for you.
+`testing` method call tells which class is the subject of the class.
+`assert_send_type` method call asserts to be valid types and confirms to be able to execute without exceptions.
 And you write the sample programs which calls all of the patterns of overloads.
 
 Note that the instrumentation is based on refinements and you need to write all method calls in the unit class definitions.

data/docs/syntax.md

@@ -531,23 +531,6 @@ interface _Foo
 end
 ```
 
-### Extension declaration
-
-Extension is to model _open class_.
-
-```
-extension Kernel (Pathname)
-  def Pathname: (String) -> Pathname
-end
-
-extension Array[A] (ActiveSupport)
-  def to: (Integer) -> Array[A]
-  def from: (Integer) -> Array[A]
-  def second: () -> A?
-  def third: () -> A?
-end
-```
-
 ### Type alias declaration
 
 You can declare an alias of types.

data/goodcheck.yml

@@ -3,7 +3,7 @@ rules:
     pattern: 💪👽🚨
     message: Do you forget to delete `arglists` section?
     glob:
-      - "stdlib/**/*.rbs"
+      - "{core,stdlib}/**/*.rbs"
     fail:
       - |
         # arglists 💪👽🚨 << Delete this section
@@ -22,7 +22,7 @@ rules:
     justification:
       - Documents (comments) may contain that pattern.
     glob:
-      - "stdlib/**/*.rbs"
+      - "{core,stdlib}/**/*.rbs"
     fail:
       - "def `send`: (String | Symbol arg0, *untyped arg1) -> untyped"
     pass:
@@ -71,7 +71,7 @@ rules:
         end
     pass:
       - |
-        class IntegerTest < Minitest::Test
+        class IntegerTest < Test::Unit::TestCase
           include TypeAssertions
 
           testing "Integer"

data/lib/rbs/ast/declarations.rb

@@ -300,53 +300,6 @@ module RBS
         end
       end
 
-      class Extension < Base
-        attr_reader :name
-        attr_reader :type_params
-        attr_reader :extension_name
-        attr_reader :members
-        attr_reader :annotations
-        attr_reader :location
-        attr_reader :comment
-
-        def initialize(name:, type_params:, extension_name:, members:, annotations:, location:, comment:)
-          @name = name
-          @type_params = type_params
-          @extension_name = extension_name
-          @members = members
-          @annotations = annotations
-          @location = location
-          @comment = comment
-        end
-
-        def ==(other)
-          other.is_a?(Extension) &&
-            other.name == name &&
-            other.type_params == type_params &&
-            other.extension_name == extension_name &&
-            other.members == members
-        end
-
-        alias eql? ==
-
-        def hash
-          self.class.hash ^ name.hash ^ type_params.hash ^ extension_name.hash ^ members.hash
-        end
-
-        def to_json(*a)
-          {
-            declaration: :extension,
-            name: name,
-            type_params: type_params,
-            extension_name: extension_name,
-            members: members,
-            annotations: annotations,
-            location: location,
-            comment: comment
-          }.to_json(*a)
-        end
-      end
-
       class Interface < Base
         attr_reader :name
         attr_reader :type_params

data/lib/rbs/definition_builder.rb

@@ -44,7 +44,8 @@ module RBS
 
         ancestors = ancestor_builder.interface_ancestors(type_name)
         Definition.new(type_name: type_name, entry: entry, self_type: self_type, ancestors: ancestors).tap do |definition|
-          ancestor_builder.one_interface_ancestors(type_name).included_interfaces.each do |mod|
+          included_interfaces = ancestor_builder.one_interface_ancestors(type_name).included_interfaces or raise
+          included_interfaces.each do |mod|
             defn = build_interface(mod.name)
             subst = Substitution.build(defn.type_params, mod.args)
 
@@ -54,13 +55,17 @@ module RBS
           end
 
           methods = method_builder.build_interface(type_name)
+          one_ancestors = ancestor_builder.one_interface_ancestors(type_name)
+
+          validate_type_params(definition, methods: methods, ancestors: one_ancestors)
+
           methods.each do |defn|
-            method = case defn.original
+            method = case original = defn.original
                      when AST::Members::MethodDefinition
-                       defs = defn.original.types.map do |method_type|
+                       defs = original.types.map do |method_type|
                          Definition::Method::TypeDef.new(
                            type: method_type,
-                           member: defn.original,
+                           member: original,
                            defined_in: type_name,
                            implemented_in: nil
                          )
@@ -73,15 +78,15 @@ module RBS
                          alias_of: nil
                        )
                      when AST::Members::Alias
-                       unless definition.methods.key?(defn.original.old_name)
+                       unless definition.methods.key?(original.old_name)
                          raise UnknownMethodAliasError.new(
-                           original_name: defn.original.old_name,
-                           aliased_name: defn.original.new_name,
-                           location: defn.original.location
+                           original_name: original.old_name,
+                           aliased_name: original.new_name,
+                           location: original.location
                          )
                        end
 
-                       original_method = definition.methods[defn.original.old_name]
+                       original_method = definition.methods[original.old_name]
                        Definition::Method.new(
                          super_method: nil,
                          defs: original_method.defs.map do |defn|
@@ -101,10 +106,14 @@ module RBS
                        end
 
                        definition.methods[defn.name]
+
+                     when AST::Members::AttrReader, AST::Members::AttrWriter, AST::Members::AttrAccessor
+                       raise
+
                      end
 
             defn.overloads.each do |overload|
-              defs = overload.types.map do |method_type|
+              overload_defs = overload.types.map do |method_type|
                 Definition::Method::TypeDef.new(
                   type: method_type,
                   member: overload,
@@ -113,7 +122,7 @@ module RBS
                 )
               end
 
-              method.defs.unshift(*defs)
+              method.defs.unshift(*overload_defs)
             end
 
             definition.methods[defn.name] = method
@@ -122,8 +131,8 @@ module RBS
       end
     end
 
-    def build_instance(type_name)
-      try_cache(type_name, cache: instance_cache) do
+    def build_instance(type_name, no_self_types: false)
+      try_cache(type_name, cache: instance_cache, key: [type_name, no_self_types]) do
         entry = env.class_decls[type_name] or raise "Unknown name for build_instance: #{type_name}"
         ensure_namespace!(type_name.namespace, location: entry.decls[0].decl.location)
 
@@ -141,31 +150,39 @@ module RBS
             validate_type_params definition, methods: methods, ancestors: one_ancestors
 
             if super_class = one_ancestors.super_class
-              defn = build_instance(super_class.name)
-              merge_definition(src: defn,
-                               dest: definition,
-                               subst: Substitution.build(defn.type_params, super_class.args),
-                               keep_super: true)
+              case super_class
+              when Definition::Ancestor::Instance
+                build_instance(super_class.name).yield_self do |defn|
+                  merge_definition(src: defn,
+                                  dest: definition,
+                                  subst: Substitution.build(defn.type_params, super_class.args),
+                                  keep_super: true)
+                end
+              else
+                raise
+              end
             end
 
-            if one_ancestors.self_types
-              one_ancestors.self_types.each do |ans|
-                defn = if ans.name.interface?
-                         build_interface(ans.name)
-                       else
-                         build_instance(ans.name)
-                       end
+            if self_types = one_ancestors.self_types
+              unless no_self_types
+                self_types.each do |ans|
+                  defn = if ans.name.interface?
+                           build_interface(ans.name)
+                         else
+                           build_instance(ans.name)
+                         end
 
-                # Successor interface method overwrites.
-                merge_definition(src: defn,
-                                 dest: definition,
-                                 subst: Substitution.build(defn.type_params, ans.args),
-                                 keep_super: true)
+                  # Successor interface method overwrites.
+                  merge_definition(src: defn,
+                                   dest: definition,
+                                   subst: Substitution.build(defn.type_params, ans.args),
+                                   keep_super: true)
+                end
               end
             end
 
-            one_ancestors.included_modules.each do |mod|
-              defn = build_instance(mod.name)
+            one_ancestors.each_included_module do |mod|
+              defn = build_instance(mod.name, no_self_types: true)
               merge_definition(src: defn,
                                dest: definition,
                                subst: Substitution.build(defn.type_params, mod.args))
@@ -173,16 +190,20 @@ module RBS
 
             interface_methods = {}
 
-            one_ancestors.included_interfaces.each do |mod|
+            one_ancestors.each_included_interface do |mod|
               defn = build_interface(mod.name)
               subst = Substitution.build(defn.type_params, mod.args)
 
               defn.methods.each do |name, method|
                 if interface_methods.key?(name)
+                  include_member = mod.source
+
+                  raise unless include_member.is_a?(AST::Members::Include)
+
                   raise DuplicatedInterfaceMethodDefinitionError.new(
                     type: self_type,
                     method_name: name,
-                    member: mod.source
+                    member: include_member
                   )
                 end
 
@@ -221,7 +242,7 @@ module RBS
               end
             end
 
-            one_ancestors.prepended_modules.each do |mod|
+            one_ancestors.each_prepended_module do |mod|
               defn = build_instance(mod.name)
               merge_definition(src: defn,
                                dest: definition,
@@ -261,24 +282,28 @@ module RBS
               end
             end
 
-            one_ancestors.extended_modules.each do |mod|
-              defn = build_instance(mod.name)
-              merge_definition(src: defn,
+            one_ancestors.each_extended_module do |mod|
+              mod_defn = build_instance(mod.name, no_self_types: true)
+              merge_definition(src: mod_defn,
                                dest: definition,
-                               subst: Substitution.build(defn.type_params, mod.args))
+                               subst: Substitution.build(mod_defn.type_params, mod.args))
             end
 
             interface_methods = {}
-            one_ancestors.extended_interfaces.each do |mod|
-              defn = build_interface(mod.name)
-              subst = Substitution.build(defn.type_params, mod.args)
+            one_ancestors.each_extended_interface do |mod|
+              mod_defn = build_interface(mod.name)
+              subst = Substitution.build(mod_defn.type_params, mod.args)
 
-              defn.methods.each do |name, method|
+              mod_defn.methods.each do |name, method|
                 if interface_methods.key?(name)
+                  src_member = mod.source
+
+                  raise unless src_member.is_a?(AST::Members::Extend)
+
                   raise DuplicatedInterfaceMethodDefinitionError.new(
                     type: self_type,
                     method_name: name,
-                    member: mod.source
+                    member: src_member
                   )
                 end
 
@@ -418,6 +443,20 @@ module RBS
       end
     end
 
+    def source_location(source, decl)
+      case source
+      when nil
+        decl.location
+      when :super
+        case decl
+        when AST::Declarations::Class
+          decl.super_class&.location
+        end
+      else
+        source.location
+      end
+    end
+
     def validate_type_params(definition, ancestors:, methods:)
       type_params = definition.type_params_decl
 
@@ -429,19 +468,17 @@ module RBS
         when Definition::Ancestor::Instance
           result = calculator.in_inherit(name: ancestor.name, args: ancestor.args, variables: param_names)
           validate_params_with(type_params, result: result) do |param|
-            location = case source = ancestor.source
-                       when nil
-                         definition.entry.primary.decl.location
-                       when :super
-                         definition.entry.primary.decl.super_class.location
-                       else
-                         source.location
-                       end
+            decl = case entry = definition.entry
+                   when Environment::ModuleEntry, Environment::ClassEntry
+                     entry.primary.decl
+                   when Environment::SingleEntry
+                     entry.decl
+                   end
 
             raise InvalidVarianceAnnotationError.new(
               type_name: definition.type_name,
               param: param,
-              location: location
+              location: source_location(ancestor.source, decl)
             )
           end
         end
@@ -481,8 +518,6 @@ module RBS
                          nil
                        when nil
                          nil
-                       else
-                         raise
                        end
 
         if method_types
@@ -537,11 +572,11 @@ module RBS
           if interface_methods.key?(method_name)
             interface_method = interface_methods[method_name]
 
-            if method_def.original
+            if original = method_def.original
               raise DuplicatedMethodDefinitionError.new(
                 type: definition.self_type,
                 method_name: method_name,
-                members: [method_def.original]
+                members: [original]
               )
             end
 
@@ -561,6 +596,7 @@ module RBS
               )
             end
 
+            # @type var accessibility: RBS::Definition::accessibility
             accessibility = if method_name == :initialize
                               :private
                             else
@@ -640,7 +676,7 @@ module RBS
         end
 
         method_def.overloads.each do |overload|
-          defs = overload.types.map do |method_type|
+          type_defs = overload.types.map do |method_type|
             Definition::Method::TypeDef.new(
               type: method_type,
               member: overload,
@@ -649,7 +685,7 @@ module RBS
             )
           end
 
-          method.defs.unshift(*defs)
+          method.defs.unshift(*type_defs)
         end
 
         definition.methods[method_name] = method
@@ -717,8 +753,10 @@ module RBS
       )
     end
 
-    def try_cache(type_name, cache:)
-      cached = _ = cache[type_name]
+    def try_cache(type_name, cache:, key: type_name)
+      # @type var cc: Hash[untyped, Definition | false | nil]
+      cc = _ = cache
+      cached = cc[key]
 
       case cached
       when Definition
@@ -726,11 +764,11 @@ module RBS
       when false
         raise
       when nil
-        cache[type_name] = false
+        cc[key] = false
         begin
-          cache[type_name] = yield
+          cc[key] = yield
         rescue => ex
-          cache.delete(type_name)
+          cc.delete(key)
           raise ex
         end
       else