syntax_tree 4.2.0 → 5.0.0

data/lib/syntax_tree/pattern.rb

@@ -75,98 +75,213 @@ module SyntaxTree
 
     private
 
+    # Shortcut for combining two procs into one that returns true if both return
+    # true.
     def combine_and(left, right)
-      ->(node) { left.call(node) && right.call(node) }
+      ->(other) { left.call(other) && right.call(other) }
     end
 
+    # Shortcut for combining two procs into one that returns true if either
+    # returns true.
     def combine_or(left, right)
-      ->(node) { left.call(node) || right.call(node) }
+      ->(other) { left.call(other) || right.call(other) }
     end
 
-    def compile_node(root)
-      case root
-      in AryPtn[constant:, requireds:, rest: nil, posts: []]
-        compiled_constant = compile_node(constant) if constant
+    # Raise an error because the given node is not supported.
+    def compile_error(node)
+      raise CompilationError, PP.pp(node, +"").chomp
+    end
+
+    # There are a couple of nodes (string literals, dynamic symbols, and regexp)
+    # that contain list of parts. This can include plain string content,
+    # interpolated expressions, and interpolated variables. We only support
+    # plain string content, so this method will extract out the plain string
+    # content if it is the only element in the list.
+    def extract_string(node)
+      parts = node.parts
 
-        preprocessed = requireds.map { |required| compile_node(required) }
+      if parts.length == 1 && (part = parts.first) && part.is_a?(TStringContent)
+        part.value
+      end
+    end
 
-        compiled_requireds = ->(node) do
-          deconstructed = node.deconstruct
+    # in [foo, bar, baz]
+    def compile_aryptn(node)
+      compile_error(node) if !node.rest.nil? || node.posts.any?
 
-          deconstructed.length == preprocessed.length &&
-            preprocessed
-              .zip(deconstructed)
-              .all? { |(matcher, value)| matcher.call(value) }
-        end
+      constant = node.constant
+      compiled_constant = compile_node(constant) if constant
 
-        if compiled_constant
-          combine_and(compiled_constant, compiled_requireds)
-        else
-          compiled_requireds
-        end
-      in Binary[left:, operator: :|, right:]
-        combine_or(compile_node(left), compile_node(right))
-      in Const[value:] if SyntaxTree.const_defined?(value)
+      preprocessed = node.requireds.map { |required| compile_node(required) }
+
+      compiled_requireds = ->(other) do
+        deconstructed = other.deconstruct
+
+        deconstructed.length == preprocessed.length &&
+          preprocessed
+            .zip(deconstructed)
+            .all? { |(matcher, value)| matcher.call(value) }
+      end
+
+      if compiled_constant
+        combine_and(compiled_constant, compiled_requireds)
+      else
+        compiled_requireds
+      end
+    end
+
+    # in foo | bar
+    def compile_binary(node)
+      compile_error(node) if node.operator != :|
+
+      combine_or(compile_node(node.left), compile_node(node.right))
+    end
+
+    # in Ident
+    # in String
+    def compile_const(node)
+      value = node.value
+
+      if SyntaxTree.const_defined?(value, false)
         clazz = SyntaxTree.const_get(value)
 
-        ->(node) { node.is_a?(clazz) }
-      in Const[value:] if Object.const_defined?(value)
+        ->(other) { clazz === other }
+      elsif Object.const_defined?(value, false)
         clazz = Object.const_get(value)
 
-        ->(node) { node.is_a?(clazz) }
-      in ConstPathRef[
-           parent: VarRef[value: Const[value: "SyntaxTree"]], constant:
-         ]
-        compile_node(constant)
-      in DynaSymbol[parts: []]
+        ->(other) { clazz === other }
+      else
+        compile_error(node)
+      end
+    end
+
+    # in SyntaxTree::Ident
+    def compile_const_path_ref(node)
+      parent = node.parent
+      compile_error(node) if !parent.is_a?(VarRef) || !parent.value.is_a?(Const)
+
+      if parent.value.value == "SyntaxTree"
+        compile_node(node.constant)
+      else
+        compile_error(node)
+      end
+    end
+
+    # in :""
+    # in :"foo"
+    def compile_dyna_symbol(node)
+      if node.parts.empty?
         symbol = :""
 
-        ->(node) { node == symbol }
-      in DynaSymbol[parts: [TStringContent[value:]]]
+        ->(other) { symbol === other }
+      elsif (value = extract_string(node))
         symbol = value.to_sym
 
-        ->(attribute) { attribute == value }
-      in HshPtn[constant:, keywords:, keyword_rest: nil]
-        compiled_constant = compile_node(constant)
-
-        preprocessed =
-          keywords.to_h do |keyword, value|
-            raise NoMatchingPatternError unless keyword.is_a?(Label)
-            [keyword.value.chomp(":").to_sym, compile_node(value)]
-          end
+        ->(other) { symbol === other }
+      else
+        compile_error(node)
+      end
+    end
 
-        compiled_keywords = ->(node) do
-          deconstructed = node.deconstruct_keys(preprocessed.keys)
+    # in Ident[value: String]
+    # in { value: String }
+    def compile_hshptn(node)
+      compile_error(node) unless node.keyword_rest.nil?
+      compiled_constant = compile_node(node.constant) if node.constant
 
-          preprocessed.all? do |keyword, matcher|
-            matcher.call(deconstructed[keyword])
-          end
+      preprocessed =
+        node.keywords.to_h do |keyword, value|
+          compile_error(node) unless keyword.is_a?(Label)
+          [keyword.value.chomp(":").to_sym, compile_node(value)]
         end
 
-        if compiled_constant
-          combine_and(compiled_constant, compiled_keywords)
-        else
-          compiled_keywords
+      compiled_keywords = ->(other) do
+        deconstructed = other.deconstruct_keys(preprocessed.keys)
+
+        preprocessed.all? do |keyword, matcher|
+          matcher.call(deconstructed[keyword])
         end
-      in RegexpLiteral[parts: [TStringContent[value:]]]
+      end
+
+      if compiled_constant
+        combine_and(compiled_constant, compiled_keywords)
+      else
+        compiled_keywords
+      end
+    end
+
+    # in /foo/
+    def compile_regexp_literal(node)
+      if (value = extract_string(node))
         regexp = /#{value}/
 
-        ->(attribute) { regexp.match?(attribute) }
-      in StringLiteral[parts: []]
-        ->(attribute) { attribute == "" }
-      in StringLiteral[parts: [TStringContent[value:]]]
-        ->(attribute) { attribute == value }
-      in SymbolLiteral[value:]
-        symbol = value.value.to_sym
+        ->(attribute) { regexp === attribute }
+      else
+        compile_error(node)
+      end
+    end
+
+    # in ""
+    # in "foo"
+    def compile_string_literal(node)
+      if node.parts.empty?
+        ->(attribute) { "" === attribute }
+      elsif (value = extract_string(node))
+        ->(attribute) { value === attribute }
+      else
+        compile_error(node)
+      end
+    end
+
+    # in :+
+    # in :foo
+    def compile_symbol_literal(node)
+      symbol = node.value.value.to_sym
 
-        ->(attribute) { attribute == symbol }
-      in VarRef[value: Const => value]
+      ->(attribute) { symbol === attribute }
+    end
+
+    # in Foo
+    # in nil
+    def compile_var_ref(node)
+      value = node.value
+
+      if value.is_a?(Const)
         compile_node(value)
-      in VarRef[value: Kw[value: "nil"]]
-        ->(attribute) { attribute.nil? }
+      elsif value.is_a?(Kw) && value.value.nil?
+        ->(attribute) { nil === attribute }
+      else
+        compile_error(node)
+      end
+    end
+
+    # Compile any kind of node. Dispatch out to the individual compilation
+    # methods based on the type of node.
+    def compile_node(node)
+      case node
+      when AryPtn
+        compile_aryptn(node)
+      when Binary
+        compile_binary(node)
+      when Const
+        compile_const(node)
+      when ConstPathRef
+        compile_const_path_ref(node)
+      when DynaSymbol
+        compile_dyna_symbol(node)
+      when HshPtn
+        compile_hshptn(node)
+      when RegexpLiteral
+        compile_regexp_literal(node)
+      when StringLiteral
+        compile_string_literal(node)
+      when SymbolLiteral
+        compile_symbol_literal(node)
+      when VarRef
+        compile_var_ref(node)
+      else
+        compile_error(node)
       end
-    rescue NoMatchingPatternError
-      raise CompilationError, PP.pp(root, +"").chomp
     end
   end
 end

data/lib/syntax_tree/plugin/single_quotes.rb

@@ -1,3 +1,7 @@
 # frozen_string_literal: true
 
-SyntaxTree::Formatter::OPTIONS[:quote] = "'"
+module SyntaxTree
+  class Formatter
+    SINGLE_QUOTES = true
+  end
+end

data/lib/syntax_tree/plugin/trailing_comma.rb

@@ -1,3 +1,7 @@
 # frozen_string_literal: true
 
-SyntaxTree::Formatter::OPTIONS[:trailing_comma] = true
+module SyntaxTree
+  class Formatter
+    TRAILING_COMMA = true
+  end
+end

data/lib/syntax_tree/rake/task.rb

@@ -78,7 +78,7 @@ module SyntaxTree
 
         arguments << "--ignore-files=#{ignore_files}" if ignore_files != ""
 
-        SyntaxTree::CLI.run(arguments + Array(source_files))
+        abort if SyntaxTree::CLI.run(arguments + Array(source_files)) != 0
       end
     end
   end

data/lib/syntax_tree/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SyntaxTree
-  VERSION = "4.2.0"
+  VERSION = "5.0.0"
 end

data/lib/syntax_tree/visitor/environment.rb

@@ -4,10 +4,6 @@ module SyntaxTree
   # The environment class is used to keep track of local variables and arguments
   # inside a particular scope
   class Environment
-    # [Array[Local]] The local variables and arguments defined in this
-    # environment
-    attr_reader :locals
-
     # This class tracks the occurrences of a local variable or argument
     class Local
       # [Symbol] The type of the local (e.g. :argument, :variable)
@@ -38,6 +34,13 @@ module SyntaxTree
       end
     end
 
+    # [Array[Local]] The local variables and arguments defined in this
+    # environment
+    attr_reader :locals
+
+    # [Environment | nil] The parent environment
+    attr_reader :parent
+
     #   initialize: (Environment | nil parent) -> void
     def initialize(parent = nil)
       @locals = {}

data/lib/syntax_tree/visitor/field_visitor.rb

@@ -103,7 +103,7 @@ module SyntaxTree
       end
 
       def visit_args_forward(node)
-        visit_token(node, "args_forward")
+        node(node, "args_forward") { comments(node) }
       end
 
       def visit_array(node)
@@ -184,6 +184,14 @@ module SyntaxTree
         end
       end
 
+      def visit_block(node)
+        node(node, "block") do
+          field("block_var", node.block_var) if node.block_var
+          field("bodystmt", node.bodystmt)
+          comments(node)
+        end
+      end
+
       def visit_blockarg(node)
         node(node, "blockarg") do
           field("name", node.name) if node.name
@@ -209,14 +217,6 @@ module SyntaxTree
         end
       end
 
-      def visit_brace_block(node)
-        node(node, "brace_block") do
-          field("block_var", node.block_var) if node.block_var
-          field("statements", node.statements)
-          comments(node)
-        end
-      end
-
       def visit_break(node)
         node(node, "break") do
           field("arguments", node.arguments)
@@ -315,6 +315,8 @@ module SyntaxTree
 
       def visit_def(node)
         node(node, "def") do
+          field("target", node.target)
+          field("operator", node.operator)
           field("name", node.name)
           field("params", node.params)
           field("bodystmt", node.bodystmt)
@@ -322,20 +324,6 @@ module SyntaxTree
         end
       end
 
-      def visit_def_endless(node)
-        node(node, "def_endless") do
-          if node.target
-            field("target", node.target)
-            field("operator", node.operator)
-          end
-
-          field("name", node.name)
-          field("paren", node.paren) if node.paren
-          field("statement", node.statement)
-          comments(node)
-        end
-      end
-
       def visit_defined(node)
         node(node, "defined") do
           field("value", node.value)
@@ -343,41 +331,6 @@ module SyntaxTree
         end
       end
 
-      def visit_defs(node)
-        node(node, "defs") do
-          field("target", node.target)
-          field("operator", node.operator)
-          field("name", node.name)
-          field("params", node.params)
-          field("bodystmt", node.bodystmt)
-          comments(node)
-        end
-      end
-
-      def visit_do_block(node)
-        node(node, "do_block") do
-          field("block_var", node.block_var) if node.block_var
-          field("bodystmt", node.bodystmt)
-          comments(node)
-        end
-      end
-
-      def visit_dot2(node)
-        node(node, "dot2") do
-          field("left", node.left) if node.left
-          field("right", node.right) if node.right
-          comments(node)
-        end
-      end
-
-      def visit_dot3(node)
-        node(node, "dot3") do
-          field("left", node.left) if node.left
-          field("right", node.right) if node.right
-          comments(node)
-        end
-      end
-
       def visit_dyna_symbol(node)
         node(node, "dyna_symbol") do
           list("parts", node.parts)
@@ -435,14 +388,6 @@ module SyntaxTree
         visit_token(node, "excessed_comma")
       end
 
-      def visit_fcall(node)
-        node(node, "fcall") do
-          field("value", node.value)
-          field("arguments", node.arguments) if node.arguments
-          comments(node)
-        end
-      end
-
       def visit_field(node)
         node(node, "field") do
           field("parent", node.parent)
@@ -523,14 +468,6 @@ module SyntaxTree
         end
       end
 
-      def visit_if_mod(node)
-        node(node, "if_mod") do
-          field("statement", node.statement)
-          field("predicate", node.predicate)
-          comments(node)
-        end
-      end
-
       def visit_if_op(node)
         node(node, "if_op") do
           field("predicate", node.predicate)
@@ -747,6 +684,15 @@ module SyntaxTree
         node(node, "qwords_beg") { field("value", node.value) }
       end
 
+      def visit_range(node)
+        node(node, "range") do
+          field("left", node.left) if node.left
+          field("operator", node.operator)
+          field("right", node.right) if node.right
+          comments(node)
+        end
+      end
+
       def visit_rassign(node)
         node(node, "rassign") do
           field("value", node.value)
@@ -769,7 +715,7 @@ module SyntaxTree
       end
 
       def visit_redo(node)
-        visit_token(node, "redo")
+        node(node, "redo") { comments(node) }
       end
 
       def visit_regexp_beg(node)
@@ -825,7 +771,7 @@ module SyntaxTree
       end
 
       def visit_retry(node)
-        visit_token(node, "retry")
+        node(node, "retry") { comments(node) }
       end
 
       def visit_return(node)
@@ -835,10 +781,6 @@ module SyntaxTree
         end
       end
 
-      def visit_return0(node)
-        visit_token(node, "return0")
-      end
-
       def visit_rparen(node)
         node(node, "rparen") { field("value", node.value) }
       end
@@ -982,14 +924,6 @@ module SyntaxTree
         end
       end
 
-      def visit_unless_mod(node)
-        node(node, "unless_mod") do
-          field("statement", node.statement)
-          field("predicate", node.predicate)
-          comments(node)
-        end
-      end
-
       def visit_until(node)
         node(node, "until") do
           field("predicate", node.predicate)
@@ -998,22 +932,6 @@ module SyntaxTree
         end
       end
 
-      def visit_until_mod(node)
-        node(node, "until_mod") do
-          field("statement", node.statement)
-          field("predicate", node.predicate)
-          comments(node)
-        end
-      end
-
-      def visit_var_alias(node)
-        node(node, "var_alias") do
-          field("left", node.left)
-          field("right", node.right)
-          comments(node)
-        end
-      end
-
       def visit_var_field(node)
         node(node, "var_field") do
           field("value", node.value)
@@ -1056,14 +974,6 @@ module SyntaxTree
         end
       end
 
-      def visit_while_mod(node)
-        node(node, "while_mod") do
-          field("statement", node.statement)
-          field("predicate", node.predicate)
-          comments(node)
-        end
-      end
-
       def visit_word(node)
         node(node, "word") do
           list("parts", node.parts)
@@ -1100,12 +1010,8 @@ module SyntaxTree
         end
       end
 
-      def visit_yield0(node)
-        visit_token(node, "yield0")
-      end
-
       def visit_zsuper(node)
-        visit_token(node, "zsuper")
+        node(node, "zsuper") { comments(node) }
       end
 
       def visit___end__(node)