Remove structure from map types

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,
+    AbstractTree, BuiltInFunction, Context, Format, Function, List, Map, SyntaxNode, Type, Value,
-    Type, Value,
 };
 
 static ARGS: OnceLock<Value> = 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::Fs => Type::Map,
-            BuiltInValue::Json => Type::Map(Some(
+            BuiltInValue::Json => Type::Map,
-                Structure::from_map(self.get().as_map().unwrap()).unwrap(),
-            )),
             BuiltInValue::Length => BuiltInFunction::Length.r#type(),
             BuiltInValue::Output => BuiltInFunction::Output.r#type(),
-            BuiltInValue::Random => Type::Map(None),
+            BuiltInValue::Random => Type::Map,
-            BuiltInValue::Str => Type::Map(None),
+            BuiltInValue::Str => Type::Map,
         }
     }
 

src/abstract_tree/index.rs

@@ -48,17 +48,7 @@ impl AbstractTree for Index {
     fn expected_type(&self, context: &Context) -> Result<Type, ValidationError> {
         match self.collection.expected_type(context)? {
             Type::List(item_type) => Ok(*item_type.clone()),
-            Type::Map(structure) => {
+            Type::Map => Ok(Type::Any),
-                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::None => Ok(Type::None),
             r#type => Ok(r#type),
         }

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<Type>),
-    Map(Option<Structure>),
+    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::Collection, Type::Map)
-            | (Type::Map(_), Type::Collection)
+            | (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,13 +241,9 @@ impl Format for Type {
                 item_type.format(output, indent_level);
                 output.push(']');
             }
-            Type::Map(structure_option) => {
+            Type::Map => {
-                if let Some(structure) = structure_option {
-                    output.push_str(&structure.to_string());
-                } else {
                 output.push_str("map");
             }
-            }
             Type::None => output.push_str("none"),
             Type::Number => output.push_str("num"),
             Type::String => output.push_str("str"),
@@ -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"),

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) => {
+            ValueNode::Structure(_) => Type::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::Range(_) => Type::Range,
         };
 

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) => {
+            Value::Map(_) => Type::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::Function(function) => function.r#type().clone(),
             Value::String(_) => Type::String,
             Value::Float(_) => Type::Float,

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))
         }))
     )
 }