Type can be weakened (e.g. use Collection instead of List here). Generalization of ConcreteCollectionCheck

[Luro02]

What it does

It should do what the IntelliJ lint does, detect code segments where one can use an interface (or superclass?) instead of the current type, because the code does not use any of the concrete types.

Locations where this might be done:

• variable declaration: local, parameter, field
• return value (might be tricky to implement, but could be worth it)

How to implement

The code tries to find types that can be replaced with either a supertype or an interface without the existing code breaking.

0. Check that all assigned values can be converted to the super type
1. For declarations, find all uses of the variable. For return values, find all invocations of the method.
2. Check if all uses/accesses would work with a super type as well (e.g. variable not passed to a method only taking ArrayList, only invokes methods that are in List as well, ...). Here one might do a more complex implementation by checking if the use can be weakened as well. (Note: This might hurt performance)

It might make sense to implement some form of utility method similar to the findCommonParent one, like this:

CtType<?> findCommonType(CtTypedElement first, CtTypedElement... other) {
    // ...
}

Lint Name

TYPE_CAN_BE_WEAKENED

Category

oop

Example

<code>

Could be written as:

<code>