Allow direct cast (abstracts) of typeParameters if underlying type matches target type.

m0rkeulv · m0rkeulv · commit 556bb60ea680 · 2025-03-02T20:50:27.000+01:00
+ check assign references for hints when determining array literal type.
diff --git a/src/main/java/com/intellij/plugins/haxe/model/evaluator/HaxeExpressionEvaluatorHandlers.java b/src/main/java/com/intellij/plugins/haxe/model/evaluator/HaxeExpressionEvaluatorHandlers.java
@@ -2295,6 +2295,21 @@ static ResultHolder findExpectedTypeForUnify(@NotNull PsiElement element) {
         }
       }
     }
+    if(parent instanceof  HaxeAssignExpression assignExpression) {
+      HaxeExpression leftExpression = assignExpression.getLeftExpression();
+      if(leftExpression instanceof HaxeReferenceExpression referenceExpression) {
+        PsiElement resolve = referenceExpression.resolve();
+        if(resolve instanceof  HaxePsiField field) {
+          HaxeTypeTag tag = field.getTypeTag();
+          if (tag != null) {
+            ResultHolder typeTag = HaxeTypeResolver.getTypeFromTypeTag(tag, element);
+            if (!typeTag.isUnknown()) {
+              return typeTag;
+            }
+          }
+        }
+      }
+    }
     if (parent instanceof HaxeCallExpressionList callExpressionList
         && callExpressionList.getParent() instanceof HaxeCallExpression callExpression) {
 
diff --git a/src/main/java/com/intellij/plugins/haxe/model/evaluator/assign/AssignEvaluationSettings.java b/src/main/java/com/intellij/plugins/haxe/model/evaluator/assign/AssignEvaluationSettings.java
@@ -5,6 +5,7 @@ public record AssignEvaluationSettings(
         boolean checkDirectCasts,
         boolean checkImplicitCasts,
         boolean contravariance,
-        boolean ignoreFromConstraints
+        boolean ignoreFromConstraints,
+        boolean implicitTypeMustMatchUnderlying
 ) {
 }
diff --git a/src/main/java/com/intellij/plugins/haxe/model/evaluator/assign/HaxeAssignEvaluation.java b/src/main/java/com/intellij/plugins/haxe/model/evaluator/assign/HaxeAssignEvaluation.java
@@ -57,8 +57,8 @@ public HaxeAssignEvaluation(@NotNull ResultHolder to, @NotNull ResultHolder from
       this.from = from.getType();
     }
     // contexts used to check if we are in a scope with macro keyword
-    toContext = to.getElementContext();
-    fromContext = from.getElementContext();
+    toContext = this.to.getElementContext();
+    fromContext = this.from.getElementContext();
   }
 
   public void fullyResolveTypes() {
@@ -302,7 +302,7 @@ static private boolean canAssignToFromFunction(
             toArgtype = tryExtractRestType(toArgtype);
           }
         }
-        boolean argCompatibility = HaxeTypeCompatible.canAssignToFromContravariance(toArgtype, fromArgType, true, false);
+        boolean argCompatibility = HaxeTypeCompatible.canAssignToFromContravariance(toArgtype, fromArgType, true, false, false);
         if (!argCompatibility) {
           return false;
         }
@@ -400,7 +400,7 @@ public void testTypeParameterConstraints(boolean checkDirectCasts, boolean check
    * Note: abstracts can be of all kinds of types(class, function enum, anonymous structures etc.) and can also be cased to these types
    * So there's a lot to check for here.
    */
-  public void testAbstractAssignRules(boolean checkDirectCasts, boolean checkImplicitCasts) {
+  public void testAbstractAssignRules(boolean checkDirectCasts, boolean checkImplicitCasts, boolean implicitTypeMustMatchUnderlying) {
     if (to instanceof SpecificHaxeClassReference toClassReference && from instanceof SpecificHaxeClassReference fromClassReference ) {
 
       HaxeClassModel toModel = toClassReference.getHaxeClassModel();
@@ -582,10 +582,15 @@ else if (from instanceof SpecificHaxeClassReference fromClassReference) {
    */
   private @Nullable Boolean canAssignUsingDirectCastFrom(SpecificHaxeClassReference toClassReference, SpecificTypeReference fromClassReference) {
     return directCastRecursionGuard.computePreventingRecursion(toClassReference.context, true, () -> {
+
       List<SpecificTypeReference> directCasts = toClassReference.getDirectCastFromTypes();
       for (SpecificTypeReference directCastType : directCasts) {
         // direct casts  can be "chained" (ex. Int -> Float -> Single)
         if (HaxeTypeCompatible.canAssignToFromReference(directCastType, fromClassReference, true, false)) {
+          //
+          if(config.implicitTypeMustMatchUnderlying()) {
+            if (underlyingTypeAndCastCheck(toClassReference, directCastType)) continue;
+          }
           complete(true, "Abstract (from) direct cast match");
           return true;
         }
@@ -594,16 +599,30 @@ else if (from instanceof SpecificHaxeClassReference fromClassReference) {
     });
   }
 
+  // TODO mlo: need verification
+  //  its unclear to me how / when type parameters of abstracts can be directly casted. from some simple tests it seems to be a
+  //  requirement that the abstracts direct cast matches its underlying type (only when working with typeParameters).
+  private static boolean underlyingTypeAndCastCheck(SpecificHaxeClassReference toClassReference, SpecificTypeReference directCastType) {
+    HaxeClassModel haxeClassModel = toClassReference.getHaxeClassModel();
+    if (haxeClassModel != null) {
+      SpecificTypeReference underlyingType = haxeClassModel.getUnderlyingType();
+      if (underlyingType != null && !underlyingType.isSameType(directCastType)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
 
   static boolean canAssignTypeParameters(HaxeAssignEvaluation context, @NotNull ResultHolder[] toSpecifics, @NotNull ResultHolder[] fromSpecifics) {
-   return canAssignTypeParameters(context,toSpecifics,fromSpecifics, false);
+   return canAssignTypeParameters(context,toSpecifics,fromSpecifics, false, false);
   }
-  static boolean canAssignTypeParameters(HaxeAssignEvaluation context, @NotNull ResultHolder[] toSpecifics, @NotNull ResultHolder[] fromSpecifics, boolean ignoreFromConstraints) {
+  static boolean canAssignTypeParameters(HaxeAssignEvaluation context, @NotNull ResultHolder[] toSpecifics, @NotNull ResultHolder[] fromSpecifics, boolean ignoreFromConstraints, boolean implicitTypeMustMatchUnderlying) {
     if (toSpecifics.length != fromSpecifics.length) return false;
     for (int i = 0, length = toSpecifics.length; i < length; i++) {
       ResultHolder toSpecific = toSpecifics[i];
       ResultHolder fromSpecific = fromSpecifics[i];
-      if (!HaxeTypeCompatible.canAssignToFromTypeParameter(context, toSpecific, fromSpecific, ignoreFromConstraints)) {
+      if (!HaxeTypeCompatible.canAssignToFromTypeParameter(context, toSpecific, fromSpecific, ignoreFromConstraints, implicitTypeMustMatchUnderlying)) {
         return false;
       }
     }
diff --git a/src/main/java/com/intellij/plugins/haxe/model/evaluator/assign/HaxeClassAssignUtil.java b/src/main/java/com/intellij/plugins/haxe/model/evaluator/assign/HaxeClassAssignUtil.java
@@ -19,7 +19,7 @@ public class HaxeClassAssignUtil  {
 
   static boolean sameTypeCheck(HaxeAssignEvaluation context, SpecificHaxeClassReference toClassReference, SpecificHaxeClassReference fromClassReference) {
     if (toClassReference.getHaxeClass() == fromClassReference.getHaxeClass()) {
-      if (canAssignTypeParameters(context, toClassReference.getSpecifics(), fromClassReference.getSpecifics(), context.getConfig().ignoreFromConstraints())) {
+      if (canAssignTypeParameters(context, toClassReference.getSpecifics(), fromClassReference.getSpecifics(), context.getConfig().ignoreFromConstraints(), true)) {
         return true;
       }
     }
diff --git a/src/main/java/com/intellij/plugins/haxe/model/evaluator/assign/HaxeTypeCompatible.java b/src/main/java/com/intellij/plugins/haxe/model/evaluator/assign/HaxeTypeCompatible.java
@@ -14,10 +14,10 @@ public class HaxeTypeCompatible {
 
     //TODO mlo: add some kind of recursion guard  (implicit cast can loop around)?
 
-    private static final AssignEvaluationSettings DEFAULT_SETTINGS = new AssignEvaluationSettings(false, true,true, false, false);
-    private static final AssignEvaluationSettings DEFAULT_STRICT_SETTINGS = new AssignEvaluationSettings(true, false, false, false, false);
-    private static final AssignEvaluationSettings CONTRAVARIANCE_SETTINGS = new AssignEvaluationSettings(false, true, true, true, false);
-    private static final AssignEvaluationSettings CALL_EXPRESSION_SETTINGS = new AssignEvaluationSettings(false, true, true, false, true);
+    private static final AssignEvaluationSettings DEFAULT_SETTINGS = new AssignEvaluationSettings(false, true,true, false, false, false);
+    private static final AssignEvaluationSettings DEFAULT_STRICT_SETTINGS = new AssignEvaluationSettings(true, false, false, false, false, false);
+    private static final AssignEvaluationSettings CONTRAVARIANCE_SETTINGS = new AssignEvaluationSettings(false, true, true, true, false, false);
+    private static final AssignEvaluationSettings CALL_EXPRESSION_SETTINGS = new AssignEvaluationSettings(false, true, true, false, true, false);
 
     /**
      * Regular can assign will allow Dynamic to be assigned to anything and also check implicit casts (@:to/@From) and handle special annotation rules
@@ -34,7 +34,7 @@ static public boolean canAssignToFromReference(HaxeAssignEvaluation context, @Nu
 
     static public boolean canAssignToFromReference(@Nullable SpecificTypeReference to, @Nullable SpecificTypeReference from, boolean checkDirectCasts, boolean checkImplicitCasts) {
         if (to == null || from == null) return false;
-        AssignEvaluationSettings settings = new AssignEvaluationSettings(false, checkDirectCasts, checkImplicitCasts, false, false);
+        AssignEvaluationSettings settings = new AssignEvaluationSettings(false, checkDirectCasts, checkImplicitCasts, false, false, false);
         return canAssignToFromEvaluation(to.createHolder(), from.createHolder(), settings, null).result;
     }
 
@@ -54,9 +54,9 @@ static public boolean canAssignToFromContravariance(@Nullable ResultHolder to, @
         return canAssignToFromEvaluation(to, from, CONTRAVARIANCE_SETTINGS, null).result;
     }
 
-    static public boolean canAssignToFromContravariance(@Nullable ResultHolder to, @Nullable ResultHolder from, boolean checkDirectCasts, boolean checkImplicitCasts) {
+    static public boolean canAssignToFromContravariance(@Nullable ResultHolder to, @Nullable ResultHolder from, boolean checkDirectCasts, boolean checkImplicitCasts, boolean implicitTypeMustMatchUnderlying) {
         if (to == null || from == null) return false;
-        AssignEvaluationSettings settings = new AssignEvaluationSettings(false, checkDirectCasts, checkImplicitCasts, true, false);
+        AssignEvaluationSettings settings = new AssignEvaluationSettings(false, checkDirectCasts, checkImplicitCasts, true, false, implicitTypeMustMatchUnderlying);
         return canAssignToFromEvaluation(to, from, settings, null).result;
     }
 
@@ -70,7 +70,7 @@ static public HaxeAssignEvaluation evaluateAssignToFromForNewAndCallExpression(@
 
     static public boolean canAssignToFromReference(@Nullable ResultHolder to, @Nullable ResultHolder from, boolean checkDirectCasts, boolean checkImplicitCasts, boolean contravariance) {
         if (to == null || from == null) return false;
-        AssignEvaluationSettings settings = new AssignEvaluationSettings(false, checkDirectCasts, checkImplicitCasts, contravariance, false);
+        AssignEvaluationSettings settings = new AssignEvaluationSettings(false, checkDirectCasts, checkImplicitCasts, contravariance, false, false);
         return canAssignToFromEvaluation(to, from, false, checkDirectCasts, checkImplicitCasts, contravariance).result;
     }
 
@@ -104,12 +104,12 @@ static public HaxeAssignEvaluation evaluateAssignToFrom(@NotNull ResultHolder to
      */
     static public boolean canAssignToFromTypeParameter(@Nullable ResultHolder to, @Nullable ResultHolder from) {
         if (to == null || from == null) return false;
-        return canAssignToFromTypeParameter(null, to, from, false);
+        return canAssignToFromTypeParameter(null, to, from, false, false);
     }
 
-    static public boolean canAssignToFromTypeParameter(HaxeAssignEvaluation context, @Nullable ResultHolder to, @Nullable ResultHolder from, boolean ignoreFromConstraints) {
+    static public boolean canAssignToFromTypeParameter(HaxeAssignEvaluation context, @Nullable ResultHolder to, @Nullable ResultHolder from, boolean ignoreFromConstraints,  boolean implicitTypeMustMatchUnderlying) {
         if (to == null || from == null) return false;
-        return canAssignToFromStrictEvaluation(context, to, from, ignoreFromConstraints).result;
+        return canAssignToFromStrictEvaluation(context, to, from, ignoreFromConstraints, implicitTypeMustMatchUnderlying).result;
     }
 
     /**
@@ -121,9 +121,9 @@ private static HaxeAssignEvaluation canAssignToFromStrictEvaluation(HaxeAssignEv
         return canAssignToFromEvaluation(to, from, DEFAULT_STRICT_SETTINGS, context);
     }
 
-    private static HaxeAssignEvaluation canAssignToFromStrictEvaluation(HaxeAssignEvaluation context, @NotNull ResultHolder to, @NotNull ResultHolder from, boolean ignoreFromConstraints) {
+    private static HaxeAssignEvaluation canAssignToFromStrictEvaluation(HaxeAssignEvaluation context, @NotNull ResultHolder to, @NotNull ResultHolder from, boolean ignoreFromConstraints, boolean implicitTypeMustMatchUnderlying) {
         // Note: There's a hack in abstract canAssign that allow  assign when abstracts underlying type is Dynamic and it got direct "from Dynamic" cast
-        AssignEvaluationSettings settings = new AssignEvaluationSettings(true, false, false, false, ignoreFromConstraints);
+        AssignEvaluationSettings settings = new AssignEvaluationSettings(true, true, false, false,  ignoreFromConstraints, implicitTypeMustMatchUnderlying);
         return canAssignToFromEvaluation(to, from, settings, context);
     }
 
@@ -163,7 +163,7 @@ static public HaxeAssignEvaluation canAssignToFromEvaluation(@NotNull ResultHold
                                                                  boolean contravariance,
                                                                  @Nullable HaxeAssignEvaluation parent
     ) {
-        AssignEvaluationSettings settings = new AssignEvaluationSettings(strictBasicCheck, checkDirectCasts, checkImplicitCasts, contravariance, false);
+        AssignEvaluationSettings settings = new AssignEvaluationSettings(strictBasicCheck, checkDirectCasts, checkImplicitCasts, contravariance, false, false);
         return canAssignToFromEvaluation(to,from, settings, parent);
     }
     static public HaxeAssignEvaluation canAssignToFromEvaluation(@NotNull ResultHolder to, @NotNull ResultHolder from,
@@ -189,7 +189,7 @@ static public HaxeAssignEvaluation canAssignToFromEvaluation(@NotNull ResultHold
                 if (!evaluation.completed) evaluation.testEnumAssignRules();
                 if (!evaluation.completed) evaluation.testFunctionAssignRules();
                 if (!evaluation.completed) evaluation.testAnonymousAssignRules();
-                if (!evaluation.completed) evaluation.testAbstractAssignRules(settings.checkDirectCasts(), settings.checkImplicitCasts());
+                if (!evaluation.completed) evaluation.testAbstractAssignRules(settings.checkDirectCasts(), settings.checkImplicitCasts(), settings.implicitTypeMustMatchUnderlying());
                 if (!evaluation.completed) evaluation.testTypeParameterConstraints(settings.checkDirectCasts(), settings.checkImplicitCasts());
                 return true;
             });
diff --git a/src/test/java/com/intellij/plugins/haxe/ide/HaxeSemanticAnnotatorTest.java b/src/test/java/com/intellij/plugins/haxe/ide/HaxeSemanticAnnotatorTest.java
@@ -611,6 +611,10 @@ public void testInitializeIntWithClass() throws Exception {
     doTestNoFixWithWarnings();
   }
 
+  @Test
+  public void testArrayLiteralTypeDetectionAndCast() throws Exception {
+    doTestNoFixWithWarnings();
+  }
   @Test
   public void testAssignClassToInt() throws Exception {
     doTestNoFixWithWarnings();
diff --git a/src/test/resources/testData/annotation.semantic/ArrayLiteralTypeDetectionAndCast.hx b/src/test/resources/testData/annotation.semantic/ArrayLiteralTypeDetectionAndCast.hx
@@ -0,0 +1,36 @@
+package ;
+
+class AssignArrayLiteral {
+    var fieldColor:Array<TestColor>;
+    var propertyColor(default, default):Array<TestColor>;
+
+    var fieldInt:Array<Int>;
+    var propertyInt(default, default):Array<Int>;
+
+    public function new() {
+        var variableColor:Array<TestColor>;
+        var variableInt:Array<Int>;
+        // correct
+        variableColor = [0xFF008000, 0xFFFF0000];
+        fieldColor = [0xFF008000, 0xFFFF0000];
+        propertyColor = [0xFF008000, 0xFFFF0000];
+
+        fieldInt = fieldColor;
+        propertyInt = propertyColor;
+        variableInt = variableColor;
+
+        argumentTest(variableColor, fieldColor, propertyColor);
+        argumentTest(variableInt, fieldInt, propertyColor);
+
+        //wrong
+        variableColor = <error descr="Incompatible type: Array<String> should be Array<TestColor>">["0xFF008000", "0xFFFF0000"]</error>;
+        fieldColor = <error descr="Incompatible type: Array<String> should be Array<TestColor>">["0xFF008000", "0xFFFF0000"]</error>;
+        propertyColor = <error descr="Incompatible type: Array<String> should be Array<TestColor>">["0xFF008000", "0xFFFF0000"]</error>;
+
+    }
+
+    public function argumentTest(x:Array<TestColor>, y:Array<Int>, z:Array<UInt>) {}
+}
+
+
+abstract TestColor(Int) from Int from UInt to Int to UInt {}
diff --git a/src/test/resources/testData/annotation.semantic/FunctionBind1.hx b/src/test/resources/testData/annotation.semantic/FunctionBind1.hx
@@ -36,16 +36,11 @@ class FunctionBindTest1 {
         var bind:(...Float) -> String = varargs.bind(1, _);
         var bind:haxe.Rest<Float> -> String = varargs.bind(1, _);
         var bind:Int -> String = varargs.bind(_, [1.0, 2.0, 3.0]);
-
+        var bind = varargs.bind(_, [1, 2, 3]);
 
         //wrong
         var bind = varargs.bind(1, <error descr="Type mismatch (Expected: 'haxe.Rest<Float>' got: 'String')">"string"</error>); // String should be haxe.Rest<Float>
         var bind = varargs.bind(<error descr="Too many arguments (expected 2 but got 3)\"">1, _, _</error> ); // Too many callback arguments
 
-
-//TODOS
-
-        //TODO should be allowed (literal array should be allowed to be interpetated as array floats)
-        var bind = varargs.bind(_, <error descr="Type mismatch (Expected: 'haxe.Rest<Float>' got: 'Array<Int>')">[1, 2, 3]</error>);
     }
 }
diff --git a/src/test/resources/testData/annotation.semantic/FunctionBind2.hx b/src/test/resources/testData/annotation.semantic/FunctionBind2.hx
@@ -32,17 +32,12 @@ class FunctionBindTest2 {
         var bind:(...Float) -> String = varargs.bind(1, _);
         var bind:haxe.Rest<Float > -> String  = varargs.bind( 1 , _);
         var bind:Int -> String = varargs.bind(_,  [1.0,  2.0, 3.0]);
-
+        var bind = varargs.bind(_, [1, 2, 3]);
 
         //wrong
         var bind = varargs.bind(1, <error descr="Type mismatch (Expected: 'haxe.Rest<Float>' got: 'String')">"string"</error>); // String should be haxe.Rest<Float>
         var bind = varargs.bind(<error descr="Too many arguments (expected 2 but got 3)\"">1, _, _</error> ); // Too many callback arguments
 
-
-        //TODOS
-
-        //TODO should be allowed (literal array should be allowed to be interpetated as array floats)
-        var bind = varargs.bind(_, <error descr="Type mismatch (Expected: 'haxe.Rest<Float>' got: 'Array<Int>')">[1, 2, 3]</error>);
     }
 
     function normal(x:Int, y:Float):String {return null;}

Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@ public record AssignEvaluationSettings(`
`5`	`5`	`boolean checkDirectCasts,`
`6`	`6`	`boolean checkImplicitCasts,`
`7`	`7`	`boolean contravariance,`
`8`		`- boolean ignoreFromConstraints`
	`8`	`+ boolean ignoreFromConstraints,`
	`9`	`+ boolean implicitTypeMustMatchUnderlying`
`9`	`10`	`) {`
`10`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public class HaxeClassAssignUtil {`
`19`	`19`
`20`	`20`	`static boolean sameTypeCheck(HaxeAssignEvaluation context, SpecificHaxeClassReference toClassReference, SpecificHaxeClassReference fromClassReference) {`
`21`	`21`	`if (toClassReference.getHaxeClass() == fromClassReference.getHaxeClass()) {`
`22`		`- if (canAssignTypeParameters(context, toClassReference.getSpecifics(), fromClassReference.getSpecifics(), context.getConfig().ignoreFromConstraints())) {`
	`22`	`+ if (canAssignTypeParameters(context, toClassReference.getSpecifics(), fromClassReference.getSpecifics(), context.getConfig().ignoreFromConstraints(), true)) {`
`23`	`23`	`return true;`
`24`	`24`	`}`
`25`	`25`	`}`