rbi 0.2.4 → 0.3.0

data/lib/rbi/rewriters/merge_trees.rb

@@ -37,8 +37,6 @@ module RBI
     # end
     # ~~~
     class Merge
-      extend T::Sig
-
       class Keep < ::T::Enum
         enums do
           NONE = new
@@ -48,9 +46,7 @@ module RBI
       end
 
       class << self
-        extend T::Sig
-
-        sig { params(left: Tree, right: Tree, left_name: String, right_name: String, keep: Keep).returns(MergeTree) }
+        #: (Tree left, Tree right, ?left_name: String, ?right_name: String, ?keep: Keep) -> MergeTree
         def merge_trees(left, right, left_name: "left", right_name: "right", keep: Keep::NONE)
           left.nest_singleton_methods!
           right.nest_singleton_methods!
@@ -63,10 +59,10 @@ module RBI
         end
       end
 
-      sig { returns(MergeTree) }
+      #: MergeTree
       attr_reader :tree
 
-      sig { params(left_name: String, right_name: String, keep: Keep).void }
+      #: (?left_name: String, ?right_name: String, ?keep: Keep) -> void
       def initialize(left_name: "left", right_name: "right", keep: Keep::NONE)
         @left_name = left_name
         @right_name = right_name
@@ -75,7 +71,7 @@ module RBI
         @scope_stack = T.let([@tree], T::Array[Tree])
       end
 
-      sig { params(tree: Tree).void }
+      #: (Tree tree) -> void
       def merge(tree)
         v = TreeMerger.new(@tree, left_name: @left_name, right_name: @right_name, keep: @keep)
         v.visit(tree)
@@ -84,26 +80,22 @@ module RBI
 
       # Used for logging / error displaying purpose
       class Conflict < T::Struct
-        extend T::Sig
-
         const :left, Node
         const :right, Node
         const :left_name, String
         const :right_name, String
 
-        sig { returns(String) }
+        #: -> String
         def to_s
           "Conflicting definitions for `#{left}`"
         end
       end
 
       class TreeMerger < Visitor
-        extend T::Sig
-
-        sig { returns(T::Array[Conflict]) }
+        #: Array[Conflict]
         attr_reader :conflicts
 
-        sig { params(output: Tree, left_name: String, right_name: String, keep: Keep).void }
+        #: (Tree output, ?left_name: String, ?right_name: String, ?keep: Keep) -> void
         def initialize(output, left_name: "left", right_name: "right", keep: Keep::NONE)
           super()
           @tree = output
@@ -115,7 +107,8 @@ module RBI
           @conflicts = T.let([], T::Array[Conflict])
         end
 
-        sig { override.params(node: T.nilable(Node)).void }
+        # @override
+        #: (Node? node) -> void
         def visit(node)
           return unless node
 
@@ -164,12 +157,12 @@ module RBI
 
         private
 
-        sig { returns(Tree) }
+        #: -> Tree
         def current_scope
           T.must(@scope_stack.last)
         end
 
-        sig { params(node: Node).returns(T.nilable(Node)) }
+        #: (Node node) -> Node?
         def previous_definition(node)
           case node
           when Indexable
@@ -181,14 +174,14 @@ module RBI
           nil
         end
 
-        sig { params(left: Scope, right: Scope).void }
+        #: (Scope left, Scope right) -> void
         def make_conflict_scope(left, right)
           @conflicts << Conflict.new(left: left, right: right, left_name: @left_name, right_name: @right_name)
           scope_conflict = ScopeConflict.new(left: left, right: right, left_name: @left_name, right_name: @right_name)
           left.replace(scope_conflict)
         end
 
-        sig { params(left: Node, right: Node).void }
+        #: (Node left, Node right) -> void
         def make_conflict_tree(left, right)
           @conflicts << Conflict.new(left: left, right: right, left_name: @left_name, right_name: @right_name)
           tree = left.parent_conflict_tree
@@ -200,7 +193,7 @@ module RBI
           tree.right << right
         end
 
-        sig { params(left: Scope, right: Scope).returns(Scope) }
+        #: (Scope left, Scope right) -> Scope
         def replace_scope_header(left, right)
           right_copy = right.dup_empty
           left.replace(right_copy)
@@ -243,12 +236,14 @@ module RBI
       # end
       # ~~~
       class ConflictTreeMerger < Visitor
-        sig { override.params(node: T.nilable(Node)).void }
+        # @override
+        #: (Node? node) -> void
         def visit(node)
           visit_all(node.nodes) if node.is_a?(Tree)
         end
 
-        sig { override.params(nodes: T::Array[Node]).void }
+        # @override
+        #: (Array[Node] nodes) -> void
         def visit_all(nodes)
           last_conflict_tree = T.let(nil, T.nilable(ConflictTree))
           nodes.dup.each do |node|
@@ -269,7 +264,7 @@ module RBI
 
         private
 
-        sig { params(left: Tree, right: Tree).void }
+        #: (Tree left, Tree right) -> void
         def merge_conflict_trees(left, right)
           right.nodes.dup.each do |node|
             left << node
@@ -280,19 +275,17 @@ module RBI
   end
 
   class Node
-    extend T::Sig
-
     # Can `self` and `_other` be merged into a single definition?
-    sig { params(_other: Node).returns(T::Boolean) }
+    #: (Node _other) -> bool
     def compatible_with?(_other)
       true
     end
 
     # Merge `self` and `other` into a single definition
-    sig { params(other: Node).void }
+    #: (Node other) -> void
     def merge_with(other); end
 
-    sig { returns(T.nilable(ConflictTree)) }
+    #: -> ConflictTree?
     def parent_conflict_tree
       parent = T.let(parent_tree, T.nilable(Node))
       while parent
@@ -305,9 +298,8 @@ module RBI
   end
 
   class NodeWithComments
-    extend T::Sig
-
-    sig { override.params(other: Node).void }
+    # @override
+    #: (Node other) -> void
     def merge_with(other)
       return unless other.is_a?(NodeWithComments)
 
@@ -318,9 +310,7 @@ module RBI
   end
 
   class Tree
-    extend T::Sig
-
-    sig { params(other: Tree, left_name: String, right_name: String, keep: Rewriters::Merge::Keep).returns(MergeTree) }
+    #: (Tree other, ?left_name: String, ?right_name: String, ?keep: Rewriters::Merge::Keep) -> MergeTree
     def merge(other, left_name: "left", right_name: "right", keep: Rewriters::Merge::Keep::NONE)
       Rewriters::Merge.merge_trees(self, other, left_name: left_name, right_name: right_name, keep: keep)
     end
@@ -328,19 +318,10 @@ module RBI
 
   # A tree that _might_ contain conflicts
   class MergeTree < Tree
-    extend T::Sig
-
-    sig { returns(T::Array[Rewriters::Merge::Conflict]) }
+    #: Array[Rewriters::Merge::Conflict]
     attr_reader :conflicts
 
-    sig do
-      params(
-        loc: T.nilable(Loc),
-        comments: T::Array[Comment],
-        conflicts: T::Array[Rewriters::Merge::Conflict],
-        block: T.nilable(T.proc.params(node: Tree).void),
-      ).void
-    end
+    #: (?loc: Loc?, ?comments: Array[Comment], ?conflicts: Array[Rewriters::Merge::Conflict]) ?{ (Tree node) -> void } -> void
     def initialize(loc: nil, comments: [], conflicts: [], &block)
       super(loc: loc, comments: comments)
       @conflicts = conflicts
@@ -351,10 +332,8 @@ module RBI
   class DuplicateNodeError < Error; end
 
   class Scope
-    extend T::Sig
-
     # Duplicate `self` scope without its body
-    sig { returns(T.self_type) }
+    #: -> self
     def dup_empty
       case self
       when Module
@@ -378,45 +357,40 @@ module RBI
   end
 
   class Class
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       other.is_a?(Class) && superclass_name == other.superclass_name
     end
   end
 
   class Module
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       other.is_a?(Module)
     end
   end
 
   class Struct
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       other.is_a?(Struct) && members == other.members && keyword_init == other.keyword_init
     end
   end
 
   class Const
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       other.is_a?(Const) && name == other.name && value == other.value
     end
   end
 
   class Attr
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       return false unless other.is_a?(Attr)
       return false unless names == other.names
@@ -424,7 +398,8 @@ module RBI
       sigs.empty? || other.sigs.empty? || sigs == other.sigs
     end
 
-    sig { override.params(other: Node).void }
+    # @override
+    #: (Node other) -> void
     def merge_with(other)
       return unless other.is_a?(Attr)
 
@@ -436,36 +411,32 @@ module RBI
   end
 
   class AttrReader
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       other.is_a?(AttrReader) && super
     end
   end
 
   class AttrWriter
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       other.is_a?(AttrWriter) && super
     end
   end
 
   class AttrAccessor
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       other.is_a?(AttrAccessor) && super
     end
   end
 
   class Method
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       return false unless other.is_a?(Method)
       return false unless name == other.name
@@ -474,7 +445,8 @@ module RBI
       sigs.empty? || other.sigs.empty? || sigs == other.sigs
     end
 
-    sig { override.params(other: Node).void }
+    # @override
+    #: (Node other) -> void
     def merge_with(other)
       return unless other.is_a?(Method)
 
@@ -486,81 +458,72 @@ module RBI
   end
 
   class Mixin
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       other.is_a?(Mixin) && names == other.names
     end
   end
 
   class Include
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       other.is_a?(Include) && super
     end
   end
 
   class Extend
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       other.is_a?(Extend) && super
     end
   end
 
   class MixesInClassMethods
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       other.is_a?(MixesInClassMethods) && super
     end
   end
 
   class Helper
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       other.is_a?(Helper) && name == other.name
     end
   end
 
   class Send
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       other.is_a?(Send) && method == other.method && args == other.args
     end
   end
 
   class TStructField
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       other.is_a?(TStructField) && name == other.name && type == other.type && default == other.default
     end
   end
 
   class TStructConst
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       other.is_a?(TStructConst) && super
     end
   end
 
   class TStructProp
-    extend T::Sig
-
-    sig { override.params(other: Node).returns(T::Boolean) }
+    # @override
+    #: (Node other) -> bool
     def compatible_with?(other)
       other.is_a?(TStructProp) && super
     end
@@ -581,15 +544,13 @@ module RBI
   # end
   # ~~~
   class ConflictTree < Tree
-    extend T::Sig
-
-    sig { returns(Tree) }
+    #: Tree
     attr_reader :left, :right
 
-    sig { returns(String) }
+    #: String
     attr_reader :left_name, :right_name
 
-    sig { params(left_name: String, right_name: String).void }
+    #: (?left_name: String, ?right_name: String) -> void
     def initialize(left_name: "left", right_name: "right")
       super()
       @left_name = left_name
@@ -614,22 +575,13 @@ module RBI
   # end
   # ~~~
   class ScopeConflict < Tree
-    extend T::Sig
-
-    sig { returns(Scope) }
+    #: Scope
     attr_reader :left, :right
 
-    sig { returns(String) }
+    #: String
     attr_reader :left_name, :right_name
 
-    sig do
-      params(
-        left: Scope,
-        right: Scope,
-        left_name: String,
-        right_name: String,
-      ).void
-    end
+    #: (left: Scope, right: Scope, ?left_name: String, ?right_name: String) -> void
     def initialize(left:, right:, left_name: "left", right_name: "right")
       super()
       @left = left

data/lib/rbi/rewriters/nest_non_public_members.rb

@@ -4,9 +4,8 @@
 module RBI
   module Rewriters
     class NestNonPublicMembers < Visitor
-      extend T::Sig
-
-      sig { override.params(node: T.nilable(Node)).void }
+      # @override
+      #: (Node? node) -> void
       def visit(node)
         return unless node
 
@@ -40,9 +39,7 @@ module RBI
   end
 
   class Tree
-    extend T::Sig
-
-    sig { void }
+    #: -> void
     def nest_non_public_members!
       visitor = Rewriters::NestNonPublicMembers.new
       visitor.visit(self)
@@ -50,12 +47,10 @@ module RBI
   end
 
   class VisibilityGroup < Tree
-    extend T::Sig
-
-    sig { returns(Visibility) }
+    #: Visibility
     attr_reader :visibility
 
-    sig { params(visibility: Visibility).void }
+    #: (Visibility visibility) -> void
     def initialize(visibility)
       super()
       @visibility = visibility

data/lib/rbi/rewriters/nest_singleton_methods.rb

@@ -4,9 +4,8 @@
 module RBI
   module Rewriters
     class NestSingletonMethods < Visitor
-      extend T::Sig
-
-      sig { override.params(node: T.nilable(Node)).void }
+      # @override
+      #: (Node? node) -> void
       def visit(node)
         return unless node
 
@@ -30,9 +29,7 @@ module RBI
   end
 
   class Tree
-    extend T::Sig
-
-    sig { void }
+    #: -> void
     def nest_singleton_methods!
       visitor = Rewriters::NestSingletonMethods.new
       visitor.visit(self)

data/lib/rbi/rewriters/nest_top_level_members.rb

@@ -20,16 +20,15 @@ module RBI
     # end
     # ~~~
     class NestTopLevelMembers < Visitor
-      extend T::Sig
-
-      sig { void }
+      #: -> void
       def initialize
         super
 
         @top_level_object_class = T.let(nil, T.nilable(Class))
       end
 
-      sig { override.params(node: T.nilable(Node)).void }
+      # @override
+      #: (Node? node) -> void
       def visit(node)
         return unless node
 
@@ -57,9 +56,7 @@ module RBI
   end
 
   class Tree
-    extend T::Sig
-
-    sig { void }
+    #: -> void
     def nest_top_level_members!
       visitor = Rewriters::NestTopLevelMembers.new
       visitor.visit(self)

data/lib/rbi/rewriters/remove_known_definitions.rb

@@ -46,12 +46,10 @@ module RBI
     # OPERATIONS
     # ~~~
     class RemoveKnownDefinitions < Visitor
-      extend T::Sig
-
-      sig { returns(T::Array[Operation]) }
+      #: Array[Operation]
       attr_reader :operations
 
-      sig { params(index: Index).void }
+      #: (Index index) -> void
       def initialize(index)
         super()
         @index = index
@@ -59,14 +57,7 @@ module RBI
       end
 
       class << self
-        extend T::Sig
-
-        sig do
-          params(
-            tree: Tree,
-            index: Index,
-          ).returns([Tree, T::Array[Operation]])
-        end
+        #: (Tree tree, Index index) -> [Tree, Array[Operation]]
         def remove(tree, index)
           v = RemoveKnownDefinitions.new(index)
           v.visit(tree)
@@ -74,12 +65,13 @@ module RBI
         end
       end
 
-      sig { params(nodes: T::Array[Node]).void }
+      #: (Array[Node] nodes) -> void
       def visit_all(nodes)
         nodes.dup.each { |node| visit(node) }
       end
 
-      sig { override.params(node: T.nilable(Node)).void }
+      # @override
+      #: (Node? node) -> void
       def visit(node)
         return unless node
 
@@ -98,7 +90,7 @@ module RBI
 
       private
 
-      sig { params(node: Indexable).returns(T.nilable(Node)) }
+      #: (Indexable node) -> Node?
       def previous_definition_for(node)
         node.index_ids.each do |id|
           previous = @index[id].first
@@ -107,7 +99,7 @@ module RBI
         nil
       end
 
-      sig { params(node: Node, previous: Node).returns(T::Boolean) }
+      #: (Node node, Node previous) -> bool
       def can_delete_node?(node, previous)
         return false unless node.class == previous.class
 
@@ -125,19 +117,17 @@ module RBI
         end
       end
 
-      sig { params(node: Node, previous: Node).void }
+      #: (Node node, Node previous) -> void
       def delete_node(node, previous)
         node.detach
         @operations << Operation.new(deleted_node: node, duplicate_of: previous)
       end
 
       class Operation < T::Struct
-        extend T::Sig
-
         const :deleted_node, Node
         const :duplicate_of, Node
 
-        sig { returns(String) }
+        #: -> String
         def to_s
           "Deleted #{duplicate_of} at #{deleted_node.loc} (duplicate from #{duplicate_of.loc})"
         end