-
Notifications
You must be signed in to change notification settings - Fork 302
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
add support for accesses from lambdas
For lambdas in Java code (e.g. `() -> "some value"`) the compiler adds a synthetic static method to the Java class that follows the naming pattern `lambda$declaringMethod$42`. It also adds an `invokeDynamic` instruction that creates the link from the method that declares the lambda to this static method.
So far we ignore those `invokeDynamic` instructions for lambda cases. On the other hand we treat the synthetic lambda method like an ordinary method. This can lead to confusing behavior, e.g.
```
Supplier<SomeObject> call() {
return () -> new SomeObject();
}
```
will now create a `JavaConstructorCall` that originates from some method `lambda$call$0()`, while there will be no trace about any constructor call from within the method `call()`.
We decided that for a typical user the simplest and likely most appropriate behavior will be to treat this constructor call from within the lambda as a `JavaConstructorCall` from `call()` to `SomeObject.<init>()` (even though technically it is something different, since the call to `new SomeObject()` will in this case not happen on invocation time of the method, but on invocation time of the return value). From an architecture test point of view the relevant information will likely be, that there is a dependency from `call()` to `new SomeObject()`, which is exactly what this way of treating the call from the lambda will provide.
Thus, to improve this we will track all `invokeDynamic` instructions and then "merge" these with the accesses from synthetic lambda methods into more appropriate accesses from the code unit declaring the lambda to the target that the synthetic lambda method targets. For cases where users actually want to distinguish a "direct" access and one that is declared in the context of a lambda we add the boolean flag `declaredInLambda` to `JavaAccess`. This way the information can still be retrieved if it should be relevant in a certain context.
Signed-off-by: Hannes Oberprantacher <h.oberprantacher@gmail.com>
Signed-off-by: Peter Gafert <peter.gafert@tngtech.com>- Loading branch information
1 parent
e5bb469
commit a404fb4
Showing
18 changed files
with
854 additions
and
53 deletions.
There are no files selected for viewing
51 changes: 51 additions & 0 deletions
51
...m/tngtech/archunit/core/importer/ClassFileImporterLambdaAccessesNewerJavaVersionTest.java
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,51 @@ | ||
| package com.tngtech.archunit.core.importer; | ||
|
|
||
| import java.util.Set; | ||
| import java.util.function.Supplier; | ||
|
|
||
| import com.tngtech.archunit.core.domain.JavaAccess; | ||
| import com.tngtech.archunit.core.domain.JavaClasses; | ||
| import com.tngtech.archunit.core.domain.JavaConstructorCall; | ||
| import com.tngtech.java.junit.dataprovider.DataProviderRunner; | ||
| import org.junit.Test; | ||
| import org.junit.runner.RunWith; | ||
|
|
||
| import static com.google.common.collect.Iterables.getOnlyElement; | ||
| import static com.tngtech.archunit.core.domain.JavaConstructor.CONSTRUCTOR_NAME; | ||
| import static com.tngtech.archunit.testutil.Assertions.assertThatAccess; | ||
| import static java.util.stream.Collectors.toSet; | ||
|
|
||
| @RunWith(DataProviderRunner.class) | ||
| public class ClassFileImporterLambdaAccessesNewerJavaVersionTest { | ||
| /** | ||
| * This is a special case: For local constructors the Java compiler actually adds a lambda calling the constructor | ||
| * for a constructor reference. Since we do not distinguish between calls from within a lambda and outside it, | ||
| * this will lead to such a constructor reference being reported as a constructor call. | ||
| * | ||
| * Note that this actually does not compile with JDK 8 | ||
| */ | ||
| @Test | ||
| public void imports_constructor_reference_to_local_class_from_lambda_without_parameter_as_direct_call() { | ||
| class Target { | ||
| } | ||
|
|
||
| @SuppressWarnings("unused") | ||
| class Caller { | ||
| Supplier<Supplier<Target>> call() { | ||
| return () -> Target::new; | ||
| } | ||
| } | ||
|
|
||
| JavaClasses classes = new ClassFileImporter().importClasses(Target.class, Caller.class); | ||
| JavaConstructorCall call = getOnlyElement( | ||
| filterOriginByName(classes.get(Caller.class).getConstructorCallsFromSelf(), "call")); | ||
|
|
||
| assertThatAccess(call).isFrom("call").isTo(Target.class, CONSTRUCTOR_NAME, getClass()); | ||
| } | ||
|
|
||
| private <ACCESS extends JavaAccess<?>> Set<ACCESS> filterOriginByName(Set<ACCESS> calls, String methodName) { | ||
| return calls.stream() | ||
| .filter(call -> call.getOrigin().getName().equals(methodName)) | ||
| .collect(toSet()); | ||
| } | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.