Update.

Author: dsherret

src/ast.rs

@@ -68,10 +68,31 @@ impl<'a> From<Value<'a>> for serde_json::Value {
       }
       Value::BooleanLit(b) => serde_json::Value::Bool(b.value),
       Value::NullKeyword(_) => serde_json::Value::Null,
-      Value::NumberLit(num) => match serde_json::Number::from_str(num.value) {
-        Ok(number) => serde_json::Value::Number(number),
-        Err(_) => serde_json::Value::String(num.value.to_string()),
-      },
+      Value::NumberLit(num) => {
+        // Check if this is a hexadecimal literal (0x or 0X prefix)
+        let num_str = num.value.trim_start_matches('-');
+        if num_str.len() > 2 && (num_str.starts_with("0x") || num_str.starts_with("0X")) {
+          // Parse hexadecimal and convert to decimal
+          let hex_part = &num_str[2..];
+          match i64::from_str_radix(hex_part, 16) {
+            Ok(decimal_value) => {
+              let final_value = if num.value.starts_with('-') {
+                -decimal_value
+              } else {
+                decimal_value
+              };
+              serde_json::Value::Number(serde_json::Number::from(final_value))
+            }
+            Err(_) => serde_json::Value::String(num.value.to_string()),
+          }
+        } else {
+          // Standard decimal number
+          match serde_json::Number::from_str(num.value) {
+            Ok(number) => serde_json::Value::Number(number),
+            Err(_) => serde_json::Value::String(num.value.to_string()),
+          }
+        }
+      }
       Value::Object(obj) => {
         let mut map = serde_json::map::Map::new();
         for prop in obj.properties {

src/cst/mod.rs

@@ -1442,10 +1442,30 @@ impl CstNumberLit {
   pub fn to_serde_value(&self) -> Option<serde_json::Value> {
     use std::str::FromStr;
     let raw = self.0.borrow().value.clone();
-    match serde_json::Number::from_str(&raw) {
-      Ok(number) => Some(serde_json::Value::Number(number)),
-      // If the number is invalid, return it as a string (same behavior as AST conversion)
-      Err(_) => Some(serde_json::Value::String(raw)),
+
+    // check if this is a hexadecimal literal (0x or 0X prefix)
+    let num_str = raw.trim_start_matches('-');
+    if num_str.len() > 2 && (num_str.starts_with("0x") || num_str.starts_with("0X")) {
+      // parse hexadecimal and convert to decimal
+      let hex_part = &num_str[2..];
+      match i64::from_str_radix(hex_part, 16) {
+        Ok(decimal_value) => {
+          let final_value = if raw.starts_with('-') {
+            -decimal_value
+          } else {
+            decimal_value
+          };
+          Some(serde_json::Value::Number(serde_json::Number::from(final_value)))
+        }
+        Err(_) => Some(serde_json::Value::String(raw)),
+      }
+    } else {
+      // standard decimal number
+      match serde_json::Number::from_str(&raw) {
+        Ok(number) => Some(serde_json::Value::Number(number)),
+        // if the number is invalid, return it as a string (same behavior as AST conversion)
+        Err(_) => Some(serde_json::Value::String(raw)),
+      }
     }
   }
 }

src/parse_to_ast.rs

@@ -576,21 +576,30 @@ mod tests {
 
   #[test]
   fn it_should_parse_unquoted_keys_with_hex_and_trailing_comma() {
-    let parse_result = parse_to_ast(
-      r#"{
+    let text = r#"{
       CP_CanFuncReqId: 0x7DF,  // 2015
-  }"#,
-      &Default::default(),
-      &Default::default(),
-    )
-    .unwrap();
+  }"#;
+    {
+      let parse_result = parse_to_ast(text, &Default::default(), &Default::default()).unwrap();
 
-    let value = parse_result.value.unwrap();
-    let obj = value.as_object().unwrap();
-    assert_eq!(obj.properties.len(), 1);
-    assert_eq!(obj.properties[0].name.as_str(), "CP_CanFuncReqId");
+      let value = parse_result.value.unwrap();
+      let obj = value.as_object().unwrap();
+      assert_eq!(obj.properties.len(), 1);
+      assert_eq!(obj.properties[0].name.as_str(), "CP_CanFuncReqId");
 
-    let number_value = obj.properties[0].value.as_number_lit().unwrap();
-    assert_eq!(number_value.value, "0x7DF");
+      let number_value = obj.properties[0].value.as_number_lit().unwrap();
+      assert_eq!(number_value.value, "0x7DF");
+    }
+    #[cfg(feature = "serde")]
+    {
+      let value = crate::parse_to_serde_value(text, &Default::default()).unwrap().unwrap();
+      // hexadecimal numbers are converted to decimal in serde output
+      assert_eq!(
+        value,
+        serde_json::json!({
+          "CP_CanFuncReqId": 2015
+        })
+      );
+    }
   }
 }

src/serde.rs

@@ -84,4 +84,24 @@ mod tests {
 
     assert_eq!(result, Some(SerdeValue::Object(expected_value)));
   }
+
+  #[test]
+  fn it_should_parse_hexadecimal_numbers_to_decimal() {
+    let result = parse_to_serde_value(
+      r#"{
+        "hex1": 0x7DF,
+        "hex2": 0xFF,
+        "hex3": 0x10
+      }"#,
+      &Default::default(),
+    )
+    .unwrap();
+
+    let mut expected_value = serde_json::map::Map::new();
+    expected_value.insert("hex1".to_string(), SerdeValue::Number(serde_json::Number::from(2015)));
+    expected_value.insert("hex2".to_string(), SerdeValue::Number(serde_json::Number::from(255)));
+    expected_value.insert("hex3".to_string(), SerdeValue::Number(serde_json::Number::from(16)));
+
+    assert_eq!(result, Some(SerdeValue::Object(expected_value)));
+  }
 }