refactor: Drop the string type annotation (#489)

Author: zharinov

AGENTS.md

@@ -28,8 +28,7 @@ Validate once, at the boundary. Two smells to fix on sight: a swallowed must-hol
 | `(_)`               | Any named node                     |
 | `_`                 | Any node                           |
 | `@name`             | Capture (snake_case only)          |
-| `@x :: T`           | Type annotation                    |
-| `@x :: string`      | Extract node text                  |
+| `@x :: T`           | Type annotation (T is PascalCase)  |
 | `field: pattern`    | Field constraint                   |
 | `-field`            | Negated field (assert absent)      |
 | `?` `*` `+`         | Quantifiers (0-1, 0+, 1+)          |

README.md

@@ -75,17 +75,17 @@ Extract function signatures from Rust. `Type` references itself to handle nested
 
 ```clojure
 Type = [
-  Simple: [(type_identifier) (primitive_type)] @name :: string
+  Simple: [(type_identifier) (primitive_type)] @name
   Generic: (generic_type
-    type: (type_identifier) @name :: string
+    type: (type_identifier) @name
     type_arguments: (type_arguments (Type)* @args))
 ]
 
 Func = (function_item
-  name: (identifier) @name :: string
+  name: (identifier) @name
   parameters: (parameters
     (parameter
-      pattern: (identifier) @param :: string
+      pattern: (identifier) @param
       type: (Type) @type
     )* @params))
 
@@ -104,13 +104,32 @@ Plotnik infers TypeScript types from the query structure. `Type` is recursive: `
 
 ```sh
 ❯ plotnik infer query.ptk --lang rust
-export type Type =
-  | { $tag: "Simple"; $data: { name: string } }
-  | { $tag: "Generic"; $data: { name: string; args: Type[] } };
+export interface Node {
+  kind: string;
+  text: string;
+  span: [number, number];
+}
+
+export interface TypeSimple {
+  $tag: "Simple";
+  $data: { name: Node };
+}
+
+export interface TypeGeneric {
+  $tag: "Generic";
+  $data: { args: Type[]; name: Node };
+}
+
+export type Type = TypeSimple | TypeGeneric;
+
+export interface FuncParams {
+  param: Node;
+  type: Type;
+}
 
 export interface Func {
-  name: string;
-  params: { param: string; type: Type }[];
+  name: Node;
+  params: FuncParams[];
 }
 
 export interface Funcs {
@@ -121,33 +140,42 @@ export interface Funcs {
 Run the query against `lib.rs` to extract structured JSON:
 
 ```sh
-❯ plotnik exec query.ptk lib.rs
+❯ plotnik exec query.ptk lib.rs --entry Funcs
 {
   "funcs": [
     {
-      "name": "get",
+      "name": { "kind": "identifier", "text": "get", "span": [3, 6] },
       "params": [{
-        "param": "key",
+        "param": { "kind": "identifier", "text": "key", "span": [7, 10] },
         "type": {
           "$tag": "Generic",
           "$data": {
-            "name": "Option",
+            "name": { "kind": "type_identifier", "text": "Option", "span": [12, 18] },
             "args": [{
               "$tag": "Generic",
               "$data": {
-                "name": "Vec",
-                "args": [{ "$tag": "Simple", "$data": { "name": "String" } }]
+                "name": { "kind": "type_identifier", "text": "Vec", "span": [19, 22] },
+                "args": [{
+                  "$tag": "Simple",
+                  "$data": { "name": { "kind": "type_identifier", "text": "String", "span": [23, 29] } }
+                }]
               }
             }]
           }
         }
       }]
     },
     {
-      "name": "set",
+      "name": { "kind": "identifier", "text": "set", "span": [40, 43] },
       "params": [
-        { "param": "key", "type": { "$tag": "Simple", "$data": { "name": "String" } } },
-        { "param": "val", "type": { "$tag": "Simple", "$data": { "name": "i32" } } }
+        {
+          "param": { "kind": "identifier", "text": "key", "span": [44, 47] },
+          "type": { "$tag": "Simple", "$data": { "name": { "kind": "type_identifier", "text": "String", "span": [49, 55] } } }
+        },
+        {
+          "param": { "kind": "identifier", "text": "val", "span": [57, 60] },
+          "type": { "$tag": "Simple", "$data": { "name": { "kind": "primitive_type", "text": "i32", "span": [62, 65] } } }
+        }
       ]
     }
   ]

crates/plotnik-bytecode/src/bytecode/constants.rs

@@ -9,7 +9,8 @@ pub const MAGIC: [u8; 4] = *b"PTKQ";
 /// v4: Removed the trivia section.
 /// v5: Added extras-only anchor navigation modes.
 /// v6: Reserved bit 7 of a Nav byte for the Up family (uniform 5-bit level).
-pub const VERSION: u32 = 6;
+/// v7: Type kind and effect opcode discriminants renumbered contiguously.
+pub const VERSION: u32 = 7;
 
 /// Section alignment in bytes.
 pub const SECTION_ALIGN: usize = 64;

crates/plotnik-bytecode/src/bytecode/dump.rs

@@ -184,7 +184,6 @@ fn dump_types_defs(out: &mut String, module: &Module, ctx: &DumpContext) {
                 let name = match kind {
                     TypeKind::Void => "<Void>",
                     TypeKind::Node => "<Node>",
-                    TypeKind::String => "<String>",
                     _ => unreachable!(),
                 };
                 (name.to_string(), String::new())

crates/plotnik-bytecode/src/bytecode/effects.rs

@@ -7,7 +7,7 @@ pub const EFFECT_PAYLOAD_BITS: u32 = 10;
 /// Largest representable effect payload (the low [`EFFECT_PAYLOAD_BITS`]).
 pub const EFFECT_PAYLOAD_MAX: usize = (1 << EFFECT_PAYLOAD_BITS) - 1;
 
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
 #[repr(u8)]
 pub enum EffectOpcode {
     Node = 0,
@@ -19,11 +19,10 @@ pub enum EffectOpcode {
     Set = 6,
     Enum = 7,
     EndEnum = 8,
-    Text = 9,
-    Clear = 10,
-    Null = 11,
-    SuppressBegin = 12,
-    SuppressEnd = 13,
+    Clear = 9,
+    Null = 10,
+    SuppressBegin = 11,
+    SuppressEnd = 12,
 }
 
 impl EffectOpcode {
@@ -44,11 +43,10 @@ impl EffectOpcode {
             6 => Self::Set,
             7 => Self::Enum,
             8 => Self::EndEnum,
-            9 => Self::Text,
-            10 => Self::Clear,
-            11 => Self::Null,
-            12 => Self::SuppressBegin,
-            13 => Self::SuppressEnd,
+            9 => Self::Clear,
+            10 => Self::Null,
+            11 => Self::SuppressBegin,
+            12 => Self::SuppressEnd,
             _ => return None,
         };
         Some(op)

crates/plotnik-bytecode/src/bytecode/format.rs

@@ -277,7 +277,6 @@ pub fn format_effect(effect: &EffectOp) -> String {
         EffectOpcode::Set => format!("Set(M{})", effect.payload),
         EffectOpcode::Enum => format!("Enum(M{})", effect.payload),
         EffectOpcode::EndEnum => "EndEnum".to_string(),
-        EffectOpcode::Text => "Text".to_string(),
         EffectOpcode::Clear => "Clear".to_string(),
         EffectOpcode::Null => "Null".to_string(),
         EffectOpcode::SuppressBegin => "SuppressBegin".to_string(),

crates/plotnik-bytecode/src/bytecode/instructions_tests.rs

@@ -193,7 +193,6 @@ fn arb_effect() -> impl Strategy<Value = EffectOp> {
         EffectOpcode::Set,
         EffectOpcode::Enum,
         EffectOpcode::EndEnum,
-        EffectOpcode::Text,
         EffectOpcode::Clear,
         EffectOpcode::Null,
         EffectOpcode::SuppressBegin,

crates/plotnik-bytecode/src/bytecode/module/effect_stack.rs

@@ -276,7 +276,7 @@ fn apply_effect(
 
     let err = || ModuleError::EffectStackImbalance(step);
     match op {
-        Node | Text | Null | Clear => {}
+        Node | Null | Clear => {}
         SuppressBegin => *suppress += 1,
         // At depth 0 a `SuppressEnd` would drive the counter negative — the
         // exact underflow the VM panics on.

crates/plotnik-bytecode/src/bytecode/module/forged_tests.rs

@@ -394,12 +394,12 @@ fn forged_invalid_nav_is_rejected() {
 
 #[test]
 fn forged_invalid_effect_opcode_is_rejected() {
-    // `14` is past the 0..=13 effect range; `EffectOpcode::from_u8` would panic
+    // `13` is past the 0..=12 effect range; `EffectOpcode::from_u8` would panic
     // when the VM emits this effect.
     let mut bytes = emit_bytes(STRUCT_QUERY);
     let slot = effect_slots(&bytes)[0];
     let existing = u16::from_le_bytes([bytes[slot], bytes[slot + 1]]);
-    let forged = (14u16 << 10) | (existing & 0x3FF);
+    let forged = (13u16 << 10) | (existing & 0x3FF);
     bytes[slot..slot + 2].copy_from_slice(&forged.to_le_bytes());
     reseal(&mut bytes);
 
@@ -639,12 +639,12 @@ fn forged_dropped_scope_close_is_rejected() {
 
 #[test]
 fn forged_suppress_underflow_is_rejected() {
-    // Replace a data effect with a bare `SuppressEnd` (opcode 13). With no
+    // Replace a data effect with a bare `SuppressEnd` (opcode 12). With no
     // matching `SuppressBegin` on the path, the VM's suppression counter would
     // underflow and `.expect()` panic; the verifier rejects it at load.
     let mut bytes = emit_bytes(STRUCT_QUERY);
     let slot = first_effect_op(&bytes, |op| op == 4 || op == 6);
-    bytes[slot..slot + 2].copy_from_slice(&(13u16 << 10).to_le_bytes());
+    bytes[slot..slot + 2].copy_from_slice(&(12u16 << 10).to_le_bytes());
     reseal(&mut bytes);
 
     let err = Module::load(&bytes).expect_err("forged SuppressEnd underflow must be rejected");

crates/plotnik-bytecode/src/bytecode/type_meta.rs

@@ -35,7 +35,7 @@ const _: () = assert!(std::mem::size_of::<TypeDef>() == TypeDef::SIZE);
 /// Structured view of TypeDef data, eliminating the need for Option-returning accessors.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum TypeData {
-    /// Primitive types: Void, Node, String.
+    /// Primitive types: Void, Node.
     Primitive(TypeKind),
     /// Wrapper types: Optional, ArrayZeroOrMore, ArrayOneOrMore, Alias.
     Wrapper { kind: TypeKind, inner: TypeId },
@@ -51,7 +51,7 @@ impl TypeDef {
     /// Serialized size in bytes.
     pub const SIZE: usize = 4;
 
-    /// Create a builtin type (Void, Node, String).
+    /// Create a builtin type (Void, Node).
     pub fn builtin(kind: TypeKind) -> Self {
         Self {
             data: 0,
@@ -160,7 +160,7 @@ impl TypeDef {
     pub fn try_classify(&self) -> Option<TypeData> {
         let kind = TypeKind::from_u8(self.kind)?;
         Some(match kind {
-            TypeKind::Void | TypeKind::Node | TypeKind::String => TypeData::Primitive(kind),
+            TypeKind::Void | TypeKind::Node => TypeData::Primitive(kind),
             TypeKind::Optional
             | TypeKind::ArrayZeroOrMore
             | TypeKind::ArrayOneOrMore