steep 0.11.1 → 0.12.0

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

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1,49 @@
+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

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

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

@@ -0,0 +1,271 @@
+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