fix: false-positive downcast warnings

compiler/plc_ast/src/ast.rs

@@ -1057,20 +1057,8 @@ pub fn pre_process(unit: &mut CompilationUnit, id_provider: IdProvider) {
     pre_processor::pre_process(unit, id_provider)
 }
 impl Operator {
-    /// returns true, if this operator results in a bool value
-    pub fn is_bool_type(&self) -> bool {
-        matches!(
-            self,
-            Operator::Equal
-                | Operator::NotEqual
-                | Operator::Less
-                | Operator::Greater
-                | Operator::LessOrEqual
-                | Operator::GreaterOrEqual
-        )
-    }
-
-    /// returns true, if this operator is a comparison operator
+    /// returns true, if this operator is a comparison operator,
+    /// resulting in a bool value
     /// (=, <>, >, <, >=, <=)
     pub fn is_comparison_operator(&self) -> bool {
         matches!(

compiler/plc_ast/src/literals.rs

@@ -259,6 +259,18 @@ impl AstLiteral {
                 | AstLiteral::DateAndTime { .. }
         )
     }
+
+    pub fn is_numerical(&self) -> bool {
+        matches!(
+            self,
+            AstLiteral::Integer { .. }
+                | AstLiteral::Real { .. }
+                | AstLiteral::Time { .. }
+                | AstLiteral::Date { .. }
+                | AstLiteral::TimeOfDay { .. }
+                | AstLiteral::DateAndTime { .. }
+        )
+    }
 }
 
 impl Debug for AstLiteral {

compiler/plc_diagnostics/src/diagnostics/diagnostics_registry.rs

@@ -300,7 +300,7 @@ lazy_static! {
     Error,
     include_str!("./error_codes/E066.md"),
     E067,
-    Info,
+    Warning,
     include_str!("./error_codes/E067.md"), //Implicit typecast
     E068,
     Error,

src/resolver.rs

@@ -1327,7 +1327,7 @@ impl<'i> TypeAnnotator<'i> {
                             )
                         };
 
-                        let target_name = if data.operator.is_bool_type() {
+                        let target_name = if data.operator.is_comparison_operator() {
                             BOOL_TYPE.to_string()
                         } else {
                             bigger_type.get_name().to_string()

src/validation.rs

@@ -30,13 +30,13 @@ mod variable;
 #[cfg(test)]
 mod tests;
 
-#[derive(Clone)]
 pub struct ValidationContext<'s, T: AnnotationMap> {
     annotations: &'s T,
     index: &'s Index,
     /// the type_name of the context for a reference (e.g. `a.b` where `a`'s type is the context of `b`)
     qualifier: Option<&'s str>,
     is_call: bool,
+    is_builtin_call: bool,
 }
 
 impl<'s, T: AnnotationMap> ValidationContext<'s, T> {
@@ -46,6 +46,7 @@ impl<'s, T: AnnotationMap> ValidationContext<'s, T> {
             index: self.index,
             qualifier: Some(qualifier),
             is_call: self.is_call,
+            is_builtin_call: self.is_builtin_call,
         }
     }
 
@@ -55,6 +56,7 @@ impl<'s, T: AnnotationMap> ValidationContext<'s, T> {
             index: self.index,
             qualifier,
             is_call: self.is_call,
+            is_builtin_call: self.is_builtin_call,
         }
     }
 
@@ -78,12 +80,35 @@ impl<'s, T: AnnotationMap> ValidationContext<'s, T> {
             index: self.index,
             qualifier: self.qualifier,
             is_call: true,
+            is_builtin_call: self.is_builtin_call,
         }
     }
 
     fn is_call(&self) -> bool {
         self.is_call
     }
+
+    fn set_is_builtin_call(&self) -> Self {
+        ValidationContext {
+            annotations: self.annotations,
+            index: self.index,
+            qualifier: self.qualifier,
+            is_call: self.is_call,
+            is_builtin_call: true,
+        }
+    }
+}
+
+impl<'s, T: AnnotationMap> Clone for ValidationContext<'s, T> {
+    fn clone(&self) -> Self {
+        ValidationContext {
+            annotations: self.annotations,
+            index: self.index,
+            qualifier: self.qualifier,
+            is_call: self.is_call,
+            is_builtin_call: self.is_builtin_call,
+        }
+    }
 }
 
 /// This trait should be implemented by any validator used by `validation::Validator`
@@ -150,7 +175,8 @@ impl<'a> Validator<'a> {
     }
 
     pub fn visit_unit<T: AnnotationMap>(&mut self, annotations: &T, index: &Index, unit: &CompilationUnit) {
-        let context = ValidationContext { annotations, index, qualifier: None, is_call: false };
+        let context =
+            ValidationContext { annotations, index, qualifier: None, is_call: false, is_builtin_call: false };
         // validate POU and declared Variables
         for pou in &unit.units {
             visit_pou(self, pou, &context.with_qualifier(pou.name.as_str()));

src/validation/statement.rs

@@ -3,8 +3,8 @@ use std::{collections::HashSet, mem::discriminant};
 use plc_ast::control_statements::ForLoopStatement;
 use plc_ast::{
     ast::{
-        flatten_expression_list, AstNode, AstStatement, DirectAccess, DirectAccessType, JumpStatement,
-        Operator, ReferenceAccess,
+        flatten_expression_list, AstNode, AstStatement, BinaryExpression, CallStatement, DirectAccess,
+        DirectAccessType, JumpStatement, Operator, ReferenceAccess, UnaryExpression,
     },
     control_statements::{AstControlStatement, ConditionalBlock},
     literals::{Array, AstLiteral, StringValue},
@@ -833,9 +833,8 @@ fn validate_assignment<T: AnnotationMap>(
                     location.clone(),
                 ));
             }
-        } else if right.is_literal() {
-            // TODO: See https://github.com/PLC-lang/rusty/issues/857
-            // validate_assignment_type_sizes(validator, left_type, right_type, location, context)
+        } else {
+            validate_assignment_type_sizes(validator, left_type, right, context)
         }
     }
 }
@@ -1343,26 +1342,105 @@ fn validate_type_nature<T: AnnotationMap>(
     }
 }
 
-fn _validate_assignment_type_sizes<T: AnnotationMap>(
+fn validate_assignment_type_sizes<T: AnnotationMap>(
     validator: &mut Validator,
     left: &DataType,
-    right: &DataType,
-    location: &SourceLocation,
+    right: &AstNode,
     context: &ValidationContext<T>,
 ) {
-    if left.get_type_information().get_size(context.index)
-        < right.get_type_information().get_size(context.index)
-    {
-        validator.push_diagnostic(
-            Diagnostic::new(format!(
-                "Potential loss of information due to assigning '{}' to variable of type '{}'.",
-                left.get_name(),
-                right.get_name()
-            ))
-            .with_error_code("E067")
-            .with_location(location.clone()),
-        )
+    use std::collections::HashMap;
+    fn get_expression_types_and_locations<'b, T: AnnotationMap>(
+        expression: &AstNode,
+        context: ValidationContext<'b, T>,
+        lhs_is_signed_int: bool,
+    ) -> HashMap<&'b DataType, Vec<SourceLocation>> {
+        let mut map: HashMap<&DataType, Vec<SourceLocation>> = HashMap::new();
+        match expression.get_stmt_peeled() {
+            AstStatement::BinaryExpression(BinaryExpression { operator, left, right, .. })
+                if !operator.is_comparison_operator() =>
+            {
+                get_expression_types_and_locations(left, context.clone(), lhs_is_signed_int)
+                    .into_iter()
+                    .for_each(|(k, v)| map.entry(k).or_default().extend(v));
+                // the RHS type in a MOD expression has no impact on the resulting value type
+                if matches!(operator, Operator::Modulo) {
+                    return map
+                };
+                get_expression_types_and_locations(right, context, lhs_is_signed_int)
+                    .into_iter()
+                    .for_each(|(k, v)| map.entry(k).or_default().extend(v));
+            }
+            AstStatement::UnaryExpression(UnaryExpression { operator, value })
+                if !operator.is_comparison_operator() =>
+            {
+                get_expression_types_and_locations(value, context, lhs_is_signed_int)
+                    .into_iter()
+                    .for_each(|(k, v)| map.entry(k).or_default().extend(v));
+            }
+            // `get_literal_actual_signed_type_name` will always return `LREAL` for FP literals, so they will be handled by the fall-through case according to their annotated type
+            AstStatement::Literal(lit) if !matches!(lit, &AstLiteral::Real(_)) => {
+                if !lit.is_numerical() {
+                    return map
+                }
+                if let Some(dt) = get_literal_actual_signed_type_name(lit, lhs_is_signed_int)
+                    .map(|name| context.index.get_type(name).unwrap_or(context.index.get_void_type()))
+                {
+                    map.entry(dt).or_default().push(expression.get_location());
+                }
+            }
+            AstStatement::CallStatement(CallStatement { operator, parameters })
+                // special handling for builtin selector functions MUX and SEL
+                if matches!(operator.get_flat_reference_name().unwrap_or_default(), "MUX" | "SEL") =>
+            {
+                let Some(args) = parameters else {
+                    return map
+                };
+                if let AstStatement::ExpressionList(list) = args.get_stmt_peeled() {
+                    // skip the selector argument since it will never be assigned to the target type
+                    list.iter().skip(1).flat_map(|arg| {
+                        get_expression_types_and_locations(arg, context.set_is_builtin_call(), lhs_is_signed_int)
+                    })
+                    .for_each(|(k, v)| map.entry(k).or_default().extend(v));
+                };
+            }
+            _ => {
+                if !(context.annotations.get_generic_nature(expression).is_none() || context.is_builtin_call) {
+                    return map
+                };
+                if let Some(dt) = context.annotations.get_type(expression, context.index) {
+                    map.entry(dt).or_default().push(expression.get_location());
+                }
+            }
+        };
+        map
     }
+
+    let lhs = left.get_type_information();
+    let lhs_size = lhs.get_size(context.index);
+    let results_in_truncation = |rhs: &DataType| {
+        let rhs = rhs.get_type_information();
+        let rhs_size = rhs.get_size(context.index);
+        lhs_size < rhs_size
+            || (lhs_size == rhs_size
+                && ((lhs.is_signed_int() && rhs.is_unsigned_int()) || (lhs.is_int() && rhs.is_float())))
+    };
+
+    get_expression_types_and_locations(right, context.clone(), lhs.is_signed_int())
+        .into_iter()
+        .filter(|(dt, _)| !dt.is_aggregate_type() && results_in_truncation(dt))
+        .for_each(|(dt, location)| {
+            location.into_iter().for_each(|loc| {
+                validator.push_diagnostic(
+                    Diagnostic::new(format!(
+                        "Implicit downcast from '{}' to '{}'.",
+                        get_datatype_name_or_slice(validator.context, dt),
+                        get_datatype_name_or_slice(validator.context, left)
+                    ))
+                    .with_error_code("E067")
+                    .with_location(loc),
+                );
+            })
+        });
 }
 
 mod helper {