rbi 0.1.13 → 0.2.0

data/lib/rbi/rewriters/attr_to_methods.rb

@@ -0,0 +1,169 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  class UnexpectedMultipleSigsError < Error
+    sig { returns(Node) }
+    attr_reader :node
+
+    sig { params(node: Node).void }
+    def initialize(node)
+      super(<<~MSG)
+        This declaration cannot have more than one sig.
+
+        #{node.string.chomp}
+      MSG
+
+      @node = node
+    end
+  end
+
+  module Rewriters
+    class AttrToMethods < Visitor
+      extend T::Sig
+
+      sig { override.params(node: T.nilable(Node)).void }
+      def visit(node)
+        case node
+        when Tree
+          visit_all(node.nodes.dup)
+
+        when Attr
+          replace(node, with: node.convert_to_methods)
+        end
+      end
+
+      private
+
+      sig { params(node: Node, with: T::Array[Node]).void }
+      def replace(node, with:)
+        tree = node.parent_tree
+        raise ReplaceNodeError, "Can't replace #{self} without a parent tree" unless tree
+
+        node.detach
+        with.each { |node| tree << node }
+      end
+    end
+  end
+
+  class Tree
+    extend T::Sig
+
+    sig { void }
+    def replace_attributes_with_methods!
+      visitor = Rewriters::AttrToMethods.new
+      visitor.visit(self)
+    end
+  end
+
+  class Attr
+    sig { abstract.returns(T::Array[Method]) }
+    def convert_to_methods; end
+
+    private
+
+    sig(:final) { returns([T.nilable(Sig), T.nilable(T.any(Type, String))]) }
+    def parse_sig
+      raise UnexpectedMultipleSigsError, self if 1 < sigs.count
+
+      sig = sigs.first
+      return [nil, nil] unless sig
+
+      attribute_type = case self
+      when AttrReader, AttrAccessor then sig.return_type
+      when AttrWriter then sig.params.first&.type
+      end
+
+      [sig, attribute_type]
+    end
+
+    sig do
+      params(
+        name: String,
+        sig: T.nilable(Sig),
+        visibility: Visibility,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+      ).returns(Method)
+    end
+    def create_getter_method(name, sig, visibility, loc, comments)
+      Method.new(
+        name,
+        params: [],
+        visibility: visibility,
+        sigs: sig ? [sig] : [],
+        loc: loc,
+        comments: comments,
+      )
+    end
+
+    sig do
+      params(
+        name: String,
+        sig: T.nilable(Sig),
+        attribute_type: T.nilable(T.any(Type, String)),
+        visibility: Visibility,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+      ).returns(Method)
+    end
+    def create_setter_method(name, sig, attribute_type, visibility, loc, comments) # rubocop:disable Metrics/ParameterLists
+      sig = if sig # Modify the original sig to correct the name, and remove the return type
+        params = attribute_type ? [SigParam.new(name, attribute_type)] : []
+
+        Sig.new(
+          params: params,
+          return_type: "void",
+          is_abstract: sig.is_abstract,
+          is_override: sig.is_override,
+          is_overridable: sig.is_overridable,
+          is_final: sig.is_final,
+          type_params: sig.type_params,
+          checked: sig.checked,
+          loc: sig.loc,
+        )
+      end
+
+      Method.new(
+        "#{name}=",
+        params: [ReqParam.new(name)],
+        visibility: visibility,
+        sigs: sig ? [sig] : [],
+        loc: loc,
+        comments: comments,
+      )
+    end
+  end
+
+  class AttrAccessor
+    sig { override.returns(T::Array[Method]) }
+    def convert_to_methods
+      sig, attribute_type = parse_sig
+
+      names.flat_map do |name|
+        [
+          create_getter_method(name.to_s, sig, visibility, loc, comments),
+          create_setter_method(name.to_s, sig, attribute_type, visibility, loc, comments),
+        ]
+      end
+    end
+  end
+
+  class AttrReader
+    sig { override.returns(T::Array[Method]) }
+    def convert_to_methods
+      sig, _ = parse_sig
+
+      names.map { |name| create_getter_method(name.to_s, sig, visibility, loc, comments) }
+    end
+  end
+
+  class AttrWriter
+    sig { override.returns(T::Array[Method]) }
+    def convert_to_methods
+      sig, attribute_type = parse_sig
+
+      names.map { |name| create_setter_method(name.to_s, sig, attribute_type, visibility, loc, comments) }
+    end
+  end
+end

data/lib/rbi/rewriters/flatten_singleton_methods.rb

@@ -0,0 +1,65 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  module Rewriters
+    # Rewrite non-singleton methods inside singleton classes to singleton methods
+    #
+    # Example:
+    # ~~~rb
+    # class << self
+    #  def m1; end
+    #  def self.m2; end
+    #
+    #  class << self
+    #    def m3; end
+    #  end
+    # end
+    # ~~~
+    #
+    # will be rewritten to:
+    #
+    # ~~~rb
+    # def self.m1; end
+    #
+    # class << self
+    #   def self.m2; end
+    #   def self.m3; end
+    # end
+    # ~~~
+    class FlattenSingletonMethods < Visitor
+      extend T::Sig
+
+      sig { override.params(node: T.nilable(Node)).void }
+      def visit(node)
+        return unless node
+
+        case node
+        when SingletonClass
+          node.nodes.dup.each do |child|
+            visit(child)
+            next unless child.is_a?(Method) && !child.is_singleton
+
+            child.detach
+            child.is_singleton = true
+            T.must(node.parent_tree) << child
+          end
+
+          node.detach if node.nodes.empty?
+        when Tree
+          visit_all(node.nodes)
+        end
+      end
+    end
+  end
+
+  class Tree
+    extend T::Sig
+
+    sig { void }
+    def flatten_singleton_methods!
+      visitor = Rewriters::FlattenSingletonMethods.new
+      visitor.visit(self)
+    end
+  end
+end

data/lib/rbi/rewriters/flatten_visibilities.rb

@@ -0,0 +1,65 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  module Rewriters
+    # Flattens visibility nodes into method nodes
+    #
+    # Example:
+    # ~~~rb
+    # class A
+    #   def m1; end
+    #   private
+    #   def m2; end
+    #   def m3; end
+    # end
+    # ~~~
+    #
+    # will be transformed into:
+    #
+    # ~~~rb
+    # class A
+    #   def m1; end
+    #   private def m2; end
+    #   private def m3; end
+    # end
+    # ~~~
+    class FlattenVisibilities < Visitor
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        super
+
+        @current_visibility = T.let([Public.new], T::Array[Visibility])
+      end
+
+      sig { override.params(node: T.nilable(Node)).void }
+      def visit(node)
+        return unless node
+
+        case node
+        when Public, Protected, Private
+          @current_visibility[-1] = node
+          node.detach
+        when Tree
+          @current_visibility << Public.new
+          visit_all(node.nodes.dup)
+          @current_visibility.pop
+        when Attr, Method
+          node.visibility = T.must(@current_visibility.last)
+        end
+      end
+    end
+  end
+
+  class Tree
+    extend T::Sig
+
+    sig { void }
+    def flatten_visibilities!
+      visitor = Rewriters::FlattenVisibilities.new
+      visitor.visit(self)
+    end
+  end
+end

data/lib/rbi/rewriters/group_nodes.rb

@@ -2,6 +2,8 @@
 # frozen_string_literal: true
 
 module RBI
+  class GroupNodesError < Error; end
+
   module Rewriters
     class GroupNodes < Visitor
       extend T::Sig
@@ -12,8 +14,7 @@ module RBI
 
         case node
         when Tree
-          kinds = node.nodes.map(&:group_kind)
-          kinds.compact!
+          kinds = node.nodes.map { |child| group_kind(child) }
           kinds.uniq!
 
           groups = {}
@@ -22,12 +23,54 @@ module RBI
           node.nodes.dup.each do |child|
             visit(child)
             child.detach
-            groups[child.group_kind] << child
+            groups[group_kind(child)] << child
           end
 
           groups.each { |_, group| node << group }
         end
       end
+
+      private
+
+      sig { params(node: Node).returns(Group::Kind) }
+      def group_kind(node)
+        case node
+        when Group
+          node.kind
+        when Include, Extend
+          Group::Kind::Mixins
+        when RequiresAncestor
+          Group::Kind::RequiredAncestors
+        when Helper
+          Group::Kind::Helpers
+        when TypeMember
+          Group::Kind::TypeMembers
+        when MixesInClassMethods
+          Group::Kind::MixesInClassMethods
+        when Send
+          Group::Kind::Sends
+        when Attr
+          Group::Kind::Attrs
+        when TStructField
+          Group::Kind::TStructFields
+        when TEnumBlock
+          Group::Kind::TEnums
+        when VisibilityGroup
+          Group::Kind::Methods
+        when Method
+          if node.name == "initialize"
+            Group::Kind::Inits
+          else
+            Group::Kind::Methods
+          end
+        when SingletonClass
+          Group::Kind::SingletonClasses
+        when Scope, Const
+          Group::Kind::Consts
+        else
+          raise GroupNodesError, "Unknown group for #{self}"
+        end
+      end
     end
   end
 
@@ -41,50 +84,6 @@ module RBI
     end
   end
 
-  class Node
-    extend T::Sig
-
-    sig { returns(Group::Kind) }
-    def group_kind
-      case self
-      when Group
-        kind
-      when Include, Extend
-        Group::Kind::Mixins
-      when RequiresAncestor
-        Group::Kind::RequiredAncestors
-      when Helper
-        Group::Kind::Helpers
-      when TypeMember
-        Group::Kind::TypeMembers
-      when MixesInClassMethods
-        Group::Kind::MixesInClassMethods
-      when Send
-        Group::Kind::Sends
-      when Attr
-        Group::Kind::Attrs
-      when TStructField
-        Group::Kind::TStructFields
-      when TEnumBlock
-        Group::Kind::TEnums
-      when VisibilityGroup
-        Group::Kind::Methods
-      when Method
-        if name == "initialize"
-          Group::Kind::Inits
-        else
-          Group::Kind::Methods
-        end
-      when SingletonClass
-        Group::Kind::SingletonClasses
-      when Scope, Const
-        Group::Kind::Consts
-      else
-        raise "Unknown group for #{self}"
-      end
-    end
-  end
-
   class Group < Tree
     extend T::Sig
 

data/lib/rbi/rewriters/merge_trees.rb

@@ -348,6 +348,8 @@ module RBI
     end
   end
 
+  class DuplicateNodeError < Error; end
+
   class Scope
     extend T::Sig
 
@@ -357,6 +359,12 @@ module RBI
       case self
       when Module
         Module.new(name, loc: loc, comments: comments)
+      when TEnum
+        TEnum.new(name, loc: loc, comments: comments)
+      when TEnumBlock
+        TEnumBlock.new(loc: loc, comments: comments)
+      when TStruct
+        TStruct.new(name, loc: loc, comments: comments)
       when Class
         Class.new(name, superclass_name: superclass_name, loc: loc, comments: comments)
       when Struct
@@ -364,7 +372,7 @@ module RBI
       when SingletonClass
         SingletonClass.new(loc: loc, comments: comments)
       else
-        raise "Can't duplicate node #{self}"
+        raise DuplicateNodeError, "Can't duplicate node #{self}"
       end
     end
   end
@@ -549,20 +557,6 @@ module RBI
     end
   end
 
-  class TEnumBlock
-    extend T::Sig
-
-    sig { override.params(other: Node).void }
-    def merge_with(other)
-      return unless other.is_a?(TEnumBlock)
-
-      super
-      other.names.each do |name|
-        names << name unless names.include?(name)
-      end
-    end
-  end
-
   class TStructProp
     extend T::Sig
 
@@ -592,6 +586,9 @@ module RBI
     sig { returns(Tree) }
     attr_reader :left, :right
 
+    sig { returns(String) }
+    attr_reader :left_name, :right_name
+
     sig { params(left_name: String, right_name: String).void }
     def initialize(left_name: "left", right_name: "right")
       super()
@@ -602,15 +599,6 @@ module RBI
       @right = T.let(Tree.new, Tree)
       @right.parent_tree = self
     end
-
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      v.printl("<<<<<<< #{@left_name}")
-      v.visit(left)
-      v.printl("=======")
-      v.visit(right)
-      v.printl(">>>>>>> #{@right_name}")
-    end
   end
 
   # A conflict between two scope headers
@@ -631,6 +619,9 @@ module RBI
     sig { returns(Scope) }
     attr_reader :left, :right
 
+    sig { returns(String) }
+    attr_reader :left_name, :right_name
+
     sig do
       params(
         left: Scope,
@@ -646,26 +637,5 @@ module RBI
       @left_name = left_name
       @right_name = right_name
     end
-
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
-
-      v.printl("# #{loc}") if loc && v.print_locs
-      v.visit_all(comments)
-
-      v.printl("<<<<<<< #{@left_name}")
-      left.print_header(v)
-      v.printl("=======")
-      right.print_header(v)
-      v.printl(">>>>>>> #{@right_name}")
-      left.print_body(v)
-    end
-
-    sig { override.returns(T::Boolean) }
-    def oneline?
-      left.oneline?
-    end
   end
 end

data/lib/rbi/rewriters/{nest_non_public_methods.rb → nest_non_public_members.rb}

@@ -3,7 +3,7 @@
 
 module RBI
   module Rewriters
-    class NestNonPublicMethods < Visitor
+    class NestNonPublicMembers < Visitor
       extend T::Sig
 
       sig { override.params(node: T.nilable(Node)).void }
@@ -18,7 +18,7 @@ module RBI
 
           node.nodes.dup.each do |child|
             visit(child)
-            next unless child.is_a?(Method)
+            next unless child.is_a?(Attr) || child.is_a?(Method)
 
             child.detach
             case child.visibility
@@ -43,8 +43,8 @@ module RBI
     extend T::Sig
 
     sig { void }
-    def nest_non_public_methods!
-      visitor = Rewriters::NestNonPublicMethods.new
+    def nest_non_public_members!
+      visitor = Rewriters::NestNonPublicMembers.new
       visitor.visit(self)
     end
   end

data/lib/rbi/rewriters/nest_top_level_members.rb

@@ -0,0 +1,68 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  module Rewriters
+    # This rewriter moves top-level members into a top-level Object class
+    #
+    # Example:
+    # ~~~rb
+    # def foo; end
+    # attr_reader :bar
+    # ~~~
+    #
+    # will be rewritten to:
+    #
+    # ~~~rb
+    # class Object
+    #  def foo; end
+    #  attr_reader :bar
+    # end
+    # ~~~
+    class NestTopLevelMembers < Visitor
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        super
+
+        @top_level_object_class = T.let(nil, T.nilable(Class))
+      end
+
+      sig { override.params(node: T.nilable(Node)).void }
+      def visit(node)
+        return unless node
+
+        case node
+        when Tree
+          visit_all(node.nodes.dup)
+        else
+          scope = node.parent_scope
+          unless scope
+            parent = node.parent_tree
+            raise unless parent
+
+            node.detach
+
+            unless @top_level_object_class
+              @top_level_object_class = Class.new("Object")
+              parent.nodes << @top_level_object_class
+            end
+
+            @top_level_object_class << node
+          end
+        end
+      end
+    end
+  end
+
+  class Tree
+    extend T::Sig
+
+    sig { void }
+    def nest_top_level_members!
+      visitor = Rewriters::NestTopLevelMembers.new
+      visitor.visit(self)
+    end
+  end
+end