From 5e685d66415b67017acf5536d2bfc6c1fd4f6f9f Mon Sep 17 00:00:00 2001 From: Jeff Date: Wed, 14 Feb 2024 19:07:34 -0500 Subject: [PATCH] Remove structure from map types --- src/abstract_tree/built_in_value.rs | 13 +++++-------- src/abstract_tree/index.rs | 12 +----------- src/abstract_tree/type.rs | 24 ++++++++++-------------- src/abstract_tree/value_node.rs | 12 ++---------- src/value/mod.rs | 15 ++------------- tests/as.rs | 2 +- 6 files changed, 21 insertions(+), 57 deletions(-) diff --git a/src/abstract_tree/built_in_value.rs b/src/abstract_tree/built_in_value.rs index a71114f..10c81c0 100644 --- a/src/abstract_tree/built_in_value.rs +++ b/src/abstract_tree/built_in_value.rs @@ -6,8 +6,7 @@ use serde::{Deserialize, Serialize}; use crate::{ built_in_functions::{fs::fs_functions, json::json_functions, str::string_functions, Callable}, error::{RuntimeError, SyntaxError, ValidationError}, - AbstractTree, BuiltInFunction, Context, Format, Function, List, Map, Structure, SyntaxNode, - Type, Value, + AbstractTree, BuiltInFunction, Context, Format, Function, List, Map, SyntaxNode, Type, Value, }; static ARGS: OnceLock = OnceLock::new(); @@ -87,14 +86,12 @@ impl BuiltInValue { match self { BuiltInValue::Args => Type::list(Type::String), BuiltInValue::AssertEqual => BuiltInFunction::AssertEqual.r#type(), - BuiltInValue::Fs => Type::Map(None), - BuiltInValue::Json => Type::Map(Some( - Structure::from_map(self.get().as_map().unwrap()).unwrap(), - )), + BuiltInValue::Fs => Type::Map, + BuiltInValue::Json => Type::Map, BuiltInValue::Length => BuiltInFunction::Length.r#type(), BuiltInValue::Output => BuiltInFunction::Output.r#type(), - BuiltInValue::Random => Type::Map(None), - BuiltInValue::Str => Type::Map(None), + BuiltInValue::Random => Type::Map, + BuiltInValue::Str => Type::Map, } } diff --git a/src/abstract_tree/index.rs b/src/abstract_tree/index.rs index a401235..4eb6c1b 100644 --- a/src/abstract_tree/index.rs +++ b/src/abstract_tree/index.rs @@ -48,17 +48,7 @@ impl AbstractTree for Index { fn expected_type(&self, context: &Context) -> Result { match self.collection.expected_type(context)? { Type::List(item_type) => Ok(*item_type.clone()), - Type::Map(structure) => { - if let Some(structure) = structure { - if let IndexExpression::Identifier(identifier) = &self.index { - if let Some((_, r#type)) = structure.inner().get(identifier.inner()) { - return Ok(r#type.clone()); - } - } - } - - Ok(Type::Any) - } + Type::Map => Ok(Type::Any), Type::None => Ok(Type::None), r#type => Ok(r#type), } diff --git a/src/abstract_tree/type.rs b/src/abstract_tree/type.rs index c8a68c8..b1092f9 100644 --- a/src/abstract_tree/type.rs +++ b/src/abstract_tree/type.rs @@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize}; use crate::{ error::{RuntimeError, SyntaxError, ValidationError}, - AbstractTree, Context, Format, Identifier, Structure, SyntaxNode, Value, + AbstractTree, Context, Format, Identifier, SyntaxNode, Value, }; #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)] @@ -20,7 +20,7 @@ pub enum Type { }, Integer, List(Box), - Map(Option), + Map, None, Number, String, @@ -58,13 +58,13 @@ impl Type { | (Type::Collection, Type::Collection) | (Type::Collection, Type::List(_)) | (Type::List(_), Type::Collection) - | (Type::Collection, Type::Map(_)) - | (Type::Map(_), Type::Collection) + | (Type::Collection, Type::Map) + | (Type::Map, Type::Collection) | (Type::Collection, Type::String) | (Type::String, Type::Collection) | (Type::Float, Type::Float) | (Type::Integer, Type::Integer) - | (Type::Map(_), Type::Map(_)) + | (Type::Map, Type::Map) | (Type::Number, Type::Number) | (Type::Number, Type::Integer) | (Type::Number, Type::Float) @@ -121,7 +121,7 @@ impl Type { } pub fn is_map(&self) -> bool { - matches!(self, Type::Map(_)) + matches!(self, Type::Map) } } @@ -173,7 +173,7 @@ impl AbstractTree for Type { } } "int" => Type::Integer, - "map" => Type::Map(None), + "map" => Type::Map, "num" => Type::Number, "none" => Type::None, "str" => Type::String, @@ -241,12 +241,8 @@ impl Format for Type { item_type.format(output, indent_level); output.push(']'); } - Type::Map(structure_option) => { - if let Some(structure) = structure_option { - output.push_str(&structure.to_string()); - } else { - output.push_str("map"); - } + Type::Map => { + output.push_str("map"); } Type::None => output.push_str("none"), Type::Number => output.push_str("num"), @@ -288,7 +284,7 @@ impl Display for Type { } Type::Integer => write!(f, "int"), Type::List(item_type) => write!(f, "[{item_type}]"), - Type::Map(_) => write!(f, "map"), + Type::Map => write!(f, "map"), Type::Number => write!(f, "num"), Type::None => write!(f, "none"), Type::String => write!(f, "str"), diff --git a/src/abstract_tree/value_node.rs b/src/abstract_tree/value_node.rs index 1a15b9d..2e71137 100644 --- a/src/abstract_tree/value_node.rs +++ b/src/abstract_tree/value_node.rs @@ -217,17 +217,9 @@ impl AbstractTree for ValueNode { Type::None } } - ValueNode::Map(_, _) => Type::Map(None), + ValueNode::Map(_, _) => Type::Map, ValueNode::BuiltInValue(built_in_value) => built_in_value.expected_type(context)?, - ValueNode::Structure(node_map) => { - let mut value_map = BTreeMap::new(); - - for (key, (_statement_option, r#type)) in node_map { - value_map.insert(key.to_string(), (None, r#type.clone())); - } - - Type::Map(Some(Structure::new(value_map))) - } + ValueNode::Structure(_) => Type::Map, ValueNode::Range(_) => Type::Range, }; diff --git a/src/value/mod.rs b/src/value/mod.rs index 0b43767..27b6412 100644 --- a/src/value/mod.rs +++ b/src/value/mod.rs @@ -1,5 +1,5 @@ //! Types that represent runtime values. -use crate::{error::RuntimeError, Identifier, Type, TypeSpecification}; +use crate::{error::RuntimeError, Type}; use serde::{ de::{MapAccess, SeqAccess, Visitor}, @@ -80,18 +80,7 @@ impl Value { Type::List(Box::new(Type::Any)) } } - Value::Map(map) => { - let mut identifier_types = Vec::new(); - - for (key, value) in map.inner().unwrap().iter() { - identifier_types.push(( - Identifier::new(key.clone()), - TypeSpecification::new(value.r#type()), - )); - } - - Type::Map(None) - } + Value::Map(_) => Type::Map, Value::Function(function) => function.r#type().clone(), Value::String(_) => Type::String, Value::Float(_) => Type::Float, diff --git a/tests/as.rs b/tests/as.rs index ec31c78..5f6a29d 100644 --- a/tests/as.rs +++ b/tests/as.rs @@ -39,7 +39,7 @@ fn conversion_runtime_error() { interpret(&format!("json:parse('{JSON}') as [map]")), Err(Error::Runtime(RuntimeError::ConversionImpossible { value: json_value, - target_type: Type::List(Box::new(Type::Map(None))) + target_type: Type::List(Box::new(Type::Map)) })) ) }