expressir 2.4.31-arm-linux → 2.4.36-arm-linux

data/lib/expressir/lsp/workspace.rb

@@ -0,0 +1,402 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Lsp
+    # The cross-document view used by the server: open documents, schema
+    # resolution through USE/REFERENCE interfaces, diagnostics, navigation
+    # and rename computation.
+    class Workspace
+      SEVERITIES = { error: 1, warning: 2, info: 3, hint: 4 }.freeze
+
+      attr_reader :documents
+
+      def initialize
+        @documents = {}
+      end
+
+      def open(uri:, text:, path: nil)
+        @documents[uri] = Document.new(uri: uri, text: text, path: path)
+      end
+
+      def change(uri:, text:)
+        document = @documents[uri]
+        return document.update(text) if document
+
+        self.open(uri: uri, text: text)
+      end
+
+      def close(uri)
+        @documents.delete(uri)
+      end
+
+      def document(uri)
+        @documents[uri]
+      end
+
+      def symbols(uri)
+        document(uri)&.symbols || []
+      end
+
+      def diagnostics(uri)
+        document = @documents[uri]
+        return [] unless document
+
+        return [parse_diagnostic(document)] if document.parse_error
+
+        checker_notes.filter_map { |note| diagnostic_for(document, note) }
+      end
+
+      def definition(uri, position)
+        target = target_at(uri, position)
+        return nil unless target
+
+        location(target[:doc], target[:node])
+      end
+
+      def references(uri, position, include_declaration: true)
+        target = target_at(uri, position)
+        return [] unless target
+
+        declaration = target[:node]
+        results = reference_locations(declaration)
+        results << location(target[:doc], declaration) if include_declaration
+        dedupe_locations(results)
+      end
+
+      def hover(uri, position)
+        target = target_at(uri, position)
+        return nil unless target
+
+        value = Express::PrettyFormatter.new.format(target[:node])
+        {
+          "contents" => {
+            "kind" => "markdown",
+            "value" => "```express\n#{value}\n```",
+          },
+        }
+      rescue StandardError
+        nil
+      end
+
+      def prepare_rename(uri, position)
+        target = target_at(uri, position)
+        return nil unless target
+
+        document = target[:doc]
+        node = target[:node]
+        { "range" => document.range_for(node),
+          "placeholder" => node.id.to_s }
+      end
+
+      # Returns the URI→edits map for a rename, after applying the edits
+      # in memory and verifying that every affected document still parses.
+      def rename(uri, position, new_name)
+        target = target_at(uri, position)
+        return nil unless target
+
+        edits = rename_edits(target[:doc], target[:node], new_name)
+        verify_rename!(edits, target[:node], new_name)
+        { "changes" => edits }
+      end
+
+      private
+
+      def checker_notes
+        key = @documents.each_value.map { |doc| doc.text.hash }
+        return @checker_notes if key == @checker_notes_key
+
+        files = @documents.each_value.filter_map(&:file)
+        notes = if files.empty?
+                  []
+                else
+                  repository = Model::Repository.new(files: files)
+                  Express::Checker.new(repository).check.notes
+                end
+        @checker_notes = notes
+        @checker_notes_key = key
+        notes
+      rescue StandardError
+        []
+      end
+
+      def diagnostic_for(document, note)
+        schema = document.schemas.find do |candidate|
+          candidate.id.to_s.casecmp?(note.schema.to_s)
+        end
+        return nil unless schema
+        return nil if resolved_note?(document, note)
+
+        node = note.node
+        range = if node&.source_offset
+                  document.range(node.source_offset,
+                                 node.respond_to?(:id) && node.id ? node.id.to_s.bytesize : 1)
+                else
+                  document.range_for(schema)
+                end
+        {
+          "range" => range,
+          "severity" => SEVERITIES.fetch(note.severity, 3),
+          "code" => note.id,
+          "source" => "expressir",
+          "message" => note.message.to_s,
+        }
+      end
+
+      # The checker sees one file at a time; an open document that supplies
+      # the referenced schema or interfaced declaration is not unresolved.
+      def resolved_note?(document, note)
+        return false unless note.id == :check_unresolved_ref
+        return false unless note.node.is_a?(Model::References::SimpleReference)
+
+        !resolve_reference(document, note.node).nil? ||
+          !schema_by_id(note.node.id).nil?
+      rescue StandardError
+        false
+      end
+
+      def parse_diagnostic(document)
+        error = document.parse_error
+        message = error.message.to_s
+        line = message[/line (\d+)/, 1].to_i
+        character = message[/char (\d+)/, 1].to_i
+        line = 1 if line.zero?
+        character = 1 if character.zero?
+        start = { "line" => line - 1, "character" => character - 1 }
+        {
+          "range" => { "start" => start,
+                       "end" => start.merge("character" => start["character"] + 1) },
+          "severity" => 1,
+          "source" => "expressir",
+          "message" => message.lines.first.to_s.strip,
+        }
+      end
+
+      def target_at(uri, position)
+        document = @documents[uri]
+        return nil unless document&.file
+
+        token = document.token_at(position)
+        return nil unless token
+
+        declaration = document.declaration_nodes.find do |node|
+          document.name_offset(node) == token.start_byte &&
+            node.id.to_s.casecmp?(token.text)
+        end
+        return { doc: document, node: declaration, token: token } if declaration
+
+        reference = document.reference_nodes.find do |node|
+          node.source_offset == token.start_byte
+        end
+        return nil unless reference
+
+        resolved = resolve_reference(document, reference)
+        resolved && { doc: resolved[:doc], node: resolved[:node], token: token }
+      end
+
+      def resolve_reference(document, node)
+        schema = schema_of(node)
+        return nil unless schema
+
+        local = node.find(node.id)
+        if local
+          target_doc = document_for_node(local) || document
+          return { doc: target_doc, node: local }
+        end
+
+        resolve_interface(schema, node.id)
+      rescue StandardError
+        nil
+      end
+
+      def resolve_interface(schema, name)
+        Array(schema.interfaces).each do |interface|
+          interface_schema = schema_by_id(interface.schema&.id)
+          next unless interface_schema
+
+          items = Array(interface.items)
+          if items.empty?
+            node = interface_schema[:schema].find(name)
+            return { doc: interface_schema[:doc], node: node } if node
+          else
+            items.each do |item|
+              local_name = item.id || item.ref&.id
+              next unless local_name.to_s.casecmp?(name.to_s)
+
+              node = interface_schema[:schema].find(item.ref&.id)
+              return { doc: interface_schema[:doc], node: node } if node
+            end
+          end
+        end
+        nil
+      end
+
+      def schema_by_id(id)
+        return nil unless id
+
+        @documents.each_value do |document|
+          document.schemas.each do |schema|
+            next unless schema.id.to_s.casecmp?(id.to_s)
+
+            return { doc: document, schema: schema }
+          end
+        end
+        nil
+      end
+
+      def document_for_node(node)
+        schema = schema_of(node)
+        return nil unless schema
+
+        @documents.each_value do |document|
+          return document if document.schemas.any? { |candidate| candidate.equal?(schema) }
+        end
+        nil
+      end
+
+      def schema_of(node)
+        current = node
+        current = current.parent while current && !current.is_a?(Model::Declarations::Schema)
+        current
+      end
+
+      def location(document, node)
+        { "uri" => document.uri, "range" => document.range_for(node) }
+      end
+
+      def reference_locations(declaration)
+        declaring_schema = schema_of(declaration)
+        @documents.each_value.flat_map do |document|
+          document.reference_nodes.filter_map do |reference|
+            resolved = resolve_reference(document, reference)
+            next unless resolved && same_declaration?(resolved[:node], declaration)
+
+            location(document, reference)
+          end + interface_locations(document, declaring_schema, declaration)
+        end
+      end
+
+      def interface_locations(document, declaring_schema, declaration)
+        document.schemas.flat_map do |schema|
+          Array(schema.interfaces).flat_map do |interface|
+            next [] unless interface.schema&.id.to_s.casecmp?(declaring_schema.id.to_s)
+
+            Array(interface.items).filter_map do |item|
+              next unless item.ref&.id.to_s.casecmp?(declaration.id.to_s)
+
+              location(document, item.ref)
+            end
+          end
+        end
+      end
+
+      def same_declaration?(left, right)
+        left.path.to_s.casecmp?(right.path.to_s)
+      end
+
+      def rename_edits(declaring_document, declaration, new_name)
+        edits = {}
+        add_edit(edits, declaring_document, declaration, new_name)
+
+        @documents.each_value do |document|
+          document.schemas.each do |schema|
+            rename_references(document, schema, declaration, new_name, edits)
+            rename_interface_items(document, schema, declaration, new_name, edits)
+          end
+        end
+        edits
+      end
+
+      def rename_references(document, schema, declaration, new_name, edits)
+        document.reference_nodes.each do |reference|
+          next unless schema_of(reference).equal?(schema)
+          next unless reference.id.to_s.casecmp?(declaration.id.to_s)
+
+          resolved = resolve_reference(document, reference)
+          next unless resolved && same_declaration?(resolved[:node], declaration)
+
+          add_edit(edits, document, reference, new_name)
+        end
+      end
+
+      def rename_interface_items(document, schema, declaration, new_name, edits)
+        Array(schema.interfaces).each do |interface|
+          next unless interface.schema&.id.to_s.casecmp?(schema_of(declaration).id.to_s)
+
+          Array(interface.items).each do |item|
+            next unless item.ref&.id.to_s.casecmp?(declaration.id.to_s)
+
+            add_edit(edits, document, item.ref, new_name)
+          end
+        end
+      end
+
+      def add_edit(edits, document, node, new_name)
+        range = document.range_for(node)
+        list = (edits[document.uri] ||= [])
+        return if list.any? { |edit| edit["range"] == range }
+
+        list << { "range" => range, "newText" => new_name }
+      end
+
+      def verify_rename!(edits, declaration, new_name)
+        declaring_schema = schema_of(declaration)
+        edits.each do |uri, document_edits|
+          document = @documents[uri]
+          text = apply_edits(document.text, document_edits)
+          probe = Document.new(uri: uri, text: text, path: document.path)
+          raise "rename produced invalid EXPRESS in #{uri}" if probe.parse_error
+
+          verify_schema_after_rename(document, probe, declaring_schema,
+                                     declaration, new_name, uri)
+        end
+      end
+
+      # The renamed declaration may disappear under its old path; every
+      # other removal is a structure loss and aborts the rename.
+      def verify_schema_after_rename(document, probe, declaring_schema,
+                                     declaration, _new_name, uri)
+        index = document.schemas.index(declaring_schema)
+        return unless index
+
+        probe_schema = probe.schemas[index]
+        return unless probe_schema
+
+        old_path = "#{declaring_schema.id}.#{declaration.id}".downcase
+        unexpected = Express::SchemaCompare
+          .compare(declaring_schema, probe_schema)
+          .select do |delta|
+            delta.op == :removed && delta.path.to_s.downcase != old_path
+          end
+        raise "rename removed unrelated declarations in #{uri}" if unexpected.any?
+
+        formatted = Express::Formatter.format(probe_schema)
+        formatted_probe = Document.new(uri: uri, text: formatted,
+                                       path: document.path)
+        raise "renamed schema does not format in #{uri}" if formatted_probe.parse_error
+      end
+
+      def apply_edits(text, edits)
+        scratch = Document.new(uri: "file:///nonexistent", text: text)
+        source = text.b
+        offsets = edits.map do |edit|
+          start_byte = scratch.byte_offset(edit["range"]["start"]["line"],
+                                           edit["range"]["start"]["character"])
+          end_byte = scratch.byte_offset(edit["range"]["end"]["line"],
+                                         edit["range"]["end"]["character"])
+          [start_byte, end_byte, edit["newText"].b]
+        end
+        offsets.sort_by { |start_byte, _, _| -start_byte }.each do |start_byte, end_byte, replacement|
+          source[start_byte...end_byte] = replacement
+        end
+        source.force_encoding(Encoding::UTF_8)
+      end
+
+      def dedupe_locations(locations)
+        locations.uniq do |location|
+          [location["uri"], location["range"]["start"]["line"],
+           location["range"]["start"]["character"]]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/lsp.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Expressir
+  # Language Server Protocol support: stdio JSON-RPC transport, open
+  # documents, and the workspace view that resolves across schemas.
+  module Lsp
+    autoload :Document, "#{__dir__}/lsp/document"
+    autoload :Workspace, "#{__dir__}/lsp/workspace"
+    autoload :Server, "#{__dir__}/lsp/server"
+  end
+end

data/lib/expressir/model/declarations/entity.rb

@@ -56,6 +56,138 @@ module Expressir
             *remark_items,
           ]
         end
+
+        # eeng compute-inheritance: the full supertype closure, nearest
+        # supertype first, cycle-safe. Cross-schema supertypes resolve
+        # through the enclosing repository.
+        # @return [Array<Entity>]
+        def supertype_closure
+          closure = []
+          visited = { id&.safe_downcase => true }
+          queue = Array(subtype_of).map { |ref| ref.respond_to?(:id) ? ref.id : ref }
+          while (name = queue.shift)
+            key = name&.safe_downcase
+            next if key.nil? || visited.key?(key)
+
+            supertype = find_supertype_entity(key)
+            next unless supertype
+
+            visited[key] = true
+            closure << supertype
+            queue.concat(Array(supertype.subtype_of).map do |ref|
+              ref.respond_to?(:id) ? ref.id : ref
+            end)
+          end
+          closure
+        end
+
+        # Explicit attributes inherited from the supertype closure,
+        # nearest supertype first, skipping ids this entity (or a
+        # nearer ancestor) redeclares.
+        # @return [Array<ExplicitAttribute>]
+        def inherited_explicit_attributes
+          claimed = explicit_only(Array(attributes)).filter_map(&:id).map(&:safe_downcase)
+          closure = supertype_closure
+          closure.flat_map do |supertype|
+            explicit_only(Array(supertype.attributes)).filter_map do |attr|
+              next nil unless attr.id
+
+              key = attr.id.safe_downcase
+              next nil if claimed.include?(key)
+
+              claimed << key
+              attr
+            end
+          end
+        end
+
+        # Derived attributes accumulated from the supertype closure.
+        # @return [Array<DerivedAttribute>]
+        def inherited_derived_attributes
+          closure = supertype_closure
+          seen = {}
+          closure.flat_map do |supertype|
+            derived_attribute_items(supertype).filter_map do |attr|
+              next nil unless attr.id
+
+              key = attr.id.safe_downcase
+              next nil if seen.key?(key)
+
+              seen[key] = true
+              attr
+            end
+          end
+        end
+
+        # Inverse attributes accumulated from the supertype closure.
+        # @return [Array<InverseAttribute>]
+        def inherited_inverse_attributes
+          closure = supertype_closure
+          seen = {}
+          closure.flat_map do |supertype|
+            inverse_attribute_items(supertype).filter_map do |attr|
+              next nil unless attr.id
+
+              key = attr.id.safe_downcase
+              next nil if seen.key?(key)
+
+              seen[key] = true
+              attr
+            end
+          end
+        end
+
+        # All explicit attributes: own + inherited (eeng
+        # explicit-attrs materialization).
+        # @return [Array<ExplicitAttribute>]
+        def all_explicit_attributes
+          [*explicit_only(Array(attributes)), *inherited_explicit_attributes]
+        end
+
+        private
+
+        # Entity#attributes carries every attribute kind; the explicit
+        # kind is Expressir::Model::Declarations::Attribute.
+        # DerivedAttribute/InverseAttribute subclass Attribute, so the
+        # explicit kind is the exact base class.
+        def explicit_only(attrs)
+          attrs.select { |a| a.instance_of?(Expressir::Model::Declarations::Attribute) }
+        end
+
+        # The Ruby parse path parks every attribute kind in `attributes`
+        # (typed by class); the core path fills derived_attributes/
+        # inverse_attributes instead. Both layouts resolve to the same
+        # items here.
+        def derived_attribute_items(entity)
+          own = Array(entity.derived_attributes)
+          return own if own.any?
+
+          Array(entity.attributes).grep(Expressir::Model::Declarations::DerivedAttribute)
+        end
+
+        def inverse_attribute_items(entity)
+          own = Array(entity.inverse_attributes)
+          return own if own.any?
+
+          Array(entity.attributes).grep(Expressir::Model::Declarations::InverseAttribute)
+        end
+
+        def find_supertype_entity(key)
+          container = parent
+          container = container.parent while container &&
+              !container.is_a?(Model::Repository) &&
+              !container.is_a?(Model::ExpFile)
+          return nil unless container.respond_to?(:schemas)
+
+          container.schemas.each do |foreign|
+            next unless foreign.respond_to?(:entities)
+
+            foreign.entities.each do |candidate|
+              return candidate if candidate.id&.safe_downcase == key
+            end
+          end
+          nil
+        end
       end
     end
   end

data/lib/expressir/model/declarations/schema.rb

@@ -127,6 +127,19 @@ module Expressir
           @formatted_hyperlinked_adoc ||= Expressir::Express::AdocSourceFormatter.format(self)
         end
 
+        USE_ITEM_KINDS = [
+          Expressir::Model::Declarations::Entity,
+          Expressir::Model::Declarations::Type,
+        ].freeze
+
+        REFERENCE_ITEM_KINDS = [
+          Expressir::Model::Declarations::Constant,
+          Expressir::Model::Declarations::Entity,
+          Expressir::Model::Declarations::Function,
+          Expressir::Model::Declarations::Procedure,
+          Expressir::Model::Declarations::Type,
+        ].freeze
+
         private
 
         # @param [String] id
@@ -142,6 +155,7 @@ module Expressir
         end
 
         # @return [Array<InterfacedItem>]
+
         def interfaced_items
           return [] unless parent
 
@@ -151,6 +165,11 @@ module Expressir
           end.compact
         end
 
+        # ISO 10303-11 implicit interfacing: USE exposes entities and
+        # types only; REFERENCE has no implicit interfacing. Listed
+        # items follow eeng resolve-interface: use-from resolves via
+        # find-type/entity, reference-from via the 5-kind or-chain.
+
         # Direct items of one interface plus the items visible through
         # the foreign schema's own USE interfaces (transitive USE
         # visibility, eeng :use-only → :use-from recursion).
@@ -171,16 +190,23 @@ module Expressir
           end
 
           own = if interface.items.empty?
-                  safe_children.map do |base_item|
-                    create_interfaced_item(base_item.id, base_item)
+                  if interface.kind == Interface::REFERENCE
+                    []
+                  else
+                    safe_children.filter_map do |base_item|
+                      next nil unless USE_ITEM_KINDS.any? { |k| base_item.is_a?(k) }
+
+                      create_interfaced_item(base_item.id, base_item)
+                    end
                   end
                 else
                   interface.items.filter_map do |item|
                     base_item = children_by_id[item.ref.id.safe_downcase]
-                    if base_item
-                      create_interfaced_item(item.id || base_item.id,
-                                             base_item)
-                    end
+                    next nil unless base_item
+                    next nil unless item_kind_interfacable?(interface.kind, base_item)
+
+                    create_interfaced_item(item.id || base_item.id,
+                                           base_item)
                   end
                 end
 
@@ -197,6 +223,11 @@ module Expressir
           end.flatten
         end
 
+        def item_kind_interfacable?(kind, node)
+          kinds = kind == Interface::REFERENCE ? REFERENCE_ITEM_KINDS : USE_ITEM_KINDS
+          kinds.any? { |k| node.is_a?(k) }
+        end
+
         # Find a foreign schema by name: same file first, then the
         # enclosing repository (expressir's compiled/batch repository).
         def foreign_schema(name)