rbs 2.6.0 → 2.7.0.pre.1

data/lib/rbs/sorter.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module RBS
+  class Sorter
+    include RBS::AST
+
+    attr_reader :path, :stdout
+
+    def initialize(path, stdout: $stdout)
+      @path = path
+      @stdout = stdout
+    end
+
+    def run
+      stdout.puts "Opening #{path}..."
+
+      buffer = Buffer.new(name: path, content: path.read)
+      sigs = Parser.parse_signature(buffer)
+
+      sigs.each do |m|
+        sort_decl! m
+      end
+
+      stdout.puts "Writing #{path}..."
+      path.open('w') do |out|
+        writer = RBS::Writer.new(out: out)
+        writer.write sigs
+      end
+    end
+
+    def group(member)
+      case member
+      when Declarations::Alias
+        -3
+      when Declarations::Constant
+        -2
+      when Declarations::Class, Declarations::Module
+        -1
+      when Members::Include
+        0.0
+      when Members::Prepend
+        0.2
+      when Members::Extend
+        0.4
+      when Members::ClassVariable
+        1
+      when Members::ClassInstanceVariable
+        2
+      when Members::InstanceVariable
+        3
+      when Members::AttrAccessor, Members::AttrWriter, Members::AttrReader
+        if member.kind == :singleton
+          5.0
+        else
+          6.0
+        end
+      when Members::MethodDefinition
+        case member.kind
+        when :singleton_instance
+          4
+        when :singleton
+          if member.name == :new
+            5.2
+          elsif member.visibility == :public
+            5.4
+          else
+            5.6
+          end
+        else
+          if member.name == :initialize
+            6.2
+          elsif member.visibility == :public
+            6.4
+          else
+            6.6
+          end
+        end
+      when Members::Alias
+        if member.singleton?
+          5.4
+        else
+          6.4
+        end
+      else
+        raise
+      end
+    end
+
+    def key(member)
+      case member
+      when Members::Include, Members::Extend, Members::Prepend
+        member.name.to_s
+      when Members::ClassVariable, Members::ClassInstanceVariable, Members::InstanceVariable
+        member.name.to_s
+      when Members::AttrAccessor, Members::AttrWriter, Members::AttrReader
+        member.name.to_s
+      when Members::MethodDefinition
+        member.name.to_s
+      when Members::Alias
+        member.new_name.to_s
+      when Declarations::Constant
+        member.name.to_s
+      when Declarations::Alias
+        member.name.to_s
+      when Declarations::Class, Declarations::Module
+        member.name.to_s
+      else
+        raise
+      end
+    end
+
+    def sort_decl!(decl)
+      case decl
+      when Declarations::Class, Declarations::Module, Declarations::Interface
+        decl.members.each { |m| sort_decl! m }
+
+        current_visibility = :public
+        decl.members.map! do |m|
+          case m
+          when Members::Public
+            current_visibility = :public
+            nil
+          when Members::Private
+            current_visibility = :private
+            nil
+          when Members::MethodDefinition, Members::AttrReader, Members::AttrWriter, Members::AttrAccessor
+            m.update(visibility: m.visibility || current_visibility)
+          else
+            m
+          end
+        end
+        decl.members.compact!
+
+        decl.members.sort! do |m1, m2|
+          group1 = group(m1)
+          group2 = group(m2)
+
+          if group1 == group2
+            key(m1) <=> key(m2)
+          else
+            group1 <=> group2
+          end
+        end
+
+        current_visibility = :public
+        decl.members.map! do |m|
+          case m
+          when Members::MethodDefinition, Members::AttrReader, Members::AttrWriter, Members::AttrAccessor
+            new = m.update(visibility: nil)
+            cur = current_visibility
+            current_visibility = m.visibility
+            if cur != m.visibility
+              [
+                m.visibility == :public ? Members::Public.new(location: nil) : Members::Private.new(location: nil),
+                new
+              ]
+            else
+              new
+            end
+          else
+            m
+          end
+        end
+        decl.members.flatten!
+      end
+    end
+  end
+end

data/lib/rbs/substitution.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RBS
   class Substitution
     attr_reader :mapping

data/lib/rbs/test/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RBS
   module Test
     module Errors

data/lib/rbs/test/hook.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rbs"
 require "pp"
 

data/lib/rbs/test/observer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RBS
   module Test
     module Observer

data/lib/rbs/test/setup.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rbs"
 require "rbs/test"
 require "optparse"

data/lib/rbs/test/setup_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RBS
   module Test
     module SetupHelper

data/lib/rbs/test/spy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RBS
   module Test
   end

data/lib/rbs/test/tester.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RBS
   module Test
     class Tester

data/lib/rbs/test/type_check.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RBS
   module Test
     class TypeCheck

data/lib/rbs/test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "securerandom"
 require "rbs/test/observer"
 require "rbs/test/spy"

data/lib/rbs/type_alias_dependency.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RBS
   class TypeAliasDependency
     attr_reader :env

data/lib/rbs/type_alias_regularity.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RBS
   class TypeAliasRegularity
     class Diagnostic

data/lib/rbs/type_name.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RBS
   class TypeName
     attr_reader :namespace

data/lib/rbs/type_name_resolver.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RBS
   class TypeNameResolver
     Query = _ = Struct.new(:type_name, :context, keyword_init: true)
@@ -35,11 +37,11 @@ module RBS
 
       query = Query.new(type_name: type_name, context: context)
       try_cache(query) do
-        path_head, *path_tail = type_name.to_namespace.path
+        path_head, *path_tail = type_name.split
         raise unless path_head
 
         name_head = TypeName.new(name: path_head, namespace: Namespace.empty)
- 
+
         absolute_head = context.find do |namespace|
           # @type break: TypeName
           full_name = name_head.with_prefix(namespace)

data/lib/rbs/types.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RBS
   module Types
     module NoFreeVariables
@@ -843,12 +845,12 @@ module RBS
       def map_type(&block)
         if block
           Function.new(
-            required_positionals: required_positionals.map {|param| param.map_type(&block) },
-            optional_positionals: optional_positionals.map {|param| param.map_type(&block) },
+            required_positionals: amap(required_positionals) {|param| param.map_type(&block) },
+            optional_positionals: amap(optional_positionals) {|param| param.map_type(&block) },
             rest_positionals: rest_positionals&.yield_self {|param| param.map_type(&block) },
-            trailing_positionals: trailing_positionals.map {|param| param.map_type(&block) },
-            required_keywords: required_keywords.transform_values {|param| param.map_type(&block) },
-            optional_keywords: optional_keywords.transform_values {|param| param.map_type(&block) },
+            trailing_positionals: amap(trailing_positionals) {|param| param.map_type(&block) },
+            required_keywords: hmapv(required_keywords) {|param| param.map_type(&block) },
+            optional_keywords: hmapv(optional_keywords) {|param| param.map_type(&block) },
             rest_keywords: rest_keywords&.yield_self {|param| param.map_type(&block) },
             return_type: yield(return_type)
           )
@@ -857,6 +859,22 @@ module RBS
         end
       end
 
+      def amap(array, &block)
+        if array.empty?
+          _ = array
+        else
+          array.map(&block)
+        end
+      end
+
+      def hmapv(hash, &block)
+        if hash.empty?
+          _ = hash
+        else
+          hash.transform_values(&block)
+        end
+      end
+
       def map_type_name(&block)
         map_type do |type|
           type.map_type_name(&block)
@@ -1020,64 +1038,85 @@ module RBS
     class Block
       attr_reader :type
       attr_reader :required
+      attr_reader :self_type
 
-      def initialize(type:, required:)
+      def initialize(type:, required:, self_type: nil)
         @type = type
         @required = required ? true : false
+        @self_type = self_type
       end
 
       def ==(other)
         other.is_a?(Block) &&
           other.type == type &&
-          other.required == required
+          other.required == required &&
+          other.self_type == self_type
       end
 
       def to_json(state = _ = nil)
         {
           type: type,
-          required: required
+          required: required,
+          self_type: self_type
         }.to_json(state)
       end
 
       def sub(s)
         self.class.new(
           type: type.sub(s),
-          required: required
+          required: required,
+          self_type: self_type&.sub(s)
         )
       end
 
       def map_type(&block)
         Block.new(
           required: required,
-          type: type.map_type(&block)
+          type: type.map_type(&block),
+          self_type: self_type ? yield(self_type) : nil
         )
       end
     end
 
+    module SelfTypeBindingHelper
+      module_function
+
+      def self_type_binding_to_s(t)
+        if t
+          "[self: #{t}] "
+        else
+          ""
+        end
+      end
+    end
+
     class Proc
       attr_reader :type
       attr_reader :block
+      attr_reader :self_type
       attr_reader :location
 
-      def initialize(location:, type:, block:)
+      def initialize(location:, type:, block:, self_type: nil)
         @type = type
         @block = block
         @location = location
+        @self_type = self_type
       end
 
       def ==(other)
-        other.is_a?(Proc) && other.type == type && other.block == block
+        other.is_a?(Proc) && other.type == type && other.block == block && other.self_type == self_type
       end
 
       alias eql? ==
 
       def hash
-        self.class.hash ^ type.hash ^ block.hash
+        self.class.hash ^ type.hash ^ block.hash ^ self_type.hash
       end
 
       def free_variables(set = Set[])
         type.free_variables(set)
         block&.type&.free_variables(set)
+        self_type&.free_variables(set)
         set
       end
 
@@ -1086,24 +1125,33 @@ module RBS
           class: :proc,
           type: type,
           block: block,
-          location: location
+          location: location,
+          self_type: self_type
         }.to_json(state)
       end
 
       def sub(s)
-        self.class.new(type: type.sub(s), block: block&.sub(s), location: location)
+        self.class.new(
+          type: type.sub(s),
+          block: block&.sub(s),
+          self_type: self_type&.sub(s),
+          location: location
+        )
       end
 
       def to_s(level = 0)
+        self_binding = SelfTypeBindingHelper.self_type_binding_to_s(self_type)
+        block_self_binding = SelfTypeBindingHelper.self_type_binding_to_s(block&.self_type)
+
         case
         when b = block
           if b.required
-            "^(#{type.param_to_s}) { (#{b.type.param_to_s}) -> #{b.type.return_to_s} } -> #{type.return_to_s}"
+            "^(#{type.param_to_s}) #{self_binding}{ (#{b.type.param_to_s}) #{block_self_binding}-> #{b.type.return_to_s} } -> #{type.return_to_s}"
           else
-            "^(#{type.param_to_s}) ?{ (#{b.type.param_to_s}) -> #{b.type.return_to_s} } -> #{type.return_to_s}"
+            "^(#{type.param_to_s}) #{self_binding}?{ (#{b.type.param_to_s}) #{block_self_binding}-> #{b.type.return_to_s} } -> #{type.return_to_s}"
           end
         else
-          "^(#{type.param_to_s}) -> #{type.return_to_s}"
+          "^(#{type.param_to_s}) #{self_binding}-> #{type.return_to_s}"
         end
       end
 
@@ -1120,6 +1168,7 @@ module RBS
         Proc.new(
           type: type.map_type_name(&block),
           block: self.block&.map_type {|type| type.map_type_name(&block) },
+          self_type: self_type&.map_type_name(&block),
           location: location
         )
       end
@@ -1129,6 +1178,7 @@ module RBS
           Proc.new(
             type: type.map_type(&block),
             block: self.block&.map_type(&block),
+            self_type: self_type ? yield(self_type) : nil,
             location: location
           )
         else

data/lib/rbs/validator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RBS
   class Validator
     attr_reader :env

data/lib/rbs/variance_calculator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RBS
   class VarianceCalculator
     class Result

data/lib/rbs/vendorer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RBS
   class Vendorer
     attr_reader :vendor_dir

data/lib/rbs/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RBS
-  VERSION = "2.6.0"
+  VERSION = "2.7.0.pre.1"
 end

data/lib/rbs/writer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RBS
   class Writer
     attr_reader :out
@@ -280,7 +282,7 @@ module RBS
                "self.#{method_name(member.name)}"
              end
 
-      string = ""
+      string = +""
 
       prefix = "#{visibility}def #{name}:"
       padding = " " * (prefix.size-1)

data/lib/rbs.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rbs/version"
 
 require "set"
@@ -59,12 +61,12 @@ module RBS
     attr_reader :logger_output
 
     def logger
-      @logger ||= Logger.new(logger_output || STDERR, level: logger_level || "warn", progname: "rbs")
+      @logger ||= Logger.new(logger_output || STDERR, level: logger_level || Logger::WARN, progname: "rbs")
     end
 
     def logger_output=(val)
-      @logger_output = val
       @logger = nil
+      @logger_output = val
     end
 
     def logger_level=(level)

data/lib/rdoc/discover.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+begin
+  gem 'rdoc', '~> 6.4.0'
+  require 'rdoc_plugin/parser'
+  module RDoc
+    class Parser
+      class RBS < Parser
+        parse_files_matching(/\.rbs$/)
+        def scan
+          ::RBS::RDocPlugin::Parser.new(@top_level, @content).scan
+        end
+      end
+    end
+  end
+rescue Gem::LoadError
+    # Error :sad:
+rescue Exception
+    # Exception :sad:
+end