| // Copyright (c) 2019, 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.retrace.internal; |
| |
| import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRange; |
| import com.android.tools.r8.naming.ClassNamingForNameMapper.MappedRangesOfName; |
| import com.android.tools.r8.naming.MemberNaming; |
| import com.android.tools.r8.naming.MemberNaming.MethodSignature; |
| import com.android.tools.r8.naming.mappinginformation.OutlineCallsiteMappingInformation; |
| import com.android.tools.r8.references.MethodReference; |
| import com.android.tools.r8.retrace.RetraceMethodElement; |
| import com.android.tools.r8.retrace.RetraceMethodResult; |
| import com.android.tools.r8.retrace.RetraceStackTraceContext; |
| import com.android.tools.r8.retrace.RetracedMethodReference; |
| import com.android.tools.r8.retrace.RetracedSourceFile; |
| import com.android.tools.r8.retrace.internal.RetraceClassResultImpl.RetraceClassElementImpl; |
| import com.android.tools.r8.utils.ListUtils; |
| import com.android.tools.r8.utils.OptionalBool; |
| import com.android.tools.r8.utils.Pair; |
| import java.util.ArrayList; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.OptionalInt; |
| import java.util.Set; |
| import java.util.function.Function; |
| import java.util.stream.Stream; |
| |
| public class RetraceMethodResultImpl implements RetraceMethodResult { |
| |
| private final MethodDefinition methodDefinition; |
| private final RetraceClassResultImpl classResult; |
| private final List<Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>>> |
| mappedRanges; |
| private final RetracerImpl retracer; |
| private OptionalBool isAmbiguousCache = OptionalBool.UNKNOWN; |
| |
| RetraceMethodResultImpl( |
| RetraceClassResultImpl classResult, |
| List<Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>>> mappedRanges, |
| MethodDefinition methodDefinition, |
| RetracerImpl retracer) { |
| this.classResult = classResult; |
| this.mappedRanges = mappedRanges; |
| this.methodDefinition = methodDefinition; |
| this.retracer = retracer; |
| assert classResult != null; |
| assert !mappedRanges.isEmpty(); |
| } |
| |
| @Override |
| public boolean isAmbiguous() { |
| if (!isAmbiguousCache.isUnknown()) { |
| return isAmbiguousCache.isTrue(); |
| } |
| if (mappedRanges.size() > 1) { |
| isAmbiguousCache = OptionalBool.TRUE; |
| return true; |
| } |
| List<MemberNamingWithMappedRangesOfName> mappedRangesOfNames = mappedRanges.get(0).getSecond(); |
| if (mappedRangesOfNames == null || mappedRangesOfNames.size() < 2) { |
| isAmbiguousCache = OptionalBool.FALSE; |
| return false; |
| } |
| MethodSignature outermostSignature = |
| ListUtils.last(mappedRangesOfNames.get(0).getMappedRanges()) |
| .getOriginalSignature() |
| .asMethodSignature(); |
| for (int i = 1; i < mappedRangesOfNames.size(); i++) { |
| if (!outermostSignature.equals( |
| ListUtils.last(mappedRangesOfNames.get(i).getMappedRanges()) |
| .getOriginalSignature() |
| .asMethodSignature())) { |
| isAmbiguousCache = OptionalBool.TRUE; |
| return true; |
| } |
| } |
| isAmbiguousCache = OptionalBool.FALSE; |
| return false; |
| } |
| |
| @Override |
| public boolean isEmpty() { |
| List<MemberNamingWithMappedRangesOfName> mappedRangesOfNames = mappedRanges.get(0).getSecond(); |
| return mappedRangesOfNames == null || mappedRangesOfNames.isEmpty(); |
| } |
| |
| @Override |
| public RetraceFrameResultImpl narrowByPosition( |
| RetraceStackTraceContext context, OptionalInt position) { |
| List<RetraceFrameResultData> narrowedRanges = new ArrayList<>(); |
| RetraceStackTraceContextImpl stackTraceContext = null; |
| if (context instanceof RetraceStackTraceContextImpl) { |
| stackTraceContext = (RetraceStackTraceContextImpl) context; |
| } |
| boolean hasPosition = position.isPresent() && position.getAsInt() > 0; |
| Function<MemberNamingWithMappedRangesOfName, List<MappedRange>> selector = |
| hasPosition ? filterOnExistingPosition(position.getAsInt()) : filterOnNoPosition(); |
| for (Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>> mappedRange : |
| mappedRanges) { |
| narrowMappedRangeByPosition( |
| mappedRange, selector, position, stackTraceContext, narrowedRanges); |
| } |
| if (hasPosition && narrowedRanges.isEmpty()) { |
| for (Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>> mappedRange : |
| mappedRanges) { |
| narrowMappedRangeByPosition( |
| mappedRange, |
| filterOnMappedRangesWithNoMinifiedRange(), |
| position, |
| stackTraceContext, |
| narrowedRanges); |
| } |
| } |
| if (narrowedRanges.isEmpty()) { |
| boolean preamblePosition = position.isEmpty() || position.getAsInt() <= 0; |
| for (Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>> mappedRange : |
| mappedRanges) { |
| List<MemberNamingWithMappedRangesOfName> memberNamingWithMappedRanges = new ArrayList<>(); |
| // If we could find a result, and we have observed a reported preamble position, we create a |
| // mapping containing only the member-naming. |
| if (mappedRange.getSecond() != null && preamblePosition) { |
| memberNamingWithMappedRanges = |
| ListUtils.map( |
| mappedRange.getSecond(), |
| m -> |
| // Check if we have a catch-all range since that could map 0 to a non-zero |
| // original line. |
| m.isSingleCatchAllRange() |
| ? m |
| : new MemberNamingWithMappedRangesOfName( |
| m.getMemberNaming(), MappedRangesOfName.empty())); |
| } |
| narrowedRanges.add( |
| new RetraceFrameResultData( |
| mappedRange.getFirst(), memberNamingWithMappedRanges, position)); |
| } |
| } |
| return new RetraceFrameResultImpl( |
| classResult, |
| narrowedRanges, |
| methodDefinition, |
| retracer, |
| (RetraceStackTraceContextImpl) context); |
| } |
| |
| private void narrowMappedRangeByPosition( |
| Pair<RetraceClassElementImpl, List<MemberNamingWithMappedRangesOfName>> mappedRange, |
| Function<MemberNamingWithMappedRangesOfName, List<MappedRange>> selector, |
| OptionalInt position, |
| RetraceStackTraceContextImpl stackTraceContext, |
| List<RetraceFrameResultData> narrowedRanges) { |
| List<MemberNamingWithMappedRangesOfName> memberNamingWithMappedRanges = mappedRange.getSecond(); |
| if (memberNamingWithMappedRanges == null) { |
| narrowedRanges.add(new RetraceFrameResultData(mappedRange.getFirst(), null, position)); |
| return; |
| } |
| List<MemberNamingWithMappedRangesOfName> newMemberNamingsResult = new ArrayList<>(); |
| for (MemberNamingWithMappedRangesOfName memberNamingWithMappedRange : |
| memberNamingWithMappedRanges) { |
| List<MappedRange> mappedRangesForPosition = selector.apply(memberNamingWithMappedRange); |
| if (mappedRangesForPosition == null || mappedRangesForPosition.isEmpty()) { |
| continue; |
| } else if (stackTraceContext != null && stackTraceContext.hasRewritePosition()) { |
| List<OutlineCallsiteMappingInformation> outlineCallsiteInformation = |
| ListUtils.last(mappedRangesForPosition).getOutlineCallsiteInformation(); |
| if (!outlineCallsiteInformation.isEmpty()) { |
| assert outlineCallsiteInformation.size() == 1 |
| : "There can only be one outline entry for a line"; |
| int newPosition = |
| outlineCallsiteInformation |
| .get(0) |
| .rewritePosition(stackTraceContext.getRewritePosition()); |
| narrowMappedRangeByPosition( |
| mappedRange, |
| filterOnExistingPosition(newPosition), |
| OptionalInt.of(newPosition), |
| stackTraceContext.buildFromThis().clearRewritePosition().build(), |
| narrowedRanges); |
| return; |
| } |
| } |
| MemberNamingWithMappedRangesOfName newMemberNaming = |
| new MemberNamingWithMappedRangesOfName( |
| memberNamingWithMappedRange.getMemberNaming(), |
| new MappedRangesOfName(mappedRangesForPosition)); |
| newMemberNamingsResult.add(newMemberNaming); |
| } |
| if (!newMemberNamingsResult.isEmpty()) { |
| narrowedRanges.add( |
| new RetraceFrameResultData(mappedRange.getFirst(), newMemberNamingsResult, position)); |
| } |
| } |
| |
| private Function<MemberNamingWithMappedRangesOfName, List<MappedRange>> filterOnExistingPosition( |
| int position) { |
| return memberNamingWithMappedRange -> memberNamingWithMappedRange.allRangesForLine(position); |
| } |
| |
| private Function<MemberNamingWithMappedRangesOfName, List<MappedRange>> |
| filterOnMappedRangesWithNoMinifiedRange() { |
| return MemberNamingWithMappedRangesOfName::mappedRangesWithNoMinifiedRange; |
| } |
| |
| private Function<MemberNamingWithMappedRangesOfName, List<MappedRange>> filterOnNoPosition() { |
| return MemberNamingWithMappedRangesOfName::getMappedRangesWithNoMinifiedRangeAndPositionZero; |
| } |
| |
| @Override |
| public Stream<RetraceMethodElement> stream() { |
| return mappedRanges.stream() |
| .flatMap( |
| mappedRangePair -> { |
| RetraceClassElementImpl classElement = mappedRangePair.getFirst(); |
| List<MemberNamingWithMappedRangesOfName> memberNamingsWithMappedRange = |
| mappedRangePair.getSecond(); |
| if (memberNamingsWithMappedRange == null || memberNamingsWithMappedRange.isEmpty()) { |
| return Stream.of( |
| new ElementImpl( |
| this, |
| classElement, |
| RetracedMethodReferenceImpl.create( |
| methodDefinition.substituteHolder( |
| classElement.getRetracedClass().getClassReference())), |
| null)); |
| } |
| Set<MethodSignature> seen = new HashSet<>(); |
| List<ElementImpl> newElements = new ArrayList<>(memberNamingsWithMappedRange.size()); |
| memberNamingsWithMappedRange.forEach( |
| memberNamingWithMappedRangesOfName -> { |
| MethodSignature originalSignature = |
| getMethodSignatureFromMapping(memberNamingWithMappedRangesOfName); |
| if (seen.add(originalSignature)) { |
| MethodReference methodReference = |
| RetraceUtils.methodReferenceFromMethodSignature( |
| originalSignature, |
| classElement.getRetracedClass().getClassReference()); |
| newElements.add( |
| new ElementImpl( |
| this, |
| classElement, |
| RetracedMethodReferenceImpl.create(methodReference), |
| memberNamingWithMappedRangesOfName)); |
| } |
| }); |
| return newElements.stream(); |
| }); |
| } |
| |
| private MethodSignature getMethodSignatureFromMapping( |
| MemberNamingWithMappedRangesOfName memberNamingWithMappedRanges) { |
| MemberNaming memberNaming = memberNamingWithMappedRanges.getMemberNaming(); |
| return (memberNaming != null && !isAmbiguous()) |
| ? memberNaming.getOriginalSignature().asMethodSignature() |
| : ListUtils.last(memberNamingWithMappedRanges.getMappedRanges()) |
| .getOriginalSignature() |
| .asMethodSignature(); |
| } |
| |
| public static class ElementImpl implements RetraceMethodElement { |
| |
| private final RetracedMethodReferenceImpl methodReference; |
| private final RetraceMethodResultImpl retraceMethodResult; |
| private final RetraceClassElementImpl classElement; |
| private final MemberNamingWithMappedRangesOfName mapping; |
| |
| private ElementImpl( |
| RetraceMethodResultImpl retraceMethodResult, |
| RetraceClassElementImpl classElement, |
| RetracedMethodReferenceImpl methodReference, |
| MemberNamingWithMappedRangesOfName mapping) { |
| this.classElement = classElement; |
| this.retraceMethodResult = retraceMethodResult; |
| this.methodReference = methodReference; |
| this.mapping = mapping; |
| } |
| |
| @Override |
| public boolean isCompilerSynthesized() { |
| if (mapping == null) { |
| return false; |
| } |
| if (mapping.getMemberNaming() != null && !retraceMethodResult.isAmbiguous()) { |
| return mapping.getMemberNaming().isCompilerSynthesized(); |
| } else { |
| List<MappedRange> mappedRanges = mapping.getMappedRanges(); |
| return !mappedRanges.isEmpty() && ListUtils.last(mappedRanges).isCompilerSynthesized(); |
| } |
| } |
| |
| @Override |
| public boolean isUnknown() { |
| return methodReference.isUnknown(); |
| } |
| |
| @Override |
| public RetracedMethodReference getRetracedMethod() { |
| return methodReference; |
| } |
| |
| @Override |
| public RetraceMethodResult getParentResult() { |
| return retraceMethodResult; |
| } |
| |
| @Override |
| public RetraceClassElementImpl getClassElement() { |
| return classElement; |
| } |
| |
| @Override |
| public RetracedSourceFile getSourceFile() { |
| return RetraceUtils.getSourceFile( |
| methodReference.getHolderClass(), retraceMethodResult.retracer); |
| } |
| } |
| } |
