Datasets:
Mlxa
/
java_methods

Dataset card Data Studio Files
xet
Community
1
Unnamed: 0
int64
0
305k
body
stringlengths
7
52.9k
name
stringlengths
1
185
23,300
Result (@NotNull TraceInfo info) { final Map<TraceElement, List<TraceElement>> direct = info.getDirectTrace(); final Map<TraceElement, List<TraceElement>> reverse = info.getReverseTrace(); if (direct == null || reverse == null) { // TODO: throw correct exception throw new RuntimeException(); } return Result.of(direct, reverse); }
resolve
23,301
Result (@NotNull TraceInfo info) { final Map<Integer, TraceElement> before = info.getValuesOrderBefore(); final Map<Integer, TraceElement> after = info.getValuesOrderAfter(); final Map<TraceElement, List<TraceElement>> direct = new HashMap<>(); final Map<TraceElement, List<TraceElement>> reverse = new HashMap<>(); final Map<Object, List<TraceElement>> grouped = StreamEx .of(after.keySet()) .sorted() .map(after::get) .groupingBy(IdentityResolver::extractKey); final Map<Object, Integer> key2Index = new HashMap<>(); for (final TraceElement element : before.values()) { final Object key = extractKey(element); final List<TraceElement> elements = grouped.get(key); if (elements == null || elements.isEmpty()) { direct.put(element, Collections.emptyList()); continue; } final int nextIndex = key2Index.getOrDefault(key, -1) + 1; key2Index.put(key, nextIndex); final TraceElement afterItem = elements.get(nextIndex); direct.put(element, Collections.singletonList(afterItem)); reverse.put(afterItem, Collections.singletonList(element)); } return Result.of(direct, reverse); }
resolve
23,302
Object (@NotNull TraceElement element) { final Object key = TraceUtil.extractKey(element); return key == null ? NULL_MARKER : key; }
extractKey
23,303
Result (@NotNull TraceInfo info) { final Map<TraceElement, List<TraceElement>> forward = new LinkedHashMap<>(); final Map<TraceElement, List<TraceElement>> backward = new LinkedHashMap<>(); final Map<Integer, TraceElement> before = info.getValuesOrderBefore(); final Map<Integer, TraceElement> after = info.getValuesOrderAfter(); if (after.isEmpty()) { before.values().forEach(x -> forward.put(x, Collections.emptyList())); } else { assert after.size() == 1; final TraceElement optionalContent = after.values().iterator().next(); final List<TraceElement> backwardTrace = new ArrayList<>(); final Object optionalKey = TraceUtil.extractKey(optionalContent); for (final TraceElement beforeElement : before.values()) { if (Objects.equals(TraceUtil.extractKey(beforeElement), optionalKey)) { backwardTrace.add(beforeElement); forward.put(beforeElement, Collections.singletonList(optionalContent)); } else { forward.put(beforeElement, Collections.emptyList()); } } backward.put(optionalContent, backwardTrace); } return Result.of(forward, backward); }
resolve
23,304
Result (@NotNull TraceInfo info) { final Map<Integer, TraceElement> before = info.getValuesOrderBefore(); final Map<Integer, TraceElement> after = info.getValuesOrderAfter(); assert after.size() == 1; final TraceElement resultElement = after.values().iterator().next(); final List<TraceElement> to = Collections.singletonList(resultElement); final Map<TraceElement, List<TraceElement>> forward = new LinkedHashMap<>(); for (final TraceElement beforeElement : before.values()) { forward.put(beforeElement, to); } final Map<TraceElement, List<TraceElement>> backward = Collections.singletonMap(resultElement, new ArrayList<>(before.values())); return Result.of(forward, backward); }
resolve
23,305
Result (@NotNull TraceInfo info) { final Map<Integer, TraceElement> before = info.getValuesOrderBefore(); final Map<Integer, TraceElement> after = info.getValuesOrderAfter(); assert before.size() >= after.size(); final Map<TraceElement, List<TraceElement>> forward = new LinkedHashMap<>(); final Map<TraceElement, List<TraceElement>> backward = new LinkedHashMap<>(); final int[] beforeTimes = before.keySet().stream().mapToInt(Integer::intValue).sorted().toArray(); final int[] afterTimes = after.keySet().stream().mapToInt(Integer::intValue).sorted().toArray(); int beforeIndex = 0; for (final int afterTime : afterTimes) { final TraceElement afterElement = after.get(afterTime); final Value afterValue = afterElement.getValue(); while (beforeIndex < beforeTimes.length) { final TraceElement beforeElement = before.get(beforeTimes[beforeIndex]); if (Objects.equals(beforeElement.getValue(), afterValue)) { forward.put(beforeElement, Collections.singletonList(afterElement)); backward.put(afterElement, Collections.singletonList(beforeElement)); beforeIndex++; break; } forward.put(beforeElement, Collections.emptyList()); beforeIndex++; } } while (beforeIndex < beforeTimes.length) { final int beforeTime = beforeTimes[beforeIndex]; forward.put(before.get(beforeTime), Collections.emptyList()); beforeIndex++; } return Result.of(forward, backward); }
resolve
23,306
Result (@NotNull Map<TraceElement, List<TraceElement>> direct, @NotNull Map<TraceElement, List<TraceElement>> reverse) { return new Result() { @NotNull @Override public Map<TraceElement, List<TraceElement>> getDirectOrder() { return direct; } @NotNull @Override public Map<TraceElement, List<TraceElement>> getReverseOrder() { return reverse; } }; }
of
23,307
Result (@NotNull TraceInfo info) { final Map<Integer, TraceElement> before = info.getValuesOrderBefore(); final Map<Integer, TraceElement> after = info.getValuesOrderAfter(); final Iterator<TraceElement> leftIterator = before.values().iterator(); final Iterator<TraceElement> rightIterator = after.values().iterator(); final Map<TraceElement, List<TraceElement>> forward = new LinkedHashMap<>(); final Map<TraceElement, List<TraceElement>> backward = new LinkedHashMap<>(); while (leftIterator.hasNext() && rightIterator.hasNext()) { final TraceElement left = leftIterator.next(); final TraceElement right = rightIterator.next(); forward.put(left, Collections.singletonList(right)); backward.put(right, Collections.singletonList(left)); } while (leftIterator.hasNext()) { forward.put(leftIterator.next(), Collections.emptyList()); } return Result.of(forward, backward); }
resolve
23,308
Result (@NotNull TraceInfo info) { final Map<Integer, TraceElement> before = info.getValuesOrderBefore(); final Map<Integer, TraceElement> after = info.getValuesOrderAfter(); final Map<TraceElement, List<TraceElement>> forward = new HashMap<>(); final Map<TraceElement, List<TraceElement>> backward = new HashMap<>(); final int[] beforeTimes = before.keySet().stream().mapToInt(Integer::intValue).toArray(); final int[] afterTimes = after.keySet().stream().mapToInt(Integer::intValue).toArray(); int beforeIndex = 0; for (int i = 0; i < beforeTimes.length; i++) { final TraceElement afterElement = before.get(beforeTimes[i]); final List<TraceElement> afterElements = new ArrayList<>(); final int nextBeforeTime = i + 1 < beforeTimes.length ? beforeTimes[i + 1] : Integer.MAX_VALUE; while (beforeIndex < afterTimes.length && afterTimes[beforeIndex] < nextBeforeTime) { final TraceElement beforeElement = after.get(afterTimes[beforeIndex]); afterElements.add(beforeElement); backward.put(beforeElement, Collections.singletonList(afterElement)); beforeIndex++; } forward.put(afterElement, afterElements); } return Result.of(forward, backward); }
resolve
23,309
Result (@NotNull TraceInfo info) { final Map<Integer, TraceElement> orderBefore = info.getValuesOrderBefore(); final Map<Integer, TraceElement> orderAfter = info.getValuesOrderAfter(); return Result.of(toEmptyMap(orderBefore), toEmptyMap(orderAfter)); }
resolve
23,310
void (@NotNull ResolvedStreamCall.Intermediate intermediate) { myIntermediates.add(intermediate); }
addIntermediate
23,311
void (@NotNull ResolvedStreamCall.Terminator terminator) { myTerminator = terminator; }
setTerminator
23,312
ResolvedStreamChain () { if (myTerminator == null) { throw new IllegalStateException("terminator not specified"); } return new ResolvedStreamChainImpl(myTerminator, myIntermediates); }
build
23,313
TerminatorStreamCall () { return myCall; }
getCall
23,314
PrevAwareState () { return myStateAfter; }
getStateAfter
23,315
NextAwareState () { return myStateBefore; }
getStateBefore
23,316
IntermediateStreamCall () { return myCall; }
getCall
23,317
NextAwareState () { return myStateBefore; }
getStateBefore
23,318
PrevAwareState () { return myStateAfter; }
getStateAfter
23,319
List<LibrarySupportProvider> () { return EP_NAME.getExtensionList(); }
getList
23,320
void (@NotNull StreamChain chain, @NotNull TracingCallback callback) { final String streamTraceExpression = myExpressionBuilder.createTraceExpression(chain); final XStackFrame stackFrame = mySession.getCurrentStackFrame(); final XDebuggerEvaluator evaluator = mySession.getDebugProcess().getEvaluator(); if (stackFrame != null && evaluator != null) { evaluator.evaluate(XExpressionImpl.fromText(streamTraceExpression, EvaluationMode.CODE_FRAGMENT), new XEvaluationCallbackBase() { @Override public void evaluated(@NotNull XValue result) { if (result instanceof JavaValue) { final Value reference = ((JavaValue)result).getDescriptor().getValue(); if (reference instanceof ArrayReference) { final TracingResult interpretedResult; try { interpretedResult = myResultInterpreter.interpret(chain, (ArrayReference)reference); } catch (Throwable t) { callback.evaluationFailed(streamTraceExpression, StreamDebuggerBundle.message("evaluation.failed.cannot.interpret.result", t.getMessage())); throw t; } final EvaluationContextImpl context = ((JavaValue)result).getEvaluationContext(); callback.evaluated(interpretedResult, context); return; } if (reference instanceof ObjectReference) { final ReferenceType type = ((ObjectReference)reference).referenceType(); if (type instanceof ClassType classType) { while (classType != null && !CommonClassNames.JAVA_LANG_THROWABLE.equals(classType.name())) { classType = classType.superclass(); } if (classType != null) { final String exceptionMessage = tryExtractExceptionMessage((ObjectReference)reference); final String description = "Evaluation failed: " + type.name() + " exception thrown"; final String descriptionWithReason = exceptionMessage == null ? description : description + ": " + exceptionMessage; callback.evaluationFailed(streamTraceExpression, descriptionWithReason); return; } } } } callback.evaluationFailed(streamTraceExpression, StreamDebuggerBundle.message("evaluation.failed.unknown.result.type")); } @Override public void errorOccurred(@NotNull String errorMessage) { callback.compilationFailed(streamTraceExpression, errorMessage); } }, stackFrame.getSourcePosition()); } }
trace
23,321
void (@NotNull XValue result) { if (result instanceof JavaValue) { final Value reference = ((JavaValue)result).getDescriptor().getValue(); if (reference instanceof ArrayReference) { final TracingResult interpretedResult; try { interpretedResult = myResultInterpreter.interpret(chain, (ArrayReference)reference); } catch (Throwable t) { callback.evaluationFailed(streamTraceExpression, StreamDebuggerBundle.message("evaluation.failed.cannot.interpret.result", t.getMessage())); throw t; } final EvaluationContextImpl context = ((JavaValue)result).getEvaluationContext(); callback.evaluated(interpretedResult, context); return; } if (reference instanceof ObjectReference) { final ReferenceType type = ((ObjectReference)reference).referenceType(); if (type instanceof ClassType classType) { while (classType != null && !CommonClassNames.JAVA_LANG_THROWABLE.equals(classType.name())) { classType = classType.superclass(); } if (classType != null) { final String exceptionMessage = tryExtractExceptionMessage((ObjectReference)reference); final String description = "Evaluation failed: " + type.name() + " exception thrown"; final String descriptionWithReason = exceptionMessage == null ? description : description + ": " + exceptionMessage; callback.evaluationFailed(streamTraceExpression, descriptionWithReason); return; } } } } callback.evaluationFailed(streamTraceExpression, StreamDebuggerBundle.message("evaluation.failed.unknown.result.type")); }
evaluated
23,322
void (@NotNull String errorMessage) { callback.compilationFailed(streamTraceExpression, errorMessage); }
errorOccurred
23,323
String (@NotNull ObjectReference exception) { final ReferenceType type = exception.referenceType(); final Field messageField = type.fieldByName("detailMessage"); if (messageField == null) return null; final Value message = exception.getValue(messageField); if (message instanceof StringReference) { return ((StringReference)message).value(); } return null; }
tryExtractExceptionMessage
23,324
TraceElement (@Nullable Value streamResult) { return new TraceElementImpl(Integer.MAX_VALUE, streamResult); }
ofResultValue
23,325
boolean (Object obj) { if (obj instanceof TraceElement) { final int time = ((TraceElement)obj).getTime(); return time == myTime; } return false; }
equals
23,326
int () { return getTime(); }
hashCode
23,327
int () { return myTime; }
getTime
23,328
Value () { return myValue; }
getValue
23,329
int (@NotNull TraceElement other) { return Integer.compare(myTime, other.getTime()); }
compareTo
23,330
List<Value> () { return Collections.singletonList(myResult.getValue()); }
getRawValues
23,331
StreamCall () { return myPrevCall; }
getPrevCall
23,332
List<TraceElement> (@NotNull TraceElement value) { return myToPrev.getOrDefault(value, Collections.emptyList()); }
getPrevValues
23,333
TracingResult (@NotNull StreamChain chain, @NotNull ArrayReference resultArray) { final ArrayReference info = (ArrayReference)resultArray.getValue(0); final ArrayReference result = (ArrayReference)resultArray.getValue(1); final Value streamResult = result.getValue(0); final Value time = resultArray.getValue(2); logTime(time); final List<TraceInfo> trace = getTrace(chain, info); return new TracingResultImpl(chain, TraceElementImpl.ofResultValue(streamResult), trace, isException(result)); }
interpret
23,334
List<TraceInfo> (@NotNull StreamChain chain, @NotNull ArrayReference info) { final int callCount = chain.length(); final List<TraceInfo> result = new ArrayList<>(callCount); for (int i = 0; i < callCount; i++) { final StreamCall call = chain.getCall(i); final Value trace = info.getValue(i); final CallTraceInterpreter interpreter = myInterpreterFactory.getInterpreter(call.getName()); final TraceInfo traceInfo = trace == null ? ValuesOrderInfo.empty(call) : interpreter.resolve(call, trace); result.add(traceInfo); } return result; }
getTrace
23,335
void (@NotNull Value elapsedTimeArray) { final Value elapsedTime = ((ArrayReference)elapsedTimeArray).getValue(0); final long elapsedNanoseconds = ((LongValue)elapsedTime).value(); final long elapsedMillis = TimeUnit.NANOSECONDS.toMillis(elapsedNanoseconds); LOG.info("evaluation completed in " + elapsedMillis + "ms"); }
logTime
23,336
boolean (@NotNull ArrayReference result) { final ReferenceType type = result.referenceType(); if (type instanceof ArrayType) { if (((ArrayType)type).componentTypeName().contains("Throwable")) { return true; } } return false; }
isException
23,337
List<TraceElement> () { return myElements; }
getTrace
23,338
StreamCall () { return myPrevCall; }
getPrevCall
23,339
List<TraceElement> (@NotNull TraceElement value) { return myToPrev.getOrDefault(value, Collections.emptyList()); }
getPrevValues
23,340
StreamCall () { return myNextCall; }
getNextCall
23,341
List<TraceElement> (@NotNull TraceElement value) { return myToNext.getOrDefault(value, Collections.emptyList()); }
getNextValues
23,342
StreamCall () { return myNextCall; }
getNextCall
23,343
List<TraceElement> (@NotNull TraceElement value) { return myToNext.getOrDefault(value, Collections.emptyList()); }
getNextValues
23,344
TraceElement () { return myStreamResult; }
getResult
23,345
boolean () { return myIsResultException; }
exceptionThrown
23,346
List<TraceInfo> () { return myTrace; }
getTrace
23,347
ResolvedTracingResult (@NotNull ResolverFactory resolverFactory) { assert myTrace.size() == mySourceChain.length(); List<ValuesOrderResolver.Result> resolvedTraces = ContainerUtil.map(myTrace, x -> resolverFactory.getResolver(x.getCall().getName()).resolve(x)); final TraceInfo firstCallTrace = myTrace.get(0); final List<IntermediateStreamCall> intermediateCalls = mySourceChain.getIntermediateCalls(); final ResolvedStreamChainImpl.Builder chainBuilder = new ResolvedStreamChainImpl.Builder(); final List<TraceElement> valuesBeforeFirstCall = TraceUtil.sortedByTime(firstCallTrace.getValuesOrderBefore().values()); final FirstStateImpl firstState = new FirstStateImpl(valuesBeforeFirstCall, firstCallTrace.getCall(), resolvedTraces.get(0).getDirectOrder()); if (intermediateCalls.isEmpty()) { chainBuilder.setTerminator(buildResolvedTerminationCall(myTrace.get(0), firstState, resolvedTraces.get(0).getReverseOrder())); } else { final ArrayList<IntermediateStateImpl> states = new ArrayList<>(); for (int i = 0; i < intermediateCalls.size() - 1; i++) { states.add(new IntermediateStateImpl(TraceUtil.sortedByTime(myTrace.get(i).getValuesOrderAfter().values()), intermediateCalls.get(i), intermediateCalls.get(i + 1), resolvedTraces.get(i).getReverseOrder(), resolvedTraces.get(i + 1).getDirectOrder())); } states.add(new IntermediateStateImpl(TraceUtil.sortedByTime(myTrace.get(myTrace.size() - 1).getValuesOrderBefore().values()), intermediateCalls.get(intermediateCalls.size() - 1), mySourceChain.getTerminationCall(), resolvedTraces.get(resolvedTraces.size() - 2).getReverseOrder(), resolvedTraces.get(resolvedTraces.size() - 1).getDirectOrder())); chainBuilder.addIntermediate(new ResolvedIntermediateCallImpl(intermediateCalls.get(0), firstState, states.get(0))); for (int i = 1; i < states.size(); i++) { chainBuilder.addIntermediate(new ResolvedIntermediateCallImpl(intermediateCalls.get(i), states.get(i - 1), states.get(i))); } chainBuilder.setTerminator(buildResolvedTerminationCall(myTrace.get(myTrace.size() - 1), states.get(states.size() - 1), resolvedTraces.get(resolvedTraces.size() - 1).getReverseOrder())); } return new MyResolvedResult(chainBuilder.build()); }
resolve
23,348
ResolvedStreamChain () { return myChain; }
getResolvedChain
23,349
StreamChain () { return mySourceChain; }
getSourceChain
23,350
boolean () { return myIsResultException; }
exceptionThrown
23,351
TraceElement () { return myStreamResult; }
getResult
23,352
TraceInfo (@NotNull StreamCall call, @NotNull Value value) { if (value instanceof ArrayReference trace) { final Value before = trace.getValue(0); final Value after = trace.getValue(1); if (before instanceof ArrayReference && after instanceof ArrayReference) { final Map<Integer, TraceElement> beforeTrace = resolveTrace((ArrayReference)before); final Map<Integer, TraceElement> afterTrace = resolveTrace((ArrayReference)after); return new ValuesOrderInfo(call, beforeTrace, afterTrace); } } throw new UnexpectedValueException("peek operation trace is wrong format"); }
resolve
23,353
TraceElement (@NotNull Value key, @Nullable Value value) { if (key instanceof IntegerValue) { return new TraceElementImpl(((IntegerValue)key).value(), value); } throw new UnexpectedValueException("key must be an integer value"); }
resolveTraceElement
23,354
TraceInfo (@NotNull StreamCall call, @NotNull Value value) { if (!(value instanceof ArrayReference array)) { throw new UnexpectedValueTypeException("Array reference expected. But " + value.type().name() + " received"); } final TraceInfo resolved = myPeekResolver.resolve(call, array.getValue(0)); final Map<Integer, TraceElement> before = resolved.getValuesOrderBefore(); if (before.isEmpty()) { return resolved; } int timeAfter = extractTime(array) + 1; final PrimitiveIterator.OfInt iterator = IntStreamEx.of(before.keySet()).sorted().iterator(); final Map<Integer, TraceElement> after = new HashMap<>(before.size()); while (iterator.hasNext()) { final int timeBefore = iterator.next(); final TraceElement elementBefore = before.get(timeBefore); final TraceElement elementAfter = new TraceElementImpl(timeAfter, elementBefore.getValue()); after.put(timeAfter, elementAfter); ++timeAfter; } return new ValuesOrderInfo(call, before, after); }
resolve
23,355
int (@NotNull ArrayReference value) { final Value timeArray = value.getValue(1); if (timeArray instanceof ArrayReference) { final Value time = ((ArrayReference)timeArray).getValue(0); if (time instanceof IntegerValue) { return ((IntegerValue)time).value(); } } throw new UnexpectedValueException("Could not find a maximum time value"); }
extractTime
23,356
TraceInfo (@NotNull StreamCall call, @NotNull Value value) { if (value instanceof ArrayReference) { final Value peeksResult = ((ArrayReference)value).getValue(0); final TraceInfo peekInfo = myPeekResolver.resolve(call, peeksResult); final Map<Integer, TraceElement> before = peekInfo.getValuesOrderBefore(); final Value optionalTrace = ((ArrayReference)value).getValue(1); final Value optionalValue = getOptionalValue(optionalTrace); if (optionalValue == null) { return new ValuesOrderInfo(call, before, Collections.emptyMap()); } final TraceElementImpl element = new TraceElementImpl(Integer.MAX_VALUE - 1, optionalValue); return new ValuesOrderInfo(call, before, Collections.singletonMap(element.getTime(), element)); } throw new UnexpectedValueException("trace termination with optional result must be an array value"); }
resolve
23,357
Value (@NotNull Value optionalTrace) { if (!(optionalTrace instanceof ArrayReference trace)) { throw new UnexpectedValueTypeException("optional trace must be an array value"); } if (!optionalIsPresent(trace)) { return null; } final Value value = trace.getValue(1); if (value instanceof ArrayReference) { return ((ArrayReference)value).getValue(0); } throw new UnexpectedValueTypeException("unexpected format for an optional value"); }
getOptionalValue
23,358
boolean (@NotNull ArrayReference optionalTrace) { final Value isPresentFlag = optionalTrace.getValue(0); if (isPresentFlag instanceof ArrayReference) { final Value isPresentValue = ((ArrayReference)isPresentFlag).getValue(0); if (isPresentValue instanceof BooleanValue) { return ((BooleanValue)isPresentValue).value(); } } throw new UnexpectedValueTypeException("unexpected format for optional isPresent value"); }
optionalIsPresent
23,359
boolean (@NotNull Collection<TraceElement> traceBeforeFilter, @NotNull Collection<TraceElement> traceAfterFilter) { return !traceAfterFilter.isEmpty(); }
getResult
23,360
Action (boolean result) { if (result) { return Action.CONNECT_FILTERED; } else { return Action.CONNECT_DIFFERENCE; } }
getAction
23,361
TraceInfo (@NotNull StreamCall call, @NotNull Value value) { if (value instanceof ArrayReference array) { if (array.length() != 2) { throw new UnexpectedArrayLengthException("trace array for *match call should contain two items. Actual = " + array.length()); } final Value peeksResult = array.getValue(0); final Value streamResult = array.getValue(1); final TraceElement streamResultElement = TraceElementImpl.ofResultValue(((ArrayReference)streamResult).getValue(0)); final TraceInfo peeksInfo = myPeekResolver.resolve(call, peeksResult); final Collection<TraceElement> traceBeforeFilter = peeksInfo.getValuesOrderBefore().values(); final Map<Integer, TraceElement> traceAfter = peeksInfo.getValuesOrderAfter(); final Collection<TraceElement> traceAfterFilter = traceAfter.values(); final boolean result = getResult(traceBeforeFilter, traceAfterFilter); final Action action = getAction(result); final Map<Integer, TraceElement> beforeTrace = Action.CONNECT_FILTERED.equals(action) ? onlyFiltered(traceAfterFilter) : difference(traceBeforeFilter, traceAfter.keySet()); return new ValuesOrderInfo(call, beforeTrace, makeIndexByTime(Stream.of(streamResultElement))); } throw new UnexpectedValueTypeException("value should be array reference, but given " + value.type().toString()); }
resolve
23,362
TraceInfo (@NotNull StreamCall call, @NotNull Value value) { if (value instanceof ArrayReference) { final Value peekTrace = ((ArrayReference)value).getValue(0); final Value trace = ((ArrayReference)value).getValue(1); final TraceInfo order = myPeekResolver.resolve(call, peekTrace); final Map<TraceElement, List<TraceElement>> direct = resolve(trace, order, Direction.DIRECT); final Map<TraceElement, List<TraceElement>> reverse = resolve(trace, order, Direction.REVERSE); return new MyDistinctInfo(order, direct, reverse); } throw new UnexpectedValueException("distinct trace must be an array value"); }
resolve
23,363
int (@NotNull Value value) { if (value instanceof IntegerValue) { return ((IntegerValue)value).value(); } throw new UnexpectedValueTypeException("value should be IntegerValue, but actual is " + value.type().name()); }
extractIntValue
23,364
StreamCall () { return myStreamCall; }
getCall
23,365
TraceInfo (@NotNull StreamCall call) { return new ValuesOrderInfo(call, Collections.emptyMap(), Collections.emptyMap()); }
empty
23,366
boolean (@NotNull Collection<TraceElement> traceBeforeFilter, @NotNull Collection<TraceElement> traceAfterFilter) { return traceAfterFilter.isEmpty(); }
getResult
23,367
Action (boolean result) { if (result) { return Action.CONNECT_DIFFERENCE; } else { return Action.CONNECT_FILTERED; } }
getAction
23,368
boolean (@NotNull Collection<TraceElement> traceBeforeFilter, @NotNull Collection<TraceElement> traceAfterFilter) { return traceBeforeFilter.size() == traceAfterFilter.size(); }
getResult
23,369
Action (boolean result) { if (result) { return Action.CONNECT_FILTERED; } else { return Action.CONNECT_DIFFERENCE; } }
getAction
23,370
String () { return "peek"; }
getName
23,371
List<CallArgument> () { return myLambda; }
getArguments
23,372
TextRange () { return TextRange.EMPTY_RANGE; }
getTextRange
23,373
StreamCallType () { return StreamCallType.INTERMEDIATE; }
getType
23,374
GenericType () { return myElementType; }
getTypeAfter
23,375
GenericType () { return myElementType; }
getTypeBefore
23,376
void (@NotNull AnActionEvent e) { final XDebugSession session = DebuggerUIUtil.getSession(e); final PsiElement element = session == null ? null : myPositionResolver.getNearestElementToBreakpoint(session); final Presentation presentation = e.getPresentation(); if (element == null) { presentation.setVisible(true); presentation.setEnabled(false); } else { ChainResolver.ChainStatus chainStatus = CHAIN_RESOLVER.tryFindChain(element); switch (chainStatus) { case LANGUAGE_NOT_SUPPORTED -> presentation.setEnabledAndVisible(false); case FOUND -> presentation.setEnabledAndVisible(true); case COMPUTING, NOT_FOUND -> { presentation.setVisible(true); presentation.setEnabled(false); } } } }
update
23,377
ActionUpdateThread () { return ActionUpdateThread.BGT; }
getActionUpdateThread
23,378
void (@NotNull AnActionEvent e) { XDebugSession session = DebuggerUIUtil.getSession(e); LibrarySupportProvider.EP_NAME.getExtensionList(); XSourcePosition position = session == null ? null : session.getCurrentPosition(); PsiElement element = session == null ? null : myPositionResolver.getNearestElementToBreakpoint(session); if (element == null || position == null) { LOG.info("element at cursor not found"); return; } List<ChainResolver.StreamChainWithLibrary> chains = CHAIN_RESOLVER.getChains(element); if (chains.isEmpty()) { LOG.warn("stream chain is not built"); return; } if (chains.size() == 1) { runTrace(chains.get(0).chain, chains.get(0).provider, session); } else { Project project = session.getProject(); VirtualFile file = position.getFile(); Editor editor = FileEditorManager.getInstance(project).openTextEditor(new OpenFileDescriptor(project, file), true); LOG.assertTrue(editor != null); ApplicationManager.getApplication() .invokeLater(() -> { new MyStreamChainChooser(editor).show(ContainerUtil.map(chains, StreamChainOption::new), provider -> runTrace(provider.chain, provider.provider, session)); }); } }
actionPerformed
23,379
void (@NotNull StreamChain chain, @NotNull LibrarySupportProvider provider, @NotNull XDebugSession session) { final EvaluationAwareTraceWindow window = new EvaluationAwareTraceWindow(session, chain); ApplicationManager.getApplication().invokeLater(window::show); final Project project = session.getProject(); final TraceExpressionBuilder expressionBuilder = provider.getExpressionBuilder(project); final TraceResultInterpreterImpl resultInterpreter = new TraceResultInterpreterImpl(provider.getLibrarySupport().getInterpreterFactory()); final StreamTracer tracer = new EvaluateExpressionTracer(session, expressionBuilder, resultInterpreter); tracer.trace(chain, new TracingCallback() { @Override public void evaluated(@NotNull TracingResult result, @NotNull EvaluationContextImpl context) { final ResolvedTracingResult resolvedTrace = result.resolve(provider.getLibrarySupport().getResolverFactory()); ApplicationManager.getApplication() .invokeLater(() -> window.setTrace(resolvedTrace, context)); } @Override public void evaluationFailed(@NotNull String traceExpression, @NotNull String message) { notifyUI(message); throw new TraceEvaluationException(message, traceExpression); } @Override public void compilationFailed(@NotNull String traceExpression, @NotNull String message) { notifyUI(message); throw new TraceCompilationException(message, traceExpression); } private void notifyUI(@NotNull @Nls String message) { ApplicationManager.getApplication().invokeLater(() -> window.setFailMessage(message)); } }); }
runTrace
23,380
void (@NotNull TracingResult result, @NotNull EvaluationContextImpl context) { final ResolvedTracingResult resolvedTrace = result.resolve(provider.getLibrarySupport().getResolverFactory()); ApplicationManager.getApplication() .invokeLater(() -> window.setTrace(resolvedTrace, context)); }
evaluated
23,381
void (@NotNull String traceExpression, @NotNull String message) { notifyUI(message); throw new TraceEvaluationException(message, traceExpression); }
evaluationFailed
23,382
void (@NotNull String traceExpression, @NotNull String message) { notifyUI(message); throw new TraceCompilationException(message, traceExpression); }
compilationFailed
23,383
void (@NotNull @Nls String message) { ApplicationManager.getApplication().invokeLater(() -> window.setFailMessage(message)); }
notifyUI
23,384
Stream<TextRange> () { return Stream.of( new TextRange(chain.getQualifierExpression().getTextRange().getStartOffset(), chain.getTerminationCall().getTextRange().getEndOffset())); }
rangeStream
23,385
String () { return chain.getCompactText(); }
getText
23,386
ChainStatus (@NotNull PsiElement elementAtDebugger) { ChainsSearchResult result = mySearchResult.get(); if (result.isSuitableFor(elementAtDebugger)) { return result.chainsStatus; } result = ChainsSearchResult.of(elementAtDebugger); checkChainsExistenceInBackground(elementAtDebugger, result, myExecutor); mySearchResult.set(result); return result.chainsStatus; }
tryFindChain
23,387
List<StreamChainWithLibrary> (@NotNull PsiElement elementAtDebugger) { ChainsSearchResult result = mySearchResult.get(); if (!result.isSuitableFor(elementAtDebugger) || !result.chainsStatus.equals(ChainStatus.FOUND)) { LOG.error("Cannot build chains: " + result.chainsStatus); return Collections.emptyList(); } // TODO: move to background List<StreamChainWithLibrary> chains = new ArrayList<>(); String elementLanguageId = elementAtDebugger.getLanguage().getID(); LibrarySupportProvider.EP_NAME.forEachExtensionSafe(provider -> { if (provider.getLanguageId().equals(elementLanguageId)) { StreamChainBuilder chainBuilder = provider.getChainBuilder(); if (chainBuilder.isChainExists(elementAtDebugger)) { for (StreamChain x : chainBuilder.build(elementAtDebugger)) { chains.add(new StreamChainWithLibrary(x, provider)); } } } }); return chains; }
getChains
23,388
void (@NotNull PsiElement elementAtDebugger, @NotNull ChainsSearchResult searchResult, @NotNull ExecutorService executor) { List<LibrarySupportProvider> extensions = forLanguage(elementAtDebugger.getLanguage()); if (extensions.isEmpty()) { searchResult.markUnsupportedLanguage(); } else { ReadAction.nonBlocking(() -> { boolean found = false; for (LibrarySupportProvider provider : extensions) { try { if (provider.getChainBuilder().isChainExists(elementAtDebugger)) { found = true; break; } } catch (ProcessCanceledException e) { throw e; } catch (Throwable e) { LOG.error(e); } } if (LOG.isDebugEnabled()) { LOG.debug("Chains found:" + found); } searchResult.updateStatus(found); }) .inSmartMode(elementAtDebugger.getProject()) .submit(executor); } }
checkChainsExistenceInBackground
23,389
List<LibrarySupportProvider> (@NotNull Language language) { return LibrarySupportProvider.EP_NAME.getByGroupingKey(language.getID(), ChainResolver.class, LibrarySupportProvider::getLanguageId); }
forLanguage
23,390
long (@Nullable PsiFile file) { return file == null ? -1 : file.getModificationStamp(); }
getModificationStamp
23,391
ChainsSearchResult (@NotNull PsiElement element) { return new ChainsSearchResult(element.hashCode(), element.getTextOffset(), element.getContainingFile()); }
of
23,392
void () { }
dispose
23,393
List<Value> () { return myState.getRawValues(); }
getValues
23,394
List<TraceElement> () { return myState.getTrace(); }
getTrace
23,395
StreamCall () { return myToNext == null ? null : myToNext.getNextCall(); }
getNextCall
23,396
StreamCall () { return myToPrev == null ? null : myToPrev.getPrevCall(); }
getPrevCall
23,397
List<TraceElement> (@NotNull TraceElement element) { return myToNext == null ? Collections.emptyList() : myToNext.getNextValues(element); }
getNextValues
23,398
List<TraceElement> (@NotNull TraceElement element) { return myToPrev == null ? Collections.emptyList() : myToPrev.getPrevValues(element); }
getPrevValues
23,399
boolean (@NotNull PropagationDirection direction) { for (final TraceContainer container : myTraceContainers) { if (container.highlightedExists()) { return true; } } return PropagationDirection.FORWARD.equals(direction) ? selectionExistsForward() : selectionExistsBackward(); }
isSelectionExists