Kotlin class assertion generation problem

There is a small problem:

Generator is creating assertion methods twice in Abstract***Assert classes for code where Kotlin class with lateinit collection field is generified with complex java class. Generated code cannot compile

Example to reproduce the problem:

Klass.kt:

```
class Klass {
lateinit var collection: Collection
}
```

JavaClass.java:

```
public class JavaClass {}
```

Result:
```
/**
* Abstract base class for {@link Klass} specific assertions - Generated by CustomAssertionGenerator.
*/
@javax.annotation.Generated(value="assertj-assertions-generator")
public abstract class AbstractKlassAssert, A extends Klass> extends AbstractObjectAssert {

/**
* Creates a new {@link AbstractKlassAssert} to make assertions on actual Klass.
* @param actual the Klass we want to make assertions on.
*/
protected AbstractKlassAssert(A actual, Class selfType) {
super(actual, selfType);
}

/**
* Verifies that the actual Klass's collection contains the given JavaClass elements.
* @param collection the given elements that should be contained in actual Klass's collection.
* @return this assertion object.
* @throws AssertionError if the actual Klass's collection does not contain all given JavaClass elements.
*/
public S hasCollection(JavaClass... collection) {
// check that actual Klass we want to make assertions on is not null.
isNotNull();

// check that given JavaClass varargs is not null.
if (collection == null) failWithMessage("Expecting collection parameter not to be null.");

// check with standard error message, to set another message call: info.overridingErrorMessage("my error message");
Iterables.instance().assertContains(info, actual.getCollection(), collection);

// return the current assertion for method chaining
return myself;
}

/**
* Verifies that the actual Klass's collection contains the given JavaClass elements in Collection.
* @param collection the given elements that should be contained in actual Klass's collection.
* @return this assertion object.
* @throws AssertionError if the actual Klass's collection does not contain all given JavaClass elements.
*/
public S hasCollection(java.util.Collection collection) {
// check that actual Klass we want to make assertions on is not null.
isNotNull();

// check that given JavaClass collection is not null.
if (collection == null) {
failWithMessage("Expecting collection parameter not to be null.");
return myself; // to fool Eclipse "Null pointer access" warning on toArray.
}

// check with standard error message, to set another message call: info.overridingErrorMessage("my error message");
Iterables.instance().assertContains(info, actual.getCollection(), collection.toArray());

// return the current assertion for method chaining
return myself;
}

/**
* Verifies that the actual Klass's collection contains only the given JavaClass elements and nothing else in whatever order.
* @param collection the given elements that should be contained in actual Klass's collection.
* @return this assertion object.
* @throws AssertionError if the actual Klass's collection does not contain all given JavaClass elements.
*/
public S hasOnlyCollection(JavaClass... collection) {
// check that actual Klass we want to make assertions on is not null.
isNotNull();

// check that given JavaClass varargs is not null.
if (collection == null) failWithMessage("Expecting collection parameter not to be null.");

// check with standard error message, to set another message call: info.overridingErrorMessage("my error message");
Iterables.instance().assertContainsOnly(info, actual.getCollection(), collection);

// return the current assertion for method chaining
return myself;
}

/**
* Verifies that the actual Klass's collection contains only the given JavaClass elements in Collection and nothing else in whatever order.
* @param collection the given elements that should be contained in actual Klass's collection.
* @return this assertion object.
* @throws AssertionError if the actual Klass's collection does not contain all given JavaClass elements.
*/
public S hasOnlyCollection(java.util.Collection collection) {
// check that actual Klass we want to make assertions on is not null.
isNotNull();

// check that given JavaClass collection is not null.
if (collection == null) {
failWithMessage("Expecting collection parameter not to be null.");
return myself; // to fool Eclipse "Null pointer access" warning on toArray.
}

// check with standard error message, to set another message call: info.overridingErrorMessage("my error message");
Iterables.instance().assertContainsOnly(info, actual.getCollection(), collection.toArray());

// return the current assertion for method chaining
return myself;
}

/**
* Verifies that the actual Klass's collection does not contain the given JavaClass elements.
*
* @param collection the given elements that should not be in actual Klass's collection.
* @return this assertion object.
* @throws AssertionError if the actual Klass's collection contains any given JavaClass elements.
*/
public S doesNotHaveCollection(JavaClass... collection) {
// check that actual Klass we want to make assertions on is not null.
isNotNull();

// check that given JavaClass varargs is not null.
if (collection == null) failWithMessage("Expecting collection parameter not to be null.");

// check with standard error message (use overridingErrorMessage before contains to set your own message).
Iterables.instance().assertDoesNotContain(info, actual.getCollection(), collection);

// return the current assertion for method chaining
return myself;
}

/**
* Verifies that the actual Klass's collection does not contain the given JavaClass elements in Collection.
*
* @param collection the given elements that should not be in actual Klass's collection.
* @return this assertion object.
* @throws AssertionError if the actual Klass's collection contains any given JavaClass elements.
*/
public S doesNotHaveCollection(java.util.Collection collection) {
// check that actual Klass we want to make assertions on is not null.
isNotNull();

// check that given JavaClass collection is not null.
if (collection == null) {
failWithMessage("Expecting collection parameter not to be null.");
return myself; // to fool Eclipse "Null pointer access" warning on toArray.
}

// check with standard error message (use overridingErrorMessage before contains to set your own message).
Iterables.instance().assertDoesNotContain(info, actual.getCollection(), collection.toArray());

// return the current assertion for method chaining
return myself;
}

/**
* Verifies that the actual Klass has no collection.
* @return this assertion object.
* @throws AssertionError if the actual Klass's collection is not empty.
*/
public S hasNoCollection() {
// check that actual Klass we want to make assertions on is not null.
isNotNull();

// we override the default error message with a more explicit one
String assertjErrorMessage = "\nExpecting :\n <%s>\nnot to have collection but had :\n <%s>";

// check
if (actual.getCollection().iterator().hasNext()) {
failWithMessage(assertjErrorMessage, actual, actual.getCollection());
}

// return the current assertion for method chaining
return myself;
}

/**
* Verifies that the actual Klass's collection contains the given JavaClass elements.
* @param collection the given elements that should be contained in actual Klass's collection.
* @return this assertion object.
* @throws AssertionError if the actual Klass's collection does not contain all given JavaClass elements.
*/
public S hasCollection(JavaClass... collection) {
// check that actual Klass we want to make assertions on is not null.
isNotNull();

// check that given JavaClass varargs is not null.
if (collection == null) failWithMessage("Expecting collection parameter not to be null.");

// check with standard error message, to set another message call: info.overridingErrorMessage("my error message");
Iterables.instance().assertContains(info, actual.collection, collection);

// return the current assertion for method chaining
return myself;
}

/**
* Verifies that the actual Klass's collection contains the given JavaClass elements in Collection.
* @param collection the given elements that should be contained in actual Klass's collection.
* @return this assertion object.
* @throws AssertionError if the actual Klass's collection does not contain all given JavaClass elements.
*/
public S hasCollection(java.util.Collection collection) {
// check that actual Klass we want to make assertions on is not null.
isNotNull();

// check that given JavaClass collection is not null.
if (collection == null) {
failWithMessage("Expecting collection parameter not to be null.");
return myself; // to fool Eclipse "Null pointer access" warning on toArray.
}

// check with standard error message, to set another message call: info.overridingErrorMessage("my error message");
Iterables.instance().assertContains(info, actual.collection, collection.toArray());

// return the current assertion for method chaining
return myself;
}

/**
* Verifies that the actual Klass's collection contains only the given JavaClass elements and nothing else in whatever order.
* @param collection the given elements that should be contained in actual Klass's collection.
* @return this assertion object.
* @throws AssertionError if the actual Klass's collection does not contain all given JavaClass elements.
*/
public S hasOnlyCollection(JavaClass... collection) {
// check that actual Klass we want to make assertions on is not null.
isNotNull();

// check that given JavaClass varargs is not null.
if (collection == null) failWithMessage("Expecting collection parameter not to be null.");

// check with standard error message, to set another message call: info.overridingErrorMessage("my error message");
Iterables.instance().assertContainsOnly(info, actual.collection, collection);

// return the current assertion for method chaining
return myself;
}

/**
* Verifies that the actual Klass's collection contains only the given JavaClass elements in Collection and nothing else in whatever order.
* @param collection the given elements that should be contained in actual Klass's collection.
* @return this assertion object.
* @throws AssertionError if the actual Klass's collection does not contain all given JavaClass elements.
*/
public S hasOnlyCollection(java.util.Collection collection) {
// check that actual Klass we want to make assertions on is not null.
isNotNull();

// check that given JavaClass collection is not null.
if (collection == null) {
failWithMessage("Expecting collection parameter not to be null.");
return myself; // to fool Eclipse "Null pointer access" warning on toArray.
}

// check with standard error message, to set another message call: info.overridingErrorMessage("my error message");
Iterables.instance().assertContainsOnly(info, actual.collection, collection.toArray());

// return the current assertion for method chaining
return myself;
}

/**
* Verifies that the actual Klass's collection does not contain the given JavaClass elements.
*
* @param collection the given elements that should not be in actual Klass's collection.
* @return this assertion object.
* @throws AssertionError if the actual Klass's collection contains any given JavaClass elements.
*/
public S doesNotHaveCollection(JavaClass... collection) {
// check that actual Klass we want to make assertions on is not null.
isNotNull();

// check that given JavaClass varargs is not null.
if (collection == null) failWithMessage("Expecting collection parameter not to be null.");

// check with standard error message (use overridingErrorMessage before contains to set your own message).
Iterables.instance().assertDoesNotContain(info, actual.collection, collection);

// return the current assertion for method chaining
return myself;
}

/**
* Verifies that the actual Klass's collection does not contain the given JavaClass elements in Collection.
*
* @param collection the given elements that should not be in actual Klass's collection.
* @return this assertion object.
* @throws AssertionError if the actual Klass's collection contains any given JavaClass elements.
*/
public S doesNotHaveCollection(java.util.Collection collection) {
// check that actual Klass we want to make assertions on is not null.
isNotNull();

// check that given JavaClass collection is not null.
if (collection == null) {
failWithMessage("Expecting collection parameter not to be null.");
return myself; // to fool Eclipse "Null pointer access" warning on toArray.
}

// check with standard error message (use overridingErrorMessage before contains to set your own message).
Iterables.instance().assertDoesNotContain(info, actual.collection, collection.toArray());

// return the current assertion for method chaining
return myself;
}

/**
* Verifies that the actual Klass has no collection.
* @return this assertion object.
* @throws AssertionError if the actual Klass's collection is not empty.
*/
public S hasNoCollection() {
// check that actual Klass we want to make assertions on is not null.
isNotNull();

// we override the default error message with a more explicit one
String assertjErrorMessage = "\nExpecting :\n <%s>\nnot to have collection but had :\n <%s>";

// check
if (actual.collection.iterator().hasNext()) {
failWithMessage(assertjErrorMessage, actual, actual.collection);
}

// return the current assertion for method chaining
return myself;
}

}
```

Beginne mit dem Kotlin-Reproducer in Klass.kt und JavaClass.java und untersuche anschließend den Generatorpfad, der AbstractKlassAssert erzeugt. Bestätige, dass die generierten Assertion-Methoden nur einmal ausgegeben werden und dass die resultierende Java-Klasse kompiliert.

Vom Indexierungsmodell aus dem Issue-Text verfasst.