Remove unsigned integer type for now

src/wasm-lib/kcl/src/ast/types.rs

@@ -1346,7 +1346,6 @@ impl Literal {
             // calling (6.0).to_string() outputs "6" not "6.0".
             // It's important that fractional numbers stay fractional after recasting.
             LiteralValue::Fractional(n) => format!("{n:?}"),
-            LiteralValue::UInteger(n) => n.to_string(),
             LiteralValue::IInteger(n) => n.to_string(),
             LiteralValue::String(ref s) => {
                 let quote = if self.raw.trim().starts_with('"') { '"' } else { '\'' };
@@ -1972,8 +1971,7 @@ impl MemberExpression {
             LiteralIdentifier::Literal(literal) => {
                 let value = literal.value.clone();
                 match value {
-                    LiteralValue::UInteger(x) => return self.get_result_array(memory, x as usize),
-                    LiteralValue::IInteger(x) if x > 0 => return self.get_result_array(memory, x as usize),
+                    LiteralValue::IInteger(x) if x >= 0 => return self.get_result_array(memory, x as usize),
                     LiteralValue::IInteger(x) => {
                         return Err(KclError::Syntax(KclErrorDetails {
                             source_ranges: vec![self.into()],

src/wasm-lib/kcl/src/ast/types/literal_value.rs

@@ -8,7 +8,6 @@ use super::{Literal, Value};
 #[ts(export)]
 #[serde(tag = "type", content = "data", rename_all = "snake_case")]
 pub enum LiteralValue {
-    UInteger(u64),
     IInteger(i64),
     Fractional(f64),
     String(String),
@@ -24,7 +23,6 @@ impl From<LiteralValue> for JValue {
     fn from(value: LiteralValue) -> Self {
         match value {
             LiteralValue::IInteger(x) => x.into(),
-            LiteralValue::UInteger(x) => x.into(),
             LiteralValue::Fractional(x) => x.into(),
             LiteralValue::String(x) => x.into(),
         }
@@ -49,24 +47,19 @@ impl From<String> for LiteralValue {
     }
 }
 
-impl From<u64> for LiteralValue {
-    fn from(value: u64) -> Self {
-        Self::UInteger(value)
-    }
-}
 impl From<u32> for LiteralValue {
     fn from(value: u32) -> Self {
-        Self::UInteger(value as u64)
+        Self::IInteger(value as i64)
     }
 }
 impl From<u16> for LiteralValue {
     fn from(value: u16) -> Self {
-        Self::UInteger(value as u64)
+        Self::IInteger(value as i64)
     }
 }
 impl From<u8> for LiteralValue {
     fn from(value: u8) -> Self {
-        Self::UInteger(value as u64)
+        Self::IInteger(value as i64)
     }
 }
 impl From<&'static str> for LiteralValue {

src/wasm-lib/kcl/src/parser/math.rs

@@ -94,7 +94,7 @@ mod tests {
     #[test]
     fn parse_and_evaluate() {
         /// Make a literal
-        fn lit(n: u64) -> BinaryPart {
+        fn lit(n: i64) -> BinaryPart {
             BinaryPart::Literal(Box::new(Literal {
                 start: 0,
                 end: 0,

src/wasm-lib/kcl/src/parser/parser_impl.rs

@@ -238,7 +238,7 @@ fn unsigned_number_literal(i: TokenSlice) -> PResult<Literal> {
         .try_map(|token: Token| match token.token_type {
             TokenType::Number => {
                 if let Ok(x) = token.value.parse::<u64>() {
-                    return Ok((LiteralValue::UInteger(x), token));
+                    return Ok((LiteralValue::IInteger(x as i64), token));
                 }
                 let x: f64 = token.value.parse().map_err(|_| {
                     KclError::Syntax(KclErrorDetails {
@@ -397,6 +397,7 @@ fn integer_range(i: TokenSlice) -> PResult<Vec<Value>> {
     let (_token1, ceiling) = integer.parse_next(i)?;
     Ok((floor..=ceiling)
         .map(|num| {
+            let num = num as i64;
             Value::Literal(Box::new(Literal {
                 start: token0.start,
                 end: token0.end,