rbs 3.8.0 → 3.9.0.dev.1

data/lib/rbs/test/type_check.rb

@@ -22,8 +22,8 @@ module RBS
       end
 
       def overloaded_call(method, method_name, call, errors:)
-        es = method.method_types.map do |method_type|
-          es = method_call(method_name, method_type, call, errors: [])
+        es = method.defs.map do |type_def|
+          es = method_call(method_name, type_def.type, call, errors: [], annotations: type_def.annotations)
 
           if es.empty?
             return errors
@@ -58,11 +58,11 @@ module RBS
         errors
       end
 
-      def method_call(method_name, method_type, call, errors:)
+      def method_call(method_name, method_type, call, errors:, annotations: [])
         return errors if method_type.type.is_a?(Types::UntypedFunction)
 
         args(method_name, method_type, method_type.type, call.method_call, errors, type_error: Errors::ArgumentTypeError, argument_error: Errors::ArgumentError)
-        self.return(method_name, method_type, method_type.type, call.method_call, errors, return_error: Errors::ReturnTypeError)
+        self.return(method_name, method_type, method_type.type, call.method_call, errors, return_error: Errors::ReturnTypeError, annotations:)
 
         if method_type.block
           case
@@ -106,8 +106,10 @@ module RBS
         end
       end
 
-      def return(method_name, method_type, fun, call, errors, return_error:)
+      def return(method_name, method_type, fun, call, errors, return_error:, annotations: [])
         if call.return?
+          return if Test.call(call.return_value, IS_AP, NilClass) && annotations.find { |a| a.string == "implicitly-returns-nil" }
+
           unless value(call.return_value, fun.return_type)
             errors << return_error.new(klass: self_class,
                                        method_name: method_name,

data/lib/rbs/types.rb

@@ -15,7 +15,7 @@ module RBS
     end
 
     module NoTypeName
-      def map_type_name
+      def map_type_name(&)
         self
       end
     end
@@ -107,10 +107,16 @@ module RBS
       class Bool < Base; end
       class Void < Base; end
       class Any < Base
+        def initialize(location:, todo: false)
+          super(location: location)
+          todo! if todo
+        end
+
         def to_s(level=0)
           @string || "untyped"
         end
 
+        # @deprecated: this method is now called from the constructor, do not call it from outside
         def todo!
           @string = '__todo__'
           self
@@ -229,7 +235,7 @@ module RBS
 
       include EmptyEachType
 
-      def map_type_name
+      def map_type_name(&)
         ClassSingleton.new(
           name: yield(name, location, self),
           location: location
@@ -323,6 +329,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(name: name,
                        args: args.map {|ty| ty.sub(s) },
                        location: location)
@@ -365,6 +373,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(name: name,
                        args: args.map {|ty| ty.sub(s) },
                        location: location)
@@ -407,6 +417,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         Alias.new(name: name, args: args.map {|ty| ty.sub(s) }, location: location)
       end
 
@@ -463,6 +475,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(types: types.map {|ty| ty.sub(s) },
                        location: location)
       end
@@ -536,7 +550,7 @@ module RBS
             end
           end
         else
-          raise ArgumentError, "only one of `:fields` or `:all_fields` is requireds"
+          raise ArgumentError, "only one of `:fields` or `:all_fields` is required"
         end
 
         @location = location
@@ -568,6 +582,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(
           all_fields: all_fields.transform_values {|ty, required| [ty.sub(s), required] },
           location: location
@@ -658,6 +674,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(type: type.sub(s), location: location)
       end
 
@@ -746,15 +764,26 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(types: types.map {|ty| ty.sub(s) },
                        location: location)
       end
 
       def to_s(level = 0)
+        strs = types.map do |ty|
+          case ty
+          when Intersection
+            ty.to_s([1, level].max)
+          else
+            ty.to_s
+          end
+        end
+
         if level > 0
-          "(#{types.join(" | ")})"
+          "(#{strs.join(" | ")})"
         else
-          types.join(" | ")
+          strs.join(" | ")
         end
       end
 
@@ -826,6 +855,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(types: types.map {|ty| ty.sub(s) },
                        location: location)
       end
@@ -1078,6 +1109,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         map_type {|ty| ty.sub(s) }
       end
 
@@ -1257,6 +1290,8 @@ module RBS
       end
 
       def sub(subst)
+        return self if subst.empty?
+
         map_type { _1.sub(subst) }
       end
 
@@ -1331,6 +1366,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(
           type: type.sub(s),
           required: required,
@@ -1400,6 +1437,8 @@ module RBS
       end
 
       def sub(s)
+        return self if s.empty?
+
         self.class.new(
           type: type.sub(s),
           block: block&.sub(s),

data/lib/rbs/unit_test/spy.rb

@@ -20,6 +20,8 @@ module RBS
         attr_reader :object
         attr_reader :method_name
 
+        NO_RETURN = Object.new
+
         def initialize(object:, method_name:)
           @callback = -> (_) { }
           @object = object
@@ -39,7 +41,7 @@ module RBS
             define_method(
               spy.method_name,
               _ = -> (*args, &block) do
-                return_value = nil
+                return_value = NO_RETURN
                 exception = nil
                 block_calls = [] #: Array[Test::ArgumentsReturn]
 
@@ -105,7 +107,7 @@ module RBS
                       arguments: args,
                       exception: exception
                     )
-                  when return_value
+                  when ::RBS::UnitTest::Spy::WrapSpy::NO_RETURN != return_value
                     Test::ArgumentsReturn.return(
                       arguments: args,
                       value: return_value

data/lib/rbs/unit_test/type_assertions.rb

@@ -163,7 +163,7 @@ module RBS
           end
         end
 
-        last_trace = trace.last or raise
+        last_trace = trace.last or raise "empty trace"
 
         yield(mt, last_trace, result, exception)
       end
@@ -182,9 +182,9 @@ module RBS
 
           assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, "Call trace does not match with given method type: #{trace.inspect}"
 
-          method_types = method_types(method)
-          all_errors = method_types.map {|t| typecheck.method_call(method, t, trace, errors: []) }
-          assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_types.join(" | ")}"
+          method_defs = method_defs(method)
+          all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.each_annotation.to_a) }
+          assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}"
 
           raise exception if exception
 
@@ -219,30 +219,36 @@ module RBS
           assert_operator exception, :is_a?, ::Exception
           assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }
 
-          method_types = method_types(method)
-          all_errors = method_types.map {|t| typecheck.method_call(method, t, trace, errors: []) }
-          assert all_errors.all? {|es| es.size > 0 }, "Call trace unexpectedly matches one of method definitions:\n  #{trace.inspect}\n  #{method_types.join(" | ")}"
+          method_defs = method_defs(method)
+          all_errors = method_defs.map {|t| typecheck.method_call(method, t.type, trace, errors: [], annotations: t.each_annotation.to_a) }
+          assert all_errors.all? {|es| es.size > 0 }, "Call trace unexpectedly matches one of method definitions:\n  #{trace.inspect}\n  #{method_defs.map(&:type).join(" | ")}"
 
           result
         end
       end
 
-      def method_types(method)
+      def method_defs(method)
         type, definition = target
 
         case type
         when Types::ClassInstance
           subst = RBS::Substitution.build(definition.type_params, type.args)
-          definition.methods[method].method_types.map do |method_type|
-            method_type.sub(subst)
+          definition.methods[method].defs.map do |type_def|
+            type_def.update(
+              type: type_def.type.sub(subst)
+            )
           end
         when Types::ClassSingleton
-          definition.methods[method].method_types
+          definition.methods[method].defs
         else
           raise
         end
       end
 
+      def method_types(method)
+        method_defs(method).map(&:type)
+      end
+
       def allows_error(*errors)
         yield
       rescue *errors => exn

data/lib/rbs/validator.rb

@@ -151,6 +151,10 @@ module RBS
       end
     end
 
+    def validate_variable(var)
+      validate_type(var.type, context: nil)
+    end
+
     def validate_class_alias(entry:)
       case env.normalize_module_name?(entry.decl.new_name)
       when nil

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "3.8.0"
+  VERSION = "3.9.0.dev.1"
 end

data/lib/rbs/writer.rb

@@ -77,14 +77,19 @@ module RBS
     end
 
     def write(contents)
-      dirs = contents.select {|c| c.is_a?(AST::Directives::Base) } #: Array[AST::Directives::t]
+      resolves = contents.select { _1.is_a?(AST::Directives::ResolveTypeNames) } #: Array[AST::Directives::ResolveTypeNames]
+      uses = contents.select {|c| c.is_a?(AST::Directives::Use) } #: Array[AST::Directives::Use]
       decls = contents.select {|c| c.is_a?(AST::Declarations::Base) } #: Array[AST::Declarations::t]
 
-      dirs.each do |dir|
-        write_directive(dir)
+      if first_resolves = resolves.first
+        puts "# resolve-type-names: #{first_resolves.value}"
+        puts
       end
 
-      puts unless dirs.empty?
+      uses.each do |dir|
+        write_use_directive(dir)
+      end
+      puts unless uses.empty?
 
       [nil, *decls].each_cons(2) do |prev, decl|
         raise unless decl
@@ -94,7 +99,7 @@ module RBS
       end
     end
 
-    def write_directive(dir)
+    def write_use_directive(dir)
       clauses = dir.clauses.map do |clause|
         case clause
         when AST::Directives::Use::SingleClause

data/lib/rbs.rb

@@ -9,6 +9,7 @@ require "pp"
 require "ripper"
 require "logger"
 require "tsort"
+require "strscan"
 
 require "rbs/errors"
 require "rbs/buffer"

data/rbs.gemspec

@@ -30,7 +30,7 @@ Gem::Specification.new do |spec|
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
     `git ls-files -z`.split("\x0").reject do |f|
       [
-        %r{^(test|spec|features|bin|steep|benchmark)/},
+        %r{^(test|spec|features|bin|steep|benchmark|templates)/},
         /Gemfile/
       ].any? {|r| f.match(r) }
     end

data/sig/collection/config/lockfile_generator.rbs

@@ -4,7 +4,7 @@ module RBS
       class LockfileGenerator
         # Name of stdlibs that was rbs-bundled stdlib but is now a gem.
         #
-        ALUMNI_STDLIBS: Hash[String, String]
+        ALUMNI_STDLIBS: Hash[String, String?]
 
         class GemfileLockMismatchError < StandardError
           @expected: Pathname

data/sig/declarations.rbs

@@ -205,8 +205,10 @@ module RBS
         attr_reader type: Types::t
         attr_reader location: loc?
         attr_reader comment: Comment?
+        attr_reader annotations: Array[Annotation]
 
-        def initialize: (name: TypeName, type: Types::t, location: loc?, comment: Comment?) -> void
+        def initialize: (name: TypeName, type: Types::t, location: loc?, comment: Comment?, annotations: Array[Annotation]) -> void
+                      | %a{deprecated} (name: TypeName, type: Types::t, location: loc?, comment: Comment?) -> void
 
         include _HashEqual
         include _ToJson
@@ -223,8 +225,10 @@ module RBS
         attr_reader type: Types::t
         attr_reader location: loc?
         attr_reader comment: Comment?
+        attr_reader annotations: Array[Annotation]
 
-        def initialize: (name: Symbol, type: Types::t, location: loc?, comment: Comment?) -> void
+        def initialize: (name: Symbol, type: Types::t, location: loc?, comment: Comment?, annotations: Array[Annotation]) -> void
+                      | %a{deprecated} (name: Symbol, type: Types::t, location: loc?, comment: Comment?) -> void
 
         include _HashEqual
         include _ToJson
@@ -250,7 +254,10 @@ module RBS
 
         attr_reader comment: Comment?
 
-        def initialize: (new_name: TypeName, old_name: TypeName, location: loc?, comment: Comment?) -> void
+        attr_reader annotations: Array[Annotation]
+
+        def initialize: (new_name: TypeName, old_name: TypeName, location: loc?, comment: Comment?, annotations: Array[Annotation]) -> void
+                      | %a{deprecated} (new_name: TypeName, old_name: TypeName, location: loc?, comment: Comment?) -> void
 
         include _HashEqual
       end

data/sig/definition.rbs

@@ -6,8 +6,15 @@ module RBS
       attr_reader parent_variable: Variable?
       attr_reader type: Types::t
       attr_reader declared_in: TypeName
+      type source = AST::Members::AttrAccessor
+                  | AST::Members::AttrReader
+                  | AST::Members::AttrWriter
+                  | AST::Members::InstanceVariable
+                  | AST::Members::ClassVariable
+                  | AST::Members::ClassInstanceVariable
+      attr_reader source: source
 
-      def initialize: (parent_variable: Variable?, type: Types::t, declared_in: TypeName) -> void
+      def initialize: (parent_variable: Variable?, type: Types::t, declared_in: TypeName, source: source) -> void
 
       def sub: (Substitution) -> Variable
     end
@@ -21,22 +28,50 @@ module RBS
         attr_reader defined_in: TypeName
         attr_reader implemented_in: TypeName?
 
-        # Annotations given to `#member`
+        # Annotations given to the method definition syntax
+        #
+        # If the method have multiple syntaxes, union of the annotations to the member will be included, without dedup.
+        #
+        # The value should be updated during setup.
+        #
         attr_reader member_annotations: Array[AST::Annotation]
 
         # Annotations given to the overload associated to the method type
+        #
+        # The value should be updated during setup.
+        #
         attr_reader overload_annotations: Array[AST::Annotation]
 
-        # Concatenation of `member_annotations` and `overload_annotations`
-        attr_reader annotations: Array[AST::Annotation]
-
-        def initialize: (type: MethodType, member: method_member, defined_in: TypeName, implemented_in: TypeName?, ?overload_annotations: Array[AST::Annotation]) -> void
+        # Always returns an empty array
+        %a{deprecated} attr_reader annotations: Array[AST::Annotation]
+
+        # `overload_annotations` is ignored.
+        def initialize: (
+            type: MethodType,
+            member: method_member,
+            defined_in: TypeName,
+            implemented_in: TypeName?
+          ) -> void
+        | %a{deprecated} (
+            type: MethodType,
+            member: method_member,
+            defined_in: TypeName,
+            implemented_in: TypeName?,
+            overload_annotations: nil
+          ) -> void
 
         def comment: () -> AST::Comment?
 
         def update: (?type: MethodType, ?member: method_member, ?defined_in: TypeName, ?implemented_in: TypeName?) -> TypeDef
 
         def overload?: () -> bool
+
+        # Yields member and overload annotations, without dedup
+        #
+        # Member annotation yields first.
+        #
+        def each_annotation: () { (AST::Annotation) -> void } -> void
+                           | () -> Enumerator[AST::Annotation]
       end
 
       attr_reader super_method: Method?
@@ -49,21 +84,38 @@ module RBS
       attr_reader comments: Array[AST::Comment]
 
       attr_reader members: Array[method_member]
+
+      # The original method when the method is defined with `alias` syntax
       attr_reader alias_of: Method?
 
+      # Present if the method is defined with `alias` syntax
+      attr_reader alias_member: AST::Members::Alias?
+
       # Unused, always returns empty array
-      attr_reader extra_annotations: Array[AST::Annotation]
+      %a{deprecated} attr_reader extra_annotations: Array[AST::Annotation]
 
-      # Union of annotations given to `defs`, not contains annotations given to each overload
+      # Union of annotations given to `def`s and `alias`, not contains annotations given to each overload
+      #
+      # The elements will be updated during `Method` object setup.
+      #
       attr_reader annotations: Array[AST::Annotation]
 
       # Note that the annotations given through `annotations:` keyword is ignored.
       #
-      def initialize: (super_method: Method?,
-                       defs: Array[TypeDef],
-                       accessibility: accessibility,
-                       alias_of: Method?,
-                       ?annotations: Array[AST::Annotation]) -> void
+      def initialize: (
+          super_method: Method?,
+          defs: Array[TypeDef],
+          accessibility: accessibility,
+          alias_of: Method?,
+          alias_member: AST::Members::Alias?
+        ) -> void
+      | %a{deprecated} (
+          super_method: Method?,
+          defs: Array[TypeDef],
+          accessibility: accessibility,
+          alias_of: Method?,
+          annotations: Array[AST::Annotation]
+        ) -> void
 
       def public?: () -> bool
 
@@ -90,7 +142,8 @@ module RBS
         ?defs: Array[TypeDef],
         ?accessibility: accessibility,
         ?alias_of: Method?,
-        ?annotations: Array[AST::Annotation]
+        ?annotations: Array[AST::Annotation],
+        ?alias_member: AST::Members::Alias?
       ) -> Method
     end
 

data/sig/definition_builder.rbs

@@ -105,7 +105,15 @@ module RBS
 
     def source_location: (Definition::Ancestor::Instance::source, AST::Declarations::t) -> Location[untyped, untyped]?
 
-    def insert_variable: (TypeName, Hash[Symbol, Definition::Variable], name: Symbol, type: Types::t) -> void
+    def validate_variable: (Definition::Variable) -> void
+
+    def insert_variable: (
+      TypeName,
+      Hash[Symbol, Definition::Variable],
+      name: Symbol,
+      type: Types::t,
+      source: Definition::Variable::source
+    ) -> void
 
     # Add method definition to `methods`, which will be merged to `class_definition` after defining all methods at this *level* -- class, module, or interface
     #
@@ -142,11 +150,17 @@ module RBS
       Hash[Symbol, Definition::Method]? self_type_methods,
     ) -> void
 
-    # Updates `definition` with methods and variables of `type_name` that can be a module or a class
+    # Updates `definition` with methods and instance variables of `type_name` that can be a module or a class
     #
     # It processes includes and prepends recursively.
+    # If `define_class_vars:` is falsy, it skips inserting class variables.
     #
-    def define_instance: (Definition definition, TypeName type_name, Substitution subst) -> void
+    def define_instance: (
+      Definition definition,
+      TypeName type_name,
+      Substitution subst,
+      define_class_vars: bool
+    ) -> void
 
     # Updates `definition` with methods defined in an interface `type_name`
     #

data/sig/directives.rbs

@@ -1,7 +1,7 @@
 module RBS
   module AST
     module Directives
-      type t = Use
+      type t = Use | ResolveTypeNames
 
       class Base
       end
@@ -56,6 +56,22 @@ module RBS
 
         def initialize: (clauses: Array[clause], location: loc?) -> void
       end
+
+      class ResolveTypeNames < Base
+        # ```
+        # # resolve-type-names: false
+        #   ^^^^^^^^^^^^^^^^^^          keyword
+        #                     ^         colon
+        #                       ^^^^^   value
+        # ```
+        type loc = Location[:keyword | :colon | :value, bot]
+
+        attr_reader location: loc?
+
+        attr_reader value: bool
+
+        def initialize: (value: bool, location: loc?) -> void
+      end
     end
   end
 end

data/sig/environment.rbs

@@ -141,6 +141,8 @@ module RBS
     #
     def resolve_type_names: (?only: Set[AST::Declarations::t]?) -> Environment
 
+    def resolve_signature: (Resolver::TypeNameResolver, UseMap::Table, Array[AST::Directives::t], Array[AST::Declarations::t], ?only: Set[AST::Declarations::t]?) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
+
     def inspect: () -> String
 
     def buffers: () -> Array[Buffer]

data/sig/errors.rbs

@@ -182,6 +182,22 @@ module RBS
     def location: () -> AST::Members::Mixin::loc?
   end
 
+  class VariableDuplicationError < DefinitionError
+    include DetailedMessageable
+
+    attr_reader member: AST::Members::Var
+
+    def initialize: (member: AST::Members::Var) -> void
+
+    def location: () -> Location[bot, bot]
+  end
+
+  class InstanceVariableDuplicationError < VariableDuplicationError
+  end
+
+  class ClassInstanceVariableDuplicationError < VariableDuplicationError
+  end
+
   # The `alias` member declares an alias from unknown method
   #
   class UnknownMethodAliasError < DefinitionError

data/sig/parser.rbs

@@ -68,6 +68,10 @@ module RBS
     #
     def self.parse_signature: (Buffer | String) -> [Buffer, Array[AST::Directives::t], Array[AST::Declarations::t]]
 
+    # Returns the magic comment from the buffer
+    #
+    def self.magic_comment: (Buffer) -> AST::Directives::ResolveTypeNames?
+
     # Parse whole RBS file and return result.
     #
     # ```ruby
@@ -86,7 +90,7 @@ module RBS
 
     def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> MethodType?
 
-    def self._parse_signature: (Buffer, Integer end_pos) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
+    def self._parse_signature: (Buffer, Integer start_pos, Integer end_pos) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
 
     def self._lex: (Buffer, Integer end_pos) -> Array[[Symbol, Location[untyped, untyped]]]
 

data/sig/subtractor.rbs

@@ -24,7 +24,7 @@ module RBS
 
     private def mixin_exist?: (TypeName owner, AST::Members::Include | AST::Members::Extend | AST::Members::Prepend, context: Resolver::context) -> boolish
 
-    private def filter_redundunt_access_modifiers: (Array[AST::Declarations::t | AST::Members::t]) -> Array[AST::Declarations::t | AST::Members::t]
+    private def filter_redundant_access_modifiers: (Array[AST::Declarations::t | AST::Members::t]) -> Array[AST::Declarations::t | AST::Members::t]
 
     private def access_modifier?: (AST::Declarations::t | AST::Members::t?) -> bool