rbs 0.2.0

data/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/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/lib/rbs/version.rb

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

data/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