rbi 0.1.14 → 0.2.1

data/lib/rbi/rewriters/attr_to_methods.rb

@@ -62,7 +62,7 @@ module RBI
 
     private
 
-    sig(:final) { returns([T.nilable(Sig), T.nilable(String)]) }
+    sig(:final) { returns([T.nilable(Sig), T.nilable(T.any(Type, String))]) }
     def parse_sig
       raise UnexpectedMultipleSigsError, self if 1 < sigs.count
 
@@ -101,7 +101,7 @@ module RBI
       params(
         name: String,
         sig: T.nilable(Sig),
-        attribute_type: T.nilable(String),
+        attribute_type: T.nilable(T.any(Type, String)),
         visibility: Visibility,
         loc: T.nilable(Loc),
         comments: T::Array[Comment],

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/merge_trees.rb

@@ -359,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
@@ -551,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
 

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