steep 0.14.0 → 0.15.0

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

@@ -1,140 +0,0 @@
-module Ruby
-  module Signature
-    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
-end

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

@@ -1,49 +0,0 @@
-module Ruby
-  module Signature
-    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
-          Signature.logger.info "Cleaning vendor root: #{vendor_dir}..."
-          vendor_dir.rmtree
-        end
-      end
-
-      def stdlib!()
-        ensure_dir do
-          Signature.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)
-          Signature.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
-            Signature.logger.info "Vendoring gem(#{name}:#{version}): #{sig_path} => #{gem_dir}..."
-            FileUtils.copy_entry sig_path, gem_dir
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,5 +0,0 @@
-module Ruby
-  module Signature
-    VERSION = "0.1.0"
-  end
-end

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

@@ -1,271 +0,0 @@
-module Ruby
-  module Signature
-    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
-end