rbs 2.8.4 → 3.8.1

data/lib/rbs/types.rb

@@ -73,7 +73,7 @@ module RBS
           when Types::Bases::Void
             'void'
           when Types::Bases::Any
-            'untyped'
+            raise
           when Types::Bases::Nil
             'nil'
           when Types::Bases::Top
@@ -90,11 +90,32 @@ module RBS
             raise "Unexpected base type: #{inspect}"
           end
         end
+
+        def has_self_type?
+          self.is_a?(Types::Bases::Self)
+        end
+
+        def has_classish_type?
+          self.is_a?(Bases::Instance) || self.is_a?(Bases::Class)
+        end
+
+        def with_nonreturn_void?
+          self.is_a?(Bases::Void)
+        end
       end
 
       class Bool < Base; end
       class Void < Base; end
-      class Any < Base; end
+      class Any < Base
+        def to_s(level=0)
+          @string || "untyped"
+        end
+
+        def todo!
+          @string = '__todo__'
+          self
+        end
+      end
       class Nil < Base; end
       class Top < Base; end
       class Bottom < Base; end
@@ -162,6 +183,18 @@ module RBS
       end
 
       include EmptyEachType
+
+      def has_self_type?
+        false
+      end
+
+      def has_classish_type?
+        false
+      end
+
+      def with_nonreturn_void?
+        false
+      end
     end
 
     class ClassSingleton
@@ -202,6 +235,18 @@ module RBS
           location: location
         )
       end
+
+      def has_self_type?
+        false
+      end
+
+      def has_classish_type?
+        false
+      end
+
+      def with_nonreturn_void?
+        false
+      end
     end
 
     module Application
@@ -241,6 +286,25 @@ module RBS
           enum_for :each_type
         end
       end
+
+      def has_self_type?
+        each_type.any? {|type| type.has_self_type? }
+      end
+
+      def has_classish_type?
+        each_type.any? {|type| type.has_classish_type? }
+      end
+
+      def with_nonreturn_void?
+        each_type.any? do |type|
+          if type.is_a?(Bases::Void)
+            # `void` in immediate generics parameter is allowed
+            false
+          else
+            type.with_nonreturn_void?
+          end
+        end
+      end
     end
 
     class Interface
@@ -436,25 +500,56 @@ module RBS
           enum_for :map_type
         end
       end
+
+      def has_self_type?
+        each_type.any? {|type| type.has_self_type? }
+      end
+
+      def has_classish_type?
+        each_type.any? {|type| type.has_classish_type? }
+      end
+
+      def with_nonreturn_void?
+        each_type.any? {|type| type.with_nonreturn_void? }
+      end
     end
 
     class Record
-      attr_reader :fields
+      attr_reader :all_fields, :fields, :optional_fields
       attr_reader :location
 
-      def initialize(fields:, location:)
-        @fields = fields
+      def initialize(all_fields: nil, fields: nil, location:)
+        case
+        when fields && all_fields.nil?
+          @all_fields = fields.transform_values { |v| [v, true] }
+          @fields = fields
+          @optional_fields = {}
+        when all_fields && fields.nil?
+          @all_fields = all_fields
+          @fields = {}
+          @optional_fields = {}
+          all_fields.each do |(k, (v, required))|
+            if required
+              @fields[k] = v
+            else
+              @optional_fields[k] = v
+            end
+          end
+        else
+          raise ArgumentError, "only one of `:fields` or `:all_fields` is requireds"
+        end
+
         @location = location
       end
 
       def ==(other)
-        other.is_a?(Record) && other.fields == fields
+        other.is_a?(Record) && other.fields == fields && other.optional_fields == optional_fields
       end
 
       alias eql? ==
 
       def hash
-        self.class.hash ^ fields.hash
+        self.class.hash ^ all_fields.hash
       end
 
       def free_variables(set = Set.new)
@@ -462,27 +557,35 @@ module RBS
           fields.each_value do |type|
             type.free_variables set
           end
+          optional_fields.each_value do |type|
+            type.free_variables set
+          end
         end
       end
 
       def to_json(state = _ = nil)
-        { class: :record, fields: fields, location: location }.to_json(state)
+        { class: :record, fields: fields, optional_fields: optional_fields, location: location }.to_json(state)
       end
 
       def sub(s)
-        self.class.new(fields: fields.transform_values {|ty| ty.sub(s) },
-                       location: location)
+        self.class.new(
+          all_fields: all_fields.transform_values {|ty, required| [ty.sub(s), required] },
+          location: location
+        )
       end
 
       def to_s(level = 0)
-        return "{ }" if self.fields.empty?
+        return "{ }" if all_fields.empty?
 
-        fields = self.fields.map do |key, type|
-          if key.is_a?(Symbol) && key.match?(/\A[A-Za-z_][A-Za-z_]*\z/)
+        fields = all_fields.map do |key, (type, required)|
+          field = if key.is_a?(Symbol) && key.match?(/\A[A-Za-z_][A-Za-z_0-9]*\z/)
             "#{key}: #{type}"
           else
             "#{key.inspect} => #{type}"
           end
+
+          field = "?#{field}" unless required
+          field
         end
         "{ #{fields.join(", ")} }"
       end
@@ -490,6 +593,7 @@ module RBS
       def each_type(&block)
         if block
           fields.each_value(&block)
+          optional_fields.each_value(&block)
         else
           enum_for :each_type
         end
@@ -497,7 +601,7 @@ module RBS
 
       def map_type_name(&block)
         Record.new(
-          fields: fields.transform_values {|ty| ty.map_type_name(&block) },
+          all_fields: all_fields.transform_values {|ty, required| [ty.map_type_name(&block), required] },
           location: location
         )
       end
@@ -505,13 +609,25 @@ module RBS
       def map_type(&block)
         if block
           Record.new(
-            fields: fields.transform_values {|type| yield type },
+            all_fields: all_fields.transform_values {|type, required| [yield(type), required] },
             location: location
           )
         else
           enum_for :map_type
         end
       end
+
+      def has_self_type?
+        each_type.any? {|type| type.has_self_type? }
+      end
+
+      def has_classish_type?
+        each_type.any? {|type| type.has_classish_type? }
+      end
+
+      def with_nonreturn_void?
+        each_type.any? {|type| type.with_nonreturn_void? }
+      end
     end
 
     class Optional
@@ -552,6 +668,8 @@ module RBS
           when Symbol
             return "#{type.to_s(1)} ?"
           end
+        when RBS::Types::Proc
+          return "(#{type.to_s(1)})?"
         end
 
         "#{type.to_s(1)}?"
@@ -582,6 +700,18 @@ module RBS
           enum_for :map_type
         end
       end
+
+      def has_self_type?
+        each_type.any? {|type| type.has_self_type? }
+      end
+
+      def has_classish_type?
+        each_type.any? {|type| type.has_classish_type? }
+      end
+
+      def with_nonreturn_void?
+        each_type.any? {|type| type.with_nonreturn_void? }
+      end
     end
 
     class Union
@@ -650,6 +780,18 @@ module RBS
           location: location
         )
       end
+
+      def has_self_type?
+        each_type.any? {|type| type.has_self_type? }
+      end
+
+      def has_classish_type?
+        each_type.any? {|type| type.has_classish_type? }
+      end
+
+      def with_nonreturn_void?
+        each_type.any? {|type| type.with_nonreturn_void? }
+      end
     end
 
     class Intersection
@@ -719,6 +861,18 @@ module RBS
           location: location
         )
       end
+
+      def has_self_type?
+        each_type.any? {|type| type.has_self_type? }
+      end
+
+      def has_classish_type?
+        each_type.any? {|type| type.has_classish_type? }
+      end
+
+      def with_nonreturn_void?
+        each_type.any? {|type| type.with_nonreturn_void? }
+      end
     end
 
     class Function
@@ -757,10 +911,10 @@ module RBS
 
         def to_s
           if name
-            if Parser::KEYWORDS.include?(name.to_s)
-              "#{type} `#{name}`"
-            else
+            if name.match?(/\A[a-zA-Z0-9_]+\z/)
               "#{type} #{name}"
+            else
+              "#{type} `#{name}`"
             end
           else
             "#{type}"
@@ -1033,6 +1187,121 @@ module RBS
           false
         end
       end
+
+      def has_self_type?
+        each_type.any? {|type| type.has_self_type? }
+      end
+
+      def has_classish_type?
+        each_type.any? {|type| type.has_classish_type? }
+      end
+
+      def with_nonreturn_void?
+        if each_param.any? {|param| param.type.with_nonreturn_void? }
+          true
+        else
+          if return_type.is_a?(Bases::Void)
+            false
+          else
+            return_type.with_nonreturn_void?
+          end
+        end
+      end
+    end
+
+    class UntypedFunction
+      attr_reader :return_type
+
+      def initialize(return_type:)
+        @return_type = return_type
+      end
+
+      def free_variables(acc = Set.new)
+        return_type.free_variables(acc)
+      end
+
+      def map_type(&block)
+        if block
+          update(return_type: yield(return_type))
+        else
+          enum_for :map_type
+        end
+      end
+
+      def map_type_name(&block)
+        UntypedFunction.new(
+          return_type: return_type.map_type_name(&block)
+        )
+      end
+
+      def each_type(&block)
+        if block
+          yield return_type
+        else
+          enum_for :each_type
+        end
+      end
+
+      def each_param(&block)
+        if block
+          # noop
+        else
+          enum_for :each_param
+        end
+      end
+
+      def to_json(state = _ = nil)
+        {
+          return_type: return_type
+        }.to_json(state)
+      end
+
+      def sub(subst)
+        map_type { _1.sub(subst) }
+      end
+
+      def with_return_type(ty)
+        update(return_type: ty)
+      end
+
+      def update(return_type: self.return_type)
+        UntypedFunction.new(return_type: return_type)
+      end
+
+      def empty?
+        true
+      end
+
+      def has_self_type?
+        return_type.has_self_type?
+      end
+
+      def has_classish_type?
+        return_type.has_classish_type?
+      end
+
+      def with_nonreturn_void?
+        false
+      end
+
+      def param_to_s
+        "?"
+      end
+
+      def return_to_s
+        return_type.to_s(1)
+      end
+
+      def ==(other)
+        other.is_a?(UntypedFunction) && other.return_type == return_type
+      end
+
+      alias eql? ==
+
+      def hash
+        self.class.hash ^ return_type.hash
+      end
+
     end
 
     class Block
@@ -1158,7 +1427,11 @@ module RBS
       def each_type(&block)
         if block
           type.each_type(&block)
+          yield self_type if self_type
           self.block&.type&.each_type(&block)
+          if self_type = self.block&.self_type
+            yield self_type
+          end
         else
           enum_for :each_type
         end
@@ -1185,6 +1458,26 @@ module RBS
           enum_for :map_type
         end
       end
+
+      def has_self_type?
+        each_type.any? {|type| type.has_self_type? }
+      end
+
+      def has_classish_type?
+        each_type.any? {|type| type.has_classish_type? }
+      end
+
+      def with_nonreturn_void?
+        if type.with_nonreturn_void? || self_type&.with_nonreturn_void?
+          true
+        else
+          if block = block()
+            block.type.with_nonreturn_void? || block.self_type&.with_nonreturn_void? || false
+          else
+            false
+          end
+        end
+      end
     end
 
     class Literal
@@ -1218,6 +1511,47 @@ module RBS
       def to_s(level = 0)
         literal.inspect
       end
+
+      def has_self_type?
+        false
+      end
+
+      def has_classish_type?
+        false
+      end
+
+      def with_nonreturn_void?
+        false
+      end
+
+      TABLE = {
+        "\\a" => "\a",
+        "\\b" => "\b",
+        "\\e" => "\033",
+        "\\f" => "\f",
+        "\\n" => "\n",
+        "\\r" => "\r",
+        "\\s" => " ",
+        "\\t" => "\t",
+        "\\v" => "\v",
+        "\\\"" => "\"",
+        "\\\'" => "'",
+        "\\\\" => "\\",
+        "\\" => ""
+      }
+
+      def self.unescape_string(string, is_double_quote)
+        if is_double_quote
+          string.gsub!(/\\([0-9]{1,3})/) { ($1 || "").to_i(8).chr }
+          string.gsub!(/\\x([0-9a-f]{1,2})/) { ($1 || "").to_i(16).chr }
+          string.gsub!(/\\u([0-9a-fA-F]{4})/) { ($1 || "").to_i(16).chr(Encoding::UTF_8) }
+          string.gsub!(/\\[abefnrstv"'\\]?/, TABLE)
+          string
+        else
+          string.gsub!(/\\['\\]/, TABLE)
+          string
+        end
+      end
     end
   end
 end

data/lib/rbs/unit_test/convertibles.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module RBS
+  module UnitTest
+    module Convertibles
+      class BlankSlate < BasicObject
+        instance_methods.each do |im|
+          next if im == :__send__
+          undef_method im
+        end
+
+        def __with_object_methods(*methods)
+          methods.each do |method|
+            singleton_class = ::Object.instance_method(:singleton_class).bind_call(self) #: Class
+            singleton_class.instance_eval do
+              define_method method, ::Object.instance_method(method)
+            end
+          end
+          self
+        end
+      end
+
+      class ToIO < BlankSlate
+        def initialize(io = $stdout)
+          @io = io
+        end
+
+        def to_io
+          @io
+        end
+      end
+
+      class ToI < BlankSlate
+        def initialize(value = 3)
+          @value = value
+        end
+
+        def to_i
+          @value
+        end
+      end
+
+      class ToInt < BlankSlate
+        def initialize(value = 3)
+          @value = value
+        end
+
+        def to_int
+          @value
+        end
+      end
+
+      class ToF < BlankSlate
+        def initialize(value = 0.1)
+          @value = value
+        end
+
+        def to_f
+          @value
+        end
+      end
+
+      class ToR < BlankSlate
+        def initialize(value = 1r)
+          @value = value
+        end
+
+        def to_r
+          @value
+        end
+      end
+
+      class ToC < BlankSlate
+        def initialize(value = 1i)
+          @value = value
+        end
+
+        def to_c
+          @value
+        end
+      end
+
+      class ToStr < BlankSlate
+        def initialize(value = "")
+          @value = value
+        end
+
+        def to_str
+          @value
+        end
+      end
+
+      class ToS < BlankSlate
+        def initialize(value = "")
+          @value = value
+        end
+
+        def to_s
+          @value
+        end
+      end
+
+      class ToSym < BlankSlate
+        def initialize(value = :&)
+          @value = value
+        end
+
+        def to_sym
+          @value
+        end
+      end
+
+      class ToA < BlankSlate
+        def initialize(*args)
+          @args = args
+        end
+
+        def to_a
+          @args
+        end
+      end
+
+      class ToArray < BlankSlate
+        def initialize(*args)
+          @args = args
+        end
+
+        def to_ary
+          @args
+        end
+      end
+
+      class ToHash < BlankSlate
+        def initialize(hash = { 'hello' => 'world' })
+          @hash = hash
+        end
+
+        def to_hash
+          @hash
+        end
+      end
+
+      class ToPath < BlankSlate
+        def initialize(value = "")
+          @value = value
+        end
+
+        def to_path
+          @value
+        end
+      end
+
+      class CustomRange < BlankSlate
+        attr_reader :begin, :end
+
+        def initialize(begin_, end_, exclude_end = false)
+          @begin = begin_
+          @end = end_
+          @exclude_end = exclude_end
+        end
+
+        def exclude_end? = @exclude_end
+      end
+
+      class Each < BlankSlate
+        def initialize(*args)
+          @args = args
+        end
+
+        def each(&block)
+          @args.each(&block)
+        end
+      end
+    end
+  end
+end