steep 0.14.0 → 0.15.0

data/vendor/ruby-signature/lib/rbs/variance_calculator.rb

@@ -0,0 +1,138 @@
+module RBS
+  class VarianceCalculator
+    class Result
+      attr_reader :result
+
+      def initialize(variables:)
+        @result = {}
+        variables.each do |x|
+          result[x] = :unused
+        end
+      end
+
+      def covariant(x)
+        case result[x]
+        when :unused
+          result[x] = :covariant
+        when :contravariant
+          result[x] = :invariant
+        end
+      end
+
+      def contravariant(x)
+        case result[x]
+        when :unused
+          result[x] = :contravariant
+        when :covariant
+          result[x] = :invariant
+        end
+      end
+
+      def invariant(x)
+        result[x] = :invariant
+      end
+
+      def each(&block)
+        result.each(&block)
+      end
+
+      def include?(name)
+        result.key?(name)
+      end
+
+      def compatible?(var, with_annotation:)
+        variance = result[var]
+
+        case
+        when variance == :unused
+          true
+        when with_annotation == :invariant
+          true
+        when variance == with_annotation
+          true
+        else
+          false
+        end
+      end
+    end
+
+    attr_reader :builder
+
+    def initialize(builder:)
+      @builder = builder
+    end
+
+    def env
+      builder.env
+    end
+
+    def in_method_type(method_type:, variables:)
+      result = Result.new(variables: variables)
+
+      method_type.type.each_param do |param|
+        type(param.type, result: result, context: :contravariant)
+      end
+
+      if method_type.block
+        method_type.block.type.each_param do |param|
+          type(param.type, result: result, context: :covariant)
+        end
+        type(method_type.block.type.return_type, result: result, context: :contravariant)
+      end
+
+      type(method_type.type.return_type, result: result, context: :covariant)
+
+      result
+    end
+
+    def in_inherit(name:, args:, variables:)
+      type = Types::ClassInstance.new(name: name, args: args, location: nil)
+
+      Result.new(variables: variables).tap do |result|
+        type(type, result: result, context: :covariant)
+      end
+    end
+
+    def type(type, result:, context:)
+      case type
+      when Types::Variable
+        if result.include?(type.name)
+          case context
+          when :covariant
+            result.covariant(type.name)
+          when :contravariant
+            result.contravariant(type.name)
+          when :invariant
+            result.invariant(type.name)
+          end
+        end
+      when Types::ClassInstance, Types::Interface
+        decl = env.find_class(type.name)
+        type.args.each.with_index do |ty, i|
+          var = decl.type_params.params[i]
+          case var.variance
+          when :invariant
+            type(ty, result: result, context: :invariant)
+          when :covariant
+            type(ty, result: result, context: context)
+          when :contravariant
+            con = case context
+                  when :invariant
+                    :invariant
+                  when :covariant
+                    :contravariant
+                  when :contravariant
+                    :covariant
+                  end
+            type(ty, result: result, context: con)
+          end
+        end
+      when Types::Tuple, Types::Record, Types::Union, Types::Intersection
+        # Covariant types
+        type.each_type do |ty|
+          type(ty, result: result, context: context)
+        end
+      end
+    end
+  end
+end

data/vendor/ruby-signature/lib/rbs/vendorer.rb

@@ -0,0 +1,47 @@
+module RBS
+  class Vendorer
+    attr_reader :vendor_dir
+
+    def initialize(vendor_dir:)
+      @vendor_dir = vendor_dir
+    end
+
+    def ensure_dir
+      unless vendor_dir.directory?
+        vendor_dir.mkpath
+      end
+
+      yield
+    end
+
+    def clean!
+      ensure_dir do
+        RBS.logger.info "Cleaning vendor root: #{vendor_dir}..."
+        vendor_dir.rmtree
+      end
+    end
+
+    def stdlib!()
+      ensure_dir do
+        RBS.logger.info "Vendoring stdlib: #{EnvironmentLoader::STDLIB_ROOT} => #{vendor_dir + "stdlib"}..."
+        FileUtils.copy_entry EnvironmentLoader::STDLIB_ROOT, vendor_dir + "stdlib"
+      end
+    end
+
+    def gem!(name, version)
+      ensure_dir do
+        sig_path = EnvironmentLoader.gem_sig_path(name, version)
+        RBS.logger.debug "Checking gem signature path: name=#{name}, version=#{version}, path=#{sig_path}"
+
+        if sig_path&.directory?
+          gems_dir = vendor_dir + "gems"
+          gems_dir.mkpath unless gems_dir.directory?
+
+          gem_dir = gems_dir + name
+          RBS.logger.info "Vendoring gem(#{name}:#{version}): #{sig_path} => #{gem_dir}..."
+          FileUtils.copy_entry sig_path, gem_dir
+        end
+      end
+    end
+  end
+end

data/vendor/ruby-signature/lib/rbs/version.rb

@@ -0,0 +1,3 @@
+module RBS
+  VERSION = "0.1.0"
+end

data/vendor/ruby-signature/lib/rbs/writer.rb

@@ -0,0 +1,269 @@
+module RBS
+  class Writer
+    attr_reader :out
+
+    def initialize(out:)
+      @out = out
+    end
+
+    def write_annotation(annotations, level:)
+      prefix = " " * level
+
+      annotations.each do |annotation|
+        string = annotation.string
+        case
+        when string !~ /\}/
+          out.puts "#{prefix}%a{#{string}}"
+        when string !~ /\)/
+          out.puts "#{prefix}%a(#{string})"
+        when string !~ /\]/
+          out.puts "#{prefix}%a[#{string}]"
+        when string !~ /\>/
+          out.puts "#{prefix}%a<#{string}>"
+        when string !~ /\|/
+          out.puts "#{prefix}%a|#{string}|"
+        end
+      end
+    end
+
+    def write_comment(comment, level:)
+      if comment
+        prefix = " " * level
+        comment.string.lines.each do |line|
+          line = " #{line}" unless line.chomp.empty?
+          out.puts "#{prefix}##{line}"
+        end
+      end
+    end
+
+    def write(decls)
+      [nil, *decls].each_cons(2) do |prev, decl|
+        preserve_empty_line(prev, decl)
+        write_decl decl
+      end
+    end
+
+    def write_decl(decl)
+      case decl
+      when AST::Declarations::Class
+        super_class = if decl.super_class
+                        " < #{name_and_args(decl.super_class.name, decl.super_class.args)}"
+                      end
+        write_comment decl.comment, level: 0
+        write_annotation decl.annotations, level: 0
+        out.puts "class #{name_and_params(decl.name, decl.type_params)}#{super_class}"
+
+        [nil, *decl.members].each_cons(2) do |prev, member|
+          preserve_empty_line prev, member
+          write_member member
+        end
+
+        out.puts "end"
+
+      when AST::Declarations::Module
+        self_type = if decl.self_type
+                      " : #{decl.self_type}"
+                    end
+
+        write_comment decl.comment, level: 0
+        write_annotation decl.annotations, level: 0
+        out.puts "module #{name_and_params(decl.name, decl.type_params)}#{self_type}"
+        decl.members.each.with_index do |member, index|
+          if index > 0
+            out.puts
+          end
+          write_member member
+        end
+        out.puts "end"
+      when AST::Declarations::Constant
+        write_comment decl.comment, level: 0
+        out.puts "#{decl.name}: #{decl.type}"
+
+      when AST::Declarations::Global
+        write_comment decl.comment, level: 0
+        out.puts "#{decl.name}: #{decl.type}"
+
+      when AST::Declarations::Alias
+        write_comment decl.comment, level: 0
+        write_annotation decl.annotations, level: 0
+        out.puts "type #{decl.name} = #{decl.type}"
+
+      when AST::Declarations::Interface
+        write_comment decl.comment, level: 0
+        write_annotation decl.annotations, level: 0
+        out.puts "interface #{name_and_params(decl.name, decl.type_params)}"
+        decl.members.each.with_index do |member, index|
+          if index > 0
+            out.puts
+          end
+          write_member member
+        end
+        out.puts "end"
+
+      when AST::Declarations::Extension
+        write_comment decl.comment, level: 0
+        write_annotation decl.annotations, level: 0
+        out.puts "extension #{name_and_args(decl.name, decl.type_params)} (#{decl.extension_name})"
+        decl.members.each.with_index do |member, index|
+          if index > 0
+            out.puts
+          end
+          write_member member
+        end
+        out.puts "end"
+      end
+    end
+
+    def name_and_params(name, params)
+      if params.empty?
+        "#{name}"
+      else
+        ps = params.each.map do |param|
+          s = ""
+          if param.skip_validation
+            s << "unchecked "
+          end
+          case param.variance
+          when :invariant
+            # nop
+          when :covariant
+            s << "out "
+          when :contravariant
+            s << "in "
+          end
+          s + param.name.to_s
+        end
+
+        "#{name}[#{ps.join(", ")}]"
+      end
+    end
+
+    def name_and_args(name, args)
+      if name && args
+        if args.empty?
+          "#{name}"
+        else
+          "#{name}[#{args.join(", ")}]"
+        end
+      end
+    end
+
+    def write_member(member)
+      case member
+      when AST::Members::Include
+        write_comment member.comment, level: 2
+        write_annotation member.annotations, level: 2
+        out.puts "  include #{name_and_args(member.name, member.args)}"
+      when AST::Members::Extend
+        write_comment member.comment, level: 2
+        write_annotation member.annotations, level: 2
+        out.puts "  extend #{name_and_args(member.name, member.args)}"
+      when AST::Members::Prepend
+        write_comment member.comment, level: 2
+        write_annotation member.annotations, level: 2
+        out.puts "  prepend #{name_and_args(member.name, member.args)}"
+      when AST::Members::AttrAccessor
+        write_comment member.comment, level: 2
+        write_annotation member.annotations, level: 2
+        out.puts "  #{attribute(:accessor, member)}"
+      when AST::Members::AttrReader
+        write_comment member.comment, level: 2
+        write_annotation member.annotations, level: 2
+        out.puts "  #{attribute(:reader, member)}"
+      when AST::Members::AttrWriter
+        write_comment member.comment, level: 2
+        write_annotation member.annotations, level: 2
+        out.puts "  #{attribute(:writer, member)}"
+      when AST::Members::Public
+        out.puts "  public"
+      when AST::Members::Private
+        out.puts "  private"
+      when AST::Members::Alias
+        write_comment member.comment, level: 2
+        write_annotation member.annotations, level: 2
+        new_name = member.singleton? ? "self.#{member.new_name}" : member.new_name
+        old_name = member.singleton? ? "self.#{member.old_name}" : member.old_name
+        out.puts "  alias #{new_name} #{old_name}"
+      when AST::Members::InstanceVariable
+        write_comment member.comment, level: 2
+        out.puts "  #{member.name}: #{member.type}"
+      when AST::Members::ClassInstanceVariable
+        write_comment member.comment, level: 2
+        out.puts "  self.#{member.name}: #{member.type}"
+      when AST::Members::ClassVariable
+        write_comment member.comment, level: 2
+        out.puts "  #{member.name}: #{member.type}"
+      when AST::Members::MethodDefinition
+        write_comment member.comment, level: 2
+        write_annotation member.annotations, level: 2
+        write_def member
+      end
+    end
+
+    def method_name(name)
+      s = name.to_s
+
+      if /\A#{Parser::KEYWORDS_RE}\z/.match?(s)
+        "`#{s}`"
+      else
+        s
+      end
+    end
+
+    def write_def(member)
+      name = case member.kind
+             when :instance
+               "#{method_name(member.name)}"
+             when :singleton_instance
+               "self?.#{method_name(member.name)}"
+             when :singleton
+               "self.#{method_name(member.name)}"
+             end
+
+      attrs = member.attributes.empty? ? "" : member.attributes.join(" ") + " "
+      prefix = "  #{attrs}def #{name}:"
+      padding = " " * (prefix.size-1)
+
+      out.print prefix
+
+      member.types.each.with_index do |type, index|
+        if index > 0
+          out.print padding
+          out.print "|"
+        end
+        out.puts " #{type}"
+      end
+    end
+
+    def attribute(kind, attr)
+      var = case attr.ivar_name
+            when nil
+              ""
+            when false
+              "()"
+            else
+              "(#{attr.ivar_name})"
+            end
+      "attr_#{kind} #{attr.name}#{var}: #{attr.type}"
+    end
+
+    def preserve_empty_line(prev, decl)
+      return unless prev
+
+      decl = decl.comment if decl.respond_to?(:comment) && decl.comment
+
+      # When the signature is not constructed by the parser,
+      # it always inserts an empty line.
+      if !prev.location || !decl.location
+        out.puts
+        return
+      end
+
+      prev_end_line = prev.location.end_line
+      start_line = decl.location.start_line
+      if start_line - prev_end_line > 1
+        out.puts
+      end
+    end
+  end
+end

data/vendor/ruby-signature/lib/rbs.rb

@@ -0,0 +1,64 @@
+require "rbs/version"
+
+require "set"
+require "json"
+require "pathname"
+require "pp"
+require "ripper"
+require "logger"
+require "tsort"
+
+require "rbs/errors"
+require "rbs/buffer"
+require "rbs/location"
+require "rbs/namespace"
+require "rbs/type_name"
+require "rbs/types"
+require "rbs/method_type"
+require "rbs/ast/declarations"
+require "rbs/ast/members"
+require "rbs/ast/annotation"
+require "rbs/environment"
+require "rbs/environment_loader"
+require "rbs/builtin_names"
+require "rbs/definition"
+require "rbs/definition_builder"
+require "rbs/variance_calculator"
+require "rbs/substitution"
+require "rbs/constant"
+require "rbs/constant_table"
+require "rbs/ast/comment"
+require "rbs/writer"
+require "rbs/prototype/rbi"
+require "rbs/prototype/rb"
+require "rbs/prototype/runtime"
+require "rbs/environment_walker"
+require "rbs/vendorer"
+
+begin
+  require "rbs/parser"
+rescue LoadError
+  STDERR.puts "Missing parser Ruby code? Running `rake parser` may solve the issue"
+  raise
+end
+
+module RBS
+  class <<self
+    attr_reader :logger_level
+    attr_reader :logger_output
+
+    def logger
+      @logger ||= Logger.new(logger_output || STDERR, level: logger_level || "warn", progname: "rbs")
+    end
+
+    def logger_output=(val)
+      @logger_output = val
+      @logger = nil
+    end
+
+    def logger_level=(level)
+      @logger_level = level
+      @logger = nil
+    end
+  end
+end

data/vendor/ruby-signature/lib/ruby/signature.rb

@@ -1,64 +1,7 @@
-require "ruby/signature/version"
+STDERR.puts "🚨🚨 ruby-signature is renamed to rbs. require 'rbs' instead of 'ruby/signature'. 🚨🚨"
 
-require "set"
-require "json"
-require "pathname"
-require "pp"
-require "ripper"
-require "logger"
-require "tsort"
+require "rbs"
 
-require "ruby/signature/errors"
-require "ruby/signature/buffer"
-require "ruby/signature/location"
-require "ruby/signature/namespace"
-require "ruby/signature/type_name"
-require "ruby/signature/types"
-require "ruby/signature/method_type"
-require "ruby/signature/ast/declarations"
-require "ruby/signature/ast/members"
-require "ruby/signature/ast/annotation"
-require "ruby/signature/environment"
-require "ruby/signature/environment_loader"
-require "ruby/signature/builtin_names"
-require "ruby/signature/definition"
-require "ruby/signature/definition_builder"
-require "ruby/signature/variance_calculator"
-require "ruby/signature/substitution"
-require "ruby/signature/constant"
-require "ruby/signature/constant_table"
-require "ruby/signature/ast/comment"
-require "ruby/signature/writer"
-require "ruby/signature/prototype/rbi"
-require "ruby/signature/prototype/rb"
-require "ruby/signature/prototype/runtime"
-require "ruby/signature/environment_walker"
-require "ruby/signature/vendorer"
-
-begin
-  require "ruby/signature/parser"
-rescue LoadError
-  STDERR.puts "Missing parser Ruby code? Running `rake parser` may solve the issue"
-  raise
-end
-
-module Ruby::Signature
-  class <<self
-    attr_reader :logger_level
-    attr_reader :logger_output
-
-    def logger
-      @logger ||= Logger.new(logger_output || STDERR, level: logger_level || "warn", progname: "ruby-signature")
-    end
-
-    def logger_output=(val)
-      @logger_output = val
-      @logger = nil
-    end
-
-    def logger_level=(level)
-      @logger_level = level
-      @logger = nil
-    end
-  end
+module Ruby
+  Signature = RBS
 end

data/vendor/ruby-signature/{ruby-signature.gemspec → rbs.gemspec}

@@ -1,11 +1,11 @@
 
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "ruby/signature/version"
+require "rbs/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "ruby-signature"
-  spec.version       = Ruby::Signature::VERSION
+  spec.name          = "rbs"
+  spec.version       = RBS::VERSION
   spec.authors       = ["Soutaro Matsumoto"]
   spec.email         = ["matsumoto@soutaro.com"]
 
@@ -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 { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.files << "lib/ruby/signature/parser.rb"
+  spec.files << "lib/rbs/parser.rb"
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]

data/vendor/ruby-signature/stdlib/abbrev/abbrev.rbs

@@ -1,3 +1,60 @@
+# Calculates the set of unambiguous abbreviations for a given set of strings.
+#
+#     require 'abbrev'
+#     require 'pp'
+#
+#     pp Abbrev.abbrev(['ruby'])
+#     #=>  {"ruby"=>"ruby", "rub"=>"ruby", "ru"=>"ruby", "r"=>"ruby"}
+#
+#     pp Abbrev.abbrev(%w{ ruby rules })
+#
+# *Generates:*
+#     { "ruby"  =>  "ruby",
+#       "rub"   =>  "ruby",
+#       "rules" =>  "rules",
+#       "rule"  =>  "rules",
+#       "rul"   =>  "rules" }
+#
+# It also provides an array core extension, Array#abbrev.
+#
+#     pp %w{ summer winter }.abbrev
+#
+# *Generates:*
+#     { "summer"  => "summer",
+#       "summe"   => "summer",
+#       "summ"    => "summer",
+#       "sum"     => "summer",
+#       "su"      => "summer",
+#       "s"       => "summer",
+#       "winter"  => "winter",
+#       "winte"   => "winter",
+#       "wint"    => "winter",
+#       "win"     => "winter",
+#       "wi"      => "winter",
+#       "w"       => "winter" }
+#
 module Abbrev
-  def self?.abbrev: (Array[String], ?(String | Regexp | nil)) -> Hash[String, String]
+  # Given a set of strings, calculate the set of unambiguous abbreviations for
+  # those strings, and return a hash where the keys are all the possible
+  # abbreviations and the values are the full strings.
+  #
+  # Thus, given `words` is "car" and "cone", the keys pointing to "car" would be
+  # "ca" and "car", while those pointing to "cone" would be "co", "con", and
+  # "cone".
+  #
+  #     require 'abbrev'
+  #
+  #     Abbrev.abbrev(%w{ car cone })
+  #     #=> {"ca"=>"car", "con"=>"cone", "co"=>"cone", "car"=>"car", "cone"=>"cone"}
+  #
+  # The optional `pattern` parameter is a pattern or a string. Only input strings
+  # that match the pattern or start with the string are included in the output
+  # hash.
+  #
+  #     Abbrev.abbrev(%w{car box cone crab}, /b/)
+  #     #=> {"box"=>"box", "bo"=>"box", "b"=>"box", "crab" => "crab"}
+  #
+  #     Abbrev.abbrev(%w{car box cone}, 'ca')
+  #     #=> {"car"=>"car", "ca"=>"car"}
+  def self?.abbrev: (Array[String], ?String | Regexp | nil) -> Hash[String, String]
 end