Unnecessary reflections in code generated for arrays

[volivan239]

Description

In some cases codegen works with arrays using reflection even if there is no need for it.

To Reproduce

Run plugin on the following code:

package rndpkg;

class C {
    int x;
    public C(int x) { this.x = x; }
}

public class SomeClass {
    public int f(C[] c) {
        c[0].x -= 1;
        return c[0].x;
    }
}

Expected behavior

Produced tests don't use reflection.

Actual behavior

Tests look like this:

  @Test
  @DisplayName("f: c = C[0] -> throw ArrayIndexOutOfBoundsException")
  public void testFThrowsAIOOBEWithEmptyObjectArray() throws Throwable {
      SomeClass someClass = new SomeClass();
      Object[] c = createArray("rndpkg.C", 0);
      
      /* This test fails because method [rndpkg.SomeClass.f] produces [java.lang.ArrayIndexOutOfBoundsException: 0]
          rndpkg.SomeClass.f(SomeClass.java:10) */
      Class someClassClazz = Class.forName("rndpkg.SomeClass");
      Class cType = Class.forName("[Lrndpkg.C;");
      Method fMethod = someClassClazz.getDeclaredMethod("f", cType);
      fMethod.setAccessible(true);
      Object[] fMethodArguments = new Object[1];
      fMethodArguments[0] = c;
      try {
          fMethod.invoke(someClass, fMethodArguments);
      } catch (InvocationTargetException invocationTargetException) {
          throw invocationTargetException.getTargetException();
      }
  }

[alisevych]

@volivan239

Additional context

Reflection is used for Object instantiating for the following class also:

import java.util.Arrays;

public class Bor  {

    public String[] next = new String[12];

    Bor() {
        Arrays.fill(next, "boo");
    }

    public int size() {
        return next.length;
    }

}

[volivan239]

@alisevych Thanks for your example! Although, I think the reasons for using reflection here are not related to arrays and it is an another issue.

The problem here is that apparently, according to the comments in code, we use only constructors that satisfy condition: the body of constructor contains only statements matching pattern this.a = something where "a" is an argument of the constructor (although this is not true for fuzzer). So, we are not using non-trivial constructors. For example, in the following example we will use reflection too (fuzzer needs to be turned off):

public class Bor  {
    int x;

    int helper() {
        return 0;
    }

    Bor() {
        this.x = helper();
    }

    public int size() {
        return 1;
    }
}

It needs discussion why it is so and how we can change this behavior. Unfortunately, I'm not competent enough to say something definite.

[alisevych]

@volivan239 Thank you for investigation! Will create a separate Feature request for this subject.

[alisevych]

@volivan239
Please check test generation for the following code - reflection is used for SomeClass instantiating:

class C {
    int x;
    public C(int x) { this.x = x; }
}

public class SomeClass {

    private C[] array = new C[2];
    public void f(C c) {
        array[0] = c;
        array[1] = c;
    }
}

[volivan239]

@volivan239 Please check test generation for the following code - reflection is used for SomeClass instantiating:

class C {
    int x;
    public C(int x) { this.x = x; }
}

public class SomeClass {

    private C[] array = new C[2];
    public void f(C c) {
        array[0] = c;
        array[1] = c;
    }
}

I believe it is more or less expected behavior here: SomeClass has private fields, so we need reflection to set them anyway. And as long as we need reflection, instantiating through createInstance seems (to me) more straightforward than using constructors and then directly setting all fields.