rust-merge 7.1.1 → 7.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1dfc835a820ae028e33c90465264b92dc88cd4cdf34438a2f0ba6764cce2767f
-  data.tar.gz: a93887e99883c9407d844fff137fd1481ba63ab0954c0323e5083239f6180d9e
+  metadata.gz: aef016d95324b777f2300aa31db682b1cb717ea3ade223d5f44058e0f8c42428
+  data.tar.gz: 2a97cb609a0a13efa790fec5a8a7bd76feff180babd2932c7751ed0d0bed3209
 SHA512:
-  metadata.gz: 5c5322b6242de321539d64c67357d99c14de95da18869a06c1580d58dbc42b827589ae0d7e45ab58c0f8bfba66139f137eea095ae848f7bad7ec07bbbb425664
-  data.tar.gz: 7be12db8ca09e406f25efbccdc4d72440955eecc1567694678b4798e09a9afd8d1da68eceef3de4e3e22c135820ce062b0c069b7a8a55ad6ab54cfd397001374
+  metadata.gz: 2fc3aa2c3a852d2bd196b2a963fda2b3f3a890e4cf6a27270b4311ab0bb70c7ff7d6357cd9ba8ed6b7859bd9b290d35bc0bfd2c2b43471955b602127b5bd74fe
+  data.tar.gz: 7ee67c2c39b1fad125389987ab0341de1f0fdf0e95d9cf3e4ed9627cc84c9f7d37ddbd15ad6b116569f951b1b0c0b1669612c5fe513cfc2da76b3905d2827cd2

data/README.md

@@ -45,7 +45,7 @@ I've summarized my thoughts in [this blog post](https://dev.to/galtzo/hostile-ta
 
 ### Compatibility
 
-Compatible with MRI Ruby 4.0.0+, and concordant releases of JRuby, and TruffleRuby.
+Compatible with MRI Ruby 4.0.0+, JRuby, and TruffleRuby.
 CI workflows and Appraisals are generated for MRI Ruby 4.0.0+.
 This test floor is configured by `ruby.test_minimum` in `.kettle-jem.yml` and
 may be higher than the gem's runtime compatibility floor when legacy Rubies are
@@ -119,20 +119,12 @@ See [SECURITY.md][🔐security].
 ## 🤝 Contributing
 
 If you need some ideas of where to help, you could work on adding more code coverage,
-or if it is already 💯 (see [below](#code-coverage)) check [issues][🤝gh-issues] or [PRs][🤝gh-pulls],
-or use the gem and think about how it could be better.
+check [issues][🤝gh-issues] or [PRs][🤝gh-pulls], or use the gem and think about how it could be better.
 
 We [![Keep A Changelog][📗keep-changelog-img]][📗keep-changelog] so if you make changes, remember to update it.
 
 See [CONTRIBUTING.md][🤝contributing] for more detailed instructions.
 
-### Code Coverage
-
-<details markdown="1">
-<summary>Coverage service badges</summary>
-
-</details>
-
 ## 📌 Versioning
 
 This library follows [![Semantic Versioning 2.0.0][📌semver-img]][📌semver] for its public API where practical.

data/lib/rust/merge/file_analysis.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Rust
+  module Merge
+    # Native TreeHaver analysis of safely attributable top-level Rust items.
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity -- one AST pass establishes ordered ownership and attribute/comment attachment
+    class FileAnalysis
+      attr_reader :source, :root_node, :declarations, :errors, :backend
+
+      def initialize(source)
+        @source = source
+        @backend = TREE_SITTER_BACKEND.id.to_sym
+        @errors = []
+        parse!
+      rescue StandardError => e
+        @root_node = nil
+        @declarations = [].freeze
+        @errors = [e].freeze
+      end
+
+      private
+
+      def parse!
+        @root_node = TreeHaver.parser_for(:rust, backend_type: :tree_sitter).parse(source).root_node
+        raise TreeHaver::NotAvailable, 'Rust parse returned no root node' unless root_node
+        raise TreeHaver::NotAvailable, 'Rust parse contains syntax errors' if root_node.has_error?
+
+        wrappers = []
+        pending = []
+        root_node.children.each do |node|
+          if attachable?(node)
+            if comment?(node) && trailing_comment?(wrappers.last, node)
+              wrappers.last.attach_trailing_comment!(node)
+            else
+              pending << node
+            end
+            next
+          end
+          if NodeWrapper::DECLARATION_TYPES.include?(node.type)
+            wrappers << NodeWrapper.new(node, source: source, leading_comments: attached_prefix(pending, node))
+            pending.clear
+          elsif globally_unmanaged?(node)
+            pending.clear
+          elsif node.named?
+            raise TreeHaver::NotAvailable, "Unmanaged top-level Rust node #{node.type.inspect}"
+          end
+        end
+        @declarations = wrappers.freeze
+      end
+
+      def attachable?(node)
+        comment?(node) || NodeWrapper::ATTRIBUTE_TYPES.include?(node.type)
+      end
+
+      def comment?(node) = NodeWrapper::COMMENT_TYPES.include?(node.type)
+
+      def globally_unmanaged?(node)
+        %w[inner_attribute_item shebang].include?(node.type)
+      end
+
+      def trailing_comment?(owner, comment)
+        owner && whitespace_only?(source.byteslice(owner.end_byte...comment.start_byte).to_s) &&
+          source.byteslice(owner.end_byte...comment.start_byte).to_s.count("\n").zero?
+      end
+
+      def attached_prefix(items, owner)
+        attached = []
+        cursor = owner.start_byte
+        items.reverse_each do |item|
+          gap = source.byteslice(item.end_byte...cursor).to_s
+          break unless whitespace_only?(gap)
+          break if gap.count("\n") > 1 && !structural_attribute?(item)
+
+          attached.unshift(item)
+          cursor = item.start_byte
+        end
+        attached.freeze
+      end
+
+      def structural_attribute?(item)
+        return true if NodeWrapper::ATTRIBUTE_TYPES.include?(item.type)
+
+        !find_descendant(item, 'outer_doc_comment_marker').nil?
+      end
+
+      def find_descendant(parent, type)
+        return parent if parent.type == type
+
+        parent.children.each do |child|
+          found = find_descendant(child, type)
+          return found if found
+        end
+        nil
+      end
+
+      def whitespace_only?(value)
+        value.each_byte.all? { |byte| [9, 10, 13, 32].include?(byte) }
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+  end
+end

data/lib/rust/merge/node_wrapper.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module Rust
+  module Merge
+    # Structural identity and source-range adapter for one top-level Rust item.
+    # rubocop:disable Metrics/AbcSize, Metrics/ClassLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity -- Rust item forms share one structural identity boundary
+    class NodeWrapper
+      DECLARATION_TYPES = %w[
+        const_item
+        enum_item
+        expression_statement
+        extern_crate_declaration
+        function_item
+        impl_item
+        macro_definition
+        mod_item
+        static_item
+        struct_item
+        trait_item
+        type_item
+        union_item
+        use_declaration
+      ].freeze
+      NAMED_ITEMS = {
+        'const_item' => [:const, %w[identifier]],
+        'enum_item' => [:enum, %w[type_identifier]],
+        'function_item' => [:function, %w[identifier]],
+        'macro_definition' => [:macro, %w[identifier]],
+        'mod_item' => [:module, %w[identifier]],
+        'static_item' => [:static, %w[identifier]],
+        'struct_item' => [:struct, %w[type_identifier]],
+        'trait_item' => [:trait, %w[type_identifier]],
+        'type_item' => [:type, %w[type_identifier]],
+        'union_item' => [:union, %w[type_identifier]]
+      }.freeze
+      COMMENT_TYPES = %w[block_comment line_comment].freeze
+      ATTRIBUTE_TYPES = %w[attribute_item].freeze
+
+      attr_reader :node, :source, :leading_comments, :trailing_comments
+
+      def initialize(node, source:, leading_comments: [])
+        @node = node
+        @source = source
+        @leading_comments = leading_comments.freeze
+        @trailing_comments = []
+      end
+
+      def signature
+        value = case node.type
+                when 'use_declaration' then use_signature
+                when 'extern_crate_declaration' then extern_crate_signature
+                when 'impl_item' then impl_signature
+                when 'expression_statement' then macro_invocation_signature
+                else named_signature(node)
+                end
+        value.freeze
+      end
+
+      def membership_signature
+        return semantic_node(use_body) if compound_use?
+
+        signature
+      end
+
+      def compound? = compound_use?
+      def start_byte = leading_comments.first&.start_byte || node.start_byte
+      def end_byte = trailing_comments.last&.end_byte || node.end_byte
+      def start_line = line_for_byte(start_byte)
+      def end_line = line_for_byte(end_byte.zero? ? 0 : end_byte - 1)
+      def source_text = source.byteslice(start_byte...end_byte).to_s
+      def attach_trailing_comment!(comment) = trailing_comments << comment
+      def semantic_tree = semantic_node(node)
+
+      private
+
+      def named_signature(value)
+        kind, name_types = NAMED_ITEMS.fetch(value.type) do
+          raise ArgumentError, "Unsupported top-level Rust node #{value.type.inspect}"
+        end
+        name = direct_named_child(value, name_types)
+        raise ArgumentError, "#{value.type} has no structurally attributable name" unless name
+
+        [kind, text(name)]
+      end
+
+      def use_signature
+        body = use_body
+        return [:use_tree, use_tree_root(body)] if compound_use?
+
+        [:use, use_target(body)]
+      end
+
+      def use_body
+        node.children.find do |child|
+          child.named? && child.type != 'visibility_modifier'
+        end || raise(ArgumentError, 'use declaration has no structural tree')
+      end
+
+      def compound_use?
+        node.type == 'use_declaration' && !find_descendant(use_body, %w[use_list]).nil?
+      end
+
+      def use_tree_root(body)
+        return :root if body.type == 'use_list'
+
+        child = body.children.find { |candidate| candidate.named? && candidate.type != 'use_list' }
+        raise ArgumentError, 'compound use tree has no structural root' unless child
+
+        path_head(child)
+      end
+
+      def use_target(body)
+        case body.type
+        when 'use_as_clause'
+          target = body.children.find(&:named?)
+          raise ArgumentError, 'use alias has no structural target' unless target
+
+          path_head(target)
+        when 'scoped_identifier'
+          path_head(body)
+        when 'use_wildcard'
+          [:wildcard, path_head(body)]
+        when 'identifier', 'self', 'super', 'crate'
+          text(body)
+        else
+          [:tree, semantic_node(body)]
+        end
+      end
+
+      def extern_crate_signature
+        identifiers = node.children.select { |child| child.type == 'identifier' }
+        raise ArgumentError, 'extern crate declaration has no crate name' if identifiers.empty?
+
+        [:extern_crate, text(identifiers.first)]
+      end
+
+      def impl_signature
+        children = node.children
+        for_index = children.index { |child| child.type == 'for' }
+        type_nodes = children.select { |child| rust_type_node?(child) }
+        target = for_index ? children[(for_index + 1)..].find { |child| rust_type_node?(child) } : type_nodes.last
+        trait = for_index && children[...for_index].reverse.find { |child| rust_type_node?(child) }
+        raise ArgumentError, 'impl item has no structural target' unless target
+
+        polarity = children.any? { |child| child.type == '!' } ? :negative : :positive
+        [:impl, trait && path_head(trait), path_head(target), polarity, generic_arity]
+      end
+
+      def generic_arity
+        parameters = node.children.find { |child| child.type == 'type_parameters' }
+        return 0 unless parameters
+
+        parameters.children.count do |child|
+          %w[type_parameter lifetime_parameter const_parameter].include?(child.type)
+        end
+      end
+
+      def rust_type_node?(value)
+        return false unless value.named?
+
+        excluded = %w[type_parameters where_clause declaration_list visibility_modifier] +
+                   COMMENT_TYPES + ATTRIBUTE_TYPES
+        !excluded.include?(value.type)
+      end
+
+      def macro_invocation_signature
+        invocation = node.children.find { |child| child.type == 'macro_invocation' }
+        raise ArgumentError, 'expression statement is not a top-level macro invocation' unless invocation
+
+        path = invocation.children.find do |child|
+          %w[identifier scoped_identifier].include?(child.type)
+        end
+        raise ArgumentError, 'macro invocation has no structural path' unless path
+
+        [:macro_invocation, path_head(path)]
+      end
+
+      def path_head(value)
+        case value.type
+        when 'generic_type', 'reference_type', 'pointer_type'
+          child = value.children.find(&:named?)
+          child ? path_head(child) : value.type
+        when 'scoped_identifier', 'scoped_type_identifier'
+          value.children.select(&:named?).map { |child| path_head(child) }
+        when 'use_wildcard'
+          child = value.children.find(&:named?)
+          child ? path_head(child) : :wildcard
+        else
+          text(value)
+        end
+      end
+
+      def direct_named_child(parent, types)
+        parent.children.find { |candidate| types.include?(candidate.type) }
+      end
+
+      def find_descendant(parent, types)
+        return parent if types.include?(parent.type)
+
+        parent.children.each do |child|
+          found = find_descendant(child, types)
+          return found if found
+        end
+        nil
+      end
+
+      def semantic_node(value)
+        children = value.children
+        return [value.type, text(value)] if children.empty?
+
+        [value.type, children.select(&:named?).map { |child| semantic_node(child) }]
+      end
+
+      def text(value) = source.byteslice(value.start_byte...value.end_byte).to_s
+      def line_for_byte(byte) = source.byteslice(0...byte).to_s.count("\n") + 1
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/ClassLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+  end
+end