feat(isc): support function targets (upcase/downcase), any(alias), empty fields

- Add upcase/downcase/title_case/reverse/strip/swapcase as function_call
  item atoms (used as to: value)
- any() now accepts bare identifier (alias_arg) inside parens, e.g.
  before any(upper)
- generic_field accepts empty fields (just identifier, no value)
- Add comment handling in tests_block converter

Verification: 172/289 maps equivalent (60%).

Author: ronaldtse

exe/codemod-imp-to-isc

@@ -376,6 +376,9 @@ module Interscript
           elsif @scanner.scan(/\}/)
             depth -= 1
             @out << "}"
+          elsif @scanner.scan(/#[^\n]*/)
+            # Preserve comment lines verbatim
+            @out << @scanner.matched
           elsif @scanner.scan(/\btest\b/)
             # `test "X", "Y"` -> `"X" -> "Y"`
             @out << ""

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

@@ -17,10 +17,18 @@ module Items
               any_constructor |
               capture_constructor |
               maybe_constructor |
+              function_call |
               capture_reference |
               alias_reference
           end
 
+          # Function call: upcase, downcase, title_case, reverse, etc.
+          # These appear as the `to` value in sub rules: `sub "X" upcase`.
+          rule(:function_call) do
+            (str("upcase") | str("downcase") | str("title_case") |
+              str("reverse") | str("strip") | str("swapcase")).as(:function)
+          end
+
           rule(:zero_width_primitive) do
             (
               str("boundary") |
@@ -34,10 +42,15 @@ module Items
 
           rule(:any_constructor) do
             str("any") >> str("(") >> whitespace? >>
-              (range_arg | set_arg).as(:any) >>
+              (range_arg | set_arg | alias_arg).as(:any) >>
               whitespace? >> str(")")
           end
 
+          # `any(identifier)` — accept a bare alias reference inside any().
+          rule(:alias_arg) do
+            (keyword.absent? >> identifier).as(:alias_ref)
+          end
+
           # capture(...) — wraps a sub-expression with a capture group.
           # The captured value can be referenced in the target via `ref(N)`.
           rule(:capture_constructor) do

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

@@ -113,12 +113,19 @@ module Metadata
           # field additions; semantic validation happens in DocumentBuilder.
           rule(:generic_field) do
             identifier.as(:field_name) >> whitespace? >>
-              field_value.as(:field_value)
+              (empty_field | field_value.as(:field_value))
           end
 
           rule(:field_value) do
             quoted_string |
-              (newline.absent? >> (str("}").absent? >> any)).repeat(0).as(:raw)
+              (newline.absent? >> (str("}").absent? >> any)).repeat(1).as(:raw)
+          end
+
+          rule(:empty_field) do
+            # An identifier with no value (just newline or `}` after). The
+            # separate rule prevents the generic_field's value rule from
+            # consuming into the next field.
+            (newline.present? | str("}").present?).as(:empty)
           end
 
           # Raw text inside `{ ... }` — for description blocks. Consumes any

lib/interscript/isc/items.rb

@@ -48,6 +48,19 @@ def inspect
         end
       end
 
+      # Function call: upcase, downcase, etc. Used as `to` value in sub rules.
+      class Function
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def inspect
+          "Function(#{@name})"
+        end
+      end
+
       class AliasRef
         attr_reader :name
 

lib/interscript/isc/transform.rb

@@ -52,6 +52,7 @@ 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: 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(materialize_item(inner)) }