expressir 2.4.2 → 2.4.4

data/lib/expressir/express/formatters/remark_formatter.rb

@@ -125,7 +125,7 @@ module Expressir
 
           # For scope containers: exclude last remark ONLY if it's a tail remark (END_* remark)
           # Keep all embedded remarks
-          if is_scope_container && preamble_remarks.length > 1
+          if is_scope_container && preamble_remarks.length >= 1
             last_remark = preamble_remarks.last
             # Only exclude if it's a tail remark
             preamble_remarks = preamble_remarks[0..-2] if last_remark.tail?
@@ -154,15 +154,39 @@ module Expressir
           end
         end
 
-        # Remarks written after their statement on the same line. Attachment
-        # only assigns these to single-line statements, so appending keeps
-        # them on that statement's line.
+        # Remarks written after their statement on the same line, which for a
+        # single-line statement is where appending puts them back. Opener
+        # remarks are excluded: those belong on the first line rather than
+        # after the closing keyword, and {#format_opener_remarks} emits them.
+        # Mid-keyword remarks (ELSE / OTHERWISE regions) are excluded too:
+        # {#format_mid_keyword_remarks} emits them after their keyword.
         def format_inline_statement_remarks(node)
+          formatted_inline_remarks(node) { |remark| remark.region.nil? }
+        end
+
+        # Remarks that trailed the opening line of a statement spanning
+        # several lines, as in `IF x THEN -- why`. Where they are written back
+        # is Formatter#format's business, not this method's.
+        def format_opener_remarks(node)
+          formatted_inline_remarks(node, &:opener?)
+        end
+
+        # Remarks that trailed a mid-construct keyword of `node` — the ELSE
+        # line of an IF, the OTHERWISE line of a CASE — emitted after that
+        # keyword, where they were written.
+        def format_mid_keyword_remarks(node, region)
+          formatted_inline_remarks(node) { |remark| remark.inline_region?(region) }
+        end
+
+        # The inline remarks of a node that the given block accepts, formatted
+        # and joined. The callers partition the same collection, so every
+        # inline remark is emitted by exactly one of them.
+        def formatted_inline_remarks(node, &)
           return "" if @no_remarks
-          return "" unless node.is_a?(Model::Statement)
+          return "" unless node.is_a?(Model::TakesInlineRemark)
 
           Array(node.untagged_remarks).filter_map do |remark|
-            next unless remark.inline?
+            next unless remark.inline? && yield(remark)
 
             formatted = format_untagged_remark(remark)
             formatted unless formatted.empty?

data/lib/expressir/express/formatters/statements_formatter.rb

@@ -98,6 +98,8 @@ module Expressir
                    "OTHERWISE",
                    " ",
                    ":",
+                   format_mid_keyword_remarks(node,
+                                              Model::RemarkPlacement::OTHERWISE_REGION),
                  ].join,
                  indent(format(node.otherwise_statement)),
                ]
@@ -167,7 +169,11 @@ module Expressir
             *(then_trailing if has_else),
             *if has_else
                [
-                 "ELSE",
+                 [
+                   "ELSE",
+                   format_mid_keyword_remarks(node,
+                                              Model::RemarkPlacement::ELSE_REGION),
+                 ].join,
                  indent(node.else_statements.map { |x| format(x) }.join("\n")),
                ].join("\n")
              end,

data/lib/expressir/express/interface_dot.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # Interface dependency GraphViz emitter — port of eeng
+    # kernel/dot-graph.lisp `:interface` graph (parity-ee stage 10).
+    #
+    # Nodes are schema names (lowercase); edges are USE FROM (default
+    # blue) and REFERENCE FROM (default green). An edge with an item
+    # list uses arrowhead=curve; a bare interface uses arrowhead=normal.
+    class InterfaceDot
+      def initialize(root_schema, repository,
+                     iface: :both, uf_color: :blue, rf_color: :green,
+                     depth: nil, prune: [])
+        @root = root_schema
+        @repository = repository
+        @iface = iface
+        @uf_color = uf_color
+        @rf_color = rf_color
+        @depth = depth
+        @prune = Array(prune).map { |n| n.to_s.downcase }
+        @by_name = repository.schemas.compact.to_h { |s| [s.id.safe_downcase, s] }
+      end
+
+      def write(io = nil)
+        owned = io.nil?
+        io ||= +""
+        schemas, edges = collect
+        io << "// -*- Mode: Dot -*-\n\n"
+        io << "// Dot File Written by Expressir\n"
+        io << "//    #{Expressir::VERSION}\n"
+        io << "\ndigraph interfaces {\n"
+        io << "  node [shape=none];\n"
+        if %i[both use].include?(@iface)
+          io << "  edge [color=#{@uf_color}];\n"
+          edges.select { |e| e[:kind] == :use }.each do |e|
+            head = e[:items] ? "curve" : "normal"
+            io << "  #{e[:from]} -> #{e[:to]} [arrowhead=#{head}];\n"
+          end
+        end
+        if %i[both ref].include?(@iface)
+          io << "  edge [color=#{@rf_color}];\n"
+          edges.select { |e| e[:kind] == :ref }.each do |e|
+            head = e[:items] ? "curve" : "normal"
+            io << "  #{e[:from]} -> #{e[:to]} [arrowhead=#{head}];\n"
+          end
+        end
+        # Ensure isolated schemas still appear as nodes.
+        named = edges.flat_map { |e| [e[:from], e[:to]] }.uniq
+        (schemas.map { |s| s.id.downcase } - named).each do |n|
+          io << "  #{n};\n"
+        end
+        io << "}\n"
+        owned ? io : nil
+      end
+
+      private
+
+      def collect
+        visited = {}
+        edges = []
+        queue = [[@root, 0]]
+        until queue.empty?
+          schema, level = queue.shift
+          key = schema.id.safe_downcase
+          next if visited.key?(key)
+          next if @prune.include?(key)
+
+          visited[key] = schema
+
+          Array(schema.interfaces).each do |iface|
+            target_name = iface_schema_name(iface)
+            next unless target_name
+
+            tkey = target_name.safe_downcase
+            next if @prune.include?(tkey)
+            next if tkey == key
+
+            kind = iface.kind == Model::Declarations::Interface::REFERENCE ? :ref : :use
+            next if @iface == :use && kind != :use
+            next if @iface == :ref && kind != :ref
+
+            edges << {
+              kind: kind,
+              items: Array(iface.items).any?,
+              from: key,
+              to: tkey,
+            }
+
+            target = @by_name[tkey]
+            next unless target
+            next if @depth && level + 1 >= @depth
+
+            queue << [target, level + 1]
+          end
+        end
+        [visited.values, edges.uniq]
+      end
+
+      def iface_schema_name(iface)
+        iface.schema.is_a?(String) ? iface.schema : iface.schema&.id
+      end
+    end
+  end
+end

data/lib/expressir/express/listing.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Expressir
+  module Express
+    # Declaration listing and SMRL index writers — ports of eeng
+    # plugins/p11/wo-list.lisp and wo-smrl-xml.lisp (parity-ee stage 09).
+    #
+    # Two encodings share the same schema walk and declaration ordering
+    # (TYPE, ENTITY, SUBTYPE_CONSTRAINT, FUNCTION, RULE, PROCEDURE —
+    # each sorted by name):
+    #   :list     — human-readable SCHEMA.name; inventory
+    #   :smrl_xml — <concatenated_express_file_content_list> index
+    class Listing
+      DECL_ORDER = %i[types entities subtype_constraints functions rules procedures].freeze
+      DECL_LABEL = {
+        types: "TYPE",
+        entities: "ENTITY",
+        subtype_constraints: "SUBTYPE_CONSTRAINT",
+        functions: "FUNCTION",
+        rules: "RULE",
+        procedures: "PROCEDURE",
+      }.freeze
+      XML_TAG = {
+        types: "type",
+        entities: "entity",
+        subtype_constraints: "subtype_constraint",
+        functions: "function",
+        rules: "rule",
+        procedures: "procedure",
+      }.freeze
+
+      def self.list(schemas, io = nil)
+        new(Array(schemas)).write(:list, io)
+      end
+
+      def self.smrl_xml(schemas, io = nil, source: nil)
+        new(Array(schemas)).write(:smrl_xml, io, source: source)
+      end
+
+      def initialize(schemas)
+        @schemas = schemas.compact.sort_by { |s| s.id.to_s.downcase }
+      end
+
+      def write(encoding, io = nil, source: nil)
+        owned = io.nil?
+        io ||= +""
+        case encoding
+        when :list then write_list(io)
+        when :smrl_xml then write_smrl_xml(io, source: source)
+        else
+          raise ArgumentError, "unknown listing encoding #{encoding.inspect}"
+        end
+        owned ? io : nil
+      end
+
+      private
+
+      def write_list(io)
+        @schemas.each_with_index do |schema, i|
+          io << "\n" if i.positive?
+          write_schema_list(schema, io)
+        end
+      end
+
+      def write_schema_list(schema, io)
+        version = schema.version ? " #{schema.version}" : ""
+        io << "SCHEMA #{schema.id.downcase}#{version};\n\n"
+        counts = decl_counts(schema)
+        DECL_ORDER.each do |key|
+          io << format("(* %-20s %4d *)\n", DECL_LABEL[key], counts[key])
+        end
+        ifaces = Array(schema.interfaces)
+        if ifaces.any?
+          io << "\n"
+          ifaces.each do |iface|
+            kind = iface.kind == Model::Declarations::Interface::REFERENCE ? "REFERENCE FROM" : "USE FROM"
+            target = iface_name(iface)
+            suffix = Array(iface.items).any? ? "(...)" : ""
+            io << "    #{kind} #{target}#{suffix};\n"
+          end
+        end
+        constants = Array(schema.constants).sort_by { |c| c.id.to_s.downcase }
+        if constants.any?
+          io << "\n"
+          constants.each { |c| io << "  CONSTANT #{c.id.downcase};\n" }
+        end
+        decls = ordered_decls(schema)
+        if decls.any?
+          io << "\n"
+          decls.each do |key, name|
+            io << "  #{DECL_LABEL[key]} #{schema.id}.#{name.downcase};\n"
+          end
+        end
+      end
+
+      def write_smrl_xml(io, source: nil)
+        io << "<!-- Written by Expressir -->\n"
+        io << "<!--    #{Expressir::VERSION} -->\n"
+        io << "<!-- File: #{source} -->\n" if source
+        io << "<concatenated_express_file_content_list>\n\n"
+        names = @schemas.map { |s| schema_name_string(s.id) }
+        io << "<!-- #{@schemas.size} Schema#{'ta' unless @schemas.size == 1}:\n"
+        io << "   #{names.join(', ')}\n"
+        io << "-->\n"
+        @schemas.each do |schema|
+          io << "\n\n"
+          write_schema_xml(schema, io)
+        end
+        io << "\n</concatenated_express_file_content_list>\n"
+      end
+
+      def write_schema_xml(schema, io)
+        io << "<schema>#{schema_name_string(schema.id)}</schema>\n"
+        if schema.version
+          io << "   <schema_version>#{schema.version}</schema_version>\n"
+        end
+        counts = decl_counts(schema)
+        DECL_ORDER.each do |key|
+          io << format("  <!-- %-20s %4d -->\n", DECL_LABEL[key], counts[key])
+        end
+        Array(schema.interfaces).each do |iface|
+          tag = iface.kind == Model::Declarations::Interface::REFERENCE ? "reference-from" : "use-from"
+          target = iface_name(iface)
+          suffix = Array(iface.items).any? ? "(...)" : ""
+          io << "    <#{tag}>#{target}#{suffix}</#{tag}>\n"
+        end
+        Array(schema.constants).sort_by { |c| c.id.to_s.downcase }.each do |c|
+          io << "  <constant>#{c.id.downcase}</constant>\n"
+        end
+        ordered_decls(schema).each do |key, name|
+          tag = XML_TAG[key] || key.to_s
+          cased = if key == :entities && arm_mode?(schema)
+                    name.split("_").map(&:capitalize).join("_")
+                  else
+                    name.downcase
+                  end
+          io << "  <#{tag}>#{schema.id}.#{cased}</#{tag}>\n"
+        end
+      end
+
+      def decl_counts(schema)
+        DECL_ORDER.to_h { |k| [k, Array(schema.public_send(k)).size] }
+      end
+
+      def ordered_decls(schema)
+        DECL_ORDER.flat_map do |key|
+          Array(schema.public_send(key))
+            .sort_by { |d| d.id.to_s.downcase }
+            .map { |d| [key, d.id] }
+        end
+      end
+
+      def iface_name(iface)
+        name = iface.schema.is_a?(String) ? iface.schema : iface.schema&.id
+        schema_name_string(name)
+      end
+
+      # eeng schema-name-string: arm/mim/arm_lf/mim_lf tails stay lowercase;
+      # everything else downcased.
+      def schema_name_string(name)
+        return "" unless name
+
+        name.to_s.downcase
+      end
+
+      def arm_mode?(schema)
+        id = schema.id.to_s.downcase
+        id.end_with?("arm", "arm_lf")
+      end
+    end
+  end
+end

data/lib/expressir/express/model_traversal.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # Structural traversal over model trees, mirroring {ModelVisitor}:
+    # every typed attribute, statements included. Nodes are keyed by
+    # attribute path plus array index — stable across a compiled-set
+    # round trip because the wire is byte-identical — which is what the
+    # remark and reference overlays key on ({Model::ModelElement#path}
+    # is empty for id-less nodes).
+    module ModelTraversal
+      module_function
+
+      def each_node(node, key, &block)
+        yield node, key
+        return unless node.is_a?(Model::ModelElement)
+
+        node.class.attributes.each_key do |attr|
+          next if Model::ModelElement::SKIP_ATTRIBUTES.include?(attr) || attr == :parent
+
+          value = node.public_send(attr)
+          case value
+          when Array
+            value.each_with_index do |item, index|
+              next unless item.is_a?(Model::ModelElement)
+
+              each_node(item, "#{key}/#{attr}[#{index}]", &block)
+            end
+          when Model::ModelElement
+            each_node(value, "#{key}/#{attr}", &block)
+          end
+        end
+      end
+
+      def each_model(models, &block)
+        models.each_with_index do |model, index|
+          each_node(model, "model[#{index}]", &block)
+        end
+      end
+    end
+  end
+end

data/lib/expressir/express/node_position_index.rb

@@ -13,6 +13,9 @@ module Expressir
     # instances; this module turns those spans into a line-keyed index that
     # remark attachment can query.
     class NodePositionIndex
+      EMPTY = [].freeze
+      private_constant :EMPTY
+
       # Single source of truth for "what collections does this node have"
       # lives on the model — each class declares its own via the
       # `collection_attributes` macro. Referenced by both RemarkAttacher
@@ -21,31 +24,133 @@ module Expressir
 
       attr_reader :nodes
 
+      # Semantic entries starting on `line` (node order).
+      def starting_at(line)
+        semantic_by_line[line] || EMPTY
+      end
+
+      # Semantic entries ending on `line` (node order).
+      def ending_at(line)
+        semantic_by_end_line[line] || EMPTY
+      end
+
+      # Semantic entries whose span covers `line` (node order within the
+      # covering band).
+      def spanning(line)
+        band = line / BAND
+        bands = span_bands
+        return EMPTY unless bands.key?(band)
+
+        bands[band].select { |n| line.between?(n[:line], n[:end_line]) }
+      end
+
+      # Semantic entries with end_line < line, ascending by end_line.
+      def semantic_ending_before(line)
+        sorted = semantic_by_end_line_list
+        idx = sorted.bsearch_index { |n| n[:end_line] >= line } || sorted.size
+        sorted[0...idx]
+      end
+
+      # The first semantic entry (smallest line), for preamble remarks.
+      def first_semantic
+        first_by_line = semantic_by_line.keys.min
+        first_by_line && semantic_by_line[first_by_line]&.first
+      end
+
+      # Entries owned by `owner` within any of `collections`, in node order.
+      # Identity-keyed: ownership is object identity (the tree-walker's
+      # `.equal?` semantics), and value-equal model objects must not
+      # collide.
+      def children_in(owner, collections)
+        per_collection = children_index[owner]
+        return EMPTY unless per_collection
+
+        entries = per_collection.values_at(*collections).compact.flatten(1)
+        entries.sort_by { |n| node_order(n) }
+      end
+
+      # First node (in node order) that is_a?(type), memoized per type.
+      def first_node_of_type(type)
+        @first_of_type ||= {}
+        @first_of_type[type] ||= @nodes.find { |n| n[:node].is_a?(type) }&.dig(:node)
+      end
+
+      def semantic_entries
+        @semantic_entries ||=
+          @nodes.select { |n| n[:line] && semantic?(n[:node]) }
+      end
+
+      # Non-vivifying: missed lookups must not materialize keys, or
+      # `keys.min`-style queries see phantom lines.
+      def semantic_by_line
+        @semantic_by_line ||= begin
+          h = {}
+          semantic_entries.each { |n| (h[n[:line]] ||= []) << n }
+          h
+        end
+      end
+
+      def semantic_by_end_line
+        @semantic_by_end_line ||= begin
+          h = {}
+          semantic_entries.each { |n| (h[n[:end_line]] ||= []) << n if n[:end_line] }
+          h
+        end
+      end
+
+      def semantic_by_end_line_list
+        @semantic_by_end_line_list ||=
+          semantic_entries.select { |n| n[:end_line] }.sort_by { |n| n[:end_line] }
+      end
+
+      def children_index
+        @children_index ||= begin
+          index = {}.compare_by_identity
+          @nodes.each do |n|
+            next unless n[:owner] && n[:line]
+
+            per_owner = (index[n[:owner]] ||= {})
+            (per_owner[n[:collection]] ||= []) << n
+          end
+          index
+        end
+      end
+
+      def span_bands
+        @span_bands ||= begin
+          bands = Hash.new { |hash, key| hash[key] = [] }
+          semantic_entries.each do |n|
+            next unless n[:end_line]
+
+            ((n[:line] / BAND)..(n[:end_line] / BAND)).each do |band|
+              bands[band] << n
+            end
+          end
+          bands
+        end
+      end
+
+      BAND = 1024
+      private_constant :BAND
+
       def initialize(model, line_map)
         @model = model
         @line_map = line_map
         @nodes = build_sorted_nodes
+        @node_order = nil
       end
 
       # Returns the most-specific node whose span contains `remark_line`,
       # preferring same-line starts/ends, then smallest containing span.
-      # Excludes Repository and Cache (not semantic scopes for remarks).
+      # Skips nodes that cannot own such a remark; see {#remark_scope?}.
       def nearest_node_to(remark_line)
-        same_start = nodes.select do |n|
-          n[:line] == remark_line && semantic?(n[:node])
-        end
+        same_start = starting_at(remark_line).select { |n| remark_scope?(n[:node]) }
         return same_start.last[:node] if same_start.any?
 
-        same_end = nodes.select do |n|
-          n[:end_line] == remark_line && semantic?(n[:node])
-        end
+        same_end = ending_at(remark_line).select { |n| remark_scope?(n[:node]) }
         return same_end.last[:node] if same_end.any?
 
-        containing = nodes.select do |n|
-          n[:line] && n[:end_line] &&
-            n[:line] <= remark_line && n[:end_line] >= remark_line &&
-            semantic?(n[:node])
-        end
+        containing = spanning(remark_line).select { |n| remark_scope?(n[:node]) }
 
         if containing.any?
           exp_file_node = containing.find { |n| n[:node].is_a?(Model::ExpFile) }
@@ -62,16 +167,13 @@ module Expressir
           candidates = containing if candidates.empty?
           candidates.min_by { |n| n[:end_line] - n[:line] }[:node]
         else
-          before = nodes.select do |n|
-            n[:end_line] && n[:end_line] < remark_line && semantic?(n[:node])
-          end
+          before = semantic_ending_before(remark_line)
           if before.any?
             before.max_by { |n| n[:end_line] }[:node]
           else
             # Remark is before all nodes (e.g., preamble comment before SCHEMA).
             # Attach to the first semantic node.
-            after = nodes.select { |n| n[:line] && semantic?(n[:node]) }
-            after.min_by { |n| n[:line] }[:node] if after.any?
+            first_semantic&.dig(:node)
           end
         end
       end
@@ -90,21 +192,46 @@ module Expressir
                     end
         return nil unless node_type
 
-        matching = nodes.select do |n|
+        candidates = (0..2).flat_map do |back|
+          ending_at(remark_line - back)
+        end.select do |n|
           n[:node].is_a?(node_type) &&
-            (n[:end_line] == remark_line ||
-             (n[:end_line] && n[:end_line] <= remark_line && n[:end_line] >= remark_line - 2))
+            n[:end_line] <= remark_line && n[:end_line] >= remark_line - 2
         end
 
-        matching.first&.dig(:node) || nodes.find { |n| n[:node].is_a?(node_type) }&.dig(:node)
+        candidates.min_by { |n| node_order(n) }&.dig(:node) ||
+          first_node_of_type(node_type)
       end
 
       private
 
+      def node_order(entry)
+        @node_order ||= begin
+          map = {}.compare_by_identity
+          @nodes.each_with_index { |n, i| map[n] = i }
+          map
+        end
+        @node_order[entry]
+      end
+
       def semantic?(node)
         !node.is_a?(Model::Repository) && !node.is_a?(Model::Cache)
       end
 
+      # Whether a node can own a remark sitting on a line of its own.
+      # Distinct from Model::TakesInlineRemark, which asks whether a node can
+      # own a remark written AFTER it on the same line: a statement answers
+      # yes to both; an interface clause only to that one.
+      #
+      # An interface clause is indexed (so a remark trailing it can find it
+      # via the same-line lookup), but it encloses nothing: an own-line
+      # remark below `REFERENCE FROM x;` introduces whatever comes next, and
+      # giving it to the clause would both misplace it and lose it, since
+      # nothing renders remarks there.
+      def remark_scope?(node)
+        semantic?(node) && !node.is_a?(Model::Declarations::Interface)
+      end
+
       def build_sorted_nodes
         result = []
         collect_nodes(@model, result, Set.new)