ast-merge 7.1.9 → 7.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04bdf1ce1f71ec916ca922099d490d0fe67091d20c7a8114dc1b62fedd2a8d5f
-  data.tar.gz: 722576217cd11484781d8ff0e86ec00ad854a359df87c116749fc33cc369154f
+  metadata.gz: 54246c2a0a295278fc701f94b29176973d1a12f0a7241b82d0e0a9490cb4248d
+  data.tar.gz: 598d2c26c795c77e0d66d4105885210b0908755aa97e69155e7a8c3a7b1af853
 SHA512:
-  metadata.gz: e13565697fb9d3304133b1a3673723d038c1985165c7e2fd7742edfb62bdbc1edf575ba37930a05e3dbfcd25696abd0d5a27efcea8eef1ada2658d33d7ee2a16
-  data.tar.gz: c05d2fa15953c8158ff8a7bfa08a6a239265b4388593be42b4a4f7cac3b9852862fc878446e96d5c96deb56ec456b50033b59827bef7793c0e3044376321177c
+  metadata.gz: 570d218b5cb765f6d61f4bc7169ee1ffca21a032b61ee408e6556b285223a55715486387cb0f73d99abd7d3388bbec67e484f3407f0a2d1adc7fe224c15b26c7
+  data.tar.gz: c7868ee942c0a708f8af61c1020b1957433ca8715ee16e4a0c0506ccb5a5f5b8f26a9c9c63cc9f14fb5517147a0e1c504292a397cbdbba494126003dd57213ce

data/lib/ast/merge/provider_contract.rb

@@ -133,9 +133,9 @@ module Ast
         operations = normalize_identifiers(values)
         unknown = operations - OPERATIONS
         raise InvalidProviderError, "Unknown provider operations: #{unknown.join(', ')}" unless unknown.empty?
-        unless operations.sort == OPERATIONS.sort
-          raise InvalidProviderError, "Provider must implement all operations: #{OPERATIONS.join(', ')}"
-        end
+        # Methods remain required so direct unsupported calls fail consistently;
+        # advertised capabilities must reflect only implemented operations.
+        raise InvalidProviderError, 'Provider must advertise at least one operation' if operations.empty?
 
         operations
       end

data/lib/ast/merge/rust_host_provider.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+require 'json'
+
+# rubocop:disable Metrics/AbcSize, Metrics/ClassLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/ParameterLists, Metrics/PerceivedComplexity
+
+module Ast
+  module Merge
+    # Opt-in provider adapter for operations implemented by the compiled Rust
+    # host. Concrete format gems supply the host method names and metadata.
+    class RustHostProvider
+      class << self
+        def available?(required_methods = [])
+          require 'structuredmerge_core' unless defined?(::StructuredmergeCore)
+          required_methods.all? { |method_name| ::StructuredmergeCore.respond_to?(method_name) }
+        rescue LoadError
+          false
+        end
+      end
+
+      def initialize(provider_id:, family:, dialect:, package:, package_version:, host_methods:)
+        @provider_id = provider_id
+        @family = family
+        @dialect = dialect
+        @package = package
+        @package_version = package_version
+        @host_methods = host_methods.freeze
+      end
+
+      attr_reader :provider_id, :family
+
+      def capabilities
+        {
+          operations: ProviderContract::OPERATIONS,
+          dialects: [@dialect],
+          backends: [:rust_tslp],
+          profiles: [:source_preserving],
+          role: :workflow,
+          source_preservation: %i[exact_source declaration_fragments line_provenance reparse]
+        }.freeze
+      end
+
+      def analyze(request)
+        raw = call_host(:analyze, request.fetch(:source), request.fetch(:dialect).to_s)
+        return failure(:analyze, request, raw) unless raw.fetch('ok')
+
+        analysis = raw.fetch('analysis')
+        owners = Array(analysis['declarations'])
+        owners = Array(analysis['owners']) if owners.empty?
+        success(
+          :analyze,
+          request,
+          analysis: {
+            backend: :rust_tslp,
+            valid: true,
+            declarations: owners.map do |owner|
+              {
+                path: logical_owner_path(owner),
+                signature: logical_owner_path(owner),
+                source_role: :source,
+                line_range: owner.fetch('line_range', line_range(request.fetch(:source), owner['source_fragment']))
+              }
+            end
+          },
+          verification: { source_parsed: true, rust_host: true }
+        )
+      rescue KeyError, JSON::ParserError => e
+        failure(:analyze, request, error_payload('parse_error', e.message, 'source'))
+      end
+
+      def diff2(request)
+        before = analysis_for(request.fetch(:before_source), request.fetch(:dialect).to_s)
+        return failure(:diff2, request, before) unless before.fetch('ok')
+
+        after = analysis_for(request.fetch(:after_source), request.fetch(:dialect).to_s)
+        return failure(:diff2, request, after) unless after.fetch('ok')
+
+        before_owners = owner_map(
+          before,
+          source: request.fetch(:before_source),
+          source_role: :before
+        )
+        after_owners = owner_map(
+          after,
+          source: request.fetch(:after_source),
+          source_role: :after
+        )
+        changes = (before_owners.keys | after_owners.keys).filter_map do |path|
+          before_owner = before_owners[path]
+          after_owner = after_owners[path]
+          next if same_owner?(before_owner, after_owner)
+
+          change = if before_owners.key?(path)
+                     after_owners.key?(path) ? :edited : :deleted
+                   else
+                     :added
+                   end
+          {
+            path: path,
+            before: revision_record(before_owner, :before),
+            after: revision_record(after_owner, :after),
+            change: change
+          }
+        end
+        success(
+          :diff2,
+          request,
+          envelope: {
+            changes: changes,
+            verification: { before_parsed: true, after_parsed: true, rust_host: true }
+          },
+          diff: { changes: changes }
+        )
+      rescue KeyError, JSON::ParserError => e
+        failure(:diff2, request, error_payload('parse_error', e.message, 'source'))
+      end
+
+      def merge2(request)
+        raw = call_host(
+          :merge2,
+          request.fetch(:current_source),
+          request.fetch(:incoming_source),
+          request.fetch(:dialect).to_s
+        )
+        merge_result(:merge2, request, raw)
+      rescue KeyError, JSON::ParserError => e
+        failure(:merge2, request, error_payload('parse_error', e.message, 'source'))
+      end
+
+      def merge3(request)
+        raw = call_host(
+          :merge3,
+          request.fetch(:base_source),
+          request.fetch(:ours_source),
+          request.fetch(:theirs_source),
+          request.fetch(:dialect).to_s
+        )
+        merge_result(:merge3, request, raw)
+      rescue KeyError, JSON::ParserError => e
+        failure(:merge3, request, error_payload('parse_error', e.message, 'source'))
+      end
+
+      private
+
+      def host
+        require 'structuredmerge_core' unless defined?(::StructuredmergeCore)
+        ::StructuredmergeCore
+      end
+
+      def call_host(operation, *args)
+        JSON.parse(host.public_send(@host_methods.fetch(operation), *args))
+      end
+
+      def analysis_for(source, dialect)
+        call_host(:analyze, source, dialect)
+      end
+
+      def owner_map(raw, source:, source_role:)
+        analysis = raw.fetch('analysis')
+        declarations = Array(analysis['declarations'])
+        unless declarations.empty?
+          return declarations.to_h do |declaration|
+            path = logical_owner_path(declaration)
+            [path, declaration.merge(
+              'path' => path,
+              'line_range' => line_range(source, declaration['text'] || declaration['source_fragment']),
+              'source_role' => source_role
+            )]
+          end
+        end
+
+        analysis.fetch('owners').to_h do |owner|
+          path = logical_owner_path(owner)
+          [path, owner.merge(
+            'path' => path,
+            'line_range' => line_range(source, owner['text'] || owner['source_fragment']),
+            'source_role' => source_role
+          )]
+        end
+      end
+
+      def same_owner?(before_owner, after_owner)
+        return true if before_owner.nil? && after_owner.nil?
+        return false if before_owner.nil? || after_owner.nil?
+
+        if before_owner.key?('text') || after_owner.key?('text') ||
+           before_owner.key?('source_fragment') || after_owner.key?('source_fragment')
+          (before_owner['text'] || before_owner['source_fragment']) ==
+            (after_owner['text'] || after_owner['source_fragment'])
+        else
+          before_owner == after_owner
+        end
+      end
+
+      def revision_record(owner, source_role)
+        return { present: false, source_role: source_role, line_range: [nil, nil] } unless owner
+
+        { present: true, source_role: source_role, line_range: owner.fetch('line_range', [nil, nil]) }
+      end
+
+      def line_range(source, fragment)
+        return [nil, nil] if fragment.nil?
+
+        # Host declaration fragments include their terminating newline. The
+        # public provider contract reports the declaration's content lines,
+        # not the separator owned by the following region.
+        content = fragment.sub(/\r?\n+\z/, '')
+        start = source.index(fragment)
+        return [nil, nil] unless start
+
+        end_index = start + content.length
+        start_line = source[0...start].count("\n") + 1
+        end_line = source[0...end_index].count("\n") + 1
+        [start_line, end_line]
+      end
+
+      def logical_owner_path(owner)
+        match_key = owner['match_key']
+        return owner.fetch('path') if match_key.nil? || match_key.empty?
+
+        kind = if owner['declaration_kind']
+                 owner['declaration_kind']
+               elsif owner['owner_kind'].nil? || owner['owner_kind'] == 'declaration'
+                 'function'
+               else
+                 owner.fetch('owner_kind')
+               end
+        "[:#{kind}, #{match_key.inspect}]"
+      end
+
+      def merge_result(operation, request, raw)
+        diagnostics = raw.fetch('diagnostics', []).map { |diagnostic| normalize_diagnostic(diagnostic) }
+        conflicts = raw.fetch('conflicts', [])
+        success = operation == :merge2 ? raw.fetch('ok') : raw.fetch('outcome') == 'clean'
+        envelope = {
+          provider: provider_metadata(request),
+          profile: { profile_id: request[:profile_id] || :source_preserving },
+          diagnostics: diagnostics,
+          conflicts: conflicts,
+          verification: {
+            rust_host: true,
+            source_preserving: true,
+            base_participated: operation == :merge3
+          }
+        }
+        ProviderResult.build(operation: operation, success: success, envelope: envelope, output: raw['output'])
+      end
+
+      def success(operation, request, envelope: {}, **payload)
+        ProviderResult.build(operation: operation, success: true, envelope: {
+          provider: provider_metadata(request),
+          profile: { profile_id: request[:profile_id] || :source_preserving },
+          verification: payload.delete(:verification) || {}
+        }.merge(envelope), **payload)
+      end
+
+      def failure(operation, request, raw)
+        diagnostics = Array(raw['diagnostics']).map { |diagnostic| normalize_diagnostic(diagnostic) }
+        diagnostics = [normalize_diagnostic(raw)] if diagnostics.empty?
+        ProviderResult.build(
+          operation: operation,
+          success: false,
+          envelope: {
+            provider: provider_metadata(request),
+            profile: { profile_id: request[:profile_id] || :source_preserving },
+            diagnostics: diagnostics,
+            verification: { rust_host: true }
+          }
+        )
+      end
+
+      def error_payload(category, message, source_role)
+        {
+          'diagnostics' => [{
+            'category' => category,
+            'message' => "#{source_role} parse error: #{message}",
+            'severity' => 'error'
+          }]
+        }
+      end
+
+      def normalize_diagnostic(diagnostic)
+        diagnostic.transform_keys(&:to_sym).merge(
+          category: diagnostic.fetch('category', 'parse_error').to_sym,
+          severity: diagnostic.fetch('severity', 'error').to_sym,
+          blocking: true
+        )
+      end
+
+      def provider_metadata(request)
+        {
+          provider_id: provider_id,
+          family: family,
+          dialect: request[:dialect] || @dialect,
+          backend: :rust_tslp,
+          package: @package,
+          package_version: @package_version
+        }
+      end
+    end
+  end
+end
+
+# rubocop:enable Metrics/AbcSize, Metrics/ClassLength, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/ParameterLists, Metrics/PerceivedComplexity

data/lib/ast/merge/structural_edit/README.md

@@ -61,6 +61,17 @@ It keeps the source-preserving removal behavior passive while also recording:
 - which adjacent owners survived
 - which removed comment/layout attachments should be promoted rather than dropped
 
+Blank lines at the junction are capped rather than preserved. Removal's
+replacement is always empty, so nothing needs separating from the content that
+follows, and the blank run that preceded the removed range already separates the
+survivors. Re-emitting the removed owner's trailing separator would either
+duplicate it, giving two blank lines at a junction where the source had one, or
+invent a leading blank line when the range started the file. `SplicePlan`
+therefore ignores `preserve_removed_trailing_blank_lines` for an empty
+replacement, and caps any remaining junction run at the longest single
+contributing run so a genuine multi-blank separator that lies outside the removed
+range survives intact.
+
 Minimal example:
 
 ```ruby

data/lib/ast/merge/structural_edit/blank_line_support.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Ast
+  module Merge
+    module StructuralEdit
+      # Blank-line invariants for structural splices and removals.
+      #
+      # This module owns the separator arithmetic a splice must respect so that
+      # editing a line range cannot invent blank lines the source never had. It
+      # stays parser-agnostic, working purely on source text the same way
+      # +BoundarySupport+ works purely on line ranges and attachments.
+      #
+      # The two rules here are complementary:
+      #
+      # - {#missing_trailing_blank_line_chunks} decides which trailing blanks a
+      #   replacement should re-emit so it is not left butting against the
+      #   following content.
+      # - {#cap_junction_blank_runs} then limits the blank run formed where the
+      #   spliced head meets the untouched tail, so the two sides of a junction
+      #   never stack into a longer run than either had.
+      #
+      # Removal is what makes both rules necessary. A replacement supplies its own
+      # text, so the head usually ends in content and no junction run forms.
+      # Deletion supplies none, which is exactly when separators on both sides of
+      # the removed range become adjacent.
+      module BlankLineSupport
+        module_function
+
+        # Trailing blank lines of +text+, as an array of line chunks.
+        #
+        # The chunks keep their trailing newlines so callers can rejoin them
+        # losslessly.
+        #
+        # @param text [String] source fragment
+        # @return [Array<String>] trailing blank lines, in source order
+        def trailing_blank_line_chunks(text)
+          text.lines.reverse.take_while { |line| line.strip.empty? }.reverse
+        end
+
+        # Leading blank lines of +text+.
+        #
+        # @param text [String] source fragment
+        # @return [Array<String>] leading blank lines, in source order
+        def leading_blank_line_chunks(text)
+          text.lines.take_while { |line| line.strip.empty? }
+        end
+
+        # Trailing blanks from a removed range that a replacement should re-emit,
+        # so the replacement is not left butting against the following content.
+        #
+        # Returns nothing when the replacement already ends in at least as many
+        # blanks as the removed range did, or when the tail opens with a blank and
+        # so needs no separator.
+        #
+        # @param removed_content [String] source removed by the splice
+        # @param replacement [String] text substituted for the removed range
+        # @param after_content [String] untouched source following the range
+        # @return [Array<String>] trailing blank chunks to append to the replacement
+        def missing_trailing_blank_line_chunks(removed_content:, replacement:, after_content:)
+          removed_chunks = trailing_blank_line_chunks(removed_content)
+          kept_chunks = trailing_blank_line_chunks(replacement)
+          return [] if removed_chunks.empty?
+          return [] if kept_chunks.length >= removed_chunks.length
+          return [] if after_content.start_with?("\n")
+
+          removed_chunks[kept_chunks.length..]
+        end
+
+        # Cap the blank-line run formed where a spliced head meets the untouched
+        # tail, so a splice never emits a longer run than any single contributor
+        # already had.
+        #
+        # Capping at the longest contributing run rather than at one is what keeps
+        # a source that genuinely separates sections with two blanks intact, and
+        # leaves in-place replacement unaffected, since its head ends with the
+        # replacement text and forms no junction run at all. This mirrors the
+        # excess-blank trimming the *-merge emitters already perform, keeping one
+        # rule across the stack instead of a second, weaker one for structural
+        # edits.
+        #
+        # This is a line-count invariant, not full blank-line ownership.
+        # Layout::Gap#effective_controller can attribute a shared gap to a
+        # surviving owner, but only where the analysis populates gaps. Psych-backed
+        # analyses report empty layout attachments for nested mapping entries, so
+        # ownership has no data to consult there. Wiring gap ownership into removal
+        # needs gap population for those owners first.
+        #
+        # @param head [String] spliced source up to the junction
+        # @param tail [String] untouched source after the junction
+        # @param preserved_count [Integer] blanks appended to the replacement
+        # @param before_content [String] untouched source before the range
+        # @param replacement [String] text substituted for the removed range
+        # @return [String] head and tail joined with the junction run capped
+        def cap_junction_blank_runs(head:, tail:, preserved_count:, before_content:, replacement:)
+          trailing_run = trailing_blank_line_chunks(head).length
+          return head + tail if tail.empty? || trailing_run.zero?
+
+          leading_run = leading_blank_line_chunks(tail).length
+          allowed = max_contributing_blank_run(before_content, replacement, preserved_count, leading_run)
+          excess = (trailing_run + leading_run) - allowed
+          return head + tail unless excess.positive?
+
+          # +allowed+ counts +leading_run+ among the contributors, so
+          # +excess+ is always at most +trailing_run+ and never pops past the
+          # head's own blanks. +trailing_run+ is nonzero because of the guard above.
+          pop_blank_lines(head, count: excess) + tail
+        end
+
+        # Longest blank run any single contributor brings to a junction.
+        #
+        # The contributors are the blanks before the range, the blanks the
+        # replacement itself ends with, the blanks preserved from the removed
+        # range, and the blanks the tail opens with.
+        #
+        # @return [Integer]
+        # @api private
+        def max_contributing_blank_run(before_content, replacement, preserved_count, leading_run)
+          [
+            trailing_blank_line_chunks(before_content).length,
+            trailing_blank_line_chunks(replacement).length,
+            preserved_count,
+            leading_run
+          ].max
+        end
+
+        # Drop the last +count+ blank lines from +head+.
+        #
+        # @return [String]
+        # @api private
+        def pop_blank_lines(head, count:)
+          head_lines = head.lines
+          head_lines.pop(count)
+          head_lines.join
+        end
+      end
+    end
+  end
+end

data/lib/ast/merge/structural_edit/remove_plan.rb

@@ -24,6 +24,10 @@ module Ast
         # @param metadata [Hash] base metadata
         # @param preserve_removed_trailing_blank_lines [Boolean] whether trailing blank lines should survive in the splice
         # @param options [Hash] extra metadata merged into +metadata+
+        #
+        # @note Removal always passes an empty replacement, so trailing blank
+        #   preservation is not applied; the junction blank run is capped instead.
+        #   See BlankLineSupport.
         def initialize(source:, remove_start_line:, remove_end_line:, leading_boundary: nil, trailing_boundary: nil,
                        removed_attachments: [], removed_owners: nil, retained_owners: nil, metadata: {}, preserve_removed_trailing_blank_lines: true, **options)
           normalized_removed_attachments = Array(removed_attachments).compact.freeze

data/lib/ast/merge/structural_edit/splice_plan.rb

@@ -39,6 +39,12 @@ module Ast
         # @param preserve_removed_trailing_blank_lines [Boolean] whether to preserve trailing blank lines from removed content
         # @param metadata [Hash] base metadata
         # @param options [Hash] extra metadata merged into +metadata+
+        #
+        # @note An empty replacement never preserves trailing blanks: a deletion
+        #   contributes no text to separate from the following content, and the
+        #   blank run preceding the range already separates the survivors. The
+        #   junction blank run is also capped at the longest single contributing
+        #   run. See BlankLineSupport for both rules.
         def initialize(source:, replacement:, replace_start_line:, replace_end_line:, leading_boundary: nil,
                        trailing_boundary: nil, preserve_removed_trailing_blank_lines: true, metadata: {}, **options)
           @source = source.to_s
@@ -92,7 +98,9 @@ module Ast
         #
         # @return [String]
         def merged_content
-          +before_content + replacement_with_preserved_boundary_layout + after_content
+          preserved = preserved_trailing_blank_line_chunks
+          head = +before_content + replacement_with_preserved_boundary_layout(preserved)
+          capped_junction_content(head, after_content, preserved.length)
         end
 
         def changed?
@@ -134,33 +142,52 @@ module Ast
 
         private
 
-        def replacement_with_preserved_boundary_layout
+        def replacement_with_preserved_boundary_layout(preserved_chunks)
           result = +replacement
-
-          result << missing_trailing_blank_line_chunks.join if preserve_removed_trailing_blank_lines?
+          result << preserved_chunks.join unless preserved_chunks.empty?
 
           result
         end
 
-        def preserve_removed_trailing_blank_lines?
-          return false unless preserve_removed_trailing_blank_lines
-
-          !after_content.empty? &&
-            !missing_trailing_blank_line_chunks.empty?
-        end
-
-        def missing_trailing_blank_line_chunks
-          removed_blank_chunks = trailing_blank_line_chunks(removed_content)
-          replacement_blank_chunks = trailing_blank_line_chunks(replacement)
-          return [] if removed_blank_chunks.empty?
-          return [] if replacement_blank_chunks.length >= removed_blank_chunks.length
-          return [] if after_content.start_with?("\n")
-
-          removed_blank_chunks[replacement_blank_chunks.length..]
+        # Trailing blank chunks from the removed range that the replacement should
+        # re-emit, so it is not left butting against the following content.
+        #
+        # An empty replacement preserves nothing: a deletion contributes no text of
+        # its own to separate, and the blank run that preceded the range already
+        # separates the survivors. Re-emitting the removed owner's trailing
+        # separator instead either duplicates it -- two blanks at a junction where
+        # the source had one -- or, when the range starts the file, invents a
+        # leading blank the source never had. Deleting a job from a GitHub Actions
+        # workflow produced the first; deleting a leading block produced the second.
+        def preserved_trailing_blank_line_chunks
+          return [] unless preserve_removed_trailing_blank_lines
+          return [] if replacement.empty?
+          return [] if after_content.empty?
+
+          BlankLineSupport.missing_trailing_blank_line_chunks(
+            removed_content: removed_content,
+            replacement: replacement,
+            after_content: after_content
+          )
         end
 
-        def trailing_blank_line_chunks(text)
-          text.lines.reverse.take_while { |line| line.strip.empty? }.reverse
+        # Cap the blank run where the spliced head meets the untouched tail.
+        #
+        # Removal is what exposes this: a blank on each side of the removed owner
+        # was separated by that owner's own text, and deleting it makes the two
+        # runs adjacent. Observed in both shapes -- removing a Ruby `appraise`
+        # block, whose owner range ends at the statement so the separator on either
+        # side survives, and removing a GitHub Actions job, whose range includes
+        # the job's trailing separator so it stacks on the blank that preceded it.
+        # In each case the source had a single blank and the splice emitted two.
+        def capped_junction_content(head, tail, preserved_count)
+          BlankLineSupport.cap_junction_blank_runs(
+            head: head,
+            tail: tail,
+            preserved_count: preserved_count,
+            before_content: before_content,
+            replacement: replacement
+          )
         end
 
         def validate_range!

data/lib/ast/merge/structural_edit.rb

@@ -8,6 +8,7 @@ module Ast
     # boundaries and splice plans without taking ownership of parser-specific
     # traversal or post-processing behavior.
     module StructuralEdit
+      autoload :BlankLineSupport, 'ast/merge/structural_edit/blank_line_support'
       autoload :BoundarySupport, 'ast/merge/structural_edit/boundary_support'
       autoload :Boundary, 'ast/merge/structural_edit/boundary'
       autoload :PlanSet, 'ast/merge/structural_edit/plan_set'

data/lib/ast/merge/typed_core_provider.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'json'
+
+module Ast
+  module Merge
+    # Shared typed transport adaptation. Subclasses select explicit Rust profiles.
+    class TypedCoreProvider
+      DIALECTS = %i[json jsonc json5].freeze
+      ROLES = { analyze: %i[source], diff2: %i[before after], merge2: %i[incoming current],
+                merge3: %i[base ours theirs] }.freeze
+      VERIFICATION_FIELDS = %i[consumed_source_roles directional_roles_preserved base_participated
+                               classification_reached output_reparsed structural_equivalence preservation retained_source_regions].freeze
+      # Only generated read-only data records are projected. Registry objects,
+      # operation controls and executable handles must never be traversed.
+      DATA_RECORDS = %w[OperationResult ResultProvider ResultProfile ResultParserSelection
+                        ResultVerification PreservationProperty ResultSourceRegion ResultRange ResultSpan ResultPoint
+                        ResultAnalysis ResultDiff ResultChange ResultConflict ResultDiagnostic
+                        DiagnosticRecord PortableDiagnostic DiagnosticOrigin DiagnosticSourceRef DiagnosticSubjectRef
+                        ConflictRecord PortableConflict ConflictSubject ConflictSourceAlternative ConflictClassification
+                        ConflictLocalization ConflictResolution ExactConflictRegion NativeExtension].freeze
+
+      def self.available?
+        require 'structuredmerge_core' unless defined?(::StructuredmergeCore)
+        ::StructuredmergeCore.respond_to?(:execute_operation) && TreeHaver::Backends::RustTslp.available?
+      rescue LoadError
+        false
+      end
+
+      def provider_id = self.class::PROVIDER_ID
+      def family = self.class::FAMILY
+
+      def capabilities
+        { operations: self.class::OPERATIONS, dialects: self.class::DIALECTS, backends: [:rust_tslp],
+          profiles: [:source_preserving], role: :workflow,
+          source_preservation: %i[exact_source byte_spans reparse] }.freeze
+      end
+
+      ROLES.each_key do |operation|
+        define_method(operation) { |request| execute(operation, request) }
+      end
+
+      private
+
+      def core = ::StructuredmergeCore
+
+      def execute(operation, request)
+        unless capabilities[:operations].include?(operation)
+          return Ast::Merge::ProviderResult.unsupported(operation: operation,
+                                                        message: 'Typed profile does not implement this operation')
+        end
+
+        fields = ROLES.fetch(operation).map { |role| role == :source ? :source : :"#{role}_source" }
+        allowed = fields + %i[dialect provider_id family backend profile_id request_id] + additional_fields
+        unless (request.keys - allowed).empty? &&
+               self.class::DIALECTS.include?(request.fetch(:dialect, default_dialect).to_s.to_sym) &&
+               [nil, 'rust_tslp'].include?(request[:backend]&.to_s) &&
+               [nil, 'source_preserving'].include?(request[:profile_id]&.to_s) &&
+               [nil, provider_id].include?(request[:provider_id]) && [nil, family].include?(request[:family]&.to_s)
+          return Ast::Merge::ProviderResult.unsupported(operation: operation,
+                                                        message: 'Typed provider cannot honor the requested fields or selectors')
+        end
+        unless self.class.available?
+          return Ast::Merge::ProviderResult.unsupported(operation: operation,
+                                                        message: 'structuredmerge-core is unavailable')
+        end
+
+        dialect = request.fetch(:dialect, default_dialect).to_s
+        parser_id = TreeHaver::Backends::RustTslp.register_language_parser(parser_language(dialect))
+        sources = ROLES.fetch(operation).zip(fields).to_h do |role, field|
+          text = request.fetch(field)
+          unless text.is_a?(String) && [Encoding::UTF_8, Encoding::US_ASCII, Encoding::ASCII_8BIT].include?(text.encoding)
+            raise ArgumentError, 'Source must contain UTF-8 bytes'
+          end
+
+          text = text.dup.force_encoding(Encoding::UTF_8)
+          raise ArgumentError, 'Source must be valid UTF-8' unless text.valid_encoding?
+
+          text.freeze
+          [role, core::OperationSource.new(source_id: role.to_s, role: role, content: text,
+                                           encoding: 'utf-8', byte_length: text.bytesize, sha256: Digest::SHA256.hexdigest(text), extra: {})]
+        end
+        typed_request = core::OperationRequest.new(schema: 'structuredmerge.operation-request/v1',
+                                                   request_id: request[:request_id] || "ruby-#{provider_id}-#{operation}", operation: policy(operation, request), sources: sources,
+                                                   provider_selection: core::MergeProviderSelection.new(provider_id: self.class::CORE_PROVIDER, family: family,
+                                                                                                        dialect: dialect, profile_id: self.class::CORE_PROFILE, required_capabilities: [operation.to_s], extra: {}),
+                                                   parser_selection: core::OperationParserSelection.new(backend: parser_id, preference: [], required_capabilities: [], extra: {}),
+                                                   extensions: [], metadata: {}, extra: {})
+        result = core.execute_operation(typed_request,
+                                        core::ParseLimits.new(max_batch_items: 3, max_input_bytes: 64 * 1024 * 1024, max_nodes: 1_000_000,
+                                                              max_diagnostics: 1000))
+        project(operation, request, result)
+      rescue KeyError, ArgumentError, TypeError, RangeError => e
+        Ast::Merge::ProviderResult.invalid_request(operation: operation, message: e.message)
+      rescue RuntimeError => e
+        Ast::Merge::ProviderResult.build(operation: operation, success: false,
+                                         envelope: { diagnostics: [{ category: :provider_failure, severity: :error, blocking: true, message: e.message }] })
+      end
+
+      def additional_fields = []
+      def default_dialect = self.class::DIALECTS.first
+      def parser_language(dialect) = dialect == 'json' ? 'json' : 'json5'
+      def owner_path(owner) = owner.fetch('path')
+
+      def policy(operation, _request)
+        case operation
+        when :analyze
+          core::OperationPolicy.from_analyze(core::AnalyzePolicy.new(extra: {}))
+        when :diff2
+          core::OperationPolicy.from_diff2(core::DiffPolicy.new(comparison_profile: 'exact-source-owners',
+                                                                equivalence: ['exact-source'], extra: {}))
+        when :merge2
+          core::OperationPolicy.from_merge2(core::DirectionalMergePolicy.new(
+                                              directional_merge: 'template-into-current', render_policy: 'source-preserving', extra: {}
+                                            ))
+        when :merge3
+          core::OperationPolicy.from_merge3(core::ThreeWayMergePolicy.new(render_policy: 'source-preserving',
+                                                                          fallback_policy: 'none', extra: {}))
+        end
+      end
+
+      # Only open metadata values are encoded by the generated binding; never
+      # send or decode a whole-operation JSON string.
+      def metadata(values)
+        values.to_h { |key, value| [key, JSON.parse(value)] }
+      end
+
+      def project(operation, request, result)
+        changes = result.changes.map do |change|
+          states = metadata(change.role_states)
+          { id: change.id, path: change.path, subject_ref: change.subject_ref, change: change.classification.to_sym,
+            before: revision(states['before'], :before, change.source_spans), after: revision(states['after'], :after, change.source_spans),
+            source_spans: change.source_spans, metadata: metadata(change.metadata) }
+        end
+        diagnostics = result.diagnostics.map do |record|
+          diagnostic = record.canonical || record.migration
+          { id: diagnostic.id, code: diagnostic.code, category: diagnostic.category.to_sym,
+            severity: diagnostic.severity.to_sym, message: diagnostic.message, blocking: diagnostic.blocking, typed_record: record }
+        end
+        conflicts = result.conflicts.map do |record|
+          canonical = record.canonical
+          native = canonical && metadata(canonical.classification.extra)['native_conflict']
+          native || { typed_record: record }
+        end
+        verification = VERIFICATION_FIELDS.to_h { |field| [field, result.verification.public_send(field)] }
+        verification[:rust_core] = true
+        payload = { output: result.output, conflicted_output: result.conflicted_output, typed_result: result }
+        if result.analysis
+          facts = metadata(result.analysis.extra)
+          payload[:analysis] = { backend: :rust_tslp, valid: true, facts: facts,
+                                 declarations: facts.fetch('owners').map do |owner|
+                                   { path: owner_path(owner), signature: owner_path(owner), source_role: :source,
+                                     line_range: line_range(owner.fetch('span')), byte_range: owner.fetch('span').fetch('range') }
+                                 end }
+        end
+        payload[:diff] = { changes: changes } if result.diff
+        projected = Ast::Merge::ProviderResult.build(operation: operation, success: result.ok,
+                                                     envelope: { provider: { provider_id: provider_id, family: family, dialect: request.fetch(:dialect, default_dialect),
+                                                                             backend: :rust_tslp, package: self.class::PACKAGE, package_version: package_version },
+                                                                 profile: { profile_id: :source_preserving, core_profile_id: result.profile.profile_id },
+                                                                 diagnostics: diagnostics, changes: changes, conflicts: conflicts,
+                                                                 render_report: metadata(result.render_report), verification: verification }, **payload)
+        portable(projected)
+      end
+
+      def portable(value)
+        case value
+        when Hash then value.sort_by { |key, _item| key.to_s }.to_h { |key, item| [key, portable(item)] }
+        when Array then value.map { |item| portable(item) }
+        when String, Symbol, Numeric, TrueClass, FalseClass, NilClass then value
+        else
+          name = value.class.name
+          unless name&.start_with?('StructuredmergeCore::') && DATA_RECORDS.include?(name.delete_prefix('StructuredmergeCore::'))
+            raise TypeError, 'Unsupported typed core data record'
+          end
+
+          value.class.public_instance_methods(false).sort.to_h do |field|
+            raise TypeError, 'Unexpected executable method on core data record' unless value.method(field).arity.zero?
+
+            item = value.public_send(field)
+            item = metadata(item) if %i[extra metadata data role_states render_report].include?(field)
+            item = item.map { |entry| metadata(entry) } if field == :fallbacks
+            item = JSON.parse(item) if field == :payload
+            [field, portable(item)]
+          end
+        end
+      end
+
+      def revision(state, role, source_spans)
+        return { present: false, source_role: role, line_range: [nil, nil] } unless state
+
+        span = state.fetch('owner', state)['span']
+        unless span
+          # Native-owner diffs carry regions rather than JSON owner records.
+          # Line points come from the kernel's typed span, never host text scans.
+          typed = source_spans.fetch(role)
+          span = { 'range' => { 'start_byte' => typed.range.start_byte, 'end_byte' => typed.range.end_byte },
+                   'start_point' => { 'row' => typed.start_point.row, 'column' => typed.start_point.column },
+                   'end_point' => { 'row' => typed.end_point.row, 'column' => typed.end_point.column } }
+        end
+        { present: true, source_role: role, line_range: line_range(span), byte_range: span.fetch('range') }
+      end
+
+      def line_range(span)
+        start = span.fetch('start_point')
+        finish = span.fetch('end_point')
+        end_row = finish.fetch('row')
+        end_row -= 1 if finish.fetch('column').zero? && end_row > start.fetch('row')
+        [start.fetch('row') + 1, end_row + 1]
+      end
+    end
+  end
+end

data/lib/ast/merge/version.rb

@@ -5,7 +5,7 @@ module Ast
     # Version namespace for this gem.
     module Version
       # Current gem version.
-      VERSION = '7.1.9'
+      VERSION = '7.1.10'
     end
     # Current gem version exposed at the traditional constant location.
     VERSION = Version::VERSION # Traditional Constant Location

data/lib/ast/merge.rb

@@ -86,6 +86,7 @@ module Ast
     autoload :PortableBenchmarkContract, 'ast/merge/portable_benchmark_contract'
     autoload :ProviderContract, 'ast/merge/provider_contract'
     autoload :ProviderRegistry, 'ast/merge/provider_registry'
+    autoload :RustHostProvider, 'ast/merge/rust_host_provider'
     autoload :ProviderResult, 'ast/merge/provider_result'
     autoload :SectionTyping, 'ast/merge/section_typing'
     autoload :SmartMergerBase, 'ast/merge/smart_merger_base'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ast-merge
 version: !ruby/object:Gem::Version
-  version: 7.1.9
+  version: 7.1.10
 platform: ruby
 authors:
 - Peter H. Boling
@@ -77,14 +77,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.9
+        version: 7.1.10
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.9
+        version: 7.1.10
 - !ruby/object:Gem::Dependency
   name: version_gem
   requirement: !ruby/object:Gem::Requirement
@@ -111,20 +111,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.34
+        version: 3.1.8
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.34
+        version: 3.1.8
 - !ruby/object:Gem::Dependency
   name: bundler-audit
   requirement: !ruby/object:Gem::Requirement
@@ -202,7 +202,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.3
+        version: 3.2.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -212,7 +212,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.3
+        version: 3.2.5
 - !ruby/object:Gem::Dependency
   name: kettle-test
   requirement: !ruby/object:Gem::Requirement
@@ -222,7 +222,7 @@ dependencies:
         version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.21
+        version: 2.0.23
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -232,7 +232,7 @@ dependencies:
         version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.21
+        version: 2.0.23
 - !ruby/object:Gem::Dependency
   name: turbo_tests2
   requirement: !ruby/object:Gem::Requirement
@@ -242,7 +242,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.7
+        version: 3.2.14
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -252,7 +252,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.7
+        version: 3.2.14
 - !ruby/object:Gem::Dependency
   name: ruby-progressbar
   requirement: !ruby/object:Gem::Requirement
@@ -276,7 +276,7 @@ dependencies:
         version: '1.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.8
+        version: 1.0.9
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -286,7 +286,7 @@ dependencies:
         version: '1.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.8
+        version: 1.0.9
 - !ruby/object:Gem::Dependency
   name: gitmoji-regex
   requirement: !ruby/object:Gem::Requirement
@@ -296,7 +296,7 @@ dependencies:
         version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.12
+        version: 2.0.15
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -306,7 +306,7 @@ dependencies:
         version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.12
+        version: 2.0.15
 description: "☯️ Core diagnostics, conformance, planning, reporting, and review-state
   contracts for Structured Merge."
 email:
@@ -452,6 +452,7 @@ files:
 - lib/ast/merge/runtime/root_session_support.rb
 - lib/ast/merge/runtime/session.rb
 - lib/ast/merge/runtime/surface.rb
+- lib/ast/merge/rust_host_provider.rb
 - lib/ast/merge/section_typing.rb
 - lib/ast/merge/smart_merger_base.rb
 - lib/ast/merge/source_region_report_support.rb
@@ -462,6 +463,7 @@ files:
 - lib/ast/merge/source_render/result.rb
 - lib/ast/merge/structural_edit.rb
 - lib/ast/merge/structural_edit/README.md
+- lib/ast/merge/structural_edit/blank_line_support.rb
 - lib/ast/merge/structural_edit/boundary.rb
 - lib/ast/merge/structural_edit/boundary_support.rb
 - lib/ast/merge/structural_edit/plan_set.rb
@@ -486,6 +488,7 @@ files:
 - lib/ast/merge/trailing_groups/alignment_sort.rb
 - lib/ast/merge/trailing_groups/core.rb
 - lib/ast/merge/trailing_groups/dest_iterate.rb
+- lib/ast/merge/typed_core_provider.rb
 - lib/ast/merge/unresolved_policy.rb
 - lib/ast/merge/unresolved_review_state.rb
 - lib/ast/merge/unresolved_support.rb
@@ -497,10 +500,10 @@ licenses:
 - PolyForm-Small-Business-1.0.0
 metadata:
   homepage_uri: https://structuredmerge.org
-  source_code_uri: https://github.com/structuredmerge/structuredmerge-ruby/tree/v7.1.9
-  changelog_uri: https://github.com/structuredmerge/structuredmerge-ruby/blob/v7.1.9/CHANGELOG.md
+  source_code_uri: https://github.com/structuredmerge/structuredmerge-ruby/tree/v7.1.10
+  changelog_uri: https://github.com/structuredmerge/structuredmerge-ruby/blob/v7.1.10/CHANGELOG.md
   bug_tracker_uri: https://github.com/structuredmerge/structuredmerge-ruby/issues
-  documentation_uri: https://www.rubydoc.info/gems/ast-merge/7.1.9
+  documentation_uri: https://www.rubydoc.info/gems/ast-merge/7.1.10
   funding_uri: https://github.com/sponsors/pboling
   wiki_uri: https://github.com/structuredmerge/structuredmerge-ruby/wiki
   news_uri: https://www.railsbling.com/tags/ast-merge
@@ -530,7 +533,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.17
+rubygems_version: 4.0.20
 specification_version: 4
 summary: "☯️ Structured Merge AST/core contracts for the Ruby monorepo"
 test_files: []