feat: qualified alias refs through ISC — map.<dep-alias>.<name>

The alias reference grammar accepts identifier.identifier; the
transform builds AliasRef with the map qualifier, the adapter builds
Item::Alias with map:, and Isc::Generator emits the dotted form.
Round-trips through the Python runtime, which resolves the target
against its dependency table (interscript-py alias-vocabulary PR).

Author: ronaldtse

lib/interscript/isc/generator.rb

@@ -126,7 +126,7 @@ def item(i)
         when Interscript::Node::Item::Any
           any(i)
         when Interscript::Node::Item::Alias
-          identifier(i.name)
+          i.map ? "#{i.map}.#{identifier(i.name)}" : identifier(i.name)
         when Interscript::Node::Item::CaptureGroup
           "capture(#{item(i.data)})"
         when Interscript::Node::Item::CaptureRef

lib/interscript/isc/grammar/concerns/items.rb

@@ -101,7 +101,9 @@ module Items
           end
 
           rule(:alias_reference) do
-            (keyword.absent? >> identifier >> str("{").absent?).as(:alias)
+            (keyword.absent? >> identifier >>
+              (str(".") >> identifier.as(:qualified_name)).maybe >>
+              str("{").absent?).as(:alias)
           end
 
           # ref(N) — reference to Nth capture group. Only valid in `to` position.

lib/interscript/isc/items.rb

@@ -62,10 +62,11 @@ def inspect
       end
 
       class AliasRef
-        attr_reader :name
+        attr_reader :name, :map
 
-        def initialize(name)
+        def initialize(name, map: nil)
           @name = name
+          @map = map
         end
 
         def inspect

lib/interscript/isc/node_adapter.rb

@@ -160,7 +160,7 @@ def convert_item(item)
         when Items::Primitive
           convert_primitive(item)
         when Items::AliasRef
-          Interscript::Node::Item::Alias.new(item.name.to_sym)
+          convert_alias_ref(item)
         when Items::Capture
           Interscript::Node::Item::CaptureRef.new(item.index)
         when Items::Function
@@ -190,6 +190,10 @@ def convert_primitive(item)
         Interscript::Node::Item::Alias.new(item.name.to_sym)
       end
 
+      def convert_alias_ref(item)
+        Interscript::Node::Item::Alias.new(item.name.to_sym, map: item.map&.to_sym)
+      end
+
       def convert_concat(concat)
         parts = concat.parts.map { |p| convert_item(p) }
         return parts.first if parts.size == 1

lib/interscript/isc/transform.rb

@@ -51,6 +51,9 @@ class Transform < Parslet::Transform
       rule(none: simple(:_)) { Items::None.new }
       rule(primitive: simple(:p)) { Items::Primitive.new(p.to_s) }
       rule(function: simple(:f)) { Items::Function.new(f.to_s) }
+      rule(alias: {identifier: simple(:n), qualified_name: simple(:q)}) {
+        Items::AliasRef.new(q.to_s, map: n.to_s)
+      }
       rule(alias: simple(:n)) { Items::AliasRef.new(n.to_s) }
       rule(ref: subtree(:h)) { Items::Capture.new(h[:digit].to_s.to_i) }
       rule(capture_inner: subtree(:inner)) { Items::CaptureGroup.new(Interscript::Isc::Transform.materialize_item(inner)) }