convert correctness tests to lit

Author: volsa

src/validation/statement.rs

@@ -777,20 +777,26 @@ fn validate_ref_assignment<T: AnnotationMap>(
     assignment: &Assignment,
     assignment_location: &SourceLocation,
 ) {
-    // Assert that the rhs is a variable that can be referenced
-    if !assignment.right.is_reference() {
-        validator.push_diagnostic(
-            Diagnostic::new("Invalid assignment, expected a reference")
-                .with_location(&assignment.right.location)
-                .with_error_code("E098"),
-        );
-    }
+    let mut assert_reference = |node: &AstNode| {
+        if !node.is_reference() {
+            validator.push_diagnostic(
+                Diagnostic::new("Invalid assignment, expected a reference")
+                    .with_location(&node.location)
+                    .with_error_code("E098"),
+            );
+        }
+    };
+
+    assert_reference(&assignment.left);
+    assert_reference(&assignment.right);
 
     // Lastly, assert the type the lhs references matches with the rhs
-    let type_lhs = context.annotations.get_type(&assignment.left, context.index).unwrap();
-    let type_rhs = context.annotations.get_type(&assignment.right, context.index).unwrap();
+    let type_lhs = context.annotations.get_type_or_void(&assignment.left, context.index);
+    let type_rhs = context.annotations.get_type_or_void(&assignment.right, context.index);
+    let type_info_lhs = context.index.find_elementary_pointer_type(type_lhs.get_type_information());
+    let type_info_rhs = context.index.find_elementary_pointer_type(type_rhs.get_type_information());
 
-    if type_lhs != type_rhs {
+    if type_info_lhs != type_info_rhs {
         validator.push_diagnostic(
             Diagnostic::new(format!(
                 "Invalid assignment, types {} and {} differ",

src/validation/tests/assignment_validation_tests.rs

@@ -1246,11 +1246,12 @@ fn reference_to_variables_and_ref_assignments() {
                 referenceToFooInitializedArray      : REFERENCE TO ARRAY[1..5] OF DINT;
             END_VAR
 
-            referenceToFoo REF= foo;
+            refToFoo        REF= foo;
+            referenceToFoo  REF= foo;
 
             // Invalid
+            1 REF= foo;
             foo REF= foo;
-            refToFoo REF= foo;
             referenceToFoo REF= 0;
             referenceToFoo REF= referenceToFoo;
         END_FUNCTION
@@ -1293,16 +1294,16 @@ fn reference_to_variables_and_ref_assignments() {
        │                 │                                      
        │                 REFERENCE TO variables can not reference arrays, pointers or bits
 
-    error[E098]: Invalid assignment, types REF_TO DINT and DINT differ
+    error[E098]: Invalid assignment, expected a reference
        ┌─ <internal>:30:13
        │
-    30 │             refToFoo REF= foo;
-       │             ^^^^^^^^^^^^^^^^^ Invalid assignment, types REF_TO DINT and DINT differ
+    30 │             1 REF= foo;
+       │             ^ Invalid assignment, expected a reference
 
     error[E098]: Invalid assignment, expected a reference
-       ┌─ <internal>:31:33
+       ┌─ <internal>:32:33
        │
-    31 │             referenceToFoo REF= 0;
+    32 │             referenceToFoo REF= 0;
        │                                 ^ Invalid assignment, expected a reference
 
     "###);

src/validation/variable.rs

@@ -217,49 +217,52 @@ fn validate_reference_to_declaration<T: AnnotationMap>(
     variable: &Variable,
     variable_entry: &VariableIndexEntry,
 ) {
-    if let Some(variable_type) = context.index.find_effective_type_by_name(variable_entry.get_type_name()) {
-        if variable_type.get_type_information().is_reference_to() {
-            let DataTypeInformation::Pointer { inner_type_name, .. } = variable_type.get_type_information()
-            else {
-                unreachable!("`REFERENCE TO` is defined as a pointer, hence this must exist")
-            };
+    let Some(variable_ty) = context.index.find_effective_type_by_name(variable_entry.get_type_name()) else {
+        return;
+    };
 
-            // Assert that no initializers are present in the `REFERENCE TO` declaration
-            if let Some(ref initializer) = variable.initializer {
-                if variable_type.get_type_information().is_reference_to() {
-                    validator.push_diagnostic(
-                        Diagnostic::new("Initializations of REFERENCE TO variables are disallowed")
-                            .with_location(&initializer.location)
-                            .with_error_code("E099"),
-                    );
-                }
-            }
+    if !variable_ty.get_type_information().is_reference_to() {
+        return;
+    }
 
-            // Assert that the referenced type is no variable reference
-            let qualifier = context.qualifier.unwrap_or_default();
-            let inner_ty_is_local_var = context.index.find_member(qualifier, inner_type_name).is_some();
-            let inner_ty_is_global_var = context.index.find_global_variable(inner_type_name).is_some();
+    let Some(inner_ty_name) = variable_ty.get_type_information().get_inner_pointer_type_name() else {
+        unreachable!("`REFERENCE TO` is defined as a pointer, hence this must exist")
+    };
 
-            if inner_ty_is_local_var || inner_ty_is_global_var {
-                validator.push_diagnostic(
-                    Diagnostic::new("REFERENCE TO variables can not reference other variables")
-                        .with_location(&variable_type.location)
-                        .with_error_code("E099"),
-                );
-            }
+    // Assert that no initializers are present in the `REFERENCE TO` declaration
+    if let Some(ref initializer) = variable.initializer {
+        if variable_ty.get_type_information().is_reference_to() {
+            validator.push_diagnostic(
+                Diagnostic::new("Initializations of REFERENCE TO variables are disallowed")
+                    .with_location(&initializer.location)
+                    .with_error_code("E099"),
+            );
+        }
+    }
 
-            // Lastly assert that the referenced type is no array, pointer or bit
-            let inner_type = context.index.find_effective_type_by_name(inner_type_name);
-            if let Some(ty) = inner_type {
-                if ty.is_array() || ty.is_pointer() || ty.is_bit() {
-                    validator.push_diagnostic(
-                        Diagnostic::new("REFERENCE TO variables can not reference arrays, pointers or bits")
-                            .with_location(&variable.location)
-                            .with_secondary_location(&ty.location)
-                            .with_error_code("E099"),
-                    );
-                }
-            }
+    // Assert that the referenced type is no variable reference
+    let qualifier = context.qualifier.unwrap_or_default();
+    let inner_ty_is_local_var = context.index.find_member(qualifier, inner_ty_name).is_some();
+    let inner_ty_is_global_var = context.index.find_global_variable(inner_ty_name).is_some();
+
+    if inner_ty_is_local_var || inner_ty_is_global_var {
+        validator.push_diagnostic(
+            Diagnostic::new("REFERENCE TO variables can not reference other variables")
+                .with_location(&variable_ty.location)
+                .with_error_code("E099"),
+        );
+    }
+
+    // Lastly assert that the referenced type is no array, pointer or bit
+    let inner_type = context.index.find_effective_type_by_name(inner_ty_name);
+    if let Some(ty) = inner_type {
+        if ty.is_array() || ty.is_pointer() || ty.is_bit() {
+            validator.push_diagnostic(
+                Diagnostic::new("REFERENCE TO variables can not reference arrays, pointers or bits")
+                    .with_location(&variable.location)
+                    .with_secondary_location(&ty.location)
+                    .with_error_code("E099"),
+            );
         }
     }
 }

tests/correctness/pointers.rs

@@ -242,108 +242,3 @@ fn value_behind_function_block_pointer_is_assigned_to_correctly() {
     assert!(!maintype.a);
     assert!(maintype.b);
 }
-
-#[test]
-fn reference_assignment() {
-    let function = r"
-        FUNCTION main : DINT
-            VAR
-                a : REF_TO DINT;
-                b : DINT := 5;
-            END_VAR
-
-            a REF= b;
-            main := a^;
-        END_FUNCTION
-    ";
-
-    let res: i32 = compile_and_run(function.to_string(), &mut MainType::default());
-    assert_eq!(5, res);
-}
-
-#[test]
-fn reference_to_assignment() {
-    let function = r"
-        FUNCTION main : DINT
-            VAR
-                a : REFERENCE TO DINT;
-                b : DINT := 5;
-            END_VAR
-            a REF= b;
-            main := a;
-        END_FUNCTION
-    ";
-
-    let res: i32 = compile_and_run(function, &mut MainType::default());
-    assert_eq!(5, res);
-}
-
-#[test]
-fn reference_to_variable_referencing_other_reference_to_variable() {
-    let function = r"
-        FUNCTION main : DINT
-            VAR
-                foo : REFERENCE TO DINT;
-                bar : REFERENCE TO DINT;
-                qux : DINT;
-            END_VAR
-            
-            bar REF= qux;
-            foo REF= bar;
-            qux := 5;
-
-            main := foo; // foo -> bar -> qux
-        END_FUNCTION
-    ";
-
-    let res: i32 = compile_and_run(function, &mut MainType::default());
-    assert_eq!(5, res);
-}
-
-#[test]
-fn reference_to_variable_referencing_itself() {
-    let function = r"
-        FUNCTION main : DINT
-            VAR
-                foo : REFERENCE TO DINT;
-                bar : REFERENCE TO DINT;
-                qux : DINT;
-            END_VAR
-            
-            foo REF= bar;
-            bar REF= qux;
-
-            bar REF= bar; 
-            qux := 5;
-
-            main := bar; // bar (-> bar) -> qux
-        END_FUNCTION
-    ";
-
-    let res: i32 = compile_and_run(function, &mut MainType::default());
-    assert_eq!(5, res);
-}
-
-#[test]
-fn reference_to_variable_referencing_struct() {
-    let function = r"
-        TYPE Transaction : STRUCT
-            id      : DINT;
-            amount  : DINT;
-            message : STRING;
-        END_STRUCT END_TYPE
-
-        FUNCTION main : DINT
-            VAR
-                txn     : Transaction := (id := 1, amount := 5, message := 'whats up');
-                refTxn  : REFERENCE TO Transaction;
-            END_VAR
-
-            refTxn REF= txn;
-            main := refTxn.amount;
-        END_FUNCTION
-    ";
-
-    let res: i32 = compile_and_run(function, &mut MainType::default());
-    assert_eq!(5, res);
-}

tests/lit/single/pointer/ref_assignment_operator.st

@@ -0,0 +1,11 @@
+// RUN: (%COMPILE %s && %RUN) | %CHECK %s
+// CHECK: 5
+FUNCTION main : DINT
+    VAR
+        a : REF_TO DINT;
+        b : DINT := 5;
+    END_VAR
+    a REF= b;
+
+    printf('%d$N', a^);
+END_FUNCTION

tests/lit/single/pointer/referenceto_variable_referencing_itself.st

@@ -0,0 +1,17 @@
+// RUN: (%COMPILE %s && %RUN) | %CHECK %s
+// CHECK: 5
+FUNCTION main : DINT
+    VAR
+        foo : REFERENCE TO DINT;
+        bar : REFERENCE TO DINT;
+        qux : DINT;
+    END_VAR
+
+    foo REF= bar;
+    bar REF= qux;
+
+    bar REF= bar;
+    qux := 5;
+
+    printf('%d$N', bar); // bar (-> bar) -> qux
+END_FUNCTION

tests/lit/single/pointer/referenceto_variable_referencing_other_referenceto_variable.st

@@ -0,0 +1,15 @@
+// RUN: (%COMPILE %s && %RUN) | %CHECK %s
+// CHECK: 5
+FUNCTION main : DINT
+    VAR
+        foo : REFERENCE TO DINT;
+        bar : REFERENCE TO DINT;
+        qux : DINT;
+    END_VAR
+
+    bar REF= qux;
+    foo REF= bar;
+    qux := 5;
+
+    printf('%d$N', foo); // foo -> bar -> qux
+END_FUNCTION

tests/lit/single/pointer/referenceto_variable_referencing_struct.st

@@ -0,0 +1,17 @@
+// RUN: (%COMPILE %s && %RUN) | %CHECK %s
+// CHECK: 5
+TYPE Transaction : STRUCT
+    id      : DINT;
+    amount  : DINT;
+    message : STRING;
+END_STRUCT END_TYPE
+
+FUNCTION main : DINT
+    VAR
+        txn     : Transaction := (id := 1, amount := 5, message := 'whats up');
+        refTxn  : REFERENCE TO Transaction;
+    END_VAR
+
+    refTxn REF= txn;
+    printf('%d$N', refTxn.amount);
+END_FUNCTION