fix: improve unresolved reference validation in array access (#1432)

Author: volsa

src/resolver/tests/resolve_expressions_tests.rs

@@ -5786,3 +5786,43 @@ fn reference_to_alloca_nested_resolved() {
         unreachable!("Must be an assignment");
     }
 }
+
+#[test]
+fn reference_inside_array_access_index_is_resolved() {
+    let id_provider = IdProvider::default();
+    let (unit, mut index) = index_with_ids(
+        "
+        FUNCTION main : DINT
+            VAR
+                arr : ARRAY[1..5] OF DINT;
+                idx : DINT;
+            END_VAR
+
+            arr[idx];
+        END_FUNCTION
+        ",
+        id_provider.clone(),
+    );
+
+    let annotations = annotate_with_ids(&unit, &mut index, id_provider);
+    let stmt = &unit.implementations[0].statements[0];
+    if let AstNode {
+        stmt: AstStatement::ReferenceExpr(ReferenceExpr { access: ReferenceAccess::Index(idx), .. }),
+        ..
+    } = stmt
+    {
+        insta::assert_debug_snapshot!(annotations.get(idx).unwrap(), @r###"
+        Variable {
+            resulting_type: "DINT",
+            qualified_name: "main.idx",
+            constant: false,
+            argument_type: ByVal(
+                Local,
+            ),
+            auto_deref: None,
+        }
+        "###);
+    } else {
+        unreachable!("Expected a reference expression")
+    }
+}

src/validation/statement.rs

@@ -436,7 +436,7 @@ fn validate_access_index<T: AnnotationMap>(
             }
         }
         AstStatement::ReferenceExpr(_) => {
-            let ref_type = context.annotations.get_type_or_void(access_index, context.index);
+            let Some(ref_type) = context.annotations.get_type(access_index, context.index) else { return };
             if !ref_type.get_type_information().is_int() {
                 validator.push_diagnostic(
                     Diagnostic::new(format!("Invalid type {} for direct variable access. Only variables of Integer types are allowed", ref_type.get_name()))
@@ -557,7 +557,11 @@ fn visit_array_access<T: AnnotationMap>(
     access: &AstNode,
     context: &ValidationContext<T>,
 ) {
-    let target_type = context.annotations.get_type_or_void(reference, context.index).get_type_information();
+    let Some(target_type) =
+        context.annotations.get_type(reference, context.index).map(|it| it.get_type_information())
+    else {
+        return;
+    };
 
     match target_type {
         DataTypeInformation::Array { dimensions, .. } => match access.get_stmt() {
@@ -615,6 +619,7 @@ fn validate_array_access<T: AnnotationMap>(
     dimension_index: usize,
     context: &ValidationContext<T>,
 ) {
+    visit_statement(validator, access, context);
     if let AstStatement::Literal(AstLiteral::Integer(value)) = access.get_stmt() {
         if let Some(dimension) = dimensions.get(dimension_index) {
             if let Ok(range) = dimension.get_range(context.index) {
@@ -631,7 +636,11 @@ fn validate_array_access<T: AnnotationMap>(
             }
         }
     } else {
-        let type_info = context.annotations.get_type_or_void(access, context.index).get_type_information();
+        let Some(type_info) =
+            context.annotations.get_type(access, context.index).map(|it| it.get_type_information())
+        else {
+            return;
+        };
         if !type_info.is_int() {
             validator.push_diagnostic(
                     Diagnostic::new(format!(

src/validation/tests/statement_validation_tests.rs

@@ -1997,3 +1997,66 @@ fn validate_property_call_with_braces() {
        │             ^^^^^^^^^^^^^^^ Properties cannot be called like functions. Remove `()`
     "###);
 }
+
+#[test]
+fn unresolved_reference_in_array_access() {
+    let diagnostics = parse_and_validate_buffered(
+        "
+        PROGRAM mainProg
+        VAR
+            foo: ARRAY[0..1] OF DINT;
+            val: DINT;
+        END_VAR
+            // OK
+            foo[val];
+            // unresolved reference
+            foo[bar];
+        END_PROGRAM
+        ",
+    );
+
+    assert_snapshot!(diagnostics, @r###"
+    error[E048]: Could not resolve reference to bar
+       ┌─ <internal>:10:17
+       │
+    10 │             foo[bar];
+       │                 ^^^ Could not resolve reference to bar
+    "###);
+}
+
+#[test]
+fn unresolved_qualified_reference_in_array_access() {
+    let diagnostics = parse_and_validate_buffered(
+        "
+        FUNCTION_BLOCK fb
+        VAR
+            val: DINT;
+        END_VAR
+        END_FUNCTION_BLOCK
+        PROGRAM mainProg
+        VAR
+            foo: ARRAY[0..1] OF DINT;
+            instance: fb;
+        END_VAR
+            // OK
+            foo[fb.val];
+            // unresolved reference
+            foo[fb.bar];
+        END_PROGRAM
+        ",
+    );
+
+    assert_snapshot!(diagnostics, @r###"
+    warning[E049]: Illegal access to private member fb.val
+       ┌─ <internal>:13:20
+       │
+    13 │             foo[fb.val];
+       │                    ^^^ Illegal access to private member fb.val
+
+    error[E048]: Could not resolve reference to bar
+       ┌─ <internal>:15:20
+       │
+    15 │             foo[fb.bar];
+       │                    ^^^ Could not resolve reference to bar
+    "###);
+}