archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-27 06:45:07 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8335642: Hide Transform implementation for Class-File API

Browse source 
Reviewed-by: asotona
This commit is contained in:
Chen Liang 2024-07-15 12:11:53 +00:00
parent 2b0adfc2de
commit a253e0ff4b
9 changed files with 66 additions and 136 deletions
Download patch file Download diff file Expand all files Collapse all files

17
src/java.base/share/classes/java/lang/classfile/ClassFileBuilder.java
View file

@ -27,8 +27,9 @@ package java.lang.classfile;
import java.lang.constant.ClassDesc;
import java.util.function.Consumer;
import java.lang.classfile.constantpool.ConstantPool;
import java.lang.classfile.constantpool.ConstantPoolBuilder;
import jdk.internal.classfile.impl.TransformImpl;
import jdk.internal.javac.PreviewFeature;
/**
@ -71,25 +72,19 @@ public sealed interface ClassFileBuilder<E extends ClassFileElement, B extends C
*/
ConstantPoolBuilder constantPool();
/**
* {@return whether the provided constant pool is compatible with this builder}
* @param source the constant pool to test compatibility with
*/
default boolean canWriteDirect(ConstantPool source) {
return constantPool().canWriteDirect(source);
}
/**
* Apply a transform to a model, directing results to this builder.
* @param model the model to transform
* @param transform the transform to apply
* @return this builder
*/
default void transform(CompoundElement<E> model, ClassFileTransform<?, E, B> transform) {
default B transform(CompoundElement<E> model, ClassFileTransform<?, E, B> transform) {
@SuppressWarnings("unchecked")
B builder = (B) this;
var resolved = transform.resolve(builder);
var resolved = TransformImpl.resolve(transform, builder);
resolved.startHandler().run();
model.forEach(resolved.consumer());
resolved.endHandler().run();
return builder;
}
}

45
src/java.base/share/classes/java/lang/classfile/ClassFileTransform.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2022, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -24,7 +24,6 @@
*/
package java.lang.classfile;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.lang.classfile.attribute.RuntimeVisibleAnnotationsAttribute;
@ -124,46 +123,4 @@ public sealed interface ClassFileTransform<
* @return the chained transform
*/
C andThen(C next);
/**
* The result of binding a transform to a builder. Used primarily within
* the implementation to perform transformation.
*
* @param <E> the element type
*
* @since 22
*/
@PreviewFeature(feature = PreviewFeature.Feature.CLASSFILE_API)
interface ResolvedTransform<E extends ClassFileElement> {
/**
* {@return a {@link Consumer} to receive elements}
*/
Consumer<E> consumer();
/**
* {@return an action to call at the end of transformation}
*/
Runnable endHandler();
/**
* {@return an action to call at the start of transformation}
*/
Runnable startHandler();
}
/**
* Bind a transform to a builder. If the transform is chained, intermediate
* builders are created for each chain link. If the transform is stateful
* (see, e.g., {@link ClassTransform#ofStateful(Supplier)}), the supplier is
* invoked to get a fresh transform object.
*
* <p>This method is a low-level method that should rarely be used by
* user code; most of the time, user code should prefer
* {@link ClassFileBuilder#transform(CompoundElement, ClassFileTransform)},
* which resolves the transform and executes it on the current builder.
*
* @param builder the builder to bind to
* @return the bound result
*/
ResolvedTransform<E> resolve(B builder);
}

13
src/java.base/share/classes/java/lang/classfile/ClassTransform.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2022, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -171,15 +171,4 @@ public non-sealed interface ClassTransform
default ClassTransform andThen(ClassTransform t) {
return new TransformImpl.ChainedClassTransform(this, t);
}
/**
* @implSpec The default implementation returns a resolved transform bound
* to the given class builder.
*/
@Override
default ResolvedTransform<ClassElement> resolve(ClassBuilder builder) {
return new TransformImpl.ResolvedTransformImpl<>(e -> accept(builder, e),
() -> atEnd(builder),
() -> atStart(builder));
}
}

3
src/java.base/share/classes/java/lang/classfile/CodeBuilder.java
View file

@ -87,6 +87,7 @@ import java.lang.classfile.instruction.TypeCheckInstruction;
import static java.util.Objects.requireNonNull;
import static jdk.internal.classfile.impl.BytecodeHelpers.handleDescToHandleInfo;
import jdk.internal.classfile.impl.TransformImpl;
import jdk.internal.javac.PreviewFeature;
/**
@ -190,7 +191,7 @@ public sealed interface CodeBuilder
* @return this builder
*/
default CodeBuilder transforming(CodeTransform transform, Consumer<CodeBuilder> handler) {
var resolved = transform.resolve(this);
var resolved = TransformImpl.resolve(transform, this);
resolved.startHandler().run();
handler.accept(new ChainedCodeBuilder(this, resolved.consumer()));
resolved.endHandler().run();

13
src/java.base/share/classes/java/lang/classfile/CodeTransform.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2022, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -96,15 +96,4 @@ public non-sealed interface CodeTransform
default CodeTransform andThen(CodeTransform t) {
return new TransformImpl.ChainedCodeTransform(this, t);
}
/**
* @implSpec The default implementation returns a resolved transform bound
* to the given code builder.
*/
@Override
default ResolvedTransform<CodeElement> resolve(CodeBuilder builder) {
return new TransformImpl.ResolvedTransformImpl<>(e -> accept(builder, e),
() -> atEnd(builder),
() -> atStart(builder));
}
}

13
src/java.base/share/classes/java/lang/classfile/FieldTransform.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2022, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -111,15 +111,4 @@ public non-sealed interface FieldTransform
default FieldTransform andThen(FieldTransform t) {
return new TransformImpl.ChainedFieldTransform(this, t);
}
/**
* @implSpec The default implementation returns a resolved transform bound
* to the given field builder.
*/
@Override
default ResolvedTransform<FieldElement> resolve(FieldBuilder builder) {
return new TransformImpl.ResolvedTransformImpl<>(e -> accept(builder, e),
() -> atEnd(builder),
() -> atStart(builder));
}
}

13
src/java.base/share/classes/java/lang/classfile/MethodTransform.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2022, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -111,17 +111,6 @@ public non-sealed interface MethodTransform
return new TransformImpl.MethodCodeTransform(xform);
}
/**
* @implSpec The default implementation returns a resolved transform bound
* to the given method builder.
*/
@Override
default ResolvedTransform<MethodElement> resolve(MethodBuilder builder) {
return new TransformImpl.ResolvedTransformImpl<>(e -> accept(builder, e),
() -> atEnd(builder),
() -> atStart(builder));
}
/**
* @implSpec
* The default implementation returns this method transform chained with another

7
src/java.base/share/classes/jdk/internal/classfile/impl/AbstractDirectBuilder.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2022, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -24,6 +24,7 @@
*/
package jdk.internal.classfile.impl;
import java.lang.classfile.constantpool.ConstantPool;
import java.util.Optional;
import java.lang.classfile.Attribute;
@ -43,6 +44,10 @@ public class AbstractDirectBuilder<M> {
return constantPool;
}
public boolean canWriteDirect(ConstantPool source) {
return constantPool().canWriteDirect(source);
}
public Optional<M> original() {
return Optional.ofNullable(original);
}

78
src/java.base/share/classes/jdk/internal/classfile/impl/TransformImpl.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2022, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -24,6 +24,8 @@
*/
package jdk.internal.classfile.impl;
import java.lang.classfile.ClassFileBuilder;
import java.lang.classfile.ClassFileTransform;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;
@ -32,7 +34,6 @@ import java.lang.classfile.ClassBuilder;
import java.lang.classfile.ClassElement;
import java.lang.classfile.ClassTransform;
import java.lang.classfile.ClassFileElement;
import java.lang.classfile.ClassFileTransform;
import java.lang.classfile.CodeBuilder;
import java.lang.classfile.CodeElement;
import java.lang.classfile.CodeModel;
@ -46,7 +47,7 @@ import java.lang.classfile.MethodElement;
import java.lang.classfile.MethodModel;
import java.lang.classfile.MethodTransform;
public class TransformImpl {
public final class TransformImpl {
// ClassTransform
private TransformImpl() {
@ -58,7 +59,23 @@ public class TransformImpl {
private static final Runnable NOTHING = () -> { };
interface UnresolvedClassTransform extends ClassTransform {
public static <E extends ClassFileElement, B extends ClassFileBuilder<E, B>>
ResolvedTransform<E> resolve(ClassFileTransform<?, E, B> transform, B builder) {
if (transform instanceof ResolvableTransform) {
@SuppressWarnings("unchecked")
var ut = (ResolvableTransform<E, B>) transform;
return ut.resolve(builder);
}
return new ResolvedTransform<>(e -> transform.accept(builder, e),
() -> transform.atEnd(builder),
() -> transform.atStart(builder));
}
interface ResolvableTransform<E extends ClassFileElement, B extends ClassFileBuilder<E, B>> {
ResolvedTransform<E> resolve(B builder);
}
interface UnresolvedClassTransform extends ClassTransform, ResolvableTransform<ClassElement, ClassBuilder> {
@Override
default void accept(ClassBuilder builder, ClassElement element) {
throw new UnsupportedOperationException("transforms must be resolved before running");
@ -75,12 +92,11 @@ public class TransformImpl {
}
}
public record ResolvedTransformImpl<E extends ClassFileElement>(Consumer<E> consumer,
public record ResolvedTransform<E extends ClassFileElement>(Consumer<E> consumer,
Runnable endHandler,
Runnable startHandler)
implements ClassFileTransform.ResolvedTransform<E> {
Runnable startHandler) {
public ResolvedTransformImpl(Consumer<E> consumer) {
public ResolvedTransform(Consumer<E> consumer) {
this(consumer, NOTHING, NOTHING);
}
}
@ -89,11 +105,11 @@ public class TransformImpl {
ClassTransform next)
implements UnresolvedClassTransform {
@Override
public ResolvedTransformImpl<ClassElement> resolve(ClassBuilder builder) {
ResolvedTransform<ClassElement> downstream = next.resolve(builder);
public ResolvedTransform<ClassElement> resolve(ClassBuilder builder) {
ResolvedTransform<ClassElement> downstream = TransformImpl.resolve(next, builder);
ClassBuilder chainedBuilder = new ChainedClassBuilder(builder, downstream.consumer());
ResolvedTransform<ClassElement> upstream = t.resolve(chainedBuilder);
return new ResolvedTransformImpl<>(upstream.consumer(),
ResolvedTransform<ClassElement> upstream = TransformImpl.resolve(t, chainedBuilder);
return new ResolvedTransform<>(upstream.consumer(),
chainRunnable(upstream.endHandler(), downstream.endHandler()),
chainRunnable(upstream.startHandler(), downstream.startHandler()));
}
@ -103,7 +119,7 @@ public class TransformImpl {
implements UnresolvedClassTransform {
@Override
public ResolvedTransform<ClassElement> resolve(ClassBuilder builder) {
return supplier.get().resolve(builder);
return TransformImpl.resolve(supplier.get(), builder);
}
}
@ -112,7 +128,7 @@ public class TransformImpl {
implements UnresolvedClassTransform {
@Override
public ResolvedTransform<ClassElement> resolve(ClassBuilder builder) {
return new ResolvedTransformImpl<>(ce -> {
return new ResolvedTransform<>(ce -> {
if (ce instanceof MethodModel mm && filter.test(mm))
builder.transformMethod(mm, transform);
else
@ -135,7 +151,7 @@ public class TransformImpl {
implements UnresolvedClassTransform {
@Override
public ResolvedTransform<ClassElement> resolve(ClassBuilder builder) {
return new ResolvedTransformImpl<>(ce -> {
return new ResolvedTransform<>(ce -> {
if (ce instanceof FieldModel fm && filter.test(fm))
builder.transformField(fm, transform);
else
@ -155,7 +171,7 @@ public class TransformImpl {
// MethodTransform
interface UnresolvedMethodTransform extends MethodTransform {
interface UnresolvedMethodTransform extends MethodTransform, ResolvableTransform<MethodElement, MethodBuilder> {
@Override
default void accept(MethodBuilder builder, MethodElement element) {
throw new UnsupportedOperationException("transforms must be resolved before running");
@ -177,10 +193,10 @@ public class TransformImpl {
implements TransformImpl.UnresolvedMethodTransform {
@Override
public ResolvedTransform<MethodElement> resolve(MethodBuilder builder) {
ResolvedTransform<MethodElement> downstream = next.resolve(builder);
ResolvedTransform<MethodElement> downstream = TransformImpl.resolve(next, builder);
MethodBuilder chainedBuilder = new ChainedMethodBuilder(builder, downstream.consumer());
ResolvedTransform<MethodElement> upstream = t.resolve(chainedBuilder);
return new ResolvedTransformImpl<>(upstream.consumer(),
ResolvedTransform<MethodElement> upstream = TransformImpl.resolve(t, chainedBuilder);
return new ResolvedTransform<>(upstream.consumer(),
chainRunnable(upstream.endHandler(), downstream.endHandler()),
chainRunnable(upstream.startHandler(), downstream.startHandler()));
}
@ -190,7 +206,7 @@ public class TransformImpl {
implements TransformImpl.UnresolvedMethodTransform {
@Override
public ResolvedTransform<MethodElement> resolve(MethodBuilder builder) {
return supplier.get().resolve(builder);
return TransformImpl.resolve(supplier.get(), builder);
}
}
@ -198,7 +214,7 @@ public class TransformImpl {
implements TransformImpl.UnresolvedMethodTransform {
@Override
public ResolvedTransform<MethodElement> resolve(MethodBuilder builder) {
return new ResolvedTransformImpl<>(me -> {
return new ResolvedTransform<>(me -> {
if (me instanceof CodeModel cm) {
builder.transformCode(cm, xform);
}
@ -219,7 +235,7 @@ public class TransformImpl {
// FieldTransform
interface UnresolvedFieldTransform extends FieldTransform {
interface UnresolvedFieldTransform extends FieldTransform, ResolvableTransform<FieldElement, FieldBuilder> {
@Override
default void accept(FieldBuilder builder, FieldElement element) {
throw new UnsupportedOperationException("transforms must be resolved before running");
@ -240,10 +256,10 @@ public class TransformImpl {
implements UnresolvedFieldTransform {
@Override
public ResolvedTransform<FieldElement> resolve(FieldBuilder builder) {
ResolvedTransform<FieldElement> downstream = next.resolve(builder);
ResolvedTransform<FieldElement> downstream = TransformImpl.resolve(next, builder);
FieldBuilder chainedBuilder = new ChainedFieldBuilder(builder, downstream.consumer());
ResolvedTransform<FieldElement> upstream = t.resolve(chainedBuilder);
return new ResolvedTransformImpl<>(upstream.consumer(),
ResolvedTransform<FieldElement> upstream = TransformImpl.resolve(t, chainedBuilder);
return new ResolvedTransform<>(upstream.consumer(),
chainRunnable(upstream.endHandler(), downstream.endHandler()),
chainRunnable(upstream.startHandler(), downstream.startHandler()));
}
@ -253,13 +269,13 @@ public class TransformImpl {
implements UnresolvedFieldTransform {
@Override
public ResolvedTransform<FieldElement> resolve(FieldBuilder builder) {
return supplier.get().resolve(builder);
return TransformImpl.resolve(supplier.get(), builder);
}
}
// CodeTransform
interface UnresolvedCodeTransform extends CodeTransform {
interface UnresolvedCodeTransform extends CodeTransform, ResolvableTransform<CodeElement, CodeBuilder> {
@Override
default void accept(CodeBuilder builder, CodeElement element) {
throw new UnsupportedOperationException("transforms must be resolved before running");
@ -280,10 +296,10 @@ public class TransformImpl {
implements UnresolvedCodeTransform {
@Override
public ResolvedTransform<CodeElement> resolve(CodeBuilder builder) {
ResolvedTransform<CodeElement> downstream = next.resolve(builder);
ResolvedTransform<CodeElement> downstream = TransformImpl.resolve(next, builder);
CodeBuilder chainedBuilder = new ChainedCodeBuilder(builder, downstream.consumer());
ResolvedTransform<CodeElement> upstream = t.resolve(chainedBuilder);
return new ResolvedTransformImpl<>(upstream.consumer(),
ResolvedTransform<CodeElement> upstream = TransformImpl.resolve(t, chainedBuilder);
return new ResolvedTransform<>(upstream.consumer(),
chainRunnable(upstream.endHandler(), downstream.endHandler()),
chainRunnable(upstream.startHandler(), downstream.startHandler()));
}
@ -293,7 +309,7 @@ public class TransformImpl {
implements UnresolvedCodeTransform {
@Override
public ResolvedTransform<CodeElement> resolve(CodeBuilder builder) {
return supplier.get().resolve(builder);
return TransformImpl.resolve(supplier.get(), builder);
}
}
}