Files
horizon-airdef/crates/horizon-client/examples/command_parse_fixture.rs
T
Ludovic Marie 1e03d531eb Parse every command exactly as vanilla's Brigadier tree does
Ports vanilla's packrat parser with SNBT and component-predicate grammars, the
entity selector, block state and item parsers, resource-or-inline codec
arguments, and the remaining argument types, suggestion providers and error
cursors. The tree gains compute, data modify compute, place, locate poi,
datapack create, item modifiers and the parse-only commands (dialog, kick,
posteffect, fetchprofile, spectate, publish, waypoint, debug, jfr), with
release-dispatcher permissions. /particle takes the 26.3 option syntax.

The oracle's stand-in server now holds a fresh world's real state (data pack
managers, pack repository, empty storages, clocks, templates, an overworld),
so vanilla answers every input instead of crashing on about 1,100 per level.
The command parse harness matches on 39,685 of 39,685 commands at permission
levels 4, 2 and 0.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-10 20:56:06 +02:00

257 lines
11 KiB
Rust

//! Command parsing for differential tests against vanilla's Brigadier tree
//! (tools/test_command_parse_parity.py): reads one command per line and prints
//! the parse result, the error (rendered text and UTF-16 cursor), the parsed
//! node names and the completion suggestions at the end of the input, in the
//! same JSON-lines shape as VanillaCommandParseOracle.
//!
//! usage: command_parse_fixture RESOURCES REGISTRIES.json CORPUS PERMISSION OUTPUT
use horizon_client::{
command::{ArgType, Dispatcher, NodeKind, Registries, args::RegistryIds, vanilla},
lang,
};
use serde_json::{Value, json};
use std::{fs, path::Path};
fn strings(v: &Value) -> Vec<String> {
v.as_array()
.map(|a| {
a.iter()
.filter_map(|x| x.as_str().map(str::to_owned))
.collect()
})
.unwrap_or_default()
}
fn utf16(input: &str, byte: usize) -> usize {
let mut end = byte.min(input.len());
while !input.is_char_boundary(end) {
end -= 1;
}
input[..end].encode_utf16().count()
}
fn parser_id(ty: &ArgType) -> String {
match ty {
ArgType::Bool => "brigadier:bool".into(),
ArgType::Integer { .. } => "brigadier:integer".into(),
ArgType::Float { .. } => "brigadier:float".into(),
ArgType::Double { .. } => "brigadier:double".into(),
ArgType::Word | ArgType::Str | ArgType::Greedy => "brigadier:string".into(),
ArgType::Entity { .. } => "minecraft:entity".into(),
ArgType::BlockPos => "minecraft:block_pos".into(),
ArgType::Vec3 { .. } => "minecraft:vec3".into(),
ArgType::Rotation => "minecraft:rotation".into(),
ArgType::Angle => "minecraft:angle".into(),
ArgType::Item => "minecraft:item_stack".into(),
ArgType::ItemPredicate => "minecraft:item_predicate".into(),
ArgType::BlockState => "minecraft:block_state".into(),
ArgType::BlockPredicate => "minecraft:block_predicate".into(),
ArgType::Resource(_) => "minecraft:resource".into(),
ArgType::Id(_) => "minecraft:resource_location".into(),
ArgType::Res(_) => "minecraft:resource".into(),
ArgType::ResKey(_) => "minecraft:resource_key".into(),
ArgType::ResOrTag(_) => "minecraft:resource_or_tag".into(),
ArgType::ResOrTagKey(_) => "minecraft:resource_or_tag_key".into(),
ArgType::StrEnum(values, _) => match values.first().copied() {
Some("world_surface") => "minecraft:heightmap".into(),
Some("none") if values.len() == 3 && values[1] == "left_right" => "minecraft:template_mirror".into(),
Some("none") if values.len() == 3 => "minecraft:swing_animation".into(),
_ => "minecraft:template_rotation".into(),
},
ArgType::HexColor => "minecraft:hex_color".into(),
ArgType::Uuid => "minecraft:uuid".into(),
ArgType::GameProfile => "minecraft:game_profile".into(),
ArgType::Style => "minecraft:style".into(),
ArgType::Name(_) => "brigadier:string".into(),
ArgType::Time { .. } => "minecraft:time".into(),
ArgType::GameMode => "minecraft:gamemode".into(),
ArgType::Message => "minecraft:message".into(),
ArgType::Dimension => "minecraft:dimension".into(),
ArgType::Anchor => "minecraft:entity_anchor".into(),
ArgType::Swizzle => "minecraft:swizzle".into(),
ArgType::Component => "minecraft:component".into(),
ArgType::Nbt => "minecraft:nbt_compound_tag".into(),
ArgType::ScoreHolder { .. } => "minecraft:score_holder".into(),
ArgType::Objective => "minecraft:objective".into(),
ArgType::Team => "minecraft:team".into(),
ArgType::Criteria => "minecraft:objective_criteria".into(),
ArgType::ScoreboardSlot => "minecraft:scoreboard_slot".into(),
ArgType::Operation => "minecraft:operation".into(),
ArgType::TeamColor => "minecraft:team_color".into(),
ArgType::IntRange => "minecraft:int_range".into(),
ArgType::FloatRange => "minecraft:float_range".into(),
ArgType::NbtPath => "minecraft:nbt_path".into(),
ArgType::NbtTag => "minecraft:nbt_tag".into(),
ArgType::Vec2 => "minecraft:vec2".into(),
ArgType::ColumnPos => "minecraft:column_pos".into(),
ArgType::Particle => "minecraft:particle".into(),
ArgType::Enum(words) => format!("enum:{}", words.join("|")),
ArgType::Function => "minecraft:function".into(),
ArgType::Slots => "minecraft:slots".into(),
ArgType::Slot => "minecraft:item_slot".into(),
ArgType::SlotSource => "minecraft:slot_source".into(),
ArgType::ResourceOrId(r) => match *r {
"minecraft:loot_table" => "minecraft:loot_table".into(),
"minecraft:item_modifier" => "minecraft:loot_modifier".into(),
"minecraft:predicate" => "minecraft:loot_predicate".into(),
"minecraft:context_int_provider" => "minecraft:context_int_provider".into(),
"minecraft:context_float_provider" => "minecraft:context_float_provider".into(),
"minecraft:dialog" => "minecraft:dialog".into(),
_ => "minecraft:feature".into(),
},
}
}
fn tree(d: &Dispatcher, node: usize) -> Value {
let n = &d.nodes[node];
let mut children = serde_json::Map::new();
for &c in &n.children {
let child = &d.nodes[c];
let mut v = tree(d, c);
match &child.kind {
NodeKind::Literal(_) => v["type"] = json!("literal"),
NodeKind::Argument { ty, .. } => {
v["type"] = json!("argument");
v["parser"] = json!(parser_id(ty));
}
NodeKind::Root => {}
}
children.insert(child.name().to_owned(), v);
}
let mut v = json!({"children": children});
if n.command.is_some() {
v["executable"] = json!(true);
}
if n.redirect.is_some() {
v["redirect"] = json!(true);
}
v
}
fn main() -> horizon_client::Result<()> {
let args: Vec<String> = std::env::args().collect();
if args.get(1).map(String::as_str) == Some("tree") {
let d = vanilla::release_dispatcher();
let mut v = tree(d, 0);
v["type"] = json!("root");
fs::write(&args[2], v.to_string())?;
return Ok(());
}
if args.len() != 6 {
return Err(
"usage: command_parse_fixture RESOURCES REGISTRIES CORPUS PERMISSION OUTPUT".into(),
);
}
let root = Path::new(&args[1]).to_path_buf();
lang::set(lang::Language::load(&[&root], lang::DEFAULT));
let r: Value = serde_json::from_slice(&fs::read(&args[2])?)?;
let mut reg = Registries {
permission: args[4].parse()?,
..Registries::default()
};
reg.items = strings(&r["items"]);
reg.item_tags = strings(&r["item_tags"]);
reg.block_tags = strings(&r["block_tags"]);
for (id, props) in r["blocks"].as_object().into_iter().flatten() {
let props = props
.as_array()
.into_iter()
.flatten()
.map(|p| (p[0].as_str().unwrap_or("").to_owned(), strings(&p[1])))
.collect();
reg.blocks.insert(id.clone(), props);
}
reg.summonable = strings(&r["summonable"]);
reg.entity_types = strings(&r["entity_types"]);
reg.effects = strings(&r["effects"]);
reg.attributes = strings(&r["attributes"]);
reg.sounds = strings(&r["sounds"]);
reg.enchantments = strings(&r["enchantments"]);
reg.structures = strings(&r["structures"]);
reg.biomes = strings(&r["biomes"]);
reg.damage_types = strings(&r["damage_types"]);
reg.clocks = strings(&r["clocks"]);
reg.timelines = strings(&r["timelines"]);
reg.dimensions = strings(&r["dimensions"]);
reg.players = strings(&r["players"]);
reg.teams = strings(&r["teams"]);
reg.objectives = strings(&r["objectives"]);
reg.tracked = strings(&r["tracked"]);
for (name, entry) in r["by_registry"].as_object().into_iter().flatten() {
reg.by_registry.insert(
name.clone(),
RegistryIds {
ids: strings(&entry["ids"]),
tags: strings(&entry["tags"]),
},
);
}
reg.block_entities = strings(&r["block_entities"]).into_iter().collect();
for (tag, members) in r["block_tag_members"].as_object().into_iter().flatten() {
reg.block_tag_members.insert(tag.clone(), strings(members));
}
reg.templates = strings(&r["templates"]);
reg.persistent_components = strings(&r["persistent_components"]);
reg.learnable_recipes = strings(&r["learnable_recipes"]);
for (clock, markers) in r["clock_time_markers"].as_object().into_iter().flatten() {
reg.clock_time_markers.insert(clock.clone(), strings(markers));
}
for (id, criteria) in r["advancement_criteria"].as_object().into_iter().flatten() {
reg.advancement_criteria.insert(id.clone(), strings(criteria));
}
reg.datapacks_enabled = strings(&r["datapacks_selected"]);
let enabled = reg.datapacks_enabled.clone();
reg.datapacks_disabled = strings(&r["datapacks_enableable"])
.into_iter()
.filter(|p| !enabled.contains(p))
.collect();
reg.advancements = reg.ids("minecraft:advancement").to_vec();
reg.recipes = reg.ids("minecraft:recipe").to_vec();
reg.loot_tables = reg.ids("minecraft:loot_table").to_vec();
reg.predicates = reg.ids("minecraft:predicate").to_vec();
reg.item_modifiers = reg.ids("minecraft:item_modifier").to_vec();
let dispatcher = vanilla::release_dispatcher();
let mut out = String::new();
for input in fs::read_to_string(&args[3])?.lines() {
let parse = dispatcher.parse(input, &reg);
let result = match parse.executable() {
Ok(_) => {
let mut nodes = Vec::new();
let mut c = Some(&parse.context);
while let Some(ctx) = c {
nodes.extend(
ctx.nodes
.iter()
.map(|(n, _)| dispatcher.nodes[*n].name().to_owned()),
);
c = ctx.child.as_deref();
}
json!({"ok": true, "nodes": nodes})
}
Err(e) => json!({
"ok": false,
"error": e.message.plain(),
// CommandSyntaxException.getCursor is -1 without context.
"cursor": if e.input.is_some() { utf16(input, e.cursor) as i64 } else { -1 },
}),
};
let (range, list) = dispatcher.suggestions(&parse, input.len(), &reg);
let list: Vec<String> = list
.into_iter()
.map(|s| match s.tooltip {
Some(t) => format!("{}\t{t}", s.text),
None => s.text,
})
.collect();
let row = json!({
"in": input,
"parse": result,
"sugg": {"start": utf16(input, range.0), "end": utf16(input, range.1), "list": list},
});
out.push_str(&row.to_string());
out.push('\n');
}
fs::write(&args[5], out)?;
Ok(())
}