Reject interpolation property for non-angle animations

Instead of checking individual angle-* interpolation mode values,
reject the `interpolation` property entirely when the animated
property is not of type angle. This is simpler and more robust
since it handles all expression forms, not just literal identifiers.

Author: task-jp

internal/compiler/object_tree.rs

@@ -2348,33 +2348,18 @@ fn animation_element_from_node(
         );
         None
     } else {
-        // Check if angle-* interpolation mode is used with a non-angle property
-        for binding in anim.Binding() {
-            let Some(ident) = binding.child_token(SyntaxKind::Identifier) else { continue };
-            if parser::normalize_identifier(ident.text()) != "interpolation" {
-                continue;
-            }
-            // Check if the binding value is a simple identifier (QualifiedName)
-            let binding_expr = binding.BindingExpression();
-            let Some(expr) = binding_expr.Expression() else { continue };
-            let Some(qn) = expr.QualifiedName() else { continue };
-            let mode = qn.text().to_string();
-            let normalized_mode = parser::normalize_identifier(&mode);
-            // Check for angle-* interpolation modes
-            if matches!(
-                normalized_mode.as_str(),
-                "angle-shorter" | "angle-longer" | "angle-clockwise" | "angle-counterclockwise"
-            ) && prop_type != Type::Angle
-            {
-                diag.push_error(
-                    format!(
-                        "The '{}' interpolation mode can only be used with angle properties, but '{}' has type {}",
-                        mode.trim(),
-                        prop_name.text().to_string().trim(),
-                        prop_type
-                    ),
-                    &qn,
-                );
+        // The `interpolation` property is only meaningful for angle properties
+        if prop_type != Type::Angle {
+            for binding in anim.Binding() {
+                let Some(ident) = binding.child_token(SyntaxKind::Identifier) else {
+                    continue;
+                };
+                if parser::normalize_identifier(ident.text()) == "interpolation" {
+                    diag.push_error(
+                        "The 'interpolation' property is only allowed when animating angle properties".into(),
+                        &ident,
+                    );
+                }
             }
         }
 

internal/compiler/tests/syntax/basic/property_animation.slint

@@ -11,26 +11,17 @@ export TestCase := Rectangle {
 //      ^error{Unknown property x in PropertyAnimation}
     }
 
-    // Test: angle-* interpolation modes should only be used with angle properties
+    // Test: interpolation property is rejected for non-angle properties
     animate width {
         interpolation: angle-shorter;
-//                     >           <error{The 'angle-shorter' interpolation mode can only be used with angle properties, but 'width' has type length}
+//      >           <error{The 'interpolation' property is only allowed when animating angle properties}
     }
     animate height {
-        interpolation: angle-longer;
-//                     >          <error{The 'angle-longer' interpolation mode can only be used with angle properties, but 'height' has type length}
-    }
-    animate opacity {
-        interpolation: angle-clockwise;
-//                     >             <error{The 'angle-clockwise' interpolation mode can only be used with angle properties, but 'opacity' has type float}
-    }
-
-    // Valid: linear interpolation can be used with any property type
-    animate min-width {
         interpolation: linear;
+//      >           <error{The 'interpolation' property is only allowed when animating angle properties}
     }
 
-    // Valid: angle-* interpolation with angle properties
+    // Valid: interpolation with angle properties
     property <angle> my-angle;
     animate my-angle {
         interpolation: angle-shorter;