| // Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| package com.android.tools.r8.tracereferences; |
| |
| import com.android.tools.r8.DiagnosticsHandler; |
| import com.android.tools.r8.Keep; |
| import com.android.tools.r8.KeepForSubclassing; |
| import com.android.tools.r8.references.ClassReference; |
| import com.android.tools.r8.references.FieldReference; |
| import com.android.tools.r8.references.MethodReference; |
| import com.android.tools.r8.references.PackageReference; |
| |
| /** Consumer interface for recording references */ |
| @KeepForSubclassing |
| public interface TraceReferencesConsumer { |
| |
| /** |
| * Interface for asking for the access flags for a traced reference when the definition is present |
| */ |
| @Keep |
| interface AccessFlags { |
| boolean isStatic(); |
| |
| boolean isPublic(); |
| |
| boolean isProtected(); |
| |
| boolean isPrivate(); |
| } |
| |
| /** |
| * Interface for asking for additional class information for a traced class when the definition is |
| * found. |
| */ |
| @Keep |
| interface ClassAccessFlags extends AccessFlags { |
| boolean isInterface(); |
| |
| boolean isEnum(); |
| } |
| |
| @Keep |
| interface FieldAccessFlags extends AccessFlags {} |
| |
| @Keep |
| interface MethodAccessFlags extends AccessFlags {} |
| |
| /** Interface implemented by all references reported */ |
| @Keep |
| interface TracedReference<T, F> { |
| /** Returns if the reference does not have a definition in the program traced. */ |
| boolean isMissingDefinition(); |
| |
| /** Returns the reference traced. */ |
| T getReference(); |
| |
| /** |
| * Returns the access flags for the reference traced. If the definition is not found (<code> |
| * isMissingDefinition()</code> returns <code>true</code>) the access flags are not known and |
| * this returns <code>null</code>. |
| */ |
| F getAccessFlags(); |
| } |
| |
| @Keep |
| interface TracedClass extends TracedReference<ClassReference, ClassAccessFlags> {} |
| |
| @Keep |
| interface TracedField extends TracedReference<FieldReference, FieldAccessFlags> {} |
| |
| @Keep |
| interface TracedMethod extends TracedReference<MethodReference, MethodAccessFlags> {} |
| |
| /** |
| * Callback when class has been traced. |
| * |
| * <p>The consumer is expected not to throw, but instead report any errors via the diagnostics |
| * {@param handler}. If an error is reported via {@param handler} and no exceptions are thrown, |
| * then trace references guaranties to exit with an error. |
| * |
| * @param tracedClass Traced class |
| * @param handler Diagnostics handler for reporting. |
| */ |
| void acceptType(TracedClass tracedClass, DiagnosticsHandler handler); |
| |
| /** |
| * Callback when class has been traced. |
| * |
| * <p>The consumer is expected not to throw, but instead report any errors via the diagnostics |
| * {@param handler}. If an error is reported via {@param handler} and no exceptions are thrown, |
| * then trace references guaranties to exit with an error. |
| * |
| * @param tracedField Traced field |
| * @param handler Diagnostics handler for reporting. |
| */ |
| void acceptField(TracedField tracedField, DiagnosticsHandler handler); |
| |
| /** |
| * Callback when class has been traced. |
| * |
| * <p>The consumer is expected not to throw, but instead report any errors via the diagnostics |
| * {@param handler}. If an error is reported via {@param handler} and no exceptions are thrown, |
| * then trace references guaranties to exit with an error. |
| * |
| * @param tracedMethod Traced method |
| * @param handler Diagnostics handler for reporting. |
| */ |
| void acceptMethod(TracedMethod tracedMethod, DiagnosticsHandler handler); |
| |
| /** |
| * Callback when package which is required for package private access has been traced. |
| * |
| * <p>The consumer is expected not to throw, but instead report any errors via the diagnostics |
| * {@param handler}. If an error is reported via {@param handler} and no exceptions are thrown, |
| * then trace references guaranties to exit with an error. |
| * |
| * @param pkg Traced package |
| * @param handler Diagnostics handler for reporting. |
| */ |
| default void acceptPackage(PackageReference pkg, DiagnosticsHandler handler) {} |
| |
| /** |
| * Tracing has finished. There will be no more calls to any of the <code>acceptXXX</code> methods. |
| * |
| * <p>The consumer is expected not to throw, but instead report any errors via the diagnostics |
| * {@param handler}. If an error is reported via {@param handler} and no exceptions are thrown, |
| * then trace references guaranties to exit with an error. |
| * |
| * @param handler Diagnostics handler for reporting. |
| */ |
| default void finished(DiagnosticsHandler handler) {} |
| |
| static TraceReferencesConsumer emptyConsumer() { |
| return ForwardingConsumer.EMPTY_CONSUMER; |
| } |
| |
| /** Forwarding consumer to delegate to an optional existing consumer. */ |
| @Keep |
| class ForwardingConsumer implements TraceReferencesConsumer { |
| |
| private static final TraceReferencesConsumer EMPTY_CONSUMER = new ForwardingConsumer(null); |
| |
| private final TraceReferencesConsumer consumer; |
| |
| public ForwardingConsumer(TraceReferencesConsumer consumer) { |
| this.consumer = consumer; |
| } |
| |
| @Override |
| public void acceptType(TracedClass tracedClass, DiagnosticsHandler handler) { |
| if (consumer != null) { |
| consumer.acceptType(tracedClass, handler); |
| } |
| } |
| |
| @Override |
| public void acceptField(TracedField tracedField, DiagnosticsHandler handler) { |
| if (consumer != null) { |
| consumer.acceptField(tracedField, handler); |
| } |
| } |
| |
| @Override |
| public void acceptMethod(TracedMethod tracedMethod, DiagnosticsHandler handler) { |
| if (consumer != null) { |
| consumer.acceptMethod(tracedMethod, handler); |
| } |
| } |
| |
| @Override |
| public void acceptPackage(PackageReference pkg, DiagnosticsHandler handler) { |
| if (consumer != null) { |
| consumer.acceptPackage(pkg, handler); |
| } |
| } |
| |
| @Override |
| public void finished(DiagnosticsHandler handler) { |
| if (consumer != null) { |
| consumer.finished(handler); |
| } |
| } |
| } |
| } |