Files
marqdo/src/host/json.rs
T
cflmy 9331af78e2 release(2.8.0): 合入 CHANGELOG/README/发版说明/skills prove 任务;CI 链接指向 doc/releases
- CHANGELOG.md:v2.8.0 条目(中英双语);
- README.md:版本行 2.7.1→2.8.0 + 愿景第 6 条(知识可证明);
- doc/releases/v2.8.0.md:双语发版说明(亮点/用法/已知限制);
- skills/marqdo-dev/index.mq.md:新增 prove 任务(路径/目录模式/
  require_lean/json;参数用 + 行声明升参,check 与 narrative-ratio 通过);
- 设计文档 §12.5 标记已合入;发版链接统一指向 doc/releases/v2.8.0.md。
2026-11-18 10:29:26 +08:00

457 lines
18 KiB
Rust
Executable File

//! JSON host primitives + Value↔JSON mapping.
//!
//! Integer gate matches Lean \(V_{\mathsf{safe}}\) (`doc/design/v-safe-json.md`):
//! JSON integers with `|n| > 2^53-1` refuse on encode and decode.
use crate::value::Value;
/// JavaScript `Number.MAX_SAFE_INTEGER` / Lean `ForeignJSON.maxSafe`.
pub const MAX_SAFE_INT: i64 = 9_007_199_254_740_991; // 2^53 - 1
pub fn in_safe_int(n: i64) -> bool {
(-MAX_SAFE_INT..=MAX_SAFE_INT).contains(&n)
}
fn ood_int_err(n: impl std::fmt::Display) -> String {
format!("json: integer outside V_safe (±(2^53-1)): {n}")
}
/// The integer boundary is semantic, not a property of JSON spelling or the
/// host's Int/Num tag. Exponent notation must not bypass it.
fn checked_number(n: f64) -> Result<serde_json::Value, String> {
if !n.is_finite() { return Err("json: non-finite number outside V_safe".into()); }
if n.fract() == 0.0 && n.abs() > MAX_SAFE_INT as f64 { return Err(ood_int_err(n)); }
Ok(serde_json::Value::Number(serde_json::Number::from_f64(n)
.ok_or("json: non-finite number outside V_safe")?))
}
#[derive(Debug)]
pub(crate) enum DecodeError { Syntax(String), Domain(String) }
struct BoundaryValue(Value);
impl<'de> serde::Deserialize<'de> for BoundaryValue {
fn deserialize<D: serde::Deserializer<'de>>(de: D) -> Result<Self, D::Error> {
struct BoundaryVisitor;
impl<'de> serde::de::Visitor<'de> for BoundaryVisitor {
type Value = BoundaryValue;
fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { f.write_str("a boundary JSON value") }
fn visit_unit<E: serde::de::Error>(self) -> Result<Self::Value,E> { Ok(BoundaryValue(Value::None)) }
fn visit_bool<E: serde::de::Error>(self, v: bool) -> Result<Self::Value,E> { Ok(BoundaryValue(Value::Bool(v))) }
fn visit_i64<E: serde::de::Error>(self, n: i64) -> Result<Self::Value,E> {
if !in_safe_int(n) { return Err(E::custom(ood_int_err(n))); }
Ok(BoundaryValue(Value::Int(n)))
}
fn visit_u64<E: serde::de::Error>(self, n: u64) -> Result<Self::Value,E> {
if n > MAX_SAFE_INT as u64 { return Err(E::custom(ood_int_err(n))); }
Ok(BoundaryValue(Value::Int(n as i64)))
}
fn visit_f64<E: serde::de::Error>(self, n: f64) -> Result<Self::Value,E> {
checked_number(n).map_err(E::custom)?;
Ok(BoundaryValue(Value::Num(n)))
}
fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value,E> { Ok(BoundaryValue(Value::Text(v.into()))) }
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value,E> { Ok(BoundaryValue(Value::Text(v))) }
fn visit_seq<A: serde::de::SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value,A::Error> {
let mut xs = Vec::new();
while let Some(BoundaryValue(v)) = seq.next_element()? { xs.push(v); }
Ok(BoundaryValue(Value::List(xs)))
}
fn visit_map<A: serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Self::Value,A::Error> {
use serde::de::Error;
let mut fields = Vec::new();
let mut keys = std::collections::HashSet::new();
while let Some(key) = map.next_key::<String>()? {
if !keys.insert(key.clone()) { return Err(A::Error::custom("json: duplicate object key outside V_safe")); }
let BoundaryValue(v) = map.next_value()?;
fields.push((key, v));
}
// Preserve the pre-existing JSON object's canonical key order.
fields.sort_by(|a, b| a.0.cmp(&b.0));
let value = Value::Map(fields);
value_to_json(&value).map_err(A::Error::custom)?;
Ok(BoundaryValue(value))
}
}
de.deserialize_any(BoundaryVisitor)
}
}
pub(crate) fn decode_text(text: &str) -> Result<Value, DecodeError> {
use serde::Deserialize;
let classify = |error: serde_json::Error| {
let message = error.to_string();
// serde_json categorizes its own numeric-overflow diagnostic as Syntax.
// It is a domain refusal for a grammar-valid unbounded JSON number.
// Match this trusted decoder diagnostic, never foreign program output.
if message.starts_with("number out of range at line ") {
return DecodeError::Domain(format!("json: number outside V_safe: {message}"));
}
match error.classify() {
serde_json::error::Category::Data => DecodeError::Domain(message),
_ => DecodeError::Syntax(message),
}
};
let mut de = serde_json::Deserializer::from_str(text);
let value = BoundaryValue::deserialize(&mut de).map_err(classify)?;
de.end().map_err(classify)?;
Ok(value.0)
}
/// The call protocol envelope is not a runtime column table. Validate each
/// actual argument with BoundaryValue while keeping duplicate-key detection.
pub(crate) fn decode_arguments(text: &str) -> Result<Vec<(String, Value)>, String> {
use serde::Deserialize;
struct Arguments(Vec<(String, Value)>);
impl<'de> serde::Deserialize<'de> for Arguments {
fn deserialize<D: serde::Deserializer<'de>>(de: D) -> Result<Self,D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = Arguments;
fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
f.write_str("a JSON object of named arguments")
}
fn visit_map<A: serde::de::MapAccess<'de>>(self, mut map: A) -> Result<Arguments,A::Error> {
use serde::de::Error;
let mut args = Vec::new();
let mut keys = std::collections::HashSet::new();
while let Some(key) = map.next_key::<String>()? {
if !keys.insert(key.clone()) { return Err(A::Error::custom("duplicate argument name")); }
let BoundaryValue(value) = map.next_value()?;
args.push((key, value));
}
Ok(Arguments(args))
}
}
de.deserialize_map(Visitor)
}
}
let mut de = serde_json::Deserializer::from_str(text);
let args = Arguments::deserialize(&mut de).map_err(|e| e.to_string())?;
de.end().map_err(|e| e.to_string())?;
Ok(args.0)
}
pub fn parse(text: &Value) -> Result<Value, String> {
let s = match text {
Value::Text(s) => s.as_str(),
_ => return Err("json parse needs text".into()),
};
decode_text(s).map_err(|e| match e {
DecodeError::Syntax(e) | DecodeError::Domain(e) => format!("json parse: {e}"),
})
}
pub fn stringify(value: &Value, indent: Option<&Value>) -> Result<Value, String> {
let j = value_to_json(value)?;
let pretty = match indent {
None => false,
Some(Value::Int(n)) => *n > 0,
Some(Value::Bool(b)) => *b,
Some(Value::None) => false,
Some(_) => return Err("json stringify indent must be int or bool".into()),
};
let s = if pretty {
serde_json::to_string_pretty(&j).map_err(|e| format!("json stringify: {e}"))?
} else {
serde_json::to_string(&j).map_err(|e| format!("json stringify: {e}"))?
};
Ok(Value::Text(s))
}
pub fn get(value: &Value, key: &Value) -> Result<Value, String> {
let k = match key {
Value::Text(s) => s.as_str(),
_ => return Err("json get key must be text".into()),
};
match value {
Value::Map(entries) => Ok(entries
.iter()
.find(|(kk, _)| kk == k)
.map(|(_, v)| v.clone())
.unwrap_or(Value::None)),
_ => Err("json get needs map".into()),
}
}
pub fn keys(value: &Value) -> Result<Value, String> {
match value {
Value::Map(entries) => Ok(Value::List(
entries.iter().map(|(k, _)| Value::Text(k.clone())).collect(),
)),
_ => Err("json keys needs map".into()),
}
}
/// JSON-encode a text value including surrounding quotes (for building request bodies).
pub fn quote(text: &Value) -> Result<Value, String> {
let s = match text {
Value::Text(s) => s.as_str(),
_ => return Err("json quote needs text".into()),
};
serde_json::to_string(s)
.map(Value::Text)
.map_err(|e| format!("json quote: {e}"))
}
pub(crate) fn json_to_value(v: &serde_json::Value) -> Result<Value, String> {
Ok(match v {
serde_json::Value::Null => Value::None,
serde_json::Value::Bool(b) => Value::Bool(*b),
serde_json::Value::Number(n) => {
if let Some(i) = n.as_i64() {
if !in_safe_int(i) {
return Err(ood_int_err(i));
}
Value::Int(i)
} else if let Some(u) = n.as_u64() {
// Always > i64::MAX ⇒ outside V_safe; never coerce via f64/Text.
return Err(ood_int_err(u));
} else if let Some(f) = n.as_f64() {
// Host extension: non-integer JSON numbers → Num (not in Lean SafeVal).
checked_number(f)?;
Value::Num(f)
} else {
return Err(format!("json: unsupported number: {n}"));
}
}
serde_json::Value::String(s) => Value::Text(s.clone()),
serde_json::Value::Array(xs) => {
let mut out = Vec::with_capacity(xs.len());
for x in xs {
out.push(json_to_value(x)?);
}
Value::List(out)
}
serde_json::Value::Object(map) => {
let mut entries = Vec::with_capacity(map.len());
for (k, v) in map {
entries.push((k.clone(), json_to_value(v)?));
}
Value::Map(entries)
}
})
}
pub(crate) fn value_to_json(v: &Value) -> Result<serde_json::Value, String> {
Ok(match v {
Value::None => serde_json::Value::Null,
Value::Bool(b) => serde_json::Value::Bool(*b),
Value::Int(n) => {
if !in_safe_int(*n) {
return Err(ood_int_err(*n));
}
serde_json::Value::Number((*n).into())
}
Value::Num(n) => checked_number(*n)?,
Value::Text(s) => serde_json::Value::String(s.clone()),
Value::List(xs) => {
let mut arr = Vec::with_capacity(xs.len());
for x in xs {
arr.push(value_to_json(x)?);
}
serde_json::Value::Array(arr)
}
Value::Map(entries) => {
// Column-table maps (all fields lists): refuse unequal list lengths.
let list_lens: Vec<usize> = entries
.iter()
.filter_map(|(_, v)| match v {
Value::List(xs) => Some(xs.len()),
_ => None,
})
.collect();
if list_lens.len() == entries.len() && list_lens.len() >= 2 {
let n0 = list_lens[0];
if list_lens.iter().any(|&n| n != n0) {
return Err(
"json: table column arity mismatch (unequal list lengths)".into(),
);
}
}
let mut map = serde_json::Map::new();
for (k, v) in entries {
map.insert(k.clone(), value_to_json(v)?);
}
serde_json::Value::Object(map)
}
Value::Formula(e) => match e {
crate::formula::Expr::Matrix { rows, .. } => {
let mut arr = Vec::with_capacity(rows.len());
for row in rows {
let mut cells = Vec::with_capacity(row.len());
for &n in row {
cells.push(
serde_json::Number::from_f64(n)
.map(serde_json::Value::Number)
.ok_or_else(|| "json: non-finite number outside V_safe".to_string())?,
);
}
arr.push(serde_json::Value::Array(cells));
}
serde_json::Value::Array(arr)
}
other => {
let s = crate::formula::simplify(other);
if let crate::formula::Expr::Num(n) = s {
serde_json::Number::from_f64(n)
.map(serde_json::Value::Number)
.ok_or_else(|| "json: non-finite number outside V_safe".to_string())?
} else {
serde_json::Value::String(e.as_display())
}
}
},
Value::Code(c) => serde_json::Value::String(c.source.clone()),
Value::Secret(_) => serde_json::Value::String("<secret>".into()),
Value::Handle(_) => {
return Err("json: session handle cannot be serialized".into());
}
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn quote_escapes_text() {
let q = quote(&Value::Text("a\"b".into())).unwrap();
assert_eq!(q, Value::Text("\"a\\\"b\"".into()));
}
#[test]
fn roundtrip_max_safe() {
for n in [MAX_SAFE_INT, -MAX_SAFE_INT, 0_i64, 1, -1] {
let j = value_to_json(&Value::Int(n)).unwrap();
let v = json_to_value(&j).unwrap();
assert_eq!(v, Value::Int(n));
}
}
#[test]
fn refuse_ood_encode() {
for n in [
MAX_SAFE_INT + 1,
-MAX_SAFE_INT - 1,
1_i64 << 53, // 2^53
1_i64 << 60, // 2^60
(1_i64 << 60) + 1, // 2^60+1
] {
let err = value_to_json(&Value::Int(n)).unwrap_err();
assert!(
err.contains("outside V_safe"),
"encode {n}: {err}"
);
}
}
#[test]
fn refuse_ood_decode() {
for n in [
MAX_SAFE_INT + 1,
-MAX_SAFE_INT - 1,
1_i64 << 53,
1_i64 << 60,
(1_i64 << 60) + 1,
] {
let raw = format!("{n}");
let j: serde_json::Value = serde_json::from_str(&raw).unwrap();
let err = json_to_value(&j).unwrap_err();
assert!(
err.contains("outside V_safe"),
"decode {n}: {err}"
);
}
}
#[test]
fn refuse_nested_ood() {
let j: serde_json::Value =
serde_json::from_str("{\"a\":[1152921504606846977]}").unwrap();
let err = json_to_value(&j).unwrap_err();
assert!(err.contains("outside V_safe"), "{err}");
}
#[test]
fn decimal_string_ok() {
let j = serde_json::Value::String("1152921504606846977".into());
assert_eq!(
json_to_value(&j).unwrap(),
Value::Text("1152921504606846977".into())
);
}
#[test]
fn float_host_extension_ok() {
let j: serde_json::Value = serde_json::from_str("1.5").unwrap();
match json_to_value(&j).unwrap() {
Value::Num(f) => assert!((f - 1.5).abs() < 1e-12),
other => panic!("expected Num, got {other:?}"),
}
}
#[test]
fn refuse_u64_above_i64_max() {
// 2^63 as JSON integer: as_i64 fails, as_u64 succeeds.
let j: serde_json::Value = serde_json::from_str("9223372036854775808").unwrap();
let err = json_to_value(&j).unwrap_err();
assert!(err.contains("outside V_safe"), "{err}");
}
#[test]
fn refuse_session_handle_encode() {
let err = value_to_json(&Value::Handle("s1".into())).unwrap_err();
assert!(
err.contains("session handle cannot be serialized"),
"{err}"
);
}
#[test]
fn refuse_unequal_column_table_encode() {
let ragged = Value::Map(vec![
("a".into(), Value::List(vec![Value::Int(1), Value::Int(2)])),
("b".into(), Value::List(vec![Value::Int(3)])),
]);
let err = value_to_json(&ragged).unwrap_err();
assert!(err.contains("arity mismatch"), "{err}");
}
#[test]
fn refuse_nonfinite_in_nested_payloads() {
for n in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
for v in [Value::Num(n), Value::List(vec![Value::Num(n)]),
Value::Map(vec![("x".into(), Value::Num(n))])] {
assert!(value_to_json(&v).unwrap_err().contains("outside V_safe"));
}
}
}
#[test]
fn exponent_and_float_tags_cannot_bypass_integer_domain() {
for text in ["9007199254740992.0", "9.007199254740992e15", "1e100", "1e9999", "-9.007199254740992e15"] {
assert!(parse(&Value::Text(text.into())).unwrap_err().contains("outside V_safe"), "{text}");
}
for n in [9_007_199_254_740_992.0, -9_007_199_254_740_992.0, 1e100] {
assert!(value_to_json(&Value::List(vec![Value::Num(n)])).unwrap_err().contains("outside V_safe"));
}
for text in ["1.5", "-0.0", "9.007199254740991e15"] {
assert!(parse(&Value::Text(text.into())).is_ok(), "valid extension {text}");
}
}
#[test]
fn strict_decode_refuses_duplicate_keys_and_ragged_columns() {
for text in [r#"{"a":1,"a":2}"#, r#"[{"x":null,"x":true}]"#,
r#"{"a":[1],"b":[2,3]}"#] {
assert!(matches!(decode_text(text), Err(DecodeError::Domain(_))), "{text}");
}
for text in [r#"{"a":[1],"b":"metadata"}"#, r#"{"a":[],"b":[]}"#,
r#"{"__proto__":{"safe":true},"constructor":"data"}"#] {
assert!(decode_text(text).is_ok(), "{text}");
}
assert!(matches!(decode_text("not JSON"), Err(DecodeError::Syntax(_))));
}
}