Pass analyzer test

dust-lang/src/analyzer.rs

@@ -13,8 +13,9 @@ use crate::{
     ast::{
         AbstractSyntaxTree, AstError, BlockExpression, CallExpression, ElseExpression,
         FieldAccessExpression, IfExpression, LetStatement, ListExpression, ListIndexExpression,
-        LoopExpression, MapExpression, Node, OperatorExpression, RangeExpression, Span, Statement,
+        LiteralExpression, LoopExpression, MapExpression, Node, OperatorExpression,
-        StructDefinition, StructExpression, TupleAccessExpression,
+        PrimitiveValueExpression, RangeExpression, Span, Statement, StructDefinition,
+        StructExpression, TupleAccessExpression,
     },
     core_library, parse, Context, ContextError, DustError, Expression, Identifier, StructType,
     Type,
@@ -224,6 +225,56 @@ impl<'recovered, 'a: 'recovered> Analyzer<'a> {
             Expression::ListIndex(list_index_expression) => {
                 let ListIndexExpression { list, index } = list_index_expression.inner.as_ref();
 
+                let list_type = list.return_type(&self.context)?;
+
+                let literal_type = if let Expression::Literal(Node { inner, .. }) = index {
+                    Some(inner.as_ref().clone())
+                } else {
+                    None
+                };
+
+                if let Some(Type::List { length, .. }) = list_type {
+                    if let Some(LiteralExpression::Primitive(PrimitiveValueExpression::Integer(
+                        integer,
+                    ))) = literal_type
+                    {
+                        if integer < 0 || integer >= length as i64 {
+                            return Err(AnalysisError::IndexOutOfBounds {
+                                index: index.clone(),
+                                length,
+                                list: list.clone(),
+                                index_value: integer,
+                            });
+                        }
+                    }
+                }
+
+                if let Some(Type::String {
+                    length: Some(length),
+                }) = list_type
+                {
+                    if let Some(LiteralExpression::Primitive(PrimitiveValueExpression::Integer(
+                        integer,
+                    ))) = literal_type
+                    {
+                        if integer < 0 || integer >= length as i64 {
+                            return Err(AnalysisError::IndexOutOfBounds {
+                                index: index.clone(),
+                                length,
+                                list: list.clone(),
+                                index_value: integer,
+                            });
+                        }
+                    }
+                }
+
+                if list_type.is_none() {
+                    return Err(AnalysisError::ExpectedValueFromExpression {
+                        expression: list.clone(),
+                        found_type: list_type,
+                    });
+                }
+
                 self.analyze_expression(list)?;
                 self.analyze_expression(index)?;
             }
@@ -302,10 +353,60 @@ impl<'recovered, 'a: 'recovered> Analyzer<'a> {
                 OperatorExpression::Math { left, right, .. } => {
                     self.analyze_expression(left)?;
                     self.analyze_expression(right)?;
+
+                    let left_type = left.return_type(&self.context)?;
+                    let right_type = right.return_type(&self.context)?;
+
+                    if left_type.is_none() {
+                        return Err(AnalysisError::ExpectedValueFromExpression {
+                            expression: left.clone(),
+                            found_type: left_type,
+                        });
+                    }
+
+                    if right_type.is_none() {
+                        return Err(AnalysisError::ExpectedValueFromExpression {
+                            expression: right.clone(),
+                            found_type: right_type,
+                        });
+                    }
+
+                    if left_type != right_type {
+                        return Err(AnalysisError::ExpectedType {
+                            expected: left_type.unwrap(),
+                            actual: right_type.unwrap(),
+                            actual_expression: right.clone(),
+                        });
+                    }
                 }
                 OperatorExpression::Logic { left, right, .. } => {
                     self.analyze_expression(left)?;
                     self.analyze_expression(right)?;
+
+                    let left_type = left.return_type(&self.context)?;
+                    let right_type = right.return_type(&self.context)?;
+
+                    if left_type.is_none() {
+                        return Err(AnalysisError::ExpectedValueFromExpression {
+                            expression: left.clone(),
+                            found_type: left_type,
+                        });
+                    }
+
+                    if right_type.is_none() {
+                        return Err(AnalysisError::ExpectedValueFromExpression {
+                            expression: right.clone(),
+                            found_type: right_type,
+                        });
+                    }
+
+                    if left_type != right_type {
+                        return Err(AnalysisError::ExpectedType {
+                            expected: left_type.unwrap(),
+                            actual: right_type.unwrap(),
+                            actual_expression: right.clone(),
+                        });
+                    }
                 }
             },
             Expression::Range(range_expression) => match range_expression.inner.as_ref() {
@@ -325,7 +426,7 @@ impl<'recovered, 'a: 'recovered> Analyzer<'a> {
                         .map_err(|error| AnalysisError::ContextError {
                             error,
                             position: name.position,
-                        });
+                        })?;
 
                     for (_, expression) in fields {
                         self.analyze_expression(expression)?;
@@ -401,23 +502,21 @@ pub enum AnalysisError {
         error: ContextError,
         position: Span,
     },
-    ExpectedBoolean {
+    ExpectedType {
-        actual: Statement,
+        expected: Type,
+        actual: Type,
+        actual_expression: Expression,
+    },
+    ExpectedTypeMultiple {
+        expected: Vec<Type>,
+        actual: Type,
+        actual_expression: Expression,
     },
     ExpectedIdentifier {
-        actual: Statement,
+        actual: Expression,
     },
     ExpectedIdentifierOrString {
-        actual: Statement,
+        actual: Expression,
-    },
-    ExpectedIntegerOrRange {
-        actual: Statement,
-    },
-    ExpectedList {
-        actual: Statement,
-    },
-    ExpectedMap {
-        actual: Statement,
     },
     ExpectedValueFromStatement {
         actual: Statement,
@@ -432,9 +531,9 @@ pub enum AnalysisError {
         position: Span,
     },
     IndexOutOfBounds {
-        list: Statement,
+        list: Expression,
-        index: Statement,
+        index: Expression,
-        index_value: usize,
+        index_value: i64,
         length: usize,
     },
     TypeConflict {
@@ -443,8 +542,8 @@ pub enum AnalysisError {
         expected: Type,
     },
     UndefinedField {
-        identifier: Statement,
+        identifier: Expression,
-        statement: Statement,
+        statement: Expression,
     },
     UndefinedType {
         identifier: Node<Identifier>,
@@ -453,7 +552,7 @@ pub enum AnalysisError {
         identifier: Node<Identifier>,
     },
     UnexectedString {
-        actual: Statement,
+        actual: Expression,
     },
     UndefinedVariable {
         identifier: Node<Identifier>,
@@ -471,12 +570,14 @@ impl AnalysisError {
         match self {
             AnalysisError::AstError(ast_error) => ast_error.position(),
             AnalysisError::ContextError { position, .. } => *position,
-            AnalysisError::ExpectedBoolean { actual } => actual.position(),
+            AnalysisError::ExpectedType {
+                actual_expression, ..
+            } => actual_expression.position(),
+            AnalysisError::ExpectedTypeMultiple {
+                actual_expression, ..
+            } => actual_expression.position(),
             AnalysisError::ExpectedIdentifier { actual } => actual.position(),
             AnalysisError::ExpectedIdentifierOrString { actual } => actual.position(),
-            AnalysisError::ExpectedIntegerOrRange { actual } => actual.position(),
-            AnalysisError::ExpectedList { actual } => actual.position(),
-            AnalysisError::ExpectedMap { actual } => actual.position(),
             AnalysisError::ExpectedValueFromExpression { expression, .. } => expression.position(),
             AnalysisError::ExpectedValueFromStatement { actual } => actual.position(),
             AnalysisError::ExpectedValueArgumentCount { position, .. } => *position,
@@ -499,23 +600,37 @@ impl Display for AnalysisError {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match self {
             AnalysisError::AstError(ast_error) => write!(f, "{}", ast_error),
-            Self::ContextError { error, position } => {
+            AnalysisError::ContextError { error, .. } => write!(f, "{}", error),
-                write!(f, "Context error at {:?}: {}", position, error)
+
+            AnalysisError::ExpectedType {
+                expected,
+                actual,
+                actual_expression,
+            } => {
+                write!(
+                    f,
+                    "Expected type {:?}, found {:?} in {}",
+                    expected, actual, actual_expression
+                )
             }
-            AnalysisError::ExpectedBoolean { actual, .. } => {
+            AnalysisError::ExpectedTypeMultiple {
-                write!(f, "Expected boolean, found {}", actual)
+                expected,
+                actual,
+                actual_expression,
+            } => {
+                write!(
+                    f,
+                    "Expected one of {:?}, found {:?} in {}",
+                    expected, actual, actual_expression
+                )
             }
+
             AnalysisError::ExpectedIdentifier { actual, .. } => {
                 write!(f, "Expected identifier, found {}", actual)
             }
             AnalysisError::ExpectedIdentifierOrString { actual } => {
                 write!(f, "Expected identifier or string, found {}", actual)
             }
-            AnalysisError::ExpectedIntegerOrRange { actual, .. } => {
-                write!(f, "Expected integer or range, found {}", actual)
-            }
-            AnalysisError::ExpectedList { actual } => write!(f, "Expected list, found {}", actual),
-            AnalysisError::ExpectedMap { actual } => write!(f, "Expected map, found {}", actual),
             AnalysisError::ExpectedValueFromExpression {
                 expression,
                 found_type,
@@ -623,18 +738,46 @@ mod tests {
     #[test]
     fn tuple_struct_with_wrong_field_types() {
         let source = "
-            struct Foo(int, float)
+            struct Foo(int, float);
             Foo(1, 2)
         ";
 
-        assert_eq!(analyze(source), todo!());
+        assert_eq!(
+            analyze(source),
+            Err(DustError::Analysis {
+                analysis_error: AnalysisError::TypeConflict {
+                    actual_expression: Expression::literal(2, (52, 53)),
+                    actual_type: Type::Integer,
+                    expected: Type::Float,
+                },
+                source,
+            })
+        );
     }
 
     #[test]
     fn constant_list_index_out_of_bounds() {
         let source = "[1, 2, 3][3]";
 
-        assert_eq!(analyze(source), todo!());
+        assert_eq!(
+            analyze(source),
+            Err(DustError::Analysis {
+                analysis_error: AnalysisError::IndexOutOfBounds {
+                    list: Expression::list(
+                        vec![
+                            Expression::literal(1, (1, 2)),
+                            Expression::literal(2, (4, 5)),
+                            Expression::literal(3, (7, 8)),
+                        ],
+                        (0, 9)
+                    ),
+                    index: Expression::literal(3, (10, 11)),
+                    index_value: 3,
+                    length: 3,
+                },
+                source,
+            })
+        );
     }
 
     #[test]
@@ -665,18 +808,21 @@ mod tests {
         assert_eq!(analyze(source), todo!());
     }
 
-    #[test]
-    fn length_no_arguments() {
-        let source = "length()";
-
-        assert_eq!(analyze(source), todo!());
-    }
-
     #[test]
     fn float_plus_integer() {
         let source = "42.0 + 2";
 
-        assert_eq!(analyze(source), todo!());
+        assert_eq!(
+            analyze(source),
+            Err(DustError::Analysis {
+                analysis_error: AnalysisError::ExpectedType {
+                    expected: Type::Float,
+                    actual: Type::Integer,
+                    actual_expression: Expression::literal(2, (7, 8)),
+                },
+                source,
+            })
+        );
     }
 
     #[test]

dust-lang/src/ast/expression.rs

@@ -381,7 +381,9 @@ impl Expression {
                     PrimitiveValueExpression::Integer(_) => Some(Type::Integer),
                     PrimitiveValueExpression::Float(_) => Some(Type::Float),
                 },
-                LiteralExpression::String(_) => Some(Type::String),
+                LiteralExpression::String(string) => Some(Type::String {
+                    length: Some(string.len()),
+                }),
             },
             Expression::Loop(loop_expression) => match loop_expression.inner.as_ref() {
                 LoopExpression::For { block, .. } => block.inner.return_type(context)?,

dust-lang/src/built_in_function.rs

@@ -14,15 +14,11 @@ use crate::{Identifier, Type, Value};
 pub enum BuiltInFunction {
     // String tools
     ToString,
-    LengthString,
 
     // Integer and float tools
     IsEven,
     IsOdd,
 
-    // List tools
-    LengthList,
-
     // I/O
     ReadLine,
     WriteLine,
@@ -33,8 +29,6 @@ impl BuiltInFunction {
         match self {
             BuiltInFunction::IsEven => "is_even",
             BuiltInFunction::IsOdd => "is_odd",
-            BuiltInFunction::LengthList => "length",
-            BuiltInFunction::LengthString => "length",
             BuiltInFunction::ReadLine => "read_line",
             BuiltInFunction::ToString { .. } => "to_string",
             BuiltInFunction::WriteLine => "write_line",
@@ -46,8 +40,6 @@ impl BuiltInFunction {
             BuiltInFunction::ToString { .. } => None,
             BuiltInFunction::IsEven => None,
             BuiltInFunction::IsOdd => None,
-            BuiltInFunction::LengthList => None,
-            BuiltInFunction::LengthString => None,
             BuiltInFunction::ReadLine => None,
             BuiltInFunction::WriteLine => None,
         }
@@ -58,13 +50,6 @@ impl BuiltInFunction {
             BuiltInFunction::ToString { .. } => Some(vec![("value".into(), Type::Any)]),
             BuiltInFunction::IsEven => Some(vec![("value".into(), Type::Number)]),
             BuiltInFunction::IsOdd => Some(vec![("value".into(), Type::Number)]),
-            BuiltInFunction::LengthList => Some(vec![(
-                "value".into(),
-                Type::ListOf {
-                    item_type: Box::new(Type::Any),
-                },
-            )]),
-            BuiltInFunction::LengthString => Some(vec![("value".into(), Type::String)]),
             BuiltInFunction::ReadLine => None,
             BuiltInFunction::WriteLine => Some(vec![("value".into(), Type::Any)]),
         }
@@ -72,12 +57,10 @@ impl BuiltInFunction {
 
     pub fn return_type(&self) -> Option<Type> {
         match self {
-            BuiltInFunction::ToString { .. } => Some(Type::String),
+            BuiltInFunction::ToString { .. } => Some(Type::String { length: None }),
             BuiltInFunction::IsEven => Some(Type::Boolean),
             BuiltInFunction::IsOdd => Some(Type::Boolean),
-            BuiltInFunction::LengthList => Some(Type::Number),
+            BuiltInFunction::ReadLine => Some(Type::String { length: None }),
-            BuiltInFunction::LengthString => Some(Type::Number),
-            BuiltInFunction::ReadLine => Some(Type::String),
             BuiltInFunction::WriteLine => None,
         }
     }
@@ -117,20 +100,6 @@ impl BuiltInFunction {
                     Err(BuiltInFunctionError::ExpectedInteger)
                 }
             }
-            BuiltInFunction::LengthList => {
-                if let Value::List(list) = &value_arguments.unwrap()[0] {
-                    Ok(Some(Value::Integer(list.len() as i64)))
-                } else {
-                    Err(BuiltInFunctionError::ExpectedList)
-                }
-            }
-            BuiltInFunction::LengthString => {
-                if let Value::String(string) = &value_arguments.unwrap()[0] {
-                    Ok(Some(Value::Integer(string.len() as i64)))
-                } else {
-                    Err(BuiltInFunctionError::ExpectedString)
-                }
-            }
             BuiltInFunction::ReadLine => {
                 let mut input = String::new();
 

dust-lang/src/core_library.rs

@@ -34,15 +34,6 @@ pub fn core_library<'a>() -> &'a Context {
                     (0, 0),
                 ),
             ),
-            (
-                Identifier::new("length"),
-                (
-                    ContextData::VariableValue(Value::Function(Function::BuiltIn(
-                        BuiltInFunction::LengthList,
-                    ))),
-                    (0, 0),
-                ),
-            ),
             (
                 Identifier::new("read_line"),
                 (

dust-lang/src/type.rs

@@ -54,7 +54,9 @@ pub enum Type {
     Range {
         r#type: RangeableType,
     },
-    String,
+    String {
+        length: Option<usize>,
+    },
     Struct(StructType),
     Tuple(Vec<Type>),
 }
@@ -83,7 +85,7 @@ impl Type {
             | (Type::Character, Type::Character)
             | (Type::Float, Type::Float)
             | (Type::Integer, Type::Integer)
-            | (Type::String, Type::String) => return Ok(()),
+            | (Type::String { .. }, Type::String { .. }) => return Ok(()),
             (
                 Type::Generic {
                     concrete_type: left,
@@ -272,7 +274,7 @@ impl Display for Type {
             }
             Type::Number => write!(f, "num"),
             Type::Range { r#type } => write!(f, "{type} range"),
-            Type::String => write!(f, "str"),
+            Type::String { .. } => write!(f, "str"),
             Type::Struct(struct_type) => write!(f, "{struct_type}"),
             Type::Tuple(fields) => {
                 write!(f, "(")?;
@@ -358,8 +360,8 @@ impl Ord for Type {
                 left_type.cmp(right_type)
             }
             (Type::Range { .. }, _) => Ordering::Greater,
-            (Type::String, Type::String) => Ordering::Equal,
+            (Type::String { length: left }, Type::String { length: right }) => left.cmp(right),
-            (Type::String, _) => Ordering::Greater,
+            (Type::String { .. }, _) => Ordering::Greater,
             (Type::Struct(left_struct), Type::Struct(right_struct)) => {
                 left_struct.cmp(right_struct)
             }
@@ -638,7 +640,7 @@ mod tests {
     #[test]
     fn errors() {
         let foo = Type::Integer;
-        let bar = Type::String;
+        let bar = Type::String { length: None };
 
         assert_eq!(
             foo.check(&bar),
@@ -666,7 +668,7 @@ mod tests {
             Type::Range {
                 r#type: RangeableType::Integer,
             },
-            Type::String,
+            Type::String { length: None },
         ];
 
         for left in types.clone() {

dust-lang/src/value.rs

@@ -200,7 +200,9 @@ impl Value {
                     r#type: rangeable_type,
                 }
             }
-            Value::String(_) => Type::String,
+            Value::String(string) => Type::String {
+                length: Some(string.len()),
+            },
             Value::Struct(r#struct) => match r#struct {
                 Struct::Unit { name } => Type::Struct(StructType::Unit { name: name.clone() }),
                 Struct::Tuple { name, fields } => {

dust-lang/src/vm.rs

@@ -1685,12 +1685,26 @@ mod tests {
     }
 
     #[test]
-    fn length() {
+    fn list_length() {
-        let input = "length([1, 2, 3])";
+        let input = "[1, 2, 3].length";
 
         assert_eq!(run(input), Ok(Some(Value::Integer(3))));
     }
 
+    #[test]
+    fn string_length() {
+        let input = "\"hello\".length";
+
+        assert_eq!(run(input), Ok(Some(Value::Integer(5))));
+    }
+
+    #[test]
+    fn map_length() {
+        let input = "map { a = 42, b = 4.0 }.length";
+
+        assert_eq!(run(input), Ok(Some(Value::Integer(2))));
+    }
+
     #[test]
     fn add() {
         let input = "1 + 2";