rbi 0.2.4 → 0.3.2

data/lib/rbi/rewriters/remove_known_definitions.rb

@@ -46,27 +46,18 @@ 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
-        @operations = T.let([], T::Array[Operation])
+        @operations = [] #: Array[Operation]
       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
 
@@ -115,29 +107,27 @@ module RBI
         when Scope
           node.empty?
         when Attr
-          previous = T.cast(previous, Attr)
+          previous = previous #: as Attr
           node.names == previous.names && node.sigs == previous.sigs
         when Method
-          previous = T.cast(previous, Method)
+          previous = previous #: as Method
           node.params == previous.params && node.sigs == previous.sigs
         else
           true
         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

data/lib/rbi/rewriters/sort_nodes.rb

@@ -4,9 +4,8 @@
 module RBI
   module Rewriters
     class SortNodes < Visitor
-      extend T::Sig
-
-      sig { override.params(node: T.nilable(Node)).void }
+      # @override
+      #: (Node? node) -> void
       def visit(node)
         sort_node_names!(node) if node
 
@@ -32,7 +31,9 @@ module RBI
             next res if res && res != 0 # we can sort the nodes by their name, let's stop here
 
             # Finally, if the two nodes have the same rank and the same name or at least one node is anonymous then,
-            T.must(original_order[a]) <=> T.must(original_order[b]) # we keep the original order
+            original_order_a = original_order[a] #: as !nil
+            original_order_b = original_order[b] #: as !nil
+            original_order_a <=> original_order_b # we keep the original order
           end
         end
 
@@ -41,7 +42,7 @@ module RBI
 
       private
 
-      sig { params(node: Node).returns(Integer) }
+      #: (Node node) -> Integer
       def node_rank(node)
         case node
         when Group                then group_rank(node.kind)
@@ -69,7 +70,7 @@ module RBI
         end
       end
 
-      sig { params(kind: Group::Kind).returns(Integer) }
+      #: (Group::Kind kind) -> Integer
       def group_rank(kind)
         case kind
         when Group::Kind::Mixins              then 0
@@ -90,7 +91,7 @@ module RBI
         end
       end
 
-      sig { params(node: Node).returns(T.nilable(String)) }
+      #: (Node node) -> String?
       def node_name(node)
         case node
         when Module, Class, Struct, Const, Method, Helper, RequiresAncestor
@@ -102,7 +103,7 @@ module RBI
         end
       end
 
-      sig { params(node: Node).void }
+      #: (Node node) -> void
       def sort_node_names!(node)
         case node
         when Attr
@@ -113,9 +114,7 @@ module RBI
   end
 
   class Tree
-    extend T::Sig
-
-    sig { void }
+    #: -> void
     def sort_nodes!
       visitor = Rewriters::SortNodes.new
       visitor.visit(self)

data/lib/rbi/rewriters/translate_rbs_sigs.rb

@@ -0,0 +1,87 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  module Rewriters
+    # Translate all RBS signature comments to Sorbet RBI signatures
+    class TranslateRBSSigs < Visitor
+      class Error < RBI::Error; end
+
+      # @override
+      #: (Node? node) -> void
+      def visit(node)
+        return unless node
+
+        case node
+        when Tree
+          visit_all(node.nodes)
+        when AttrAccessor, AttrReader, AttrWriter
+          rbs_comments = extract_rbs_comments(node)
+          rbs_comments.each do |comment|
+            node.sigs << translate_rbs_attr_type(node, comment)
+          end
+        when Method
+          rbs_comments = extract_rbs_comments(node)
+          rbs_comments.each do |comment|
+            node.sigs << translate_rbs_method_type(node, comment)
+          end
+        end
+      end
+
+      private
+
+      #: (Method | Attr) -> Array[RBSComment]
+      def extract_rbs_comments(node)
+        comments = node.comments.dup
+        node.comments.clear
+
+        rbs_sigs = [] #: Array[RBSComment]
+
+        comments.each do |comment|
+          case comment
+          when RBSComment
+            rbs_sigs << comment
+          else
+            node.comments << comment
+          end
+        end
+
+        rbs_sigs
+      end
+
+      #: (Method, RBSComment) -> Sig
+      def translate_rbs_method_type(node, comment)
+        method_type = ::RBS::Parser.parse_method_type(comment.text)
+        translator = RBS::MethodTypeTranslator.new(node)
+        translator.visit(method_type)
+        translator.result
+      end
+
+      #: (Attr, RBSComment) -> Sig
+      def translate_rbs_attr_type(node, comment)
+        attr_type = ::RBS::Parser.parse_type(comment.text)
+        sig = Sig.new
+
+        if node.is_a?(AttrWriter)
+          if node.names.size != 1
+            raise Error, "AttrWriter must have exactly one name"
+          end
+
+          name = node.names.first #: as !nil
+          sig.params << SigParam.new(name.to_s, RBS::TypeTranslator.translate(attr_type))
+        end
+
+        sig.return_type = RBS::TypeTranslator.translate(attr_type)
+        sig
+      end
+    end
+  end
+
+  class Tree
+    #: -> void
+    def translate_rbs_sigs!
+      visitor = Rewriters::TranslateRBSSigs.new
+      visitor.visit(self)
+    end
+  end
+end