Generate sorbet types in a rake task

Author: kddnewton

Rakefile

@@ -16,7 +16,16 @@ task default: :test
 
 configure = ->(task) do
   task.source_files =
-    FileList[%w[Gemfile Rakefile syntax_tree.gemspec lib/**/*.rb test/*.rb]]
+    FileList[
+      %w[
+        Gemfile
+        Rakefile
+        syntax_tree.gemspec
+        lib/**/*.rb
+        tasks/*.rake
+        test/*.rb
+      ]
+    ]
 
   # Since Syntax Tree supports back to Ruby 2.7.0, we need to make sure that we
   # format our code such that it's compatible with that version. This actually

lib/syntax_tree/dsl.rb

@@ -210,12 +210,17 @@ def RAssign(value, operator, pattern)
     end
 
     # Create a new ClassDeclaration node.
-    def ClassDeclaration(constant, superclass, bodystmt)
+    def ClassDeclaration(
+      constant,
+      superclass,
+      bodystmt,
+      location = Location.default
+    )
       ClassDeclaration.new(
         constant: constant,
         superclass: superclass,
         bodystmt: bodystmt,
-        location: Location.default
+        location: location
       )
     end
 
@@ -225,12 +230,12 @@ def Comma(value)
     end
 
     # Create a new Command node.
-    def Command(message, arguments, block)
+    def Command(message, arguments, block, location = Location.default)
       Command.new(
         message: message,
         arguments: arguments,
         block: block,
-        location: Location.default
+        location: location
       )
     end
 
@@ -247,8 +252,8 @@ def CommandCall(receiver, operator, message, arguments, block)
     end
 
     # Create a new Comment node.
-    def Comment(value, inline)
-      Comment.new(value: value, inline: inline, location: Location.default)
+    def Comment(value, inline, location = Location.default)
+      Comment.new(value: value, inline: inline, location: location)
     end
 
     # Create a new Const node.
@@ -285,14 +290,21 @@ def CVar(value)
     end
 
     # Create a new DefNode node.
-    def DefNode(target, operator, name, params, bodystmt)
+    def DefNode(
+      target,
+      operator,
+      name,
+      params,
+      bodystmt,
+      location = Location.default
+    )
       DefNode.new(
         target: target,
         operator: operator,
         name: name,
         params: params,
         bodystmt: bodystmt,
-        location: Location.default
+        location: location
       )
     end
 
@@ -565,8 +577,8 @@ def MAssign(target, value)
     end
 
     # Create a new MethodAddBlock node.
-    def MethodAddBlock(call, block)
-      MethodAddBlock.new(call: call, block: block, location: Location.default)
+    def MethodAddBlock(call, block, location = Location.default)
+      MethodAddBlock.new(call: call, block: block, location: location)
     end
 
     # Create a new MLHS node.

lib/syntax_tree/parser.rb

@@ -912,7 +912,12 @@ def on_bodystmt(statements, rescue_clause, else_clause, ensure_clause)
       # in the case that we're inside of an endless method definition. In this
       # case we'll wrap it in a Statements node to be consistent.
       unless statements.is_a?(Statements)
-        statements = Statements.new(self, body: [statements], location: statements.location)
+        statements =
+          Statements.new(
+            self,
+            body: [statements],
+            location: statements.location
+          )
       end
 
       parts = [statements, rescue_clause, else_clause, ensure_clause].compact
@@ -1894,14 +1899,16 @@ def on_hshptn(constant, keywords, keyword_rest)
           else
             tstring_beg_index =
               tokens.rindex do |token|
-                token.is_a?(TStringBeg) && token.location.start_char < label.location.start_char
+                token.is_a?(TStringBeg) &&
+                  token.location.start_char < label.location.start_char
               end
 
             tstring_beg = tokens.delete_at(tstring_beg_index)
 
             label_end_index =
               tokens.rindex do |token|
-                token.is_a?(LabelEnd) && token.location.start_char == label.location.end_char
+                token.is_a?(LabelEnd) &&
+                  token.location.start_char == label.location.end_char
               end
 
             label_end = tokens.delete_at(label_end_index)
@@ -1913,7 +1920,7 @@ def on_hshptn(constant, keywords, keyword_rest)
                 location: tstring_beg.location.to(label_end.location)
               ),
               value
-            ] 
+            ]
           end
         end
 

lib/syntax_tree/reflection.rb

@@ -34,10 +34,10 @@ class TupleType
         def initialize(types)
           @types = types
         end
-      
+
         def ===(value)
           value.is_a?(Array) && value.length == types.length &&
-            value.zip(types).all? { _2 === _1 }
+            value.zip(types).all? { |item, type| type === item }
         end
 
         def inspect
@@ -64,16 +64,20 @@ def inspect
 
       class << self
         def parse(comment)
+          comment = comment.gsub(/\n/, " ")
+
           unless comment.start_with?("[")
             raise "Comment does not start with a bracket: #{comment.inspect}"
           end
 
           count = 1
           found =
-            comment.chars[1..].find.with_index(1) do |char, index|
-              count += { "[" => 1, "]" => -1 }.fetch(char, 0)
-              break index if count == 0
-            end
+            comment.chars[1..]
+              .find
+              .with_index(1) do |char, index|
+                count += { "[" => 1, "]" => -1 }.fetch(char, 0)
+                break index if count == 0
+              end
 
           # If we weren't able to find the end of the balanced brackets, then
           # the comment is malformed.
@@ -209,7 +213,7 @@ def parse_comments(statements, index)
           attribute =
             Attribute.new(
               statement.arguments.parts.first.value.value.to_sym,
-              parse_comments(statements, statement_index).join(" ")
+              "#{parse_comments(statements, statement_index).join("\n")}\n"
             )
 
           # Ensure that we don't already have an attribute named the same as
@@ -223,10 +227,11 @@ def parse_comments(statements, index)
       end
 
       # Finally, set it up in the hash of nodes so that we can use it later.
+      comments = parse_comments(main_statements, main_statement_index)
       node =
         Node.new(
           main_statement.constant.constant.value.to_sym,
-          parse_comments(main_statements, main_statement_index).join("\n"),
+          "#{comments.join("\n")}\n",
           attributes
         )
 

lib/syntax_tree/translation/parser.rb

@@ -2364,8 +2364,7 @@ def visit_statements(node)
 
       # Visit a StringConcat node.
       def visit_string_concat(node)
-        location =
-          source_map_collection(expression: source_range_node(node))
+        location = source_map_collection(expression: source_range_node(node))
 
         s(:dstr, [visit(node.left), visit(node.right)], location)
       end

lib/syntax_tree/yarv/compiler.rb

@@ -1050,11 +1050,21 @@ def visit_if_op(node)
         visit_if(
           IfNode.new(
             predicate: node.predicate,
-            statements: Statements.new(nil, body: [node.truthy], location: Location.default),
+            statements:
+              Statements.new(
+                nil,
+                body: [node.truthy],
+                location: Location.default
+              ),
             consequent:
               Else.new(
                 keyword: Kw.new(value: "else", location: Location.default),
-                statements: Statements.new(nil, body: [node.falsy], location: Location.default),
+                statements:
+                  Statements.new(
+                    nil,
+                    body: [node.falsy],
+                    location: Location.default
+                  ),
                 location: Location.default
               ),
             location: Location.default