- 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。
457 lines
18 KiB
Rust
Executable File
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(_))));
|
|
}
|
|
|
|
}
|